Struct voxelize::Server

pub struct Server {
    pub port: u16,
    pub addr: String,
    pub started: bool,
    pub serve: String,
    pub interval: u64,
    pub secret: Option<String>,
    /* private fields */
}

A websocket server for Voxelize, holds all worlds data, and runs as a background system service.

Fields

port: u16

The port that this voxelize server is running on.

addr: String

The address that this voxelize server is running on.

started: bool

Whether or not if the socket server has started as a system service.

serve: String

Static folder to serve from.

interval: u64

Interval to tick the server at.

secret: Option<String>

A secret to join the server.

Implementations

impl Server

pub fn new() -> ServerBuilder

Create a new Voxelize server instance used to host all the worlds.

Example

// Create a server of port 4000 on "0.0.0.0"
let server = Server::new().addr("0.0.0.0").port(4000).build();

// Run the server on Voxelize
Voxelize::run(server);

pub fn add_world(&mut self, world: World) -> Result<&mut World, AddWorldError>

Add a world instance to the server. Different worlds have different configurations, and can hold their own set of clients within. If the server has already started, the added world will be started right away.

pub fn create_world(
    &mut self,
    name: &str,
    config: &WorldConfig
) -> Result<&mut World, AddWorldError>

Create a world in the server. Different worlds have different configurations, and can hold their own set of clients within. If the server has already started, the added world will be started right away.

pub fn get_world(&self, world_name: &str) -> Option<&World>

Get a world reference by name.

pub fn get_world_mut(&mut self, world_name: &str) -> Option<&mut World>

Get a mutable world reference by name.

pub fn on_request(&mut self, id: &str, data: Message)

Handler for client’s message.

pub fn prepare(&mut self)

Prepare all worlds on the server to start.

pub fn tick(&mut self)

Tick every world on this server.

Trait Implementations

impl Actor for Server

Make actor from ChatServer

type Context = Context<Server>

We are going to use simple Context, we just need ability to communicate with other actors.

fn started(&mut self, ctx: &mut Self::Context)

Called when an actor gets polled the first time.

fn stopping(&mut self, ctx: &mut Self::Context) -> Running

Called after an actor is in Actor::Stopping state.

fn stopped(&mut self, ctx: &mut Self::Context)

Called after an actor is stopped.

fn start(self) -> Addr<Self> where
    Self: Actor<Context = Context<Self>>, 

Start a new asynchronous actor, returning its address.

fn start_default() -> Addr<Self> where
    Self: Actor<Context = Context<Self>> + Default, 

Construct and start a new asynchronous actor, returning its address.

fn start_in_arbiter<F>(wrk: &ArbiterHandle, f: F) -> Addr<Self> where
    Self: Actor<Context = Context<Self>>,
    F: 'static + FnOnce(&mut Context<Self>) -> Self + Send, 

Start new actor in arbiter’s thread.

fn create<F>(f: F) -> Addr<Self> where
    Self: Actor<Context = Context<Self>>,
    F: FnOnce(&mut Context<Self>) -> Self, 

Start a new asynchronous actor given a Context.

impl Handler<ClientMessage> for Server

Handler for Message message.

type Result = ()

The type of value that this handler will return.

fn handle(&mut self, msg: ClientMessage, _: &mut Context<Self>)

This method is called for every message received by this actor.

impl Handler<Connect> for Server

Handler for Connect message.

Register new session and assign unique id to this session

type Result = MessageResult<Connect>

The type of value that this handler will return.

fn handle(&mut self, msg: Connect, _: &mut Context<Self>) -> Self::Result

This method is called for every message received by this actor.

impl Handler<Disconnect> for Server

Handler for Disconnect message.

type Result = ()

The type of value that this handler will return.

fn handle(&mut self, msg: Disconnect, _: &mut Context<Self>)

This method is called for every message received by this actor.