class ALPSTCPClient():
bufsize = 1500
def __init__(self, ip, port, receiver_func=None, background=False):
self.ip_string = ip
self.port = port
self.receiver_func_callback = receiver_func
self.background = background
self.tcpclient = socket(AF_INET, SOCK_STREAM)
# self.__objname = inspect.stack()[1][-2][0].split('=')[0].strip()
def connect(self, thread_name="TCPClient Thread", error_except=True):
if not error_except:
self.tcpclient.connect((self.ip_string, self.port))
else:
try:
self.tcpclient.connect((self.ip_string, self.port))
except Exception as e:
ALPSDebug.alps_error(e)
return False
self.receiver_thread = ALPSThread(threadfunc=self.receiver_handle_thread, threadname=thread_name)
self.receiver_thread.setDaemon(not self.background)
self.receiver_thread.start()
return True
def send(self, data, error_except=True):
if not error_except:
return self.tcpclient.sendall(data)
try:
self.tcpclient.sendall(data)
except Exception as e:
ALPSDebug.alps_error(e, '\n', inspect.getframeinfo((inspect.currentframe().f_back)))
return False
return True
def receiver_handle_thread(self):
while True:
try:
data = self.tcpclient.recv(self.bufsize)
except:
data = ''
if data:
if callable(self.receiver_func_callback):
self.receiver_func_callback(self, data)
else:
self.close()
break
def close(self):
try:
self.tcpclient.shutdown(SHUT_RDWR)
except:
pass
finally:
self.tcpclient.close()
def __init__(self, ip, port, receiver_func=None, connection_event_func=None, background=False, thread_name="TCPServer Thread"):
self.ip_string = ip
self.port = port
self.receiver_func_callback = receiver_func
self.connection_event_callback = connection_event_func
self.background = background
self.connections = {}
self.tcpserver = ThreadingTCPServer((self.ip_string, self.port), self.__request_handle_process)
self.tcpserver.allow_reuse_address = True
tcpsock_thread = ALPSThread(threadfunc=self.tcpserver.serve_forever, threadname=thread_name)
tcpsock_thread.setDaemon(not self.background)
tcpsock_thread.start()
class NodeDiscover:
def __init__(self, discover_timer_cb):
self.__discover_timer_cb = discover_timer_cb
self.__node_list = []
self.mac_collect_enabled = True
self.discover_timer_enabled = True
self.discover_timer_interval = 10
self.__node_discover_thread = ALPSThread(threadfunc=self.__node_discover_timer,
threadname="NodeManager Discover Timer Thread")
def StartDiscover(self):
self.__node_discover_thread.start()
def do_node_discover(self):
if self.mac_collect_enabled:
mac_list = NICDiscover.discover()[0]
for mac in mac_list:
if mac not in self.__node_list:
self.__node_list.append(mac)
self.__discover_timer_cb(self.__node_list)
def __node_discover_timer(self):
while True:
if self.discover_timer_enabled:
self.do_node_discover()
time.sleep(self.discover_timer_interval)
def append(self, node):
if node in self.__node_list:
return False
self.__node_list.append(node)
self.__discover_timer_cb(self.__node_list)
return True
def extend(self, nodes):
for _node in nodes:
if _node in self.__node_list:
return False
self.__node_list.extend(nodes)
self.__discover_timer_cb(self.__node_list)
return True
def remove(self, node):
if node not in self.__node_list:
return False
self.__node_list.remove(node)
self.__discover_timer_cb(self.__node_list)
return True
def hasnode(self, node):
return node in self.__node_list
def __init__(self, configure, connection_callback, **kwargs):
assert configure.has_key('remote_address')
remote_ip, remote_port = configure['remote_address']
self.connection_append = connection_callback[0]
self.connection_remove = connection_callback[1]
self.receiver_cb = connection_callback[2]
for key, value in kwargs.iteritems():
setattr(self, key, value)
self.tcp_client = ALPSTCPClient(remote_ip,
remote_port,
receiver_func=self.__receiver,
background=True)
tcp_client_connect_thread = ALPSThread(threadfunc=self.__connection_attempt_thread,
threadname="Distributor TCP Client Thread")
tcp_client_connect_thread.start()
class ALPSUDPConnection:
def __receiver_thread(self, request, client_address, server):
message = request[0]
if callable(self.receiver_func_callback):
self.receiver_func_callback(self, client_address, message)
# print client_address
def __init__(self, ip, port, receiver_func=None, background=False, use_threading=True):
self.ip_string = ip
self.port = port
self.receiver_func_callback = receiver_func
self.background = background
if use_threading:
self.udpconnection = ThreadingUDPServer((self.ip_string, self.port), self.__receiver_thread)
else:
self.udpconnection = UDPServer((self.ip_string, self.port), self.__receiver_thread)
self.udpconnection.allow_reuse_address = True
# self.__objname = inspect.stack()[1][-2][0].split('=')[0].strip()
def __serve_forever(self):
try:
self.udpconnection.serve_forever()
except:
pass
def bind(self, thread_name="UDPConnection Thread"):
self.udpsock_thread = ALPSThread(threadfunc=self.__serve_forever, threadname=thread_name)
self.udpsock_thread.setDaemon(not self.background)
self.udpsock_thread.start()
def send(self, client_address, message, error_except=True):
if type(client_address) is tuple:
addr_tuple = client_address
else:
addr_tuple = (client_address.split(':')[0], int(client_address.split(':')[1]))
if not error_except:
return self.udpconnection.socket.sendto(message, addr_tuple)
try:
self.udpconnection.socket.sendto(message, addr_tuple)
except Exception as e:
ALPSDebug.alps_error(e, '\n', inspect.getframeinfo((inspect.currentframe().f_back)))
return False
return True
def close(self):
self.udpconnection.server_close()
def __init__(self, discover_timer_cb):
self.__discover_timer_cb = discover_timer_cb
self.__node_list = []
self.mac_collect_enabled = True
self.discover_timer_enabled = True
self.discover_timer_interval = 10
self.__node_discover_thread = ALPSThread(threadfunc=self.__node_discover_timer,
threadname="NodeManager Discover Timer Thread")
class ALPSUNIXConnection:
def __receiver_thread(self, request, client_path, server):
message = request[0]
if callable(self.receiver_func_callback):
self.receiver_func_callback(self, client_path, message)
# print client_path
def __init__(self, path, receiver_func=None, background=False, use_threading=True):
self.path = path
self.receiver_func_callback = receiver_func
self.background = background
if use_threading:
self.unixconnection = ThreadingUnixDatagramServer(self.path, self.__receiver_thread)
else:
self.unixconnection = UnixDatagramServer(self.path, self.__receiver_thread)
# self.__objname = inspect.stack()[1][-2][0].split('=')[0].strip()
def __serve_forever(self):
try:
self.unixconnection.serve_forever()
except:
pass
def bind(self, thread_name="UNIXConnection Thread"):
self.unixsock_thread = ALPSThread(threadfunc=self.__serve_forever, threadname=thread_name)
self.unixsock_thread.setDaemon(not self.background)
self.unixsock_thread.start()
def send(self, path, message, error_except=True):
if not error_except:
return self.unixconnection.socket.sendto(message, path)
try:
self.unixconnection.socket.sendto(message, path)
except Exception as e:
ALPSDebug.alps_error(e, '\n', ALPSDebug.format_inspect_traceback(inspect.currentframe().f_back))
return False
return True
def close(self):
os.unlink(self.path)
self.unixconnection.server_close()
def connect(self, thread_name="TCPClient Thread", error_except=True):
if not error_except:
self.tcpclient.connect((self.ip_string, self.port))
else:
try:
self.tcpclient.connect((self.ip_string, self.port))
except Exception as e:
ALPSDebug.alps_error(e)
return False
self.receiver_thread = ALPSThread(threadfunc=self.receiver_handle_thread, threadname=thread_name)
self.receiver_thread.setDaemon(not self.background)
self.receiver_thread.start()
return True
def bind(self, thread_name="UNIXConnection Thread"):
self.unixsock_thread = ALPSThread(threadfunc=self.__serve_forever, threadname=thread_name)
self.unixsock_thread.setDaemon(not self.background)
self.unixsock_thread.start()
