def test_log(self):
gLog.open("2", 10)
gLog.print(
"""
Expected output:
Interleaved output from multiple threads
Each thread logs
(a) when it is starting
(b) multiple lines of output
(c) when it has ended
There should be NO BLANK LINES in the log and
each line should contain output from a single thread.
The line '....MIDPOINT...' appears half way through.
In the first half lines are about 90 characters long.
In the second half lines are twice as long.
"""
)
for digit in range(10):
PrintManyLinesToLog(str(digit)).start()
sleep(2)
gLog.flush()
gLog.print("...................... MIDPOINT.........................")
for digit in range(10):
PrintManyLinesToLog(str(digit) + str(digit) + str(digit)).start()
sleep(5)
gLog.close()
raise Exception("EXCEPTION EXPECTED: Check correctness of output in file log_test.txt")
def __init__(self, number, quSend, quRead):
print("Initializing process {0}".format(number)); sys.stdout.flush()
gLog.print("Initializing process {0}".format(number))
self.number = number
self.quSend = quSend
self.quRead = quRead
Process.__init__(self)
def getNonblocking(self):
try:
msg = self.inQu.get(False) # non-blocking
#gLog.print("MsgHandler {0}: getNonblocking message {1}".format(self.name, msg))
return msg
except multiprocessing.queues.Empty:
gLog.print("MsgHandler {0}: getNonblocking empty qu exception)".format(self.name))
raise multiprocessing.queues.Empty
def getNonblocking(self):
try:
msg = self.msgHandler.getNonblocking()
# gLog.print("Throttle {0}: getNonlocking msg {1}".format(self.name, msg))
return msg
except multiprocessing.queues.Empty:
gLog.print("Throttle {0}: getNonlocking empty qu exception".format(self.name))
raise multiprocessing.queues.Empty
def startPumps(self):
#gLog.print("MsgHandler {0}: trying to start pumps".format(self.name))
internalQu = Queue()
msgSock = MsgSocket(name = self.name)
msgSock.connect(self.host, self.port)
MsgInternalQuPump(name = self.name, internalQu = internalQu, inQuList = self.inQuList).start()
MsgInQuPump(name = self.name, sock = msgSock, inQuList = self.inQuList).start()
MsgOutQuPump(name = self.name, sock = msgSock, outQu = self.outQu, internalQu = internalQu).start()
gLog.print("MsgHandler {0}: has started pumps".format(self.name))
def __init__(self, name, socketToClient, clientHandlerFunction):
Thread.__init__(self)
assert(isinstance(name, str))
assert(isinstance(socketToClient, socket))
assert(clientHandlerFunction is not None)
gLog.print("Client handler {0}: created for peer {1}".format(name, socketToClient.getpeername()))
self.name = name
self.socketToClient = socketToClient
self.clientHandlerFunction = clientHandlerFunction
def readLayout(self, fileName):
gLog.print("Throttle {0}: sending DoReadLayoutMsg using file {1}".format(self.name, fileName))
assert isinstance(fileName, str)
self.addInterest(PutReadLayoutResponseMsg)
self.put(DoReadLayoutMsg(fileName=fileName))
msg = self.waitFor(PutReadLayoutResponseMsg(responseFlag=0, code=0))
self.removeInterest(PutReadLayoutResponseMsg)
sleep(3)
return msg
def run(self):
gLog.print("MsgOutQuPump {0}: starting".format(self.name))
while True:
msg = self.outQu.get()
if type(msg) in InQuListMsgs:
#gLog.print("MsgOutQuPump {0}: getting ready to put {1}".format(self.name, msg))
self.internalQu.put(msg)
else:
#gLog.print("MsgOutQuPump {0}: getting ready to send {1}".format(self.name, msg))
self.sk.send(msg)
def run(self):
gLog.print("MsgInQuPump {0}: starting".format(self.name))
while True:
st = self.sk.receive()
msg = makeMsgStr(st)
for x in self.inQuList:
q = x.inQu
messageTypes = x.interests
if type(msg) in messageTypes:
q.put(msg)
def __init__(self, name = None, sock = None, outQu = None, internalQu = None):
Thread.__init__(self)
assert(isinstance(name, str))
assert(isinstance(sock, MsgSocket))
assert(isinstance(outQu, multiprocessing.queues.Queue))
assert(isinstance(internalQu, multiprocessing.queues.Queue))
gLog.print("MsgOutQuPump {0}: initializing".format(name))
self.name = name
self.sk = sock
self.outQu = outQu
self.internalQu = internalQu
def __init__(self, name = "1", host = None, port = None, clientHandlerFunction = None):
Thread.__init__(self)
assert(host is None or isinstance(name, str))
assert(isinstance(host, str))
assert(isinstance(port, int))
assert(clientHandlerFunction is not None)
gLog.print("Message server {0}: initializing at ({1}, {2})".format(name, host, port))
self.name = name
if host is None:
host = socket.gethostname()
self.host = host
self.port = port
self.clientHandlerFunction = clientHandlerFunction
self.serverSocket = None
def run(self):
gLog.print("MsgInternalQuPump {0}: starting".format(self.name))
while True:
msg = self.internalQu.get()
if isinstance(msg, RemoveAllInterestsMsg):
gLog.print("MsgInternalQuPump {0}: removing all interests for inQuNum {1}".
format(self.name, msg.inQuNum))
# if there is no entry for this inQuNum raise an exception
# else remove all interests for this inQuNum
if len(self.inQuList) <= msg.inQuNum:
raise Exception("MsgInternalQuPump {0}: inQuNum {1} is too large.".format(self.name, msg.inQuNum))
else:
interestList = self.inQuList[msg.inQuNum].interests
for interest in interestList:
interestList.remove(interest)
elif isinstance(msg, AddInterestMsg):
gLog.print("MsgInternalQuPump {0}: adding interest {1} for inQuNum {2}".
format(self.name, msg.interest, msg.inQuNum))
# if there is no entry for this inQuNum raise an exception
# elif the inQuNum already has this interest pass
# else add an interest for this inQuNum
if len(self.inQuList) <= msg.inQuNum:
raise Exception("MsgInternalQuPump {0}: inQuNum {1} is too large.".format(self.name, msg.inQuNum))
else:
x = self.inQuList[msg.inQuNum]
if msg.interest in x.interests:
pass
# The interest could have been have added at a higher level
#raise Exception("MsgInternalQuPump {0}: Can't add. inQuNum {1} already has {2}".
# format(self.name, msg.inQuNum, msg.interest))
else:
x.interests.append(msg.interest)
elif isinstance(msg, RemoveInterestMsg):
gLog.print("MsgInternalQuPump {0}: removing interest {1} for inQuNum {2}".
format(self.name, msg.interest, msg.inQuNum))
# if there is no entry for this inQuNum raise an exception
# elif there is no matching interest raise an exception
# else remove an interest for this inQuNum
if len(self.inQuList) <= msg.inQuNum:
raise Exception("MsgInternalQuPump {0}: inQuNum {1} is too large.".format(self.name, msg.inQuNum))
else:
x = self.inQuList[msg.inQuNum]
if not msg.interest in x.interests:
raise Exception("MsgInternalQuPump {0}: Can't remove. inQuNum {1} doesn't have {2}".
format(self.name, msg.inQuNum, msg.interest))
else:
x.interests.remove(msg.interest)
else:
gLog.print("MsgInternalQuPump {0}: unrecognized message {1}}".format(self.name, msg))
def receive(self):
if len(self.inBuffer) < 2:
buf = self.sock.recv(1024)
for x in buf:
self.inBuffer.append(x)
strSize = self.inBuffer[0] + 128 * self.inBuffer[1]
while strSize + 2 > len(self.inBuffer):
buf = self.sock.recv(1024) # WARNING: if length of buf is 0, then the connection has been broken
for x in buf:
self.inBuffer.append(x)
strMsg = self.inBuffer[2:2 + strSize]
self.inBuffer = self.inBuffer[2 + strSize:]
msg = splitMsgStr(strMsg)
gLog.print(" >>> Received {0} from peer {1}".format(msg, self.sock.getpeername()))
return msg
def __init__(self, name = None, sock = None, inQuList = None):
Thread.__init__(self)
assert(isinstance(name, str))
assert(isinstance(sock, MsgSocket))
assert(isinstance(inQuList, list))
for x in inQuList:
assert(isinstance(x, InQuListEntry))
assert(isinstance(x.inQu, multiprocessing.queues.Queue))
assert(isinstance(x.interests, list))
for y in x.interests:
assert(y in ControllerInMsgs)
gLog.print("MsgInQuPump {0}: initializing".format(name))
self.name = name
self.sk = sock
self.inQuList = inQuList
def initTrain(self, address, position):
gLog.print("Throttle {0}: sending DoLocoInitMsg".format(self.name))
assert 0 <= address <= 9999
assert isinstance(position, list) or isinstance(position, tuple)
self.put(DoLocoInitMsg(address=address, sensors=position))
responseMsg = None
if position:
self.addInterest(PutInitOutcomeMsg)
responseMsg = self.waitFor(PutInitOutcomeMsg(physAdd=address, physSlot=0, virtAdd=0, virtSlot=0))
self.removeInterest(PutInitOutcomeMsg)
if responseMsg.physSlot > 120:
self.virtSlot = None
else:
self.virtSlot = responseMsg.virtSlot
return responseMsg
def getPath(self, pathKind, preSensor, fromSensor, toSensor, sensorsToExclude):
gLog.print("Throttle {0}: sending GetPathMsg".format(self.name))
self.addInterest(PutPathMsg)
self.put(
GetPathMsg(
slot=self.virtSlot,
pathKind=pathKind,
preSensor=preSensor,
fromSensor=fromSensor,
toSensor=toSensor,
sensorsToExclude=sensorsToExclude,
)
)
msg = self.waitFor(PutPathMsg(sensors=[]))
self.removeInterest(PutPathMsg)
return msg.sensors
def __init__(self, name = None, comPkg = None):
gLog.print("MsgHandler {0}: initializing".format(name))
assert(isinstance(name, str))
assert(isinstance(comPkg, CommunicationsPackage))
inQu = comPkg.inQu
inQuNum = comPkg.inQuNum
outQu = comPkg.outQu
assert(isinstance(inQu, multiprocessing.queues.Queue))
assert(isinstance(outQu, multiprocessing.queues.Queue))
assert(0 <= inQuNum)
self.name = name
self.inQu = inQu
self.inQuNum = inQuNum
self.outQu = outQu
def __init__(self, name = None, host = None, port = None, inQuList = None, outQu = None):
gLog.print("MsgPumpHandler {0}: initializing".format(name))
assert(isinstance(name, str))
assert(isinstance(host, str))
assert(port > 1000)
assert(isinstance(inQuList, list))
for x in inQuList:
assert(isinstance(x, InQuListEntry))
assert(isinstance(x.inQu, multiprocessing.queues.Queue))
assert(isinstance(x.interests, list))
#print(str(x))
for y in x.interests:
assert(y in ControllerInMsgs)
assert(isinstance(outQu, multiprocessing.queues.Queue))
self.name = name
self.host = host
self.port = port
self.inQuList = inQuList
self.outQu = outQu
def __init__(self, number, quSend, quRead):
print("Initializing gui {0}".format(number)); sys.stdout.flush()
gLog.print("Initializing gui {0}".format(number))
self.number = number
self.quSend = quSend
self.quRead = quRead
EasyFrame.__init__(self, title = "GUI " + str(number))
# Label and field for the input
self.addLabel(text = "Input", row = 0, column = 0)
self.inputField = self.addTextField(text = "", row = 0, column = 1)
# Text area for the output
self.outputArea = self.addTextArea(text = "", row = 1, column = 0, columnspan = 2, width = 50, height = 15)
# The command button
self.button = self.addButton(text = "Send", row = 2, column = 0, columnspan = 2, command = self.sendMessage)
# Set up the queue reader for this window
quReaderThread = QuReaderThread(self, self.quRead)
quReaderThread.start()
def connect(self, host, port):
assert(isinstance(host, str))
assert(port > 0)
gLog.print("MsgSocket {0}: is trying to connect to ({1}, {2})".format(self.name, host, port))
self.inBuffer = bytearray()
self.sock = socket()
for i in range(5):
if not self.sock.connect_ex((host, port)):
gLog.print("MsgSocket {0}: has connected to peer {1}".format(self.name, self.sock.getpeername()))
return
else:
gLog.print("MsgSocket {0}: failed to connect to ({1}, {2})".format(self.name, host, port))
sleep(1)
st = "MsgSocket {0}: gave up trying to connect to ({1}, {2})".format(self.name, host, port)
gLog.print(st)
raise Exception(st)
def run(self):
gLog.print("Starting " + self.character)
tempStr = ""
for i in range(80):
tempStr = tempStr + self.character
for i in range(50):
self.lineCount += 1
gLog.print(tempStr + ": count = " + str(self.lineCount))
gLog.print("Ending " + self.character)
def __init__(self, name=None, comPkg=None):
gLog.print("Throttle {0}: initializing".format(name))
assert isinstance(name, str)
assert isinstance(comPkg, CommunicationsPackage)
inQu = comPkg.inQu
inQuNum = comPkg.inQuNum
outQu = comPkg.outQu
assert isinstance(inQu, multiprocessing.queues.Queue)
assert inQuNum >= 0
assert isinstance(outQu, multiprocessing.queues.Queue)
self.name = name
self.virtSlot = None
self.direction = kForward
self.lights = kOff
self.horn = kOff
self.bell = kOff
self.mute = kOff
self.F5 = 0 # Flip this to close next turnout
self.F6 = 0 # Flip this ot throw next turnout
self.msgHandler = MsgHandler(name=self.name, comPkg=comPkg)
def kill(self, name="all"):
"""
I don't want to make this function static. It is easier to use as a member function."
Usage (only uses first three letters of name)
If name unrecognized, then defaults to "all"
kill("simulator")
kill("controller")
kill("ut4")
kill("RBLDisplay")
kill("adminthrottle")
kill("all")
"""
# todo this doesn't work under Windows 8 at school. For instance, get the message:
# todo ERROR: The process "StartController" not found.
if name.lower()[:3] == "sim":
name = "RailroadBig"
elif name.lower()[:3] == "con":
name = "StartController"
elif name.lower()[:3] == "ut4":
name = "Throttle"
elif name.lower()[:3] == "rbl":
name = "RBLDisplay"
elif name.lower()[:3] == "adm":
name = "adminthrottle"
elif name.lower()[:3] == "all":
name = "all"
else:
name = "all"
if name != "all":
if "XP" in platform.platform():
killThis = "tskill " + name
subprocess.call(killThis, shell=True)
else:
killThis = "taskkill /T /IM " + name
subprocess.call(killThis, shell=True)
gLog.print("sak: " + killThis)
else:
if "XP" in platform.platform():
subprocess.call("tskill RailroadBig", shell=True)
subprocess.call("tskill StartController", shell=True)
subprocess.call("tskill Throttle", shell=True)
subprocess.call("tskill RBLDisplay", shell=True)
subprocess.call("tskill adminthrottle", shell=True)
gLog.print("sak: tskill RailroadBig, StartController, Throttle, RBLDisplay, AdminThrottle")
else:
subprocess.call("taskkill /T /IM RailroadBig", shell=True)
subprocess.call("taskkill /T /IM StartController", shell=True)
subprocess.call("taskkill /T /IM Throttle", shell=True)
subprocess.call("taskkill /T /IM RBLDisplay", shell=True)
subprocess.call("taskkill /T /IM adminthrottle", shell=True)
gLog.print("sak: taskkill /T /IM RailroadBig, StartController, Throttle, RBLDisplay, AdminThrottle ")
def run(self):
gLog.print("Message server {0}: running".format(self.name))
self.serverSocket = socket()
self.serverSocket.bind((self.host, self.port)) # bind
self.serverSocket.listen(5) # listen
gLog.print("Message server {0}: now listening at ({1}, {2})".format(self.name, self.host, self.port))
while True:
socketToClient, address = self.serverSocket.accept() # accept
gLog.print("Message server {0}: just created a connection to peer at {1}".
format(self.name, socketToClient.getpeername()))
ClientHandlerThread("1", socketToClient, self.clientHandlerFunction).start()
def close(self):
gLog.print("MsgSocket {0}: closing ".format(self.name))
self.sock.close()
def __init__(self, myGui, myQu):
print("Initializing a queue reader"); sys.stdout.flush()
gLog.print("Initializing a queue reader")
Thread.__init__(self)
self.myGui = myGui
self.myQu = myQu
def run(self):
gLog.open(str(self.number))
print("Running process {0}".format(self.number)); sys.stdout.flush()
gLog.print("Running process {0}".format(self.number))
TheGui(self.number, self.quSend, self.quRead).mainloop()
def run(self):
msgSocketToClient = MsgSocket()
msgSocketToClient.attach(self.socketToClient)
gLog.print("Client handler {0}: running with peer {1} and function {2}"
.format(self.name, self.socketToClient.getpeername(), self.clientHandlerFunction))
self.clientHandlerFunction(msgSocketToClient)
def start(self, name, ip="", port="", trace="", logs="", layoutFile=""):
"""
Usage (only uses first three letters of name)
start("simulator")
start("controller", ip = "127.0.0.1", port = "1234", trace = "yes")
start("ut4", ip = "127.0.0.1", port = "1234")
start("RBLDisplay", ip = "127.0.0.1", port = "1235")
start("adminthrottle", ip = "127.0.0.1", port = "1235", layoutFile = "layout.xml", logs = "no")
"""
startThis = ""
# start("simulator")
if name.lower()[:3] == "sim":
startThis = "start " + self.sakPath + "/RailroadBig.exe"
subprocess.call(startThis, shell=True)
sleep(1)
# start("controller", ip = "127.0.0.1", port = "1234", trace = "yes")
elif name.lower()[:3] == "con":
if ip == "":
ip = "127.0.0.1" # default to local host
if port == "":
port = "1234" # default to the simulator
if trace == "" or trace.lower()[:1] == "y":
trace = "yes" # default to trace on
else:
trace = "no"
startThis = "start " + self.sakPath + "/StartController.exe" + \
" IP " + ip + \
" PORT " + port + \
" TRACE " + trace
subprocess.call(startThis, shell=True)
sleep(3)
# start("ut4", ip = "127.0.0.1", port = "1234")
elif name.lower()[:3] == "ut4":
if ip == "":
ip = "127.0.0.1" # default to local host
if port == "":
port = "1234" # default to the simulator
startThis = "start " + self.sakPath + "/Throttle.exe" + \
" IP " + ip + \
" PORT " + port
subprocess.call(startThis, shell=True)
# start("RBLDisplay", ip = "127.0.0.1", port = "1235")
elif name.lower()[:3] == "rbl":
if ip == "":
ip = "127.0.0.1" # default to local host
if port == "":
port = "1235" # default to the controller
startThis = "start " + self.sakPath + "/RBLDisplay.exe" + \
" IP " + ip + \
" PORT " + port
subprocess.call(startThis, shell=True)
# start("adminthrottle", ip = "127.0.0.1", port = "1235", layoutFile = "layout.xml", logs = "no")
elif name.lower()[:3] == "adm":
if ip == "":
ip = "127.0.0.1" # default to local host
if port == "" or port == "1235":
port = "1235" # default to controller
mode = "controller" # default to controller mode
else:
mode = "standalone" # default to standalone mode
if layoutFile == "":
layoutFile = "layout.xml" # default to layout.xml
if logs == "" or logs.lower()[:1] == "n":
logs = "no" # default to logs off
else:
logs = "yes"
startThis = "start " + self.sakPath + "/adminthrottle.exe" + \
" IP " + ip + \
" PORT " + port + \
" MODE " + mode + \
" KEYBOARDLOG " + logs + \
" ADMINLOG " + logs
if mode == "controller":
startThis = startThis + " LAYOUTFILE " + layoutFile
subprocess.call(startThis, shell=True)
# Log it
gLog.print("sak: " + startThis)
def setPath(self, st):
self.sakPath = st
gLog.print("sak: path is {0} ".format(st))
