fix: allow to stats not-running container

cli/stats_helpers.go

@@ -170,11 +170,11 @@ func collect(ctx context.Context, s *StatsEntryWithLock, cli client.CommonAPICli
 			}
 
 			// first time PrecpuStats will be nil
-			if v.PrecpuStats != nil {
+			if v.PrecpuStats != nil && v.PrecpuStats.CPUUsage != nil {
 				previousCPU = v.PrecpuStats.CPUUsage.TotalUsage
 				previousSystem = v.PrecpuStats.SyetemCPUUsage
 			}
-			cpuPercent = calculateCPUPercentUnix(previousCPU, previousSystem, v)
+			cpuPercent = calculateCPUPercentUnix(previousCPU, previousSystem, v.CPUStats)
 			blkRead, blkWrite = calculateBlockIO(v.BlkioStats)
 			mem = calculateMemUsageUnixNoCache(v.MemoryStats)
 			memLimit = float64(v.MemoryStats.Limit)
@@ -228,18 +228,22 @@ func collect(ctx context.Context, s *StatsEntryWithLock, cli client.CommonAPICli
 	}
 }
 
-func calculateCPUPercentUnix(previousCPU, previousSystem uint64, v *types.ContainerStats) float64 {
+func calculateCPUPercentUnix(previousCPU, previousSystem uint64, cpuStats *types.CPUStats) float64 {
+	if cpuStats == nil || cpuStats.CPUUsage == nil {
+		return 0.0
+	}
+
 	var (
 		cpuPercent = 0.0
 		// calculate the change for the cpu usage of the container in between readings
-		cpuDelta = float64(v.CPUStats.CPUUsage.TotalUsage) - float64(previousCPU)
+		cpuDelta = float64(cpuStats.CPUUsage.TotalUsage) - float64(previousCPU)
 		// calculate the change for the entire system between readings
-		systemDelta = float64(v.CPUStats.SyetemCPUUsage) - float64(previousSystem)
-		onlineCPUs  = float64(v.CPUStats.OnlineCpus)
+		systemDelta = float64(cpuStats.SyetemCPUUsage) - float64(previousSystem)
+		onlineCPUs  = float64(cpuStats.OnlineCpus)
 	)
 
 	if onlineCPUs == 0.0 {
-		onlineCPUs = float64(len(v.CPUStats.CPUUsage.PercpuUsage))
+		onlineCPUs = float64(len(cpuStats.CPUUsage.PercpuUsage))
 	}
 	if systemDelta > 0.0 && cpuDelta > 0.0 {
 		cpuPercent = (cpuDelta / systemDelta) * onlineCPUs * 100.0
@@ -273,6 +277,9 @@ func calculateNetwork(network map[string]types.NetworkStats) (float64, float64)
 // calculateMemUsageUnixNoCache calculate memory usage of the container.
 // Page cache is intentionally excluded to avoid misinterpretation of the output.
 func calculateMemUsageUnixNoCache(mem *types.MemoryStats) float64 {
+	if mem == nil || len(mem.Stats) == 0 {
+		return 0.0
+	}
 	return float64(mem.Usage - mem.Stats["cache"])
 }
 

cri/v1alpha2/cri_utils.go

@@ -26,8 +26,6 @@ import (
 	"github.com/alibaba/pouch/pkg/randomid"
 	"github.com/alibaba/pouch/pkg/utils"
 
-	"github.com/containerd/cgroups"
-	"github.com/containerd/typeurl"
 	"github.com/cri-o/ocicni/pkg/ocicni"
 	"github.com/go-openapi/strfmt"
 	"github.com/sirupsen/logrus"
@@ -1070,26 +1068,21 @@ func (c *CriManager) getContainerMetrics(ctx context.Context, meta *mgr.Containe
 		Annotations: annotations,
 	}
 
-	stats, _, err := c.ContainerMgr.Stats(ctx, meta.ID)
+	metricsMeta, metrics, err := c.ContainerMgr.Stats(ctx, meta.ID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get stats of container %q: %v", meta.ID, err)
 	}
 
-	if stats != nil {
-		s, err := typeurl.UnmarshalAny(stats.Data)
-		if err != nil {
-			return nil, fmt.Errorf("failed to extract container metrics: %v", err)
-		}
-		metrics := s.(*cgroups.Metrics)
+	if metricsMeta != nil {
 		if metrics.CPU != nil && metrics.CPU.Usage != nil {
 			cs.Cpu = &runtime.CpuUsage{
-				Timestamp:            stats.Timestamp.UnixNano(),
+				Timestamp:            metricsMeta.Timestamp.UnixNano(),
 				UsageCoreNanoSeconds: &runtime.UInt64Value{Value: metrics.CPU.Usage.Total},
 			}
 		}
 		if metrics.Memory != nil && metrics.Memory.Usage != nil {
 			cs.Memory = &runtime.MemoryUsage{
-				Timestamp:       stats.Timestamp.UnixNano(),
+				Timestamp:       metricsMeta.Timestamp.UnixNano(),
 				WorkingSetBytes: &runtime.UInt64Value{Value: metrics.Memory.Usage.Usage},
 			}
 		}

daemon/mgr/container_stats.go

@@ -32,48 +32,46 @@ func (mgr *ContainerManager) StreamStats(ctx context.Context, name string, confi
 	}
 
 	outStream := config.OutStream
-	if !c.IsRunningOrPaused() {
-		return errors.New("can only stats running or paused container")
-	}
 
 	var preCPUStats *types.CPUStats
 
-	wrapContainerStats := func(timestamp time.Time, metric *cgroups.Metrics) (*types.ContainerStats, error) {
-		stats := toContainerStats(timestamp, c, metric)
+	wrapContainerStats := func(metricMeta *containerdtypes.Metric, metric *cgroups.Metrics) (*types.ContainerStats, error) {
+		stats := toContainerStats(c, metricMeta, metric)
+
 		systemCPUUsage, err := getSystemCPUUsage()
 		if err != nil {
 			return nil, err
 		}
 		stats.PrecpuStats = preCPUStats
 		stats.CPUStats.SyetemCPUUsage = systemCPUUsage
 		preCPUStats = stats.CPUStats
+
 		networkStat, err := mgr.NetworkMgr.GetNetworkStats(c.NetworkSettings.SandboxID)
 		if err != nil {
 			// --net=none or disconnect from network, the sandbox will be nil
-			logrus.Warnf("sandbox not found, name = %s, err= %v", name, err)
+			logrus.Debugf("failed to get network stats from container %s: %v", name, err)
 		}
 		stats.Networks = networkStat
 		return stats, nil
 	}
 
-	if c.IsRunningOrPaused() && !config.Stream {
+	// just collect stats data once.
+	if !config.Stream {
 		metrics, stats, err := mgr.Stats(ctx, name)
 		if err != nil {
 			return err
 		}
-		containerStat, err := wrapContainerStats(metrics.Timestamp, stats)
+		containerStat, err := wrapContainerStats(metrics, stats)
 		if err != nil {
 			return errors.Errorf("failed to wrap the containerStat: %v", err)
 		}
 		return json.NewEncoder(outStream).Encode(containerStat)
 	}
 
-	if config.Stream {
-		wf := ioutils.NewWriteFlusher(outStream)
-		defer wf.Close()
-		wf.Flush()
-		outStream = wf
-	}
+	wf := ioutils.NewWriteFlusher(outStream)
+	defer wf.Close()
+	wf.Flush()
+	outStream = wf
 
 	enc := json.NewEncoder(outStream)
 
@@ -89,14 +87,12 @@ func (mgr *ContainerManager) StreamStats(ctx context.Context, name string, confi
 				return err
 			}
 
-			if metrics != nil {
-				containerStat, err := wrapContainerStats(metrics.Timestamp, stats)
-				if err != nil {
-					return errors.Errorf("failed to wrap the containerStat: %v", err)
-				}
-				if err := enc.Encode(containerStat); err != nil {
-					return err
-				}
+			containerStat, err := wrapContainerStats(metrics, stats)
+			if err != nil {
+				return errors.Errorf("failed to wrap the containerStat: %v", err)
+			}
+			if err := enc.Encode(containerStat); err != nil {
+				return err
 			}
 
 			time.Sleep(DefaultStatsInterval)
@@ -114,10 +110,9 @@ func (mgr *ContainerManager) Stats(ctx context.Context, name string) (*container
 	c.Lock()
 	defer c.Unlock()
 
-	// only get metrics when the container is running
-	// return error to help client quick fail
+	// empty stats for not-running container.
 	if !c.IsRunningOrPaused() {
-		return nil, nil, errors.New("can only stats running or paused container")
+		return nil, nil, nil
 	}
 
 	metric, err := mgr.Client.ContainerStats(ctx, c.ID)
@@ -133,9 +128,19 @@ func (mgr *ContainerManager) Stats(ctx context.Context, name string) (*container
 	return metric, v.(*cgroups.Metrics), nil
 }
 
-func toContainerStats(time time.Time, container *Container, metric *cgroups.Metrics) *types.ContainerStats {
+func toContainerStats(container *Container, metricMeta *containerdtypes.Metric, metric *cgroups.Metrics) *types.ContainerStats {
+	if metricMeta == nil {
+		return &types.ContainerStats{
+			ID:          container.ID,
+			Name:        container.Name,
+			PidsStats:   &types.PidsStats{},
+			CPUStats:    &types.CPUStats{},
+			BlkioStats:  &types.BlkioStats{},
+			MemoryStats: &types.MemoryStats{},
+		}
+	}
 	return &types.ContainerStats{
-		Read: strfmt.DateTime(time),
+		Read: strfmt.DateTime(metricMeta.Timestamp),
 		ID:   container.ID,
 		Name: container.Name,
 		PidsStats: &types.PidsStats{

test/cli_stats_test.go

@@ -45,15 +45,3 @@ func (s *PouchStatsSuite) TestStatsNoStream(c *check.C) {
 		c.Fatalf("container name not present in the stats output, %s", res.Stdout())
 	}
 }
-
-func (s *PouchStatsSuite) TestStatsWrongState(c *check.C) {
-	cname := "TestStatsWrongState"
-	command.PouchRun("create", "--name", cname, busyboxImage, "top").Assert(c, icmd.Success)
-	defer DelContainerForceMultyTime(c, cname)
-
-	res := command.PouchRun("stats", "--no-stream", cname)
-	errString := res.Stderr()
-	if !strings.Contains(errString, "can only stats running or paused container") {
-		c.Fatalf("got unexpected error, %s", errString)
-	}
-}