def set_persister(self, persister): self.persister = persister self.in_db, self.out_db = persister.getTodayPersister() #self.persister.report( self.inDb) #self.persister.report( self.outDb) p = SynchronousParser(self.fix) import time for db in (self.in_db, self.out_db): start = time.time() i = 0.0 c = db.cursor() while True: v = c.next() if not v: break msg, _, _ = p.feed(v[1]) i += 1 endTime = time.time() dur = endTime - start print "%s parsed %s messages in %s secs (%s/sec)" % (db, i, dur, i / dur) self.in_msg_seq_num = self.persister.getNextSeq(self.in_db) self.out_msg_seq_num = self.persister.getNextSeq(self.out_db) print "Setting sequence numbers %s %s" % (self.in_msg_seq_num, self.out_msg_seq_num)
def set_persister(self, persister): self.persister = persister self.in_db, self.out_db = persister.getTodayPersister() #self.persister.report( self.inDb) #self.persister.report( self.outDb) p = SynchronousParser(self.fix) import time for db in (self.in_db, self.out_db): start = time.time() i = 0.0 c = db.cursor() while True: v = c.next() if not v: break msg, _, _ = p.feed(v[1]) i += 1 endTime = time.time() dur = endTime - start print "%s parsed %s messages in %s secs (%s/sec)" % (db, i, dur, i / dur ) self.in_msg_seq_num = self.persister.getNextSeq(self.in_db) self.out_msg_seq_num = self.persister.getNextSeq(self.out_db) print "Setting sequence numbers %s %s" % ( self.in_msg_seq_num, self.out_msg_seq_num)
def __init__(self, session_manager, fix, config): self.session_manager = session_manager self.protocol = None self.fix = fix self.sender = config.sender self.target = config.target self.sender_compid = fix.SenderCompID(self.sender) self.target_compid = fix.TargetCompID(self.target) self.begin_string = fix.BeginString(fix.version) self.out_msg_seq_num = 1 self.in_msg_seq_num = 1 self.set_persister( BerkeleyPersister(config.persistRoot, self.sender, self.target)) self.heartbeat_interval = config.heartbeatInterval # Why do we need an sp? self.sp = SynchronousParser(self.fix) self.last_by_type = {} self.state = None if config.app: self.set_app(config.app) else: self.set_app(FIXApplication(fix)) self.on_integrity_exception = None self.last_integrity_exception = None self.want_to_be_logged_in = True
def __init__(self, session_manager, fix, config): self.session_manager = session_manager self.protocol = None self.fix = fix self.sender = config.sender self.target = config.target self.sender_compid = fix.SenderCompID(self.sender) self.target_compid = fix.TargetCompID(self.target) self.begin_string = fix.BeginString(fix.version) self.out_msg_seq_num = 1 self.in_msg_seq_num = 1 self.set_persister(BerkeleyPersister(config.persistRoot, self.sender, self.target)) self.heartbeat_interval = config.heartbeatInterval # Why do we need an sp? self.sp = SynchronousParser(self.fix) self.last_by_type = {} self.state = None if config.app: self.set_app(config.app) else: self.set_app(FIXApplication(fix)) self.on_integrity_exception = None self.last_integrity_exception = None self.want_to_be_logged_in = True
def setUp(self): self.fix = parse_specification(self.version) self.fp = SynchronousParser(self.fix) self.sendConfig = SessionConfig( 'initiator', 0, 'localhost', 'INITIATOR', 'ACCEPTOR', os.path.join(tempfile.mktemp(), "sender"), # Will be tempfile 60, None) self.ds = Session(None, self.fix, self.sendConfig) major, minor = self.version.split('.')[1:] self.numVersion = int(major) * 10 + int(minor) print "NV = %s" % self.numVersion
def recover(self): assert self.session is not None self.in_recovery = True sp = SynchronousParser(self.fix) c = self.session.persister.ledger.cursor() while True: d = c.next() if not d: break try: msg, _, _ = sp.parse(d[1]) self.recovered_message(msg) except ParseException: msg = cPickle.loads(d[1]) self.recovered_message(msg) c.close() self.on_recovery_done() self.in_recovery = False
def __init__(self, fix, config, initiatorProtocol=InitiatorFIXProtocol, acceptorProtocol=AcceptorFIXProtocol): self.fix = fix self.config = config self.sessionLookup = {} self.initiatorProtocol = initiatorProtocol self.acceptorProtocol = acceptorProtocol self.beginString = self.fix.BeginString(self.fix.version) self.sessionByTuple = {} self.acceptorsByTuple = {} self.initiatorsByTuple = {} self.acceptorsByPort = defaultdict(lambda: {}) self.initiatorFactories = [] self.acceptorFactories = {} self.sessions = [] self.perspective = None for s in config: idTuple = (s.sender, s.target) session = Session(self, fix, s) self.sessions.append(session) self.sessionByTuple[idTuple] = idTuple if s.connectionType == 'initiator': #session.host = s.host #session.port = s.port f = InitiatorFactory(self, session, s.host, s.port) session.factory = f self.initiatorFactories.append(f) self.initiatorsByTuple[idTuple] = session else: assert s.connectionType == 'acceptor', "Must be acceptor or initiator" self.acceptorsByPort[s.port][idTuple] = session self.acceptorsByTuple[idTuple] = session self.sessionByTuple[idTuple] = session for port, sessionMap in self.acceptorsByPort.items(): af = AcceptorFactory(self, sessionMap) self.acceptorFactories[port] = af self.sp = SynchronousParser(self.fix)
def setUp( self): self.fix = parse_specification( self.version ) self.fp = SynchronousParser(self.fix) self.sendConfig = SessionConfig( 'initiator', 0, 'localhost', 'INITIATOR', 'ACCEPTOR', os.path.join( tempfile.mktemp(), "sender" ), # Will be tempfile 60, None ) self.ds = Session( None, self.fix, self.sendConfig) major, minor = self.version.split('.')[1:] self.numVersion = int(major) * 10 + int(minor) print "NV = %s" % self.numVersion
class SpecTester(unittest.TestCase): version = '4.1' def __repr__(self): return "SpecTester(%s,%s)" % (self.version, self.testMethod) __str__ = __repr__ def __init__(self, testMethod, version='FIX.4.0'): # NB nose wants the init method of a testcase to unittest.TestCase.__init__(self, methodName=testMethod) self.version = version self.testMethod = testMethod def setUp(self): self.fix = parse_specification(self.version) self.fp = SynchronousParser(self.fix) self.sendConfig = SessionConfig( 'initiator', 0, 'localhost', 'INITIATOR', 'ACCEPTOR', os.path.join(tempfile.mktemp(), "sender"), # Will be tempfile 60, None) self.ds = Session(None, self.fix, self.sendConfig) major, minor = self.version.split('.')[1:] self.numVersion = int(major) * 10 + int(minor) print "NV = %s" % self.numVersion def test_parse(self): codex = [ ["ExecID('102')", None], ["OrdStatus.FILLED", None], ["OrderID('myOrderID')", None], ["ExecTransType.NEW", lambda x, y: y < 43], # Got dropped in 43 ["Symbol( 'CSCO')", None], ["AvgPx( 32.34 )", None], ["LastPx( 32.34 )", None], ["Side.BUY", None], ["ExecType.NEW", lambda x, y: y > 40], ["OrderQty(300)", None], ["CumQty( 100)", None], ["LastShares( 100)", lambda x, y: y < 43], ["LastQty( 100)", lambda x, y: y > 42], ["LeavesQty( 200)", lambda x, y: y > 40], ["ClOrdID( 'MYOrder')", None] ] fields = [] for expr, cond in codex: if cond is None or cond(self.fix.version, self.numVersion): fields.append(eval("self.pyfix.%s" % expr)) ## msg = self.pyfix.ExecutionReport( fields = [self.pyfix.ExecID( '102'), ## self.pyfix.OrdStatus.FILLED, ## self.pyfix.OrderID('myOrderID'), ## self.pyfix.ExecTransType.NEW, ## self.pyfix.Symbol( 'CSCO'), ## self.pyfix.AvgPx( 32.34 ), ## self.pyfix.Side.BUY, ## self.pyfix.ExecType.NEW, ## self.pyfix.OrderQty(300), ## self.pyfix.CumQty( 100), ## self.pyfix.LeavesQty( 200), ## self.pyfix.ClOrdID( "ORDER_2232") ] ) msg = self.fix.ExecutionReport(fields=fields) asFix = self.ds.compile_message(msg) msg2, _, _ = self.fp.feed(asFix) self.assertEqual(msg2.to_fix(), asFix)
class Session(object): def __init__(self, session_manager, fix, config): self.session_manager = session_manager self.protocol = None self.fix = fix self.sender = config.sender self.target = config.target self.sender_compid = fix.SenderCompID(self.sender) self.target_compid = fix.TargetCompID(self.target) self.begin_string = fix.BeginString(fix.version) self.out_msg_seq_num = 1 self.in_msg_seq_num = 1 self.set_persister( BerkeleyPersister(config.persistRoot, self.sender, self.target)) self.heartbeat_interval = config.heartbeatInterval # Why do we need an sp? self.sp = SynchronousParser(self.fix) self.last_by_type = {} self.state = None if config.app: self.set_app(config.app) else: self.set_app(FIXApplication(fix)) self.on_integrity_exception = None self.last_integrity_exception = None self.want_to_be_logged_in = True def set_app(self, app): self.app = app self.app.set_session(self) def set_state(self, old_state, new_state): self.app.set_state(old_state, new_state) def bind_protocol(self, protocol): assert self.protocol is None assert protocol.session is None protocol.session = self self.protocol = protocol self.app.set_protocol(protocol) def release_protocol(self): assert self.protocol.session == self assert self.protocol is not None self.protocol.session = None self.protocol = None def str_connected(self): return { True: " Connected ", False: "Disconnected" }[self.isConnected()] def __repr__(self): return "Session(%s-%s %s [%s,%s] )" % ( self.sender, self.target, self.str_connected(), self.in_msg_seq_num, self.out_msg_seq_num) def dump_in(self, x): self.dump_msg(self.in_db, x) def dump_out(self, x): self.dump_msg(self.out_db, x) def logoff(self, want_to_be_logged_on=False): assert self.isConnected() self.want_to_be_logged_in = want_to_be_logged_on # TODO - investigate - I put this in for a reason! self.protocol._logoff() def logon(self ): # This translates to "want to be logged on" for an acceptor! assert not self.isConnected() self.want_to_be_logged_in = True if self.factory: assert self.factory.__class__ == InitiatorFactory, "Logic error only initiators keep track of factory" self.factory.logon() def dump_msg(self, db, x): raw_msg = db[x] msg, x, y = self.sp.feed(raw_msg) msg.dump() print x, y def parse(self, msg): return self.sp.feed(msg)[0] def isConnected(self): return self.protocol is not None def set_persister(self, persister): self.persister = persister self.in_db, self.out_db = persister.getTodayPersister() #self.persister.report( self.inDb) #self.persister.report( self.outDb) p = SynchronousParser(self.fix) import time for db in (self.in_db, self.out_db): start = time.time() i = 0.0 c = db.cursor() while True: v = c.next() if not v: break msg, _, _ = p.feed(v[1]) i += 1 endTime = time.time() dur = endTime - start print "%s parsed %s messages in %s secs (%s/sec)" % (db, i, dur, i / dur) self.in_msg_seq_num = self.persister.getNextSeq(self.in_db) self.out_msg_seq_num = self.persister.getNextSeq(self.out_db) print "Setting sequence numbers %s %s" % (self.in_msg_seq_num, self.out_msg_seq_num) def persist_and_advance(self, message_string, check_in_sequence=True): msg, _, _ = self.sp.feed(message_string) msg_seq = msg.get_header_field_value(self.fix.MsgSeqNum) if check_in_sequence: seq = self.persister.getNextSeq(self.in_db) seq2 = self.persister.getNextSeq(self.out_db) assert msg_seq >= seq, "Received %s vs %s %s" % (msg_seq, seq, seq2) self.persister.persistInMsg(msg_seq, message_string) self.in_msg_seq_num = msg_seq + 1 def compile_message(self, msg, poss_dup=False, force_sequence_number=None, orig_sending_time=None, persist=True, disable_validation=False): sending_time = self.fix.SendingTime(datetime.datetime.now()) body_length = self.fix.BodyLength(0) check_sum = self.fix.CheckSum(0) if force_sequence_number: seq = force_sequence_number else: seq = self.out_msg_seq_num header = [ self.begin_string, body_length, msg.msgTypeField, self.sender_compid, self.target_compid, self.fix.MsgSeqNum(seq), sending_time ] if poss_dup: header = header[:-1] + [self.fix.PossDupFlag('Y')] + header[-1:] if orig_sending_time: header = header[:-1] + [ self.fix.OrigSendingTime(orig_sending_time) ] + header[-1:] footer = [check_sum] msg.header_fields = header msg.footer_fields = footer # this will check what we've done so far #msg.checkStructure() #msg.validate() msg.calc_body_length(mutate=True) msg.calc_check_sum(mutate=True) #msg.checkBodyLength() #bl2 = msg.calcBodyLength( ) #cs2 = msg.calcCheckSum() if not disable_validation: msg.validate() #assert bl==bl2, "Body Length failed before/after consistency check" #assert cs==cs2, "Checksum failed before/after consistency check" ret = msg.to_fix() if not poss_dup: if persist: self.persister.persistOutMsg(self.out_msg_seq_num, ret) #self.outDb[self.outMsgSeqNum] = ret #self.outDb.sync() self.out_msg_seq_num += 1 return ret
class Session(object): def __init__(self, session_manager, fix, config): self.session_manager = session_manager self.protocol = None self.fix = fix self.sender = config.sender self.target = config.target self.sender_compid = fix.SenderCompID(self.sender) self.target_compid = fix.TargetCompID(self.target) self.begin_string = fix.BeginString(fix.version) self.out_msg_seq_num = 1 self.in_msg_seq_num = 1 self.set_persister(BerkeleyPersister(config.persistRoot, self.sender, self.target)) self.heartbeat_interval = config.heartbeatInterval # Why do we need an sp? self.sp = SynchronousParser(self.fix) self.last_by_type = {} self.state = None if config.app: self.set_app(config.app) else: self.set_app(FIXApplication(fix)) self.on_integrity_exception = None self.last_integrity_exception = None self.want_to_be_logged_in = True def set_app(self, app): self.app = app self.app.set_session(self) def set_state(self, old_state, new_state): self.app.set_state(old_state, new_state) def bind_protocol(self, protocol): assert self.protocol is None assert protocol.session is None protocol.session = self self.protocol = protocol self.app.set_protocol(protocol) def release_protocol(self): assert self.protocol.session == self assert self.protocol is not None self.protocol.session = None self.protocol = None def str_connected(self): return {True: " Connected ", False: "Disconnected"}[self.isConnected()] def __repr__(self): return "Session(%s-%s %s [%s,%s] )" % (self.sender, self.target, self.str_connected(), self.in_msg_seq_num, self.out_msg_seq_num) def dump_in(self, x): self.dump_msg(self.in_db, x) def dump_out(self, x): self.dump_msg(self.out_db, x) def logoff(self, want_to_be_logged_on=False): assert self.isConnected() self.want_to_be_logged_in = want_to_be_logged_on # TODO - investigate - I put this in for a reason! self.protocol._logoff() def logon(self): # This translates to "want to be logged on" for an acceptor! assert not self.isConnected() self.want_to_be_logged_in = True if self.factory: assert self.factory.__class__ == InitiatorFactory, "Logic error only initiators keep track of factory" self.factory.logon() def dump_msg(self, db, x): raw_msg = db[x] msg, x, y = self.sp.feed(raw_msg) msg.dump() print x, y def parse(self, msg): return self.sp.feed(msg)[0] def isConnected(self): return self.protocol is not None def set_persister(self, persister): self.persister = persister self.in_db, self.out_db = persister.getTodayPersister() #self.persister.report( self.inDb) #self.persister.report( self.outDb) p = SynchronousParser(self.fix) import time for db in (self.in_db, self.out_db): start = time.time() i = 0.0 c = db.cursor() while True: v = c.next() if not v: break msg, _, _ = p.feed(v[1]) i += 1 endTime = time.time() dur = endTime - start print "%s parsed %s messages in %s secs (%s/sec)" % (db, i, dur, i / dur ) self.in_msg_seq_num = self.persister.getNextSeq(self.in_db) self.out_msg_seq_num = self.persister.getNextSeq(self.out_db) print "Setting sequence numbers %s %s" % ( self.in_msg_seq_num, self.out_msg_seq_num) def persist_and_advance(self, message_string, check_in_sequence=True): msg, _, _ = self.sp.feed(message_string) msg_seq = msg.get_header_field_value(self.fix.MsgSeqNum) if check_in_sequence: seq = self.persister.getNextSeq(self.in_db) seq2 = self.persister.getNextSeq(self.out_db) assert msg_seq >= seq, "Received %s vs %s %s" % (msg_seq, seq, seq2) self.persister.persistInMsg(msg_seq, message_string) self.in_msg_seq_num = msg_seq + 1 def compile_message(self, msg, poss_dup=False, force_sequence_number=None, orig_sending_time=None, persist=True, disable_validation=False): sending_time = self.fix.SendingTime(datetime.datetime.now()) body_length = self.fix.BodyLength(0) check_sum = self.fix.CheckSum(0) if force_sequence_number: seq = force_sequence_number else: seq = self.out_msg_seq_num header = [self.begin_string, body_length, msg.msgTypeField, self.sender_compid, self.target_compid, self.fix.MsgSeqNum(seq), sending_time ] if poss_dup: header = header[:-1] + [self.fix.PossDupFlag('Y')] + header[-1:] if orig_sending_time: header = header[:-1] + [self.fix.OrigSendingTime(orig_sending_time)] + header[-1:] footer = [check_sum] msg.header_fields = header msg.footer_fields = footer # this will check what we've done so far #msg.checkStructure() #msg.validate() msg.calc_body_length(mutate=True) msg.calc_check_sum(mutate=True) #msg.checkBodyLength() #bl2 = msg.calcBodyLength( ) #cs2 = msg.calcCheckSum() if not disable_validation: msg.validate() #assert bl==bl2, "Body Length failed before/after consistency check" #assert cs==cs2, "Checksum failed before/after consistency check" ret = msg.to_fix() if not poss_dup: if persist: self.persister.persistOutMsg(self.out_msg_seq_num, ret) #self.outDb[self.outMsgSeqNum] = ret #self.outDb.sync() self.out_msg_seq_num += 1 return ret
class SpecTester(unittest.TestCase): version = '4.1' def __repr__(self): return "SpecTester(%s,%s)" % (self.version, self.testMethod) __str__=__repr__ def __init__(self, testMethod, version = 'FIX.4.0' ): # NB nose wants the init method of a testcase to unittest.TestCase.__init__(self, methodName = testMethod) self.version = version self.testMethod = testMethod def setUp( self): self.fix = parse_specification( self.version ) self.fp = SynchronousParser(self.fix) self.sendConfig = SessionConfig( 'initiator', 0, 'localhost', 'INITIATOR', 'ACCEPTOR', os.path.join( tempfile.mktemp(), "sender" ), # Will be tempfile 60, None ) self.ds = Session( None, self.fix, self.sendConfig) major, minor = self.version.split('.')[1:] self.numVersion = int(major) * 10 + int(minor) print "NV = %s" % self.numVersion def test_parse(self): codex = [ [ "ExecID('102')" , None ], [ "OrdStatus.FILLED" , None ], [ "OrderID('myOrderID')" , None ], [ "ExecTransType.NEW" , lambda x,y: y<43 ], # Got dropped in 43 [ "Symbol( 'CSCO')" , None ], [ "AvgPx( 32.34 )" , None ], [ "LastPx( 32.34 )" , None ], [ "Side.BUY" , None ], [ "ExecType.NEW" , lambda x,y: y>40 ], [ "OrderQty(300)" , None ], [ "CumQty( 100)" , None ], [ "LastShares( 100)" , lambda x,y: y<43], [ "LastQty( 100)" , lambda x,y: y>42 ], [ "LeavesQty( 200)" , lambda x,y: y>40 ], [ "ClOrdID( 'MYOrder')" , None ] ] fields = [] for expr, cond in codex: if cond is None or cond(self.fix.version, self.numVersion ): fields.append( eval("self.pyfix.%s" % expr ) ) ## msg = self.pyfix.ExecutionReport( fields = [self.pyfix.ExecID( '102'), ## self.pyfix.OrdStatus.FILLED, ## self.pyfix.OrderID('myOrderID'), ## self.pyfix.ExecTransType.NEW, ## self.pyfix.Symbol( 'CSCO'), ## self.pyfix.AvgPx( 32.34 ), ## self.pyfix.Side.BUY, ## self.pyfix.ExecType.NEW, ## self.pyfix.OrderQty(300), ## self.pyfix.CumQty( 100), ## self.pyfix.LeavesQty( 200), ## self.pyfix.ClOrdID( "ORDER_2232") ] ) msg = self.fix.ExecutionReport( fields = fields ) asFix = self.ds.compile_message(msg) msg2, _ ,_ = self.fp.feed(asFix) self.assertEqual( msg2.to_fix(), asFix)