class VtServer(RpcServer):
"""vn.trader服务器"""
#----------------------------------------------------------------------
def __init__(self, repAddress, pubAddress):
"""Constructor"""
super(VtServer, self).__init__(repAddress, pubAddress)
self.usePickle()
# 创建主引擎对象
self.engine = MainEngine()
for gw_name in init_gateway_names['CTP']:
print('add {0}'.format(gw_name))
self.engine.addGateway(ctpGateway, gw_name)
# 注册主引擎的方法到服务器的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.engine.eventEngine.registerGeneralHandler(self.eventHandler)
#----------------------------------------------------------------------
def eventHandler(self, event):
"""事件处理"""
self.publish(event.type_, event)
#----------------------------------------------------------------------
def stopServer(self):
"""停止服务器"""
# 关闭引擎
self.engine.exit()
# 停止服务器线程
self.stop()
class VtServer(RpcServer):
"""vn.trader服务器"""
#----------------------------------------------------------------------
def __init__(self, repAddress, pubAddress):
"""Constructor"""
super(VtServer, self).__init__(repAddress, pubAddress)
self.usePickle()
# 创建主引擎对象
self.engine = MainEngine()
for gw_name in init_gateway_names['CTP']:
print( 'add {0}'.format(gw_name))
self.engine.addGateway(ctpGateway, gw_name)
# 注册主引擎的方法到服务器的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.engine.eventEngine.registerGeneralHandler(self.eventHandler)
#----------------------------------------------------------------------
def eventHandler(self, event):
"""事件处理"""
self.publish(event.type_, event)
#----------------------------------------------------------------------
def stopServer(self):
"""停止服务器"""
# 关闭引擎
self.engine.exit()
# 停止服务器线程
self.stop()
class VtServer(RpcServer):
"""vn.trader服务器"""
#----------------------------------------------------------------------
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 eventHandler(self, event):
"""事件处理"""
self.publish(event.type_, event)
#----------------------------------------------------------------------
def stopServer(self):
"""停止服务器"""
# 关闭引擎
self.engine.exit()
# 停止服务器线程
self.stop()
class VtServer(RpcServer):
"""vn.trader服务器"""
#----------------------------------------------------------------------
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 eventHandler(self, event):
"""事件处理"""
self.publish(event.type_, event)
#----------------------------------------------------------------------
def stopServer(self):
"""停止服务器"""
# 关闭引擎
self.engine.exit()
# 停止服务器线程
self.stop()
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
class VtServer(RpcServer):
"""
---vn.trader服务器：
注册主引擎方法
注册通用事件处理函数
运行服务器
"""
# ----------------------------------------------------------------------
def __init__(self, repAddress, pubAddress):
"""构造器"""
super(VtServer, self).__init__(repAddress, pubAddress)
# 使用cPickle作为数据的序列化工具
self.usePickle()
# 创建主引擎对象
self.engine = MainEngine()
for gw_name in init_gateway_names['CTP']:
print('add {0}'.format(gw_name))
# ？
self.engine.addGateway(ctpGateway, gw_name)
# 注册vtEngine的MainEngine的方法到Rpc服务器的功能函数字典__functions
self.register(self.engine.connect) # 连接特定名称的接口
self.register(self.engine.disconnect) # 断开底层gateway的连接
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) # 保存策略的数据
# 将通用事件处理函数注册到__generalHandlers中
# __generalHandlers：用来保存通用回调函数（所有事件均调用）
self.engine.eventEngine.registerGeneralHandler(self.eventHandler)
# ----------------------------------------------------------------------
def eventHandler(self, event):
"""事件处理"""
# 打包数据，广播发送
self.publish(event.type_, event)
# ----------------------------------------------------------------------
def stopServer(self):
"""停止服务器"""
# 关闭主引擎
self.engine.exit()
# 停止服务器线程
self.stop()
class MarketService(TradeService):
def __init__(self, name):
TradeService.__init__(self, name)
self.active = False # 工作状态
self.queue = Queue() # 队列
self.thread = Thread(target=self.threadDataFanout) # 线程
self.ee = None
self.mainEngine = None
self.logger = instance.getLogger()
self.symbols = {} # 已经订阅的合约
self.contracts = OrderedDict()
self.ticks_counter = 0
self.ticks_samples = []
self.tick_filters = []
self.market_ticks = {} # 相同的coin存在多市场的即时报价
# 'BTC':{
# 'BINANCE': {'open':11,'close':12,'gateway':'BINANCE','ask',..'bid'},
# 'OKEX': {'open': 11, 'close': 12, 'gateway': 'OKEX', 'ask',..'bid'},
# }
def init(self, cfgs, **kwargs):
self.service_id = cfgs.get('id')
self.service_type = ServiceType.MarketAdapter
super(MarketService, self).init(cfgs)
self.initFilters()
def syncDownServiceConfig(self):
TradeService.syncDownServiceConfig(self)
def setupFanoutAndLogHandler(self):
from mantis.trade.log import TradeServiceLogHandler
self.initFanoutSwitchers(self.cfgs.get('fanout'))
handler = TradeServiceLogHandler(self)
self.logger.addHandler(handler)
def start(self, block=True):
self.setupFanoutAndLogHandler()
# 创建日志引擎
super(MarketService, self).start()
self.active = True
self.thread.start()
le = self.logger
# le = LogEngine()
# le.setLogLevel(le.LEVEL_INFO)
# le.addConsoleHandler()
le.info(u'启动行情记录运行子进程')
self.ee = EventEngine()
le.info(u'事件引擎创建成功')
self.mainEngine = MainEngine(self.ee) # 忽略掉 默认的 DataEngine
self.registerEvent()
le.info(u'主引擎创建成功')
for gw in self.cfgs.get('gateways'):
gateway = None
if gw.get('name').upper() == binanceGateway.gatewayName:
gateway = binanceGateway
if gateway:
self.mainEngine.addGateway(gateway)
self.mainEngine.connect(gateway.gatewayName, gw)
le.info(u'注册日志事件监听')
le.info(u'连接CTP接口')
def processLogEvent(self, event):
print event
def processErrorEvent(self, event):
"""
处理错误事件
错误信息在每次登陆后，会将当日所有已产生的均推送一遍，所以不适合写入日志
"""
error = event.dict_['data']
print u'错误代码：%s，错误信息：%s' % (error.errorID, error.errorMsg)
def stop(self):
super(MarketService, self).stop()
self.mainEngine.exit()
if self.active:
self.active = False
# self.thread.join()
def join(self):
self.thread.join()
# def subscribe(self,*symbols):
# for symbol in symbols:
# if not self.symbols.has_key(symbol):
# req = VtSubscribeReq()
# req.symbol = symbol
# self.mainEngine.subscribe(req, xtpGateway.gatewayName) # XTP
# self.symbols[symbol] = symbol
#
# if not symbols :
# self.mainEngine.subscribe(None,xtpGateway.gatewayName) # 订阅全市场所有股票
#
# def unsubscribe(self,*symbols):
# for s in symbols:
# if s in self.symbols.keys():
# del self.symbols[s]
def getSymbols(self):
return list(self.contracts.keys())
def procecssTickEvent(self, event):
"""处理行情事件"""
tick = event.dict_['data']
# tick = self.filterTicks(tick)
# print 'Tick:',tick
if tick:
# 生成datetime对象
if not tick.datetime:
# tick.datetime = datetime.strptime(' '.join([tick.date, tick.time]), '%Y%m%d %H:%M:%S.%f')
tick.service = self.getServiceType() + '.' + self.getServiceId(
)
self.queue.put(tick)
def initFilters(self):
from mantis.fundamental.utils.importutils import import_class
for clsname in self.cfgs.get('xtp_tick_filters', []):
cls = import_class(clsname)
filter = cls()
self.tick_filters.append(filter)
def filterTicks(self, tick):
"""必须同时满足所有filter数据检查条件"""
for f in self.tick_filters:
tick = f.validate(tick)
if not tick:
break
return tick
def registerEvent(self):
"""注册事件监听"""
self.ee.register(EVENT_TICK, self.procecssTickEvent)
self.ee.register(EVENT_LOG, self.processLogEvent)
self.ee.register(EVENT_ERROR, self.processErrorEvent)
self.ee.register(EVENT_CONTRACT, self.processContractEvent)
# def subscribeAllContracts(self):
# for symbol in self.contracts.keys():
# req = VtSubscribeReq()
# req.symbol = symbol
# req.exchange = EXCHANGE_SSE
# # self.mainEngine.subscribe( req, xtpGateway.gatewayName) # CTP
# self.mainEngine.subscribe( None, xtpGateway.gatewayName) # CTP
def processContractEvent(self, event):
"""处理合约事件
连接交易系统之后,会通过此接口接收到CTP所有当前合约
"""
# contract = event.dict_['data']
# self.contracts[ contract.vtSymbol] = contract
# if contract.last:
# # start contract subscribe
# self.subscribeAllContracts()
pass
def threadDataFanout(self):
"""运行插入线程"""
while self.active:
try:
# print 'current tick queue size:', self.queue.qsize()
# dbName, collectionName, d = self.queue.get(block=True, timeout=1)
tick = self.queue.get(block=True, timeout=1)
symbol = tick.vtSymbol
dt = datetime.datetime.strptime(
' '.join([tick.date, tick.time]), '%Y%m%d %H:%M:%S.%f')
tick.ts = datetime_to_timestamp(dt) # 合约生成时间
tick.ts_host = int(time.time()) # 主机系统时间
jsondata = json.dumps(tick.__dict__)
self.dataFanout('switch0', jsondata, symbol=symbol)
# 多交易所的价格聚合
content = self.market_ticks.get(symbol)
if not content:
content = {}
self.market_ticks[tick.symbol] = content
content[tick.exchange] = tick.__dict__
jsondata = json.dumps(content)
self.dataFanout('switch1', jsondata, symbol=symbol)
# -- cache current tick into redis ---
key_name = CoinMarketSymbolTickFormat.format(
symbol=tick.vtSymbol)
redis = instance.datasourceManager.get('redis').conn
# redis.hmset(key_name, tick.__dict__)
redis.set(key_name, jsondata)
# self.ticks_counter += 1
# if len(self.ticks_samples) > 5:
# del self.ticks_samples[0]
# self.ticks_samples.append(tick.__dict__)
except Exception as e:
# self.logger.error( str(e) )
pass
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 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()
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()
