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
