Ejemplo n.º 1
0
 def sync_call(self, apiname, args={}, timeout=10):
     """ 给定参数args,同步调用RPCServer的apiname服务,
     返回该服务的处理结果。如果超时,返回None。
     
     Args:
         apiname (str): 服务API名称。
         args (dict): 给服务API的参数。
         handler (function): 回调函数。
     """
     log.debug('sync_call: %s' % apiname)
     if not isinstance(args, dict):
         self._timeout = 0
         self._sync_ret = None
         raise InvalidRPCClientArguments(argtype=type(args))
     self.rid += 1
     args['apiname'] = apiname
     args['rid'] = self.rid
     with self._sync_call_time_lock:
         self._sync_call_time = datetime.now()
     self._timeout = timeout
     with self._handlers_lock:
         self._handlers[self.rid] = None
     self._event_engine.emit(Event(self.EVENT_CLIENT, args))
     self._waiting_server_data()
     ret = self._sync_ret
     #self._sync_ret = None
     return ret
Ejemplo n.º 2
0
 def sync_call(self, apiname, args={}, timeout=10):
     """ 给定参数args,同步调用RPCServer的apiname服务,
     返回该服务的处理结果。如果超时,返回None。
     
     Args:
         apiname (str): 服务API名称。
         args (dict): 给服务API的参数。
         handler (function): 回调函数。
     """
     log.debug('sync_call: %s' % apiname)
     if not isinstance(args, dict):
         self._timeout = 0
         self._sync_ret = None
         raise InvalidRPCClientArguments(argtype=type(args))
     self.rid += 1
     args['apiname'] = apiname
     args['rid'] = self.rid
     with self._sync_call_time_lock:
         self._sync_call_time = datetime.now()
     self._timeout = timeout
     with self._handlers_lock:
         self._handlers[self.rid] = None
     self._event_engine.emit(Event(self.EVENT_CLIENT, args))
     self._waiting_server_data()
     ret = self._sync_ret
     #self._sync_ret = None
     return ret
Ejemplo n.º 3
0
 def _process(self, event):
     """处理事件"""
     if event.route not in self._routes:
         logger.warning("事件%s 没有被处理" % event.route)
         return
     for handler in self._routes[event.route]:
         try:
             # @NOTE 会阻塞事件队列,除非另起线程。
             logger.debug("处理事件%s" % event.route)
             handler(event)
         except Exception as e:
             print e
Ejemplo n.º 4
0
 def _process(self, event):
     """处理事件"""
     if event.route not in self._routes:
         logger.warning("事件%s 没有被处理" % event.route)
         return
     for handler in self._routes[event.route]:
         try:
             # @NOTE 会阻塞事件队列,除非另起线程。
             logger.debug("处理事件%s" % event.route)
             handler(event)    
         except Exception as e:
             print e
Ejemplo n.º 5
0
 def _run_timer(self):
     while True:
         if not self._timeout == 0:
             with self._sync_call_time_lock:
                 mtime = self._sync_call_time
             delta = (datetime.now()-mtime).seconds
             if delta >= self._timeout:
                 #print "timeout", self._timeout, delta
                 # 不可重入,保证self.rid就是超时的那个
                 with self._handlers_lock:
                     del self._handlers[self.rid]
                 log.debug("[RPCClient._runtimer] 处理超时, delete rid; %s" % self.rid)
                 self._timeout = 0
                 self._notify_server_data()
         time.sleep(self._timer_sleep)
Ejemplo n.º 6
0
 def _run_timer(self):
     while True:
         if not self._timeout == 0:
             with self._sync_call_time_lock:
                 mtime = self._sync_call_time
             delta = (datetime.now() - mtime).seconds
             if delta >= self._timeout:
                 #print "timeout", self._timeout, delta
                 # 不可重入,保证self.rid就是超时的那个
                 with self._handlers_lock:
                     del self._handlers[self.rid]
                 logger.debug("[RPCClient._runtimer] 处理超时, delete rid; %s" %
                              self.rid)
                 self._timeout = 0
                 self._notify_server_data()
         sleep(self._timer_sleep)
Ejemplo n.º 7
0
 def _process_request(self, event):
     #print "rpcsever: ", event.route, event.args
     args = event.args
     rid = args['rid']
     apiname = args['apiname']
     del args['rid']
     del args['apiname']
     log.debug('RPCServer process: %s' % apiname)
     try:
         with self._routes_lock:
             handler = self._routes[apiname]
         ## @TODO async
         ret = handler(**args)
     except Exception as e:
         print e, "****"
     else:
         args = {'ret': ret, 'rid': rid}
         log.debug('RPCServer emit')
         self._event_engine.emit(Event(self.EVENT_SERVER, args))
Ejemplo n.º 8
0
 def _process_apiback(self, event):
     assert(event.route == self.EVENT_SERVER)
     self._timeout = 0
     rid = event.args['rid']
     try:
         with self._handlers_lock:
             handler = self._handlers[rid]
     except KeyError:
         logger.info('[RPCClient._process_apiback] 放弃超时任务的返回结果')
     else:
         try:
             if handler:
                 handler(event.args['ret'])
             else:
                 self._sync_ret = event.args['ret']
                 self._notify_server_data()
         except Exception as e:
             print e
         logger.debug("[RPCClient._process_apiback] 删除已经完成的任务 rid; %s" % rid)
         with self._handlers_lock:
             del self._handlers[rid]
Ejemplo n.º 9
0
 def _process_request(self, event):
     #print "rpcsever: ", event.route, event.args
     args = event.args
     rid = args['rid']
     apiname = args['apiname']
     del args['rid']
     del args['apiname']
     log.debug('RPCServer process: %s' % apiname)
     try:
         with self._routes_lock:
             handler = self._routes[apiname]
         ## @TODO async    
         ret = handler(**args)
     except Exception as e:
         print e, "****" 
     else:
         args = { 'ret': ret,
                 'rid': rid
         }
         log.debug('RPCServer emit')
         self._event_engine.emit(Event(self.EVENT_SERVER, args))
Ejemplo n.º 10
0
 def add_comb(self, comb, settings = { }):
     """ 添加策略组合组合
     
     Args:
         comb (list): 一个策略组合
     """
     self._combs.append(comb)
     if settings:
         num_strategy = len(comb) 
         assert (settings['captial'] > 0)
         assert len(settings['ratio']) == num_strategy
         assert(sum(settings['ratio']) == 1)
     ctxs = []
     for i, s in enumerate(comb):
         iset = { }
         if settings:
             iset = { 'captial': settings['captial'] * settings['ratio'][i] }
             logger.debug(iset)
         ctxs.append(StrategyContext(s.name, iset))
     self.context.add_strategy_context(ctxs)
     blotters = [ ctx.blotter for ctx in  ctxs]
     return blotter.Profile(blotters, self.all_data, self.pcontracts[0], len(self._combs)-1)
Ejemplo n.º 11
0
 def _process_apiback(self, event):
     assert (event.route == self.EVENT_SERVER)
     self._timeout = 0
     rid = event.args['rid']
     try:
         with self._handlers_lock:
             handler = self._handlers[rid]
     except KeyError:
         logger.info('[RPCClient._process_apiback] 放弃超时任务的返回结果')
     else:
         try:
             if handler:
                 handler(event.args['ret'])
             else:
                 self._sync_ret = event.args['ret']
                 self._notify_server_data()
         except Exception as e:
             print e
         logger.debug("[RPCClient._process_apiback] 删除已经完成的任务 rid; %s" %
                      rid)
         with self._handlers_lock:
             del self._handlers[rid]
Ejemplo n.º 12
0
 def add_comb(self, comb, settings = { }):
     """ 添加策略组合组合
     
     Args:
         comb (list): 一个策略组合
     """
     self._combs.append(comb)
     if settings:
         num_strategy = len(comb) 
         assert (settings['captial'] > 0)
         assert len(settings['ratio']) == num_strategy
         assert(sum(settings['ratio']) == 1)
     ctxs = []
     for i, s in enumerate(comb):
         iset = { }
         if settings:
             iset = { 'captial': settings['captial'] * settings['ratio'][i] }
             logger.debug(iset)
         ctxs.append(StrategyContext(s.name, iset))
     self.context.add_strategy_context(ctxs)
     blotters = [ ctx.blotter for ctx in  ctxs]
     return blotter.Profile(blotters, self.all_data, self.pcontracts[0], len(self._combs)-1)
Ejemplo n.º 13
0
 def process_trading_events(self, append):
     """ 提交订单,撮合,更新持仓 """
     if self._orders:
         self.events_pool.put(SignalEvent(self._orders))
     self._orders = []
     new_signal = False  # 保证至少一次价格撮合。
     event = None
     while True:
         # 事件处理。
         try:
             event = self.events_pool.get()
         except Queue.Empty:
             assert (False)
         except IndexError:
             if new_signal:
                 break
         else:
             #if event.type == 'MARKET':
             #strategy.calculate_signals(event)
             #port.update_timeindex(event)
             if event.type == Event.SIGNAL:
                 try:
                     self.blotter.update_signal(event)
                 except TradingError as e:
                     logger.debug(e)
                     return
             elif event.type == Event.ORDER:
                 self.exchange.insert_order(event)
             elif event.type == Event.FILL:
                 # 模拟交易接口收到报单成交
                 self.blotter.api.on_transaction(event)
         # 价格撮合。note: bar价格撮合要求撮合置于运算后面。
         if event == None or event.type == Event.ORDER:
             self.exchange.make_market(self.blotter._bars)
             new_signal = True
     self.blotter.update_status(self._datetime, append)
Ejemplo n.º 14
0
    def process_trading_events(self):
        # 一次策略循环可能产生多个委托单。
        if self._orders:
            self.events_pool.put(SignalEvent(self._orders))
        self._orders = []
        maked = False # 保证至少一次价格撮合。
        while True:
           # 事件处理。 
            try:
                event = self.events_pool.get()
            except Queue.Empty:
                if maked:
                    break
            except IndexError:
                break
            else:
                if event is not None:
                    #if event.type == 'MARKET':
                        #strategy.calculate_signals(event)
                        #port.update_timeindex(event)
                    if event.type == Event.SIGNAL:
                        try:
                            self.blotter.update_signal(event)
                        except TradingError as e:
                            logger.debug(e)
                            return

                    elif event.type == Event.ORDER:
                        self.exchange.insert_order(event)

                    elif event.type == Event.FILL:
                        # 模拟交易接口收到报单成交
                        self.blotter.api.on_transaction(event)
            # 价格撮合。note: bar价格撮合要求撮合置于运算后面。
            self.exchange.make_market(self.blotter._bars)
            maked = True
Ejemplo n.º 15
0
 def process_trading_events(self, append):
     """ 提交订单,撮合,更新持仓 """
     if self._orders:
         self.events_pool.put(SignalEvent(self._orders))
     self._orders = []
     new_signal = False # 保证至少一次价格撮合。
     event = None
     while True:
        # 事件处理。 
         try:
             event = self.events_pool.get()
         except Queue.Empty:
             assert(False)
         except IndexError:
             if new_signal:
                 break
         else:
             #if event.type == 'MARKET':
                 #strategy.calculate_signals(event)
                 #port.update_timeindex(event)
             if event.type == Event.SIGNAL:
                 try:
                     self.blotter.update_signal(event)
                 except TradingError as e:
                     logger.debug(e)
                     return
             elif event.type == Event.ORDER:
                 self.exchange.insert_order(event)
             elif event.type == Event.FILL:
                 # 模拟交易接口收到报单成交
                 self.blotter.api.on_transaction(event)
         # 价格撮合。note: bar价格撮合要求撮合置于运算后面。
         if event == None or event.type == Event.ORDER:
             self.exchange.make_market(self.blotter._bars)
             new_signal = True
     self.blotter.update_status(self._datetime, append)
Ejemplo n.º 16
0
 def _run_server(self):
     strevent = self._server_recv_event_socket.recv()
     self._broadcast_event_socket.send(strevent)
     logger.debug("[server] broadcast message: %s" % strevent)
Ejemplo n.º 17
0
 def _run_client(self):
     message = self._client_recv_event_socket.recv()
     event = Event.message_to_event(message)
     logger.debug("[client] receive message: %s" % event)
     self._queue_engine.emit(event)
Ejemplo n.º 18
0
 def _run_client(self):
     message = self._client_recv_event_socket.recv()
     event = Event.message_to_event(message)
     logger.debug("[client] receive message: %s" % event)
     self._queue_engine.emit(event)
Ejemplo n.º 19
0
 def _run_server(self):
     strevent = self._server_recv_event_socket.recv()
     self._broadcast_event_socket.send(strevent)
     logger.debug("[server] broadcast message: %s" % strevent)