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 _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 stringReceived(self, frame): tmi = TTransport.TMemoryBuffer(frame) tmo = TTransport.TMemoryBuffer() iprot = self.factory.iprot_factory.getProtocol(tmi) oprot = self.factory.oprot_factory.getProtocol(tmo) server_ctx = TwistedRpcConnectionContext(self.transport.socket) d = self.factory.processor.process(iprot, oprot, server_ctx) d.addCallbacks(self.processOk, self.processError, callbackArgs=(tmo,))
def __init__(self, *args): if (len(args) == 2): self.__initArgs__(args[0], args[1], TTransport.TTransportFactoryBase(), TTransport.TTransportFactoryBase(), TBinaryProtocol.TBinaryProtocolFactory(), TBinaryProtocol.TBinaryProtocolFactory()) elif (len(args) == 4): self.__initArgs__(args[0], args[1], args[2], args[2], args[3], args[3]) elif (len(args) == 6): self.__initArgs__(args[0], args[1], args[2], args[3], args[4], args[5])
def handle(self): """Handle requests. WARNING! You must call prepare BEFORE calling handle. """ assert self.prepared, "You have to call prepare before handle" rset, wset, xset = self._select() for readable in rset: if readable == self._read.fileno(): # don't care i just need to clean readable flag self._read.recv(1024) elif readable in self.socket.handles: client_socket = self.socket.accept() connection = Connection(client_socket, self) self.clients[client_socket.fileno()] = connection else: connection = self.clients[readable] connection.read() if connection.status == WAIT_PROCESS: itransport = TTransport.TMemoryBuffer(connection.message) # Header protocol needs oprot == iprot. This implies the # input memory buffer is reused for output too. if isinstance(self.in_protocol, THeaderProtocolFactory): omembuf = itransport iprot = self.in_protocol.getProtocol(itransport) oprot = iprot else: # Otherwise, assume we need a TFramedTransport. omembuf = TTransport.TMemoryBuffer() itransport = TTransport.TFramedTransport(itransport) otransport = TTransport.TFramedTransport(omembuf) iprot = self.in_protocol.getProtocol(itransport) oprot = self.out_protocol.getProtocol(otransport) if self.max_queue_size == 0 or \ self.tasks.qsize() <= self.max_queue_size: self.tasks.put([ self.processor, iprot, oprot, omembuf, connection ]) else: logging.error( "Queue max size of %d exceeded. Request rejected.", self.max_queue_size) for writeable in wset: self.clients[writeable].write() for oob in xset: if oob in self.clients: connection = self.clients[oob] connection.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 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 connectionLost(self, reason=connectionDone): if sys.version_info[0] >= 3: client_req_iter = self.client._reqs.items() else: client_req_iter = self.client._reqs.items() for _, v in client_req_iter: tex = TTransport.TTransportException( type=TTransport.TTransportException.END_OF_FILE, message=self._errormsg or 'Connection closed') v.errback(tex)
def serialize(protocol_factory, thr): # type: (Any, Any) -> AnyStr """Convenience method for serializing objects using the given protocol factory and a TMemoryBuffer.""" transport = TTransport.TMemoryBuffer() protocol = protocol_factory.getProtocol(transport) thr.write(protocol) if isinstance(protocol, THeaderProtocol.THeaderProtocol): protocol.trans.flush() return transport.getvalue()
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 stringReceived(self, frame): tr = TTransport.TMemoryBuffer(frame) iprot = self._iprot_factory.getProtocol(tr) (fname, mtype, rseqid) = iprot.readMessageBegin() try: method = self.recv_map[fname] except KeyError: method = getattr(self.client, 'recv_' + fname) self.recv_map[fname] = method method(iprot, mtype, rseqid)
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 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, 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 deserialize(protocol_factory, data, thr_out): # type: (Any, AnyStr, T) -> T """Convenience method for deserializing objects using the given protocol factory and a TMemoryBuffer. returns its thr_out argument.""" transport = TTransport.TMemoryBuffer(data) try: protocol = protocol_factory.getProtocol(transport, thr_out.thrift_spec) # noqa: T484 except TypeError: protocol = protocol_factory.getProtocol(transport) if isinstance(protocol, THeaderProtocol.THeaderProtocol): # this reads the THeader headers to detect what the underlying # protocol is, as well as looking at transforms, etc. protocol.trans.readFrame(0) protocol.reset_protocol() thr_out.read(protocol) # noqa: T484 return thr_out
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 __thrift_to_json(x): trans = TTransport.TMemoryBuffer() proto = TSimpleJSONProtocol.TSimpleJSONProtocol(trans) x.write(proto) return json.loads(trans.getvalue())