Oct 10, 2022 · Oct 4, 2022 · Oct 4, 2022 · Oct 4, 2022 · Oct 4, 2022 · Oct 5, 2022
diff --git a/.github/workflows/coder.yaml b/.github/workflows/coder.yaml
  push:
    branches:
      - main
    tags:
      - "*"

  pull_request:

      - name: Checkout
        uses: actions/checkout@v2
      - name: typos-action
        uses: crate-ci/typos@master
        uses: crate-ci/typos@v1.12.8
        with:
          config: .github/workflows/typos.toml
      - name: Fix Helper
        with:
          name: failed-test-videos
          path: ./site/test-results/**/*.webm
          retention:days: 7
          retention-days: 7

  chromatic:
    # REMARK: this is only used to build storybook and deploy it to Chromatic.
diff --git a/.github/workflows/dogfood.yaml b/.github/workflows/dogfood.yaml
  push:
    branches:
      - main
    tags:
      - "*"
    paths:
      - "dogfood/**"
  pull_request:
diff --git a/.vscode/settings.json b/.vscode/settings.json
    "cliflag",
    "cliui",
    "codecov",
    "Codespaces",
    "coderd",
    "coderdenttest",
    "coderdtest",
    "codersdk",
    "cronstrue",
    "drpcmux",
    "drpcserver",
    "Dsts",
    "enablements",
    "fatih",
    "Formik",
    "gitsshkey",
diff --git a/README.md b/README.md

 ```sh
 # Automatically sets up an external access URL on *.try.coder.app
 coder server --tunnel
 coder server

 # Requires a PostgreSQL instance and external access URL
 coder server --postgres-url <url> --access-url <url>
diff --git a/agent/agent.go b/agent/agent.go
 "fmt"
 "io"
 "net"
 "net/http"
 "net/netip"
 "os"
 "os/exec"
 go a.sshServer.HandleConn(a.stats.wrapConn(conn))
 }
 }()

 reconnectingPTYListener, err := a.network.Listen("tcp", ":"+strconv.Itoa(codersdk.TailnetReconnectingPTYPort))
 if err != nil {
 a.logger.Critical(ctx, "listen for reconnecting pty", slog.Error(err))
 go a.handleReconnectingPTY(ctx, msg, conn)
 }
 }()

 speedtestListener, err := a.network.Listen("tcp", ":"+strconv.Itoa(codersdk.TailnetSpeedtestPort))
 if err != nil {
 a.logger.Critical(ctx, "listen for speedtest", slog.Error(err))
 }()
 }
 }()

 statisticsListener, err := a.network.Listen("tcp", ":"+strconv.Itoa(codersdk.TailnetStatisticsPort))
 if err != nil {
 a.logger.Critical(ctx, "listen for statistics", slog.Error(err))
 return
 }
 go func() {
 defer statisticsListener.Close()
 server := &http.Server{
 Handler:           a.statisticsHandler(),
 ReadTimeout:       20 * time.Second,
 ReadHeaderTimeout: 20 * time.Second,
 WriteTimeout:      20 * time.Second,
 ErrorLog:          slog.Stdlib(ctx, a.logger.Named("statistics_http_server"), slog.LevelInfo),
 }
 go func() {
 <-ctx.Done()
 _ = server.Close()
 }()

 err = server.Serve(statisticsListener)
 if err != nil && !xerrors.Is(err, http.ErrServerClosed) && !strings.Contains(err.Error(), "use of closed network connection") {
 a.logger.Critical(ctx, "serve statistics HTTP server", slog.Error(err))
 }
 }()
 }

 // runCoordinator listens for nodes and updates the self-node as it changes.
diff --git a/agent/ports_supported.go b/agent/ports_supported.go
 //go:build linux || (windows && amd64)

 package agent

 import (
 "time"

 "github.com/cakturk/go-netstat/netstat"
 "golang.org/x/xerrors"

 "github.com/coder/coder/codersdk"
 )

 func (lp *listeningPortsHandler) getListeningPorts() ([]codersdk.ListeningPort, error) {
 lp.mut.Lock()
 defer lp.mut.Unlock()

 if time.Since(lp.mtime) < time.Second {
 // copy
 ports := make([]codersdk.ListeningPort, len(lp.ports))
 copy(ports, lp.ports)
 return ports, nil
 }

 tabs, err := netstat.TCPSocks(func(s *netstat.SockTabEntry) bool {
 return s.State == netstat.Listen
 })
 if err != nil {
 return nil, xerrors.Errorf("scan listening ports: %w", err)
 }

 seen := make(map[uint16]struct{}, len(tabs))
 ports := []codersdk.ListeningPort{}
 for _, tab := range tabs {
 if tab.LocalAddr == nil || tab.LocalAddr.Port < uint16(codersdk.MinimumListeningPort) {
 continue
 }

 // Don't include ports that we've already seen. This can happen on
 // Windows, and maybe on Linux if you're using a shared listener socket.
 if _, ok := seen[tab.LocalAddr.Port]; ok {
 continue
 }
 seen[tab.LocalAddr.Port] = struct{}{}

 procName := ""
 if tab.Process != nil {
 procName = tab.Process.Name
 }
 ports = append(ports, codersdk.ListeningPort{
 ProcessName: procName,
 Network:     codersdk.ListeningPortNetworkTCP,
 Port:        tab.LocalAddr.Port,
 })
 }

 lp.ports = ports
 lp.mtime = time.Now()

 // copy
 ports = make([]codersdk.ListeningPort, len(lp.ports))
 copy(ports, lp.ports)
 return ports, nil
 }
diff --git a/agent/ports_unsupported.go b/agent/ports_unsupported.go
 //go:build !linux && !(windows && amd64)

 package agent

 import "github.com/coder/coder/codersdk"

 func (lp *listeningPortsHandler) getListeningPorts() ([]codersdk.ListeningPort, error) {
 // Can't scan for ports on non-linux or non-windows_amd64 systems at the
 // moment. The UI will not show any "no ports found" message to the user, so
 // the user won't suspect a thing.
 return []codersdk.ListeningPort{}, nil
 }
diff --git a/agent/statsendpoint.go b/agent/statsendpoint.go
 package agent

 import (
 "net/http"
 "sync"
 "time"

 "github.com/go-chi/chi"

 "github.com/coder/coder/coderd/httpapi"
 "github.com/coder/coder/codersdk"
 )

 func (*agent) statisticsHandler() http.Handler {
 r := chi.NewRouter()
 r.Get("/", func(rw http.ResponseWriter, r *http.Request) {
 httpapi.Write(r.Context(), rw, http.StatusOK, codersdk.Response{
 Message: "Hello from the agent!",
 })
 })

 lp := &listeningPortsHandler{}
 r.Get("/api/v0/listening-ports", lp.handler)

 return r
 }

 type listeningPortsHandler struct {
 mut   sync.Mutex
 ports []codersdk.ListeningPort
 mtime time.Time
 }

 // handler returns a list of listening ports. This is tested by coderd's
 // TestWorkspaceAgentListeningPorts test.
 func (lp *listeningPortsHandler) handler(rw http.ResponseWriter, r *http.Request) {
 ports, err := lp.getListeningPorts()
 if err != nil {
 httpapi.Write(r.Context(), rw, http.StatusInternalServerError, codersdk.Response{
 Message: "Could not scan for listening ports.",
 Detail:  err.Error(),
 })
 return
 }

 httpapi.Write(r.Context(), rw, http.StatusOK, codersdk.ListeningPortsResponse{
 Ports: ports,
 })
 }
diff --git a/cli/agent.go b/cli/agent.go
 }
 }

 ctx, cancelFunc := context.WithTimeout(cmd.Context(), time.Hour)
 defercancelFunc()
 for retry.New(100*time.Millisecond, 5*time.Second).Wait(ctx) {
 err := client.PostWorkspaceAgentVersion(cmd.Context(), version)
 retryCtx, cancelRetry := context.WithTimeout(cmd.Context(), time.Hour)
 defercancelRetry()
 forretrier :=retry.New(100*time.Millisecond, 5*time.Second); retrier.Wait(retryCtx); {
 err := client.PostWorkspaceAgentVersion(retryCtx, version)
 if err != nil {
 logger.Warn(cmd.Context(), "post agent version: %w", slog.Error(err), slog.F("version", version))
 logger.Warn(retryCtx, "post agent version: %w", slog.Error(err), slog.F("version", version))
 continue
 }
 logger.Info(ctx, "updated agent version", slog.F("version", version))
 logger.Info(retryCtx, "updated agent version", slog.F("version", version))
 break
 }

diff --git a/cli/cliui/table.go b/cli/cliui/table.go
 // Special type formatting.
 switch val := v.(type) {
 case time.Time:
 v = val.Format(time.Stamp)
 v = val.Format(time.RFC3339)
 case *time.Time:
 if val != nil {
 v = val.Format(time.Stamp)
 v = val.Format(time.RFC3339)
 }
 case *int64:
 if val != nil {
 v = *val
 }
 case fmt.Stringer:
 if val != nil {
diff --git a/cli/cliui/table_test.go b/cli/cliui/table_test.go
 t.Parallel()

 expected := `
 NAME  AGE  ROLES    SUB 1 NAME  SUB 1 AGE  SUB 2 NAME  SUB 2 AGE  SUB 3 INNER NAME  SUB 3 INNER AGE  SUB 4       TIME             TIME PTR
 foo    10  [a b c]  foo1               11  foo2        12         foo3                           13  {foo4 14 }Aug  2 15:49:10  Aug  2 15:49:10
 bar    20  [a]      bar1               21  <nil>       <nil>      bar3                           23  {bar4 24 }Aug  2 15:49:10  <nil>
 baz    30  []       baz1               31  <nil>       <nil>      baz3                           33  {baz4 34 }Aug  2 15:49:10  <nil>
 NAME  AGE  ROLES    SUB 1 NAME  SUB 1 AGE  SUB 2 NAME  SUB 2 AGE  SUB 3 INNER NAME  SUB 3 INNER AGE  SUB 4       TIMETIME PTR
 foo    10  [a b c]  foo1               11  foo2        12         foo3                           13  {foo4 14 }2022-08-02T15:49:10Z  2022-08-02T15:49:10Z
 bar    20  [a]      bar1               21  <nil>       <nil>      bar3                           23  {bar4 24 }2022-08-02T15:49:10Z  <nil>
 baz    30  []       baz1               31  <nil>       <nil>      baz3                           33  {baz4 34 }2022-08-02T15:49:10Z  <nil>
 `

 // Test with non-pointer values.
 t.Parallel()

 expected := `
 NAME  AGE  ROLES    SUB 1 NAME  SUB 1 AGE  SUB 2 NAME  SUB 2 AGE  SUB 3 INNER NAME  SUB 3 INNER AGE  SUB 4       TIME             TIME PTR
 bar    20  [a]      bar1               21  <nil>       <nil>      bar3                           23  {bar4 24 }Aug  2 15:49:10  <nil>
 baz    30  []       baz1               31  <nil>       <nil>      baz3                           33  {baz4 34 }Aug  2 15:49:10  <nil>
 foo    10  [a b c]  foo1               11  foo2        12         foo3                           13  {foo4 14 }Aug  2 15:49:10  Aug  2 15:49:10
 NAME  AGE  ROLES    SUB 1 NAME  SUB 1 AGE  SUB 2 NAME  SUB 2 AGE  SUB 3 INNER NAME  SUB 3 INNER AGE  SUB 4       TIMETIME PTR
 bar    20  [a]      bar1               21  <nil>       <nil>      bar3                           23  {bar4 24 }2022-08-02T15:49:10Z  <nil>
 baz    30  []       baz1               31  <nil>       <nil>      baz3                           33  {baz4 34 }2022-08-02T15:49:10Z  <nil>
 foo    10  [a b c]  foo1               11  foo2        12         foo3                           13  {foo4 14 }2022-08-02T15:49:10Z  2022-08-02T15:49:10Z
 `

 out, err := cliui.DisplayTable(in, "name", nil)

 expected := `
 NAME  SUB 1 NAME  SUB 3 INNER NAME  TIME
 foo   foo1        foo3Aug  2 15:49:10
 bar   bar1        bar3Aug  2 15:49:10
 baz   baz1        baz3Aug  2 15:49:10
 foo   foo1        foo32022-08-02T15:49:10Z
 bar   bar1        bar32022-08-02T15:49:10Z
 baz   baz1        baz32022-08-02T15:49:10Z
 `

 out, err := cliui.DisplayTable(in, "", []string{"name", "sub_1_name", "sub_3 inner name", "time"})
diff --git a/cli/parameters.go b/cli/parameters.go
 // constructing curl requests.
 Hidden:  true,
 Aliases: []string{"params"},
 RunE: func(cmd *cobra.Command, args []string) error {
 return cmd.Help()
 },
 }
 cmd.AddCommand(
 parameterList(),
diff --git a/cli/resetpassword_test.go b/cli/resetpassword_test.go
 serverCmd, cfg := clitest.New(t,
 "server",
 "--address", ":0",
 "--access-url", "example.com",
 "--postgres-url", connectionURL,
 "--cache-dir", t.TempDir(),
 )
diff --git a/cli/root.go b/cli/root.go
 users(),
 versionCmd(),
 workspaceAgent(),
 tokens(),
 }
 }

diff --git a/cli/schedule.go b/cli/schedule.go
 Annotations: workspaceCommand,
 Use:         "schedule { show | start | stop | override } <workspace>",
 Short:       "Schedule automated start and stop times for workspaces",
 RunE: func(cmd *cobra.Command, args []string) error {
 return cmd.Help()
 },
 }

 scheduleCmd.AddCommand(
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,8 +4,6 @@ on:
		push:
		branches:
		- main
		tags:
		- "*"

		pull_request:

Expand DownExpand Up		@@ -36,7 +34,7 @@ jobs:
		- name: Checkout
		uses: actions/checkout@v2
		- name: typos-action
		uses: crate-ci/typos@master
		uses: crate-ci/typos@v1.12.8
		with:
		config: .github/workflows/typos.toml
		- name: Fix Helper
Expand DownExpand Up		@@ -630,7 +628,7 @@ jobs:
		with:
		name: failed-test-videos
		path: ./site/test-results/*/.webm
		retention:days: 7
		retention-days: 7

		chromatic:
		# REMARK: this is only used to build storybook and deploy it to Chromatic.
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -9,8 +9,8 @@
		"cliflag",
		"cliui",
		"codecov",
		"Codespaces",
		"coderd",
		"coderdenttest",
		"coderdtest",
		"codersdk",
		"cronstrue",
Expand All		@@ -24,6 +24,7 @@
		"drpcmux",
		"drpcserver",
		"Dsts",
		"enablements",
		"fatih",
		"Formik",
		"gitsshkey",
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -58,7 +58,7 @@ Once installed, you can start a production deployment<sup>1</sup> with a single

		```sh
		# Automatically sets up an external access URL on *.try.coder.app
		coder server --tunnel
		coder server

		# Requires a PostgreSQL instance and external access URL
		coder server --postgres-url <url> --access-url <url>
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -10,6 +10,7 @@ import (
		"fmt"
		"io"
		"net"
		"net/http"
		"net/netip"
		"os"
		"os/exec"
Expand DownExpand Up		@@ -206,6 +207,7 @@ func (a agent) runTailnet(ctx context.Context, derpMap tailcfg.DERPMap) {
		go a.sshServer.HandleConn(a.stats.wrapConn(conn))
		}
		}()

		reconnectingPTYListener, err := a.network.Listen("tcp", ":"+strconv.Itoa(codersdk.TailnetReconnectingPTYPort))
		if err != nil {
		a.logger.Critical(ctx, "listen for reconnecting pty", slog.Error(err))
Expand DownExpand Up		@@ -240,6 +242,7 @@ func (a agent) runTailnet(ctx context.Context, derpMap tailcfg.DERPMap) {
		go a.handleReconnectingPTY(ctx, msg, conn)
		}
		}()

		speedtestListener, err := a.network.Listen("tcp", ":"+strconv.Itoa(codersdk.TailnetSpeedtestPort))
		if err != nil {
		a.logger.Critical(ctx, "listen for speedtest", slog.Error(err))
Expand All		@@ -261,6 +264,31 @@ func (a agent) runTailnet(ctx context.Context, derpMap tailcfg.DERPMap) {
		}()
		}
		}()

		statisticsListener, err := a.network.Listen("tcp", ":"+strconv.Itoa(codersdk.TailnetStatisticsPort))
		if err != nil {
		a.logger.Critical(ctx, "listen for statistics", slog.Error(err))
		return
		}
		go func() {
		defer statisticsListener.Close()
		server := &http.Server{
		Handler: a.statisticsHandler(),
		ReadTimeout: 20 * time.Second,
		ReadHeaderTimeout: 20 * time.Second,
		WriteTimeout: 20 * time.Second,
		ErrorLog: slog.Stdlib(ctx, a.logger.Named("statistics_http_server"), slog.LevelInfo),
		}
		go func() {
		<-ctx.Done()
		_ = server.Close()
		}()

		err = server.Serve(statisticsListener)
		if err != nil && !xerrors.Is(err, http.ErrServerClosed) && !strings.Contains(err.Error(), "use of closed network connection") {
		a.logger.Critical(ctx, "serve statistics HTTP server", slog.Error(err))
		}
		}()
		}

		// runCoordinator listens for nodes and updates the self-node as it changes.
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,64 @@
		//go:build linux \|\| (windows && amd64)

		package agent

		import (
		"time"

		"github.com/cakturk/go-netstat/netstat"
		"golang.org/x/xerrors"

		"github.com/coder/coder/codersdk"
		)

		func (lp *listeningPortsHandler) getListeningPorts() ([]codersdk.ListeningPort, error) {
		lp.mut.Lock()
		defer lp.mut.Unlock()

		if time.Since(lp.mtime) < time.Second {
		// copy
		ports := make([]codersdk.ListeningPort, len(lp.ports))
		copy(ports, lp.ports)
		return ports, nil
		}

		tabs, err := netstat.TCPSocks(func(s *netstat.SockTabEntry) bool {
		return s.State == netstat.Listen
		})
		if err != nil {
		return nil, xerrors.Errorf("scan listening ports: %w", err)
		}

		seen := make(map[uint16]struct{}, len(tabs))
		ports := []codersdk.ListeningPort{}
		for _, tab := range tabs {
		if tab.LocalAddr == nil \|\| tab.LocalAddr.Port < uint16(codersdk.MinimumListeningPort) {
		continue
		}

		// Don't include ports that we've already seen. This can happen on
		// Windows, and maybe on Linux if you're using a shared listener socket.
		if _, ok := seen[tab.LocalAddr.Port]; ok {
		continue
		}
		seen[tab.LocalAddr.Port] = struct{}{}

		procName := ""
		if tab.Process != nil {
		procName = tab.Process.Name
		}
		ports = append(ports, codersdk.ListeningPort{
		ProcessName: procName,
		Network: codersdk.ListeningPortNetworkTCP,
		Port: tab.LocalAddr.Port,
		})
		}

		lp.ports = ports
		lp.mtime = time.Now()

		// copy
		ports = make([]codersdk.ListeningPort, len(lp.ports))
		copy(ports, lp.ports)
		return ports, nil
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,12 @@
		//go:build !linux && !(windows && amd64)

		package agent

		import "github.com/coder/coder/codersdk"

		func (lp *listeningPortsHandler) getListeningPorts() ([]codersdk.ListeningPort, error) {
		// Can't scan for ports on non-linux or non-windows_amd64 systems at the
		// moment. The UI will not show any "no ports found" message to the user, so
		// the user won't suspect a thing.
		return []codersdk.ListeningPort{}, nil
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,49 @@
		package agent

		import (
		"net/http"
		"sync"
		"time"

		"github.com/go-chi/chi"

		"github.com/coder/coder/coderd/httpapi"
		"github.com/coder/coder/codersdk"
		)

		func (*agent) statisticsHandler() http.Handler {
		r := chi.NewRouter()
		r.Get("/", func(rw http.ResponseWriter, r *http.Request) {
		httpapi.Write(r.Context(), rw, http.StatusOK, codersdk.Response{
		Message: "Hello from the agent!",
		})
		})

		lp := &listeningPortsHandler{}
		r.Get("/api/v0/listening-ports", lp.handler)

		return r
		}

		type listeningPortsHandler struct {
		mut sync.Mutex
		ports []codersdk.ListeningPort
		mtime time.Time
		}

		// handler returns a list of listening ports. This is tested by coderd's
		// TestWorkspaceAgentListeningPorts test.
		func (lp listeningPortsHandler) handler(rw http.ResponseWriter, r http.Request) {
		ports, err := lp.getListeningPorts()
		if err != nil {
		httpapi.Write(r.Context(), rw, http.StatusInternalServerError, codersdk.Response{
		Message: "Could not scan for listening ports.",
		Detail: err.Error(),
		})
		return
		}

		httpapi.Write(r.Context(), rw, http.StatusOK, codersdk.ListeningPortsResponse{
		Ports: ports,
		})
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -168,15 +168,15 @@ func workspaceAgent() *cobra.Command {
		}
		}

		ctx, cancelFunc := context.WithTimeout(cmd.Context(), time.Hour)
		defercancelFunc()
		for retry.New(100time.Millisecond, 5time.Second).Wait(ctx) {
		err := client.PostWorkspaceAgentVersion(cmd.Context(), version)
		retryCtx, cancelRetry := context.WithTimeout(cmd.Context(), time.Hour)
		defercancelRetry()
		forretrier :=retry.New(100time.Millisecond, 5time.Second); retrier.Wait(retryCtx); {
		err := client.PostWorkspaceAgentVersion(retryCtx, version)
		if err != nil {
		logger.Warn(cmd.Context(), "post agent version: %w", slog.Error(err), slog.F("version", version))
		logger.Warn(retryCtx, "post agent version: %w", slog.Error(err), slog.F("version", version))
		continue
		}
		logger.Info(ctx, "updated agent version", slog.F("version", version))
		logger.Info(retryCtx, "updated agent version", slog.F("version", version))
		break
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -153,10 +153,14 @@ func DisplayTable(out any, sort string, filterColumns []string) (string, error)
		// Special type formatting.
		switch val := v.(type) {
		case time.Time:
		v = val.Format(time.Stamp)
		v = val.Format(time.RFC3339)
		case *time.Time:
		if val != nil {
		v = val.Format(time.Stamp)
		v = val.Format(time.RFC3339)
		}
		case *int64:
		if val != nil {
		v = *val
		}
		case fmt.Stringer:
		if val != nil {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -131,10 +131,10 @@ func Test_DisplayTable(t *testing.T) {
		t.Parallel()

		expected := `
		NAME AGE ROLES SUB 1 NAME SUB 1 AGE SUB 2 NAME SUB 2 AGE SUB 3 INNER NAME SUB 3 INNER AGE SUB 4 TIME TIME PTR
		foo 10 [a b c] foo1 11 foo2 12 foo3 13 {foo4 14 }Aug 2 15:49:10 Aug 2 15:49:10
		bar 20 [a] bar1 21 <nil> <nil> bar3 23 {bar4 24 }Aug 2 15:49:10 <nil>
		baz 30 [] baz1 31 <nil> <nil> baz3 33 {baz4 34 }Aug 2 15:49:10 <nil>
		NAME AGE ROLES SUB 1 NAME SUB 1 AGE SUB 2 NAME SUB 2 AGE SUB 3 INNER NAME SUB 3 INNER AGE SUB 4 TIMETIME PTR
		foo 10 [a b c] foo1 11 foo2 12 foo3 13 {foo4 14 }2022-08-02T15:49:10Z 2022-08-02T15:49:10Z
		bar 20 [a] bar1 21 <nil> <nil> bar3 23 {bar4 24 }2022-08-02T15:49:10Z <nil>
		baz 30 [] baz1 31 <nil> <nil> baz3 33 {baz4 34 }2022-08-02T15:49:10Z <nil>
		`

		// Test with non-pointer values.
Expand All		@@ -158,10 +158,10 @@ baz 30 [] baz1 31 <nil> <nil> baz3
		t.Parallel()

		expected := `
		NAME AGE ROLES SUB 1 NAME SUB 1 AGE SUB 2 NAME SUB 2 AGE SUB 3 INNER NAME SUB 3 INNER AGE SUB 4 TIME TIME PTR
		bar 20 [a] bar1 21 <nil> <nil> bar3 23 {bar4 24 }Aug 2 15:49:10 <nil>
		baz 30 [] baz1 31 <nil> <nil> baz3 33 {baz4 34 }Aug 2 15:49:10 <nil>
		foo 10 [a b c] foo1 11 foo2 12 foo3 13 {foo4 14 }Aug 2 15:49:10 Aug 2 15:49:10
		NAME AGE ROLES SUB 1 NAME SUB 1 AGE SUB 2 NAME SUB 2 AGE SUB 3 INNER NAME SUB 3 INNER AGE SUB 4 TIMETIME PTR
		bar 20 [a] bar1 21 <nil> <nil> bar3 23 {bar4 24 }2022-08-02T15:49:10Z <nil>
		baz 30 [] baz1 31 <nil> <nil> baz3 33 {baz4 34 }2022-08-02T15:49:10Z <nil>
		foo 10 [a b c] foo1 11 foo2 12 foo3 13 {foo4 14 }2022-08-02T15:49:10Z 2022-08-02T15:49:10Z
		`

		out, err := cliui.DisplayTable(in, "name", nil)
Expand All		@@ -175,9 +175,9 @@ foo 10 [a b c] foo1 11 foo2 12 foo3

		expected := `
		NAME SUB 1 NAME SUB 3 INNER NAME TIME
		foo foo1 foo3Aug 2 15:49:10
		bar bar1 bar3Aug 2 15:49:10
		baz baz1 baz3Aug 2 15:49:10
		foo foo1 foo32022-08-02T15:49:10Z
		bar bar1 bar32022-08-02T15:49:10Z
		baz baz1 baz32022-08-02T15:49:10Z
		`

		out, err := cliui.DisplayTable(in, "", []string{"name", "sub_1_name", "sub_3 inner name", "time"})
Expand Down