mirror of https://github.com/chipsenkbeil/distant
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
110 lines
3.0 KiB
Rust
110 lines
3.0 KiB
Rust
use std::io;
|
|
use std::net::IpAddr;
|
|
|
|
use distant_auth::Verifier;
|
|
use serde::de::DeserializeOwned;
|
|
use serde::Serialize;
|
|
|
|
use crate::common::{PortRange, TcpListener, Version};
|
|
use crate::server::{Server, ServerConfig, ServerHandler, TcpServerRef};
|
|
|
|
pub struct TcpServerBuilder<T>(Server<T>);
|
|
|
|
impl<T> Server<T> {
|
|
/// Consume [`Server`] and produce a builder for a TCP variant.
|
|
pub fn into_tcp_builder(self) -> TcpServerBuilder<T> {
|
|
TcpServerBuilder(self)
|
|
}
|
|
}
|
|
|
|
impl Default for TcpServerBuilder<()> {
|
|
fn default() -> Self {
|
|
Self(Server::new())
|
|
}
|
|
}
|
|
|
|
impl<T> TcpServerBuilder<T> {
|
|
pub fn config(self, config: ServerConfig) -> Self {
|
|
Self(self.0.config(config))
|
|
}
|
|
|
|
pub fn handler<U>(self, handler: U) -> TcpServerBuilder<U> {
|
|
TcpServerBuilder(self.0.handler(handler))
|
|
}
|
|
|
|
pub fn verifier(self, verifier: Verifier) -> Self {
|
|
Self(self.0.verifier(verifier))
|
|
}
|
|
|
|
pub fn version(self, version: Version) -> Self {
|
|
Self(self.0.version(version))
|
|
}
|
|
}
|
|
|
|
impl<T> TcpServerBuilder<T>
|
|
where
|
|
T: ServerHandler + Sync + 'static,
|
|
T::Request: DeserializeOwned + Send + Sync + 'static,
|
|
T::Response: Serialize + Send + 'static,
|
|
{
|
|
pub async fn start<P>(self, addr: IpAddr, port: P) -> io::Result<TcpServerRef>
|
|
where
|
|
P: Into<PortRange> + Send,
|
|
{
|
|
let listener = TcpListener::bind(addr, port).await?;
|
|
let port = listener.port();
|
|
let inner = self.0.start(listener)?;
|
|
Ok(TcpServerRef { addr, port, inner })
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::net::{Ipv6Addr, SocketAddr};
|
|
|
|
use async_trait::async_trait;
|
|
use distant_auth::DummyAuthHandler;
|
|
use test_log::test;
|
|
|
|
use super::*;
|
|
use crate::client::Client;
|
|
use crate::common::Request;
|
|
use crate::server::RequestCtx;
|
|
|
|
pub struct TestServerHandler;
|
|
|
|
#[async_trait]
|
|
impl ServerHandler for TestServerHandler {
|
|
type Request = String;
|
|
type Response = String;
|
|
|
|
async fn on_request(&self, ctx: RequestCtx<Self::Request, Self::Response>) {
|
|
// Echo back what we received
|
|
ctx.reply.send(ctx.request.payload.to_string()).unwrap();
|
|
}
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn should_invoke_handler_upon_receiving_a_request() {
|
|
let server = TcpServerBuilder::default()
|
|
.handler(TestServerHandler)
|
|
.verifier(Verifier::none())
|
|
.start(IpAddr::V6(Ipv6Addr::LOCALHOST), 0)
|
|
.await
|
|
.expect("Failed to start TCP server");
|
|
|
|
let mut client: Client<String, String> =
|
|
Client::tcp(SocketAddr::from((server.ip_addr(), server.port())))
|
|
.auth_handler(DummyAuthHandler)
|
|
.connect()
|
|
.await
|
|
.expect("Client failed to connect");
|
|
|
|
let response = client
|
|
.send(Request::new("hello".to_string()))
|
|
.await
|
|
.expect("Failed to send message");
|
|
assert_eq!(response.payload, "hello");
|
|
}
|
|
}
|