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(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)
