udpate cadvisor dependency to v0.28.2

vendor/github.com/google/cadvisor/container/containerd/BUILD

@@ -0,0 +1,50 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "client.go",
+        "factory.go",
+        "grpc.go",
+        "handler.go",
+    ],
+    importpath = "github.com/google/cadvisor/container/containerd",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/containerd/containerd/api/services/containers/v1:go_default_library",
+        "//vendor/github.com/containerd/containerd/api/services/tasks/v1:go_default_library",
+        "//vendor/github.com/containerd/containerd/api/services/version/v1:go_default_library",
+        "//vendor/github.com/containerd/containerd/containers:go_default_library",
+        "//vendor/github.com/containerd/containerd/dialer:go_default_library",
+        "//vendor/github.com/containerd/containerd/errdefs:go_default_library",
+        "//vendor/github.com/containerd/containerd/namespaces:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/github.com/golang/protobuf/ptypes/empty:go_default_library",
+        "//vendor/github.com/google/cadvisor/container:go_default_library",
+        "//vendor/github.com/google/cadvisor/container/common:go_default_library",
+        "//vendor/github.com/google/cadvisor/container/libcontainer:go_default_library",
+        "//vendor/github.com/google/cadvisor/fs:go_default_library",
+        "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
+        "//vendor/github.com/google/cadvisor/manager/watcher:go_default_library",
+        "//vendor/github.com/opencontainers/runc/libcontainer/cgroups:go_default_library",
+        "//vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs:go_default_library",
+        "//vendor/github.com/opencontainers/runc/libcontainer/configs:go_default_library",
+        "//vendor/github.com/opencontainers/runtime-spec/specs-go:go_default_library",
+        "//vendor/golang.org/x/net/context:go_default_library",
+        "//vendor/google.golang.org/grpc:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/google/cadvisor/container/containerd/client.go

@@ -0,0 +1,122 @@
+// Copyright 2017 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 containerd
+
+import (
+	"context"
+	"time"
+
+	containersapi "github.com/containerd/containerd/api/services/containers/v1"
+	tasksapi "github.com/containerd/containerd/api/services/tasks/v1"
+	versionapi "github.com/containerd/containerd/api/services/version/v1"
+	"github.com/containerd/containerd/containers"
+	"github.com/containerd/containerd/dialer"
+	"github.com/containerd/containerd/errdefs"
+	pempty "github.com/golang/protobuf/ptypes/empty"
+	"google.golang.org/grpc"
+)
+
+const (
+	// k8sNamespace is the namespace we use to connect containerd.
+	k8sNamespace = "k8s.io"
+)
+
+type client struct {
+	containerService containersapi.ContainersClient
+	taskService      tasksapi.TasksClient
+	versionService   versionapi.VersionClient
+}
+
+type containerdClient interface {
+	LoadContainer(ctx context.Context, id string) (*containers.Container, error)
+	TaskPid(ctx context.Context, id string) (uint32, error)
+	Version(ctx context.Context) (string, error)
+}
+
+// Client creates a containerd client
+func Client() (containerdClient, error) {
+	gopts := []grpc.DialOption{
+		grpc.WithInsecure(),
+		grpc.FailOnNonTempDialError(true),
+		grpc.WithDialer(dialer.Dialer),
+		grpc.WithBlock(),
+		grpc.WithTimeout(2 * time.Second),
+		grpc.WithBackoffMaxDelay(3 * time.Second),
+	}
+	unary, stream := newNSInterceptors(k8sNamespace)
+	gopts = append(gopts,
+		grpc.WithUnaryInterceptor(unary),
+		grpc.WithStreamInterceptor(stream),
+	)
+
+	conn, err := grpc.Dial(dialer.DialAddress("/var/run/containerd/containerd.sock"), gopts...)
+	if err != nil {
+		return nil, err
+	}
+	c := &client{
+		containerService: containersapi.NewContainersClient(conn),
+		taskService:      tasksapi.NewTasksClient(conn),
+		versionService:   versionapi.NewVersionClient(conn),
+	}
+	return c, err
+}
+
+func (c *client) LoadContainer(ctx context.Context, id string) (*containers.Container, error) {
+	r, err := c.containerService.Get(ctx, &containersapi.GetContainerRequest{
+		ID: id,
+	})
+	if err != nil {
+		return nil, errdefs.FromGRPC(err)
+	}
+	return containerFromProto(r.Container), nil
+}
+
+func (c *client) TaskPid(ctx context.Context, id string) (uint32, error) {
+	response, err := c.taskService.Get(ctx, &tasksapi.GetRequest{
+		ContainerID: id,
+	})
+	if err != nil {
+		return 0, errdefs.FromGRPC(err)
+	}
+	return response.Process.Pid, nil
+}
+
+func (c *client) Version(ctx context.Context) (string, error) {
+	response, err := c.versionService.Version(ctx, &pempty.Empty{})
+	if err != nil {
+		return "", errdefs.FromGRPC(err)
+	}
+	return response.Version, nil
+}
+
+func containerFromProto(containerpb containersapi.Container) *containers.Container {
+	var runtime containers.RuntimeInfo
+	if containerpb.Runtime != nil {
+		runtime = containers.RuntimeInfo{
+			Name:    containerpb.Runtime.Name,
+			Options: containerpb.Runtime.Options,
+		}
+	}
+	return &containers.Container{
+		ID:          containerpb.ID,
+		Labels:      containerpb.Labels,
+		Image:       containerpb.Image,
+		Runtime:     runtime,
+		Spec:        containerpb.Spec,
+		Snapshotter: containerpb.Snapshotter,
+		SnapshotKey: containerpb.SnapshotKey,
+		Extensions:  containerpb.Extensions,
+	}
+}

vendor/github.com/google/cadvisor/container/containerd/factory.go

@@ -0,0 +1,148 @@
+// Copyright 2017 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 containerd
+
+import (
+	"flag"
+	"fmt"
+	"path"
+	"regexp"
+	"strings"
+
+	"github.com/golang/glog"
+	"golang.org/x/net/context"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/container/libcontainer"
+	"github.com/google/cadvisor/fs"
+	info "github.com/google/cadvisor/info/v1"
+	"github.com/google/cadvisor/manager/watcher"
+)
+
+var ArgContainerdEndpoint = flag.String("containerd", "unix:///var/run/containerd.sock", "containerd endpoint")
+
+// The namespace under which containerd aliases are unique.
+const k8sContainerdNamespace = "containerd"
+
+// Regexp that identifies containerd cgroups, containers started with
+// --cgroup-parent have another prefix than 'containerd'
+var containerdCgroupRegexp = regexp.MustCompile(`([a-z0-9]{64})`)
+
+type containerdFactory struct {
+	machineInfoFactory info.MachineInfoFactory
+	client             containerdClient
+	version            string
+	// Information about the mounted cgroup subsystems.
+	cgroupSubsystems libcontainer.CgroupSubsystems
+	// Information about mounted filesystems.
+	fsInfo        fs.FsInfo
+	ignoreMetrics container.MetricSet
+}
+
+func (self *containerdFactory) String() string {
+	return k8sContainerdNamespace
+}
+
+func (self *containerdFactory) NewContainerHandler(name string, inHostNamespace bool) (handler container.ContainerHandler, err error) {
+	client, err := Client()
+	if err != nil {
+		return
+	}
+
+	metadataEnvs := []string{}
+	return newContainerdContainerHandler(
+		client,
+		name,
+		self.machineInfoFactory,
+		self.fsInfo,
+		&self.cgroupSubsystems,
+		inHostNamespace,
+		metadataEnvs,
+		self.ignoreMetrics,
+	)
+}
+
+// Returns the containerd ID from the full container name.
+func ContainerNameToContainerdID(name string) string {
+	id := path.Base(name)
+	if matches := containerdCgroupRegexp.FindStringSubmatch(id); matches != nil {
+		return matches[1]
+	}
+	return id
+}
+
+// isContainerName returns true if the cgroup with associated name
+// corresponds to a containerd container.
+func isContainerName(name string) bool {
+	// TODO: May be check with HasPrefix ContainerdNamespace
+	if strings.HasSuffix(name, ".mount") {
+		return false
+	}
+	return containerdCgroupRegexp.MatchString(path.Base(name))
+}
+
+// Containerd can handle and accept all containerd created containers
+func (self *containerdFactory) CanHandleAndAccept(name string) (bool, bool, error) {
+	// if the container is not associated with containerd, we can't handle it or accept it.
+	if !isContainerName(name) {
+		return false, false, nil
+	}
+	// Check if the container is known to containerd and it is running.
+	id := ContainerNameToContainerdID(name)
+	// If container and task lookup in containerd fails then we assume
+	// that the container state is not known to containerd
+	ctx := context.Background()
+	_, err := self.client.LoadContainer(ctx, id)
+	if err != nil {
+		return false, false, fmt.Errorf("failed to load container: %v", err)
+	}
+
+	return true, true, nil
+}
+
+func (self *containerdFactory) DebugInfo() map[string][]string {
+	return map[string][]string{}
+}
+
+// Register root container before running this function!
+func Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo, ignoreMetrics container.MetricSet) error {
+	client, err := Client()
+	if err != nil {
+		return fmt.Errorf("unable to create containerd client: %v", err)
+	}
+
+	containerdVersion, err := client.Version(context.Background())
+	if err != nil {
+		return fmt.Errorf("failed to fetch containerd client version: %v", err)
+	}
+
+	cgroupSubsystems, err := libcontainer.GetCgroupSubsystems()
+	if err != nil {
+		return fmt.Errorf("failed to get cgroup subsystems: %v", err)
+	}
+
+	glog.Infof("Registering containerd factory")
+	f := &containerdFactory{
+		cgroupSubsystems:   cgroupSubsystems,
+		client:             client,
+		fsInfo:             fsInfo,
+		machineInfoFactory: factory,
+		version:            containerdVersion,
+		ignoreMetrics:      ignoreMetrics,
+	}
+
+	container.RegisterContainerHandlerFactory(f, []watcher.ContainerWatchSource{watcher.Raw})
+	return nil
+}

vendor/github.com/google/cadvisor/container/containerd/grpc.go

@@ -0,0 +1,49 @@
+// Copyright 2017 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.
+
+//This code has been taken from containerd repo to avoid large library import
+package containerd
+
+import (
+	"github.com/containerd/containerd/namespaces"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+)
+
+type namespaceInterceptor struct {
+	namespace string
+}
+
+func (ni namespaceInterceptor) unary(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+	_, ok := namespaces.Namespace(ctx)
+	if !ok {
+		ctx = namespaces.WithNamespace(ctx, ni.namespace)
+	}
+	return invoker(ctx, method, req, reply, cc, opts...)
+}
+
+func (ni namespaceInterceptor) stream(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
+	_, ok := namespaces.Namespace(ctx)
+	if !ok {
+		ctx = namespaces.WithNamespace(ctx, ni.namespace)
+	}
+	return streamer(ctx, desc, cc, method, opts...)
+}
+
+func newNSInterceptors(ns string) (grpc.UnaryClientInterceptor, grpc.StreamClientInterceptor) {
+	ni := namespaceInterceptor{
+		namespace: ns,
+	}
+	return grpc.UnaryClientInterceptor(ni.unary), grpc.StreamClientInterceptor(ni.stream)
+}

vendor/github.com/google/cadvisor/container/containerd/handler.go

@@ -0,0 +1,246 @@
+// Copyright 2017 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.
+
+// Handler for containerd containers.
+package containerd
+
+import (
+	"encoding/json"
+	"fmt"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/opencontainers/runc/libcontainer/cgroups"
+	cgroupfs "github.com/opencontainers/runc/libcontainer/cgroups/fs"
+	libcontainerconfigs "github.com/opencontainers/runc/libcontainer/configs"
+	"golang.org/x/net/context"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/container/common"
+	containerlibcontainer "github.com/google/cadvisor/container/libcontainer"
+	"github.com/google/cadvisor/fs"
+	info "github.com/google/cadvisor/info/v1"
+	specs "github.com/opencontainers/runtime-spec/specs-go"
+)
+
+type containerdContainerHandler struct {
+	client             containerdClient
+	name               string
+	id                 string
+	aliases            []string
+	machineInfoFactory info.MachineInfoFactory
+	// Absolute path to the cgroup hierarchies of this container.
+	// (e.g.: "cpu" -> "/sys/fs/cgroup/cpu/test")
+	cgroupPaths map[string]string
+	// Manager of this container's cgroups.
+	cgroupManager cgroups.Manager
+	fsInfo        fs.FsInfo
+	poolName      string
+	// Time at which this container was created.
+	creationTime time.Time
+	// Metadata associated with the container.
+	labels map[string]string
+	envs   map[string]string
+	// The container PID used to switch namespaces as required
+	pid int
+	// Image name used for this container.
+	image string
+	// The host root FS to read
+	rootFs string
+	// Filesystem handler.
+	ignoreMetrics container.MetricSet
+}
+
+var _ container.ContainerHandler = &containerdContainerHandler{}
+
+// newContainerdContainerHandler returns a new container.ContainerHandler
+func newContainerdContainerHandler(
+	client containerdClient,
+	name string,
+	machineInfoFactory info.MachineInfoFactory,
+	fsInfo fs.FsInfo,
+	cgroupSubsystems *containerlibcontainer.CgroupSubsystems,
+	inHostNamespace bool,
+	metadataEnvs []string,
+	ignoreMetrics container.MetricSet,
+) (container.ContainerHandler, error) {
+	// Create the cgroup paths.
+	cgroupPaths := make(map[string]string, len(cgroupSubsystems.MountPoints))
+	for key, val := range cgroupSubsystems.MountPoints {
+		cgroupPaths[key] = path.Join(val, name)
+	}
+
+	// Generate the equivalent cgroup manager for this container.
+	cgroupManager := &cgroupfs.Manager{
+		Cgroups: &libcontainerconfigs.Cgroup{
+			Name: name,
+		},
+		Paths: cgroupPaths,
+	}
+
+	id := ContainerNameToContainerdID(name)
+	// We assume that if load fails then the container is not known to containerd.
+	ctx := context.Background()
+	cntr, err := client.LoadContainer(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	var spec specs.Spec
+	if err := json.Unmarshal(cntr.Spec.Value, &spec); err != nil {
+		return nil, err
+	}
+
+	taskPid, err := client.TaskPid(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	rootfs := "/"
+	if !inHostNamespace {
+		rootfs = "/rootfs"
+	}
+
+	handler := &containerdContainerHandler{
+		id:                 id,
+		client:             client,
+		name:               name,
+		machineInfoFactory: machineInfoFactory,
+		cgroupPaths:        cgroupPaths,
+		cgroupManager:      cgroupManager,
+		rootFs:             rootfs,
+		fsInfo:             fsInfo,
+		envs:               make(map[string]string),
+		labels:             make(map[string]string),
+		ignoreMetrics:      ignoreMetrics,
+		pid:                int(taskPid),
+		creationTime:       cntr.CreatedAt,
+	}
+	// Add the name and bare ID as aliases of the container.
+	handler.labels = cntr.Labels
+	handler.image = cntr.Image
+	handler.aliases = []string{id, name}
+	for _, envVar := range spec.Process.Env {
+		if envVar != "" {
+			splits := strings.SplitN(envVar, "=", 2)
+			if len(splits) == 2 {
+				handler.envs[splits[0]] = splits[1]
+			}
+		}
+	}
+
+	return handler, nil
+}
+
+func (self *containerdContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	return info.ContainerReference{
+		Id:        self.id,
+		Name:      self.name,
+		Namespace: k8sContainerdNamespace,
+		Labels:    self.labels,
+		Aliases:   self.aliases,
+	}, nil
+}
+
+func (self *containerdContainerHandler) needNet() bool {
+	// Since containerd does not handle networking ideally we need to return based
+	// on ignoreMetrics list. Here the assumption is the presence of cri-containerd
+	// label
+	if !self.ignoreMetrics.Has(container.NetworkUsageMetrics) {
+		//TODO change it to exported cri-containerd constants
+		return self.labels["io.cri-containerd.kind"] == "sandbox"
+	}
+	return false
+}
+
+func (self *containerdContainerHandler) GetSpec() (info.ContainerSpec, error) {
+	// TODO: Since we dont collect disk usage stats for containerd, we set hasFilesystem
+	// to false. Revisit when we support disk usage stats for containerd
+	hasFilesystem := false
+	spec, err := common.GetSpec(self.cgroupPaths, self.machineInfoFactory, self.needNet(), hasFilesystem)
+	spec.Labels = self.labels
+	spec.Envs = self.envs
+	spec.Image = self.image
+
+	return spec, err
+}
+
+func (self *containerdContainerHandler) getFsStats(stats *info.ContainerStats) error {
+	mi, err := self.machineInfoFactory.GetMachineInfo()
+	if err != nil {
+		return err
+	}
+
+	if !self.ignoreMetrics.Has(container.DiskIOMetrics) {
+		common.AssignDeviceNamesToDiskStats((*common.MachineInfoNamer)(mi), &stats.DiskIo)
+	}
+	return nil
+}
+
+func (self *containerdContainerHandler) GetStats() (*info.ContainerStats, error) {
+	stats, err := containerlibcontainer.GetStats(self.cgroupManager, self.rootFs, self.pid, self.ignoreMetrics)
+	if err != nil {
+		return stats, err
+	}
+	// Clean up stats for containers that don't have their own network - this
+	// includes containers running in Kubernetes pods that use the network of the
+	// infrastructure container. This stops metrics being reported multiple times
+	// for each container in a pod.
+	if !self.needNet() {
+		stats.Network = info.NetworkStats{}
+	}
+
+	// Get filesystem stats.
+	err = self.getFsStats(stats)
+	return stats, err
+}
+
+func (self *containerdContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
+	return []info.ContainerReference{}, nil
+}
+
+func (self *containerdContainerHandler) GetCgroupPath(resource string) (string, error) {
+	path, ok := self.cgroupPaths[resource]
+	if !ok {
+		return "", fmt.Errorf("could not find path for resource %q for container %q\n", resource, self.name)
+	}
+	return path, nil
+}
+
+func (self *containerdContainerHandler) GetContainerLabels() map[string]string {
+	return self.labels
+}
+
+func (self *containerdContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
+	return containerlibcontainer.GetProcesses(self.cgroupManager)
+}
+
+func (self *containerdContainerHandler) Exists() bool {
+	return common.CgroupExists(self.cgroupPaths)
+}
+
+func (self *containerdContainerHandler) Type() container.ContainerType {
+	return container.ContainerTypeContainerd
+}
+
+func (self *containerdContainerHandler) Start() {
+}
+
+func (self *containerdContainerHandler) Cleanup() {
+}
+
+func (self *containerdContainerHandler) GetContainerIPAddress() string {
+	// containerd doesnt take care of networking.So it doesnt maintain networking states
+	return ""
+}