lafere_api/
client.rs

1use std::net::SocketAddrV4;
2use std::sync::Arc;
3
4use crate::error::ApiError;
5use crate::message::{Action, FromMessage, IntoMessage, Message};
6use crate::request::Request;
7use crate::request_handlers::RequestHandlers;
8use crate::server::Session;
9
10use lafere::client::Connection;
11pub use lafere::client::{Config, ReconStrat};
12use lafere::error::{RequestError, TaskError};
13pub use lafere::packet::PlainBytes;
14use lafere::packet::{Packet, PacketBytes};
15use lafere::util::{ByteStream, SocketAddr};
16
17#[cfg(feature = "encrypted")]
18use crypto::signature::PublicKey;
19#[cfg(feature = "encrypted")]
20pub use lafere::packet::EncryptedBytes;
21
22pub struct Client<A, B> {
23	inner: Connection<Message<A, B>>,
24}
25
26impl<A> Client<A, PlainBytes>
27where
28	A: Action + Send + 'static,
29{
30	// plain
31	pub fn new<S>(
32		stream: S,
33		cfg: Config,
34		recon_strat: Option<ReconStrat<S>>,
35	) -> Self
36	where
37		S: ByteStream,
38	{
39		Self {
40			inner: Connection::new(stream, cfg, recon_strat),
41		}
42	}
43}
44
45#[cfg(feature = "encrypted")]
46#[cfg_attr(docsrs, doc(cfg(feature = "encrypted")))]
47impl<A> Client<A, EncryptedBytes>
48where
49	A: Action + Send + 'static,
50{
51	pub fn new_encrypted<S>(
52		stream: S,
53		cfg: Config,
54		recon_strat: Option<ReconStrat<S>>,
55		pub_key: PublicKey,
56	) -> Self
57	where
58		S: ByteStream,
59	{
60		Self {
61			inner: Connection::new_encrypted(stream, cfg, recon_strat, pub_key),
62		}
63	}
64}
65
66impl<A, B> Client<A, B>
67where
68	A: Action,
69	B: PacketBytes,
70{
71	pub async fn request<R>(&self, req: R) -> Result<R::Response, R::Error>
72	where
73		R: Request<Action = A>,
74		R: IntoMessage<A, B>,
75		R::Response: FromMessage<A, B>,
76		R::Error: FromMessage<A, B>,
77	{
78		let mut msg =
79			req.into_message().map_err(R::Error::from_message_error)?;
80		msg.header_mut().set_action(R::ACTION);
81
82		let res = self
83			.inner
84			.request(msg)
85			.await
86			.map_err(R::Error::from_request_error)?;
87
88		// now deserialize the response
89		if res.is_success() {
90			R::Response::from_message(res).map_err(R::Error::from_message_error)
91		} else {
92			R::Error::from_message(res)
93				.map(Err)
94				.map_err(R::Error::from_message_error)?
95		}
96	}
97
98	/// ## Panics
99	/// if a RequestHandlers was already attached
100	pub async fn attach_request_handlers(
101		&mut self,
102		handlers: RequestHandlers<A, B>,
103	) -> Result<(), RequestError>
104	where
105		A: Send + Sync + 'static,
106		B: PacketBytes + Send + 'static,
107	{
108		if !self.inner.is_server_requests_enabled() {
109			self.inner.enable_server_requests().await?;
110		}
111
112		let session = Arc::new(Session::new(SocketAddr::V4(
113			SocketAddrV4::new([0, 0, 0, 0].into(), 0).into(),
114		)));
115		session.set(self.inner.configurator());
116
117		let sender = self.inner.clone_sender();
118		let receiver = self.inner.take_receiver().unwrap();
119
120		tokio::spawn(async move {
121			handlers.handle_connection(session, sender, receiver).await;
122		});
123
124		Ok(())
125	}
126}
127
128impl<A, B> Client<A, B> {
129	pub async fn closed(&mut self) {
130		self.inner.closed().await
131	}
132
133	pub async fn close(self) -> Result<(), TaskError> {
134		self.inner.close().await
135	}
136}
lafere_api/client.rs

lafere_api/
client.rs
