source: ResearchApps/Measurement/warpnet_framework/warpnet_client_azimuth_controller.py

# WARPnet Client<->Server Architecture
# WARPnet Parameter Definitions
#
# Author: Siddharth Gupta

from warpnet_client_definitions import *
from warpnet_common_params import *
from twisted.python import threadable
import re
from datetime import *
import time

EMU_RETRANSMIT_COUNT = 10 # Max retries to send the data struct
EMU_WAIT_TIME = 30 # Time to wait before resending data structs

class Emulator():

    def __init__(self, factory):
        self.factory = factory
        self.updateComplete = False
        self.returnStatus = False
    
    def connect(self, ipaddress):
        self.sendMessage(SC_EMULATOR_PRESENT, {'ip': ipaddress})
    
    def command(self, *args):
        #Concatenates all the user's arguments, delimited by spaces
        # Arguments are converted to strings if needed
        command = ' '.join(map(str,args))
        return self.sendMessage(SC_EMULATOR_MSG_TO_BOX, {'msg': command + '\n'}, self.updateFromServer)

    
    def waitForUpdate(self):
        while reactor.running and not self.updateComplete:
            pass
        return self.returnStatus
            
    def updateFromServer(self, data, status):
        if status:
            if re.search('ace_success', data['msg']):
                self.returnStatus = True
            else:
                print data['msg']
                self.returnStatus = False
                #raise Exception('ACE_ERROR (%s): %s ' % (datetime.now().strftime("%H:%M:%S"), data))
        else:
            self.returnStatus = False
        self.updateComplete = True

    def sendMessage(self, sendType, dataDict, callback=None):
        self.updateComplete = False
        if callback != None:
            self.factory.dataQueue.append(EmulatorResponse(dataDict, callback, self.factory))
        self.factory.sendDataToServer(sendType, dataDict)
        if not threadable.isInIOThread() and callback != None:
            return self.waitForUpdate()

class EmulatorResponse(WaitForResponse):
    
    def __init__(self, dataDict, instanceToCall, factoryInstance):
        self.dataDict = dataDict
        self.instanceToCall = instanceToCall
        self.factoryInstance = factoryInstance
        
        self.resendCounter = 0
        self.timeoutTimer = reactor.callLater(EMU_WAIT_TIME, self.timeoutExpired)
    
    def responseCheck(self, data):
        #print data
        if data['pktType'] == SC_EMULATOR_MSG_FROM_BOX:
            if self.timeoutTimer.active():
                self.timeoutTimer.cancel()
            self.factoryInstance.removeFromQueue(self)
            self.instanceToCall(data, True)
            return True
        return False

    def timeoutExpired(self):
        self.resendCounter += 1
        if self.resendCounter > EMU_RETRANSMIT_COUNT:
            self.factoryInstance.removeFromQueue(self)
            #print "too many timeouts, cancelling send"
            self.instanceToCall({'stat': C_TIMEOUT}, False)
        else:
            print "emulator resent after timeout: %s" % self.dataDict
            self.factoryInstance.sendDataToServer(SC_EMULATOR_MSG_TO_BOX, self.dataDict)
            self.timeoutTimer = reactor.callLater(EMU_WAIT_TIME, self.timeoutExpired)