iron_os_packages_api/
server.rs

1//! This api is unstable and should only be used by packages-server
2
3use crate::action::Action;
4use crate::error::{Result, Error};
5
6use std::time::Duration;
7use std::any::Any;
8use std::sync::Arc;
9
10pub use stream_api::server::{Session, Config, EncryptedBytes};
11use stream_api::request::{RequestHandler, Request};
12use stream_api::server::{BuiltServer};
13use stream_api::message::{IntoMessage, FromMessage};
14pub use stream::handler::Configurator;
15use stream::util::testing::PanicListener;
16use stream::util::{Listener, SocketAddr};
17
18use crypto::signature::Keypair;
19
20use tokio::net::{TcpListener, ToSocketAddrs};
21
22// long since pings are not implemented yet
23const TIMEOUT: Duration = Duration::from_secs(10);
24const BODY_LIMIT: u32 = 4096;// 4kb request limit
25
26type StreamServer<L> = stream_api::server::Server<
27	Action, EncryptedBytes, L, Keypair
28>;
29
30pub struct Server<L> {
31	inner: StreamServer<L>
32}
33
34impl<L> Server<L> {
35	pub fn register_request<H>(&mut self, handler: H)
36	where H: RequestHandler<EncryptedBytes, Action=Action> + Send + Sync + 'static {
37		self.inner.register_request(handler);
38	}
39
40	pub fn register_data<D>(&mut self, data: D)
41	where D: Any + Send + Sync {
42		self.inner.register_data(data);
43	}
44
45	pub fn into_inner(self) -> StreamServer<L> {
46		self.inner
47	}
48}
49
50impl<L> Server<L>
51where L: Listener {
52	/// Panics if one of the request handlers panics
53	pub async fn run(self) -> Result<()> {
54		self.inner.run().await
55			.map_err(|e| Error::Other(format!("server failed {}", e)))
56	}
57}
58
59impl Server<TcpListener> {
60	pub async fn new<A>(addr: A, priv_key: Keypair) -> Result<Self>
61	where A: ToSocketAddrs {
62		let listener = TcpListener::bind(addr).await
63			.map_err(|e| Error::Other(format!("could not bind {}", e)))?;
64
65		Ok(Self {
66			inner: StreamServer::new_encrypted(listener, Config {
67				timeout: TIMEOUT,
68				body_limit: BODY_LIMIT
69			}, priv_key)
70		})
71	}
72}
73
74impl Server<PanicListener> {
75	pub fn new_testing(priv_key: Keypair) -> Self {
76		Self {
77			inner: StreamServer::new_encrypted(PanicListener::new(), Config {
78				timeout: TIMEOUT,
79				body_limit: BODY_LIMIT
80			}, priv_key)
81		}
82	}
83
84	pub fn build(self) -> TestingServer {
85		TestingServer {
86			inner: self.inner.build(),
87			session: Arc::new(Session::new(
88				SocketAddr::V4("127.0.0.1:8080".parse().unwrap())
89			))
90		}
91	}
92}
93
94pub struct TestingServer {
95	inner: BuiltServer<Action, EncryptedBytes, PanicListener, Keypair>,
96	session: Arc<Session>
97}
98
99impl TestingServer {
100	pub fn session(&self) -> &Session {
101		&self.session
102	}
103
104	pub fn reset_session(&mut self) {
105		self.session = Arc::new(Session::new(
106			SocketAddr::V4("127.0.0.1:8080".parse().unwrap())
107		));
108	}
109
110	pub fn get_data<D: std::any::Any>(&self) -> &D {
111		self.inner.get_data().unwrap()
112	}
113
114	pub async fn request<R>(
115		&self,
116		r: R
117	) -> std::result::Result<R::Response, R::Error>
118	where
119		R: Request<Action=Action>,
120		R: IntoMessage<Action, EncryptedBytes>,
121		R::Response: FromMessage<Action, EncryptedBytes>,
122		R::Error: FromMessage<Action, EncryptedBytes>
123	{
124		self.inner.request(r, &self.session).await
125	}
126}
iron_os_packages_api/server.rs

iron_os_packages_api/
server.rs
