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(HARpcZKClientManager, 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, 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 = HARpcZKClientManager.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()
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(HARpcZKClientManager,
self).__init__(hosts=hosts,
timeout=self._timeout,
connection_retry=connection_retry)
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, 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, 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, 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 = HARpcZKClientManager.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()
