Merge pull request #1213 from timstclair/raw

Read docker container spec from cgroupfs, rather than libcontainer spec

Author: tallclair

container/common/helpers.go

@@ -25,7 +25,6 @@ import (
 
 	info "github.com/google/cadvisor/info/v1"
 	"github.com/google/cadvisor/utils"
-	"github.com/google/cadvisor/utils/machine"
 
 	"github.com/golang/glog"
 )
@@ -45,26 +44,10 @@ func DebugInfo(watches map[string][]string) map[string][]string {
 	return out
 }
 
-type AbstractContainerHandler interface {
-	GetCgroupPaths() map[string]string
-	GetMachineInfoFactory() info.MachineInfoFactory
-	GetName() string
-	GetRootNetworkDevices() ([]info.NetInfo, error)
-	GetExternalMounts() []Mount
-	HasNetwork() bool
-	HasFilesystem() bool
-}
-
-func GetSpec(handler AbstractContainerHandler) (info.ContainerSpec, error) {
-	cgroupPaths := handler.GetCgroupPaths()
-	machineInfoFactory := handler.GetMachineInfoFactory()
-	name := handler.GetName()
-	externalMounts := handler.GetExternalMounts()
-
+func GetSpec(cgroupPaths map[string]string, machineInfoFactory info.MachineInfoFactory, hasNetwork, hasFilesystem bool) (info.ContainerSpec, error) {
 	var spec info.ContainerSpec
 
-	// The raw driver assumes unified hierarchy containers.
-
+	// Assume unified hierarchy containers.
 	// Get the lowest creation time from all hierarchies as the container creation time.
 	now := time.Now()
 	lowestTime := now
@@ -120,51 +103,22 @@ func GetSpec(handler AbstractContainerHandler) (info.ContainerSpec, error) {
 	}
 
 	// Memory
-	if name == "/" {
-		// Get memory and swap limits of the running machine
-		memLimit, err := machine.GetMachineMemoryCapacity()
-		if err != nil {
-			glog.Warningf("failed to obtain memory limit for machine container")
-			spec.HasMemory = false
-		} else {
-			spec.Memory.Limit = uint64(memLimit)
-			// Spec is marked to have memory only if the memory limit is set
+	memoryRoot, ok := cgroupPaths["memory"]
+	if ok {
+		if utils.FileExists(memoryRoot) {
 			spec.HasMemory = true
-		}
-
-		swapLimit, err := machine.GetMachineSwapCapacity()
-		if err != nil {
-			glog.Warningf("failed to obtain swap limit for machine container")
-		} else {
-			spec.Memory.SwapLimit = uint64(swapLimit)
-		}
-	} else {
-		memoryRoot, ok := cgroupPaths["memory"]
-		if ok {
-			if utils.FileExists(memoryRoot) {
-				spec.HasMemory = true
-				spec.Memory.Limit = readUInt64(memoryRoot, "memory.limit_in_bytes")
-				spec.Memory.SwapLimit = readUInt64(memoryRoot, "memory.memsw.limit_in_bytes")
-			}
+			spec.Memory.Limit = readUInt64(memoryRoot, "memory.limit_in_bytes")
+			spec.Memory.SwapLimit = readUInt64(memoryRoot, "memory.memsw.limit_in_bytes")
 		}
 	}
 
-	spec.HasFilesystem = name == "/" || externalMounts != nil || handler.HasFilesystem()
-
-	spec.HasNetwork = handler.HasNetwork()
+	spec.HasNetwork = hasNetwork
+	spec.HasFilesystem = hasFilesystem
 
 	if blkioRoot, ok := cgroupPaths["blkio"]; ok && utils.FileExists(blkioRoot) {
 		spec.HasDiskIo = true
 	}
 
-	// Check physical network devices for root container.
-	nd, err := handler.GetRootNetworkDevices()
-	if err != nil {
-		return spec, err
-	}
-
-	spec.HasNetwork = spec.HasNetwork || len(nd) != 0
-
 	return spec, nil
 }
 
@@ -237,3 +191,13 @@ func MakeCgroupPaths(mountPoints map[string]string, name string) map[string]stri
 
 	return cgroupPaths
 }
+
+func CgroupExists(cgroupPaths map[string]string) bool {
+	// If any cgroup exists, the container is still alive.
+	for _, cgroupPath := range cgroupPaths {
+		if utils.FileExists(cgroupPath) {
+			return true
+		}
+	}
+	return false
+}

container/docker/handler.go

@@ -18,7 +18,6 @@ package docker
 import (
 	"fmt"
 	"io/ioutil"
-	"math"
 	"path"
 	"strings"
 	"time"
@@ -28,7 +27,6 @@ import (
 	containerlibcontainer "github.com/google/cadvisor/container/libcontainer"
 	"github.com/google/cadvisor/fs"
 	info "github.com/google/cadvisor/info/v1"
-	"github.com/google/cadvisor/utils"
 
 	docker "github.com/fsouza/go-dockerclient"
 	"github.com/opencontainers/runc/libcontainer/cgroups"
@@ -222,50 +220,6 @@ func (self *dockerContainerHandler) ContainerReference() (info.ContainerReferenc
 	}, nil
 }
 
-func (self *dockerContainerHandler) readLibcontainerConfig() (*libcontainerconfigs.Config, error) {
-	config, err := containerlibcontainer.ReadConfig(*dockerRootDir, *dockerRunDir, self.id)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read libcontainer config: %v", err)
-	}
-
-	// Replace cgroup parent and name with our own since we may be running in a different context.
-	if config.Cgroups == nil {
-		config.Cgroups = new(libcontainerconfigs.Cgroup)
-	}
-	config.Cgroups.Name = self.name
-	config.Cgroups.Parent = "/"
-
-	return config, nil
-}
-
-func libcontainerConfigToContainerSpec(config *libcontainerconfigs.Config, mi *info.MachineInfo) info.ContainerSpec {
-	var spec info.ContainerSpec
-	spec.HasMemory = true
-	spec.Memory.Limit = math.MaxUint64
-	spec.Memory.SwapLimit = math.MaxUint64
-
-	if config.Cgroups.Resources != nil {
-		if config.Cgroups.Resources.Memory > 0 {
-			spec.Memory.Limit = uint64(config.Cgroups.Resources.Memory)
-		}
-		if config.Cgroups.Resources.MemorySwap > 0 {
-			spec.Memory.SwapLimit = uint64(config.Cgroups.Resources.MemorySwap)
-		}
-
-		// Get CPU info
-		spec.HasCpu = true
-		spec.Cpu.Limit = 1024
-		if config.Cgroups.Resources.CpuShares != 0 {
-			spec.Cpu.Limit = uint64(config.Cgroups.Resources.CpuShares)
-		}
-		spec.Cpu.Mask = utils.FixCpuMask(config.Cgroups.Resources.CpusetCpus, mi.NumCores)
-	}
-
-	spec.HasDiskIo = true
-
-	return spec
-}
-
 func (self *dockerContainerHandler) needNet() bool {
 	if !self.ignoreMetrics.Has(container.NetworkUsageMetrics) {
 		return !strings.HasPrefix(self.networkMode, "container:")
@@ -274,28 +228,8 @@ func (self *dockerContainerHandler) needNet() bool {
 }
 
 func (self *dockerContainerHandler) GetSpec() (info.ContainerSpec, error) {
-	mi, err := self.machineInfoFactory.GetMachineInfo()
-	if err != nil {
-		return info.ContainerSpec{}, err
-	}
-	libcontainerConfig, err := self.readLibcontainerConfig()
-	if err != nil {
-		return info.ContainerSpec{}, err
-	}
-
-	spec := libcontainerConfigToContainerSpec(libcontainerConfig, mi)
-	spec.CreationTime = self.creationTime
-
-	if !self.ignoreMetrics.Has(container.DiskUsageMetrics) {
-		spec.HasFilesystem = true
-	}
-
-	spec.Labels = self.labels
-	spec.Envs = self.envs
-	spec.Image = self.image
-	spec.HasNetwork = self.needNet()
-
-	return spec, err
+	hasFilesystem := !self.ignoreMetrics.Has(container.DiskUsageMetrics)
+	return common.GetSpec(self.cgroupPaths, self.machineInfoFactory, self.needNet(), hasFilesystem)
 }
 
 func (self *dockerContainerHandler) getFsStats(stats *info.ContainerStats) error {
@@ -399,7 +333,7 @@ func (self *dockerContainerHandler) StopWatchingSubcontainers() error {
 }
 
 func (self *dockerContainerHandler) Exists() bool {
-	return containerlibcontainer.Exists(*dockerRootDir, *dockerRunDir, self.id)
+	return common.CgroupExists(self.cgroupPaths)
 }
 
 func DockerInfo() (docker.DockerInfo, error) {