traffic_ops/v3-client/server.go - trafficcontrol - Git at Google

 /*

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 */

 package client

 import (
 	"errors"
 	"fmt"
 	"net"
 	"net/http"
 	"net/url"
 	"strings"

 	"github.com/apache/trafficcontrol/lib/go-tc"
 	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
 )

 const (
 	// API_SERVERS is Deprecated: will be removed in the next major version. Be aware this may not be the URI being requested, for clients created with Login and ClientOps.ForceLatestAPI false.
 	API_SERVERS = apiBase + "/servers"
 	// API_SERVERS_DETAILS is Deprecated: will be removed in the next major version. Be aware this may not be the URI being requested, for clients created with Login and ClientOps.ForceLatestAPI false.
 	API_SERVERS_DETAILS = apiBase + "/servers/details"
 	// API_SERVER_ASSIGN_DELIVERY_SERVICES is Deprecated: will be removed in the next major version. Be aware this may not be the URI being requested, for clients created with Login and ClientOps.ForceLatestAPI false.
 	API_SERVER_ASSIGN_DELIVERY_SERVICES = API_SERVER_DELIVERY_SERVICES + "?replace=%t"

 	APIServers                      = "/servers"
 	APIServersDetails               = "/servers/details"
 	APIServerAssignDeliveryServices = APIServerDeliveryServices + "?replace=%t"
 )

 func needAndCanFetch(id *int, name *string) bool {
 	return (id == nil || *id == 0) && name != nil && *name != ""
 }

 // CreateServer creates a Server.
 // Deprecated: CreateServer will be removed in 6.0. Use CreateServerWithHdr.
 func (to *Session) CreateServer(server tc.Server) (tc.Alerts, toclientlib.ReqInf, error) {
 	upgraded, err := server.ToNullable().Upgrade()
 	if err != nil {
 		return tc.Alerts{}, toclientlib.ReqInf{}, fmt.Errorf("upgrading server: %v", err)
 	}
 	return to.CreateServerWithHdr(upgraded, nil)
 }

 // CreateServerWithHdr creates the given server, with whatever headers are
 // passed added to the request.
 func (to *Session) CreateServerWithHdr(server tc.ServerV30, hdr http.Header) (tc.Alerts, toclientlib.ReqInf, error) {

 	var alerts tc.Alerts
 	var remoteAddr net.Addr
 	reqInf := toclientlib.ReqInf{CacheHitStatus: toclientlib.CacheHitStatusMiss, RemoteAddr: remoteAddr}

 	if needAndCanFetch(server.CachegroupID, server.Cachegroup) {
 		cg, _, err := to.GetCacheGroupNullableByNameWithHdr(*server.Cachegroup, nil)
 		if err != nil {
 			return alerts, reqInf, fmt.Errorf("no cachegroup named %s: %v", *server.Cachegroup, err)
 		}
 		if len(cg) == 0 {
 			return alerts, reqInf, fmt.Errorf("no cachegroup named %s", *server.Cachegroup)
 		}
 		if cg[0].ID == nil {
 			return alerts, reqInf, fmt.Errorf("Cachegroup named %s has a nil ID", *server.Cachegroup)
 		}
 		server.CachegroupID = cg[0].ID
 	}
 	if needAndCanFetch(server.CDNID, server.CDNName) {
 		c, _, err := to.GetCDNByNameWithHdr(*server.CDNName, nil)
 		if err != nil {
 			return alerts, reqInf, fmt.Errorf("no CDN named %s: %v", *server.CDNName, err)
 		}
 		if len(c) == 0 {
 			return alerts, reqInf, fmt.Errorf("no CDN named %s", *server.CDNName)
 		}
 		server.CDNID = &c[0].ID
 	}
 	if needAndCanFetch(server.PhysLocationID, server.PhysLocation) {
 		ph, _, err := to.GetPhysLocationByNameWithHdr(*server.PhysLocation, nil)
 		if err != nil {
 			return alerts, reqInf, fmt.Errorf("no physlocation named %s: %v", *server.PhysLocation, err)
 		}
 		if len(ph) == 0 {
 			return alerts, reqInf, fmt.Errorf("no physlocation named %s", *server.PhysLocation)
 		}
 		server.PhysLocationID = &ph[0].ID
 	}
 	if needAndCanFetch(server.ProfileID, server.Profile) {
 		pr, _, err := to.GetProfileByNameWithHdr(*server.Profile, nil)
 		if err != nil {
 			return alerts, reqInf, fmt.Errorf("no profile named %s: %v", *server.Profile, err)
 		}
 		if len(pr) == 0 {
 			return alerts, reqInf, fmt.Errorf("no profile named %s", *server.Profile)
 		}
 		server.ProfileID = &pr[0].ID
 	}
 	if needAndCanFetch(server.StatusID, server.Status) {
 		st, _, err := to.GetStatusByNameWithHdr(*server.Status, nil)
 		if err != nil {
 			return alerts, reqInf, fmt.Errorf("no status named %s: %v", *server.Status, err)
 		}
 		if len(st) == 0 {
 			return alerts, reqInf, fmt.Errorf("no status named %s", *server.Status)
 		}
 		server.StatusID = &st[0].ID
 	}
 	if (server.TypeID == nil || *server.TypeID == 0) && server.Type != "" {
 		ty, _, err := to.GetTypeByNameWithHdr(server.Type, nil)
 		if err != nil {
 			return alerts, reqInf, fmt.Errorf("no type named %s: %v", server.Type, err)
 		}
 		if len(ty) == 0 {
 			return alerts, reqInf, fmt.Errorf("no type named %s", server.Type)
 		}
 		server.TypeID = &ty[0].ID
 	}

 	reqInf, err := to.post(APIServers, server, hdr, &alerts)
 	return alerts, reqInf, err
 }

 func (to *Session) UpdateServerByIDWithHdr(id int, server tc.ServerV30, header http.Header) (tc.Alerts, toclientlib.ReqInf, error) {
 	var alerts tc.Alerts
 	route := fmt.Sprintf("%s/%d", APIServers, id)
 	reqInf, err := to.put(route, server, header, &alerts)
 	return alerts, reqInf, err
 }

 // UpdateServerByID updates a Server by ID.
 // Deprecated: UpdateServerByID will be removed in 6.0. Use UpdateServerByIDWithHdr.
 func (to *Session) UpdateServerByID(id int, server tc.Server) (tc.Alerts, toclientlib.ReqInf, error) {
 	upgraded, err := server.ToNullable().Upgrade()
 	if err != nil {
 		return tc.Alerts{}, toclientlib.ReqInf{}, fmt.Errorf("upgrading server: %v", err)
 	}
 	return to.UpdateServerByIDWithHdr(id, upgraded, nil)
 }

 // GetServersWithHdr retrieves a list of servers using the given optional query
 // string parameters and HTTP headers.
 func (to *Session) GetServersWithHdr(params *url.Values, header http.Header) (tc.ServersV3Response, toclientlib.ReqInf, error) {
 	route := APIServers
 	if params != nil {
 		route += "?" + params.Encode()
 	}

 	var data tc.ServersV3Response
 	reqInf, err := to.get(route, header, &data)
 	return data, reqInf, err
 }

 // GetServers returns a list of Servers.
 // The 'params' parameter can be used to optionally pass URL "query string
 // parameters" in the request.
 // It returns, in order, the API response that Traffic Ops returned, a request
 // info object, and any error that occurred.
 // Deprecated: GetServers will be removed in 6.0. Use GetServersWithHdr.
 func (to *Session) GetServers(params *url.Values) ([]tc.Server, toclientlib.ReqInf, error) {
 	srvs, inf, err := to.GetServersWithHdr(params, nil)
 	if err != nil {
 		return []tc.Server{}, inf, err
 	}

 	servers := make([]tc.Server, 0, len(srvs.Response))
 	for _, srv := range srvs.Response {
 		nullable := tc.ServerNullable(srv)
 		v2, err := nullable.ToServerV2()
 		if err != nil {
 			return []tc.Server{}, inf, fmt.Errorf("converting server to v2: %v", err)
 		}
 		servers = append(servers, v2.ToNonNullable())
 	}
 	return servers, inf, nil
 }

 // GetFirstServer returns the first server in a servers GET response.
 // If no servers match, an error is returned.
 // The 'params' parameter can be used to optionally pass URL "query string
 // parameters" in the request.
 // It returns, in order, the API response that Traffic Ops returned, a request
 // info object, and any error that occurred.
 func (to *Session) GetFirstServer(params *url.Values, header http.Header) (tc.ServerV30, toclientlib.ReqInf, error) {
 	serversResponse, reqInf, err := to.GetServersWithHdr(params, header)
 	var firstServer tc.ServerV30
 	if err != nil || reqInf.StatusCode == http.StatusNotModified {
 		return firstServer, reqInf, err
 	}
 	for _, firstServer = range serversResponse.Response {
 		return firstServer, reqInf, err
 	}

 	err = fmt.Errorf("unable to find server matching params %v", *params)
 	return firstServer, reqInf, err
 }

 // GetServerDetailsByHostNameWithHdr retrieves the "details" of all servers with
 // the given hostname.
 // Deprecated: Server "details" as a concept have been removed from the latest
 // version of the API, and clients should use GetServersWithHdr instead.
 func (to *Session) GetServerDetailsByHostNameWithHdr(hostName string, header http.Header) ([]tc.ServerDetailV30, toclientlib.ReqInf, error) {
 	v := url.Values{}
 	v.Add("hostName", hostName)
 	route := APIServersDetails + "?" + v.Encode()
 	var data tc.ServersV3DetailResponse
 	reqInf, err := to.get(route, header, &data)
 	return data.Response, reqInf, err
 }

 // GetServerDetailsByHostName GETs Servers by the Server hostname.
 // Deprecated: GetServerDetailsByHostName will be removed in 6.0. Use GetServerDetailsByHostNameWithHdr.
 func (to *Session) GetServerDetailsByHostName(hostName string) ([]tc.ServerDetailV30, toclientlib.ReqInf, error) {
 	return to.GetServerDetailsByHostNameWithHdr(hostName, nil)
 }

 // DeleteServerByID DELETEs a Server by ID.
 func (to *Session) DeleteServerByID(id int) (tc.Alerts, toclientlib.ReqInf, error) {
 	route := fmt.Sprintf("%s/%d", APIServers, id)
 	var alerts tc.Alerts
 	reqInf, err := to.del(route, nil, &alerts)
 	return alerts, reqInf, err
 }

 func (to *Session) GetServerFQDNWithHdr(n string, header http.Header) (string, tc.Alerts, toclientlib.ReqInf, error) {
 	// TODO fix to only request one server
 	params := url.Values{}
 	params.Add("hostName", n)

 	resp, reqInf, err := to.GetServersWithHdr(&params, header)
 	if err != nil {
 		return "", resp.Alerts, reqInf, err
 	}

 	var fdn string
 	for _, server := range resp.Response {
 		if server.HostName != nil && server.DomainName != nil {
 			fdn = fmt.Sprintf("%s.%s", *server.HostName, *server.DomainName)
 		}
 	}

 	if fdn == "" {
 		err = fmt.Errorf("No Server %s found", n)
 	}

 	return fdn, resp.Alerts, reqInf, err
 }

 // GetServerFQDN returns the Fully Qualified Domain Name (FQDN) of the first
 // server found to have the Host Name 'n'.
 // Deprecated: GetServerFQDN will be removed in 6.0. Use GetServerFQDNWithHdr.
 func (to *Session) GetServerFQDN(n string) (string, tc.Alerts, toclientlib.ReqInf, error) {
 	return to.GetServerFQDNWithHdr(n, nil)
 }

 func (to *Session) GetServersShortNameSearchWithHdr(shortname string, header http.Header) ([]string, tc.Alerts, toclientlib.ReqInf, error) {
 	var serverlst []string
 	resp, reqInf, err := to.GetServersWithHdr(nil, header)
 	if err != nil {
 		return serverlst, resp.Alerts, reqInf, err
 	}

 	for _, server := range resp.Response {
 		if server.HostName != nil && strings.Contains(*server.HostName, shortname) {
 			serverlst = append(serverlst, *server.HostName)
 		}
 	}

 	if len(serverlst) == 0 {
 		err = errors.New("No Servers Found")
 	}

 	return serverlst, resp.Alerts, reqInf, err
 }

 // GetServersShortNameSearch returns all of the Host Names of servers that
 // contain 'shortname'.
 // Deprecated: GetServersShortNameSearch will be removed in 6.0. Use GetServersShortNameSearchWithHdr.
 func (to *Session) GetServersShortNameSearch(shortname string) ([]string, tc.Alerts, toclientlib.ReqInf, error) {
 	return to.GetServersShortNameSearchWithHdr(shortname, nil)
 }

 // AssignDeliveryServiceIDsToServerID assigns a set of Delivery Services to a
 // single server, optionally replacing any and all existing assignments.
 // 'server' should be the requested server's ID, 'dsIDs' should be a slice of
 // the requested Delivery Services' IDs. If 'replace' is 'true', existing
 // assignments to the server will be replaced.
 func (to *Session) AssignDeliveryServiceIDsToServerID(server int, dsIDs []int, replace bool) (tc.Alerts, toclientlib.ReqInf, error) {
 	// datatypes here match the library tc.Server's and tc.DeliveryService's ID fields
 	endpoint := fmt.Sprintf(APIServerAssignDeliveryServices, server, replace)
 	var alerts tc.Alerts
 	reqInf, err := to.post(endpoint, dsIDs, nil, &alerts)
 	return alerts, reqInf, err
 }

 func (to *Session) GetServerIDDeliveryServicesWithHdr(server int, header http.Header) ([]tc.DeliveryServiceNullable, toclientlib.ReqInf, error) {
 	endpoint := fmt.Sprintf(APIServerDeliveryServices, server)
 	var data tc.DeliveryServicesNullableResponse
 	reqInf, err := to.get(endpoint, header, &data)
 	return data.Response, reqInf, err
 }

 // GetServerIDDeliveryServices returns all of the Delivery Services assigned to the server identified
 // by the integral, unique identifier 'server'.
 // Deprecated: GetServerIDDeliveryServices will be removed in 6.0. Use GetServerIDDeliveryServicesWithHdr.
 func (to *Session) GetServerIDDeliveryServices(server int) ([]tc.DeliveryServiceNullable, toclientlib.ReqInf, error) {
 	return to.GetServerIDDeliveryServicesWithHdr(server, nil)
 }

 func (to *Session) GetServerUpdateStatusWithHdr(hostName string, header http.Header) (tc.ServerUpdateStatus, toclientlib.ReqInf, error) {
 	path := APIServers + `/` + hostName + `/update_status`
 	data := []tc.ServerUpdateStatus{}
 	reqInf, err := to.get(path, header, &data)
 	if err != nil {
 		return tc.ServerUpdateStatus{}, reqInf, err
 	}
 	if len(data) == 0 {
 		return tc.ServerUpdateStatus{}, reqInf, errors.New("Traffic Ops returned no update statuses for that server")
 	}
 	return data[0], reqInf, nil
 }

 // GetServerUpdateStatus GETs the Server Update Status by the Server hostname.
 // Deprecated: GetServerUpdateStatus will be removed in 6.0. Use GetServerUpdateStatusWithHdr.
 func (to *Session) GetServerUpdateStatus(hostName string) (tc.ServerUpdateStatus, toclientlib.ReqInf, error) {
 	return to.GetServerUpdateStatusWithHdr(hostName, nil)
 }
	/*

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
	*/

	package client

	import (
	"errors"
	"fmt"
	"net"
	"net/http"
	"net/url"
	"strings"

	"github.com/apache/trafficcontrol/lib/go-tc"
	"github.com/apache/trafficcontrol/traffic_ops/toclientlib"
	)

	const (
	// API_SERVERS is Deprecated: will be removed in the next major version. Be aware this may not be the URI being requested, for clients created with Login and ClientOps.ForceLatestAPI false.
	API_SERVERS = apiBase + "/servers"
	// API_SERVERS_DETAILS is Deprecated: will be removed in the next major version. Be aware this may not be the URI being requested, for clients created with Login and ClientOps.ForceLatestAPI false.
	API_SERVERS_DETAILS = apiBase + "/servers/details"
	// API_SERVER_ASSIGN_DELIVERY_SERVICES is Deprecated: will be removed in the next major version. Be aware this may not be the URI being requested, for clients created with Login and ClientOps.ForceLatestAPI false.
	API_SERVER_ASSIGN_DELIVERY_SERVICES = API_SERVER_DELIVERY_SERVICES + "?replace=%t"

	APIServers = "/servers"
	APIServersDetails = "/servers/details"
	APIServerAssignDeliveryServices = APIServerDeliveryServices + "?replace=%t"
	)

	func needAndCanFetch(id int, name string) bool {
	return (id == nil \|\| id == 0) && name != nil && name != ""
	}

	// CreateServer creates a Server.
	// Deprecated: CreateServer will be removed in 6.0. Use CreateServerWithHdr.
	func (to *Session) CreateServer(server tc.Server) (tc.Alerts, toclientlib.ReqInf, error) {
	upgraded, err := server.ToNullable().Upgrade()
	if err != nil {
	return tc.Alerts{}, toclientlib.ReqInf{}, fmt.Errorf("upgrading server: %v", err)
	}
	return to.CreateServerWithHdr(upgraded, nil)
	}

	// CreateServerWithHdr creates the given server, with whatever headers are
	// passed added to the request.
	func (to *Session) CreateServerWithHdr(server tc.ServerV30, hdr http.Header) (tc.Alerts, toclientlib.ReqInf, error) {

	var alerts tc.Alerts
	var remoteAddr net.Addr
	reqInf := toclientlib.ReqInf{CacheHitStatus: toclientlib.CacheHitStatusMiss, RemoteAddr: remoteAddr}

	if needAndCanFetch(server.CachegroupID, server.Cachegroup) {
	cg, _, err := to.GetCacheGroupNullableByNameWithHdr(*server.Cachegroup, nil)
	if err != nil {
	return alerts, reqInf, fmt.Errorf("no cachegroup named %s: %v", *server.Cachegroup, err)
	}
	if len(cg) == 0 {
	return alerts, reqInf, fmt.Errorf("no cachegroup named %s", *server.Cachegroup)
	}
	if cg[0].ID == nil {
	return alerts, reqInf, fmt.Errorf("Cachegroup named %s has a nil ID", *server.Cachegroup)
	}
	server.CachegroupID = cg[0].ID
	}
	if needAndCanFetch(server.CDNID, server.CDNName) {
	c, _, err := to.GetCDNByNameWithHdr(*server.CDNName, nil)
	if err != nil {
	return alerts, reqInf, fmt.Errorf("no CDN named %s: %v", *server.CDNName, err)
	}
	if len(c) == 0 {
	return alerts, reqInf, fmt.Errorf("no CDN named %s", *server.CDNName)
	}
	server.CDNID = &c[0].ID
	}
	if needAndCanFetch(server.PhysLocationID, server.PhysLocation) {
	ph, _, err := to.GetPhysLocationByNameWithHdr(*server.PhysLocation, nil)
	if err != nil {
	return alerts, reqInf, fmt.Errorf("no physlocation named %s: %v", *server.PhysLocation, err)
	}
	if len(ph) == 0 {
	return alerts, reqInf, fmt.Errorf("no physlocation named %s", *server.PhysLocation)
	}
	server.PhysLocationID = &ph[0].ID
	}
	if needAndCanFetch(server.ProfileID, server.Profile) {
	pr, _, err := to.GetProfileByNameWithHdr(*server.Profile, nil)
	if err != nil {
	return alerts, reqInf, fmt.Errorf("no profile named %s: %v", *server.Profile, err)
	}
	if len(pr) == 0 {
	return alerts, reqInf, fmt.Errorf("no profile named %s", *server.Profile)
	}
	server.ProfileID = &pr[0].ID
	}
	if needAndCanFetch(server.StatusID, server.Status) {
	st, _, err := to.GetStatusByNameWithHdr(*server.Status, nil)
	if err != nil {
	return alerts, reqInf, fmt.Errorf("no status named %s: %v", *server.Status, err)
	}
	if len(st) == 0 {
	return alerts, reqInf, fmt.Errorf("no status named %s", *server.Status)
	}
	server.StatusID = &st[0].ID
	}
	if (server.TypeID == nil \|\| *server.TypeID == 0) && server.Type != "" {
	ty, _, err := to.GetTypeByNameWithHdr(server.Type, nil)
	if err != nil {
	return alerts, reqInf, fmt.Errorf("no type named %s: %v", server.Type, err)
	}
	if len(ty) == 0 {
	return alerts, reqInf, fmt.Errorf("no type named %s", server.Type)
	}
	server.TypeID = &ty[0].ID
	}

	reqInf, err := to.post(APIServers, server, hdr, &alerts)
	return alerts, reqInf, err
	}

	func (to *Session) UpdateServerByIDWithHdr(id int, server tc.ServerV30, header http.Header) (tc.Alerts, toclientlib.ReqInf, error) {
	var alerts tc.Alerts
	route := fmt.Sprintf("%s/%d", APIServers, id)
	reqInf, err := to.put(route, server, header, &alerts)
	return alerts, reqInf, err
	}

	// UpdateServerByID updates a Server by ID.
	// Deprecated: UpdateServerByID will be removed in 6.0. Use UpdateServerByIDWithHdr.
	func (to *Session) UpdateServerByID(id int, server tc.Server) (tc.Alerts, toclientlib.ReqInf, error) {
	upgraded, err := server.ToNullable().Upgrade()
	if err != nil {
	return tc.Alerts{}, toclientlib.ReqInf{}, fmt.Errorf("upgrading server: %v", err)
	}
	return to.UpdateServerByIDWithHdr(id, upgraded, nil)
	}

	// GetServersWithHdr retrieves a list of servers using the given optional query
	// string parameters and HTTP headers.
	func (to Session) GetServersWithHdr(params url.Values, header http.Header) (tc.ServersV3Response, toclientlib.ReqInf, error) {
	route := APIServers
	if params != nil {
	route += "?" + params.Encode()
	}

	var data tc.ServersV3Response
	reqInf, err := to.get(route, header, &data)
	return data, reqInf, err
	}

	// GetServers returns a list of Servers.
	// The 'params' parameter can be used to optionally pass URL "query string
	// parameters" in the request.
	// It returns, in order, the API response that Traffic Ops returned, a request
	// info object, and any error that occurred.
	// Deprecated: GetServers will be removed in 6.0. Use GetServersWithHdr.
	func (to Session) GetServers(params url.Values) ([]tc.Server, toclientlib.ReqInf, error) {
	srvs, inf, err := to.GetServersWithHdr(params, nil)
	if err != nil {
	return []tc.Server{}, inf, err
	}

	servers := make([]tc.Server, 0, len(srvs.Response))
	for _, srv := range srvs.Response {
	nullable := tc.ServerNullable(srv)
	v2, err := nullable.ToServerV2()
	if err != nil {
	return []tc.Server{}, inf, fmt.Errorf("converting server to v2: %v", err)
	}
	servers = append(servers, v2.ToNonNullable())
	}
	return servers, inf, nil
	}

	// GetFirstServer returns the first server in a servers GET response.
	// If no servers match, an error is returned.
	// The 'params' parameter can be used to optionally pass URL "query string
	// parameters" in the request.
	// It returns, in order, the API response that Traffic Ops returned, a request
	// info object, and any error that occurred.
	func (to Session) GetFirstServer(params url.Values, header http.Header) (tc.ServerV30, toclientlib.ReqInf, error) {
	serversResponse, reqInf, err := to.GetServersWithHdr(params, header)
	var firstServer tc.ServerV30
	if err != nil \|\| reqInf.StatusCode == http.StatusNotModified {
	return firstServer, reqInf, err
	}
	for _, firstServer = range serversResponse.Response {
	return firstServer, reqInf, err
	}

	err = fmt.Errorf("unable to find server matching params %v", *params)
	return firstServer, reqInf, err
	}

	// GetServerDetailsByHostNameWithHdr retrieves the "details" of all servers with
	// the given hostname.
	// Deprecated: Server "details" as a concept have been removed from the latest
	// version of the API, and clients should use GetServersWithHdr instead.
	func (to *Session) GetServerDetailsByHostNameWithHdr(hostName string, header http.Header) ([]tc.ServerDetailV30, toclientlib.ReqInf, error) {
	v := url.Values{}
	v.Add("hostName", hostName)
	route := APIServersDetails + "?" + v.Encode()
	var data tc.ServersV3DetailResponse
	reqInf, err := to.get(route, header, &data)
	return data.Response, reqInf, err
	}

	// GetServerDetailsByHostName GETs Servers by the Server hostname.
	// Deprecated: GetServerDetailsByHostName will be removed in 6.0. Use GetServerDetailsByHostNameWithHdr.
	func (to *Session) GetServerDetailsByHostName(hostName string) ([]tc.ServerDetailV30, toclientlib.ReqInf, error) {
	return to.GetServerDetailsByHostNameWithHdr(hostName, nil)
	}

	// DeleteServerByID DELETEs a Server by ID.
	func (to *Session) DeleteServerByID(id int) (tc.Alerts, toclientlib.ReqInf, error) {
	route := fmt.Sprintf("%s/%d", APIServers, id)
	var alerts tc.Alerts
	reqInf, err := to.del(route, nil, &alerts)
	return alerts, reqInf, err
	}

	func (to *Session) GetServerFQDNWithHdr(n string, header http.Header) (string, tc.Alerts, toclientlib.ReqInf, error) {
	// TODO fix to only request one server
	params := url.Values{}
	params.Add("hostName", n)

	resp, reqInf, err := to.GetServersWithHdr(&params, header)
	if err != nil {
	return "", resp.Alerts, reqInf, err
	}

	var fdn string
	for _, server := range resp.Response {
	if server.HostName != nil && server.DomainName != nil {
	fdn = fmt.Sprintf("%s.%s", server.HostName, server.DomainName)
	}
	}

	if fdn == "" {
	err = fmt.Errorf("No Server %s found", n)
	}

	return fdn, resp.Alerts, reqInf, err
	}

	// GetServerFQDN returns the Fully Qualified Domain Name (FQDN) of the first
	// server found to have the Host Name 'n'.
	// Deprecated: GetServerFQDN will be removed in 6.0. Use GetServerFQDNWithHdr.
	func (to *Session) GetServerFQDN(n string) (string, tc.Alerts, toclientlib.ReqInf, error) {
	return to.GetServerFQDNWithHdr(n, nil)
	}

	func (to *Session) GetServersShortNameSearchWithHdr(shortname string, header http.Header) ([]string, tc.Alerts, toclientlib.ReqInf, error) {
	var serverlst []string
	resp, reqInf, err := to.GetServersWithHdr(nil, header)
	if err != nil {
	return serverlst, resp.Alerts, reqInf, err
	}

	for _, server := range resp.Response {
	if server.HostName != nil && strings.Contains(*server.HostName, shortname) {
	serverlst = append(serverlst, *server.HostName)
	}
	}

	if len(serverlst) == 0 {
	err = errors.New("No Servers Found")
	}

	return serverlst, resp.Alerts, reqInf, err
	}

	// GetServersShortNameSearch returns all of the Host Names of servers that
	// contain 'shortname'.
	// Deprecated: GetServersShortNameSearch will be removed in 6.0. Use GetServersShortNameSearchWithHdr.
	func (to *Session) GetServersShortNameSearch(shortname string) ([]string, tc.Alerts, toclientlib.ReqInf, error) {
	return to.GetServersShortNameSearchWithHdr(shortname, nil)
	}

	// AssignDeliveryServiceIDsToServerID assigns a set of Delivery Services to a
	// single server, optionally replacing any and all existing assignments.
	// 'server' should be the requested server's ID, 'dsIDs' should be a slice of
	// the requested Delivery Services' IDs. If 'replace' is 'true', existing
	// assignments to the server will be replaced.
	func (to *Session) AssignDeliveryServiceIDsToServerID(server int, dsIDs []int, replace bool) (tc.Alerts, toclientlib.ReqInf, error) {
	// datatypes here match the library tc.Server's and tc.DeliveryService's ID fields
	endpoint := fmt.Sprintf(APIServerAssignDeliveryServices, server, replace)
	var alerts tc.Alerts
	reqInf, err := to.post(endpoint, dsIDs, nil, &alerts)
	return alerts, reqInf, err
	}

	func (to *Session) GetServerIDDeliveryServicesWithHdr(server int, header http.Header) ([]tc.DeliveryServiceNullable, toclientlib.ReqInf, error) {
	endpoint := fmt.Sprintf(APIServerDeliveryServices, server)
	var data tc.DeliveryServicesNullableResponse
	reqInf, err := to.get(endpoint, header, &data)
	return data.Response, reqInf, err
	}

	// GetServerIDDeliveryServices returns all of the Delivery Services assigned to the server identified
	// by the integral, unique identifier 'server'.
	// Deprecated: GetServerIDDeliveryServices will be removed in 6.0. Use GetServerIDDeliveryServicesWithHdr.
	func (to *Session) GetServerIDDeliveryServices(server int) ([]tc.DeliveryServiceNullable, toclientlib.ReqInf, error) {
	return to.GetServerIDDeliveryServicesWithHdr(server, nil)
	}

	func (to *Session) GetServerUpdateStatusWithHdr(hostName string, header http.Header) (tc.ServerUpdateStatus, toclientlib.ReqInf, error) {
	path := APIServers + `/` + hostName + `/update_status`
	data := []tc.ServerUpdateStatus{}
	reqInf, err := to.get(path, header, &data)
	if err != nil {
	return tc.ServerUpdateStatus{}, reqInf, err
	}
	if len(data) == 0 {
	return tc.ServerUpdateStatus{}, reqInf, errors.New("Traffic Ops returned no update statuses for that server")
	}
	return data[0], reqInf, nil
	}

	// GetServerUpdateStatus GETs the Server Update Status by the Server hostname.
	// Deprecated: GetServerUpdateStatus will be removed in 6.0. Use GetServerUpdateStatusWithHdr.
	func (to *Session) GetServerUpdateStatus(hostName string) (tc.ServerUpdateStatus, toclientlib.ReqInf, error) {
	return to.GetServerUpdateStatusWithHdr(hostName, nil)
	}