def main(self):
"""Main (thread) loop"""
try:
self.send("Thread running", "signal")
try:
sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM) #; yield 0.3
except socket.error, e:
#handle initial failure to create socket.
# If we can't create a socket we might as well give up now.
# This matches the behaviour of the main TCP client but it might be better passing as
# an Axon.Ipc.errorInformation carrying the exception otherwise what is the IPC class
# for?
self.send(e, "signal")
# I am assuming that by using queues there are no race conditions between this operations.
self.send(socketShutdown(), "signal")
return
self.send("socket object created", "signal")
try:
sock.connect((self.host, self.port))
except socket.error, e:
self.send(e, "signal")
try:
result = sock.close()
except:
pass
self.send(socketShutdown(), "signal")
return
def main(self):
"""Main (thread) loop"""
try:
self.send("Thread running","signal")
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#; yield 0.3
except socket.error, e:
#handle initial failure to create socket.
# If we can't create a socket we might as well give up now.
# This matches the behaviour of the main TCP client but it might be better passing as
# an Axon.Ipc.errorInformation carrying the exception otherwise what is the IPC class
# for?
self.send(e,"signal")
# I am assuming that by using queues there are no race conditions between this operations.
self.send(socketShutdown(),"signal")
return
self.send("socket object created","signal")
try:
sock.connect((self.host, self.port))
except socket.error, e:
self.send(e,"signal")
try:
result = sock.close()
except:
pass
self.send(socketShutdown(),"signal")
return
def handleClosedCSA(self, shutdownCSAMessage):
"""
handleClosedCSA(shutdownCSAMessage) -> None
Terminates and unwires the protocol handler for the closing socket.
Keyword arguments:
shutdownCSAMessage -- shutdownCSAMessage.object is the ConnectedSocketAdapter for socket that is closing.
"""
connectedSocket = shutdownCSAMessage.object
try:
bundle = self.retrieveTrackedResourceInformation(connectedSocket)
except KeyError:
# This means we've actually already done this...
return
resourceInboxes, resourceOutboxes, (protocolHandler, controllink) = bundle
self.connectedSockets = [x for x in self.connectedSockets if x != self.connectedSockets]
self.unlink(thelinkage=controllink)
self.send(socketShutdown(), resourceOutboxes[0]) # This is now instantly delivered
self.send(shutdownMicroprocess(), resourceOutboxes[1]) # This is now instantly delivered
self.removeChild(connectedSocket)
self.removeChild(protocolHandler)
self.deleteOutbox(resourceOutboxes[0]) # So this is now safe
# This did not used to be the case.
self.deleteOutbox(resourceOutboxes[1]) # So this is now safe
# This did not used to be the case.
self.ceaseTrackingResource(connectedSocket)
def handleClosedCSA(self, shutdownCSAMessage):
"""
handleClosedCSA(shutdownCSAMessage) -> None
Terminates and unwires the protocol handler for the closing socket.
Keyword arguments:
shutdownCSAMessage -- shutdownCSAMessage.object is the ConnectedSocketAdapter for socket that is closing.
"""
# print (shutdownCSAMessage)
# print (shutdownCSAMessage.object)
connectedSocket = shutdownCSAMessage.object
# print ("CLOSING", connectedSocket)
try:
bundle = self.retrieveTrackedResourceInformation(connectedSocket)
# print ("BUNDLE", bundle)
except KeyError:
# This means we've actually already done this...
return
resourceInboxes, resourceOutboxes, (protocolHandler,
controllink) = bundle
# print (bundle)
self.connectedSockets = [
x for x in self.connectedSockets if x != connectedSocket
]
if controllink:
self.unlink(thelinkage=controllink)
# else:
# print ("Control Link is null, not unlinking")
self.send(socketShutdown(),
resourceOutboxes[0]) # This is now instantly delivered
self.send(shutdownMicroprocess(),
resourceOutboxes[1]) # This is now instantly delivered
self.removeChild(connectedSocket)
self.removeChild(protocolHandler)
self.deleteOutbox(resourceOutboxes[0]) # So this is now safe
# This did not used to be the case.
self.deleteOutbox(resourceOutboxes[1]) # So this is now safe
# This did not used to be the case.
# print ("CEASING TRACKING", self._resourceStore)
self.ceaseTrackingResource(connectedSocket)
def main(self):
"""Main (thread) loop"""
try:
self.send("Thread running","signal")
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#; yield 0.3
except socket.error:
e = sys.exc_info()[1]
#handle initial failure to create socket.
# If we can't create a socket we might as well give up now.
# This matches the behaviour of the main TCP client but it might be better passing as
# an Axon.Ipc.errorInformation carrying the exception otherwise what is the IPC class
# for?
self.send(e,"signal")
# I am assuming that by using queues there are no race conditions between this operations.
self.send(socketShutdown(),"signal")
return
self.send("socket object created","signal")
try:
sock.connect((self.host, self.port))
except socket.error:
e = sys.exc_info()[1]
self.send(e,"signal")
try:
result = sock.close()
except:
pass
self.send(socketShutdown(),"signal")
return
self.send("socket connected","signal")
producerFinished = 0
if self.sendmessage != None:
try:
sock.send(self.sendmessage)
except socket.error:
e = sys.exc_info()[1]
self.send(e,"signal")
try:
result = sock.close()
except:
pass
self.send(socketShutdown(), "signal")
return
# This loop will handle sending, control and signal communications
# including with the recv thread. Apart from the sending all the calls
# should be non-blocking. sending should rarely take a significant
# time. One non-blocking call will operate with a short timeout to
# prevent busy wait taking too much CPU time.
while 1:
try:
data = sock.recv(1024)
if not data: # This implies the connection has barfed.
break
self.send(data)
# except socket.timeout, to:
# pass # common case Try again next loop.
except socket.error:
err = sys.exc_info()[1]
self.send(err,"signal")
break # The task is finished now.
try:
if self.dataReady("control"):
msg = self.recv("control")
if isinstance(msg, Axon.Ipc.producerFinished):
break
# Want to give opportunity for inbox messages to get into the
# inbox queue before shutting down the sending system.
except Empty:
e = sys.exc_info()[1]
pass # Normal case.
#end while 1
# After breaking out of while loop clean up socket before ending the thread.
try:
sock.shutdown(2)
except socket.error:
e = sys.exc_info()[1]
pass
try:
sock.close()
except socket.error:
e = sys.exc_info()[1]
self.send(e,"signal")
self.send(socketShutdown(),"signal")
#Normal exit
except Exception:
e = sys.exc_info()[1]
self.send("Unexpected exception","signal")
self.send(e,"signal")
self.send(socketShutdown(),"signal")
def passOnShutdown(self):
self.send(socketShutdown(self, [self.socket, self.howDied]),
"CreatorFeedback")
self.send(shutdownCSA(self, (self, self.socket)), "signal")
# inbox queue before shutting down the sending system.
except Empty, e:
pass # Normal case.
#end while 1
# After breaking out of while loop clean up socket before ending the thread.
try:
sock.shutdown(2)
except socket.error, e:
pass
try:
sock.close()
except socket.error, e:
self.send(e,"signal")
self.send(socketShutdown(),"signal")
#Normal exit
except Exception, e:
self.send("Unexpected exception","signal")
self.send(e,"signal")
self.send(socketShutdown(),"signal")
#Unhandled exception exit. Reports via the signal outqueue as it can't print errors here.
__kamaelia_components__ = ( ThreadedTCPClient, )
if __name__ =="__main__":
from Axon.Scheduler import scheduler
from Kamaelia.Util.Console import ConsoleEchoer
from Axon.Ipc import newComponent
from Kamaelia.Chassis.ConnectedServer import SimpleServer
class ThreadedTCPClient(Axon.ThreadedComponent.threadedcomponent):
"""\
ThreadedTCPClient(host,port[,chargen][,initalsendmessage]) -> threaded component with a TCP connection to a server.
Establishes a TCP connection to the specified server.
Keyword arguments:
- host -- address of the server to connect to (string)
- port -- port number to connect on
- initialsendmessage -- to be send immediately after connection is established (default=None)
"""
Inboxes = {
"inbox": "data to send to the socket",
"control": "",
}
Outboxes = {
"outbox": "data received from the socket",
"signal": "diagnostic output, errors and shutdown messages",
}
def __init__(self, host, port, chargen=0, initialsendmessage=None):
"""x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
super(ThreadedTCPClient, self).__init__()
self.host = host
self.port = port
self.chargen = chargen
self.sendmessage = initialsendmessage
def main(self):
"""Main (thread) loop"""
try:
self.send("Thread running", "signal")
try:
sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM) #; yield 0.3
except socket.error, e:
#handle initial failure to create socket.
# If we can't create a socket we might as well give up now.
# This matches the behaviour of the main TCP client but it might be better passing as
# an Axon.Ipc.errorInformation carrying the exception otherwise what is the IPC class
# for?
self.send(e, "signal")
# I am assuming that by using queues there are no race conditions between this operations.
self.send(socketShutdown(), "signal")
return
self.send("socket object created", "signal")
try:
sock.connect((self.host, self.port))
except socket.error, e:
self.send(e, "signal")
try:
result = sock.close()
except:
pass
self.send(socketShutdown(), "signal")
return
self.send("socket connected", "signal")
producerFinished = 0
if self.sendmessage != None:
try:
sock.send(self.sendmessage)
except socket.error, e:
self.send(e, "signal")
try:
result = sock.close()
except:
pass
self.send(socketShutdown(), "signal")
return
# inbox queue before shutting down the sending system.
except Empty, e:
pass # Normal case.
#end while 1
# After breaking out of while loop clean up socket before ending the thread.
try:
sock.shutdown(2)
except socket.error, e:
pass
try:
sock.close()
except socket.error, e:
self.send(e, "signal")
self.send(socketShutdown(), "signal")
#Normal exit
except Exception, e:
self.send("Unexpected exception", "signal")
self.send(e, "signal")
self.send(socketShutdown(), "signal")
#Unhandled exception exit. Reports via the signal outqueue as it can't print errors here.
__kamaelia_components__ = (ThreadedTCPClient, )
if __name__ == "__main__":
from Axon.Scheduler import scheduler
from Kamaelia.Util.Console import ConsoleEchoer
from Axon.Ipc import newComponent
from Kamaelia.Chassis.ConnectedServer import SimpleServer
from Kamaelia.Protocol.FortuneCookieProtocol import FortuneCookieProtocol
def passOnShutdown(self):
self.send(socketShutdown(self,[self.socket,self.howDied]), "CreatorFeedback")
self.send(shutdownCSA(self, (self,self.socket)), "signal")