goal: remove dependency on saved machine state

Author: nyiyui

cmd/device-client/main.go

@@ -4,15 +4,10 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"encoding/json"
-	"errors"
 	"flag"
-	"fmt"
-	"io/fs"
 	"net/http"
 	"net/rpc"
 	"os"
-	"path/filepath"
-	"sync"
 	"time"
 
 	"github.com/nyiyui/qrystal/device"
@@ -42,40 +37,6 @@ type ClientConfig struct {
 	transport       *http.Transport
 }
 
-type MachineData struct {
-	Machines     map[string]goal.Machine
-	machinesLock sync.RWMutex
-	path         string
-}
-
-func LoadMachineData(path string) (*MachineData, error) {
-	var m MachineData
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("reading failed: %w", err)
-	}
-	err = json.Unmarshal(data, &m)
-	if err != nil {
-		return nil, fmt.Errorf("parsing failed: %w", err)
-	}
-	m.path = path
-	return &m, nil
-}
-
-func (m *MachineData) setMachine(clientName string, gm goal.Machine) {
-	m.machinesLock.Lock()
-	defer m.machinesLock.Unlock()
-	m.Machines[clientName] = gm
-	data, err := json.Marshal(m)
-	if err != nil {
-		panic(err)
-	}
-	err = os.WriteFile(m.path, data, 0600)
-	if err != nil {
-		zap.S().Errorf("saving machine data failed: %s. Updating WireGuard interfaces may fail.", err)
-	}
-}
-
 func main() {
 	util.SetupLog()
 
@@ -183,23 +144,10 @@ func main() {
 		dnsClient = dns.NewDirectClient(s)
 	}
 
-	path := filepath.Join(os.Getenv("STATE_DIRECTORY"), "MachineData.json")
-	m, err := LoadMachineData(path)
-	if err != nil {
-		zap.S().Debugf("IsNotExist=%t", os.IsNotExist(err))
-		if errors.Is(err, fs.ErrNotExist) {
-			zap.S().Info("no machine data found. Creating a blank one…")
-			m = new(MachineData)
-			m.Machines = map[string]goal.Machine{}
-			m.path = path
-		} else {
-			zap.S().Fatalf("loading machine data failed: %s", err)
-		}
-	}
-	createGoroutines(m, dnsClient, config)
+	createGoroutines(dnsClient, config)
 }
 
-func createGoroutines(m *MachineData, dnsClient dns.Client, config Config) {
+func createGoroutines(dnsClient dns.Client, config Config) {
 	util.Notify("READY=1\nSTATUS=starting…")
 	for clientName, cc := range config.Clients {
 		go func(clientName string, cc ClientConfig) {
@@ -212,7 +160,6 @@ func createGoroutines(m *MachineData, dnsClient dns.Client, config Config) {
 			}
 			c.SetCanForward(config.CanForward)
 			c.SetAssumeProc(config.AssumeProc)
-			c.Machine = m.Machines[clientName]
 			c.SetDNSClient(dnsClient)
 			continuous := new(device.ContinousClient)
 			continuous.Client = c
@@ -229,9 +176,6 @@ func createGoroutines(m *MachineData, dnsClient dns.Client, config Config) {
 						zap.S().Errorf("%s: %s", clientName, err)
 						break
 					}
-					if updated {
-						m.setMachine(clientName, c.Machine)
-					}
 					if !latest {
 						if updated {
 							zap.S().Infof("%s: updated but not latest; trying again…", clientName)

cmd/test-device/main.go

@@ -12,8 +12,6 @@ import (
 )
 
 type Config struct {
-	MachineJSONPath string
-
 	BaseURL    string
 	Token      util.Token
 	Network    string
@@ -44,19 +42,6 @@ func main() {
 	}
 	zap.S().Info("created client.")
 
-	machineData, err := os.ReadFile(config.MachineJSONPath)
-	if err != nil {
-		panic(err)
-	}
-	err = json.Unmarshal(machineData, &c.Machine)
-	if err != nil {
-		panic(err)
-	}
-	data, err := json.MarshalIndent(c.Machine, "", "  ")
-	if err != nil {
-		panic(err)
-	}
-	zap.S().Infof("parsed machine data:\n%s", data)
 	latest, err := c.ReifySpec()
 	if err != nil {
 		panic(err)
@@ -65,13 +50,4 @@ func main() {
 		panic("posted but already not latest")
 	}
 	zap.S().Info("reified spec.")
-	machineData, err = json.Marshal(c.Machine)
-	if err != nil {
-		panic(err)
-	}
-	err = os.WriteFile(config.MachineJSONPath, machineData, 0600)
-	if err != nil {
-		panic(err)
-	}
-	zap.S().Infof("saved machine data:\n%s", machineData)
 }

cmd/test-goal/main.go

@@ -9,60 +9,35 @@ import (
 
 	"github.com/nyiyui/qrystal/goal"
 	"github.com/nyiyui/qrystal/util"
-	"github.com/vishvananda/netlink"
 	"go.uber.org/zap"
-	"golang.zx2c4.com/wireguard/wgctrl"
 )
 
-var aMachine string
-var bMachine string
+var mPath string
 
 func main() {
 	util.SetupLog()
 
-	flag.StringVar(&aMachine, "a-path", "", "path to starting state")
-	flag.StringVar(&bMachine, "b-path", "", "path to goal state")
+	flag.StringVar(&mPath, "m-path", "", "path to goal state")
 	flag.Parse()
 
 	zap.S().Info("parsing machine data…")
-	aMachineData, err := os.ReadFile(aMachine)
-	if err != nil {
-		panic(err)
-	}
-	bMachineData, err := os.ReadFile(bMachine)
+	raw, err := os.ReadFile(mPath)
 	if err != nil {
 		panic(err)
 	}
 
-	var a goal.Machine
-	var b goal.Machine
-	err = json.Unmarshal(aMachineData, &a)
-	if err != nil {
-		panic(err)
-	}
-	err = json.Unmarshal(bMachineData, &b)
+	var m goal.Machine
+	err = json.Unmarshal(raw, &m)
 	if err != nil {
 		panic(err)
 	}
 	zap.S().Info("done parsing machine data.")
 
-	md := goal.DiffMachine(&a, &b)
-	zap.S().Info("generated diff.")
-	data, err := json.MarshalIndent(md, "  ", "  ")
+	applier, err := goal.NewApplier(goal.ApplierOptions{})
 	if err != nil {
 		panic(err)
 	}
-	zap.S().Infof("machine diff:\n%s\n", data)
-	client, err := wgctrl.New()
-	if err != nil {
-		panic(err)
-	}
-	handle, err := netlink.NewHandle()
-	if err != nil {
-		panic(err)
-	}
-
-	err = goal.ApplyMachineDiff(a, b, md, client, handle, true)
+	err = applier.ApplyMachine(m)
 	if err != nil {
 		panic(err)
 	}

device/client.go

@@ -18,20 +18,16 @@ import (
 	"github.com/nyiyui/qrystal/spec"
 	"github.com/nyiyui/qrystal/util"
 	"go.uber.org/zap"
-	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
 type Client struct {
 	client     *http.Client
 	baseURL    *url.URL
-	Machine    goal.Machine
-	wgClient   *wgctrl.Client
-	goalHandle *goal.Handle
+	applier    *goal.Applier
 	dns        dns.Client
 	dnsLock    sync.Mutex
 	canForward bool
-	assumeProc bool
 
 	spec       spec.SpecCensored
 	token      util.Token
@@ -45,11 +41,7 @@ func NewClient(httpClient *http.Client, baseURL string, token util.Token, networ
 	if err != nil {
 		return nil, err
 	}
-	wgClient, err := wgctrl.New()
-	if err != nil {
-		return nil, err
-	}
-	goalHandle, err := goal.NewHandle()
+	applier, err := goal.NewApplier(goal.ApplierOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -59,8 +51,7 @@ func NewClient(httpClient *http.Client, baseURL string, token util.Token, networ
 	return &Client{
 		client:     httpClient,
 		baseURL:    baseURL2,
-		wgClient:   wgClient,
-		goalHandle: goalHandle,
+		applier:    applier,
 		token:      token,
 		network:    network,
 		device:     device,
@@ -72,8 +63,13 @@ func (c *Client) SetCanForward(canForward bool) {
 	c.canForward = canForward
 }
 
-func (c *Client) SetAssumeProc(assumeProc bool) {
-	c.assumeProc = assumeProc
+func (c *Client) SetAssumeProc(assumeProc bool) error {
+	var err error
+	c.applier, err = goal.NewApplier(goal.ApplierOptions{Linux: goal.ApplierOptionsLinux{ReadWriteProc: !assumeProc}})
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 func (c *Client) SetDNSClient(client dns.Client) {
@@ -147,17 +143,11 @@ func (c *Client) ReifySpec() (latest bool, err error) {
 	gm.Interfaces[0].PrivateKey = goal.Key(c.privateKey)
 	data, _ = json.Marshal(gm)
 	zap.S().Debugf("compiled spec:\n%s", data)
-	data, _ = json.Marshal(c.Machine)
-	zap.S().Debugf("machine spec:\n%s", data)
-	diff := goal.DiffMachine(&c.Machine, &gm)
-	data, _ = json.Marshal(diff)
-	zap.S().Debugf("diff:\n%s", data)
 	zap.S().Debug("applying machine…")
-	err = goal.ApplyMachineDiff(c.Machine, gm, diff, c.wgClient, c.goalHandle, !c.assumeProc)
+	err = c.applier.ApplyMachine(gm)
 	if err != nil {
 		return false, fmt.Errorf("apply spec: %w", err)
 	}
-	c.Machine = gm
 	zap.S().Debug("applied machine.")
 
 	// === post status ===