package daemon import ( "cmp" "context" "fmt" "isle/admin" "isle/bootstrap" "isle/nebula" "slices" "golang.org/x/exp/maps" ) // RPC exposes all RPC methods which are available to be called over the RPC // interface. type RPC struct { daemon Daemon } // NewRPC initializes and returns an RPC instance. func NewRPC(daemon Daemon) *RPC { return &RPC{daemon} } // CreateNetworkRequest contains the arguments to the CreateNetwork RPC method. // // All fields are required. type CreateNetworkRequest struct { // Human-readable name of the network. Name string // Primary domain name that network services are served under. Domain string // 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. IPNet nebula.IPNet // The name of this first host in the network. HostName nebula.HostName } // CreateNetwork passes through to the Daemon method of the same name. func (r *RPC) CreateNetwork( ctx context.Context, req CreateNetworkRequest, ) ( admin.Admin, error, ) { return r.daemon.CreateNetwork( ctx, req.Name, req.Domain, req.IPNet, req.HostName, ) } // JoinNetwork passes through to the Daemon method of the same name. func (r *RPC) JoinNetwork( ctx context.Context, req bootstrap.Bootstrap, ) ( struct{}, error, ) { return struct{}{}, r.daemon.JoinNetwork(ctx, req) } // GetHostsResult wraps the results from the GetHosts RPC method. type GetHostsResult struct { Hosts []bootstrap.Host } // GetHosts returns all hosts known to the network, sorted by their name. func (r *RPC) GetHosts( ctx context.Context, req struct{}, ) ( GetHostsResult, error, ) { b, err := r.daemon.GetBootstrap(ctx) if err != nil { return GetHostsResult{}, fmt.Errorf("retrieving bootstrap: %w", err) } hosts := maps.Values(b.Hosts) slices.SortFunc(hosts, func(a, b bootstrap.Host) int { return cmp.Compare(a.Name, b.Name) }) return GetHostsResult{hosts}, nil } // GetGarageClientParams passes through to the Daemon method of the same name. func (r *RPC) GetGarageClientParams( ctx context.Context, req struct{}, ) ( bootstrap.GarageClientParams, error, ) { b, err := r.daemon.GetBootstrap(ctx) if err != nil { return bootstrap.GarageClientParams{}, fmt.Errorf( "retrieving bootstrap: %w", err, ) } return b.GarageClientParams(), nil } func (r *RPC) GetNebulaCAPublicCredentials( ctx context.Context, req struct{}, ) ( nebula.CAPublicCredentials, error, ) { b, err := r.daemon.GetBootstrap(ctx) if err != nil { return nebula.CAPublicCredentials{}, fmt.Errorf( "retrieving bootstrap: %w", err, ) } return b.CAPublicCredentials, nil }