def test_ActivityOnAnyWriterResultsInMessageOnThatWritersService(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(newWriter(S,( dummyservice1, "LOOKINGFORTHIS") ),"notify")
dummyservice2 = (E, "inbox")
S._deliver(newWriter(S,( dummyservice2, "THENFORTHIS") ),"notify")
dummyservice3 = (F, "inbox")
S._deliver(newWriter(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):
selectorService, selectorShutdownService, S = Selector.getSelectorServices(
self.tracker)
if S:
S.activate()
yield 1
yield 1
yield 1
self.link((self, "selector"), (selectorService))
self.send(newWriter(self, ((self, "ready"), self.fh)), "selector")
dataPending = ""
try:
while 1:
# no data pending
if dataPending == "":
while not self.dataReady("inbox"):
self.checkShutdown(noNeedToWait=True)
self.pause()
yield 1
dataPending = self.recv("inbox")
# now try to send it
try:
#self.fh.write(dataPending)
byteswritten = os.write(self.fh.fileno(), dataPending)
if byteswritten >= 0:
dataPending = dataPending[byteswritten:]
# dataPending=""
except OSError, IOError:
# data pending
# wait around until stdin is ready
if not self.dataReady("ready"):
self.send(newWriter(self, ((self, "ready"), self.fh)),
"selector")
while not self.dataReady("ready"):
self.checkShutdown(noNeedToWait=False)
self.pause()
yield 1
self.recv("ready")
self.checkShutdown(noNeedToWait=False)
except UserWarning:
pass # ordered to shutdown!
self.send(removeWriter(self, (self.fh)), "selector")
try:
self.fh.close()
except:
pass
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))
self.send(newWriter(self,((self, "ready"), self.fh)), "selector")
dataPending=""
try:
while 1:
# no data pending
if dataPending=="":
while not self.dataReady("inbox"):
self.checkShutdown(noNeedToWait=True)
self.pause()
yield 1
dataPending = self.recv("inbox")
# now try to send it
try:
#self.fh.write(dataPending)
byteswritten = os.write(self.fh.fileno(),dataPending)
if byteswritten >= 0:
dataPending = dataPending[byteswritten:]
# dataPending=""
except OSError,IOError:
# data pending
# wait around until stdin is ready
if not self.dataReady("ready"):
self.send(newWriter(self,((self, "ready"), self.fh)), "selector")
while not self.dataReady("ready"):
self.checkShutdown(noNeedToWait=False)
self.pause()
yield 1
self.recv("ready")
self.checkShutdown(noNeedToWait=False)
except UserWarning:
pass # ordered to shutdown!
self.send(removeWriter(self,(self.fh)), "selector")
try:
self.fh.close()
except:
pass
self.send(self.shutdownMsg,"signal")
def _safesend(self, sock, data):
"""Internal only function, used for sending data, and handling EAGAIN style
retry scenarios gracefully"""
bytes_sent = 0
try:
bytes_sent = sock.send(data)
return bytes_sent
except socket.error:
msg = sys.exc_info()[1]
(errorno, errmsg) = msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
self.connectionSENDLive = False
self.howDied = sg
# Print( "Oh No! Socket Died - sending!", e)
except TypeError:
ex = sys.exc_info()[1]
if self.noisyErrors:
print ("CSA: Exception sending on socket: ", ex, "(no automatic conversion to string occurs).")
if self.crashOnBadDataToSend:
raise ex
self.sending = False
if self.connectionSENDLive:
self.send(newWriter(self, ((self, "SendReady"), sock)), "_selectorSignal")
return bytes_sent
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 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 _safesend(self, sock, data):
"""Internal only function, used for sending data, and handling EAGAIN style
retry scenarios gracefully"""
bytes_sent = 0
try:
bytes_sent = sock.send(data)
return bytes_sent
except socket.error:
msg = sys.exc_info()[1]
(errorno, errmsg) = msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
self.connectionSENDLive = False
self.howDied = sg
# Print( "Oh No! Socket Died - sending!", e)
except TypeError:
ex = sys.exc_info()[1]
if self.noisyErrors:
print("CSA: Exception sending on socket: ", ex,
"(no automatic conversion to string occurs).")
if self.crashOnBadDataToSend:
raise ex
self.sending = False
if self.connectionSENDLive:
self.send(newWriter(self, ((self, "SendReady"), sock)),
"_selectorSignal")
return bytes_sent
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 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 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):
# 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):
# 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):
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices()
if newSelector:
newSelector.activate()
self.link((self, "_selectorSignal"), selectorService)
self.send(newWriter(self, ((self, "WriteReady"), self.sock)),
"_selectorSignal")
# TODO: Make me shutdown nicely
while 1:
#TODO: Write me :D
pass
def test_ActivityOnAnyWriterResultsInMessageOnThatWritersService(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(newWriter(S, (dummyservice1, "LOOKINGFORTHIS")), "notify")
dummyservice2 = (E, "inbox")
S._deliver(newWriter(S, (dummyservice2, "THENFORTHIS")), "notify")
dummyservice3 = (F, "inbox")
S._deliver(newWriter(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):
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(
)
if newSelector:
newSelector.activate()
self.link((self, "_selectorSignal"), selectorService)
self.send(newWriter(self, ((self, "WriteReady"), self.sock)),
"_selectorSignal")
# TODO: Make me shutdown nicely
while 1:
#TODO: Write me :D
pass
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 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 main(self):
""" Main loop """
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
shutdownOnEmptyBuffer = False
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, producerFinished):
shutdownOnEmptyBuffer = True
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
# Make sure everything which could get sent does so before we
# exit
if shutdownOnEmptyBuffer:
if (not self.dataReady("inbox") and
len(self.sendBuffer[0]) == 0):
self.send(producerFinished(), "signal")
break
if self.dataReady("writeReady"):
self.recv("writeReady")
self.sending = True
if self.sending:
self.sendLoop(self.remote)
# This line is sketchy. I have a feeling it'll lead to never
# pausing in certain circumstances. So far it's not happened...
if not shutdownOnEmptyBuffer:
if (not self.anyReady() or
not (self.sending and len(self.sendBuffer[0]) != 0)):
self.pause()
yield 1
self.send(removeWriter(self, self.sock), "_selectorSignal")
yield 1
self.sock.close()
def main(self):
""" Main loop """
self.sock.setblocking(0)
self.setupSelector()
yield 1
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
shutdownOnEmptyBuffer = False
while 1:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, producerFinished):
shutdownOnEmptyBuffer = True
if isinstance(msg, shutdownMicroprocess):
self.send(msg, "signal")
break
# Make sure everything which could get sent does so before we
# exit
if shutdownOnEmptyBuffer:
if (not self.dataReady("inbox")
and len(self.sendBuffer[0]) == 0):
self.send(producerFinished(), "signal")
break
if self.dataReady("writeReady"):
self.recv("writeReady")
self.sending = True
if self.sending:
self.sendLoop(self.remote)
# This line is sketchy. I have a feeling it'll lead to never
# pausing in certain circumstances. So far it's not happened...
if not shutdownOnEmptyBuffer:
if (not self.anyReady() or
not (self.sending and len(self.sendBuffer[0]) != 0)):
self.pause()
yield 1
self.send(removeWriter(self, self.sock), "_selectorSignal")
yield 1
self.sock.close()
def safeSend(self, data, target):
"""
Send data over the socket, handling errors gracefully
Arguments:
- data -- the data to send over the socket
- target -- (address, port) tuple indicating where to send the data
"""
bytesSent = 0
try:
bytesSent = self.sock.sendto(data, target)
return bytesSent
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if errorno == errno.AGAIN or errorno == errno.EWOULDBLOCK:
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
def safeSend(self, data, target):
"""
Send data over the socket, handling errors gracefully
Arguments:
- data -- the data to send over the socket
- target -- (address, port) tuple indicating where to send the data
"""
bytesSent = 0
try:
bytesSent = self.sock.sendto(data, target)
return bytesSent
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if errorno == errno.AGAIN or errorno == errno.EWOULDBLOCK:
self.send(newWriter(self, ((self, "writeReady"), self.sock)),
"_selectorSignal")
def test_RemoveWriter_ResultsInWriterNoLongerBeingSelectedOrWiredIn(self):
"main - Sending a remove writer message unwires/links a component, and also removes it's selectable from the writers 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(newWriter(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
S._deliver(removeWriter(S,"LOOKINGFORTHIS"),"notify")
for i in xrange(100):
S.next();
try:
S.postoffice.next()
except:
pass
print
self.assert_( len(D.inboxes["inbox"]) == 0 )
def test_RemoveWriter_ResultsInWriterNoLongerBeingSelectedOrWiredIn(self):
"main - Sending a remove writer message unwires/links a component, and also removes it's selectable from the writers 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(newWriter(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
S._deliver(removeWriter(S, "LOOKINGFORTHIS"), "notify")
for i in xrange(100):
S.next()
try:
S.postoffice.next()
except:
pass
print
self.assert_(len(D.inboxes["inbox"]) == 0)
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")
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
self.connectionSENDLive = False
self.howDied = socket.msg
except TypeError, ex:
if self.noisyErrors:
print "CSA: Exception sending on socket: ", ex, "(no automatic conversion to string occurs)."
if self.crashOnBadDataToSend:
raise ex
self.sending = False
if self.connectionSENDLive:
self.send(newWriter(self, ((self, "SendReady"), sock)), "_selectorSignal")
return bytes_sent
def flushSendQueue(self):
if len(self.sendQueue) > 0:
data = self.sendQueue[0]
bytes_sent = self._safesend(self.socket, data)
if bytes_sent:
if bytes_sent == len(data):
del self.sendQueue[0]
else:
self.sendQueue[0] = data[bytes_sent:]
def _saferecv(self, sock, size=32768):
"""Internal only function, used for recieving data, and handling EAGAIN style
retry scenarios gracefully"""
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 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")
except socket.error, socket.msg:
(errorno, errmsg) = socket.msg.args
if not (errorno == errno.EAGAIN or errorno == errno.EWOULDBLOCK):
self.connectionSENDLive = False
self.howDied = socket.msg
except TypeError, ex:
if self.noisyErrors:
print "CSA: Exception sending on socket: ", ex, "(no automatic conversion to string occurs)."
if self.crashOnBadDataToSend:
raise ex
self.sending = False
if self.connectionSENDLive:
self.send(newWriter(self, ((self, "SendReady"), sock)),
"_selectorSignal")
return bytes_sent
def flushSendQueue(self):
if len(self.sendQueue) > 0:
data = self.sendQueue[0]
bytes_sent = self._safesend(self.socket, data)
if bytes_sent:
if bytes_sent == len(data):
del self.sendQueue[0]
else:
self.sendQueue[0] = data[bytes_sent:]
def _saferecv(self, sock, size=32768):
"""Internal only function, used for recieving data, and handling EAGAIN style
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
