def shutdown(self):
for timer in self._scheduled_timers:
timer.cancel()
for notification in self._notifications:
handler = self.__get_multicast_handler()
handler.send_byebye(notification)
handler.release_response()
UDPServer.shutdown(self)
class UDPEchoClientTest(BaseHostTest):
def __init__(self):
"""
Initialise test parameters.
:return:
"""
BaseHostTest.__init__(self)
self.SERVER_IP = None # Will be determined after knowing the target IP
self.SERVER_PORT = 0 # Let TCPServer choose an arbitrary port
self.server = None
self.server_thread = None
self.target_ip = None
@staticmethod
def find_interface_to_target_addr(target_ip):
"""
Finds IP address of the interface through which it is connected to the target.
:return:
"""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((target_ip, 0)) # Target IP, Any port
ip = s.getsockname()[0]
s.close()
return ip
def setup_udp_server(self):
"""
sets up a UDP server for target to connect and send test data.
:return:
"""
# !NOTE: There should mechanism to assert in the host test
if self.SERVER_IP is None:
self.log("setup_udp_server() called before determining server IP!")
self.notify_complete(False)
# Returning none will suppress host test from printing success code
self.server = UDPServer((self.SERVER_IP, self.SERVER_PORT), UDPEchoClientHandler)
ip, port = self.server.server_address
self.SERVER_PORT = port
self.server.allow_reuse_address = True
self.log("HOST: Listening for UDP packets: " + self.SERVER_IP + ":" + str(self.SERVER_PORT))
self.server_thread = Thread(target=UDPEchoClientTest.server_thread_func, args=(self,))
self.server_thread.start()
@staticmethod
def server_thread_func(this):
"""
Thread function to run TCP server forever.
:param this:
:return:
"""
this.server.serve_forever()
@event_callback("target_ip")
def _callback_target_ip(self, key, value, timestamp):
"""
Callback to handle reception of target's IP address.
:param key:
:param value:
:param timestamp:
:return:
"""
self.target_ip = value
self.SERVER_IP = self.find_interface_to_target_addr(self.target_ip)
self.setup_udp_server()
@event_callback("host_ip")
def _callback_host_ip(self, key, value, timestamp):
"""
Callback for request for host IP Addr
"""
self.send_kv("host_ip", self.SERVER_IP)
@event_callback("host_port")
def _callback_host_port(self, key, value, timestamp):
"""
Callback for request for host port
"""
self.send_kv("host_port", self.SERVER_PORT)
def teardown(self):
if self.server:
self.server.shutdown()
self.server_thread.join()
class DPM:
"""
DPM is Data Processing Module
DPM is used to receive data from routes
and preprocesses the data and then sends it to WCM and PAM
"""
def __init__(self, interval):
"""
init the DPM
:param interval: the time interval of sending data (ms)
:return:
"""
self.__interval = interval / 1000.0
self.__ip = socket.gethostbyname(socket.gethostname())
self.__udpServer = UDPServer(('0.0.0.0', DPM_PORT), DataRecvServer)
def start(self):
"""
start running the DPM
:return:
"""
thSend = Thread(target=self.runSend)
self.__needQuit = False
thSend.daemon = True
thSend.start()
self.__udpServer.serve_forever()
try:
thSend.join()
except KeyboardInterrupt:
self.quit()
def runSend(self):
"""
Send data to the WCM
:return:
"""
while not self.__needQuit:
sleep(self.__interval)
with lock:
body = json.dumps(dataDict)
header = struct.pack('>BIxxxxI', DPM_MES_TYPE, int(time()),
len(body))
print int(time()), body
"""
send data to WCM
"""
try:
WCMSender = TcpClient('0.0.0.0', WCM_PORT)
WCMSender.connect()
WCMSender.write(header)
WCMSender.write(body.encode('utf-8'))
WCMSender.flush()
except:
print 'conncect WCM failed'
finally:
WCMSender.close()
dataDict.clear()
def quit(self):
"""
quit the deamon
:return:
"""
self.__needQuit = True
self.__udpServer.shutdown()
class UDPEchoClientTest(BaseHostTest):
def __init__(self):
"""
Initialise test parameters.
:return:
"""
BaseHostTest.__init__(self)
self.SERVER_IP = None # Will be determined after knowing the target IP
self.SERVER_PORT = 0 # Let TCPServer choose an arbitrary port
self.server = None
self.server_thread = None
self.target_ip = None
@staticmethod
def find_interface_to_target_addr(target_ip):
"""
Finds IP address of the interface through which it is connected to the target.
:return:
"""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
s.connect((target_ip, 0)) # Target IP, any port
except socket.error:
s.connect((target_ip, 8000)) # Target IP, 'random' port
ip = s.getsockname()[0]
s.close()
return ip
def setup_udp_server(self):
"""
sets up a UDP server for target to connect and send test data.
:return:
"""
# !NOTE: There should mechanism to assert in the host test
if self.SERVER_IP is None:
self.log("setup_udp_server() called before determining server IP!")
self.notify_complete(False)
# Returning none will suppress host test from printing success code
self.server = UDPServer((self.SERVER_IP, self.SERVER_PORT),
UDPEchoClientHandler)
ip, port = self.server.server_address
self.SERVER_PORT = port
self.server.allow_reuse_address = True
self.log("HOST: Listening for UDP packets: " + self.SERVER_IP + ":" +
str(self.SERVER_PORT))
self.server_thread = Thread(
target=UDPEchoClientTest.server_thread_func, args=(self, ))
self.server_thread.start()
@staticmethod
def server_thread_func(this):
"""
Thread function to run TCP server forever.
:param this:
:return:
"""
this.server.serve_forever()
@event_callback("target_ip")
def _callback_target_ip(self, key, value, timestamp):
"""
Callback to handle reception of target's IP address.
:param key:
:param value:
:param timestamp:
:return:
"""
self.target_ip = value
self.SERVER_IP = self.find_interface_to_target_addr(self.target_ip)
self.setup_udp_server()
@event_callback("host_ip")
def _callback_host_ip(self, key, value, timestamp):
"""
Callback for request for host IP Addr
"""
self.send_kv("host_ip", self.SERVER_IP)
@event_callback("host_port")
def _callback_host_port(self, key, value, timestamp):
"""
Callback for request for host port
"""
self.send_kv("host_port", self.SERVER_PORT)
def teardown(self):
if self.server:
self.server.shutdown()
self.server_thread.join()
def shutdown(self): print '[*] cldap server: shutting down...' UDPServer.shutdown(self)
class DPM:
"""
DPM is Data Processing Module
DPM is used to receive data from routes
and preprocesses the data and then sends it to WCM and PAM
"""
def __init__(self, interval):
"""
init the DPM
:param interval: the time interval of sending data (ms)
:return:
"""
self.__interval = interval / 1000.0
self.__ip = socket.gethostbyname(socket.gethostname())
self.__udpServer = UDPServer(('0.0.0.0', DPM_PORT), DataRecvServer)
def start(self):
"""
start running the DPM
:return:
"""
thSend = Thread(target=self.runSend)
self.__needQuit = False
thSend.daemon = True
thSend.start()
self.__udpServer.serve_forever()
try:
thSend.join()
except KeyboardInterrupt:
self.quit()
def runSend(self):
"""
Send data to the WCM
:return:
"""
while not self.__needQuit:
sleep(self.__interval)
with lock:
body = json.dumps(dataDict)
header = struct.pack('>BIxxxxI', DPM_MES_TYPE, int(time()), len(body))
print int(time()), body
"""
send data to WCM
"""
try:
WCMSender = TcpClient('0.0.0.0', WCM_PORT)
WCMSender.connect()
WCMSender.write(header)
WCMSender.write(body.encode('utf-8'))
WCMSender.flush()
except:
print 'conncect WCM failed'
finally:
WCMSender.close()
dataDict.clear()
def quit(self):
"""
quit the deamon
:return:
"""
self.__needQuit = True
self.__udpServer.shutdown()
