use crate::{
config::FILE_LOG_PATH,
errors::FixerError,
fileutil::session_id_filename_prefix,
log::{LogEnum, LogFactoryEnum, LogFactoryTrait, LogTrait},
session::session_id::SessionID,
settings::Settings,
};
use ramhorns::Template;
use rustc_hash::FxHashMap;
use std::{path::Path, sync::Arc};
use tokio::{
fs::{File, OpenOptions},
io::AsyncWriteExt,
};
const GLOBAL_PATH: &str = "GLOBAL";
pub struct FileLog {
event_file: File,
message_file: File,
}
impl LogTrait for FileLog {
async fn on_incoming(&mut self, data: &[u8]) {
let _ = self.message_file.write_all(data).await;
let _ = self.message_file.write_all(b"\n").await;
}
async fn on_outgoing(&mut self, data: &[u8]) {
let _ = self.message_file.write_all(data).await;
let _ = self.message_file.write_all(b"\n").await;
}
async fn on_event(&mut self, data: &str) {
let _ = self.event_file.write_all(data.as_bytes()).await;
let _ = self.event_file.write_all(b"\n").await;
}
async fn on_eventf(&mut self, fmt: &str, params: FxHashMap<String, String>) {
let tpl = Template::new(fmt).unwrap();
self.on_event(&tpl.render(¶ms)).await;
}
}
impl FileLog {
async fn new(prefix: &str, log_path: &str) -> Result<Self, String> {
let event_log_name = Path::new(log_path).join(format!("{prefix}.event.current.log"));
let message_log_name =
Path::new(log_path).join(format!("{prefix}.messages.current.log"));
tokio::fs::create_dir_all(log_path)
.await
.map_err(|err| err.to_string())?;
let event_file = OpenOptions::new()
.write(true)
.read(true)
.create(true)
.append(true)
.open(&event_log_name)
.await
.map_err(|err| err.to_string())?;
let message_file = OpenOptions::new()
.write(true)
.read(true)
.create(true)
.append(true)
.open(&message_log_name)
.await
.map_err(|err| err.to_string())?;
Ok(FileLog {
event_file,
message_file,
})
}
}
#[derive(Default, Clone)]
pub struct FileLogFactory {
global_log_path: String,
session_log_paths: FxHashMap<Arc<SessionID>, String>,
}
impl FileLogFactory {
#[allow(clippy::new_ret_no_self)]
pub async fn new(settings: &mut Settings) -> Result<LogFactoryEnum, FixerError> {
let mut log_factory = FileLogFactory::default();
let gs_option = settings.global_settings().await;
let gss = gs_option.as_ref().unwrap();
let res = gss.setting(FILE_LOG_PATH)?;
log_factory.global_log_path = res;
for entry in &settings.session_settings().await {
let (sid, session_settings) = entry.pair();
let log_path = session_settings.setting(FILE_LOG_PATH)?;
log_factory.session_log_paths.insert(sid.clone(), log_path);
}
Ok(LogFactoryEnum::FileLogFactory(log_factory))
}
}
impl LogFactoryTrait for FileLogFactory {
async fn create(&mut self) -> Result<LogEnum, String> {
let logger = FileLog::new(GLOBAL_PATH, &self.global_log_path).await?;
Ok(LogEnum::FileLog(logger))
}
async fn create_session_log(&mut self, session_id: Arc<SessionID>) -> Result<LogEnum, String> {
let prefix = session_id_filename_prefix(&session_id);
let log_path = self.session_log_paths.get(&session_id).ok_or_else(|| {
format!("logger not defined for {:?}", &*session_id.to_string())
})?;
let logger = FileLog::new(&prefix, log_path).await?;
Ok(LogEnum::FileLog(logger))
}
}
#[cfg(test)]
mod tests {
use super::FileLogFactory;
use crate::{
log::{LogFactoryTrait, LogTrait},
settings::Settings,
};
use std::path::Path;
use tempfile::TempDir;
use tokio::{
fs::File,
io::{AsyncBufReadExt, BufReader},
};
async fn generate_helper(global_path: &str, local_path: &str) -> Settings {
let cfg_str = format!(
r"# default settings for sessions
[DEFAULT]
ConnectionType=initiator
ReconnectInterval=60
SenderCompID=TW
FileLogPath={global_path}
# session definition
[SESSION]
BeginString=FIX.4.1
TargetCompID=ARCA
FileLogPath={local_path}
[SESSION]
BeginString=FIX.4.1
TargetCompID=ARCA
SessionQualifier=BS
",
);
let cfg = cfg_str.as_bytes();
let s_result = Settings::parse(cfg).await;
assert!(s_result.is_ok());
s_result.unwrap()
}
#[tokio::test]
async fn test_file_log_file_log_factory_new() {
let file_log_factory_result = FileLogFactory::new(&mut Settings::new()).await;
assert!(
file_log_factory_result.is_err(),
"Should expect error when settings have no file log path"
);
let mut settings = generate_helper(".", "mydir").await;
let factory_result = FileLogFactory::new(&mut settings).await;
assert!(factory_result.is_ok(), "Did not expect error",);
}
#[tokio::test]
async fn test_new_file_log() {
let tmp_dir = TempDir::new().unwrap();
let tmp = tmp_dir.path().to_str().unwrap().to_string();
let mut settings = generate_helper(&tmp, &tmp).await;
let factory_result = FileLogFactory::new(&mut settings).await;
assert!(factory_result.is_ok());
let mut factory = factory_result.unwrap();
let logger_result = factory.create().await;
assert!(logger_result.is_ok());
let messages_path = Path::new(&tmp).join("GLOBAL.messages.current.log");
let event_path = Path::new(&tmp).join("GLOBAL.event.current.log");
assert!(messages_path.exists());
assert!(event_path.exists());
}
#[tokio::test]
async fn test_file_log_append() {
let tmp_dir = TempDir::new().unwrap();
let tmp = tmp_dir.path().to_str().unwrap().to_string();
let mut settings = generate_helper(&tmp, &tmp).await;
let factory_result = FileLogFactory::new(&mut settings).await;
assert!(factory_result.is_ok());
let mut factory = factory_result.unwrap();
let logger_result = factory.create().await;
assert!(logger_result.is_ok());
let mut logger = logger_result.unwrap();
let message_path = Path::new(&tmp).join("GLOBAL.messages.current.log");
let event_path = Path::new(&tmp).join("GLOBAL.event.current.log");
logger.on_incoming(b"incoming").await;
let mut msg_buf = String::new();
let message_file = File::open(&message_path).await.unwrap();
let mut message_reader = BufReader::new(message_file);
let bytes_read = message_reader.read_line(&mut msg_buf).await.unwrap();
assert!(bytes_read != 0, "expected to read incoming message");
logger.on_event("Event").await;
let mut msg_buf = String::new();
let event_file = File::open(&event_path).await.unwrap();
let mut event_reader = BufReader::new(event_file);
let bytes_read = event_reader.read_line(&mut msg_buf).await.unwrap();
assert!(bytes_read != 0, "expected to read event");
let new_factory_result = FileLogFactory::new(&mut settings).await;
assert!(new_factory_result.is_ok());
let mut new_factory = new_factory_result.unwrap();
let new_logger_result = new_factory.create().await;
assert!(new_logger_result.is_ok());
let mut new_logger = new_logger_result.unwrap();
new_logger.on_incoming(b"incoming2").await;
let message_file = File::open(&message_path).await.unwrap();
let mut reader = BufReader::new(message_file);
let mut lines = Vec::new();
let mut buf = String::new();
while reader.read_line(&mut buf).await.unwrap() != 0 {
lines.push(buf.clone());
buf.clear();
}
assert!(lines.len() >= 2, "expected at least 2 message lines, got {}", lines.len());
new_logger.on_event("Event2").await;
let event_file = File::open(&event_path).await.unwrap();
let mut reader = BufReader::new(event_file);
let mut lines = Vec::new();
let mut buf = String::new();
while reader.read_line(&mut buf).await.unwrap() != 0 {
lines.push(buf.clone());
buf.clear();
}
assert!(lines.len() >= 2, "expected at least 2 event lines, got {}", lines.len());
}
}