go/daemon/config.go

@@ -44,20 +44,22 @@ var HTTPSocketPath = sync.OnceValue(func() string {
 
 func pickNetworkConfig(
 	daemonConfig daecommon.Config, creationParams bootstrap.CreationParams,
-) *daecommon.NetworkConfig {
+) (
+	daecommon.NetworkConfig, bool,
+) {
 	if len(daemonConfig.Networks) == 1 { // DEPRECATED
 		if c, ok := daemonConfig.Networks[daecommon.DeprecatedNetworkID]; ok {
-			return &c
+			return c, true
 		}
 	}
 
 	for searchStr, networkConfig := range daemonConfig.Networks {
 		if creationParams.Matches(searchStr) {
-			return &networkConfig
+			return networkConfig, true
 		}
 	}
 
-	return nil
+	return daecommon.NetworkConfig{}, false
 }
 
 ////////////////////////////////////////////////////////////////////////////////

go/daemon/daecommon/config.go

@@ -86,18 +86,6 @@ type NetworkConfig struct {
 	} `yaml:"storage"`
 }
 
-// NewNetworkConfig returns a new NetworkConfig populated with its default
-// values. If a callback is given the NetworkConfig will be passed to it for
-// modification prior to having defaults populated.
-func NewNetworkConfig(fn func(*NetworkConfig)) NetworkConfig {
-	var c NetworkConfig
-	if fn != nil {
-		fn(&c)
-	}
-	c.fillDefaults()
-	return c
-}
-
 func (c *NetworkConfig) fillDefaults() {
 	if c.DNS.Resolvers == nil {
 		c.DNS.Resolvers = []string{
@@ -225,15 +213,9 @@ func CopyDefaultConfig(into io.Writer) error {
 // fill in default values where it can.
 func (c *Config) UnmarshalYAML(n *yaml.Node) error {
 	{ // DEPRECATED
-		// We decode into a wrapped NetworkConfig, so that its UnmarshalYAML
-		// doesn't get invoked. This prevents fillDefaults from getting
-		// automatically called, so the IsZero check will work as intended. This
-		// means we need to call fillDefaults manually though.
-		type wrap NetworkConfig
 		var networkConfig NetworkConfig
-		_ = n.Decode((*wrap)(&networkConfig))
+		_ = n.Decode(&networkConfig)
 		if !toolkit.IsZero(networkConfig) {
-			networkConfig.fillDefaults()
 			*c = Config{
 				Networks: map[string]NetworkConfig{
 					DeprecatedNetworkID: networkConfig,

go/daemon/daecommon/config_test.go

@@ -1,72 +0,0 @@
-package daecommon
-
-import (
-	"isle/yamlutil"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"gopkg.in/yaml.v3"
-)
-
-func TestConfig_UnmarshalYAML(t *testing.T) { // TODO test validation
-	tests := []struct {
-		label  string
-		str    string
-		config Config
-	}{
-		{"empty", ``, Config{}},
-		{
-			"DEPRECATED single global network",
-			`
-				{"dns":{"resolvers":["a"]}}
-			`,
-			Config{
-				Networks: map[string]NetworkConfig{
-					DeprecatedNetworkID: NewNetworkConfig(func(c *NetworkConfig) {
-						c.DNS.Resolvers = []string{"a"}
-					}),
-				},
-			},
-		},
-		{
-			"single network",
-			`
-				networks:
-					foo: {"dns":{"resolvers":["a"]}}
-			`,
-			Config{
-				Networks: map[string]NetworkConfig{
-					"foo": NewNetworkConfig(func(c *NetworkConfig) {
-						c.DNS.Resolvers = []string{"a"}
-					}),
-				},
-			},
-		},
-		{
-			"multiple networks",
-			`
-				networks:
-					foo: {"dns":{"resolvers":["a"]}}
-					bar: {}
-			`,
-			Config{
-				Networks: map[string]NetworkConfig{
-					"foo": NewNetworkConfig(func(c *NetworkConfig) {
-						c.DNS.Resolvers = []string{"a"}
-					}),
-					"bar": NewNetworkConfig(nil),
-				},
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.label, func(t *testing.T) {
-			test.str = yamlutil.ReplacePrefixTabs(test.str)
-			var config Config
-			err := yaml.Unmarshal([]byte(test.str), &config)
-			assert.NoError(t, err)
-			assert.Equal(t, test.config, config)
-		})
-	}
-}

go/daemon/daemon.go

@@ -21,7 +21,8 @@ var _ RPC = (*Daemon)(nil)
 
 type joinedNetwork struct {
 	network.Network
-	config *daecommon.NetworkConfig
+
+	userConfig bool
 }
 
 // Daemon implements all methods of the Daemon interface, plus others used
@@ -74,23 +75,25 @@ func New(
 		ctx = mctx.WithAnnotator(ctx, creationParams)
 
 		var (
-			id            = creationParams.ID
+			id               = creationParams.ID
-			networkConfig = pickNetworkConfig(daemonConfig, creationParams)
+			networkConfig, _ = pickNetworkConfig(daemonConfig, creationParams)
 		)
 
-		n, err := networkLoader.Load(
+		network, err := networkLoader.Load(
 			ctx,
 			logger.WithNamespace("network"),
+			networkConfig,
 			creationParams,
-			&network.Opts{
+			nil,
-				Config: networkConfig,
-			},
 		)
 		if err != nil {
 			return nil, fmt.Errorf("loading network %q: %w", id, err)
 		}
 
-		d.networks[id] = joinedNetwork{n, networkConfig}
+		d.networks[id] = joinedNetwork{
+			Network:    network,
+			userConfig: true,
+		}
 	}
 
 	return d, nil
@@ -111,18 +114,21 @@ func New(
 // - network.ErrInvalidConfig
 func (d *Daemon) CreateNetwork(
 	ctx context.Context,
-	name, domain string, ipNet nebula.IPNet, hostName nebula.HostName,
+	name, domain string,
+	ipNet nebula.IPNet,
+	hostName nebula.HostName,
 ) error {
+	creationParams := bootstrap.NewCreationParams(name, domain)
+	ctx = mctx.WithAnnotator(ctx, creationParams)
+
+	networkConfig, ok := pickNetworkConfig(d.daemonConfig, creationParams)
+	if !ok {
+		return errors.New("couldn't find network config for network being created")
+	}
+
 	d.l.Lock()
 	defer d.l.Unlock()
 
-	var (
-		creationParams = bootstrap.NewCreationParams(name, domain)
-		networkConfig  = pickNetworkConfig(d.daemonConfig, creationParams)
-	)
-
-	ctx = mctx.WithAnnotator(ctx, creationParams)
-
 	if joined, err := alreadyJoined(ctx, d.networks, creationParams); err != nil {
 		return fmt.Errorf("checking if already joined to network: %w", err)
 	} else if joined {
@@ -133,19 +139,22 @@ func (d *Daemon) CreateNetwork(
 	n, err := d.networkLoader.Create(
 		ctx,
 		d.logger.WithNamespace("network"),
+		networkConfig,
 		creationParams,
 		ipNet,
 		hostName,
-		&network.Opts{
+		nil,
-			Config: networkConfig,
-		},
 	)
 	if err != nil {
 		return fmt.Errorf("creating network: %w", err)
 	}
 
 	d.logger.Info(ctx, "Network created successfully")
-	d.networks[creationParams.ID] = joinedNetwork{n, networkConfig}
+	d.networks[creationParams.ID] = joinedNetwork{
+		Network:    n,
+		userConfig: true,
+	}
+
 	return nil
 }
 
@@ -157,17 +166,17 @@ func (d *Daemon) CreateNetwork(
 func (d *Daemon) JoinNetwork(
 	ctx context.Context, newBootstrap network.JoiningBootstrap,
 ) error {
-	d.l.Lock()
-	defer d.l.Unlock()
-
 	var (
-		creationParams = newBootstrap.Bootstrap.NetworkCreationParams
+		creationParams   = newBootstrap.Bootstrap.NetworkCreationParams
-		networkID      = creationParams.ID
+		networkConfig, _ = pickNetworkConfig(d.daemonConfig, creationParams)
-		networkConfig  = pickNetworkConfig(d.daemonConfig, creationParams)
+		networkID        = creationParams.ID
 	)
 
 	ctx = mctx.WithAnnotator(ctx, newBootstrap.Bootstrap.NetworkCreationParams)
 
+	d.l.Lock()
+	defer d.l.Unlock()
+
 	if joined, err := alreadyJoined(ctx, d.networks, creationParams); err != nil {
 		return fmt.Errorf("checking if already joined to network: %w", err)
 	} else if joined {
@@ -178,10 +187,9 @@ func (d *Daemon) JoinNetwork(
 	n, err := d.networkLoader.Join(
 		ctx,
 		d.logger.WithNamespace("network"),
+		networkConfig,
 		newBootstrap,
-		&network.Opts{
+		nil,
-			Config: networkConfig,
-		},
 	)
 	if err != nil {
 		return fmt.Errorf(
@@ -190,14 +198,17 @@ func (d *Daemon) JoinNetwork(
 	}
 
 	d.logger.Info(ctx, "Network joined successfully")
-	d.networks[networkID] = joinedNetwork{n, networkConfig}
+	d.networks[networkID] = joinedNetwork{
+		Network:    n,
+		userConfig: true,
+	}
 	return nil
 }
 
 func withNetwork[Res any](
 	ctx context.Context,
 	d *Daemon,
-	fn func(context.Context, joinedNetwork) (Res, error),
+	fn func(context.Context, network.Network) (Res, error),
 ) (
 	Res, error,
 ) {
@@ -242,12 +253,41 @@ func (d *Daemon) GetNetworks(
 	return res, nil
 }
 
+// SetConfig applies a new NetworkConfig to a joined network. It uses the same
+// mechanism as the rest of the [network.RPC] methods on the Daemon to choose a
+// network.
+//
+// Besides the errors related to network choosing which are returned by all
+// other [network.RPC] methods, this may also return ErrUserManagedNetworkConfig
+// if the network's configuration is not managed by the Daemon, but is instead
+// provided via the config by the user.
+func (d *Daemon) SetConfig(
+	ctx context.Context, config daecommon.NetworkConfig,
+) error {
+	d.l.RLock()
+	defer d.l.RUnlock()
+
+	// TODO needs to check that public addresses aren't being shared
+	// across networks, and whatever else happens in Config.Validate.
+
+	network, err := pickNetwork(ctx, d.networkLoader, d.networks)
+	if err != nil {
+		return err
+	}
+
+	if network.userConfig {
+		return ErrUserManagedNetworkConfig
+	}
+
+	return network.SetConfig(ctx, config)
+}
+
 // GetHost implements the method for the network.RPC interface.
 func (d *Daemon) GetHosts(ctx context.Context) ([]bootstrap.Host, error) {
 	return withNetwork(
 		ctx,
 		d,
-		func(ctx context.Context, n joinedNetwork) ([]bootstrap.Host, error) {
+		func(ctx context.Context, n network.Network) ([]bootstrap.Host, error) {
 			return n.GetHosts(ctx)
 		},
 	)
@@ -263,7 +303,7 @@ func (d *Daemon) GetGarageClientParams(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n joinedNetwork,
+			ctx context.Context, n network.Network,
 		) (
 			network.GarageClientParams, error,
 		) {
@@ -283,7 +323,7 @@ func (d *Daemon) GetNebulaCAPublicCredentials(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n joinedNetwork,
+			ctx context.Context, n network.Network,
 		) (
 			nebula.CAPublicCredentials, error,
 		) {
@@ -298,7 +338,7 @@ func (d *Daemon) RemoveHost(ctx context.Context, hostName nebula.HostName) error
 		ctx,
 		d,
 		func(
-			ctx context.Context, n joinedNetwork,
+			ctx context.Context, n network.Network,
 		) (
 			struct{}, error,
 		) {
@@ -320,7 +360,7 @@ func (d *Daemon) CreateHost(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n joinedNetwork,
+			ctx context.Context, n network.Network,
 		) (
 			network.JoiningBootstrap, error,
 		) {
@@ -341,7 +381,7 @@ func (d *Daemon) CreateNebulaCertificate(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n joinedNetwork,
+			ctx context.Context, n network.Network,
 		) (
 			nebula.Certificate, error,
 		) {
@@ -350,7 +390,6 @@ func (d *Daemon) CreateNebulaCertificate(
 	)
 }
 
-// GetConfig implements the method for the network.RPC interface.
 func (d *Daemon) GetConfig(
 	ctx context.Context,
 ) (
@@ -360,7 +399,7 @@ func (d *Daemon) GetConfig(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n joinedNetwork,
+			ctx context.Context, n network.Network,
 		) (
 			daecommon.NetworkConfig, error,
 		) {
@@ -369,26 +408,6 @@ func (d *Daemon) GetConfig(
 	)
 }
 
-// SetConfig implements the method for the network.RPC interface.
-func (d *Daemon) SetConfig(
-	ctx context.Context, config daecommon.NetworkConfig,
-) error {
-	_, err := withNetwork(
-		ctx,
-		d,
-		func(ctx context.Context, n joinedNetwork) (struct{}, error) {
-			if n.config != nil {
-				return struct{}{}, ErrUserManagedNetworkConfig
-			}
-
-			// TODO needs to check that public addresses aren't being shared
-			// across networks, and whatever else happens in Config.Validate.
-			return struct{}{}, n.SetConfig(ctx, config)
-		},
-	)
-	return err
-}
-
 // Shutdown blocks until all resources held or created by the daemon,
 // including child processes it has started, have been cleaned up.
 //

go/daemon/daemon_test.go

@@ -1,227 +0,0 @@
-package daemon
-
-import (
-	"context"
-	"isle/bootstrap"
-	"isle/daemon/daecommon"
-	"isle/daemon/network"
-	"isle/toolkit"
-	"testing"
-
-	"dev.mediocregopher.com/mediocre-go-lib.git/mlog"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-type expectNetworkLoad struct {
-	creationParams bootstrap.CreationParams
-	networkConfig  *daecommon.NetworkConfig
-	network        *network.MockNetwork
-}
-
-type harnessOpts struct {
-	config               daecommon.Config
-	expectNetworksLoaded []expectNetworkLoad
-}
-
-func (o *harnessOpts) withDefaults() *harnessOpts {
-	if o == nil {
-		o = new(harnessOpts)
-	}
-	return o
-}
-
-type harness struct {
-	ctx           context.Context
-	networkLoader *network.MockLoader
-	daemon        *Daemon
-}
-
-func newHarness(t *testing.T, opts *harnessOpts) *harness {
-	t.Parallel()
-
-	opts = opts.withDefaults()
-
-	var (
-		ctx           = context.Background()
-		logger        = toolkit.NewTestLogger(t)
-		networkLoader = network.NewMockLoader(t)
-	)
-
-	expectLoadable := make(
-		[]bootstrap.CreationParams, len(opts.expectNetworksLoaded),
-	)
-	for i, expectNetworkLoaded := range opts.expectNetworksLoaded {
-		expectLoadable[i] = expectNetworkLoaded.creationParams
-		networkLoader.
-			On(
-				"Load",
-				toolkit.MockArg[context.Context](),
-				toolkit.MockArg[*mlog.Logger](),
-				expectNetworkLoaded.creationParams,
-				&network.Opts{
-					Config: expectNetworkLoaded.networkConfig,
-				},
-			).
-			Return(expectNetworkLoaded.network, nil).
-			Once()
-
-		expectNetworkLoaded.network.On("Shutdown").Return(nil).Once()
-	}
-
-	networkLoader.
-		On("Loadable", toolkit.MockArg[context.Context]()).
-		Return(expectLoadable, nil).
-		Once()
-
-	daemon, err := New(ctx, logger, networkLoader, opts.config)
-	require.NoError(t, err)
-
-	t.Cleanup(func() {
-		t.Log("Shutting down Daemon")
-		assert.NoError(t, daemon.Shutdown())
-	})
-
-	return &harness{ctx, networkLoader, daemon}
-}
-
-func TestNew(t *testing.T) {
-	t.Run("no networks loaded", func(t *testing.T) {
-		_ = newHarness(t, nil)
-	})
-
-	t.Run("DEPRECATED network config matching", func(t *testing.T) {
-		var (
-			creationParams = bootstrap.NewCreationParams("AAA", "a.com")
-			networkConfig  = daecommon.NewNetworkConfig(func(c *daecommon.NetworkConfig) {
-				c.DNS.Resolvers = []string{"foo"}
-			})
-			config = daecommon.Config{
-				Networks: map[string]daecommon.NetworkConfig{
-					daecommon.DeprecatedNetworkID: networkConfig,
-				},
-			}
-		)
-
-		_ = newHarness(t, &harnessOpts{
-			config: config,
-			expectNetworksLoaded: []expectNetworkLoad{
-				{
-					creationParams,
-					&networkConfig,
-					network.NewMockNetwork(t),
-				},
-			},
-		})
-	})
-
-	t.Run("network config matching", func(t *testing.T) {
-		var (
-			creationParamsA = bootstrap.NewCreationParams("AAA", "a.com")
-			creationParamsB = bootstrap.NewCreationParams("BBB", "b.com")
-			creationParamsC = bootstrap.NewCreationParams("CCC", "c.com")
-			creationParamsD = bootstrap.NewCreationParams("DDD", "d.com")
-
-			networkConfigA = daecommon.NewNetworkConfig(func(c *daecommon.NetworkConfig) {
-				c.DNS.Resolvers = []string{"foo"}
-			})
-
-			networkConfigB = daecommon.NewNetworkConfig(func(c *daecommon.NetworkConfig) {
-				c.VPN.Tun.Device = "bar"
-			})
-
-			networkConfigC = daecommon.NewNetworkConfig(func(c *daecommon.NetworkConfig) {
-				c.Storage.Allocations = []daecommon.ConfigStorageAllocation{
-					{
-						DataPath: "/path/data",
-						MetaPath: "/path/meta",
-						Capacity: 1,
-					},
-				}
-			})
-
-			config = daecommon.Config{
-				Networks: map[string]daecommon.NetworkConfig{
-					creationParamsA.ID:     networkConfigA,
-					creationParamsB.Name:   networkConfigB,
-					creationParamsC.Domain: networkConfigC,
-					"unknown":              {},
-				},
-			}
-		)
-
-		_ = newHarness(t, &harnessOpts{
-			config: config,
-			expectNetworksLoaded: []expectNetworkLoad{
-				{
-					creationParamsA,
-					&networkConfigA,
-					network.NewMockNetwork(t),
-				},
-				{
-					creationParamsB,
-					&networkConfigB,
-					network.NewMockNetwork(t),
-				},
-				{
-					creationParamsC,
-					&networkConfigC,
-					network.NewMockNetwork(t),
-				},
-				{
-					creationParamsD,
-					nil,
-					network.NewMockNetwork(t),
-				},
-			},
-		})
-	})
-}
-
-func TestDaemon_SetConfig(t *testing.T) {
-	t.Run("success", func(t *testing.T) {
-		var (
-			networkA = network.NewMockNetwork(t)
-			h        = newHarness(t, &harnessOpts{
-				expectNetworksLoaded: []expectNetworkLoad{{
-					bootstrap.NewCreationParams("AAA", "a.com"), nil, networkA,
-				}},
-			})
-
-			networkConfig = daecommon.NewNetworkConfig(func(c *daecommon.NetworkConfig) {
-				c.VPN.Tun.Device = "foo"
-			})
-		)
-
-		networkA.
-			On("SetConfig", toolkit.MockArg[context.Context](), networkConfig).
-			Return(nil).
-			Once()
-
-		err := h.daemon.SetConfig(h.ctx, networkConfig)
-		assert.NoError(t, err)
-	})
-
-	t.Run("ErrUserManagedNetworkConfig", func(t *testing.T) {
-		var (
-			creationParams = bootstrap.NewCreationParams("AAA", "a.com")
-			networkA       = network.NewMockNetwork(t)
-			networkConfig  = daecommon.NewNetworkConfig(nil)
-
-			h = newHarness(t, &harnessOpts{
-				config: daecommon.Config{
-					Networks: map[string]daecommon.NetworkConfig{
-						creationParams.Name: networkConfig,
-					},
-				},
-				expectNetworksLoaded: []expectNetworkLoad{
-					{creationParams, &networkConfig, networkA},
-				},
-			})
-		)
-
-		networkConfig.VPN.Tun.Device = "foo"
-		err := h.daemon.SetConfig(h.ctx, networkConfig)
-		assert.ErrorIs(t, err, ErrUserManagedNetworkConfig)
-	})
-}

go/daemon/network.go

@@ -18,22 +18,16 @@ func pickNetwork(
 		return joinedNetwork{}, ErrNoNetwork
 	}
 
-	networkSearchStr := getNetworkSearchStr(ctx)
-	if networkSearchStr == "" {
-		if len(networks) > 1 {
-			return joinedNetwork{}, ErrNoMatchingNetworks
-		}
-		for _, network := range networks {
-			return network, nil
-		}
-	}
-
 	creationParams, err := networkLoader.Loadable(ctx)
 	if err != nil {
 		return joinedNetwork{}, fmt.Errorf("getting loadable networks: %w", err)
 	}
 
-	matchingNetworkIDs := make([]string, 0, len(networks))
+	var (
+		networkSearchStr   = getNetworkSearchStr(ctx)
+		matchingNetworkIDs = make([]string, 0, len(networks))
+	)
+
 	for _, creationParam := range creationParams {
 		if networkSearchStr == "" || creationParam.Matches(networkSearchStr) {
 			matchingNetworkIDs = append(matchingNetworkIDs, creationParam.ID)

go/daemon/network/config.go

@@ -1,42 +0,0 @@
-package network
-
-import (
-	"errors"
-	"fmt"
-	"io/fs"
-	"isle/daemon/daecommon"
-	"isle/jsonutil"
-	"isle/toolkit"
-	"path/filepath"
-)
-
-// loadStoreConfig writes the given NetworkConfig to the networkStateDir if the
-// config is non-nil. If the config is nil then a config is read from
-// networkStateDir, returning the zero value if no config was previously
-// stored.
-func loadStoreConfig(
-	networkStateDir toolkit.Dir, config *daecommon.NetworkConfig,
-) (
-	daecommon.NetworkConfig, error,
-) {
-	path := filepath.Join(networkStateDir.Path, "config.json")
-
-	if config == nil {
-		config = new(daecommon.NetworkConfig)
-		err := jsonutil.LoadFile(&config, path)
-		if err != nil && !errors.Is(err, fs.ErrNotExist) {
-			return daecommon.NetworkConfig{}, fmt.Errorf(
-				"loading %q: %w", path, err,
-			)
-		}
-		return *config, nil
-	}
-
-	if err := jsonutil.WriteFile(*config, path, 0600); err != nil {
-		return daecommon.NetworkConfig{}, fmt.Errorf(
-			"writing to %q: %w", path, err,
-		)
-	}
-
-	return *config, nil
-}

go/daemon/network/loader.go

@@ -59,6 +59,7 @@ type Loader interface {
 	Load(
 		context.Context,
 		*mlog.Logger,
+		daecommon.NetworkConfig,
 		bootstrap.CreationParams,
 		*Opts,
 	) (
@@ -72,6 +73,7 @@ type Loader interface {
 	Join(
 		context.Context,
 		*mlog.Logger,
+		daecommon.NetworkConfig,
 		JoiningBootstrap,
 		*Opts,
 	) (
@@ -89,11 +91,12 @@ type Loader interface {
 	//   - hostName: The name of this first host in the network.
 	//
 	// Errors:
-	//   - ErrInvalidConfig - If the Opts.Config field is not valid. It must be
+	//   - ErrInvalidConfig - if daemonConfig doesn't have 3 storage allocations
-	//     non-nil and have at least 3 storage allocations.
+	//     configured.
 	Create(
 		context.Context,
 		*mlog.Logger,
+		daecommon.NetworkConfig,
 		bootstrap.CreationParams,
 		nebula.IPNet,
 		nebula.HostName,
@@ -185,7 +188,7 @@ func (l *loader) Loadable(
 	creationParams := make([]bootstrap.CreationParams, 0, len(networkStateDirs))
 
 	for _, networkStateDir := range networkStateDirs {
-		thisCreationParams, err := loadCreationParams(networkStateDir)
+		thisCreationParams, err := LoadCreationParams(networkStateDir)
 		if err != nil {
 			return nil, fmt.Errorf(
 				"loading creation params from %q: %w",
@@ -202,6 +205,7 @@ func (l *loader) Loadable(
 func (l *loader) Load(
 	ctx context.Context,
 	logger *mlog.Logger,
+	networkConfig daecommon.NetworkConfig,
 	creationParams bootstrap.CreationParams,
 	opts *Opts,
 ) (
@@ -222,6 +226,7 @@ func (l *loader) Load(
 		ctx,
 		logger.WithNamespace("network"),
 		l.envBinDirPath,
+		networkConfig,
 		networkStateDir,
 		networkRuntimeDir,
 		opts,
@@ -231,6 +236,7 @@ func (l *loader) Load(
 func (l *loader) Join(
 	ctx context.Context,
 	logger *mlog.Logger,
+	networkConfig daecommon.NetworkConfig,
 	joiningBootstrap JoiningBootstrap,
 	opts *Opts,
 ) (
@@ -254,6 +260,7 @@ func (l *loader) Join(
 		ctx,
 		logger.WithNamespace("network"),
 		l.envBinDirPath,
+		networkConfig,
 		joiningBootstrap,
 		networkStateDir,
 		networkRuntimeDir,
@@ -264,6 +271,7 @@ func (l *loader) Join(
 func (l *loader) Create(
 	ctx context.Context,
 	logger *mlog.Logger,
+	networkConfig daecommon.NetworkConfig,
 	creationParams bootstrap.CreationParams,
 	ipNet nebula.IPNet,
 	hostName nebula.HostName,
@@ -286,6 +294,7 @@ func (l *loader) Create(
 		ctx,
 		logger.WithNamespace("network"),
 		l.envBinDirPath,
+		networkConfig,
 		networkStateDir,
 		networkRuntimeDir,
 		creationParams,

go/daemon/network/loader_mock.go

@@ -6,6 +6,8 @@ import (
 	context "context"
 	bootstrap "isle/bootstrap"
 
+	daecommon "isle/daemon/daecommon"
+
 	mlog "dev.mediocregopher.com/mediocre-go-lib.git/mlog"
 
 	mock "github.com/stretchr/testify/mock"
@@ -18,9 +20,9 @@ type MockLoader struct {
 	mock.Mock
 }
 
-// Create provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5
+// Create provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5, _a6
-func (_m *MockLoader) Create(_a0 context.Context, _a1 *mlog.Logger, _a2 bootstrap.CreationParams, _a3 nebula.IPNet, _a4 nebula.HostName, _a5 *Opts) (Network, error) {
+func (_m *MockLoader) Create(_a0 context.Context, _a1 *mlog.Logger, _a2 daecommon.NetworkConfig, _a3 bootstrap.CreationParams, _a4 nebula.IPNet, _a5 nebula.HostName, _a6 *Opts) (Network, error) {
-	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5)
+	ret := _m.Called(_a0, _a1, _a2, _a3, _a4, _a5, _a6)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Create")
@@ -28,19 +30,19 @@ func (_m *MockLoader) Create(_a0 context.Context, _a1 *mlog.Logger, _a2 bootstra
 
 	var r0 Network
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, bootstrap.CreationParams, nebula.IPNet, nebula.HostName, *Opts) (Network, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, bootstrap.CreationParams, nebula.IPNet, nebula.HostName, *Opts) (Network, error)); ok {
-		return rf(_a0, _a1, _a2, _a3, _a4, _a5)
+		return rf(_a0, _a1, _a2, _a3, _a4, _a5, _a6)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, bootstrap.CreationParams, nebula.IPNet, nebula.HostName, *Opts) Network); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, bootstrap.CreationParams, nebula.IPNet, nebula.HostName, *Opts) Network); ok {
-		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
+		r0 = rf(_a0, _a1, _a2, _a3, _a4, _a5, _a6)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(Network)
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *mlog.Logger, bootstrap.CreationParams, nebula.IPNet, nebula.HostName, *Opts) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, bootstrap.CreationParams, nebula.IPNet, nebula.HostName, *Opts) error); ok {
-		r1 = rf(_a0, _a1, _a2, _a3, _a4, _a5)
+		r1 = rf(_a0, _a1, _a2, _a3, _a4, _a5, _a6)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -48,9 +50,9 @@ func (_m *MockLoader) Create(_a0 context.Context, _a1 *mlog.Logger, _a2 bootstra
 	return r0, r1
 }
 
-// Join provides a mock function with given fields: _a0, _a1, _a2, _a3
+// Join provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
-func (_m *MockLoader) Join(_a0 context.Context, _a1 *mlog.Logger, _a2 JoiningBootstrap, _a3 *Opts) (Network, error) {
+func (_m *MockLoader) Join(_a0 context.Context, _a1 *mlog.Logger, _a2 daecommon.NetworkConfig, _a3 JoiningBootstrap, _a4 *Opts) (Network, error) {
-	ret := _m.Called(_a0, _a1, _a2, _a3)
+	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Join")
@@ -58,19 +60,19 @@ func (_m *MockLoader) Join(_a0 context.Context, _a1 *mlog.Logger, _a2 JoiningBoo
 
 	var r0 Network
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, JoiningBootstrap, *Opts) (Network, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, JoiningBootstrap, *Opts) (Network, error)); ok {
-		return rf(_a0, _a1, _a2, _a3)
+		return rf(_a0, _a1, _a2, _a3, _a4)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, JoiningBootstrap, *Opts) Network); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, JoiningBootstrap, *Opts) Network); ok {
-		r0 = rf(_a0, _a1, _a2, _a3)
+		r0 = rf(_a0, _a1, _a2, _a3, _a4)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(Network)
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *mlog.Logger, JoiningBootstrap, *Opts) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, JoiningBootstrap, *Opts) error); ok {
-		r1 = rf(_a0, _a1, _a2, _a3)
+		r1 = rf(_a0, _a1, _a2, _a3, _a4)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -78,9 +80,9 @@ func (_m *MockLoader) Join(_a0 context.Context, _a1 *mlog.Logger, _a2 JoiningBoo
 	return r0, r1
 }
 
-// Load provides a mock function with given fields: _a0, _a1, _a2, _a3
+// Load provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4
-func (_m *MockLoader) Load(_a0 context.Context, _a1 *mlog.Logger, _a2 bootstrap.CreationParams, _a3 *Opts) (Network, error) {
+func (_m *MockLoader) Load(_a0 context.Context, _a1 *mlog.Logger, _a2 daecommon.NetworkConfig, _a3 bootstrap.CreationParams, _a4 *Opts) (Network, error) {
-	ret := _m.Called(_a0, _a1, _a2, _a3)
+	ret := _m.Called(_a0, _a1, _a2, _a3, _a4)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Load")
@@ -88,19 +90,19 @@ func (_m *MockLoader) Load(_a0 context.Context, _a1 *mlog.Logger, _a2 bootstrap.
 
 	var r0 Network
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, bootstrap.CreationParams, *Opts) (Network, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, bootstrap.CreationParams, *Opts) (Network, error)); ok {
-		return rf(_a0, _a1, _a2, _a3)
+		return rf(_a0, _a1, _a2, _a3, _a4)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, bootstrap.CreationParams, *Opts) Network); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, bootstrap.CreationParams, *Opts) Network); ok {
-		r0 = rf(_a0, _a1, _a2, _a3)
+		r0 = rf(_a0, _a1, _a2, _a3, _a4)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(Network)
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *mlog.Logger, bootstrap.CreationParams, *Opts) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *mlog.Logger, daecommon.NetworkConfig, bootstrap.CreationParams, *Opts) error); ok {
-		r1 = rf(_a0, _a1, _a2, _a3)
+		r1 = rf(_a0, _a1, _a2, _a3, _a4)
 	} else {
 		r1 = ret.Error(1)
 	}

go/daemon/network/network.go

@@ -154,14 +154,6 @@ type Network interface {
 // Network instance. A nil Opts is equivalent to a zero value.
 type Opts struct {
 	GarageAdminToken string // Will be randomly generated if left unset.
-
-	// Config will be used as the configuration of the Network from its
-	// initialization onwards.
-	//
-	// If not given then the most recent NetworkConfig for the network will be
-	// used, either that which it was most recently initialized with or which
-	// was passed to [SetConfig].
-	Config *daecommon.NetworkConfig
 }
 
 func (o *Opts) withDefaults() *Opts {
@@ -197,61 +189,44 @@ type network struct {
 	wg           sync.WaitGroup
 }
 
-// newNetwork returns an instantiated *network instance. All initialization
+// instatiateNetwork returns an instantiated *network instance which has not yet
-// steps which are common to all *network creation methods (load, join, create)
+// been initialized.
-// are included here as well.
+func instatiateNetwork(
-func newNetwork(
 	ctx context.Context,
 	logger *mlog.Logger,
+	networkConfig daecommon.NetworkConfig,
 	envBinDirPath string,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
-	dirsMayExist bool,
 	opts *Opts,
-) (
+) *network {
-	*network, error,
+	ctx = context.WithoutCancel(ctx)
-) {
+	ctx, cancel := context.WithCancel(ctx)
-	ctx, cancel := context.WithCancel(context.WithoutCancel(ctx))
+	return &network{
-
+		logger:        logger,
-	var (
+		networkConfig: networkConfig,
-		n = &network{
+		envBinDirPath: envBinDirPath,
-			logger:        logger,
+		stateDir:      stateDir,
-			envBinDirPath: envBinDirPath,
+		runtimeDir:    runtimeDir,
-			stateDir:      stateDir,
+		opts:          opts.withDefaults(),
-			runtimeDir:    runtimeDir,
+		workerCtx:     ctx,
-			opts:          opts.withDefaults(),
+		workerCancel:  cancel,
-			workerCtx:     ctx,
-			workerCancel:  cancel,
-		}
-		err error
-	)
-
-	n.networkConfig, err = loadStoreConfig(n.stateDir, n.opts.Config)
-	if err != nil {
-		return nil, fmt.Errorf("resolving network config: %w", err)
 	}
-
-	secretsDir, err := n.stateDir.MkChildDir("secrets", dirsMayExist)
-	if err != nil {
-		return nil, fmt.Errorf("creating secrets dir: %w", err)
-	}
-
-	n.secretsStore = secrets.NewFSStore(secretsDir.Path)
-
-	return n, nil
 }
 
-// loadCreationParams returns the CreationParams of a Network which was
+// LoadCreationParams returns the CreationParams of a Network which was
 // Created/Joined with the given state directory.
-func loadCreationParams(
+//
+// TODO probably can be private
+func LoadCreationParams(
 	stateDir toolkit.Dir,
 ) (
 	bootstrap.CreationParams, error,
 ) {
 	var (
-		// TODO store/load the creation params separately from the rest of the
+		// TODO store/load the creation params separately from the rest of
-		// bootstrap, since the bootstrap contains potentially the entire host
+		// the bootstrap, since the bootstrap contains potentially the
-		// list of a network, which could be pretty bulky.
+		// entire host list of a network, which could be pretty bulky.
 		bootstrapFilePath = bootstrap.StateDirPath(stateDir.Path)
 		bs                bootstrap.Bootstrap
 	)
@@ -269,23 +244,25 @@ func load(
 	ctx context.Context,
 	logger *mlog.Logger,
 	envBinDirPath string,
+	networkConfig daecommon.NetworkConfig,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
 	opts *Opts,
 ) (
 	Network, error,
 ) {
-	n, err := newNetwork(
+	n := instatiateNetwork(
 		ctx,
 		logger,
+		networkConfig,
 		envBinDirPath,
 		stateDir,
 		runtimeDir,
-		true,
 		opts,
 	)
-	if err != nil {
+
-		return nil, fmt.Errorf("instantiating Network: %w", err)
+	if err := n.initializeDirs(true); err != nil {
+		return nil, fmt.Errorf("initializing directories: %w", err)
 	}
 
 	var (
@@ -308,6 +285,7 @@ func join(
 	ctx context.Context,
 	logger *mlog.Logger,
 	envBinDirPath string,
+	networkConfig daecommon.NetworkConfig,
 	joiningBootstrap JoiningBootstrap,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
@@ -315,17 +293,18 @@ func join(
 ) (
 	Network, error,
 ) {
-	n, err := newNetwork(
+	n := instatiateNetwork(
 		ctx,
 		logger,
+		networkConfig,
 		envBinDirPath,
 		stateDir,
 		runtimeDir,
-		false,
 		opts,
 	)
-	if err != nil {
+
-		return nil, fmt.Errorf("instantiating Network: %w", err)
+	if err := n.initializeDirs(false); err != nil {
+		return nil, fmt.Errorf("initializing directories: %w", err)
 	}
 
 	if err := secrets.Import(
@@ -345,6 +324,7 @@ func create(
 	ctx context.Context,
 	logger *mlog.Logger,
 	envBinDirPath string,
+	networkConfig daecommon.NetworkConfig,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
 	creationParams bootstrap.CreationParams,
@@ -354,6 +334,12 @@ func create(
 ) (
 	Network, error,
 ) {
+	if len(networkConfig.Storage.Allocations) < 3 {
+		return nil, ErrInvalidConfig.WithData(
+			"At least three storage allocations are required.",
+		)
+	}
+
 	nebulaCACreds, err := nebula.NewCACredentials(creationParams.Domain, ipNet)
 	if err != nil {
 		return nil, fmt.Errorf("creating nebula CA cert: %w", err)
@@ -361,23 +347,18 @@ func create(
 
 	garageRPCSecret := toolkit.RandStr(32)
 
-	n, err := newNetwork(
+	n := instatiateNetwork(
 		ctx,
 		logger,
+		networkConfig,
 		envBinDirPath,
 		stateDir,
 		runtimeDir,
-		false,
 		opts,
 	)
-	if err != nil {
-		return nil, fmt.Errorf("instantiating Network: %w", err)
-	}
 
-	if len(n.networkConfig.Storage.Allocations) < 3 {
+	if err := n.initializeDirs(false); err != nil {
-		return nil, ErrInvalidConfig.WithData(
+		return nil, fmt.Errorf("initializing directories: %w", err)
-			"At least three storage allocations are required.",
-		)
 	}
 
 	err = daecommon.SetGarageRPCSecret(ctx, n.secretsStore, garageRPCSecret)
@@ -410,6 +391,16 @@ func create(
 	return n, nil
 }
 
+func (n *network) initializeDirs(mayExist bool) error {
+	secretsDir, err := n.stateDir.MkChildDir("secrets", mayExist)
+	if err != nil {
+		return fmt.Errorf("creating secrets dir: %w", err)
+	}
+
+	n.secretsStore = secrets.NewFSStore(secretsDir.Path)
+	return nil
+}
+
 func (n *network) periodically(
 	label string,
 	fn func(context.Context) error,
@@ -1025,10 +1016,6 @@ func (n *network) GetConfig(context.Context) (daecommon.NetworkConfig, error) {
 func (n *network) SetConfig(
 	ctx context.Context, config daecommon.NetworkConfig,
 ) error {
-	if _, err := loadStoreConfig(n.stateDir, &config); err != nil {
-		return fmt.Errorf("storing new config: %w", err)
-	}
-
 	prevBootstrap, err := n.reload(ctx, &config, nil)
 	if err != nil {
 		return fmt.Errorf("reloading config: %w", err)

go/daemon/network/network_it_test.go

@@ -17,7 +17,7 @@ func TestCreate(t *testing.T) {
 		network = h.createNetwork(t, "primus", nil)
 	)
 
-	gotCreationParams, err := loadCreationParams(network.stateDir)
+	gotCreationParams, err := LoadCreationParams(network.stateDir)
 	assert.NoError(t, err)
 	assert.Equal(
 		t, gotCreationParams, network.getBootstrap(t).NetworkCreationParams,
@@ -25,30 +25,31 @@ func TestCreate(t *testing.T) {
 }
 
 func TestLoad(t *testing.T) {
-	t.Run("given config", func(t *testing.T) {
+	var (
-		var (
+		h       = newIntegrationHarness(t)
-			h             = newIntegrationHarness(t)
+		network = h.createNetwork(t, "primus", &createNetworkOpts{
-			network       = h.createNetwork(t, "primus", nil)
+			manualShutdown: true,
-			networkConfig = network.getConfig(t)
+		})
-		)
+	)
 
-		network.opts.Config = &networkConfig
+	t.Log("Shutting down network")
-		network.restart(t)
+	assert.NoError(t, network.Shutdown())
 
-		assert.Equal(t, networkConfig, network.getConfig(t))
+	t.Log("Calling Load")
-	})
+	loadedNetwork, err := load(
+		h.ctx,
+		h.logger.WithNamespace("loadedNetwork"),
+		getEnvBinDirPath(),
+		network.getConfig(t),
+		network.stateDir,
+		h.mkDir(t, "runtime"),
+		network.opts,
+	)
+	assert.NoError(t, err)
 
-	t.Run("load previous config", func(t *testing.T) {
+	t.Cleanup(func() {
-		var (
+		t.Log("Shutting down loadedNetwork")
-			h             = newIntegrationHarness(t)
+		assert.NoError(t, loadedNetwork.Shutdown())
-			network       = h.createNetwork(t, "primus", nil)
-			networkConfig = network.getConfig(t)
-		)
-
-		network.opts.Config = nil
-		network.restart(t)
-
-		assert.Equal(t, networkConfig, network.getConfig(t))
 	})
 }
 
@@ -60,7 +61,13 @@ func TestJoin(t *testing.T) {
 			secondus = h.joinNetwork(t, primus, "secondus", nil)
 		)
 
-		assert.Equal(t, primus.getHostsByName(t), secondus.getHostsByName(t))
+		primusHosts, err := primus.GetHosts(h.ctx)
+		assert.NoError(t, err)
+
+		secondusHosts, err := secondus.GetHosts(h.ctx)
+		assert.NoError(t, err)
+
+		assert.Equal(t, primusHosts, secondusHosts)
 	})
 
 	t.Run("with alloc", func(t *testing.T) {
@@ -77,10 +84,28 @@ func TestJoin(t *testing.T) {
 		t.Log("reloading primus' hosts")
 		assert.NoError(t, primus.Network.(*network).reloadHosts(h.ctx))
 
-		assert.Equal(t, primus.getHostsByName(t), secondus.getHostsByName(t))
+		primusHosts, err := primus.GetHosts(h.ctx)
+		assert.NoError(t, err)
+
+		secondusHosts, err := secondus.GetHosts(h.ctx)
+		assert.NoError(t, err)
+
+		assert.Equal(t, primusHosts, secondusHosts)
 	})
 }
 
+func TestNetwork_GetConfig(t *testing.T) {
+	var (
+		h       = newIntegrationHarness(t)
+		network = h.createNetwork(t, "primus", nil)
+	)
+
+	config, err := network.GetConfig(h.ctx)
+	assert.NoError(t, err)
+
+	assert.Equal(t, config, network.getConfig(t))
+}
+
 func TestNetwork_SetConfig(t *testing.T) {
 	allocsToRoles := func(
 		hostName nebula.HostName, allocs []bootstrap.GarageHostInstance,
@@ -234,22 +259,4 @@ func TestNetwork_SetConfig(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NotContains(t, layout.Roles, removedRole)
 	})
-
-	t.Run("changes reflected after restart", func(t *testing.T) {
-		var (
-			h       = newIntegrationHarness(t)
-			network = h.createNetwork(t, "primus", &createNetworkOpts{
-				numStorageAllocs: 4,
-			})
-			networkConfig = network.getConfig(t)
-		)
-
-		networkConfig.Storage.Allocations = networkConfig.Storage.Allocations[:3]
-		assert.NoError(t, network.SetConfig(h.ctx, networkConfig))
-
-		network.opts.Config = nil
-		network.restart(t)
-
-		assert.Equal(t, networkConfig, network.getConfig(t))
-	})
 }

go/daemon/network/network_it_util_test.go

@@ -2,6 +2,7 @@ package network
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"isle/bootstrap"
 	"isle/daemon/daecommon"
@@ -17,6 +18,7 @@ import (
 	"dev.mediocregopher.com/mediocre-go-lib.git/mlog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
 )
 
 // Utilities related to running network integration tests
@@ -60,6 +62,16 @@ func newTunDevice() string {
 	return fmt.Sprintf("isle-test-%d", atomic.AddUint64(&tunDeviceCounter, 1))
 }
 
+func mustParseNetworkConfigf(str string, args ...any) daecommon.NetworkConfig {
+	str = fmt.Sprintf(str, args...)
+
+	var networkConfig daecommon.NetworkConfig
+	if err := yaml.Unmarshal([]byte(str), &networkConfig); err != nil {
+		panic(fmt.Sprintf("parsing network config: %v", err))
+	}
+	return networkConfig
+}
+
 type integrationHarness struct {
 	ctx        context.Context
 	logger     *mlog.Logger
@@ -124,24 +136,35 @@ func (h *integrationHarness) mkNetworkConfig(
 		opts = new(networkConfigOpts)
 	}
 
-	return daecommon.NewNetworkConfig(func(c *daecommon.NetworkConfig) {
+	publicAddr := ""
-		if opts.hasPublicAddr {
+	if opts.hasPublicAddr {
-			c.VPN.PublicAddr = newPublicAddr()
+		publicAddr = newPublicAddr()
-		}
+	}
 
-		c.VPN.Tun.Device = newTunDevice() // TODO is this necessary??
+	allocs := make([]map[string]any, opts.numStorageAllocs)
-
+	for i := range allocs {
-		c.Storage.Allocations = make(
+		allocs[i] = map[string]any{
-			[]daecommon.ConfigStorageAllocation, opts.numStorageAllocs,
+			"data_path": h.mkDir(t, "data").Path,
-		)
+			"meta_path": h.mkDir(t, "meta").Path,
-		for i := range c.Storage.Allocations {
+			"capacity":  1,
-			c.Storage.Allocations[i] = daecommon.ConfigStorageAllocation{
-				DataPath: h.mkDir(t, "data").Path,
-				MetaPath: h.mkDir(t, "meta").Path,
-				Capacity: 1,
-			}
 		}
-	})
+	}
+
+	allocsJSON, err := json.Marshal(allocs)
+	require.NoError(t, err)
+
+	return mustParseNetworkConfigf(`
+        vpn:
+          public_addr: %q
+          tun:
+            device: %q
+        storage:
+          allocations: %s
+        `,
+		publicAddr,
+		newTunDevice(),
+		allocsJSON,
+	)
 }
 
 type createNetworkOpts struct {
@@ -180,7 +203,7 @@ func (h *integrationHarness) createNetwork(
 	t *testing.T,
 	hostNameStr string,
 	opts *createNetworkOpts,
-) *integrationHarnessNetwork {
+) integrationHarnessNetwork {
 	t.Logf("Creating as %q", hostNameStr)
 	opts = opts.withDefaults()
 
@@ -199,7 +222,6 @@ func (h *integrationHarness) createNetwork(
 
 		networkOpts = &Opts{
 			GarageAdminToken: "admin_token",
-			Config:           &networkConfig,
 		}
 	)
 
@@ -207,6 +229,7 @@ func (h *integrationHarness) createNetwork(
 		h.ctx,
 		logger,
 		getEnvBinDirPath(),
+		networkConfig,
 		stateDir,
 		runtimeDir,
 		opts.creationParams,
@@ -218,7 +241,16 @@ func (h *integrationHarness) createNetwork(
 		t.Fatalf("creating Network: %v", err)
 	}
 
-	nh := &integrationHarnessNetwork{
+	if !opts.manualShutdown {
+		t.Cleanup(func() {
+			t.Logf("Shutting down Network %q", hostNameStr)
+			if err := network.Shutdown(); err != nil {
+				t.Logf("Shutting down Network %q failed: %v", hostNameStr, err)
+			}
+		})
+	}
+
+	return integrationHarnessNetwork{
 		network,
 		h.ctx,
 		logger,
@@ -227,17 +259,6 @@ func (h *integrationHarness) createNetwork(
 		runtimeDir,
 		networkOpts,
 	}
-
-	if !opts.manualShutdown {
-		t.Cleanup(func() {
-			t.Logf("Shutting down Network %q", hostNameStr)
-			if err := nh.Shutdown(); err != nil {
-				t.Logf("Shutting down Network %q failed: %v", hostNameStr, err)
-			}
-		})
-	}
-
-	return nh
 }
 
 type joinNetworkOpts struct {
@@ -258,10 +279,10 @@ func (o *joinNetworkOpts) withDefaults() *joinNetworkOpts {
 
 func (h *integrationHarness) joinNetwork(
 	t *testing.T,
-	network *integrationHarnessNetwork,
+	network integrationHarnessNetwork,
 	hostNameStr string,
 	opts *joinNetworkOpts,
-) *integrationHarnessNetwork {
+) integrationHarnessNetwork {
 	opts = opts.withDefaults()
 	hostName := nebula.HostName(hostNameStr)
 
@@ -280,7 +301,6 @@ func (h *integrationHarness) joinNetwork(
 		runtimeDir    = h.mkDir(t, "runtime")
 		networkOpts   = &Opts{
 			GarageAdminToken: "admin_token",
-			Config:           &networkConfig,
 		}
 	)
 
@@ -289,6 +309,7 @@ func (h *integrationHarness) joinNetwork(
 		h.ctx,
 		logger,
 		getEnvBinDirPath(),
+		networkConfig,
 		joiningBootstrap,
 		stateDir,
 		runtimeDir,
@@ -298,7 +319,16 @@ func (h *integrationHarness) joinNetwork(
 		t.Fatalf("joining network: %v", err)
 	}
 
-	nh := &integrationHarnessNetwork{
+	if !opts.manualShutdown {
+		t.Cleanup(func() {
+			t.Logf("Shutting down Network %q", hostNameStr)
+			if err := joinedNetwork.Shutdown(); err != nil {
+				t.Logf("Shutting down Network %q failed: %v", hostNameStr, err)
+			}
+		})
+	}
+
+	return integrationHarnessNetwork{
 		joinedNetwork,
 		h.ctx,
 		logger,
@@ -307,34 +337,6 @@ func (h *integrationHarness) joinNetwork(
 		runtimeDir,
 		networkOpts,
 	}
-
-	if !opts.manualShutdown {
-		t.Cleanup(func() {
-			t.Logf("Shutting down Network %q", hostNameStr)
-			if err := nh.Shutdown(); err != nil {
-				t.Logf("Shutting down Network %q failed: %v", hostNameStr, err)
-			}
-		})
-	}
-
-	return nh
-}
-
-func (nh *integrationHarnessNetwork) restart(t *testing.T) {
-	t.Log("Shutting down network (restart)")
-	require.NoError(t, nh.Network.Shutdown())
-
-	t.Log("Loading network (restart)")
-	var err error
-	nh.Network, err = load(
-		nh.ctx,
-		nh.logger,
-		getEnvBinDirPath(),
-		nh.stateDir,
-		nh.runtimeDir,
-		nh.opts,
-	)
-	require.NoError(t, err)
 }
 
 func (nh *integrationHarnessNetwork) getConfig(t *testing.T) daecommon.NetworkConfig {

go/daemon/rpc.go

@@ -26,23 +26,15 @@ type RPC interface {
 
 	GetNetworks(context.Context) ([]bootstrap.CreationParams, error)
 
-	// SetConfig extends the [network.RPC] method of the same name such that
-	// [ErrUserManagedNetworkConfig] is returned if the picked network is
-	// configured as part of the [daecommon.Config] which the Daemon was
-	// initialized with.
-	//
-	// See the `network.RPC` documentation in this interface for more usage
-	// details.
 	SetConfig(context.Context, daecommon.NetworkConfig) error
 
 	// All network.RPC methods are automatically implemented by Daemon using the
 	// currently joined network. If no network is joined then any call to these
 	// methods will return ErrNoNetwork.
 	//
-	// If more than one Network is joined then all calls to these methods must
+	// All calls to these methods must be accompanied with a context produced by
-	// be accompanied with a context produced by WithNetwork, in order to choose
+	// WithNetwork, in order to choose the network. These methods may return
-	// the network. These methods may return these errors, in addition to those
+	// these errors, in addition to those documented on the individual methods:
-	// documented on the individual methods:
 	//
 	// Errors:
 	// - ErrNoNetwork

go/toolkit/testutils.go

@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"dev.mediocregopher.com/mediocre-go-lib.git/mlog"
-	"github.com/stretchr/testify/mock"
 )
 
 // MarkIntegrationTest marks a test as being an integration test. It will be
@@ -32,10 +31,3 @@ func NewTestLogger(t *testing.T) *mlog.Logger {
 		MaxLevel:       level.Int(),
 	})
 }
-
-// MockArg returns a value which can be used as a [mock.Call] argument, and
-// which will match any value of type T. If T is an interface then also values
-// implementing that interface will be matched.
-func MockArg[T any]() any {
-	return mock.MatchedBy(func(T) bool { return true })
-}

go/yamlutil/testutils.go

@@ -1,29 +0,0 @@
-package yamlutil
-
-import (
-	"strings"
-)
-
-// ReplacePrefixTabs will replace the leading tabs of each line with two spaces.
-// Tabs are not a valid indent in yaml (wtf), but they are convenient to use in
-// go when using multi-line strings.
-//
-// ReplacePrefixTabs should only be used within tests.
-func ReplacePrefixTabs(str string) string {
-	lines := strings.Split(str, "\n")
-	for i := range lines {
-		var n int
-		for _, r := range lines[i] {
-			if r == '\t' {
-				n++
-			} else {
-				break
-			}
-		}
-
-		spaces := strings.Repeat("  ", n)
-		lines[i] = spaces + lines[i][n:]
-	}
-
-	return strings.Join(lines, "\n")
-}