in cache-config/t3cutil/getdatacfg.go [187:829]
func GetConfigData(toClient *toreq.TOClient, disableProxy bool, cacheHostName string, revalOnly bool, oldCfg *ConfigData, version string) (*ConfigData, error) {
start := time.Now()
defer func() { log.Infof("GetTOData took %v\n", time.Since(start)) }()
toIPs := &sync.Map{} // each Traffic Ops request could get a different IP, so track them all
toData := &ConfigData{}
toData.Version = version
toData.MetaData.CacheHostName = cacheHostName
if oldCfg != nil && oldCfg.Version != toData.Version {
log.Infof("old config version '%s' doesn't match current version '%s', old config will not be used!\n", oldCfg.Version, toData.Version)
oldCfg = nil
}
serverProfilesParams := &sync.Map{} // map[atscfg.ProfileName][]tc.Parameter
serverProfilesParamsMetaData := &sync.Map{} // map[atscfg.ProfileName]ReqMetaData
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.GlobalParams)
}
globalParams, reqInf, err := toClient.GetGlobalParameters(reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetGlobalParameters"))
if err != nil {
return nil, errors.New("getting global parameters: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "Global Params")
toData.GlobalParams = oldCfg.GlobalParams
} else {
log.Infof("Getting config: %v is modified, using new response", "Global Params")
toData.GlobalParams = globalParams
}
toData.MetaData.GlobalParams = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
if !disableProxy {
toProxyURLStr := ""
for _, param := range toData.GlobalParams {
if param.Name == TrafficOpsProxyParameterName {
toProxyURLStr = param.Value
break
}
}
if toProxyURLStr != "" {
realTOURL := toClient.URL()
toClient.SetURL(toProxyURLStr)
log.Infoln("using Traffic Ops proxy '" + toProxyURLStr + "'")
if _, _, err := toClient.GetCDNs(nil); err != nil {
log.Warnln("Traffic Ops proxy '" + toProxyURLStr + "' failed to get CDNs, falling back to real Traffic Ops")
toClient.SetURL(realTOURL)
}
} else {
log.Infoln("Traffic Ops proxy enabled, but GLOBAL Parameter '" + TrafficOpsProxyParameterName + "' missing or empty, not using proxy")
}
} else {
log.Infoln("Traffic Ops proxy is disabled, not checking or using GLOBAL Parameter '" + TrafficOpsProxyParameterName)
}
oldServer := &atscfg.Server{}
if oldCfg != nil {
for _, toServer := range oldCfg.Servers {
if toServer.HostName != "" && toServer.HostName == oldCfg.MetaData.CacheHostName {
oldServer = &toServer
break
}
}
}
serversF := func() error {
defer func(start time.Time) { log.Infof("serversF took %v\n", time.Since(start)) }(time.Now())
// TODO TOAPI add /servers?cdn=1 query param
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.Servers)
}
servers, reqInf, err := toClient.GetServers(reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetServers"))
if err != nil {
return errors.New("getting servers: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "Servers")
toData.Servers = oldCfg.Servers
} else {
log.Infof("Getting config: %v is modified, using new response", "Servers")
toData.Servers = servers
}
toData.MetaData.Servers = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
server := &atscfg.Server{}
for _, toServer := range toData.Servers {
if toServer.HostName != "" && toServer.HostName == cacheHostName {
server = &toServer
break
}
}
if server.ID == 0 {
return errors.New("server '" + cacheHostName + " not found in servers")
} else if server.CDN == "" {
return errors.New("server '" + cacheHostName + " missing CDNName")
} else if server.CDNID == 0 {
return errors.New("server '" + cacheHostName + " missing CDNID")
} else if len(server.Profiles) == 0 {
return errors.New("server '" + cacheHostName + " missing Profile")
}
toData.Server = server
sslF := func() error {
defer func(start time.Time) { log.Infof("sslF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil && oldServer.CDN != "" && oldServer.CDN == server.CDN {
reqHdr = MakeReqHdr(oldCfg.MetaData.SSLKeys)
}
keys, reqInf, err := toClient.GetCDNSSLKeys(tc.CDNName(server.CDN), reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetCDNSSLKeys("+server.CDN+")"))
if err != nil {
return errors.New("getting cdn '" + server.CDN + "': " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "SSLKeys")
toData.SSLKeys = oldCfg.SSLKeys
} else {
log.Infof("Getting config: %v is modified, using new response", "SSLKeys")
toData.SSLKeys = keys
}
toData.MetaData.SSLKeys = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
dsF := func() error {
defer func(start time.Time) { log.Infof("dsF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil && oldServer.CDN != "" && oldServer.CDN == server.CDN {
reqHdr = MakeReqHdr(oldCfg.MetaData.DeliveryServices)
}
dses, reqInf, err := toClient.GetCDNDeliveryServices(server.CDNID, reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetCDNDeliveryServices("+strconv.Itoa(server.CDNID)+")"))
if err != nil {
return errors.New("getting delivery services: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "DeliveryServices")
toData.DeliveryServices = oldCfg.DeliveryServices
} else {
log.Infof("Getting config: %v is modified, using new response", "DeliveryServices")
toData.DeliveryServices = dses
}
toData.MetaData.DeliveryServices = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
// TODO uncomment when MSO Origins are changed to not use DSS, to avoid the DSS call if it isn't necessary
// allDSesHaveTopologies := true
// for _, ds := range toData.DeliveryServices {
// if ds.CDNID == nil || *ds.CDNID != *server.CDNID {
// continue
// }
// if ds.Topology == nil {
// allDSesHaveTopologies = false
// break
// }
// }
dssF := func() error {
defer func(start time.Time) { log.Infof("dssF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil && oldServer.CDN != "" && oldServer.CDN == server.CDN {
reqHdr = MakeReqHdr(oldCfg.MetaData.DeliveryServiceServers)
}
dss, reqInf, err := toClient.GetDeliveryServiceServers(nil, nil, server.CDN, reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetDeliveryServiceServers("+server.CDN+")"))
if err != nil {
return errors.New("getting delivery service servers: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "DeliveryServiceServers")
toData.DeliveryServiceServers = oldCfg.DeliveryServiceServers
} else {
log.Infof("Getting config: %v is modified, using new response", "DeliveryServiceServers")
toData.DeliveryServiceServers = filterUnusedDSS(dss, toData.Server.CDNID, toData.Servers, toData.DeliveryServices)
}
toData.MetaData.DeliveryServiceServers = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
uriSignKeysF := func() error {
defer func(start time.Time) { log.Infof("uriF took %v\n", time.Since(start)) }(time.Now())
uriSigningKeys := map[tc.DeliveryServiceName][]byte{}
toData.MetaData.URISigningKeys = map[tc.DeliveryServiceName]ReqMetaData{}
for _, ds := range toData.DeliveryServices {
if ds.XMLID == "" {
continue // TODO warn?
}
// TODO read meta config gen, and only include servers which are included in the meta (assigned to edge or all for mids? read the meta gen to find out)
if ds.SigningAlgorithm == nil || *ds.SigningAlgorithm != tc.SigningAlgorithmURISigning {
continue
}
reqHdr := (http.Header)(nil)
if oldCfg != nil && oldCfg.MetaData.URISigningKeys != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.URISigningKeys[tc.DeliveryServiceName(ds.XMLID)])
}
keys, reqInf, err := toClient.GetURISigningKeys(ds.XMLID, reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetURISigningKeys("+ds.XMLID+")"))
if err != nil {
if strings.Contains(strings.ToLower(err.Error()), "not found") {
log.Errorln("Delivery service '" + ds.XMLID + "' is uri_signing, but keys not found! Skipping!")
continue
} else {
return errors.New("getting uri signing keys for ds '" + ds.XMLID + "': " + err.Error())
}
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "URISigningKeys["+ds.XMLID+"]")
uriSigningKeys[tc.DeliveryServiceName(ds.XMLID)] = oldCfg.URISigningKeys[tc.DeliveryServiceName(ds.XMLID)]
} else {
log.Infof("Getting config: %v is modified, using new response", "URISigningKeys["+ds.XMLID+"]")
uriSigningKeys[tc.DeliveryServiceName(ds.XMLID)] = keys
}
toData.MetaData.URISigningKeys[tc.DeliveryServiceName(ds.XMLID)] = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
toData.URISigningKeys = uriSigningKeys
return nil
}
urlSigKeysF := func() error {
defer func(start time.Time) { log.Infof("urlF took %v\n", time.Since(start)) }(time.Now())
urlSigKeys := map[tc.DeliveryServiceName]tc.URLSigKeys{}
toData.MetaData.URLSigKeys = map[tc.DeliveryServiceName]ReqMetaData{}
for _, ds := range toData.DeliveryServices {
if ds.XMLID == "" {
continue // TODO warn?
}
// TODO read meta config gen, and only include servers which are included in the meta (assigned to edge or all for mids? read the meta gen to find out)
if ds.SigningAlgorithm == nil || *ds.SigningAlgorithm != tc.SigningAlgorithmURLSig {
continue
}
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.URLSigKeys[tc.DeliveryServiceName(ds.XMLID)])
}
keys, reqInf, err := toClient.GetURLSigKeys(ds.XMLID, reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetURLSigKeys("+ds.XMLID+")"))
if err != nil {
if strings.Contains(strings.ToLower(err.Error()), "not found") {
log.Errorln("Delivery service '" + ds.XMLID + "' is url_sig, but keys not found! Skipping!: " + err.Error())
continue
} else {
return errors.New("getting url sig keys for ds '" + ds.XMLID + "': " + err.Error())
}
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "URLSigKeys["+ds.XMLID+"]")
urlSigKeys[tc.DeliveryServiceName(ds.XMLID)] = oldCfg.URLSigKeys[tc.DeliveryServiceName(ds.XMLID)]
} else {
log.Infof("Getting config: %v is modified, using new response", "URLSigKeys["+ds.XMLID+"]")
urlSigKeys[tc.DeliveryServiceName(ds.XMLID)] = keys
}
toData.MetaData.URLSigKeys[tc.DeliveryServiceName(ds.XMLID)] = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
toData.URLSigKeys = urlSigKeys
return nil
}
fs := []func() error{}
if !revalOnly {
fs = append([]func() error{uriSignKeysF, urlSigKeysF}, fs...) // skip keys for reval-only, which doesn't need them
}
if !revalOnly { // TODO when MSO Origins are changed to not use DSS, we can add `&& !allDSesHaveTopologies` here, to avoid the DSS call if it isn't necessary
// skip DSS if reval-only (which doesn't need DSS)
fs = append([]func() error{dssF}, fs...)
}
return util.JoinErrs(runParallel(fs))
}
// TODO use a single func/request, when TO has an endpoint to get all params on multiple profiles with a single request, e.g. `/parameters?profiles=a,b,c`
serverParamsF := func(profileName atscfg.ProfileName) error {
defer func(start time.Time) { log.Infof("serverParamsF(%v) took %v\n", profileName, time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
if md, ok := oldCfg.MetaData.ServerProfilesParams[profileName]; ok {
reqHdr = MakeReqHdr(md)
}
}
params, reqInf, err := toClient.GetServerProfileParameters(string(profileName), reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetServerProfileParameters("+string(profileName)+")"))
if err != nil {
return errors.New("getting server profile '" + string(profileName) + "' parameters: " + err.Error())
} else if len(params) == 0 {
return errors.New("getting server profile '" + string(profileName) + "' parameters: no parameters (profile not found?)")
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "ServerParams")
serverProfilesParams.Store(profileName, oldCfg.ServerProfilesParams[profileName])
} else {
log.Infof("Getting config: %v is modified, using new response", "ServerProfileParams("+string(profileName))
serverProfilesParams.Store(profileName, params)
}
serverProfilesParamsMetaData.Store(profileName, MakeReqMetaData(reqInf.RespHeaders))
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
serverParamsFs := []func() error{}
for _, profileNamePtr := range server.Profiles {
profileName := profileNamePtr // must copy, because Go for-loops overwrite the variable every iteration
serverParamsFs = append(serverParamsFs, func() error { return serverParamsF(atscfg.ProfileName(profileName)) })
}
cdnF := func() error {
defer func(start time.Time) { log.Infof("cdnF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil && oldServer.CDN != "" && oldServer.CDN == server.CDN {
reqHdr = MakeReqHdr(oldCfg.MetaData.CDN)
}
cdn, reqInf, err := toClient.GetCDN(tc.CDNName(server.CDN), reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetCDN("+server.CDN+")"))
if err != nil {
return errors.New("getting cdn '" + server.CDN + "': " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "CDN")
toData.CDN = oldCfg.CDN
} else {
log.Infof("Getting config: %v is modified, using new response", "CDN")
toData.CDN = &cdn
}
toData.MetaData.CDN = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
jobsF := func() error {
defer func(start time.Time) { log.Infof("jobsF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil && oldServer.CDN != "" && oldServer.CDN == server.CDN {
reqHdr = MakeReqHdr(oldCfg.MetaData.Jobs)
}
jobs, reqInf, err := toClient.GetJobs(reqHdr, server.CDN)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetJobs("+server.CDN+")"))
if err != nil {
return errors.New("getting jobs: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "Jobs")
toData.Jobs = oldCfg.Jobs
} else {
log.Infof("Getting config: %v is modified, using new response", "Jobs")
toData.Jobs = jobs
}
toData.MetaData.Jobs = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
fs := []func() error{dsF, cdnF, jobsF}
fs = append(fs, serverParamsFs...)
if !revalOnly {
fs = append([]func() error{sslF}, fs...) // skip ssl keys for reval only, which doesn't need them
}
return util.JoinErrs(runParallel(fs))
}
cgF := func() error {
defer func(start time.Time) { log.Infof("cfF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.CacheGroups)
}
cacheGroups, reqInf, err := toClient.GetCacheGroups(reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetCacheGroups"))
if err != nil {
return errors.New("getting cachegroups: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "CacheGroups")
toData.CacheGroups = oldCfg.CacheGroups
} else {
log.Infof("Getting config: %v is modified, using new response", "CacheGroups")
toData.CacheGroups = cacheGroups
}
toData.MetaData.CacheGroups = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
capsF := func() error {
defer func(start time.Time) { log.Infof("capsF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.ServerCapabilities)
}
log.Infof("Getting config: ServerCapabilities reqHdr %+v", reqHdr)
caps, reqInf, err := toClient.GetServerCapabilitiesByID(nil, reqHdr) // TODO change to not take a param; it doesn't use it to request TO anyway.
log.Infoln(toreq.RequestInfoStr(reqInf, "GetServerCapabilitiesByID"))
if err != nil {
return errors.New("getting server caps from Traffic Ops: " + err.Error())
} else {
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "ServerCapabilities")
toData.ServerCapabilities = oldCfg.ServerCapabilities
} else {
log.Infof("Getting config: %v is modified, using new response", "ServerCapabilities")
toData.ServerCapabilities = caps
}
toData.MetaData.ServerCapabilities = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
}
return nil
}
// this endpoint has been removed in APIv5, DS required capabilities will be populated by t3c-generate
// from the deliveryservice structure, /this is being kept for backwards compatability
dsCapsF := func() error {
defer func(start time.Time) { log.Infof("dscapsF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.DSRequiredCapabilities)
}
caps, reqInf, err := toClient.GetDeliveryServiceRequiredCapabilitiesByID(nil, reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetDeliveryServiceRequiredCapabilitiesByID"))
if err != nil {
if strings.Contains(err.Error(), "/api/5.0/deliveryservices_required_capabilities' does not exist") {
log.Infof("This endpoint was removed in APIv5 %s", err.Error())
return nil
}
return errors.New("getting DS required capabilities: " + err.Error())
} else {
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "DSRequiredCapabilities")
toData.DSRequiredCapabilities = oldCfg.DSRequiredCapabilities
} else {
log.Infof("Getting config: %v is modified, using new response", "DSRequiredCapabilities")
toData.DSRequiredCapabilities = caps
}
toData.MetaData.DSRequiredCapabilities = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
}
return nil
}
dsrF := func() error {
defer func(start time.Time) { log.Infof("dsrF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.DeliveryServiceRegexes)
}
dsr, reqInf, err := toClient.GetDeliveryServiceRegexes(reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetDeliveryServiceRegexes"))
if err != nil {
return errors.New("getting delivery service regexes: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "DeliveryServiceRegexes")
toData.DeliveryServiceRegexes = oldCfg.DeliveryServiceRegexes
} else {
log.Infof("Getting config: %v is modified, using new response", "DeliveryServiceRegexes")
toData.DeliveryServiceRegexes = dsr
}
toData.MetaData.DeliveryServiceRegexes = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
cacheKeyConfigParamsF := func() error {
defer func(start time.Time) { log.Infof("cacheKeyConfigParamsF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.CacheKeyConfigParams)
}
params, reqInf, err := toClient.GetConfigFileParameters("cachekey.config", reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetConfigFileParameters(cachekey.config)"))
if err != nil {
return errors.New("getting cache key parameters: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "CacheKeyParams")
toData.CacheKeyConfigParams = oldCfg.CacheKeyConfigParams
} else {
log.Infof("Getting config: %v is modified, using new response", "CacheKeyParams")
toData.CacheKeyConfigParams = params
}
toData.MetaData.CacheKeyConfigParams = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
remapConfigParamsF := func() error {
defer func(start time.Time) { log.Infof("remapConfigParamsF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.RemapConfigParams)
}
params, reqInf, err := toClient.GetConfigFileParameters("remap.config", reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetConfigFileParameters(remap.config)"))
if err != nil {
return errors.New("getting cache key parameters: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "RemapConfigParams")
toData.RemapConfigParams = oldCfg.RemapConfigParams
} else {
log.Infof("Getting config: %v is modified, using new response", "RemapConfigParams")
toData.RemapConfigParams = params
}
toData.MetaData.RemapConfigParams = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
parentConfigParamsF := func() error {
defer func(start time.Time) { log.Infof("parentConfigParamsF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.ParentConfigParams)
}
parentConfigParams, reqInf, err := toClient.GetConfigFileParameters("parent.config", reqHdr) // TODO make const in lib/go-atscfg
log.Infoln(toreq.RequestInfoStr(reqInf, "GetConfigFileParameters(parent.config)"))
if err != nil {
return errors.New("getting parent.config parameters: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "ParentConfigParams")
toData.ParentConfigParams = oldCfg.ParentConfigParams
} else {
log.Infof("Getting config: %v is modified, using new response", "ParentConfigParams")
toData.ParentConfigParams = parentConfigParams
}
toData.MetaData.ParentConfigParams = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
topologiesF := func() error {
defer func(start time.Time) { log.Infof("topologiesF took %v\n", time.Since(start)) }(time.Now())
{
reqHdr := (http.Header)(nil)
if oldCfg != nil {
reqHdr = MakeReqHdr(oldCfg.MetaData.Topologies)
}
topologies, reqInf, err := toClient.GetTopologies(reqHdr)
log.Infoln(toreq.RequestInfoStr(reqInf, "GetTopologies"))
if err != nil {
return errors.New("getting topologies: " + err.Error())
}
if reqInf.StatusCode == http.StatusNotModified {
log.Infof("Getting config: %v not modified, using old config", "Topologies")
toData.Topologies = oldCfg.Topologies
} else {
log.Infof("Getting config: %v is modified, using new response", "Topologies")
toData.Topologies = topologies
}
toData.MetaData.Topologies = MakeReqMetaData(reqInf.RespHeaders)
toIPs.Store(reqInf.RemoteAddr, nil)
}
return nil
}
fs := []func() error{serversF, cgF}
if !revalOnly {
// skip data not needed for reval, if we're reval-only
fs = append([]func() error{dsrF, cacheKeyConfigParamsF, remapConfigParamsF, parentConfigParamsF, capsF, dsCapsF, topologiesF}, fs...)
}
errs := runParallel(fs)
toAddrSet := map[string]struct{}{} // use a set to remove duplicates
toIPs.Range(func(key, val interface{}) bool {
toAddrSet[key.(net.Addr).String()] = struct{}{}
return true
})
for addr, _ := range toAddrSet {
toData.TrafficOpsAddresses = append(toData.TrafficOpsAddresses, addr)
}
toData.TrafficOpsURL = toClient.URL()
toData.ServerProfilesParams = map[atscfg.ProfileName][]tc.ParameterV5{}
serverProfilesParams.Range(func(key, val interface{}) bool {
profileName := key.(atscfg.ProfileName)
params := val.([]tc.ParameterV5)
toData.ServerProfilesParams[profileName] = params
return true
})
toData.MetaData.ServerProfilesParams = map[atscfg.ProfileName]ReqMetaData{}
serverProfilesParamsMetaData.Range(func(key, val interface{}) bool {
profileName := key.(atscfg.ProfileName)
metaData := val.(ReqMetaData)
toData.MetaData.ServerProfilesParams[profileName] = metaData
return true
})
if len(errs) == 0 && toData.Server != nil {
err := error(nil)
toData.ServerParams, err = atscfg.GetServerParameters(toData.Server, combineParams(toData.ServerProfilesParams))
if err != nil {
errs = append(errs, err)
}
}
return toData, util.JoinErrs(errs)
}