def __new__(cls, agent_url, class_name, **kwargs_ontology):
entity_id = lib_util.KWArgsToEntityId(class_name, **kwargs_ontology)
if agent_url:
host_agent = agent_to_host(agent_url)
instance_key = host_agent + "+++" + entity_id
else:
instance_key = "NO_AGENT" + "+++" + entity_id
# TODO: The key to this class instance must include the host associated to the agent.
try:
cache_instance = cls.m_instances_cache[instance_key]
return cache_instance
except KeyError:
new_instance = super(BaseCIMClass, cls).__new__(cls)
cls.m_instances_cache[instance_key] = new_instance
return new_instance
def create_CIM_class(agentUrl,className,**kwargsOntology):
global CacheCIMClasses
entity_id = lib_util.KWArgsToEntityId(className,**kwargsOntology)
# No need to use the class in the key, because the cache is class-specific.
DEBUG("create_CIM_class agentUrl=%s className=%s entity_id=%s",agentUrl,className,entity_id)
try:
newCIMClass = CacheCIMClasses[className]
#DEBUG("Found existing className=%s",className)
except KeyError:
# This class is not yet created.
# TODO: If entity_label contains slashes, submodules must be imported.
newCIMClass = CIM_class_factory_no_cache(className)
CacheCIMClasses[className] = newCIMClass
# Now, it creates a new instance and stores it in the cache of the CIM class.
newInstance = newCIMClass(agentUrl, className, **kwargsOntology)
return newInstance
def __new__(cls, agentUrl, className, **kwargsOntology):
entity_id = lib_util.KWArgsToEntityId(className, **kwargsOntology)
if agentUrl:
hostAgent = agent_to_host(agentUrl)
instanceKey = hostAgent + "+++" + entity_id
else:
instanceKey = "NO_AGENT" + "+++" + entity_id
# TODO: The key to this class instance must include the host associated to the agent.
try:
cacheInstance = cls.m_instances_cache[instanceKey]
DEBUG("BaseCIMClass.__new__ %s is IN the cache instanceKey=",instanceKey)
return cacheInstance
except KeyError:
DEBUG("BaseCIMClass.__new__ %s is NOT in the cache instanceKey=",instanceKey)
# newInstance = super(ClassA, cls).__new__(cls, agentUrl, **kwargsOntology)
#DEBUG("cls=%s kwargs=%s",cls.__name__,str(kwargs))
newInstance = super(BaseCIMClass, cls).__new__(cls)
cls.m_instances_cache[instanceKey] = newInstance
return newInstance
def Derived__init__(self, agent_url, class_name, **kwargs_ontology):
"""This function will be used as a constructor for the new class."""
for key, value in kwargs_ontology.items():
setattr(self, key, value)
entity_id = lib_util.KWArgsToEntityId(class_name, **kwargs_ontology)
BaseCIMClass.__init__(self, agent_url, entity_id, kwargs_ontology)
def CallbackSelect(self, grph, class_name, predicate_prefix,
filtered_where_key_values):
DEBUG(
"SurvolCallbackSelect class_name=%s predicate_prefix=%s where_key_values=%s",
class_name, predicate_prefix, str(filtered_where_key_values))
# Maybe there is a script: predicate_prefix="survol:CIM_DataFile/mapping_processes"
prefix, colon, script_nickname = predicate_prefix.partition(":")
DEBUG("SurvolCallbackSelect script_nickname=%s", script_nickname)
if script_nickname:
# For example: script_nickname="CIM_DataFile/mapping_processes"
# Wildcards or directories are not accepted yet.
script_name = "sources_types/" + script_nickname + ".py"
DEBUG(
"SurvolCallbackSelect script_name=%s filtered_where_key_values=%s",
script_name, str(filtered_where_key_values))
# TODO: Check that there are enough parameters for this script ?
my_source = lib_client.SourceLocal(script_name, class_name,
**filtered_where_key_values)
DEBUG("SurvolCallbackSelect my_source=%s", my_source)
my_triplestore = my_source.get_triplestore()
# This is returned anyway, as a triplestore that rdflib Sparql can work on.
my_triplestore.copy_to_graph(grph)
list_instances = my_triplestore.get_instances()
# TODO: We filter only the objects of the right type,
# TODO: ... but we lose all the other objects which could be stored in the output triplestore !!...
DEBUG("SurvolCallbackSelect tp=%s class_name=%s",
type(list_instances), class_name)
DEBUG("SurvolCallbackSelect list_instances=%s",
str(list_instances))
for one_instance in list_instances:
WARNING(
"SurvolCallbackSelect one_instance.__class__.__name__=%s",
one_instance.__class__.__name__)
if one_instance.__class__.__name__ == class_name:
# 'CIM_DataFile.Name=/usr/lib/systemd/systemd-journald'
instance_url = one_instance.__class__.__name__ + "." + one_instance.m_entity_id
one_instance.m_key_value_pairs[
lib_kbase.
PredicateIsDefinedBy] = lib_common.NodeLiteral(
predicate_prefix)
# Add it again, so the original Sparql query will work.
one_instance.m_key_value_pairs[
lib_kbase.PredicateSeeAlso] = lib_common.NodeLiteral(
predicate_prefix)
DEBUG("SurvolCallbackSelect instance_url=%s", instance_url)
yield (instance_url, one_instance.m_key_value_pairs)
else:
entity_module = lib_util.GetEntityModule(class_name)
if not entity_module:
raise Exception(
"SurvolCallbackSelect: No module for class:%s" %
class_name)
try:
enumerate_function = entity_module.SelectFromWhere
except AttributeError:
exc = sys.exc_info()[1]
WARNING("No Enumerate for %s:%s", class_name, str(exc))
return
iter_enumeration = enumerate_function(filtered_where_key_values)
# for one_key_value_dict in iter_enumeration:
for one_key_value_dict_nodes in iter_enumeration:
class_ontology = lib_util.OntologyClassKeys(class_name)
ontology_key_values = {}
for key_node, value_node in one_key_value_dict_nodes.items():
key_str = lib_properties.PropToQName(key_node)
if key_str in class_ontology:
ontology_key_values[key_str] = str(value_node)
# This reorders the attributes if needed.
key_value_path = lib_util.KWArgsToEntityId(
class_name, **ontology_key_values)
# key_value_path = ".".join( '%s="%s"' % ( lib_properties.PropToQName(key), str(value) ) for key, value in one_key_value_dict_nodes.items() )
object_path = "SurvolLocalHost:" + class_name + "." + key_value_path
one_key_value_dict_nodes[
lib_kbase.PredicateIsDefinedBy] = lib_common.NodeLiteral(
predicate_prefix)
# Add it again, so the original Sparql query will work.
one_key_value_dict_nodes[
lib_kbase.PredicateSeeAlso] = lib_common.NodeLiteral(
predicate_prefix)
yield (object_path, one_key_value_dict_nodes)