isle/go/daemon/daemon.go

// Package daemon implements the isle daemon, which is a long-running service
// managing all isle background tasks and sub-processes for a single network.
package daemon

import (
	"context"
	"errors"
	"fmt"
	"isle/bootstrap"
	"isle/daemon/daecommon"
	"isle/daemon/network"
	"isle/nebula"
	"sort"
	"sync"

	"dev.mediocregopher.com/mediocre-go-lib.git/mctx"
	"dev.mediocregopher.com/mediocre-go-lib.git/mlog"
)

var _ RPC = (*Daemon)(nil)

type joinedNetwork struct {
	network.Network

	userConfig bool
}

// Daemon implements all methods of the Daemon interface, plus others used
// to manage this particular implementation.
//
// Daemon manages all child processes and state required by the isle
// service, as well as an HTTP socket over which RPC calls will be served.
//
// Inner Children instance(s) will be wrapped such that they will be
// automatically shutdown and re-created whenever there's changes in the network
// which require the configuration to be changed (e.g. a new nebula lighthouse).
// During such an inner restart all methods will return ErrRestarting, except
// Shutdown which will block until the currently executing restart is finished
// and then shutdown cleanly from there.
//
// While still starting up the Daemon for the first time all methods will return
// ErrInitializing, except Shutdown which will block until initialization is
// canceled.
type Daemon struct {
	logger        *mlog.Logger
	networkLoader network.Loader
	daemonConfig  daecommon.Config

	l        sync.RWMutex
	networks map[string]joinedNetwork
}

// New initializes and returns a Daemon.
func New(
	ctx context.Context,
	logger *mlog.Logger,
	networkLoader network.Loader,
	daemonConfig daecommon.Config,
) (
	*Daemon, error,
) {
	d := &Daemon{
		logger:        logger,
		networkLoader: networkLoader,
		daemonConfig:  daemonConfig,
		networks:      map[string]joinedNetwork{},
	}

	loadableNetworks, err := networkLoader.Loadable(ctx)
	if err != nil {
		return nil, fmt.Errorf("listing loadable networks: %w", err)
	}

	for _, creationParams := range loadableNetworks {
		ctx = mctx.WithAnnotator(ctx, creationParams)

		var (
			id               = creationParams.ID
			networkConfig, _ = pickNetworkConfig(daemonConfig, creationParams)
		)

		network, err := networkLoader.Load(
			ctx,
			logger.WithNamespace("network"),
			networkConfig,
			creationParams,
			nil,
		)
		if err != nil {
			return nil, fmt.Errorf("loading network %q: %w", id, err)
		}

		d.networks[id] = joinedNetwork{
			Network:    network,
			userConfig: true,
		}
	}

	return d, nil
}

// CreateNetwork will initialize a new network using the given parameters.
//   - name: Human-readable name of the network.
//   - domain: Primary domain name that network services are served under.
//   - ipNet: An IP subnet, in CIDR form, which will be the overall range of
//     possible IPs in the network. The first IP in this network range will become
//     this first host's IP.
//   - hostName: The name of this first host in the network.
//
// The daemon on which this is called will become the first host in the network,
// and will have full administrative privileges.
//
// Errors:
// - network.ErrInvalidConfig
func (d *Daemon) CreateNetwork(
	ctx context.Context,
	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()

	if joined, err := alreadyJoined(ctx, d.networks, creationParams); err != nil {
		return fmt.Errorf("checking if already joined to network: %w", err)
	} else if joined {
		return ErrAlreadyJoined
	}

	d.logger.Info(ctx, "Creating network")
	n, err := d.networkLoader.Create(
		ctx,
		d.logger.WithNamespace("network"),
		networkConfig,
		creationParams,
		ipNet,
		hostName,
		nil,
	)
	if err != nil {
		return fmt.Errorf("creating network: %w", err)
	}

	d.logger.Info(ctx, "Network created successfully")
	d.networks[creationParams.ID] = joinedNetwork{
		Network:    n,
		userConfig: true,
	}

	return nil
}

// JoinNetwork joins the Daemon to an existing network using the given
// Bootstrap.
//
// Errors:
// - ErrAlreadyJoined
func (d *Daemon) JoinNetwork(
	ctx context.Context, newBootstrap network.JoiningBootstrap,
) error {
	var (
		creationParams   = newBootstrap.Bootstrap.NetworkCreationParams
		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 {
		return ErrAlreadyJoined
	}

	d.logger.Info(ctx, "Joining network")
	n, err := d.networkLoader.Join(
		ctx,
		d.logger.WithNamespace("network"),
		networkConfig,
		newBootstrap,
		nil,
	)
	if err != nil {
		return fmt.Errorf(
			"joining network %q: %w", networkID, err,
		)
	}

	d.logger.Info(ctx, "Network joined successfully")
	d.networks[networkID] = joinedNetwork{
		Network:    n,
		userConfig: true,
	}
	return nil
}

func withNetwork[Res any](
	ctx context.Context,
	d *Daemon,
	fn func(context.Context, network.Network) (Res, error),
) (
	Res, error,
) {
	d.l.RLock()
	defer d.l.RUnlock()

	network, err := pickNetwork(ctx, d.networkLoader, d.networks)
	if err != nil {
		var zero Res
		return zero, err
	}

	return fn(ctx, network)
}

// GetNetworks returns all networks which have been joined by the Daemon,
// ordered by their name.
func (d *Daemon) GetNetworks(
	ctx context.Context,
) (
	[]bootstrap.CreationParams, error,
) {
	d.l.RLock()
	defer d.l.RUnlock()

	res := make([]bootstrap.CreationParams, 0, len(d.networks))
	for id, network := range d.networks {
		creationParams, err := network.GetNetworkCreationParams(ctx)
		if err != nil {
			return nil, fmt.Errorf(
				"getting network creation params of network %q: %w", id, err,
			)
		}

		res = append(res, creationParams)
	}

	sort.Slice(res, func(i, j int) bool {
		return res[i].Name < res[j].Name
	})

	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) {
			return n.GetHosts(ctx)
		},
	)
}

// GetGarageClientParams implements the method for the network.RPC interface.
func (d *Daemon) GetGarageClientParams(
	ctx context.Context,
) (
	network.GarageClientParams, error,
) {
	return withNetwork(
		ctx,
		d,
		func(
			ctx context.Context, n network.Network,
		) (
			network.GarageClientParams, error,
		) {
			return n.GetGarageClientParams(ctx)
		},
	)
}

// GetNebulaCAPublicCredentials implements the method for the network.RPC
// interface.
func (d *Daemon) GetNebulaCAPublicCredentials(
	ctx context.Context,
) (
	nebula.CAPublicCredentials, error,
) {
	return withNetwork(
		ctx,
		d,
		func(
			ctx context.Context, n network.Network,
		) (
			nebula.CAPublicCredentials, error,
		) {
			return n.GetNebulaCAPublicCredentials(ctx)
		},
	)
}

// RemoveHost implements the method for the network.RPC interface.
func (d *Daemon) RemoveHost(ctx context.Context, hostName nebula.HostName) error {
	_, err := withNetwork(
		ctx,
		d,
		func(
			ctx context.Context, n network.Network,
		) (
			struct{}, error,
		) {
			return struct{}{}, n.RemoveHost(ctx, hostName)
		},
	)
	return err
}

// CreateHost implements the method for the network.RPC interface.
func (d *Daemon) CreateHost(
	ctx context.Context,
	hostName nebula.HostName,
	opts network.CreateHostOpts,
) (
	network.JoiningBootstrap, error,
) {
	return withNetwork(
		ctx,
		d,
		func(
			ctx context.Context, n network.Network,
		) (
			network.JoiningBootstrap, error,
		) {
			return n.CreateHost(ctx, hostName, opts)
		},
	)
}

// CreateNebulaCertificate implements the method for the network.RPC interface.
func (d *Daemon) CreateNebulaCertificate(
	ctx context.Context,
	hostName nebula.HostName,
	hostPubKey nebula.EncryptingPublicKey,
) (
	nebula.Certificate, error,
) {
	return withNetwork(
		ctx,
		d,
		func(
			ctx context.Context, n network.Network,
		) (
			nebula.Certificate, error,
		) {
			return n.CreateNebulaCertificate(ctx, hostName, hostPubKey)
		},
	)
}

func (d *Daemon) GetConfig(
	ctx context.Context,
) (
	daecommon.NetworkConfig, error,
) {
	return withNetwork(
		ctx,
		d,
		func(
			ctx context.Context, n network.Network,
		) (
			daecommon.NetworkConfig, error,
		) {
			return n.GetConfig(ctx)
		},
	)
}

// Shutdown blocks until all resources held or created by the daemon,
// including child processes it has started, have been cleaned up.
//
// If this returns an error then it's possible that child processes are
// still running and are no longer managed.
func (d *Daemon) Shutdown() error {
	d.l.Lock()
	defer d.l.Unlock()

	var (
		errCh = make(chan error, len(d.networks))
		errs  []error
	)

	for id := range d.networks {
		var (
			id = id
			n  = d.networks[id]
		)

		go func() {
			if err := n.Shutdown(); err != nil {
				errCh <- fmt.Errorf("shutting down network %q: %w", id, err)
			}
			errCh <- nil
		}()
	}

	for range cap(errCh) {
		errs = append(errs, <-errCh)
	}

	return errors.Join(errs...)
}