use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use sapphire_bridge_api::{
Ack, GrainId, IncomingParams, PeersResult, RegisterParams, RegisterResult, StatusResult,
UnregisterParams, WORKSPACES, WorkgroupWorkspaceInfo, WorkspacesResult,
};
use sapphire_bridge_client::BridgeClient;
use sapphire_ipc::{ClientInfo, Connection, ManagedBy, Router, ServerInfo, serve};
#[derive(Clone, Debug, Default)]
pub struct Seen {
pub registrations: Vec<RegisterParams>,
pub unregistrations: Vec<GrainId>,
}
pub struct StubBridge {
pub seen: Arc<Mutex<Seen>>,
pub device_id: GrainId,
pub workgroup_id: GrainId,
pub listed: Arc<Mutex<Vec<WorkgroupWorkspaceInfo>>>,
peers_queries: Arc<AtomicUsize>,
announcer: sapphire_ipc::Sender,
}
impl StubBridge {
pub async fn start() -> (StubBridge, Arc<BridgeClient>) {
let seen = Arc::new(Mutex::new(Seen::default()));
let device_id = GrainId::random();
let workgroup_id = GrainId::random();
let peers_queries = Arc::new(AtomicUsize::new(0));
let listed = Arc::new(Mutex::new(Vec::new()));
let (client_conn, server_conn) = Connection::pair();
let announcer = server_conn.sender();
let router = Arc::new(
Router::new()
.method(sapphire_bridge_api::REGISTER, {
let seen = Arc::clone(&seen);
move |ctx| {
let seen = Arc::clone(&seen);
async move {
let params: RegisterParams = serde_json::from_value(ctx.params)
.map_err(|e| {
sapphire_ipc::RpcError::invalid_params(e.to_string())
})?;
seen.lock().expect("stub").registrations.push(params);
serde_json::to_value(RegisterResult {
device_id,
node_id: "stub".into(),
workgroup_id,
})
.map_err(|e| sapphire_ipc::RpcError::internal(e.to_string()))
}
}
})
.method(sapphire_bridge_api::UNREGISTER, {
let seen = Arc::clone(&seen);
move |ctx| {
let seen = Arc::clone(&seen);
async move {
let params: UnregisterParams = serde_json::from_value(ctx.params)
.map_err(|e| {
sapphire_ipc::RpcError::invalid_params(e.to_string())
})?;
seen.lock()
.expect("stub")
.unregistrations
.push(params.workspace_id);
serde_json::to_value(Ack {})
.map_err(|e| sapphire_ipc::RpcError::internal(e.to_string()))
}
}
})
.method(sapphire_bridge_api::PEERS, {
let peers_queries = Arc::clone(&peers_queries);
move |_| {
let peers_queries = Arc::clone(&peers_queries);
async move {
peers_queries.fetch_add(1, Ordering::Relaxed);
serde_json::to_value(PeersResult {
peers: vec![],
roles: vec![],
})
.map_err(|e| sapphire_ipc::RpcError::internal(e.to_string()))
}
}
})
.method(WORKSPACES, {
let listed = Arc::clone(&listed);
move |_| {
let listed = Arc::clone(&listed);
async move {
serde_json::to_value(WorkspacesResult {
workspaces: listed.lock().expect("stub").clone(),
})
.map_err(|e| sapphire_ipc::RpcError::internal(e.to_string()))
}
}
})
.method(sapphire_bridge_api::STATUS, |_| async move {
serde_json::to_value(StatusResult {
version: "stub".into(),
node_id: "stub".into(),
workgroup: None,
routes: vec![],
embedding: None,
})
.map_err(|e| sapphire_ipc::RpcError::internal(e.to_string()))
}),
);
tokio::spawn(async move {
let info = ServerInfo {
version: "stub".into(),
api: sapphire_bridge_api::API_VERSION,
app_api: None,
pid: std::process::id(),
managed_by: ManagedBy::Service,
};
let _ = serve(server_conn, router, "bridge", info).await;
});
let info = ClientInfo {
kind: "test".into(),
version: "stub".into(),
api: sapphire_bridge_api::API_VERSION,
app_api: None,
pid: std::process::id(),
};
let (client, _) = sapphire_ipc::Client::handshake(client_conn, "bridge", info)
.await
.expect("the stub handshake");
let client = Arc::new(BridgeClient::from_client(
Arc::new(client),
std::env::temp_dir(),
));
(
StubBridge {
seen,
listed,
device_id,
workgroup_id,
peers_queries,
announcer,
},
client,
)
}
pub async fn announce(&self, workspace_id: GrainId, ticket: &str) {
let params = IncomingParams {
workspace_id,
peer_device_id: GrainId::random(),
ticket: ticket.to_owned(),
};
let _ = self
.announcer
.send(sapphire_ipc::Message::Notification(
sapphire_ipc::Notification {
method: sapphire_bridge_api::INCOMING.to_owned(),
params: serde_json::to_value(params).expect("announcement"),
},
))
.await;
}
pub fn peers_queries(&self) -> usize {
self.peers_queries.load(Ordering::Relaxed)
}
pub fn list(&self, info: WorkgroupWorkspaceInfo) {
self.listed.lock().expect("stub").push(info);
}
pub fn last_workspaces(&self) -> Vec<GrainId> {
self.seen
.lock()
.expect("stub")
.registrations
.last()
.map(|r| r.workspaces.iter().map(|w| w.workspace_id).collect())
.unwrap_or_default()
}
}