tetsy_jsonrpc_ws_server/
server_builder.rs

1use std::net::SocketAddr;
2use std::sync::Arc;
3
4use crate::core;
5use crate::server_utils;
6use crate::server_utils::cors::Origin;
7use crate::server_utils::hosts::{DomainsValidation, Host};
8use crate::server_utils::reactor::UninitializedExecutor;
9use crate::server_utils::session::SessionStats;
10
11use crate::error::Result;
12use crate::metadata::{MetaExtractor, NoopExtractor};
13use crate::server::Server;
14use crate::session;
15
16/// Builder for `WebSockets` server
17pub struct ServerBuilder<M: core::Metadata, S: core::Middleware<M>> {
18	handler: Arc<core::MetaIoHandler<M, S>>,
19	meta_extractor: Arc<dyn MetaExtractor<M>>,
20	allowed_origins: Option<Vec<Origin>>,
21	allowed_hosts: Option<Vec<Host>>,
22	request_middleware: Option<Arc<dyn session::RequestMiddleware>>,
23	session_stats: Option<Arc<dyn SessionStats>>,
24	executor: UninitializedExecutor,
25	max_connections: usize,
26	max_payload_bytes: usize,
27}
28
29impl<M: core::Metadata + Default, S: core::Middleware<M>> ServerBuilder<M, S> {
30	/// Creates new `ServerBuilder`
31	pub fn new<T>(handler: T) -> Self
32	where
33		T: Into<core::MetaIoHandler<M, S>>,
34	{
35		Self::with_meta_extractor(handler, NoopExtractor)
36	}
37}
38
39impl<M: core::Metadata, S: core::Middleware<M>> ServerBuilder<M, S> {
40	/// Creates new `ServerBuilder`
41	pub fn with_meta_extractor<T, E>(handler: T, extractor: E) -> Self
42	where
43		T: Into<core::MetaIoHandler<M, S>>,
44		E: MetaExtractor<M>,
45	{
46		ServerBuilder {
47			handler: Arc::new(handler.into()),
48			meta_extractor: Arc::new(extractor),
49			allowed_origins: None,
50			allowed_hosts: None,
51			request_middleware: None,
52			session_stats: None,
53			executor: UninitializedExecutor::Unspawned,
54			max_connections: 100,
55			max_payload_bytes: 5 * 1024 * 1024,
56		}
57	}
58
59	/// Utilize existing event loop executor to poll RPC results.
60	pub fn event_loop_executor(mut self, executor: server_utils::tokio::runtime::TaskExecutor) -> Self {
61		self.executor = UninitializedExecutor::Shared(executor);
62		self
63	}
64
65	/// Sets a meta extractor.
66	pub fn session_meta_extractor<T: MetaExtractor<M>>(mut self, extractor: T) -> Self {
67		self.meta_extractor = Arc::new(extractor);
68		self
69	}
70
71	/// Allowed origins.
72	pub fn allowed_origins(mut self, allowed_origins: DomainsValidation<Origin>) -> Self {
73		self.allowed_origins = allowed_origins.into();
74		self
75	}
76
77	/// Allowed hosts.
78	pub fn allowed_hosts(mut self, allowed_hosts: DomainsValidation<Host>) -> Self {
79		self.allowed_hosts = allowed_hosts.into();
80		self
81	}
82
83	/// Session stats
84	pub fn session_stats<T: SessionStats>(mut self, stats: T) -> Self {
85		self.session_stats = Some(Arc::new(stats));
86		self
87	}
88
89	/// Sets a request middleware. Middleware will be invoked before each handshake request.
90	/// You can either terminate the handshake in the middleware or run a default behaviour after.
91	pub fn request_middleware<T: session::RequestMiddleware>(mut self, middleware: T) -> Self {
92		self.request_middleware = Some(Arc::new(middleware));
93		self
94	}
95
96	/// Maximal number of concurrent connections this server supports.
97	/// Default: 100
98	pub fn max_connections(mut self, max_connections: usize) -> Self {
99		self.max_connections = max_connections;
100		self
101	}
102
103	/// Maximal size of the payload (in bytes)
104	/// Default: 5MB
105	pub fn max_payload(mut self, max_payload_bytes: usize) -> Self {
106		self.max_payload_bytes = max_payload_bytes;
107		self
108	}
109
110	/// Starts a new `WebSocket` server in separate thread.
111	/// Returns a `Server` handle which closes the server when droped.
112	pub fn start(self, addr: &SocketAddr) -> Result<Server> {
113		Server::start(
114			addr,
115			self.handler,
116			self.meta_extractor,
117			self.allowed_origins,
118			self.allowed_hosts,
119			self.request_middleware,
120			self.session_stats,
121			self.executor,
122			self.max_connections,
123			self.max_payload_bytes,
124		)
125	}
126}