def __init__(self, processor, lsocket, inputProtocolFactory=None, outputProtocolFactory=None, threads=10, readTimeout=None, maxQueueSize=0): self.processor = self._getProcessor(processor) self.socket = lsocket self.in_protocol = inputProtocolFactory or TBinaryProtocolFactory() self.out_protocol = outputProtocolFactory or self.in_protocol self.threads = int(threads) self.clients = {} self.max_queue_size = maxQueueSize # do not set this as a hard size # maximum - the queue may need # extra space for close() self.tasks = Queue.Queue() self._read, self._write = _create_socketpair() self.prepared = False self._stop = False self.serverEventHandler = TServer.TServerEventHandler() self.select_timeout = DEFAULT_SELECT_TIMEOUT self.poller = TSocket.ConnectionEpoll() if hasattr(select, "epoll") \ else TSocket.ConnectionSelect() self.last_logged_error = 0 timeouts = [x for x in [self.select_timeout, readTimeout] \ if x is not None] if len(timeouts) > 0: self.select_timeout = min(timeouts) self._readTimeout = readTimeout
def test_bad_port(self): port = 'bogus' with self.assertRaises(ValueError): with TSocket.TServerSocket(port=port): pass with self.assertRaises(ValueError): with TSocket.TSocket(port=port): pass
def test_unix_socket(self): text = "hi" # sample text to send over the wire with tempfile.NamedTemporaryFile(delete=True) as fh: unix_socket = fh.name with TSocket.TServerSocket(unix_socket=unix_socket) as server: with TSocket.TSocket(unix_socket=unix_socket) as conn: conn.write(text) with server.accept() as client: read = client.read(len(text)) self.assertEquals(read, text) # The socket will not be cleaned up when the server has been shutdown. self.assertTrue(os.path.exists(unix_socket))
def test_deprecated_str_form_of_port(self): # Make sure that the deprecated form of the `port` parameter is # accepted in TServerSocket and TSocket. port = "0" text = "hi" # sample text to send over the wire # NB: unfortunately unittest.TestCase.assertWarns isn't available until # py3. with TSocket.TServerSocket(port=port, family=socket.AF_INET6) as server: addr = server.getSocketNames()[0] with TSocket.TSocket(host=addr[0], port=str(addr[1])) as conn: conn.write(text) with server.accept() as client: read = client.read(len(text)) self.assertEquals(read, text)
def test_open_failure(self): # Bind a server socket to an address, but don't actually listen on it. server_socket = socket.socket(socket.AF_INET6) try: server_socket.bind(('::', 0)) server_port = server_socket.getsockname()[1] # Explicitly use "localhost" as the hostname, so that the # connect code will try both IPv6 and IPv4. We want to # exercise the failure behavior when trying multiple addresses. sock = TSocket.TSocket(host='localhost', port=server_port) sock.setTimeout(50) # ms try: sock.open() self.fail('unexpectedly succeeded to connect to closed socket') except TTransport.TTransportException: # sock.open() should not leave the file descriptor open # when it fails self.assertEquals(None, sock.handle) self.assertEquals({}, sock.handles) # Calling close() again on the socket should be a no-op, # and shouldn't throw an error sock.close() finally: server_socket.close()
def open_SSL(self, ip, port, timeout, ssl_config=None): """open the SSL connection :param ip: the server ip :param port: the server port :param timeout: the timeout for connect and execute :ssl_config: configs for SSL :return: void """ self._ip = ip self._port = port self._timeout = timeout try: if ssl_config is not None: s = TSSLSocket.TSSLSocket( self._ip, self._port, ssl_config.unix_socket, ssl_config.ssl_version, ssl_config.cert_reqs, ssl_config.ca_certs, ssl_config.verify_name, ssl_config.keyfile, ssl_config.certfile, ssl_config.allow_weak_ssl_versions) else: s = TSocket.TSocket(self._ip, self._port) if timeout > 0: s.setTimeout(timeout) transport = TTransport.TBufferedTransport(s) protocol = TBinaryProtocol.TBinaryProtocol(transport) transport.open() self._connection = GraphService.Client(protocol) resp = self._connection.verifyClientVersion( VerifyClientVersionReq()) if resp.error_code != ErrorCode.SUCCEEDED: self._connection._iprot.trans.close() raise ClientServerIncompatibleException(resp.error_msg) except Exception: raise
def test_usage_as_context_manager(self): """ Asserts that both TSocket and TServerSocket can be used with `with` and that their resources are disposed of at the close of the `with`. """ text = "hi" # sample text to send over the wire with TSocket.TServerSocket(port=0, family=socket.AF_INET6) as server: addr = server.getSocketNames()[0] with TSocket.TSocket(host=addr[0], port=addr[1]) as conn: conn.write(text) self.assertFalse(conn.isOpen()) with server.accept() as client: read = client.read(len(text)) self.assertFalse(conn.isOpen()) self.assertFalse(server.isListening()) self.assertEquals(read, text)
def test_throw_populates_headers(self): handler = self.Handler({7: "hello"}) processor = TestService.Processor(handler) server = TCppServerTestManager.make_server(processor) with TCppServerTestManager(server) as server: host, port = server.addr() with TSocket.TSocket(host=host, port=port) as sock: transport = THeaderTransport.THeaderTransport(sock) protocol = THeaderProtocol.THeaderProtocol(transport) client = TestService.Client(protocol, protocol) try: client.throwUserException() self.fail('Expect to throw UserException2') except UserException2: pass self.assertEquals("UserException2", transport.get_headers()["uex"]) self.assertIn("Some message", transport.get_headers()["uexw"]) try: client.throwUncaughtException("a message!") self.fail('Expect to throw TApplicationException') except TApplicationException: pass self.assertEquals("TApplicationException", transport.get_headers()["uex"]) self.assertIn("a message!", transport.get_headers()["uexw"])
def _get_client(self, options): socket = TSocket.TSocket(unix_socket=options.path) if options.framed: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) return self._get_client_by_transport(options, transport, socket=socket)
def establish_a_rare_connection(pytestconfig): addr = pytestconfig.getoption("address") host_addr = addr.split(":") if addr else ["localhost", get_ports()[0]] socket = TSocket.TSocket(host_addr[0], host_addr[1]) transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(transport) transport.open() return GraphService.Client(protocol)
def _get_client(self, options): host, port = self._parse_host_port(options.host, self.default_port) socket = (TSSLSocket.TSSLSocket(host, port) if options.ssl else TSocket.TSocket(host, port)) if options.framed: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) return self._get_client_by_transport(options, transport, socket=socket)
def _get_client_by_host(self): config = self.config host, port = self._parse_host_port(config.host, self.default_port) socket = (TSSLSocket.TSSLSocket(host, port) if config.ssl else TSocket.TSocket(host, port)) if config.framed: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) return self._get_client_by_transport(config, transport, socket=socket)
def get_connection(ip, port): try: socket = TSocket.TSocket(ip, port) transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(transport) transport.open() connection = GraphService.Client(protocol) except Exception as ex: assert False, 'Create connection to {}:{} failed'.format( ip, port) return connection
def open(self): try: self.close() s = TSocket.TSocket(self._address.host, self._address.port) if self._timeout > 0: s.setTimeout(self._timeout) transport = TTransport.TBufferedTransport(s) protocol = TBinaryProtocol.TBinaryProtocol(transport) transport.open() self._connection = GraphStorageService.Client(protocol) except Exception: raise
def open(self): try: self.close() s = TSocket.TSocket(self._leader[0], self._leader[1]) if self._timeout > 0: s.setTimeout(self._timeout) transport = TTransport.TBufferedTransport(s) protocol = TBinaryProtocol.TBinaryProtocol(transport) transport.open() self._connection = MetaService.Client(protocol) except Exception: raise
def _expiring_rpc(self, server, service, method, tm, headers, *args, **kwargs): host, port = server.addr() with TSocket.TSocket(host=host, port=port) as sock: sock.setTimeout(tm) transport = THeaderTransport.THeaderTransport(sock) if headers: for key, val in headers.items(): transport.set_header(key, val) protocol = THeaderProtocol.THeaderProtocol(transport) client = service.Client(protocol, protocol) return getattr(client, method)(*args, **kwargs)
def open(self, ip, port, timeout): self._ip = ip self._port = port try: s = TSocket.TSocket(self._ip, self._port) if timeout > 0: s.setTimeout(timeout) transport = TTransport.TBufferedTransport(s) protocol = TBinaryProtocol.TBinaryProtocol(transport) transport.open() self._connection = GraphService.Client(protocol) except Exception: raise
def test_poller_process(self): # Make sure that pollers do not fail when they're given None as timeout text = "hi" # sample text to send over the wire with TSocket.TServerSocket(port=0, family=socket.AF_INET6) as server: addr = server.getSocketNames()[0] def write_data(): # delay writing to verify that poller.process is waiting time.sleep(1) with TSocket.TSocket(host=addr[0], port=addr[1]) as conn: conn.write(text) poller = TSocket.ConnectionSelect() thread = threading.Thread(target=write_data) thread.start() for filenos in server.handles.keys(): poller.read(filenos) r, _, x = poller.process(timeout=None) thread.join() # Verify that r is non-empty self.assertTrue(r)
def open(self, ip, port, timeout): """open the connection :param ip: the server ip :param port: the server port :param timeout: the timeout for connect and execute :return: void """ self._ip = ip self._port = port self._timeout = timeout s = TSocket.TSocket(self._ip, self._port) if timeout > 0: s.setTimeout(timeout) transport = TTransport.TBufferedTransport(s) protocol = TBinaryProtocol.TBinaryProtocol(transport) transport.open() self._connection = GraphService.Client(protocol) resp = self._connection.verifyClientVersion(VerifyClientVersionReq()) if resp.error_code != ErrorCode.SUCCEEDED: self._connection._iprot.trans.close() raise ClientVersionRejectedException(resp.error_msg)
def do_test(): with TSocket.TServerSocket(port=0, family=socket.AF_INET6): raise Exception('test_error')
def write_data(): # delay writing to verify that poller.process is waiting time.sleep(1) with TSocket.TSocket(host=addr[0], port=addr[1]) as conn: conn.write(text)