DFX

A FIX protocol engine.

Goals

• [x] Runtime Message verification
• [x] Read config from file
• [x] Pass the test suite available
  • [x] FIX40
  • [x] FIX41
  • [x] FIX42
  • [x] FIX43
  • [x] FIX44
  • [x] FIX: fix44::testresendrepeating_group > Now the tests compares ordered fields, so the response match the expectation but are not exactly the same.
  • [x] FIXT11
  • [x] FIX50
  • [x] FIX50SP1
  • [x] FIX50SP2
  • [ ] FUTURE > IGNORED! > Currently not supported by Quickfix or Quickfix/N
  • [x] MISC
• [x] SSL / TLS
• [x] FileStore for messages
• [x] FileLogger
  • [x] Similar to quickfix
  • [x] [log](https://docs.rs/log/latest/log/) Logger

WIP

• Add inline and doc comments
  • Doc External
  • Doc Internal
  • Inline

TODO

• Add message factory from data dictionary.
• Codegen static data dictionary from xml.
• Replace with Traits where possible
• Allow compile time message definitions
• MessageCracker
• Cleanup session.rs
  • Simplify message handling
  • Simplify next / next_msg()

Credits

Heavily derived / inspired from QuickfixN

Examples

```rust use dfx::{ connection::SocketAcceptor, session::{Session, SessionSettings}, messagestore::{DefaultStoreFactory, MemoryStoreFactory}, datadictionary_provider::DefaultDataDictionaryProvider, logging::PrintlnLogFactory, message::DefaultMessageFactory, session::FromAppError, session::ApplicationError, session::LogonReject, session::DoNotAccept, message::Message, };

[derive(Clone, Default)]

struct Application;

impl dfx::session::Application for Application {

fn on_create(&mut self, _session_id: &dfx::session_id::SessionId) -> Result<(), DoNotAccept> {
    println!("Application: {}", _session_id);
    Ok(())
}

fn on_logon(&mut self, _session_id: &dfx::session_id::SessionId) -> Result<(), LogonReject> {
    println!("Application Logon: {}", _session_id);
    Ok(())
}

fn on_logout(&mut self, _session_id: &dfx::session_id::SessionId) -> Result<(), ApplicationError> {
    println!("Application Logout: {}", _session_id);
    Ok(())
}

fn to_admin(
    &mut self,
    message: Message,
    _session_id: &dfx::session_id::SessionId,
) -> Result<Message, dfx::field_map::FieldMapError> {
    println!("Application To Admin: {}", _session_id);
    Ok(message)
}

fn from_admin(
    &mut self,
    _message: &Message,
    _session_id: &dfx::session_id::SessionId,
) -> Result<(), dfx::field_map::FieldMapError> {
    println!("Application From Admin: {}", _session_id);
    Ok(())
}

fn to_app(
    &mut self,
    _message: &mut Message,
    _session_id: &dfx::session_id::SessionId,
) -> Result<(), ApplicationError> {
    println!("Application To App: {}", _session_id);
    Ok(())
}

fn from_app(
    &mut self,
    message: &Message,
    session_id: &dfx::session_id::SessionId,
) -> Result<(), FromAppError> {
    println!("Application From App: {}", session_id);
    // Echo back to sender
    Session::send_to_session(session_id, message.clone()).unwrap();
    Ok(())
}

}

let app = Application::default(); // TODO Use the following to read it from file: // let sessionsettings = SessionSettings::fromfile("fix.cfg").unwrap(); let sessionsettings = SessionSettings::default(); let mut acceptor = SocketAcceptor::new( &sessionsettings, app, DefaultStoreFactory::new(&session_settings), DefaultDataDictionaryProvider::new(), PrintlnLogFactory::new(), DefaultMessageFactory::new(), );

acceptor.start(); ```