Struct packets::server::Server

pub struct Server {
    pub listener: TcpListener,
    // some fields omitted
}

A simple server

Examples

Echo server

use packets::*;
use packets::server::*;
use std::net::SocketAddr;
use std::time::Instant;

// Bind the server to localhost at port 60000.
let mut server = Server::bind("localhost:60000", &ServerConfig::default()).unwrap();
let start_time = Instant::now();
loop {
  server.accept_all(); // Accept all incoming connections.

  // Using String as our packet type for this example, receive all incoming packets along with
  // their addresses. Any Serde-compatible type can be used as the packet type.
  let packets: Vec<(SocketAddr, String)> = server.receive_all().unwrap();
  for (addr, packet) in packets {
    server.send(addr, &packet); // Echo the data back to the client.
  }

  // For this example we shut the server down after 1 second.
  if start_time.elapsed().as_secs() > 1 {
    break;
  }
}

server.shutdown(); // Close all connections to the server.

Fields

listener: TcpListener

Implementations

impl Server

pub fn accept(&mut self) -> Result<Option<SocketAddr>>

Attempt to accept a new connection.

pub fn accept_all(&mut self) -> Result<Vec<SocketAddr>>

Use this function to accept all pending connections.

pub fn accept_blocking(&mut self) -> Result<SocketAddr>

Block until a new connection is accepted.

pub fn bind<B: ToSocketAddrs>(addr: B, config: &ServerConfig) -> Result<Server>

pub fn block_until_receive_from(
    &mut self,
    addr: SocketAddr,
    timeout: Duration
) -> Result<PacketReceiveStatus>

pub fn connections(&self) -> Vec<&Connection>

pub fn receive<A: Serialize + DeserializeOwned>(
    &mut self
) -> Result<Option<(SocketAddr, A)>>

Iterate over connections until we find one that is

pub fn receive_all<A: Serialize + DeserializeOwned>(
    &mut self
) -> Result<Vec<(SocketAddr, A)>>

pub fn receive_from<A: Serialize + DeserializeOwned>(
    &mut self,
    addr: SocketAddr
) -> Result<Option<A>>

pub fn send<A: Serialize + DeserializeOwned>(
    &mut self,
    addr: SocketAddr,
    packet: &A
) -> Result<()>

Send a packet to a specific connection identified by its address.

pub fn send_global<A: Serialize + DeserializeOwned>(
    &mut self,
    packet: &A
) -> Result<()>

Send a packet to all connections.

pub fn shutdown(self) -> Result<()>

Shuts this server down, closing all connections, then drops this object. The server cannot be used after it has been shut down as the Server object is moved into this function and then dropped.

pub fn with_connection<A, F>(&mut self, addr: SocketAddr, f: F) -> Result<A> where
    F: FnOnce(&mut Connection) -> Result<A>, 

Run a closure on a

Trait Implementations

impl Debug for Server

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.