package daemon import ( "encoding/json" "errors" "fmt" "runtime" "golang.org/x/net/context" "github.com/docker/docker/api/types/backend" "github.com/docker/docker/container" "github.com/docker/docker/pkg/ioutils" "github.com/docker/engine-api/types" "github.com/docker/engine-api/types/versions" "github.com/docker/engine-api/types/versions/v1p20" ) // ContainerStats writes information about the container to the stream // given in the config object. func (daemon *Daemon) ContainerStats(ctx context.Context, prefixOrName string, config *backend.ContainerStatsConfig) error { if runtime.GOOS == "windows" { return errors.New("Windows does not support stats") } // Remote API version (used for backwards compatibility) apiVersion := config.Version container, err := daemon.GetContainer(prefixOrName) if err != nil { return err } // If the container is not running and requires no stream, return an empty stats. if !container.IsRunning() && !config.Stream { return json.NewEncoder(config.OutStream).Encode(&types.Stats{}) } outStream := config.OutStream if config.Stream { wf := ioutils.NewWriteFlusher(outStream) defer wf.Close() wf.Flush() outStream = wf } var preCPUStats types.CPUStats getStatJSON := func(v interface{}) *types.StatsJSON { ss := v.(types.StatsJSON) ss.PreCPUStats = preCPUStats preCPUStats = ss.CPUStats return &ss } enc := json.NewEncoder(outStream) updates := daemon.subscribeToContainerStats(container) defer daemon.unsubscribeToContainerStats(container, updates) noStreamFirstFrame := true for { select { case v, ok := <-updates: if !ok { return nil } var statsJSON interface{} statsJSONPost120 := getStatJSON(v) if versions.LessThan(apiVersion, "1.21") { var ( rxBytes uint64 rxPackets uint64 rxErrors uint64 rxDropped uint64 txBytes uint64 txPackets uint64 txErrors uint64 txDropped uint64 ) for _, v := range statsJSONPost120.Networks { rxBytes += v.RxBytes rxPackets += v.RxPackets rxErrors += v.RxErrors rxDropped += v.RxDropped txBytes += v.TxBytes txPackets += v.TxPackets txErrors += v.TxErrors txDropped += v.TxDropped } statsJSON = &v1p20.StatsJSON{ Stats: statsJSONPost120.Stats, Network: types.NetworkStats{ RxBytes: rxBytes, RxPackets: rxPackets, RxErrors: rxErrors, RxDropped: rxDropped, TxBytes: txBytes, TxPackets: txPackets, TxErrors: txErrors, TxDropped: txDropped, }, } } else { statsJSON = statsJSONPost120 } if !config.Stream && noStreamFirstFrame { // prime the cpu stats so they aren't 0 in the final output noStreamFirstFrame = false continue } if err := enc.Encode(statsJSON); err != nil { return err } if !config.Stream { return nil } case <-ctx.Done(): return nil } } } func (daemon *Daemon) subscribeToContainerStats(c *container.Container) chan interface{} { return daemon.statsCollector.collect(c) } func (daemon *Daemon) unsubscribeToContainerStats(c *container.Container, ch chan interface{}) { daemon.statsCollector.unsubscribe(c, ch) } // GetContainerStats collects all the stats published by a container func (daemon *Daemon) GetContainerStats(container *container.Container) (*types.StatsJSON, error) { stats, err := daemon.stats(container) if err != nil { return nil, err } if !container.Config.NetworkDisabled { if stats.Networks, err = daemon.getNetworkStats(container); err != nil { return nil, err } } return stats, nil } // Resolve Network SandboxID in case the container reuse another container's network stack func (daemon *Daemon) getNetworkSandboxID(c *container.Container) (string, error) { curr := c for curr.HostConfig.NetworkMode.IsContainer() { containerID := curr.HostConfig.NetworkMode.ConnectedContainer() connected, err := daemon.GetContainer(containerID) if err != nil { return "", fmt.Errorf("Could not get container for %s", containerID) } curr = connected } return curr.NetworkSettings.SandboxID, nil } func (daemon *Daemon) getNetworkStats(c *container.Container) (map[string]types.NetworkStats, error) { sandboxID, err := daemon.getNetworkSandboxID(c) if err != nil { return nil, err } sb, err := daemon.netController.SandboxByID(sandboxID) if err != nil { return nil, err } lnstats, err := sb.Statistics() if err != nil { return nil, err } stats := make(map[string]types.NetworkStats) // Convert libnetwork nw stats into engine-api stats for ifName, ifStats := range lnstats { stats[ifName] = types.NetworkStats{ RxBytes: ifStats.RxBytes, RxPackets: ifStats.RxPackets, RxErrors: ifStats.RxErrors, RxDropped: ifStats.RxDropped, TxBytes: ifStats.TxBytes, TxPackets: ifStats.TxPackets, TxErrors: ifStats.TxErrors, TxDropped: ifStats.TxDropped, } } return stats, nil }