Refactor the Sandbox package into Sandbox + Container.

This is a necessary prerequisite for supporting multiple containers in a single
sandbox.

All the commands (in cmd package) now call operations on Containers (container
package). When a Container first starts, it will create a Sandbox with the same
ID.

The Sandbox class is now simpler, as it only knows how to create boot/gofer
processes, and how to forward commands into the running boot process.

There are TODOs sprinkled around for additional support for multiple
containers. Most notably, we need to detect when a container is intended to run
in an existing sandbox (by reading the metadata), and then have some way to
signal to the sandbox to start a new container. Other urpc calls into the
sandbox need to pass the container ID, so the sandbox can run the operation on
the given container. These are only half-plummed through right now.

PiperOrigin-RevId: 196688269
Change-Id: I1ecf4abbb9dd8987a53ae509df19341aaf42b5b0

1 files changed, 17 insertions, 17 deletions

diff --git a/runsc/cmd/list.go b/runsc/cmd/list.go
index bf7cb41bb..d554bf7cf 100644
--- a/runsc/cmd/list.go
+++ b/runsc/cmd/list.go
@@ -26,7 +26,7 @@ import (
 	"github.com/google/subcommands"
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 	"gvisor.googlesource.com/gvisor/runsc/boot"
-	"gvisor.googlesource.com/gvisor/runsc/sandbox"
+	"gvisor.googlesource.com/gvisor/runsc/container"
 )
 
 // List implements subcommands.Command for the "list" command for the "list" command.
@@ -64,7 +64,7 @@ func (l *List) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 	}
 
 	conf := args[0].(*boot.Config)
-	ids, err := sandbox.List(conf.RootDir)
+	ids, err := container.List(conf.RootDir)
 	if err != nil {
 		Fatalf("%v", err)
 	}
@@ -76,14 +76,14 @@ func (l *List) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 		return subcommands.ExitSuccess
 	}
 
-	// Collect the sandboxes.
-	var sandboxes []*sandbox.Sandbox
+	// Collect the containers.
+	var containers []*container.Container
 	for _, id := range ids {
-		s, err := sandbox.Load(conf.RootDir, id)
+		c, err := container.Load(conf.RootDir, id)
 		if err != nil {
-			Fatalf("error loading sandbox %q: %v", id, err)
+			Fatalf("error loading container %q: %v", id, err)
 		}
-		sandboxes = append(sandboxes, s)
+		containers = append(containers, c)
 	}
 
 	switch l.format {
@@ -91,24 +91,24 @@ func (l *List) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 		// Print a nice table.
 		w := tabwriter.NewWriter(os.Stdout, 12, 1, 3, ' ', 0)
 		fmt.Fprint(w, "ID\tPID\tSTATUS\tBUNDLE\tCREATED\tOWNER\n")
-		for _, s := range sandboxes {
+		for _, c := range containers {
 			fmt.Fprintf(w, "%s\t%d\t%s\t%s\t%s\t%s\n",
-				s.ID,
-				s.Pid,
-				s.Status,
-				s.BundleDir,
-				s.CreatedAt.Format(time.RFC3339Nano),
-				s.Owner)
+				c.ID,
+				c.Pid(),
+				c.Status,
+				c.BundleDir,
+				c.CreatedAt.Format(time.RFC3339Nano),
+				c.Owner)
 		}
 		w.Flush()
 	case "json":
 		// Print just the states.
 		var states []specs.State
-		for _, s := range sandboxes {
-			states = append(states, s.State())
+		for _, c := range containers {
+			states = append(states, c.State())
 		}
 		if err := json.NewEncoder(os.Stdout).Encode(states); err != nil {
-			Fatalf("error marshaling sandbox state: %v", err)
+			Fatalf("error marshaling container state: %v", err)
 		}
 	default:
 		Fatalf("unknown list format %q", l.format)