def _create_connection(self, type):
transport = TTornadoStreamTransport(self.__host, self.__port)
pfactory = TBinaryProtocolFactory()
connection = self.__client_cls(transport, pfactory)
rpc_connection = RPCConnection(self.__host + ':' + str(self.__port) + ':' + str(self.__weight), type, connection)
try:
transport.open()
except Exception,e:
pass
def __init__(self, sasl_client_factory, mechanism, host, port):
"""
@param sasl_client_factory: a callable that returns a new sasl.Client object
@param mechanism: the SASL mechanism (e.g. "GSSAPI")
@param host: ip address or host name
@param port: port
"""
TTornadoStreamTransport.__init__(self, host, port)
self.sasl_client_factory = sasl_client_factory
self.sasl = None
self.mechanism = mechanism
self.opened = False
self.encode = None
self.__wbuf = StringIO()
def __init__(self, sasl_client_factory, mechanism, host, port):
"""
@param sasl_client_factory: a callable that returns a new sasl.Client object
@param mechanism: the SASL mechanism (e.g. "GSSAPI")
@param host: ip address or host name
@param port: port
"""
TTornadoStreamTransport.__init__(self, host, port)
self.sasl_client_factory = sasl_client_factory
self.sasl = None
self.mechanism = mechanism
self.opened = False
self.encode = None
self.__wbuf = StringIO()
def get_transport_factory(cls):
from thriftpy.tornado import TTornadoStreamTransport
return lambda socket: TTornadoStreamTransport(
socket[0],
socket[1],
read_timeout=timedelta(milliseconds=socket[2])
)
def __init__(self,
host=None,
port=10000,
authMechanism=None,
user=None,
password=None,
configuration=None):
super(TornadoConnection, self).__init__(authMechanism)
#Must set a password for thrift, even if it doesn't need one
#Open issue with python-sasl
password = self._check_password(authMechanism, password)
if authMechanism == "NOSASL":
self.transport = TTornadoStreamTransport(host, port)
else:
saslc, sasl_mech = self._get_sasl_client(host, authMechanism, user,
password, configuration)
self.transport = TSaslClientTransportTornado(
saslc, sasl_mech, host, port)
pfactory = TBinaryProtocolFactory()
self.client = TCLIServiceTornado.Client(self.transport, pfactory)
def create(self, key):
server_node = self.__provider.select()
transport = TTornadoStreamTransport(server_node.address,
server_node.port)
protocol = TCompactProtocol.TCompactProtocolFactory()
mprotocol = TMultiplexedProtocol.TMultiplexedProtocol(protocol, key)
client = getattr(self.__ifaces.get(key), "Client")
yield gen.Task(transport.open)
instance = client(transport, mprotocol)
# transport close function
def close(self):
try:
self._iprot.trans.close()
self._oprot.trans.close()
logger.info("Client closed.")
except:
logger.error("Client close error!")
#add close function
instance.close = partial(close, instance)
yield instance
raise gen.Return()
def close(self):
TTornadoStreamTransport.close(self)
self.sasl = None
def close(self):
TTornadoStreamTransport.close(self)
self.sasl = None
def get_transport_factory(self):
from thrift.TTornado import TTornadoStreamTransport
return lambda socket: TTornadoStreamTransport(socket[0], socket[1])
