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 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, 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, 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)
def set_timeout(cls, socket, timeout):
socket.setTimeout(timeout)
