Type Definition daemon_engine::unix::UnixServer

type UnixServer<C> = Server<UnixStream, C, UnixInfo>;

UnixServer is a Server implementation over UnixStream and UnixInfo types with a generic codec

extern crate tokio;
use tokio::prelude::*;
use tokio::{spawn, run};
 
#[macro_use]
extern crate serde_derive;
 
extern crate daemon_engine;
use daemon_engine::{UnixServer, JsonCodec};
 
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Request {}
 
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Response {}
 
 
let addr = "/var/tmp/test-daemon.sock";
let server = future::lazy(move || {
    let mut s = UnixServer::<JsonCodec<Response, Request>>::new(&addr, JsonCodec::new()).unwrap();
    let server_handle = s
        .incoming()
        .unwrap()
        .for_each(move |r| {
            println!("Request data {:?} info: {:?}", r.data(), r.info());
            r.send(Response{}).wait().unwrap();
            Ok(())
        }).map_err(|_e| ());
    spawn(server_handle);
    Ok(())
});
run(server);
 

Methods

impl<C> UnixServer<C> where
    C: Encoder + Decoder + Clone + Send + 'static,
    <C as Decoder>::Item: Clone + Send + Debug,
    <C as Decoder>::Error: Send + Debug,
    <C as Encoder>::Item: Clone + Send + Debug,
    <C as Encoder>::Error: Send + Debug, 

Unix server implementation

This binds to and listens on a unix domain socket

pub fn new(path: &str, codec: C) -> Result<UnixServer<C>, Error>

pub fn shutdown(&self)