func processHealthResult(cacheHealthChan <-chan cache.Result, toData todata.TODataThreadsafe, localStates peer.CRStatesThreadsafe, lastHealthDurations DurationMapThreadsafe, statHistory StatHistoryThreadsafe, monitorConfig TrafficMonitorConfigMapThreadsafe, peerStates peer.CRStatesPeersThreadsafe, combinedStates peer.CRStatesThreadsafe, fetchCount UintThreadsafe, errorCount UintThreadsafe, events EventsThreadsafe, localCacheStatus CacheAvailableStatusThreadsafe, lastHealthEndTimes map[enum.CacheName]time.Time, healthHistory map[enum.CacheName][]cache.Result, results []cache.Result) {
if len(results) == 0 {
return
}
toDataCopy := toData.Get() // create a copy, so the same data used for all processing of this cache health result
monitorConfigCopy := monitorConfig.Get() // copy now, so all calculations are on the same data
for _, healthResult := range results {
log.Debugf("poll %v %v healthresultman start\n", healthResult.PollID, time.Now())
fetchCount.Inc()
var prevResult cache.Result
healthResultHistory := healthHistory[enum.CacheName(healthResult.Id)]
// healthResultHistory := healthHistory.Get(enum.CacheName(healthResult.Id))
if len(healthResultHistory) != 0 {
prevResult = healthResultHistory[len(healthResultHistory)-1]
}
health.GetVitals(&healthResult, &prevResult, &monitorConfigCopy)
// healthHistory.Set(enum.CacheName(healthResult.Id), pruneHistory(append(healthHistory.Get(enum.CacheName(healthResult.Id)), healthResult), defaultMaxHistory))
healthHistory[enum.CacheName(healthResult.Id)] = pruneHistory(append(healthHistory[enum.CacheName(healthResult.Id)], healthResult), defaultMaxHistory)
isAvailable, whyAvailable := health.EvalCache(healthResult, &monitorConfigCopy)
if localStates.Get().Caches[healthResult.Id].IsAvailable != isAvailable {
log.Infof("Changing state for %s was: %t now: %t because %s errors: %v", healthResult.Id, prevResult.Available, isAvailable, whyAvailable, healthResult.Errors)
events.Add(Event{Time: time.Now().Unix(), Description: whyAvailable, Name: healthResult.Id, Hostname: healthResult.Id, Type: toDataCopy.ServerTypes[enum.CacheName(healthResult.Id)].String(), Available: isAvailable})
}
localCacheStatus.Set(enum.CacheName(healthResult.Id), CacheAvailableStatus{Available: isAvailable, Status: monitorConfigCopy.TrafficServer[healthResult.Id].Status}) // TODO move within localStates
localStates.SetCache(healthResult.Id, peer.IsAvailable{IsAvailable: isAvailable})
log.Debugf("poll %v %v calculateDeliveryServiceState start\n", healthResult.PollID, time.Now())
calculateDeliveryServiceState(toDataCopy.DeliveryServiceServers, localStates)
log.Debugf("poll %v %v calculateDeliveryServiceState end\n", healthResult.PollID, time.Now())
}
// TODO determine if we should combineCrStates() here
for _, healthResult := range results {
if lastHealthStart, ok := lastHealthEndTimes[enum.CacheName(healthResult.Id)]; ok {
d := time.Since(lastHealthStart)
lastHealthDurations.Set(enum.CacheName(healthResult.Id), d)
}
lastHealthEndTimes[enum.CacheName(healthResult.Id)] = time.Now()
log.Debugf("poll %v %v finish\n", healthResult.PollID, time.Now())
healthResult.PollFinished <- healthResult.PollID
}
}
func (handler Handler) Handle(id string, r io.Reader, err error, pollId uint64, pollFinished chan<- uint64) {
log.Debugf("poll %v %v handle start\n", pollId, time.Now())
result := Result{
Id: id,
Available: false,
Errors: []error{},
Time: time.Now(), // TODO change this to be computed the instant we get the result back, to minimise inaccuracy
PollID: pollId,
PollFinished: pollFinished,
}
if err != nil {
log.Errorf("%v handler given error '%v'\n", id, err) // error here, in case the thing that called Handle didn't error
result.Errors = append(result.Errors, err)
handler.ResultChannel <- result
return
}
if r == nil {
log.Errorf("%v handle reader nil\n", id)
result.Errors = append(result.Errors, fmt.Errorf("handler got nil reader"))
handler.ResultChannel <- result
return
}
result.PrecomputedData.Reporting = true
if err := json.NewDecoder(r).Decode(&result.Astats); err != nil {
log.Errorf("%s procnetdev decode error '%v'\n", id, err)
result.Errors = append(result.Errors, err)
handler.ResultChannel <- result
return
}
if result.Astats.System.ProcNetDev == "" {
log.Warnf("addkbps %s procnetdev empty\n", id)
}
log.Debugf("poll %v %v handle decode end\n", pollId, time.Now())
if err != nil {
result.Errors = append(result.Errors, err)
log.Errorf("addkbps handle %s error '%v'\n", id, err)
} else {
result.Available = true
}
if handler.Precompute() {
log.Debugf("poll %v %v handle precompute start\n", pollId, time.Now())
result = handler.precompute(result)
log.Debugf("poll %v %v handle precompute end\n", pollId, time.Now())
}
log.Debugf("poll %v %v handle write start\n", pollId, time.Now())
handler.ResultChannel <- result
log.Debugf("poll %v %v handle end\n", pollId, time.Now())
}
func createCacheStatuses(cacheTypes map[enum.CacheName]enum.CacheType, statHistory map[enum.CacheName][]cache.Result, lastHealthDurations map[enum.CacheName]time.Duration, cacheStates map[string]peer.IsAvailable, lastKbpsStats ds.StatsLastKbps, localCacheStatusThreadsafe CacheAvailableStatusThreadsafe) map[enum.CacheName]CacheStatus {
conns := createCacheConnections(statHistory)
statii := map[enum.CacheName]CacheStatus{}
localCacheStatus := localCacheStatusThreadsafe.Get()
for cacheName, cacheType := range cacheTypes {
cacheStatHistory, ok := statHistory[cacheName]
if !ok {
log.Warnf("createCacheStatuses stat history missing cache %s\n", cacheName)
continue
}
if len(cacheStatHistory) < 1 {
log.Warnf("createCacheStatuses stat history empty for cache %s\n", cacheName)
continue
}
log.Debugf("createCacheStatuses NOT empty for cache %s\n", cacheName)
var loadAverage *float64
procLoadAvg := cacheStatHistory[0].Astats.System.ProcLoadavg
if procLoadAvg != "" {
firstSpace := strings.IndexRune(procLoadAvg, ' ')
if firstSpace == -1 {
log.Warnf("WARNING unexpected proc.loadavg '%s' for cache %s\n", procLoadAvg, cacheName)
} else {
loadAverageVal, err := strconv.ParseFloat(procLoadAvg[:firstSpace], 64)
if err != nil {
log.Warnf("proc.loadavg doesn't contain a float prefix '%s' for cache %s\n", procLoadAvg, cacheName)
} else {
loadAverage = &loadAverageVal
}
}
}
var queryTime *int64
queryTimeVal, ok := lastHealthDurations[cacheName]
if !ok {
log.Warnf("cache not in last health durations cache %s\n", cacheName)
} else {
queryTimeInt := int64(queryTimeVal / time.Millisecond)
queryTime = &queryTimeInt
}
var kbps *float64
kbpsVal, ok := lastKbpsStats.Caches[enum.CacheName(cacheName)]
if !ok {
log.Warnf("cache not in last kbps cache %s\n", cacheName)
} else {
kbps = &kbpsVal.Kbps
}
var connections *int64
connectionsVal, ok := conns[enum.CacheName(cacheName)]
if !ok {
log.Warnf("cache not in connections %s\n", cacheName)
} else {
connections = &connectionsVal
}
var status *string
statusVal, ok := localCacheStatus[enum.CacheName(cacheName)]
if !ok {
log.Warnf("cache not in statuses %s\n", cacheName)
} else {
statusString := statusVal.Status + " - "
if localCacheStatus[enum.CacheName(cacheName)].Available {
statusString += "available"
} else {
statusString += "unavailable"
}
status = &statusString
}
cacheTypeStr := string(cacheType)
statii[enum.CacheName(cacheName)] = CacheStatus{Type: &cacheTypeStr, LoadAverage: loadAverage, QueryTimeMilliseconds: queryTime, BandwidthKbps: kbps, ConnectionCount: connections, Status: status}
}
return statii
}
func addAvailableData(dsStats Stats, crStates peer.Crstates, serverCachegroups map[enum.CacheName]enum.CacheGroupName, serverDs map[string][]string, serverTypes map[enum.CacheName]enum.CacheType, statHistory map[enum.CacheName][]cache.Result) (Stats, error) {
for cache, available := range crStates.Caches {
cacheGroup, ok := serverCachegroups[enum.CacheName(cache)]
if !ok {
log.Warnf("CreateStats not adding availability data for '%s': not found in Cachegroups\n", cache)
continue
}
deliveryServices, ok := serverDs[cache]
if !ok {
log.Warnf("CreateStats not adding availability data for '%s': not found in DeliveryServices\n", cache)
continue
}
cacheType, ok := serverTypes[enum.CacheName(cache)]
if !ok {
log.Warnf("CreateStats not adding availability data for '%s': not found in Server Types\n", cache)
continue
}
for _, deliveryService := range deliveryServices {
if deliveryService == "" {
log.Errorf("EMPTY addAvailableData DS") // various bugs in other functions can cause this - this will help identify and debug them.
continue
}
stat, ok := dsStats.DeliveryService[enum.DeliveryServiceName(deliveryService)]
if !ok {
log.Warnf("CreateStats not adding availability data for '%s': not found in Stats\n", cache)
continue // TODO log warning? Error?
}
if available.IsAvailable {
// c.IsAvailable.Value
stat.Common.IsAvailable.Value = true
stat.Common.CachesAvailable.Value++
cacheGroupStats := stat.CacheGroups[enum.CacheGroupName(cacheGroup)]
cacheGroupStats.IsAvailable.Value = true
stat.CacheGroups[enum.CacheGroupName(cacheGroup)] = cacheGroupStats
stat.Total.IsAvailable.Value = true
typeStats := stat.Type[cacheType]
typeStats.IsAvailable.Value = true
stat.Type[cacheType] = typeStats
}
// TODO fix nested ifs
if results, ok := statHistory[enum.CacheName(cache)]; ok {
if len(results) < 1 {
log.Warnf("no results %v %v\n", cache, deliveryService)
} else {
result := results[0]
if result.PrecomputedData.Reporting {
stat.Common.CachesReporting[enum.CacheName(cache)] = true
} else {
log.Debugf("no reporting %v %v\n", cache, deliveryService)
}
}
} else {
log.Debugf("no result for %v %v\n", cache, deliveryService)
}
dsStats.DeliveryService[enum.DeliveryServiceName(deliveryService)] = stat // TODO Necessary? Remove?
}
}
return dsStats, nil
}