def init(q_name, my_app_name):
''' '''
swtich = XmlConfig.get('/monitor')
if swtich.get('switch','OFF').upper() == 'OFF':
global SWITCH
logging.info('the monitor is not turing on')
SWITCH = 'OFF'
return
monitor_serv_info = XmlConfig.get('/monitor/monitor_serv_addr')
host = monitor_serv_info['host']
port =int(monitor_serv_info['port'])
max_idle_time = XmlConfig.get('/monitor/max_idle_time')
alert_inverval = XmlConfig.get('/monitor/alert_interval')
keepers_info = XmlConfig.list('/monitor/keepers/')
emails = []
mobiles = []
for i in keepers_info.values():
emails.extend(i['emails'].split(','))
mobiles.extend(i['mobiles'].split(','))
global MBC
MBC = Client(my_app_name, (host, port) )
res = MBC.register({
'mobiles': mobiles,
'emails' : emails,
'max_idle_time': int(max_idle_time),
'alert_interval': alert_inverval,
})
if res['code'] != 201:
logging.warning('monitor register %s',res)
def get_xml_value( prefix, key, default ):
_map_ = XmlConfig.get( prefix )
if not _map_ or \
type(_map_) != dict or \
not _map_.has_key( key ):
value = default
else :
value = _map_[ key ]
return value
def connect(id, conf=None):
'''使用连接池连接数据库'''
if not _DB_POOL_.has_key(id):
if not conf:
conf = XmlConfig.get('/db/db2/' + id)
conf.setdefault('conn_options', {})
poolConf = conf.pop('pooling', 'pool_size=4').split(';')
poolConf = [i.split('=') for i in poolConf]
poolConf = dict([(i[0], eval(i[1])) for i in poolConf])
_DB_POOL_[id] = QueuePool(lambda: ibm_db_dbi.connect(**conf), **poolConf)
return Conn(_DB_POOL_[id].connect())
def load_from_xmlconfig(xpath, route_class=DataRing, *args, **kwargs):
"""从XmlConfig加载资源
"""
import XmlConfig
if xpath[-1:] != '/':
xpath += '/'
res_name = xpath.split('/')[-2]
if DATA_ROUTES.has_key(res_name):
return 0
nodes = XmlConfig.list(xpath)
if not nodes:
return -1
set_resource(res_name, route_class(nodes, *args, **kwargs))
return 1
def bind(self, zmq_id):
self.zmq_id = zmq_id
if "" == _ZMQ_POOL_.get(zmq_id, ""):
conf = XmlConfig.get('/resource/msgQue/zmq/' + zmq_id)
if conf == None:
print "没有%s相关的配置"%zmq_id
return
conn_str = conf.get("connection")
module = int(conf.get("module"))
self.receivce_block = int(conf.get("recvice_block", 0))
self.zmq_context = zmq.Context()
self.zmq = self.zmq_context.socket(module)
self.zmq.bind(conn_str)
_ZMQ_POOL_[zmq_id] = self
else:
self.zmq = _ZMQ_POOL_.get(zmq_id)
def initAppData(xcfg=None, props=None):
"""初始化一个ICE的应用数据类
xcfg XmlConfig配置的路径（可选）
props 额外指定的属性（可选）
"""
data = Ice.InitializationData()
data.properties = Ice.createProperties()
if xcfg:
import XmlConfig
if xcfg[-1:] != '/':
xcfg += '/'
for k, v in XmlConfig.list(xcfg).items():
data.properties.setProperty(k, v)
if props:
for k, v in props.items():
data.properties.setProperty(k, v)
return data
def connect(id, conf=None):
'''使用连接池连接数据库'''
if not _DB_POOL_.has_key(id):
if not conf:
conf = XmlConfig.get('/db/mysql/' + id)
poolConf = conf.pop('pooling', 'pool_size=4').split(';')
poolConf = [i.split('=') for i in poolConf]
poolConf = dict([(i[0], eval(i[1])) for i in poolConf])
_DB_POOL_[id] = QueuePool(lambda: _connect(**conf), **poolConf)
for i in range(_DB_POOL_[id].size() + 1):
conn = _DB_POOL_[id].connect()
try:
conn.ping()
break
except MySQLdb.OperationalError:
conn.invalidate()
return Conn(conn)
def connect(id, conf=None):
'''使用连接池连接数据库'''
if not _DB_POOL_.has_key(id):
if not conf:
conf = XmlConfig.get('/db/oracle/' + id)
for i in ['threaded', 'twophase', 'events']:
if conf.has_key(i):
conf[i] = eval(str(conf[i]))
poolConf = conf.pop('pooling', 'pool_size=4').split(';')
poolConf = [i.split('=') for i in poolConf]
poolConf = dict([(i[0], eval(i[1])) for i in poolConf])
_DB_POOL_[id] = QueuePool(lambda: cx_Oracle.connect(**conf), **poolConf)
for i in range(_DB_POOL_[id].size() + 1):
conn = _DB_POOL_[id].connect()
try:
conn.ping()
break
except cx_Oracle.Error:
conn.invalidate()
return Conn(conn)
def get(id, conf=None):
if not _SQLSERVER_DBS_.has_key(id):
if not conf:
conf = XmlConfig.get('/db/sqlserver/' + id)
_SQLSERVER_DBS_[id] = SqlServer(conf)
return _SQLSERVER_DBS_[id]
#coding=gbk
'''ÅÆÆ׼Ǽģ'''
from Message import dispatcher
import random
import JsonUtil as json
import zlog as logging
import traceback
from Protocol import Command as C
from Protocol import Key as K
import Version
import XmlConfig
CLIENT_GROUP = XmlConfig.get("/xml/Paipu/client_group")["value"]
CLIENT_NAME = XmlConfig.get("/xml/Paipu/client_name")["value"]
SERVER_GROUP = XmlConfig.get("/xml/Paipu/server_group")["value"]
SERVER_NAME = XmlConfig.get("/xml/Paipu/server_name")["value"]
MD_ADDR = XmlConfig.get("/xml/Server_addr/md_addr")["value"]
MY_ADDR = 'tcp://'
DELAY = 4
try:
CLIENT_MD = dispatcher.Dispatcher()
CLIENT_MD.init([CLIENT_GROUP, CLIENT_NAME], MY_ADDR, MD_ADDR, 'write')
except:
logging.error(traceback.format_exc())
def send(msg):
''' ·¢ËÍÏûÏ¢ '''
CLIENT_MD.send((SERVER_GROUP, SERVER_NAME), msg, DELAY)
#coding=gbk
''' 消息模块 '''
import dispatcher
import zlog as logging
import XmlConfig
GROUP_NAME = XmlConfig.get("/xml/Server_name/group_name")["value"]
LOCAL_ADDR = XmlConfig.get("/xml/Server_addr/local_addr")["value"]
MD_ADDR = XmlConfig.get("/xml/Server_addr/md_addr")["value"]
message_read = dispatcher.Dispatcher()
message_write = dispatcher.Dispatcher()
def regist( server_name ):
#初始化
logging.info( '注册地址为：%s'%str( (GROUP_NAME, server_name)) )
ret = message_read.init( ( GROUP_NAME, server_name ), LOCAL_ADDR, MD_ADDR , 'read')
if ret == 1:
logging.info( 'regist sucess!' )
else:
return False
ret = message_write.init( ( GROUP_NAME, server_name ), LOCAL_ADDR, MD_ADDR , 'write')
if ret == 1:
logging.info( 'regist sucess!' )
version: 1.1
1.1 添加 SWITCH OFF 时候的alert处理
"""
import os
import sys
import time
import socket
import zlog as logging
import threading
import traceback
import JsonUtil
import XmlConfig
import dispatcher
XmlConfig.loadFile(os.environ['_BASIC_PATH_'] + '/etc/monitor.xml')
############################################################
class Client:
"""监控服务的客户端
"""
monitor_type = 'basic'
def __init__(self, app_id, svc_addr):
"""构造函数
参数：
import XmlConfig
XmlConfig.loadFile("./poker_game.xml")
watcher_group_name = XmlConfig.get("/xml/Watcher_name/group_name")["value"]
watcher_server_name = XmlConfig.get("/xml/Watcher_name/server_name")["value"]
print(watcher_group_name)
print(watcher_server_name)
import traceback
import signal
if not os.environ.has_key('_BASIC_PATH_'):
_BASIC_PATH_ = os.path.abspath(__file__)
_BASIC_PATH_ = _BASIC_PATH_[:_BASIC_PATH_.rfind('/test/')]
os.environ['_BASIC_PATH_'] = _BASIC_PATH_
if sys.path.count(os.environ['_BASIC_PATH_'] + '/lib') == 0:
sys.path.append(os.environ['_BASIC_PATH_'] + '/mod')
sys.path.append(os.environ['_BASIC_PATH_'] + '/lib')
sys.path.append(os.environ['_BASIC_PATH_'] + '/lib/common')
sys.path.append(os.environ['_BASIC_PATH_'] + '/libs')
sys.path.append(os.environ['_BASIC_PATH_'] + '/libs/pypi')
import XmlConfig
XmlConfig.setEncoding('gbk')
XmlConfig.loadFile(_BASIC_PATH_ + '/etc/service.xml')
import Ice
Ice.loadSlice(_BASIC_PATH_ + '/etc/EAS.ice')
import EasClient
import JsonUtil
if __name__ == '__main__':
eas_instance = EasClient.EasClient().getInstance('account')
func_name = sys.argv[1]
if func_name == 'createTencentOrder':
params = {
'orderid': '132453453451324',
'uid': '6444',
import Pickle as Pc
import Redis as Re
import Message.RMonitor as RM
import os
import threading
import Data
import XmlConfig
# 终止信号
END_EVENT = threading.Event()
# 启动进程的服务名
global server_name
# 游戏服务地址的前缀
SERVER_ADDR_PREFIX = XmlConfig.get("/xml/Redis_addr/server_addr_prefix")["value"]
def register_server( appid ):
''' 对启动服务进行注册 '''
global server_name
server_name = appid
return True
def start():
''' 进程启动，加载序列内容 '''
global server_name
pickle_x = Pickle( server_name )
1.1 添加 SWITCH OFF 时候的alert处理
"""
import os
import sys
import time
import socket
import zlog as logging
import threading
import traceback
import JsonUtil
import XmlConfig
from . import dispatcher
XmlConfig.loadFile(os.environ['_BASIC_PATH_'] + '/etc/monitor.xml')
############################################################
class Client:
"""监控服务的客户端
"""
monitor_type = 'basic'
def __init__(self, app_id, svc_addr):
"""构造函数
参数：