use crate::bus::{Bus, payload_of};
use crate::channels::{Channel, Request};
use crate::errors::SemiontError;
use crate::event_bus::EventBus;
use crate::namespaces::{
AuthNamespace, BeckonNamespace, BindNamespace, BrowseNamespace, FrameNamespace,
GatherNamespace, JobNamespace, MarkNamespace, MatchNamespace, Refresher, SystemNamespace,
YieldNamespace,
};
use crate::storage::SessionStorage;
use crate::timing::{BUS_REQUEST_TIMEOUT, INVALIDATION_WINDOW, JOB_SILENCE, JOB_STATUS_POLL};
use crate::transport::{ConnectionState, ContentTransport, Envelope, GatewayOperations, Transport};
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::watch;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ClientTiming {
pub bus_request: Duration,
pub job_silence: Duration,
pub job_status_poll: Duration,
pub invalidation_window: Duration,
}
impl Default for ClientTiming {
fn default() -> ClientTiming {
ClientTiming {
bus_request: BUS_REQUEST_TIMEOUT,
job_silence: JOB_SILENCE,
job_status_poll: JOB_STATUS_POLL,
invalidation_window: INVALIDATION_WINDOW,
}
}
}
#[derive(Clone)]
pub struct CachePersistence {
pub storage: Arc<dyn SessionStorage>,
pub key_prefix: String,
}
#[derive(Clone, Default)]
pub struct ClientOptions {
pub timing: ClientTiming,
pub cache_persistence: Option<CachePersistence>,
}
#[derive(Clone)]
pub(crate) struct Links {
pub transport: Arc<dyn Transport>,
pub wire: Bus,
pub own: EventBus,
pub timing: ClientTiming,
}
impl Links {
pub async fn request<R: Request>(
&self,
payload: &R::Payload,
) -> Result<<R::Result as Channel>::Payload, SemiontError> {
self.wire
.request::<R>(payload, self.timing.bus_request)
.await
}
pub async fn drive<C: Channel>(
&self,
payload: &C::Payload,
) -> Result<Option<u64>, SemiontError> {
Ok(self.wire.emit::<C>(payload, Envelope::default()).await?)
}
pub fn signal<C: Channel>(&self, payload: &C::Payload, envelope: Envelope) {
let _ = self.own.publish::<C>(payload, envelope);
}
pub fn report<C: Channel>(&self, payload: &C::Payload) {
let Ok(payload) = payload_of(payload) else {
return;
};
let wire = self.wire.clone();
tokio::spawn(async move {
let _ = wire.emit_on(C::NAME, payload, Envelope::default()).await;
});
}
}
pub struct SemiontClient {
transport: Arc<dyn Transport>,
wire: Bus,
own: EventBus,
refresher: Arc<Refresher>,
pub frame: FrameNamespace,
pub browse: BrowseNamespace,
pub mark: MarkNamespace,
pub bind: BindNamespace,
pub gather: GatherNamespace,
pub match_: MatchNamespace,
pub yield_: YieldNamespace,
pub beckon: BeckonNamespace,
pub job: JobNamespace,
pub auth: Option<AuthNamespace>,
pub system: Option<SystemNamespace>,
}
impl SemiontClient {
pub fn new(
transport: Arc<dyn Transport>,
content: Arc<dyn ContentTransport>,
gateway: Option<Arc<dyn GatewayOperations>>,
options: ClientOptions,
) -> SemiontClient {
let own = EventBus::new();
transport.bridge_into(Arc::new(own.clone()));
let wire = Bus::new(transport.clone());
let links = Links {
transport: transport.clone(),
wire: wire.clone(),
own: own.clone(),
timing: options.timing,
};
let browse = BrowseNamespace::new(
links.clone(),
content.clone(),
options.cache_persistence.as_ref(),
);
let gather = GatherNamespace::new(links.clone());
let match_ = MatchNamespace::new(links.clone());
SemiontClient {
transport,
wire,
own,
refresher: Refresher::new(&links, &browse, &gather, &match_),
frame: FrameNamespace::new(links.clone()),
browse,
mark: MarkNamespace::new(links.clone()),
bind: BindNamespace::new(links.clone()),
gather,
match_,
yield_: YieldNamespace::new(links.clone(), content),
beckon: BeckonNamespace::new(links.clone()),
job: JobNamespace::new(links),
auth: gateway.clone().map(AuthNamespace::new),
system: gateway.map(SystemNamespace::new),
}
}
pub fn transport(&self) -> &Arc<dyn Transport> {
&self.transport
}
pub fn bus(&self) -> &EventBus {
&self.own
}
pub fn wire(&self) -> &Bus {
&self.wire
}
pub fn base_url(&self) -> &str {
self.transport.base_url()
}
pub fn state(&self) -> watch::Receiver<ConnectionState> {
self.transport.state()
}
pub fn persistence_settled(&self) -> bool {
self.browse.persistence_settled()
}
pub async fn close(&self) {
self.refresher.dispose();
self.browse.dispose();
self.gather.dispose();
self.match_.dispose();
self.transport.close().await;
self.own.destroy();
}
}
impl Drop for SemiontClient {
fn drop(&mut self) {
self.own.destroy();
}
}