def __init__(self,
service_group,
port,
jid,
service_version,
servie_mgr_ip=None,
servie_mgr_port=None,
default_load=1,
load_getter=None):
self.service_group = service_group
self.port = port
self.jid = jid
self.service_version = service_version
self.default_load = default_load
self.current_load = default_load
self.load_getter = load_getter
self.process_name = sys.argv[0]
self.running = False
if not servie_mgr_ip:
servie_mgr_ip = ParamCacher().sm_ip
if not servie_mgr_port:
servie_mgr_port = SM_UDP_PORT
super(ServiceAdvertiser, self).__init__(servie_mgr_ip, servie_mgr_port,
self.get_msg)
def _start_redis_client(self):
"""
启动redis client
:return:
"""
rc = redis_client.RedisClient.instance(
ArgumentParser().args.redis_ip,
ArgumentParser().args.redis_port,
ArgumentParser().args.redis_db)
ParamCacher().redis_client = rc
def _start_orm(self):
"""
orm初始化
:return:
"""
orm_engine = OrmEngine(ArgumentParser().args.db_host,
ArgumentParser().args.db_port,
ArgumentParser().args.db_name,
ArgumentParser().args.db_user,
ArgumentParser().args.db_password)
ParamCacher().orm_engine = orm_engine
def _start_mysqldb(self):
"""
mysql db引擎开启
:return:
"""
db_instance = DBInstance(db_host=ArgumentParser().args.db_host,
db_port=ArgumentParser().args.db_port,
db_name=ArgumentParser().args.db_name,
db_username=ArgumentParser().args.db_user,
db_password=ArgumentParser().args.db_password,
err_file=logger.fatal)
db_instance.init()
ParamCacher().db_instance = db_instance
def stop_service(self, *args):
"""
退出服务
:param args: 参数
:return:
"""
# 保存数据
self.update()
self.exit()
if not self.is_sm:
self.adv.notify_shutdown()
result = stop_service(ParamCacher().sm_rpc,
ArgumentParser().args.service_id)
assert result['result'] == error_code.ERROR_SUCCESS
[thread.stop() for thread in self.thread_ls]
def __init__(self,
service_type,
service_version,
is_sm=False,
db_update_dir_path=None,
use_mysqldb=False,
use_orm=False,
use_redis=False):
self.service_type = service_type
self.service_version = service_version
self.thread_ls = []
self.is_sm = is_sm
self.db_update_dir_path = db_update_dir_path
self.use_mysqldb = use_mysqldb
self.use_orm = use_orm
self.use_redis = use_redis
self.adv = None
self.sm_rpc = None
logger.init_log(self.service_type, self.service_type)
ExitHandler().add_exit_handler(self.stop_service)
arg_parser = ArgumentParser()
p = arg_parser.get_argparser()
self.add_cmd_opts(p)
p.add_argument('--service_type',
default=service_type,
type=str,
help="The type of the service")
p.add_argument('--service_version',
default=use_redis,
type=str,
help="The version of the service")
p.add_argument('--is_sm',
default=is_sm,
type=bool,
help="Whether it is the service manager")
p.add_argument('--db_update_dir_path',
default=db_update_dir_path,
type=str,
help="The dir for db update use")
p.add_argument('--use_mysqldb',
default=use_mysqldb,
type=parser_boolean,
help="Whether to use the mysqldb lib")
p.add_argument('--use_orm',
default=use_orm,
type=parser_boolean,
help="Whether to use the orm db lib")
p.add_argument('--use_redis',
default=use_redis,
type=parser_boolean,
help="Whether to use the redis cache")
p.add_argument('--logger_mask',
default='0000',
type=str,
help="The logger mask em es fm fs")
IpFinder().is_extranet = arg_parser.args.is_extranet
if not self.is_sm:
SMParamParser(service_type=self.service_type,
sm_rpc=ParamCacher().sm_rpc,
arg_parser=p,
rdm_port_fun=get_random_port)
self.add_cmd_opts_after_sm(p)
if self.db_update_dir_path:
self._db_update()
if self.use_mysqldb:
self._start_mysqldb()
if self.use_redis:
self._start_redis_client()
args = arg_parser.args
arg_parser.will_change = False
self.init(args)
logger.set_logger_level(args.logger_level)