def __init__(self, server_address, use_simulator, simulatorLoopData,
retryNumBind, logWriter):
self.onReciceEvent = self.defaultOnReciveEvent
self.logWriter = logWriter
if use_simulator:
self.sock = mockupSocket(simulatorLoopData)
print('IpController: using port simulator')
else:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print('IpController: Using ' + str(server_address[1]))
self.streamProcessor = StreamProcessor(self.onReceiveControl,
self.onReceiveSignal,
self.onReceiveAutopilot)
tryNum = retryNumBind
while True:
try:
self.sock.bind(server_address)
break
except Exception as e:
sys.stderr.write(
'IpController: failed ({0}/{1}): {2}\n'.format(
tryNum, retryNumBind, e))
tryNum -= 1
if tryNum < 1:
raise Exception("IpController: can't bind socket!")
#end of method execution - exception raised
time.sleep(5)
self.sock.listen(1)
def __init__(self, uartDev, usartBaundRate, logWriter):
self.uartController = UartController(uartDev, usartBaundRate)
self.uartOpened = True
self.logWriter = logWriter
self.onReceiveEvent = self.defaultOnReceiveEvent
self.streamProcessor = StreamProcessor(self.onReceiveControl,
self.onReceiveSignal,
self.onReceiveAutopilot)
self.receivingThread = TimerThread('receivingThread',
self.receiveThread, 0.05) # 20 Hz
self.receivingThread.start()
def __init__(self, datainfo, timeinfo):
'''
This constructor is supposed to initialize data members.
Use triple quotes for function documentation.
'''
# Just print some info from the datainfo variable
print(
"The Budget for this data set is: %d seconds" %
datainfo['time_budget'], 'name:', datainfo['name'])
print("Loaded %d time features, %d numerical features, %d categorical " \
"features and %d multi valued categorical variables" \
%(datainfo['loaded_feat_types'][0], datainfo['loaded_feat_types'][1],\
datainfo['loaded_feat_types'][2],datainfo['loaded_feat_types'][3]))
overall_spenttime = time.time() - timeinfo[0]
dataset_spenttime = time.time() - timeinfo[1]
print("[***] Overall time spent %5.2f sec" % overall_spenttime)
print("[***] Dataset time spent %5.2f sec" % dataset_spenttime)
self.num_train_samples = 0
self.num_feat = 1
self.num_labels = 1
self.is_trained = False
### install hyperopt and lightgbm ###
#print("AutoGBT[Model]:installing hyperopt and lightgbm...")
#setupmgr.pip_install("hyperopt")
#setupmgr.pip_install("lightgbm")
import StreamProcessor
self.mdl = StreamProcessor.StreamSaveRetrainPredictor()
self.score = []
self.batch_num = 0
def __init__(self, server_address, use_simulator, simulatorLoopData, retryNumBind, logWriter):
self.onReciceEvent=self.defaultOnReciveEvent
self.logWriter = logWriter
if use_simulator:
self.sock = mockupSocket(simulatorLoopData)
print('IpController: using port simulator')
else:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print('IpController: Using ' + str(server_address[1]))
self.streamProcessor = StreamProcessor(self.onReceiveControl, self.onReceiveSignal, self.onReceiveAutopilot)
tryNum=retryNumBind
while True:
try:
self.sock.bind(server_address)
break
except Exception as e:
sys.stderr.write('IpController: failed ({0}/{1}): {2}\n'.format(tryNum,retryNumBind,e))
tryNum-=1
if tryNum<1:
raise Exception("IpController: can't bind socket!")
#end of method execution - exception raised
time.sleep(5)
self.sock.listen(1)
def __init__(self, adress, port):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((adress, port))
except:
print 'Unable to connect to the server!', adress, ':', port
sys.exit()
print 'Successfuly connected to the server', adress, ':', port
self.keepConnectionFlag = True
self.streamProcessor = StreamProcessor(self.onDebugReceive,
self.onPongReceive)
self.sendingControlThread = TimerThread(self.sendingControlHandler,
0.1)
self.sendingSignalThread = TimerThread(self.sendingSignalHandler, 1.0)
def __init__(self,uartDev, usartBaundRate, logWriter):
self.uartController = UartController(uartDev, usartBaundRate)
self.uartOpened = True
self.logWriter = logWriter
self.onReceiveEvent = self.defaultOnReceiveEvent
self.streamProcessor = StreamProcessor(self.onReceiveControl, self.onReceiveSignal, self.onReceiveAutopilot)
self.receivingThread = TimerThread('receivingThread',self.receiveThread, 0.05) # 20 Hz
self.receivingThread.start()
def __init__(self, adress, port):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((adress, port))
except:
print 'Unable to connect to the server!', adress, ':', port
sys.exit()
print 'Successfuly connected to the server', adress, ':', port
self.keepConnectionFlag = True
self.streamProcessor = StreamProcessor(self.onDebugReceive, self.onPongReceive)
self.sendingControlThread = TimerThread(self.sendingControlHandler, 0.1)
self.sendingSignalThread = TimerThread(self.sendingSignalHandler, 1.0)
def __init__(self,datainfo):
'''
This constructor is supposed to initialize data members.
Use triple quotes for function documentation.
'''
# Just print some info from the datainfo variable
self.num_train_samples=0
self.num_feat=1
self.num_labels=1
self.is_trained=False
### install hyperopt and lightgbm ###
print("AutoGBT[Model]:installing hyperopt and lightgbm...")
setupmgr.pip_install("hyperopt")
setupmgr.pip_install("lightgbm")
import StreamProcessor
self.mdl = StreamProcessor.StreamSaveRetrainPredictor()
class ADdroneClient:
sock = None
streamProcessor = None
keepConnectionFlag = False
""" ControlData sending """
controlData = None
sendingControlThread = None
# method called by sending thread to send ControlData to server
def sendingControlHandler(self):
if self.controlData is not None:
self.sock.send(self.controlData.data)
""" Ping sending """
pingTimestamp = None
pingData = None
isPongReceived = True
sendingSignalThread = None
# method called by sending thread to send Ping to server
# sending is only avalible when previous Pong was received
def sendingSignalHandler(self):
if isPongReceived:
pingData = '%%%%abcd'
isPongReceived = False
pingTimestamp = datetime.datetime.now()
self.sock.send(pingData)
""" on receive handlers """
def onDebugReceive(self, data):
print onDebugReceive
pass
def onPongReceive(self, data):
if data == pingData:
now = datetime.datetime.now()
isPongReceived = True
d = now - pingTimestamp
print 'onPongReceive: ' + (d.seconds * 1000 +
d.microseconds / 1000)
else:
print 'Bad data received at signal chanell'
def __init__(self, adress, port):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((adress, port))
except:
print 'Unable to connect to the server!', adress, ':', port
sys.exit()
print 'Successfuly connected to the server', adress, ':', port
self.keepConnectionFlag = True
self.streamProcessor = StreamProcessor(self.onDebugReceive,
self.onPongReceive)
self.sendingControlThread = TimerThread(self.sendingControlHandler,
0.1)
self.sendingSignalThread = TimerThread(self.sendingSignalHandler, 1.0)
def proceedReceiving(self):
BUFFER_SIZE = 512
try:
data = self.connection.recv(BUFFER_SIZE)
except:
data = None
print 'proceedReceiving: IP receive ERROR/TIMEOUT'
if not data:
print 'IpController: client disconnected:', self.client_address
self.keepConnectionFlag = False
return
self.streamProcessor.processStream(data)
def setControlData(self, controlData):
self.controlData = controlData
def close(self):
self.sock.close()
self.sendingControlThread.close()
self.sendingSignalThread.close()
class DroneController:
uartController = None
receivingThread = None
logWriter = None
noDebugReceivingCounter = 0
maxTimeoutCounter = 20 # 20 * 0.05 = 1s
onReceiveEvent = None # Event to call when read data from USART
streamProcessor = None
uartOpened = None
def __init__(self,uartDev, usartBaundRate, logWriter):
self.uartController = UartController(uartDev, usartBaundRate)
self.uartOpened = True
self.logWriter = logWriter
self.onReceiveEvent = self.defaultOnReceiveEvent
self.streamProcessor = StreamProcessor(self.onReceiveControl, self.onReceiveSignal, self.onReceiveAutopilot)
self.receivingThread = TimerThread('receivingThread',self.receiveThread, 0.05) # 20 Hz
self.receivingThread.start()
#onReceiveEvent - call this function when new CommData is received via UART
def setOnReceiveEvent(self, onReceiveEvent):
self.onReceiveEvent = onReceiveEvent
def defaultOnReceiveEvent(self, commData):
self.logWriter.noteEvent('DroneController: defaultOnReceiveEvent' + str(commData))
def close(self):
print('DroneControler: close')
if self.uartOpened:
print ('DroneControler: UART opened, sending STOP command')
self.sendCommData(ControlData.StopCommand())
# wait for sending and response
time.sleep(1.5)
TimerThread.kill(self.receivingThread)
self.uartController.close()
self.uartOpened = False
# Thread
# uartConnection
# handler for receiving thread
def receiveThread(self):
data = self.uartController.recv()
dataLength = len(data)
if dataLength == 0:
self.noDebugReceivingCounter += 1
if self.noDebugReceivingCounter >= self.maxTimeoutCounter:
# build ERROR_CONNECTION DebugData and call onReceiveEvent
debugData = DebugData.SomeValidDebugMessage()
debugData.setConnectionLost()
self.logWriter.noteEvent('DroneController: Error! Receiving thread timeout.')
self.onReceiveEvent(debugData)
self.noDebugReceivingCounter = 0
return
self.noDebugReceivingCounter = 0
log_msg = 'DroneController: received: [0x' + str(data.encode("hex")) + ']'
self.logWriter.noteEvent(log_msg)
# push data to stream processor - when data packet is be received onReceive event will be called
self.streamProcessor.processStream(data)
# event called by StreamProcessor - on control preamble
def onReceiveControl(self, debugDataMsg):
debugData = DebugData(debugDataMsg)
if debugData.isValid():
# forward data to DronController
self.onReceiveEvent(debugData)
log_msg = 'DroneController: DebugData received: [' + str(debugData) + ']'
else:
log_msg = 'DroneController: INVALID DebugData received: [' + debugDataMsg + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on signal preamble
def onReceiveSignal(self, signalPongMsg):
# this event should never be called on Uart communication side
log_msg = 'DroneController: Unexpected event received [' + str(signalPongMsg.encode("hex")) + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on autopilota preamble
def onReceiveAutopilot(self, autopilotDataMsg):
autopilotData = AutopilotData(autopilotDataMsg)
if autopilotData.isValid():
# forward data to DroneController
self.onReceiveEvent(autopilotData)
log_msg = 'DroneController: AutopilotData received [0x' + str(autopilotDataMsg.encode("hex")) + ']'
else:
log_msg = 'DroneController: INVALID AutopilotData received [0x' + autopilotDataMsg + ']'
self.logWriter.noteEvent(log_msg)
# send CommData to drone
def sendCommData(self, commData):
log_msg = 'DroneController: Forwarding CommData: [0x' + commData.data.encode("hex") + ']'
self.logWriter.noteEvent(log_msg)
self.uartController.send(commData.data)
def getDebugData(self):
return self.debugData
class DroneController:
uartController = None
receivingThread = None
logWriter = None
noDebugReceivingCounter = 0
maxTimeoutCounter = 20 # 20 * 0.05 = 1s
onReceiveEvent = None # Event to call when read data from USART
streamProcessor = None
uartOpened = None
def __init__(self, uartDev, usartBaundRate, logWriter):
self.uartController = UartController(uartDev, usartBaundRate)
self.uartOpened = True
self.logWriter = logWriter
self.onReceiveEvent = self.defaultOnReceiveEvent
self.streamProcessor = StreamProcessor(self.onReceiveControl,
self.onReceiveSignal,
self.onReceiveAutopilot)
self.receivingThread = TimerThread('receivingThread',
self.receiveThread, 0.05) # 20 Hz
self.receivingThread.start()
#onReceiveEvent - call this function when new CommData is received via UART
def setOnReceiveEvent(self, onReceiveEvent):
self.onReceiveEvent = onReceiveEvent
def defaultOnReceiveEvent(self, commData):
self.logWriter.noteEvent('DroneController: defaultOnReceiveEvent' +
str(commData))
def close(self):
print('DroneControler: close')
if self.uartOpened:
print('DroneControler: UART opened, sending STOP command')
self.sendCommData(ControlData.StopCommand())
# wait for sending and response
time.sleep(1.5)
TimerThread.kill(self.receivingThread)
self.uartController.close()
self.uartOpened = False
# Thread
# uartConnection
# handler for receiving thread
def receiveThread(self):
data = self.uartController.recv()
dataLength = len(data)
if dataLength == 0:
self.noDebugReceivingCounter += 1
if self.noDebugReceivingCounter >= self.maxTimeoutCounter:
# build ERROR_CONNECTION DebugData and call onReceiveEvent
debugData = DebugData.SomeValidDebugMessage()
debugData.setConnectionLost()
self.logWriter.noteEvent(
'DroneController: Error! Receiving thread timeout.')
self.onReceiveEvent(debugData)
self.noDebugReceivingCounter = 0
return
self.noDebugReceivingCounter = 0
log_msg = 'DroneController: received: [0x' + str(
data.encode("hex")) + ']'
self.logWriter.noteEvent(log_msg)
# push data to stream processor - when data packet is be received onReceive event will be called
self.streamProcessor.processStream(data)
# event called by StreamProcessor - on control preamble
def onReceiveControl(self, debugDataMsg):
debugData = DebugData(debugDataMsg)
if debugData.isValid():
# forward data to DronController
self.onReceiveEvent(debugData)
log_msg = 'DroneController: DebugData received: [' + str(
debugData) + ']'
else:
log_msg = 'DroneController: INVALID DebugData received: [' + debugDataMsg + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on signal preamble
def onReceiveSignal(self, signalPongMsg):
# this event should never be called on Uart communication side
log_msg = 'DroneController: Unexpected event received [' + str(
signalPongMsg.encode("hex")) + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on autopilota preamble
def onReceiveAutopilot(self, autopilotDataMsg):
autopilotData = AutopilotData(autopilotDataMsg)
if autopilotData.isValid():
# forward data to DroneController
self.onReceiveEvent(autopilotData)
log_msg = 'DroneController: AutopilotData received [0x' + str(
autopilotDataMsg.encode("hex")) + ']'
else:
log_msg = 'DroneController: INVALID AutopilotData received [0x' + autopilotDataMsg + ']'
self.logWriter.noteEvent(log_msg)
# send CommData to drone
def sendCommData(self, commData):
log_msg = 'DroneController: Forwarding CommData: [0x' + commData.data.encode(
"hex") + ']'
self.logWriter.noteEvent(log_msg)
self.uartController.send(commData.data)
def getDebugData(self):
return self.debugData
class ADdroneClient:
sock = None
streamProcessor = None
keepConnectionFlag = False
""" ControlData sending """
controlData = None
sendingControlThread = None
# method called by sending thread to send ControlData to server
def sendingControlHandler(self):
if self.controlData is not None:
self.sock.send(self.controlData.data)
""" Ping sending """
pingTimestamp = None
pingData = None
isPongReceived = True
sendingSignalThread = None
# method called by sending thread to send Ping to server
# sending is only avalible when previous Pong was received
def sendingSignalHandler(self):
if isPongReceived:
pingData = '%%%%abcd'
isPongReceived = False
pingTimestamp = datetime.datetime.now()
self.sock.send(pingData)
""" on receive handlers """
def onDebugReceive(self, data):
print onDebugReceive
pass
def onPongReceive(self, data):
if data == pingData:
now = datetime.datetime.now()
isPongReceived = True
d = now - pingTimestamp
print 'onPongReceive: ' + (d.seconds*1000 + d.microseconds/1000)
else:
print 'Bad data received at signal chanell'
def __init__(self, adress, port):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((adress, port))
except:
print 'Unable to connect to the server!', adress, ':', port
sys.exit()
print 'Successfuly connected to the server', adress, ':', port
self.keepConnectionFlag = True
self.streamProcessor = StreamProcessor(self.onDebugReceive, self.onPongReceive)
self.sendingControlThread = TimerThread(self.sendingControlHandler, 0.1)
self.sendingSignalThread = TimerThread(self.sendingSignalHandler, 1.0)
def proceedReceiving(self):
BUFFER_SIZE = 512
try:
data = self.connection.recv(BUFFER_SIZE)
except:
data = None
print 'proceedReceiving: IP receive ERROR/TIMEOUT'
if not data:
print 'IpController: client disconnected:', self.client_address
self.keepConnectionFlag = False
return
self.streamProcessor.processStream(data)
def setControlData(self, controlData):
self.controlData = controlData
def close(self):
self.sock.close()
self.sendingControlThread.close()
self.sendingSignalThread.close()
class IpController:
sock = None
connection = None
keepConnectionFlag = False
client_address = None
logWriter = None
onReceiveEvent = None #function one argument
streamProcessor = None
def __init__(self, server_address, use_simulator, simulatorLoopData,
retryNumBind, logWriter):
self.onReciceEvent = self.defaultOnReciveEvent
self.logWriter = logWriter
if use_simulator:
self.sock = mockupSocket(simulatorLoopData)
print('IpController: using port simulator')
else:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print('IpController: Using ' + str(server_address[1]))
self.streamProcessor = StreamProcessor(self.onReceiveControl,
self.onReceiveSignal,
self.onReceiveAutopilot)
tryNum = retryNumBind
while True:
try:
self.sock.bind(server_address)
break
except Exception as e:
sys.stderr.write(
'IpController: failed ({0}/{1}): {2}\n'.format(
tryNum, retryNumBind, e))
tryNum -= 1
if tryNum < 1:
raise Exception("IpController: can't bind socket!")
#end of method execution - exception raised
time.sleep(5)
self.sock.listen(1)
def setOnReceiveEvent(self, receiveEvent):
self.onReceiveEvent = receiveEvent
def defaultOnReciveEvent(self, commData):
self.logWriter.noteEvent(
'IpController: defaultOnReceiveEvent, data: ' + str(commData))
def acceptConnection(self):
self.keepConnectionFlag = False
self.connection, self.client_address = self.sock.accept()
self.keepConnectionFlag = True
print 'IpController: client connected:', self.client_address
self.logWriter.noteEvent('IpController: Client connected: ' + \
str(self.client_address))
def icConnected(self):
return not (self.connection is None)
def sendCommData(self, data):
if not self.icConnected():
return False
try:
self.connection.send(data)
log_msg = 'IpController: send: [0x' + str(
data.encode("hex")) + '] len:' + str(len(data))
except Exception as e:
log_msg = 'IpController: send failed: ' + str(
data) + " Exception: " + str(e)
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on control preamble
def onReceiveControl(self, controlDataMsg):
controlData = ControlData(controlDataMsg)
if controlData.isValid():
# forward data to DronController
self.onReceiveEvent(controlData)
log_msg = 'IpController: ControlData received: [' + str(
controlData) + ']'
else:
log_msg = 'IpController: INVALID ControlData received: [' + controlDataMsg + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on signal preamble
def onReceiveSignal(self, signalPongMsg):
# immadetely response with ping
self.sendCommData(signalPongMsg)
log_msg = 'IpController: Signal received [0x' + str(
signalPongMsg.encode("hex")) + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on autopilot preamble
def onReceiveAutopilot(self, autopilotDataMsg):
autopilotData = AutopilotData(autopilotDataMsg)
if autopilotData.isValid():
# forward data to DroneController
self.onReceiveEvent(autopilotData)
log_msg = 'IpController: AutopilotData received [0x' + str(
autopilotDataMsg.encode("hex")) + ']'
else:
log_msg = 'IpController: INVALID AutopilotData received [0x' + autopilotDataMsg + ']'
self.logWriter.noteEvent(log_msg)
def forwardIncomingPacket(self):
BUFFER_SIZE = 512
try:
data = self.connection.recv(BUFFER_SIZE)
log_msg = 'IpController: received: [0x' + str(
data.encode("hex")) + ']'
self.logWriter.noteEvent(log_msg)
except:
data = None
print 'IpController: forwardIncomingPacket: IP receive ERROR/TIMEOUT'
if not data:
print 'IpController: client disconnected:', self.client_address
self.keepConnectionFlag = False
return
self.streamProcessor.processStream(data)
def close(self):
self.keepConnectionFlag = False
self.sock.close()
def keepConnection(self):
return self.keepConnectionFlag
class IpController:
sock = None
connection = None
keepConnectionFlag = False
client_address = None
logWriter = None
onReceiveEvent = None #function one argument
streamProcessor = None
def __init__(self, server_address, use_simulator, simulatorLoopData, retryNumBind, logWriter):
self.onReciceEvent=self.defaultOnReciveEvent
self.logWriter = logWriter
if use_simulator:
self.sock = mockupSocket(simulatorLoopData)
print('IpController: using port simulator')
else:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print('IpController: Using ' + str(server_address[1]))
self.streamProcessor = StreamProcessor(self.onReceiveControl, self.onReceiveSignal, self.onReceiveAutopilot)
tryNum=retryNumBind
while True:
try:
self.sock.bind(server_address)
break
except Exception as e:
sys.stderr.write('IpController: failed ({0}/{1}): {2}\n'.format(tryNum,retryNumBind,e))
tryNum-=1
if tryNum<1:
raise Exception("IpController: can't bind socket!")
#end of method execution - exception raised
time.sleep(5)
self.sock.listen(1)
def setOnReceiveEvent(self, receiveEvent):
self.onReceiveEvent = receiveEvent
def defaultOnReciveEvent(self, commData):
self.logWriter.noteEvent('IpController: defaultOnReceiveEvent, data: ' + str(commData))
def acceptConnection(self):
self.keepConnectionFlag = False
self.connection, self.client_address = self.sock.accept()
self.keepConnectionFlag = True
print 'IpController: client connected:', self.client_address
self.logWriter.noteEvent('IpController: Client connected: ' + \
str(self.client_address))
def icConnected(self):
return not (self.connection is None)
def sendCommData(self, data):
if not self.icConnected():
return False
try:
self.connection.send(data)
log_msg = 'IpController: send: [0x' + str(data.encode("hex")) + '] len:' + str(len(data))
except Exception as e:
log_msg = 'IpController: send failed: ' + str(data) + " Exception: " + str(e)
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on control preamble
def onReceiveControl(self, controlDataMsg):
controlData = ControlData(controlDataMsg)
if controlData.isValid():
# forward data to DronController
self.onReceiveEvent(controlData)
log_msg = 'IpController: ControlData received: [' + str(controlData) + ']'
else:
log_msg = 'IpController: INVALID ControlData received: [' + controlDataMsg + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on signal preamble
def onReceiveSignal(self, signalPongMsg):
# immadetely response with ping
self.sendCommData(signalPongMsg)
log_msg = 'IpController: Signal received [0x' + str(signalPongMsg.encode("hex")) + ']'
self.logWriter.noteEvent(log_msg)
# event called by StreamProcessor - on autopilot preamble
def onReceiveAutopilot(self, autopilotDataMsg):
autopilotData = AutopilotData(autopilotDataMsg)
if autopilotData.isValid():
# forward data to DroneController
self.onReceiveEvent(autopilotData)
log_msg = 'IpController: AutopilotData received [0x' + str(autopilotDataMsg.encode("hex")) + ']'
else:
log_msg = 'IpController: INVALID AutopilotData received [0x' + autopilotDataMsg + ']'
self.logWriter.noteEvent(log_msg)
def forwardIncomingPacket(self):
BUFFER_SIZE = 512
try:
data = self.connection.recv(BUFFER_SIZE)
log_msg='IpController: received: [0x' + str(data.encode("hex"))+']'
self.logWriter.noteEvent(log_msg)
except:
data = None
print 'IpController: forwardIncomingPacket: IP receive ERROR/TIMEOUT'
if not data:
print 'IpController: client disconnected:', self.client_address
self.keepConnectionFlag = False
return
self.streamProcessor.processStream(data)
def close(self):
self.keepConnectionFlag = False
self.sock.close()
def keepConnection(self):
return self.keepConnectionFlag
