Move deps from _workspace/ to vendor/

godep restore
pushd $GOPATH/src/github.com/appc/spec
git co master
popd
go get go4.org/errorutil
rm -rf Godeps
godep save ./...
git add vendor
git add -f $(git ls-files --other vendor/)
git co -- Godeps/LICENSES Godeps/.license_file_state Godeps/OWNERS

vendor/github.com/google/cadvisor/container/docker/client.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.
+
+// Handler for /validate content.
+// Validates cadvisor dependencies - kernel, os, docker setup.
+
+package docker
+
+import (
+	"sync"
+
+	dclient "github.com/fsouza/go-dockerclient"
+)
+
+var (
+	dockerClient    *dclient.Client
+	dockerClientErr error
+	once            sync.Once
+)
+
+func Client() (*dclient.Client, error) {
+	once.Do(func() {
+		dockerClient, dockerClientErr = dclient.NewClient(*ArgDockerEndpoint)
+	})
+	return dockerClient, dockerClientErr
+}

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

@@ -0,0 +1,222 @@
+// Copyright 2014 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 docker
+
+import (
+	"flag"
+	"fmt"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/container/libcontainer"
+	"github.com/google/cadvisor/fs"
+	info "github.com/google/cadvisor/info/v1"
+
+	docker "github.com/fsouza/go-dockerclient"
+	"github.com/golang/glog"
+)
+
+var ArgDockerEndpoint = flag.String("docker", "unix:///var/run/docker.sock", "docker endpoint")
+
+// The namespace under which Docker aliases are unique.
+var DockerNamespace = "docker"
+
+// Basepath to all container specific information that libcontainer stores.
+// TODO: Deprecate this flag
+var dockerRootDir = flag.String("docker_root", "/var/lib/docker", "Absolute path to the Docker state root directory (default: /var/lib/docker)")
+var dockerRunDir = flag.String("docker_run", "/var/run/docker", "Absolute path to the Docker run directory (default: /var/run/docker)")
+
+// Regexp that identifies docker cgroups, containers started with
+// --cgroup-parent have another prefix than 'docker'
+var dockerCgroupRegexp = regexp.MustCompile(`([a-z0-9]{64})`)
+
+var dockerEnvWhitelist = flag.String("docker_env_metadata_whitelist", "", "a comma-separated list of environment variable keys that needs to be collected for docker containers")
+
+// TODO(vmarmol): Export run dir too for newer Dockers.
+// Directory holding Docker container state information.
+func DockerStateDir() string {
+	return libcontainer.DockerStateDir(*dockerRootDir)
+}
+
+const (
+	dockerRootDirKey = "Root Dir"
+)
+
+func RootDir() string {
+	return *dockerRootDir
+}
+
+type storageDriver string
+
+const (
+	// TODO: Add support for devicemapper storage usage.
+	devicemapperStorageDriver storageDriver = "devicemapper"
+	aufsStorageDriver         storageDriver = "aufs"
+	overlayStorageDriver      storageDriver = "overlay"
+	zfsStorageDriver          storageDriver = "zfs"
+)
+
+type dockerFactory struct {
+	machineInfoFactory info.MachineInfoFactory
+
+	storageDriver storageDriver
+	storageDir    string
+
+	client *docker.Client
+
+	// Information about the mounted cgroup subsystems.
+	cgroupSubsystems libcontainer.CgroupSubsystems
+
+	// Information about mounted filesystems.
+	fsInfo fs.FsInfo
+
+	dockerVersion []int
+
+	ignoreMetrics container.MetricSet
+}
+
+func (self *dockerFactory) String() string {
+	return DockerNamespace
+}
+
+func (self *dockerFactory) NewContainerHandler(name string, inHostNamespace bool) (handler container.ContainerHandler, err error) {
+	client, err := Client()
+	if err != nil {
+		return
+	}
+
+	metadataEnvs := strings.Split(*dockerEnvWhitelist, ",")
+
+	handler, err = newDockerContainerHandler(
+		client,
+		name,
+		self.machineInfoFactory,
+		self.fsInfo,
+		self.storageDriver,
+		self.storageDir,
+		&self.cgroupSubsystems,
+		inHostNamespace,
+		metadataEnvs,
+		self.dockerVersion,
+		self.ignoreMetrics,
+	)
+	return
+}
+
+// Returns the Docker ID from the full container name.
+func ContainerNameToDockerId(name string) string {
+	id := path.Base(name)
+
+	if matches := dockerCgroupRegexp.FindStringSubmatch(id); matches != nil {
+		return matches[1]
+	}
+
+	return id
+}
+
+func isContainerName(name string) bool {
+	return dockerCgroupRegexp.MatchString(path.Base(name))
+}
+
+// Docker handles all containers under /docker
+func (self *dockerFactory) CanHandleAndAccept(name string) (bool, bool, error) {
+	// docker factory accepts all containers it can handle.
+	canAccept := true
+
+	if !isContainerName(name) {
+		return false, canAccept, fmt.Errorf("invalid container name")
+	}
+
+	// Check if the container is known to docker and it is active.
+	id := ContainerNameToDockerId(name)
+
+	// We assume that if Inspect fails then the container is not known to docker.
+	ctnr, err := self.client.InspectContainer(id)
+	if err != nil || !ctnr.State.Running {
+		return false, canAccept, fmt.Errorf("error inspecting container: %v", err)
+	}
+
+	return true, canAccept, nil
+}
+
+func (self *dockerFactory) DebugInfo() map[string][]string {
+	return map[string][]string{}
+}
+
+var (
+	version_regexp_string = `(\d+)\.(\d+)\.(\d+)`
+	version_re            = regexp.MustCompile(version_regexp_string)
+)
+
+// TODO: switch to a semantic versioning library.
+func parseDockerVersion(full_version_string string) ([]int, error) {
+	matches := version_re.FindAllStringSubmatch(full_version_string, -1)
+	if len(matches) != 1 {
+		return nil, fmt.Errorf("version string \"%v\" doesn't match expected regular expression: \"%v\"", full_version_string, version_regexp_string)
+	}
+	version_string_array := matches[0][1:]
+	version_array := make([]int, 3)
+	for index, version_string := range version_string_array {
+		version, err := strconv.Atoi(version_string)
+		if err != nil {
+			return nil, fmt.Errorf("error while parsing \"%v\" in \"%v\"", version_string, full_version_string)
+		}
+		version_array[index] = version
+	}
+	return version_array, nil
+}
+
+// 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 communicate with docker daemon: %v", err)
+	}
+
+	dockerInfo, err := ValidateInfo()
+	if err != nil {
+		return fmt.Errorf("failed to validate Docker info: %v", err)
+	}
+
+	// Version already validated above, assume no error here.
+	dockerVersion, _ := parseDockerVersion(dockerInfo.ServerVersion)
+
+	storageDir := dockerInfo.DockerRootDir
+	if storageDir == "" {
+		storageDir = *dockerRootDir
+	}
+	cgroupSubsystems, err := libcontainer.GetCgroupSubsystems()
+	if err != nil {
+		return fmt.Errorf("failed to get cgroup subsystems: %v", err)
+	}
+
+	glog.Infof("Registering Docker factory")
+	f := &dockerFactory{
+		cgroupSubsystems:   cgroupSubsystems,
+		client:             client,
+		dockerVersion:      dockerVersion,
+		fsInfo:             fsInfo,
+		machineInfoFactory: factory,
+		storageDriver:      storageDriver(dockerInfo.Driver),
+		storageDir:         storageDir,
+		ignoreMetrics:      ignoreMetrics,
+	}
+
+	container.RegisterContainerHandlerFactory(f)
+	return nil
+}

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

@@ -0,0 +1,411 @@
+// Copyright 2014 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 Docker containers.
+package docker
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path"
+	"strings"
+	"time"
+
+	"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"
+
+	docker "github.com/fsouza/go-dockerclient"
+	"github.com/opencontainers/runc/libcontainer/cgroups"
+	cgroupfs "github.com/opencontainers/runc/libcontainer/cgroups/fs"
+	libcontainerconfigs "github.com/opencontainers/runc/libcontainer/configs"
+)
+
+const (
+	// The read write layers exist here.
+	aufsRWLayer = "diff"
+	// Path to the directory where docker stores log files if the json logging driver is enabled.
+	pathToContainersDir = "containers"
+)
+
+type dockerContainerHandler struct {
+	client             *docker.Client
+	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
+
+	storageDriver    storageDriver
+	fsInfo           fs.FsInfo
+	rootfsStorageDir 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
+
+	// The network mode of the container
+	networkMode string
+
+	// Filesystem handler.
+	fsHandler common.FsHandler
+
+	ignoreMetrics container.MetricSet
+}
+
+func getRwLayerID(containerID, storageDir string, sd storageDriver, dockerVersion []int) (string, error) {
+	const (
+		// Docker version >=1.10.0 have a randomized ID for the root fs of a container.
+		randomizedRWLayerMinorVersion = 10
+		rwLayerIDFile                 = "mount-id"
+	)
+	if (dockerVersion[0] <= 1) && (dockerVersion[1] < randomizedRWLayerMinorVersion) {
+		return containerID, nil
+	}
+
+	bytes, err := ioutil.ReadFile(path.Join(storageDir, "image", string(sd), "layerdb", "mounts", containerID, rwLayerIDFile))
+	if err != nil {
+		return "", fmt.Errorf("failed to identify the read-write layer ID for container %q. - %v", containerID, err)
+	}
+	return string(bytes), err
+}
+
+func newDockerContainerHandler(
+	client *docker.Client,
+	name string,
+	machineInfoFactory info.MachineInfoFactory,
+	fsInfo fs.FsInfo,
+	storageDriver storageDriver,
+	storageDir string,
+	cgroupSubsystems *containerlibcontainer.CgroupSubsystems,
+	inHostNamespace bool,
+	metadataEnvs []string,
+	dockerVersion []int,
+	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,
+	}
+
+	rootFs := "/"
+	if !inHostNamespace {
+		rootFs = "/rootfs"
+		storageDir = path.Join(rootFs, storageDir)
+	}
+
+	id := ContainerNameToDockerId(name)
+
+	// Add the Containers dir where the log files are stored.
+	// FIXME: Give `otherStorageDir` a more descriptive name.
+	otherStorageDir := path.Join(storageDir, pathToContainersDir, id)
+
+	rwLayerID, err := getRwLayerID(id, storageDir, storageDriver, dockerVersion)
+	if err != nil {
+		return nil, err
+	}
+	var rootfsStorageDir string
+	switch storageDriver {
+	case aufsStorageDriver:
+		rootfsStorageDir = path.Join(storageDir, string(aufsStorageDriver), aufsRWLayer, rwLayerID)
+	case overlayStorageDriver:
+		rootfsStorageDir = path.Join(storageDir, string(overlayStorageDriver), rwLayerID)
+	}
+
+	handler := &dockerContainerHandler{
+		id:                 id,
+		client:             client,
+		name:               name,
+		machineInfoFactory: machineInfoFactory,
+		cgroupPaths:        cgroupPaths,
+		cgroupManager:      cgroupManager,
+		storageDriver:      storageDriver,
+		fsInfo:             fsInfo,
+		rootFs:             rootFs,
+		rootfsStorageDir:   rootfsStorageDir,
+		envs:               make(map[string]string),
+		ignoreMetrics:      ignoreMetrics,
+	}
+
+	if !ignoreMetrics.Has(container.DiskUsageMetrics) {
+		handler.fsHandler = common.NewFsHandler(time.Minute, rootfsStorageDir, otherStorageDir, fsInfo)
+	}
+
+	// We assume that if Inspect fails then the container is not known to docker.
+	ctnr, err := client.InspectContainer(id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to inspect container %q: %v", id, err)
+	}
+	handler.creationTime = ctnr.Created
+	handler.pid = ctnr.State.Pid
+
+	// Add the name and bare ID as aliases of the container.
+	handler.aliases = append(handler.aliases, strings.TrimPrefix(ctnr.Name, "/"), id)
+	handler.labels = ctnr.Config.Labels
+	handler.image = ctnr.Config.Image
+	handler.networkMode = ctnr.HostConfig.NetworkMode
+
+	// split env vars to get metadata map.
+	for _, exposedEnv := range metadataEnvs {
+		for _, envVar := range ctnr.Config.Env {
+			splits := strings.SplitN(envVar, "=", 2)
+			if splits[0] == exposedEnv {
+				handler.envs[strings.ToLower(exposedEnv)] = splits[1]
+			}
+		}
+	}
+
+	return handler, nil
+}
+
+func (self *dockerContainerHandler) Start() {
+	if self.fsHandler != nil {
+		self.fsHandler.Start()
+	}
+}
+
+func (self *dockerContainerHandler) Cleanup() {
+	if self.fsHandler != nil {
+		self.fsHandler.Stop()
+	}
+}
+
+func (self *dockerContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	return info.ContainerReference{
+		Id:        self.id,
+		Name:      self.name,
+		Aliases:   self.aliases,
+		Namespace: DockerNamespace,
+		Labels:    self.labels,
+	}, nil
+}
+
+func (self *dockerContainerHandler) needNet() bool {
+	if !self.ignoreMetrics.Has(container.NetworkUsageMetrics) {
+		return !strings.HasPrefix(self.networkMode, "container:")
+	}
+	return false
+}
+
+func (self *dockerContainerHandler) GetSpec() (info.ContainerSpec, error) {
+	hasFilesystem := !self.ignoreMetrics.Has(container.DiskUsageMetrics)
+	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 *dockerContainerHandler) getFsStats(stats *info.ContainerStats) error {
+	if self.ignoreMetrics.Has(container.DiskUsageMetrics) {
+		return nil
+	}
+	switch self.storageDriver {
+	case aufsStorageDriver, overlayStorageDriver, zfsStorageDriver:
+	default:
+		return nil
+	}
+
+	deviceInfo, err := self.fsInfo.GetDirFsDevice(self.rootfsStorageDir)
+	if err != nil {
+		return err
+	}
+
+	mi, err := self.machineInfoFactory.GetMachineInfo()
+	if err != nil {
+		return err
+	}
+
+	var (
+		limit  uint64
+		fsType string
+	)
+
+	// Docker does not impose any filesystem limits for containers. So use capacity as limit.
+	for _, fs := range mi.Filesystems {
+		if fs.Device == deviceInfo.Device {
+			limit = fs.Capacity
+			fsType = fs.Type
+			break
+		}
+	}
+
+	fsStat := info.FsStats{Device: deviceInfo.Device, Type: fsType, Limit: limit}
+
+	fsStat.BaseUsage, fsStat.Usage = self.fsHandler.Usage()
+	stats.Filesystem = append(stats.Filesystem, fsStat)
+
+	return nil
+}
+
+// TODO(vmarmol): Get from libcontainer API instead of cgroup manager when we don't have to support older Dockers.
+func (self *dockerContainerHandler) 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)
+	if err != nil {
+		return stats, err
+	}
+
+	return stats, nil
+}
+
+func (self *dockerContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
+	// No-op for Docker driver.
+	return []info.ContainerReference{}, nil
+}
+
+func (self *dockerContainerHandler) 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 *dockerContainerHandler) ListThreads(listType container.ListType) ([]int, error) {
+	// TODO(vmarmol): Implement.
+	return nil, nil
+}
+
+func (self *dockerContainerHandler) GetContainerLabels() map[string]string {
+	return self.labels
+}
+
+func (self *dockerContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
+	return containerlibcontainer.GetProcesses(self.cgroupManager)
+}
+
+func (self *dockerContainerHandler) WatchSubcontainers(events chan container.SubcontainerEvent) error {
+	return fmt.Errorf("watch is unimplemented in the Docker container driver")
+}
+
+func (self *dockerContainerHandler) StopWatchingSubcontainers() error {
+	// No-op for Docker driver.
+	return nil
+}
+
+func (self *dockerContainerHandler) Exists() bool {
+	return common.CgroupExists(self.cgroupPaths)
+}
+
+func DockerInfo() (docker.DockerInfo, error) {
+	client, err := Client()
+	if err != nil {
+		return docker.DockerInfo{}, fmt.Errorf("unable to communicate with docker daemon: %v", err)
+	}
+	info, err := client.Info()
+	if err != nil {
+		return docker.DockerInfo{}, err
+	}
+	return *info, nil
+}
+
+func DockerImages() ([]docker.APIImages, error) {
+	client, err := Client()
+	if err != nil {
+		return nil, fmt.Errorf("unable to communicate with docker daemon: %v", err)
+	}
+	images, err := client.ListImages(docker.ListImagesOptions{All: false})
+	if err != nil {
+		return nil, err
+	}
+	return images, nil
+}
+
+// Checks whether the dockerInfo reflects a valid docker setup, and returns it if it does, or an
+// error otherwise.
+func ValidateInfo() (*docker.DockerInfo, error) {
+	client, err := Client()
+	if err != nil {
+		return nil, fmt.Errorf("unable to communicate with docker daemon: %v", err)
+	}
+
+	dockerInfo, err := client.Info()
+	if err != nil {
+		return nil, fmt.Errorf("failed to detect Docker info: %v", err)
+	}
+
+	// Fall back to version API if ServerVersion is not set in info.
+	if dockerInfo.ServerVersion == "" {
+		version, err := client.Version()
+		if err != nil {
+			return nil, fmt.Errorf("unable to get docker version: %v", err)
+		}
+		dockerInfo.ServerVersion = version.Get("Version")
+	}
+	version, err := parseDockerVersion(dockerInfo.ServerVersion)
+	if err != nil {
+		return nil, err
+	}
+
+	if version[0] < 1 {
+		return nil, fmt.Errorf("cAdvisor requires docker version %v or above but we have found version %v reported as %q", []int{1, 0, 0}, version, dockerInfo.ServerVersion)
+	}
+
+	// Check that the libcontainer execdriver is used if the version is < 1.11
+	// (execution drivers are no longer supported as of 1.11).
+	if version[0] <= 1 && version[1] <= 10 &&
+		!strings.HasPrefix(dockerInfo.ExecutionDriver, "native") {
+		return nil, fmt.Errorf("docker found, but not using native exec driver")
+	}
+
+	if dockerInfo.Driver == "" {
+		return nil, fmt.Errorf("failed to find docker storage driver")
+	}
+
+	return dockerInfo, nil
+}