rebase: update K8s packages to v0.32.1

Update K8s packages in go.mod to v0.32.1

Signed-off-by: Praveen M <m.praveen@ibm.com>

vendor/github.com/google/cadvisor/collector/collector_manager.go

@@ -0,0 +1,109 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+const metricLabelPrefix = "io.cadvisor.metric."
+
+type GenericCollectorManager struct {
+	Collectors         []*collectorData
+	NextCollectionTime time.Time
+}
+
+type collectorData struct {
+	collector          Collector
+	nextCollectionTime time.Time
+}
+
+// Returns a new CollectorManager that is thread-compatible.
+func NewCollectorManager() (CollectorManager, error) {
+	return &GenericCollectorManager{
+		Collectors:         []*collectorData{},
+		NextCollectionTime: time.Now(),
+	}, nil
+}
+
+func GetCollectorConfigs(labels map[string]string) map[string]string {
+	configs := map[string]string{}
+	for k, v := range labels {
+		if strings.HasPrefix(k, metricLabelPrefix) {
+			name := strings.TrimPrefix(k, metricLabelPrefix)
+			configs[name] = v
+		}
+	}
+	return configs
+}
+
+func (cm *GenericCollectorManager) RegisterCollector(collector Collector) error {
+	cm.Collectors = append(cm.Collectors, &collectorData{
+		collector:          collector,
+		nextCollectionTime: time.Now(),
+	})
+	return nil
+}
+
+func (cm *GenericCollectorManager) GetSpec() ([]v1.MetricSpec, error) {
+	metricSpec := []v1.MetricSpec{}
+	for _, c := range cm.Collectors {
+		specs := c.collector.GetSpec()
+		metricSpec = append(metricSpec, specs...)
+	}
+
+	return metricSpec, nil
+}
+
+func (cm *GenericCollectorManager) Collect() (time.Time, map[string][]v1.MetricVal, error) {
+	var errors []error
+
+	// Collect from all collectors that are ready.
+	var next time.Time
+	metrics := map[string][]v1.MetricVal{}
+	for _, c := range cm.Collectors {
+		if c.nextCollectionTime.Before(time.Now()) {
+			var err error
+			c.nextCollectionTime, metrics, err = c.collector.Collect(metrics)
+			if err != nil {
+				errors = append(errors, err)
+			}
+		}
+
+		// Keep track of the next collector that will be ready.
+		if next.IsZero() || next.After(c.nextCollectionTime) {
+			next = c.nextCollectionTime
+		}
+	}
+	cm.NextCollectionTime = next
+	return next, metrics, compileErrors(errors)
+}
+
+// Make an error slice into a single error.
+func compileErrors(errors []error) error {
+	if len(errors) == 0 {
+		return nil
+	}
+
+	res := make([]string, len(errors))
+	for i := range errors {
+		res[i] = fmt.Sprintf("Error %d: %v", i, errors[i].Error())
+	}
+	return fmt.Errorf("%s", strings.Join(res, ","))
+}

vendor/github.com/google/cadvisor/collector/config.go

@@ -0,0 +1,101 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import (
+	"time"
+
+	"encoding/json"
+
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+type Config struct {
+	// the endpoint to hit to scrape metrics
+	Endpoint EndpointConfig `json:"endpoint"`
+
+	// holds information about different metrics that can be collected
+	MetricsConfig []MetricConfig `json:"metrics_config"`
+}
+
+// metricConfig holds information extracted from the config file about a metric
+type MetricConfig struct {
+	// the name of the metric
+	Name string `json:"name"`
+
+	// enum type for the metric type
+	MetricType v1.MetricType `json:"metric_type"`
+
+	// metric units to display on UI and in storage (eg: MB, cores)
+	// this is only used for display.
+	Units string `json:"units"`
+
+	// data type of the metric (eg: int, float)
+	DataType v1.DataType `json:"data_type"`
+
+	// the frequency at which the metric should be collected
+	PollingFrequency time.Duration `json:"polling_frequency"`
+
+	// the regular expression that can be used to extract the metric
+	Regex string `json:"regex"`
+}
+
+type Prometheus struct {
+	// the endpoint to hit to scrape metrics
+	Endpoint EndpointConfig `json:"endpoint"`
+
+	// the frequency at which metrics should be collected
+	PollingFrequency time.Duration `json:"polling_frequency"`
+
+	// holds names of different metrics that can be collected
+	MetricsConfig []string `json:"metrics_config"`
+}
+
+type EndpointConfig struct {
+	// The full URL of the endpoint to reach
+	URL string
+	// A configuration in which an actual URL is constructed from, using the container's ip address
+	URLConfig URLConfig
+}
+
+type URLConfig struct {
+	// the protocol to use for connecting to the endpoint. Eg 'http' or 'https'
+	Protocol string `json:"protocol"`
+
+	// the port to use for connecting to the endpoint. Eg '8778'
+	Port json.Number `json:"port"`
+
+	// the path to use for the endpoint. Eg '/metrics'
+	Path string `json:"path"`
+}
+
+func (ec *EndpointConfig) UnmarshalJSON(b []byte) error {
+	url := ""
+	config := URLConfig{
+		Protocol: "http",
+		Port:     "8000",
+	}
+
+	if err := json.Unmarshal(b, &url); err == nil {
+		ec.URL = url
+		return nil
+	}
+	err := json.Unmarshal(b, &config)
+	if err == nil {
+		ec.URLConfig = config
+		return nil
+	}
+	return err
+}

vendor/github.com/google/cadvisor/collector/fakes.go

@@ -0,0 +1,37 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import (
+	"time"
+
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+type FakeCollectorManager struct {
+}
+
+func (fkm *FakeCollectorManager) RegisterCollector(collector Collector) error {
+	return nil
+}
+
+func (fkm *FakeCollectorManager) GetSpec() ([]v1.MetricSpec, error) {
+	return []v1.MetricSpec{}, nil
+}
+
+func (fkm *FakeCollectorManager) Collect(metric map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) {
+	var zero time.Time
+	return zero, metric, nil
+}

vendor/github.com/google/cadvisor/collector/generic_collector.go

@@ -0,0 +1,183 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/google/cadvisor/container"
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+type GenericCollector struct {
+	// name of the collector
+	name string
+
+	// holds information extracted from the config file for a collector
+	configFile Config
+
+	// holds information necessary to extract metrics
+	info *collectorInfo
+
+	// The Http client to use when connecting to metric endpoints
+	httpClient *http.Client
+}
+
+type collectorInfo struct {
+	// minimum polling frequency among all metrics
+	minPollingFrequency time.Duration
+
+	// regular expresssions for all metrics
+	regexps []*regexp.Regexp
+
+	// Limit for the number of srcaped metrics. If the count is higher,
+	// no metrics will be returned.
+	metricCountLimit int
+}
+
+// Returns a new collector using the information extracted from the configfile
+func NewCollector(collectorName string, configFile []byte, metricCountLimit int, containerHandler container.ContainerHandler, httpClient *http.Client) (*GenericCollector, error) {
+	var configInJSON Config
+	err := json.Unmarshal(configFile, &configInJSON)
+	if err != nil {
+		return nil, err
+	}
+
+	configInJSON.Endpoint.configure(containerHandler)
+
+	// TODO : Add checks for validity of config file (eg : Accurate JSON fields)
+
+	if len(configInJSON.MetricsConfig) == 0 {
+		return nil, fmt.Errorf("No metrics provided in config")
+	}
+
+	minPollFrequency := time.Duration(0)
+	regexprs := make([]*regexp.Regexp, len(configInJSON.MetricsConfig))
+
+	for ind, metricConfig := range configInJSON.MetricsConfig {
+		// Find the minimum specified polling frequency in metric config.
+		if metricConfig.PollingFrequency != 0 {
+			if minPollFrequency == 0 || metricConfig.PollingFrequency < minPollFrequency {
+				minPollFrequency = metricConfig.PollingFrequency
+			}
+		}
+
+		regexprs[ind], err = regexp.Compile(metricConfig.Regex)
+		if err != nil {
+			return nil, fmt.Errorf("Invalid regexp %v for metric %v", metricConfig.Regex, metricConfig.Name)
+		}
+	}
+
+	// Minimum supported polling frequency is 1s.
+	minSupportedFrequency := 1 * time.Second
+	if minPollFrequency < minSupportedFrequency {
+		minPollFrequency = minSupportedFrequency
+	}
+
+	if len(configInJSON.MetricsConfig) > metricCountLimit {
+		return nil, fmt.Errorf("Too many metrics defined: %d limit: %d", len(configInJSON.MetricsConfig), metricCountLimit)
+	}
+
+	return &GenericCollector{
+		name:       collectorName,
+		configFile: configInJSON,
+		info: &collectorInfo{
+			minPollingFrequency: minPollFrequency,
+			regexps:             regexprs,
+			metricCountLimit:    metricCountLimit,
+		},
+		httpClient: httpClient,
+	}, nil
+}
+
+// Returns name of the collector
+func (collector *GenericCollector) Name() string {
+	return collector.name
+}
+
+func (collector *GenericCollector) configToSpec(config MetricConfig) v1.MetricSpec {
+	return v1.MetricSpec{
+		Name:   config.Name,
+		Type:   config.MetricType,
+		Format: config.DataType,
+		Units:  config.Units,
+	}
+}
+
+func (collector *GenericCollector) GetSpec() []v1.MetricSpec {
+	specs := []v1.MetricSpec{}
+	for _, metricConfig := range collector.configFile.MetricsConfig {
+		spec := collector.configToSpec(metricConfig)
+		specs = append(specs, spec)
+	}
+	return specs
+}
+
+// Returns collected metrics and the next collection time of the collector
+func (collector *GenericCollector) Collect(metrics map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) {
+	currentTime := time.Now()
+	nextCollectionTime := currentTime.Add(time.Duration(collector.info.minPollingFrequency))
+
+	uri := collector.configFile.Endpoint.URL
+	response, err := collector.httpClient.Get(uri)
+	if err != nil {
+		return nextCollectionTime, nil, err
+	}
+
+	defer response.Body.Close()
+
+	pageContent, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nextCollectionTime, nil, err
+	}
+
+	var errorSlice []error
+
+	for ind, metricConfig := range collector.configFile.MetricsConfig {
+		matchString := collector.info.regexps[ind].FindStringSubmatch(string(pageContent))
+		if matchString != nil {
+			if metricConfig.DataType == v1.FloatType {
+				regVal, err := strconv.ParseFloat(strings.TrimSpace(matchString[1]), 64)
+				if err != nil {
+					errorSlice = append(errorSlice, err)
+				}
+				metrics[metricConfig.Name] = []v1.MetricVal{
+					{FloatValue: regVal, Timestamp: currentTime},
+				}
+			} else if metricConfig.DataType == v1.IntType {
+				regVal, err := strconv.ParseInt(strings.TrimSpace(matchString[1]), 10, 64)
+				if err != nil {
+					errorSlice = append(errorSlice, err)
+				}
+				metrics[metricConfig.Name] = []v1.MetricVal{
+					{IntValue: regVal, Timestamp: currentTime},
+				}
+
+			} else {
+				errorSlice = append(errorSlice, fmt.Errorf("Unexpected value of 'data_type' for metric '%v' in config ", metricConfig.Name))
+			}
+		} else {
+			errorSlice = append(errorSlice, fmt.Errorf("No match found for regexp: %v for metric '%v' in config", metricConfig.Regex, metricConfig.Name))
+		}
+	}
+	return nextCollectionTime, metrics, compileErrors(errorSlice)
+}

vendor/github.com/google/cadvisor/collector/prometheus_collector.go

@@ -0,0 +1,286 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"sort"
+	"time"
+
+	rawmodel "github.com/prometheus/client_model/go"
+	"github.com/prometheus/common/expfmt"
+	"github.com/prometheus/common/model"
+
+	"github.com/google/cadvisor/container"
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+type PrometheusCollector struct {
+	// name of the collector
+	name string
+
+	// rate at which metrics are collected
+	pollingFrequency time.Duration
+
+	// holds information extracted from the config file for a collector
+	configFile Prometheus
+
+	// the metrics to gather (uses a map as a set)
+	metricsSet map[string]bool
+
+	// Limit for the number of scaped metrics. If the count is higher,
+	// no metrics will be returned.
+	metricCountLimit int
+
+	// The Http client to use when connecting to metric endpoints
+	httpClient *http.Client
+}
+
+// Returns a new collector using the information extracted from the configfile
+func NewPrometheusCollector(collectorName string, configFile []byte, metricCountLimit int, containerHandler container.ContainerHandler, httpClient *http.Client) (*PrometheusCollector, error) {
+	var configInJSON Prometheus
+	err := json.Unmarshal(configFile, &configInJSON)
+	if err != nil {
+		return nil, err
+	}
+
+	configInJSON.Endpoint.configure(containerHandler)
+
+	minPollingFrequency := configInJSON.PollingFrequency
+
+	// Minimum supported frequency is 1s
+	minSupportedFrequency := 1 * time.Second
+
+	if minPollingFrequency < minSupportedFrequency {
+		minPollingFrequency = minSupportedFrequency
+	}
+
+	if metricCountLimit < 0 {
+		return nil, fmt.Errorf("Metric count limit must be greater than or equal to 0")
+	}
+
+	var metricsSet map[string]bool
+	if len(configInJSON.MetricsConfig) > 0 {
+		metricsSet = make(map[string]bool, len(configInJSON.MetricsConfig))
+		for _, name := range configInJSON.MetricsConfig {
+			metricsSet[name] = true
+		}
+	}
+
+	if len(configInJSON.MetricsConfig) > metricCountLimit {
+		return nil, fmt.Errorf("Too many metrics defined: %d limit %d", len(configInJSON.MetricsConfig), metricCountLimit)
+	}
+
+	// TODO : Add checks for validity of config file (eg : Accurate JSON fields)
+	return &PrometheusCollector{
+		name:             collectorName,
+		pollingFrequency: minPollingFrequency,
+		configFile:       configInJSON,
+		metricsSet:       metricsSet,
+		metricCountLimit: metricCountLimit,
+		httpClient:       httpClient,
+	}, nil
+}
+
+// Returns name of the collector
+func (collector *PrometheusCollector) Name() string {
+	return collector.name
+}
+
+func (collector *PrometheusCollector) GetSpec() []v1.MetricSpec {
+
+	response, err := collector.httpClient.Get(collector.configFile.Endpoint.URL)
+	if err != nil {
+		return nil
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		return nil
+	}
+
+	dec := expfmt.NewDecoder(response.Body, expfmt.ResponseFormat(response.Header))
+
+	var specs []v1.MetricSpec
+
+	for {
+		d := rawmodel.MetricFamily{}
+		if err = dec.Decode(&d); err != nil {
+			break
+		}
+		name := d.GetName()
+		if len(name) == 0 {
+			continue
+		}
+		// If metrics to collect is specified, skip any metrics not in the list to collect.
+		if _, ok := collector.metricsSet[name]; collector.metricsSet != nil && !ok {
+			continue
+		}
+
+		spec := v1.MetricSpec{
+			Name:   name,
+			Type:   metricType(d.GetType()),
+			Format: v1.FloatType,
+		}
+		specs = append(specs, spec)
+	}
+
+	if err != nil && err != io.EOF {
+		return nil
+	}
+
+	return specs
+}
+
+// metricType converts Prometheus metric type to cadvisor metric type.
+// If there is no mapping then just return the name of the Prometheus metric type.
+func metricType(t rawmodel.MetricType) v1.MetricType {
+	switch t {
+	case rawmodel.MetricType_COUNTER:
+		return v1.MetricCumulative
+	case rawmodel.MetricType_GAUGE:
+		return v1.MetricGauge
+	default:
+		return v1.MetricType(t.String())
+	}
+}
+
+type prometheusLabels []*rawmodel.LabelPair
+
+func labelSetToLabelPairs(labels model.Metric) prometheusLabels {
+	var promLabels prometheusLabels
+	for k, v := range labels {
+		name := string(k)
+		value := string(v)
+		promLabels = append(promLabels, &rawmodel.LabelPair{Name: &name, Value: &value})
+	}
+	return promLabels
+}
+
+func (s prometheusLabels) Len() int      { return len(s) }
+func (s prometheusLabels) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// ByName implements sort.Interface by providing Less and using the Len and
+// Swap methods of the embedded PrometheusLabels value.
+type byName struct{ prometheusLabels }
+
+func (s byName) Less(i, j int) bool {
+	return s.prometheusLabels[i].GetName() < s.prometheusLabels[j].GetName()
+}
+
+func prometheusLabelSetToCadvisorLabels(promLabels model.Metric) map[string]string {
+	labels := make(map[string]string)
+	for k, v := range promLabels {
+		if string(k) == "__name__" {
+			continue
+		}
+		labels[string(k)] = string(v)
+	}
+	return labels
+}
+
+func prometheusLabelSetToCadvisorLabel(promLabels model.Metric) string {
+	labels := labelSetToLabelPairs(promLabels)
+	sort.Sort(byName{labels})
+	var b bytes.Buffer
+
+	for i, l := range labels {
+		if i > 0 {
+			b.WriteString("\xff")
+		}
+		b.WriteString(l.GetName())
+		b.WriteString("=")
+		b.WriteString(l.GetValue())
+	}
+
+	return b.String()
+}
+
+// Returns collected metrics and the next collection time of the collector
+func (collector *PrometheusCollector) Collect(metrics map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) {
+	currentTime := time.Now()
+	nextCollectionTime := currentTime.Add(time.Duration(collector.pollingFrequency))
+
+	uri := collector.configFile.Endpoint.URL
+	response, err := collector.httpClient.Get(uri)
+	if err != nil {
+		return nextCollectionTime, nil, err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		return nextCollectionTime, nil, fmt.Errorf("server returned HTTP status %s", response.Status)
+	}
+
+	sdec := expfmt.SampleDecoder{
+		Dec: expfmt.NewDecoder(response.Body, expfmt.ResponseFormat(response.Header)),
+		Opts: &expfmt.DecodeOptions{
+			Timestamp: model.TimeFromUnixNano(currentTime.UnixNano()),
+		},
+	}
+
+	var (
+		// 50 is chosen as a reasonable guesstimate at a number of metrics we can
+		// expect from virtually any endpoint to try to save allocations.
+		decSamples = make(model.Vector, 0, 50)
+		newMetrics = make(map[string][]v1.MetricVal)
+	)
+	for {
+		if err = sdec.Decode(&decSamples); err != nil {
+			break
+		}
+
+		for _, sample := range decSamples {
+			metName := string(sample.Metric[model.MetricNameLabel])
+			if len(metName) == 0 {
+				continue
+			}
+			// If metrics to collect is specified, skip any metrics not in the list to collect.
+			if _, ok := collector.metricsSet[metName]; collector.metricsSet != nil && !ok {
+				continue
+			}
+			// TODO Handle multiple labels nicer. Prometheus metrics can have multiple
+			// labels, cadvisor only accepts a single string for the metric label.
+			label := prometheusLabelSetToCadvisorLabel(sample.Metric)
+			labels := prometheusLabelSetToCadvisorLabels(sample.Metric)
+
+			metric := v1.MetricVal{
+				FloatValue: float64(sample.Value),
+				Timestamp:  sample.Timestamp.Time(),
+				Label:      label,
+				Labels:     labels,
+			}
+			newMetrics[metName] = append(newMetrics[metName], metric)
+			if len(newMetrics) > collector.metricCountLimit {
+				return nextCollectionTime, nil, fmt.Errorf("too many metrics to collect")
+			}
+		}
+		decSamples = decSamples[:0]
+	}
+
+	if err != nil && err != io.EOF {
+		return nextCollectionTime, nil, err
+	}
+
+	for key, val := range newMetrics {
+		metrics[key] = append(metrics[key], val...)
+	}
+
+	return nextCollectionTime, metrics, nil
+}

vendor/github.com/google/cadvisor/collector/types.go

@@ -0,0 +1,53 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import (
+	"time"
+
+	v1 "github.com/google/cadvisor/info/v1"
+)
+
+// TODO(vmarmol): Export to a custom metrics type when that is available.
+
+// Metric collector.
+type Collector interface {
+	// Collect metrics from this collector.
+	// Returns the next time this collector should be collected from.
+	// Next collection time is always returned, even when an error occurs.
+	// A collection time of zero means no more collection.
+	Collect(map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error)
+
+	// Return spec for all metrics associated with this collector
+	GetSpec() []v1.MetricSpec
+
+	// Name of this collector.
+	Name() string
+}
+
+// Manages and runs collectors.
+type CollectorManager interface {
+	// Register a collector.
+	RegisterCollector(collector Collector) error
+
+	// Collect from collectors that are ready and return the next time
+	// at which a collector will be ready to collect from.
+	// Next collection time is always returned, even when an error occurs.
+	// A collection time of zero means no more collection.
+	Collect() (time.Time, map[string][]v1.MetricVal, error)
+
+	// Get metric spec from all registered collectors.
+	GetSpec() ([]v1.MetricSpec, error)
+}

vendor/github.com/google/cadvisor/collector/util.go

@@ -0,0 +1,26 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import "github.com/google/cadvisor/container"
+
+func (endpointConfig *EndpointConfig) configure(containerHandler container.ContainerHandler) {
+	//If the exact URL was not specified, generate it based on the ip address of the container.
+	endpoint := endpointConfig
+	if endpoint.URL == "" {
+		ipAddress := containerHandler.GetContainerIPAddress()
+		endpointConfig.URL = endpoint.URLConfig.Protocol + "://" + ipAddress + ":" + endpoint.URLConfig.Port.String() + endpoint.URLConfig.Path
+	}
+}