package daemon import ( "cmp" "context" "fmt" "isle/bootstrap" "isle/nebula" "net/netip" "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, ) ( struct{}, error, ) { return struct{}{}, 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 JoiningBootstrap, ) ( 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 the call through to the Daemon method of the // same name. func (r *RPC) GetGarageClientParams( ctx context.Context, req struct{}, ) ( GarageClientParams, error, ) { return r.daemon.GetGarageClientParams(ctx) } // GetNebulaCAPublicCredentials returns the CAPublicCredentials for the network. 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 } // RemoveHostRequest contains the arguments to the RemoveHost RPC method. // // All fields are required. type RemoveHostRequest struct { HostName nebula.HostName } // RemoveHost passes the call through to the Daemon method of the same name. func (r *RPC) RemoveHost(ctx context.Context, req RemoveHostRequest) (struct{}, error) { return struct{}{}, r.daemon.RemoveHost(ctx, req.HostName) } // CreateHostRequest contains the arguments to the // CreateHost RPC method. // // All fields are required. type CreateHostRequest struct { HostName nebula.HostName IP netip.Addr Opts CreateHostOpts } // CreateHostResult wraps the results from the CreateHost RPC method. type CreateHostResult struct { JoiningBootstrap JoiningBootstrap } // CreateHost passes the call through to the Daemon method of the // same name. func (r *RPC) CreateHost( ctx context.Context, req CreateHostRequest, ) ( CreateHostResult, error, ) { joiningBootstrap, err := r.daemon.CreateHost( ctx, req.HostName, req.IP, req.Opts, ) if err != nil { return CreateHostResult{}, err } return CreateHostResult{JoiningBootstrap: joiningBootstrap}, nil } // CreateNebulaCertificateRequest contains the arguments to the // CreateNebulaCertificate RPC method. // // All fields are required. type CreateNebulaCertificateRequest struct { HostName nebula.HostName HostEncryptingPublicKey nebula.EncryptingPublicKey Opts CreateNebulaCertificateOpts } // CreateNebulaCertificateResult wraps the results from the // CreateNebulaCertificate RPC method. type CreateNebulaCertificateResult struct { HostNebulaCertifcate nebula.Certificate } // CreateNebulaCertificate passes the call through to the Daemon method of the // same name. func (r *RPC) CreateNebulaCertificate( ctx context.Context, req CreateNebulaCertificateRequest, ) ( CreateNebulaCertificateResult, error, ) { cert, err := r.daemon.CreateNebulaCertificate( ctx, req.HostName, req.HostEncryptingPublicKey, req.Opts, ) if err != nil { return CreateNebulaCertificateResult{}, err } return CreateNebulaCertificateResult{ HostNebulaCertifcate: cert, }, nil }