394 lines
16 KiB
Python
394 lines
16 KiB
Python
# coding:utf-8
|
||
import time
|
||
import datetime
|
||
import traceback
|
||
import sys
|
||
import json
|
||
import os
|
||
import threading
|
||
import logging
|
||
from typing import Optional, Dict, Any, List
|
||
from dataclasses import dataclass
|
||
|
||
import redis
|
||
from xtquant import xtdata
|
||
from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
|
||
from xtquant.xttype import StockAccount
|
||
from xtquant import xtconstant
|
||
|
||
# ================= 0. Windows 补丁 =================
|
||
try:
|
||
import ctypes
|
||
kernel32 = ctypes.windll.kernel32
|
||
kernel32.SetConsoleMode(kernel32.GetStdHandle(-10), 128)
|
||
except:
|
||
pass
|
||
|
||
@dataclass
|
||
class TerminalStatus:
|
||
"""终端实例状态封装"""
|
||
qmt_id: str
|
||
alias: str
|
||
account_id: str
|
||
is_connected: bool
|
||
last_heartbeat: str
|
||
|
||
# ================= 1. 业务逻辑辅助类 =================
|
||
|
||
class PositionManager:
|
||
"""Redis 虚拟持仓管理（全局单例）"""
|
||
def __init__(self, r_client):
|
||
self.r = r_client
|
||
|
||
def _get_key(self, strategy_name):
|
||
return f"POS:{strategy_name}"
|
||
|
||
def mark_holding(self, strategy_name, code):
|
||
self.r.hsetnx(self._get_key(strategy_name), code, 0)
|
||
|
||
def rollback_holding(self, strategy_name, code):
|
||
key = self._get_key(strategy_name)
|
||
val = self.r.hget(key, code)
|
||
if val is not None and int(val) == 0:
|
||
self.r.hdel(key, code)
|
||
|
||
def update_actual_volume(self, strategy_name, code, delta_vol):
|
||
key = self._get_key(strategy_name)
|
||
new_vol = self.r.hincrby(key, code, int(delta_vol))
|
||
if new_vol <= 0:
|
||
self.r.hdel(key, code)
|
||
new_vol = 0
|
||
return new_vol
|
||
|
||
def get_position(self, strategy_name, code):
|
||
vol = self.r.hget(self._get_key(strategy_name), code)
|
||
return int(vol) if vol else 0
|
||
|
||
def get_holding_count(self, strategy_name):
|
||
return self.r.hlen(self._get_key(strategy_name))
|
||
|
||
def get_all_virtual_positions(self, strategy_name):
|
||
return self.r.hgetall(self._get_key(strategy_name))
|
||
|
||
def force_delete(self, strategy_name, code):
|
||
self.r.hdel(self._get_key(strategy_name), code)
|
||
|
||
class DailySettlement:
|
||
"""终端级别的日终对账"""
|
||
def __init__(self, unit):
|
||
self.unit = unit
|
||
self.has_settled = False
|
||
|
||
def run_settlement(self):
|
||
trader = self.unit.xt_trader
|
||
acc = self.unit.acc_obj
|
||
if not trader: return
|
||
|
||
real_positions = trader.query_stock_positions(acc)
|
||
real_pos_map = {p.stock_code: p.volume for p in real_positions if p.volume > 0} if real_positions else {}
|
||
|
||
manager = MultiEngineManager()
|
||
strategies = manager.get_strategies_by_terminal(self.unit.qmt_id)
|
||
for s_name in strategies:
|
||
virtual = manager.pos_manager.get_all_virtual_positions(s_name)
|
||
for code, v_str in virtual.items():
|
||
if code not in real_pos_map:
|
||
manager.pos_manager.force_delete(s_name, code)
|
||
elif int(v_str) == 0 and code in real_pos_map:
|
||
manager.pos_manager.update_actual_volume(s_name, code, real_pos_map[code])
|
||
self.has_settled = True
|
||
|
||
def reset_flag(self):
|
||
self.has_settled = False
|
||
|
||
# ================= 2. 执行单元 (TradingUnit) =================
|
||
|
||
class UnitCallback(XtQuantTraderCallback):
|
||
def __init__(self, unit):
|
||
self.unit = unit
|
||
self.is_connected = False
|
||
|
||
def on_disconnected(self):
|
||
logging.getLogger("QMT_Engine").warning(f"终端 {self.unit.alias}({self.unit.qmt_id}) 物理连接断开")
|
||
self.is_connected = False
|
||
|
||
def on_stock_trade(self, trade):
|
||
try:
|
||
cache_info = self.unit.order_cache.get(trade.order_id)
|
||
if not cache_info: return
|
||
s_name, _, action = cache_info
|
||
manager = MultiEngineManager()
|
||
if action == 'BUY':
|
||
manager.pos_manager.update_actual_volume(s_name, trade.stock_code, trade.traded_volume)
|
||
elif action == 'SELL':
|
||
manager.pos_manager.update_actual_volume(s_name, trade.stock_code, -trade.traded_volume)
|
||
except:
|
||
logging.getLogger("QMT_Engine").error(traceback.format_exc())
|
||
|
||
def on_order_error(self, err):
|
||
cache = self.unit.order_cache.get(err.order_id)
|
||
if cache and cache[2] == 'BUY':
|
||
MultiEngineManager().pos_manager.rollback_holding(cache[0], cache[1])
|
||
self.unit.order_cache.pop(err.order_id, None)
|
||
|
||
class TradingUnit:
|
||
"""终端实例执行单元，负责管理单个 QMT 进程"""
|
||
def __init__(self, t_cfg):
|
||
self.qmt_id = t_cfg['qmt_id']
|
||
self.alias = t_cfg.get('alias', self.qmt_id)
|
||
self.path = t_cfg['path']
|
||
self.account_id = t_cfg['account_id']
|
||
self.account_type = t_cfg['account_type']
|
||
|
||
self.xt_trader = None
|
||
self.acc_obj = None
|
||
self.callback = None
|
||
self.settler = None
|
||
self.order_cache = {}
|
||
self.last_heartbeat = "N/A"
|
||
|
||
def cleanup(self):
|
||
"""强制销毁资源，确保文件句柄释放"""
|
||
if self.xt_trader:
|
||
try:
|
||
logging.getLogger("QMT_Engine").info(f"正在销毁终端 {self.alias} 的旧资源...")
|
||
self.xt_trader.stop()
|
||
self.xt_trader = None # 显式置空
|
||
self.callback = None
|
||
time.sleep(1.5) # 给 C++ 引擎留出释放 down_queue 锁的时间
|
||
except:
|
||
pass
|
||
|
||
def connect(self):
|
||
"""连接 QMT 终端"""
|
||
self.cleanup() # 启动前先执行清理
|
||
try:
|
||
# 采用动态 Session ID 避免冲突
|
||
session_id = int(time.time()) + hash(self.qmt_id) % 1000
|
||
self.xt_trader = XtQuantTrader(self.path, session_id)
|
||
self.acc_obj = StockAccount(self.account_id, self.account_type)
|
||
self.callback = UnitCallback(self)
|
||
|
||
self.xt_trader.register_callback(self.callback)
|
||
self.xt_trader.start()
|
||
res = self.xt_trader.connect()
|
||
|
||
if res == 0:
|
||
self.xt_trader.subscribe(self.acc_obj)
|
||
self.callback.is_connected = True
|
||
self.settler = DailySettlement(self)
|
||
logging.getLogger("QMT_Engine").info(f"终端 {self.alias} 连接成功 (SID: {session_id})")
|
||
return True
|
||
return False
|
||
except Exception as e:
|
||
logging.getLogger("QMT_Engine").error(f"终端 {self.alias} 连接异常: {repr(e)}")
|
||
return False
|
||
|
||
# ================= 3. 总控中心 (MultiEngineManager) =================
|
||
|
||
class MultiEngineManager:
|
||
_instance = None
|
||
_lock = threading.Lock()
|
||
|
||
def __new__(cls):
|
||
if cls._instance is None:
|
||
with cls._lock:
|
||
if cls._instance is None:
|
||
cls._instance = super().__new__(cls)
|
||
return cls._instance
|
||
|
||
def __init__(self):
|
||
if hasattr(self, '_initialized'): return
|
||
self.units: Dict[str, TradingUnit] = {}
|
||
self.config = {}
|
||
self.is_running = True
|
||
self.start_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||
self._initialized = True
|
||
|
||
def initialize(self, config_file='config.json'):
|
||
self._setup_logger()
|
||
with open(config_file, 'r', encoding='utf-8') as f:
|
||
self.config = json.load(f)
|
||
|
||
self.r = redis.Redis(**self.config['redis'], decode_responses=True)
|
||
self.pos_manager = PositionManager(self.r)
|
||
|
||
for t_cfg in self.config.get('qmt_terminals', []):
|
||
unit = TradingUnit(t_cfg)
|
||
unit.connect()
|
||
self.units[unit.qmt_id] = unit
|
||
|
||
def _setup_logger(self):
|
||
log_dir = "logs"
|
||
if not os.path.exists(log_dir): os.makedirs(log_dir)
|
||
log_file = os.path.join(log_dir, f"{datetime.date.today().strftime('%Y-%m-%d')}.log")
|
||
logger = logging.getLogger("QMT_Engine")
|
||
logger.setLevel(logging.INFO)
|
||
# 确保日志流为 UTF-8
|
||
fmt = logging.Formatter('[%(asctime)s] [%(threadName)s] %(message)s', '%H:%M:%S')
|
||
fh = logging.FileHandler(log_file, mode='a', encoding='utf-8')
|
||
fh.setFormatter(fmt)
|
||
sh = logging.StreamHandler(sys.stdout)
|
||
sh.setFormatter(fmt)
|
||
logger.addHandler(fh)
|
||
logger.addHandler(sh)
|
||
|
||
def get_strategies_by_terminal(self, qmt_id):
|
||
return [s for s, cfg in self.config['strategies'].items() if cfg.get('qmt_id') == qmt_id]
|
||
|
||
def run_trading_loop(self):
|
||
self.logger = logging.getLogger("QMT_Engine")
|
||
self.logger.info(">>> 多终端交易主循环线程已启动 <<<")
|
||
last_check = 0
|
||
while self.is_running:
|
||
try:
|
||
now_t = time.time()
|
||
curr_hms = datetime.datetime.now().strftime('%H%M%S')
|
||
|
||
# --- 健康检查与自动修复 ---
|
||
if now_t - last_check > 25:
|
||
last_check = now_t
|
||
for unit in self.units.values():
|
||
is_unit_alive = False
|
||
if unit.xt_trader and unit.acc_obj:
|
||
try:
|
||
# 物理探测：通过查资产确认连接有效性
|
||
asset = unit.xt_trader.query_stock_asset(unit.acc_obj)
|
||
if asset:
|
||
is_unit_alive = True
|
||
unit.last_heartbeat = datetime.datetime.now().strftime('%H:%M:%S')
|
||
# 状态修正：物理通但逻辑False时自动拉回
|
||
if unit.callback and not unit.callback.is_connected:
|
||
unit.callback.is_connected = True
|
||
self.logger.info(f"✅ 修正终端 {unit.alias} 状态为在线")
|
||
except:
|
||
is_unit_alive = False
|
||
|
||
# 断线重连策略
|
||
if not is_unit_alive:
|
||
# 避让 QMT 夜间重启高峰 (21:32 - 21:50)
|
||
if not ('213200' <= curr_hms <= '215000'):
|
||
self.logger.warning(f"🚫 终端 {unit.alias} 物理连接丢失，执行重连...")
|
||
unit.connect()
|
||
else:
|
||
self.logger.info(f"⏳ 处于 QMT 重启时段 ({curr_hms})，跳过重连操作...")
|
||
|
||
# --- 交易逻辑处理 ---
|
||
is_trading = ('091500' <= curr_hms <= '113030') or ('130000' <= curr_hms <= '150030')
|
||
if is_trading:
|
||
for s_name in self.config['strategies'].keys():
|
||
self.process_route(s_name)
|
||
|
||
# --- 收盘结算与标志位重置 ---
|
||
elif '150500' <= curr_hms <= '151500':
|
||
for unit in self.units.values():
|
||
if unit.settler and not unit.settler.has_settled:
|
||
unit.settler.run_settlement()
|
||
elif '153000' <= curr_hms <= '160000':
|
||
for unit in self.units.values():
|
||
if unit.settler: unit.settler.reset_flag()
|
||
|
||
time.sleep(1 if is_trading else 5)
|
||
except:
|
||
self.logger.error("主循环异常：")
|
||
self.logger.error(traceback.format_exc())
|
||
time.sleep(10)
|
||
|
||
def process_route(self, strategy_name):
|
||
strat_cfg = self.config['strategies'].get(strategy_name)
|
||
unit = self.units.get(strat_cfg.get('qmt_id'))
|
||
if not unit or not unit.callback or not unit.callback.is_connected: return
|
||
|
||
msg_json = self.r.lpop(f"{strategy_name}_real")
|
||
if not msg_json: return
|
||
|
||
try:
|
||
data = json.loads(msg_json)
|
||
# 严格校验消息日期
|
||
if data.get('timestamp', '').split(' ')[0] != datetime.date.today().strftime('%Y-%m-%d'):
|
||
return
|
||
|
||
if data['action'] == 'BUY':
|
||
self._execute_buy(unit, strategy_name, data)
|
||
elif data['action'] == 'SELL':
|
||
self._execute_sell(unit, strategy_name, data)
|
||
except:
|
||
pass
|
||
|
||
def _execute_buy(self, unit, strategy_name, data):
|
||
strat_cfg = self.config['strategies'][strategy_name]
|
||
# 1. 槽位校验
|
||
if data['total_slots'] != strat_cfg['total_slots']:
|
||
self.logger.error(f"[{strategy_name}] 信号槽位({data['total_slots']})与配置({strat_cfg['total_slots']})不符")
|
||
return
|
||
|
||
# 2. 持仓数检查
|
||
if self.pos_manager.get_holding_count(strategy_name) >= strat_cfg['total_slots']:
|
||
return
|
||
|
||
try:
|
||
asset = unit.xt_trader.query_stock_asset(unit.acc_obj)
|
||
# 计算该终端的总槽位之和
|
||
terminal_strategies = self.get_strategies_by_terminal(unit.qmt_id)
|
||
total_slots = sum(self.config['strategies'][s]['total_slots'] for s in terminal_strategies)
|
||
|
||
if not asset or total_slots <= 0: return
|
||
|
||
# 3. 资金等权分配 (基于该终端总资产)
|
||
total_equity = asset.cash + asset.market_value
|
||
target_amt = total_equity / total_slots
|
||
actual_amt = min(target_amt, asset.cash * 0.98) # 预留手续费滑点
|
||
|
||
if actual_amt < 2000:
|
||
self.logger.warning(f"[{strategy_name}] 单笔预算 {actual_amt:.2f} 不足 2000 元，取消买入")
|
||
return
|
||
|
||
# 4. 价格与股数
|
||
offset = strat_cfg.get('execution', {}).get('buy_price_offset', 0.0)
|
||
price = round(float(data['price']) + offset, 3)
|
||
vol = int(actual_amt / (price if price > 0 else 1.0) / 100) * 100
|
||
|
||
if vol < 100: return
|
||
|
||
oid = unit.xt_trader.order_stock(unit.acc_obj, data['stock_code'], xtconstant.STOCK_BUY,
|
||
vol, xtconstant.FIX_PRICE, price, strategy_name, 'PyBuy')
|
||
if oid != -1:
|
||
unit.order_cache[oid] = (strategy_name, data['stock_code'], 'BUY')
|
||
self.pos_manager.mark_holding(strategy_name, data['stock_code'])
|
||
self.logger.info(f"√√√ [{unit.alias}] {strategy_name} 下单买入: {data['stock_code']} {vol}股 @ {price}")
|
||
except:
|
||
self.logger.error(traceback.format_exc())
|
||
|
||
def _execute_sell(self, unit, strategy_name, data):
|
||
v_vol = self.pos_manager.get_position(strategy_name, data['stock_code'])
|
||
if v_vol <= 0: return
|
||
|
||
real_pos = unit.xt_trader.query_stock_positions(unit.acc_obj)
|
||
rp = next((p for p in real_pos if p.stock_code == data['stock_code']), None) if real_pos else None
|
||
can_use = rp.can_use_volume if rp else 0
|
||
|
||
# 取虚拟持仓和实盘可用持仓的最小值
|
||
final_vol = min(v_vol, can_use)
|
||
if final_vol <= 0:
|
||
self.logger.warning(f"[{strategy_name}] 卖出拦截: {data['stock_code']} 实盘无可用持仓")
|
||
return
|
||
|
||
try:
|
||
offset = self.config['strategies'][strategy_name].get('execution', {}).get('sell_price_offset', 0.0)
|
||
price = round(float(data['price']) + offset, 3)
|
||
|
||
oid = unit.xt_trader.order_stock(unit.acc_obj, data['stock_code'], xtconstant.STOCK_SELL,
|
||
final_vol, xtconstant.FIX_PRICE, price, strategy_name, 'PySell')
|
||
if oid != -1:
|
||
unit.order_cache[oid] = (strategy_name, data['stock_code'], 'SELL')
|
||
self.logger.info(f"√√√ [{unit.alias}] {strategy_name} 下单卖出: {data['stock_code']} {final_vol}股 @ {price}")
|
||
except:
|
||
self.logger.error(traceback.format_exc())
|
||
|
||
def get_all_status(self) -> List[TerminalStatus]:
|
||
return [TerminalStatus(u.qmt_id, u.alias, u.account_id, (u.callback.is_connected if u.callback else False), u.last_heartbeat) for u in self.units.values()]
|
||
|
||
def stop(self):
|
||
self.is_running = False
|
||
for u in self.units.values():
|
||
u.cleanup() |