source: ResearchApps/Measurement/warpnet_framework/warpnet_client_definitions.py

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

from warpnet_common_params import *
from twisted.internet import reactor
import struct, time

class WaitForResponse():
    # the receiver gives the received packet to this checker. if the response matches then it must cancel itself from the queue and cancel the
    # resender.
    def responseCheck(self, data):
        pass

    # recreate the timeouttimer, increment the resend counter, resend just the data
    def timeoutExpired(self):
        pass

class InstructionClass:

    sendType = -1 # packet type of sent command
    returnType = SC_STAT
    updateComplete = False
    returnStatus = False
    
    def waitForUpdate(self):
        while reactor.running and not self.updateComplete:
            pass
        return self.returnStatus
            
    def updateFromServer(self, data, status):
        updateComplete = True
        

def checkError(statusCode):
    if statusCode == SC_STAT_GROUP_UNMATCHED:
        print "Server does not know of group"
    elif statusCode == SC_STAT_NOT_CONN_NODE:
        print "Not connected to specified nodes"
    elif statusCode == SC_NOT_REGISTERED:
        print "Not registered for struct, group pair"
    elif statusCode == C_TIMEOUT:
        print "Request timed out"
    else:
        print "Error not known. Status Code = %d" % statusCode
        
# create blank ClientStruct that users can extend for structs that are understood at the WARP board
class ClientStruct:
    structID = -1
    expectedReturnStructID = -1
    updateDone = False
    returnStatus = False
    lockStatus = False
    
    def __init__(self, logger):
        if logger is None:
            self.loggers = []
        else:
            self.loggers = [logger]

    # The prepToSend function is called by a Node instance when it is about to send this struct to a particular node. The destination
    # nodeID will be provided by the instance and the struct must embed this in the right order. The returned data is the byte packed
    # sequence that is understood by the node.  
    def prepToSend(self, nodeID):
        self.updateDone = False
        return struct.pack('BB', self.structID, nodeID) #pack converts the variables to binary
    
    def callbackFromResponse(self, data, status):
        if status:
            self.updateFromNode(data['raw'], data['pcapts'])
        else:
            if data['stat'] == SC_DATA_LOCKED:
                print "Data struct is locked, cannot update"
            else:
                checkError(data['stat'])
        self.returnStatus = status
        self.updateDone = True
    
    # The updateFromNode function is called when the node either receives a response to a sent struct or receives an unrequested struct.
    def updateFromNode(self, data, pcapts):
        pass

    def updateComplete(self):
        #print "waiting in update done"
        while reactor.running and not self.updateDone:
            pass
            #print "%s" % self.updateDone
        return self.returnStatus

    def addLogger(self, loggerInst):
        print "in add logger"
        self.loggers.append(loggerInst)
        print "new logger list %s" % self.loggers


    def logData(self, data):
        for logger in self.loggers:
            logger.log(data)

class DataCollector():
    
    def log(self, dataToLog):
        pass