def get_component_set_from(config, components_lists):
"""
Use the Guesser API to fetch the components set from the given
components_lists
"""
all_set = set()
module_name = config.get(DEPMAKE_ACTION_NAME, GUESSER_MODULE_NAME)
_LOGGER.debug("Guesser module name: %s" , module_name)
module = __import__(to_str_from_unicode(module_name, should_be_uni=True))
# Go through sys.modules to find modules inside packages
module = sys.modules[module_name]
params = config.get(DEPMAKE_ACTION_NAME, GUESSER_PARAMS_NAME)
params = replace_if_none(params)
_LOGGER.debug("Guesser parameters: %s", params)
params = to_str_from_unicode(params)
guesser = module.get_guesser(params)
_LOGGER.info("Using guesser: %s", guesser)
for cl in components_lists:
cl = to_str_from_unicode(cl, 'utf-8', True)
(components_for, unknown) = guesser.guess_type(cl)
if len(unknown) != 0:
_LOGGER.warning("%s: [Unknown components]", unknown)
for table in components_for:
for type_ in components_for[table]:
components = NodeSet(components_for[table][type_])
for component in components:
comp2 = to_unicode(component)
all_set.add(Component(comp2, type_, table))
return all_set
def test_to_str_from_unicode(self):
uni = u"mmąöî"
nonascii = lib.to_str_from_unicode(uni, should_be_uni=True)
assert type(uni) == unicode
assert len(uni) == 5
assert type(nonascii) == str
assert len(nonascii) != 5
assert nonascii == "mmąöî"
def makedepgraph(config, rules, components_lists, options):
"""
Return the dependency graph for the given pair ('req_ruleset',
'components_lists').
"""
ruleset = RuleSet(rules.values())
all_set = get_component_set_from(config, components_lists)
force_opt = options.force
force_rule = force_opt.split(',') if force_opt is not None else []
docache = True if getattr(options, 'docache', 'yes') == 'yes' else False
_LOGGER.debug("Caching filter results (docache) is: %s", docache)
depgraph = ruleset.get_depgraph(all_set, force_rule, docache)
if _LOGGER.isEnabledFor(logging.DEBUG):
_LOGGER.debug("Components set: %s",
NodeSet.fromlist([to_str_from_unicode(x.id) for x in all_set]))
_LOGGER.debug("Remaining: %s",
NodeSet.fromlist([str(x) for x in depgraph.remaining_components]))
_LOGGER.debug("List: %s",
NodeSet.fromlist([str(x) for x in depgraph.components_map]))
return depgraph
def _update_hash(checksum, rule):
"""
Update the given checksum with all required fields of the given rule.
"""
checksum.update(to_str_from_unicode(rule.ruleset, should_be_uni=True))
checksum.update(to_str_from_unicode(rule.name, should_be_uni=True))
for type_ in rule.types:
checksum.update(to_str_from_unicode(type_, should_be_uni=True))
# Do not take filter into account
# ruleset_h.update(str(rule.filter))
checksum.update(to_str_from_unicode(replace_if_none_by_uni(rule.action), \
should_be_uni=True))
checksum.update(to_str_from_unicode(replace_if_none_by_uni(rule.depsfinder), \
should_be_uni=True))
checksum.update(to_str_from_unicode(replace_if_none_by_uni(rule.help), \
should_be_uni=True))
for dep in rule.dependson:
checksum.update(to_str_from_unicode(replace_if_none_by_uni(dep), \
should_be_uni=True))
def _filter_impl(self, component):
var_map = _get_var_map(component.id,
component.name,
component.type,
component.category,
self.rule.ruleset,
self.rule.name,
self.rule.help)
cmd_string = substitute(var_map, self.rule.filter)
cmd = shlex.split(to_str_from_unicode(cmd_string, should_be_uni=True))
_LOGGER.debug("%s: calling filter cmd: %s", self.rule.name, cmd)
try:
popen = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
bufsize=-1) # Use system default
except OSError as ose:
_LOGGER.error("%s: can't call filter '%s': %s",
self.rule.name, cmd_string, ose)
return False
(msg_std, msg_err) = popen.communicate()
msg_std = msg_std.strip()
msg_err = msg_err.strip()
_LOGGER.debug("%s: output of filter command %s on component %s: %s",
self.rule.name, cmd_string, component, msg_std)
if len(msg_err) != 0:
_LOGGER.warning("%s: error when applying filter command " + \
"%s to component %s: %s",
self.rule.name, cmd_string,
component, msg_err)
_LOGGER.debug("%s: filter command: %s RC: %d",
self.rule.name,
cmd_string,
popen.returncode)
return popen.returncode == os.EX_OK
def _get_deps(self, component, rule):
"""
Find dependencies of a given component. This implies calling
the rule.depsfinder script. Substitution of variables is done.
Returns None if the given rule has already been applied on
the given component.
"""
result = dict()
depsfinder = rule.depsfinder
if rule.dependson is None or len(rule.dependson) == 0 or \
depsfinder is None or len(depsfinder) == 0:
_LOGGER.debug("No 'DepsFinder' or 'DependsOn' specified" + \
" in rule %s for component %s. Skipping.",
rule, component)
return result
var_map = _get_var_map(component.id,
component.name,
component.type,
component.category,
self.ruleset.name,
rule.name,
rule.help)
cmd = substitute(var_map, depsfinder)
_LOGGER.debug("Calling depsfinder for component %s: %s", component, cmd)
popen_args = shlex.split(to_str_from_unicode(cmd, should_be_uni=True))
try:
popen = subprocess.Popen(popen_args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
bufsize=-1) # Use system default
except OSError as ose:
_LOGGER.error("Can't call depsfinder '%s': %s", cmd, ose)
return result
(msg_std, msg_err) = popen.communicate()
msg_std = msg_std.strip()
msg_err = msg_err.strip()
if len(msg_err) != 0:
_LOGGER.warning("Depsfinder error when " + \
"applying rule %s to component %s: %s",
rule, component, msg_err)
deps = set()
with StringIO(to_unicode(msg_std)) as reader:
for dep in reader:
dep_id = dep.strip()
if len(dep_id) == 0:
continue
dependency = self.components_map.get(dep_id)
if dependency is None:
_LOGGER.debug("Creating dep for component %s with id: %r",
component, dep_id)
dependency = Component(dep_id)
self.components_map[dep_id] = dependency
deps.add(dependency)
_update_graph_with_node(self.dag, dep_id)
if _LOGGER.isEnabledFor(INFO):
_LOGGER.info("%s.depsfinder(%s): %s",
rule.name, component.id,
NodeSet.fromlist([str(x.id) for x in deps]))
# Find match only on rule.dependson
return _find_match([self.ruleset.rules_for[x] for x in rule.dependson],
deps)