use std::sync::Arc;
use connectrpc::{
InboundStream, PreEncoded, RequestContext, Response, ServiceRequest, error::ConnectError,
};
use futures_util::StreamExt;
use super::{ClientIdentity, ManagerError, SessionManager, SessionState, time};
use crate::proto::{common, worker};
fn error_detail_message(reason: common::ErrorReason) -> common::ErrorDetail {
common::ErrorDetail {
reason: buffa::EnumValue::Known(reason),
domain: "longtrader.worker".to_string(),
..Default::default()
}
}
fn error_detail(reason: common::ErrorReason) -> connectrpc::ErrorDetail {
connectrpc::ErrorDetail::from_message(
"longtrader.common.v1.ErrorDetail",
&error_detail_message(reason),
)
}
impl From<ManagerError> for ConnectError {
fn from(err: ManagerError) -> Self {
match err {
ManagerError::NotFound(msg) => Self::not_found(msg),
ManagerError::Unauthenticated => Self::unauthenticated("authentication failed"),
ManagerError::InvalidArgument(msg) => Self::invalid_argument(msg),
ManagerError::SyncInProgress { .. } => Self::failed_precondition(err.to_string())
.with_detail(error_detail(common::ErrorReason::SyncInProgress)),
ManagerError::CancelsFailed { .. } => Self::internal(err.to_string()),
ManagerError::Port(e) => Self::internal(e.to_string()),
}
}
}
#[cfg(test)]
mod error_detail_tests {
use super::*;
#[test]
fn sync_in_progress_carries_the_typed_reason() {
let detail = error_detail_message(common::ErrorReason::SyncInProgress);
assert!(matches!(
detail.reason,
buffa::EnumValue::Known(common::ErrorReason::SyncInProgress)
));
assert_eq!(detail.domain, "longtrader.worker");
}
#[test]
fn detail_names_the_contract_message() {
let detail = error_detail(common::ErrorReason::SyncInProgress);
assert_eq!(detail.type_url, "longtrader.common.v1.ErrorDetail");
assert!(detail.value.is_some());
}
}
pub struct WorkerSessionServiceImpl {
pub manager: Arc<SessionManager>,
}
#[allow(refining_impl_trait)]
impl worker::WorkerSessionService for WorkerSessionServiceImpl {
async fn attach_session(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::AttachSessionRequest>,
) -> connectrpc::ServiceResult<PreEncoded<worker::AttachSessionResponse>> {
let req = request.to_owned_message();
let policy = req.policy.as_option().cloned();
let client =
ClientIdentity { name: req.client_name.clone(), version: req.client_version.clone() };
let (session_id, heartbeat_interval_ms) = self
.manager
.attach_with_reconnect(&req.token, policy, &req.session_id, &client)
.await?;
let resp = worker::AttachSessionResponse {
session_id,
heartbeat_interval_ms,
server_time: buffa::MessageField::some(time::now_ts()),
capabilities: vec![
"reconcile".to_string(),
"kill_switch".to_string(),
"event_replay".to_string(),
],
..Default::default()
};
Response::ok(PreEncoded::from_message(&resp))
}
async fn keep_alive(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::KeepAliveRequest>,
) -> connectrpc::ServiceResult<PreEncoded<worker::KeepAliveResponse>> {
let req = request.to_owned_message();
let handle = self.manager.get(&req.session_id).await?;
handle.touch().await;
let resp = worker::KeepAliveResponse {
server_time_ns: time::now_ns(),
heartbeat_interval_ms: handle.heartbeat_interval_ms,
..Default::default()
};
Response::ok(PreEncoded::from_message(&resp))
}
async fn reconcile_state(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::ReconcileStateRequest>,
) -> connectrpc::ServiceResult<PreEncoded<worker::ReconcileStateResponse>> {
let req = request.to_owned_message();
self.manager.begin_reconcile(&req.session_id).await?;
let snapshot = self
.manager
.gateway()
.sync_state(self.manager.default_exchange())
.await
.map_err(ManagerError::from)?;
self.manager.complete_reconcile(&req.session_id, snapshot.snapshot_sequence).await?;
let resp = worker::ReconcileStateResponse {
snapshot_sequence: snapshot.snapshot_sequence,
snapshot_time: snapshot.snapshot_time,
balances: snapshot.balances,
positions: snapshot.positions,
open_orders: snapshot.open_orders,
..Default::default()
};
Response::ok(PreEncoded::from_message(&resp))
}
async fn set_kill_switch_policy(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::SetKillSwitchPolicyRequest>,
) -> connectrpc::ServiceResult<PreEncoded<worker::SetKillSwitchPolicyResponse>> {
let req = request.to_owned_message();
let handle = self.manager.get(&req.session_id).await?;
if let Some(policy) = req.policy.as_option() {
handle.update_policy(|current| super::apply_policy(current, policy)).await?;
}
let resp = worker::SetKillSwitchPolicyResponse::default();
Response::ok(PreEncoded::from_message(&resp))
}
async fn register_strategy(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::RegisterStrategyRequest>,
) -> connectrpc::ServiceResult<PreEncoded<worker::RegisterStrategyResponse>> {
let req = request.to_owned_message();
let handle = self.manager.get(&req.session_id).await?;
let strategy_id = ulid::Ulid::generate().to_string();
handle
.set_strategy(super::StrategyInfo {
id: strategy_id.clone(),
name: req.name.clone(),
started_at_ms: time::now_ns() / 1_000_000,
orders_submitted: 0,
log_events: 0,
})
.await;
let resp = worker::RegisterStrategyResponse { strategy_id, ..Default::default() };
Response::ok(PreEncoded::from_message(&resp))
}
async fn strategy_status(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::StrategyStatusRequest>,
) -> connectrpc::ServiceResult<PreEncoded<worker::StrategyStatusResponse>> {
let req = request.to_owned_message();
let handle = self.manager.get(&req.session_id).await?;
let info = handle.strategy_info().await;
let resp = worker::StrategyStatusResponse {
state: buffa::EnumValue::Known(
handle.state().map_or(worker::SessionState::Attached, SessionState::to_proto),
),
strategy_id: info.as_ref().map_or_default(|i| i.id.clone()),
name: info.as_ref().map_or_default(|i| i.name.clone()),
started_at: info.as_ref().map_or(buffa::MessageField::none(), |i| {
buffa::MessageField::some(time::timestamp_from_ms(i.started_at_ms))
}),
orders_submitted: handle.orders_submitted_count(),
log_events: info.as_ref().map_or(0, |i| i.log_events),
..Default::default()
};
Response::ok(PreEncoded::from_message(&resp))
}
async fn stop_strategy(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::StopStrategyRequest>,
) -> connectrpc::ServiceResult<PreEncoded<worker::StopStrategyResponse>> {
let req = request.to_owned_message();
let final_state =
self.manager.stop_session(&req.session_id, req.cancel_open_orders).await?;
let resp = worker::StopStrategyResponse {
final_state: buffa::EnumValue::Known(
final_state.map_or(worker::SessionState::GracefulShutdown, SessionState::to_proto),
),
..Default::default()
};
Response::ok(PreEncoded::from_message(&resp))
}
async fn report_log(
&self,
_ctx: RequestContext,
mut requests: InboundStream<worker::LogEvent>,
) -> connectrpc::ServiceResult<PreEncoded<worker::ReportLogResponse>> {
let mut accepted: u64 = 0;
while let Some(item) = requests.next().await {
let event = item?.to_owned_message();
let level = match event.level {
buffa::EnumValue::Known(level) => level,
buffa::EnumValue::Unknown(_) => worker::LogLevel::Unspecified,
};
let fields: std::collections::HashMap<String, String> =
event.fields.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
self.manager
.report_log(&event.session_id, level, event.message.clone(), fields)
.await?;
accepted += 1;
}
let resp = worker::ReportLogResponse { accepted, ..Default::default() };
Response::ok(PreEncoded::from_message(&resp))
}
async fn stream_strategy_events(
&self,
_ctx: RequestContext,
request: ServiceRequest<'_, worker::StreamStrategyEventsRequest>,
) -> connectrpc::ServiceResult<connectrpc::ServiceStream<worker::StrategyEvent>> {
let req = request.to_owned_message();
let handle = self.manager.get(&req.session_id).await?;
let after_seq: u64 = if req.resume_token.is_empty() {
0
} else {
req.resume_token.parse().map_err(|_| {
ConnectError::invalid_argument(format!(
"bad resume_token {:?}; expected decimal sequence",
req.resume_token
))
})?
};
let mut rx = handle.subscribe();
let watermark = handle.current_seq();
let replay = handle.replay_after(after_seq).await;
let stream = async_stream::stream! {
for event in replay {
if event.header.as_option().is_some_and(|h| h.sequence > watermark) {
continue;
}
yield Ok((*event).clone());
}
loop {
match rx.recv().await {
Ok(event) => yield Ok((*event).clone()),
Err(tokio::sync::broadcast::error::RecvError::Lagged(n)) => {
tracing::warn!(
session = %req.session_id,
lagged = n,
"event stream lagged; terminating so the client resyncs"
);
break;
}
Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
}
}
};
Ok(Response::stream(stream))
}
}
#[cfg(test)]
mod service_contract_tests {
use std::sync::Arc as StdArc;
use buffa::{HasMessageView, Message};
use bytes::Bytes;
use connectrpc::{CodecFormat, Encodable, RequestContext, ServiceRequest};
use super::*;
use crate::{
adapters::MockAdapter,
ports::TradingGateway as _,
proto::{trading, worker, worker::WorkerSessionService as _},
};
fn test_service() -> (StdArc<MockAdapter>, StdArc<WorkerSessionServiceImpl>) {
let adapter = StdArc::new(MockAdapter::new(rust_decimal_macros::dec!(100)));
let gateway: StdArc<dyn crate::ports::TradingGateway> = adapter.clone();
let market: StdArc<dyn crate::ports::MarketDataSource> = adapter.clone();
let manager = StdArc::new(SessionManager::new(
None,
crate::ports::exchange_id("mock", ""),
gateway,
market,
));
(adapter, StdArc::new(WorkerSessionServiceImpl { manager }))
}
async fn attach_reply(
svc: &WorkerSessionServiceImpl,
request: worker::AttachSessionRequest,
) -> worker::AttachSessionResponse {
let body = Bytes::from(request.encode_to_vec());
let view = worker::AttachSessionRequest::decode_view(&body).expect("the request decodes");
let req = ServiceRequest::from_parts(&view, &body);
let resp = svc
.attach_session(RequestContext::new(Default::default()), req)
.await
.expect("a well-formed attach must be accepted");
worker::AttachSessionResponse::decode_from_slice(
&resp.body.encode(CodecFormat::Proto).expect("the reply encodes"),
)
.expect("the reply decodes as AttachSessionResponse")
}
async fn reconcile_reply(
svc: &WorkerSessionServiceImpl,
session_id: &str,
) -> worker::ReconcileStateResponse {
let request = worker::ReconcileStateRequest {
session_id: session_id.to_string(),
..Default::default()
};
let body = Bytes::from(request.encode_to_vec());
let view = worker::ReconcileStateRequest::decode_view(&body).expect("the request decodes");
let req = ServiceRequest::from_parts(&view, &body);
let resp = svc
.reconcile_state(RequestContext::new(Default::default()), req)
.await
.expect("a reconcile on an attached session must be accepted");
worker::ReconcileStateResponse::decode_from_slice(
&resp.body.encode(CodecFormat::Proto).expect("the reply encodes"),
)
.expect("the reply decodes as ReconcileStateResponse")
}
#[tokio::test]
async fn attach_session_advertises_the_full_lease() {
let (_mock, svc) = test_service();
let resp = attach_reply(
&svc,
worker::AttachSessionRequest {
token: "t".to_string(),
client_name: "test".to_string(),
client_version: "0.0.0".to_string(),
..Default::default()
},
)
.await;
assert!(!resp.session_id.is_empty(), "the session id binds every later call");
assert_eq!(
resp.heartbeat_interval_ms,
crate::session::DEFAULT_HEARTBEAT_MS,
"the client paces its KeepAlive on the negotiated interval"
);
assert!(resp.server_time.as_option().is_some(), "the server clock anchors lease math");
assert_eq!(
resp.capabilities,
vec!["reconcile".to_string(), "kill_switch".to_string(), "event_replay".to_string()],
"capabilities are what the client feature-detects against"
);
}
#[tokio::test]
async fn reconcile_state_returns_the_snapshot_verbatim() {
let (mock, svc) = test_service();
mock.set_positions(vec![trading::Position {
symbol: "BTC/USDT".to_string(),
..Default::default()
}])
.await;
let resting = mock
.create_order(trading::CreateOrderRequest {
exchange_id: buffa::MessageField::some(svc.manager.default_exchange().clone()),
order: buffa::MessageField::some(trading::OrderRequest {
client_order_id: "resting-1".to_string(),
symbol: "BTC/USDT".to_string(),
r#type: buffa::EnumValue::Known(trading::OrderType::Limit),
side: buffa::EnumValue::Known(trading::OrderSide::Buy),
amount: buffa::MessageField::some(longtrader_contract::ext::decimal_to_common(
rust_decimal_macros::dec!(1),
)),
..Default::default()
}),
..Default::default()
})
.await
.expect("test setup");
let attached = attach_reply(
&svc,
worker::AttachSessionRequest { token: "t".to_string(), ..Default::default() },
)
.await;
let resp = reconcile_reply(&svc, &attached.session_id).await;
assert_eq!(resp.snapshot_sequence, 1, "the mock's first snapshot watermark");
assert!(resp.snapshot_time.as_option().is_some(), "the snapshot is stamped in time");
assert_eq!(resp.balances.len(), 1, "the mock venue reports one balance");
assert_eq!(resp.positions.len(), 1, "the seeded position must be returned");
assert_eq!(
resp.open_orders.iter().map(|o| o.id.clone()).collect::<Vec<_>>(),
vec![resting.id.clone()],
"the resting order must be returned"
);
}
#[tokio::test]
async fn register_strategy_stamps_the_start_in_epoch_milliseconds() {
let (_mock, svc) = test_service();
let attached = attach_reply(
&svc,
worker::AttachSessionRequest { token: "t".to_string(), ..Default::default() },
)
.await;
let request = worker::RegisterStrategyRequest {
session_id: attached.session_id.clone(),
name: "grid".to_string(),
..Default::default()
};
let body = Bytes::from(request.encode_to_vec());
let view =
worker::RegisterStrategyRequest::decode_view(&body).expect("the request decodes");
let req = ServiceRequest::from_parts(&view, &body);
let resp = svc
.register_strategy(RequestContext::new(Default::default()), req)
.await
.expect("a register on an attached session must be accepted");
let resp = worker::RegisterStrategyResponse::decode_from_slice(
&resp.body.encode(CodecFormat::Proto).expect("the reply encodes"),
)
.expect("the reply decodes as RegisterStrategyResponse");
assert!(!resp.strategy_id.is_empty(), "the strategy id is what later RPCs address");
let handle = svc.manager.get(&attached.session_id).await.expect("test setup");
let info = handle.strategy_info().await.expect("the record was stored");
assert_eq!(info.name, "grid");
assert_eq!(info.id, resp.strategy_id);
assert!(
info.started_at_ms > 1_600_000_000_000,
"started_at_ms must be epoch milliseconds, got {}",
info.started_at_ms
);
}
}