def initLogEngine(self):
"""初始化日志引擎"""
if not globalSetting["logActive"]:
return
# 创建引擎
self.logEngine = LogEngine()
# 设置日志级别
levelDict = {
"debug": LogEngine.LEVEL_DEBUG,
"info": LogEngine.LEVEL_INFO,
"warn": LogEngine.LEVEL_WARN,
"error": LogEngine.LEVEL_ERROR,
"critical": LogEngine.LEVEL_CRITICAL,
}
level = levelDict.get(globalSetting["logLevel"],
LogEngine.LEVEL_CRITICAL)
self.logEngine.setLogLevel(level)
# 设置输出
if globalSetting['logConsole']:
self.logEngine.addConsoleHandler()
if globalSetting['logFile']:
self.logEngine.addFileHandler()
def __init__(self, url, apikey, secretkey):
self.__url = url
self.__apikey = apikey
self.__secretkey = secretkey
if not self.logger:
OKCoinFuture.logger = LogEngine()
def __init__(self, url, ot_key, ot_secret):
self.__url = url
self.__apikey = ot_key
self.__secretkey = ot_secret
if not self.logger:
OneTokenRestful.logger = LogEngine()
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 run(self):
if self.running:
return
self.running = True
le = LogEngine()
self.le = le
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.addFileHandler()
le.info(u'启动CTA策略守护父进程')
DAY_START = time(8, 45) # 日盘启动和停止时间
DAY_END = time(15, 30)
NIGHT_START = time(20, 45) # 夜盘启动和停止时间
NIGHT_END = time(2, 45)
self.process = None # 子进程句柄
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 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():
"""主程序入口"""
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():
"""子进程运行函数"""
# 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策略运行子进程')
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 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 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 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 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():
"""主程序入口"""
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 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 runParentProcess():
"""父进程运行函数"""
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.info('启动CTA策略守护父进程')
# DAY_START = time(8, 59) # 日盘启动和停止时间1
# DAY_END = time(10, 16)
# DAY_START2 = time(10, 29) # 日盘启动和停止时间2
# DAY_END2 = time(11, 31)
# DAY_START3 = time(13, 29) # 日盘启动和停止时间3
# DAY_END3 = time(15, 1)
# NIGHT_START = time(20, 59) # 夜盘启动和停止时间
# NIGHT_END = time(23, 31)
p = None # 子进程句柄
while True:
# currentTime = datetime.now().time()
recording = True ##7天24小时无限制运行，False为限制运行条件
# 判断当前处于的时间段
# if ((currentTime >= DAY_START and currentTime <= DAY_END) or
# (currentTime >= DAY_START2 and currentTime <= DAY_END2) or
# (currentTime >= DAY_START3 and currentTime <= DAY_END3) or
# (currentTime >= NIGHT_START and currentTime <= NIGHT_END)):
# recording = True
# if datetime.today().weekday() == 5 or datetime.today().weekday() == 6:
# recording = False
# 记录时间则需要启动子进程
if recording and p is None:
le.info('启动子进程')
p = multiprocessing.Process(target=runChildProcess)
p.start()
le.info('子进程启动成功')
# 非记录时间则退出子进程
if not recording and p is not None:
le.info('关闭子进程')
p.terminate()
p.join()
p = None
le.info('子进程关闭成功')
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)
# 添加交易接口
me.addGateway(ctpGateway)
# 添加上层应用
me.addApp(ctaStrategy)
me.addApp(rpcService)
le.info(u'主引擎创建成功')
# 阻塞运行
le.info(u'服务器启动成功')
while 1:
sleep(1)
class SignalScaningEngine(object):
"""
信号扫描回测引擎
函数接口和信号引擎保持一样，
从而实现同一套代码从回测到实盘。
"""
TICK_MODE = 'tick'
BAR_MODE = 'bar'
DB_DATA_TYPE = 'DB'
FILE_DATA_TYPE = 'FILE'
#----------------------------------------------------------------------
def __init__(self):
"""Constructor"""
self.dataStartDate = None # 回测数据开始日期，String
self.dataEndDate = None # 回测数据结束日期，String
self.dt = None # 最新的时间
self.logList = [] # 日志记录
self.datatype = self.DB_DATA_TYPE
# 日志引擎实例
self.logEngine = None
self.initLogEngine()
#----------------------------------------------------------------------
def initLogEngine(self):
"""初始化日志引擎"""
if not globalSetting["logActive"]:
return
# 创建引擎
self.logEngine = LogEngine()
# 设置日志级别
levelDict = {
"debug": LogEngine.LEVEL_DEBUG,
"info": LogEngine.LEVEL_INFO,
"warn": LogEngine.LEVEL_WARN,
"error": LogEngine.LEVEL_ERROR,
"critical": LogEngine.LEVEL_CRITICAL,
}
level = levelDict.get(globalSetting["logLevel"],
LogEngine.LEVEL_CRITICAL)
self.logEngine.setLogLevel(level)
# 设置输出
if globalSetting['logConsole']:
self.logEngine.addConsoleHandler()
if globalSetting['logFile']:
self.logEngine.addFileHandler()
# 注册事件监听
#self.registerLogEvent(EVENT_LOG)
#------------------------------------------------
# 通用功能
#------------------------------------------------
#----------------------------------------------------------------------
def roundToPriceTick(self, price):
"""取整价格到合约最小价格变动"""
if not self.priceTick:
return price
newPrice = round(price / self.priceTick, 0) * self.priceTick
return newPrice
#----------------------------------------------------------------------
def output(self, content):
"""输出内容"""
print(str(datetime.now()) + "\t" + content)
#------------------------------------------------
# 参数设置相关
#------------------------------------------------
#----------------------------------------------------------------------
def setStartDate(self, startDate='20100416', initDays=0):
"""设置回测的启动日期"""
self.dataStartDate = startDate
# self.initDays = initDays
# self.dataStartDate = datetime.strptime(startDate, '%Y%m%d')
# initTimeDelta = timedelta(initDays)
# self.strategyStartDate = self.dataStartDate + initTimeDelta
#----------------------------------------------------------------------
def setEndDate(self, endDate='20100416'):
self.dataEndDate = endDate
#----------------------------------------------------------------------
def setBacktestingMode(self, mode):
"""设置回测模式"""
self.mode = mode
#----------------------------------------------------------------------
def setDatabase(self, dbName, symbol):
"""设置历史数据所用的数据库"""
self.dbName = dbName
self.symbol = symbol
#----------------------------------------------------------------------
def setSize(self, size):
"""设置合约大小"""
self.size = size
#----------------------------------------------------------------------
def setPriceTick(self, priceTick):
"""设置价格最小变动"""
self.priceTick = priceTick
#------------------------------------------------
# 数据回放相关
#------------------------------------------------
#----------------------------------------------------------------------
def loadHistoryData(self):
# 首先根据回测模式，确认要使用的数据类
if self.mode == self.BAR_MODE:
dataClass = VtBarData
func = self.newBar
else:
dataClass = VtTickData
func = self.newTick
if self.datatype == self.DB_DATA_TYPE:
pass
else:
pass
"""载入历史数据"""
self.dbClient = pymongo.MongoClient(globalSetting['mongoHost'],
globalSetting['mongoPort'])
collection = self.dbClient[self.dbName][self.symbol]
self.output(u'开始载入数据')
# 载入初始化需要用的数据
strStartDate = self.dataStartDate
strEndDate = self.dataEndDate
msg = u'data length:%s %s', strStartDate, strEndDate
print(msg)
flt = {'date': {'$gte': strStartDate, '$lt': strStartDate}}
initCursor = collection.find(flt).sort('datetime')
print('flt:', flt)
print(self.dbName, self.symbol)
# 将数据从查询指针中读取出，并生成列表
self.initData = [] # 清空initData列表
for d in initCursor:
data = dataClass()
data.__dict__ = d
self.initData.append(data)
# 载入回测数据
if not self.dataEndDate:
flt = {
'date': {
'$gte': strStartDate
}
} # 数据过滤条件 self.strategyStartDate
else:
flt = {
'date': {
"$gte": strStartDate,
"$lte": strEndDate
}
} # self.dataEndDate
self.dbCursor = collection.find(flt).sort('datetime')
print('flt:', flt)
print(self.dbName, self.symbol)
if isinstance(self.dbCursor, list):
count = len(initCursor) + len(self.dbCursor)
else:
count = initCursor.count() + self.dbCursor.count()
self.output(u'载入完成，数据量：%s' % count)
#----------------------------------------------------------------------
def runBacktesting(self):
"""运行回测"""
# 载入历史数据
self.loadHistoryData()
# 首先根据回测模式，确认要使用的数据类
if self.mode == self.BAR_MODE:
dataClass = VtBarData
func = self.newBar
else:
dataClass = VtTickData
func = self.newTick
self.output(u'开始回测')
#self.strategy.onInit()
#self.strategy.inited = True
self.output(u'策略初始化完成')
self.strategy.trading = True
self.strategy.onStart()
self.output(u'策略启动完成')
self.output(u'开始回放数据')
for d in self.dbCursor:
data = dataClass()
data.__dict__ = d
func(data)
self.output(u'数据回放结束')
#----------------------------------------------------------------------
def newBar(self, bar):
"""新的K线"""
self.bar = bar
self.dt = bar.datetime
self.strategy.onBar(bar) # 推送K线到策略中
self.updateDailyClose(bar.datetime, bar.close)
#----------------------------------------------------------------------
def newTick(self, tick):
"""新的Tick"""
self.tick = tick
self.dt = tick.datetime
self.strategy.onTick(tick)
self.updateDailyClose(tick.datetime, tick.lastPrice)
#----------------------------------------------------------------------
def initStrategy(self, signalClass, setting=None):
"""
初始化策略
setting是策略的参数设置，如果使用类中写好的默认设置则可以不传该参数
"""
self.strategy = signalClass(self, setting, signalClass.templateName)
self.strategy.name = self.strategy.className
#------------------------------------------------
# 策略接口相关
#------------------------------------------------
#----------------------------------------------------------------------
def subscribe(self, call, vtSymbol):
"""回测中忽略"""
pass
def putStrategyEvent(self, name):
"""发送策略更新事件，回测中忽略"""
pass
#----------------------------------------------------------------------
def putVarEvent(self, call, d):
"""更新变量"""
pass
#----------------------------------------------------------------------
def putParamEvent(self, call, d):
"""发送策略更新事件，回测中忽略"""
pass
#----------------------------------------------------------------------
def insertData(self, dbName, collectionName, data):
"""考虑到回测中不允许向数据库插入数据，防止实盘交易中的一些代码出错"""
pass
#----------------------------------------------------------------------
def putSignalEvent(self, signal, d):
"""出现信号"""
signalName = signal.signalName
d['signalName'] = signalName
# event = Event(EVENT_SIGNAL_PARAM)
# event.dict_['data'] = d
# self.eventEngine.put( event )
# self.mainEngine.dbInsert( SIGNALTRADING_DB_NAME, SIGNAL_COLLECTION_NAME, d)
# print( d )
self.log('debug', d)
def log(self, level, msg):
if (level == 'debug'):
self.logEngine.debug(msg)
if (level == 'info'):
self.logEngine.info(msg)
if (level == 'warn'):
self.logEngine.warn(msg)
if (level == 'error'):
self.logEngine.error(msg)
pass
#----------------------------------------------------------------------
def loadBar(self, dbName, collectionName, startDate):
"""直接返回初始化数据列表中的Bar"""
return self.initData
#----------------------------------------------------------------------
def loadTick(self, dbName, collectionName, startDate):
"""直接返回初始化数据列表中的Tick"""
return self.initData
#----------------------------------------------------------------------
def writeLog(self, content):
"""记录日志"""
log = str(self.dt) + ' ' + content
self.logList.append(log)
#----------------------------------------------------------------------
def saveSyncData(self, strategy):
"""保存同步数据（无效）"""
pass
#----------------------------------------------------------------------
def getPriceTick(self, strategy):
"""获取最小价格变动"""
return self.priceTick
#----------------------------------------------------------------------
def sendSignal(self, signal): # VtSignal = type(signal)
pass
#----------------------------------------------------------------------
def updateDailyClose(self, datetime, lastPrice):
pass
from multiprocessing import Process
import webbrowser
from webServer import run as runWebServer
from tradingServer import main as runTradingServer
from vnpy.trader.vtEngine import LogEngine
START_TIME = time(20, 45)
CLOSE_TIME = time(15, 30)
if __name__ == '__main__':
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
# 进入循环
pWeb = None
pTrading = None
import os
print(os.getpid())
while True:
le.info('-'*30)
dt = datetime.now()
le.info(u'当前时间：%s' %dt)
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 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():
"""子进程运行函数"""
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():
"""子进程运行函数"""
# 创建日志引擎
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)
# 创建日志引擎
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 runChildProcess():
"""子进程运行函数"""
print('-'*20)
# 创建日志引擎，其实在MainEngine中会创建日志引擎的，
# 不过为了能在这里就可以使用，就先创建了，反正是singlon模式
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接口初始化
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('-' * 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('启动行情记录运行子进程')
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 runParentProcess():
"""父进程运行函数"""
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.info('启动行情记录守护父进程')
DAY_START = time(8, 57) # 日盘启动和停止时间
DAY_END = time(15, 18)
NIGHT_START = time(20, 57) # 夜盘启动和停止时间
NIGHT_END = time(2, 33)
p = None # 子进程句柄
while True:
currentTime = datetime.now().time()
recording = False
# 判断当前处于的时间段
if ((currentTime >= DAY_START and currentTime <= DAY_END) or
(currentTime >= NIGHT_START) or
(currentTime <= NIGHT_END)):
recording = True
# 过滤周末时间段：周六全天，周五夜盘，周日日盘
if ((datetime.today().weekday() == 6) or
(datetime.today().weekday() == 5 and currentTime > NIGHT_END) or
(datetime.today().weekday() == 0 and currentTime < DAY_START)):
recording = False
# 记录时间则需要启动子进程
if recording and p is None:
le.info('启动子进程')
p = multiprocessing.Process(target=runChildProcess)
p.start()
le.info('子进程启动成功')
# 非记录时间则退出子进程
if not recording and p is not None:
le.info('关闭子进程')
p.terminate()
p.join()
p = None
le.info('子进程关闭成功')
sleep(5)
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)
from __future__ import print_function
from time import sleep
from datetime import datetime, time
from multiprocessing import Process
from webServer import run as runWebServer
from tradingServer import main as runTradingServer
from vnpy.trader.vtEngine import LogEngine
START_TIME = time(20, 45)
CLOSE_TIME = time(15, 30)
if __name__ == '__main__':
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
# 进入循环
pWeb = None
pTrading = None
while True:
le.info('-' * 30)
dt = datetime.now()
le.info(u'当前时间：%s' % dt)
currentTime = dt.time()
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 '-' * 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'主引擎创建成功')
ee.register(EVENT_LOG, le.processLogEvent)
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)
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 runParentProcess():
"""父进程运行函数"""
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.info(u'启动CTA策略守护父进程')
DAY_START = time(8, 45) # 日盘启动和停止时间
DAY_END = time(15, 30)
NIGHT_START = time(20, 45) # 夜盘启动和停止时间
NIGHT_END = time(2, 45)
p = None # 子进程句柄
while True:
currentTime = datetime.now().time()
recording = False
# 判断当前处于的时间段
if ((currentTime >= DAY_START and currentTime <= DAY_END) or
(currentTime >= NIGHT_START) or
(currentTime <= NIGHT_END)):
recording = True
# 记录时间则需要启动子进程
if recording and p is None:
le.info(u'启动子进程')
p = multiprocessing.Process(target=runChildProcess)
p.start()
le.info(u'子进程启动成功')
# 非记录时间则退出子进程
if not recording and p is not None:
le.info(u'关闭子进程')
p.terminate()
p.join()
p = None
le.info(u'子进程关闭成功')
sleep(5)
def runParentProcess():
"""父进程运行函数"""
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.info(u'启动CTA策略守护父进程')
DAY_START = time(8, 45) # 日盘启动和停止时间
DAY_END = time(15, 30)
NIGHT_START = time(20, 45) # 夜盘启动和停止时间
NIGHT_END = time(2, 45)
p = None # 子进程句柄
while True:
currentTime = datetime.now().time()
recording = False
# 判断当前处于的时间段
if ((currentTime >= DAY_START and currentTime <= DAY_END) or
(currentTime >= NIGHT_START) or
(currentTime <= NIGHT_END)):
recording = True
# 记录时间则需要启动子进程
if recording and p is None:
le.info(u'启动子进程')
p = multiprocessing.Process(target=runChildProcess)
p.start()
le.info(u'子进程启动成功')
# 非记录时间则退出子进程
if not recording and p is not None:
le.info(u'关闭子进程')
p.terminate()
p.join()
p = None
le.info(u'子进程关闭成功')
sleep(5)
def runParentProcess():
"""父进程运行函数,限制交易时间"""
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
le.info('启动行情记录守护父进程')
DAY_START = time(8, 59) # 日盘启动和停止时间1
DAY_END = time(10, 16)
DAY_START2 = time(10, 29) # 日盘启动和停止时间2
DAY_END2 = time(11, 31)
DAY_START3 = time(13, 29) # 日盘启动和停止时间3
DAY_END3 = time(15, 0o1)
NIGHT_START = time(20, 59) # 夜盘启动和停止时间
NIGHT_END = time(23, 31)
p = None # 子进程句柄
while True:
currentTime = datetime.now().time()
recording = False
# 判断当前处于的时间段
if ((currentTime >= DAY_START and currentTime <= DAY_END)
or (currentTime >= DAY_START2 and currentTime <= DAY_END2)
or (currentTime >= DAY_START3 and currentTime <= DAY_END3)
or (currentTime >= NIGHT_START and currentTime <= NIGHT_END)):
recording = True
if datetime.today().weekday() == 5 or datetime.today().weekday() == 6:
recording = False
# 记录时间则需要启动子进程
if recording and p is None:
le.info('启动子进程')
p = multiprocessing.Process(target=runChildProcess)
p.start()
le.info('子进程启动成功')
# 非记录时间则退出子进程
if not recording and p is not None:
le.info('关闭子进程')
p.terminate()
p.join()
p = None
le.info('子进程关闭成功')
sleep(5)
import multiprocessing
from datetime import datetime, time
from time import sleep
from vnpy.event import EventEngine2
from vnpy.trader.app import dataRecorder
from vnpy.trader.gateway import ctpGateway
from vnpy.trader.vtEngine import MainEngine, LogEngine
from vnpy.trader.vtEvent import EVENT_LOG
from vnpy.trader.vtFunction import sendRecordErrorEmail
#监控写文件的时间格式
TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
# 创建日志引擎
le = LogEngine()
le.setLogLevel(le.LEVEL_INFO)
le.addConsoleHandler()
#----------------------------------------------------------------------
def runChildProcess():
"""子进程运行函数"""
le.info(u'启动行情记录运行子进程')
ee = EventEngine2()
le.info(u'事件引擎创建成功')
me = MainEngine(ee, le)
me.addGateway(ctpGateway)
