Exemplo n.º 1
0
 private bool allDependenciesCompatible(CkanModule mod, KspVersionCriteria ksp_version)
 {
     // we need to check that we can get everything we depend on
     if (mod.depends != null)
     {
         foreach (RelationshipDescriptor dependency in mod.depends)
         {
             try
             {
                 if (!dependency.MatchesAny(null, InstalledDlls.ToHashSet(), InstalledDlc) &&
                     !LatestAvailableWithProvides(dependency.name, ksp_version).Any())
                 {
                     return(false);
                 }
             }
             catch (KeyNotFoundException e)
             {
                 log.ErrorFormat("Cannot find available version with provides for {0} in registry", dependency.name);
                 throw e;
             }
             catch (ModuleNotFoundKraken)
             {
                 return(false);
             }
         }
     }
     return(true);
 }
Exemplo n.º 2
0
 /// <summary>
 /// Partition all CkanModules in available_modules into
 /// compatible and incompatible groups.
 /// </summary>
 /// <param name="versCrit">Version criteria to determine compatibility</param>
 public void SetCompatibleVersion(KspVersionCriteria versCrit)
 {
     if (!versCrit.Equals(sorter?.CompatibleVersions))
     {
         sorter = new CompatibilitySorter(
             versCrit, available_modules, providers,
             InstalledDlls.ToHashSet(), _installedDlcModules
             );
     }
 }
Exemplo n.º 3
0
        private async Task HandleManagedDlls(PackageIdentity packageIdentity, List <ZipArchiveEntry> zipArchiveEntries)
        {
            var entriesWithTargetFramework = zipArchiveEntries
                                             .Select(e => new { TargetFramework = NuGetFramework.Parse(e.FullName.Split('/')[1]), Entry = e }).ToList();

            if (_filterOurRefFiles)
            {
                entriesWithTargetFramework = entriesWithTargetFramework.Where(e => !string.Equals(e.Entry.FullName.Split('/')[0], "ref")).ToList();
            }

            var compatibleEntries       = entriesWithTargetFramework.Where(e => _compProvider.IsCompatible(_targetFramework, e.TargetFramework)).ToList();
            var mostCompatibleFramework = _reducer.GetNearest(_targetFramework, compatibleEntries.Select(x => x.TargetFramework));

            if (mostCompatibleFramework == null)
            {
                return;
            }

            var matchingEntries = entriesWithTargetFramework
                                  .Where(e => e.TargetFramework == mostCompatibleFramework).ToList();

            if (matchingEntries.Any())
            {
                var pluginAssemblies = new List <string>();

                foreach (var e in matchingEntries)
                {
                    ZipFileExtensions.ExtractToFile(e.Entry, Path.Combine(_root, e.Entry.Name), overwrite: true);

                    var installedDllInfo = new DllInfo
                    {
                        RelativeFilePath         = Path.Combine(packageIdentity.ToString(), e.Entry.FullName),
                        FullFilePath             = Path.Combine(_root, packageIdentity.ToString(), e.Entry.FullName),
                        FileName                 = e.Entry.Name,
                        TargetFrameworkName      = e.TargetFramework.ToString(),
                        TargetFrameworkShortName = e.TargetFramework.GetShortFolderName(),
                        PackageIdentity          = packageIdentity.Id,
                        TargetVersion            = e.TargetFramework.Version.ToString()
                    };

                    InstalledDlls.Add(installedDllInfo);

                    if (packageIdentity.Id == _pluginNuGetPackage.Identity.Id)
                    {
                        pluginAssemblies.Add(e.Entry.Name);
                    }
                }

                await File.WriteAllLinesAsync(Path.Combine(_root, PluginAssemblyFilesFileName), pluginAssemblies);
            }
        }