def serveClient(self, socket, address): """Process input/output from a client for as long as possible""" client = TSocket() client.setHandle(socket) self.peerName = client.getPeerName() thread_info = current_thread() itrans = self.inputTransportFactory.getTransport(client) otrans = self.outputTransportFactory.getTransport(client) iprot = self.inputProtocolFactory.getProtocol(itrans) if isinstance(self.inputProtocolFactory, THeaderProtocolFactory): oprot = iprot else: oprot = self.outputProtocolFactory.getProtocol(otrans) try: while True: if isinstance(getattr(self.processor._handler, 'peerName', None), dict): self.processor._handler.peerName[thread_info] = client.getPeerName() else: self.processor._handler.peerName = {thread_info: client.getPeerName()} self.processor.process(iprot, oprot) except TTransportException as tx: pass except Exception as x: self.logger.error('[%s]', x, extra={'clientip': client.getPeerName()}) itrans.close() otrans.close()
class TLateInitSSLSocket(TTransportBase): def __init__(self, handle): self.handle = handle self.socket = None def getSocket(self): if self.socket is None: self.handle.do_handshake() self.socket = TSocket() self.socket.setHandle(self.handle) return self.socket def isOpen(self): return self.getSocket().isOpen() def setTimeout(self, ms): return self.getSocket().setTimeout(ms) def read(self, sz): return self.getSocket().read(sz) def write(self, sz): return self.getSocket().write(sz) def flush(self): return self.getSocket().flush() def close(self): if self.socket is None: self.handle.close() else: return self.getSocket().close()
def handle_stream(self, sock, address): tsock = TSocket() tsock.setHandle(sock) itrans = self.itrans.getTransport(tsock) otrans = self.otrans.getTransport(tsock) iprot = self.iprot.getProtocol(itrans) oprot = self.oprot.getProtocol(otrans) try: while True: self.processor.process(iprot, oprot) except TTransportException, ex: pass
def handle(self, client_socket: socket.socket, address: Address) -> None: client = TSocket() client.setHandle(client_socket) trans = self.transport_factory.getTransport(client) prot = self.protocol_factory.getProtocol(trans) try: while self.started: self.processor.process(prot, prot) except TTransportException: pass finally: trans.close()
def handle(self, client_socket, _): client = TSocket() client.setHandle(client_socket) trans = self.transport_factory.getTransport(client) prot = self.protocol_factory.getProtocol(trans) server_context = TRpcConnectionContext(client, prot, prot) try: while self.started: self.processor.process(prot, prot, server_context) except TTransportException: pass finally: trans.close()
def serveClient(self, socket, address): """Process input/output from a client for as long as possible""" client = TSocket() client.setHandle(socket) itrans = self.inputTransportFactory.getTransport(client) otrans = self.outputTransportFactory.getTransport(client) iprot = self.inputProtocolFactory.getProtocol(itrans) if isinstance(self.inputProtocolFactory, THeaderProtocolFactory): oprot = iprot else: oprot = self.outputProtocolFactory.getProtocol(otrans) try: while True: self.processor.process(iprot, oprot) except TTransportException: pass except Exception as x: logging.exception(x) itrans.close() otrans.close()
def serveClient(self, socket, address): """Process input/output from a client for as long as possible""" client = TSocket() client.setHandle(socket) itrans = self.inputTransportFactory.getTransport(client) otrans = self.outputTransportFactory.getTransport(client) iprot = self.inputProtocolFactory.getProtocol(itrans) if isinstance(self.inputProtocolFactory, THeaderProtocolFactory): oprot = iprot else: oprot = self.outputProtocolFactory.getProtocol(otrans) try: while True: self.processor.process(iprot, oprot) except TTransportException as tx: pass except Exception as x: logging.exception(x) itrans.close() otrans.close()
def accept(self): while True: plain_client, addr = self.handle.accept() #print self.allowed_ips, addr[0] if self.allowed_ips and addr[0] not in self.allowed_ips: logging.warn ("client %s is not allowed to connect" % (addr[0])) plain_client.close() continue try: client = ssl.wrap_socket(plain_client, certfile=self.certfile, server_side=True, ssl_version=self.SSL_VERSION) except (ssl.SSLError), e: # failed handshake/ssl wrap, close socket to client plain_client.close() logging.exception (e) continue result = TSocket() result.setHandle(client) return result