Struct NodeServer

pub struct NodeServer<T: Node> { /* private fields */ }

The node service represents your node running on greenlight’s infrastructure. You can use the exposed RPC methods to interact with your node. The URI used to connect to the node depends on where the node is being scheduled and is returned by the Scheduler.Schedule() RPC call.

Notice that in order to connect to the node the caller must use the node-specific mTLS keypair returned by Scheduler.Register() or Scheduler.Recover(). In particular the anonymous mTLS keypair is rejected by the node.

Deprecated methods are being replaced by the standardized and automatically managed cln-grpc protocol you can find in node.proto

Implementations

impl<T: Node> NodeServer<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.

Trait Implementations

impl<T: Node> Clone for NodeServer<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Node> Debug for NodeServer<T>

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

Formats the value using the given formatter.

impl<T: Node> NamedService for NodeServer<T>

const NAME: &'static str = "greenlight.Node"

The Service-Name as described here.

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

where T: Node, 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<<NodeServer<T> as Service<Request<B>>>::Response, <NodeServer<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.