def send(self, msg):
"""Send message (TCP)."""
message = networking.build_message(networking.SEND,
id=self.id,
payload=msg)
# print '[ParrotSocket %s] send: %s' % (self.id, message)
self.comm_chan.send_cmd(message, self)
def connect(self, sender, **params):
# Incoming client connection request
client_cid, server_ip, server_port = (params['id'], params['ip'], params['port'])
server_cids =self.lookup(server_ip, server_port)
if not server_cids:
print "\033[31m"
print "NO MATCHING SERVER"
print " Message: ", params
print " Network: ",
self.description()
print " Sender: ",
sender.description()
print "-------------\033[0m"
return False
# Inform the server
server_cid = server_cids[0]
server_connection_cid = str(uuid.uuid4())
server_interface = self.listeners[server_cid]['interface']
msg = networking.build_message(networking.NEW_CONN, id=server_cid, new_id=server_connection_cid)
server_interface.send(msg)
# Mapping from connection_id to interface
self.mapping[client_cid] = server_interface
self.mapping[server_connection_cid] = sender
self.connections[client_cid] = server_connection_cid
self.connections[server_connection_cid] = client_cid
return True
def accept(self, sender, **params):
# Acknowledge to other end of connection
src_cid = params['id']
dst = self.mapping[src_cid]
msg = networking.build_message(networking.ACCEPTED, id=self.connections[src_cid])
dst.send(msg)
return True
def __init__(self, node, family=AF_INET, type=SOCK_STREAM, proto=0, **kwargs):
"""
Create a ParrotSocket
node -- node for which this socket is simulated (caller)
family -- only AF_INET (default) supported
type -- either SOCK_STREAM (default) or SOCK_DGRAM
proto -- protocol number, usually zero (default)
kwargs -- internal use only, see implementation of accept()
"""
self.node = node
self._family = family
self._type = type
self._proto = proto
self.comm_chan = node.comm_chan
self.ip = "0.0.0.0"
self.port = None
self.pending_op = None
self.pending_params = None
self.queue = Queue.Queue()
self.name = kwargs.get('iface_name', 'UNASSIGNED')
new_uuid = str(uuid.uuid4())
self.id = kwargs.get('id', new_uuid)
# is_connect_event implies socket was created in response to a CONNECT
is_connect_event = (self.id != new_uuid)
# NB. While it's OK to register a serial device as ser0, ser1, etc.,
# that is NOT possible for sockets, so we use the id instead.
self.comm_chan.register_handler_for_interface(self.id, self._set_data)
if is_connect_event:
msg = networking.build_message(networking.ACCEPT, id=self.id)
self.comm_chan.send_cmd(msg, self)
def send(self, sender, **params):
# Relay to other end of connection
src_cid, payload = (params['id'], params['payload'])
dst = self.mapping[src_cid]
msg = networking.build_message(networking.RECEIVED, id=self.connections[src_cid], payload=payload)
dst.send(msg)
return True
def close(self):
"""Close the socket."""
if self.comm_chan.has_registered_handler(self.id):
# self._dump_queue()
message = networking.build_message(networking.DISCONN, id=self.id)
self.comm_chan.send_cmd(message, self)
self.comm_chan.unregister_handler_for_interface(self.id)
def sendto(self, data, address):
"""Send `data` (UDP) to an `address` which is a tuple of (ip, port)."""
if not self.port:
self._assign_port()
message = networking.build_message(networking.SENDTO, id=self.id, src_port=self.port, dst_ip=address[0], dst_port=address[1], payload=data)
# print '[ParrotSocket %s] send: %s' % (self.id, message)
self.comm_chan.send_cmd(message, self)
def close(self):
"""Close the socket."""
if self.comm_chan.has_registered_handler(self.id):
# self._dump_queue()
message = networking.build_message(networking.DISCONN, id=self.id)
self.comm_chan.send_cmd(message, self)
self.comm_chan.unregister_handler_for_interface(self.id)
def listen(self, backlog=5):
"""Listen for connections made to the socket. The `backlog` argument is currently unused."""
# FIXME: backlog
msg = networking.build_message(networking.LISTEN,
id=self.id,
ip=self.ip,
port=self.port)
self.comm_chan.send_cmd(msg, self)
def _become_active_listener(self, assign_port = True):
## Inform BP that we are listening.
if not self.port:
if not assign_port:
raise SocketException("Parrot UDP socket has no assigned port")
else:
self._assign_port()
message = networking.build_message(networking.RECVFROM, id=self.id, ip=self.ip, port=self.port)
self.comm_chan.send_cmd(message, self)
def disconnect(self, sender, **params):
src_cid = params['id']
# If source is TCP inform other end of connection that we're closing
if src_cid in self.mapping:
dst = self.mapping[src_cid]
msg = networking.build_message(networking.DISCONN, id=self.connections[src_cid])
dst.send(msg)
self.remove_from_map(src_cid)
return True
def sendto(self, data, address):
"""Send `data` (UDP) to an `address` which is a tuple of (ip, port)."""
if not self.port:
self._assign_port()
message = networking.build_message(networking.SENDTO,
id=self.id,
src_port=self.port,
dst_ip=address[0],
dst_port=address[1],
payload=data)
# print '[ParrotSocket %s] send: %s' % (self.id, message)
self.comm_chan.send_cmd(message, self)
def _become_active_listener(self, assign_port=True):
## Inform BP that we are listening.
if not self.port:
if not assign_port:
raise SocketException("Parrot UDP socket has no assigned port")
else:
self._assign_port()
message = networking.build_message(networking.RECVFROM,
id=self.id,
ip=self.ip,
port=self.port)
self.comm_chan.send_cmd(message, self)
def connect(self, address):
"""Connect to an address where `address` is a tuple of (ip, port)."""
self.name = self.interface_lookup(address[0]);
message = networking.build_message(networking.CONNECT, id=self.id, ip=address[0], port=address[1])
# print '[ParrotSocket %s] connect: %s (%s)' % (self.id, message, self.name)
self.comm_chan.send_cmd(message, self)
# Block here waiting for ACCEPT from server
message = self.queue.get()
op, params = networking.parse_message(message)
if op != networking.ACCEPTED or params['id'] != self.id:
raise SocketException("Failed in connecting")
def sendto(self, sender, **params):
# e.g. SENDTO 79c1fb86-3c97-4c19-80ae-92e9e02251c1 2137 10.1.2.2 4321 Hello over UDP
(src_cid, src_port, dest_ip, dest_port, payload) = (params['id'], params['src_port'], params['dst_ip'], params['dst_port'], params['payload'])
src_ip = sender.properties['ip']
dest_ids = self.lookup(dest_ip, dest_port)
if not dest_ids:
return True # This is UDP, no guarantees!
dst_id = dest_ids[0]
dst = self.listeners[dst_id]['interface']
msg = networking.build_message(networking.RECDFROM, id=dst_id, dst_port=dest_port, src_ip=src_ip, src_port=src_port, payload=payload)
dst.send(msg)
return True
def connect(self, address):
"""Connect to an address where `address` is a tuple of (ip, port)."""
self.name = self.interface_lookup(address[0])
message = networking.build_message(networking.CONNECT,
id=self.id,
ip=address[0],
port=address[1])
# print '[ParrotSocket %s] connect: %s (%s)' % (self.id, message, self.name)
self.comm_chan.send_cmd(message, self)
# Block here waiting for ACCEPT from server
message = self.queue.get()
op, params = networking.parse_message(message)
if op != networking.ACCEPTED or params['id'] != self.id:
raise SocketException("Failed in connecting")
def __init__(self,
node,
family=AF_INET,
type=SOCK_STREAM,
proto=0,
**kwargs):
"""
Create a ParrotSocket
node -- node for which this socket is simulated (caller)
family -- only AF_INET (default) supported
type -- either SOCK_STREAM (default) or SOCK_DGRAM
proto -- protocol number, usually zero (default)
kwargs -- internal use only, see implementation of accept()
"""
self.node = node
self._family = family
self._type = type
self._proto = proto
self.comm_chan = node.comm_chan
self.ip = "0.0.0.0"
self.port = None
self.pending_op = None
self.pending_params = None
self.queue = Queue.Queue()
self.name = kwargs.get('iface_name', 'UNASSIGNED')
new_uuid = str(uuid.uuid4())
self.id = kwargs.get('id', new_uuid)
# is_connect_event implies socket was created in response to a CONNECT
is_connect_event = (self.id != new_uuid)
# NB. While it's OK to register a serial device as ser0, ser1, etc.,
# that is NOT possible for sockets, so we use the id instead.
self.comm_chan.register_handler_for_interface(self.id, self._set_data)
if is_connect_event:
msg = networking.build_message(networking.ACCEPT, id=self.id)
self.comm_chan.send_cmd(msg, self)
def listen(self, backlog=5):
"""Listen for connections made to the socket. The `backlog` argument is currently unused."""
# FIXME: backlog
msg = networking.build_message(networking.LISTEN, id=self.id, ip=self.ip, port=self.port)
self.comm_chan.send_cmd(msg, self)
def send(self, msg):
"""Send message (TCP)."""
message = networking.build_message(networking.SEND, id=self.id, payload=msg)
# print '[ParrotSocket %s] send: %s' % (self.id, message)
self.comm_chan.send_cmd(message, self)
