Pass NetworkConfig into Network loaders as an optional argument

WIP: daemon needs tests

go/daemon/config.go

@@ -44,22 +44,20 @@ 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, true
+			return &c
 		}
 	}
 
 	for searchStr, networkConfig := range daemonConfig.Networks {
 		if creationParams.Matches(searchStr) {
-			return networkConfig, true
+			return &networkConfig
 		}
 	}
 
-	return daecommon.NetworkConfig{}, false
+	return nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////

go/daemon/daemon.go

@@ -21,8 +21,7 @@ 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
@@ -75,25 +74,23 @@ func New(
 		ctx = mctx.WithAnnotator(ctx, creationParams)
 
 		var (
-			id               = creationParams.ID
+			id            = creationParams.ID
-			networkConfig, _ = pickNetworkConfig(daemonConfig, creationParams)
+			networkConfig = pickNetworkConfig(daemonConfig, creationParams)
 		)
 
-		network, err := networkLoader.Load(
+		n, err := networkLoader.Load(
 			ctx,
 			logger.WithNamespace("network"),
-			networkConfig,
 			creationParams,
-			nil,
+			&network.Opts{
+				Config: networkConfig,
+			},
 		)
 		if err != nil {
 			return nil, fmt.Errorf("loading network %q: %w", id, err)
 		}
 
-		d.networks[id] = joinedNetwork{
+		d.networks[id] = joinedNetwork{n, networkConfig}
-			Network:    network,
-			userConfig: true,
-		}
 	}
 
 	return d, nil
@@ -114,21 +111,18 @@ func New(
 // - network.ErrInvalidConfig
 func (d *Daemon) CreateNetwork(
 	ctx context.Context,
-	name, domain string,
+	name, domain string, ipNet nebula.IPNet, hostName nebula.HostName,
-	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 {
@@ -139,22 +133,19 @@ func (d *Daemon) CreateNetwork(
 	n, err := d.networkLoader.Create(
 		ctx,
 		d.logger.WithNamespace("network"),
-		networkConfig,
 		creationParams,
 		ipNet,
 		hostName,
-		nil,
+		&network.Opts{
+			Config: networkConfig,
+		},
 	)
 	if err != nil {
 		return fmt.Errorf("creating network: %w", err)
 	}
 
 	d.logger.Info(ctx, "Network created successfully")
-	d.networks[creationParams.ID] = joinedNetwork{
+	d.networks[creationParams.ID] = joinedNetwork{n, networkConfig}
-		Network:    n,
-		userConfig: true,
-	}
-
 	return nil
 }
 
@@ -166,17 +157,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
-		networkConfig, _ = pickNetworkConfig(d.daemonConfig, creationParams)
+		networkID      = creationParams.ID
-		networkID        = creationParams.ID
+		networkConfig  = pickNetworkConfig(d.daemonConfig, creationParams)
 	)
 
 	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 {
@@ -187,9 +178,10 @@ func (d *Daemon) JoinNetwork(
 	n, err := d.networkLoader.Join(
 		ctx,
 		d.logger.WithNamespace("network"),
-		networkConfig,
 		newBootstrap,
-		nil,
+		&network.Opts{
+			Config: networkConfig,
+		},
 	)
 	if err != nil {
 		return fmt.Errorf(
@@ -198,17 +190,14 @@ func (d *Daemon) JoinNetwork(
 	}
 
 	d.logger.Info(ctx, "Network joined successfully")
-	d.networks[networkID] = joinedNetwork{
+	d.networks[networkID] = joinedNetwork{n, networkConfig}
-		Network:    n,
-		userConfig: true,
-	}
 	return nil
 }
 
 func withNetwork[Res any](
 	ctx context.Context,
 	d *Daemon,
-	fn func(context.Context, network.Network) (Res, error),
+	fn func(context.Context, joinedNetwork) (Res, error),
 ) (
 	Res, error,
 ) {
@@ -253,41 +242,12 @@ 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 network.Network) ([]bootstrap.Host, error) {
+		func(ctx context.Context, n joinedNetwork) ([]bootstrap.Host, error) {
 			return n.GetHosts(ctx)
 		},
 	)
@@ -303,7 +263,7 @@ func (d *Daemon) GetGarageClientParams(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n network.Network,
+			ctx context.Context, n joinedNetwork,
 		) (
 			network.GarageClientParams, error,
 		) {
@@ -323,7 +283,7 @@ func (d *Daemon) GetNebulaCAPublicCredentials(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n network.Network,
+			ctx context.Context, n joinedNetwork,
 		) (
 			nebula.CAPublicCredentials, error,
 		) {
@@ -338,7 +298,7 @@ func (d *Daemon) RemoveHost(ctx context.Context, hostName nebula.HostName) error
 		ctx,
 		d,
 		func(
-			ctx context.Context, n network.Network,
+			ctx context.Context, n joinedNetwork,
 		) (
 			struct{}, error,
 		) {
@@ -360,7 +320,7 @@ func (d *Daemon) CreateHost(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n network.Network,
+			ctx context.Context, n joinedNetwork,
 		) (
 			network.JoiningBootstrap, error,
 		) {
@@ -381,7 +341,7 @@ func (d *Daemon) CreateNebulaCertificate(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n network.Network,
+			ctx context.Context, n joinedNetwork,
 		) (
 			nebula.Certificate, error,
 		) {
@@ -390,6 +350,7 @@ func (d *Daemon) CreateNebulaCertificate(
 	)
 }
 
+// GetConfig implements the method for the network.RPC interface.
 func (d *Daemon) GetConfig(
 	ctx context.Context,
 ) (
@@ -399,7 +360,7 @@ func (d *Daemon) GetConfig(
 		ctx,
 		d,
 		func(
-			ctx context.Context, n network.Network,
+			ctx context.Context, n joinedNetwork,
 		) (
 			daecommon.NetworkConfig, error,
 		) {
@@ -408,6 +369,26 @@ 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/network/config.go

@@ -0,0 +1,42 @@
+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,7 +59,6 @@ type Loader interface {
 	Load(
 		context.Context,
 		*mlog.Logger,
-		daecommon.NetworkConfig,
 		bootstrap.CreationParams,
 		*Opts,
 	) (
@@ -73,7 +72,6 @@ type Loader interface {
 	Join(
 		context.Context,
 		*mlog.Logger,
-		daecommon.NetworkConfig,
 		JoiningBootstrap,
 		*Opts,
 	) (
@@ -91,12 +89,11 @@ type Loader interface {
 	//   - hostName: The name of this first host in the network.
 	//
 	// Errors:
-	//   - ErrInvalidConfig - if daemonConfig doesn't have 3 storage allocations
+	//   - ErrInvalidConfig - If the Opts.Config field is not valid. It must be
-	//     configured.
+	//     non-nil and have at least 3 storage allocations.
 	Create(
 		context.Context,
 		*mlog.Logger,
-		daecommon.NetworkConfig,
 		bootstrap.CreationParams,
 		nebula.IPNet,
 		nebula.HostName,
@@ -188,7 +185,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",
@@ -205,7 +202,6 @@ func (l *loader) Loadable(
 func (l *loader) Load(
 	ctx context.Context,
 	logger *mlog.Logger,
-	networkConfig daecommon.NetworkConfig,
 	creationParams bootstrap.CreationParams,
 	opts *Opts,
 ) (
@@ -226,7 +222,6 @@ func (l *loader) Load(
 		ctx,
 		logger.WithNamespace("network"),
 		l.envBinDirPath,
-		networkConfig,
 		networkStateDir,
 		networkRuntimeDir,
 		opts,
@@ -236,7 +231,6 @@ func (l *loader) Load(
 func (l *loader) Join(
 	ctx context.Context,
 	logger *mlog.Logger,
-	networkConfig daecommon.NetworkConfig,
 	joiningBootstrap JoiningBootstrap,
 	opts *Opts,
 ) (
@@ -260,7 +254,6 @@ func (l *loader) Join(
 		ctx,
 		logger.WithNamespace("network"),
 		l.envBinDirPath,
-		networkConfig,
 		joiningBootstrap,
 		networkStateDir,
 		networkRuntimeDir,
@@ -271,7 +264,6 @@ 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,
@@ -294,7 +286,6 @@ func (l *loader) Create(
 		ctx,
 		logger.WithNamespace("network"),
 		l.envBinDirPath,
-		networkConfig,
 		networkStateDir,
 		networkRuntimeDir,
 		creationParams,

go/daemon/network/network.go

@@ -154,6 +154,14 @@ 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 {
@@ -189,44 +197,61 @@ type network struct {
 	wg           sync.WaitGroup
 }
 
-// instatiateNetwork returns an instantiated *network instance which has not yet
+// newNetwork returns an instantiated *network instance. All initialization
-// been initialized.
+// steps which are common to all *network creation methods (load, join, create)
-func instatiateNetwork(
+// are included here as well.
+func newNetwork(
 	ctx context.Context,
 	logger *mlog.Logger,
-	networkConfig daecommon.NetworkConfig,
 	envBinDirPath string,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
+	dirsMayExist bool,
 	opts *Opts,
-) *network {
+) (
-	ctx = context.WithoutCancel(ctx)
+	*network, error,
-	ctx, cancel := context.WithCancel(ctx)
+) {
-	return &network{
+	ctx, cancel := context.WithCancel(context.WithoutCancel(ctx))
-		logger:        logger,
+
-		networkConfig: networkConfig,
+	var (
-		envBinDirPath: envBinDirPath,
+		n = &network{
-		stateDir:      stateDir,
+			logger:        logger,
-		runtimeDir:    runtimeDir,
+			envBinDirPath: envBinDirPath,
-		opts:          opts.withDefaults(),
+			stateDir:      stateDir,
-		workerCtx:     ctx,
+			runtimeDir:    runtimeDir,
-		workerCancel:  cancel,
+			opts:          opts.withDefaults(),
+			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
+		// TODO store/load the creation params separately from the rest of the
-		// the bootstrap, since the bootstrap contains potentially the
+		// bootstrap, since the bootstrap contains potentially the entire host
-		// entire host list of a network, which could be pretty bulky.
+		// list of a network, which could be pretty bulky.
 		bootstrapFilePath = bootstrap.StateDirPath(stateDir.Path)
 		bs                bootstrap.Bootstrap
 	)
@@ -244,25 +269,23 @@ func load(
 	ctx context.Context,
 	logger *mlog.Logger,
 	envBinDirPath string,
-	networkConfig daecommon.NetworkConfig,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
 	opts *Opts,
 ) (
 	Network, error,
 ) {
-	n := instatiateNetwork(
+	n, err := newNetwork(
 		ctx,
 		logger,
-		networkConfig,
 		envBinDirPath,
 		stateDir,
 		runtimeDir,
+		true,
 		opts,
 	)
-
+	if err != nil {
-	if err := n.initializeDirs(true); err != nil {
+		return nil, fmt.Errorf("instantiating Network: %w", err)
-		return nil, fmt.Errorf("initializing directories: %w", err)
 	}
 
 	var (
@@ -285,7 +308,6 @@ func join(
 	ctx context.Context,
 	logger *mlog.Logger,
 	envBinDirPath string,
-	networkConfig daecommon.NetworkConfig,
 	joiningBootstrap JoiningBootstrap,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
@@ -293,18 +315,17 @@ func join(
 ) (
 	Network, error,
 ) {
-	n := instatiateNetwork(
+	n, err := newNetwork(
 		ctx,
 		logger,
-		networkConfig,
 		envBinDirPath,
 		stateDir,
 		runtimeDir,
+		false,
 		opts,
 	)
-
+	if err != nil {
-	if err := n.initializeDirs(false); err != nil {
+		return nil, fmt.Errorf("instantiating Network: %w", err)
-		return nil, fmt.Errorf("initializing directories: %w", err)
 	}
 
 	if err := secrets.Import(
@@ -324,7 +345,6 @@ func create(
 	ctx context.Context,
 	logger *mlog.Logger,
 	envBinDirPath string,
-	networkConfig daecommon.NetworkConfig,
 	stateDir toolkit.Dir,
 	runtimeDir toolkit.Dir,
 	creationParams bootstrap.CreationParams,
@@ -334,12 +354,6 @@ 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)
@@ -347,18 +361,23 @@ func create(
 
 	garageRPCSecret := toolkit.RandStr(32)
 
-	n := instatiateNetwork(
+	n, err := newNetwork(
 		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 {
+	if len(n.networkConfig.Storage.Allocations) < 3 {
-		return nil, fmt.Errorf("initializing directories: %w", err)
+		return nil, ErrInvalidConfig.WithData(
+			"At least three storage allocations are required.",
+		)
 	}
 
 	err = daecommon.SetGarageRPCSecret(ctx, n.secretsStore, garageRPCSecret)
@@ -391,16 +410,6 @@ 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,
@@ -1016,6 +1025,10 @@ 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,31 +25,30 @@ func TestCreate(t *testing.T) {
 }
 
 func TestLoad(t *testing.T) {
-	var (
+	t.Run("given config", func(t *testing.T) {
-		h       = newIntegrationHarness(t)
+		var (
-		network = h.createNetwork(t, "primus", &createNetworkOpts{
+			h             = newIntegrationHarness(t)
-			manualShutdown: true,
+			network       = h.createNetwork(t, "primus", nil)
-		})
+			networkConfig = network.getConfig(t)
-	)
+		)
 
-	t.Log("Shutting down network")
+		network.opts.Config = &networkConfig
-	assert.NoError(t, network.Shutdown())
+		network.restart(t)
 
-	t.Log("Calling Load")
+		assert.Equal(t, networkConfig, network.getConfig(t))
-	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.Cleanup(func() {
+	t.Run("load previous config", func(t *testing.T) {
-		t.Log("Shutting down loadedNetwork")
+		var (
-		assert.NoError(t, loadedNetwork.Shutdown())
+			h             = newIntegrationHarness(t)
+			network       = h.createNetwork(t, "primus", nil)
+			networkConfig = network.getConfig(t)
+		)
+
+		network.opts.Config = nil
+		network.restart(t)
+
+		assert.Equal(t, networkConfig, network.getConfig(t))
 	})
 }
 
@@ -61,13 +60,7 @@ func TestJoin(t *testing.T) {
 			secondus = h.joinNetwork(t, primus, "secondus", nil)
 		)
 
-		primusHosts, err := primus.GetHosts(h.ctx)
+		assert.Equal(t, primus.getHostsByName(t), secondus.getHostsByName(t))
-		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) {
@@ -84,28 +77,10 @@ func TestJoin(t *testing.T) {
 		t.Log("reloading primus' hosts")
 		assert.NoError(t, primus.Network.(*network).reloadHosts(h.ctx))
 
-		primusHosts, err := primus.GetHosts(h.ctx)
+		assert.Equal(t, primus.getHostsByName(t), secondus.getHostsByName(t))
-		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,
@@ -259,4 +234,22 @@ 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

@@ -203,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()
 
@@ -222,6 +222,7 @@ func (h *integrationHarness) createNetwork(
 
 		networkOpts = &Opts{
 			GarageAdminToken: "admin_token",
+			Config:           &networkConfig,
 		}
 	)
 
@@ -229,7 +230,6 @@ func (h *integrationHarness) createNetwork(
 		h.ctx,
 		logger,
 		getEnvBinDirPath(),
-		networkConfig,
 		stateDir,
 		runtimeDir,
 		opts.creationParams,
@@ -241,16 +241,7 @@ func (h *integrationHarness) createNetwork(
 		t.Fatalf("creating Network: %v", err)
 	}
 
-	if !opts.manualShutdown {
+	nh := &integrationHarnessNetwork{
-		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,
@@ -259,6 +250,17 @@ 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 {
@@ -279,10 +281,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)
 
@@ -301,6 +303,7 @@ func (h *integrationHarness) joinNetwork(
 		runtimeDir    = h.mkDir(t, "runtime")
 		networkOpts   = &Opts{
 			GarageAdminToken: "admin_token",
+			Config:           &networkConfig,
 		}
 	)
 
@@ -309,7 +312,6 @@ func (h *integrationHarness) joinNetwork(
 		h.ctx,
 		logger,
 		getEnvBinDirPath(),
-		networkConfig,
 		joiningBootstrap,
 		stateDir,
 		runtimeDir,
@@ -319,16 +321,7 @@ func (h *integrationHarness) joinNetwork(
 		t.Fatalf("joining network: %v", err)
 	}
 
-	if !opts.manualShutdown {
+	nh := &integrationHarnessNetwork{
-		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,
@@ -337,6 +330,34 @@ 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,15 +26,23 @@ 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.
 	//
-	// All calls to these methods must be accompanied with a context produced by
+	// If more than one Network is joined then all calls to these methods must
-	// WithNetwork, in order to choose the network. These methods may return
+	// be accompanied with a context produced by WithNetwork, in order to choose
-	// these errors, in addition to those documented on the individual methods:
+	// the network. These methods may return these errors, in addition to those
+	// documented on the individual methods:
 	//
 	// Errors:
 	// - ErrNoNetwork