use crate::{
application::Application,
connection::{read_loop, write_loop},
log::{LogEnum, LogFactoryEnum},
parser::Parser,
registry::unregister_session,
session::{
AdminEnum, Connect, FixIn, Session, StopReq, factory::SessionFactory, session_id::SessionID,
},
settings::Settings,
store::MessageStoreFactoryEnum,
tls,
};
use simple_error::SimpleResult;
use std::sync::Arc;
use tokio::{
io::BufReader,
net::TcpStream,
sync::{mpsc::UnboundedSender, watch},
task::JoinHandle,
time::sleep,
};
pub(crate) struct SessionHandle {
pub(crate) session: Option<Session>,
admin_tx: UnboundedSender<AdminEnum>,
tls_connector: Option<tokio_rustls::TlsConnector>,
session_settings: crate::session::settings::SessionSettings,
session_id: Arc<SessionID>,
}
pub struct Initiator {
pub(crate) sessions: Vec<SessionHandle>,
stop_tx: watch::Sender<bool>,
stop_rx: watch::Receiver<bool>,
task_handles: Vec<JoinHandle<()>>,
}
impl Initiator {
pub async fn new(
app: Arc<dyn Application>,
store_factory: MessageStoreFactoryEnum,
settings: Settings,
log_factory: LogFactoryEnum,
) -> SimpleResult<Self> {
let factory = SessionFactory {
build_initiators: true,
};
let mut sessions = Vec::new();
let session_settings = settings.session_settings().await;
for entry in &session_settings {
let (session_id, ss) = entry.pair();
let session = factory
.create_session(
session_id.clone(),
store_factory.clone(),
ss,
log_factory.clone(),
app.clone(),
)
.await?;
let admin_tx = session.admin.tx.clone();
let tls_connector = tls::load_tls_connector(ss).await?;
let sid = session.session_id.clone();
sessions.push(SessionHandle {
session: Some(session),
admin_tx,
tls_connector,
session_settings: ss.clone(),
session_id: sid,
});
}
let (stop_tx, stop_rx) = watch::channel(false);
Ok(Initiator {
sessions,
stop_tx,
stop_rx,
task_handles: Vec::new(),
})
}
#[allow(clippy::unused_async)]
pub async fn start(&mut self) -> SimpleResult<()> {
for handle in &mut self.sessions {
let mut session = handle
.session
.take()
.expect("Initiator::start() called more than once");
let connect_addresses = session.session_settings.socket_connect_address.clone();
let reconnect_interval = session
.session_settings
.reconnect_interval
.try_into()
.unwrap_or(std::time::Duration::from_secs(30));
let in_chan_capacity = session.session_settings.in_chan_capacity;
let admin_tx = handle.admin_tx.clone();
let mut stop_rx = self.stop_rx.clone();
let tls_connector = handle.tls_connector.clone();
let session_settings = handle.session_settings.clone();
let task_handle = tokio::spawn(async move {
let run_handle = tokio::spawn(async move {
session.run().await;
});
let mut address_index: usize = 0;
loop {
if *stop_rx.borrow() {
break;
}
if connect_addresses.is_empty() {
break;
}
let address = &connect_addresses[address_index % connect_addresses.len()];
address_index = address_index.wrapping_add(1);
let tcp_result = tokio::select! {
result = TcpStream::connect(address) => Some(result),
_ = stop_rx.changed() => None,
};
let Some(Ok(tcp_stream)) = tcp_result else {
if tcp_result.is_none() {
break;
}
tokio::select! {
() = sleep(reconnect_interval) => {},
_ = stop_rx.changed() => { break; }
}
continue;
};
let connected = if let Some(ref connector) = tls_connector {
let Ok(server_name) = tls::get_server_name(&session_settings, address)
else {
tokio::select! {
() = sleep(reconnect_interval) => {},
_ = stop_rx.changed() => { break; }
}
continue;
};
match connector.connect(server_name, tcp_stream).await {
Ok(tls_stream) => {
let (r, w) = tokio::io::split(tls_stream);
Some((
Box::new(r) as Box<dyn tokio::io::AsyncRead + Unpin + Send>,
Box::new(w)
as Box<dyn tokio::io::AsyncWrite + Unpin + Send>,
))
}
Err(_) => None, }
} else {
let (r, w) = tokio::io::split(tcp_stream);
Some((
Box::new(r) as Box<dyn tokio::io::AsyncRead + Unpin + Send>,
Box::new(w) as Box<dyn tokio::io::AsyncWrite + Unpin + Send>,
))
};
let Some((read_half, write_half)) = connected else {
tokio::select! {
() = sleep(reconnect_interval) => {},
_ = stop_rx.changed() => { break; }
}
continue;
};
let (msg_out_tx, msg_out_rx) =
tokio::sync::mpsc::channel::<Vec<u8>>(crate::session::DEFAULT_MSG_OUT_CAPACITY);
let (msg_in_tx, msg_in_rx) = {
let cap = if in_chan_capacity > 0 {
in_chan_capacity
} else {
1
};
tokio::sync::mpsc::channel::<FixIn>(cap)
};
let (err_tx, mut err_rx) =
tokio::sync::mpsc::unbounded_channel::<SimpleResult<()>>();
let _ = admin_tx.send(AdminEnum::Connect(Connect {
message_out: msg_out_tx,
message_in: msg_in_rx,
err: err_tx,
}));
if let Some(result) = err_rx.recv().await
&& result.is_err() {
tokio::select! {
() = sleep(reconnect_interval) => {},
_ = stop_rx.changed() => { break; }
}
continue;
}
let buf_reader = BufReader::new(read_half);
let parser = Parser::new(buf_reader);
let read_task =
tokio::spawn(async move { read_loop(parser, msg_in_tx).await });
let write_task = tokio::spawn(async move {
write_loop(write_half, msg_out_rx, LogEnum::default()).await;
});
tokio::select! {
_ = read_task => {},
_ = write_task => {},
_ = stop_rx.changed() => { break; }
}
tokio::select! {
() = sleep(reconnect_interval) => {},
_ = stop_rx.changed() => { break; }
}
}
let _ = admin_tx.send(AdminEnum::StopReq(StopReq));
let _ = run_handle.await;
});
self.task_handles.push(task_handle);
}
Ok(())
}
pub async fn stop(&mut self) {
let _ = self.stop_tx.send(true);
for handle in &self.sessions {
let _ = handle.admin_tx.send(AdminEnum::StopReq(StopReq));
}
for task in self.task_handles.drain(..) {
let _ = task.await;
}
for handle in &self.sessions {
let _ = unregister_session(&handle.session_id);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::application::NOPApp;
use crate::log::LogFactoryEnum;
use crate::registry::{SESSIONS, unregister_session};
use crate::store::MessageStoreFactoryEnum;
use serial_test::serial;
use tokio::io::BufReader;
fn clean_sessions() {
let keys: Vec<_> = SESSIONS.iter().map(|e| e.key().clone()).collect();
for key in keys {
let _ = unregister_session(&key);
}
}
async fn make_initiator_settings(host: &str, port: &str) -> Settings {
let cfg = format!(
r"
[DEFAULT]
[SESSION]
BeginString=FIX.4.2
SenderCompID=INITIATOR
TargetCompID=ACCEPTOR
HeartBtInt=30
SocketConnectHost={host}
SocketConnectPort={port}
"
);
Settings::parse(BufReader::new(cfg.as_bytes()))
.await
.unwrap()
}
#[tokio::test]
#[serial]
async fn test_initiator_new_creates_sessions() {
clean_sessions();
let app: Arc<dyn Application> = Arc::new(NOPApp::new());
let store_factory = MessageStoreFactoryEnum::default();
let log_factory = LogFactoryEnum::default();
let settings = make_initiator_settings("127.0.0.1", "5000").await;
let initiator = Initiator::new(app, store_factory, settings, log_factory)
.await
.expect("Initiator::new should succeed");
assert_eq!(1, initiator.sessions.len(), "should have 1 session");
let session = initiator.sessions[0]
.session
.as_ref()
.expect("session should exist before start()");
assert!(session.session_settings.initiate_logon, "should be an initiator session");
assert_eq!(
"127.0.0.1:5000", session.session_settings.socket_connect_address[0],
"should have correct connect address"
);
clean_sessions();
}
#[tokio::test]
#[serial]
async fn test_initiator_start_stop() {
clean_sessions();
let app: Arc<dyn Application> = Arc::new(NOPApp::new());
let store_factory = MessageStoreFactoryEnum::default();
let log_factory = LogFactoryEnum::default();
let settings = make_initiator_settings("127.0.0.1", "19123").await;
let mut initiator = Initiator::new(app, store_factory, settings, log_factory)
.await
.expect("Initiator::new should succeed");
initiator
.start()
.await
.expect("Initiator::start should succeed");
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
initiator.stop().await;
clean_sessions();
}
#[tokio::test]
#[serial]
async fn test_initiator_connects_to_acceptor() {
clean_sessions();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("should bind");
let listen_addr = listener.local_addr().unwrap();
let port = listen_addr.port().to_string();
let accept_handle = tokio::spawn(async move {
let (stream, _) = listener.accept().await.expect("should accept");
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
drop(stream);
});
let app: Arc<dyn Application> = Arc::new(NOPApp::new());
let store_factory = MessageStoreFactoryEnum::default();
let log_factory = LogFactoryEnum::default();
let settings = make_initiator_settings("127.0.0.1", &port).await;
let mut initiator = Initiator::new(app, store_factory, settings, log_factory)
.await
.expect("Initiator::new should succeed");
initiator
.start()
.await
.expect("Initiator::start should succeed");
let _ = accept_handle.await;
initiator.stop().await;
clean_sessions();
}
}