Implement the suspend and resume commands

For halting the emulation and putting the VM into paused run state.

Also query the status of running instances, when showing in "list".

* Use the new driver framework for pause

* Add integration test for suspend/resume

Signed-off-by: Anders F Björklund <anders.f.bjorklund@gmail.com>

Author: afbjorklund

README.md

@@ -213,6 +213,12 @@ Use `<INSTANCE>:<FILENAME>` to specify a source or target inside an instance.
 #### `limactl stop`
 `limactl stop [--force] <INSTANCE>`: stop the instance
 
+#### `limactl suspend`
+`limactl suspend <INSTANCE>`: pause the instance
+
+#### `limactl resume`
+`limactl resume <INSTANCE>`: unpause the instance
+
 #### `limactl delete`
 `limactl delete [--force] <INSTANCE>`: delete the instance
 

cmd/limactl/main.go

@@ -100,6 +100,8 @@ func newApp() *cobra.Command {
 		newEditCommand(),
 		newFactoryResetCommand(),
 		newDiskCommand(),
+		newSuspendCommand(),
+		newResumeCommand(),
 	)
 	return rootCmd
 }

cmd/limactl/resume.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/lima-vm/lima/pkg/pause"
+	"github.com/lima-vm/lima/pkg/store"
+
+	"github.com/spf13/cobra"
+)
+
+func newResumeCommand() *cobra.Command {
+	var resumeCmd = &cobra.Command{
+		Use:               "resume INSTANCE",
+		Short:             "Resume (unpause) an instance",
+		Aliases:           []string{"unpause"},
+		Args:              cobra.MaximumNArgs(1),
+		RunE:              resumeAction,
+		ValidArgsFunction: resumeBashComplete,
+	}
+
+	return resumeCmd
+}
+
+func resumeAction(cmd *cobra.Command, args []string) error {
+	instName := DefaultInstanceName
+	if len(args) > 0 {
+		instName = args[0]
+	}
+
+	inst, err := store.Inspect(instName)
+	if err != nil {
+		return err
+	}
+
+	if inst.Status != store.StatusPaused {
+		return fmt.Errorf("expected status %q, got %q", store.StatusPaused, inst.Status)
+	}
+
+	ctx := cmd.Context()
+	return pause.Resume(ctx, inst)
+}
+
+func resumeBashComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return bashCompleteInstanceNames(cmd)
+}

cmd/limactl/suspend.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/lima-vm/lima/pkg/pause"
+	"github.com/lima-vm/lima/pkg/store"
+
+	"github.com/spf13/cobra"
+)
+
+func newSuspendCommand() *cobra.Command {
+	var suspendCmd = &cobra.Command{
+		Use:               "suspend INSTANCE",
+		Short:             "Suspend (pause) an instance",
+		Aliases:           []string{"pause"},
+		Args:              cobra.MaximumNArgs(1),
+		RunE:              suspendAction,
+		ValidArgsFunction: suspendBashComplete,
+	}
+
+	return suspendCmd
+}
+
+func suspendAction(cmd *cobra.Command, args []string) error {
+	instName := DefaultInstanceName
+	if len(args) > 0 {
+		instName = args[0]
+	}
+
+	inst, err := store.Inspect(instName)
+	if err != nil {
+		return err
+	}
+
+	if inst.Status != store.StatusRunning {
+		return fmt.Errorf("expected status %q, got %q", store.StatusRunning, inst.Status)
+	}
+
+	ctx := cmd.Context()
+	return pause.Suspend(ctx, inst)
+}
+
+func suspendBashComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return bashCompleteInstanceNames(cmd)
+}

hack/test-example.sh

@@ -21,6 +21,7 @@ declare -A CHECKS=(
 	["systemd-strict"]="1"
 	["mount-home"]="1"
 	["containerd-user"]="1"
+	["pause"]="1"
 	["restart"]="1"
 	["port-forwards"]="1"
 	["vmnet"]=""
@@ -263,6 +264,28 @@ if [[ -n ${CHECKS["disk"]} ]]; then
 	set +x
 fi
 
+if [[ -n ${CHECKS["pause"]} ]]; then
+	INFO "Suspending \"$NAME\""
+	limactl suspend "$NAME"
+
+	got=$(limactl ls --format '{{.Status}}' "$NAME")
+	expected="Paused"
+	if [ "$got" != "$expected" ]; then
+		ERROR "suspend status: expected=${expected} got=${got}"
+		exit 1
+	fi
+
+	INFO "Resuming \"$NAME\""
+	limactl resume "$NAME"
+
+	got=$(limactl ls --format '{{.Status}}' "$NAME")
+	expected="Running"
+	if [ "$got" != "$expected" ]; then
+		ERROR "resume status: expected=${expected} got=${got}"
+		exit 1
+	fi
+fi
+
 if [[ -n ${CHECKS["restart"]} ]]; then
 	INFO "Create file in the guest home directory and verify that it still exists after a restart"
 	# shellcheck disable=SC2016

pkg/driver/driver.go

@@ -2,11 +2,17 @@ package driver
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/lima-vm/lima/pkg/limayaml"
 	"github.com/lima-vm/lima/pkg/store"
 )
 
+type BaseStatus struct {
+	Paused  bool
+	Running bool
+}
+
 type Driver interface {
 	Validate() error
 
@@ -19,6 +25,12 @@ type Driver interface {
 	ChangeDisplayPassword(_ context.Context, password string) error
 
 	GetDisplayConnection(_ context.Context) (string, error)
+
+	Suspend(_ context.Context) error
+
+	Resume(_ context.Context) error
+
+	QueryStatus(_ context.Context) (*BaseStatus, error)
 }
 
 type BaseDriver struct {
@@ -51,3 +63,15 @@ func (d *BaseDriver) ChangeDisplayPassword(_ context.Context, password string) e
 func (d *BaseDriver) GetDisplayConnection(_ context.Context) (string, error) {
 	return "", nil
 }
+
+func (d *BaseDriver) Suspend(_ context.Context) error {
+	return fmt.Errorf("unimplemented")
+}
+
+func (d *BaseDriver) Resume(_ context.Context) error {
+	return fmt.Errorf("unimplemented")
+}
+
+func (d *BaseDriver) QueryStatus(_ context.Context) (*BaseStatus, error) {
+	return &BaseStatus{Paused: false, Running: true}, nil
+}

pkg/hostagent/api/api.go

@@ -3,3 +3,8 @@ package api
 type Info struct {
 	SSHLocalPort int `json:"sshLocalPort,omitempty"`
 }
+
+type Status struct {
+	Running bool `json:"running"`
+	Paused  bool `json:"paused"`
+}

pkg/hostagent/api/client/client.go

@@ -16,6 +16,7 @@ import (
 type HostAgentClient interface {
 	HTTPClient() *http.Client
 	Info(context.Context) (*api.Info, error)
+	Status(context.Context) (*api.Status, error)
 }
 
 // NewHostAgentClient creates a client.
@@ -62,3 +63,18 @@ func (c *client) Info(ctx context.Context) (*api.Info, error) {
 	}
 	return &info, nil
 }
+
+func (c *client) Status(ctx context.Context) (*api.Status, error) {
+	u := fmt.Sprintf("http://%s/%s/status", c.dummyHost, c.version)
+	resp, err := httpclientutil.Get(ctx, c.HTTPClient(), u)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	var status api.Status
+	dec := json.NewDecoder(resp.Body)
+	if err := dec.Decode(&status); err != nil {
+		return nil, err
+	}
+	return &status, nil
+}

pkg/hostagent/api/server/server.go

@@ -46,7 +46,29 @@ func (b *Backend) GetInfo(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write(m)
 }
 
+// GetStatus is the handler for GET /v{N}/status
+func (b *Backend) GetStatus(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	status, err := b.Agent.Status(ctx)
+	if err != nil {
+		b.onError(w, r, err, http.StatusInternalServerError)
+		return
+	}
+	m, err := json.Marshal(status)
+	if err != nil {
+		b.onError(w, r, err, http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(m)
+}
+
 func AddRoutes(r *mux.Router, b *Backend) {
 	v1 := r.PathPrefix("/v1").Subrouter()
 	v1.Path("/info").Methods("GET").HandlerFunc(b.GetInfo)
+	v1.Path("/status").Methods("GET").HandlerFunc(b.GetStatus)
 }

pkg/hostagent/hostagent.go

@@ -381,6 +381,18 @@ func (a *HostAgent) Info(_ context.Context) (*hostagentapi.Info, error) {
 	return info, nil
 }
 
+func (a *HostAgent) Status(ctx context.Context) (*hostagentapi.Status, error) {
+	driverStatus, err := a.driver.QueryStatus(ctx)
+	if err != nil {
+		return nil, err
+	}
+	status := &hostagentapi.Status{
+		Running: driverStatus.Running,
+		Paused:  driverStatus.Paused,
+	}
+	return status, nil
+}
+
 func (a *HostAgent) startHostAgentRoutines(ctx context.Context) error {
 	a.onClose = append(a.onClose, func() error {
 		logrus.Debugf("shutting down the SSH master")

pkg/pause/pause.go

@@ -0,0 +1,47 @@
+package pause
+
+import (
+	"context"
+
+	"github.com/lima-vm/lima/pkg/driver"
+	"github.com/lima-vm/lima/pkg/driverutil"
+	"github.com/lima-vm/lima/pkg/store"
+)
+
+func Suspend(ctx context.Context, inst *store.Instance) error {
+	y, err := inst.LoadYAML()
+	if err != nil {
+		return err
+	}
+
+	limaDriver := driverutil.CreateTargetDriverInstance(&driver.BaseDriver{
+		Instance: inst,
+		Yaml:     y,
+	})
+
+	if err := limaDriver.Suspend(ctx); err != nil {
+		return err
+	}
+
+	inst.Status = store.StatusPaused
+	return nil
+}
+
+func Resume(ctx context.Context, inst *store.Instance) error {
+	y, err := inst.LoadYAML()
+	if err != nil {
+		return err
+	}
+
+	limaDriver := driverutil.CreateTargetDriverInstance(&driver.BaseDriver{
+		Instance: inst,
+		Yaml:     y,
+	})
+
+	if err := limaDriver.Resume(ctx); err != nil {
+		return err
+	}
+
+	inst.Status = store.StatusRunning
+	return nil
+}