Struct Scheduler

pub struct Scheduler<Creds> { /* private fields */ }

A scheduler client to interact with the scheduler service. It has different implementations depending on the implementations

Implementations

impl<Creds> Scheduler<Creds>

where Creds: TlsConfigProvider,

pub async fn new(network: Network, creds: Creds) -> Result<Scheduler<Creds>>

Creates a new scheduler client with the provided parameters. A scheduler created this way is considered unauthenticated and limited in its scope.

Example

let node_id = vec![0, 1, 2, 3];
let network = Network::Regtest;
let creds = Nobody::new();
let scheduler = Scheduler::new(network, creds).await.unwrap();

pub async fn with( network: Network, creds: Creds, uri: impl Into<String>, ) -> Result<Scheduler<Creds>>

Creates a new scheduler client with the provided parameters and custom URI. A scheduler created this way is considered unauthenticated and limited in its scope.

Example

let node_id = vec![0, 1, 2, 3];
let network = Network::Regtest;
let creds = Nobody::new();
let uri = "https://example.com".to_string();
let scheduler = Scheduler::with(network, creds, uri).await.unwrap();

impl<Creds> Scheduler<Creds>

pub async fn register( &self, signer: &Signer, invite_code: Option<String>, ) -> Result<RegistrationResponse>

Registers a new node with the scheduler service.

Arguments

• signer - The signer instance bound to the node.
• invite_code - Optional invite code to register the node.

Example

let node_id = vec![0, 1, 2, 3];
let network = Network::Regtest;
let creds = Nobody::new();
let scheduler = Scheduler::new(network, creds.clone()).await.unwrap();
let secret = vec![0, 0, 0, 0];
let signer = Signer::new(secret, network, creds).unwrap(); // Create or obtain a signer instance
let registration_response = scheduler.register(&signer, None).await.unwrap();

pub async fn recover(&self, signer: &Signer) -> Result<RecoveryResponse>

Recovers a previously registered node with the scheduler service.

Arguments

• signer - The signer instance used to sign the recovery challenge.

Example

let node_id = vec![0, 1, 2, 3];
let network = Network::Regtest;
let creds = Nobody::new();
let scheduler = Scheduler::new(network, creds.clone()).await.unwrap();
let secret = vec![0, 0, 0, 0];
let signer = Signer::new(secret, network, creds).unwrap(); // Create or obtain a signer instance
let recovery_response = scheduler.recover(&signer).await.unwrap();

pub async fn authenticate<Auth>(&self, creds: Auth) -> Result<Scheduler<Auth>>

where Auth: TlsConfigProvider + RuneProvider,

Elevates the scheduler client to an authenticated scheduler client that is able to schedule a node for example.

Arguments

• creds - Credentials that carry a TlsConfig and a Rune. These are credentials returned during registration or recovery.

Example

let node_id = vec![0, 1, 2, 3];
let network = Network::Regtest;
let creds = Nobody::new();
let scheduler_unauthed = Scheduler::new(network, creds.clone()).await.unwrap();
let secret = vec![0, 0, 0, 0];
let signer = Signer::new(secret, network, creds).unwrap(); // Create or obtain a signer instance
let registration_response = scheduler_unauthed.register(&signer, None).await.unwrap();
let creds = Device::from_bytes(registration_response.creds);
let scheduler_authed = scheduler_unauthed.authenticate(creds);

impl<Creds> Scheduler<Creds>

where Creds: TlsConfigProvider + RuneProvider + NodeIdProvider + Clone,

pub async fn schedule(&self) -> Result<NodeInfoResponse>

Schedules a node at the scheduler service. Once a node is scheduled one can access it through the node client.

Example

let node_id = vec![0, 1, 2, 3];
let network = Network::Regtest;
let creds = Device::from_path("my/path/to/credentials.glc");
let scheduler = Scheduler::new(network, creds.clone()).await.unwrap();
let info = scheduler.schedule().await.unwrap();
let node_client: Client  = Node::new(node_id, creds).unwrap().connect(info.grpc_uri).await.unwrap();

pub async fn node<T>(&self) -> Result<T>

where T: GrpcClient,

Schedules a node at the scheduler service and returns a node client.

Example

let node_id = vec![0, 1, 2, 3];
let network = Network::Regtest;
let creds = Device::from_path("my/path/to/credentials.glc");
let scheduler = Scheduler::new(network, creds.clone()).await.unwrap();
let node_client: Client  = scheduler.node().await.unwrap();

pub async fn get_node_info(&self, wait: bool) -> Result<NodeInfoResponse>

pub async fn export_node(&self) -> Result<ExportNodeResponse>

pub async fn get_invite_codes(&self) -> Result<ListInviteCodesResponse>

pub async fn add_outgoing_webhook( &self, uri: String, ) -> Result<AddOutgoingWebhookResponse>

pub async fn list_outgoing_webhooks( &self, ) -> Result<ListOutgoingWebhooksResponse>

pub async fn delete_webhooks(&self, webhook_ids: Vec<i64>) -> Result<Empty>

pub async fn rotate_outgoing_webhook_secret( &self, webhook_id: i64, ) -> Result<WebhookSecretResponse>

Trait Implementations

impl<Creds: Clone> Clone for Scheduler<Creds>

fn clone(&self) -> Scheduler<Creds>

Returns a copy of the value.

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

Performs copy-assignment from source.