cadvisor: Index | Files | Directories

package container

import ""

Package container defines types for sub-container events and also defines an interface for container operation handlers.


Package Files

container.go factory.go


var AllMetrics = MetricSet{
    CpuUsageMetrics:                struct{}{},
    ProcessSchedulerMetrics:        struct{}{},
    PerCpuUsageMetrics:             struct{}{},
    MemoryUsageMetrics:             struct{}{},
    MemoryNumaMetrics:              struct{}{},
    CpuLoadMetrics:                 struct{}{},
    DiskIOMetrics:                  struct{}{},
    AcceleratorUsageMetrics:        struct{}{},
    DiskUsageMetrics:               struct{}{},
    NetworkUsageMetrics:            struct{}{},
    NetworkTcpUsageMetrics:         struct{}{},
    NetworkAdvancedTcpUsageMetrics: struct{}{},
    NetworkUdpUsageMetrics:         struct{}{},
    ProcessMetrics:                 struct{}{},
    AppMetrics:                     struct{}{},
    HugetlbUsageMetrics:            struct{}{},
    PerfMetrics:                    struct{}{},
    ReferencedMemoryMetrics:        struct{}{},
    CPUTopologyMetrics:             struct{}{},
    ResctrlMetrics:                 struct{}{},

AllMetrics represents all kinds of metrics that cAdvisor supported.

func ClearContainerHandlerFactories Uses

func ClearContainerHandlerFactories()

Clear the known factories.

func DebugInfo Uses

func DebugInfo() map[string][]string

func HasFactories Uses

func HasFactories() bool

Returns whether there are any container handler factories registered.

func InitializeFSContext Uses

func InitializeFSContext(context *fs.Context) error

func InitializePlugins Uses

func InitializePlugins(factory info.MachineInfoFactory, fsInfo fs.FsInfo, includedMetrics MetricSet) []watcher.ContainerWatcher

func RegisterContainerHandlerFactory Uses

func RegisterContainerHandlerFactory(factory ContainerHandlerFactory, watchTypes []watcher.ContainerWatchSource)

Register a ContainerHandlerFactory. These should be registered from least general to most general as they will be asked in order whether they can handle a particular container.

func RegisterPlugin Uses

func RegisterPlugin(name string, plugin Plugin) error

type ContainerHandler Uses

type ContainerHandler interface {
    // Returns the ContainerReference
    ContainerReference() (info.ContainerReference, error)

    // Returns container's isolation spec.
    GetSpec() (info.ContainerSpec, error)

    // Returns the current stats values of the container.
    GetStats() (*info.ContainerStats, error)

    // Returns the subcontainers of this container.
    ListContainers(listType ListType) ([]info.ContainerReference, error)

    // Returns the processes inside this container.
    ListProcesses(listType ListType) ([]int, error)

    // Returns absolute cgroup path for the requested resource.
    GetCgroupPath(resource string) (string, error)

    // Returns container labels, if available.
    GetContainerLabels() map[string]string

    // Returns the container's ip address, if available
    GetContainerIPAddress() string

    // Returns whether the container still exists.
    Exists() bool

    // Cleanup frees up any resources being held like fds or go routines, etc.

    // Start starts any necessary background goroutines - must be cleaned up in Cleanup().
    // It is expected that most implementations will be a no-op.

    // Type of handler
    Type() ContainerType

Interface for container operation handlers.

func NewContainerHandler Uses

func NewContainerHandler(name string, watchType watcher.ContainerWatchSource, inHostNamespace bool) (ContainerHandler, bool, error)

Create a new ContainerHandler for the specified container.

type ContainerHandlerFactory Uses

type ContainerHandlerFactory interface {
    // Create a new ContainerHandler using this factory. CanHandleAndAccept() must have returned true.
    NewContainerHandler(name string, inHostNamespace bool) (c ContainerHandler, err error)

    // Returns whether this factory can handle and accept the specified container.
    CanHandleAndAccept(name string) (handle bool, accept bool, err error)

    // Name of the factory.
    String() string

    // Returns debugging information. Map of lines per category.
    DebugInfo() map[string][]string

type ContainerType Uses

type ContainerType int
const (
    ContainerTypeRaw ContainerType = iota

type ListType Uses

type ListType int

ListType describes whether listing should be just for a specific container or performed recursively.

const (
    ListSelf ListType = iota

type MetricKind Uses

type MetricKind string

MetricKind represents the kind of metrics that cAdvisor exposes.

const (
    CpuUsageMetrics                MetricKind = "cpu"
    ProcessSchedulerMetrics        MetricKind = "sched"
    PerCpuUsageMetrics             MetricKind = "percpu"
    MemoryUsageMetrics             MetricKind = "memory"
    MemoryNumaMetrics              MetricKind = "memory_numa"
    CpuLoadMetrics                 MetricKind = "cpuLoad"
    DiskIOMetrics                  MetricKind = "diskIO"
    DiskUsageMetrics               MetricKind = "disk"
    NetworkUsageMetrics            MetricKind = "network"
    NetworkTcpUsageMetrics         MetricKind = "tcp"
    NetworkAdvancedTcpUsageMetrics MetricKind = "advtcp"
    NetworkUdpUsageMetrics         MetricKind = "udp"
    AcceleratorUsageMetrics        MetricKind = "accelerator"
    AppMetrics                     MetricKind = "app"
    ProcessMetrics                 MetricKind = "process"
    HugetlbUsageMetrics            MetricKind = "hugetlb"
    PerfMetrics                    MetricKind = "perf_event"
    ReferencedMemoryMetrics        MetricKind = "referenced_memory"
    CPUTopologyMetrics             MetricKind = "cpu_topology"
    ResctrlMetrics                 MetricKind = "resctrl"

func (MetricKind) String Uses

func (mk MetricKind) String() string

type MetricSet Uses

type MetricSet map[MetricKind]struct{}

func (MetricSet) Add Uses

func (ms MetricSet) Add(mk MetricKind)

func (MetricSet) Difference Uses

func (ms MetricSet) Difference(ms1 MetricSet) MetricSet

func (MetricSet) Has Uses

func (ms MetricSet) Has(mk MetricKind) bool

type Plugin Uses

type Plugin interface {
    // InitializeFSContext is invoked when populating an fs.Context object for a new manager.
    // A returned error here is fatal.
    InitializeFSContext(context *fs.Context) error

    // Register is invoked when starting a manager. It can optionally return a container watcher.
    // A returned error is logged, but is not fatal.
    Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo, includedMetrics MetricSet) (watcher.ContainerWatcher, error)


commonUnmarshal's a Containers description json file.
containerdThis code has been taken from containerd repo to avoid large library import
containerd/installThe install package registers containerd.NewPlugin() as the "containerd" container provider when imported
crioHandler for CRI-O containers.
crio/installThe install package registers crio.NewPlugin() as the "crio" container provider when imported
dockerProvides global docker information.
docker/installThe install package registers docker.NewPlugin() as the "docker" container provider when imported
rawHandler for "raw" containers.
systemd/installThe install package registers systemd.NewPlugin() as the "systemd" container provider when imported

Package container imports 6 packages (graph) and is imported by 1172 packages. Updated 2020-09-11. Refresh now. Tools for package owners.