public static Dictionary <GUIMod, string> ComputeConflictsFromModList(IRegistryQuerier registry, IEnumerable <ModChange> change_set, KspVersionCriteria ksp_version) { var modules_to_install = new HashSet <string>(); var modules_to_remove = new HashSet <string>(); var options = new RelationshipResolverOptions { without_toomanyprovides_kraken = true, proceed_with_inconsistencies = true, without_enforce_consistency = true, with_recommends = false }; foreach (var change in change_set) { switch (change.ChangeType) { case GUIModChangeType.None: break; case GUIModChangeType.Install: modules_to_install.Add(change.Mod.Identifier); break; case GUIModChangeType.Remove: modules_to_remove.Add(change.Mod.Identifier); break; case GUIModChangeType.Update: break; default: throw new ArgumentOutOfRangeException(); } } // Only check mods that would exist after the changes are made. IEnumerable <CkanModule> installed = registry.InstalledModules.Where( im => !modules_to_remove.Contains(im.Module.identifier) ).Select(im => im.Module); // Convert ONLY modules_to_install with CkanModule.FromIDandVersion, // because it may not find already-installed modules. IEnumerable <CkanModule> mods_to_check = installed.Union( modules_to_install.Except(modules_to_remove).Select( name => CkanModule.FromIDandVersion(registry, name, ksp_version) ) ); var resolver = new RelationshipResolver( mods_to_check, change_set.Where(ch => ch.ChangeType == GUIModChangeType.Remove) .Select(ch => ch.Mod.ToModule()), options, registry, ksp_version ); return(resolver.ConflictList.ToDictionary(item => new GUIMod(item.Key, registry, ksp_version), item => item.Value)); }
/// <summary> /// Attempts to convert the module_names to ckan modules via CkanModule.FromIDandVersion and then calls RelationshipResolver.ctor(IEnumerable{CkanModule}, Registry, KSPVersion)"/> /// </summary> /// <param name="module_names"></param> /// <param name="options"></param> /// <param name="registry"></param> /// <param name="kspversion"></param> public RelationshipResolver(IEnumerable <string> module_names, RelationshipResolverOptions options, IRegistryQuerier registry, KspVersion kspversion) : this(module_names.Select(name => CkanModule.FromIDandVersion(registry, name, kspversion)).ToList(), options, registry, kspversion) { // Does nothing, just calls the other overloaded constructor }
public RelationshipResolver(ICollection <string> moduleNames, RelationshipResolverOptions options, Registry registry, KSPVersion kspversion) : this(moduleNames.Select(name => CkanModule.FromIDandVersion(registry, name, kspversion)).ToList(), options, registry, kspversion) { // Does nothing, just calles the other overloaded constructor }
/// <summary> /// Creates a new resolver that will find a way to install all the modules specified. /// </summary> public RelationshipResolver(ICollection <string> modules, RelationshipResolverOptions options, Registry registry, KSPVersion kspversion) { this.registry = registry; this.kspversion = kspversion; // Start by figuring out what versions we're installing, and then // adding them to the list. This *must* be pre-populated with all // user-specified modules, as they may be supplying things that provide // virtual packages. var user_requested_mods = new List <CkanModule>(); log.DebugFormat("Processing relationships for {0} modules", modules.Count); foreach (string module in modules) { // Throws ModuleNotFoundKraken if it can't be found CkanModule mod = CkanModule.FromIDandVersion(registry, module, kspversion); log.DebugFormat("Preparing to resolve relationships for {0} {1}", mod.identifier, mod.version); foreach (CkanModule listed_mod in modlist.Values.Where(listed_mod => listed_mod.ConflictsWith(mod))) { throw new InconsistentKraken(string.Format("{0} conflicts with {1}, can't install both.", mod, listed_mod)); } user_requested_mods.Add(mod); Add(mod); } // Now that we've already pre-populated modlist, we can resolve // the rest of our dependencies. foreach (CkanModule module in user_requested_mods) { log.InfoFormat("Resolving relationships for {0}", module.identifier); Resolve(module, options); } var final_modules = new List <Module>(modlist.Values); final_modules.AddRange(registry.InstalledModules.Select(x => x.Module)); if (!options.without_enforce_consistency) { // Finally, let's do a sanity check that our solution is actually sane. SanityChecker.EnforceConsistency( final_modules, registry.InstalledDlls ); } }
/// <summary> /// Translate mods from identifiers in its default or identifier=version format into CkanModules, /// optionally falling back to incompatible modules if no compatibles could be found. /// </summary> /// <param name="name">The identifier or identifier=version of the module</param> /// <param name="options">If options.allow_incompatible is set, fall back to searching incompatible modules if no compatible has been found</param> /// <param name="registry">CKAN registry object for current game instance</param> /// <param name="GameVersion">The current KSP version criteria to consider</param> /// <returns>A CkanModule</returns> private static CkanModule TranslateModule(string name, RelationshipResolverOptions options, IRegistryQuerier registry, GameVersionCriteria GameVersion) { if (options.allow_incompatible) { try { return(CkanModule.FromIDandVersion(registry, name, GameVersion)); } catch (ModuleNotFoundKraken) { // No versions found matching our game version, so // look for incompatible versions. return(CkanModule.FromIDandVersion(registry, name, null)); } } else { return(CkanModule.FromIDandVersion(registry, name, GameVersion)); } }