isle/go/daemon/network/loader.go

303 lines
6.6 KiB
Go
Raw Normal View History

//go:generate mockery --name Loader --inpackage --filename loader_mock.go
package network
import (
"context"
"fmt"
"isle/bootstrap"
"isle/daemon/children"
"isle/daemon/daecommon"
"isle/nebula"
"isle/toolkit"
"dev.mediocregopher.com/mediocre-go-lib.git/mlog"
)
func networkStateDir(
networksStateDir toolkit.Dir, networkID string, mayExist bool,
) (
toolkit.Dir, error,
) {
return networksStateDir.MkChildDir(networkID, mayExist)
}
func networkRuntimeDir(
networksRuntimeDir toolkit.Dir, networkID string, mayExist bool,
) (
toolkit.Dir, error,
) {
return networksRuntimeDir.MkChildDir(networkID, mayExist)
}
func networkDirs(
networksStateDir, networksRuntimeDir toolkit.Dir,
networkID string,
mayExist bool,
) (
stateDir, runtimeDir toolkit.Dir, err error,
) {
h := new(toolkit.MkDirHelper)
stateDir, _ = h.Maybe(
networkStateDir(networksStateDir, networkID, mayExist),
)
runtimeDir, _ = h.Maybe(
networkRuntimeDir(networksRuntimeDir, networkID, mayExist),
)
err = h.Err()
return
}
// Loader is responsible for joining/creating Networks and making them loadable
// later.
type Loader interface {
// Loadable returns the CreationParams for all Networks which can be Loaded.
Loadable(context.Context) ([]bootstrap.CreationParams, error)
// Load initializes and returns a Network instance for a network which was
// previously joined or created, and which has the given CreationParams.
Load(
context.Context,
*mlog.Logger,
bootstrap.CreationParams,
*Opts,
) (
Network, error,
)
// Join initializes and returns a Network instance for an existing network
// which was not previously joined to on this host. Once Join has been
// called for a particular network it will error on subsequent calls for
// that same network, Load should be used instead.
Join(
context.Context,
*mlog.Logger,
JoiningBootstrap,
*Opts,
) (
Network, error,
)
// Create initializes and returns a Network for a brand new network which
// uses the given creation 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.
//
// Errors:
// - ErrInvalidConfig - If the Opts.Config field is not valid. It must be
// non-nil and have at least 3 storage allocations.
Create(
context.Context,
*mlog.Logger,
bootstrap.CreationParams,
nebula.IPNet,
nebula.HostName,
*Opts,
) (
Network, error,
)
}
// LoaderOpts are optional parameters which can be passed in when initializing a
// new Loader instance. A nil LoaderOpts is equivalent to a zero value.
type LoaderOpts struct {
// Defaults to that returned by daecommon.GetEnvVars.
EnvVars daecommon.EnvVars
}
func (o *LoaderOpts) withDefaults() *LoaderOpts {
if o == nil {
o = new(LoaderOpts)
}
if o.EnvVars == (daecommon.EnvVars{}) {
o.EnvVars = daecommon.GetEnvVars()
}
return o
}
type loader struct {
envBinDirPath string
networksStateDir toolkit.Dir
networksRuntimeDir toolkit.Dir
nebulaDeviceNamer *children.NebulaDeviceNamer
}
// NewLoader returns a new Loader which will use the given directories to load
// and create Network instances.
func NewLoader(
ctx context.Context,
logger *mlog.Logger,
envBinDirPath string,
opts *LoaderOpts,
) (
Loader, error,
) {
opts = opts.withDefaults()
if err := migrateToMultiNetworkStateDirectory(
ctx,
logger.WithNamespace("migration-multi-network-state-dir"),
opts.EnvVars.StateDir,
); err != nil {
return nil, fmt.Errorf(
"migrating to multi-network state directory: %w", err,
)
}
h := new(toolkit.MkDirHelper)
networksStateDir, _ := h.Maybe(
opts.EnvVars.StateDir.MkChildDir("networks", true),
)
networksRuntimeDir, _ := h.Maybe(
opts.EnvVars.RuntimeDir.MkChildDir("networks", true),
)
if err := h.Err(); err != nil {
return nil, fmt.Errorf("creating networks sub-directories: %w", err)
}
return &loader{
envBinDirPath,
networksStateDir,
networksRuntimeDir,
children.NewNebulaDeviceNamer(),
}, nil
}
func (l *loader) Loadable(
ctx context.Context,
) (
[]bootstrap.CreationParams, error,
) {
networkStateDirs, err := l.networksStateDir.ChildDirs()
if err != nil {
return nil, fmt.Errorf(
"listing children of %q: %w", l.networksStateDir.Path, err,
)
}
creationParams := make([]bootstrap.CreationParams, 0, len(networkStateDirs))
for _, networkStateDir := range networkStateDirs {
thisCreationParams, err := loadCreationParams(networkStateDir)
if err != nil {
return nil, fmt.Errorf(
"loading creation params from %q: %w",
networkStateDir.Path,
err,
)
}
creationParams = append(creationParams, thisCreationParams)
}
return creationParams, nil
}
func (l *loader) Load(
ctx context.Context,
logger *mlog.Logger,
creationParams bootstrap.CreationParams,
opts *Opts,
) (
Network, error,
) {
networkID := creationParams.ID
networkStateDir, networkRuntimeDir, err := networkDirs(
l.networksStateDir, l.networksRuntimeDir, networkID, true,
)
if err != nil {
return nil, fmt.Errorf(
"creating sub-directories for network %q: %w", networkID, err,
)
}
return load(
ctx,
logger,
l.envBinDirPath,
l.nebulaDeviceNamer,
networkStateDir,
networkRuntimeDir,
opts,
)
}
func (l *loader) Join(
ctx context.Context,
logger *mlog.Logger,
joiningBootstrap JoiningBootstrap,
opts *Opts,
) (
Network, error,
) {
var (
creationParams = joiningBootstrap.Bootstrap.NetworkCreationParams
networkID = creationParams.ID
)
networkStateDir, networkRuntimeDir, err := networkDirs(
l.networksStateDir, l.networksRuntimeDir, networkID, false,
)
if err != nil {
return nil, fmt.Errorf(
"creating sub-directories for network %q: %w", networkID, err,
)
}
return join(
ctx,
logger,
l.envBinDirPath,
l.nebulaDeviceNamer,
joiningBootstrap,
networkStateDir,
networkRuntimeDir,
opts,
)
}
func (l *loader) Create(
ctx context.Context,
logger *mlog.Logger,
creationParams bootstrap.CreationParams,
ipNet nebula.IPNet,
hostName nebula.HostName,
opts *Opts,
) (
Network, error,
) {
networkID := creationParams.ID
networkStateDir, networkRuntimeDir, err := networkDirs(
l.networksStateDir, l.networksRuntimeDir, networkID, false,
)
if err != nil {
return nil, fmt.Errorf(
"creating sub-directories for network %q: %w", networkID, err,
)
}
return create(
ctx,
logger,
l.envBinDirPath,
l.nebulaDeviceNamer,
networkStateDir,
networkRuntimeDir,
creationParams,
ipNet,
hostName,
opts,
)
}