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):
"""Main loop."""
for v in self.runClient():
yield v
if (self.sock is not None) and (self.CSA is not None):
self.send(removeReader(self.CSA, self.sock), "_selectorSignal")
self.send(removeWriter(self.CSA, self.sock), "_selectorSignal")
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):
"""Main loop."""
for v in self.runClient():
yield v
if (self.sock is not None) and (self.CSA is not None):
self.send(removeReader(self.CSA, self.sock), "_selectorSignal")
self.send(removeWriter(self.CSA, self.sock), "_selectorSignal")
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):
"""Main loop."""
# wait before connecting
waitUntil = time.time() + self.delay
while time.time() < waitUntil:
yield 1
for v in self.runClient():
yield v
if (self.sock is not None) and (self.CSA is not None):
self.send(removeReader(self.CSA, self.sock), "_selectorSignal")
self.send(removeWriter(self.CSA, self.sock), "_selectorSignal")
def main(self):
"""Main loop."""
# wait before connecting
waitUntil = time.time() + self.delay
while time.time() < waitUntil:
yield 1
for v in self.runClient():
yield v
if (self.sock is not None) and (self.CSA is not None):
self.send(removeReader(self.CSA, self.sock), "_selectorSignal")
self.send(removeWriter(self.CSA, self.sock), "_selectorSignal")
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 stop(self):
"""Stop method provided to allow the scheduler to kill TCPClient connections cleanly if necessary.
(Only rarely, if ever, needed - you are not expected to call this yourself)"""
try:
self.sock.shutdown(2)
except:
pass # Well, we tried.
try:
self.sock.close()
except:
pass # Well, we tried.
self.send(producerFinished(self,self.howDied), "signal")
if (self.sock is not None) and (self.CSA is not None):
self.send(removeReader(self.CSA, self.sock), "_selectorSignal")
self.send(removeWriter(self.CSA, self.sock), "_selectorSignal")
self.send(producerFinished(),"signal")
super(TCPClient, self).stop()
def stop(self):
"""Stop method provided to allow the scheduler to kill TCPClient connections cleanly if necessary.
(Only rarely, if ever, needed - you are not expected to call this yourself)"""
try:
self.sock.shutdown(2)
except:
pass # Well, we tried.
try:
self.sock.close()
except:
pass # Well, we tried.
self.send(producerFinished(self, self.howDied), "signal")
if (self.sock is not None) and (self.CSA is not None):
self.send(removeReader(self.CSA, self.sock), "_selectorSignal")
self.send(removeWriter(self.CSA, self.sock), "_selectorSignal")
self.send(producerFinished(), "signal")
super(TCPClient, self).stop()
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 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 closeSocket(self, shutdownMessage):
"""\
Respond to a socketShutdown message by closing the socket.
Sends a removeReader and removeWriter message to the selectorComponent.
Sends a shutdownCSA(self, theCSA) message to "protocolHandlerSignal" outbox.
"""
theComponent, (
sock, howdied) = shutdownMessage.caller, shutdownMessage.message
shutdownMessage.caller, shutdownMessage.message = None, None
shutdownMessage = None
# print ("SOCKET HANDLERS BEFORE", self.socket_handlers)
# print ("TCPServer.closeSocket", theComponent,(sock,howdied))
### FIXME: Pass on how died as well in TCPServer!
found = False
for s in self.socket_handlers:
if self.socket_handlers[s] == theComponent:
found = True
break
if found:
sock = s
if sock is not None:
theComponent = self.socket_handlers[sock]
sock.close()
if theComponent:
# tell the selector about it shutting down
self.send(removeReader(theComponent, sock), "_selectorSignal")
self.send(removeWriter(theComponent, sock), "_selectorSignal")
# tell protocol handlers
self.send(_ki.shutdownCSA(self, theComponent),
"protocolHandlerSignal") # "signal")
# Delete the child component
# print; print ("DELETING", theComponent)
self.removeChild(theComponent)
if sock:
del self.socket_handlers[sock]
sock = None
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 stop(self):
# Some of these are going to crash initially when stop is called
# print ("I AM CALLED")
# Print( "stopping")
if self.socket is None:
# SELF.STOP CALLED TWICE - possible under limited circumstances (crashes primarily)
# Only want to call once though, so exit here.
# Print( "Oh, hold on")
return
try:
self.socket.shutdown(2)
# Print( "socket.shutdown succeeded")
except Exception:
e = sys.exc_info()[1]
# Explicitly silencing this because it is possible (but rare) that
# the socket was already shutdown due to an earlier error.
# Print( "socket.shutdown failed for some reason", e)
pass
try:
# Print( "socket.close ...")
self.socket.close()
# Print( " ... succeeded")
except Exception:
e = sys.exc_info()[1]
# Print( " ... failed")
# Explicitly silencing this because it is possible (but rare) that
# the socket was already closed due to an earlier error.
pass
sock = self.socket
self.socket = None
self.passOnShutdown()
if (sock is not None):
self.send(removeReader(self, sock), "_selectorSignal")
self.send(removeWriter(self, sock), "_selectorSignal")
sock = None
super(ConnectedSocketAdapter, self).stop()
self.stop = lambda : None # Make it rather hard to call us twice by mistake
def closeSocket(self, shutdownMessage):
"""\
Respond to a socketShutdown message by closing the socket.
Sends a removeReader and removeWriter message to the selectorComponent.
Sends a shutdownCSA(self, theCSA) message to "protocolHandlerSignal" outbox.
"""
theComponent,(sock,howdied) = shutdownMessage.caller, shutdownMessage.message
shutdownMessage.caller, shutdownMessage.message = None, None
shutdownMessage = None
# print "SOCKET HANDLERS BEFORE", self.socket_handlers
# print "TCPServer.closeSocket", theComponent,(sock,howdied)
### FIXME: Pass on how died as well in TCPServer!
found = False
for s in self.socket_handlers:
if self.socket_handlers[s]==theComponent:
found = True
break
if found:
sock = s
if sock is not None:
theComponent = self.socket_handlers[sock]
sock.close()
if theComponent:
# tell the selector about it shutting down
self.send(removeReader(theComponent, sock), "_selectorSignal")
self.send(removeWriter(theComponent, sock), "_selectorSignal")
# tell protocol handlers
self.send(_ki.shutdownCSA(self, theComponent), "protocolHandlerSignal")# "signal")
# Delete the child component
# print; print "DELETING", theComponent
self.removeChild(theComponent)
if sock:
del self.socket_handlers[sock]
sock = None
def stop(self):
# Some of these are going to crash initially when stop is called
# print ("I AM CALLED")
# Print( "stopping")
if self.socket is None:
# SELF.STOP CALLED TWICE - possible under limited circumstances (crashes primarily)
# Only want to call once though, so exit here.
# Print( "Oh, hold on")
return
try:
self.socket.shutdown(2)
# Print( "socket.shutdown succeeded")
except Exception:
e = sys.exc_info()[1]
# Explicitly silencing this because it is possible (but rare) that
# the socket was already shutdown due to an earlier error.
# Print( "socket.shutdown failed for some reason", e)
pass
try:
# Print( "socket.close ...")
self.socket.close()
# Print( " ... succeeded")
except Exception:
e = sys.exc_info()[1]
# Print( " ... failed")
# Explicitly silencing this because it is possible (but rare) that
# the socket was already closed due to an earlier error.
pass
sock = self.socket
self.socket = None
self.passOnShutdown()
if (sock is not None):
self.send(removeReader(self, sock), "_selectorSignal")
self.send(removeWriter(self, sock), "_selectorSignal")
sock = None
super(ConnectedSocketAdapter, self).stop()
self.stop = lambda: None # Make it rather hard to call us twice by mistake
def closeSocket(self, shutdownMessage):
"""\
Respond to a socketShutdown message by closing the socket.
Sends a removeReader and removeWriter message to the selectorComponent.
Sends a shutdownCSA(self, theCSA) message to "protocolHandlerSignal" outbox.
"""
theComponent,(sock,howdied) = shutdownMessage.caller, shutdownMessage.message
### FIXME: Pass on how died as well in TCPServer!
theComponent = self.socket_handlers[sock]
sock.close()
# tell the selector about it shutting down
self.send(removeReader(theComponent, sock), "_selectorSignal")
self.send(removeWriter(theComponent, sock), "_selectorSignal")
# self.send(removeReader(theComponent, theComponent.socket), "_selectorSignal")
# self.send(removeWriter(theComponent, theComponent.socket), "_selectorSignal")
# tell protocol handlers
self.send(_ki.shutdownCSA(self, theComponent), "protocolHandlerSignal")# "signal")
# Delete the child component
self.removeChild(theComponent)
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")
# \
#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")
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 OSError, e:
# \
#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")
