Bump cAdvisor (and dependencies) godeps version

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

@@ -20,6 +20,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/blang/semver"
 	rktapi "github.com/coreos/rkt/api/v1alpha"
 
 	"golang.org/x/net/context"
@@ -29,6 +30,7 @@ import (
 const (
 	defaultRktAPIServiceAddr = "localhost:15441"
 	timeout                  = 2 * time.Second
+	minimumRktBinVersion     = "1.6.0"
 )
 
 var (
@@ -55,7 +57,25 @@ func Client() (rktapi.PublicAPIClient, error) {
 			return
 		}
 
-		rktClient = rktapi.NewPublicAPIClient(apisvcConn)
+		apisvc := rktapi.NewPublicAPIClient(apisvcConn)
+
+		resp, err := apisvc.GetInfo(context.Background(), &rktapi.GetInfoRequest{})
+		if err != nil {
+			rktClientErr = fmt.Errorf("rkt: GetInfo() failed: %v", err)
+			return
+		}
+
+		binVersion, err := semver.Make(resp.Info.RktVersion)
+		if err != nil {
+			rktClientErr = fmt.Errorf("rkt: couldn't parse RtVersion: %v", err)
+			return
+		}
+		if binVersion.LT(semver.MustParse(minimumRktBinVersion)) {
+			rktClientErr = fmt.Errorf("rkt: binary version is too old(%v), requires at least %v", resp.Info.RktVersion, minimumRktBinVersion)
+			return
+		}
+
+		rktClient = apisvc
 	})
 
 	return rktClient, rktClientErr

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

@@ -16,12 +16,12 @@ package rkt
 
 import (
 	"fmt"
-	"strings"
 
 	"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"
 
 	"github.com/golang/glog"
 )
@@ -58,14 +58,9 @@ func (self *rktFactory) NewContainerHandler(name string, inHostNamespace bool) (
 }
 
 func (self *rktFactory) CanHandleAndAccept(name string) (bool, bool, error) {
-	// will ignore all cgroup names that don't either correspond to the machine.slice that is the pod or the containers that belong to the pod
-	// only works for machined rkt pods at the moment
+	accept, err := verifyPod(name)
 
-	if strings.HasPrefix(name, "/machine.slice/machine-rkt\\x2d") {
-		accept, err := verifyName(name)
-		return true, accept, err
-	}
-	return false, false, fmt.Errorf("%s not handled by rkt handler", name)
+	return accept, accept, err
 }
 
 func (self *rktFactory) DebugInfo() map[string][]string {
@@ -99,6 +94,6 @@ func Register(machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, igno
 		ignoreMetrics:      ignoreMetrics,
 		rktPath:            rktPath,
 	}
-	container.RegisterContainerHandlerFactory(factory)
+	container.RegisterContainerHandlerFactory(factory, []watcher.ContainerWatchSource{watcher.Rkt})
 	return nil
 }

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

@@ -18,7 +18,6 @@ package rkt
 import (
 	"fmt"
 	"os"
-	"path"
 	"time"
 
 	rktapi "github.com/coreos/rkt/api/v1alpha"
@@ -100,20 +99,19 @@ func newRktContainerHandler(name string, rktClient rktapi.PublicAPIClient, rktPa
 	})
 	if err != nil {
 		return nil, err
-	} else {
-		var annotations []*rktapi.KeyValue
-		if parsed.Container == "" {
-			pid = int(resp.Pod.Pid)
-			apiPod = resp.Pod
-			annotations = resp.Pod.Annotations
-		} else {
-			var ok bool
-			if annotations, ok = findAnnotations(resp.Pod.Apps, parsed.Container); !ok {
-				glog.Warningf("couldn't find application in Pod matching %v", parsed.Container)
-			}
-		}
-		labels = createLabels(annotations)
 	}
+	annotations := resp.Pod.Annotations
+	if parsed.Container != "" { // As not empty string, an App container
+		if contAnnotations, ok := findAnnotations(resp.Pod.Apps, parsed.Container); !ok {
+			glog.Warningf("couldn't find app %v in pod", parsed.Container)
+		} else {
+			annotations = append(annotations, contAnnotations...)
+		}
+	} else { // The Pod container
+		pid = int(resp.Pod.Pid)
+		apiPod = resp.Pod
+	}
+	labels = createLabels(annotations)
 
 	cgroupPaths := common.MakeCgroupPaths(cgroupSubsystems.MountPoints, name)
 
@@ -196,7 +194,12 @@ func (handler *rktContainerHandler) Cleanup() {
 func (handler *rktContainerHandler) GetSpec() (info.ContainerSpec, error) {
 	hasNetwork := handler.hasNetwork && !handler.ignoreMetrics.Has(container.NetworkUsageMetrics)
 	hasFilesystem := !handler.ignoreMetrics.Has(container.DiskUsageMetrics)
-	return common.GetSpec(handler.cgroupPaths, handler.machineInfoFactory, hasNetwork, hasFilesystem)
+
+	spec, err := common.GetSpec(handler.cgroupPaths, handler.machineInfoFactory, hasNetwork, hasFilesystem)
+
+	spec.Labels = handler.labels
+
+	return spec, err
 }
 
 func (handler *rktContainerHandler) getFsStats(stats *info.ContainerStats) error {
@@ -260,68 +263,17 @@ func (handler *rktContainerHandler) GetContainerLabels() map[string]string {
 }
 
 func (handler *rktContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
-	containers := make(map[string]struct{})
-
-	// Rkt containers do not have subcontainers, only the "Pod" does.
-	if handler.isPod == false {
-		var ret []info.ContainerReference
-		return ret, nil
-	}
-
-	// Turn the system.slice cgroups  into the Pod's subcontainers
-	for _, cgroupPath := range handler.cgroupPaths {
-		err := common.ListDirectories(path.Join(cgroupPath, "system.slice"), path.Join(handler.name, "system.slice"), listType == container.ListRecursive, containers)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// Create the container references. for the Pod's subcontainers
-	ret := make([]info.ContainerReference, 0, len(handler.apiPod.Apps))
-	for cont := range containers {
-		aliases := make([]string, 1)
-		parsed, err := parseName(cont)
-		if err != nil {
-			return nil, fmt.Errorf("this should be impossible!, unable to parse rkt subcontainer name = %s", cont)
-		}
-		aliases = append(aliases, parsed.Pod+":"+parsed.Container)
-
-		labels := make(map[string]string)
-		if annotations, ok := findAnnotations(handler.apiPod.Apps, parsed.Container); !ok {
-			glog.Warningf("couldn't find application in Pod matching %v", parsed.Container)
-		} else {
-			labels = createLabels(annotations)
-		}
-
-		ret = append(ret, info.ContainerReference{
-			Name:      cont,
-			Aliases:   aliases,
-			Namespace: RktNamespace,
-			Labels:    labels,
-		})
-	}
-
-	return ret, nil
-}
-
-func (handler *rktContainerHandler) ListThreads(listType container.ListType) ([]int, error) {
-	// TODO(sjpotter): Implement?  Not implemented with docker yet
-	return nil, nil
+	return common.ListContainers(handler.name, handler.cgroupPaths, listType)
 }
 
 func (handler *rktContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
 	return libcontainer.GetProcesses(handler.cgroupManager)
 }
 
-func (handler *rktContainerHandler) WatchSubcontainers(events chan container.SubcontainerEvent) error {
-	return fmt.Errorf("watch is unimplemented in the Rkt container driver")
-}
-
-func (handler *rktContainerHandler) StopWatchingSubcontainers() error {
-	// No-op for Rkt driver.
-	return nil
-}
-
 func (handler *rktContainerHandler) Exists() bool {
 	return common.CgroupExists(handler.cgroupPaths)
 }
+
+func (handler *rktContainerHandler) Type() container.ContainerType {
+	return container.ContainerTypeRkt
+}

vendor/github.com/google/cadvisor/container/rkt/helpers.go

@@ -20,7 +20,9 @@ import (
 	"path"
 	"strings"
 
+	rktapi "github.com/coreos/rkt/api/v1alpha"
 	"github.com/golang/glog"
+	"golang.org/x/net/context"
 )
 
 type parsedName struct {
@@ -28,34 +30,80 @@ type parsedName struct {
 	Container string
 }
 
-func verifyName(name string) (bool, error) {
-	_, err := parseName(name)
-	return err == nil, err
+func verifyPod(name string) (bool, error) {
+	pod, err := cgroupToPod(name)
+
+	if err != nil || pod == nil {
+		return false, err
+	}
+
+	// Anything handler can handle is also accepted.
+	// Accept cgroups that are sub the pod cgroup, except "system.slice"
+	//   - "system.slice" doesn't contain any processes itself
+	accept := !strings.HasSuffix(name, "/system.slice")
+
+	return accept, nil
+}
+
+func cgroupToPod(name string) (*rktapi.Pod, error) {
+	rktClient, err := Client()
+	if err != nil {
+		return nil, fmt.Errorf("couldn't get rkt api service: %v", err)
+	}
+
+	resp, err := rktClient.ListPods(context.Background(), &rktapi.ListPodsRequest{
+		Filters: []*rktapi.PodFilter{
+			{
+				States:        []rktapi.PodState{rktapi.PodState_POD_STATE_RUNNING},
+				PodSubCgroups: []string{name},
+			},
+		},
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to list pods: %v", err)
+	}
+
+	if len(resp.Pods) == 0 {
+		return nil, nil
+	}
+
+	if len(resp.Pods) != 1 {
+		return nil, fmt.Errorf("returned %d (expected 1) pods for cgroup %v", len(resp.Pods), name)
+	}
+
+	return resp.Pods[0], nil
 }
 
 /* Parse cgroup name into a pod/container name struct
    Example cgroup fs name
 
-   pod - /sys/fs/cgroup/cpu/machine.slice/machine-rkt\\x2df556b64a\\x2d17a7\\x2d47d7\\x2d93ec\\x2def2275c3d67e.scope/
-   container under pod - /sys/fs/cgroup/cpu/machine.slice/machine-rkt\\x2df556b64a\\x2d17a7\\x2d47d7\\x2d93ec\\x2def2275c3d67e.scope/system.slice/alpine-sh.service
+   pod - /machine.slice/machine-rkt\\x2df556b64a\\x2d17a7\\x2d47d7\\x2d93ec\\x2def2275c3d67e.scope/
+    or   /system.slice/k8s-..../
+   container under pod - /machine.slice/machine-rkt\\x2df556b64a\\x2d17a7\\x2d47d7\\x2d93ec\\x2def2275c3d67e.scope/system.slice/alpine-sh.service
+    or  /system.slice/k8s-..../system.slice/pause.service
 */
-//TODO{sjpotter}: this currently only recognizes machined started pods, which actually doesn't help with k8s which uses them as systemd services, need a solution for both
 func parseName(name string) (*parsedName, error) {
-	splits := strings.Split(name, "/")
-	if len(splits) == 3 || len(splits) == 5 {
-		parsed := &parsedName{}
+	pod, err := cgroupToPod(name)
+	if err != nil {
+		return nil, fmt.Errorf("parseName: couldn't convert %v to a rkt pod: %v", name, err)
+	}
+	if pod == nil {
+		return nil, fmt.Errorf("parseName: didn't return a pod for %v", name)
+	}
 
-		if splits[1] == "machine.slice" {
-			replacer := strings.NewReplacer("machine-rkt\\x2d", "", ".scope", "", "\\x2d", "-")
-			parsed.Pod = replacer.Replace(splits[2])
-			if len(splits) == 3 {
-				return parsed, nil
-			}
-			if splits[3] == "system.slice" {
-				parsed.Container = strings.Replace(splits[4], ".service", "", -1)
-				return parsed, nil
-			}
+	splits := strings.Split(name, "/")
+
+	parsed := &parsedName{}
+
+	if len(splits) == 3 || len(splits) == 5 {
+		parsed.Pod = pod.Id
+
+		if len(splits) == 5 {
+			parsed.Container = strings.Replace(splits[4], ".service", "", -1)
 		}
+
+		return parsed, nil
 	}
 
 	return nil, fmt.Errorf("%s not handled by rkt handler", name)
@@ -80,7 +128,7 @@ func getRootFs(root string, parsed *parsedName) string {
 
 	bytes, err := ioutil.ReadFile(tree)
 	if err != nil {
-		glog.Infof("ReadFile failed, couldn't read %v to get upper dir: %v", tree, err)
+		glog.Errorf("ReadFile failed, couldn't read %v to get upper dir: %v", tree, err)
 		return ""
 	}