Crate tari_service_framework

Service framework

This module contains the building blocks for async services.

It consists of the following modules:

initializer

This module contains the ServiceInitializer trait. Service modules should implement this trait and pass that implementation to the StackBuilder.

stack

Contains the StackBuilder that is responsible for collecting and 'executing' the implementations of ServiceInitializer.

handles

A set of utilities used to collect and share handles between services. The StackBuilder is responsible for initializing a ServiceHandlesFuture and making it available to ServiceInitializer implementations.

Handles are simply a way to communicate with their corresponding service. Typically, a SenderService would be used for this purpose but a handle can be implemented in any way the implementor sees fit.

reply_channel

This provides for query messages to be sent to services along with a "reply channel" for the service to send back results. The reply_channel::unbounded function is used to create a sender/receiver pair. The sender implements tower_service::Service and can be used to make requests of a applicable type. The receiver implements futures::Stream and will provide a RequestContext object that contains a oneshot reply channel that the service can use to reply back to the caller.

Examples

reply_channel

use tari_service_framework::{reply_channel, tower::ServiceExt};

block_on(async {
   let (mut sender, mut receiver) = reply_channel::unbounded();

   let (result, _) = futures::join!(
        // Make the request and make progress on the resulting future
        sender.call_ready("upper"),
        // At the same time receive the request and reply
        async move {
          let req_context = receiver.next().await.unwrap();
          let msg = req_context.request().unwrap().clone();
          req_context.reply(msg.to_uppercase());
        }
    );

   assert_eq!(result.unwrap(), "UPPER");
});

Modules

reply_channel
tower

Structs

LazyService	LazyService
RegisterHandle	This initializer adds a handle to the service context.
ServiceHandles	Simple collection for named handles
ServiceInitializerContext	Contains context for service initialization.
StackBuilder	Responsible for building and collecting handles and (usually long-running) service futures. finish is an async function which resolves once all the services are initialized, or returns an error if any one of the services fails to initialize.

Traits

Service	An asynchronous function from a Request to a Response.
ServiceInitializer	Implementors of this trait will initialize a service The StackBuilder builds impls of this trait.

Type Definitions

ServiceInitializationError