5 unstable releases
0.3.1 | Jul 29, 2024 |
---|---|
0.3.0 | Jul 23, 2024 |
0.2.1 | Jul 11, 2024 |
0.2.0 | Jul 6, 2024 |
0.1.0 | Jul 3, 2024 |
#663 in Parser implementations
31 downloads per month
325KB
8K
SLoC
FIX/FAST Protocol Decoder/Encoder
FAST (FIX Adapted for STreaming protocol) is a space and processing efficient encoding method for message oriented data streams.
The FAST protocol has been developed as part of the FIX Market Data Optimization Working Group. FAST data compression algorithm is designed to optimize electronic exchange of financial data, particularly for high volume, low latency data dissemination. It significantly reduces bandwidth requirements and latency between sender and receiver. FAST works especially well at improving performance during periods of peak message rates.
Technical Specification: https://www.fixtrading.org/standards/fast-online/
Supported version: 1.x.1
Usage
Add to your Cargo.toml
:
[dependencies]
fastlib = "0.3"
Serialize/Deserialize using serde
For templates defined in XML, e.g.:
<?xml version="1.0" encoding="UTF-8" ?>
<templates xmlns="http://www.fixprotocol.org/ns/fast/td/1.1">
<template name="MsgHeader">
<uInt32 id="34" name="MsgSeqNum"/>
<uInt64 id="52" name="SendingTime"/>
</template>
<template id="1" name="MDHeartbeat">
<templateRef name="MsgHeader"/>
</template>
<template id="2" name="MDLogout">
<templateRef name="MsgHeader"/>
<string id="58" name="Text" presence="optional"/>
</template>
</templates>
Define the message types in Rust:
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
enum Message {
MDHeartbeat(Heartbeat),
MDLogout(Logout),
}
#[derive(Serialize, Deserialize)]
struct MsgHeader {
#[serde(rename = "MsgSeqNum")]
msg_seq_num: u32,
#[serde(rename = "SendingTime")]
sending_time: u64,
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
struct Heartbeat {
#[serde(flatten)]
msg_header: MsgHeader,
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
struct Logout {
#[serde(flatten)]
msg_header: MsgHeader,
text: Option<String>,
}
Some implementation guidelines:
<templates>
must be implemented asenum
;<decimal>
can be deserialized tof64
orfastlib::Decimal
(if you need to preserve original scale);<byteVector>
is aVec<u8>
and must be prefixed with#[serde(with = "serde_bytes")]
;<sequence>
is aVec<SequenceItem>
, whereSequenceItem
is astruct
;<group>
is a nestedstruct
;- fields with optional presence are
Option<...>
; - static template reference can be plain fields from the template or flattened
struct
, - dynamic template references must be
Box<Message>
with#[serde(rename = "templateRef:N")]
, whereN
is a 0-based index of the<teplateRef>
in its group.
To deserialize a message call fastlib::from_vec
, fastlib::from_bytes
or from_stream
:
use fastlib::Decoder;
// Create a decoder from XML templates.
let mut decoder = Decoder::new_from_xml(include_str!("templates.xml"))?;
// Raw data that contains one message.
let raw_data: Vec<u8> = vec![ ... ];
// Deserialize a message.
let msg: Message = fastlib::from_vec(&mut decoder, raw_data)?;
To serialize a message call fastlib::to_vec
, fastlib::to_bytes
or to_stream
:
use fastlib::Encoder;
// Create a encoder from XML templates.
let mut encoder = Encoder::new_from_xml(include_str!("templates.xml"))?;
// Message to serialize.
let msg = Message::MDHeartbeat{
Heartbeat {
...
}
};
// Serialize a message.
let raw: Vec<u8> = fastlib::to_vec(&mut encoder, &msg)?;
Decode to JSON
use fastlib::Decoder;
use fastlib::JsonMessageFactory;
// Create a decoder from XML templates.
let mut decoder = Decoder::new_from_xml(include_str!("templates.xml"))?;
// Raw data that contains one message.
let raw_data: Vec<u8> = vec![ ... ];
// Create a JSON message factory.
let mut msg = JsonMessageFactory::new();
// Decode the message.
decoder.decode_vec(raw_data, &mut msg)?;
println!("{}", msg.json);
Decode using own message factory
Make a new struct that implements fastlib::MessageFactory
trait:
use fastlib::{MessageFactory, Value};
pub struct MyMessageFactory {
}
impl MessageFactory for MyMessageFactory {
// ... your implementation here ...
}
You have to implement callbacks that will be called during message decoding:
pub trait MessageFactory {
// Process template id
fn start_template(&mut self, id: u32, name: &str);
fn stop_template(&mut self);
// Process field value
fn set_value(&mut self, id: u32, name: &str, value: Option<Value>);
// Process sequence
fn start_sequence(&mut self, id: u32, name: &str, length: u32);
fn start_sequence_item(&mut self, index: u32);
fn stop_sequence_item(&mut self);
fn stop_sequence(&mut self);
// Process group
fn start_group(&mut self, name: &str);
fn stop_group(&mut self);
// Process template ref
fn start_template_ref(&mut self, name: &str, dynamic: bool);
fn stop_template_ref(&mut self);
}
For examples see implementation for fastlib::text::TextMessageFactory
or fastlib::text::JsonMessageFactory
but more likely you will want to construct you own message structs.
Then create a decoder from templates XML file and decode a message:
use fastlib::Decoder;
// Create a decoder from XML templates.
let mut decoder = Decoder::new_from_xml(include_str!("templates.xml"))?;
// Raw data that contains one message.
let raw_data: Vec<u8> = vec![ ... ];
// Create a message factory.
let mut msg = MyMessageFactory{};
// Decode the message.
decoder.decode_vec(raw_data, &mut msg)?;
Examples
License
This project is licensed under the MIT license.
Dependencies
~2–3MB
~51K SLoC