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 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
pub mod mail;
pub mod session;
pub mod tcp;
use model::controll::*;
use model::mail::*;
use tokio::net::TcpStream;
use tokio::prelude::*;
/**
An object implementing this trait handles TCP connections in a `Future`.
The caller would ask the service to `handle()` the `TcpStream`,
then poll the returned future or more likely `tokio::spawn()` it.
Here's a dead simple implementation that returns a completed future
and doesn't do anything with the stream:
```
# extern crate samotop;
# extern crate tokio;
# use samotop;
# use samotop::service::*;
# use tokio::net::TcpStream;
# use tokio::prelude::*;
# use tokio::prelude::future::FutureResult;
#[derive(Clone, Debug)]
pub struct DeadService;
impl TcpService for DeadService {
type Future = FutureResult<(), ()>;
fn handle(self, _stream: TcpStream) -> Self::Future {
future::ok(()) // or do something with the stream
}
}
```
You can then use this `DeadService` in samotop:
```
# use samotop::service::tcp::DeadService;
let task = samotop::builder()
.with(DeadService)
.build_task();
```
The `SamotopService` implements this trait.
*/
pub trait TcpService {
type Future: Future<Item = (), Error = ()>;
fn handle(self, stream: TcpStream) -> Self::Future;
}
/**
The service which implements this trait has a name.
*/
pub trait NamedService {
fn name(&self) -> String;
}
/**
A mail guard can be queried whether a recepient is accepted on on which address.
*/
pub trait MailGuard {
type Future: Future<Item = AcceptRecipientResult>;
fn accept(&self, request: AcceptRecipientRequest) -> Self::Future;
}
/**
A mail queue allows us to queue an e-mail.
We start with an envelope. Then, depending on implementation,
the `Mail` implementation receives the e-mail body.
Finally, the caller queues the mail by calling `Mail.queue()`.
*/
pub trait MailQueue {
type Mail;
type MailFuture: Future<Item = Option<Self::Mail>>;
fn mail(&self, envelope: Envelope) -> Self::MailFuture;
}
/**
The final step of sending a mail is queueing it for delivery.
*/
pub trait Mail {
fn queue(self) -> QueueResult;
}
/**
A session service handles the Samotop session
*/
pub trait SessionService {
type Handler;
fn start(&self, tls_conf: TlsControll) -> Self::Handler;
}