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(okexGateway)
me.addApp(dataRecorder)
le.info(u'主引擎创建成功')
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_ERROR, processErrorEvent)
le.info(u'注册日志事件监听')
me.connect('OKEX')
le.info(u'连接OKEX接口')
while True:
sleep(1)
def main():
"""主程序入口"""
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.addFileHandler()
le.info('服务器进程启动')
# 创建事件引擎
ee = EventEngine2()
le.info('事件引擎创建成功')
# 创建主引擎
me = MainEngine(ee)
# 添加交易接口
me.addGateway(ctpGateway)
# 添加上层应用
me.addApp(ctaStrategy)
me.addApp(rpcService)
le.info('主引擎创建成功')
# 阻塞运行
le.info('服务器启动成功')
while 1:
sleep(1)
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():
"""子进程运行函数"""
# 创建日志引擎
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接口')
has_recorder_day = False
while True:
sleep(1)
if has_recorder_day == False:
time_now = datetime.now()
if time_now.time().hour > 15 and time_now.time().minute > 5:
event1 = Event(type_=EVENT_RECORDER_DAY)
ee.put(event1)
has_recorder_day = True
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 __init__(self, repAddress, pubAddress):
"""Constructor"""
super(VtServer, self).__init__(repAddress, pubAddress)
self.usePickle()
# 创建事件引擎
self.ee = EventEngine2()
# 创建主引擎对象
self.engine = MainEngine(self.ee)
# 注册主引擎的方法到服务器的RPC函数
self.register(self.engine.connect)
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.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.getAllGatewayDetails)
# 注册事件引擎发送的事件处理监听
self.engine.eventEngine.registerGeneralHandler(self.eventHandler)
def runChildProcess():
"""子进程运行函数"""
print('-' * 20)
# 创建日志引擎
le = setup_logger(filename='logs/vnpy.log', debug=False)
# 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接口')
while True:
sleep(1)
def runChildProcess():
"""子进程运行函数"""
print('-' * 20)
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.info('启动行情记录运行子进程')
ee = EventEngine2()
le.info('事件引擎创建成功')
me = MainEngine(ee)
me.addGateway(ctpGateway)
me.addApp(dataRecorder)
le.info('主引擎创建成功')
ee.register(EVENT_LOG, le.processLogEvent)
le.info('注册日志事件监听')
me.connect('CTP')
le.info('连接CTP接口')
while True:
sleep(1)
def runChildProcess():
"""子进程运行函数"""
# print('-'*20)
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_WARN)
# le.addConsoleHandler()
le.addFileHandler()
le.info(u'启动CTA策略运行子进程')
ee = EventEngine2()
le.info(u'事件引擎创建成功')
me = MainEngine(ee)
me.addGateway(ctpGateway)
me.addGateway(ibGateway)
me.addApp(riskManager)
me.addApp(ctaStrategy)
# me.addApp(dataRecorder)
le.info(u'主引擎创建成功')
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_CTA_LOG, le.processLogEvent)
le.info(u'注册日志事件监听')
me.connect('IB')
le.info(u'连接IB接口')
sleep(5) # 等待接口初始化
me.connect('CTP')
le.info(u'连接CTP接口')
# sleep(10) # 等待接口初始化
can_done1 = Event()
can_done1.wait(timeout=10)
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:
can_done2 = Event()
can_done2.wait(timeout=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)
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 run(self):
print('-' * 30)
self.running = True
# 创建日志引擎
le = LogEngine()
self.le = le
le.setLogLevel(le.LEVEL_INFO)
# le.addConsoleHandler()
# le.addFileHandler()
le.info(u'启动CTA策略运行子进程')
ee = EventEngine2()
self.ee = ee
le.info(u'事件引擎创建成功')
me = MainEngine(ee)
self.me = me
me.addGateway(okexfGateway)
me.addGateway(huobiGateway)
me.addGateway(binanceGateway)
me.addGateway(bitmexGateway)
me.addGateway(oandaGateway)
if is_windows:
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'注册日志事件监听')
for gw in self.get_gateways(me):
le.info(u'连接Gateway[%s]的行情和交易接口' % gw)
me.connect(gw)
sleep(5) # 等待接口初始化
me.dataEngine.saveContracts() # 保存合约信息到文件
cta = me.getApp(ctaStrategy.appName)
self.cta = cta
le.info(u"读取策略配置")
cta.loadSetting()
le.info(u"初始化所有策略")
cta.initAll()
le.info(u"开始所有策略")
cta.startAll()
def runChildProcess():
"""子进程运行函数"""
print '*' * 50
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.addFileHandler()
le.info(u'marketMaker childProcess is working')
ee = EventEngine2()
me = MainEngine(ee)
le.info(u'MainEngine has been established')
me.addGateway(huobiGateway)
le.info(u'huobiGateway has been established')
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_MMK_LOG, le.processLogEvent)
ee.register(EVENT_ERROR, processError)
le.info(u'register log event monitor')
me.connect('HUOBI')
le.info(u'connect huobiGateway')
sleep(5) # 等待CTP接口初始化
# for k,v in me.dataEngine.contractDict.items():
# print '%s:%s' % (k,v.__dict__)
me.addApp(mmkStrategy)
mmk = me.getApp(mmkStrategy.appName)
mmk.loadSetting()
# le.info(u'MMK策略载入成功')
mmk.initAll()
# le.info(u'MMK策略初始化成功')
mmk.startAll()
# le.info(u'MMK策略启动成功')
while True:
sleep(10)
def runChildProcess():
"""子进程运行函数"""
print '*' * 50
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.addFileHandler()
le.info(u'tab childProcess is working')
ee = EventEngine2()
me = MainEngine(ee)
le.info(u'MainEngine has been established')
me.addGateway(binanceGateway)
le.info(u'binanceGateway has been established')
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_ERROR, processError)
ee.register(EVENT_TABTRADING_LOG, le.processLogEvent)
ee.register(EVENT_TABTRADING_ALGOLOG, le.processLogEvent)
le.info(u'register log event monitor')
me.connect('BINANCE')
le.info(u'connect binanceGateway')
sleep(5) # 等待CTP接口初始化
# for k,v in me.dataEngine.contractDict.items():
# print '%s:%s' % (k,v.__dict__)
me.addApp(tabStrategy_binance)
tab = me.getApp(tabStrategy_binance.appName)
tab.init()
le.info(u'tabEngine_binance has been inited')
# tab.algoEngine.startAlgo()
# le.info(u'tabAlgo已启动')
# tab.startAll()
# le.info(u'CTA策略启动成功')
while True:
sleep(10)
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(futuGateway)
me.addApp(ctaStrategy)
le.info(u'主引擎创建成功')
def process_error(event):
error = event.dict_['data']
le.error(error.errorMsg)
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_ERROR, process_error)
ee.register(EVENT_CTA_LOG, le.processLogEvent)
le.info(u'注册日志事件监听')
me.connect('FUTU')
le.info(u'连接CTP接口')
sleep(5) # 等待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 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.connect('CTP')
le.info(u'连接CTP接口')
sleep(10) # 等待CTP接口初始化
print("hehe")
me.updateDominant()
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(u'启动CTA策略运行子进程')
ee = EventEngine2()
le.info(u'事件引擎创建成功')
me = MainEngine(ee)
me.addGateway(ctpGateway)
me.addApp(dailyStrategy)
#me.addApp(rpcService) ##先不加
le.info(u'主引擎创建成功')
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_DAILY_LOG, le.processLogEvent)
ee.register(EVENT_ERROR,le.processErrorEvent)
le.info(u'注册日志事件监听')
me.connect('CTP')
le.info(u'连接CTP接口')
le.setMysqlClient(me.mysqlClient) ##日志写数据库
sleep(5) # 等待CTP接口初始化
cta = me.getApp(dailyStrategy.appName)
cta.loadSetting()
le.info(u'CTA策略载入成功')
cta.initAll()
le.info(u'CTA策略初始化成功')
cta.startAll()
le.info(u'CTA策略启动成功')
while True:
sleep(1)
def run_strategy():
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
ee = EventEngine2()
me = MainEngine(ee)
me.addGateway(gateway)
me.addApp(ctaStrategy)
# ee.register(EVENT_LOG, le.processLogEvent)
# ee.register(EVENT_CTA_LOG, le.processLogEvent)
me.connect(gateway.gatewayName)
gw = me.getGateway(gateway.gatewayName)
cta = me.getApp(ctaStrategy.appName)
cta.settingfilePath = "CTA_setting.json"
cta.loadSetting()
cta.initAll()
cta.startAll()
def runChildProcess():
"""子进程运行函数"""
# print('-'*20)
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_WARN)
# le.addConsoleHandler()
le.addFileHandler()
le.info(u'启动CTA策略运行子进程')
ee = EventEngine2()
le.info(u'事件引擎创建成功')
me = MainEngine(ee)
me.addGateway(onetokenGateway)
me.addApp(riskManager)
me.addApp(ctaStrategy)
# me.addApp(dataRecorder)
le.info(u'主引擎创建成功')
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_CTA_LOG, le.processLogEvent)
le.info(u'注册日志事件监听')
me.connect('ONETOKEN')
le.info(u'连接1token接口')
sleep(5) # 等待接口初始化
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)
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 run(self, monitor=False):
self.running = True
# 创建日志引擎
le = LogEngine()
self.le = le
le.setLogLevel(le.LEVEL_INFO)
# le.addConsoleHandler()
# le.addFileHandler()
le.info(u'启动CTA策略运行子进程')
ee = EventEngine2()
self.ee = ee
le.info(u'事件引擎创建成功')
self.handle_rs_setting()
me = initialize_main_engine(ee)
self.me = me
le.info(u'主引擎创建成功')
ee.register(EVENT_LOG, le.processLogEvent)
ee.register(EVENT_CTA_LOG, le.processLogEvent)
ee.register(EVENT_ERROR, processErrorEvent)
le.info(u'注册日志事件监听')
for gw in self.get_gateways(me):
le.info(u'连接Gateway[%s]的行情和交易接口' % gw)
me.connect(gw)
sleep(5) # 等待接口初始化
me.dataEngine.saveContracts() # 保存合约信息到文件
cta = me.getApp(ctaStrategy.appName)
self.cta = cta
le.info(u"读取策略配置")
cta.loadSetting()
le.info(u"初始化所有策略")
cta.initAll()
if monitor:
cta.enablePlugin(CtaStrategyInfoPlugin)
le.info(u"开始所有策略")
cta.startAll()
def main():
"""客户端主程序入口"""
# 创建事件引擎
eventEngine = EventEngine2()
eventEngine.start(timer=False)
# 创建客户端
reqAddress = 'tcp://localhost:2014'
subAddress = 'tcp://localhost:0602'
client = VtClient(reqAddress, subAddress, eventEngine)
client.subscribeTopic('')
client.start()
# 初始化主引擎和主窗口对象
mainEngine = ClientEngine(client, eventEngine)
mainWindow = MainWindow(mainEngine, mainEngine.eventEngine)
mainWindow.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('-' * 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 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 __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
from vnpy.event import EventEngine2
from vnpy.trader.vtZcEngine import DbEngine
from vnpy.trader.vtConstant import (DIRECTION_LONG, DIRECTION_SHORT,
STATUS_NOTTRADED, STATUS_PARTTRADED, STATUS_UNKNOWN,
PRICETYPE_MARKETPRICE)
from vnpy.trader.vtSendMail import SendEmail
import pandas as pd
# 自定义日志级别
LOG_DEBUG = 10
LOG_INFO = 20
LOG_IMPORTANT = 30
LOG_ERROR = 40
# 全局公用的数据库引擎
eeEE = EventEngine2()
mydb = DbEngine(eeEE)
"""
对于一个交易单位的封装，设定目标仓位后自动进行仓位管理
"""
class Cell(object):
def __init__(self, vtSymbol, direction, target_unit, plan_in_price, in_condition):
self.vtSymbol = vtSymbol # 合约
self.open_direction = direction # 买卖方向
self.target_unit = target_unit # 目标仓位
self.plan_in_price = plan_in_price # 计划入场价格
self.in_condition = in_condition # 入场条件 1:20日突破 2:55日突破 3:0.5N 4:移仓
except NameError:
pass # Python 3
# 创建主引擎代理对象
from vnpy.event import EventEngine2
from vnpy.trader.vtEvent import (EVENT_TICK, EVENT_ORDER, EVENT_TRADE,
EVENT_ACCOUNT, EVENT_POSITION, EVENT_LOG,
EVENT_ERROR, EVENT_CONTRACT)
from vnpy.trader.vtObject import VtSubscribeReq, VtOrderReq, VtCancelOrderReq
from vnpy.trader.app.rpcService.rsClient import MainEngineProxy
from vnpy.trader.app.ctaStrategy.ctaBase import EVENT_CTA_LOG, EVENT_CTA_STRATEGY
reqAddress = 'tcp://localhost:6688'
subAddress = 'tcp://localhost:8866'
ee = EventEngine2()
me = MainEngineProxy(ee)
me.init(reqAddress, subAddress)
#----------------------------------------------------------------------
def printLog(event):
"""打印日志"""
log = event.dict_['data']
print(log.logTime, log.logContent)
ee.register(EVENT_LOG, printLog)
# 载入Web密码
import json