def clientServiceGreenlet(self):
ezd = ServiceDiscoveryClient(gConfig.zk)
ezd.register_endpoint(gConfig.appName, EzFrontendServiceName,
gConfig.internal_hostname, gConfig.thriftPort)
ezd.set_security_id_for_application(gConfig.appName, '_Ez_EFE')
while gConfig.run:
try:
handler = ezRPKazookeeper.EzReverseProxyHandler(
self._logger, self._sfh)
processor = EzFrontendService.Processor(handler)
transport = TSSLServerSocket(
host=gConfig.internal_hostname,
port=gConfig.thriftPort,
verify_pattern=gConfig.ez_frontend_access,
ca_certs=gConfig.ez_cafile,
cert=gConfig.ez_certfile,
key=gConfig.ez_keyfile)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#server = TServer.TSimpleServer(processor,transport,tfactory,pfactory)
server = TGeventServer(self._logger, processor, transport,
tfactory, pfactory)
gevent.sleep()
server.serve()
except Exception as e:
self._logger.exception("Error in Thrift server: %s" % e)
self._logger.info("exiting clientServiceGreenlet")
class EzThriftServerTestHarness(KazooTestCase):
"""The EzThriftServerTestHarness extends KazooTestCase to provide service discovery for clients in tests
The thrift server is started using a TSimpleServer and registered with EzBake service discovery
"""
def setUp(self):
super(EzThriftServerTestHarness, self).setUp()
self.sd_client = ServiceDiscoveryClient(self.hosts)
self.server_processes = []
@staticmethod
def __thrift_server(processor, host="localhost", port=8449, use_simple_server=True,
use_ssl=False, ca_certs=None, cert=None, key=None):
if use_ssl:
transport = TSSLServerSocket(host=host, port=port,
ca_certs=ca_certs, cert=cert, key=key)
else:
transport = TSocket.TServerSocket(host=host, port=port)
t_factory = TTransport.TBufferedTransportFactory()
p_factory = TBinaryProtocol.TBinaryProtocolFactory()
if use_simple_server:
server = TServer.TSimpleServer(processor, transport, t_factory, p_factory)
else:
server = TServer.TThreadedServer(processor, transport, t_factory, p_factory)
try:
server.serve()
print 'server started!'
except (Exception, AttributeError, TTransportException) as e:
print e
logger.error("Server error: %s", e)
def add_server(self, app_name, service_name, host, port, processor, use_simple_server=True, wait=1,
use_ssl=False, ca_certs=None, cert=None, key=None):
self.sd_client.register_endpoint(app_name, service_name, host, port)
server_process = Process(target=self.__thrift_server,
args=(processor, host, port, use_simple_server, use_ssl, ca_certs, cert, key))
server_process.start()
time.sleep(wait)
self.server_processes.append(server_process)
def tearDown(self):
super(EzThriftServerTestHarness, self).tearDown()
for server_process in self.server_processes:
if server_process.is_alive():
server_process.terminate()
def clientServiceGreenlet(self):
ezd = ServiceDiscoveryClient(gConfig.zk)
ezd.register_endpoint(gConfig.appName, EzFrontendServiceName, gConfig.internal_hostname, gConfig.thriftPort)
ezd.set_security_id_for_application(gConfig.appName, '_Ez_EFE')
while gConfig.run:
try:
handler = ezRPKazookeeper.EzReverseProxyHandler(self._logger, self._sfh)
processor = EzFrontendService.Processor(handler)
transport = TSSLServerSocket(host=gConfig.internal_hostname,
port=gConfig.thriftPort,
ca_certs=gConfig.ez_cafile,
cert=gConfig.ez_certfile,
key=gConfig.ez_keyfile)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#server = TServer.TSimpleServer(processor,transport,tfactory,pfactory)
server = TGeventServer(self._logger, processor, transport, tfactory, pfactory)
gevent.sleep()
server.serve()
except Exception as e:
self._logger.exception("Error in Thrift server: %s" % e)
self._logger.info("exiting clientServiceGreenlet")
def setUp(self):
"""
"""
super(ThriftClientPoolTest, self).setUp()
ezd_client = ServiceDiscoveryClient(self.hosts)
ez_props = EzConfiguration().getProperties()
ez_props["thrift.use.ssl"] = "false"
ez_props["zookeeper.connection.string"] = self.hosts
application_name = ApplicationConfiguration(ez_props).getApplicationName()
self.serverProcesses = []
for endpoint in ENDPOINTS:
host, port = endpoint.split(':')
port = int(port)
server_process = Process(target=start_ezpz, args=(EzPzHandler(), port,))
server_process.start()
time.sleep(1)
self.serverProcesses.append(server_process)
ezd_client.register_endpoint(application_name, "ezpz", host, port)
ezd_client.register_endpoint(application_name, "service_one", 'localhost', 8083)
ezd_client.register_endpoint(application_name, "service_two", 'localhost', 8084)
ezd_client.register_endpoint(application_name, "service_three", 'localhost', 8085)
ezd_client.register_common_endpoint('common_service_one', 'localhost', 8080)
ezd_client.register_common_endpoint('common_service_two', 'localhost', 8081)
ezd_client.register_common_endpoint('common_service_three', 'localhost', 8082)
ezd_client.register_common_endpoint('common_service_multi', '192.168.1.1', 6060)
ezd_client.register_common_endpoint('common_service_multi', '192.168.1.2', 6161)
ezd_client.register_endpoint("NotThriftClientPool", "unknown_service_three", 'localhost', 8091)
ezd_client.register_endpoint("NotThriftClientPool", "unknown_service_three", 'localhost', 8092)
ezd_client.register_endpoint("NotThriftClientPool", "unknown_service_three", 'localhost', 8093)
self.clientPool = ThriftClientPool(ez_props)
class ServiceDiscoveryClientTest(KazooTestCase):
"""Basic set of tests for ServiceDiscoveryClient."""
def setUp(self):
"""Replace the Zookeeper client on the module."""
super(ServiceDiscoveryClientTest, self).setUp()
self.ezDiscovery = ServiceDiscoveryClient(self.hosts)
def tearDown(self):
"""Clean up the Zookeeper entries."""
super(ServiceDiscoveryClientTest, self).tearDown()
def test_register_endpoint(self):
"""Register an endpoint and make sure it ends up in Zookeeper."""
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8080)
endpoints = self.ezDiscovery.get_endpoints("foo", "bar")
self.assertEqual(endpoints[0], "localhost:8080")
def test_register_common_endpoint(self):
"""Register a common endpoint and make sure it ends up in Zookeeper."""
self.ezDiscovery.register_common_endpoint('bar', 'localhost', 8080)
endpoints = self.ezDiscovery.get_common_endpoints("bar")
self.assertEqual(endpoints[0], "localhost:8080")
def test_unregister_endpoint(self):
"""Register and unregister an endpoint and make sure it is gone."""
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8080)
self.ezDiscovery.unregister_endpoint('foo', 'bar', 'localhost', 8080)
endpoints = self.ezDiscovery.get_endpoints("foo", "bar")
self.assertEqual(len(endpoints), 0)
def test_unregister_common_endpoint(self):
"""Register and unregister a common endpoint and make sure it is gone. """
self.ezDiscovery.register_common_endpoint('bar', 'localhost', 8080)
self.ezDiscovery.unregister_common_endpoint('bar', 'localhost', 8080)
endpoints = self.ezDiscovery.get_common_endpoints("bar")
self.assertEqual(len(endpoints), 0)
def test_unregister_none_exist_endpoint(self):
""" make sure no exception is raised """
self.ezDiscovery.unregister_endpoint('foo', 'bar', 'localhost', 8000)
def test_unregister_multiple_endpoints(self):
"""Test that when multiple endpoints get made and some removed the tree
of endpoints stays correct.
"""
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8000)
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8888)
# Unregister the first endpoint.
self.ezDiscovery.unregister_endpoint('foo', 'bar', 'localhost', 8000)
endpoints = self.ezDiscovery.get_endpoints('foo', 'bar')
self.assertEqual(len(endpoints), 1)
self.assertEqual(endpoints[0], 'localhost:8888')
# Unregister the second endpoint.
self.ezDiscovery.unregister_endpoint('foo', 'bar', 'localhost', 8888)
endpoints = self.ezDiscovery.get_endpoints('foo', 'bar')
self.assertEqual(len(endpoints), 0)
base_path = '/'.join([
ServiceDiscoveryClient.NAMESPACE,
'foo',
'bar',
ServiceDiscoveryClient.ENDPOINTS
])
self.assertTrue(self.client.exists(base_path))
def test_get_applications(self):
"""Test application list."""
# Create a few application endpoints.
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8000)
self.ezDiscovery.register_endpoint('harry', 'sally', 'localhost', 8080)
self.assertEqual(2, len(self.ezDiscovery.get_applications()))
def test_get_services(self):
"""Test the application services list."""
# Create a few application endpoints.
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8000)
self.ezDiscovery.register_endpoint('foo', 'baz', 'localhost', 8001)
self.ezDiscovery.register_endpoint('harry', 'sally', 'localhost', 8080)
# Make sure it returns the right count for a single service.
self.assertEqual(2, len(self.ezDiscovery.get_services('foo')))
self.assertEqual(1, len(self.ezDiscovery.get_services('harry')))
self.assertEqual('sally', self.ezDiscovery.get_services('harry')[0])
def test_get_common_services(self):
"""Test fetching common services."""
# Make a few common services and and an external, ensure they return
# properly.
self.ezDiscovery.register_common_endpoint('foo', 'localhost', 8000)
self.ezDiscovery.register_common_endpoint('bar', 'localhost', 8001)
self.ezDiscovery.register_endpoint('harry', 'sally', 'localhost', 8080)
self.assertEqual(2, len(self.ezDiscovery.get_common_services()))
def test_get_endpoints(self):
"""Test endpoint list fetching."""
# Create a few application endpoints.
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8000)
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8001)
self.ezDiscovery.register_endpoint('harry', 'sally', 'localhost', 8080)
self.assertEqual(2, len(self.ezDiscovery.get_endpoints('foo', 'bar')))
def test_get_common_endpoints(self):
"""Test fetching common endpoints."""
# Create a few common endpoints and one not, test results.
self.ezDiscovery.register_common_endpoint('foo', 'localhost', 8000)
self.ezDiscovery.register_common_endpoint('foo', 'localhost', 8001)
self.ezDiscovery.register_endpoint('harry', 'sally', 'localhost', 8080)
self.assertEqual(2, len(self.ezDiscovery.get_common_endpoints('foo')))
self.assertEquals(0, len(self.ezDiscovery.get_common_endpoints('sally')))
def test_is_service_common(self):
"""Ensure only common services return true."""
# Test one that does not exist.
self.assertFalse(self.ezDiscovery.is_service_common('foo'))
self.ezDiscovery.register_common_endpoint('foo', 'localhost', 8000)
self.assertTrue(self.ezDiscovery.is_service_common('foo'))
self.ezDiscovery.register_endpoint('harry', 'sally', 'localhost', 8080)
self.assertFalse(self.ezDiscovery.is_service_common('sally'))
def test_set_security_id_for_application(self):
"""Ensure security id's get set for applications."""
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8000)
self.ezDiscovery.set_security_id_for_application('foo', 'sid')
path = '/'.join([
ServiceDiscoveryClient.NAMESPACE,
'foo',
ServiceDiscoveryClient.SECURITY,
ServiceDiscoveryClient.SECURITY_ID
])
self.assertTrue(self.client.exists(path))
self.assertEquals('sid', self.client.get(path)[0])
def test_set_security_id_for_common_service(self):
"""Ensure security id's get set for common services."""
self.ezDiscovery.register_common_endpoint('foo', 'localhost', 8000)
self.ezDiscovery.set_security_id_for_common_service('foo', 'sid')
path = '/'.join([
ServiceDiscoveryClient.NAMESPACE,
'/'.join([ServiceDiscoveryClient.COMMON_APP_NAME, 'foo']),
ServiceDiscoveryClient.SECURITY,
ServiceDiscoveryClient.SECURITY_ID
])
self.assertTrue(self.client.exists(path))
self.assertEquals('sid', self.client.get(path)[0])
def test_get_security_id_for_application(self):
"""Ensure fetching application security id's returns properly."""
# Fetch one that does not exist.
self.assertEquals(
None,
self.ezDiscovery.get_security_id('foo')
)
self.ezDiscovery.register_endpoint('foo', 'bar', 'localhost', 8000)
self.ezDiscovery.set_security_id_for_application('foo', 'sid')
self.assertEquals(
'sid',
self.ezDiscovery.get_security_id('foo')
)
def test_get_security_id_for_common_service(self):
"""Ensure fetching application security id's returns properly."""
# clear the cache
self.ezDiscovery.securityIdCache.clear()
# Fetch one does not exist.
self.assertEquals(
None,
self.ezDiscovery.get_security_id('foo')
)
self.ezDiscovery.register_common_endpoint('foo', 'localhost', 8000)
self.ezDiscovery.set_security_id_for_common_service('foo', 'sid')
self.assertEquals(
'sid',
self.ezDiscovery.get_security_id('foo')
)
