hostagent: Add GET /v1/driver/config, PATCH /v1/driver/config APIs to ha.sock

- pkg/driver: Add `Driver.RuntimeConfig`
- pkg/hostagent/api/client: Add `HostAgentClient.DriverConfig`
- pkg/hostagent/api/server: Add `Backend.DriverConfig`
- pkg/hostagent: Add `HostAgent.DriverRuntimeConfig`
- pkg/vz: Add `LimaVzDriver.RuntimeConfig`
- pkg/instance: Add `saveOnStop` parameter to `StopGracefully`

Signed-off-by: Norio Nomura <[email protected]>

Author: norio-nomura

cmd/limactl/stop.go

@@ -39,7 +39,7 @@ func stopAction(cmd *cobra.Command, args []string) error {
 	if force {
 		instance.StopForcibly(inst)
 	} else {
-		err = instance.StopGracefully(inst)
+		err = instance.StopGracefully(inst, false)
 	}
 	// TODO: should we also reconcile networks if graceful stop returned an error?
 	if err == nil {

pkg/driver/driver.go

@@ -68,6 +68,9 @@ type Driver interface {
 
 	// GuestAgentConn returns the guest agent connection, or nil (if forwarded by ssh).
 	GuestAgentConn(_ context.Context) (net.Conn, error)
+
+	// RuntimeConfig accepts config containing changes to the runtime configuration, and returns the updated runtime configuration.
+	RuntimeConfig(_ context.Context, config interface{}) (interface{}, error)
 }
 
 type BaseDriver struct {
@@ -149,3 +152,7 @@ func (d *BaseDriver) GuestAgentConn(_ context.Context) (net.Conn, error) {
 	// use the unix socket forwarded by host agent
 	return nil, nil
 }
+
+func (d *BaseDriver) RuntimeConfig(_ context.Context, _ interface{}) (interface{}, error) {
+	return nil, fmt.Errorf("unimplemented")
+}

pkg/hostagent/api/client/client.go

@@ -4,9 +4,11 @@ package client
 // Apache License 2.0
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 
 	"github.com/lima-vm/lima/pkg/hostagent/api"
@@ -16,6 +18,7 @@ import (
 type HostAgentClient interface {
 	HTTPClient() *http.Client
 	Info(context.Context) (*api.Info, error)
+	DriverConfig(context.Context, interface{}) (interface{}, error)
 }
 
 // NewHostAgentClient creates a client.
@@ -62,3 +65,35 @@ func (c *client) Info(ctx context.Context) (*api.Info, error) {
 	}
 	return &info, nil
 }
+
+func (c *client) DriverConfig(ctx context.Context, config interface{}) (interface{}, error) {
+	u := fmt.Sprintf("http://%s/%s/driver/config", c.dummyHost, c.version)
+	method := "GET"
+	var body io.Reader
+	if config != nil {
+		method = "PATCH"
+		b, err := json.Marshal(config)
+		if err != nil {
+			return nil, err
+		}
+		body = bytes.NewBuffer(b)
+	}
+	req, err := http.NewRequestWithContext(ctx, method, u, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := c.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if err := httpclientutil.Successful(resp); err != nil {
+		return nil, err
+	}
+	dec := json.NewDecoder(resp.Body)
+	if err := dec.Decode(&config); err != nil {
+		return nil, err
+	}
+	return &config, nil
+}

pkg/hostagent/api/server/server.go

@@ -50,6 +50,36 @@ func (b *Backend) GetInfo(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write(m)
 }
 
+// DriverConfig is the handler for GET /v1/driver/config and PATCH /v1/driver/config.
+func (b *Backend) DriverConfig(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	var config interface{}
+	if r.Method == http.MethodPatch {
+		defer r.Body.Close()
+		if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
+			b.onError(w, err, http.StatusBadRequest)
+			return
+		}
+	}
+	config, err := b.Agent.DriverRuntimeConfig(ctx, config)
+	if err != nil {
+		b.onError(w, err, http.StatusInternalServerError)
+		return
+	}
+	m, err := json.Marshal(config)
+	if err != nil {
+		b.onError(w, err, http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(m)
+}
+
 func AddRoutes(r *http.ServeMux, b *Backend) {
 	r.Handle("/v1/info", http.HandlerFunc(b.GetInfo))
+	r.Handle("GET /v1/driver/config", http.HandlerFunc(b.DriverConfig))
+	r.Handle("PATCH /v1/driver/config", http.HandlerFunc(b.DriverConfig))
 }

pkg/hostagent/hostagent.go

@@ -423,6 +423,10 @@ func (a *HostAgent) Info(_ context.Context) (*hostagentapi.Info, error) {
 	return info, nil
 }
 
+func (a *HostAgent) DriverRuntimeConfig(ctx context.Context, config interface{}) (interface{}, error) {
+	return a.driver.RuntimeConfig(ctx, config)
+}
+
 func (a *HostAgent) startHostAgentRoutines(ctx context.Context) error {
 	if *a.instConfig.Plain {
 		logrus.Info("Running in plain mode. Mounts, port forwarding, containerd, etc. will be ignored. Guest agent will not be running.")

pkg/instance/stop.go

@@ -9,19 +9,43 @@ import (
 	"strings"
 	"time"
 
+	hostagentclient "github.com/lima-vm/lima/pkg/hostagent/api/client"
 	hostagentevents "github.com/lima-vm/lima/pkg/hostagent/events"
+	"github.com/lima-vm/lima/pkg/limayaml"
 	"github.com/lima-vm/lima/pkg/osutil"
 	"github.com/lima-vm/lima/pkg/store"
 	"github.com/lima-vm/lima/pkg/store/filenames"
 	"github.com/sirupsen/logrus"
 )
 
-func StopGracefully(inst *store.Instance) error {
-	// TODO: support store.StatusSuspended
-	if inst.Status != store.StatusRunning {
+func StopGracefully(inst *store.Instance, saveOnStop bool) error {
+	if inst.Status == store.StatusSaved {
+		if saveOnStop {
+			return fmt.Errorf("Instance %q is already saved", inst.Name)
+		}
+		return fmt.Errorf("Instance %q is saved. To stop, run `limactl start %s && limactl stop %s`", inst.Name, inst.Name, inst.Name)
+	} else if inst.Status != store.StatusRunning {
 		return fmt.Errorf("expected status %q, got %q (maybe use `limactl stop -f`?)", store.StatusRunning, inst.Status)
 	}
 
+	if inst.VMType == limayaml.VZ {
+		haSock := filepath.Join(inst.Dir, filenames.HostAgentSock)
+		haClient, err := hostagentclient.NewHostAgentClient(haSock)
+		if err != nil {
+			logrus.WithError(err).Error("Failed to create a host agent client")
+		}
+		ctx, cancel := context.WithTimeout(context.TODO(), 3*time.Second)
+		defer cancel()
+		disableSaveOnStopConfig := struct {
+			SaveOnStop bool `json:"saveOnStop"`
+		}{SaveOnStop: saveOnStop}
+		_, err = haClient.DriverConfig(ctx, disableSaveOnStopConfig)
+		if err != nil {
+			return fmt.Errorf("failed to disable saveOnStop: %w", err)
+		}
+	} else if saveOnStop {
+		return fmt.Errorf("save is not supported for %q", inst.VMType)
+	}
 	begin := time.Now() // used for logrus propagation
 	logrus.Infof("Sending SIGINT to hostagent process %d", inst.HostAgentPID)
 	if err := osutil.SysKill(inst.HostAgentPID, osutil.SigInt); err != nil {

pkg/vz/vz_driver_darwin.go

@@ -8,14 +8,17 @@ import (
 	"fmt"
 	"net"
 	"path/filepath"
+	"runtime"
 	"time"
 
 	"github.com/Code-Hex/vz/v3"
+	"github.com/mitchellh/mapstructure"
 
 	"github.com/sirupsen/logrus"
 
 	"github.com/lima-vm/lima/pkg/driver"
 	"github.com/lima-vm/lima/pkg/limayaml"
+	"github.com/lima-vm/lima/pkg/osutil"
 	"github.com/lima-vm/lima/pkg/reflectutil"
 	"github.com/lima-vm/lima/pkg/store/filenames"
 )
@@ -204,6 +207,34 @@ func (l *LimaVzDriver) RunGUI() error {
 	return fmt.Errorf("RunGUI is not supported for the given driver '%s' and display '%s'", "vz", *l.Instance.Config.Video.Display)
 }
 
+func (l *LimaVzDriver) RuntimeConfig(_ context.Context, config interface{}) (interface{}, error) {
+	if config == nil {
+		return l.config, nil
+	}
+	var newConfig LimaVzDriverRuntimeConfig
+	err := mapstructure.Decode(config, &newConfig)
+	if err != nil {
+		return nil, err
+	}
+	if newConfig.SaveOnStop {
+		if runtime.GOARCH != "arm64" {
+			return nil, fmt.Errorf("saveOnStop is not supported on %s", runtime.GOARCH)
+		} else if runtime.GOOS != "darwin" {
+			return nil, fmt.Errorf("saveOnStop is not supported on %s", runtime.GOOS)
+		} else if macOSProductVersion, err := osutil.ProductVersion(); err != nil {
+			return nil, fmt.Errorf("failed to get macOS product version: %w", err)
+		} else if macOSProductVersion.Major < 14 {
+			return nil, fmt.Errorf("saveOnStop is not supported on macOS %d", macOSProductVersion.Major)
+		}
+		logrus.Info("VZ RuntimeConfiguration changed: SaveOnStop is enabled")
+		l.config.SaveOnStop = true
+	} else {
+		logrus.Info("VZ RuntimeConfiguration changed: SaveOnStop is disabled")
+		l.config.SaveOnStop = false
+	}
+	return l.config, nil
+}
+
 func (l *LimaVzDriver) Stop(_ context.Context) error {
 	if l.config.SaveOnStop {
 		machineStatePath := filepath.Join(l.Instance.Dir, filenames.VzMachineState)