def get_default_stream(self, name: str):
if self._mod_index is None:
raise mlerrcode.MlModuleNotFound("Unable to access module index when resolving default stream")
module = self._mod_index.get_module(name)
if not module:
raise mlerrcode.MlModuleNotFound("Module {} not found".format(name))
defaults = module.get_defaults()
if defaults:
return defaults.get_default_stream()
return module.get_all_streams()[0].get_stream_name()
def _get_repodata_streams(self) -> List[Modulemd.ModuleStreamV2]:
"""
_get_repodata_streams -- collect all repodata streams and select current default.
:return: List of stream objects
:rtype: List
"""
self._proc._streams.clear()
self._proc.index_modules()
#TODO: Optimize error data
not_found = []
for s_type in self.repodata.get_streams():
try:
if s_type.stream:
self._proc.pick_stream(s_type)
else:
self._proc.pick_default_stream(s_type=s_type)
except mlerrcode.MlModuleNotFound as e:
not_found += e.data["streams"]
if not_found:
raise mlerrcode.MlModuleNotFound("Module not found").set_data("streams", not_found)
return self._proc._streams
def resolve(self, streams):
"""
resolve - resolve dependencies for the requested streams
The algorithm traverses the dependency tree recursively using backtracking to collect multiple solutions.
:param streams: the requested streams
:return:
A list of solution-score pairs that satisfy all the dependency requirements for the requested streams
Each solution is a list of selected stream contexts for the requested streams and their dependencies.
The score indicates the number of selected default streams in the solution.
"""
self._streams = streams
# Collect all the available contexts for the requested streams
# to get an initial list of candidates at the root of the tree
contexts = []
not_found = []
for s in streams:
ctx = self._proc.get_stream_contexts(s)
if ctx:
contexts.extend(self._proc.get_stream_contexts(s))
else:
not_found.append(s.to_obj())
# Throw an error if any of the requested streams are not found
if not_found:
raise mlerrcode.MlModuleNotFound("Module not found").set_data(
"streams", not_found)
self._solutions = []
self._do_resolve([], contexts)
return self._solutions
def get_rpm_blacklist(self):
if self._mod_index is None:
raise mlerrcode.MlModuleNotFound("No module index has been found")
enabled_packages: Set = set()
for stream in self._enabled_stream_modules.values():
enabled_packages = enabled_packages.union(stream.get_rpm_artifacts())
all_packages: Set = set()
for name in self._mod_index.get_module_names():
module = self._mod_index.get_module(name)
for stream in module.get_all_streams():
all_packages = all_packages.union(stream.get_rpm_artifacts())
return list(all_packages.difference((enabled_packages)))
def get_default_stream(self, name: str):
if self._mod_index is None:
raise mlerrcode.MlGeneralException("Module index not found")
module = self._mod_index.get_module(name)
if not module:
raise mlerrcode.MlModuleNotFound(
"Module {} not found".format(name)).set_data(
"streams", [mltypes.MLStreamType(name, "").to_obj()])
defaults = module.get_defaults()
if defaults:
return defaults.get_default_stream()
return module.get_all_streams()[0].get_stream_name()
def pick_stream(self, s_type: mltypes.MLStreamType):
if s_type.name in MLLibmodProc.RESERVED_STREAMS:
# Reserved streams are always enabled
return
if self._is_stream_enabled(s_type):
enabled_stream = self._enabled_stream_modules[s_type.name]
if enabled_stream.get_stream_name() == s_type.stream:
# Stream already enabled, nothing to do
return
else:
# Another stream of the same module already enabled
conflicting = [
mltypes.MLStreamType(s_type.name, enabled_stream.get_stream_name()).to_obj(),
s_type.to_obj()
]
raise mlerrcode.MlConflictingStreams("Conflicting streams").set_data("streams", conflicting)
all_deps = set() # type: ignore
allContexts = self.get_stream_contexts(s_type=s_type)
if not allContexts:
raise mlerrcode.MlModuleNotFound("Module not found").set_data("streams", [s_type.to_obj()])
for c in allContexts:
all_deps = all_deps.union(self.get_stream_dependencies(c))
enabledDeps = []
for d in all_deps:
enabledDeps.append((d, self.get_actual_stream(d)))
for ctx in allContexts:
currDeps = self.get_dep_streams(ctx)
if all(i in enabledDeps for i in currDeps):
for dstream in currDeps:
self.pick_stream(s_type=mltypes.MLStreamType(name=dstream[0], streamname=dstream[1]))
self.enable_stream(ctx)
self._streams.append(ctx)
else:
# Return s_type
raise mlerrcode.MlDependencyResolutionError("Dependencies cannot be resolved").set_data("streams", [s_type.to_obj()])