def __init__(self, endpoint: str, sender_comp_id: str, target_comp_id: str, username: str, password: str, certs: dict, fix_version="FIX.4.4", heartbeat_interval=3): assert isinstance(endpoint, str) assert isinstance(sender_comp_id, str) assert isinstance(target_comp_id, str) assert isinstance(username, str) assert isinstance(password, str) assert(isinstance(certs, dict) or (certs is None)) self.endpoint = endpoint self.senderCompId = sender_comp_id self.targetCompId = target_comp_id self.username = username self.password = password self.certs = certs self.fix_version = fix_version self.heartbeat_interval = heartbeat_interval self.sequenceNum = 0 self.connection_state = FixConnectionState.DISCONNECTED self.reader = None self.writer = None self.parser = simplefix.FixParser() # This lock probably isn't needed because `reader.read` blocks. self.lock = asyncio.Lock() self.caller_loop = asyncio.get_event_loop() self.session_loop = None self.last_msg_sent = None self.logging_out = False self.write_queue = queue.Queue() self.application_messages = queue.Queue() # clientId: Queue self.order_book = {}
def from_raw(cls, raw_message: bytes) -> "t.Optional[FixMessage]": parser = sf.FixParser() parser.append_buffer(raw_message) msg = parser.get_message() if msg is None: return None return cls(msg)
async def dispatch(self): """read from stream and dispatch messages""" await self.send_logon(heart_bt_int=30) self.request_sent = datetime.now() parser = simplefix.FixParser() done = False while not done: data = await self.reader.read(_READ_BUFFER_SIZE) if len(data) == 0: logging.warning("EOF") break parser.append_buffer(data) while not done: message = parser.get_message() if message is None: break logging.debug("Message: %s", message) if message.message_type == simplefix.MSGTYPE_LOGON: done = await self._on_logon(message) elif message.message_type == simplefix.MSGTYPE_LOGOUT: done = await self._on_logout(message) elif message.message_type == simplefix.MSGTYPE_TEST_REQUEST: done = await self._on_test_request(message) elif message.message_type == simplefix.MSGTYPE_HEARTBEAT: done = await self._on_heartbeat(message) else: done = await self.on_message(message) await self._close() logging.info("Close the connection") self.writer.close() await self.writer.wait_closed()
def getLastQty(self): '''Temp -- replace now that we have parse''' p = simplefix.FixParser() p.append_buffer(buf) m = p.get_message() lastQty = m.get(32) return lastQty
def reset(self): """Reset the parser state. Discards any received by unprocessed data.""" # Parser. self._parser = simplefix.FixParser() # My CompID. self._my_comp_id = "" # Peer's CompID. self._peer_comp_id = "" # Next expected sequence number. self._in_seq = 1 # Sequence number to be used for next sent message. self._out_seq = 1 # Interval before sending TestRequest or Heartbeat messages. self._heartbeat_interval = 30 * 1000 # Outstanding test request identifiers. self._test_requests = {} return
def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(("127.0.0.1", 10102)) p = simplefix.FixParser() # Logon m = simplefix.FixMessage() m.append_pair(8, "FIX.4.2") m.append_pair(35, "A") m.append_pair(49, "CLIENT") m.append_pair(56, "SERVER") m.append_pair(52, datetime.datetime.utcnow().isoformat('-')[:-3]) m.append_pair(98, 0) # No encrytion m.append_pair(108, 30) s.sendall(m.encode()) while True: data = s.recv(8192) p.append_buffer(data) r = p.get_message() if r: break print m.encode().replace(simplefix.SOH, "|")
def __init__(self, seqObj): # Initialize the Fix message objects here self.seqObj = seqObj self.message = simplefix.FixMessage() self.resp_mesg = simplefix.FixParser() self.seqObj.updateReqSequence(sys.argv[1]) print(self.seqObj.getReqSequence()) return
def decode(self, raw_msg): parser = simplefix.FixParser() parser.append_buffer(raw_msg) msg = parser.get_message() if msg is not None: return SimpleFixMessageContainer(msg), len(raw_msg) else: return None, len(raw_msg)
def from_raw(cls, raw_message): parser = simplefix.FixParser() parser.append_buffer(raw_message) msg = parser.get_message() if msg is None: return msg converted = FixMessage() for tag, val in msg: converted.append_pair(tag, val) return converted
def __init__(self, server: Server, sock: socket.SocketType): """Constructor. :param server: Server instance that owns this session. :param sock: ephemeral sock for this session.""" self._server = server self._socket = sock self._name = None self._parser = simplefix.FixParser() self._is_connected = True self._queue = [] asyncio.get_event_loop().add_reader(sock, self.readable) return
def __init__(self, host="fix.remarkets.primary.com.ar", port=9876, verbose=0): self.msg_send_to_sound = 0 self.host = host self.port = port self.verbose = verbose self.lst_50_msg_time = time.time() if self.verbose: print('SocketUtils: Creating Socket') self.sock = None self.FIX_engine = FIXEngine() self.connect() self.reconnection_needed = False self.connected = False self.msg_buffer = simplefix.FixParser()
def __init__(self, name: str): """Constructor.""" self._name = name self._comp_id = b'' self._auto_heartbeat = True self._auto_sequence = True self._raw = False self._next_send_sequence = 0 self._last_seen_sequence = 0 self._host = None self._port = None self._is_connected = False self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self._socket.setblocking(True) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._parser = simplefix.FixParser() self._queue = [] return
def recvMesg( self ): # function which receives the messages and processes it accordingly while True: self.received_message = self.s.recv(4096) self.resp_mesg.append_buffer(self.received_message) self.resp_mesg = self.resp_mesg.get_message() print(f"\r\n Received: {self.resp_mesg}") print(Fore.GREEN + "\r\nReceived:\r\n" + str(self.resp_mesg)) if self.resp_mesg.get(35, 1).decode('utf-8') == "0": print("\r\n\r\nHearbeat Response") elif self.resp_mesg.get(35, 1).decode('utf-8') == "1": print("\r\n\r\nTest Request") self.testreqid = self.resp_mesg.get(112, 1) self.testRequest(self.testreqid) elif self.resp_mesg.get(35, 1).decode('utf-8') == "2": print("\r\n\r\nsend resend request") elif self.resp_mesg.get(35, 1).decode('utf-8') == "3": print("\r\n\r\nMessage Rejected, Exiting the program") exit(1) elif self.resp_mesg.get(35, 1).decode('utf-8') == "4": print("\r\n\r\nSequence Reset..") elif self.resp_mesg.get(35, 1).decode('utf-8') == "5": print("\r\n\r\nLogout") elif self.resp_mesg.get(35, 1).decode('utf-8') == "A": print("\r\n\r\nLogged in successfully") elif self.resp_mesg.get(35, 1).decode('utf-8') == "D": print("\r\n\r\nOrder Single ") else: print(self.resp_mesg) print("\r\n\r\nProceed based on response value of 35") del self.resp_mesg self.resp_mesg = simplefix.FixParser() return
import simplefix f = open('definition.txt') t = f.read() f.close() p = simplefix.FixParser() p.append_buffer(t) # FIXME: mark end of FIX message (see simplefix issue#13) p.append_buffer(b'\x0110=000\x01') m = p.get_message() print(m)
class FixClient: HOST = '127.0.0.1' # The server's hostname or IP address PORT = 12346 # The port used by the server BEGIN_STRING = 'FIX.4.2' SENDER = 'BANZAI' TARGET = "EXEC" buf_read_size = 64 msg_seq_num = 1 msg_seq_num_lock = threading.Lock() socket_lock = threading.Lock() parser = simplefix.FixParser() socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) def __init__(self): self.heart_beat_interval = 1 def read_message(self): while True: try: # print(self.socket_lock.locked()) self.socket_lock.acquire() # buf = self.socket_client.recv(self.buf_read_size) buf = self.socket_client.recv(self.buf_read_size) self.parser.append_buffer(buf=buf) # if len(buf) == 0: # time.sleep(2) # else: # time.sleep(1) except socket.error as e: print(e) self.reconnect() # A socket error pass except IOError as e: print(e) if e.errno == errno.EPIPE: # EPIPE error pass else: pass # Other error except Exception as e: print(e) finally: self.socket_lock.release() time.sleep(1) def run(self): self.reconnect() self.send_message(self.log_on_message()) time.sleep(1) # 接收 Server 消息,根据消息类型进行不同回报 thread_read_message = threading.Thread(target=self.read_message) thread_read_message.start() thread_parse_message = threading.Thread(target=self.parse_message) thread_parse_message.start() # time.sleep(10) # self.send_message(self.new_order()) def send_message(self, message: simplefix.FixMessage): try: print("send: ", message) self.socket_lock.acquire() self.socket_client.send(message.encode()) self.socket_lock.release() # except socket.error as e: # # A socket error # pass # print(e) # except IOError as e: # print(e) # if e.errno == errno.EPIPE: # # EPIPE error # pass # else: # pass # Other error except Exception as e: print(e) def parse_message(self): while True: try: msg_recv = self.parser.get_message() if msg_recv is not None: print("receive: ", msg_recv) if msg_recv.get(MsgType) == simplefix.MSGTYPE_HEARTBEAT: # 心跳 self.send_message(self.heart_beat_message()) elif msg_recv.get(MsgType) == simplefix.MSGTYPE_LOGOUT: # 重新登陆 self.msg_seq_num_lock.acquire() self.msg_seq_num = int(msg_recv.get(MsgSeqNum)) self.msg_seq_num_lock.release() self.send_message(self.log_on_message()) else: pass except Exception as e: print(e) time.sleep(1) def log_on_message(self): msg = self.basic_message() msg.append_pair(HeartBtInt, self.heart_beat_interval, header=True) msg.append_pair(MsgType, simplefix.MSGTYPE_LOGON, header=True) return msg def heart_beat_message(self): msg = self.basic_message() msg.append_pair(MsgType, simplefix.MSGTYPE_HEARTBEAT, header=True) return msg def basic_message(self): try: print("in", self.msg_seq_num_lock.locked()) self.msg_seq_num_lock.acquire() msg = simplefix.FixMessage() msg.append_pair(BeginString, self.BEGIN_STRING, header=True) msg.append_pair(SenderCompID, self.SENDER, header=True) msg.append_pair(TargetCompID, self.TARGET, header=True) msg.append_pair(MsgSeqNum, self.msg_seq_num) self.msg_seq_num = self.msg_seq_num + 1 return msg finally: self.msg_seq_num_lock.release() print("out", self.msg_seq_num_lock.locked()) def new_order(self): try: self.msg_seq_num_lock.acquire() msg = self.basic_message() msg.append_pair(MsgType, simplefix.MSGTYPE_NEW_ORDER_SINGLE, header=True) msg.append_pair(Symbol, "000725.SZ") msg.append_pair(Side, simplefix.SIDE_BUY) msg.append_pair(OrderQty, simplefix.SIDE_BUY) msg.append_pair(OrdType, simplefix.ORDTYPE_LIMIT) msg.append_pair(Price, simplefix.SIDE_BUY) return msg except Exception as e: print(e) finally: self.msg_seq_num_lock.release() def reconnect(self): self.socket_client.close() self.socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket_client.connect((self.HOST, self.PORT)) pass
def __init__(self): self._parser = simplefix.FixParser()
def parse(buf): p = simplefix.FixParser() p.append_buffer(buf) m = p.get_message() print(m) return m