def no_ui_run():
ee = EventEngine()
me = MainEngine(ee)
me.connect('CTP')
me.dbConnect()
ce = CtaEngine(me, ee)
ce.loadSetting()
# strategyManager = CtaStrategyManager(self.ctaEngine, self.eventEngine, name)
ce.initAll()
ce.startAll()
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)
ee.register(EVENT_ERROR, processErrorEvent)
le.info(u'注册日志事件监听')
me.dbConnect()
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 runBacktestingProcess():
"""子进程运行函数"""
print('-' * 20)
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.addFileHandler()
le.info(u'启动CTA策略运行子进程')
ee = EventEngine2()
me = MainEngine(ee)
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.dbConnect()
le.info("连接数据库")
cta = me.getApp(ctaStrategy.appName)
cta.loadSetting()
le.info(u'CTA策略载入成功')
cta.setBackTestingMode()
le.info(u'运行CTA策略回测')
cta.runBacktesting()
cta.stopAll()
ee.stop()
while True:
sleep(1)
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'strategyAtrRsi']
self.g_count = 0
self.disconnect_signal = 0
self.last_dt = datetime.now()
# 实例化 主引擎
print u'instance mainengine'
self.mainEngine = MainEngine()
self.mainEngine.addGateway(ctpGateway, self.gateway_name)
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 strategy {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)
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)
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")
