132 lines
3.0 KiB
Go
132 lines
3.0 KiB
Go
package daemon
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"isle/bootstrap"
|
|
"isle/daemon/network"
|
|
"isle/toolkit"
|
|
)
|
|
|
|
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
|
|
}
|
|
|
|
// loadableNetworks returns the CreationParams for each Network which is able to
|
|
// be loaded.
|
|
func loadableNetworks(
|
|
networksStateDir toolkit.Dir,
|
|
) (
|
|
[]bootstrap.CreationParams, error,
|
|
) {
|
|
networkStateDirs, err := networksStateDir.ChildDirs()
|
|
if err != nil {
|
|
return nil, fmt.Errorf(
|
|
"listing children of %q: %w", networksStateDir.Path, err,
|
|
)
|
|
}
|
|
|
|
creationParams := make([]bootstrap.CreationParams, 0, len(networkStateDirs))
|
|
|
|
for _, networkStateDir := range networkStateDirs {
|
|
thisCreationParams, err := network.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 pickNetwork(
|
|
ctx context.Context,
|
|
networks map[string]joinedNetwork,
|
|
networksStateDir toolkit.Dir,
|
|
) (
|
|
joinedNetwork, error,
|
|
) {
|
|
if len(networks) == 0 {
|
|
return joinedNetwork{}, ErrNoNetwork
|
|
}
|
|
|
|
creationParams, err := loadableNetworks(networksStateDir)
|
|
if err != nil {
|
|
return joinedNetwork{}, fmt.Errorf("getting loadable networks: %w", err)
|
|
}
|
|
|
|
var (
|
|
networkSearchStr = getNetworkSearchStr(ctx)
|
|
matchingNetworkIDs = make([]string, 0, len(networks))
|
|
)
|
|
|
|
for _, creationParam := range creationParams {
|
|
if networkSearchStr == "" || creationParam.Matches(networkSearchStr) {
|
|
matchingNetworkIDs = append(matchingNetworkIDs, creationParam.ID)
|
|
}
|
|
}
|
|
|
|
if len(matchingNetworkIDs) == 0 {
|
|
return joinedNetwork{}, ErrNoMatchingNetworks
|
|
} else if len(matchingNetworkIDs) > 1 {
|
|
return joinedNetwork{}, ErrMultipleMatchingNetworks
|
|
}
|
|
|
|
return networks[matchingNetworkIDs[0]], nil
|
|
}
|
|
|
|
func alreadyJoined(
|
|
ctx context.Context,
|
|
networks map[string]joinedNetwork,
|
|
creationParams bootstrap.CreationParams,
|
|
) (
|
|
bool, error,
|
|
) {
|
|
for networkID, network := range networks {
|
|
existingCreationParams, err := network.GetNetworkCreationParams(ctx)
|
|
if err != nil {
|
|
return false, fmt.Errorf(
|
|
"getting creation params of network %q: %w", networkID, err,
|
|
)
|
|
} else if existingCreationParams.Conflicts(creationParams) {
|
|
return true, nil
|
|
}
|
|
}
|
|
|
|
return false, nil
|
|
}
|