replace singal queue with command bus
continuous-integration/drone/push Build is passing
Details
continuous-integration/drone/push Build is passing
Details
parent
775040be91
commit
659b44dfe6
GPG Key ID:
AD2560A0F84F0759
@ -0,0 +1,47 @@
|
|||||||
|
use async_std::sync::{Arc, Mutex};
|
||||||
|
use crate::bus::{Request, RequestEnvelope, ResponseEnvelope};
|
||||||
|
use std::fmt::{Debug, Formatter, Error};
|
||||||
|
|
||||||
|
#[async_trait]
|
||||||
|
pub trait RawBusClient: Send {
|
||||||
|
async fn send(&mut self, request: RequestEnvelope) -> ResponseEnvelope;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct BusClient(Arc<Mutex<BusClientState>>);
|
||||||
|
|
||||||
|
impl Debug for BusClient {
|
||||||
|
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
|
||||||
|
write!(f, "BusClient()")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct BusClientState {
|
||||||
|
id: u64,
|
||||||
|
raw_client: Box<dyn RawBusClient>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BusClient {
|
||||||
|
pub fn new(raw_client: Box<dyn RawBusClient>) -> BusClient {
|
||||||
|
BusClient(Arc::new(Mutex::new(
|
||||||
|
BusClientState {
|
||||||
|
id: 0,
|
||||||
|
raw_client,
|
||||||
|
}
|
||||||
|
)))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn send(&mut self, request: Request) -> ResponseEnvelope {
|
||||||
|
let mut state = self.0.lock().await;
|
||||||
|
let id = state.id;
|
||||||
|
state.id += 1;
|
||||||
|
|
||||||
|
let envelope = RequestEnvelope {
|
||||||
|
id,
|
||||||
|
request,
|
||||||
|
};
|
||||||
|
|
||||||
|
state.raw_client.send(envelope).await
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
@ -0,0 +1,38 @@
|
|||||||
|
use crate::bus::{Response, RequestEnvelope};
|
||||||
|
use async_std::sync::{Arc, Mutex};
|
||||||
|
use std::fmt::{Formatter, Debug, Error};
|
||||||
|
use futures::Stream;
|
||||||
|
|
||||||
|
#[async_trait]
|
||||||
|
pub trait BusConnection: Send + Stream<Item=RequestEnvelope> + Unpin {
|
||||||
|
async fn close(&mut self);
|
||||||
|
async fn ack(&mut self, id: u64);
|
||||||
|
async fn send(&mut self, id: u64, message: Response);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Receiver(Arc<Mutex<Box<dyn RawReceiver>>>, String);
|
||||||
|
|
||||||
|
impl Debug for Receiver {
|
||||||
|
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
|
||||||
|
write!(f, "Receiver {{ {} }}", self.1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Receiver {
|
||||||
|
pub fn new(receiver: Box<dyn RawReceiver>) -> Receiver {
|
||||||
|
let name = receiver.name();
|
||||||
|
Receiver(Arc::new(Mutex::new(receiver)), name.to_string())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn get(&mut self) -> Option<Box<dyn BusConnection>> {
|
||||||
|
self.0.lock().await.get().await
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[async_trait]
|
||||||
|
pub trait RawReceiver: Send {
|
||||||
|
fn name<'s>(&self) -> &'s str;
|
||||||
|
async fn disconnect(&mut self);
|
||||||
|
async fn get(&mut self) -> Option<Box<dyn BusConnection>>;
|
||||||
|
}
|
||||||
@ -0,0 +1,99 @@
|
|||||||
|
use std::collections::HashMap;
|
||||||
|
use crate::bus::{Response, BusConnection, RawReceiver, RequestEnvelope, ResponseEnvelope, RawBusClient};
|
||||||
|
use crate::utils::asyn::{AsyncQueue, Deferred};
|
||||||
|
use futures::Stream;
|
||||||
|
use async_std::sync::{Arc, Mutex};
|
||||||
|
use async_macros::utils::task::{Context, Poll};
|
||||||
|
use async_macros::utils::pin::Pin;
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub struct ProcessReceiver {
|
||||||
|
state: Arc<Mutex<ProcessReceiverState>>,
|
||||||
|
request_queue: AsyncQueue<RequestEnvelope>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ProcessReceiver {
|
||||||
|
pub fn new() -> Self {
|
||||||
|
ProcessReceiver {
|
||||||
|
state: Arc::new(Mutex::new(ProcessReceiverState {
|
||||||
|
id: 0,
|
||||||
|
callbacks: Default::default(),
|
||||||
|
registered_client: false,
|
||||||
|
})),
|
||||||
|
request_queue: Default::default(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn run_callback(&mut self, id: u64, response: Option<Response>) {
|
||||||
|
let mut state = self.state.lock().await;
|
||||||
|
if let Some(mut deferred) = state.callbacks.remove(&id) {
|
||||||
|
deferred.complete(ResponseEnvelope {
|
||||||
|
id,
|
||||||
|
response,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[async_trait]
|
||||||
|
impl RawReceiver for ProcessReceiver {
|
||||||
|
fn name<'s>(&self) -> &'s str {
|
||||||
|
"in-process"
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn disconnect(&mut self) {}
|
||||||
|
|
||||||
|
async fn get(&mut self) -> Option<Box<dyn BusConnection>> {
|
||||||
|
let mut state = self.state.lock().await;
|
||||||
|
if state.registered_client {
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
state.registered_client = true;
|
||||||
|
let copy = Box::new(self.clone()) as Box<dyn BusConnection>;
|
||||||
|
Some(copy)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct ProcessReceiverState {
|
||||||
|
id: u64,
|
||||||
|
callbacks: HashMap<u64, Deferred<ResponseEnvelope>>,
|
||||||
|
registered_client: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[async_trait]
|
||||||
|
impl BusConnection for ProcessReceiver {
|
||||||
|
async fn close(&mut self) {}
|
||||||
|
|
||||||
|
async fn ack(&mut self, id: u64) {
|
||||||
|
self.run_callback(id, None).await;
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn send(&mut self, id: u64, message: Response) {
|
||||||
|
self.run_callback(id, Some(message)).await;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Stream for ProcessReceiver {
|
||||||
|
type Item = RequestEnvelope;
|
||||||
|
|
||||||
|
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||||
|
Stream::poll_next(unsafe { Pin::new_unchecked(&mut self.request_queue) }, cx)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[async_trait]
|
||||||
|
impl RawBusClient for ProcessReceiver {
|
||||||
|
async fn send(&mut self, request: RequestEnvelope) -> ResponseEnvelope {
|
||||||
|
let deferred = Deferred::new();
|
||||||
|
let def_clone = deferred.clone();
|
||||||
|
{
|
||||||
|
let mut state = self.state.lock().await;
|
||||||
|
state.callbacks.insert(request.id, def_clone);
|
||||||
|
}
|
||||||
|
|
||||||
|
self.request_queue.push(request);
|
||||||
|
deferred.await
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,41 @@
|
|||||||
|
mod client;
|
||||||
|
mod server;
|
||||||
|
mod connection;
|
||||||
|
mod connection_process;
|
||||||
|
mod connection_unix;
|
||||||
|
|
||||||
|
pub use client::*;
|
||||||
|
pub use server::*;
|
||||||
|
pub use connection::*;
|
||||||
|
pub use connection_unix::*;
|
||||||
|
pub use connection_process::*;
|
||||||
|
|
||||||
|
#[derive(Clone, Default, Debug)]
|
||||||
|
pub struct Response;
|
||||||
|
|
||||||
|
#[derive(Clone, Default, Debug)]
|
||||||
|
pub struct ResponseEnvelope {
|
||||||
|
id: u64,
|
||||||
|
response: Option<Response>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Default, Debug)]
|
||||||
|
pub struct Request;
|
||||||
|
|
||||||
|
#[derive(Clone, Default, Debug)]
|
||||||
|
pub struct RequestEnvelope {
|
||||||
|
id: u64,
|
||||||
|
request: Request,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub struct IncomingMessage {
|
||||||
|
client: Client,
|
||||||
|
request: RequestEnvelope,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl IncomingMessage {
|
||||||
|
pub async fn ack(&mut self) {
|
||||||
|
self.client.ack(self.request.id);
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,240 @@
|
|||||||
|
use async_std::sync::{Arc, Mutex};
|
||||||
|
use crate::bus::{BusConnection, IncomingMessage, Receiver, BusClient, ProcessReceiver, RequestEnvelope, RawReceiver, Response};
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use crate::utils::asyn::AsyncQueue;
|
||||||
|
use async_std::task;
|
||||||
|
use std::fmt::{Debug, Formatter, Error};
|
||||||
|
use futures::{Stream, StreamExt};
|
||||||
|
use std::task::{Context, Poll};
|
||||||
|
use std::future::Future;
|
||||||
|
use std::pin::Pin;
|
||||||
|
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub struct BusServer {
|
||||||
|
process_connection: ProcessReceiver,
|
||||||
|
process_client: BusClient,
|
||||||
|
state: Arc<Mutex<BusServerState>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub struct BusServerState {
|
||||||
|
receivers: Vec<Receiver>,
|
||||||
|
clients: ClientPool,
|
||||||
|
message_queue: AsyncQueue<IncomingMessage>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BusServer {
|
||||||
|
pub fn new() -> Self {
|
||||||
|
let receiver = ProcessReceiver::new();
|
||||||
|
BusServer {
|
||||||
|
process_connection: receiver.clone(),
|
||||||
|
process_client: BusClient::new(Box::new(receiver)),
|
||||||
|
state: Arc::new(Mutex::new(BusServerState {
|
||||||
|
receivers: vec![],
|
||||||
|
clients: ClientPool::new(),
|
||||||
|
message_queue: AsyncQueue::new(),
|
||||||
|
})),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn attach_process_receiver(&mut self) {
|
||||||
|
let copy = Box::new(self.process_connection.clone()) as Box<dyn RawReceiver>;
|
||||||
|
self.add_receiver(Receiver::new(copy)).await;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn add_receiver(&mut self, receiver: Receiver) {
|
||||||
|
let mut state = self.state.lock().await;
|
||||||
|
state.receivers.push(receiver);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn run(&mut self, handler: impl MessageHandler) {
|
||||||
|
for receiver in &self.state.lock().await.receivers {
|
||||||
|
let mut cloned_receiver = receiver.clone();
|
||||||
|
let mut cloned_server = self.clone();
|
||||||
|
|
||||||
|
task::spawn(async move {
|
||||||
|
while let Some(client) = cloned_receiver.get().await {
|
||||||
|
cloned_server.register_client(client).await;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
self.message_handler(handler).await;
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn message_handler(&mut self, mut handler: impl MessageHandler) {
|
||||||
|
let mut queue = {
|
||||||
|
let state = self.state.lock().await;
|
||||||
|
state.message_queue.clone()
|
||||||
|
};
|
||||||
|
|
||||||
|
while let Some(message) = queue.next().await {
|
||||||
|
handler.handle_message(message, self.clone()).await;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn register_client(&mut self, client: Box<dyn BusConnection>) {
|
||||||
|
let mut state = self.state.lock().await;
|
||||||
|
let mut client = state.clients.register_client(client, self.clone()).await;
|
||||||
|
task::spawn(async move {
|
||||||
|
client.listen().await
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn queue(&self, message: IncomingMessage) {
|
||||||
|
let mut queue = {
|
||||||
|
let state = self.state.lock().await;
|
||||||
|
state.message_queue.clone()
|
||||||
|
};
|
||||||
|
queue.push(message);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_process_client(&self) -> BusClient {
|
||||||
|
self.process_client.clone()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[async_trait]
|
||||||
|
pub trait MessageHandler {
|
||||||
|
async fn handle_message(&mut self, message: IncomingMessage, server: BusServer);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug)]
|
||||||
|
pub struct ClientPool {
|
||||||
|
state: Arc<Mutex<ClientMap>>
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ClientPool {
|
||||||
|
async fn register_client(&mut self, client: Box<dyn BusConnection>, server: BusServer) -> Client {
|
||||||
|
self.state.lock().await.register_client(client, server)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn new() -> Self {
|
||||||
|
ClientPool { state: Arc::new(Mutex::new(ClientMap::new())) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct ClientMap {
|
||||||
|
id: u64,
|
||||||
|
clients: HashMap<u64, Client>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ClientMap {
|
||||||
|
fn new() -> ClientMap {
|
||||||
|
ClientMap {
|
||||||
|
id: 0,
|
||||||
|
clients: Default::default(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn register_client(&mut self, client: Box<dyn BusConnection>, server: BusServer) -> Client {
|
||||||
|
let client_id = self.id;
|
||||||
|
self.id += 1;
|
||||||
|
self.clients.insert(client_id, Client {
|
||||||
|
raw_client: Arc::new(Mutex::new(RawClient {
|
||||||
|
_id: client_id,
|
||||||
|
connection: client,
|
||||||
|
})),
|
||||||
|
bus_server: server,
|
||||||
|
message_queue: AsyncQueue::new(),
|
||||||
|
id: client_id,
|
||||||
|
});
|
||||||
|
|
||||||
|
let client = self.clients.get(&client_id).unwrap();
|
||||||
|
|
||||||
|
client.clone()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl Debug for Client {
|
||||||
|
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
|
||||||
|
write!(f, "Client {{ #{} }}", self.id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Client {
|
||||||
|
raw_client: Arc<Mutex<RawClient>>,
|
||||||
|
bus_server: BusServer,
|
||||||
|
message_queue: AsyncQueue<Message>,
|
||||||
|
id: u64,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum Message {
|
||||||
|
In(RequestEnvelope),
|
||||||
|
Ack(u64),
|
||||||
|
Response(u64, Response),
|
||||||
|
Close,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Client {
|
||||||
|
async fn listen(&mut self) {
|
||||||
|
let client = self.raw_client.clone();
|
||||||
|
|
||||||
|
while let Some(message) = self.next().await {
|
||||||
|
match message {
|
||||||
|
Message::In(message) => self.handle_request(message).await,
|
||||||
|
Message::Ack(id) => client.lock().await.connection.ack(id).await,
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
self.raw_client.lock().await.close().await;
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn handle_request(&self, request: RequestEnvelope) {
|
||||||
|
self.bus_server.queue(IncomingMessage {
|
||||||
|
client: self.clone(),
|
||||||
|
request,
|
||||||
|
}).await;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn ack(&mut self, id: u64) {
|
||||||
|
self.message_queue.push(Message::Ack(id));
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn send(&mut self, id: u64, response: Response) {
|
||||||
|
self.message_queue.push(Message::Response(id, response));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Stream for Client {
|
||||||
|
type Item = Message;
|
||||||
|
|
||||||
|
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||||
|
let queue_pin = unsafe { Pin::new_unchecked(&mut self.message_queue) };
|
||||||
|
match Stream::poll_next(queue_pin, cx) {
|
||||||
|
Poll::Ready(None) => return Poll::Ready(None),
|
||||||
|
Poll::Ready(Some(message)) => return Poll::Ready(Some(message)),
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut lock = self.raw_client.lock();
|
||||||
|
if let Poll::Ready(mut client) = Future::poll(unsafe { Pin::new_unchecked(&mut lock) }, cx) {
|
||||||
|
let connection_pin = unsafe { Pin::new_unchecked(&mut client.connection) };
|
||||||
|
match Stream::poll_next(connection_pin, cx) {
|
||||||
|
Poll::Ready(None) => return Poll::Ready(None),
|
||||||
|
Poll::Ready(Some(message)) => return Poll::Ready(Some(Message::In(message))),
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Poll::Pending
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct RawClient {
|
||||||
|
_id: u64,
|
||||||
|
connection: Box<dyn BusConnection>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RawClient {
|
||||||
|
async fn close(&mut self) {
|
||||||
|
self.connection.close().await;
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue