def __init__(self, server_node, iface_cls, config):
self._section_name = utils.get_module(__name__)
self._logger = logging.getLogger(__name__)
self._host = server_node.split(":")[0]
self._port = int(server_node.split(":")[1])
self._iface_cls = iface_cls
self._get_conn_timeout = config.getint(self._section_name, "pool_timeout",
default=settings.DEFAULT_POOL_TIMEOUT)
self._socket_timeout = config.getint(self._section_name, "request_timeout",
default=settings.DEFAULT_REQUEST_TIMEOUT) * 1000
self._size = config.getint(self._section_name, "pool_size", default=settings.DEFAULT_POOL_SIZE)
self._c_module_serialize = config.getboolean(self._section_name, "c_module_serialize",
default=settings.USE_C_MODULE_SERIALIZE)
self._closed = False
if ASYNC_TAG:
from gevent.lock import BoundedSemaphore
from gevent import queue as Queue
self._semaphore = BoundedSemaphore(self._size)
self._connection_queue = Queue.LifoQueue(self._size)
self._QueueEmpty = Queue.Empty
else:
from threading import BoundedSemaphore
import Queue
self._semaphore = BoundedSemaphore(self._size)
self._connection_queue = Queue.LifoQueue(self._size)
self._QueueEmpty = Queue.Empty
def __init__(self, hosts, config):
self._section_name = utils.get_module(__name__)
self._max_delay = config.getint(self._section_name, "max_retry_delay",
default=settings.DEFAULT_ZK_RETRY_MAX_DELAY)
self._timeout = config.getint(self._section_name, "time_out", default=settings.DEFAULT_ZK_CONNECTION_TIMEOUT)
connection_retry = KazooRetry(max_tries=-1, max_delay=self._max_delay)
super(prpcZKClientManager, self).__init__(hosts=hosts, timeout=self._timeout,
connection_retry=connection_retry)
def __init__(self, strategy, dynamic_host_set, config, collector=None):
self._section_name = utils.get_module(__name__)
self._logger = logging.getLogger(__name__)
self._strategy = strategy
self._collector = collector
self._heartbeat_interval = config.getint(
self._section_name,
"heartbeat_interval",
default=settings.DEFAULT_HEARTBEAT_INTERVAL)
self._monitor = settings.SERVICE_MONITOR
self._dynamic_host_set = dynamic_host_set
self._dynamic_host_set.set_onchange(self._create_hostset_onchange())
self._result_options = {
"SUCCESS": self._success,
"TIMEOUT": self._timeout,
"DEAD": self._dead,
"FAILED": self._failed
}
self.spawn(self._heartbeat)
def __init__(self, zkclient, config, is_server=False):
self._section_name = utils.get_module(__name__)
self._logger = logging.getLogger(__name__)
self._zkclient = zkclient
self._is_server = is_server
self.queue = multiprocessing.Queue()
self._info = {}
self._current_info = StatisticsInfo()
self._total_info = StatisticsInfo()
self._lock = threading.RLock()
self._path = None
self._start_time = None
self._last_update_time = None
self.__class__.collect = self.__class__._update_info
self._collect_interval = config.getint(
self._section_name,
"interval",
default=settings.DEFAULT_SEND_INFO_INTERVAL)
self._collect_nodes = config.getint(
self._section_name,
"node_num",
default=settings.DEFAULT_MAX_DETAILINFO_NODE_NUM)
if self._is_server:
self.__class__.collect = self.__class__._server_collect
def __init__(self, client_cls, config):
self._logger = logging.getLogger(__name__)
# get file name filter .py
self._section_name = utils.get_module(__name__)
self.config = config
try:
self._client_cls = client_cls
self._use_zk = config.getboolean(self._section_name,
"use_zk",
default=settings.DEFAULT_USE_ZK)
self._retries = config.getint(
self._section_name,
"retry",
default=settings.DEFAULT_REQUEST_RETRY)
self._balance_path = config.get(self._section_name,
"balance",
default=settings.LOAD_BALANCE_PATH)
balance_strategy = utils.import_class(self._balance_path)
self._client_pool_map = {}
self._dynamic_host_set = DynamicHostSet(config)
if self._use_zk:
self._service_name = config.get(self._section_name,
"service",
required=True)
self._monitor = config.getboolean(
self._section_name,
"monitor",
default=settings.SERVICE_MONITOR)
self._zk_connect_str = config.get(self._section_name,
"zk_connect_str",
required=True)
self._client_name = config.get(self._section_name, "name")
self._owner = config.get(self._section_name, "owner")
hosts = "%s/%s" % (self._zk_connect_str,
settings.DEFAULT_ZK_NAMESPACE_ROOT)
self._server_path = "%s/%s" % (
self._service_name, settings.DEFAULT_ZK_NAMESPACE_SERVERS)
self._client_path = "%s/%s" % (
self._service_name, settings.DEFAULT_ZK_NAMESPACE_CLIENTS)
self._statistic_path = "%s/%s/%s" % (
self._service_name,
settings.DEFAULT_ZK_NAMESPACE_STATISTICS,
settings.DEFAULT_ZK_NAMESPACE_CLIENTS)
# zk client node name, because of use zk sequence, so need save
self._client_node_name = None
self._zkclient = prpcZKClientManager.make(
hosts, config, "client")
# register client
if not self._zkclient.exists(self._client_path):
self._zkclient.create(self._client_path, makepath=True)
if not self._zkclient.exists(self._statistic_path):
self._zkclient.create(self._statistic_path, makepath=True)
self._collector = StatisticsCollector(
self._zkclient, config) if self._monitor else None
self._register_client()
def state_listener(state):
self._logger.debug("state listener state:%s" % state)
if state == KazooState.CONNECTED:
self._zkclient.handler.spawn(self._re_register_client)
self._zkclient.add_listener(state_listener)
self._loadbalancer = LoadBalancer(balance_strategy(),
self._dynamic_host_set,
config,
collector=self._collector)
self._dynamic_host_set.reset_with_list(
self._zkclient.get_children(self._server_path))
# add children listener
ChildrenWatch(self._zkclient,
self._server_path,
func=self._watch_server_node)
if self._collector:
self._collector.set_path(
"%s/%s" %
(self._statistic_path, self._client_node_name))
self._collector.start()
else:
connect_str = config.get(self._section_name,
"direct_address",
required=True)
if re.match(
r"^(\d{1,3}\.){3}\d{1,3}:\d{1,5}(;(\d{1,3}\.){3}\d{1,3}:\d{1,5})*$",
connect_str):
server_nodes = connect_str.split(";")
self._loadbalancer = LoadBalancer(balance_strategy(),
self._dynamic_host_set,
config)
self._dynamic_host_set.reset_with_list(server_nodes)
for server_node in server_nodes:
self._client_pool_map[server_node] = ConnectionPool(
server_node, self._client_cls, self.config)
else:
raise AttributeError("server address is invalid!")
except Exception as e:
self._logger.exception(e)
raise e
def __init__(self, processor, handler, config):
self._logger = logging.getLogger(__name__)
self._section_name = utils.get_module(__name__)
self._server = None
self._service_name = config.get(self._section_name,
"service",
required=True)
self._port = config.getint(self._section_name, "port", required=True)
self._zk_connect_str = config.get(self._section_name,
"zk_connect_str",
required=True)
self._auth_user = config.get(self._section_name,
"auth_user",
required=True)
self._auth_password = config.get(self._section_name,
"auth_password",
required=True)
self._monitor = config.getboolean(self._section_name,
"monitor",
default=settings.SERVICE_MONITOR)
self._c_module_serialize = config.getboolean(
self._section_name,
"c_module_serialize",
default=settings.USE_C_MODULE_SERIALIZE)
self._server_name = config.get(self._section_name, "name")
self._owner = config.get(self._section_name, "owner")
hosts = "%s/%s" % (self._zk_connect_str,
settings.DEFAULT_ZK_NAMESPACE_ROOT)
self._server_path = "%s/%s" % (self._service_name,
settings.DEFAULT_ZK_NAMESPACE_SERVERS)
self._statistic_path = "%s/%s/%s" % (
self._service_name, settings.DEFAULT_ZK_NAMESPACE_STATISTICS,
settings.DEFAULT_ZK_NAMESPACE_SERVERS)
# create zk acl
self._acls = []
self._acls.append(
make_digest_acl(self._auth_user, self._auth_password, all=True))
self._acls.append(make_acl("world", "anyone", read=True))
# create zk_client
self._zkclient = prpcZKClientManager.make(hosts, config, "server")
self._zkclient.add_auth(
"digest", "%s:%s" % (self._auth_user, self._auth_password))
# create zkpath
if not self._zkclient.exists(self._service_name):
self._zkclient.create(self._service_name, makepath=True)
if not self._zkclient.exists(self._server_path):
self._zkclient.create(self._server_path, acl=self._acls)
if not self._zkclient.exists(self._statistic_path):
self._zkclient.create(self._statistic_path, makepath=True)
self.transport = TSocket.TServerSocket(port=self._port)
self.tfactory = TTransport.TBufferedTransportFactory()
if self._monitor:
self._collector = StatisticsCollector(self._zkclient,
config,
is_server=True)
self._processor = self._statistics_wrapper(processor)(handler)
else:
self._processor = processor(handler)
if self._c_module_serialize:
self.pfactory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
else:
self.pfactory = TBinaryProtocol.TBinaryProtocolFactory()