Struct TCPServer 

pub struct TCPServer<State: Clone + Send + Sync + 'static = ()> { /* private fields */ }

Available on (crate features clients or servers) and crate feature servers only.

An implementation of a TCP server.

This is the “base” TCP Server class that any of the servers that cat-dev will be built on. It has extensions for handling any potential type of server that we will ever need to support.

This server accepts lots of parameters so look at the modules documentation for general info about how processing works.

Implementations

impl TCPServer<()>

pub async fn new<AddrTy, ServiceTy>( service_name: &'static str, bind_addr: AddrTy, initial_service: ServiceTy, nagle_hooks: (Option<&'static dyn PreNagleFnTy>, Option<&'static dyn PostNagleFnTy>), guard: impl Into<NagleGuard>, trace_io_during_debug: bool, ) -> Result<Self, CommonNetAPIError>

where AddrTy: ToSocketAddrs, ServiceTy: Clone + Send + Service<Request<()>, Response = Response, Error = Infallible> + 'static, ServiceTy::Future: Send + 'static,

Create a new TCP Server without having to specify any particular state.

Errors

If we cannot look up one specific address to bind too.

impl<State: Clone + Send + Sync + 'static> TCPServer<State>

pub async fn out_of_bound_send( server_id: u64, stream_id: u64, message: ResponseStreamMessage, ) -> Result<(), CatBridgeError>

Send a message completely out of band to a particular open stream.

Errors

• If the stream is not actively open.
• If we could not actively queue a packet to go out.

pub async fn out_of_bound_broadcast( server_id: u64, message: ResponseStreamMessage, ) -> Vec<Result<(), CatBridgeError>>

Send a message completely out of band to all open stream.

pub async fn new_with_state<AddrTy, ServiceTy>( service_name: &'static str, bind_addr: AddrTy, initial_service: ServiceTy, nagle_hooks: (Option<&'static dyn PreNagleFnTy>, Option<&'static dyn PostNagleFnTy>), guard: impl Into<NagleGuard>, state: State, trace_io_during_debug: bool, ) -> Result<Self, CommonNetAPIError>

where AddrTy: ToSocketAddrs, ServiceTy: Clone + Send + Service<Request<State>, Response = Response, Error = Infallible> + 'static, ServiceTy::Future: Send + 'static,

Create a new TCP Server along with the state for this server.

Errors

If we cannot look up one specific address to bind too.

pub const fn id(&self) -> u64

Get the particular ID for this server.

pub const fn ip(&self) -> IpAddr

The IP address we should connect to bind too.

pub const fn port(&self) -> u16

Get the port that we’re either binding too, or connecting too.

pub const fn set_cat_dev_slowdown(&mut self, slowdown: Option<Duration>)

Set the slowdown to before sending bytes from this server.

pub const fn chunk_output_at_size(&self) -> Option<usize>

pub const fn set_chunk_output_at_size(&mut self, new_size: Option<usize>)

pub const fn slowloris_timeout(&self) -> Duration

pub const fn set_slowloris_timeout(&mut self, slowloris_timeout: Duration)

pub const fn on_stream_begin( &self, ) -> Option<&UnderlyingOnStreamBeginService<State>>

pub fn set_raw_on_stream_begin( &mut self, on_start: Option<UnderlyingOnStreamBeginService<State>>, ) -> Result<(), CommonNetAPIError>

Set a hook to run when a stream has been created.

This is what happens when a new machine connects. So it may also be refered to as “on connect”. This assumes you’re assigning a service that already exists and is in the raw storage type, you may want to look into Self::set_on_stream_begin, or Self::set_on_stream_begin_service.

Errors

If the stream beginning hook has already been registered. If you’re looking to perform multiple actions at once, look into layer-ing.

pub fn set_on_stream_begin<HandlerTy, HandlerParamsTy>( &mut self, handler: HandlerTy, ) -> Result<(), CommonNetAPIError>

where HandlerParamsTy: Send + 'static, HandlerTy: OnResponseStreamBeginHandler<HandlerParamsTy, State> + Clone + Send + 'static,

Set a function hook to run when a stream has been created.

This is what happens when a new machine connects. So it may also be refered to as “on connect”. This assumes you’re assigning a function to on stream begin otherwise use Self::set_raw_on_stream_begin, or Self::set_on_stream_begin_service.

Errors

If the stream beginning hook has already been registered. If you’re looking to perform multiple actions at once, look into layer-ing.

pub fn set_on_stream_begin_service<ServiceTy>( &mut self, service_ty: ServiceTy, ) -> Result<(), CommonNetAPIError>

where ServiceTy: Clone + Send + Service<ResponseStreamEvent<State>, Response = bool, Error = CatBridgeError> + 'static, ServiceTy::Future: Send + 'static,

Set a function hook to run when a stream has been created.

This is what happens when a new machine connects. So it may also be refered to as “on connect”. This assumes you’re assigning a Service to on stream begin otherwise use Self::set_raw_on_stream_begin, or Self::set_on_stream_begin.

Errors

If the stream beginning hook has already been registered. If you’re looking to perform multiple actions at once, look into layer-ing.

pub fn layer_on_stream_begin<LayerTy, ServiceTy>( &mut self, layer: LayerTy, ) -> Result<(), CommonNetAPIError>

where LayerTy: Layer<UnderlyingOnStreamBeginService<State>, Service = ServiceTy>, ServiceTy: Service<ResponseStreamEvent<State>, Response = bool, Error = CatBridgeError> + Clone + Send + 'static, <LayerTy::Service as Service<ResponseStreamEvent<State>>>::Future: Send + 'static,

Add a layer to the service to process when a stream begins, or a new connection is created.

Errors

If there is no on stream begin handler that is currently active.

pub const fn on_stream_end( &self, ) -> Option<&UnderlyingOnStreamEndService<State>>

pub fn set_raw_on_stream_end( &mut self, on_end: Option<UnderlyingOnStreamEndService<State>>, ) -> Result<(), CommonNetAPIError>

Set a hook to run when a stream is being destroyed.

This is what happens when a machine disconnects. So it may also be refered to as “on disconnect”. This assumes you’re assigning a service that already exists and is in the raw storage type, you may want to look into Self::set_on_stream_end, or Self::set_on_stream_end_service.

Errors

If the stream ending hook has already been registered. If you’re looking to perform multiple actions at once, look into layer-ing.

pub fn set_on_stream_end<HandlerTy, HandlerParamsTy>( &mut self, handler: HandlerTy, ) -> Result<(), CommonNetAPIError>

where HandlerParamsTy: Send + 'static, HandlerTy: OnResponseStreamEndHandler<HandlerParamsTy, State> + Clone + Send + 'static,

Set a function hook to run when a stream is being destroyed.

This is what happens when a machine disconnects. So it may also be refered to as “on disconnect”. This assumes you’re assigning a function to on stream end otherwise use Self::set_raw_on_stream_end, or Self::set_on_stream_end_service.

Errors

If the stream ending hook has already been registered. If you’re looking to perform multiple actions at once, look into layer-ing.

pub fn set_on_stream_end_service<ServiceTy>( &mut self, service_ty: ServiceTy, ) -> Result<(), CommonNetAPIError>

where ServiceTy: Clone + Send + Service<ResponseStreamEvent<State>, Response = (), Error = CatBridgeError> + 'static, ServiceTy::Future: Send + 'static,

Set a function hook to run when a stream is being destroyed.

This is what happens when a machine disconnects. So it may also be refered to as “on disconnect”. This assumes you’re assigning a Service to on stream end otherwise use Self::set_raw_on_stream_end, or Self::set_on_stream_end.

Errors

If the stream beginning hook has already been registered. If you’re looking to perform multiple actions at once, look into layer-ing.

pub fn layer_on_stream_end<LayerTy, ServiceTy>( &mut self, layer: LayerTy, ) -> Result<(), CommonNetAPIError>

where LayerTy: Layer<UnderlyingOnStreamEndService<State>, Service = ServiceTy>, ServiceTy: Service<ResponseStreamEvent<State>, Response = (), Error = CatBridgeError> + Clone + Send + 'static, <LayerTy::Service as Service<ResponseStreamEvent<State>>>::Future: Send + 'static,

Add a layer to the service to process when a stream ends, or a new connection is destroyed.

Errors

If there is no on stream end handler that is currently active.

pub const fn initial_service( &self, ) -> &BoxCloneService<Request<State>, Response, Infallible>

pub fn layer_initial_service<LayerTy, ServiceTy>(&mut self, layer: LayerTy)

where LayerTy: Layer<BoxCloneService<Request<State>, Response, Infallible>, Service = ServiceTy>, ServiceTy: Service<Request<State>, Response = Response, Error = Infallible> + Clone + Send + 'static, <LayerTy::Service as Service<Request<State>>>::Future: Send + 'static,

pub const fn state(&self) -> &State

Get a reference to the current state of the server.

pub async fn connect(self) -> Result<(), CatBridgeError>

“Connect” to our remote client address, and start serving ourselves to whoever we connect too.

NOTE: this will NOT return until the service either runs into an error, or the task is cancelled.

Errors

If we cannot connect to the remote source, fetch the local address, or handle the connection in some other way.

pub async fn bind(self) -> Result<(), CatBridgeError>

Bind this server, and start listening on the specified address.

NOTE: this will NOT return until the service either runs into an error, or gets cancelled.

Errors

• If we cannot bind to the requested address, and port.
• If we run into an error accept’ing a TCP connection.

Trait Implementations

impl<State: Clone + Debug + Send + Sync + 'static> Debug for TCPServer<State>

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

Formats the value using the given formatter.

impl<State: Clone + Debug + Send + Sync + Valuable + 'static> Structable for TCPServer<State>

fn definition(&self) -> StructDef<'_>

Returns the struct’s definition.

impl<State: Clone + Debug + Send + Sync + Valuable + 'static> Valuable for TCPServer<State>

fn as_value(&self) -> Value<'_>

Converts self into a Value instance.

fn visit(&self, visitor: &mut dyn Visit)

Calls the relevant method on Visit to extract data from self.

fn visit_slice(slice: &[Self], visit: &mut dyn Visit)

where Self: Sized,

Calls Visit::visit_primitive_slice() with self.