def testPolicy_PERIODIC(self):
status = Status.get_status_holder("UnitTest")
reporter = TestPeriodicStatusReporter("Periodic, 0.4sec", 0.4)
status.add_reporter(reporter)
i = status.create_status_element("TestInteger", "An integer")
for x in range(0, 5):
i.set_value(x)
self.assertEquals(reporter.last_value, None) # Not updated yet
time.sleep(1)
assert reporter.last_value == 4
for x in range(5, 9):
self.assertEquals(reporter.last_value, 4) # Not updated yet
i.set_value(x)
time.sleep(1)
self.assertEquals(reporter.last_value, 8)
# Clean up
status.remove_status_element(i)
reporter.stop()
def testBasic(self):
status = Status.get_status_holder("UnitTest")
self.assertNotEqual(status, None)
self.assertEquals(status.get_name(), "UnitTest")
def downloadRFC(self, rfcNum, hostname, port):
global srcdir, dstdir
# Get details from server using P2S Lookup request
request = P2P.getRequestHeader(rfcNum, hostname)
peer_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#peer_sock.connect((socket.gethostname(), port))
peer_sock.connect((hostname, port))
peer_sock.send(request)
l = peer_sock.recv(200)
#parse response
res = P2P.validateGetReponse(l)
if(res==200):
if (ostype=="Windows"):
fpath = dstdir+"\\rfc"+rfcNum+".pdf"
else:
fpath = dstdir+"/rfc"+rfcNum+".pdf"
print 'fpath '+ fpath
f = open(fpath, "wb")
print l
data = peer_sock.recv(1024)
while (data):
f.write(data)
data = peer_sock.recv(1024)
if(sys.getsizeof(data) == 0):
break;
else:
print 'Download failed: '+Status.getResponsePhrase(res)
f.close()
peer_sock.close()
def run(self):
global rfclist
data = self.client_sock.recv(250) # Download request
print 'Download request received'
res, rfc = P2P.validateGetRequest(data, rfclist)
#res,rfc = 200 , 200
if(res == 200):
if (data):
segSize = 1024;
if(ostype=="Windows"):
filepath = srcdir+"\\rfc"+rfc+".pdf"
else:
filepath = srcdir+"/rfc"+rfc+".pdf"
f = open(filepath, "rb")
pktheader = P2P.getResponseHeader(200, filepath)
self.client_sock.send(pktheader)
data = f.read(segSize)
while (data):
self.client_sock.sendall(data)
data = f.read(segSize)
f.close()
self.client_sock.close()
print 'upload complete'
else:
pktheader = P2P.getResponseHeader(res, 'null')
self.client_sock.send(pktheader)
print 'Upload Failed: '+Status.getResponsePhrase(res)
self.client_sock.close()
return
def testInvalid(self):
status = Status.get_status_holder("UnitTest")
try:
i = status.create_status_element(None, "A number")
self.fail("Does not throw exception with no name")
except AssertionError, e:
pass
def run(self):
#sending all rfc files details to centralized index
global rfclist
global srcdir, dstdir
#for key,value in rfclist.iteritems():
# self.sendADDRequest(key, "RFC"+key)
while True:
print "Please select from the following option"
print "1.ADD RFC to CI server"
print "2.LOOKUP request to CI Server "
print "3.List all request to CI server"
print "4.Download rfc"
print "5.Exit"
user_choice= raw_input()
if user_choice =='1':
rfc_num=raw_input("Enter RFC Number to Add")
rfc_title=raw_input("Enter RFC Title to Add")
print "Sending Add RFC to CI server"
res = self.checkRFCAvailability(rfc_num)
if res==1:
if(ostype=="Windows"):
rfclist[rfc_num]= srcdir+'\\rfc'+str(rfc_num)+'.pdf'
else:
rfclist[rfc_num]= srcdir+'/rfc'+str(rfc_num)+'.pdf'
self.sendADDRequest(rfc_num,rfc_title)
else:
print 'File Not available'
print 'Save the file in the format -> rfc'+str(rfc_num)+'.pdf <- in P2PFilesrc Folder\n'
elif user_choice=='2':
rfc_num=raw_input("Enter RFC Number to lookup")
rfc_title=raw_input("Enter RFC Title to lookup")
print "Sending lookup request"
self.sendLookUpRequest(rfc_num,rfc_title)
elif user_choice=='3':
print "Sending list all request"
self.sendListAllRequest()
elif user_choice=='4':
print 'Downloading RFC'
rfc_num=raw_input("Enter RFC Number to download")
rfc_title=raw_input("Enter RFC Title to download")
resp = self.sendLookUpRequest(rfc_num,rfc_title)
host,port,stat = P2S.parseLookupResponse(resp,rfc_num,rfc_title)
print 'stat' + str(stat)
if(stat==200):
self.downloadRFC(rfc_num, host, int(port))
else:
print "Download Failed: "+Status.getResponsePhrase(stat)
elif user_choice=='5':
print "Exiting program"
print("socket closed")
self.ser_sock.close()
os._exit(1)
break
else:
print "Invalid input"
return
def test_LLReporter(self):
status = Status.get_status_holder("UnitTest")
reporter = TestLivingLabPeriodicReporter("Living lab test reporter", 1.0)
status.add_reporter(reporter)
i = status.create_status_element("TestInteger", "An integer")
i.set_value(1234)
reporter.wait_for_post(5.0)
reporter.stop()
time.sleep(1)
def response(status, li):
pktheader = "P2P-CI/1.0 "+str(status)+" "+Status.getResponsePhrase(status)+"\r\n\r\n"
pktdata = ""
if li=='null':
pktdata+="\r\n"
return pktheader+pktdata
for rfcn,title,hostname,port in li:
dataline = "RFC "+rfcn+" "+title+" "+hostname +" "+str(port)+"\r\n";
pktdata+=dataline
pktdata+="\r\n"
return pktheader+pktdata
def getResponseHeader(status,fi):
opsys = platform.system()+" "+platform.release()+" "+platform.version()
#path = 'C:\\SARAVANANB\\NCSU MAIN\\NCSU-Sem1\\CSC505\\Programs\\P2P\\P2PFilesrc\\1234.txt'
pktheader = "P2P-CI/1.0 "+str(status)+" "+Status.getResponsePhrase(status)+ "\r\n" \
"Date: "+str(datetime.datetime.now().time()) + "\r\n" \
"OS: "+opsys+"\r\n"
if(fi!='null'):
contlen = os.path.getsize(fi)
pktheader+="Last-Modified: "+str(time.ctime(os.path.getmtime(fi))) + "\r\n" +\
"Content-Length: " + str(contlen) + "\r\n" + \
"Content-Type: text/text\r\n"
pktheader+="\r\n"
return pktheader
def testPolicy_ON_CHANGE(self):
status = Status.get_status_holder("UnitTest")
reporter = TestOnChangeStatusReporter("On change")
status.add_reporter(reporter)
i = status.create_status_element("TestInteger", "Some number")
for x in range(0, 10):
i.set_value(x)
if x != reporter.value:
self.fail("Callback does not work for ON_CHANGE policy")
if reporter.name != "TestInteger":
self.fail("On_Change callback get's the wrong parameter, got '%s', expected 'TestInteger'"%reporter.name)
# Clean up
status.remove_status_element(i)
def logScreen(self):
log = LoginScreen.LoginScreen()
log.main()
email, password = log.getCredentials()
log.__del__()
self.api = TuentiAPI.API()
self.api.handleCookies()
self.api.login(email, password)
sts = Status.changeStatusScreen(self)
sts.main()
status = sts.getCredentials()
print "Email %s .Password %s" % (email, password)
image = self.api.getNextPhoto();
print image
image = self.api.getNextPhoto();
print image
def stress(data, size, delay, repeat):
reporter = LivingLabOnChangeCacheReporter("Living lab stress-test reporter", error_handler=error_handler)
status = Status.get_status_holder("StressTest")
status.add_reporter(reporter)
s = status.create_status_element("TestMixed", "A mixed test width size %d" % size)
start = time.time()
sub_start = start
for i in xrange(1, repeat+1):
s.set_value(data)
if not delay is None:
time.sleep(delay)
if i % 100 == 0:
delta = time.time() - sub_start
print "Reported %5d times." % i, "%d bytes." % size, "%.2f MB/s." % (100*size / delta / 1024 / 1024), "%2.2f reports/s" % (100 / delta)
sub_start = time.time()
delta = time.time() - start
print "> Reported %5d times." % i, "%d bytes." % size, "%.2f MB/s." % (i*size / delta / 1024 / 1024), "%2.2f reports/s" % (i / delta)
def storeM(self,u):
(self.header['id'], self.header['qr'], self.header['opcode'],
self.header['aa'], self.header['tc'], self.header['rd'],
self.header['ra'], self.header['z'], self.header['rcode'],
self.header['qdcount'], self.header['ancount'],
self.header['nscount'], self.header['arcount']) = u.getHeader()
self.header['opcodestr']=Opcode.opcodestr(self.header['opcode'])
self.header['status']=Status.statusstr(self.header['rcode'])
for i in range(self.header['qdcount']):
#print 'QUESTION %d:' % i,
self.questions.append(self.storeQ(u))
for i in range(self.header['ancount']):
#print 'ANSWER %d:' % i,
self.answers.append(self.storeRR(u))
for i in range(self.header['nscount']):
#print 'AUTHORITY RECORD %d:' % i,
self.authority.append(self.storeRR(u))
for i in range(self.header['arcount']):
#print 'ADDITIONAL RECORD %d:' % i,
self.additional.append(self.storeRR(u))
def unittest():
status = Status.get_status_holder("UnitTest")
def error_handler(code, message):
print "Error:",code,message
reporter = LivingLabPeriodicReporter("Living lab test reporter", 1.0, error_handler)
status.add_reporter(reporter)
s = status.create_status_element("TestString", "A test string")
s.set_value("Hi from Njaal")
s = status.create_status_element("TestEscaping", "A string with quotes")
s.set_value("...\"foo\"...'bar'...")
s = status.create_status_element("TestMultiline", "A multiline string")
s.set_value("Line 1\nLine2\nLine3")
s = status.create_status_element("TestUnicode", "A unicode string")
s.set_value(u"\xc4")
time.sleep(2)
print "Stopping reporter"
reporter.stop()
print "Sent %d reports"%reporter.num_reports
def testInt(self):
status = Status.get_status_holder("UnitTest")
self.assertNotEqual(status, None)
i = status.create_status_element("TestInteger", "A test value")
self.assertEquals(i.get_name(), "TestInteger")
x = status.get_status_element("TestInteger")
self.assertEquals(x, i)
# Test set and get values
for j in range(0,10):
i.set_value(j)
self.assertEquals(i.get_value(), j)
# Clean up
status.remove_status_element(i)
try:
status.get_status_element("TestInteger")
self.fail("Remove does not remove status element 'TestInteger'")
except Status.NoSuchElementException, e:
# Expected
pass
if self.error_handler:
try:
self.error_handler(resp.status, resp.read())
except Exception, e:
pass
else:
print >> sys.stderr, "Error posting but no error handler:", \
errcode, h.file.read()
if __name__ == "__main__":
"""
Small test routine to check an actual post (unittest checks locally)
"""
status = Status.get_status_holder("UnitTest")
def test_error_handler(code, message):
"""
Test error-handler
"""
print "Error:", code, message
reporter = LivingLabPeriodicReporter("Living lab test reporter",
1.0, test_error_handler)
status.add_reporter(reporter)
s = status.create_status_element("TestString", "A test string")
s.set_value("Hi from Njaal")
time.sleep(2)
print "Stopping reporter"
if args.hostname:
args.server = True
Config.server.hostname = args.hostname
if args.port:
args.server = True
Config.server.port = int(args.port)
if args.silent:
Print.silent = True
if args.json:
Config.jsonOutput = True
Status.start()
Print.info(' ,;:;;,')
Print.info(' ;;;;;')
Print.info(' .=\', ;:;;:,')
Print.info(' /_\', "=. \';:;:;')
Print.info(' @=:__, \,;:;:\'')
Print.info(' _(\.= ;:;;\'')
Print.info(' `"_( _/="`')
Print.info(' `"\'')
if args.extract:
for filePath in args.extract:
f = Fs.Nsp(filePath, 'rb')
dir = os.path.splitext(os.path.basename(filePath))[0]
except AssertionError, e:
pass
try:
status.get_status_element(None)
self.fail("Invalid get_status_element does not throw exception")
except AssertionError, e:
pass
try:
status.remove_status_element(None)
self.fail("Invalid remove_status_element does not throw exception")
except AssertionError, e:
pass
elem = Status.StatusElement("name", "description")
try:
status.remove_status_element(elem)
self.fail("Invalid remove_status_element does not throw exception")
except Status.NoSuchElementException, e:
pass
def testPolicy_ON_CHANGE(self):
status = Status.get_status_holder("UnitTest")
reporter = TestOnChangeStatusReporter("On change")
status.add_reporter(reporter)
i = status.create_status_element("TestInteger", "Some number")
for x in range(0, 10):
i.set_value(x)
def effect(self, player):
player.add_status(Status.Strength(10))
def readBus(self, bus = None):
if bus is None:
raise ValueError("RemoteTerminal.readBus: Bus is not provided")
elif not isinstance(bus, b.Bus):
raise ValueError("RemoteTerminal.readBus: Bus is invalid")
elif bus.bus.isEmpty():
raise ValueError("RemoteTerminal.readBus: Bus is empty")
else:
# reads a word from bus
word = bus.readBus()
if isinstance(word, c.Command):
# if word is address to current rt terminal
if word.getTerminalAddress() is self.getAddress():
# if command is a command word
if not word.isModeCommand():
# if command is to transmit or receive data
# if command word is to receive
if not word.isTransmitCommand():
# reads wordCount no. of times from the bus
for i in range(word.getWordCount()):
bus.readBus()
# create status word and send it on bus
response = s.Status(self.getAddress())
bus.writeBus(response)
# if command is to transmit
elif word.isTransmitCommand():
# write status word onto bus
response = s.Status(self.getAddress())
bus.writeBus(response)
# write wordCount no. of data words
for i in range(word.getWordCount()):
bus.writeBus(d.Data(i))
# if command is a mode command
else:
# get the mode code
mCode = word.getModeCode()
# if mode code is to transmit status
if mCode is c.Command.transmitStatusWord:
# randomly transmit status as either no service requested or service is requested
randResponse = random.randint(1,2)
# when no service is requested
if randResponse == 1:
response = s.Status(self.getAddress())
bus.writeBus(response)
# when service is requested
else:
response = s.Status(self.getAddress())
response.setServiceRequest()
bus.writeBus(response)
# if mode code is to transmit vector word
elif mCode is c.Command.transmitVectorWord:
# write status word to bus
response = s.Status(self.getAddress())
bus.writeBus(response)
# randomly pick one of the other existing remote terminals
ranAdd = random.randint(1,30)
# make sure a remote terminal does not communicate with itself
while ranAdd == self.getAddress():
ranAdd = random.randint(1,30)
# randomly create a receive or a transmit command word and send on bus
randTR = random.randint(1,2)
command = c.Command(self.getAddress())
command.setToCommandWord(ranAdd)
# command word to transmit
if randTR == 1:
command.setTransmitCommand()
# randomly choosing wordCount
command.setWordCount(random.randint(1,5))
bus.writeBus(command)
else:
command.setReceiveCommand()
wc = random.randint(1,5)
command.setWordCount(wc)
bus.writeBus(command)
for index in range(wc):
bus.writeBus(d.Data(index))
return bus
def effect(self, player):
player.add_status(Status.Paralyze(8))
def info(s):
if not silent and enableInfo:
Status.print_(s)
def __init__(self, reactor, parent=None):
super(Window, self).__init__(parent)
self.reactor = reactor
self.setupUi(self)
self.pushButton_Servers.clicked.connect(self.showServersList)
self.pushButton_CapacitorAxis1.clicked.connect(
lambda: self.RefreshCapacitance(0, self.label_CapacitanceAxis1))
self.pushButton_CapacitorAxis2.clicked.connect(
lambda: self.RefreshCapacitance(1, self.label_CapacitanceAxis2))
self.pushButton_CapacitorAxis3.clicked.connect(
lambda: self.RefreshCapacitance(2, self.label_CapacitanceAxis3))
self.checkBox_targetGND_Axis1.stateChanged.connect(
lambda: self.toggleTargetGround(0))
self.checkBox_targetGND_Axis2.stateChanged.connect(
lambda: self.toggleTargetGround(1))
self.checkBox_targetGND_Axis3.stateChanged.connect(
lambda: self.toggleTargetGround(2))
self.checkBox_OutputEnabled_Axis1.stateChanged.connect(
lambda: self.toggleOutput(0))
self.checkBox_OutputEnabled_Axis2.stateChanged.connect(
lambda: self.toggleOutput(1))
self.checkBox_OutputEnabled_Axis3.stateChanged.connect(
lambda: self.toggleOutput(2))
self.lineEdit_AutoPositionRelative_Axis1.editingFinished.connect(
lambda: self.UpdateAutomaticPositioningRelativePosition(0))
self.lineEdit_AutoPositionAbsolute_Axis1.editingFinished.connect(
lambda: self.UpdateAutomaticPositioningAbsolutePosition(0))
self.lineEdit_AutoPositionRelative_Axis2.editingFinished.connect(
lambda: self.UpdateAutomaticPositioningRelativePosition(1))
self.lineEdit_AutoPositionAbsolute_Axis2.editingFinished.connect(
lambda: self.UpdateAutomaticPositioningAbsolutePosition(1))
self.lineEdit_AutoPositionRelative_Axis3.editingFinished.connect(
lambda: self.UpdateAutomaticPositioningRelativePosition(2))
self.lineEdit_AutoPositionAbsolute_Axis3.editingFinished.connect(
lambda: self.UpdateAutomaticPositioningAbsolutePosition(2))
self.lineEdit_Amplitude_Axis1.editingFinished.connect(
lambda: self.UpdateAmplitude(0))
self.lineEdit_Amplitude_Axis2.editingFinished.connect(
lambda: self.UpdateAmplitude(1))
self.lineEdit_Amplitude_Axis3.editingFinished.connect(
lambda: self.UpdateAmplitude(2))
self.lineEdit_Frequency_Axis1.editingFinished.connect(
lambda: self.UpdateFrequency(0))
self.lineEdit_Frequency_Axis2.editingFinished.connect(
lambda: self.UpdateFrequency(1))
self.lineEdit_Frequency_Axis3.editingFinished.connect(
lambda: self.UpdateFrequency(2))
self.lineEdit_TargetRange_Axis1.editingFinished.connect(
lambda: self.UpdateTargetRange(0))
self.lineEdit_TargetRange_Axis2.editingFinished.connect(
lambda: self.UpdateTargetRange(1))
self.lineEdit_TargetRange_Axis3.editingFinished.connect(
lambda: self.UpdateTargetRange(2))
self.pushButton_Status_Axis1.clicked.connect(
lambda: self.ResetStatus(0))
self.pushButton_Status_Axis2.clicked.connect(
lambda: self.ResetStatus(1))
self.pushButton_Status_Axis3.clicked.connect(
lambda: self.ResetStatus(2))
self.pushButton_AutomaticMoveRelative_Axis1.clicked.connect(
lambda: self.MovingRelative(0))
self.pushButton_AutomaticMoveAbsolute_Axis1.clicked.connect(
lambda: self.MovingAbsolute(0))
self.pushButton_AutomaticMoveRelative_Axis2.clicked.connect(
lambda: self.MovingRelative(1))
self.pushButton_AutomaticMoveAbsolute_Axis2.clicked.connect(
lambda: self.MovingAbsolute(1))
self.pushButton_AutomaticMoveRelative_Axis3.clicked.connect(
lambda: self.MovingRelative(2))
self.pushButton_AutomaticMoveAbsolute_Axis3.clicked.connect(
lambda: self.MovingAbsolute(2))
self.pushButton_ManualStepMinus_Axis1.clicked.connect(
lambda: self.StartSingleStep(0, 1))
self.pushButton_ManualStepPlus_Axis1.clicked.connect(
lambda: self.StartSingleStep(0, 0))
self.pushButton_ManualStepMinus_Axis2.clicked.connect(
lambda: self.StartSingleStep(1, 1))
self.pushButton_ManualStepPlus_Axis2.clicked.connect(
lambda: self.StartSingleStep(1, 0))
self.pushButton_ManualStepMinus_Axis3.clicked.connect(
lambda: self.StartSingleStep(2, 1))
self.pushButton_ManualStepPlus_Axis3.clicked.connect(
lambda: self.StartSingleStep(2, 0))
self.IconPath = {
'Still': ':/nSOTScanner/Pictures/ManStill.png',
'Moving Negative': ':/nSOTScanner/Pictures/ManRunningLeft.png',
'Moving Positive': ':/nSOTScanner/Pictures/ManRunningRight.png',
'MoveBlockedLeft':
':/nSOTScanner/Pictures/ManRunningLeftBlocked.png',
'MoveBlockedRight':
':/nSOTScanner/Pictures/ManRunningRightBlocked.png',
'TargetReached': ':/nSOTScanner/Pictures/ManReachGoal.png',
'Error': ':/nSOTScanner/Pictures/ManError.png'
}
self.Status = ['', '', '']
self.Direction = ['Positive', 'Positive', 'Positive']
self.lineEdit_Relative = [
self.lineEdit_AutoPositionRelative_Axis1,
self.lineEdit_AutoPositionRelative_Axis2,
self.lineEdit_AutoPositionRelative_Axis3
]
self.lineEdit_Absolute = [
self.lineEdit_AutoPositionAbsolute_Axis1,
self.lineEdit_AutoPositionAbsolute_Axis2,
self.lineEdit_AutoPositionAbsolute_Axis3
]
self.lineEdit_Amplitude = [
self.lineEdit_Amplitude_Axis1, self.lineEdit_Amplitude_Axis2,
self.lineEdit_Amplitude_Axis3
]
self.lineEdit_Frequency = [
self.lineEdit_Frequency_Axis1, self.lineEdit_Frequency_Axis2,
self.lineEdit_Frequency_Axis3
]
self.lineEdit_TargetRange = [
self.lineEdit_TargetRange_Axis1, self.lineEdit_TargetRange_Axis2,
self.lineEdit_TargetRange_Axis3
]
self.pushButton_Relative = [
self.pushButton_AutomaticMoveRelative_Axis1,
self.pushButton_AutomaticMoveRelative_Axis2,
self.pushButton_AutomaticMoveRelative_Axis3
]
self.pushButton_Absolute = [
self.pushButton_AutomaticMoveAbsolute_Axis1,
self.pushButton_AutomaticMoveAbsolute_Axis2,
self.pushButton_AutomaticMoveAbsolute_Axis3
]
self.pushButton_Status = [
self.pushButton_Status_Axis1, self.pushButton_Status_Axis2,
self.pushButton_Status_Axis3
]
self.pushButton_SingleStepPlus = [
self.pushButton_ManualStepPlus_Axis1,
self.pushButton_ManualStepPlus_Axis2,
self.pushButton_ManualStepPlus_Axis3
]
self.pushButton_SingleStepMinus = [
self.pushButton_ManualStepMinus_Axis1,
self.pushButton_ManualStepMinus_Axis2,
self.pushButton_ManualStepMinus_Axis3
]
self.checkBox_OutputEnabled = [
self.checkBox_OutputEnabled_Axis1,
self.checkBox_OutputEnabled_Axis2,
self.checkBox_OutputEnabled_Axis3
]
self.lcddisplay = [
self.lcdNumber_Axis1, self.lcdNumber_Axis2, self.lcdNumber_Axis3
]
self.CurrentPosition = [0.0, 0.0, 0.0]
self.RelativePosition = [0.0, 0.0, 0.0]
self.AbsolutePosition = [0.0, 0.0, 0.0]
self.manual_Amplitude = [30.0, 30.0, 40.0]
self.manual_Frequency = [1000, 1000, 1000]
self.TargetRange = [500 * 10**-9, 500 * 10**-9, 1000 * 10**-9]
self.TargetGround = [True, True, True]
self.OutputEnabled = [True, True, True]
self.StatusWindow = Status.StatusWindow(self.reactor)
self.pushButton_StatusMonitor.clicked.connect(self.OpenStatusWindow)
self.DebugWindow = DebugPy.DebugWindow(self.reactor, self)
self.pushButton_Debug.clicked.connect(self.OpenDebugWindow)
def postStatus(self, theStatus):
if self.currentlyUsing == "":
print("Noone is currently logged in")
else:
status1 = Status(self.currentlyUsing, theStatus, [], [])
self.facebookStatus.append(status1)
def change_status_packet_handler(packet):
return {
'success':
packet.client.get_provider(packet.provider_id).send_status(
Status.Status(packet.status_id, packet.desc))
}
def run(self):
selectedTask = 0
while True:
time.sleep(1)
if self.stop_event.is_set(): break
# print("NewWhile")
if selectedTask == 0:
# print("send0")
self.sendMessage("0")
else:
# print("send1")
self.sendMessage("1")
try:
parts = str(self.sock.recv(40).decode('utf-8')).split()
if len(parts) == 0: # client is dead
self.stop_event.set()
continue
except socket.timeout:
continue
if parts[0] == "exit":
break
# print("1) printTaskList")
# print("2) info <id>")
# print("3) select <id>")
# print("4) addNewTask")
# print("5) delete <id>")
if selectedTask == 0:
if parts[0] == "printTaskList":
res = self.list.printList()
self.sendMessage(res)
if parts[0] == "info":
res = self.list.printTask(int(parts[1]))
self.sendMessage(res)
if parts[0] == "select":
res = self.list.selectTask(int(parts[1]))
if res == 0:
self.sendMessage("Task not found")
else:
self.sendMessage("Task selected")
selectedTask = res
if parts[0] == "delete":
res = self.list.deleteTask(int(parts[1]))
if res:
self.sendMessage("Task deleted")
else:
self.sendMessage("Task not found")
if parts[0] == "addNewTask":
name = self.receiveMessage()
isOk = False
start_time = datetime.today()
while not isOk:
try:
tmp_time = datetime.strptime(
self.receiveMessage(), "%d/%m/%y %H:%M")
self.sendMessage("True")
start_time = tmp_time
isOk = True
except ValueError:
self.sendMessage("False")
isOk = False
end_time = datetime.today()
while not isOk:
try:
tmp_time = datetime.strptime(
self.receiveMessage(), "%d/%m/%y %H:%M")
self.sendMessage("True")
end_time = tmp_time
isOk = True
except ValueError:
self.sendMessage("False")
# start_time = datetime.strptime(self.receiveMessage(), "%d/%m/%y %H:%M")
# end_time = datetime.strptime(self.receiveMessage(), "%d/%m/%y %H:%M")
description = self.receiveMessage()
res = self.list.addTask(name, start_time, end_time,
description)
self.sendMessage(res)
else:
# print("1) changeDescription")
# print("2) changeStatus")
# print("3) changeStartTime")
# print("4) changeEndTime")
# 5unselected
if parts[0] == "changeDescription":
des = self.receiveMessage()
res = self.list.chDescription(des, selectedTask)
if res:
self.sendMessage("Description changed")
else:
self.sendMessage("Task not found")
if parts[0] == "changeStatus":
status = int(self.receiveMessage())
st_ = Status.Status(status)
res = self.list.chStatus(st_, selectedTask)
if res:
self.sendMessage("Status changed")
else:
self.sendMessage("Task not found")
if parts[0] == "changeStartTime":
date = self.receiveMessage()
res = self.list.chTime(date, True, selectedTask)
if res:
self.sendMessage("Start Time changed")
else:
self.sendMessage("Task not found")
if parts[0] == "changeEndTime":
date = self.receiveMessage()
res = self.list.chTime(date, False, selectedTask)
if res:
self.sendMessage("End Time changed")
else:
self.sendMessage("Task not found")
if parts[0] == "unselect":
selectedTask = 0
self.sock.close()
def test_1_login_WithoutArgs_Pass_With_Only_Valid_Arguments(self):
Status.Status().login()
def debug(s):
if not silent and enableDebug:
Status.print_(s)
def effect(self, player):
player.add_status(Status.EagleEye(15))
if self.error_handler:
try:
self.error_handler(errcode, h.file.read())
except Exception, e:
pass
else:
print >> sys.stderr, "Error posting but no error handler:", errcode, h.file.read(
)
if __name__ == "__main__":
"""
Small test routine to check an actual post (unittest checks locally)
"""
status = Status.get_status_holder("UnitTest")
def error_handler(code, message):
print "Error:", code, message
reporter = LivingLabPeriodicReporter("Living lab test reporter", 1.0,
error_handler)
status.add_reporter(reporter)
s = status.create_status_element("TestString", "A test string")
s.set_value("Hi from Njaal")
time.sleep(2)
print "Stopping reporter"
reporter.stop()
def effect(self, player):
player.add_status(Status.Weakness(8))
from enum import Enum, auto
import Task
import TaskList
from datetime import datetime
import Status
st = Status.Status.created
st2 = Status.Status(0)
print(st2.name)
db = TaskList.TaskList()
db.addTask("hi", datetime.today(), datetime.today(), "123")
db.addTask("hello", datetime.today(), datetime.today(), "123")
db.addTask("hi2", datetime.today(), datetime.today(), "123")
db.printList()
id = int(input())
db.deleteTask(id)
db.printList()
print("OK")
def effect(self, player):
player.add_status(Status.Poison(8))
def test_2_login_WithArgs_Fail_With_Arg(self):
self.assertRaises(Exception, Status.Status().login, 'TestStr0')
def effect(self, player):
player.add_status(Status.Toughness(10))
def substat_new_entry(self,sub_status,code,name,status,formattedmessage):
sub_status_obj = Status.SubstatusObj(code,name,status,formattedmessage)
sub_status.append(sub_status_obj)
return sub_status
def error(s):
if not silent and enableError:
Status.print_(s)
break
beautifully_print_files(files)
return paths, files
""" DEPRECIATED METHOD:
...
"""
def initialize_display(files, paths):
None
""" METHOD:
The main method
"""
if __name__ == "__main__":
Header.display_header()
paths, files = load_files()
status = Status.Status()
hotkeys = HotKeys.HotKeys()
hotkeys.display()
hotkey_thread = threading.Thread(target = hotkeys.activate, args=(status, paths, files,))
hotkey_thread.start()
initialize_display(files, paths)
# FIXME: solve the multi-threaded keypress issue
def warning(s):
if not silent and enableWarning:
Status.print_(s)
def do_status_report(self,
operation,
status,
status_code,
message,
taskId=None,
commandStartTimeUTCTicks=None,
snapshot_info=None,
total_size=0,
failure_flag=True):
self.log("{0},{1},{2},{3}".format(operation, status, status_code,
message))
sub_stat = []
stat_rept = []
self.add_telemetry_data()
vm_health_obj = Status.VmHealthInfoObj(
ExtensionErrorCodeHelper.ExtensionErrorCodeHelper.
ExtensionErrorCodeDict[self.ExtErrorCode], int(status_code))
self.convert_telemetery_data_to_bcm_serializable_format()
stat_rept = self.do_status_json(
operation, status, sub_stat, status_code, message,
HandlerUtility.serializable_telemetry_data, taskId,
commandStartTimeUTCTicks, snapshot_info, vm_health_obj, total_size,
failure_flag)
time_delta = datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)
time_span = self.timedelta_total_seconds(time_delta) * 1000
date_place_holder = 'e2794170-c93d-4178-a8da-9bc7fd91ecc0'
stat_rept.timestampUTC = date_place_holder
date_string = r'\/Date(' + str((int)(time_span)) + r')\/'
stat_rept = "[" + json.dumps(stat_rept,
cls=Status.ComplexEncoder) + "]"
stat_rept = stat_rept.replace(date_place_holder, date_string)
# Add Status as sub-status for Status to be written on Status-File
sub_stat = self.substat_new_entry(sub_stat, '0', stat_rept, 'success',
None)
if self.get_public_settings()[CommonVariables.vmType].lower(
) == CommonVariables.VmTypeV2.lower(
) and CommonVariables.isTerminalStatus(status):
status = CommonVariables.status_success
stat_rept_file = self.do_status_json(operation, status, sub_stat,
status_code, message, None,
taskId, commandStartTimeUTCTicks,
None, None, total_size,
failure_flag)
stat_rept_file = "[" + json.dumps(stat_rept_file,
cls=Status.ComplexEncoder) + "]"
# rename all other status files, or the WALA would report the wrong
# status file.
# because the wala choose the status file with the highest sequence
# number to report.
try:
if self._context._status_file:
with open(self._context._status_file, 'w+') as f:
f.write(stat_rept_file)
except Exception as e:
errMsg = 'Status file creation failed with error: %s, stack trace: %s' % (
str(e), traceback.format_exc())
self.log(errMsg)
return stat_rept
