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,
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
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
