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".

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

Author: afbjorklund

README.md

@@ -215,6 +215,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

@@ -93,6 +93,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)
+}

pkg/driver/driver.go

@@ -7,6 +7,11 @@ import (
 	"github.com/lima-vm/lima/pkg/store"
 )
 
+type BaseStatus struct {
+	Paused  bool
+	Running bool
+}
+
 type Driver interface {
 	Validate() error
 
@@ -15,6 +20,8 @@ type Driver interface {
 	Start(_ context.Context) (chan error, error)
 
 	Stop(_ context.Context) error
+
+	QueryStatus(_ context.Context) (*BaseStatus, error)
 }
 
 type BaseDriver struct {
@@ -39,3 +46,7 @@ func (d *BaseDriver) Start(_ context.Context) (chan error, error) {
 func (d *BaseDriver) Stop(_ context.Context) error {
 	return nil
 }
+
+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

@@ -305,6 +305,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,55 @@
+package pause
+
+import (
+	"context"
+
+	"github.com/lima-vm/lima/pkg/limayaml"
+	"github.com/lima-vm/lima/pkg/qemu"
+	"github.com/lima-vm/lima/pkg/store"
+)
+
+func stop(ctx context.Context, instName, instDir string, y *limayaml.LimaYAML) error {
+	qCfg := qemu.Config{
+		Name:        instName,
+		InstanceDir: instDir,
+		LimaYAML:    y,
+	}
+	return qemu.Stop(qCfg)
+}
+
+func Suspend(ctx context.Context, inst *store.Instance) error {
+	y, err := inst.LoadYAML()
+	if err != nil {
+		return err
+	}
+
+	if err := stop(ctx, inst.Name, inst.Dir, y); err != nil {
+		return err
+	}
+
+	inst.Status = store.StatusPaused
+	return nil
+}
+
+func cont(ctx context.Context, instName, instDir string, y *limayaml.LimaYAML) error {
+	qCfg := qemu.Config{
+		Name:        instName,
+		InstanceDir: instDir,
+		LimaYAML:    y,
+	}
+	return qemu.Cont(qCfg)
+}
+
+func Resume(ctx context.Context, inst *store.Instance) error {
+	y, err := inst.LoadYAML()
+	if err != nil {
+		return err
+	}
+
+	if err := cont(ctx, inst.Name, inst.Dir, y); err != nil {
+		return err
+	}
+
+	inst.Status = store.StatusRunning
+	return nil
+}

pkg/qemu/qemu_driver.go

@@ -154,6 +154,83 @@ func logPipeRoutine(r io.Reader, header string) {
 		logrus.Debugf("%s: %s", header, line)
 	}
 }
+func newQmpClient(cfg Config) (*qmp.SocketMonitor, error) {
+	qmpSock := filepath.Join(cfg.InstanceDir, filenames.QMPSock)
+	qmpClient, err := qmp.NewSocketMonitor("unix", qmpSock, 5*time.Second)
+	if err != nil {
+		return nil, err
+	}
+	return qmpClient, nil
+}
+
+func Stop(cfg Config) error {
+	qmpClient, err := newQmpClient(cfg)
+	if err != nil {
+		return err
+	}
+	if err := qmpClient.Connect(); err != nil {
+		return err
+	}
+	defer func() { _ = qmpClient.Disconnect() }()
+	rawClient := raw.NewMonitor(qmpClient)
+	logrus.Info("Sending QMP stop command")
+	return rawClient.Stop()
+}
+
+func Cont(cfg Config) error {
+	qmpClient, err := newQmpClient(cfg)
+	if err != nil {
+		return err
+	}
+	if err := qmpClient.Connect(); err != nil {
+		return err
+	}
+	defer func() { _ = qmpClient.Disconnect() }()
+	rawClient := raw.NewMonitor(qmpClient)
+	logrus.Info("Sending QMP cont command")
+	return rawClient.Cont()
+}
+
+func (l *LimaQemuDriver) QueryStatus(ctx context.Context) (*driver.BaseStatus, error) {
+	qCfg := Config{
+		Name:         l.Instance.Name,
+		InstanceDir:  l.Instance.Dir,
+		LimaYAML:     l.Yaml,
+		SSHLocalPort: l.SSHLocalPort,
+	}
+	status, err := queryStatus(qCfg)
+	return &driver.BaseStatus{Paused: IsPaused(status), Running: IsRunning(status)}, err
+}
+
+type statusInfo struct {
+	raw.StatusInfo
+}
+
+func queryStatus(cfg Config) (*statusInfo, error) {
+	qmpClient, err := newQmpClient(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := qmpClient.Connect(); err != nil {
+		return nil, err
+	}
+	defer func() { _ = qmpClient.Disconnect() }()
+	rawClient := raw.NewMonitor(qmpClient)
+	logrus.Debug("Sending QMP query-status command")
+	status, err := rawClient.QueryStatus()
+	if err != nil {
+		return nil, err
+	}
+	return &statusInfo{status}, nil
+}
+
+func IsPaused(info *statusInfo) bool {
+	return info.Status == raw.RunStatePaused
+}
+
+func IsRunning(info *statusInfo) bool {
+	return info.Status == raw.RunStateRunning
+}
 
 type qArgTemplateApplier struct {
 	files []*os.File