def handleBacktestHistoryCreatEvent(self, event, callback): self._logger.debug( "src.core.engine.handler.Handler.handleBacktestHistoryCreatEvent: {id=%s, type=%s, priority=%s, timeStamp=%s, args=%s}" % (event.id, event.type, event.priority, event.timeStamp, event.args)) # 接收事件 [exchange, signals, timeout] = event.args exchange = str_to_list(exchange) signals = str_to_list(signals) timeout = float(timeout) # 处理事件 try: db = DB() sgn = Signal(signals) resInfoSymbol = pd.DataFrame(db.getViewMarketSymbolPairs(exchange)) # 0. start identify = 0 startTime = time.time() str = "src.core.engine.handler.Handler.handleBacktestHistoryCreatEvent: { type=%s, priority=%s, args=%s }" % ( event.type, event.priority, event.args) warnStr = Template( ", err=$err, backtest trade filed at $here, will try again...") errStr = Template( "BACKTEST TRADE ERROR. pre trade failed at $here.") ######################################## # 1. pre trade # 1.1 calc pre orders preOrders = [] isError = SIGNAL_MAX_NUM while isError > 0: try: isError = isError - 1 preOrders = sgn.backtestSignalsPreTrade(resInfoSymbol) isError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='1.1 calc pre orders')) if isError > 0: raise Exception(errStr.substitute(here='1.1 calc pre orders')) # print('1. pre signals preOrders:\n%s' % preOrders) # 1.2 calc preExecOrders preExecOrders = [] if not preOrders == []: for order in preOrders: identify = identify + 1 isError = SIGNAL_MAX_NUM res = [] while isError > 0: try: isError = isError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='1.2 excute preOrders')) if not res == []: preExecOrders.extend(res) if isError > 0: # rollback: pdOrders = pd.DataFrame(preExecOrders) self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='1.2 excute preOrders')) # print('1. pre signals preExecOrders:\n%s' % preExecOrders) # 1.3 calc preInfoOrders preInfoOrders = [] if not preExecOrders == []: preExecOrders = pd.DataFrame(preExecOrders) for server in exchange: res = [] orderIDs = preExecOrders[(preExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: preInfoOrders.extend(res) # print('1. pre signals preInfoOrders:\n%s' % preInfoOrders) # 1.4 update signals status if not preInfoOrders == []: preInfoOrders = pd.DataFrame(preInfoOrders) isError = SIGNAL_MAX_NUM while isError > 0: try: isError = isError - 1 sgn.backtestUpdateSignalStatusByOrders( preInfoOrders, resInfoSymbol) isError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='1.4 update signals status')) if isError > 0: # rollback: pdOrders = preExecOrders self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='1.4 update signals status')) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair(sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # print('1. pre signals after update:\n%s' % sgn.signals()) ######################################## # 2. run trade isError = True while isError and (time.time() - startTime < timeout or timeout == 0): # 2.1 calc run orders runOrders = [] isSubError = SIGNAL_MAX_NUM while isSubError > 0 and (time.time() - startTime < timeout or timeout == 0): try: isSubError = isSubError - 1 runOrders = sgn.backtestSignalsRunTrade(resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='2.1 calc run orders')) if isSubError > 0: # rollback: pdOrders = [] self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='2.1 calc run orders')) # print('2. run signals runOrders:\n%s' % runOrders) # 2.2 calc runExecOrders runExecOrders = [] if not runOrders == []: for order in runOrders: identify = identify + 1 isSubError = SIGNAL_MAX_NUM res = [] while isSubError > 0 and (time.time() - startTime < timeout or timeout == 0): try: isSubError = isSubError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='2.2 execute runOrders')) if not res == []: runExecOrders.extend(res) if isSubError > 0: # rollback: pdOrders = pd.DataFrame(runExecOrders) self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='2.2 execute runOrders')) # print('2. run signals runExecOrders:\n%s' % runExecOrders) # 2.3 calc runInfoOrders runInfoOrders = [] if not runExecOrders == []: runExecOrders = pd.DataFrame(runExecOrders) for server in exchange: res = [] orderIDs = runExecOrders[( runExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: runInfoOrders.extend(res) # print('2. run signals runInfoOrders:\n%s' % runInfoOrders) # 2.4 update signals status if not runInfoOrders == []: runInfoOrders = pd.DataFrame(runInfoOrders) isSubError = SIGNAL_MAX_NUM while isSubError > 0 and (time.time() - startTime < timeout or timeout == 0): try: isSubError = isSubError - 1 sgn.backtestUpdateSignalStatusByOrders( runInfoOrders, resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='2.4 update signals status')) if isSubError > 0: # rollback: pdOrders = runExecOrders self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute( here='2.4 update signals status')) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair( sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # print('2. run signals after update:\n%s' % sgn.signals()) # 2.5 update isError isMore = sgn.backtestSignalsIsRunMore(resInfoSymbol) if not isMore: isError = False ######################################## # 3. after trade isError = SIGNAL_MAX_NUM while isError > 0: isError = isError - 1 # 3.1 calc after orders afterOrders = [] isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 afterOrders = sgn.backtestSignalsAfterTrade( resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='3.1 calc after orders')) if isSubError > 0: # rollback pdOrders = [] self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='3.1 calc after orders')) # print('3. after signals afterOrders:\n%s' % afterOrders) # 3.2 calc afterExecOrders afterExecOrders = [] if not afterOrders == []: for order in afterOrders: identify = identify + 1 isSubError = SIGNAL_MAX_NUM res = [] while isSubError > 0: try: isSubError = isSubError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='3.2 excute preOrders')) if not res == []: afterExecOrders.extend(res) if isSubError > 0: # rollback: pdOrders = pd.DataFrame(afterExecOrders) self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute(here='3.2 excute preOrders')) # print('3. after signals afterExecOrders:\n%s' % afterExecOrders) # 3.3 calc afterInfoOrders afterInfoOrders = [] if not afterExecOrders == []: afterExecOrders = pd.DataFrame(afterExecOrders) for server in exchange: res = [] orderIDs = preExecOrders[( preExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: afterInfoOrders.extend(res) # print('3. after signals afterInfoOrders:\n%s' % afterInfoOrders) # 3.4 update signals status if not afterInfoOrders == []: afterInfoOrders = pd.DataFrame(afterInfoOrders) isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 sgn.backtestUpdateSignalStatusByOrders( afterInfoOrders, resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn(str + warnStr.substitute( err=err, here='3.4 update signals status')) if isSubError > 0: # rollback: pdOrders = afterExecOrders self.rollbackHandleBacktestHistoryCreatEvent( sgn, pdOrders, exchange, resInfoSymbol) raise Exception( errStr.substitute( here='3.4 update signals status')) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair( sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # print('3. after signals after update:\n%s' % sgn.signals()) # 3.5 update isError isMore = sgn.backtestSignalsIsRunMore(resInfoSymbol) if not isMore: isError = 0 except (DBException, CalcException, EngineException, Exception) as err: errStr = "src.core.engine.handler.Handler.handleBacktestHistoryCreatEvent: { type=%s, priority=%s, args=%s }, err=%s" % ( event.type, event.priority, event.args, err) self._logger.error(errStr) callback(event.id)
def rollbackHandleBacktestHistoryCreatEvent(self, sgn, pdOrders, exchange, resInfoSymbol): self._logger.debug( "src.core.engine.handler.Handler.rollbackHandleBacktestHistoryCreatEvent" ) try: db = DB() # update orders sgn status infoOrders = [] if not pdOrders.empty: for server in exchange: res = [] orderIDs = pdOrders[( pdOrders['server'] == server)]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: infoOrders.extend(res) if not infoOrders == []: infoOrders = pd.DataFrame(infoOrders) isError = SIGNAL_MAX_NUM while isError > 0: try: isError = isError - 1 sgn.backtestUpdateSignalStatusByOrders( infoOrders, resInfoSymbol) isError = 0 except Exception as err: self._logger.warn('rollback failed, will try again...') if isError > 0: raise Exception( 'rollback error, start_base assets may loss control.') # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair(sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # rollback assets isError = SIGNAL_MAX_NUM while isError > 0: isError = isError - 1 # calc after orders afterOrders = [] isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 afterOrders = sgn.backtestSignalsAfterTrade( resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn('rollback failed, will try again...') if isSubError > 0: raise Exception( 'rollback error, start_base assets may loss control.') # calc afterExecOrders afterExecOrders = [] if not afterOrders == []: for order in afterOrders: identify = identify + 1 isSubError = SIGNAL_MAX_NUM res = [] while isSubError > 0: try: isSubError = isSubError - 1 res = db.insertCreatTradeBacktestHistory( order['server'], order['fSymbol'], order['tSymbol'], order['ask_or_bid'], order['price'], order['quantity'], order['ratio'], order['type'], order['signal_id'], order['group_id'], identify) isSubError = 0 except Exception as err: self._logger.warn( 'rollback failed, will try again...') if not res == []: afterExecOrders.extend(res) if isSubError > 0: raise Exception( 'rollback error, start_base assets may loss control.' ) # calc afterInfoOrders afterInfoOrders = [] if not afterExecOrders == []: afterExecOrders = pd.DataFrame(afterExecOrders) for server in exchange: res = [] orderIDs = preExecOrders[( preExecOrders['server'] == server )]['order_id'].tolist() res = db.getTradeBacktestHistoryServerOrder([server], orderIDs) if not res == []: afterInfoOrders.extend(res) # update signals status if not afterInfoOrders == []: afterInfoOrders = pd.DataFrame(afterInfoOrders) isSubError = SIGNAL_MAX_NUM while isSubError > 0: try: isSubError = isSubError - 1 sgn.backtestUpdateSignalStatusByOrders( afterInfoOrders, resInfoSymbol) isSubError = 0 except Exception as err: self._logger.warn( 'rollback failed, will try again...') if isSubError > 0: raise Exception( 'rollback error, start_base assets may loss control.' ) # insert db signals db.insertSignalTradeDis(sgn.signals(exchange, [TYPE_DIS]), SIGNAL_BACKTEST) db.insertSignalTradeTra(sgn.signals(exchange, [TYPE_TRA]), SIGNAL_BACKTEST) db.insertSignalTradePair( sgn.signals(exchange, [TYPE_PAIR]), SIGNAL_BACKTEST) # update isError isMore = sgn.backtestSignalsIsRunMore(resInfoSymbol) if not isMore: isError = 0 except Exception as err: errStr = "src.core.engine.handler.Handler.rollbackHandleBacktestHistoryCreatEvent, err=%s" % err self._logger.critical(errStr)