def get_existing(self, port_id, callback=None, **kwargs):
_log.analyze(self.node.id, "+", {'port_id': port_id})
port_meta = PortMeta(self.node.pm, port_id=port_id)
if not port_meta.is_local():
status = response.CalvinResponse(response.NOT_FOUND, "Port %s must be local" % (port_id))
if callback:
callback(status=status, port_id=port_id)
return
else:
raise response.CalvinResponseException(status)
_log.analyze(self.node.id, "+ LOCAL CHECKED", {'port_id': port_id})
port = port_meta.port
# Now check the peer port, peer_ids is list of (peer_node_id, peer_port_id) tuples
peer_ids = port.get_peers()
_log.analyze(self.node.id, "+ GOT PEERS", {'port_id': port_id, 'peer_ids': peer_ids})
# A port may have several peers, create individual connection instances
connections = []
for peer_id in peer_ids:
# When node id is 'local' it is local
peer_node_id = self.node.id if peer_id[0] == 'local' else peer_id[0]
peer_port_meta = PortMeta(
self.node.pm,
port_id=peer_id[1], node_id=peer_node_id)
connections.append(self.get(port, peer_port_meta, callback, **kwargs))
# Make a connection instance aware of all parallel connection instances
for connection in connections:
connection.parallel_connections(connections)
return connections
def connection_request(self, payload):
""" A request from a peer to connect a port"""
_log.analyze(self.node.id, "+", payload, peer_node_id=payload['from_rt_uuid'])
if not ('peer_port_id' in payload or
('peer_actor_id' in payload and
'peer_port_name' in payload and
'peer_port_properties' in payload)):
# Not enough info to find port
_log.analyze(self.node.id, "+ NOT ENOUGH DATA", payload, peer_node_id=payload['from_rt_uuid'])
return response.CalvinResponse(response.BAD_REQUEST)
our_port_meta = PortMeta(self,
actor_id=payload['peer_actor_id'],
port_id=payload['peer_port_id'],
port_name=payload['peer_port_name'],
properties=payload['peer_port_properties'],
node_id=self.node.id)
try:
port = our_port_meta.port
except:
# We don't have the port
_log.analyze(self.node.id, "+ PORT NOT FOUND", payload, peer_node_id=payload['from_rt_uuid'])
return response.CalvinResponse(response.NOT_FOUND)
else:
# Let a specific connection handler take care of the request
peer_port_meta = PortMeta(self,
port_id=payload['port_id'],
node_id=payload['from_rt_uuid'],
properties=payload['port_properties'])
return ConnectionFactory(self.node, PURPOSE.CONNECT).get(
port, peer_port_meta, payload=payload).connection_request()
def disconnection_request(self, payload):
""" A request from a peer to disconnect a port"""
if not ('peer_port_id' in payload or
('peer_actor_id' in payload and
'peer_port_name' in payload and
'peer_port_dir' in payload)):
# Not enough info to find port
return response.CalvinResponse(response.BAD_REQUEST)
# Check if port actually is local
local_port_meta = PortMeta(
self,
actor_id=payload['peer_actor_id'] if 'peer_actor_id' in payload else None,
port_id=payload['peer_port_id'] if 'peer_port_id' in payload else None,
port_name=payload['peer_port_name'] if 'peer_port_name' in payload else None,
properties={'direction': payload['peer_port_dir'] if 'peer_port_dir' in payload else None},
node_id=self.node.id)
peer_port_meta = PortMeta(self, port_id=payload['port_id'], node_id=payload['from_rt_uuid'])
_log.analyze(self.node.id, "+", {'local': local_port_meta, 'peer': peer_port_meta},
peer_node_id=payload['from_rt_uuid'], tb=True)
try:
port = local_port_meta.port
except response.CalvinResponseException as e:
# We don't have the port
return response.CalvinResponse(response.NOT_FOUND)
else:
# Disconnect and destroy endpoints
return ConnectionFactory(self.node, PURPOSE.DISCONNECT).get(
local_port_meta.port, peer_port_meta, payload=payload
).disconnection_request(payload.get('terminate', False), payload.get('remaining_tokens', {}))
def _port_connected_remote(self, status, actor_id, port_id, peer_port_id, peer_node_id):
_log.debug("Port remote connected %s %s %s %s %s" % (actor_id, port_id, peer_port_id, peer_node_id, str(status)))
if not status:
# Failed request for connecting, likely the actor having the peer port has migrated.
# Find it and try again.
peer_port_meta = PortMeta(self, port_id=peer_port_id)
try:
peer_port_meta.retrieve(callback=CalvinCB(self._found_peer_node, actor_id=actor_id, port_id=port_id, peer_port_id=peer_port_id))
except calvinresponse.CalvinResponseException as e:
_log.exception("Failed retrieving peer port meta info %s" % str(e))
return
def connect(self, callback=None, actor_id=None, port_name=None, port_properties=None, port_id=None,
peer_node_id=None, peer_actor_id=None, peer_port_name=None, peer_port_properties=None,
peer_port_id=None):
""" Obtain any missing information to enable making a connection and make actual connect
callback: an optional callback that gets called with status when finished
local port identified by:
actor_id, port_name and port_dir='in'/'out' or
port_id
peer_node_id: an optional node id the peer port is locate on, will use storage to find it if not supplied
peer port (remote or local) identified by:
peer_actor_id, peer_port_name and peer_port_dir='in'/'out' or
peer_port_id
"""
local_port_meta = PortMeta(self, actor_id=actor_id, port_id=port_id, port_name=port_name,
properties=port_properties, node_id=self.node.id)
peer_port_meta = PortMeta(self, actor_id=peer_actor_id, port_id=peer_port_id, port_name=peer_port_name,
properties=peer_port_properties, node_id=peer_node_id)
_log.analyze(self.node.id, "+", {'local': local_port_meta, 'peer': peer_port_meta},
peer_node_id=peer_node_id, tb=True)
try:
port = local_port_meta.port
except response.CalvinResponseException as e:
if callback:
callback(status=e.response,
actor_id=actor_id,
port_name=port_name,
port_id=port_id,
peer_node_id=peer_node_id,
peer_actor_id=peer_actor_id,
peer_port_name=peer_port_name,
peer_port_id=peer_port_id)
return
else:
raise e.response
# Retrieve node id etc, raise exception if not possible, continue in _connect otherwise
try:
peer_port_meta.retrieve(callback=CalvinCB(self._connect, local_port=port, callback=callback))
except response.CalvinResponseException as e:
if callback:
callback(status=e.response,
actor_id=actor_id,
port_name=port_name,
port_id=port_id,
peer_node_id=peer_node_id,
peer_actor_id=peer_actor_id,
peer_port_name=peer_port_name,
peer_port_id=peer_port_id)
return
else:
raise e.response
