def test_SendingMultipleReadersResultsInAllSelected(self):
"main - Sending multiple newReader messages results in all being select()ed"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHISTOO")), "notify")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORANDTHIS")), "notify")
for i in xrange(100):
S.next()
lastfunc, lastargs = None, None
i = 0
func, args = MOCKSELECTORMODULE.log[i]
while not ((lastfunc, lastargs)
== (func, args)): # Search for quiescent state
i = i + 1
lastfunc, lastargs = func, args
func, args = MOCKSELECTORMODULE.log[i]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(
["LOOKINGFORTHIS", "LOOKINGFORTHISTOO", "LOOKINGFORANDTHIS"],
args[0]) #, "The selectable was added to the list of readables")
def test_ActivityOnAnyReaderResultsInMessageOnThatReadersService(self):
"main - Activity on a selectable results in a message appearing in the service provided to the selector for that selectable"
MOCKSELECTORMODULE = MockSelect(results=[ (["LOOKINGFORTHIS"],[],[]),
(["THENFORTHIS"],[],[]),
(["ANDTHENFORTHIS"],[],[]) ])
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
D = Axon.Component.component()
E = Axon.Component.component()
F = Axon.Component.component()
dummyservice1 = (D, "inbox")
S._deliver(newReader(S,( dummyservice1, "LOOKINGFORTHIS") ),"notify")
dummyservice2 = (E, "inbox")
S._deliver(newReader(S,( dummyservice2, "THENFORTHIS") ),"notify")
dummyservice3 = (F, "inbox")
S._deliver(newReader(S,( dummyservice3, "ANDTHENFORTHIS") ),"notify")
for i in xrange(100):
S.next();
try:
S.postoffice.next()
except:
pass
selectable = D.recv("inbox")
self.assertEqual(selectable,"LOOKINGFORTHIS")#, "The value returned should be the selectable we originally asked for")
selectable = E.recv("inbox")
self.assertEqual(selectable,"THENFORTHIS")#, "The value returned should be the selectable we originally asked for")
selectable = F.recv("inbox")
self.assertEqual(selectable,"ANDTHENFORTHIS")#, "The value returned should be the selectable we originally asked for")
def main(self):
#TODO: Binding should handle errors gracefully
self.sock.bind(self.local)
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(
)
if newSelector:
newSelector.activate()
yield 1
self.link((self, "_selectorSignal"), selectorService)
self.send(newReader(self, ((self, "ReadReady"), self.sock)),
"_selectorSignal")
# TODO: Make me shutdown nicely
while 1:
if self.dataReady("ReadReady"):
# if 1:
data = True
while data:
data = self.safeRecv(1024)
if data:
print "data", repr(data)
self.send(data, "outbox")
else:
print newSelector
self.pause()
yield 1
def _saferecv(self, sock, size=32768):
"""Internal only function, used for recieving data, and handling EAGAIN style
retry scenarios gracefully"""
try:
data = sock.recv(size)
if data:
self.failcount = 0
return data
# In case of a SSL object we may read no data although
# the connection per se is still up
# We therefore don't treat such possibility as an error
elif not self.isSSL: # This implies the connection has closed for some reason
self.connectionRECVLive = False
except socket.error:
msg = sys.exc_info()[1]
(errorno, errmsg) = msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
# "Recieving an error other than EAGAIN or EWOULDBLOCK when reading is a genuine error we don't handle"
self.connectionRECVLive = False
self.howDied = msg
# Print( "Oh No! Socket Died - receiving!", e)
self.receiving = False
if self.connectionRECVLive:
self.send(newReader(self, ((self, "ReadReady"), sock)), "_selectorSignal")
return None # Explicit rather than implicit.
def main(self):
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(self.tracker)
if newSelector:
newSelector.activate()
self.link((self, "_selectorSignal"),selectorService)
self.link((self, "_selectorShutdownSignal"),selectorShutdownService)
self.selectorService = selectorService
self.selectorShutdownService = selectorShutdownService
self.send(newReader(self, ((self, "newconnection"), self.listener)), "_selectorSignal")
yield 1
while 1:
if not self.anyReady():
self.pause()
if self.anyClosedSockets():
for i in xrange(10):
yield 1
self.handleNewConnection() # Data ready means that we have a connection waiting.
if self.dataReady("control"):
data = self.recv("control")
if isinstance(data, serverShutdown):
break
yield 1
self.send(removeReader(self, self.listener), "_selectorSignal")
# for i in xrange(100): yield 1
self.send(shutdown(), "_selectorShutdownSignal")
def main(self):
""" Main loop """
self.safeBind(self.local)
# FIXME: This should possibly deal with problems with setting the
# socket non-blocking
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.receiving:
self.recvLoop()
if not self.anyReady():
self.pause()
yield 1
def main(self):
#TODO: Binding should handle errors gracefully
self.sock.bind(self.local)
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices()
if newSelector:
newSelector.activate()
yield 1
self.link((self, "_selectorSignal"), selectorService)
self.send(newReader(self, ((self, "ReadReady"), self.sock)), "_selectorSignal")
# TODO: Make me shutdown nicely
while 1:
if self.dataReady("ReadReady"):
# if 1:
data = True
while data:
data = self.safeRecv(1024)
if data:
print "data", repr(data)
self.send(data, "outbox")
else:
print newSelector
self.pause()
yield 1
def main(self):
# print ("self.selectorService", self, self.selectorService)
self.link((self, "_selectorSignal"), self.selectorService)
# self.selectorService ...
self.sending = True
self.receiving = True
self.connectionRECVLive = True
self.connectionRECVLive = True
self.connectionSENDLive = True
# Print( "CSA Activated")
while self.connectionRECVLive and self.connectionSENDLive: # Note, this means half close == close
yield 1
if self.dataReady("makessl"):
# print ("****************************************************** Making SSL ******************************************************")
# Print( "CSA Made SSL")
self.recv('makessl')
self.send(removeReader(self, self.socket), "_selectorSignal")
self.send(removeWriter(self, self.socket), "_selectorSignal")
# We need to block to allow the handshake to complete
self.socket.setblocking(True)
self.socket = SSLSocket(self.socket)
self.isSSL = True
self.socket.setblocking(False)
self.send(newReader(self, ((self, "ReadReady"), self.socket)),
"_selectorSignal")
self.send(newWriter(self, ((self, "SendReady"), self.socket)),
"_selectorSignal")
self.send('', 'sslready')
# print ("****************************************************** SSL IS READY ******************************************************")
yield 1
self.checkSocketStatus() # To be written
self.handleControl(
) # Check for producerFinished message in "control" and shutdown in response
if self.sending:
self.flushSendQueue()
if self.receiving:
self.handleReceive()
if not self.canDoSomething():
self.pause()
# self.passOnShutdown()
# Print( "Stopping...")
self.stop()
# NOTE: the creator of this CSA is responsible for removing it from the selector
# print ("")
# print ("------------------------------------------------------------------------------------")
# print ("DROPPED OFF THE END OF THE GENERATOR",self.socket)
self.socket = None
# print (self.__dict__)
# print (self.postoffice)
# print ([str(x) for x in self.postoffice.linkages])
for linkage in self.postoffice.linkages:
self.unlink(thelinkage=linkage)
def main(self):
#TODO: Binding should handle errors gracefully
self.sock.bind(self.local)
self.sock.setblocking(0)
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices()
if newSelector:
newSelector.activate()
yield 1
# Link to the selector's "notify" inbox
self.link((self, "_selectorSignal"), selectorService)
self.send(newReader(self, ((self, "ReadReady"), self.sock)),
"_selectorSignal")
# TODO: Make me shutdown nicely
while 1:
if self.dataReady("ReadReady"):
self.recv("ReadReady")
data = True
while data:
data = self.safeRecv(1024)
if data:
self.send(data, "outbox")
if not self.anyReady():
self.pause()
yield 1
def main(self):
""" Main loop """
self.safeBind(self.local)
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("writeReady"):
self.recv("writeReady")
self.sending = True
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.sending:
self.sendLoop()
if self.receiving:
self.recvLoop()
if (not self.anyReady()
or not (self.sending and len(self.sendBuffer[0]) != 0)):
self.pause()
yield 1
def _saferecv(self, sock, size=32768):
"""Internal only function, used for recieving data, and handling EAGAIN style
retry scenarios gracefully"""
try:
data = sock.recv(size)
if data:
self.failcount = 0
return data
# In case of a SSL object we may read no data although
# the connection per se is still up
# We therefore don't treat such possibility as an error
elif not self.isSSL: # This implies the connection has closed for some reason
self.connectionRECVLive = False
except socket.error:
msg = sys.exc_info()[1]
(errorno, errmsg) = msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
# "Recieving an error other than EAGAIN or EWOULDBLOCK when reading is a genuine error we don't handle"
self.connectionRECVLive = False
self.howDied = msg
# Print( "Oh No! Socket Died - receiving!", e)
self.receiving = False
if self.connectionRECVLive:
self.send(newReader(self, ((self, "ReadReady"), sock)),
"_selectorSignal")
return None # Explicit rather than implicit.
def main(self):
""" Main loop """
self.safeBind(self.local)
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("writeReady"):
self.recv("writeReady")
self.sending = True
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.sending:
self.sendLoop()
if self.receiving:
self.recvLoop()
if (not self.anyReady() or
not (self.sending and len(self.sendBuffer[0]) != 0)):
self.pause()
yield 1
def main(self):
""" Main loop """
self.safeBind(self.local)
# FIXME: This should possibly deal with problems with setting the
# socket non-blocking
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.receiving:
self.recvLoop()
if not self.anyReady():
self.pause()
yield 1
def main(self):
#TODO: Binding should handle errors gracefully
self.sock.bind(self.local)
self.sock.setblocking(0)
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(
)
if newSelector:
newSelector.activate()
yield 1
# Link to the selector's "notify" inbox
self.link((self, "_selectorSignal"), selectorService)
self.send(newReader(self, ((self, "ReadReady"), self.sock)),
"_selectorSignal")
# TODO: Make me shutdown nicely
while 1:
if self.dataReady("ReadReady"):
self.recv("ReadReady")
data = True
while data:
data = self.safeRecv(1024)
if data:
self.send(data, "outbox")
if not self.anyReady():
self.pause()
yield 1
def handleNewConnection(self):
"""\
Handle notifications from the selector service of new connection requests.
Accepts and sets up new connections, wiring them up and passing them on via
the "protocolHandlerSignal" outbox.
"""
while self.dataReady("newconnection"):
data = self.recv("newconnection")
# If we recieve information on data ready, for a server it means we have a new connection
# to handle
try:
newsock, CSA = self.createConnectedSocket(self.listener)
except socket.error, e:
(errorno,errmsg) = e
if errorno != errno.EAGAIN:
if errorno != errno.EWOULDBLOCK:
raise e
else:
pass
self.socket_handlers[newsock] = CSA
self.send(_ki.newCSA(self, CSA, newsock), "protocolHandlerSignal")
self.send(newReader(CSA, ((CSA, "ReadReady"), newsock)), "_selectorSignal")
self.send(newWriter(CSA, ((CSA, "SendReady"), newsock)), "_selectorSignal")
self.addChildren(CSA)
self.link((CSA, "CreatorFeedback"),(self,"_feedbackFromCSA"))
def main(self):
if self.listener is None:
self.send(shutdownMicroprocess, 'signal') # FIXME: Should probably be producerFinished.
# FIXME: (ie advisory that I've finished, rather than
# FIXME: demand next component to shutdown)
yield 1
return # NOTE: Change from suggested fix. (Simplifies code logic/makes diff smaller)
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(self.tracker)
if newSelector:
newSelector.activate()
self.link((self, "_selectorSignal"),selectorService)
self.link((self, "_selectorShutdownSignal"),selectorShutdownService)
self.selectorService = selectorService
self.selectorShutdownService = selectorShutdownService
self.send(newReader(self, ((self, "newconnection"), self.listener)), "_selectorSignal")
yield 1
while 1:
if not self.anyReady():
self.pause()
yield 1
if self.anyClosedSockets():
for i in xrange(10):
yield 1
self.handleNewConnection() # Data ready means that we have a connection waiting.
if self.dataReady("control"):
data = self.recv("control")
if isinstance(data, serverShutdown):
break
yield 1
self.send(removeReader(self, self.listener), "_selectorSignal")
self.send(shutdown(), "_selectorShutdownSignal")
def setupCSA(self, sock):
"""\
setupCSA(sock) -> new ConnectedSocketAdapter component
Creates a ConnectedSocketAdapter component for the socket, and wires up to
it. Also sends the CSA to the "selector" service.
"""
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(self.tracker)
if newSelector:
self.addChildren(newSelector)
CSA = ConnectedSocketAdapter(sock, selectorService) # self.createConnectedSocket(sock)
self.addChildren(CSA)
self.link((self, "_selectorSignal"),selectorService)
self.link((CSA, "CreatorFeedback"),(self,"_socketFeedback"))
self.link((CSA, "outbox"), (self, "outbox"), passthrough=2)
self.link((CSA, "sslready"), (self, "sslready"), passthrough=2)
self.link((self, "inbox"), (CSA, "inbox"), passthrough=1)
self.link((self, "makessl"), (CSA, "makessl"), passthrough=1)
self.link((self, "control"), (CSA, "control"), passthrough=1) # propagate shutdown msgs
self.send(newReader(CSA, ((CSA, "ReadReady"), sock)), "_selectorSignal")
self.send(newWriter(CSA, ((CSA, "SendReady"), sock)), "_selectorSignal")
self.CSA = CSA # We need this for shutdown later
return self.childComponents()
def setupCSA(self, sock):
"""\
setupCSA(sock) -> new ConnectedSocketAdapter component
Creates a ConnectedSocketAdapter component for the socket, and wires up to
it. Also sends the CSA to the "selector" service.
"""
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(
self.tracker)
if newSelector:
self.addChildren(newSelector)
CSA = ConnectedSocketAdapter(
sock, selectorService) # self.createConnectedSocket(sock)
self.addChildren(CSA)
self.link((self, "_selectorSignal"), selectorService)
self.link((CSA, "CreatorFeedback"), (self, "_socketFeedback"))
self.link((CSA, "outbox"), (self, "outbox"), passthrough=2)
self.link((CSA, "sslready"), (self, "sslready"), passthrough=2)
self.link((self, "inbox"), (CSA, "inbox"), passthrough=1)
self.link((self, "makessl"), (CSA, "makessl"), passthrough=1)
self.link((self, "control"), (CSA, "control"),
passthrough=1) # propagate shutdown msgs
self.send(newReader(CSA, ((CSA, "ReadReady"), sock)),
"_selectorSignal")
self.send(newWriter(CSA, ((CSA, "SendReady"), sock)),
"_selectorSignal")
self.CSA = CSA # We need this for shutdown later
return self.childComponents()
def main(self):
selectorService, selectorShutdownService, S = Selector.getSelectorServices(self.tracker)
if S:
S.activate()
yield 1
yield 1
yield 1
self.link((self, "selector"), (selectorService))
dataPending = ""
waitingToStop=False
self.shutdownMsg = None
try:
while 1:
while dataPending:
self.checkShutdown()
try:
self.send(dataPending,"outbox")
dataPending=""
except noSpaceInBox:
self.pause()
yield 1
while not dataPending:
try:
#dataPending=self.fh.read(self.maxReadChunkSize)
dataPending = os.read(self.fh.fileno(), self.maxReadChunkSize)
if dataPending=="":
raise UserWarning( "STOP" )
except OSError,IOError:
# no data available yet, need to wait
if self.checkShutdown():
raise UserWarning( "STOP" )
if self.dataReady("ready"):
self.recv("ready")
else:
self.send(newReader(self,((self, "ready"), self.fh)), "selector")
while not self.dataReady("ready") and not self.checkShutdown():
self.pause()
yield 1
if self.dataReady("ready"):
self.recv("ready")
except "STOP":
pass # ordered to shutdown!
self.send(removeReader(self,(self.fh)), "selector")
try:
self.fh.close()
except:
pass
yield 1
yield 1
if not self.shutdownMsg:
self.send(producerFinished(self), "signal")
else:
self.send(self.shutdownMsg,"signal")
def main(self):
selectorService, selectorShutdownService, S = Selector.getSelectorServices(self.tracker)
if S:
S.activate()
yield 1
yield 1
yield 1
self.link((self, "selector"), (selectorService))
dataPending = ""
waitingToStop=False
self.shutdownMsg = None
try:
while 1:
while dataPending:
self.checkShutdown()
try:
self.send(dataPending,"outbox")
dataPending=""
except noSpaceInBox:
self.pause()
yield 1
while not dataPending:
try:
#dataPending=self.fh.read(self.maxReadChunkSize)
dataPending = os.read(self.fh.fileno(), self.maxReadChunkSize)
if dataPending=="":
raise "STOP"
except OSError,IOError:
# no data available yet, need to wait
if self.checkShutdown():
raise "STOP"
if self.dataReady("ready"):
self.recv("ready")
else:
self.send(newReader(self,((self, "ready"), self.fh)), "selector")
while not self.dataReady("ready") and not self.checkShutdown():
self.pause()
yield 1
if self.dataReady("ready"):
self.recv("ready")
except "STOP":
pass # ordered to shutdown!
self.send(removeReader(self,(self.fh)), "selector")
try:
self.fh.close()
except:
pass
yield 1
yield 1
if not self.shutdownMsg:
self.send(producerFinished(self), "signal")
else:
self.send(self.shutdownMsg,"signal")
def safeRecv(self, size):
try:
data = self.sock.recvfrom(size)
if data:
return data
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK:
self.send(newReader(self, "ReadReady"), self.sock)
def main(self):
# print ("self.selectorService", self, self.selectorService)
self.link((self, "_selectorSignal"), self.selectorService)
# self.selectorService ...
self.sending = True
self.receiving = True
self.connectionRECVLive = True
self.connectionRECVLive = True
self.connectionSENDLive = True
# Print( "CSA Activated")
while self.connectionRECVLive and self.connectionSENDLive: # Note, this means half close == close
yield 1
if self.dataReady("makessl"):
# print ("****************************************************** Making SSL ******************************************************")
# Print( "CSA Made SSL")
self.recv('makessl')
self.send(removeReader(self, self.socket), "_selectorSignal")
self.send(removeWriter(self, self.socket), "_selectorSignal")
# We need to block to allow the handshake to complete
self.socket.setblocking(True)
self.socket = SSLSocket(self.socket)
self.isSSL = True
self.socket.setblocking(False)
self.send(newReader(self, ((self, "ReadReady"), self.socket)), "_selectorSignal")
self.send(newWriter(self, ((self, "SendReady"), self.socket)), "_selectorSignal")
self.send('', 'sslready')
# print ("****************************************************** SSL IS READY ******************************************************")
yield 1
self.checkSocketStatus() # To be written
self.handleControl() # Check for producerFinished message in "control" and shutdown in response
if self.sending:
self.flushSendQueue()
if self.receiving:
self.handleReceive()
if not self.canDoSomething():
self.pause()
# self.passOnShutdown()
# Print( "Stopping...")
self.stop()
# NOTE: the creator of this CSA is responsible for removing it from the selector
# print ("")
# print ("------------------------------------------------------------------------------------")
# print ("DROPPED OFF THE END OF THE GENERATOR",self.socket)
self.socket=None
# print (self.__dict__)
# print (self.postoffice)
# print ([str(x) for x in self.postoffice.linkages])
for linkage in self.postoffice.linkages:
self.unlink(thelinkage=linkage)
def safeRecv(self, size):
try:
data = self.sock.recvfrom(size)
if data:
return data
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK:
self.send(newReader(self, "ReadReady"), self.sock)
def test_ActivityOnAnyReaderResultsInMessageOnThatReadersService(self):
"main - Activity on a selectable results in a message appearing in the service provided to the selector for that selectable"
MOCKSELECTORMODULE = MockSelect(
results=[(["LOOKINGFORTHIS"], [],
[]), (["THENFORTHIS"], [],
[]), (["ANDTHENFORTHIS"], [], [])])
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
D = Axon.Component.component()
E = Axon.Component.component()
F = Axon.Component.component()
dummyservice1 = (D, "inbox")
S._deliver(newReader(S, (dummyservice1, "LOOKINGFORTHIS")), "notify")
dummyservice2 = (E, "inbox")
S._deliver(newReader(S, (dummyservice2, "THENFORTHIS")), "notify")
dummyservice3 = (F, "inbox")
S._deliver(newReader(S, (dummyservice3, "ANDTHENFORTHIS")), "notify")
for i in xrange(100):
S.next()
try:
S.postoffice.next()
except:
pass
selectable = D.recv("inbox")
self.assertEqual(
selectable, "LOOKINGFORTHIS"
) #, "The value returned should be the selectable we originally asked for")
selectable = E.recv("inbox")
self.assertEqual(
selectable, "THENFORTHIS"
) #, "The value returned should be the selectable we originally asked for")
selectable = F.recv("inbox")
self.assertEqual(
selectable, "ANDTHENFORTHIS"
) #, "The value returned should be the selectable we originally asked for")
def test_SendingMultipleReadersResultsInAllSelected(self):
"main - Sending multiple newReader messages results in all being select()ed"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHISTOO") ),"notify")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORANDTHIS") ),"notify")
for i in xrange(100):
S.next()
lastfunc, lastargs = None, None
i = 0
func, args = MOCKSELECTORMODULE.log[i]
while not( (lastfunc, lastargs) == (func, args)): # Search for quiescent state
i = i + 1
lastfunc, lastargs = func, args
func, args = MOCKSELECTORMODULE.log[i]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS","LOOKINGFORTHISTOO","LOOKINGFORANDTHIS"], args[0])#, "The selectable was added to the list of readables")
def main(self):
""" Main loop """
if not self.safeBind(self.local):
self.send(shutdownMicroprocess,
"signal") # FIXME: Should probably be producer Finished.
yield 1
return
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("target"):
self.remote = self.recv("target")
if self.dataReady("writeReady"):
self.recv("writeReady")
self.sending = True
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.sending:
self.sendLoop(self.remote)
if self.receiving:
self.recvLoop()
if (not self.anyReady()
or not (self.sending and len(self.sendBuffer[0]) != 0)):
self.pause()
yield 1
self.send(removeReader(self, self.sock), "_selectorSignal")
self.send(removeWriter(self, self.sock), "_selectorSignal")
yield 1
self.sock.close()
def createConnectedSocket(self, sock):
"""\
Accepts the connection request on the specified socket and returns a
ConnectedSocketAdapter component for it.
"""
tries = 0
maxretries = 10
gotsock=False
newsock, addr = sock.accept() # <===== THIS IS THE PROBLEM
self.send(newReader(self, ((self, "newconnection"), self.listener)), "_selectorSignal")
gotsock = True
newsock.setblocking(0)
###
CSA = (self.CSA)(newsock,self.selectorService)
return newsock, CSA
def test_SendingAReadableMessageResultsInItBeingSelectedAgainst(self):
"main - If we send a newReader message to the notify inbox, it results in the selectable reader being selected on in the readers set"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS")),"notify")
for i in xrange(100): S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS"], args[0], "The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def main(self):
""" Main loop """
if not self.safeBind(self.local):
self.send(shutdownMicroprocess, "signal") # FIXME: Should probably be producer Finished.
yield 1
return
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("target"):
self.remote = self.recv("target")
if self.dataReady("writeReady"):
self.recv("writeReady")
self.sending = True
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.sending:
self.sendLoop(self.remote)
if self.receiving:
self.recvLoop()
if (not self.anyReady() or
not (self.sending and len(self.sendBuffer[0]) != 0)):
self.pause()
yield 1
self.send(removeReader(self, self.sock), "_selectorSignal")
self.send(removeWriter(self, self.sock), "_selectorSignal")
yield 1
self.sock.close()
def test_WeSendTheSelectorAServiceAndSelectableOnlySelectsTheSelectable(self):
"main - When we send the newReader message, it also includes a service upon which the selector can talk back to us. The selector only selects on the selectable part of the newReader message"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
for i in xrange(100): S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS"], args[0])#, "The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def safeRecv(self, size):
"""
Read data from the socket, handling errors gracefully
Arguments:
- size -- The number of bytes of data to request from the socket
"""
try:
data = self.sock.recvfrom(size)
if data:
return data
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK:
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
def safeRecv(self, size):
"""
Read data from the socket, handling errors gracefully
Arguments:
- size -- The number of bytes of data to request from the socket
"""
try:
data = self.sock.recvfrom(size)
if data:
return data
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK:
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
def test_RemoveReader_ResultsInReaderNoLongerBeingSelectedOrWiredIn(self):
"main - Sending a remove reader message unwires/links a component, and also removes it's selectable from the readers list"
MOCKSELECTORMODULE = MockSelect(results=[ ([], [], [] )])
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
D = Axon.Component.component()
dummyservice = (D, "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
S._deliver(removeReader(S,"LOOKINGFORTHIS"),"notify")
for i in xrange(100):
S.next();
try:
S.postoffice.next()
except:
pass
self.assert_( len(D.inboxes["inbox"]) == 0 )
def test_SendingAReadableMessageResultsInItBeingSelectedAgainst(self):
"main - If we send a newReader message to the notify inbox, it results in the selectable reader being selected on in the readers set"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
for i in xrange(100):
S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS"], args[0],
"The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def main(self):
""" Main loop """
if not self.safeBind(self.local):
self.send(shutdownMicroprocess,
"signal") # FIXME: Should probably be producer Finished.
yield 1
return
# FIXME: This should possibly deal with problems with setting the
# socket non-blocking
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.receiving:
self.recvLoop()
if not self.anyReady():
self.pause()
yield 1
self.send(removeReader(self, self.sock), "_selectorSignal")
yield 1
try:
self.sock.close()
except:
# In case the socket close fails for whatever reason
pass
self.sock = None
def test_RemoveReader_ResultsInReaderNoLongerBeingSelectedOrWiredIn(self):
"main - Sending a remove reader message unwires/links a component, and also removes it's selectable from the readers list"
MOCKSELECTORMODULE = MockSelect(results=[([], [], [])])
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
D = Axon.Component.component()
dummyservice = (D, "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
S._deliver(removeReader(S, "LOOKINGFORTHIS"), "notify")
for i in xrange(100):
S.next()
try:
S.postoffice.next()
except:
pass
self.assert_(len(D.inboxes["inbox"]) == 0)
def main(self):
""" Main loop """
if not self.safeBind(self.local):
self.send(shutdownMicroprocess, "signal") # FIXME: Should probably be producer Finished.
yield 1
return
# FIXME: This should possibly deal with problems with setting the
# socket non-blocking
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newReader(self, ((self, "readReady"), self.sock)),
"_selectorSignal")
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
if self.dataReady("readReady"):
self.recv("readReady")
self.receiving = True
if self.receiving:
self.recvLoop()
if not self.anyReady():
self.pause()
yield 1
self.send(removeReader(self, self.sock), "_selectorSignal")
yield 1
try:
self.sock.close()
except:
# In case the socket close fails for whatever reason
pass
self.sock = None
def test_ActivityOnReaderResultsInMessageOnReadersService(self):
"main - Activity on the selectable results in a message appearing in the service provided to the selector"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
D = Axon.Component.component()
dummyservice = (D, "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
for i in xrange(100):
S.next();
try:
S.postoffice.next()
except:
pass
self.assert_(not ( len(D.inboxes["inbox"]) == 0 ) )
selectable = D.recv("inbox")
self.assertEqual(selectable,"LOOKINGFORTHIS")#, "The value returned should be the selectable we originally asked for")
def test_WeSendTheSelectorAServiceAndSelectableOnlySelectsTheSelectable(
self):
"main - When we send the newReader message, it also includes a service upon which the selector can talk back to us. The selector only selects on the selectable part of the newReader message"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
for i in xrange(100):
S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(
["LOOKINGFORTHIS"],
args[0]) #, "The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def test_ActivityOnReaderResultsInMessageOnReadersService(self):
"main - Activity on the selectable results in a message appearing in the service provided to the selector"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
D = Axon.Component.component()
dummyservice = (D, "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
for i in xrange(100):
S.next()
try:
S.postoffice.next()
except:
pass
self.assert_(not (len(D.inboxes["inbox"]) == 0))
selectable = D.recv("inbox")
self.assertEqual(
selectable, "LOOKINGFORTHIS"
) #, "The value returned should be the selectable we originally asked for")
data = sock.recv(size)
if data:
self.failcount = 0
return data
else: # This implies the connection has closed for some reason
self.connectionRECVLive = False
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
# "Recieving an error other than EAGAIN or EWOULDBLOCK when reading is a genuine error we don't handle"
self.connectionRECVLive = False
self.howDied = socket.msg
self.receiving = False
if self.connectionRECVLive:
self.send(newReader(self, ((self, "ReadReady"), sock)),
"_selectorSignal")
return None # Explicit rather than implicit.
def handleReceive(self):
successful = True
while successful and self.connectionRECVLive: ### Fixme - probably want maximum iterations here
socketdata = self._saferecv(self.socket,
32768) ### Receiving may die horribly
if (socketdata):
self.send(socketdata, "outbox")
successful = True
else:
successful = False
def main(self):
writeBuffer = []
shutdownMessage = False
selectorService, selectorShutdownService, S = Selector.getSelectorServices(self.tracker)
if S:
S.activate()
yield 1
yield 1
yield 1
self.link((self, "selector"), (selectorService))
# self.link((self, "selectorsignal"), (selectorShutdownService))
x = self.openSubprocess()
self.send(newWriter(self,((self, "stdinready"), x.stdin)), "selector")
self.send(newReader(self,((self, "stderrready"), x.stderr)), "selector")
self.send(newReader(self,((self, "stdoutready"), x.stdout)), "selector")
# Assume all ready
stdin_ready = 1
stdout_ready = 1
stderr_ready = 1
exit_status = x.poll() # while x.poll() is None
success = 0
while exit_status is None:
exit_status = x.poll()
if (not self.anyReady()) and not (stdin_ready + stdout_ready + stderr_ready):
# \
#print self.name,"Mighty Foo", stdin_ready, stdout_ready, stderr_ready, len(self.inboxes["inbox"]), len(writeBuffer)
self.pause()
yield 1
continue
while self.dataReady("inbox"):
d = self.recv("inbox")
writeBuffer.append(d)
if self.dataReady("stdinready"):
self.recv("stdinready")
stdin_ready = 1
if self.dataReady("stdoutready"):
self.recv("stdoutready")
stdout_ready = 1
if self.dataReady("stderrready"):
self.recv("stderrready")
stderr_ready = 1
if len(writeBuffer)>10000:
writeBuffer=writeBuffer[-10000:]
if stdin_ready:
while len(writeBuffer) >0:
d = writeBuffer[0]
# d = writeBuffer.pop(0)
try:
count = os.write(x.stdin.fileno(), d)
writeBuffer.pop(0)
success +=1
except OSError, e:
success -=1
# \
#print self.name,"Mighty FooBar", len(self.inboxes["inbox"]), len(writeBuffer)
# Stdin wasn't ready. Let's send through a newWriter request
# Want to wait
stdin_ready = 0
writeBuffer=writeBuffer[len(writeBuffer)/2:]
self.send(newWriter(self,((self, "stdinready"), x.stdin)), "selector")
# \
#print self.name,"OK, we're waiting....", len(self.inboxes["inbox"]), len(writeBuffer)
break # Break out of this loop
except:
# \
#print self.name,"Unexpected error whilst trying to write to stdin:"
print sys.exc_info()[0]
break
def selectorWait(self, fd):
self.debug("selectorWait")
self.send(newReader(self, ((self, "_selectorready"), fd)),
"_selectorask")
def main(self):
writeBuffer = []
shutdownMessage = False
selectorService, selectorShutdownService, S = Selector.getSelectorServices(
self.tracker)
if S:
S.activate()
yield 1
yield 1
yield 1
self.link((self, "selector"), (selectorService))
# self.link((self, "selectorsignal"), (selectorShutdownService))
x = self.openSubprocess()
self.send(newWriter(self, ((self, "stdinready"), x.stdin)), "selector")
self.send(newReader(self, ((self, "stderrready"), x.stderr)),
"selector")
self.send(newReader(self, ((self, "stdoutready"), x.stdout)),
"selector")
# Assume all ready
stdin_ready = 1
stdout_ready = 1
stderr_ready = 1
exit_status = x.poll() # while x.poll() is None
success = 0
while exit_status is None:
exit_status = x.poll()
if (not self.anyReady()) and not (stdin_ready + stdout_ready +
stderr_ready):
# \
#print (self.name,"Mighty Foo", stdin_ready, stdout_ready, stderr_ready, len(self.inboxes["inbox"]), len(writeBuffer))
self.pause()
yield 1
continue
while self.dataReady("inbox"):
d = self.recv("inbox")
writeBuffer.append(d)
if self.dataReady("stdinready"):
self.recv("stdinready")
stdin_ready = 1
if self.dataReady("stdoutready"):
self.recv("stdoutready")
stdout_ready = 1
if self.dataReady("stderrready"):
self.recv("stderrready")
stderr_ready = 1
if len(writeBuffer) > 10000:
writeBuffer = writeBuffer[-10000:]
if stdin_ready:
while len(writeBuffer) > 0:
d = writeBuffer[0]
# d = writeBuffer.pop(0)
try:
count = os.write(x.stdin.fileno(), d)
writeBuffer.pop(0)
success += 1
except OSError:
e = sys.exc_info()[1]
success -= 1
# \
#print (self.name,"Mighty FooBar", len(self.inboxes["inbox"]), len(writeBuffer))
# Stdin wasn't ready. Let's send through a newWriter request
# Want to wait
stdin_ready = 0
writeBuffer = writeBuffer[len(writeBuffer) / 2:]
self.send(
newWriter(self, ((self, "stdinready"), x.stdin)),
"selector")
# \
#print (self.name,"OK, we're waiting....", len(self.inboxes["inbox"]), len(writeBuffer))
break # Break out of this loop
except:
# \
#print (self.name,"Unexpected error whilst trying to write to stdin:")
print(sys.exc_info()[0])
break
# if count != len(d):
# raise RuntimeError("Yay, we broke it")
if stdout_ready:
try:
Y = os.read(x.stdout.fileno(), 2048)
if len(Y) > 0:
self.send(Y, "outbox")
except OSError:
e = sys.exc_info()[1]
# print ("Mighty Bingle", len(self.inboxes["inbox"]), len(writeBuffer))
# stdout wasn't ready. Let's send through a newReader request
stdout_ready = 0
self.send(
newReader(self, ((self, "stdoutready"), x.stdout)),
"selector")
except:
# \
#print (self.name,"Unexpected error whilst trying to read stdout:")
print(sys.exc_info()[0])
pass
if stderr_ready: # FIXME: This needs fixing before release
try:
Y = os.read(x.stderr.fileno(), 2048)
# TEMPORARY DIVERSION OF STDERR TO OUTBOX TOO
# \
#if len(Y)>0: self.send(Y,"outbox")
## No particular plans for stderr
except OSError:
e = sys.exc_info()[1]
# \
#print (self.name,"Mighty Jibble", len(self.inboxes["inbox"]), len(writeBuffer))
# stdout wasn't ready. Let's send through a newReader request
stderr_ready = 0
self.send(
newReader(self, ((self, "stderrready"), x.stderr)),
"selector")
except:
# \
#print (self.name,"Unexpected error whilst trying to read stderr:")
print(sys.exc_info()[0])
pass
if self.dataReady("control"):
shutdownMessage = self.recv("control")
self.send(removeWriter(self, (x.stdin)), "selector")
yield 1
x.stdin.close()
yield 1
# \
#print (self.name,"UnixPipe finishing up")
while self.dataReady("stdoutready"):
# \
#print (self.name,"flushing")
self.recv("stdoutready")
try:
Y = os.read(x.stdout.fileno(), 10)
while Y:
self.send(Y, "outbox")
Y = os.read(x.stdout.fileno(), 10)
# \
#print (self.name,"Mighty Floogly")
except OSError:
e = sys.exc_info()[1]
continue
except:
break
yield 1
# remove now closed file handles from the selector, so it doesn't stay
# upset
self.send(removeReader(self, (x.stderr)), "selector")
self.send(removeReader(self, (x.stdout)), "selector")
self.send(removeWriter(self, (x.stdin)), "selector")
# \
#print (self.name,"sending shutdown")
if not shutdownMessage:
# \
#print (self.name,"new signal")
self.send(Axon.Ipc.producerFinished(), "signal")
# \
#print (self.name,"...sent")
else:
# \
#print (self.name,"old signal")
self.send(shutdownMessage, "signal")
def main(self):
writeBuffer = []
shutdownMessage = False
selectorService, selectorShutdownService, S = Selector.getSelectorServices(self.tracker)
if S:
S.activate()
yield 1
yield 1
yield 1
self.link((self, "selector"), (selectorService))
# self.link((self, "selectorsignal"), (selectorShutdownService))
x = self.openSubprocess()
self.send(newWriter(self,((self, "stdinready"), x.stdin)), "selector")
self.send(newReader(self,((self, "stderrready"), x.stderr)), "selector")
self.send(newReader(self,((self, "stdoutready"), x.stdout)), "selector")
# Assume all ready
stdin_ready = 1
stdout_ready = 1
stderr_ready = 1
exit_status = x.poll() # while x.poll() is None
success = 0
while exit_status is None:
exit_status = x.poll()
if (not self.anyReady()) and not (stdin_ready + stdout_ready + stderr_ready):
# \
#print (self.name,"Mighty Foo", stdin_ready, stdout_ready, stderr_ready, len(self.inboxes["inbox"]), len(writeBuffer))
self.pause()
yield 1
continue
while self.dataReady("inbox"):
d = self.recv("inbox")
writeBuffer.append(d)
if self.dataReady("stdinready"):
self.recv("stdinready")
stdin_ready = 1
if self.dataReady("stdoutready"):
self.recv("stdoutready")
stdout_ready = 1
if self.dataReady("stderrready"):
self.recv("stderrready")
stderr_ready = 1
if len(writeBuffer)>10000:
writeBuffer=writeBuffer[-10000:]
if stdin_ready:
while len(writeBuffer) >0:
d = writeBuffer[0]
# d = writeBuffer.pop(0)
try:
count = os.write(x.stdin.fileno(), d)
writeBuffer.pop(0)
success +=1
except OSError:
e =sys.exc_info()[1]
success -=1
# \
#print (self.name,"Mighty FooBar", len(self.inboxes["inbox"]), len(writeBuffer))
# Stdin wasn't ready. Let's send through a newWriter request
# Want to wait
stdin_ready = 0
writeBuffer=writeBuffer[len(writeBuffer)/2:]
self.send(newWriter(self,((self, "stdinready"), x.stdin)), "selector")
# \
#print (self.name,"OK, we're waiting....", len(self.inboxes["inbox"]), len(writeBuffer))
break # Break out of this loop
except:
# \
#print (self.name,"Unexpected error whilst trying to write to stdin:")
print (sys.exc_info()[0] )
break
# if count != len(d):
# raise RuntimeError("Yay, we broke it")
if stdout_ready:
try:
Y = os.read(x.stdout.fileno(),2048)
if len(Y)>0:
self.send(Y, "outbox")
except OSError:
e = sys.exc_info()[1]
# print ("Mighty Bingle", len(self.inboxes["inbox"]), len(writeBuffer))
# stdout wasn't ready. Let's send through a newReader request
stdout_ready = 0
self.send(newReader(self,((self, "stdoutready"), x.stdout)), "selector")
except:
# \
#print (self.name,"Unexpected error whilst trying to read stdout:")
print (sys.exc_info()[0])
pass
if stderr_ready: # FIXME: This needs fixing before release
try:
Y = os.read(x.stderr.fileno(),2048)
# TEMPORARY DIVERSION OF STDERR TO OUTBOX TOO
# \
#if len(Y)>0: self.send(Y,"outbox")
## No particular plans for stderr
except OSError:
e = sys.exc_info()[1]
# \
#print (self.name,"Mighty Jibble", len(self.inboxes["inbox"]), len(writeBuffer))
# stdout wasn't ready. Let's send through a newReader request
stderr_ready = 0
self.send(newReader(self,((self, "stderrready"), x.stderr)), "selector")
except:
# \
#print (self.name,"Unexpected error whilst trying to read stderr:")
print (sys.exc_info()[0])
pass
if self.dataReady("control"):
shutdownMessage = self.recv("control")
self.send(removeWriter(self,(x.stdin)), "selector")
yield 1
x.stdin.close()
yield 1
# \
#print (self.name,"UnixPipe finishing up")
while self.dataReady("stdoutready"):
# \
#print (self.name,"flushing")
self.recv("stdoutready")
try:
Y = os.read(x.stdout.fileno(),10)
while Y:
self.send(Y, "outbox")
Y = os.read(x.stdout.fileno(),10)
# \
#print (self.name,"Mighty Floogly")
except OSError:
e = sys.exc_info()[1]
continue
except:
break
yield 1
# remove now closed file handles from the selector, so it doesn't stay
# upset
self.send(removeReader(self,(x.stderr)), "selector")
self.send(removeReader(self,(x.stdout)), "selector")
self.send(removeWriter(self,(x.stdin)), "selector")
# \
#print (self.name,"sending shutdown")
if not shutdownMessage:
# \
#print (self.name,"new signal")
self.send(Axon.Ipc.producerFinished(), "signal")
# \
#print (self.name,"...sent")
else:
# \
#print (self.name,"old signal")
self.send(shutdownMessage, "signal")
def selectorWait(self, fd):
self.debug("selectorWait")
self.send(newReader(self, ((self, "_selectorready"), fd)), "_selectorask")
data = sock.recv(size)
if data:
self.failcount = 0
return data
else: # This implies the connection has closed for some reason
self.connectionRECVLive = False
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
# "Recieving an error other than EAGAIN or EWOULDBLOCK when reading is a genuine error we don't handle"
self.connectionRECVLive = False
self.howDied = socket.msg
self.receiving = False
if self.connectionRECVLive:
self.send(newReader(self, ((self, "ReadReady"), sock)), "_selectorSignal")
return None # Explicit rather than implicit.
def handleReceive(self):
successful = True
while successful and self.connectionRECVLive: ### Fixme - probably want maximum iterations here
socketdata = self._saferecv(self.socket, 32768) ### Receiving may die horribly
if (socketdata):
self.send(socketdata, "outbox")
successful = True
else:
successful = False
# print "There!",successful
# if not self.connectionRECVLive:
# print len(self.outboxes["outbox"]), "FOO", socketdata
# print "self.howDied", self.howDied
def main(self):
writeBuffer = []
shutdownMessage = False
selectorService, selectorShutdownService, S = Selector.getSelectorServices(
self.tracker)
if S:
S.activate()
yield 1
yield 1
yield 1
self.link((self, "selector"), (selectorService))
# self.link((self, "selectorsignal"), (selectorShutdownService))
x = self.openSubprocess()
self.send(newWriter(self, ((self, "stdinready"), x.stdin)), "selector")
self.send(newReader(self, ((self, "stderrready"), x.stderr)),
"selector")
self.send(newReader(self, ((self, "stdoutready"), x.stdout)),
"selector")
# Assume all ready
stdin_ready = 1
stdout_ready = 1
stderr_ready = 1
exit_status = x.poll() # while x.poll() is None
success = 0
while exit_status is None:
exit_status = x.poll()
if (not self.anyReady()) and not (stdin_ready + stdout_ready +
stderr_ready):
# \
#print self.name,"Mighty Foo", stdin_ready, stdout_ready, stderr_ready, len(self.inboxes["inbox"]), len(writeBuffer)
self.pause()
yield 1
continue
while self.dataReady("inbox"):
d = self.recv("inbox")
writeBuffer.append(d)
if self.dataReady("stdinready"):
self.recv("stdinready")
stdin_ready = 1
if self.dataReady("stdoutready"):
self.recv("stdoutready")
stdout_ready = 1
if self.dataReady("stderrready"):
self.recv("stderrready")
stderr_ready = 1
if len(writeBuffer) > 10000:
writeBuffer = writeBuffer[-10000:]
if stdin_ready:
while len(writeBuffer) > 0:
d = writeBuffer[0]
# d = writeBuffer.pop(0)
try:
count = os.write(x.stdin.fileno(), d)
writeBuffer.pop(0)
success += 1
except OSError, e:
success -= 1
# \
#print self.name,"Mighty FooBar", len(self.inboxes["inbox"]), len(writeBuffer)
# Stdin wasn't ready. Let's send through a newWriter request
# Want to wait
stdin_ready = 0
writeBuffer = writeBuffer[len(writeBuffer) / 2:]
self.send(
newWriter(self, ((self, "stdinready"), x.stdin)),
"selector")
# \
#print self.name,"OK, we're waiting....", len(self.inboxes["inbox"]), len(writeBuffer)
break # Break out of this loop
except:
# \
#print self.name,"Unexpected error whilst trying to write to stdin:"
print sys.exc_info()[0]
break
print sys.exc_info()[0]
break
# if count != len(d):
# raise RuntimeError("Yay, we broke it")
if stdout_ready:
try:
Y = os.read(x.stdout.fileno(), 2048)
if len(Y) > 0:
self.send(Y, "outbox")
except OSError, e:
# print "Mighty Bingle", len(self.inboxes["inbox"]), len(writeBuffer)
# stdout wasn't ready. Let's send through a newReader request
stdout_ready = 0
self.send(
newReader(self, ((self, "stdoutready"), x.stdout)),
"selector")
except:
# \
#print self.name,"Unexpected error whilst trying to read stdout:"
print sys.exc_info()[0]
pass
if stderr_ready: # FIXME: This needs fixing before release
try:
Y = os.read(x.stderr.fileno(), 2048)
# TEMPORARY DIVERSION OF STDERR TO OUTBOX TOO
# \
#if len(Y)>0: self.send(Y,"outbox")
## No particular plans for stderr
except OSError, e:
#print self.name,"Unexpected error whilst trying to write to stdin:"
print sys.exc_info()[0]
break
# if count != len(d):
# raise "Yay, we broke it"
if stdout_ready:
try:
Y = os.read(x.stdout.fileno(),2048)
if len(Y)>0:
self.send(Y, "outbox")
except OSError, e:
# print "Mighty Bingle", len(self.inboxes["inbox"]), len(writeBuffer)
# stdout wasn't ready. Let's send through a newReader request
stdout_ready = 0
self.send(newReader(self,((self, "stdoutready"), x.stdout)), "selector")
except:
# \
#print self.name,"Unexpected error whilst trying to read stdout:"
print sys.exc_info()[0]
pass
if stderr_ready: # FIXME: This needs fixing before release
try:
Y = os.read(x.stderr.fileno(),2048)
# TEMPORARY DIVERSION OF STDERR TO OUTBOX TOO
# \
#if len(Y)>0: self.send(Y,"outbox")
## No particular plans for stderr
except OSError, e:
# \
