// Fetch gets the CRConfig from Traffic Ops, creates the TOData maps, and atomically sets the TOData.
// TODO since the session is threadsafe, each TOData get func below could be put in a goroutine, if performance mattered
// TODO change called funcs to take CRConfigRaw instead of toSession
func (d TODataThreadsafe) Fetch(to towrap.ITrafficOpsSession, cdn string) error {
newTOData := TOData{}
crConfigBytes, err := to.CRConfigRaw(cdn)
if err != nil {
return fmt.Errorf("Error getting CRconfig from Traffic Ops: %v", err)
}
var crConfig CRConfig
if err := json.Unmarshal(crConfigBytes, &crConfig); err != nil {
return fmt.Errorf("Error unmarshalling CRconfig: %v", err)
}
newTOData.DeliveryServiceServers, newTOData.ServerDeliveryServices, err = getDeliveryServiceServers(crConfig)
if err != nil {
return err
}
newTOData.DeliveryServiceTypes, err = getDeliveryServiceTypes(crConfig)
if err != nil {
return fmt.Errorf("Error getting delivery service types from Traffic Ops: %v\n", err)
}
newTOData.DeliveryServiceRegexes, err = getDeliveryServiceRegexes(crConfig)
if err != nil {
return fmt.Errorf("Error getting delivery service regexes from Traffic Ops: %v\n", err)
}
newTOData.ServerCachegroups, err = getServerCachegroups(crConfig)
if err != nil {
return fmt.Errorf("Error getting server cachegroups from Traffic Ops: %v\n", err)
}
newTOData.ServerTypes, err = getServerTypes(crConfig)
if err != nil {
return fmt.Errorf("Error getting server types from Traffic Ops: %v\n", err)
}
d.set(newTOData)
return nil
}
func dataRequestManagerListen(dr <-chan http_server.DataRequest, opsConfig OpsConfigThreadsafe, toSession towrap.ITrafficOpsSession, localStates peer.CRStatesThreadsafe, peerStates peer.CRStatesPeersThreadsafe, combinedStates peer.CRStatesThreadsafe, statHistory StatHistoryThreadsafe, dsStats DSStatsThreadsafe, events EventsThreadsafe, staticAppData StaticAppData, healthPollInterval time.Duration, lastHealthDurations DurationMapThreadsafe, fetchCount UintThreadsafe, healthIteration UintThreadsafe, errorCount UintThreadsafe, toData todata.TODataThreadsafe, localCacheStatus CacheAvailableStatusThreadsafe, lastKbpsStats StatsLastKbpsThreadsafe) {
for {
select {
case req := <-dr:
defer close(req.Response)
var body []byte
var err error
switch req.Type {
case http_server.TRConfig:
cdnName := opsConfig.Get().CdnName
if toSession == nil {
err = fmt.Errorf("Unable to connect to Traffic Ops")
} else if cdnName == "" {
err = fmt.Errorf("No CDN Configured")
} else {
body, err = toSession.CRConfigRaw(cdnName)
}
if err != nil {
err = fmt.Errorf("TR Config: %v", err)
}
case http_server.TRStateDerived:
body, err = peer.CrstatesMarshall(combinedStates.Get())
if err != nil {
err = fmt.Errorf("TR State (derived): %v", err)
}
case http_server.TRStateSelf:
body, err = peer.CrstatesMarshall(localStates.Get())
if err != nil {
err = fmt.Errorf("TR State (self): %v", err)
}
case http_server.CacheStats:
// TODO: add support for ?hc=N query param, stats=, wildcard, individual caches
// add pp and date to the json:
/*
pp: "0=[my-ats-edge-cache-1], hc=[1]",
date: "Thu Oct 09 20:28:36 UTC 2014"
*/
params := req.Parameters
hc := 1
if _, exists := params["hc"]; exists {
v, err := strconv.Atoi(params["hc"][0])
if err == nil {
hc = v
}
}
body, err = cache.StatsMarshall(statHistory.Get(), hc)
if err != nil {
err = fmt.Errorf("CacheStats: %v", err)
}
case http_server.DSStats:
body, err = json.Marshal(ds.StatsJSON(dsStats.Get())) // TODO marshall beforehand, for performance? (test to see how often requests are made)
if err != nil {
err = fmt.Errorf("DsStats: %v", err)
}
case http_server.EventLog:
body, err = json.Marshal(JSONEvents{Events: events.Get()})
if err != nil {
err = fmt.Errorf("EventLog: %v", err)
}
case http_server.PeerStates:
body, err = json.Marshal(createApiPeerStates(peerStates.Get()))
case http_server.StatSummary:
body = []byte("TODO implement")
case http_server.Stats:
body, err = getStats(staticAppData, healthPollInterval, lastHealthDurations.Get(), fetchCount.Get(), healthIteration.Get(), errorCount.Get())
if err != nil {
err = fmt.Errorf("Stats: %v", err)
}
case http_server.ConfigDoc:
opsConfigCopy := opsConfig.Get()
// if the password is blank, leave it blank, so callers can see it's missing.
if opsConfigCopy.Password != "" {
opsConfigCopy.Password = "******"
}
body, err = json.Marshal(opsConfigCopy)
if err != nil {
err = fmt.Errorf("Config Doc: %v", err)
}
case http_server.APICacheCount: // TODO determine if this should use peerStates
body = []byte(strconv.Itoa(len(localStates.Get().Caches)))
case http_server.APICacheAvailableCount:
body = []byte(strconv.Itoa(cacheAvailableCount(localStates.Get().Caches)))
case http_server.APICacheDownCount:
body = []byte(strconv.Itoa(cacheDownCount(localStates.Get().Caches)))
case http_server.APIVersion:
s := "traffic_monitor-" + staticAppData.Version + "."
if len(staticAppData.GitRevision) > 6 {
s += staticAppData.GitRevision[:6]
} else {
s += staticAppData.GitRevision
}
body = []byte(s)
case http_server.APITrafficOpsURI:
body = []byte(opsConfig.Get().Url)
case http_server.APICacheStates:
body, err = json.Marshal(createCacheStatuses(toData.Get().ServerTypes, statHistory.Get(), lastHealthDurations.Get(), localStates.Get().Caches, lastKbpsStats.Get(), localCacheStatus))
case http_server.APIBandwidthKbps:
serverTypes := toData.Get().ServerTypes
kbpsStats := lastKbpsStats.Get()
sum := float64(0.0)
for cache, data := range kbpsStats.Caches {
if serverTypes[cache] != enum.CacheTypeEdge {
continue
}
sum += data.Kbps
}
body = []byte(fmt.Sprintf("%f", sum))
default:
err = fmt.Errorf("Unknown Request Type: %v", req.Type)
}
if err != nil {
errorCount.Inc()
log.Errorf("Request Error: %v\n", err)
} else {
req.Response <- body
}
}
}
}
// Note the OpsConfigManager is in charge of the httpServer, because ops config changes trigger server changes. If other things needed to trigger server restarts, the server could be put in its own goroutine with signal channels
func StartOpsConfigManager(
opsConfigFile string,
toSession towrap.ITrafficOpsSession,
toData todata.TODataThreadsafe,
opsConfigChangeSubscribers []chan<- handler.OpsConfig,
toChangeSubscribers []chan<- towrap.ITrafficOpsSession,
localStates peer.CRStatesThreadsafe,
peerStates peer.CRStatesPeersThreadsafe,
combinedStates peer.CRStatesThreadsafe,
statHistory StatHistoryThreadsafe,
lastStats LastStatsThreadsafe,
dsStats DSStatsThreadsafe,
events EventsThreadsafe,
staticAppData StaticAppData,
healthPollInterval time.Duration,
lastHealthDurations DurationMapThreadsafe,
fetchCount UintThreadsafe,
healthIteration UintThreadsafe,
errorCount UintThreadsafe,
localCacheStatus CacheAvailableStatusThreadsafe,
unpolledCaches UnpolledCachesThreadsafe,
) OpsConfigThreadsafe {
opsConfigFileChannel := make(chan interface{})
opsConfigFilePoller := poller.FilePoller{
File: opsConfigFile,
ResultChannel: opsConfigFileChannel,
}
opsConfigChannel := make(chan handler.OpsConfig)
opsConfigFileHandler := handler.OpsConfigFileHandler{
ResultChannel: opsConfigFilePoller.ResultChannel,
OpsConfigChannel: opsConfigChannel,
}
go opsConfigFileHandler.Listen()
go opsConfigFilePoller.Poll()
opsConfig := NewOpsConfigThreadsafe()
// TODO remove change subscribers, give Threadsafes directly to the things that need them. If they only set vars, and don't actually do work on change.
go func() {
httpServer := http_server.Server{}
for {
select {
case newOpsConfig := <-opsConfigChannel:
var err error
opsConfig.Set(newOpsConfig)
listenAddress := ":80" // default
if newOpsConfig.HttpListener != "" {
listenAddress = newOpsConfig.HttpListener
}
handleErr := func(err error) {
errorCount.Inc()
log.Errorf("OpsConfigManager: %v\n", err)
}
err = httpServer.Run(func(req http_server.DataRequest) ([]byte, int) {
return DataRequest(
req,
opsConfig,
toSession,
localStates,
peerStates,
combinedStates,
statHistory,
dsStats,
events,
staticAppData,
healthPollInterval,
lastHealthDurations,
fetchCount,
healthIteration,
errorCount,
toData,
localCacheStatus,
lastStats,
unpolledCaches,
)
}, listenAddress)
if err != nil {
handleErr(fmt.Errorf("MonitorConfigPoller: error creating HTTP server: %s\n", err))
continue
}
realToSession, err := to.Login(newOpsConfig.Url, newOpsConfig.Username, newOpsConfig.Password, newOpsConfig.Insecure)
if err != nil {
handleErr(fmt.Errorf("MonitorConfigPoller: error instantiating Session with traffic_ops: %s\n", err))
continue
}
toSession.Set(realToSession)
if err := toData.Fetch(toSession, newOpsConfig.CdnName); err != nil {
handleErr(fmt.Errorf("Error getting Traffic Ops data: %v\n", err))
continue
}
// These must be in a goroutine, because the monitorConfigPoller tick sends to a channel this select listens for. Thus, if we block on sends to the monitorConfigPoller, we have a livelock race condition.
// More generically, we're using goroutines as an infinite chan buffer, to avoid potential livelocks
for _, subscriber := range opsConfigChangeSubscribers {
go func() {
subscriber <- newOpsConfig // this is needed for cdnName
}()
}
for _, subscriber := range toChangeSubscribers {
go func() {
subscriber <- toSession
}()
}
}
}
}()
return opsConfig
}
