def test_vehicle_data_logging(): proc = wake_up_maya(start_position=None, constraints_for_training=None) # read data socket = Socket(SUB) socket.set_string_option(SUB, SUB_SUBSCRIBE, b"Publish Counter") socket.connect(FLAGS.log_port) # send control commands socket_out = Socket(PAIR) socket_out.connect(FLAGS.control_port) num_of_agents = 9 num_of_steps = 30 for steps in range(num_of_steps): for ptr in range(num_of_agents): vehicle_data = socket.recv() msg = parse_data(vehicle_data) tf.logging.info("%s" % msg) control_signal = "%s:%s" % (int(time.time() * 1000), 0) motor = 0.5 brake = 0. steer = 0. hand_brake = 0. left_light = 0 right_light = 0 control_signal += ":%s:%s:%s:%s:%s:%s:%s" % ("my_ego_vehicle", motor, brake, steer, hand_brake, left_light, right_light) socket_out.send(control_signal.encode()) maya_to_sleep(proc)
def main(): ap = argparse.ArgumentParser() ap.add_argument('-n', '--rate-limit', metavar="NUM", help="Number of requests to issue per second (default %(default)d)", default=100, type=float) ap.add_argument('-m', '--max-value', metavar="NUM", help="Maximum number that's sent for factorizing (default %(default)d)", default=10**12, type=int) ap.add_argument('--min-value', metavar="NUM", help="Maximum number that's sent for factorizing (default %(default)d)", default=10**11, type=int) ap.add_argument('--topology', metavar="URL", required=True, help="Url for topology to join to") options = ap.parse_args() delay = 1.0 / options.rate_limit sock = Socket(PUSH) sock.set_string_option(SOL_SOCKET, SOCKET_NAME, "push") sock.configure(options.topology) while True: tm = time.time() num = random.randint(options.min_value, options.max_value) sock.send(str(num)) to_sleep = tm + delay - time.time() if to_sleep > 0: time.sleep(to_sleep)
def server(url): sock = Socket(PUB) sock.bind(url) channel1 = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' channel2 = b'\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' channel3 = b'\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' channel4 = b'\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' doublearray = array.array('d') for i in range(65536): doublearray.insert(i, 0.000001 + i) doublebytes = doublearray.tobytes() # databytes = doublearray.tobytes() # pipes1 = channel1.decode('utf-8') # pipes2 = channel2.decode('utf-8') # pipes3 = channel3.decode('utf-8') # pipes4 = channel4.decode('utf-8') # datas = databytes.decode('utf-8') # pipedatas1 = pipes1+datas # pepedata1 = pipedatas1.encode('utf-8') # pipedatas2 = pipes2+datas # pepedata2 = pipedatas2.encode('utf-8') # pipedatas3 = pipes3+datas # pepedata3 = pipedatas3.encode('utf-8') # pipedatas4 = pipes4+datas # pepedata4 = pipedatas4.encode('utf-8') while True: sock.send(b''.join([channel1, doublebytes])) sock.send(b''.join([channel2, doublebytes])) sock.send(b''.join([channel3, doublebytes])) sock.send(b''.join([channel4, doublebytes]))
def main(): ap = argparse.ArgumentParser() gr = ap.add_mutually_exclusive_group() gr.add_argument('--rep', metavar="URL", help="The topology url of replier socket") gr.add_argument('--pullpush', metavar="URL", nargs=2, help="The topology urls of pull and push sockets for request processing") options = ap.parse_args() if options.rep: sock = Socket(REP) sock.configure(options.rep) sock.set_string_option(SOL_SOCKET, SOCKET_NAME, "rep") read = write = sock else: read = Socket(PULL) read.set_string_option(SOL_SOCKET, SOCKET_NAME, "pull") write = Socket(PUSH) write.set_string_option(SOL_SOCKET, SOCKET_NAME, "push") read.configure(options.pullpush[0]) write.configure(options.pullpush[1]) while True: num = int(read.recv()) res = factorize_naive(num) formula = str(num) + '=' + '*'.join(map(str, res)) write.send(formula.encode('ascii'))
def _bg(self): sock = Socket(REQ) sock.connect("inproc://server") while self.running: for func in self.bg_tasks: msg = self.dump((func, [])) sock.send(msg) self.load(sock.recv()) time.sleep(10)
def main(): ap = argparse.ArgumentParser() ap.add_argument('-n', '--requests', metavar="NUM", help="Number of requests to issue (default %(default)d)", default=10000, type=int) ap.add_argument('-c', '--concurrent', metavar="NUM", help="Number of requests sent simultaneously (default %(default)d)", default=1000, type=int) ap.add_argument('-m', '--max-value', metavar="NUM", help="Maximum number that's sent for factorizing (default %(default)d)", default=10**12, type=int) ap.add_argument('--min-value', metavar="NUM", help="Maximum number that's sent for factorizing (default %(default)d)", default=10**11, type=int) ap.add_argument('--topology', metavar="URL", required=True, help="Url for topology to join to") options = ap.parse_args() sock = Socket(REQ, domain=AF_SP_RAW) sock.set_string_option(SOL_SOCKET, SOCKET_NAME, "client") sock.configure(options.topology) start_time = time.time() reqiter = requests(options) req = {} for i in range(options.concurrent): rid, val = next(reqiter) sock.send(b'\x00\x00\x00\x00' + struct.pack('>L', rid | 0x80000000) + str(val).encode('ascii')) req[rid] = val errors = 0 sp = 0 n = 0 while req: data = sock.recv() rid = struct.unpack_from('>L', data)[0] & ~0x80000000 factors = map(int, data[4:].decode('ascii').split(',')) checkval = reduce(int.__mul__, factors) if rid not in req: sp += 1 elif req.pop(rid) != checkval: errors += 1 else: n += 1 try: rid, val = next(reqiter) except StopIteration: continue else: sock.send(b'\x00\x00\x00\x00' + struct.pack('>L', rid | 0x80000000) + str(val).encode('ascii')) req[rid] = val sec = time.time() - start_time print("Done", options.requests, "requests in", sec, "seconds, errors:", errors, ", spurious messages:", sp)
def _bg(self): sock = Socket(REQ) sock.connect('inproc://server') while self.running: for func in self.bg_tasks: msg = self.dump((func, [])) sock.send(msg) self.load(sock.recv()) time.sleep(10)
def nano_server(endpoint): s = Socket(PAIR) s.bind('ipc://' + endpoint) #s.bind('tcp://127.0.0.1:9001') try: while True: s.recv() s.send('ok') finally: s.close()
def start_service(service_name, service_protocol, service_port): socket = Socket(REP) socket.bind('%s://*:%s' % (service_protocol, service_port)) print 'Starting service %s' % service_name while True: request = socket.recv() print 'Request: %s' % request socket.send('The answer is 42')
def brain_loop(args): sock_node = Socket(BUS) sock_node.bind('tcp://*:%s' % BRAIN_PORT) sock_node.recv_timeout = 250 #sock_node.send_buffer_size = 1000 sock_node.send_timeout = 200 seq = 0 timer = set_mode(args.mode) server = Server(args) while True: ch, value = chanselect([timer.chan, server.chan], []) #print 'AFTER chanselect', ch is timer.chan, time.time() if ch is timer.chan: lights.only(*value) #print "LIGHTS", value try: seq += 1 sock_node.send( '%i %s %s' % (seq, CMD_LIGHTS, ' '.join(lights.rev_lookup[led_pin] for led_pin in value))) except Exception as ex: #print ex pass elif ch is server.chan: if value[0] == 'status': node = None try: seq += 1 sock_node.send('%i PING' % seq) while True: node_msg = sock_node.recv().split() if int(node_msg[0]) == seq: node = 'ok' break elif int(node_msg[0]) > seq: raise Exception('Skipped ping message') except Exception as ex: node = repr(ex) value[1].put({'loop': 'ok', 'node': node}) elif value[0] == 'set_period': timer.period = value[1] elif value[0] == 'trip': timer.trip = True elif value[0] == 'mode': mode = value[1] print("new mode tho %s" % mode) timer = set_mode(mode) else: print "UNKNOWN COMMAND:", value time.sleep(2)
def register_service(service_name, service_address, discovery_host, discovery_port): socket = Socket(RESPONDENT) socket.connect('tcp://%s:%s' % (discovery_host, discovery_port)) print 'Starting service registration [service: %s %s, discovery: %s:%s]' \ % (service_name, service_address, discovery_host, discovery_port) while True: message = socket.recv() if message == 'service query': socket.send('%s|%s' % (service_name, service_address))
def master_loop(): sock_slave = Socket(PAIR) sock_slave.bind('tcp://*:%s' % MASTER_PORT) sock_slave.recv_timeout = 250 #sock_slave.send_buffer_size = 1000 sock_slave.send_timeout = 200 seq = 0 timer = LightTimer() server = Server() while True: ch, value = chanselect([timer.chan, server.chan], []) #print 'AFTER chanselect', ch is timer.chan, time.time() if ch is timer.chan: lights.only(*value) #print "LIGHTS", value try: seq += 1 sock_slave.send('%i %s %s' % ( seq, CMD_LIGHTS, ' '.join(lights.rev_lookup[led_pin] for led_pin in value))) except Exception as ex: #print ex pass elif ch is server.chan: if value[0] == 'status': slave = None try: seq += 1 sock_slave.send('%i PING' % seq) while True: slave_msg = sock_slave.recv().split() if int(slave_msg[0]) == seq: slave = 'ok' break elif int(slave_msg[0]) > seq: raise Exception('Skipped ping message') except Exception as ex: slave = repr(ex) value[1].put({'loop': 'ok', 'slave': slave}) elif value[0] == 'set_period': timer.period = value[1] elif value[0] == 'trip': timer.trip = True else: print "UNKNOWN COMMAND:", value time.sleep(2)
def node_loop(brain): sock_brain = Socket(BUS) sock_brain.connect('tcp://%s:%s' % (brain, BRAIN_PORT)) while True: msg = sock_brain.recv() #print 'HEARD', msg bits = msg.split() msgid = bits[0] cmd = bits[1] if cmd == CMD_PING: sock_brain.send('%s PONG' % msgid) elif cmd == CMD_LIGHTS: which_pins = [lights.lookup[lgt] for lgt in bits[2:]] lights.only(*which_pins) else: print 'Unhandleable message: %r' % msg
def slave_loop(master): sock_master = Socket(PAIR) sock_master.connect('tcp://%s:%s' % (master, MASTER_PORT)) while True: msg = sock_master.recv() #print 'HEARD', msg bits = msg.split() msgid = bits[0] cmd = bits[1] if cmd == CMD_PING: sock_master.send('%s PONG' % msgid) elif cmd == CMD_LIGHTS: which_pins = [lights.lookup[lgt] for lgt in bits[2:]] lights.only(*which_pins) else: print 'Unhandleable message: %r' % msg
class ConsoleProxy(object): def __init__(self, url, recv_timeout=1000, send_timeout=1000): self.url = url.encode() self.socket = Socket(REQ) self.socket.recv_timeout = recv_timeout self.socket.send_timeout = send_timeout super(ConsoleProxy, self).__init__() def connect(self): self.socket.connect(self.url) def disconnect(self): self.socket.close() def send_command(self, cmd_name, echo=True, **kwargs): command = { "name": cmd_name, "args": kwargs } dump = msgpack.packb(command) if echo: print('send: ', command) try: self.socket.send(dump) except NanoMsgAPIError as e: print('send_error', e.msg) pass try: recv = self.socket.recv() unpack_msg = msgpack.unpackb(recv, encoding='utf-8') if echo: print('recv: ', recv) print(unpack_msg) return unpack_msg except NanoMsgAPIError as e: print('recv_error', e.msg)
class Client(Common): def __init__(self, uri='inproc://server', id=None): self.sock = Socket(REQ) self.sock.connect(uri) self.id = id def close(self): self.sock.close() def call(self, func, *args): msg = self.dump((func, args)) self.sock.send(msg) return self.load(self.sock.recv()) def sync_call(self, func, *args): id = self.call(func, *args) print "got id", id while True: res = self.getresult(id) if res: return res time.sleep(0.1) def result(self, id, result): return self.call("result", id, result) def getresult(self, id): return self.call("getresult", id) def getstate(self, key): return self.call("getstate", key) def setstate(self, key, value): return self.call("setstate", key, value) def getlog(self, id, since=0): return self.call("getlog", id, since) def out(self, msg): return self.call("out", self.id, msg) def err(self, msg): return self.call("err", self.id, msg)
class Client(Common): def __init__(self, uri="inproc://server", id=None): self.sock = Socket(REQ) self.sock.connect(uri) self.id = id def close(self): self.sock.close() def call(self, func, *args): msg = self.dump((func, args)) self.sock.send(msg) return self.load(self.sock.recv()) def sync_call(self, func, *args): id = self.call(func, *args) print "got id", id while True: res = self.getresult(id) if res: return res time.sleep(0.1) def result(self, id, result): return self.call("result", id, result) def getresult(self, id): return self.call("getresult", id) def getstate(self, key): return self.call("getstate", key) def setstate(self, key, value): return self.call("setstate", key, value) def getlog(self, id, since=0): return self.call("getlog", id, since) def out(self, msg): return self.call("out", self.id, msg) def err(self, msg): return self.call("err", self.id, msg)
class NanomsgPublisher(HiddenPublisher): """ Publisher class publishing messages to a certain topic to an url Attributes: context (zmq.Context): socket (Socket): Socket object of ZMQ context topic (String): Topic publisher publishs to """ def __init__(self, url, topic): """ Initializes object Args: url (String): url to publish messages to topic (String): Topic to publish messages under """ super(NanomsgPublisher, self).__init__(topic) self._socket = Socket(PUB) self._socket.send_timeout = 1 # Wait 1ms for sending self._socket.bind(url) self._logger = logging.getLogger('NanomsgPublisher') def publish(self, message): """ Publishes message Args: message (String): Message to publish """ self._socket.send('{}|{}'.format(self._topic, message)) def __enter__(self): """ Statement used for the `` with ... as ...:`` returns the object to use in the ``with`` block Returns: NanomsgPublisher """ return self def __exit__(self, exc_type, exc_value, traceback): """ Executed when leaving ``with`` block, regardless whether because of an exception or normal program flow """ self._socket.close()
class KuduQueue(DbInterface): """ Represents kudu queue """ def __init__(self, address): """ init variables """ self._address = address self._socket = None def connect(self): """ Connect to kudu """ self._socket = Socket(PUSH) self._socket.connect(self._address) def close(self): """ Disconnect from kudu """ self._socket.close() self._socket = None def send_msg(self, msg, dont_wait=False): """ Send message to queue """ assert isinstance(msg, KuduMsg) log.debug('sending bytes to kuduworker: %s', len(msg.data)) flags = DONTWAIT if dont_wait else 0 try: self._socket.send(msg.data, flags) except NanoMsgAPIError: log.warning("Nanomessage error. Reconnecting...") self.close() self.connect() self._socket.send(msg.data, flags)
class ServiceDiscovery(object): def __init__(self, port, deadline=5000): self.socket = Socket(SURVEYOR) self.port = port self.deadline = deadline self.services = defaultdict(set) def bind(self): self.socket.bind('tcp://172.30.42.174:%s' % self.port) self.socket.set_int_option(SURVEYOR, SURVEYOR_DEADLINE, self.deadline) def discover(self): if not self.socket.is_open(): return self.services self.services = defaultdict(set) self.socket.send('service query') while True: try: response = self.socket.recv() except NanoMsgAPIError: break service, address = response.split('|') self.services[service].add(address) return self.services def resolve(self, service): providers = self.services[service] if not providers: return None return random.choice(tuple(providers)) def close(self): self.socket.close()
class ServiceDiscovery(object): def __init__(self, port, deadline=5000): self.socket = Socket(SURVEYOR) self.port = port self.deadline = deadline self.services = defaultdict(set) def bind(self): self.socket.bind('tcp://*:%s' % self.port) self.socket.set_int_option(SURVEYOR, SURVEYOR_DEADLINE, self.deadline) def discover(self): if not self.socket.is_open(): return self.services self.services = defaultdict(set) self.socket.send('service query') while True: try: response = self.socket.recv() except NanoMsgAPIError: break service, address = response.split('|') self.services[service].add(address) return self.services def resolve(self, service): providers = self.services[service] if not providers: return None return random.choice(tuple(providers)) def close(self): self.socket.close()
def nano_client(endpoint): s = Socket(PAIR) s.connect('ipc://' + endpoint) #s.connect('tcp://127.0.0.1:9001') count = 0 payload = test_str(SIZE) start = time.time() try: while True: s.send(payload) s.recv() count += 1 except: pass finally: end = time.time() total = end - start print 'total: ', count print 'took: ', total print 'req / sec:', count / total print 'bandwidth: %f MBps' % (((count / total) * SIZE) / 2 ** 20) s.close()
class Daemon(Common): change_funcs = set() bg_tasks = [] def __init__(self, state, logs, worker_class): self.state = state self.logs = logs self.worker_class = worker_class self.sock = Socket(REP) self.sock.bind("inproc://server") self.sock.bind("ipc://socket") self.results = {} self.threads = {} self.running = True self.change_lock = Lock() self.id_gen = iter(range(10000000)).next self.init() def init(self): pass def recv(self): msg = self.sock.recv() # print "Received", self.load(msg) return self.load(msg) def send(self, *args): msg = self.dump(*args) return self.sock.send(msg) def run(self): t = Thread(target=self._bg) t.start() t = Thread(target=self._run) t.start() return t def _bg(self): sock = Socket(REQ) sock.connect("inproc://server") while self.running: for func in self.bg_tasks: msg = self.dump((func, [])) sock.send(msg) self.load(sock.recv()) time.sleep(10) def handle_result(self, id, result): print "Got result id=%r result=%r" % (id, result) self.results[id] = result self.send("ok") def handle_setstate(self, key, value): print "Set state key=%r value=%r" % (key, value) self.state.set(key, value) self.send("ok") def handle_getstate(self, key): value = self.state.get(key) print "Get state key=%r value=%r" % (key, value) self.send(value) def handle_out(self, id, txt): print "Got %s id=%r result=%r" % ("out", id, txt) self.logs.append(id, "out", txt) self.send("ok") def handle_err(self, id, txt): print "Got %s id=%r result=%r" % ("err", id, txt) self.logs.append(id, "err", txt) self.send("ok") def handle_getresult(self, id): result = self.results.get(id) if result: del self.results[id] del self.threads[id] print "sending result=%r for id=%r" % (result, id) self.send(result) def handle_getlog(self, id, since): result = self.logs.get(id, since) print "sending log=%r for id=%r" % (result, id) self.send(result) def _run(self): while self.running: (cmd, args) = self.recv() func = getattr(self, "handle_" + cmd, None) if func: func(*args) continue t_id, t = self.spawn_worker(cmd, args) self.send(t_id) self.threads[t_id] = t print "started thread for id=%r func=%r args=%r" % (t_id, func, args) def spawn_worker(self, cmd, args): t_id = self.id_gen() target = lambda: self.wrap(t_id, cmd, args) t = Thread(target=target) t.start() return t_id, t def wrap(self, id, cmd, args): if cmd in self.change_funcs: self.change_lock.acquire() try: w = self.worker_class(id) func = getattr(w, cmd, w.noop) if hasattr(func, "api_exposed"): try: res = func(*args) except Exception, e: res = repr(e) else:
# vim: set fileencoding=utf-8 from nanomsg import Socket, PAIR URL = "ipc:///tmp/example3" socket = Socket(PAIR) print("Socket created") socket.bind(URL) print("Bound to URL {}".format(URL)) socket.send("Hello world!") print("Message has been sent") socket.close() print("Socket closed")
class TradeEngine(BaseEngine): """ Send to and receive from msg server ,used for strategy """ setting_filename = "cta_strategy_setting.json" data_filename = "cta_strategy_data.json" def __init__(self,config:dict): super(TradeEngine, self).__init__() """ two sockets to send and recv msg """ self.__active = False self.id = 0 self.engine_type = EngineType.LIVE self._recv_sock = Socket(SUB) self._send_sock = Socket(PUSH) self._config = config self._handlers = defaultdict(list) # stragegy manage self.strategy_setting = {} # strategy_name: dict self.strategy_data = {} # strategy_name: dict self.classes = {} # class_name: stategy_class self.strategies = {} # strategy_name: strategy self.symbol_strategy_map = defaultdict( list) # vt_symbol: strategy list self.orderid_strategy_map = {} # vt_orderid: strategy self.strategy_orderid_map = defaultdict( set) # strategy_name: orderid list self.stop_order_count = 0 # for generating stop_orderid self.stop_orders = {} # stop_orderid: stop_order self.init_thread = None self.init_queue = Queue() # order,tick,position ,etc manage self.ticks = {} self.orders = {} self.trades = {} self.positions = {} self.accounts = {} self.contracts = {} self.active_orders = {} self.rq_client = None self.rq_symbols = set() self.offset_converter = OffsetConverter(self) self.init_engine() def init_engine(self): self.init_nng() self.init_rqdata() self.load_strategy_class() self.load_strategy_setting() self.load_strategy_data() self.register_event() def init_rqdata(self): result = rqdata_client.init() if result: self.write_log("RQData数据接口初始化成功") def register_event(self): """""" self.event_engine.register(EventType.TICK, self.process_tick_event) self.event_engine.register(EventType.ORDERSTATUS, self.process_order_event) self.event_engine.register(EventType.FILL, self.process_trade_event) self.event_engine.register(EventType.POSITION, self.process_position_event) self.event_engine.register(EventType.ACCOUNT, self.process_account_event) self.event_engine.register(EventType.CONTRACT, self.process_contract_event) def process_tick_event(self, event: Event): """""" tick = event strategies = self.symbol_strategy_map[tick.full_symbol] if not strategies: return # self.check_stop_order(tick) for strategy in strategies: if strategy.inited: self.call_strategy_func(strategy, strategy.on_tick, tick) self.ticks[tick.full_symbol] = tick def process_order_event(self, event: Event): """""" order = event self.offset_converter.update_order(order) strategy = self.orderid_strategy_map.get(order.vt_orderid, None) if not strategy: return # Remove vt_orderid if order is no longer active. vt_orderids = self.strategy_orderid_map[strategy.strategy_name] if order.vt_orderid in vt_orderids and not order.is_active(): vt_orderids.remove(order.vt_orderid) # For server stop order, call strategy on_stop_order function # if order.type == OrderType.STOP: # so = StopOrder( # vt_symbol=order.vt_symbol, # direction=order.direction, # offset=order.offset, # price=order.price, # volume=order.volume, # stop_orderid=order.vt_orderid, # strategy_name=strategy.strategy_name, # status=STOP_STATUS_MAP[order.status], # vt_orderid=order.vt_orderid, # ) # self.call_strategy_func(strategy, strategy.on_stop_order, so) # Call strategy on_order function self.call_strategy_func(strategy, strategy.on_order, order) self.orders[order.vt_orderid] = order # If order is active, then update data in dict. if order.is_active(): self.active_orders[order.vt_orderid] = order # Otherwise, pop inactive order from in dict elif order.vt_orderid in self.active_orders: self.active_orders.pop(order.vt_orderid) def process_trade_event(self, event: Event): """""" trade = event self.offset_converter.update_trade(trade) strategy = self.orderid_strategy_map.get(trade.vt_orderid, None) if not strategy: return # if trade.direction == Direction.LONG: # strategy.pos += trade.volume # else: # strategy.pos -= trade.volume self.call_strategy_func(strategy, strategy.on_trade, trade) self.put_strategy_event(strategy) self.trades[trade.vt_tradeid] = trade def process_position_event(self, event: Event): """""" position = event self.offset_converter.update_position(position) self.positions[position.vt_positionid] = position def process_account_event(self, event: Event): """""" account = event self.accounts[account.vt_accountid] = account def process_contract_event(self, event: Event): """""" contract = event self.contracts[contract.vt_symbol] = contract def call_strategy_func( self, strategy: StrategyBase, func: Callable, params: Any = None ): """ Call function of a strategy and catch any exception raised. """ try: if params: func(params) else: func() except Exception: strategy.trading = False strategy.inited = False msg = f"触发异常已停止\n{traceback.format_exc()}" self.write_log(msg, strategy) def add_strategy( self, class_name: str, strategy_name: str, vt_symbol: str, setting: dict ): """ Add a new strategy. """ if strategy_name in self.strategies: self.write_log(f"创建策略失败,存在重名{strategy_name}") return strategy_class = self.classes[class_name] strategy = strategy_class(self, strategy_name, vt_symbol, setting) self.strategies[strategy_name] = strategy # Add vt_symbol to strategy map. strategies = self.symbol_strategy_map[vt_symbol] strategies.append(strategy) # Update to setting file. self.update_strategy_setting(strategy_name, setting) self.put_strategy_event(strategy) def init_strategy(self, strategy_name: str): """ Init a strategy. """ self.init_queue.put(strategy_name) if not self.init_thread: self.init_thread = Thread(target=self._init_strategy) self.init_thread.start() def _init_strategy(self): """ Init strategies in queue. """ while not self.init_queue.empty(): strategy_name = self.init_queue.get() strategy = self.strategies[strategy_name] if strategy.inited: self.write_log(f"{strategy_name}已经完成初始化,禁止重复操作") continue self.write_log(f"{strategy_name}开始执行初始化") # Call on_init function of strategy self.call_strategy_func(strategy, strategy.on_init) # Restore strategy data(variables) data = self.strategy_data.get(strategy_name, None) if data: for name in strategy.variables: value = data.get(name, None) if value: setattr(strategy, name, value) # Subscribe market data contract = self.get_contract(strategy.vt_symbol) if contract: req = SubscribeEvent() req.destination = contract.gateway_name req.source = "0" req.content = strategy.symbol self.put(req) else: self.write_log(f"行情订阅失败,找不到合约{strategy.vt_symbol}", strategy) # Put event to update init completed status. strategy.inited = True self.put_strategy_event(strategy) self.write_log(f"{strategy_name}初始化完成") self.init_thread = None def start_strategy(self, strategy_name: str): """ Start a strategy. """ strategy = self.strategies[strategy_name] if not strategy.inited: self.write_log(f"策略{strategy.strategy_name}启动失败,请先初始化") return if strategy.trading: self.write_log(f"{strategy_name}已经启动,请勿重复操作") return self.call_strategy_func(strategy, strategy.on_start) strategy.trading = True self.put_strategy_event(strategy) def stop_strategy(self, strategy_name: str): """ Stop a strategy. """ strategy = self.strategies[strategy_name] if not strategy.trading: return # Call on_stop function of the strategy self.call_strategy_func(strategy, strategy.on_stop) # Change trading status of strategy to False strategy.trading = False # Cancel all orders of the strategy # self.cancel_all(strategy) # Update GUI self.put_strategy_event(strategy) def edit_strategy(self, strategy_name: str, setting: dict): """ Edit parameters of a strategy. """ strategy = self.strategies[strategy_name] strategy.update_setting(setting) self.update_strategy_setting(strategy_name, setting) self.put_strategy_event(strategy) def remove_strategy(self, strategy_name: str): """ Remove a strategy. """ strategy = self.strategies[strategy_name] if strategy.trading: self.write_log(f"策略{strategy.strategy_name}移除失败,请先停止") return # Remove setting self.remove_strategy_setting(strategy_name) # Remove from symbol strategy map strategies = self.symbol_strategy_map[strategy.vt_symbol] strategies.remove(strategy) # Remove from active orderid map if strategy_name in self.strategy_orderid_map: vt_orderids = self.strategy_orderid_map.pop(strategy_name) # Remove vt_orderid strategy map for vt_orderid in vt_orderids: if vt_orderid in self.orderid_strategy_map: self.orderid_strategy_map.pop(vt_orderid) # Remove from strategies self.strategies.pop(strategy_name) return True def load_strategy_class(self): """ Load strategy class from source code. """ path1 = Path(__file__).parent.joinpath("") self.load_strategy_class_from_folder( path1, "mystrategy") path2 = Path.cwd().joinpath("") self.load_strategy_class_from_folder(path2, "mystrategy") def load_strategy_class_from_folder(self, path: Path, module_name: str = ""): """ Load strategy class from certain folder. """ for dirpath, dirnames, filenames in os.walk(str(path)): for filename in filenames: if filename.endswith(".py"): strategy_module_name = ".".join( [module_name, filename.replace(".py", "")]) self.load_strategy_class_from_module(strategy_module_name) def load_strategy_class_from_module(self, module_name: str): """ Load strategy class from module file. """ try: module = importlib.import_module(module_name) for name in dir(module): value = getattr(module, name) if (isinstance(value, type) and issubclass(value, StrategyBase) and value is not StrategyBase): self.classes[value.__name__] = value except: # noqa msg = f"策略文件{module_name}加载失败,触发异常:\n{traceback.format_exc()}" self.write_log(msg) def load_strategy_data(self): """ Load strategy data from json file. """ self.strategy_data = load_json(self.data_filename) def sync_strategy_data(self, strategy: StrategyBase): """ Sync strategy data into json file. """ data = strategy.get_variables() data.pop("inited") # Strategy status (inited, trading) should not be synced. data.pop("trading") self.strategy_data[strategy.strategy_name] = data save_json(self.data_filename, self.strategy_data) def get_all_strategy_class_names(self): """ Return names of strategy classes loaded. """ return list(self.classes.keys()) def get_strategy_class_parameters(self, class_name: str): """ Get default parameters of a strategy class. """ strategy_class = self.classes[class_name] parameters = {} for name in strategy_class.parameters: parameters[name] = getattr(strategy_class, name) return parameters def get_strategy_parameters(self, strategy_name): """ Get parameters of a strategy. """ strategy = self.strategies[strategy_name] return strategy.get_parameters() def init_all_strategies(self): """ """ for strategy_name in self.strategies.keys(): self.init_strategy(strategy_name) def start_all_strategies(self): """ """ for strategy_name in self.strategies.keys(): self.start_strategy(strategy_name) def stop_all_strategies(self): """ """ for strategy_name in self.strategies.keys(): self.stop_strategy(strategy_name) def load_strategy_setting(self): """ Load setting file. """ self.strategy_setting = load_json(self.setting_filename) for strategy_name, strategy_config in self.strategy_setting.items(): self.add_strategy( strategy_config["class_name"], strategy_name, strategy_config["vt_symbol"], strategy_config["setting"] ) def update_strategy_setting(self, strategy_name: str, setting: dict): """ Update setting file. """ strategy = self.strategies[strategy_name] self.strategy_setting[strategy_name] = { "class_name": strategy.__class__.__name__, "vt_symbol": strategy.vt_symbol, "setting": setting, } save_json(self.setting_filename, self.strategy_setting) def remove_strategy_setting(self, strategy_name: str): """ Update setting file. """ if strategy_name not in self.strategy_setting: return self.strategy_setting.pop(strategy_name) save_json(self.setting_filename, self.strategy_setting) # def put_stop_order_event(self, stop_order: StopOrder): # """ # Put an event to update stop order status. # """ # event = Event(EVENT_CTA_STOPORDER, stop_order) # self.event_engine.put(event) def put_strategy_event(self, strategy: StrategyBase): """ Put an event to update strategy status. """ data = strategy.get_data() # event = Event(EVENT_CTA_STRATEGY, data) # self.event_engine.put(event) pass def init_nng(self): self._recv_sock.set_string_option(SUB, SUB_SUBSCRIBE, '') # receive msg start with all self._recv_sock.set_int_option(SOL_SOCKET,RCVTIMEO,100) self._recv_sock.connect(self._config['serverpub_url']) self._send_sock.connect(self._config['serverpull_url']) #------------------------------------ public functions -----------------------------# def query_bar_from_rq( self, symbol: str, exchange: Exchange, interval: Interval, start: datetime, end: datetime ): """ Query bar data from RQData. """ data = rqdata_client.query_bar( symbol, exchange, interval, start, end ) return data def load_bar( self, vt_symbol: str, days: int, interval: Interval, callback: Callable[[BarData], None] ): """""" symbol, exchange = extract_vt_symbol(vt_symbol) end = datetime.now() start = end - timedelta(days) # Query bars from RQData by default, if not found, load from database. bars = self.query_bar_from_rq(symbol, exchange, interval, start, end) if not bars: bars = database_manager.load_bar_data( symbol=symbol, exchange=exchange, interval=interval, start=start, end=end, ) for bar in bars: callback(bar) def get_tick(self, vt_symbol): """ Get latest market tick data by vt_symbol. """ return self.ticks.get(vt_symbol, None) def get_order(self, vt_orderid): """ Get latest order data by vt_orderid. """ return self.orders.get(vt_orderid, None) def get_trade(self, vt_tradeid): """ Get trade data by vt_tradeid. """ return self.trades.get(vt_tradeid, None) def get_position(self, vt_positionid): """ Get latest position data by vt_positionid. """ return self.positions.get(vt_positionid, None) def get_account(self, vt_accountid): """ Get latest account data by vt_accountid. """ return self.accounts.get(vt_accountid, None) def get_contract(self, vt_symbol): """ Get contract data by vt_symbol. """ return self.contracts.get(vt_symbol, None) def get_all_ticks(self): """ Get all tick data. """ return list(self.ticks.values()) def get_all_orders(self): """ Get all order data. """ return list(self.orders.values()) def get_all_trades(self): """ Get all trade data. """ return list(self.trades.values()) def get_all_positions(self): """ Get all position data. """ return list(self.positions.values()) def get_all_accounts(self): """ Get all account data. """ return list(self.accounts.values()) def get_all_contracts(self): """ Get all contract data. """ return list(self.contracts.values()) def get_all_active_orders(self, vt_symbol: str = ""): """ Get all active orders by vt_symbol. If vt_symbol is empty, return all active orders. """ if not vt_symbol: return list(self.active_orders.values()) else: active_orders = [ order for order in self.active_orders.values() if order.vt_symbol == vt_symbol ] return active_orders def start(self, timer=True): """ start the dispatcher thread and begin to recv msg through nng """ self.event_engine.start() print('tradeclient started ,pid = %d ' % os.getpid()) self.__active = True # print(self._config['serverpub_url']) while self.__active: try: msgin = self._recv_sock.recv(flags=0) msgin = msgin.decode("utf-8") if msgin is not None and msgin.index('|') > 0: print('tradeclient(id = %d) rec server msg:'%(self.id), msgin,'at ', datetime.now()) if msgin[-1] == '\0': msgin = msgin[:-1] if msgin[-1] == '\x00': msgin = msgin[:-1] v = msgin.split('|') msg2type = MSG_TYPE(int(v[2])) if msg2type == MSG_TYPE.MSG_TYPE_TICK_L1: m = TickEvent() m.deserialize(msgin) elif msg2type == MSG_TYPE.MSG_TYPE_RTN_ORDER: m = OrderStatusEvent() m.deserialize(msgin) elif msg2type == MSG_TYPE.MSG_TYPE_RTN_TRADE: m = FillEvent() m.deserialize(msgin) elif msg2type == MSG_TYPE.MSG_TYPE_RSP_POS: m = PositionEvent() m.deserialize(msgin) elif msg2type == MSG_TYPE.MSG_TYPE_Hist: m = HistoricalEvent() m.deserialize(msgin) elif msg2type == MSG_TYPE.MSG_TYPE_RSP_ACCOUNT: m = AccountEvent() m.deserialize(msgin) elif msg2type == MSG_TYPE.MSG_TYPE_RSP_CONTRACT: m = ContractEvent() m.deserialize(msgin) elif msg2type == MSG_TYPE.MSG_TYPE_INFO: m = InfoEvent() m.deserialize(msgin) else: m = GeneralReqEvent() m.deserialize(msgin) pass self.event_engine.put(m) # if m.event_type in self._handlers: # [handler(m) for handler in self._handlers[m.event_type]] except Exception as e: pass #print("TradeEngineError {0}".format(str(e.args[0])).encode("utf-8")) def stop(self): """ stop """ self.__active = False self.event_engine.stop() def put(self, event): """ send event msg,TODO:check the event """ # self._send_sock.send(event.serialize(),flags=1) def register_handler(self, type_, handler): """ register handler/subscriber """ # handlerList = self._handlers[type_] # if handler not in handlerList: # self._handlers[type_].append(handler) # #handlerList.append(handler) pass def unregister_handler(self, type_, handler): """ unregister handler/subscriber """ # handlerList = self._handlers[type_] # if handler in handlerList: # self._handlers.remove(handler) # if not handlerList: # del self._handlers[type_] pass def write_log(self, msg: str, strategy: StrategyBase = None): """ Create engine log event. """ # if strategy: # msg = f"{strategy.strategy_name}: {msg}" # log = LogData(msg=msg, gateway_name="CtaStrategy") # event = Event(type=EVENT_CTA_LOG, data=log) # self.event_engine.put(event) print(msg) # -------------------------------- end of public functions -----------------------------#
class PushWorker(threading.Thread): """ Pushes data into pipeline Attributes: url: String specifying endpoint socket connects to. topic: String specifying topic worker is relying data to samplingrate: Integer specifying the rate at which samples are collected in Herz [1/s] socket: Nanomsg socket object stop: threading.Event to stop Thread Note: url must be of the form ``<protocol>://<address>`` where ``<protocol>`` can have to following values: - **tcp** - send data over computer network using tcp protocol. In this case ``<address>`` has to be a valid IPv4 address of the form ``<ipv4>:<port>`` - **inproc** - Share data between threads of the same process using shared memory. In this case ``<address>`` can be an arbitrary string. - **ipc** - Share data between two processes using a file. In this case ``<address>`` can be an arbitrary string. """ def __init__(self, url, topic, loggername, samplingrate=100, retry_interval=1): """ Initializes object Args: url (string): specifying endpoint socket connects to. topic (String): specifying topic worker is relying data to. samplingrate (int): specifying the rate at which samples are collected in Herz [1/s]. """ super(PushWorker, self).__init__() self._samplingrate = samplingrate self._socket = Socket(PUSH) self._url = url self._topic = topic self._socket.connect(self._url) self._logger = logging.getLogger(loggername) self._name = loggername self._stop = threading.Event() def send(self, data): """ Sends message into queue """ message = json.dumps({'topic': self._topic, 'data': data}) self._socket.send(message) def _get_data_point(self): """ Message to retrieve one datapoint """ raise NotImplementedError('Method get_data_point not implemented for ' + \ 'PushWorker') def run(self): """ Run method for thread """ for datapoint in self._get_data_point(): self.send(datapoint) self._logger.debug('topic: {} value: {} target: {}'.format( self._topic, datapoint, self._url)) time.sleep(1. / self._samplingrate) if self.stopped: self._logger.info('{} is going down...'.format(self._name)) break self.__exit__() def stop(self): """ Stops thread """ self._stop.set() @property def stopped(self): """ Checks whether Thread is stopped. Returns True if thread stopped else False """ return self._stop.is_set() def __enter__(self): """ Statement used for the `` with ... as ...:`` returns the object to use in the ``with`` block Returns: PushWorker """ return self def __exit__(self, exc_type, exc_value, traceback): """ Executed when leaving ``with`` block, regardless whether because of an exception or normal program flow """ self._socket.close()
class RecorderEngine(BaseEngine): """ market data recorder """ config_filename = "config_server.yaml" setting_filename = "data_recorder_setting.json" # init def __init__(self, configfile: str = '', gateway: str = "CTP.MD"): super(RecorderEngine, self).__init__(event_engine=EventEngine(10)) """ two sockets to send and recv msg """ self.__active = False self._thread = Thread(target=self._run) self.id = os.getpid() self.engine_type = EngineType.LIVE self._recv_sock = Socket(SUB) self._send_sock = Socket(PUSH) if configfile: self.config_filename = configfile if gateway: self.gateway = gateway filepath = Path.cwd().joinpath("etc/" + self.config_filename) with open(filepath, encoding='utf8') as fd: self._config = yaml.load(fd) self.tick_recordings = {} self.bar_recordings = {} self.bar_generators = {} self.contracts = {} self.subscribed = False self.dayswitched = False self.init_engine() # init functions def init_engine(self): self.init_nng() self.load_contract() self.load_setting() self.register_event() self.put_event() def init_nng(self): self._recv_sock.set_string_option(SUB, SUB_SUBSCRIBE, '') # receive msg start with all self._recv_sock.set_int_option(SOL_SOCKET, RCVTIMEO, 100) self._recv_sock.connect(self._config['serverpub_url']) self._send_sock.connect(self._config['serverpull_url']) def load_contract(self): contractfile = Path.cwd().joinpath("etc/ctpcontract.yaml") with open(contractfile, encoding='utf8') as fc: contracts = yaml.load(fc) print('loading contracts, total number:', len(contracts)) for sym, data in contracts.items(): contract = ContractData( symbol=data["symbol"], exchange=Exchange(data["exchange"]), name=data["name"], product=PRODUCT_CTP2VT[str(data["product"])], size=data["size"], pricetick=data["pricetick"], net_position=True if str(data["positiontype"]) == THOST_FTDC_PT_Net else False, long_margin_ratio=data["long_margin_ratio"], short_margin_ratio=data["short_margin_ratio"], full_symbol=data["full_symbol"]) # For option only if contract.product == Product.OPTION: contract.option_underlying = data["option_underlying"], contract.option_type = OPTIONTYPE_CTP2VT.get( str(data["option_type"]), None), contract.option_strike = data["option_strike"], contract.option_expiry = datetime.strptime( str(data["option_expiry"]), "%Y%m%d"), self.contracts[contract.full_symbol] = contract def load_setting(self): """""" setting = load_json(self.setting_filename) self.tick_recordings = setting.get("tick", {}) self.bar_recordings = setting.get("bar", {}) def save_setting(self): """""" setting = {"tick": self.tick_recordings, "bar": self.bar_recordings} save_json(self.setting_filename, setting) def register_event(self): """""" self.event_engine.register(EventType.TICK, self.process_tick_event) self.event_engine.register(EventType.CONTRACT, self.process_contract_event) self.event_engine.register(EventType.RECORDER_CONTROL, self.process_recordercontrol_event) self.event_engine.register(EventType.HEADER, self.process_general_event) self.event_engine.register(EventType.TIMER, self.process_timer_event) def init_subcribe(self, src: str = 'CTP.MD'): symset = set(self.tick_recordings.keys()) symset.update(self.bar_recordings.keys()) for sym in symset: self.subscribe(sym, src) self.subscribed = True # event handler def process_timer_event(self, event): # auto subscribe at 8:55, 20:55 nowtime = datetime.now().time() if (nowtime > time(hour=8, minute=50)) and (nowtime < time( hour=8, minute=51)) and (not self.subscribed): self.init_subcribe() self.dayswitched = False if (nowtime > time(hour=20, minute=50)) and (nowtime < time( hour=20, minute=51)) and (not self.subscribed): self.init_subcribe() self.dayswitched = False # reset at 16:00 and 3:00 if (nowtime > time(hour=16, minute=0)) and (nowtime < time( hour=16, minute=1)) and (not self.dayswitched): self.subscribed = False self.dayswitched = True if (nowtime > time(hour=3, minute=0)) and (nowtime < time( hour=3, minute=1)) and (not self.dayswitched): self.subscribed = False self.dayswitched = True def process_general_event(self, event): pass def process_tick_event(self, event: Event): """""" tick = event.data dayclosetime = tick.datetime.time() < time( hour=9, minute=0) and tick.datetime.time() > time(hour=8, minute=0) nightclosetime = tick.datetime.time() < time( hour=21, minute=0) and tick.datetime.time() > time(hour=16, minute=0) if dayclosetime or nightclosetime: return # exclude onrtnsubscribe return first tick which time not in trade time if (tick.open_price) and tick.last_price and tick.ask_price_1: if tick.full_symbol in self.tick_recordings: self.record_tick(tick) if tick.full_symbol in self.bar_recordings: bg = self.get_bar_generator(tick.full_symbol) bg.update_tick(tick) def process_contract_event(self, event: Event): """""" contract = event.data self.contracts[contract.full_symbol] = contract def process_recordercontrol_event(self, event: Event): msgtype = event.msg_type deslist = ['@*', str(self.id), '@' + str(self.id)] if (event.destination not in deslist): return elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_STATUS): m = Event(type=EventType.RECORDER_CONTROL, des='@0', src=str(self.id), data=str(self.__active), msgtype=MSG_TYPE.MSG_TYPE_RECORDER_STATUS) self._send_sock.send(m.serialize()) self.put_event() elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_ADD_TICK): full_symbol = event.data self.add_tick_recording(full_symbol, event.source) elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_ADD_BAR): full_symbol = event.data self.add_bar_recording(full_symbol, event.source) elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_REMOVE_TICK): full_symbol = event.data self.remove_tick_recording(full_symbol) elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_REMOVE_BAR): full_symbol = event.data self.remove_bar_recording(full_symbol) elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_START): self.init_subcribe() elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_STOP): self.clear() elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_RELOAD): pass elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_RESET): pass elif (msgtype == MSG_TYPE.MSG_TYPE_RECORDER_GET_DATA): self.put_event() def put_event(self): """""" tick_symbols = list(self.tick_recordings.keys()) tick_symbols.sort() bar_symbols = list(self.bar_recordings.keys()) bar_symbols.sort() data = {"tick": tick_symbols, "bar": bar_symbols} msg = json.dumps(data) m = Event(type=EventType.RECORDER_CONTROL, data=msg, des='@0', src=str(self.id), msgtype=MSG_TYPE.MSG_TYPE_RECORDER_RTN_DATA) self._send_sock.send(m.serialize()) def add_bar_recording(self, full_symbol: str, src: str = 'CTP.MD'): """""" if full_symbol in self.bar_recordings: self.write_log(f"已在K线记录列表中:{full_symbol}") return contract = self.contracts.get(full_symbol, None) if not contract: self.write_log(f"找不到合约:{full_symbol}") return self.bar_recordings[full_symbol] = { "symbol": contract.symbol, "exchange": contract.exchange.value, "gateway_name": self.gateway } self.subscribe(full_symbol, src) self.save_setting() self.put_event() self.write_log(f"添加K线记录成功:{full_symbol}") def add_tick_recording(self, full_symbol: str, src: str = 'CTP.MD'): """""" if full_symbol in self.tick_recordings: self.write_log(f"已在Tick记录列表中:{full_symbol}") return contract = self.contracts.get(full_symbol, None) if not contract: self.write_log(f"找不到合约:{full_symbol}") return self.tick_recordings[full_symbol] = { "symbol": contract.symbol, "exchange": contract.exchange.value, "gateway_name": self.gateway } self.subscribe(full_symbol, src) self.save_setting() self.put_event() self.write_log(f"添加Tick记录成功:{full_symbol}") def remove_bar_recording(self, full_symbol: str): """""" if full_symbol not in self.bar_recordings: self.write_log(f"不在K线记录列表中:{full_symbol}") return self.bar_recordings.pop(full_symbol) self.save_setting() self.put_event() self.write_log(f"移除K线记录成功:{full_symbol}") def remove_tick_recording(self, full_symbol: str): """""" if full_symbol not in self.tick_recordings: self.write_log(f"不在Tick记录列表中:{full_symbol}") return self.tick_recordings.pop(full_symbol) self.save_setting() self.put_event() self.write_log(f"移除Tick记录成功:{full_symbol}") def record_tick(self, tick: TickData): """""" database_manager.save_tick_data([tick]) def record_bar(self, bar: BarData): """""" database_manager.save_bar_data([bar]) def get_bar_generator(self, full_symbol: str): """""" bg = self.bar_generators.get(full_symbol, None) if not bg: bg = BarGenerator(self.record_bar) self.bar_generators[full_symbol] = bg return bg def subscribe(self, full_symbol: str, src: str = 'CTP.MD'): contract = self.contracts.get(full_symbol, None) if contract: m = Event(type=EventType.SUBSCRIBE, msgtype=MSG_TYPE.MSG_TYPE_SUBSCRIBE_MARKET_DATA) m.destination = src m.source = str(self.id) req = SubscribeRequest() if src == 'CTP.MD': req.sym_type = SYMBOL_TYPE.CTP req.content = contract.symbol else: req.sym_type = SYMBOL_TYPE.FULL req.content = full_symbol m.data = req self._send_sock.send(m.serialize()) else: self.write_log(f"行情订阅失败,找不到合约{full_symbol}") def clear(self): self.bar_recordings.clear() self.tick_recordings.clear() self.save_setting() self.put_event() def _run(self): while self.__active: try: msgin = self._recv_sock.recv(flags=0) msgin = msgin.decode("utf-8") if msgin is not None and msgin.index('|') > 0: if msgin[0] == '@': print('recorder(pid = %d) rec @ msg:' % (self.id), msgin, 'at ', datetime.now()) if msgin[-1] == '\0': msgin = msgin[:-1] if msgin[-1] == '\x00': msgin = msgin[:-1] m = Event() m.deserialize(msgin) self.event_engine.put(m) except Exception as e: pass #print("TradeEngineError {0}".format(str(e.args[0])).encode("utf-8")) # start and stop def start(self): """ start the dispatcher thread and begin to recv msg through nng """ print('tradeclient started ,pid = %d ' % os.getpid()) self.event_engine.start() self.__active = True self._thread.start() def stop(self): """ stop """ self.__active = False self.event_engine.stop() self._thread.join() def write_log(self, msg: str): """ Create engine log event. """ # log = LogData(msg=msg, gateway_name="CtaStrategy") # event = Event(type=EVENT_CTA_LOG, data=log) # self.event_engine.put(event) print(msg)
class ClientMq(object): def __init__(self, event_engine, outgoing_quue): self._event_engine = event_engine self._outgoing_quue = outgoing_quue self._tick_sock = Socket(SUB) self._msg_sock = Socket(PAIR) self._active = False self._thread = Thread(target=self._run) def _run(self): while self._active: try: msg1 = self._tick_sock.recv(flags=1) msg1 = msg1.decode("utf-8") if msg1 is not None and msg1.index('|') > 0: if msg1[-1] == '\0': msg1 = msg1[:-1] v = msg1.split('|') k = TickEvent() k.full_symbol = v[0] k.price = v[3] self._event_engine.put(k) except Exception as e: pass # print('SUB error: ' + str(e)) try: msg2 = self._msg_sock.recv(flags=1) msg2 = msg2.decode("utf-8") if msg2 is not None and msg2.index('|') > 0: if msg2[-1] == '\0': msg2 = msg2[:-1] if msg2[-1] == '\x00': msg2 = msg2[:-1] m = GeneralEvent() m.content = msg2 self._event_engine.put(m) v = msg2.split('|') if v[0] == 's': m = OrderStatusEvent() m.broker_order_id = v[1] m.internal_order_id = v[1] m.order_status = v[2] self._event_engine.put(m) elif v[0] == 'f': m = FillEvent() m.broker_order_id = v[1] m.internal_order_id = v[1] m.timestamp = v[2] m.fill_price = v[3] m.fill_size = v[4] self._event_engine.put(m) else: pass except Exception as e: pass # print('PAIR error: '+ str(i) + '' + str(e)); # time.sleep(1) try: msg3 = self._outgoing_quue.get(False) print(msg3) self._msg_sock.send(msg3, flags=1) except Exception as e: pass def start(self, timer=True): """ start the mq thread """ self._tick_sock.connect('tcp://127.0.0.1:55555') self._tick_sock.set_string_option(SUB, SUB_SUBSCRIBE, '') # receive msg start with all self._msg_sock.connect('tcp://127.0.0.1:55558') self._active = True if not self._thread.isAlive(): self._thread.start() def stop(self): """ stop the mq thread """ self._active = False if self._thread.isAlive(): self._thread.join()
def run(self, stopflag, q): # signal.signal(signal.SIGINT, signal.SIG_IGN) qO, qN, qD = q print('tcp://*:' + self.port) s1 = Socket(REP) # s1.recv_buffer_size=1024*1024 # s1.reconnect_interval_max=1000 s1.bind('tcp://*:' + self.port) pb_n = args_pb2.p_n() s_n = self.s_n ps_n = s_n * (s_n + 1) pb_n.s_n = s_n # print("nanoMesg up") time.sleep(0.5) running = True pb_sid = args_pb2.p_sid() pb_sid.sid = 0 clients = dict() sys_platform = sys.platform while (running): # print("loop start") if stopflag.value > len(clients.keys()): running = False break if sys_platform == 'win32': try: recvstr = s1.recv() except KeyboardInterrupt: if len(clients.keys()) <= 0: running = False elif stopflag.value >= 0: print("stopflag.value: ", stopflag.value) with stopflag.get_lock(): stopflag.value += 1 continue # os.kill(self.ppid, signal.CTRL_C_EVENT) else: recvstr = s1.recv() # recvstr=s1.recv() # print(ord('c'),ord('p'),ord('r'),ord('k'),"recvstr[0]: ",recvstr[0]) if recvstr[0] == ord('c'): pb_cap = args_pb2.p_cap() pb_cap.ParseFromString(recvstr[1:]) # print("pb_cap.idx",pb_cap.idx) s1.send(pb_n.SerializeToString()) elif recvstr[0] == ord('p'): pb_gpuid = args_pb2.p_str() pb_gpuid.ParseFromString(recvstr[1:]) # TODO 解析 p_str get ohist if pb_gpuid.histNum > 0: # print(list(pb_gpuid.ohist)) qD.put( (pb_gpuid.histNum, self.bestcs, list(pb_gpuid.ohist))) pb_ga = args_pb2.p_ga() pb_ga.start = 0 pb_ga.stop = -1 ii = -1 ind_ = [] try: ii, ind_, self.bestcs = qO.get( False ) #TODO change proto to allow ord('p') fail and retry later. except queue.Empty: if stopflag.value >= 1: print("stopflag.value: ", stopflag.value) pb_ga.idx = -2 stopflag.value += 1 else: pb_ga.idx = -1 s1.send(pb_ga.SerializeToString()) continue # ind_=[random.random()]*(s_n*(s_n+1)) pb_ga.idx = ii pb_ga.bestfv = self.bestcs for i in range(s_n): pb_ga.params.append(ind_[i]) for i in range(s_n * s_n - s_n): pb_ga.params.append(ind_[i + s_n]) for i in range(s_n): pb_ga.params.append(ind_[i + s_n * s_n]) s1.send(pb_ga.SerializeToString()) # clients_lastTimeS[pb_ga.idx]=time.perf_counter() # print("p: ",clients_lastTimeS[pb_ga.idx]) if pb_gpuid.str not in clients: clients[pb_gpuid.str] = gpuClient() print(pb_gpuid.str, " connected.") else: clients[pb_gpuid.str].updateTimeStamp() elif recvstr[0] == ord('r'): res = args_pb2.res() res.ParseFromString(recvstr[1:]) # print("res chi2 recv",res.e, " ridx: ",res.ridx) if stopflag.value >= 1: pb_sid.sid = -1 print("time spend: ", clients.pop(res.idx).runTime) if len(clients.keys()) <= 0: running = False # print("stopflag: ",stopflag.value) # s1.close() s1.send(pb_sid.SerializeToString()) # print("pb_sid send",pb_sid.sid, " ridx: ",res.ridx) if res.idx in clients: clients[res.idx].updateRunTime() #TODO 解析res get shist qN.put((res.ridx, res.e)) if res.hist: # self.counter=self.counter+1 # print(self.counter,self.bestcs) if self.bestcs < 3.2E31: qD.put((-1, self.bestcs, list(res.shist))) elif recvstr[0] == ord('k'): pidx = args_pb2.p_sid() pidx.ParseFromString(recvstr[1:]) # print("keepalive: ",pidx.sid) s1.send('l') else: print("Err recv: ", recvstr[0]) s1.close() qN.close() qD.close() qN.join_thread() qD.join_thread() print("paramsServ done!")
# vim: set fileencoding=utf-8 from nanomsg import Socket, PAIR URL = "ipc:///tmp/example4" socket = Socket(PAIR) print("Socket created") socket.connect(URL) print("Connected to URL {}".format(URL)) message = socket.recv() print("Received: {}".format(message)) socket.send("Thanks for your message '{}'".format(message)) print("Response has been sent") socket.close() print("Socket closed")
rxMessage = socket.recv(flags=DONTWAIT) print("Received request: %s" % rxMessage) except NanoMsgAPIError: pass if rxMessage != None: interpretCombinatorMessage(message) # Write to socket txMessage = None if lastMachineUpdate + 200 * 1000 < time.time(): # Only create a machine update when an update can be sent over the # socket. Rate limited to one update every 200ms. txMessage = createMachineUpdate() try: print "SENDING??" socket.send(txMessage, DONTWAIT) print "SENT!" except NanoMsgAPIError: print "Unable to send nanomsg. Will retry." if rxMesssage == None and txMessage == None: # Wait 50ms and then check if there's anything to do again. sleep(0.05) def interpretCombinatorMessage(binary_message): # Receive combinator messages msg = combinator_protobuf.CombinatorMessage() msg.ParseFromString(binary_message) type = msg.WhichOneof("payload")
from nanomsg import Socket s1 = Socket('PAIR') s2 = Socket('PAIR') s1.bind('inproc://bob') s2.connect('inproc://bob') s1.send(b'hello nanomsg') print(s2.recv()) s1.close() s2.close()
from __future__ import print_function from nanomsg import Socket, PAIR, PUB s1 = Socket(PAIR) s2 = Socket(PAIR) s1.bind('inproc://bob') s2.connect('inproc://bob') s1.send(b'hello nanomsg') print(s2.recv()) s1.close() s2.close() with Socket(PAIR) as s3: with Socket(PAIR) as s4: s3.bind('inproc://demo') s4.connect('inproc://demo') s3.send('hi, I use "with"') print(s4.recv()) s4.send('Ok, I see.') print(s3.recv())
from nanomsg import Socket, REQ, REP, PUB, SUB, DONTWAIT, \ NanoMsgAPIError, EAGAIN, SUB_SUBSCRIBE # first connect to the (remote) pi (b.local) running mangorep s2 = Socket(REQ) s2.connect('tcp://b.local:5555') # set up the query in json #s = json.dumps({"Cmnd":"sysType"}) s = json.dumps({"Cmnd": "cpuTemp"}) # run the query while True: s2.send(s) msg = s2.recv() # print(msg) print(json.loads(msg.decode("utf-8"))) # note that the whole json response is printed here # actually it showed up that I am returning a \n newline I don't want... # Now corrected in mangorep (line 88 ish) time.sleep(2) """ Example output:- {'Cmnd': 'cpuTemp', 'Args': None, 'rslt': "temp=42.9'C\n"} {'Cmnd': 'cpuTemp', 'Args': None, 'rslt': "temp=41.9'C\n"} {'Cmnd': 'cpuTemp', 'Args': None, 'rslt': "temp=41.9'C\n"}
DONTWAIT ) socket = Socket(PAIR) socket_address = 'ipc:///home/d1plo1d/git_repos/teg/packages/teg-linuxcnc/example_socket' socket.bind(socket_address) # s2.connect(socket_address) # print(s2.recv()) # s2.close() while True: print "SENDING??" try: socket.send(b'hello nanomsg', DONTWAIT) print "SENT!" except NanoMsgAPIError: print "Unable to send nanomsg. Will retry." try: message = socket.recv(flags=DONTWAIT) print("Received request: %s" % message) except NanoMsgAPIError: pass # Do some 'work' time.sleep(1) # Send reply back to client # socket.send(b"World")
class StrategyEngine(BaseEngine): """ Send to and receive from msg server ,used for strategy """ config_filename = "config_server.yaml" setting_filename = "cta_strategy_setting.json" data_filename = "cta_strategy_data.json" # init def __init__(self, configfile: str = '', id: int = 1): super(StrategyEngine, self).__init__(event_engine=EventEngine(10)) """ two sockets to send and recv msg """ self.__active = False self.id = os.getpid() self.engine_type = EngineType.LIVE self._recv_sock = Socket(SUB) self._send_sock = Socket(PUSH) self._handlers = defaultdict(list) if configfile: self.config_filename = configfile filepath = Path.cwd().joinpath("etc/" + self.config_filename) with open(filepath, encoding='utf8') as fd: self._config = yaml.load(fd) self.ordercount = 0 # stragegy manage self.strategy_setting = {} # strategy_name: dict self.strategy_data = {} # strategy_name: dict self.classes = {} # class_name: stategy_class self.strategies = {} # strategy_name: strategy # self.classes_id = {} # class_id : strategy # self.strategies_id = {} # strategy_ID: strategy self.symbol_strategy_map = defaultdict( list) # full_symbol: strategy list self.orderid_strategy_map = {} # vt_orderid: strategy self.strategy_orderid_map = defaultdict( set) # strategy_name: client_order_id list self.stop_order_count = 0 # for generating stop_orderid self.stop_orders = {} # stop_orderid: stop_order self.init_thread = None self.init_queue = Queue() # order,tick,position ,etc manage self.ticks = {} self.orders = {} # clientorder id list self.trades = {} self.positions = {} self.accounts = {} self.contracts = {} self.active_orders = {} # SQ id list self.rq_client = None self.rq_symbols = set() self.offset_converter = OffsetConverter(self) self.autoinited = False self.autostarted = False self.dayswitched = False self.init_engine() # init functions def init_engine(self): self.init_nng() self.init_rqdata() self.load_contract() self.load_strategy_class() self.load_strategy_setting() self.load_strategy_data() self.register_event() def init_nng(self): self._recv_sock.set_string_option( SUB, SUB_SUBSCRIBE, '') # receive msg start with all self._recv_sock.set_int_option(SOL_SOCKET, RCVTIMEO, 100) self._recv_sock.connect(self._config['serverpub_url']) self._send_sock.connect(self._config['serverpull_url']) def init_rqdata(self): result = rqdata_client.init() if result: self.write_log("RQData数据接口初始化成功") def load_contract(self): contractfile = Path.cwd().joinpath("etc/ctpcontract.yaml") with open(contractfile, encoding='utf8') as fc: contracts = yaml.load(fc) print('loading contracts, total number:', len(contracts)) for sym, data in contracts.items(): contract = ContractData( symbol=data["symbol"], exchange=Exchange(data["exchange"]), name=data["name"], product=PRODUCT_CTP2VT[str(data["product"])], size=data["size"], pricetick=data["pricetick"], net_position=True if str( data["positiontype"]) == THOST_FTDC_PT_Net else False, long_margin_ratio=data["long_margin_ratio"], short_margin_ratio=data["short_margin_ratio"], full_symbol=data["full_symbol"] ) # For option only if contract.product == Product.OPTION: contract.option_underlying = data["option_underlying"], contract.option_type = OPTIONTYPE_CTP2VT.get( str(data["option_type"]), None), contract.option_strike = data["option_strike"], contract.option_expiry = datetime.strptime( str(data["option_expiry"]), "%Y%m%d"), self.contracts[contract.full_symbol] = contract def register_event(self): """""" self.event_engine.register(EventType.TICK, self.process_tick_event) self.event_engine.register( EventType.ORDERSTATUS, self.process_orderstatus_event) self.event_engine.register(EventType.FILL, self.process_trade_event) self.event_engine.register( EventType.POSITION, self.process_position_event) self.event_engine.register( EventType.ACCOUNT, self.process_account_event) self.event_engine.register( EventType.CONTRACT, self.process_contract_event) self.event_engine.register( EventType.STRATEGY_CONTROL, self.process_strategycontrol_event) self.event_engine.register( EventType.HEADER, self.process_general_event) self.event_engine.register(EventType.TIMER, self.process_timer_event) # event handler def process_timer_event(self, event): # auto init and start strategy at 8:57, 20:57 nowtime = datetime.now().time() dayinitflag = (nowtime > time(hour=8, minute=55)) and ( nowtime < time(hour=8, minute=56)) daystartflag = (nowtime > time(hour=8, minute=57)) and ( nowtime < time(hour=8, minute=58)) nightinitflag = (nowtime > time(hour=20, minute=55)) and ( nowtime < time(hour=20, minute=56)) nightstartflag = (nowtime > time(hour=20, minute=57)) and ( nowtime < time(hour=20, minute=58)) if (dayinitflag or nightinitflag) and (not self.autoinited): for name, strategy in self.strategies.items(): if strategy.autostart: self.init_strategy(name) self.dayswitched = False self.autoinited = True if (daystartflag or nightstartflag) and (not self.autostarted): for name, strategy in self.strategies.items(): if strategy.autostart: self.start_strategy(name) self.autostarted = True self.dayswitched = False # auto stop strategy at 16:00 and 3:00 if (nowtime > time(hour=16, minute=0)) and (nowtime < time(hour=16, minute=1)) and (not self.dayswitched): for name, strategy in self.strategies.items(): if strategy.autostart: self.reset_strategy(name) self.dayswitched = True self.autostarted = False self.autoinited = False if (nowtime > time(hour=3, minute=0)) and (nowtime < time(hour=3, minute=1)) and (not self.dayswitched): for name, strategy in self.strategies.items(): if strategy.autostart: self.reset_strategy(name) self.dayswitched = True self.autostarted = False self.autoinited = False def process_general_event(self, event): for name, strategy in self.strategies.items(): self.call_strategy_func(strategy, strategy.on_headermsg, event) pass def process_tick_event(self, event: Event): """""" tick = event.data strategies = self.symbol_strategy_map[tick.full_symbol] if not strategies: return # self.check_stop_order(tick) for strategy in strategies: if strategy.inited: self.call_strategy_func(strategy, strategy.on_tick, tick) self.ticks[tick.full_symbol] = tick def process_orderstatus_event(self, event: Event): """""" order = event.data self.offset_converter.update_order(order) # 重新计算冻结 if order.clientID != self.id: return self.orders[order.client_order_id] = order # If order is active, then update data in dict. if order.is_active(): print('order is active') self.active_orders[order.client_order_id] = order # Otherwise, pop inactive order from in dict elif order.client_order_id in self.active_orders: self.active_orders.pop(order.client_order_id) strategy = self.orderid_strategy_map.get(order.client_order_id, None) if not strategy: print(order.client_order_id, 'dont find strategy') return # Remove client_order_id if order is no longer active. client_order_ids = self.strategy_orderid_map[strategy.strategy_name] if (order.client_order_id in client_order_ids) and (not order.is_active()): print('rm inactive order in strategy order map') client_order_ids.remove(order.client_order_id) # For server stop order, call strategy on_stop_order function # if order.type == OrderType.STOP: # so = StopOrder( # full_symbol=order.full_symbol, # direction=order.direction, # offset=order.offset, # price=order.price, # volume=order.volume, # stop_orderid=order.vt_orderid, # strategy_name=strategy.strategy_name, # status=STOP_STATUS_MAP[order.status], # vt_orderid=order.vt_orderid, # ) # self.call_strategy_func(strategy, strategy.on_stop_order, so) # Call strategy on_order function self.call_strategy_func(strategy, strategy.on_order, order) def process_trade_event(self, event: Event): """""" trade = event.data self.offset_converter.update_trade(trade) if trade.clientID != self.id: return strategy = self.orderid_strategy_map.get(trade.client_order_id, None) if not strategy: return # if trade.direction == Direction.LONG: # strategy.pos += trade.volume # else: # strategy.pos -= trade.volume self.call_strategy_func(strategy, strategy.on_trade, trade) self.put_strategy_event(strategy) self.trades[trade.vt_tradeid] = trade # send qry pos to update position m = Event(type=EventType.QRY, des=event.source, src=str(self.id), msgtype=MSG_TYPE.MSG_TYPE_QRY_POS) self._send_sock.send(m.serialize()) # self.put(m) def process_position_event(self, event: Event): """""" position = event.data self.offset_converter.update_position(position) self.positions[position.key] = position def process_account_event(self, event: Event): """""" account = event.data self.accounts[account.accountid] = account def process_contract_event(self, event: Event): """""" contract = event.data self.contracts[contract.full_symbol] = contract def process_strategycontrol_event(self, event: Event): msgtype = event.msg_type deslist = ['@*', str(self.id), '@' + str(self.id)] if (event.destination not in deslist): return elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_STATUS): m = Event(type=EventType.STRATEGY_CONTROL, des='@0', src=str(self.id), msgtype=MSG_TYPE.MSG_TYPE_STRATEGY_STATUS ) self._send_sock.send(m.serialize()) # elif (event.destination not in deslist ) : # return elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_ADD): v = event.data.split('|') classname = v[0] strname = v[1] fulsym = v[2] setting = json.loads(v[3]) self.add_strategy(classname, strname, fulsym, setting) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_INIT): self.init_strategy(event.data) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_INIT_ALL): self.init_all_strategies() elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_START): self.start_strategy(event.data) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_START_ALL): self.start_all_strategies() elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_STOP): self.stop_strategy(event.data) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_STOP_ALL): self.stop_all_strategies() elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_RELOAD): self.classes.clear() self.load_strategy_class(True) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_RESET): self.reset_strategy(event.data) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_RESET_ALL): self.reset_all_strategies() elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_EDIT): v = event.data.split('|') setting = json.loads(v[1]) self.edit_strategy(v[0], setting) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_REMOVE): if self.remove_strategy(event.data): m = Event(type=EventType.STRATEGY_CONTROL, data=event.data, des='@0', src=str(self.id), msgtype=MSG_TYPE.MSG_TYPE_STRATEGY_RTN_REMOVE ) self._send_sock.send(m.serialize()) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_REMOVE_DUPLICATE): self.remove_strategy(event.data, True) elif (msgtype == MSG_TYPE.MSG_TYPE_STRATEGY_GET_DATA): # print('begin get data') if event.data: strategy = self.strategies.get(event.data, None) if strategy: self.put_strategy_event(strategy) else: # get all strategy data for strategy in self.strategies.values(): self.put_strategy_event(strategy) def call_strategy_func( self, strategy: StrategyBase, func: Callable, params: Any = None ): """ Call function of a strategy and catch any exception raised. """ try: if params: func(params) else: func() except Exception: strategy.trading = False strategy.inited = False msg = f"触发异常已停止\n{traceback.format_exc()}" self.write_log(msg, strategy) # strategy manage def add_strategy( self, class_name: str, strategy_name: str, full_symbol: str, setting: dict ): """ Add a new strategy. """ print("begin add strategy") if strategy_name in self.strategies: self.write_log(f"创建策略失败,存在重名{strategy_name}") return if class_name not in self.classes: self.write_log( f'strategy class[{class_name}] not exist, please check') return strategy_class = self.classes[class_name] strategy = strategy_class(self, strategy_name, full_symbol, setting) self.strategies[strategy_name] = strategy # Add full_symbol to strategy map. strategies = self.symbol_strategy_map[full_symbol] strategies.append(strategy) # print("335 add strategy") # Update to setting file. self.update_strategy_setting(strategy_name, setting) self.put_strategy_event(strategy) print("end add strategy") def init_strategy(self, strategy_name: str): """ Init a strategy. """ self.init_queue.put(strategy_name) if not self.init_thread: self.init_thread = Thread(target=self._init_strategy) self.init_thread.start() def _init_strategy(self): """ Init strategies in queue. """ while not self.init_queue.empty(): strategy_name = self.init_queue.get() strategy = self.strategies[strategy_name] if strategy.inited: self.write_log(f"{strategy_name}已经完成初始化,禁止重复操作") continue self.write_log(f"{strategy_name}开始执行初始化") # Call on_init function of strategy self.call_strategy_func(strategy, strategy.on_init) # Restore strategy data(variables) data = self.strategy_data.get(strategy_name, None) if data: for name in strategy.variables: value = data.get(name, None) if value: setattr(strategy, name, value) # Subscribe market data contract = self.get_contract(strategy.full_symbol) if contract: m = Event(type=EventType.SUBSCRIBE, msgtype=MSG_TYPE.MSG_TYPE_SUBSCRIBE_MARKET_DATA) m.destination = "CTP.MD" m.source = str(self.id) req = SubscribeRequest() req.sym_type = SYMBOL_TYPE.CTP req.content = contract.symbol m.data = req self._send_sock.send(m.serialize()) else: self.write_log(f"行情订阅失败,找不到合约{strategy.full_symbol}", strategy) # qry pos and acc m = Event(type=EventType.QRY, msgtype=MSG_TYPE.MSG_TYPE_QRY_POS) m.destination = strategy.api + '.' + strategy.account m.source = str(self.id) self._send_sock.send(m.serialize()) m = Event(type=EventType.QRY, msgtype=MSG_TYPE.MSG_TYPE_QRY_ACCOUNT) m.destination = strategy.api + '.' + strategy.account m.source = str(self.id) self._send_sock.send(m.serialize()) # Put event to update init completed status. strategy.inited = True self.put_strategy_event(strategy) self.write_log(f"{strategy_name}初始化完成") self.init_thread = None def start_strategy(self, strategy_name: str): """ Start a strategy. """ strategy = self.strategies[strategy_name] if not strategy.inited: self.write_log(f"策略{strategy.strategy_name}启动失败,请先初始化") return if strategy.trading: self.write_log(f"{strategy_name}已经启动,请勿重复操作") return # qry pos and acc m = Event(type=EventType.QRY, msgtype=MSG_TYPE.MSG_TYPE_QRY_POS) m.destination = strategy.api + '.' + strategy.account m.source = str(self.id) self._send_sock.send(m.serialize()) m = Event(type=EventType.QRY, msgtype=MSG_TYPE.MSG_TYPE_QRY_ACCOUNT) m.destination = strategy.api + '.' + strategy.account m.source = str(self.id) self._send_sock.send(m.serialize()) self.call_strategy_func(strategy, strategy.on_start) strategy.trading = True self.put_strategy_event(strategy) def stop_strategy(self, strategy_name: str): """ Stop a strategy. """ strategy = self.strategies[strategy_name] if not strategy.trading: return # Call on_stop function of the strategy self.call_strategy_func(strategy, strategy.on_stop) # Change trading status of strategy to False strategy.trading = False # Cancel all orders of the strategy self.cancel_all(strategy) # Update GUI self.put_strategy_event(strategy) def reset_strategy(self, strategy_name: str): "Reset a strategy" strategy = self.strategies[strategy_name] if not strategy.inited: return # stop first self.call_strategy_func(strategy, strategy.on_stop) strategy.trading = False self.cancel_all(strategy) # reset self.call_strategy_func(strategy, strategy.on_reset) strategy.inited = False self.put_strategy_event(strategy) def edit_strategy(self, strategy_name: str, setting: dict): """ Edit parameters of a strategy. """ strategy = self.strategies[strategy_name] strategy.update_setting(setting) self.update_strategy_setting(strategy_name, setting) self.put_strategy_event(strategy) def remove_strategy(self, strategy_name: str, duplicate: bool = False): """ Remove a strategy. """ print("begin remove") strategy = self.strategies[strategy_name] if strategy.trading: self.write_log(f"策略{strategy.strategy_name}移除失败,请先停止") return # Remove setting if not duplicate: self.remove_strategy_setting(strategy_name) # Remove from symbol strategy map strategies = self.symbol_strategy_map[strategy.full_symbol] strategies.remove(strategy) # Remove from active orderid map if strategy_name in self.strategy_orderid_map: orderids = self.strategy_orderid_map.pop(strategy_name) # Remove vt_orderid strategy map for _orderid in orderids: if _orderid in self.orderid_strategy_map: self.orderid_strategy_map.pop(_orderid) # Remove from strategies self.strategies.pop(strategy_name) print("end remove") return True def load_strategy_class(self, reload: bool = False): """ Load strategy class from source code. """ # app_path = Path(__file__).parent.parent # path1 = app_path.joinpath("cta_strategy", "strategies") # self.load_strategy_class_from_folder( # path1, "vnpy.app.cta_strategy.strategies") path2 = Path.cwd().joinpath("mystrategy") self.load_strategy_class_from_folder(path2, "", reload) def load_strategy_class_from_folder(self, path: Path, module_name: str = "", reload: bool = False): """ Load strategy class from certain folder. """ for dirpath, dirnames, filenames in os.walk(path): for filename in filenames: if filename.endswith(".py"): strategy_module_name = "mystrategy.".join( [module_name, filename.replace(".py", "")]) self.load_strategy_class_from_module( strategy_module_name, reload) def load_strategy_class_from_module(self, module_name: str, reload: bool = False): """ Load strategy class from module file. """ try: module = importlib.import_module(module_name) # if reload delete old attribute if reload: for attr in dir(module): if attr not in ('__name__', '__file__'): delattr(module, attr) importlib.reload(module) for name in dir(module): value = getattr(module, name) if (isinstance(value, type) and issubclass(value, CtaTemplate) and value is not CtaTemplate): self.classes[value.__name__] = value except: # noqa msg = f"策略文件{module_name}加载失败,触发异常:\n{traceback.format_exc()}" self.write_log(msg) def load_strategy_data(self): """ Load strategy data from json file. """ self.strategy_data = load_json(self.data_filename) def sync_strategy_data(self, strategy: StrategyBase): """ Sync strategy data into json file. """ data = strategy.get_variables() # Strategy status (inited, trading) should not be synced. data.pop("inited") data.pop("trading") self.strategy_data = load_json(self.data_filename) self.strategy_data[strategy.strategy_name] = data save_json(self.data_filename, self.strategy_data) def get_all_strategy_class_names(self): """ Return names of strategy classes loaded. """ return list(self.classes.keys()) def get_strategy_class_parameters(self, class_name: str): """ Get default parameters of a strategy class. """ strategy_class = self.classes[class_name] parameters = {} for name in strategy_class.parameters: parameters[name] = getattr(strategy_class, name) return parameters def get_strategy_parameters(self, strategy_name): """ Get parameters of a strategy. """ strategy = self.strategies[strategy_name] return strategy.get_parameters() def init_all_strategies(self): """ """ for strategy_name in self.strategies.keys(): self.init_strategy(strategy_name) def start_all_strategies(self): """ """ for strategy_name in self.strategies.keys(): self.start_strategy(strategy_name) def stop_all_strategies(self): """ """ for strategy_name in self.strategies.keys(): self.stop_strategy(strategy_name) def reset_all_strategies(self): for strategy_name in self.strategies.keys(): self.reset_strategy(strategy_name) def load_strategy_setting(self): """ Load setting file. """ self.strategy_setting = load_json(self.setting_filename) for strategy_name, strategy_config in self.strategy_setting.items(): self.add_strategy( strategy_config["class_name"], strategy_name, strategy_config["full_symbol"], strategy_config["setting"] ) def update_strategy_setting(self, strategy_name: str, setting: dict): """ Update setting file. """ strategy = self.strategies[strategy_name] # in order to save other engine's setting, should load again self.strategy_setting = load_json(self.setting_filename) self.strategy_setting[strategy_name] = { "class_name": strategy.__class__.__name__, "full_symbol": strategy.full_symbol, "setting": setting, } save_json(self.setting_filename, self.strategy_setting) def remove_strategy_setting(self, strategy_name: str): """ Update setting file. """ if strategy_name not in self.strategy_setting: return # in order to save other engine's setting, should load again self.strategy_setting = load_json(self.setting_filename) self.strategy_setting.pop(strategy_name) save_json(self.setting_filename, self.strategy_setting) # def put_stop_order_event(self, stop_order: StopOrder): # """ # Put an event to update stop order status. # """ # event = Event(EVENT_CTA_STOPORDER, stop_order) # self.event_engine.put(event) def put_strategy_event(self, strategy: StrategyBase): """ Put an event to update strategy status. """ data = strategy.get_data() sdata = {} sdata[strategy.strategy_name] = data # event = Event(EVENT_CTA_STRATEGY, data) # self.event_engine.put(event) msg = json.dumps(sdata) m = Event(type=EventType.STRATEGY_CONTROL, data=msg, des='@0', src=str( self.id), msgtype=MSG_TYPE.MSG_TYPE_STRATEGY_RTN_DATA) self._send_sock.send(m.serialize()) #save_json(self.data_filename, sdata) # strategy functions #get ,qry def query_bar_from_rq( self, symbol: str, exchange: Exchange, interval: Interval, start: datetime, end: datetime ): """ Query bar data from RQData. """ data = rqdata_client.query_bar( symbol, exchange, interval, start, end ) return data def load_bar( self, full_symbol: str, days: int, interval: Interval, callback: Callable[[BarData], None], datasource: str = 'DataBase' ): """""" tradedays = abs(days) weekday = datetime.now().weekday() adddays = 2 if (days - weekday > 0) else 0 if weekday == 6: tradedays = days + 1 else: tradedays = days + adddays symbol, exchange = extract_full_symbol(full_symbol) end = datetime.now() start = end - timedelta(days=tradedays) # Query bars from RQData by default, if not found, load from database. bars = self.query_bar_from_rq(symbol, exchange, interval, start, end) if not bars: bars = database_manager.load_bar_data( symbol=symbol, exchange=exchange, interval=interval, start=start, end=end, ) for bar in bars: callback(bar) def load_tick(self, full_symbol: str, days: int, callback: Callable, datasource: str = 'DataBase'): tradedays = abs(days) weekday = datetime.now().weekday() adddays = 2 if (days - weekday > 0) else 0 if weekday == 6: tradedays = days + 1 else: tradedays = days + adddays symbol, exchange = extract_full_symbol(full_symbol) end = datetime.now() start = end - timedelta(tradedays) ticks = database_manager.load_tick_data(symbol, exchange, start, end) for tick in ticks: callback(tick) def get_tick(self, full_symbol): """ Get latest market tick data by full_symbol. """ return self.ticks.get(full_symbol, None) def get_order(self, orderid: int): """ Get latest order data by orderid. """ return self.orders.get(orderid, None) def get_trade(self, vt_tradeid): """ Get trade data by vt_tradeid. """ return self.trades.get(vt_tradeid, None) def get_position(self, key): """ Get latest position data by vt_positionid. """ return self.positions.get(key, None) def get_account(self, accountid): """ Get latest account data by accountid. """ return self.accounts.get(accountid, None) def get_contract(self, full_symbol): """ Get contract data by full_symbol. """ return self.contracts.get(full_symbol, None) def get_all_ticks(self): """ Get all tick data. """ return list(self.ticks.values()) def get_all_orders(self): """ Get all order data. """ return list(self.orders.values()) def get_all_trades(self): """ Get all trade data. """ return list(self.trades.values()) def get_all_positions(self): """ Get all position data. """ return list(self.positions.values()) def get_all_accounts(self): """ Get all account data. """ return list(self.accounts.values()) def get_all_contracts(self): """ Get all contract data. """ return list(self.contracts.values()) def get_all_active_orders(self, full_symbol: str = ""): """ Get all active orders by full_symbol. If full_symbol is empty, return all active orders. """ if not full_symbol: return list(self.active_orders.values()) else: active_orders = [ order for order in self.active_orders.values() if order.full_symbol == full_symbol ] return active_orders def get_position_holding(self, acc: str, full_symbol: str): return self.offset_converter.get_position_holding(acc, full_symbol) def get_strategy_active_orderids(self, strategy_name: str): oidset = self.strategy_orderid_map[strategy_name] return oidset #order, cancel def send_order( self, strategy: StrategyBase, original_req: OrderRequest, lock: bool = False ): """ Send a new order to server. """ # Convert with offset converter req_list = self.offset_converter.convert_order_request( original_req, lock) # Send Orders orderids = [] for req in req_list: req.clientID = self.id req.client_order_id = self.ordercount self.ordercount += 1 m = Event(type=EventType.ORDER, data=req, des=req.api + '.' + req.account, src=str(self.id) ) if req.api == "CTP.TD": m.msg_type = MSG_TYPE.MSG_TYPE_ORDER_CTP elif req.api == "PAPER.TD": m.msg_type = MSG_TYPE.MSG_TYPE_ORDER_PAPER else: print("error:api not support!") return [] msg = m.serialize() print(f'tradeclient {self.id} send msg: {msg}') self._send_sock.send(msg) orderids.append(req.client_order_id) self.offset_converter.update_order_request(req) # Save relationship between orderid and strategy. self.orderid_strategy_map[req.client_order_id] = strategy self.strategy_orderid_map[strategy.strategy_name].add( req.client_order_id) return orderids def cancel_order(self, strategy: StrategyBase, orderid: int): """ Cancel existing order by orderid. """ order = self.get_order(orderid) if not order: self.write_log(f"撤单失败,找不到委托{orderid}", strategy) return req = order.create_cancel_request() m = Event(type=EventType.CANCEL, data=req, des=order.api + '.' + order.account, src=str(self.id), msgtype=MSG_TYPE.MSG_TYPE_ORDER_ACTION ) msg = m.serialize() print(f'tradeclient {self.id} send msg: {msg}') self._send_sock.send(msg) def cancel_all(self, strategy: StrategyBase): """ Cancel all active orders of a strategy. """ orderids = self.strategy_orderid_map[strategy.strategy_name] if not orderids: print(strategy.strategy_name, 'has no active order') return for orderid in copy(orderids): print('cancel oid:', orderid) self.cancel_order(strategy, orderid) def send_testmsg(self): m = Event(des='CTP.MD', src=str(self.id), msgtype=MSG_TYPE.MSG_TYPE_TEST) msg = m.serialize() self._send_sock.send(msg) print(f'tradeclient {self.id} send msg: {msg}') # start and stop def start(self, timer=True): """ start the dispatcher thread and begin to recv msg through nng """ self.event_engine.start() print('tradeclient started ,pid = %d ' % os.getpid()) self.__active = True while self.__active: try: msgin = self._recv_sock.recv(flags=0) msgin = msgin.decode("utf-8") if msgin is not None and msgin.index('|') > 0: if msgin[0] == '@': print('tradeclient(pid = %d) rec @ msg:' % (self.id), msgin, 'at ', datetime.now()) if msgin[-1] == '\0': msgin = msgin[:-1] if msgin[-1] == '\x00': msgin = msgin[:-1] m = Event() m.deserialize(msgin) self.event_engine.put(m) except Exception as e: pass #print("TradeEngineError {0}".format(str(e.args[0])).encode("utf-8")) def stop(self): """ stop """ self.__active = False self.event_engine.stop() def put(self, event): """ send event msg,TODO:check the event """ # self._send_sock.send(event.serialize(), flags=1) def register_handler(self, type_, handler): """ register handler/subscriber """ # self.event_engine.register(type_,handler) # handlerList = self._handlers[type_] # if handler not in handlerList: # self._handlers[type_].append(handler) # #handlerList.append(handler) pass def unregister_handler(self, type_, handler): """ unregister handler/subscriber """ # handlerList = self._handlers[type_] # if handler in handlerList: # self._handlers.remove(handler) # if not handlerList: # del self._handlers[type_] pass def write_log(self, msg: str, strategy: StrategyBase = None): """ Create engine log event. """ # if strategy: # msg = f"{strategy.strategy_name}: {msg}" # log = LogData(msg=msg, gateway_name="CtaStrategy") # event = Event(type=EVENT_CTA_LOG, data=log) # self.event_engine.put(event) print(msg)
class ClientMq(object): def __init__(self, ui_event_engine, outgoing_quue): self._ui_event_engine = ui_event_engine self._outgoing_quue = outgoing_quue self._tick_sock = Socket(SUB) self._msg_sock = Socket(PAIR) self._active = False self._thread = Thread(target=self._run) def _run(self): while self._active: try: msg1 = self._tick_sock.recv(flags=1) msg1 = msg1.decode("utf-8") if msg1 is not None and msg1.index('|') > 0: if msg1[-1] == '\0': msg1 = msg1[:-1] k = TickEvent() k.deserialize(msg1) self._ui_event_engine.put(k) except Exception as e: pass try: msg2 = self._msg_sock.recv(flags=1) msg2 = msg2.decode("utf-8") if msg2 is not None and msg2.index('|') > 0: if msg2[-1] == '\0': msg2 = msg2[:-1] if msg2[-1] == '\x00': msg2 = msg2[:-1] v = msg2.split('|') if v[0] == 's': m = OrderStatusEvent() m.deserialize(msg2) self._ui_event_engine.put(m) elif v[0] == 'f': m = FillEvent() m.deserialize(msg2) self._ui_event_engine.put(m) elif v[0] == 'n': m = PositionEvent() m.deserialize(msg2) self._ui_event_engine.put(m) elif v[0] == 'h': m = HistoricalEvent() m.deserialize(msg2) self._ui_event_engine.put(m) elif v[0] == 'u': m = AccountEvent() m.deserialize(msg2) self._ui_event_engine.put(m) elif v[0] == 'r': m = ContractEvent() m.deserialize(msg2) self._ui_event_engine.put(m) elif v[0] == 'm': m = GeneralEvent() m.deserialize(msg2) self._ui_event_engine.put(m) pass except Exception as e: pass # print('PAIR error: '+ str(i) + '' + str(e)); # time.sleep(1) try: msg3 = self._outgoing_quue.get(False) self._msg_sock.send(msg3, flags=1) except Exception as e: pass def start(self, timer=True): """ start the mq thread """ self._tick_sock.connect('tcp://127.0.0.1:55555') self._tick_sock.set_string_option(SUB, SUB_SUBSCRIBE, '') # receive msg start with all self._msg_sock.connect('tcp://127.0.0.1:55558') self._active = True if not self._thread.isAlive(): self._thread.start() def stop(self): """ stop the mq thread """ self._active = False if self._thread.isAlive(): self._thread.join()
# vim: set fileencoding=utf-8 from nanomsg import Socket, PUSH from time import sleep URL = "ipc:///tmp/example2" socket = Socket(PUSH) print("Socket created") socket.connect(URL) print("Connected to URL {}".format(URL)) for i in range(10): socket.send("Hello world #{}".format(i + 1)) print("Message has been sent") sleep(0.1) socket.close() print("Socket closed")
from __future__ import print_function from nanomsg import Socket, PAIR, PUB import time s1 = Socket(PAIR) s1.bind('ipc:///tmp/wand1.ipc') while (True): kkk = "hello world!" print(kkk) s1.send(kkk) time.sleep(1) s1.close()
class Daemon(Common): change_funcs = set() bg_tasks = [] def __init__(self, state, logs, worker_class): self.state = state self.logs = logs self.worker_class = worker_class self.sock = Socket(REP) self.sock.bind('inproc://server') self.sock.bind('ipc://socket') self.results = {} self.threads = {} self.running = True self.change_lock = Lock() self.id_gen = iter(range(10000000)).next self.init() def init(self): pass def recv(self): msg = self.sock.recv() #print "Received", self.load(msg) return self.load(msg) def send(self, *args): msg = self.dump(*args) return self.sock.send(msg) def run(self): t = Thread(target=self._bg) t.start() t = Thread(target=self._run) t.start() return t def _bg(self): sock = Socket(REQ) sock.connect('inproc://server') while self.running: for func in self.bg_tasks: msg = self.dump((func, [])) sock.send(msg) self.load(sock.recv()) time.sleep(10) def handle_result(self, id, result): print "Got result id=%r result=%r" % (id, result) self.results[id] = result self.send("ok") def handle_setstate(self, key, value): print "Set state key=%r value=%r" % (key, value) self.state.set(key, value) self.send("ok") def handle_getstate(self, key): value = self.state.get(key) print "Get state key=%r value=%r" % (key, value) self.send(value) def handle_out(self, id, txt): print "Got %s id=%r result=%r" % ('out', id, txt) self.logs.append(id, 'out', txt) self.send("ok") def handle_err(self, id, txt): print "Got %s id=%r result=%r" % ('err', id, txt) self.logs.append(id, 'err', txt) self.send("ok") def handle_getresult(self, id): result = self.results.get(id) if result: del self.results[id] del self.threads[id] print "sending result=%r for id=%r" % (result, id) self.send(result) def handle_getlog(self, id, since): result = self.logs.get(id, since) print "sending log=%r for id=%r" % (result, id) self.send(result) def _run(self): while self.running: (cmd, args) = self.recv() func = getattr(self, 'handle_' + cmd, None) if func: func(*args) continue t_id, t = self.spawn_worker(cmd, args) self.send(t_id) self.threads[t_id] = t print "started thread for id=%r func=%r args=%r" % (t_id, func, args) def spawn_worker(self, cmd, args): t_id = self.id_gen() target = lambda: self.wrap(t_id, cmd, args) t = Thread(target=target) t.start() return t_id, t def wrap(self, id, cmd, args): if cmd in self.change_funcs: self.change_lock.acquire() try: w = self.worker_class(id) func = getattr(w, cmd, w.noop) if hasattr(func, 'api_exposed'): try: res = func(*args) except Exception, e: res = repr(e) else:
server_sock.bind('ipc://nanopushpull.bin') client_proc_list = [] for i in range(client_count): client_proc_list.append( subprocess.Popen(['python', 'nanopullclnt.py', '-cn', str(i + 1)])) # Give client processes time to start, otherwise the ones starting first will # get hit with a big chunk of the messages (which may not be a bad thing) sleep(1) for n in range(message_count): sent = False while not sent: try: server_sock.send(b'msg %d' % (n), DONTWAIT) sys.stdout.write('!') sys.stdout.flush() sent = True except: # Seems like no clients are currently connnected sys.stdout.write('.') sys.stdout.flush() for client_proc in client_proc_list: poll = client_proc.poll() while poll is None: sleep(1) poll = client_proc.poll() print("...finis...") server_sock.close()
class PubHandler(logging.Handler): """ A basic logging handler that emits log messages through a PUB socket. Takes a PUB socket already bound to interfaces or an interface to bind to. Example:: sock = context.socket(PUB) sock.bind("inproc://log") handler = PUBHandler(sock) Or:: handler = PUBHandler("inproc://log") These are equivalent. Log messages handled by this handler are broadcase with nanomsg PUB/SUB model. """ dayfmt = '%Y %m %d %H:%M:%S' formatters = { logging.DEBUG: EncodingFormatter( "%(asctime)-15s %(name)s.%(levelname)s " + # "in %(module)s [%(pathname)s:%(lineno)d]" + "- %(message)s\n", dayfmt), logging.INFO: EncodingFormatter( "%(asctime)-15s %(name)s.%(levelname)s " + # "in %(module)s [%(pathname)s:%(lineno)d]" + "- %(message)s\n", dayfmt), logging.WARN: EncodingFormatter( "%(asctime)-15s %(name)s.%(levelname)s " + # "in %(module)s [%(pathname)s:%(lineno)d]" + "- %(message)s\n", dayfmt), logging.ERROR: EncodingFormatter( "%(asctime)-15s %(name)s.%(levelname)s " + # "in %(module)s [%(pathname)s:%(lineno)d]" + "- %(message)s - %(exc_info)s\n", dayfmt), logging.CRITICAL: EncodingFormatter( "%(asctime)-15s %(name)s.%(levelname)s " + # "in %(module)s [%(pathname)s:%(lineno)d]" + "- %(message)s\n", dayfmt), } def __init__(self, pub_addr): logging.Handler.__init__(self) self.sock = Socket(PUB) self.sock.connect(pub_addr) log_level = logging.DEBUG self.setFormatter(PubHandler.formatters[log_level]) def emit(self, record): """ Emit a log message on nanomsg pub/sub model. """ #TODO is send asynchronous ? try: self.sock.send(self.format(record)) except (KeyboardInterrupt, SystemExit): raise except: self.handleError(record) def colse(self): self.sock.close() logging.Handler.close(self) def __del__(self): self.sock.close()