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') )