def confirmation(self, pdu): deferred(ConsoleClient._debug, "confirmation %r", pdu) try: sys.stdout.write(pdu.pduData) except Exception as err: ConsoleClient._exception( "Confirmation sys.stdout.write exception: %r", err)
def indication(self, pdu): deferred(ConsoleServer._debug, "Indication %r", pdu) try: sys.stdout.write(pdu.pduData) except Exception as err: ConsoleServer._exception( "Indication sys.stdout.write exception: %r", err)
def handle_close(self): if _debug: deferred(TCPClient._debug, "handle_close") # close the socket self.close() # make sure other routines know the socket is closed self.socket = None
def indication(self, pdu): """Send a message.""" if _debug: Node._debug("indication %r", pdu) # make sure we're connected if not self.lan: raise ConfigurationError, "unbound node" # if the pduSource is unset, fill in our address, otherwise # leave it alone to allow for simulated spoofing if pdu.pduSource is None: pdu.pduSource = self.address elif (not self.spoofing) and (pdu.pduSource != self.address): raise RuntimeError, "spoofing address conflict" # actual network delivery is deferred deferred(self.lan.process_pdu, pdu)
def handle_read(self): if _debug: deferred(UDPDirector._debug, "handle_read") try: msg, addr = self.socket.recvfrom(65536) if _debug: deferred(UDPDirector._debug, " - received %d octets from %s", len(msg), addr) # send the PDU up to the client deferred(self._response, PDU(msg, source=addr)) except socket.timeout as err: deferred(UDPDirector._error, "handle_read socket timeout: %s", err) except socket.error as err: if err.args[0] == 11: pass else: deferred(UDPDirector._error, "handle_read socket error: %s", err)
def handle_write(self): if _debug: deferred(TCPServer._debug, "handle_write") try: sent = self.send(self.request) if _debug: deferred(TCPServer._debug, " - sent %d octets, %d remaining", sent, len(self.request) - sent) self.socketError = None self.request = self.request[sent:] except socket.error as why: if (why.args[0] == 111): deferred(TCPServer._error, "connection to %r refused", self.peer) else: deferred(TCPServer._error, "handle_write socket error: %s", why) self.socketError = why
def handle_write(self): if _debug: deferred(TCPServer._debug, "handle_write") try: sent = self.send(self.request) if _debug: deferred(TCPServer._debug, " - sent %d octets, %d remaining", sent, len(self.request) - sent) self.socketError = None self.request = self.request[sent:] except socket.error, why: if (why.args[0] == 111): deferred(TCPServer._error, "connection to %r refused", self.peer) else: deferred(TCPServer._error, "handle_write socket error: %s", why) self.socketError = why
def handle_close(self): if _debug: deferred(TCPServer._debug, "handle_close") if not self: deferred(TCPServer._warning, "handle_close: self is None") return if not self.socket: deferred(TCPServer._warning, "handle_close: socket already closed") return self.close() self.socket = None
def handle_write(self): """get a PDU from the queue and send it.""" if _debug: deferred(UDPDirector._debug, "handle_write") try: pdu = self.request.get() sent = self.socket.sendto(pdu.pduData, pdu.pduDestination) if _debug: deferred(UDPDirector._debug, " - sent %d octets to %s", sent, pdu.pduDestination) except socket.error as err: deferred(UDPDirector._error, "handle_write socket error: %s", err)
def handle_connect(self): if _debug: deferred(TCPClient._debug, "handle_connect")
def handle_connect(self): if _debug: deferred(UDPDirector._debug, "handle_connect")
def indication(self, pdu): deferred(ConsoleServer._debug, "Indication %r", pdu) try: sys.stdout.write(pdu.pduData) except Exception, e: ConsoleServer._exception("Indication sys.stdout.write exception: %r", e)
def handle_read(self): deferred(ConsoleServer._debug, "handle_read") data = sys.stdin.read() deferred(ConsoleServer._debug, " - data: %r", data) deferred(self.response, PDU(data))
def handle_read(self): deferred(ConsoleClient._debug, "handle_read") data = sys.stdin.read() deferred(ConsoleClient._debug, " - data: %r", data) deferred(self.request, PDU(data))
def handle_read(self): if _debug: deferred(TCPServer._debug, "handle_read") try: msg = self.recv(65536) if _debug: deferred(TCPServer._debug, " - received %d octets", len(msg)) self.socketError = None # no socket means it was closed if not self.socket: if _debug: deferred(TCPServer._debug, " - socket was closed") else: deferred(self.response, PDU(msg)) except socket.error, err: if (err.args[0] == 111): deferred(TCPServer._error, "connection to %r refused", self.peer) else: deferred(TCPServer._error, "handle_read socket error: %s", err) self.socketError = err
def handle_connect(self): if _debug: deferred(TCPServer._debug, "handle_connect")
class UDPDirector(asyncore.dispatcher, Server, ServiceAccessPoint, Logging): def __init__(self, address, timeout=0, reuse=False, actorClass=UDPActor, sid=None, sapID=None): if _debug: UDPDirector._debug( "__init__ %r timeout=%r reuse=%r actorClass=%r sid=%r sapID=%r", address, timeout, reuse, actorClass, sid, sapID) Server.__init__(self, sid) ServiceAccessPoint.__init__(self, sapID) # check the actor class if not issubclass(actorClass, UDPActor): raise TypeError, "actorClass must be a subclass of UDPActor" self.actorClass = actorClass # save the timeout for actors self.timeout = timeout # save the address self.address = address asyncore.dispatcher.__init__(self) # ask the dispatcher for a socket self.create_socket(socket.AF_INET, socket.SOCK_DGRAM) # if the reuse parameter is provided, set the socket option if reuse: self.set_reuse_addr() # proceed with the bind self.bind(address) if _debug: UDPDirector._debug(" - getsockname: %r", self.socket.getsockname()) # allow it to send broadcasts self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) # create the request queue self.request = Queue.Queue() # start with an empty peer pool self.peers = {} def AddActor(self, actor): """Add an actor when a new one is connected.""" if _debug: UDPDirector._debug("AddActor %r", actor) self.peers[actor.peer] = actor # tell the ASE there is a new client if self.serviceElement: self.sap_request(addPeer=actor.peer) def RemoveActor(self, actor): """Remove an actor when the socket is closed.""" if _debug: UDPDirector._debug("RemoveActor %r", actor) del self.peers[actor.peer] # tell the ASE the client has gone away if self.serviceElement: self.sap_request(delPeer=actor.peer) def GetActor(self, address): return self.peers.get(address, None) def handle_connect(self): if _debug: deferred(UDPDirector._debug, "handle_connect") def readable(self): return 1 def handle_read(self): if _debug: deferred(UDPDirector._debug, "handle_read") try: msg, addr = self.socket.recvfrom(65536) if _debug: deferred(UDPDirector._debug, " - received %d octets from %s", len(msg), addr) # send the PDU up to the client deferred(self._response, PDU(msg, source=addr)) except socket.timeout, why: deferred(UDPDirector._error, "handle_read socket timeout: %s", why) except socket.error, why: if why[0] == 11: pass else: deferred(UDPDirector._error, "handle_read socket error: %s", why)
def handle_close(self): """Remove this from the monitor when it's closed.""" if _debug: deferred(UDPDirector._debug, "handle_close") self.close() self.socket = None
def confirmation(self, pdu): deferred(ConsoleClient._debug, "confirmation %r", pdu) try: sys.stdout.write(pdu.pduData) except Exception, e: ConsoleClient._exception("Confirmation sys.stdout.write exception: %r", e)