def global_lookup_iter(self, signature, param_names=None, node_id=None):
""" Lookup the described actor type
signature is the actor/component signature
param_names is optional list argument to filter out any descriptions which does not support the params
returns a dynops iterator with all found matching descriptions
"""
if node_id is None:
sign_iter = self.node.storage.get_index_iter(
['actor', 'signature', signature]).set_name("signature")
else:
sign_iter = self.node.storage.get_index_iter(
['actor', 'signature', signature,
node_id]).set_name("signature")
actor_type_iter = dynops.Map(self.global_lookup_actor,
sign_iter,
counter=0,
eager=True)
if param_names is None:
actor_type_iter.set_name("global_lookup")
return actor_type_iter
filtered_actor_type_iter = dynops.Map(self.filter_actor_on_params,
actor_type_iter,
param_names=param_names,
eager=True)
actor_type_iter.set_name("unfiltered_global_lookup")
filtered_actor_type_iter.set_name("global_lookup")
return filtered_actor_type_iter
def req_op(node, signature, shadow_params, actor_id=None, component=None):
""" Based on signature find actors' requires in global storage,
filter actors based on params that are supplied
and find any nodes with those capabilities
"""
# Lookup signature to get a list of ids of the actor types
signature_iter = node.storage.get_index_iter(
['actor', 'signature', signature])
signature_iter.set_name("shadow_match:sign")
# Lookup description for all matching actor types
description_iter = dynops.Map(get_description,
signature_iter,
eager=True,
counter=0,
node=node)
description_iter.set_name("shadow_match:desc")
# Filter with matching parameters and return set of needed capabilities
extract_caps_iter = dynops.Map(extract_capabilities,
description_iter,
eager=True,
shadow_params=shadow_params,
capabilities=set([]),
descriptions=[])
extract_caps_iter.set_name("shadow_match:extract")
# Lookup nodes having each capability
get_caps_iter = dynops.Map(get_capability,
extract_caps_iter,
eager=True,
counter=0,
node=node)
get_caps_iter.set_name("shadow_match:caps")
# Previous returned iterable with iterables, chain them to one iterable
collect_caps_iter = dynops.Chain(get_caps_iter)
collect_caps_iter.set_name("shadow_match:collect")
# return nodes that can host first seen actor type with all capabilities fulfilled
placement_iter = dynops.Map(
placement,
collect_caps_iter,
capabilities={},
descriptions=extract_caps_iter.get_kwargs()['descriptions'])
placement_iter.set_name("shadow_match:place")
return placement_iter
def resolve_remote(self, actor_name, info, cb=None):
# FIXME: no list needed since it is only done for one actor
all_desc_iters = dynops.List()
store = GlobalStore(node=self.node)
desc_iter = store.global_lookup_iter(info['signature'],
info['args'].keys())
all_desc_iters.append((actor_name, desc_iter), trigger_iter=desc_iter)
all_desc_iters.final()
collect_desc_iter = dynops.Collect(all_desc_iters).set_name(
"collected_desc")
select_iter = dynops.Map(
self.select_actor,
collect_desc_iter,
done=False,
priority={k: []
for k in self.deployable['actors'].keys()},
eager=True).set_name("select_actor")
select_iter.set_cb(self.deploy_unhandled_actor, select_iter, cb)
self.deploy_unhandled_actor(select_iter, cb)