Struct Server 

pub struct Server<S, C, P>
where
    S: MembershipStorage,
    C: ClusterProvider<S>,
    P: ObjectPlacement,
{ /* private fields */ }

Application Server. It handles object registration (Registry), clustering (through ClusterProviders), server state (via AppData), and more.

It handles various types of request: AdminCommands, RequestEnvelope, and SubscriptionRequest.

More of it can be seen in Server::run.

TODO example builder

Implementations

impl<S, C, P> Server<S, C, P>

where S: MembershipStorage, C: ClusterProvider<S>, P: ObjectPlacement,

pub fn builder() -> ServerBuilder<S, C, P>

Create an instance of Server using the builder syntax

impl<S, C, P> Server<S, C, P>

where S: MembershipStorage + 'static, C: ClusterProvider<S> + Send + Sync + 'static, P: ObjectPlacement + 'static,

pub async fn prepare(&self)

pub fn app_data<Data>(&mut self, data: Data)

where Data: Send + Sync + 'static,

pub async fn bind(&mut self) -> Result<TcpListener, ServerError>

Setup the server for running it

pub fn try_local_addr(listener: &TcpListener) -> Result<SocketAddr, ServerError>

Tries to get a local address

It will get the first ip address for the machine where it is running, and fallback to the address given by tokio’s listener

**TODO**

It potentially won’t work on machine with multiple interfaces. So we need to add support to address mapping per node before merging this.

For now, if that is your case, you need to specify the IP for binding

pub async fn run(&mut self, listener: TcpListener) -> Result<(), ServerError>

Run the server forever

This is the main loop for a Rio server. It will handle a few types of future concurrently:

• New TCP connections from clients
• AdminCommands messages from running objects
• ClusterProvider server loop

If any of these fails, the server stops running with a ServerError

Trait Implementations

impl<S, C, P> TryFrom<&Server<S, C, P>> for Service<S, P>

where S: MembershipStorage + 'static, C: ClusterProvider<S> + 'static + Send + Sync, P: ObjectPlacement + 'static,

Transforms a Server into a Service

It can’t be infalible, because it needs to be bind so it can generate a Service

type Error = ServerError

The type returned in the event of a conversion error.

fn try_from(server: &Server<S, C, P>) -> Result<Self, Self::Error>

Performs the conversion.