simple-socket 0.1.7

The basic socket server & client for testing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use std::cell::UnsafeCell;
use std::net::SocketAddr;

use super::message::{Message, Response};
use crate::server::{PostServing, SocketServer};

pub use podo_core_driver::RuntimeError;
use serde::{de::DeserializeOwned, Serialize};

pub trait ActorServer<Req, Res>
where
    Self: Send + Sync,
    Req: DeserializeOwned + PartialEq + Eq + Send + Sync,
    Res: Serialize + PartialEq + Eq + Send + Sync,
{
    fn step(&mut self) -> Result<(), RuntimeError>;

    fn stop(self) -> Result<(), RuntimeError>;

    fn pause(&mut self) -> Result<(), RuntimeError>;
    fn resume(&mut self) -> Result<(), RuntimeError>;

    fn hibernate(&mut self) -> Result<(), RuntimeError>;
    fn wake_up(&mut self) -> Result<(), RuntimeError>;

    fn request(&mut self, message: Req) -> Result<Res, RuntimeError>;

    fn run_server(self, socket: SocketAddr)
    where
        Self: Sized,
    {
        let actor = UnsafeCell::new(self);
        let get_actor = || unsafe { actor.get().as_mut().unwrap() };

        let alive = UnsafeCell::new(true);
        let get_alive = || unsafe { alive.get().as_mut().unwrap() };

        let handler = |req| match req {
            Message::Stop => {
                *get_alive() = false;
                Response::Awk
            }
            Message::Pause => {
                get_actor().pause().unwrap();
                Response::Awk
            }
            Message::Resume => {
                get_actor().resume().unwrap();
                Response::Awk
            }
            Message::Hibernate => {
                get_actor().hibernate().unwrap();
                Response::Awk
            }
            Message::WakeUp => {
                get_actor().wake_up().unwrap();
                Response::Awk
            }
            Message::Custom(m) => Response::Custom(get_actor().request(m).unwrap()),
        };

        let backlog = Default::default();
        let server = SocketServer::<Message<Req>, Response<Res>>::try_new(socket, backlog).unwrap();
        server
            .run(handler, |_| {
                get_actor().step().unwrap();

                if *get_alive() {
                    PostServing::Yield
                } else {
                    PostServing::Stop
                }
            })
            .unwrap();

        actor.into_inner().stop().unwrap();
    }
}