// getServerTypes gets the cache type of each ATS Edge+Mid Cache server, for the given CDN, from Traffic Ops. func getServerTypes(crc CRConfig) (map[enum.CacheName]enum.CacheType, error) { serverTypes := map[enum.CacheName]enum.CacheType{} for server, serverData := range crc.ContentServers { t := enum.CacheTypeFromString(serverData.Type) if t == enum.CacheTypeInvalid { return nil, fmt.Errorf("getServerTypes CRConfig unknown type for '%s': '%s'", server, serverData.Type) } serverTypes[server] = t } return serverTypes, nil }
// 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 }
// NewCacheStatFilter takes the HTTP query parameters and creates a CacheStatFilter which fulfills the `cache.Filter` interface, filtering according to the query parameters passed. // Query parameters used are `hc`, `stats`, `wildcard`, `type`, and `hosts`. // 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 NewCacheStatFilter(params url.Values, cacheTypes map[enum.CacheName]enum.CacheType) (cache.Filter, error) { validParams := map[string]struct{}{"hc": struct{}{}, "stats": struct{}{}, "wildcard": struct{}{}, "type": struct{}{}, "hosts": 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 } } statsToUse := map[string]struct{}{} if paramStats, exists := params["stats"]; exists && len(paramStats) > 0 { commaStats := strings.Split(paramStats[0], ",") for _, stat := range commaStats { statsToUse[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]) } } hosts := map[enum.CacheName]struct{}{} if paramHosts, exists := params["hosts"]; exists && len(paramHosts) > 0 { commaHosts := strings.Split(paramHosts[0], ",") for _, host := range commaHosts { hosts[enum.CacheName(host)] = struct{}{} } } // parameters without values are considered hosts, e.g. `?my-cache-0` for maybeHost, val := range params { if len(val) == 0 || (len(val) == 1 && val[0] == "") { hosts[enum.CacheName(maybeHost)] = struct{}{} } } return &CacheStatFilter{ historyCount: historyCount, statsToUse: statsToUse, wildcard: wildcard, cacheType: cacheType, hosts: hosts, cacheTypes: cacheTypes, }, nil }