cpu working on mac

coder · mtojek · Jun 20, 2023 · May 29, 2023 · Jun 7, 2023 · Jun 7, 2023
commit d6029b415cdfbf065d383a78beed970ec30d9df0
diff --git a/cli/stat.go b/cli/stat.go
@@ -2,23 +2,28 @@ package cli
 
 import (
 	"fmt"
-	"math"
 	"runtime"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/elastic/go-sysinfo"
+	sysinfotypes "github.com/elastic/go-sysinfo/types"
 
 	"github.com/coder/coder/cli/clibase"
 	"github.com/coder/coder/cli/cliui"
 )
 
 func (*RootCmd) stat() *clibase.Cmd {
+	defaultCols := []string{"host_cpu", "host_memory", "disk"}
+	if isContainerized() {
+		// If running in a container, we assume that users want to see these first. Prepend.
+		defaultCols = append([]string{"container_cpu", "container_memory"}, defaultCols...)
+	}
 	var (
 		sampleInterval time.Duration
 		formatter      = cliui.NewOutputFormatter(
-			cliui.TextFormat(),
+			cliui.TableFormat([]statsRow{}, defaultCols),
 			cliui.JSONFormat(),
 		)
 	)
@@ -35,11 +40,17 @@ func (*RootCmd) stat() *clibase.Cmd {
 			},
 		},
 		Handler: func(inv *clibase.Invocation) error {
-			stats, err := newStats(sampleInterval)
+			hi, err := sysinfo.Host()
 			if err != nil {
 				return err
 			}
-			out, err := formatter.Format(inv.Context(), stats)
+			sr := statsRow{}
+			if cs, err := statCPU(hi, sampleInterval); err != nil {
+				return err
+			} else {
+				sr.HostCPU = cs
+			}
+			out, err := formatter.Format(inv.Context(), []statsRow{sr})
 			if err != nil {
 				return err
 			}
@@ -51,96 +62,63 @@ func (*RootCmd) stat() *clibase.Cmd {
 	return cmd
 }
 
-type stats struct {
-	HostCPU         stat `json:"cpu_host"`
-	HostMemory      stat `json:"mem_host"`
-	Disk            stat `json:"disk"`
-	InContainer     bool `json:"in_container,omitempty"`
-	ContainerCPU    stat `json:"cpu_container,omitempty"`
-	ContainerMemory stat `json:"mem_container,omitempty"`
-}
-
-func (s *stats) String() string {
-	var sb strings.Builder
-	sb.WriteString(s.HostCPU.String())
-	sb.WriteString("\n")
-	sb.WriteString(s.HostMemory.String())
-	sb.WriteString("\n")
-	sb.WriteString(s.Disk.String())
-	sb.WriteString("\n")
-	if s.InContainer {
-		sb.WriteString(s.ContainerCPU.String())
-		sb.WriteString("\n")
-		sb.WriteString(s.ContainerMemory.String())
-		sb.WriteString("\n")
-	}
-	return sb.String()
-}
-
-func newStats(dur time.Duration) (stats, error) {
-	var s stats
+func statCPU(hi sysinfotypes.Host, interval time.Duration) (*stat, error) {
 	nproc := float64(runtime.NumCPU())
-	// start := time.Now()
-	// ticksPerDur := dur / tickInterval
-	h1, err := sysinfo.Host()
-	if err != nil {
-		return s, err
-	}
-	<-time.After(dur)
-	h2, err := sysinfo.Host()
-	if err != nil {
-		return s, err
+	s := &stat{
+		Unit: "cores",
 	}
-	// elapsed := time.Since(start)
-	// numTicks := elapsed / tickInterval
-	cts1, err := h1.CPUTime()
+	c1, err := hi.CPUTime()
 	if err != nil {
-		return s, err
+		return nil, err
 	}
-	cts2, err := h2.CPUTime()
+	<-time.After(interval)
+	c2, err := hi.CPUTime()
 	if err != nil {
-		return s, err
+		return nil, err
 	}
-	// Assuming the total measured should add up to $(nproc) "cores",
-	// we determine a scaling factor such that scaleFactor * total = nproc.
-	// We then calculate used as the total time spent idle, and multiply
-	// that by scaleFactor to give a rough approximation of how busy the
-	// CPU(s) were.
-	s.HostCPU.Total = nproc
-	total := (cts2.Total() - cts1.Total())
-	idle := (cts2.Idle - cts1.Idle)
+	s.Total = nproc
+	total := c2.Total() - c1.Total()
+	idle := c2.Idle - c1.Idle
 	used := total - idle
 	scaleFactor := nproc / total.Seconds()
-	s.HostCPU.Used = used.Seconds() * scaleFactor
-	s.HostCPU.Unit = "cores"
-
+	s.Used = used.Seconds() * scaleFactor
 	return s, nil
 }
 
+type statsRow struct {
+	HostCPU         *stat `json:"host_cpu" table:"host_cpu,default_sort"`
+	HostMemory      *stat `json:"host_memory" table:"host_memory"`
+	Disk            *stat `json:"disk" table:"disk"`
+	ContainerCPU    *stat `json:"container_cpu" table:"container_cpu"`
+	ContainerMemory *stat `json:"container_memory" table:"container_memory"`
+}
+
 type stat struct {
-	Used  float64 `json:"used"`
 	Total float64 `json:"total"`
 	Unit  string  `json:"unit"`
+	Used  float64 `json:"used"`
 }
 
 func (s *stat) String() string {
+	if s == nil {
+		return "-"
+	}
 	var sb strings.Builder
 	_, _ = sb.WriteString(strconv.FormatFloat(s.Used, 'f', 1, 64))
 	_, _ = sb.WriteString("/")
 	_, _ = sb.WriteString(strconv.FormatFloat(s.Total, 'f', 1, 64))
 	_, _ = sb.WriteString(" ")
 	if s.Unit != "" {
 		_, _ = sb.WriteString(s.Unit)
-		_, _ = sb.WriteString(" ")
-	}
-	_, _ = sb.WriteString("(")
-	var pct float64
-	if s.Total == 0 {
-		pct = math.NaN()
-	} else {
-		pct = s.Used / s.Total * 100
 	}
-	_, _ = sb.WriteString(strconv.FormatFloat(pct, 'f', 1, 64))
-	_, _ = sb.WriteString("%)")
 	return sb.String()
 }
+
+func isContainerized() bool {
+	hi, err := sysinfo.Host()
+	if err != nil {
+		// If we can't get the host info, we have other issues.
+		panic(err)
+	}
+	return hi.Info().Containerized != nil && *hi.Info().Containerized
+}
diff --git a/cli/stat_internal_test.go b/cli/stat_internal_test.go
@@ -12,11 +12,11 @@ func TestStatString(t *testing.T) {
 		Stat     stat
 	}{
 		{
-			Expected: "1.2/3.4 quatloos (50%)",
-			Stat:     stat{Used: 1.2, Total: 3.4, Unit: "quatloos"},
+			Expected: "1.2/5.7 quatloos",
+			Stat:     stat{Used: 1.234, Total: 5.678, Unit: "quatloos"},
 		},
 		{
-			Expected: "0/0 HP (NaN%)",
+			Expected: "0.0/0.0 HP",
 			Stat:     stat{Used: 0, Total: 0, Unit: "HP"},
 		},
 	} {

diff --git a/cli/stat_test.go b/cli/stat_test.go
@@ -3,6 +3,8 @@ package cli_test
 import (
 	"bytes"
 	"context"
+	"encoding/json"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -11,8 +13,8 @@ import (
 	"github.com/coder/coder/testutil"
 )
 
-// This just tests that the stat command is recognized and does not output
-// an empty string. Actually testing the output of the stat command is
+// This just tests that the statRow command is recognized and does not output
+// an empty string. Actually testing the output of the stats command is
 // fraught with all sorts of fun.
 func TestStatCmd(t *testing.T) {
 	t.Run("JSON", func(t *testing.T) {
@@ -24,17 +26,40 @@ func TestStatCmd(t *testing.T) {
 		inv.Stdout = buf
 		err := inv.WithContext(ctx).Run()
 		require.NoError(t, err)
-		require.NotEmpty(t, buf.String())
+		s := buf.String()
+		require.NotEmpty(t, s)
+		// Must be valid JSON
+		tmp := make([]struct{}, 0)
+		require.NoError(t, json.NewDecoder(strings.NewReader(s)).Decode(&tmp))
 	})
-	t.Run("Text", func(t *testing.T) {
+	t.Run("Table", func(t *testing.T) {
 		t.Parallel()
 		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 		t.Cleanup(cancel)
-		inv, _ := clitest.New(t, "stat", "--output=text")
+		inv, _ := clitest.New(t, "stat", "--output=table")
 		buf := new(bytes.Buffer)
 		inv.Stdout = buf
 		err := inv.WithContext(ctx).Run()
 		require.NoError(t, err)
-		require.NotEmpty(t, buf.String())
+		s := buf.String()
+		require.NotEmpty(t, s)
+		require.Contains(t, s, "HOST CPU")
+		require.Contains(t, s, "HOST MEMORY")
+		require.Contains(t, s, "DISK")
+	})
+	t.Run("Default", func(t *testing.T) {
+		t.Parallel()
+		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
+		t.Cleanup(cancel)
+		inv, _ := clitest.New(t, "stat", "--output=table")
+		buf := new(bytes.Buffer)
+		inv.Stdout = buf
+		err := inv.WithContext(ctx).Run()
+		require.NoError(t, err)
+		s := buf.String()
+		require.NotEmpty(t, s)
+		require.Contains(t, s, "HOST CPU")
+		require.Contains(t, s, "HOST MEMORY")
+		require.Contains(t, s, "DISK")
 	})
 }