def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(secGateway) me.addGateway(ctpGateway) me.addGateway(ctpsecGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(optionMaster) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'服务器进程启动') # 创建事件引擎 ee = EventEngine2() le.info(u'事件引擎创建成功') # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) # 添加上层应用 me.addApp(ctaStrategy) me.addApp(rpcService) le.info(u'主引擎创建成功') # 阻塞运行 le.info(u'服务器启动成功') while 1: sleep(1)
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ccxtGateway) me.addGateway(coinbaseGateway) me.addGateway(lbankGateway) me.addGateway(bigoneGateway) me.addGateway(fcoinGateway) me.addGateway(bitmexGateway) me.addGateway(huobiGateway) me.addGateway(okexGateway) me.addGateway(binanceGateway) me.addGateway(bitfinexGateway) # 添加上层应用 me.addApp(algoTrading) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def runChildProcess(): """子进程运行函数""" print '-'*20 printLog(u'启动CTA策略运行子进程') ee = EventEngine2() printLog(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(ctaStrategy) printLog(u'主引擎创建成功') ee.register(EVENT_LOG, processLogEvent) ee.register(EVENT_CTA_LOG, processCtaLogEvent) printLog(u'注册日志事件监听') me.connect('CTP') printLog(u'连接CTP接口') sleep(5) # 等待CTP接口初始化 cta = me.appDict[ctaStrategy.appName] cta.loadSetting() printLog(u'CTA策略载入成功') cta.initAll() printLog(u'CTA策略初始化成功') cta.startAll() printLog(u'CTA策略启动成功') while True: sleep(1)
def main(): """主程序入口""" le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'启动JAQS服务进程') ee = EventEngine() le.info(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(jaqsService) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_JS_LOG, le.processLogEvent) le.info(u'注册日志事件监听') me.connect('CTP') le.info(u'连接CTP接口') while True: sleep(1)
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) me.addGateway(oandaGateway) me.addGateway(ibGateway) me.addGateway(huobiGateway) me.addGateway(okcoinGateway) if system == 'Windows': me.addGateway(femasGateway) me.addGateway(xspeedGateway) me.addGateway(sgitGateway) me.addGateway(shzdGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) me.addApp(spreadTrading) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def runChildProcess(): """子进程运行函数""" print '-'*20 # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.info(u'启动行情记录运行子进程') ee = EventEngine2() le.info(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(dataRecorder) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) le.info(u'注册日志事件监听') me.connect('CTP') le.info(u'连接CTP接口') while True: sleep(1)
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(futuGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) me.addApp(spreadTrading) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" logger = setup_logger(filename='logs/vnpy.log', debug=False) # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine2() # 初始化主引擎和主窗口对象 mainEngine = MainEngine(ee) mainEngine.logger = logger # 添加Gatway for gw_name in init_gateway_names['CTP']: print('add {0}'.format(gw_name)) mainEngine.addGateway(ctpGateway, gw_name) # 添加应用 mainEngine.addApp(ctaStrategy) mainEngine.addApp(riskManager) mainEngine.addApp(spreadTrading) mainWindow = MainWindow(mainEngine, ee) mainWindow.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def runChildProcess(): """子进程运行函数""" print('-'*20) # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'启动CTA策略运行子进程') ee = EventEngine2() le.info(u'事件引擎创建成功') me = MainEngine(ee) le.info(u'bbbbbbbbbbbbbbbbbbbbbbbbbbbbb') me.addGateway(ctpGateway) sleep(10) # 等待CTP接口初始化 le.info(u'aaaaaaaaaaaaaaaaaaaaaaaaaaa') me.addApp(ctaStrategy) me.addApp(weixinRecorder) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_CTA_LOG, le.processLogEvent) ee.register(EVENT_ERROR, processErrorEvent) le.info(u'注册日志事件监听') me.connect('CTP') le.info(u'连接CTP接口') sleep(10) # 等待CTP接口初始化 me.dataEngine.saveContracts() # 保存合约信息到文件 cta = me.getApp(ctaStrategy.appName) cta.loadSetting() le.info(u'CTA策略载入成功') cta.initAll() le.info(u'CTA策略初始化成功') cta.startAll() le.info(u'CTA策略启动成功') while True: sleep(1)
def runChildProcess(): """子进程运行函数""" print('-' * 20) # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info('启动CTA策略运行子进程') ee = EventEngine2() le.info('事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(ctaStrategy) le.info('主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_CTA_LOG, le.processLogEvent) le.info('注册日志事件监听') me.connect('CTP') le.info('连接CTP接口') sleep(5) # 等待CTP接口初始化 cta = me.appDict[ctaStrategy.appName] cta.loadSetting() le.info('CTA策略载入成功') cta.initAll() le.info('CTA策略初始化成功') cta.startAll() le.info('CTA策略启动成功') while True: sleep(1)
def runChildProcess(): """子进程运行函数""" print '-'*20 # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'启动CTA策略运行子进程') ee = EventEngine2() le.info(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(ctaStrategy) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_CTA_LOG, le.processLogEvent) le.info(u'注册日志事件监听') me.connect('CTP') le.info(u'连接CTP接口') sleep(10) # 等待CTP接口初始化 cta = me.getApp(ctaStrategy.appName) cta.loadSetting() le.info(u'CTA策略载入成功') cta.initAll() le.info(u'CTA策略初始化成功') cta.startAll() le.info(u'CTA策略启动成功') while True: sleep(1)
def main(): """主程序入口""" print("main start") # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口, 包括行情数据接口和交易接口两部分 print("添加gateway接口, addGatewayClass") me.addGatewayClass(eastMoneyGateway) # 添加上层应用, 应用管理 #me.addApp(strategyManager) print("添加上层应用, addRiskCtrlClass") me.addRiskCtrlClass(riskCtrl1) print("添加上层应用, addStrategyClass") me.addStrategyClass(strategyDualThrust) me.addStrategyClass(strategyAtrRsi) me.addStrategyClass(strategyMacdShake) me.addApp(dataRecorder) print("添加上层应用, dataRecorder") # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 qApp.exec_() try: me.exit() sys.exit(0) except: print('GoodBye!') pass
def main(): """主程序入口""" # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def runChildProcess(): """子进程运行函数""" print '-'*20 printLog(u'启动行情记录运行子进程') ee = EventEngine2() printLog(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(dataRecorder) printLog(u'主引擎创建成功') ee.register(EVENT_LOG, processLogEvent) printLog(u'注册日志事件监听') me.connect('CTP') printLog(u'连接CTP接口') while True: sleep(1)
def runChildProcess(): """子进程运行函数""" print '-' * 20 printLog(u'启动行情记录运行子进程') ee = EventEngine2() printLog(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(dataRecorder) printLog(u'主引擎创建成功') ee.register(EVENT_LOG, processLogEvent) printLog(u'注册日志事件监听') me.connect('CTP') printLog(u'连接CTP接口') while True: sleep(1)
def main(): """主程序入口""" # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(stubNullGateway) # 添加上层应用 me.addApp(riskManager) print("1111111") me.addApp(stubStrategy) me.addApp(dataRecorder) print("22222") # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 qApp.exec_() sys.exit(0)
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) me.addGateway(ibGateway) if system == 'Windows': me.addGateway(femasGateway) me.addGateway(xspeedGateway) me.addGateway(secGateway) if system == 'Linux': me.addGateway(xtpGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) me.addApp(spreadTrading) me.addApp(algoTrading) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" logger = setup_logger(filename='logs/vnpy.log', debug=False) # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine2() # 初始化主引擎和主窗口对象 mainEngine = MainEngine(ee) mainEngine.logger = logger # 添加Gatway for gw_name in init_gateway_names['CTP_SE']: print('add {0}'.format(gw_name)) mainEngine.addGateway(ctpseGateway, gw_name) # 添加应用 mainEngine.addApp(ctaStrategy) mainEngine.addApp(riskManager) mainEngine.addApp(spreadTrading) mainEngine.addApp(dataRecorder) mainWindow = MainWindow(mainEngine, ee) mainWindow.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" # 创建事件引擎 ee = EventEngine2() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) me.addGateway(femasGateway) me.addGateway(xspeedGateway) me.addGateway(sgitGateway) me.addGateway(oandaGateway) me.addGateway(ibGateway) me.addGateway(shzdGateway) me.addGateway(huobiGateway) me.addGateway(okcoinGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(dataRecorder) me.addApp(ctaStrategy) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def runChildProcess(): """子进程运行函数""" print('-' * 30) # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) # le.addConsoleHandler() # le.addFileHandler() le.info(u'启动CTA策略运行子进程') ee = EventEngine2() le.info(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(okexGateway) me.addApp(ctaStrategy) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_CTA_LOG, le.processLogEvent) ee.register(EVENT_ERROR, processErrorEvent) le.info(u'注册日志事件监听') key = findConnectKey() me.connect(key) le.info(u'连接行情和交易接口') sleep(5) # 等待Gateway接口初始化 me.dataEngine.saveContracts() # 保存合约信息到文件 # 加载CTA策略 cta = me.getApp(ctaStrategy.appName) cta.loadSetting() cta.initAll() cta.startAll() while True: sleep(1)
def runChildProcess(): """子进程运行函数""" print('-' * 20) # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.info(u'启动行情记录运行子进程') ee = EventEngine2() le.info(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(dataRecorder) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_ERROR, processErrorEvent) le.info(u'注册日志事件监听') me.connect('CTP') le.info(u'连接CTP接口') #获取全部合约信息并自动订阅 contracts = me.getAllContracts() while len(contracts) == 0: sleep(1) contracts = me.getAllContracts() print(u"共获取" + str(len(contracts)) + u"条合约信息") for contract in contracts: if contract.productClass == u"期货": req = VtSubscribeReq() req.symbol = contract.symbol me.subscribe(req, contract.gatewayName) me.getApp(dataRecorder.appName).tickSymbolSet.add(req.symbol) while True: sleep(1)
def main(): """主程序入口""" le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'服务器进程启动') # 创建事件引擎 ee = EventEngine2() le.info(u'事件引擎创建成功') # 创建主引擎 me = MainEngine(ee) # 安全退出机制 def shutdown(signal, frame): le.info(u'安全关闭进程') me.exit() sys.exit() for sig in [signal.SIGINT, signal.SIGTERM]: signal.signal(sig, shutdown) # 添加交易接口 me.addGateway(ctpGateway) # 添加上层应用 me.addApp(ctaStrategy) me.addApp(rpcService) cta = me.getApp(ctaStrategy.appName) le.info(u'主引擎创建成功') cta.loadSetting() le.info(u'CTA策略载入成功') # 阻塞运行 le.info(u'服务器启动成功') while 1: sleep(1)
def main(): """主程序入口""" le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'服务器进程启动') # 创建事件引擎 ee = EventEngine2() le.info(u'事件引擎创建成功') # 创建主引擎 me = MainEngine(ee) # 安全退出机制 def shutdown(signal, frame): le.info(u'安全关闭进程') me.exit() sys.exit() for sig in [signal.SIGINT, signal.SIGTERM]: signal.signal(sig, shutdown) # 添加交易接口 me.addGateway(ctpGateway) # 添加上层应用 me.addApp(ctaStrategy) me.addApp(rpcService) le.info(u'主引擎创建成功') # 阻塞运行 le.info(u'服务器启动成功') while 1: sleep(1)
def runChildProcess(): """子进程运行函数""" le.info(u'启动行情记录运行子进程') ee = EventEngine2() le.info(u'事件引擎创建成功') me = MainEngine(ee, le) me.addGateway(ctpGateway) me.addApp(dataRecorder) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) le.info(u'注册日志事件监听') me.connect('CTP', dataRecorder.appName) le.info(u'连接CTP接口') while True: #向文件写时间 write_time() sleep(5)
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) # 添加上层应用 me.addApp(jaqsService) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(okexGateway) me.addGateway(huobiGateway) me.addGateway(binanceGateway) me.addGateway(bitmexGateway) me.addGateway(oandaGateway) if is_windows: me.addGateway(ctpGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) #me.addApp(algoTrading) # me.addApp(dataRecorder) # me.addApp(spreadTrading) # me.addApp(optionMaster) # me.addApp(jaqsService) # me.addApp(rpcService) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def initialize_main_engine(ee): # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(okexGateway) me.addGateway(huobiGateway) me.addGateway(binanceGateway) me.addGateway(bitmexGateway) me.addGateway(oandaGateway) if is_windows: me.addGateway(ctpGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) #me.addApp(algoTrading) # me.addApp(dataRecorder) # me.addApp(spreadTrading) # me.addApp(optionMaster) # me.addApp(jaqsService) me.addApp(rpcService) return me
def __init__(self,name): multiprocessing.Process.__init__(self) #self.fileName = fileName #self.ee = EventEngine2() #成员变量 # 创建日志引擎 self.name = name le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() self.le = le ee = EventEngine2() self.le.info(u'事件引擎创建成功') me = MainEngine(ee) me.addGateway(ctpGateway) me.addApp(ctaStrategy) self.le.info(u'主引擎创建成功') ee.register(EVENT_LOG, self.le.processLogEvent) ee.register(EVENT_CTA_LOG, self.le.processLogEvent) ee.register(EVENT_ERROR, processErrorEvent) self.le.info(u'注册日志事件监听') self.me = me
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(secGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(optionMaster) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) # 添加上层应用 me.addApp(dailyMonitorManager) # me.addApp(spreadTrading) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 me.addGateway(ctpGateway) #me.addGateway(ibGateway) if system == 'Windows': pass # me.addGateway(femasGateway) # me.addGateway(xspeedGateway) # me.addGateway(secGateway) if system == 'Linux': me.addGateway(xtpGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) # me.addApp(spreadTrading) me.addApp(algoTrading) me.addApp(signalMonitor) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() #启动后自动连接CTP, 同时也连接了数据库 me.connect("CTP") #订阅观察的品种,测试性能 #subFutures() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
def main(): """主程序入口""" # 创建Qt应用对象 qApp = createQApp() # 创建事件引擎 ee = EventEngine() # 创建主引擎 me = MainEngine(ee) # 添加交易接口 # me.addGateway(ctpGateway) # me.addGateway(oandaGateway) # me.addGateway(ibGateway) # me.addGateway(huobiGateway) # me.addGateway(okcoinGateway) if system == 'Windows': me.addGateway(femasGateway) me.addGateway(xspeedGateway) if system == 'Linux': me.addGateway(onetokenGateway) if system == 'Darwin': me.addGateway(onetokenGateway) # 添加上层应用 me.addApp(riskManager) me.addApp(ctaStrategy) me.addApp(spreadTrading) me.addApp(dataRecorder) # 创建主窗口 mw = MainWindow(me, ee) mw.showMaximized() # 在主线程中启动Qt事件循环 sys.exit(qApp.exec_())
class VtServer(RpcServer): """vn.trader 无界面服务器""" # ---------------------------------------------------------------------- def __init__(self, repAddress, pubAddress): """Constructor""" super(VtServer, self).__init__(repAddress, pubAddress) #self.usePickle() # gateway 是否连接 self.connected = False # gateway 的连接名称,在vtEngine.initGateway()里面定义,对应的配置文件是 "连接名称_connect.json", self.gateway_name = AUTO_CONNCET_GW # 启动的策略实例,须在catStrategy/CtaSetting.json 里面定义 [u'S28_RB1001', u'S28_TFT', u'S28_HCRB',u'atr_rsi'] self.strategies = [u'S30_RB0510', u'S30_HCRB05'] self.g_count = 0 self.disconnect_signal = 0 self.last_dt = datetime.now() # 创建事件引擎 ee = EventEngine2() # 创建主引擎对象 print( u'instance mainengine') self.engine = MainEngine(ee) # 添加CTP Gateway,配置文件为 CTP_Post self.engine.addGateway(ctpGateway, self.gateway_name) # 添加应用 self.engine.addApp(ctaStrategy) self.engine.addApp(riskManager) # 注册主引擎的方法到服务器的RPC函数 self.register(self.engine.connect) self.register(self.engine.disconnect) self.register(self.engine.subscribe) self.register(self.engine.sendOrder) self.register(self.engine.cancelOrder) self.register(self.engine.qryAccount) self.register(self.engine.qryPosition) self.register(self.engine.checkGatewayStatus) # 检测gateway的连接状态 self.register(self.engine.qryStatus) # 检测ctaEngine的状态 self.register(self.engine.exit) self.register(self.engine.writeLog) self.register(self.engine.dbConnect) self.register(self.engine.dbInsert) self.register(self.engine.dbQuery) self.register(self.engine.dbUpdate) self.register(self.engine.getContract) self.register(self.engine.getAllContracts) self.register(self.engine.getOrder) self.register(self.engine.getAllWorkingOrders) self.register(self.engine.getAllGatewayNames) self.register(self.engine.saveData) self.register(self.engine.initStrategy) self.register(self.engine.startStrategy) self.register(self.engine.stopStrategy) # 注册事件引擎发送的事件处理监听 self.engine.eventEngine.registerGeneralHandler(self.eventHandler) def trade_off(self): """检查现在是否为非交易时间""" now = datetime.now() a = datetime.now().replace(hour=2, minute=35, second=0, microsecond=0) b = datetime.now().replace(hour=8, minute=55, second=0, microsecond=0) c = datetime.now().replace(hour=15, minute=30, second=0, microsecond=0) d = datetime.now().replace(hour=20, minute=55, second=0, microsecond=0) weekend = (now.isoweekday() == 6 and now >= a) or (now.isoweekday() == 7) or (now.isoweekday() == 1 and now <=b) off = (a <= now <= b) or (c <= now <= d) or weekend return off def disconnect(self): """"断开底层gateway的连接""" if self.engine: self.engine.disconnect(self.gateway_name) self.connected = False def onTimer(self, event): """定时器执行逻辑,每十秒执行一次""" # 十秒才执行一次检查 self.g_count += 1 if self.g_count <= 30: return self.g_count = 0 dt = datetime.now() self.engine.qryStatus() if dt.hour != self.last_dt.hour: self.last_dt = dt print(u'noUiMain.py checkpoint:{0}'.format(dt)) self.engine.writeLog( u'noUiMain.py checkpoint:{0}'.format(dt)) # 定时断开 if self.trade_off(): """非交易时间""" if self.connected: self.engine.writeLog(u'断开连接{0}'.format(self.gateway_name)) self.disconnect() self.engine.writeLog(u'清空数据引擎') self.engine.clearData() self.connected = False self.engine.writeNotification(u'非交易时间{0},断开连接{1}'.format(dt, self.gateway_name)) return # 交易时间内,定时重连和检查 if not self.connected: self.engine.writeLog(u'启动连接{0}'.format(self.gateway_name)) self.engine.writeLog(u'清空数据引擎') self.engine.clearData() self.engine.writeLog(u'重新连接{0}'.format(self.gateway_name)) self.engine.connect(self.gateway_name) self.connected = True self.disconnect_signal = 0 self.engine.writeNotification(u'{0},重新连接{1}'.format(dt, self.gateway_name)) return else: if not self.engine.checkGatewayStatus(self.gateway_name): self.disconnect_signal += 1 if self.disconnect_signal >= 5: self.engine.writeWarning(u'检查连接{0}异常,超过{1}次'.format(self.gateway_name,self.disconnect_signal)) sys.exit(0) else: self.disconnect_signal = 0 def start(self): """启动""" super(VtServer, self).start() # 若需要连接数据库,则启动 # self.mainEngine.dbConnect() # 加载cta的配置 print( u'load cta setting') self.engine.ctaEngine.loadSetting() print(u'initialize all strategies') # 初始化策略,如果多个,则需要逐一初始化多个 for s in self.strategies: print( 'init trategy {0}'.format(s)) self.engine.ctaEngine.initStrategy(s) # 逐一启动策略 print( 'start strategy {0}'.format(s)) self.engine.ctaEngine.startStrategy(s) # 指定的连接配置 if not self.trade_off(): print( u'connect gateway:{0}'.format(self.gateway_name)) self.engine.connect(self.gateway_name) self.connected = True # 注册定时器,用于判断重连 self.engine.eventEngine.register(EVENT_TIMER, self.onTimer) # 所有的日志监控 self.logM = LogMonitor(self.engine.eventEngine) self.errorM = ErrorMonitor(self.engine.eventEngine) self.tradeM = TradeMonitor(self.engine.eventEngine) self.orderM = OrderMonitor(self.engine.eventEngine, self.engine) self.positionM = PositionMonitor(self.engine.eventEngine) self.accountM = AccountMonitor(self.engine.eventEngine) self.engine.writeNotification(u'{0},服务启动{1}'.format(datetime.now(),self. gateway_name)) # ---------------------------------------------------------------------- def eventHandler(self, event): """事件处理""" try: # 调用RpcServer.publish() if isinstance(event.type_, str): self.publish(event.type_, event) else: self.publish(event.type_.encode('utf-8'), event) except Exception as ex: print( u'event Handler exception:{0}'.format(str(ex))) # ---------------------------------------------------------------------- def stopServer(self): """停止服务器""" print( 'stopServer') # 关闭引擎 self.engine.exit() # 停止服务器线程 self.stop()
class VtServer(RpcServer): """vn.trader 无界面服务器""" # ---------------------------------------------------------------------- def __init__(self, repAddress, pubAddress): """Constructor""" super(VtServer, self).__init__(repAddress, pubAddress) #self.usePickle() # gateway 是否连接 self.connected = False # gateway 的连接名称,在vtEngine.initGateway()里面定义,对应的配置文件是 "连接名称_connect.json", self.gateway_name = AUTO_CONNCET_GW # 启动的策略实例,须在catStrategy/CtaSetting.json 里面定义 [u'S28_RB1001', u'S28_TFT', u'S28_HCRB',u'atr_rsi'] self.strategies = [u'S30_RB0510', u'S30_HCRB05'] self.g_count = 0 self.disconnect_signal = 0 self.last_dt = datetime.now() # 创建事件引擎 ee = EventEngine2() # 创建主引擎对象 print(u'instance mainengine') self.engine = MainEngine(ee) # 添加CTP Gateway,配置文件为 CTP_Post self.engine.addGateway(ctpGateway, self.gateway_name) # 添加应用 self.engine.addApp(ctaStrategy) self.engine.addApp(riskManager) # 注册主引擎的方法到服务器的RPC函数 self.register(self.engine.connect) self.register(self.engine.disconnect) self.register(self.engine.subscribe) self.register(self.engine.sendOrder) self.register(self.engine.cancelOrder) self.register(self.engine.qryAccount) self.register(self.engine.qryPosition) self.register(self.engine.checkGatewayStatus) # 检测gateway的连接状态 self.register(self.engine.qryStatus) # 检测ctaEngine的状态 self.register(self.engine.exit) self.register(self.engine.writeLog) self.register(self.engine.dbConnect) self.register(self.engine.dbInsert) self.register(self.engine.dbQuery) self.register(self.engine.dbUpdate) self.register(self.engine.getContract) self.register(self.engine.getAllContracts) self.register(self.engine.getOrder) self.register(self.engine.getAllWorkingOrders) self.register(self.engine.getAllGatewayNames) self.register(self.engine.saveData) self.register(self.engine.initStrategy) self.register(self.engine.startStrategy) self.register(self.engine.stopStrategy) # 注册事件引擎发送的事件处理监听 self.engine.eventEngine.registerGeneralHandler(self.eventHandler) def trade_off(self): """检查现在是否为非交易时间""" now = datetime.now() a = datetime.now().replace(hour=2, minute=35, second=0, microsecond=0) b = datetime.now().replace(hour=8, minute=55, second=0, microsecond=0) c = datetime.now().replace(hour=15, minute=30, second=0, microsecond=0) d = datetime.now().replace(hour=20, minute=55, second=0, microsecond=0) weekend = (now.isoweekday() == 6 and now >= a) or (now.isoweekday() == 7) off = (a <= now <= b) or (c <= now <= d) or weekend return off def disconnect(self): """"断开底层gateway的连接""" if self.engine: self.engine.disconnect(self.gateway_name) self.connected = False def onTimer(self, event): """定时器执行逻辑,每十秒执行一次""" # 十秒才执行一次检查 self.g_count += 1 if self.g_count <= 30: return self.g_count = 0 dt = datetime.now() self.engine.qryStatus() if dt.hour != self.last_dt.hour: self.last_dt = dt print(u'noUiMain.py checkpoint:{0}'.format(dt)) self.engine.writeLog(u'noUiMain.py checkpoint:{0}'.format(dt)) # 定时断开 if self.trade_off(): """非交易时间""" if self.connected: self.engine.writeLog(u'断开连接{0}'.format(self.gateway_name)) self.disconnect() self.engine.writeLog(u'清空数据引擎') self.engine.clearData() self.connected = False self.engine.writeNotification(u'非交易时间{0},断开连接{1}'.format( dt, self.gateway_name)) return # 交易时间内,定时重连和检查 if not self.connected: self.engine.writeLog(u'启动连接{0}'.format(self.gateway_name)) self.engine.writeLog(u'清空数据引擎') self.engine.clearData() self.engine.writeLog(u'重新连接{0}'.format(self.gateway_name)) self.engine.connect(self.gateway_name) self.connected = True self.disconnect_signal = 0 self.engine.writeNotification(u'{0},重新连接{1}'.format( dt, self.gateway_name)) return else: if not self.engine.checkGatewayStatus(self.gateway_name): self.disconnect_signal += 1 if self.disconnect_signal >= 5: self.engine.writeWarning(u'检查连接{0}异常,超过{1}次'.format( self.gateway_name, self.disconnect_signal)) sys.exit(0) else: self.disconnect_signal = 0 def start(self): """启动""" super(VtServer, self).start() # 若需要连接数据库,则启动 # self.mainEngine.dbConnect() # 加载cta的配置 print(u'load cta setting') self.engine.ctaEngine.loadSetting() print(u'initialize all strategies') # 初始化策略,如果多个,则需要逐一初始化多个 for s in self.strategies: print('init trategy {0}'.format(s)) self.engine.ctaEngine.initStrategy(s) # 逐一启动策略 print('start strategy {0}'.format(s)) self.engine.ctaEngine.startStrategy(s) # 指定的连接配置 if not self.trade_off(): print(u'connect gateway:{0}'.format(self.gateway_name)) self.engine.connect(self.gateway_name) self.connected = True # 注册定时器,用于判断重连 self.engine.eventEngine.register(EVENT_TIMER, self.onTimer) # 所有的日志监控 self.logM = LogMonitor(self.engine.eventEngine) self.errorM = ErrorMonitor(self.engine.eventEngine) self.tradeM = TradeMonitor(self.engine.eventEngine) self.orderM = OrderMonitor(self.engine.eventEngine, self.engine) self.positionM = PositionMonitor(self.engine.eventEngine) self.accountM = AccountMonitor(self.engine.eventEngine) self.engine.writeNotification(u'{0},服务启动{1}'.format( datetime.now(), self.gateway_name)) # ---------------------------------------------------------------------- def eventHandler(self, event): """事件处理""" try: # 调用RpcServer.publish() if isinstance(event.type_, str): self.publish(event.type_, event) else: self.publish(event.type_.encode('utf-8'), event) except Exception as ex: print(u'event Handler exception:{0}'.format(str(ex))) # ---------------------------------------------------------------------- def stopServer(self): """停止服务器""" print('stopServer') # 关闭引擎 self.engine.exit() # 停止服务器线程 self.stop()
class NoUiMain(object): def __init__(self): # gateway 是否连接 self.connected = False # gateway 的连接名称,在vtEngine.initGateway()里面定义,对应的配置文件是 "连接名称_connect.json", self.gateway_name = 'CTP' # 启动的策略实例,须在catAlgo/CtaSetting.json 里面定义 [u'S28_RB1001', u'S28_TFT', u'S28_HCRB',u'atr_rsi'] self.strategies = [u'S28_HCRB'] self.g_count = 0 self.disconnect_signal = 0 self.last_dt = datetime.now() # 创建事件引擎 ee = EventEngine2() # 实例化 主引擎 print(u'instance mainengine') self.mainEngine = MainEngine(ee) self.mainEngine.addGateway(ctpGateway, self.gateway_name) # 添加应用 self.mainEngine.addApp(ctaStrategy) self.mainEngine.addApp(riskManager) def trade_off(self): """检查现在是否为非交易时间""" now = datetime.now() a = datetime.now().replace(hour=2, minute=35, second=0, microsecond=0) b = datetime.now().replace(hour=8, minute=30, second=0, microsecond=0) c = datetime.now().replace(hour=15, minute=30, second=0, microsecond=0) d = datetime.now().replace(hour=20, minute=30, second=0, microsecond=0) weekend = (now.isoweekday() == 6 and now >= a) or (now.isoweekday() == 7) off = (a <= now <= b) or (c <= now <= d) or weekend return off def disconnect(self): """"断开底层gateway的连接""" if self.mainEngine: self.mainEngine.disconnect(self.gateway_name) self.connected = False def onTimer(self, event): """定时器执行逻辑,每十秒执行一次""" # 十秒才执行一次检查 self.g_count += 1 if self.g_count <= 30: return self.g_count = 0 dt = datetime.now() if dt.hour != self.last_dt.hour: self.last_dt = dt print(u'noUiMain.py checkpoint:{0}'.format(dt)) self.mainEngine.writeLog( u'noUiMain.py checkpoint:{0}'.format(dt)) # 定时断开 if self.trade_off(): """非交易时间""" if self.connected: self.mainEngine.writeLog(u'断开连接{0}'.format(self.gateway_name)) self.disconnect() self.mainEngine.writeLog(u'清空数据引擎') self.mainEngine.clearData() self.connected = False return # 交易时间内,定时重连和检查 if not self.connected: self.mainEngine.writeLog(u'启动连接{0}'.format(self.gateway_name)) self.mainEngine.writeLog(u'清空数据引擎') self.mainEngine.clearData() self.mainEngine.writeLog(u'重新连接{0}'.format(self.gateway_name)) self.mainEngine.connect(self.gateway_name) self.connected = True self.disconnect_signal = 0 return else: if not self.mainEngine.checkGatewayStatus(self.gateway_name): self.disconnect_signal += 1 if self.disconnect_signal >= 5: self.mainEngine.writeLog(u'检查连接{0}异常,重新启动连接'.format(self.gateway_name)) self.mainEngine.writeLog(u'断开连接{0}'.format(self.gateway_name)) self.disconnect() self.mainEngine.clearData() self.connected = False else: self.disconnect_signal = 0 # def Start(self): """启动""" # 若需要连接数据库,则启动 #self.mainEngine.dbConnect() # 加载cta的配置 print(u'load cta setting') self.mainEngine.ctaEngine.loadSetting() print(u'initialize all strategies') # 初始化策略,如果多个,则需要逐一初始化多个 for s in self.strategies: print( 'init trategy {0}'.format(s)) self.mainEngine.ctaEngine.initStrategy(s) # 逐一启动策略 print( 'start strategy {0}'.format(s)) self.mainEngine.ctaEngine.startStrategy(s) # 指定的连接配置 print( u'connect gateway:{0}'.format(self.gateway_name)) self.mainEngine.connect(self.gateway_name) self.connected = True # 注册定时器,用于判断重连 self.mainEngine.eventEngine.register(EVENT_TIMER, self.onTimer) # 所有的日志监控 self.logM = LogMonitor(self.mainEngine.eventEngine) self.errorM = ErrorMonitor(self.mainEngine.eventEngine) self.tradeM = TradeMonitor(self.mainEngine.eventEngine) self.orderM = OrderMonitor(self.mainEngine.eventEngine, self.mainEngine) self.positionM = PositionMonitor(self.mainEngine.eventEngine) self.accountM = AccountMonitor(self.mainEngine.eventEngine)
class VtServer(RpcServer): """vn.trader 无界面服务器""" # ---------------------------------------------------------------------- def __init__(self, repAddress, pubAddress): """Constructor""" super(VtServer, self).__init__(repAddress, pubAddress) #self.usePickle() # gateway 是否连接 self.connected = False # gateway 的连接名称,在vtEngine.initGateway()里面定义,对应的配置文件是 "连接名称_connect.json", self.gateway_name = AUTO_CONNCET_GW # 启动的策略实例,须在catStrategy/CtaSetting.json 里面定义 [u'S28_RB1001', u'S28_TFT', u'S28_HCRB',u'atr_rsi'] self.strategies = [] self.g_count = 0 self.disconnect_signal = 0 self.last_dt = datetime.now() # 创建事件引擎 ee = EventEngine2() # 创建主引擎对象 print(u'instance mainengine') self.engine = MainEngine(ee) # 添加Gateway, for gw_name in init_gateway_names.keys(): for gw_conf in init_gateway_names[gw_name]: print('add {}'.format(gw_conf)) self.engine.addGateway(gateway_model_dict[gw_name], gw_conf) # 添加应用 self.engine.addApp(cmaStrategy) # 注册主引擎的方法到服务器的RPC函数 self.register(self.engine.connect) self.register(self.engine.disconnect) self.register(self.engine.subscribe) self.register(self.engine.sendOrder) self.register(self.engine.cancelOrder) self.register(self.engine.qryAccount) self.register(self.engine.qryPosition) self.register(self.engine.checkGatewayStatus) # 检测gateway的连接状态 self.register(self.engine.qryStatus) # 检测ctaEngine的状态 self.register(self.engine.exit) self.register(self.engine.writeLog) self.register(self.engine.dbConnect) self.register(self.engine.dbInsert) self.register(self.engine.dbQuery) self.register(self.engine.dbUpdate) self.register(self.engine.getContract) self.register(self.engine.getAllContracts) self.register(self.engine.getOrder) self.register(self.engine.getAllWorkingOrders) self.register(self.engine.getAllGatewayNames) self.register(self.engine.saveData) self.register(self.engine.initStrategy) self.register(self.engine.startStrategy) self.register(self.engine.stopStrategy) # 注册事件引擎发送的事件处理监听 self.engine.eventEngine.registerGeneralHandler(self.eventHandler) def disconnect(self): """"断开底层gateway的连接""" if self.engine: self.engine.disconnect(self.gateway_name) self.connected = False def onTimer(self, event): """定时器执行逻辑,每十秒执行一次""" # 十秒才执行一次检查 self.g_count += 1 if self.g_count <= 30: return self.g_count = 0 dt = datetime.now() self.engine.qryStatus() if dt.hour != self.last_dt.hour: self.last_dt = dt print(u'noUiMain.py checkpoint:{0}'.format(dt)) self.engine.writeLog(u'noUiMain.py checkpoint:{0}'.format(dt)) # 交易时间内,定时重连和检查 if not self.connected: self.engine.writeLog(u'启动连接{0}'.format(self.gateway_name)) self.engine.writeLog(u'清空数据引擎') self.engine.clearData() for gw_name in self.gateway_name: self.engine.writeLog(u'重新连接{0}'.format(gw_name)) self.engine.connect(gw_name) self.connected = True self.disconnect_signal = 0 self.engine.writeNotification(u'{0},重新连接{1}'.format( dt, self.gateway_name)) return def start(self): """启动""" super(VtServer, self).start() # 若需要连接数据库,则启动 # self.mainEngine.dbConnect() # 加载cta的配置 print(u'load cma setting') self.engine.cmaEngine.loadSetting() print(u'initialize all strategies') # 初始化策略,如果多个,则需要逐一初始化多个 for s in self.strategies: print('init trategy {0}'.format(s)) self.engine.cmaEngine.initStrategy(s) # 逐一启动策略 print('start strategy {0}'.format(s)) self.engine.cmaEngine.startStrategy(s) for gw_name in self.gateway_name: self.engine.writeLog(u'connect gateway:{0}'.format(gw_name)) self.engine.connect(gw_name) self.connected = True # 注册定时器,用于判断重连 self.engine.eventEngine.register(EVENT_TIMER, self.onTimer) # 所有的日志监控 self.logM = LogMonitor(self.engine.eventEngine) self.errorM = ErrorMonitor(self.engine.eventEngine) self.tradeM = TradeMonitor(self.engine.eventEngine) self.orderM = OrderMonitor(self.engine.eventEngine, self.engine) self.positionM = PositionMonitor(self.engine.eventEngine) self.accountM = AccountMonitor(self.engine.eventEngine) self.engine.writeNotification(u'{0},服务启动{1}'.format( datetime.now(), self.gateway_name)) # ---------------------------------------------------------------------- def eventHandler(self, event): """事件处理""" try: # 调用RpcServer.publish() if isinstance(event.type_, str): self.publish(event.type_, event) else: self.publish(event.type_.encode('utf-8'), event) except Exception as ex: print(u'event Handler exception:{0}'.format(str(ex))) # ---------------------------------------------------------------------- def stopServer(self): """停止服务器""" print('stopServer') # 关闭引擎 self.engine.exit() # 停止服务器线程 self.stop()
def runChildProcess(): """子进程运行函数""" # print '-'*20 # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'启动行情记录运行子进程') # 创建主引擎 me = MainEngine() ee = me.eventEngine ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_CTA_LOG, le.processLogEvent) ee.register(EVENT_ERROR, processErrorEvent) try: # 添加交易接口 try: me.addGateway(ctpGateway) except: pass # 添加上层应用 me.addApp(riskManager) me.addApp(dataRecorder) #fix: 当服务端初始化完毕后再开启rpcService #me.addApp(rpcService) me.addApp(ctaStrategy) me.addApp(spreadTrading) me.addApp(algoTrading) le.info(u'主引擎创建成功') # 自动建立MongoDB数据库 me.dbConnect() le.info(u'connect MongoDB') # 自动建立CTP链接 me.connect('CTP') le.info(u'连接CTP接口') # 取仓位信息 me.qryPosition("CTP") while not me.getAllContracts(): sleep(5) le.info(u'收集合约信息...') sleep(3) le.info(u'合约信息中数量: %s' % len(me.getAllContracts())) # 及时保存数据引擎里的合约数据到硬盘 me.dataEngine.saveContracts() #服务端初始化完成 #开启RPC me.addApp(rpcService) le.info(u'开启RPCService') ''' bug-fix: 休息,以便于客户端连接上来收CTP信息 ''' sleep(5.) #CTP连接完成,发送重启信号 event = Event(EVENT_CTP_RESTARTED) me.eventEngine.put(event) le.info(u'通知客户端CTP RESTART') while True: sleep(1) except KeyboardInterrupt: le.info(u"Keyboard interrupt in process") finally: le.info(u"cleaning up")
def runChildProcess(): """子进程运行函数""" print('-' * 20) # 创建日志引擎 le = LogEngine() le.setLogLevel(le.LEVEL_INFO) le.addConsoleHandler() le.addFileHandler() le.info(u'启动CTA策略运行子进程') DAY_START = time(19, 00) # 日盘启动和停止时间 DAY_END = time(19, 43) cta = None # 子进程句柄 while True: currentTime = datetime.now().time() recording = False # 判断当前处于的时间段 if (currentTime >= DAY_START and currentTime <= DAY_END): recording = True else: le.info(u'未在启动时间段') # 记录时间则需要启动子进程 if recording and cta is None: ee = EventEngine2() #le.info(u'事件引擎创建成功') me = MainEngine(ee) #连接数据库 me.dbConnect() le.info("连接数据库") me.addGateway(tushareGateway) me.addApp(dataRecorderCT) me.addApp(ctaStrategy) le.info(u'主引擎创建成功') ee.register(EVENT_LOG, le.processLogEvent) ee.register(EVENT_CTA_LOG, le.processLogEvent) ee.register(EVENT_ERROR, processErrorEvent) le.info(u'注册日志事件监听') #连接数据接口 me.connect(tushareGateway.gatewayName) le.info(u'连接TUSHARE接口') #sleep(10) # 等待CTP接口初始化 cta = me.getApp(ctaStrategy.appName) cta.loadSetting() le.info(u'CTA策略载入成功') cta.initAll() le.info(u'CTA策略初始化成功') cta.startAll() le.info(u'CTA策略启动成功') # 非记录时间则退出子进程 if not recording and cta is not None: cta.stopAll() ee.stop() le.info(u'关闭子进程') return sleep(5)