def iogate(type, queuein=Queue.Queue(), queueout=Queue.Queue(), network={}): sock = Socket(network['type']) if type == 'in': for port in network['ports']: sock.bind('tcp://0.0.0.0:{port}'.format(port=port)) elif type == 'out': for node in network['nodes']: sock.connect('tcp://{ip}:{port}'.format(ip=node['ip'], port=node['port'])) def receive_messages(): while True: queuein.put({'socket':in_sock, 'data': in_sock.recv()}) print("Message received") def send_messages(): while True: sock.send(queueout.get(block=True)) print("Message has been sent") receiver = threading.Thread(target=receive_messages) sender = threading.Thread(target=send_messages) receiver.start() sender.start() return (queuein, queueout)
def iogate(type, queuein=Queue.Queue(), queueout=Queue.Queue(), network={}): sock = Socket(network['type']) if type == 'in': for port in network['ports']: sock.bind('tcp://0.0.0.0:{port}'.format(port=port)) elif type == 'out': for node in network['nodes']: sock.connect('tcp://{ip}:{port}'.format(ip=node['ip'], port=node['port'])) def receive_messages(): while True: queuein.put({'socket': in_sock, 'data': in_sock.recv()}) print("Message received") def send_messages(): while True: sock.send(queueout.get(block=True)) print("Message has been sent") receiver = threading.Thread(target=receive_messages) sender = threading.Thread(target=send_messages) receiver.start() sender.start() return (queuein, queueout)
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 _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 _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 test_image_logging(): proc = wake_up_maya(start_position=None, constraints_for_training=None) socket = Socket(SUB) socket.set_string_option(SUB, SUB_SUBSCRIBE, b"image") socket.connect(FLAGS.log_port_image) image = socket.recv() ts, image = parse_image(image) tf.logging.info("ts: %s image shape: %s" % (ts, image.shape)) maya_to_sleep(proc)
def test_lidar_logging(): proc = wake_up_maya(start_position=None, constraints_for_training=None) socket = Socket(SUB) socket.set_string_option(SUB, SUB_SUBSCRIBE, b"lidar") socket.connect(FLAGS.log_port_lidar) lidar = socket.recv() ts, point_cloud = parse_lidar_data(lidar) tf.logging.info("timestamp: %s, point cloud: %s" % (ts, point_cloud)) maya_to_sleep(proc)
def test_hd_map_logging(): proc = wake_up_maya(start_position=None, constraints_for_training=None) socket = Socket(SUB) socket.set_string_option(SUB, SUB_SUBSCRIBE, b"hd_map") socket.connect(FLAGS.log_port_hd_map) hd_map = socket.recv() my_hd_map = parse_hd_map(hd_map) tf.logging.info("%s" % my_hd_map) maya_to_sleep(proc)
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 connect(): sock = Socket(PAIR) try: sock.connect(IPC_ADDRESS) sock.send_timeout = 10000 sock.recv_timeout = 10000 except Exception as e: logger.error( "Failed to connect to address '%s' (%s)", IPC_ADDRESS, e) sock.close() raise SystemExit(1) return sock
class StreamClient(CaptureSource): def __init__(self, server_addr, direction): super().__init__(direction + '_stream') self.server_addr = 'tcp://{}:8081'.format(server_addr) self.sock = Socket(SUB) self.sock.connect(self.server_addr) self.sock.set_string_option(SUB, SUB_SUBSCRIBE, '') print('Started streaming capture source {} from {}'.format( self.direction, self.server_addr)) def acquire_next_image(self): img = unpack_image(self.sock.recv()) return img, time.time()
class TestGeneralSocketMethods(unittest.TestCase): def setUp(self): self.socket = Socket(PAIR) def tearDown(self): self.socket.close() def test_bind(self): endpoint = self.socket.bind(SOCKET_ADDRESS) self.assertNotEqual(None, endpoint) def test_connect(self): endpoint = self.socket.connect(SOCKET_ADDRESS) self.assertNotEqual(None, endpoint) def test_is_open_is_true_when_open(self): self.assertTrue(self.socket.is_open()) def test_is_open_is_false_when_closed(self): self.socket.close() self.assertFalse(self.socket.is_open()) def test_set_and_get_int_option(self): expected = 500 self.socket.set_int_option(SOL_SOCKET, SNDBUF, expected) actual = self.socket.get_int_option(SOL_SOCKET, SNDBUF) self.assertEqual(expected, actual)
class NanomsgSubscriber(HiddenSubscriber): """ Subscriber class subscribing to a certain topic Attributes: context (zmq.Context): socket (Socket): Socket object of ZMQ context topic (String): Topic subscriber subscribes to """ def __init__(self, url, topic): """ Initializes object Args: url (String): url to publish messages to topic (String): Topic to publish messages under """ super(NanomsgSubscriber, self).__init__(topic) self._socket = Socket(SUB) self._socket.recv_timeout = 500 # Wait 500ms for receiving msgs self._socket.connect(url) self._socket.set_string_option(SUB, SUB_SUBSCRIBE, topic + '|') self._logger = logging.getLogger('NanomsgSubscriber') def receive(self): """ Receives a message Returns: String """ message = self._socket.recv() return message[len(self.topic) + 1:] def __enter__(self): """ Statement used for the `` with ... as ...:`` returns the object to use in the ``with`` block Returns: NanomsgSubscriber """ 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()
def sender(queue, network, stype=PUSH): out_sock = Socket(stype) for node in network['nodes']: print('tcp://{ip}:{port}'.format(ip=node['ip'], port=node['port'])) out_sock.connect('tcp://{ip}:{port}'.format(ip=node['ip'], port=node['port'])) def send_messages(): while True: out_sock.send(queue.get(block=True)) print("Message has been sent") receiver = threading.Thread(target=send_messages) receiver.start() return out_sock
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
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
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)
def main(): sift_root = init.env_var_or_exit('SIFT_ROOT') ipc_root = init.env_var_or_exit('IPC_ROOT') dag = load_dag(sift_root) threads = {} sockets = [] node_indexes = sys.argv[1:] if len(node_indexes) == 0: print('no nodes to execute') return 1 dry = os.environ.get('DRY', 'false') if dry == 'true': return 0 for i in map(int, node_indexes): src = os.path.join(sift_root, dag['dag']['nodes'][i]['implementation']['python']) print('loading ' + src) m = new_module(i, src) # Create nanomsg socket. addr = 'ipc://%s/%d.sock'% (ipc_root, i) s = Socket(REP) s.recv_max_size = -1 s.connect(addr) print('connected to '+ addr) sockets.append(s) # Launch request handler. t = threading.Thread(target=listen_and_reply, args=(s, m.compute)) t.daemon = True t.start() threads[i] = t try: while True: time.sleep(1) for i, thr in threads.items(): if not thr.isAlive(): raise Exception('thread of node with index %d is dead' % i) finally: print('closing sockets') for s in sockets: s.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 LogSub(QThread): def __init__(self, url): self.socket = Socket(SUB) self.url = url self.handlers = [] super().__init__() def register_handler(self, handler): self.handlers.append(handler) def run(self): self.socket.set_string_option(SUB, SUB_SUBSCRIBE, b'') self.socket.connect(self.url) while True: try: msg = self.socket.recv() msg_pack = msgpack.unpackb(msg, encoding='utf-8') for h in self.handlers: h(**msg_pack) except nanomsg.NanoMsgAPIError as e: raise
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()
def sender(queue, addresses, stype): """ Bind a queue to a connecting nanomsg socket's multiple endpoints in a separate thread. Parameters ---------- queue : Queue A Queue object to be emptied by sender socket addresses : list A list of strings of format '<protocol>://<ip>:<port>' to bind to stype : int One of the nanomsg scalability socket types: PUSH, PULL, PUB, SUB, PAIR Returns ------- nanomsg socket object """ with err.applicationbound(): out_sock = Socket(stype) out_sock.set_int_option(SOL_SOCKET, SNDTIMEO, 1000) for address in addresses: endpoint = out_sock.connect(address) out_endpoints.append(endpoint) def send_messages(): """ """ while True: try: out_sock.send(queue.get(block=True)) log.info("Message has been sent") except NanoMsgAPIError as e: log.debug(e) log.debug(dir(e)) receiver = threading.Thread(target=send_messages) receiver.start() return out_sock
def sender(queue, network, stype=PUSH): out_sock = Socket(stype) out_sock.set_int_option(SOL_SOCKET, SNDTIMEO, 1000) for node in network['nodes']: endpoint = out_sock.connect('tcp://{ip}:{port}'.format( ip=node['ip'], port=node['port'])) out_endpoints.append(endpoint) def send_messages(): while True: try: out_sock.send(queue.get(block=True)) print("Message has been sent") except NanoMsgAPIError as e: print(e) print(dir(e)) receiver = threading.Thread(target=send_messages) receiver.start() return out_sock
def sender(queue, network, stype=PUSH): out_sock = Socket(stype) out_sock.set_int_option(SOL_SOCKET, SNDTIMEO, 1000) for node in network['nodes']: endpoint = out_sock.connect('tcp://{ip}:{port}'.format(ip=node['ip'], port=node['port'])) out_endpoints.append(endpoint) def send_messages(): while True: try: out_sock.send(queue.get(block=True)) print("Message has been sent") except NanoMsgAPIError as e: print(e) print(dir(e)) receiver = threading.Thread(target=send_messages) receiver.start() return out_sock
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()
class ClientMq(object): def __init__(self, event_engine): self._event_engine = event_engine 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] m = GeneralEvent() m.content = msg2 self._event_engine.put(m) except Exception as e: pass # print('PAIR error: '+ str(i) + '' + str(e)); # time.sleep(1) 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()
import ctypes from ctypes import * ll = ctypes.cdll.LoadLibrary lib = ll("/usr/local/lib64/libnanomsg.so.1.0.0") from nanomsg import Socket, PAIR, PUB from tornado.log import app_log import time import ctypes import json import time start = time.clock() s2 = Socket(PAIR) s2.connect('ipc:///tmp/pp.ipc') def test1(op): for i in range(10): time.sleep(3) op.send('bbb', 'hello world') def test2(op): stock_map = { 'aapl': 100.0, 'wbai': 20.0, 'goog': 165.0, 'baid': 144.0, 'jd': 33.0,
class NodeEditor: def __init__(self, mouse, gltext, conf): self.conf = conf self.mouse = mouse # TODO: use a special mouse object instead of the editor_main object directly. self.gltext = gltext self.nodes = [] self.links = [] self.nodes_dict = {} # integers. 16-bit node addresses self.links_dict = {} # a pair of node objects. (node1, node2) is equivalent to (node2, node1), but only one pair exists in links_dict self.mouse_hover = False self.mouse_dragging = False self.selected = None self.selected_pos_ofs = vector.Vector() h = 0. # 10 cm from the ground. nnope. for now, h has to be 0. r = 1. for i in range(10): a = float(i) / (r + 10) * 15. x, y = r * math.sin(a), r * math.cos(a) r += 0.5 n = Node( vector.Vector((x, h, y)), i + 1, self._get_node_color(i+1), gltext ) self.append_node(n) # n = Node( vector.Vector((0., h, 0.)), 1, gltext ); self.append_node(n) # n = Node( vector.Vector((1., h, 0.)), 2, gltext ); self.append_node(n) # n = Node( vector.Vector((2., h, -1.)), 3, gltext ); self.append_node(n) # n = Node( vector.Vector((-2., h, 2.)), 4, gltext ); self.append_node(n) # n = Node( vector.Vector((-1., h, 2.)), 5, gltext ); self.append_node(n) # n = Node( vector.Vector((-2., h, 1.)), 6, gltext ); self.append_node(n) # n = Node( vector.Vector((-1., h, 0.)), 7, gltext ); self.append_node(n) # n = Node( vector.Vector((-1.5, h, -1.)), 8, gltext ); self.append_node(n) # n = Node( vector.Vector((0.5, h, 1.)), 9, gltext ); self.append_node(n) # n = Node( vector.Vector((-1.4, h, 0.5)), 10, gltext ); self.append_node(n) #n.attrs["etx"] = 44 self.s1 = Socket(SUB) self.s1.connect('tcp://127.0.0.1:55555') self.s1.set_string_option(SUB, SUB_SUBSCRIBE, '') def _get_link(self, src_node, dst_node): """ create a new link object if not found from self.links. fill self.links and self.links_dict (the dict both with src_node_id and dst_node_id) """ if (src_node, dst_node) in self.links_dict: return self.links_dict[(src_node, dst_node)] elif (dst_node, src_node) in self.links_dict: return self.links_dict[(dst_node, src_node)] else: link = Link(src_node, dst_node) self.links.append(link) self.links_dict[(src_node, dst_node)] = link return link def _get_node_color(self, origin_node_id): if origin_node_id == 10: return 0.753, 0.753, 0.753, 1. if origin_node_id == 9: return 0.824, 0.412, 0.118, 1. if origin_node_id == 8: return 1.000, 0.000, 1.000, 1. if origin_node_id == 7: return 1.000, 1.000, 0.000, 1. if origin_node_id == 6: return 1.000, 0.627, 0.478, 1. if origin_node_id == 5: return 0.498, 1.000, 0.000, 1. if origin_node_id == 4: return 0.000, 1.000, 1.000, 1. if origin_node_id == 3: return 1.000, 0.922, 0.804, 1. if origin_node_id == 2: return 0.871, 0.722, 0.529, 1. if origin_node_id == 1: return 0.000, 0.749, 1.000, 1. return 0.8, 0.8, 0.8, 1.0 def append_node(self, node): assert node.node_id not in self.nodes_dict self.nodes.append(node) self.nodes_dict[node.node_id] = node def tick(self, dt, keys): for link in self.links: link.tick(dt) for node in self.nodes: node.tick(dt) try: while 1: d = self.s1.recv(flags=DONTWAIT) d = d.strip() if d: if d.startswith("data etx"): # ['data', 'etx', '0001000000000200', 'node', '0A', 'index', '0', 'neighbor', '8', 'etx', '10', 'retx', '74'] d = d.split() #llog.info(d) node_id = int(d[4], 16) # filter out empty rows if int(d[8]) != 0xFFFF: if d[10].startswith("NO_ROUTE"): d[10] = "NO" d[12] = "NO" if int(d[6]) == 0: self.nodes_dict[node_id].attrs["etx_table"] = [] self.nodes_dict[node_id].attrs["etx_table"].append("%s e%s r%s" % (d[8], d[10], d[12])) elif d.startswith("event radiopowerstate"): # ['event', 'radiopowerstate', '0052451410156550', 'node', '04', 'state', '1'] d = d.split() #llog.info(d) node_id = int(d[4], 16) radiopowerstate = int(d[6], 16) self.nodes_dict[node_id].attrs["radiopowerstate"] = radiopowerstate if radiopowerstate: self.nodes_dict[node_id].poke_radio() elif d.startswith("event beacon"): # ['event', 'beacon', '0052451410156550', 'node', '04', 'options', '0x00', 'parent', '0x0003', 'etx', '30'] d = d.split() #llog.info(d) node_id = int(d[4], 16) options = int(d[6], 16) parent = int(d[8], 16) self.nodes_dict[node_id].append_animation(BeaconAnimation(options)) self.nodes_dict[node_id].attrs["parent"] = parent elif d.startswith("event packet_to_activemessage") and 0: # ['event', 'packet', '0000372279297175', 'node', '04', 'dest', '0x1234', 'amid', '0x71'] d = d.split() #llog.info(d) src_node_id = int(d[4], 16) dst_node_id = int(d[6], 16) amid = int(d[8], 16) if dst_node_id != 0xFFFF: # filter out broadcasts src_node = self.nodes_dict[src_node_id] dst_node = self.nodes_dict[dst_node_id] link = self._get_link(src_node, dst_node) link.poke(src_node) elif d.startswith("event send_ctp_packet"): # event send_ctp_packet 0:0:38.100017602 node 0x0003 dest 0x0004 origin 0x0009 sequence 21 type 0x71 thl 5 # event send_ctp_packet 0:0:10.574584572 node 04 dest 0x0003 origin 0x0005 sequence 4 amid 0x98 thl 1 llog.info(d) d = d.split() src_node_id = int(d[4], 16) dst_node_id = int(d[6], 16) origin_node_id = int(d[8], 16) sequence_num = int(d[10]) amid = int(d[12], 16) thl = int(d[14]) src_node = self.nodes_dict[src_node_id] dst_node = self.nodes_dict[dst_node_id] link = self._get_link(src_node, dst_node) link.poke(src_node, packet_color=self._get_node_color(origin_node_id)) elif d.startswith("event packet_to_model_busy"): d = d.split() #llog.info(d) src_node_id = int(d[4], 16) dst_node_id = int(d[6], 16) if dst_node_id != 0xFFFF: # filter out broadcasts src_node = self.nodes_dict[src_node_id] dst_node = self.nodes_dict[dst_node_id] link = self._get_link(src_node, dst_node) link.poke_busy(src_node) elif d.startswith("data ctpf_buf_size"): d = d.split() #llog.info(d) node_id = int(d[4], 16) used = int(d[6]) capacity = int(d[8]) self.nodes_dict[node_id].attrs["ctpf_buf_used"] = used self.nodes_dict[node_id].attrs["ctpf_buf_capacity"] = capacity else: llog.info(d) else: break except NanoMsgAPIError as e: if e.errno != errno.EAGAIN: raise def _render_links_to_parents(self): glLineWidth(1.) glColor4f(0.4, 0.4, 0.4, 1.) # 1111_11_1______ glLineStipple(2, 1+2+4+8+32+64+256) glEnable(GL_LINE_STIPPLE) glLineWidth(2.) for node in self.nodes: parent_id = node.attrs.get("parent") if parent_id and parent_id != 0xFFFF: parent_node = self.nodes_dict[parent_id] glBegin(GL_LINES) glVertex3f(*parent_node.pos) glVertex3f(*node.pos) glEnd() glDisable(GL_LINE_STIPPLE) def render(self): for link in self.links: link.render() self._render_links_to_parents() for node in self.nodes: node.render() def render_overlay(self, camera, camera_ocs, projection_mode, w_pixels, h_pixels): # calculate node screen positions for node in self.nodes: # 1. proj obj to camera_ocs # 2. proj coord to screenspace v = camera_ocs.projv_in(node.pos) node.screen_pos.set(camera.screenspace(projection_mode, v, w_pixels, h_pixels)) # draw lines from the selected node to every other node if 0 and self.selected: glLineWidth(1.) for node in self.nodes: if node != self.selected: glColor4f(0.3,0.3,0.3,.9) glBegin(GL_LINES) glVertex3f(*self.selected.screen_pos) glVertex3f(*node.screen_pos) glEnd() glEnable(GL_TEXTURE_2D) s = (self.selected.screen_pos + node.screen_pos) / 2. link_quality = self._calc_link_quality(node, self.selected) self.gltext.drawmm("%.2f" % link_quality, s[0], s[1], bgcolor=(0.2,0.2,0.2,0.7), fgcolor=(1.,1.,1.,1.), z=s[2]) glDisable(GL_TEXTURE_2D) # draw the nodes themselves for node in self.nodes: node.render_overlay() #def recalculate_screen_pos(self, camera, camera_ocs, projection_mode, w_pixels, h_pixels): # for node in self.nodes: # # 1. proj obj to camera_ocs # # 2. proj coord to screenspace # v = camera_ocs.projv_in(node.pos) # node.screen_pos.set(camera.screenspace(projection_mode, v, w_pixels, h_pixels)) def intersects(self, sx, sy): for node in self.nodes: if node.intersects(float(sx), float(sy)): return node return None def save_graph_file(self, filename="sensormap.txt"): d = {"format": "sensed node graph", "format_version": "2013-12-19", "nodes": [], "edges": []} for node in self.nodes: p = node.pos n = {"id": node.node_id, "pos": [p[0], p[1], p[2]]} d["nodes"].append(n) edge_count = 0 for node1 in self.nodes: for node2 in self.nodes: if node1 != node2: edge_count += 1 e = {"id": edge_count, "source": node1.node_id, "dest": node2.node_id, "link_quality": self._calc_link_quality(node1, node2)} d["edges"].append(e) txt = json.dumps(d, indent=4, sort_keys=True) with open(filename, "wb") as f: f.write(txt) def _calc_link_quality(self, node1, node2): dist = node1.pos.dist(node2.pos) return dist def event(self, event): if event.type == SDL_MOUSEMOTION: for node in self.nodes: node.mouse_hover = False node = self.intersects(event.motion.x, event.motion.y) if node: self.mouse_hover = True node.mouse_hover = True else: self.mouse_hover = False if self.selected and self.mouse_dragging and self.mouse.mouse_lbdown_floor_coord: self.selected.pos.set(self.mouse.mouse_floor_coord + self.selected_pos_ofs) elif event.type == SDL_MOUSEBUTTONDOWN: if event.button.button == SDL_BUTTON_LEFT: node = self.intersects(event.button.x, event.button.y) if node: for n in self.nodes: n.selected = False self.selected = node node.selected = True self.selected_pos_ofs.set(node.pos - self.mouse.mouse_lbdown_floor_coord) self.mouse_dragging = True else: self.mouse_dragging = False elif event.type == SDL_MOUSEBUTTONUP: if event.button.button == SDL_BUTTON_LEFT: #if self.mouse_dragging: if self.mouse.mouse_lbdown_window_coord == self.mouse.mouse_window_coord: node = self.intersects(event.button.x, event.button.y) if not node: self.selected = None for n in self.nodes: n.selected = False self.mouse_dragging = False
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()
import ctypes from ctypes import * ll = ctypes.cdll.LoadLibrary lib = ll("/usr/local/lib64/libnanomsg.so.1.0.0") from nanomsg import Socket, PAIR, PUB from tornado.log import app_log import time import ctypes import json import time start = time.clock() s2 = Socket(PAIR) s2.connect('ipc:///tmp/to_py_pair.ipc') def test1(op): for i in range(10): time.sleep(3) op.send('bbb', 'hello world') def test2(op): stock_map = { 'aapl': 100.0, 'wbai': 20.0, 'goog': 165.0, 'baid': 144.0, 'jd': 33.0,
import time import os, sys from nanomsg import ( PAIR, poll, Socket, NanoMsgAPIError, DONTWAIT ) socket_address = 'ipc:///home/d1plo1d/git_repos/teg/packages/teg-linuxcnc/example_socket' socket = Socket(PAIR) socket.connect(socket_address) while True: try: message = socket.recv(flags=DONTWAIT) print("Received request: %s" % message) except NanoMsgAPIError: pass # print("NADA") # Do some 'work' time.sleep(0.1) # Send reply back to client # socket.send(b"World") 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)
from __future__ import print_function from nanomsg import Socket, PAIR, PUB s2 = Socket(PAIR) s2.connect('ipc:///tmp/wand1.ipc') while (True): print(s2.recv()) s2.close()
class ClientMq(object): def __init__(self, config, ui_event_engine, outgoing_queue): self._ui_event_engine = ui_event_engine self._outgoing_queue = outgoing_queue self._config = config self._active = False self._thread = Thread(target=self._run) def _run(self): # os.system("taskset -cp 5 %d " % os.getpid()) while self._active: try: # response msg from server msgin = self._recv_sock.recv(flags=0) msgin = msgin.decode("utf-8") if msgin is not None and msgin.index('|') > 0: # print('client rec msg:',msgin,'at ', datetime.now()) if msgin[-1] == '\0': msgin = msgin[:-1] if msgin[-1] == '\x00': msgin = msgin[:-1] m = Event() m.deserialize(msgin) self._ui_event_engine.put(m) except Exception as e: pass try: # request, qry msg to server msgout = self._outgoing_queue.get(False) print('outgoing get msg,begin send', msgout, datetime.now()) # self._send_sock.send(bytes(msgout,"ascii"), flags=0) self._send_sock.send(msgout, flags=1) print('outgoing end send', msgout, datetime.now()) except Exception as e: pass def start(self, timer=True): """ start the mq thread """ self._recv_sock = Socket(SUB) self._send_sock = Socket(PUSH) self._monitor_sock = Socket(SUB) # print(os.getpid()) self._recv_sock.connect(self._config['serverpub_url']) self._recv_sock.set_string_option(SUB, SUB_SUBSCRIBE, '') self._recv_sock.set_int_option(SOL_SOCKET, RCVTIMEO, 100) self._send_sock.connect(self._config['serverpull_url']) self._monitor_sock.connect(self._config['serversub_url']) 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, PAIR URL = "ipc:///tmp/example3" socket = Socket(PAIR) print("Socket created") socket.connect(URL) print("Connected to URL {}".format(URL)) message = socket.recv() print("Received: {}".format(message)) socket.close() print("Socket closed")
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 import os from nanomsg import poll, Socket, PUSH, PULL from time import time import sys import argparse parser = argparse.ArgumentParser( description='Extract parameters from command-line') parser.add_argument('-cn', '--clientnumber', default='1') args = parser.parse_args() client_number = int(args.clientnumber) client_sock = Socket(PULL) client_sock.connect('ipc://nanopushpull.bin') timeout = 2 # seconds not_finished = True while not_finished: time_before_poll = time() r, _ = poll([client_sock], [], timeout) time_after_poll = time() if (time_after_poll - time_before_poll - timeout > 0): print("client #%d: timeout exceeded - no more messages?" % (client_number)) break elif len(r) > 0: print("client #%d: got %s" % (client_number, client_sock.recv())) else: print("client #%d: something odd happened" % (client_number)) break
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())
# mngtest.py # simple test of python3 calling golang mangorep # Now it is possible to write simple python scripts to use # go programs on any system import json, time 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)
class NodeEditor: #STATE_PLAYBACK_ON_EDGE = 0x01 # STATE_PLAYBACK = 0x02 # playback from random place STATE_PAUSED = 0x03 # seek # get_delta_packets(dt) # get_current_timestamp def __init__(self, nugui, mouse, gltext, conf): self.conf = conf self.mouse = mouse # TODO: use a special mouse object instead of the editor_main object directly. self.gltext = gltext self.nugui = nugui self.world = world.World("ff", self.conf) self.underworld = world.World("", self.conf) # not visible. used serializing keyframes self.mouse_x = 0. self.mouse_y = 0. self.mouse_hover = False self.mouse_dragging = False self.selected = None self.selected_pos_ofs = vector.Vector() self.node_renderer = renderers.NodeRenderer(self.gltext) self.link_renderer = renderers.LinkRenderer() # saved when closing the windows. loaded at startup. self.session_filename = os.path.normpath(os.path.join(self.conf.path_database, "session_conf.txt")) self.load_session() self.recording = True self.state = self.STATE_PLAYBACK self.worldstreamer = world_streamer.WorldStreamer(sync_window_seconds=self.conf.sync_depth_seconds) #self.current_playback_time = 0. # timepoint of the simulation that is currently visible on screen. can be dragged around with a slider. self.timeslider_end_time = 0. self.graph_window = graph_window.GraphWindow(self.gltext) self.graph_window_initialized = False self.s1 = Socket(SUB) self.s1.connect('tcp://127.0.0.1:55555') self.s1.set_string_option(SUB, SUB_SUBSCRIBE, '') def tick(self, dt, keys): self.world.tick(dt) self.underworld.tick(dt) self.net_poll_packets() fresh_packets = self.worldstreamer.tick() for p in fresh_packets: self.handle_packet(p[1], self.underworld, barebones=True) if self.state == self.STATE_PLAYBACK: packets = self.worldstreamer.get_delta_packets(dt) for p in packets: self.handle_packet(p[1], self.world) if self.worldstreamer.need_keyframe(): llog.info("need keyframe!") w = self.underworld.serialize_world() #import pprint #llog.info("\n\n\nSAVING") #llog.info(pprint.pformat(w)) self.worldstreamer.put_keyframe(w) # always set the graph start 10 seconds before the first sample time. user-friendly start condition for the zoom-scroller. if self.worldstreamer.start_time != None and not self.graph_window_initialized: self.graph_window_initialized = True self.graph_window.set_totalsample_start(self.worldstreamer.start_time - 10.) self.graph_window.set_totalsample_end(self.worldstreamer.end_time) self.graph_window.set_sample_visibility(self.worldstreamer.start_time - 10., self.worldstreamer.end_time) if self.graph_window_initialized: self.graph_window.set_totalsample_end(self.worldstreamer.end_time) self.graph_window.tick() if self.graph_window_initialized: # if the graph was moved by keyboard/mouse if self.graph_window.wanted_x2_was_moved: self.graph_window.wanted_x2_was_moved = False newtime = self.graph_window.wanted_visiblesample_x2 if newtime != self.worldstreamer.current_time: llog.info("seeking from %.2f to %.2f between %.2f %.2f", self.worldstreamer.current_time, newtime, self.worldstreamer.start_time, self.worldstreamer.end_time) keyframe, packets = self.worldstreamer.seek(newtime) self.world.deserialize_world(keyframe) llog.info("seeking returned %i packets", len(packets)) if packets: # calc the timestamp from where to start using animations. use only 2 seconds worth, because # it's not very nice to animate all packets at once if seek returned 30 minutes worth of packets for example. # TODO: but if the keyframe is too close to the seek time, then we won't get even 2 seconds worth of packets. # then we'll have to use the previous keyframe. oh, too much work.. animations_start = packets[-1][0] - 2. for p in packets: timestamp, packet = p if timestamp < animations_start: # won't use animations for these packets self.handle_packet(packet, self.world, barebones=True) else: self.handle_packet(packet, self.world) if self.state == self.STATE_PLAYBACK: self.graph_window.move_sample_right_edge(self.worldstreamer.current_time) def net_poll_packets(self): try: # handle all incoming packets # TODO: sync packets by timestamp. sync time configurable. 5 seconds default? # print error if a packet arrives out of sync? how to denote this info? while 1: msg = self.s1.recv(flags=DONTWAIT) if not msg: break msg = msg.strip() if msg: try: # append the packet to timesyncer # get the timestamp. d = msg.split(None, 5) #d = d[1:] # cut off the seqno # ['data', 'etx', '0001000000000200', 'node', '0A', 'index', '0', 'neighbor', '8', 'etx', '10', 'retx', '74'] if d[0] == "data" or d[0] == "event": # get nodeid from packet node_id_name = d[4] nodeid = int(node_id_name.split("_", 1)[0], 16) self.worldstreamer.put_packet(float(d[2]), msg, nodeid) except: llog.exception("") except NanoMsgAPIError as e: if e.errno != errno.EAGAIN: raise def handle_packet(self, msg, world, barebones=False): """ barebones : if True, then won't use any animations and non-essential poking of the world. Will result in a fast barebones world that is still usable for generating keyframes. """ #llog.info("handle: %s", msg) d = msg.split() #d = d[1:] # cut off the seqno if d[0] == "data" or d[0] == "event": #timestamp = float(d[2]) #timesyncer.append(timestamp, msg) # ['data', 'etx', '0001000000000200', 'node', '0A', 'index', '0', 'neighbor', '8', 'etx', '10', 'retx', '74'] # ['data', 'etx', '0001000000000200', 'node', '0A_sniffy', 'index', '0', 'neighbor', '8', 'etx', '10', 'retx', '74'] node_id_name = d[4] node = world.get_create_named_node(node_id_name) src_node = node src_node_id = node.node_id if d[0] == "data": if d[1] == "etx": # ['data', 'etx', '0001000000000200', 'node', '0A', 'index', '0', 'neighbor', '8', 'etx', '10', 'retx', '74'] # filter out empty rows if int(d[8]) != 0xFFFF: if d[10].startswith("NO_ROUTE"): d[10] = "NO" d[12] = "NO" # when receiving entry with index 0, then clear out the whole table. if int(d[6]) == 0: node.attrs["etx_table"] = [] attrs_etx_table = node.attrs.get("etx_table", []) attrs_etx_table.append("%04X e%s r%s" % (int(d[8]), d[10], "00" if d[12] == "0" else d[12])) elif d[1] == "ctpf_buf_size": used = int(d[6]) capacity = int(d[8]) node.attrs["ctpf_buf_used"] = used node.attrs["ctpf_buf_capacity"] = capacity elif d[0] == "event": if d[1] == "radiopowerstate": # ['event', 'radiopowerstate', '0052451410156550', 'node', '04', 'state', '1'] radiopowerstate = int(d[6], 16) node.attrs["radiopowerstate"] = radiopowerstate if not barebones: if radiopowerstate: node.poke_radio() elif d[1] == "beacon": # ['event', 'beacon', '0052451410156550', 'node', '04', 'options', '0x00', 'parent', '0x0003', 'etx', '30'] options = int(d[6], 16) parent = int(d[8], 16) node.attrs["parent"] = parent if not barebones: node.append_animation(animations.BeaconAnimation(options)) elif d[1] == "packet_to_activemessage" and 0: # ['event', 'packet', '0000372279297175', 'node', '04', 'dest', '0x1234', 'amid', '0x71'] dst_node_id = int(d[6], 16) amid = int(d[8], 16) if dst_node_id != 0xFFFF: # filter out broadcasts dst_node = world.get_create_node(dst_node_id) if not barebones: link = world.get_link(src_node, dst_node) link.poke(src_node) elif d[1] == "send_ctp_packet": # event send_ctp_packet 0:0:38.100017602 node 03 dest 0x0004 origin 0x0009 sequence 21 type 0x71 thl 5 # event send_ctp_packet 0:0:10.574584572 node 04 dest 0x0003 origin 0x0005 sequence 4 amid 0x98 thl 1 dst_node_id = int(d[6], 16) origin_node_id = int(d[8], 16) sequence_num = int(d[10]) amid = int(d[12], 16) thl = int(d[14]) dst_node = world.get_create_node(dst_node_id) if not barebones: link = world.get_link(src_node, dst_node) # TODO: refactor node color link.poke(src_node, packet_color=world.get_node_color(origin_node_id)) elif d[1] == "packet_to_model_busy": dst_node_id = int(d[6], 16) if dst_node_id != 0xFFFF: # filter out broadcasts src_node = node dst_node = world.get_create_node(dst_node_id) if not barebones: link = self.world.get_link(src_node, dst_node) link.poke_busy(src_node) elif d[1] == "send_done": # 'event send_done 1425601510.21 node 2C13_8 rm 0x02 dest 0x37B6 amid 0x71 error 0x00 retry_count 9 acked 0x01 congested 0x00 dropped 0x00' ramplex_id = int(d[6],16) dst_node_id = int(d[8],16) amid = int(d[10],16) error = int(d[12],16) retry_count = int(d[14],16) acked = int(d[16],16) congested = int(d[18],16) dropped = int(d[20],16) if not barebones and retry_count > 0: node.append_animation(animations.SendRetryAnimation(max_age=1., start_color=(1.,0.,0.,1.), end_color=(0.,0.,0.,0.2), retry_count=retry_count)) else: llog.info("unknown msg %s", repr(msg)) def _render_links_to_parents(self): glLineWidth(1.) glColor4f(0.4, 0.4, 0.4, 1.) # 1111_11_1______ glLineStipple(2, 1+2+4+8+32+64+256) glEnable(GL_LINE_STIPPLE) glLineWidth(2.) for node in self.world.nodes: parent_id = node.attrs.get("parent") if parent_id and parent_id != 0xFFFF: parent_node = self.world.get_create_node(parent_id) glBegin(GL_LINES) glVertex3f(*parent_node.pos) glVertex3f(*node.pos) glEnd() glDisable(GL_LINE_STIPPLE) def render(self): for link in self.world.links: self.link_renderer.render(link) self._render_links_to_parents() for node in self.world.nodes: self.node_renderer.render(node) def render_overlay(self, camera, camera_ocs, projection_mode, w_pixels, h_pixels): # calculate node screen positions for node in self.world.nodes: # 1. proj obj to camera_ocs # 2. proj coord to screenspace v = camera_ocs.projv_in(node.pos) node.screen_pos.set(camera.screenspace(projection_mode, v, w_pixels, h_pixels)) # draw lines from the selected node to every other node if 0 and self.selected: glLineWidth(1.) for node in self.world.nodes: if node != self.selected: glColor4f(0.3,0.3,0.3,.9) glBegin(GL_LINES) glVertex3f(*self.selected.screen_pos) glVertex3f(*node.screen_pos) glEnd() glEnable(GL_TEXTURE_2D) s = (self.selected.screen_pos + node.screen_pos) / 2. link_quality = self._calc_link_quality(node, self.selected) self.gltext.drawmm("%.2f" % link_quality, s[0], s[1], bgcolor=(0.2,0.2,0.2,0.7), fgcolor=(1.,1.,1.,1.), z=s[2]) glDisable(GL_TEXTURE_2D) # draw the nodes themselves for node in self.world.nodes: self.node_renderer.render_overlay(node) t = self.gltext # render some information glEnable(GL_TEXTURE_2D) y = 5. t.drawtl(" sync depth : %.1f s " % (self.worldstreamer.sync_window_seconds), 5, y, bgcolor=(0.8,0.8,0.8,.9), fgcolor=(0.,0.,0.,1.), z=100.); y += t.height t.drawtl(" recording : yes ", 5, y); y += t.height txt = "-" if self.worldstreamer.start_time == None else round(self.worldstreamer.end_time - self.worldstreamer.start_time) t.drawtl(" duration : %s s " % (txt), 5, y); y += t.height t.drawtl(" num packets : %i " % self.worldstreamer.num_packets_sorted, 5, y); y += t.height # render and handle rewind-slider if 1: txt = "-" if self.worldstreamer.start_time == None else timestamp_to_timestr(self.worldstreamer.start_time) t.drawbl(txt, 5, h_pixels - 53, bgcolor=(0,0,0,.6), fgcolor=(.8,.8,.8,1.), z=100.) txt = "-" if self.worldstreamer.end_time == None else timestamp_to_timestr(self.worldstreamer.end_time) t.drawbr(txt, w_pixels-5, h_pixels-53) txt = "-" if self.worldstreamer.current_time == None else timestamp_to_timestr(self.worldstreamer.current_time) t.drawbm(txt, w_pixels/2, h_pixels-53, bgcolor=(0,0,0,.9)) glLineWidth(1.) glDisable(GL_TEXTURE_2D) # self.render_timeslide_scrollbar(h_pixels-80, w_pixels-10, w_pixels-20, 10) if 0: if self.worldstreamer.start_time == None: self.nugui.slider(1001, 10, h_pixels-40, w_pixels-20, 0., 0., 0., True) else: # don't update slider end time while dragging the slider if self.nugui.id_active != 1001: self.timeslider_end_time = self.worldstreamer.end_time newtime = self.nugui.slider(1001, 10, h_pixels-40, w_pixels-20, self.worldstreamer.current_time, self.worldstreamer.start_time, self.timeslider_end_time) if newtime != self.worldstreamer.current_time: llog.info("seeking from %.2f to %.2f between %.2f %.2f", self.worldstreamer.current_time, newtime, self.worldstreamer.start_time, self.worldstreamer.end_time) keyframe, packets = self.worldstreamer.seek(newtime) self.world.deserialize_world(keyframe) llog.info("seeking returned %i packets", len(packets)) for p in packets: self.handle_packet(p[1], self.world) self.graph_window.place_on_screen(0, h_pixels-51, w_pixels, 50) self.graph_window.render() txt = "playing" if self.state == self.STATE_PLAYBACK else "paused" if self.nugui.button(1002, 5, h_pixels-90, txt, w=64): if self.state == self.STATE_PLAYBACK: self.state = self.STATE_PAUSED else: self.state = self.STATE_PLAYBACK def intersects_node(self, sx, sy): for node in self.world.nodes: if node.intersects(float(sx), float(sy)): return node return None def save_graph_file(self, filename="sensormap.txt"): d = {"format": "sensed node graph", "format_version": "2013-12-19", "nodes": [], "edges": []} for node in self.world.nodes: p = node.pos n = {"id": node.node_id, "pos": [p[0], p[1], p[2]]} d["nodes"].append(n) edge_count = 0 for node1 in self.world.nodes: for node2 in self.world.nodes: if node1 != node2: edge_count += 1 e = {"id": edge_count, "source": node1.node_id, "dest": node2.node_id, "link_quality": self._calc_link_quality(node1, node2)} d["edges"].append(e) txt = json.dumps(d, indent=4, sort_keys=True) with open(filename, "wb") as f: f.write(txt) def _calc_link_quality(self, node1, node2): dist = node1.pos.dist(node2.pos) return dist def load_session(self): """ load node positions. write to self.session_node_positions """ try: with open(self.session_filename, "rb") as f: session_conf = json.load(f) except IOError: #log.warning("'%s' file not found" % path) session_conf = None # extract node positions from the conf dict if session_conf and "node_positions" in session_conf: c = session_conf.get("node_positions") # convert entries {"0x51AB": (1,2,3), ..} to format {20907, (1,2,3)} self.world.session_node_positions = {int(k, 16): v for k, v in c.items()} def save_session(self): """ save node positions. mix together prev session positions and new positions. """ # convert entries {20907: (1,2,3), ..} to format {"0x51AB", (1,2,3)} node_positions_session = {"0x%04X" % k: v for k, v in self.world.session_node_positions.items()} node_positions_used = {"0x%04X" % n.node_id: (n.pos[0], n.pos[1], n.pos[2]) for n in self.world.nodes} node_positions_session.update(node_positions_used) session_conf = {"node_positions": node_positions_session} txt = json.dumps(session_conf, indent=4, sort_keys=True) with open(self.session_filename, "wb") as f: f.write(txt) def close(self): self.save_session() def is_world_move_allowed(self): if self.graph_window.is_coordinate_inside_window(self.mouse_x, self.mouse_y): return False return True def event(self, event): if self.graph_window.event(event): return True if event.type == SDL_MOUSEMOTION: self.mouse_x = float(event.motion.x) self.mouse_y = float(event.motion.y) for node in self.world.nodes: node.mouse_hover = False node = self.intersects_node(event.motion.x, event.motion.y) if node: self.mouse_hover = True node.mouse_hover = True else: self.mouse_hover = False if self.selected and self.mouse_dragging and self.mouse.mouse_lbdown_floor_coord: self.selected.pos.set(self.mouse.mouse_floor_coord + self.selected_pos_ofs) return True elif event.type == SDL_MOUSEBUTTONDOWN: if event.button.button == SDL_BUTTON_LEFT: node = self.intersects_node(event.button.x, event.button.y) if node: for n in self.world.nodes: n.selected = False self.selected = node node.selected = True self.selected_pos_ofs.set(node.pos - self.mouse.mouse_lbdown_floor_coord) self.mouse_dragging = True else: self.mouse_dragging = False elif event.type == SDL_MOUSEBUTTONUP: if event.button.button == SDL_BUTTON_LEFT: #if self.mouse_dragging: if self.mouse.mouse_lbdown_window_coord == self.mouse.mouse_window_coord: node = self.intersects_node(event.button.x, event.button.y) if not node: self.selected = None for n in self.world.nodes: n.selected = False self.mouse_dragging = False
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)