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 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 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_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_connect(self):
if _debug: deferred(TCPClient._debug, "handle_connect")
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 handle_read(self):
deferred(ConsoleClient._debug, "handle_read")
data = sys.stdin.read()
deferred(ConsoleClient._debug, " - data: %r", data)
deferred(self.request, PDU(data))
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)
def handle_connect(self):
if _debug: deferred(TCPServer._debug, "handle_connect")
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_read(self):
deferred(ConsoleServer._debug, "handle_read")
data = sys.stdin.read()
deferred(ConsoleServer._debug, " - data: %r", data)
deferred(self.response, PDU(data))
