func Register(machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, ignoreMetrics map[container.MetricKind]struct{}) error { cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } if len(cgroupSubsystems.Mounts) == 0 { return fmt.Errorf("failed to find supported cgroup mounts for the raw factory") } watcher, err := NewInotifyWatcher() if err != nil { return err } glog.Infof("Registering Raw factory") factory := &rawFactory{ machineInfoFactory: machineInfoFactory, fsInfo: fsInfo, cgroupSubsystems: &cgroupSubsystems, watcher: watcher, ignoreMetrics: ignoreMetrics, } container.RegisterContainerHandlerFactory(factory) return nil }
func Register(machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, ignoreMetrics container.MetricSet) error { _, err := Client() if err != nil { return fmt.Errorf("unable to communicate with Rkt api service: %v", err) } rktPath, err := RktPath() if err != nil { return fmt.Errorf("unable to get the RktPath variable %v", err) } cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } if len(cgroupSubsystems.Mounts) == 0 { return fmt.Errorf("failed to find supported cgroup mounts for the raw factory") } glog.Infof("Registering Rkt factory") factory := &rktFactory{ machineInfoFactory: machineInfoFactory, fsInfo: fsInfo, cgroupSubsystems: &cgroupSubsystems, ignoreMetrics: ignoreMetrics, rktPath: rktPath, } container.RegisterContainerHandlerFactory(factory, []watcher.ContainerWatchSource{watcher.Rkt}) return 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) cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } var ( dockerStorageDriver = storageDriver(dockerInfo.Driver) thinPoolWatcher *devicemapper.ThinPoolWatcher = nil ) if dockerStorageDriver == devicemapperStorageDriver { // If the storage drive is devicemapper, create and start a // ThinPoolWatcher to monitor the size of container CoW layers with // thin_ls. dockerThinPoolName, err := dockerutil.DockerThinPoolName(*dockerInfo) if err != nil { return fmt.Errorf("couldn't find device mapper thin pool name: %v", err) } dockerMetadataDevice, err := dockerutil.DockerMetadataDevice(*dockerInfo) if err != nil { return fmt.Errorf("couldn't determine devicemapper metadata device") } thinPoolWatcher = devicemapper.NewThinPoolWatcher(dockerThinPoolName, dockerMetadataDevice) go thinPoolWatcher.Start() } glog.Infof("registering Docker factory") f := &dockerFactory{ cgroupSubsystems: cgroupSubsystems, client: client, dockerVersion: dockerVersion, fsInfo: fsInfo, machineInfoFactory: factory, storageDriver: storageDriver(dockerInfo.Driver), storageDir: RootDir(), ignoreMetrics: ignoreMetrics, thinPoolWatcher: thinPoolWatcher, } container.RegisterContainerHandlerFactory(f, []watcher.ContainerWatchSource{watcher.Raw}) return nil }
// Register root container before running this function! func Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo) error { if UseSystemd() { glog.Infof("System is using systemd") } client, err := Client() if err != nil { return fmt.Errorf("unable to communicate with docker daemon: %v", err) } if version, err := client.Version(); err != nil { return fmt.Errorf("unable to communicate with docker daemon: %v", err) } else { expected_version := []int{1, 0, 0} version_string := version.Get("Version") version, err := parseDockerVersion(version_string) if err != nil { return fmt.Errorf("couldn't parse docker version: %v", err) } for index, number := range version { if number > expected_version[index] { break } else if number < expected_version[index] { return fmt.Errorf("cAdvisor requires docker version %v or above but we have found version %v reported as \"%v\"", expected_version, version, version_string) } } } // Check that the libcontainer execdriver is used. information, err := DockerInfo() if err != nil { return fmt.Errorf("failed to detect Docker info: %v", err) } execDriver, ok := information["ExecutionDriver"] if !ok || !strings.HasPrefix(execDriver, "native") { return fmt.Errorf("docker found, but not using native exec driver") } sd, _ := information["Driver"] cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } glog.Infof("Registering Docker factory") f := &dockerFactory{ machineInfoFactory: factory, client: client, storageDriver: storageDriver(sd), cgroupSubsystems: cgroupSubsystems, fsInfo: fsInfo, } container.RegisterContainerHandlerFactory(f) return nil }
func Register(machineInfoFactory info.MachineInfoFactory) error { cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } if len(cgroupSubsystems.Mounts) == 0 { return fmt.Errorf("failed to find supported cgroup mounts for the raw factory") } glog.Infof("Registering Raw factory") factory := &rawFactory{ machineInfoFactory: machineInfoFactory, cgroupSubsystems: &cgroupSubsystems, } container.RegisterContainerHandlerFactory(factory) return 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) cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } var thinPoolWatcher *devicemapper.ThinPoolWatcher if storageDriver(dockerInfo.Driver) == devicemapperStorageDriver { thinPoolWatcher, err = startThinPoolWatcher(dockerInfo) if err != nil { glog.Errorf("devicemapper filesystem stats will not be reported: %v", err) } } glog.Infof("Registering Docker factory") f := &dockerFactory{ cgroupSubsystems: cgroupSubsystems, client: client, dockerVersion: dockerVersion, fsInfo: fsInfo, machineInfoFactory: factory, storageDriver: storageDriver(dockerInfo.Driver), storageDir: RootDir(), ignoreMetrics: ignoreMetrics, thinPoolWatcher: thinPoolWatcher, } container.RegisterContainerHandlerFactory(f, []watcher.ContainerWatchSource{watcher.Raw}) return 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 }
func NewRawContainerWatcher() (watcher.ContainerWatcher, error) { cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return nil, fmt.Errorf("failed to get cgroup subsystems: %v", err) } if len(cgroupSubsystems.Mounts) == 0 { return nil, fmt.Errorf("failed to find supported cgroup mounts for the raw factory") } watcher, err := common.NewInotifyWatcher() if err != nil { return nil, err } rawWatcher := &rawContainerWatcher{ cgroupPaths: common.MakeCgroupPaths(cgroupSubsystems.MountPoints, "/"), cgroupSubsystems: &cgroupSubsystems, watcher: watcher, stopWatcher: make(chan error), } return rawWatcher, nil }
// Register root container before running this function! func Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo) error { client, err := docker.NewClient(*ArgDockerEndpoint) if err != nil { return fmt.Errorf("unable to communicate with docker daemon: %v", err) } if version, err := client.Version(); err != nil { return fmt.Errorf("unable to communicate with docker daemon: %v", err) } else { expected_version := []int{1, 0, 0} version_string := version.Get("Version") version, err := parseDockerVersion(version_string) if err != nil { return fmt.Errorf("couldn't parse docker version: %v", err) } for index, number := range version { if number > expected_version[index] { break } else if number < expected_version[index] { return fmt.Errorf("cAdvisor requires docker version %v or above but we have found version %v reported as \"%v\"", expected_version, version, version_string) } } } // Check that the libcontainer execdriver is used. information, err := client.Info() if err != nil { return fmt.Errorf("failed to detect Docker info: %v", err) } usesNativeDriver := false for _, val := range *information { if strings.Contains(val, "ExecutionDriver=") && strings.Contains(val, "native") { usesNativeDriver = true break } } if !usesNativeDriver { return fmt.Errorf("docker found, but not using native exec driver") } usesAufsDriver := false for _, val := range *information { if strings.Contains(val, "Driver=") && strings.Contains(val, "aufs") { usesAufsDriver = true break } } if useSystemd { glog.Infof("System is using systemd") } cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } glog.Infof("Registering Docker factory") f := &dockerFactory{ machineInfoFactory: factory, client: client, usesAufsDriver: usesAufsDriver, cgroupSubsystems: cgroupSubsystems, fsInfo: fsInfo, } container.RegisterContainerHandlerFactory(f) return nil }
// Register root container before running this function! func Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo) error { client, err := Client() if err != nil { return fmt.Errorf("unable to communicate with docker daemon: %v", err) } var dockerVersion []int if version, err := client.Version(); err != nil { return fmt.Errorf("unable to communicate with docker daemon: %v", err) } else { expected_version := []int{1, 0, 0} version_string := version.Get("Version") dockerVersion, err = parseDockerVersion(version_string) if err != nil { return fmt.Errorf("couldn't parse docker version: %v", err) } for index, number := range dockerVersion { if number > expected_version[index] { break } else if number < expected_version[index] { return fmt.Errorf("cAdvisor requires docker version %v or above but we have found version %v reported as \"%v\"", expected_version, dockerVersion, version_string) } } } information, err := client.Info() if err != nil { return fmt.Errorf("failed to detect Docker info: %v", err) } // Check that the libcontainer execdriver is used. execDriver := information.Get("ExecutionDriver") if !strings.HasPrefix(execDriver, "native") { return fmt.Errorf("docker found, but not using native exec driver") } sd := information.Get("Driver") if sd == "" { return fmt.Errorf("failed to find docker storage driver") } storageDir := information.Get("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(sd), storageDir: storageDir, } container.RegisterContainerHandlerFactory(f) return nil }