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()