def handle_collector(sock, header, body):
logger.info('HANDLE COLLECTOR %s\n%s', header, body)
if 'name' in body:
slack.send_slack_message('Collector connected ' + body['name'])
else:
slack.send_slack_message('Unknown Collector connected ')
client_manager.add_client(sock, header, body)
if body['capability'] == message.CAPABILITY_TRADE or body[
'capability'] == message.CAPABILITY_REQUEST_RESPONSE:
gevent.sleep(1)
logger.info('SEND TEST PACKET to %s', body['name'])
test_header = stream_readwriter.create_header(message.REQUEST,
message.MARKET_STOCK,
message.DAY_DATA)
test_header['code'] = 'A005930'
test_header['from'] = date(2020, 6, 1)
test_header['until'] = date(2020, 6, 4)
test_body = []
stream_write(sock, test_header, body)
elif body['capability'] == message.CAPABILITY_COLLECT_SUBSCRIBE or body[
'capability'] == message.CAPABILITY_TRADE_SUBSCRIBE:
gevent.sleep(1)
logger.info('SEND TEST PACKET to %s', body['name'])
test_header = stream_readwriter.create_header(message.SUBSCRIBE,
message.MARKET_STOCK,
message.STOCK_DATA)
test_header['code'] = 'ZZ12345'
test_body = []
stream_write(sock, test_header, body)
def handle_disconnect(self, sock):
logger.warning('HANDLE DISCONNECT: SubscribeClient')
for v in self.clients.values():
for s in v[1]:
if s == sock:
v[1].remove(sock)
# Handle trade subscriber
if sock in self.trade_clients:
self.trade_clients.remove(sock)
if len(self.trade_clients) == 0:
if self.trader_sock is not None:
header = stream_readwriter.create_header(
message.REQUEST_TRADE, message.MARKET_STOCK,
message.STOP_TRADE_DATA)
body = []
stream_write(self.trader_sock, header, body)
remove_codes = []
stop_methods = {
message.STOCK_ALARM_CODE: message.STOP_ALARM_DATA,
message.BIDASK_SUFFIX: message.STOP_BIDASK_DATA,
message.SUBJECT_SUFFIX: message.STOP_SUBJECT_DATA,
message.WORLD_SUFFIX: message.STOP_WORLD_DATA,
message.INDEX_SUFFIX: message.STOP_INDEX_DATA,
}
# Handle other subscriber
for k, v in self.clients.items():
if len(v[1]) == 0:
self.collector[k].remove_subscribe_code(k)
self.collector.pop(k, None)
for stop_k, stop_v in stop_methods.items():
if k.endswith(stop_k):
header = stream_readwriter.create_header(
message.SUBSCRIBE, message.MARKET_STOCK, stop_v)
body = []
header['code'] = k
stream_write(v[0], header, body)
remove_codes.append(k)
if k not in remove_codes:
header = stream_readwriter.create_header(
message.SUBSCRIBE, message.MARKET_STOCK,
message.STOP_STOCK_DATA)
body = []
header['code'] = k
stream_write(v[0], header, body)
remove_codes.append(k)
for code in remove_codes:
self.clients.pop(code, None)
def event_connect(err_code):
if err_code == 0:
rlogger.info('Connected to KIWOOM Server')
ax_obj.OnReceiveTrData.connect(receive_trdata)
header = stream_readwriter.create_header(message.COLLECTOR, message.MARKET_STOCK, message.COLLECTOR_DATA, message.KIWOOM)
body = {'capability': message.CAPABILITY_REQUEST_RESPONSE}
stream_readwriter.write(sock, header, body)
def request_stock_uni_day_period_data(reader, code, from_date, until_date):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.UNI_PERIOD_DATA)
header['code'] = code
header['from'] = from_date
header['until'] = until_date
body = []
return reader.block_write(header, body)
def request_stock_day_data(reader, code, from_date, until_date, method=message.DAY_DATA):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, method)
header['code'] = code
header['from'] = from_date
header['until'] = until_date
body = []
return reader.block_write(header, body)
def cancel_order(reader, order_num: int, code, amount): # quantity
header = stream_readwriter.create_header(message.REQUEST_TRADE, message.MARKET_STOCK, message.CANCEL_ORDER)
header['code'] = code
header['order_number'] = order_num
header['amount'] = amount
body = []
return reader.block_write(header, body)
def request_abroad_data(reader, code, period_type, count):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.ABROAD_DATA)
header['code'] = code
header['period_type'] = period_type
header['count'] = count
body = []
return reader.block_write(header, body)
def modify_order(reader, order_num: int, code, price):
header = stream_readwriter.create_header(message.REQUEST_TRADE, message.MARKET_STOCK, message.MODIFY_ORDER)
header['code'] = code
header['order_number'] = order_num
header['price'] = price
body = []
return reader.block_write(header, body)
def send_shutdown_msg():
header = stream_readwriter.create_header(message.REQUEST,
message.MARKET_STOCK,
message.SHUTDOWN)
body = []
for c in client_manager.collectors:
stream_write(c.sock, header, body)
def request_investor_accumulate_data(reader, code, from_date, until_date):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.INVESTOR_ACCUMULATE_DATA, message.KIWOOM)
header['code'] = code
header['from'] = from_date
header['until'] = until_date
body = []
return reader.block_write(header, body)
def order_stock(reader, code, price, quantity, is_buy):
header = stream_readwriter.create_header(message.REQUEST_TRADE, message.MARKET_STOCK, message.ORDER_STOCK)
header['code'] = code
header['price'] = price
header['quantity'] = quantity
header['trade_type'] = message.ORDER_BUY if is_buy else message.ORDER_SELL
body = []
return reader.block_write(header, body)
def _send_stop_msg(self, collector_sock, code):
stop_methods = {message.STOCK_ALARM_CODE: message.STOP_ALARM_DATA,
message.BIDASK_SUFFIX: message.STOP_BIDASK_DATA,
message.SUBJECT_SUFFIX: message.STOP_SUBJECT_DATA,
message.WORLD_SUFFIX: message.STOP_WORLD_DATA,
message.INDEX_SUFFIX: message.STOP_INDEX_DATA,}
processed = False
for stop_k, stop_v in stop_methods.items():
if code.endswith(stop_k):
header = stream_readwriter.create_header(message.SUBSCRIBE, message.MARKET_STOCK, stop_v)
header['code'] = code
stream_write(collector_sock, header, [])
processed = True
if not processed:
header = stream_readwriter.create_header(message.SUBSCRIBE, message.MARKET_STOCK, message.STOP_STOCK_DATA)
header['code'] = code
stream_write(collector_sock, header, [])
def disconnect_to_trade_subscribe(self, sock, vendor=message.CYBOS):
collector = self.get_trade_subscribe_collector(vendor)
if collector is None:
logger.error('NO TRADE collector %s', vendor)
return
if sock in self.trade_subscribe_sockets[vendor]:
self.trade_subscribe_sockets[vendor].remove(sock)
if len(self.trade_subscribe_sockets[vendor]) == 0:
header = stream_readwriter.create_header(message.TRADE_SUBSCRIBE, message.MARKET_STOCK, message.STOP_TRADE_DATA)
stream_write(collector.sock, header, [], self)
def request_investor_data(reader, code, from_date, until_date):
now = datetime.now().date()
if now - from_date > timedelta(days=365):
print('over before one year data is not available')
return []
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.INVESTOR_DATA)
header['code'] = code
header['from'] = from_date
header['until'] = until_date
body = []
return reader.block_write(header, body)
def _handle_trade_subscribe_disconnection(self, sock):
for vendor in self.vendors:
collector = self.get_trade_subscribe_collector(vendor)
if collector is None:
continue
if sock in self.trade_subscribe_sockets[vendor]:
self.trade_subscribe_sockets[vendor].remove(sock)
logger.info('trade subscribe found and remove, left %d', len(self.trade_subscribe_sockets[vendor]))
if len(self.trade_subscribe_sockets[vendor]) == 0:
header = stream_readwriter.create_header(message.TRADE_SUBSCRIBE, message.MARKET_STOCK, message.STOP_TRADE_DATA)
stream_write(collector.sock, header, [], self)
def run(client_name, client_type, client_index, client_count_info):
global _sock, _client_name
app = QCoreApplication([])
while True:
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_address = (message.SERVER_IP, message.CLIENT_SOCKET_PORT)
sock.connect(server_address)
sock.settimeout(None)
print('Connected to apiserver')
break
except socket.error:
print('Retrying connect to apiserver')
time.sleep(1)
_sock = sock
socket_notifier = QtCore.QSocketNotifier(sock.fileno(),
QtCore.QSocketNotifier.Read)
socket_notifier.activated.connect(dispatch_message)
header = stream_readwriter.create_header(message.COLLECTOR,
message.MARKET_STOCK,
message.COLLECTOR_DATA)
body = {}
body['capability'] = message.CAPABILITY_COLLECT_SUBSCRIBE
body['name'] = client_name + '_COL' + str(client_index)
_client_name = body['name']
stream_readwriter.CLIENT_NAME = _client_name
stream_readwriter.write(sock, header, body)
app.exec_()
def subscribe_stock_subject(reader, code, handler):
header = stream_readwriter.create_header(message.SUBSCRIBE, message.MARKET_STOCK, message.SUBJECT_DATA)
body = []
code += message.SUBJECT_SUFFIX
reader.subscribe_write(header, body, code, handler)
def request_us_stock_code(reader, us_type):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.USCODE_DATA)
header['us_type'] = us_type
body = []
return reader.block_write(header, body)
def request_code_to_name(reader, code):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.CODE_TO_NAME_DATA)
header['code'] = code
body = []
return reader.block_write(header, body)
def _send_stop_subscribe(reader, code, method):
header = stream_readwriter.create_header(message.SUBSCRIBE, message.MARKET_STOCK, method)
body = []
reader.stop_subscribe_write(header, body, code)
def request_long_list(reader):
header = stream_readwriter.create_header(message.REQUEST_TRADE, message.MARKET_STOCK, message.GET_LONG_LIST)
body = []
return reader.block_write(header, body)
def stop_subscribe_trade(reader):
header = stream_readwriter.create_header(message.TRADE_SUBSCRIBE, message.MARKET_STOCK, message.STOP_TRADE_DATA)
body = []
reader.stop_subscribe_trade_write(header, body)
def request_yesterday_top_amount(reader, date):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.YESTERDAY_TOP_AMOUNT_DATA)
header['date'] = date
body = []
return reader.block_write(header, body)
def request_stock_uni_day_data(reader, code):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.UNI_DATA)
header['code'] = code
body = []
return reader.block_write(header, body)
def request_subscribe_stat(reader):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, message.SUBSCRIBE_STATS)
body = []
return reader.block_write(header, body)
def request_order_in_queue(reader):
header = stream_readwriter.create_header(message.REQUEST_TRADE, message.MARKET_STOCK, message.ORDER_IN_QUEUE)
body = []
return reader.block_write(header, body)
def request_stock_today_data(reader, code, method=message.TODAY_MINUTE_DATA):
header = stream_readwriter.create_header(message.REQUEST, message.MARKET_STOCK, method)
header['code'] = code
body = []
return reader.block_write(header, body)
def stop_subscribe_alarm(reader):
header = stream_readwriter.create_header(message.SUBSCRIBE, message.MARKET_STOCK, message.STOP_ALARM_DATA)
body = []
code = message.STOCK_ALARM_CODE
reader.stop_subscribe_write(header, body, code)
def get_balance(reader):
header = stream_readwriter.create_header(message.REQUEST_TRADE, message.MARKET_STOCK, message.BALANCE)
body = []
return reader.block_write(header, body)
def subscribe_index(reader, code, handler):
header = stream_readwriter.create_header(message.SUBSCRIBE, message.MARKET_STOCK, message.INDEX_DATA)
body = []
code += message.INDEX_SUFFIX
reader.subscribe_write(header, body, code, handler)
