1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
// Public domain, 2017-01-23, James Bendig.
#![allow(unused_variables)]
#[macro_use]
extern crate fix_rs;
use std::time::Duration;
use fix_rs::dictionary::field_types::other::EncryptMethod;
use fix_rs::dictionary::messages::{BusinessMessageReject,Heartbeat,Logon,Logout,Reject,ResendRequest,SequenceReset,TestRequest};
use fix_rs::fix_version::FIXVersion;
use fix_rs::fixt::engine::{Engine,EngineEvent};
use fix_rs::message_version::MessageVersion;
fn main() {
//List only the messages we need. The define_dictionary!() macro creates the following for us:
// fn build_dictionary(): A function that turns the listed messages into instructions used for
// parsing FIX messages.
// enum MessageEnum: An enum of the listed messages so Rust's match statement can be used to
// make sure all messages are being handled.
// fn message_to_enum(): A function used to convert a FIXTMessage into a MessageEnum. Since
// the Engine returns FIXTMessages, this function is a convenient way
// to match and get concrete types.
define_dictionary!(
BusinessMessageReject,
Heartbeat,
Logon,
Logout,
Reject,
ResendRequest,
SequenceReset,
TestRequest,
);
//Create an Engine which is used for initiating FIX connections.
let max_message_size = 4096; //The maximum message size allowed to be received in bytes.
let mut client = Engine::new(build_dictionary(),max_message_size).unwrap();
//Initiate a connection to a FIX engine. The connection_id is used to interact with this
//connection.
let fix_version = FIXVersion::FIXT_1_1; //Communicate with protocol version FIXT.1.1.
let message_version = MessageVersion::FIX50SP2; //Default to FIX 5.0. SP2 for outgoing messages.
let sender_comp_id = b"Client"; //SenderCompID sent in every FIX message.
let target_comp_id = b"Exchange"; //TargetCompID sent in every FIX message.
let addr = "127.0.0.1:7001"; //IP and port to connect to.
let connection_id = client.add_connection(fix_version,message_version,sender_comp_id,target_comp_id,addr).unwrap();
//Poll client for new events. Events include new messages, connection status updates, errors,
//etc.
let timeout_duration = Duration::from_secs(120); //Optional.
while let Some(event) = client.poll(timeout_duration) {
match event {
//Connection was able to open TCP stream to server.
EngineEvent::ConnectionSucceeded(connection_id) => {
println!("({})Connection succeeded",connection_id);
//Start logon process.
let mut logon_message = Logon::new();
logon_message.encrypt_method = EncryptMethod::None;
logon_message.heart_bt_int = 5;
logon_message.default_appl_ver_id = message_version;
client.send_message(connection_id,logon_message);
},
//Connection could not open TCP stream to server.
EngineEvent::ConnectionFailed(connection_id,err) => {
println!("({})Connection failed: {}",connection_id,err);
break;
},
//Connection to server was closed either using the Engine::logout() function, logout
//request by server, or an unrecoverable error.
EngineEvent::ConnectionTerminated(connection_id,reason) => {
println!("({})Connection terminated: {:?}",connection_id,reason);
break;
},
//Connection completed the logon process and is free to communicate.
EngineEvent::SessionEstablished(connection_id) => {
println!("({})Session established",connection_id);
//Start sending messages here.
},
//Connection received a new message.
EngineEvent::MessageReceived(connection_id,message) => {
//Handle the received message. Must be one of the messages listed in the
//define_dictionary!() macro above. In this case, these are all administrative
//messages that are handled by the Engine automatically but are passed along here
//for logging purposes.
match message_to_enum(&*message) {
MessageEnum::BusinessMessageReject(message) => {},
MessageEnum::Heartbeat(message) => {},
MessageEnum::Logon(message) => {},
MessageEnum::Logout(message) => {},
MessageEnum::Reject(message) => {},
MessageEnum::ResendRequest(message) => {},
MessageEnum::SequenceReset(message) => {},
MessageEnum::TestRequest(message) => {},
};
},
//Connection received a message that could not be parsed correctly.
EngineEvent::MessageReceivedGarbled(connection_id,parse_error) => {
println!("({})Could not parse message: {}",connection_id,parse_error);
},
//Connection received a message with a MsgSeqNum matching another message that was
//already received.
EngineEvent::MessageReceivedDuplicate(connection_id,message) => {
println!("({})Received message with duplicate MsgSeqNum: {}",connection_id,message.msg_seq_num());
},
//Connection received a message that doesn't follow session rules and was rejected. No
//further action is necessary but it might be worth logging.
EngineEvent::MessageRejected(connection_id,message) => {
println!("({})Message was rejected",connection_id);
},
//Connected received a ResendRequest message for the messages in
//[range.start,range.end).
EngineEvent::ResendRequested(connection_id,range) => {
println!("({})Received ResendRequest for messages where {} <= MsgSeqNum < {}",connection_id,range.start,range.end);
},
//Connection received a SequenceReset-Reset message where NewSeqNo is set to the same
//number as the expected MsgSeqNum.
EngineEvent::SequenceResetResetHasNoEffect(connection_id) => {
println!("({})Received SequenceReset-Reset with no effect",connection_id);
},
//Connection received a SequenceReset-Reset message where NewSeqNo is set to an already
//seen MsgSeqNum.
EngineEvent::SequenceResetResetInThePast(connection_id) => {
println!("({})Received SequenceReset-Reset where NoSeqNo is in the past",connection_id);
},
//Internal error setting up Engine (before any connections were added).
EngineEvent::FatalError(_,_) => {
println!("Could not setup Engine.");
break;
},
//The following events are not used for client connections.
EngineEvent::ConnectionDropped(_,_) |
EngineEvent::ConnectionAccepted(_,_,_) |
EngineEvent::ConnectionLoggingOn(_,_,_) |
EngineEvent::ListenerFailed(_,_) |
EngineEvent::ListenerAcceptFailed(_,_) => {}
}
}
}