def main(argv):
try:
yaml_path = './config/api_monitor_logger.yaml'
ct.setup_logging(yaml_path)
with open('./config/api_monitor_config.json', 'r') as f:
JsonData = json.load(f)
logger.debug(JsonData)
manual_task = ''
try:
opts, args = getopt.getopt(argv, "ht:", ["task="])
except getopt.GetoptError:
print(
'sppytraderapi_check.py -t <task> or you can use -h for help')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('python tradeapi_monitor.py -t <task>\n \
parameter -t comment: \n \
use -t can input the manul single task.\n \
task=["qry_market_data","mem","fpga","db_init","db_trade","errorLog"]. \n \
task="qry_market_data" means porcess and port monitor \n \
task="qry_security" means memory monitor \n \
task="db_trade" means db trading data monitor \n \
task="errorLog" means file error log monitor \n \
task="self_monitor" means self check monitor \n \
task="smss" means check the sms send status \n \
task="sms0" means set sms total_count=0 \n \
fpga_monitor and db_init_monitor just execute once on beginning '
)
sys.exit()
elif opt in ("-t", "--task"):
manual_task = arg
if manual_task not in ["qry_market_data", "qry_security"]:
logger.warning("[task] input is wrong, please try again!")
sys.exit()
else:
logger.info('manual_task is:%s' % manual_task)
logger.info("Start to excute the api monitor")
TraderApi_CheckData = JsonData['PyTraderApi']
res_flag = 0
for CheckData in TraderApi_CheckData:
check_flag = run_app(manual_task, CheckData)
res_flag += check_flag
if res_flag == len(TraderApi_CheckData):
msg = "Ok,所有服务器 traderapi行情查询 返回结果正确！"
logger.info(msg)
ct.send_sms_control("NoLimit", msg)
else:
logger.info("Error: 有服务器 traderapi行情查询 返回结果不正确！")
except Exception:
logger.error('Faild to run trade api monitor!', exc_info=True)
finally:
for handler in logger.handlers:
logger.removeHandler(handler)
def offer_connect_check(self):
#ndate = self.local_date.replace('-','')
error_kh_list = []
tgw_list = self.tgw_names.split("|")
#connect_ip = "172.27.128*"
for tgw_name in tgw_list:
command = "ss -anp | grep " + self.exch_front_ip + " | grep " + tgw_name
#command = "ss -anp | grep 192.168.238.7 | grep sshd"
logger.info("command:" + command)
sshRes = []
sshRes = self.sshExecCmd(command)
logger.info(sshRes)
if sshRes != ['']:
logger.info("服务器%s: 交易网关：[%s] 连接交易所前置地址正确！" %
(self.hostip, tgw_name))
error_kh_list.append(1)
else:
msg = "服务器%s: 交易网关：[%s] 连接交易所前置地址不正确，请检查连接状态！" % (self.hostip,
tgw_name)
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
error_kh_list.append(0)
self.sshClient.close()
return error_kh_list
def db_init_monitor_task():
with open('./config/table_check.json', 'r') as f:
Jsonlist = json.load(f)
logger.debug(Jsonlist)
logger.info("Start to excute the before trade monitor")
thrlist = range(len(Jsonlist))
threads = []
for (i, info) in zip(thrlist, Jsonlist):
#print("alltask.__name__:", alltask.__name__)
t = dbm.MyThread(dbm.before_trade_monitor, (info, ),
dbm.before_trade_monitor.__name__ + str(i))
threads.append(t)
for i in thrlist:
threads[i].start()
for i in thrlist:
threads[i].join()
threadResult = threads[i].get_result()
sysstr = platform.system()
if (not threadResult):
logger.error("error:奇点服务器盘前数据库初始化数据错误，请检查详细错误信息")
# ct.send_sms_control("db_init", "error:奇点服务器盘前数据库初始化数据错误，请检查详细错误信息")
if (sysstr == "Windows"):
ct.readTexts("Database init Worning")
else:
logger.info("OK:奇点服务器数据库init检查正常")
ct.send_sms_control("db_init", "OK:奇点服务器盘前数据库init检查正常")
def before_cleanup_db_monitor_task():
with open('./config/table_check.json', 'r') as f:
Jsonlist = json.load(f)
logger.debug(Jsonlist)
thrlist = range(len(Jsonlist))
threads=[]
for (i,info) in zip(thrlist, Jsonlist):
#print("alltask.__name__:", alltask.__name__)
t = dbm.MyThread(dbm.before_cleanup_db_monitor,(info,),dbm.before_cleanup_db_monitor.__name__ + str(i))
threads.append(t)
for i in thrlist:
threads[i].start()
for i in thrlist:
threads[i].join()
threadResult = threads[i].get_result()
sysstr = platform.system()
if (not threadResult) :
logger.error("error:数据库盘后清库盘前检查失败，请检查详细错误信息")
ct.send_sms_control("NoLimit", "error:数据库盘后清库盘前检查失败，请检查详细错误信息")
if (sysstr == "Windows"):
ct.readTexts("Database cleanup Worning")
else:
logger.info("OK:数据库盘后清库盘前检查正常")
def main(argv):
#默认是check_sjdr的监控检查
try:
yaml_path = './config/check_sjdr_logger.yaml'
ct.setup_logging(yaml_path)
linuxInfo = ct.get_server_config('./config/check_sjdr_config.txt')
check_flag = 0
for info in linuxInfo:
hostip = info[0]
rfc = remote_file_check(info)
error_list = rfc.check_sdjr()
if len(error_list) == 0:
msg = "ok:系统 %s 盘后当天的节点委托回传数据检查成功" % hostip
logger.info(msg)
check_flag += 1
else:
msg = "系统 %s 盘后当天的节点委托回传数据检查失败 失败的文件列表：%s " % (hostip, ';'.join(error_list))
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
if check_flag == len(linuxInfo):
logger.info(u"OK:检查盘后当天的节点委托回传数据成功!")
else:
logger.error(u"Error:检查盘后当天的节点委托回传数据失败!")
except Exception:
logger.error("盘后当天的节点委托回传数据出现异常，请参看错误日志！", exc_info=True)
finally:
for handler in logger.handlers:
logger.removeHandler(handler)
def OnRspQrySecurity(self, pSecurity, pRspInfo, nRequestID, bIsLast):
msg = "OnRspQrySecurity: ErrorID[%d] ErrorMsg[%s] RequestID[%d] IsLast[%d]" % (
pRspInfo['ErrorID'], pRspInfo['ErrorMsg'], nRequestID, bIsLast)
print(msg)
if bIsLast != 1:
print("cur_data:", self.__app.cur_data)
self.__res_list.append(pSecurity)
print(
"SecurityID[%s] SecurityName[%s] ProductID[%s] OpenDate[%s]" %
(pSecurity['SecurityID'], pSecurity['SecurityName'],
pSecurity['ProductID'], pSecurity['OpenDate']))
if pSecurity['SecurityID'] == self.__app.cur_data['SecurityID'] \
and pSecurity['SecurityName'] != '' :
msg = "OK,查询证券信息SecurityID为[%s]，SecurityName为[%s], OpenDate为[%s]" \
% (pSecurity['SecurityID'],pSecurity['SecurityName'],pSecurity['OpenDate'])
logger.info(msg)
else:
msg = "Error,查询证券信息SecurityID为[%s]，SecurityName为[%s], OpenDate为[%s]" \
% (pSecurity['SecurityID'],pSecurity['SecurityName'],pSecurity['OpenDate'])
logger.warning(msg)
else:
if len(self.__res_list) == 0:
msg = "Error:查询无结果"
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
self.__app.wake_up()
def main():
try:
yaml_path = './config/orderstatus_check_logger.yaml'
ct.setup_logging(yaml_path)
with open('./config/table_check.json', 'r') as f:
Jsonlist = json.load(f)
logger.debug(Jsonlist)
#init interval
thrlist = range(len(Jsonlist))
threads = []
for (i, info) in zip(thrlist, Jsonlist):
#print("alltask.__name__:", alltask.__name__)
t = MyThread(order_status_monitor, (info, ),
order_status_monitor.__name__ + str(i))
threads.append(t)
for i in thrlist:
threads[i].start()
for i in thrlist:
threads[i].join()
#threadResult = threads[i].get_result()
# print "thrcount:", threading.active_count()
except Exception:
logger.error('Faild to run monitor db!', exc_info=True)
ct.send_sms_control("NoLimt", "检查Order表 orderstatus失败！")
finally:
for handler in logger.handlers:
logger.removeHandler(handler)
def follow_monitor_task():
linuxInfo = ct.get_server_config('./config/check_follow_config.txt')
check_flag = 0
for info in linuxInfo:
hostip = info[0]
try:
file_checker = rfc.remote_file_check(info)
res_file = file_checker.check_follow()
if res_file[:5] != 'Error':
msg = "ok:系统 %s 跟投费率优惠文件检查成功，文件名[%s]" % (hostip,res_file)
logger.info(msg)
check_flag += 1
#20200526正常状态不再发短信
#ct.send_sms_control('NoLimit', msg)
else:
msg = "Error:系统 %s 跟投费率优惠文件检查失败 失败的原因：%s" % (hostip, res_file[6:])
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
except Exception:
msg = "Error:系统 %s 跟投费率优惠文件检查失败，出现异常，请查看服务器日志信息！" % hostip
logger.error(msg, exc_info=True)
ct.send_sms_control('NoLimit', msg)
if check_flag != 0 and check_flag == len(linuxInfo):
logger.info(u"OK:跟投费率优惠文件数据成功!")
else:
logger.warning(u"Error:跟投费率优惠文件检查数据失败!")
def fpga_task():
linuxInfo = ct.get_server_config('./config/fpga_config.txt')
# linuxInfo = [['192.168.238.7', 22, 'trade', 'trade', 'tradeserver',/home/trade/FPGA']]
try:
ms = MonitorServer(linuxInfo)
ms.fpga_monitor_run()
check_result_list = ms.fpga_Check_flag_list
logger.debug("check_result_list:")
logger.debug(check_result_list)
if len(check_result_list) == 0:
check_result = False
else:
check_result = (sum(check_result_list) == len(check_result_list))
except Exception:
check_result = False
logger.error('Faild to check fpga!', exc_info=True)
logger.info(
"************************The FPGA File Monitor Result: ************************"
)
if check_result:
logger.info("OK,FPGA Server is OK")
ct.send_sms_control("fpga", "OK:盘前FPGA文件检查正常")
else:
msg = "error:FPGA文件检查异常，请查看详细日志"
logger.error(msg)
# send_sms_control("fpga", "error:奇点服务器FPGA文件检查异常，请查看详细日志")
sysstr = platform.system()
if sysstr == "Windows":
ct.readTexts("VIP Server is Worning")
def main():
yaml_path = './config/gen_InvestorExchFee_logger.yaml'
ct.setup_logging(yaml_path)
#检查当天是否是交易日
is_tradedate = ct.get_isTradeDate(ndates)
if not is_tradedate:
logger.info("当日是非交易日，程序退出")
return 0
#检查文件是否存在
if not os.path.isfile(abcsj_dbf):
msg = "没有找到上海红利征税明细文件 %s" % abcsj_dbf
logger.error(msg)
#ct.send_sms_control('NoLimit',msg)
if not os.path.isfile(zsmx_dbf):
msg = "没有找到深圳红利征税明细文件 %s" % zsmx_dbf
logger.error(msg)
#ct.send_sms_control('NoLimit',msg)
if (os.path.isfile(abcsj_dbf) or os.path.isfile(zsmx_dbf)):
gen_ExchFee_csv()
res = insert_mysql(csv_file_name,'t_InvestorExchFee')
if res :
logger.info("插入mysql成功")
ct.send_sms_control('NoLimit',"OK，导入红利征税表t_InvestorExchFee成功")
else:
logger.error("Error，插入mysql失败")
logger.info("len(null_investorID):" + str(len(null_investorID)))
if len(null_investorID) !=0:
msg = "有没有匹配到对应的investorID的shareholderID数量为：%s" % str(len(null_investorID))
logger.info(msg)
else:
logger.info('shareholderID全匹配成功')
else:
logger.error("当天红利征税明细dbf文件没有找到")
def sjdr_monitor_task():
linuxInfo = ct.get_server_config('./config/check_sjdr_config.txt')
check_flag = 0
for info in linuxInfo:
try:
hostip = info[0]
file_checker = rfc.remote_file_check(info)
error_list = file_checker.check_sdjr()
if len(error_list) == 0:
msg = "ok:系统 %s 盘后当天的节点委托回传数据检查成功" % hostip
logger.info(msg)
check_flag += 1
else:
msg = "系统 %s 盘后当天的节点委托回传数据检查失败 失败的文件列表：%s " % (hostip, ';'.join(error_list))
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
except Exception:
logger.error("查询席位代码失败，出现异常，请查看服务器日志信息！", exc_info=True)
ct.send_sms_control('xwdm', "查询席位代码失败，出现异常，请查看服务器日志信息！")
if check_flag != 0 and check_flag == len(linuxInfo):
logger.info(u"OK:检查盘后当天的节点委托回传数据成功!")
else:
logger.warning(u"Error:检查盘后当天的节点委托回传数据失败!")
def traderapi_login_front_monitor_task():
with open('./config/api_monitor_config.json', 'r') as f:
JsonData = json.load(f)
try:
TraderApi_CheckData = JsonData['PyTraderApi']
check_result_list = []
for CheckData in TraderApi_CheckData:
front_addresses = CheckData['front_addresses']
CheckData.pop('front_addresses')
for address in front_addresses:
CheckData['address'] = address
check_flag = tdm.run_app("login_front", CheckData)
check_result_list.append(check_flag)
check_result = (sum(check_result_list) == len(check_result_list))
if check_result:
msg = "Ok,所有服务器 traderapi登陆front成功！"
logger.info(msg)
ct.send_sms_control("NoLimit", msg)
else:
logger.info("Error: 有服务器 traderapi登陆front失败！")
except Exception as e:
msg = str(e)
logger.error("tradeapi loggin monitor 异常：" + msg)
def traderapi_QMD_monitor_task():
with open('./config/api_monitor_config.json', 'r') as f:
JsonData = json.load(f)
try:
#20200810修改json文件格式
# TraderApi_CheckData = JsonData['PyTraderApi']
# res_flag = 0
# for CheckData in TraderApi_CheckData:
# check_flag = tdm.run_app("qry_market_data", CheckData)
# res_flag += check_flag
TraderApi_CheckData = JsonData['PyTraderApi']
check_result_list = []
for CheckData in TraderApi_CheckData:
front_addresses = CheckData['front_addresses']
CheckData.pop('front_addresses')
for address in front_addresses:
CheckData['address'] = address
check_flag = tdm.run_app("qry_market_data", CheckData)
check_result_list.append(check_flag)
check_result = (sum(check_result_list) == len(check_result_list))
if check_result:
msg = "Ok,所有服务器 traderapi行情查询 返回结果正确！"
logger.info(msg)
ct.send_sms_control("NoLimit", msg)
else:
logger.info("Error: 有服务器 traderapi行情查询 返回结果不正确！")
except Exception as e:
msg = str(e)
logger.error("tradeapi monitor 异常：" + msg)
def core_file_info(self, info):
command = 'find /home/trade -name core.*'
hostip = info[0]
# servername = info[4]
logger.info("command: " + command)
sshRes = self.sshExecCmd(command)
# print("sshRes:", sshRes)
if sshRes == []:
self.single_info_verify = True
msg = "OK: Server %s The count of core file is 0 " % str(hostip)
logger.info(msg)
else:
self.single_info_verify = False
sshResStr = ''.join(sshRes)
sshResList = sshResStr.strip().split('\n')
print("sshResList: ", sshResList)
# ps_list = []
for datalist in sshResList:
msg = "error: " + hostip + " Have core file:" + datalist
ct.write_log(error_log_file, msg)
logger.warning(msg)
sms_msg = "error: " + hostip + " 有core文件，请检查服务器文件"
logger.error(sms_msg)
ct.send_sms_control("core", sms_msg)
msg = "core file Check Result: " + str(self.single_info_verify)
logger.info(msg)
def check_xwdm(self):
ndate = self.local_date.replace('-','')
vip_interface_filepath = self.remote_dir + '/' + ndate +'/VIP_INTERFACE_OK' + ndate + '.csv'
vip_ok_filepath = self.remote_dir + '/' + ndate +'/4/VIP_OK' + ndate + '.csv'
error_kh_list=[]
for filepath in [vip_interface_filepath, vip_ok_filepath]:
command = "ls " + filepath
logger.info("command:" + command)
sshRes = []
sshRes = self.sshExecCmd(command)
# print("sshRes:", sshRes)
# print(sshRes[0] == filepath)
# print(sshRes == [''])
if sshRes !=['']:
logger.info("服务器%s: 文件：%s存在" % (self.hostip, filepath))
error_kh_list.append(1)
else:
msg = "服务器%s: 文件：%s不存在！" % (self.hostip, filepath)
logger.error(msg)
ct.send_sms_control('xwdm', msg)
error_kh_list.append(0)
self.sshClient.close()
return error_kh_list
def shrink_dblog_monitor_task():
with open('./config/table_check.json', 'r') as f:
Jsonlist = json.load(f)
logger.debug(Jsonlist)
thrlist = range(len(Jsonlist))
threads=[]
for (i,info) in zip(thrlist, Jsonlist):
#print("alltask.__name__:", alltask.__name__)
t = dbm.MyThread(dbm.shrink_dblog_monitor,(info,),dbm.shrink_dblog_monitor.__name__ + str(i))
threads.append(t)
for i in thrlist:
threads[i].start()
check_list = []
for i in thrlist:
threads[i].join()
threadResult = threads[i].get_result()
if (not threadResult) :
check_list.append(0)
else:
check_list.append(1)
check_flag = (sum(check_list)==len(check_list))
if (not check_flag) :
logger.error("error:有数据库日志压缩检查处理失败，请检查详细错误信息")
logger.error(check_list)
ct.send_sms_control("NoLimit", "error:有数据库日志压缩检查失败，请检查详细错误信息")
else:
logger.info("OK:所有数据库日志压缩检查正常")
def monitor_market_data(self):
#先进行查询操作
self.__spi.test_req_qry_market_data()
time.sleep(2)
market_df = pd.read_csv(self.QryMarketDataResFile, dtype=object)
# print(market_df)
# print(market_df.columns.size) #列数
# print(market_df.iloc[:,0].size)#行数
TrD_error_list = []
error_list = []
if market_df.iloc[:, 0].size != 0:
# #判断TradingDay字段是否是当天日期
# ndates = dt.datetime.now().strftime("%Y%m%d")
# nt_df = market_df[market_df['TradingDay'] != ndates]
# if len(nt_df) == 0:
# logger.info("[TradingDay]的值%s和当天日期一致" % ndates)
# else:
# #print(nt_df)
# for row in nt_df.itertuples():
# TrD_error_list.append(str(getattr(row, 'TradingDay')) + "::" + str(getattr(row, 'SecurityID')))
# msg = "Error: 服务器[%s]有证券行情TradingDay字段不是当天日期:[%s]" % (self.__address, ','.join(TrD_error_list))
# logger.info(msg)
# ct.send_sms_control("NoLimit",msg)
#判断查询的合约行情是否都返回了结果
#print("length:", len(self.QuriyList), market_df.iloc[:,0].size)
if len(self.QuriyList) == market_df.iloc[:, 0].size:
logger.info("OK：行情查询返回记录条数和查询列表条数一致")
else:
for dict_item in self.QuriyList:
security_list = list(market_df['SecurityID'])
if dict_item['SecurityID'] in security_list:
logger.info("SecurityID [%s]查询行情成功" %
dict_item['SecurityID'])
else:
logger.info("SecurityID [%s]查询行情没有返回" %
dict_item['SecurityID'])
error_list.append(dict_item['SecurityID'])
msg = "Error: 服务器[%s] traderapi行情查询 没有返回结果的SecurityID列表为：[%s]" % (
self.__address, ",".join(error_list))
logger.error(msg)
ct.send_sms_control("NoLimit", msg)
else:
error_list = self.QuriyList
msg = "Error:服务器[%s] traderapi行情查询 接口返回为空" % self.__address
logger.error(msg)
ct.send_sms_control("NoLimit", msg)
if TrD_error_list == [] and error_list == []:
msg = "Ok,服务器[%s] traderapi行情查询 返回结果正确" % self.__address
logger.info(msg)
return 1
else:
msg = "Error,服务器[%s] traderapi行情查询 返回结果不正确 %s" % (
self.__address, str(TrD_error_list) + str(error_list))
logger.error(msg)
#ct.send_sms_control("NoLimit",msg)
return 0
def run(self):
# while True:
#print("self.__api", self.__api)
# if self.__api is None:
print(traderapi.CTORATstpTraderApi_GetApiVersion())
self.__api = traderapi.CTORATstpTraderApi.CreateTstpTraderApi()
self.__spi = TraderSpi(self.__api, self)
self.__api.RegisterSpi(self.__spi)
self.__api.RegisterFront(self.__address)
#订阅私有流
#self.__api.SubscribePrivateTopic(traderapi.TORA_TERT_RESTART)
#订阅公有流
#self.__api.SubscribePublicTopic(traderapi.TORA_TERT_RESTART)
#启动接口对象
self.__api.Init()
# else:
# eventlet.monkey_patch()
# with eventlet.Timeout(3,False): #设置超时时间为2秒
# print('这条语句正常执行')
# #self.__lock.acquire()
# time.sleep(5)
# print('没有跳过这条输出')
#self.__lock.acquire()
# print("test5")
self.__spi.test_req_user_login()
time.sleep(2)
# self.__spi.test_req_qry_security()
# self.__spi.test_req_qry_trading_account()
if self.__spi.login_flag == 1:
if self.__task == "qry_market_data":
# for dict_data in self.testData["QryMarketData"]:
logger.info("excuting qry_market_data...")
self.__lock.acquire()
# self.cur_data = dict_data
self.check_flag = self.monitor_market_data()
elif self.__task == "login_front":
logger.info("excuting login_front_monitor...")
self.__lock.acquire()
self.check_flag = self.monitor_login_front()
elif self.__task == "qry_security":
for dict_data in self.testData["QrySecurity"]:
logger.info("excuting qry_security...")
pass
#self.__lock.acquire()
#self.cur_data = dict_data
#self.__spi.test_req_qry_security()
else:
logger.warning("输入的任务名称无法识别！")
else:
msg = "Error:user_login登录前置 %s 失败，程序退出." % self.__address
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
sys.exit(1)
def OnRspQryMarketData(self, pMarketData, pRspInfo, nRequestID, bIsLast):
msg = "OnRspQryMarketData: ErrorID[%d] ErrorMsg[%s] RequestID[%d] IsLast[%d]" % (
pRspInfo['ErrorID'], pRspInfo['ErrorMsg'], nRequestID, bIsLast)
logger.info(msg)
print("pMarketData:", pMarketData)
if pRspInfo['ErrorID'] != 0:
msg = "返回错误：错误信息为：%s" % pRspInfo['ErrorMsg']
logger.warning(msg)
ct.send_sms_control('NoLimit', msg)
if bIsLast != 1:
# print("cur_data:",self.__app.cur_data)
# self.__res_list.append(pMarketData)
# logger.info("SecurityID[%s] SecurityName[%s] TradingDay[%s] PreClosePrice[%s] OpenPrice[%s] LastPrice[%s] HighestPrice[%s] LowestPrice[%s] UpdateTime[%s]" % (
# pMarketData['SecurityID'],
# pMarketData['SecurityName'],
# pMarketData['TradingDay'],
# pMarketData['PreClosePrice'],
# pMarketData['OpenPrice'],
# pMarketData['LastPrice'],
# pMarketData['HighestPrice'],
# pMarketData['LowestPrice'],
# pMarketData['UpdateTime']))
#
# if pMarketData['SecurityID'] == self.__app.cur_data['SecurityID'] and pMarketData['TradingDay'] == self.ndates \
# and pMarketData['PreClosePrice'] != 0.0 and pMarketData['UpperLimitPrice'] != 0.0 and pMarketData['LowerLimitPrice'] != 0.0 :
# msg = "OK,查询行情SecurityID[%s]，昨结算价为[%s], 涨停价为[%s], 跌停价为[%s],更新时间为:%s" \
# % (pMarketData['SecurityID'],pMarketData['PreClosePrice'],pMarketData['UpperLimitPrice'],pMarketData['LowerLimitPrice'],pMarketData['UpdateTime'])
# logger.info(msg)
# else:
# msg = "Error,查询行情SecurityID[%s]，昨结算价为[%s], 涨停价为[%s], 跌停价为[%s],更新时间为:%s" \
# % (pMarketData['SecurityID'],pMarketData['PreClosePrice'],pMarketData['UpperLimitPrice'],pMarketData['LowerLimitPrice'],pMarketData['UpdateTime'])
# logger.error(msg)
# ct.send_sms_control('NoLimit',msg)
if (pMarketData != None):
data_list = list(pMarketData.values())
ttl = []
for item in data_list:
if (type(item) == bytes):
ttl.append(item.decode('utf-8'))
else:
ttl.append(item)
with open(self.__app.QryMarketDataResFile,
'a+',
encoding='utf-8',
newline='') as csvfile:
writer = csv.writer(csvfile)
writer.writerow(ttl)
else:
logger.warning("pMarketData数据为None")
def insert_mysql(csv_file_name,template_name):
logger.info("导入mysql....")
mysql_obj = myc.mysql_tools(mysqldb_info)
local_infile_value = mysql_obj.get_local_infile_value()
#判断mysql参数是否打开允许导入文件
if (local_infile_value == 'ON' and os.path.isfile(csv_file_name)):
file_sql = mysql_obj.load_table_commend_gen(csv_file_name, template_name)
logger.info(file_sql)
res = mysql_obj.execute_sql(file_sql)
else:
local_file_msg = "Error，mysql导入csv失败，local_infile 的值为： %s" % local_infile_value
ct.send_sms_control('NoLimit', local_file_msg, '13681919346')
res = 0
return res
def check_xwdm_old(self):
xwdm_file='./config/xwdm_check_list.csv'
# self.xwdm_check_col='XWDM_sz'
with open(xwdm_file,'r') as csvFile:
reader = csv.DictReader(csvFile)
check_column = [row[self.xwdm_check_col] for row in reader]
logger.info(u"奇点系统 %s 席位号列表为：" % self.hostip)
logger.info(check_column)
ndate = self.local_date.replace('-','')
if self.xwdm_check_col == 'hx_szt':
filedot='/2'
elif self.xwdm_check_col == 'hx_shangzt':
filedot='/3'
elif self.xwdm_check_col == 'hx_wanping':
filedot='/4'
filepath = self.remote_dir + '/' + ndate + filedot + '/VIP_GDH' + ndate + '.csv'
# filepath = '/home/trade/temp/20190617/VIP_GDH20190403.csv'
#command = 'cat /home/trade/temp/20190617/VIP_GDH20190403.csv | awk -F"' + ',"' + " '{OFS=\",\";print $1,$5}'"
#cat /home/trade/temp/20190617/VIP_GDH20190403.csv | awk -F"," '{OFS=",";print $1,$5}'
command = "cat " + filepath + " | awk -F\",\" \'{OFS=\",\";print $1,$5}\'"
logger.debug("command:" + command)
sshRes = []
sshRes = self.sshExecCmd(command)
self.sshClient.close()
# print "sshRes:", sshRes
xwdm_list=[]
for ssr in sshRes[1:]:
lists = ssr.split(',')
xwdm_list.append(lists)
error_kh_list = []
if len(xwdm_list) != 0:
logger.info(u"客户席位代码列表为：")
logger.info(xwdm_list)
#20191226:修改临时检查，只检查文件存在即可。
# for xwdm_item in xwdm_list:
# if (xwdm_item[1] not in check_column):
# error_kh_list.append(xwdm_item)
else:
msg = "error: 没有取到服务器 %s GDH文件 %s，请检查文件路径是否正确！" % (self.hostip, filepath)
logger.error(msg)
ct.send_sms_control('xwdm', msg)
error_kh_list=[['999','999']]
return error_kh_list
def sshConnect(self):
paramiko.util.log_to_file('./mylog/paramiko.log')
try:
#创建一个SSH客户端client对象
sshClient = paramiko.SSHClient()
# 获取客户端host_keys,默认~/.ssh/known_hosts,非默认路径需指定
sshClient.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#创建SSH连接
sshClient.connect(self.hostip, self.port, self.username,
self.password)
logger.debug("SSH connect success!")
except Exception as e:
msg = "SSH connect failed: [hostip:%s];[username:%s];[error:%s]" % (
self.hostip, self.username, str(e))
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
return sshClient
def non_trade_ps_info(self, info):
hostip = info[0]
username = info[2]
# servername = info[4]
processes = info[5]
# process_count = len(str(processes).split('|'))
command = 'ps -u ' + username + ' -elf | grep -E "' + processes + '" | grep -v grep'
# command = 'ps -u trade -elf |grep -E "dbsync 1|dbsync 2" | grep -v grep'
logger.info("command: " + command)
sshRes = self.sshExecCmd(command)
# print "sshRes:", sshRes
if sshRes == []:
self.ps_info_verify = True
msg = "OK: Server %s The count of the processes is 0 " % str(
hostip)
logger.info(msg)
else:
self.ps_info_verify = False
sshResStr = ''.join(sshRes)
sshResList = sshResStr.strip().split('\n')
# print "sshResList: ", sshResList
sshResLists = []
for sshCom in sshResList:
sshResLists.append(sshCom.strip().split())
# # print "sshResLists:\n", sshResLists
# titlename="F,S,UID,PID,PPID,C,PRI,NI,ADDR,SZ,WCHAN,TTY,TIME,CMD"
ps_list = []
for datalist in sshResLists:
# psstr=','.join(datalist)
psstr = ' '.join(datalist[14:])
logger.info("ps:" + psstr)
# chg_psstr = psstr.encode('utf-8')
ct.write_log(error_log_file, psstr)
msg = "error:" + hostip + " ::The process is " + psstr + ":: Time: " + str(
datalist[13]) + " is still working!"
ct.write_log(error_log_file, msg)
logger.warning(msg)
ps_list.append(psstr)
ps_cmd = ';'.join(ps_list)
sms_msg = "error:" + hostip + " ::Processes : " + ps_cmd + " is still working!"
ct.send_sms_control("ps_port", sms_msg)
msg = "ps Processes Check Result: " + str(self.ps_info_verify)
logger.info(msg)
def xwdm_monitor_task():
linuxInfo = ct.get_server_config('./config/check_xwdm_config.txt')
for info in linuxInfo:
try:
check_flag = 0
hostip = info[0]
c_x = cx.check_csv_file(info)
error_list = c_x.check_xwdm()
check_flag = (sum(error_list)==len(error_list))
if check_flag:
logger.info(u"ok:系统 %s 席位代码文件检查成功！" % hostip)
else:
logger.error(u"系统 %s 检查席位代码文件失败!" % hostip)
except Exception:
logger.error("查询席位代码失败，出现异常，请查看服务器日志信息！", exc_info=True)
ct.send_sms_control('xwdm', "Error:查询席位代码失败，出现异常，请查看服务器日志信息！")
def self_log_monitor_task(log_file):
logger.info("self_log_monitor_check msg")
# log_file = './mylog/non_trade_monitor_run.log'
with open(log_file, "r") as f:
lines = f.readlines()
last_line = lines[-1]
last_time_str = last_line.split(',')[0]
#暂停1秒防止一分钟运行2次
time.sleep(1)
last_time = dt.datetime.strptime(last_time_str,"%Y-%m-%d %H:%M:%S")
ntime = dt.datetime.now()
delta_time = ntime - last_time
logger.info("delta time is : %d " % delta_time.seconds)
if delta_time.seconds < 10 and delta_time.seconds >=0 :
logger.info("ok:I am alive!")
ct.send_sms_control("NoLimit", "奇点监控服务器自检正常，报警时间点：'18:59','19:59','20:59','21:59',07:59'")
else:
logger.error("error:self check failed")
def ssh_remote_command_task():
error_list = []
linuxInfo = ct.get_server_config('./config/ssh_remote_command_config.txt')
for info in linuxInfo:
hostip = info[0]
port = int(info[1])
username = info[2]
password = info[3]
command = info[5]
sshClient = ct.sshConnect(hostip, port, username, password)
if sshClient == 999:
msg = "Failed:服务器[%s],连接失败，请检查密码是否正确" % hostip
logger.error(msg)
#ct.send_sms_control("NoLimit", msg)
error_list.append(msg)
else:
logger.info("Ok: 服务器[%s]连接正常" % hostip)
logger.info(hostip + "::" + command)
#sshRes = ct.sshExecCmd(sshClient, command)
stdin, stdout, stderr = sshClient.exec_command(command)
stdoutstr = stdout.read().decode('utf-8')
ssherr = stderr.read().decode('utf-8')
if ssherr:
msg = "服务器[%s]ssh执行命令返回错误：[%s]" % (hostip, ssherr)
logger.warning(msg)
error_list.append(msg)
sshRes = []
sshRes = stdoutstr.strip().split('\n')
if sshRes == ['']:
sshRes = []
logger.info("sshRes:")
logger.info(sshRes)
sshClient.close()
if len(error_list) != 0:
temstr = ';'.join(error_list)
msg = "Failed:服务器ssh执行命令失败列表：[%s]" % temstr
logger.error(msg)
ct.send_sms_control("NoLimit", msg)
else:
logger.info("所有服务器ssh执行命令正常！")
def socket_info(self, info):
hostip = info[0]
# servername = info[4]
ports_i = info[6]
ports = ports_i.split(';')
# print "port:", ports
cur_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
logger.info(
"******************************Ports Monitor: [server:%s]*********************************"
% hostip)
ct.write_file(result_file,
cur_time + "::" + hostip + "_socket_port_info_result:")
flag_list = []
for port in ports:
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.settimeout(3)
try:
sk.connect((hostip, int(port)))
msg = "ok:" + str(hostip) + ":" + str(port) + " is ok"
ct.write_file(result_file, msg)
logger.info(msg)
list_flag = 1
flag_list.append(list_flag)
except Exception:
# print "\033[1;31;mServer port 18000 is close\033[0m"
msg = "error: " + str(hostip) + ":" + str(port) + " is closed"
logger.error(msg)
ct.send_sms_control("ps_port", msg)
ct.write_file(error_log_file, msg)
ct.write_file(result_file, msg)
list_flag = 0
flag_list.append(list_flag)
sk.close()
# print "flag_list: ", flag_list
if len(flag_list) == 0:
self.socket_info_verify = False
else:
self.socket_info_verify = (sum(flag_list) == len(flag_list))
msg = "socket Ports Check Result: " + hostip + "::" + str(
self.socket_info_verify)
logger.info(msg)
def mdapi_monitor_qry_task():
with open('./config/api_monitor_config.json', 'r') as f:
JsonData = json.load(f)
try:
res_flag = 0
for PyMdApi_CheckData in JsonData['PyMdApi']:
# PyMdApi_CheckData = JsonData['PyMdApi']
md_test = mdt.mdapi_monitor(PyMdApi_CheckData)
res = md_test.monitor_market_data()
res_flag += res
if res_flag == len(JsonData['PyMdApi']):
msg = "Ok,所有服务器mdapi行情查询返回结果正确！"
logger.info(msg)
ct.send_sms_control("NoLimit", msg)
else:
logger.info("Error: 有服务器mdapi行情查询返回结果不正确！")
except Exception as e:
msg = str(e)
logger.error("mdapi monitor 异常：" + msg)
def exchange_file_monitor_task():
linuxInfo = ct.get_server_config('./config/exchange_file_config.txt')
check_flag = 0
for info in linuxInfo:
hostip = info[0]
try:
file_checker = rfc.remote_file_check(info)
error_file_list = file_checker.check_exchange_file()
if len(error_file_list) == 0:
msg = "ok:所有系统交易所基础文件检查成功"
logger.info(msg)
check_flag += 1
ct.send_sms_control('NoLimit', msg)
else:
list_str = ';'.join(error_file_list)
msg = "Error:有系统交易所基础文件检查失败,失败的文件：%s" % list_str
logger.error(msg)
ct.send_sms_control('NoLimit', msg)
except Exception:
msg = "Error:系统交易所基础文件检查失败，出现异常，请查看服务器日志信息！"
logger.error(msg, exc_info=True)
ct.send_sms_control('NoLimit', msg)
def main(argv):
yaml_path = './config/non_trade_monitor_logger.yaml'
ct.setup_logging(yaml_path)
linuxInfo = ct.get_server_config('./config/offer_connect_config.txt')
check_result = []
for info in linuxInfo:
try:
check_flag = 0
hostip = info[0]
tgw_names = info[5]
scc = ssh_command_check(info)
error_list = scc.offer_connect_check()
check_flag = (sum(error_list) == len(error_list))
if check_flag:
logger.info(u"ok:系统 %s 交易前置 %s 连接检查成功！" % (hostip, tgw_names))
check_result.append(1)
else:
logger.error(u"系统 %s 交易前置 %s 连接检查失败：" % (hostip, tgw_names))
check_result.append(0)
except Exception:
logger.error('Faild to check offer_connect.', exc_info=True)
check_result.append(0)
# finally:
# for handler in logger.handlers:
# logger.removeHandler(handler)
final_check_flag = (sum(check_result) == len(check_result))
logger.info(check_result)
if final_check_flag:
msg = "所有报盘前置连接地址检查成功"
ct.send_sms_control("NoLimit", msg)
logger.info(msg)
else:
logger.error("报盘连接前置检查有错误！")
for handler in logger.handlers:
logger.removeHandler(handler)
