func createApiPeerStates(peerStates map[string]peer.Crstates) ApiPeerStates {
apiPeerStates := ApiPeerStates{Peers: map[enum.TrafficMonitorName]map[enum.CacheName][]CacheState{}}
for peer, state := range peerStates {
if _, ok := apiPeerStates.Peers[enum.TrafficMonitorName(peer)]; !ok {
apiPeerStates.Peers[enum.TrafficMonitorName(peer)] = map[enum.CacheName][]CacheState{}
}
peerState := apiPeerStates.Peers[enum.TrafficMonitorName(peer)]
for cache, available := range state.Caches {
peerState[enum.CacheName(cache)] = []CacheState{CacheState{Value: available.IsAvailable}}
}
apiPeerStates.Peers[enum.TrafficMonitorName(peer)] = peerState
}
return apiPeerStates
}
func (handler Handler) Handle(id string, r io.Reader, err error, pollId uint64, pollFinished chan<- uint64) {
result := Result{
Id: enum.TrafficMonitorName(id),
Available: false,
Errors: []error{},
PollID: pollId,
PollFinished: pollFinished,
}
if err != nil {
result.Errors = append(result.Errors, err)
}
if r != nil {
dec := json.NewDecoder(r)
if err := dec.Decode(&result.PeerStats); err == io.EOF {
result.Available = true
} else if err != nil {
result.Errors = append(result.Errors, err)
}
}
handler.ResultChannel <- result
}
// NewPeerStateFilter takes the HTTP query parameters and creates a cache.Filter, filtering according to the query parameters passed.
// Query parameters used are `hc`, `stats`, `wildcard`, `typep`, and `hosts`. The `stats` param filters caches. The `hosts` param filters peer Traffic Monitors. The `type` param filters cache types (edge, mid).
// If `hc` is 0, all history is returned. If `hc` is empty, 1 history is returned.
// If `stats` is empty, all stats are returned.
// If `wildcard` is empty, `stats` is considered exact.
// If `type` is empty, all cache types are returned.
func NewPeerStateFilter(params url.Values, cacheTypes map[enum.CacheName]enum.CacheType) (*PeerStateFilter, error) {
// TODO change legacy `stats` and `hosts` to `caches` and `monitors` (or `peers`).
validParams := map[string]struct{}{"hc": struct{}{}, "stats": struct{}{}, "wildcard": struct{}{}, "type": struct{}{}, "peers": struct{}{}}
if len(params) > len(validParams) {
return nil, fmt.Errorf("invalid query parameters")
}
for param, _ := range params {
if _, ok := validParams[param]; !ok {
return nil, fmt.Errorf("invalid query parameter '%v'", param)
}
}
historyCount := 1
if paramHc, exists := params["hc"]; exists && len(paramHc) > 0 {
v, err := strconv.Atoi(paramHc[0])
if err == nil {
historyCount = v
}
}
cachesToUse := map[enum.CacheName]struct{}{}
// TODO rename 'stats' to 'caches'
if paramStats, exists := params["stats"]; exists && len(paramStats) > 0 {
commaStats := strings.Split(paramStats[0], ",")
for _, stat := range commaStats {
cachesToUse[enum.CacheName(stat)] = struct{}{}
}
}
wildcard := false
if paramWildcard, exists := params["wildcard"]; exists && len(paramWildcard) > 0 {
wildcard, _ = strconv.ParseBool(paramWildcard[0]) // ignore errors, error => false
}
cacheType := enum.CacheTypeInvalid
if paramType, exists := params["type"]; exists && len(paramType) > 0 {
cacheType = enum.CacheTypeFromString(paramType[0])
if cacheType == enum.CacheTypeInvalid {
return nil, fmt.Errorf("invalid query parameter type '%v' - valid types are: {edge, mid}", paramType[0])
}
}
peersToUse := map[enum.TrafficMonitorName]struct{}{}
if paramNames, exists := params["peers"]; exists && len(paramNames) > 0 {
commaNames := strings.Split(paramNames[0], ",")
for _, name := range commaNames {
peersToUse[enum.TrafficMonitorName(name)] = struct{}{}
}
}
// parameters without values are considered names, e.g. `?my-cache-0` or `?my-delivery-service`
for maybeName, val := range params {
if len(val) == 0 || (len(val) == 1 && val[0] == "") {
peersToUse[enum.TrafficMonitorName(maybeName)] = struct{}{}
}
}
return &PeerStateFilter{
historyCount: historyCount,
cachesToUse: cachesToUse,
wildcard: wildcard,
cacheType: cacheType,
peersToUse: peersToUse,
cacheTypes: cacheTypes,
}, nil
}