Struct SchedulerServer 

pub struct SchedulerServer<T: Scheduler> { /* private fields */ }

The scheduler service is the endpoint which allows users to register a new node with greenlight, recover access to an existing node if the owner lost its credentials, schedule the node to be run on greenlight’s infrastructure, and retrieve metadata about the node.

Node

A node is the basic object representing an account on greenlight. Each node corresponds to a c-lightning instance bound to a specific network that can be scheduled on greenlight, and must have a unique node_id.

Nodes are scheduled on-demand onto the infrastructure, but the time to schedule a node is almost instantaneous.

Authentication

Users are authenticated using mTLS authentication. Applications are provisioned with an anonymous keypair that is not bound to a node, allowing access only to the unauthenticated endpoints Scheduler.GetChallenge, Scheduler.Register and Scheduler.Recover. This allows them to register or recover a node, but doesn’t give access to the node itself. Upon registering or recovering an account the user receives a keypair that is bound to the specific node. Once the user receives their personal mTLS keypair they may use it to connect to greenlight, and thus get access to the node-specific functionality. Please refer to the documentation of your grpc library to learn how to configure grpc to use the node-specific mTLS keypair.

Implementations

impl<T: Scheduler> SchedulerServer<T>

pub fn new(inner: T) -> Self

pub fn from_arc(inner: Arc<T>) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> InterceptedService<Self, F>

where F: Interceptor,

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing requests with the given encoding.

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress responses with the given encoding, if the client supports it.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

Trait Implementations

impl<T: Scheduler> Clone for SchedulerServer<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Scheduler> Debug for SchedulerServer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Scheduler> NamedService for SchedulerServer<T>

const NAME: &'static str = "scheduler.Scheduler"

The Service-Name as described here.

impl<T, B> Service<Request<B>> for SchedulerServer<T>

where T: Scheduler, B: Body + Send + 'static, B::Error: Into<StdError> + Send + 'static,

type Response = Response<UnsyncBoxBody<Bytes, Status>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<SchedulerServer<T> as Service<Request<B>>>::Response, <SchedulerServer<T> as Service<Request<B>>>::Error>> + Send>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<B>) -> Self::Future

Process the request and return the response asynchronously.