Struct CompositeSocketServer

pub struct CompositeSocketServer<const CONFIG: u64, StateType: Send + Sync + Clone + Debug + 'static> { /* private fields */ }

Real definition & implementation for our Socket Server, full of generic parameters.
Probably you want to instantiate this structure through the sugared macros new_socket_server!() or new_composite_socket_server!() instead. Generic Parameters:

• CONFIG: the u64 version of the [ConstConfig] instance used to build this struct – from which ProcessorUniType and SenderChannel derive;
• RemoteMessages: the messages that are generated by the clients (usually an enum);
• LocalMessages: the messages that are generated by the server (usually an enum);
• ProcessorUniType: an instance of a reactive-mutiny’s [Uni] type (using one of the zero-copy channels) – This [Uni] will execute the given server reactive logic for each incoming message (see how it is used in new_socket_server!() or new_composite_socket_server!());
• SenderChannel: an instance of a reactive-mutiny’s Uni movable Channel, which will provide a Stream of messages to be sent to the client;
• StateType: The state type used by the “connection routing closure” (to be provided), enabling the “Composite Protocol Stacking” pattern.

Implementations

impl<const CONFIG: u64, StateType: Send + Sync + Clone + Debug + 'static> CompositeSocketServer<CONFIG, StateType>

pub fn new<IntoString: Into<String>>( interface_ip: IntoString, port: u16, ) -> Self

Creates a new server instance listening on TCP/IP: interface_ip: the interface’s IP to listen to – 0.0.0.0 will cause listening to all network interfaces port: what port to listen to

Trait Implementations

impl<const CONFIG: u64, StateType: Send + Sync + Clone + Debug + 'static> MessagingService<CONFIG> for CompositeSocketServer<CONFIG, StateType>

type StateType = StateType

async fn spawn_processor<RemoteMessages: ReactiveMessagingDeserializer<RemoteMessages> + Send + Sync + PartialEq + Debug + 'static, LocalMessages: ReactiveMessagingSerializer<LocalMessages> + Send + Sync + PartialEq + Debug + 'static, ProcessorUniType: GenericUni<ItemType = RemoteMessages> + Send + Sync + 'static, SenderChannel: FullDuplexUniChannel<ItemType = LocalMessages, DerivedItemType = LocalMessages> + Send + Sync + 'static, OutputStreamItemsType: Send + Sync + Debug + 'static, ServerStreamType: Stream<Item = OutputStreamItemsType> + Send + 'static, ConnectionEventsCallbackFuture: Future<Output = ()> + Send + 'static, ConnectionEventsCallback: Fn(ProtocolEvent<CONFIG, LocalMessages, SenderChannel, StateType>) -> ConnectionEventsCallbackFuture + Send + Sync + 'static, ProcessorBuilderFn: Fn(String, u16, Arc<Peer<CONFIG, LocalMessages, SenderChannel, StateType>>, MessagingMutinyStream<ProcessorUniType>) -> ServerStreamType + Send + Sync + 'static>( &mut self, connection_events_callback: ConnectionEventsCallback, dialog_processor_builder_fn: ProcessorBuilderFn, ) -> Result<ConnectionChannel<StateType>, Box<dyn Error + Sync + Send>>

Spawns a task dedicated to the given “protocol processor”, returning immediately.
The given dialog_processor_builder_fn will be called for each new connection and should return a Stream that will produce non-futures & non-fallible items that may be, optionally, sent to the remote party (see crate::prelude::ResponsiveStream):

async fn start_multi_protocol<ConnectionEventsCallbackFuture: Future<Output = ()> + Send>( &mut self, initial_connection_state: StateType, connection_routing_closure: impl FnMut(&SocketConnection<StateType>, bool) -> Option<Sender<SocketConnection<StateType>>> + Send + 'static, connection_events_callback: impl for<'r> Fn(ConnectionEvent<'r, StateType>) -> ConnectionEventsCallbackFuture + Send + 'static, ) -> Result<(), Box<dyn Error + Sync + Send>>

Starts the service using the provided connection_routing_closure to distribute the connections among the configured processors – previously fed in by [Self::spawn_responsive_processor()] & [Self::spawn_unresponsive_processor()].

fn termination_waiter( &mut self, ) -> Box<dyn FnOnce() -> BoxFuture<'static, Result<(), Box<dyn Error + Send + Sync>>>>

Returns an async closure that blocks until Self::terminate() is called. Example:

async fn terminate(self) -> Result<(), Box<dyn Error + Send + Sync>>

Notifies the service it is time to stop / shutdown / terminate.
It is a recommended practice that the connection_events_handler() you provided (when starting each dialog processor) inform all clients that a remote-initiated disconnection (due to the call to this function) is happening – the protocol must support that, though.

async fn start_single_protocol( &mut self, connection_channel: ConnectionChannel<Self::StateType>, ) -> Result<(), Box<dyn Error + Sync + Send>>

where Self::StateType: Default,

Start the service with a single processor (after calling either [Self::spawn_unresponsive_processor()] or [Self::spawn_responsive_processor()] once) – A.K.A. “The Single Protocol Mode”.
See Self::start_multi_protocol() if you want a service that shares connections among different protocol processors.