// 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 config *daecommon.NetworkConfig } // 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) ) n, err := networkLoader.Load( ctx, logger.WithNamespace("network"), creationParams, &network.Opts{ Config: networkConfig, }, ) if err != nil { return nil, fmt.Errorf("loading network %q: %w", id, err) } d.networks[id] = joinedNetwork{n, networkConfig} } 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 { 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 { return ErrAlreadyJoined } d.logger.Info(ctx, "Creating network") n, err := d.networkLoader.Create( ctx, d.logger.WithNamespace("network"), creationParams, ipNet, hostName, &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{n, networkConfig} 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 { d.l.Lock() defer d.l.Unlock() var ( creationParams = newBootstrap.Bootstrap.NetworkCreationParams networkID = creationParams.ID networkConfig = pickNetworkConfig(d.daemonConfig, creationParams) ) ctx = mctx.WithAnnotator(ctx, newBootstrap.Bootstrap.NetworkCreationParams) 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"), newBootstrap, &network.Opts{ Config: networkConfig, }, ) if err != nil { return fmt.Errorf( "joining network %q: %w", networkID, err, ) } d.logger.Info(ctx, "Network joined successfully") d.networks[networkID] = joinedNetwork{n, networkConfig} return nil } func withNetwork[Res any]( ctx context.Context, d *Daemon, fn func(context.Context, joinedNetwork) (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 } // 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) { 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 joinedNetwork, ) ( 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 joinedNetwork, ) ( 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 joinedNetwork, ) ( 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 joinedNetwork, ) ( 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 joinedNetwork, ) ( nebula.Certificate, error, ) { return n.CreateNebulaCertificate(ctx, hostName, hostPubKey) }, ) } // GetConfig implements the method for the network.RPC interface. func (d *Daemon) GetConfig( ctx context.Context, ) ( daecommon.NetworkConfig, error, ) { return withNetwork( ctx, d, func( ctx context.Context, n joinedNetwork, ) ( daecommon.NetworkConfig, error, ) { return n.GetConfig(ctx) }, ) } // 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{}{}, ErrManagedNetworkConfig } // 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. // // 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...) }