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): 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 """ 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 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")