Update vendor dependencies

Change-Id: I3b1ca9f2687388c831d9d46a4e1de413ffae06ac

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

@@ -11,11 +11,11 @@ go_library(
     importpath = "github.com/google/cadvisor/container/libcontainer",
     visibility = ["//visibility:public"],
     deps = [
-        "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/google/cadvisor/container:go_default_library",
         "//vendor/github.com/google/cadvisor/info/v1:go_default_library",
         "//vendor/github.com/opencontainers/runc/libcontainer:go_default_library",
         "//vendor/github.com/opencontainers/runc/libcontainer/cgroups:go_default_library",
+        "//vendor/k8s.io/klog:go_default_library",
     ],
 )
 

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

@@ -29,9 +29,9 @@ import (
 	info "github.com/google/cadvisor/info/v1"
 
 	"bytes"
-	"github.com/golang/glog"
 	"github.com/opencontainers/runc/libcontainer"
 	"github.com/opencontainers/runc/libcontainer/cgroups"
+	"k8s.io/klog"
 )
 
 /*
@@ -72,11 +72,11 @@ func (h *Handler) GetStats() (*info.ContainerStats, error) {
 	if h.includedMetrics.Has(container.ProcessSchedulerMetrics) {
 		pids, err := h.cgroupManager.GetAllPids()
 		if err != nil {
-			glog.V(4).Infof("Could not get PIDs for container %d: %v", h.pid, err)
+			klog.V(4).Infof("Could not get PIDs for container %d: %v", h.pid, err)
 		} else {
 			stats.Cpu.Schedstat, err = schedulerStatsFromProcs(h.rootFs, pids, h.pidMetricsCache)
 			if err != nil {
-				glog.V(4).Infof("Unable to get Process Scheduler Stats: %v", err)
+				klog.V(4).Infof("Unable to get Process Scheduler Stats: %v", err)
 			}
 		}
 	}
@@ -88,7 +88,7 @@ func (h *Handler) GetStats() (*info.ContainerStats, error) {
 	if h.includedMetrics.Has(container.NetworkUsageMetrics) {
 		netStats, err := networkStatsFromProc(h.rootFs, h.pid)
 		if err != nil {
-			glog.V(4).Infof("Unable to get network stats from pid %d: %v", h.pid, err)
+			klog.V(4).Infof("Unable to get network stats from pid %d: %v", h.pid, err)
 		} else {
 			stats.Network.Interfaces = append(stats.Network.Interfaces, netStats...)
 		}
@@ -96,14 +96,14 @@ func (h *Handler) GetStats() (*info.ContainerStats, error) {
 	if h.includedMetrics.Has(container.NetworkTcpUsageMetrics) {
 		t, err := tcpStatsFromProc(h.rootFs, h.pid, "net/tcp")
 		if err != nil {
-			glog.V(4).Infof("Unable to get tcp stats from pid %d: %v", h.pid, err)
+			klog.V(4).Infof("Unable to get tcp stats from pid %d: %v", h.pid, err)
 		} else {
 			stats.Network.Tcp = t
 		}
 
 		t6, err := tcpStatsFromProc(h.rootFs, h.pid, "net/tcp6")
 		if err != nil {
-			glog.V(4).Infof("Unable to get tcp6 stats from pid %d: %v", h.pid, err)
+			klog.V(4).Infof("Unable to get tcp6 stats from pid %d: %v", h.pid, err)
 		} else {
 			stats.Network.Tcp6 = t6
 		}
@@ -111,18 +111,30 @@ func (h *Handler) GetStats() (*info.ContainerStats, error) {
 	if h.includedMetrics.Has(container.NetworkUdpUsageMetrics) {
 		u, err := udpStatsFromProc(h.rootFs, h.pid, "net/udp")
 		if err != nil {
-			glog.V(4).Infof("Unable to get udp stats from pid %d: %v", h.pid, err)
+			klog.V(4).Infof("Unable to get udp stats from pid %d: %v", h.pid, err)
 		} else {
 			stats.Network.Udp = u
 		}
 
 		u6, err := udpStatsFromProc(h.rootFs, h.pid, "net/udp6")
 		if err != nil {
-			glog.V(4).Infof("Unable to get udp6 stats from pid %d: %v", h.pid, err)
+			klog.V(4).Infof("Unable to get udp6 stats from pid %d: %v", h.pid, err)
 		} else {
 			stats.Network.Udp6 = u6
 		}
 	}
+	if h.includedMetrics.Has(container.ProcessMetrics) {
+		paths := h.cgroupManager.GetPaths()
+		path, ok := paths["cpu"]
+		if !ok {
+			klog.V(4).Infof("Could not find cgroups CPU for container %d", h.pid)
+		} else {
+			stats.Processes, err = processStatsFromProcs(h.rootFs, path)
+			if err != nil {
+				klog.V(4).Infof("Unable to get Process Stats: %v", err)
+			}
+		}
+	}
 
 	// For backwards compatibility.
 	if len(stats.Network.Interfaces) > 0 {
@@ -132,6 +144,41 @@ func (h *Handler) GetStats() (*info.ContainerStats, error) {
 	return stats, nil
 }
 
+func processStatsFromProcs(rootFs string, cgroupPath string) (info.ProcessStats, error) {
+	var fdCount uint64
+	filePath := path.Join(cgroupPath, "cgroup.procs")
+	out, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return info.ProcessStats{}, fmt.Errorf("couldn't open cpu cgroup procs file %v : %v", filePath, err)
+	}
+
+	pids := strings.Split(string(out), "\n")
+
+	// EOL is also treated as a new line while reading "cgroup.procs" file with ioutil.ReadFile.
+	// The last value is an empty string "". Ex: pids = ["22", "1223", ""]
+	// Trim the last value
+	if len(pids) != 0 && pids[len(pids)-1] == "" {
+		pids = pids[:len(pids)-1]
+	}
+
+	for _, pid := range pids {
+		dirPath := path.Join(rootFs, "/proc", pid, "fd")
+		fds, err := ioutil.ReadDir(dirPath)
+		if err != nil {
+			klog.V(4).Infof("error while listing directory %q to measure fd count: %v", dirPath, err)
+			continue
+		}
+		fdCount += uint64(len(fds))
+	}
+
+	processStats := info.ProcessStats{
+		ProcessCount: uint64(len(pids)),
+		FdCount:      fdCount,
+	}
+
+	return processStats, nil
+}
+
 func schedulerStatsFromProcs(rootFs string, pids []int, pidMetricsCache map[int]*info.CpuSchedstat) (info.CpuSchedstat, error) {
 	for _, pid := range pids {
 		f, err := os.Open(path.Join(rootFs, "proc", strconv.Itoa(pid), "schedstat"))
@@ -451,13 +498,13 @@ func setCpuStats(s *cgroups.Stats, ret *info.ContainerStats, withPerCPU bool) {
 	// We intentionally ignore these extra zeroes.
 	numActual, err := numCpusFunc()
 	if err != nil {
-		glog.Errorf("unable to determine number of actual cpus; defaulting to maximum possible number: errno %v", err)
+		klog.Errorf("unable to determine number of actual cpus; defaulting to maximum possible number: errno %v", err)
 		numActual = numPossible
 	}
 	if numActual > numPossible {
 		// The real number of cores should never be greater than the number of
 		// datapoints reported in cpu usage.
-		glog.Errorf("PercpuUsage had %v cpus, but the actual number is %v; ignoring extra CPUs", numPossible, numActual)
+		klog.Errorf("PercpuUsage had %v cpus, but the actual number is %v; ignoring extra CPUs", numPossible, numActual)
 	}
 	numActual = minUint32(numPossible, numActual)
 	ret.Cpu.Usage.PerCpu = make([]uint64, numActual)

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

@@ -19,8 +19,8 @@ import (
 
 	info "github.com/google/cadvisor/info/v1"
 
-	"github.com/golang/glog"
 	"github.com/opencontainers/runc/libcontainer/cgroups"
+	"k8s.io/klog"
 )
 
 type CgroupSubsystems struct {
@@ -61,7 +61,7 @@ func getCgroupSubsystemsHelper(allCgroups []cgroups.Mount) (CgroupSubsystems, er
 			}
 			if _, ok := mountPoints[subsystem]; ok {
 				// duplicate mount for this subsystem; use the first one we saw
-				glog.V(5).Infof("skipping %s, already using mount at %s", mount.Mountpoint, mountPoints[subsystem])
+				klog.V(5).Infof("skipping %s, already using mount at %s", mount.Mountpoint, mountPoints[subsystem])
 				continue
 			}
 			if _, ok := recordedMountpoints[mount.Mountpoint]; !ok {