def __init__(self, keyspace, server, framed_transport=True, timeout=None, credentials=None): self.server = server server = server.split(':') if len(server) <= 1: port = 9160 else: port = server[1] host = server[0] socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout*1000.0) if framed_transport: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(self.transport) super(Connection, self).__init__(protocol) self.transport.open() server_api_version = int(self.describe_version().split('.', 1)[0]) assert (server_api_version >= LOWEST_COMPATIBLE_VERSION), \ "Thrift API version incompatibility. " \ "(Server: %s, Lowest compatible version: %d)" % (server_api_version, LOWEST_COMPATIBLE_VERSION) if keyspace is not None: self.set_keyspace(keyspace) self.keyspace = keyspace if credentials is not None: request = AuthenticationRequest(credentials=credentials) self.login(request)
def __init__(self, keyspace, server, framed_transport, timeout, credentials, recycle): host, port = server.split(":") socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout*1000.0) if framed_transport: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Cassandra.Client(protocol) transport.open() client.set_keyspace(keyspace) if credentials is not None: request = AuthenticationRequest(credentials=credentials) client.login(request) self.keyspace = keyspace self.client = client self.transport = transport if recycle: self.recycle = time.time() + recycle + random.uniform(0, recycle * 0.1) else: self.recycle = None
def __init__(self, server, framed_transport, timeout, recycle): host, port = server.split(":") socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout*1000.0) if framed_transport: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Rest.Client(protocol) transport.open() # server_api_version = client.describe_version().split('.', 1) # assert server_api_version[0] == API_VERSION[0], \ # "Thrift API version mismatch. " \ # "(Client: %s, Server: %s)" % (API_VERSION[0], server_api_version[0]) self.client = client self.transport = transport if recycle: self.recycle = time.time() + recycle + random.uniform(0, recycle * 0.1) else: self.recycle = None
def getProtocol(): socket = TSocket.TSocket(*WEBDB_ADDR) socket.setTimeout(TIME_OUT * 1000) transport = TTransport.TFramedTransport(socket) transport.open() # may be after connect protocol = TBinaryProtocol.TBinaryProtocol(transport) return protocol
def __init__(self, keyspace, server, framed_transport, timeout, credentials, recycle): host, port = server.split(":") socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout*1000.0) if framed_transport: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Cassandra.Client(protocol) transport.open() server_api_version = client.describe_version().split('.', 1) assert server_api_version[0] == API_VERSION[0], \ "Thrift API version mismatch. " \ "(Client: %s, Server: %s)" % (API_VERSION[0], server_api_version[0]) client.set_keyspace(keyspace) if credentials is not None: request = AuthenticationRequest(credentials=credentials) client.login(request) self.keyspace = keyspace self.client = client self.transport = transport if recycle: self.recycle = time.time() + recycle + random.uniform(0, recycle * 0.1) else: self.recycle = None
def _connect(self): if self._conn is None: socket = TSocket.TSocket(self._host, self._port) socket.setTimeout(self._timeout) self._conn = TTransport.TFramedTransport(socket) self._client = ElephantDB.Client(TBinaryProtocol.TBinaryProtocol(self._conn)) self._conn.open()
def testConnectTimeout(self): starttime = time.time() try: leaky = [] for i in range(100): socket = TSocket.TSocket('localhost', self.port) socket.setTimeout(10) socket.open() leaky.append(socket) except: self.assert_(time.time() - starttime < 5.0)
def testConnectTimeout(self): starttime = time.time() try: leaky = [] for i in range(100): socket = TSocket.TSocket('localhost', self.port) socket.setTimeout(10) socket.open() leaky.append(socket) except Exception: self.assert_(time.time() - starttime < 5.0)
def testWriteTimeout(self): starttime = time.time() try: socket = TSocket.TSocket('localhost', self.port) socket.setTimeout(10) socket.open() lsock = self.listen_sock.accept() while True: socket.write("hi" * 100) except: self.assert_(time.time() - starttime < 5.0)
def testWriteTimeout(self): starttime = time.time() try: socket = TSocket.TSocket('localhost', self.port) socket.setTimeout(10) socket.open() lsock = self.listen_sock.accept() while True: lsock.write("hi" * 100) except Exception: self.assert_(time.time() - starttime < 5.0)
def _build_server(self, host, port): """Return a client for the given host and port.""" try: socket = TSocket.TSocket(host, int(port)) if self._timeout: socket.setTimeout(self._timeout) transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Cassandra.Client(protocol) client.transport = transport return client except Exception: return None
def open_agent_control(host): socket = TSocket.TSocket(host, 9090) # Set a timeout for the Thrift communication. This is honored for setting # up the TCP socket as well as the actualy RPC communication! socket.setTimeout(5 * 1000) transport = TTransport.TFramedTransport(socket) transport.open() protocol = TBinaryProtocol.TBinaryProtocol(transport) return HSAgent.Client(protocol)
def create_client_transport(server, framed_transport, timeout): host, port = server.split(":") socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout * 1000.0) if framed_transport: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Cassandra.Client(protocol) transport.open() return client, transport
def __init__(self, address, timeout=None): self.name = address host, port = address.split(':') socket = TSocket.TSocket(host, int(port)) if timeout: socket.setTimeout(timeout) self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(self.transport) self.client = Worker.Client(protocol) self.avg_prediction_time = 0 self.is_down = False try: self.transport.open() except: self.is_down = True
def __init__(self, load_balancer_client, load_balancer_address, possible_nodes, SLA, strategy): self.possible_nodes = [Node(x) for x in possible_nodes] for node in self.possible_nodes: for i in range(10): node.PingPrediction() node.PingAvgPredictionTime() for node in self.possible_nodes: if node.IsDown(): print 'NODE ', node.name, ' IS DOWN! ERROR!' quit() print 'Starting...' self.nodes = [] self.nodes.append(self.possible_nodes[0]) # this load balancer is always open, to check for the number of requests and # change state self.load_balancer = load_balancer_client # start a new load balancer that we will open and close before checking # latency host, port = load_balancer_address.split(':') socket = TSocket.TSocket(host, int(port)) socket.setTimeout(1000) self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(self.transport) self.load_balancer2 = LoadBalancer.Client(protocol) self.prediction_times = np.zeros(10) + SLA self.p_cycle = cycle(range(10)) self.start_time = time.time() self.nodes_log = open('/tmp/nodes', 'w', 0) self.num_requests = [0] * 12 self.previous_num_requests = 0 self.SLA = SLA self.strategy = strategy self.strategy.Start(self) self.SetStuff() # t = threading.Thread(target=self.LoadBalancerLoop) # t.start() t2 = threading.Thread(target=self.AvgPredictionLoop) t2.start() t3 = threading.Thread(target=self.PredictionTimeLoop) t3.start() t4 = threading.Thread(target=self.NumRequestsLoop) t4.start()
def __init__(self, keyspace, server, framed_transport=True, timeout=None, credentials=None, api_version=None): self.keyspace = None self.server = server server = server.split(':') if len(server) <= 1: port = 9160 else: port = server[1] host = server[0] socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout * 1000.0) if framed_transport: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(self.transport) super(Connection, self).__init__(protocol) self.transport.open() if api_version is None: server_api_version = self.describe_version() if compatible(CASSANDRA_08, server_api_version): self.version = CASSANDRA_08 elif compatible(CASSANDRA_07, server_api_version): self.version = CASSANDRA_07 else: raise ApiMismatch("Thrift API version incompatibility: " \ "server version %s is not either Cassandra 0.7 (%s) or 0.8 (%s)." % (server_api_version, CASSANDRA_07, CASSANDRA_08)) else: self.version = api_version self.set_keyspace(keyspace) if credentials is not None: request = AuthenticationRequest(credentials=credentials) self.login(request)
def create_client_transport(server, framed_transport, timeout, logins): host, port = server.split(":") socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout*1000.0) if framed_transport: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Cassandra.Client(protocol) transport.open() if logins is not None: for keyspace, credentials in logins.iteritems(): request = AuthenticationRequest(credentials=credentials) client.login(keyspace, request) return client, transport
def create_client_transport(server, framed_transport, timeout, logins): host, port = server.split(":") socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout * 1000.0) if framed_transport: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Cassandra.Client(protocol) transport.open() if logins is not None: for keyspace, credentials in logins.iteritems(): request = AuthenticationRequest(credentials=credentials) client.login(keyspace, request) return client, transport
def __init__(self, keyspace, server, framed_transport=True, timeout=None, credentials=None, api_version=None): self.keyspace = None self.server = server server = server.split(':') if len(server) <= 1: port = 9160 else: port = server[1] host = server[0] socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout*1000.0) if framed_transport: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(self.transport) super(Connection, self).__init__(protocol) self.transport.open() if api_version is None: server_api_version = self.describe_version() if compatible(CASSANDRA_10, server_api_version): self.version = CASSANDRA_10 if compatible(CASSANDRA_08, server_api_version): self.version = CASSANDRA_08 elif compatible(CASSANDRA_07, server_api_version): self.version = CASSANDRA_07 else: raise ApiMismatch("Thrift API version incompatibility: " \ "server version %s is not Cassandra 0.7, 0.8, or 1.0" % (server_api_version)) else: self.version = api_version self.set_keyspace(keyspace) if credentials is not None: request = AuthenticationRequest(credentials=credentials) self.login(request)
def setUserID(self): self.uid = False returnValue = False try: loginServerProxy = self.getServerProxy("/xmlrpc/common") setTimeout(float(Utils.settings["timeoutToGetOdooUID"]) or None) #print("timeoutToGetOdooUID: ", float(Utils.settings["timeoutToGetOdooUID"]) or None ) user_id = loginServerProxy.login( Utils.settings["odooParameters"]["db"][0], Utils.settings["odooParameters"]["user_name"][0], Utils.settings["odooParameters"]["user_password"][0]) if user_id: print("got user id from Odoo ", user_id) self.uid = user_id Utils.storeOptionInDeviceCustomization( "odooConnectedAtLeastOnce", True) returnValue = True else: print("NO user id from Odoo ", user_id) returnValue = False except ConnectionRefusedError as e: print("ConnectionRefusedError checkattendance odoo ln139", e) _logger.debug(ConnectionRefusedError) returnValue = False except socket.timeout as e: print("timeout checkattendance odoo ln139", e) returnValue = False except OSError as osError: print("osError checkattendance odoo ln139", osError) _logger.debug(OSError) if "No route to host" in str(osError): self.display.display_msg("noRouteToHost") time.sleep(1.5) returnValue = False except Exception as e: _logger.exception(e) print("exception in method setUserID: ", e) returnValue = False finally: setTimeout(None) return returnValue
def __init__(self, server, framed_transport=True, timeout=None): self.server = server self.framed_transport = framed_transport self.timeout = timeout server = server.split(":") if len(server) <= 1: port = 9090 else: port = server[1] host = server[0] socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout*1000.0) if framed_transport: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(self.transport) super(Connection, self).__init__(protocol) self.transport.open()
def setUserID(): parameters["odooUid"] = None returnValue = False try: loginServerProxy = getServerProxy("/xmlrpc/common") setTimeout(float(settings["timeoutToGetOdooUID"]) or None) print("timeoutToGetOdooUID: ", float(settings["timeoutToGetOdooUID"]) or None) user_id = loginServerProxy.login( settings["odooParameters"]["db"][0], settings["odooParameters"]["user_name"][0], settings["odooParameters"]["user_password"][0]) if user_id: #print("_"*80) print("setUserID - got user id from Odoo ", user_id) #print("_"*80) parameters["odooUid"] = user_id storeOptionInDeviceCustomization("odooConnectedAtLeastOnce", True) returnValue = True else: print("NO user id from Odoo ", user_id) returnValue = False except ConnectionRefusedError as e: print("ConnectionRefusedError registerAttendanceSync odoo ln139", e) returnValue = False except socket.timeout as e: print("timeout registerAttendanceSync odoo ln139", e) returnValue = False except OSError as osError: print("osError Utils.setuserID ", osError) # if "No route to host" in str(osError): pass returnValue = False except Exception as e: print("exception in method setUserID: ", e) returnValue = False finally: setTimeout(None) return returnValue
def __init__(self, keyspace, server, framed_transport=True, timeout=None, credentials=None): self.server = server server = server.split(':') if len(server) <= 1: port = 9160 else: port = server[1] host = server[0] socket = TSocket.TSocket(host, int(port)) if timeout is not None: socket.setTimeout(timeout * 1000.0) if framed_transport: self.transport = TTransport.TFramedTransport(socket) else: self.transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(self.transport) super(Connection, self).__init__(protocol) self.transport.open() server_api_version = int(self.describe_version().split('.', 1)[0]) assert (server_api_version >= LOWEST_COMPATIBLE_VERSION), \ "Thrift API version incompatibility. " \ "(Server: %s, Lowest compatible version: %d)" % (server_api_version, LOWEST_COMPATIBLE_VERSION) if keyspace is not None: self.set_keyspace(keyspace) self.keyspace = keyspace if credentials is not None: request = AuthenticationRequest(credentials=credentials) self.login(request)
def __init__(self, server, framed_transport, timeout, recycle): socket = TSocket.TSocket(server.hostname, server.port) if timeout is not None: socket.setTimeout(timeout * 1000.0) if framed_transport: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = Rest.Client(protocol) transport.open() # server_api_version = client.describe_version().split('.', 1) # assert server_api_version[0] == API_VERSION[0], \ # "Thrift API version mismatch. " \ # "(Client: %s, Server: %s)" % (API_VERSION[0], server_api_version[0]) self.client = client self.transport = transport if recycle: self.recycle = time.time() + recycle + random.uniform(0, recycle * 0.1) else: self.recycle = None
def set_timeout(cls, socket, timeout): socket.setTimeout(timeout)