public static void LogPackages(this IPackagingDiagnostics diagnostics, IPackageLoader loader, IEnumerable <IPackageInfo> packages) { packages.Each(p => { diagnostics.LogPackage(p, loader); }); }
/// <summary> /// Copies configuration from poco <paramref name="src"/> to <paramref name="dst"/>. /// /// Since packageloaders are type names in the poco, any new type will be loaded and instantiated. /// </summary> /// <param name="src"></param> /// <param name="dst"></param> public static void Assign(PackageFileProviderOptionsRecord src, IPackageFileProviderOptions dst) { dst.AllowOpenFiles = src.AllowOpenFiles; dst.ReuseFailedResult = src.ReuseFailedResult; dst.MaxMemorySnapshotLength = src.MaxMemorySnapshotLength; dst.MaxTempSnapshotLength = src.MaxTempSnapshotLength; // Update packageloaders. // Make list of new types List <Type> newPackageLoaders = (src.PackageLoaders ?? new string[0]).Select(typeName => Type.GetType(typeName, true)).ToList(); // Make list of old types Dictionary <Type, IPackageLoader> oldPackageLoaders = (dst.PackageLoaders ?? new IPackageLoader[0]).ToDictionary(pl => pl.GetType()); // Make new array IPackageLoader[] newArray = new IPackageLoader[newPackageLoaders.Count]; for (int i = 0; i < newArray.Length; i++) { Type type = newPackageLoaders[i]; IPackageLoader pl; if (!oldPackageLoaders.TryGetValue(type, out pl)) { pl = (IPackageLoader)Activator.CreateInstance(type); } newArray[i] = pl; } // A new reference must always be created to trigger reload as per contract. dst.PackageLoaders = newArray; }
public InterceptingKnownPackageLoader(KnownPackages packages, IPackageLoader other, UnknownPackages unknownPackages, ILogger <InterceptingKnownPackageLoader> logger) { _packages = packages ?? throw new ArgumentNullException(nameof(packages)); _other = other ?? throw new ArgumentNullException(nameof(other)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _unknownPackages = unknownPackages ?? throw new ArgumentNullException(nameof(unknownPackages)); }
public PackageInstaller(string packagePath, string packageDataDirectory, string basePath, IPackageInfo package, IPackageLoader loader) { this.packagePath = packagePath; this.packageDataDirectory = packageDataDirectory; this.basePath = basePath; this.package = package; this.loader = loader; packageZip = new ZipFile(packagePath); }
public TargetCompatibilityReferenceAnalyzer( IPackageLoader packageLoader, IVersionComparer comparer, ILogger <TargetCompatibilityReferenceAnalyzer> logger) { _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public WindowsCompatReferenceAnalyzer( IPackageLoader loader, IVersionComparer comparer, ILogger <WindowsCompatReferenceAnalyzer> logger) { _logger = logger; _loader = loader; _comparer = comparer; }
public DownloadsViewModelProvider(IPackageLoader packageLoader, IOptions <AccessOptions> accessOptions, IOptions <PackageOptions> packageOptions, ILogger <DownloadsViewModelProvider> logger) { _packageLoader = packageLoader; _accessOptions = accessOptions; _packageOptions = packageOptions; _logger = logger; }
public UpgradeAssistantReferenceAnalyzer(IOptions <PackageUpdaterOptions> updaterOptions, IPackageLoader packageLoader, ILogger <UpgradeAssistantReferenceAnalyzer> logger) { if (updaterOptions is null) { throw new ArgumentNullException(nameof(updaterOptions)); } _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public PackageMapReferenceAnalyzer( PackageMapProvider packageMapProvider, IPackageLoader packageLoader, IVersionComparer comparer, ILogger <PackageMapReferenceAnalyzer> logger) { _packageMapProvider = packageMapProvider ?? throw new ArgumentNullException(nameof(packageMapProvider)); _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public NewtonsoftReferenceAnalyzer( IPackageLoader packageLoader, ITargetFrameworkMonikerComparer tfmComparer, ITransitiveDependencyIdentifier transitiveIdentifier, ILogger <NewtonsoftReferenceAnalyzer> logger) { _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _tfmComparer = tfmComparer ?? throw new ArgumentNullException(nameof(tfmComparer)); _transitiveIdentifier = transitiveIdentifier ?? throw new ArgumentNullException(nameof(transitiveIdentifier)); }
public ToolsFactory(IPackageLoader packageLoader, IAlignedVersionsDownloader downloader, IFrameworkList frameworkList, ILogger <ToolsFactory> log) { _packageLoader = packageLoader; _downloader = downloader; _frameworkList = frameworkList; _nuGetLog = new MicrosoftLogger(log); _releases = new Lazy <Task <Dictionary <NuGetVersion, NuGetRelease> > >(async() => { using (var sourceCacheContext = new SourceCacheContext()) { var versions2x = await _downloader.GetDownloadedVersionsAsync( PackageIds2x, sourceCacheContext, _nuGetLog, CancellationToken.None); var pairs2x = versions2x .Select(x => new KeyValuePair <NuGetVersion, NuGetRelease>(x, NuGetRelease.Version2x)); var versions3x = await _downloader.GetDownloadedVersionsAsync( PackageIds3x, sourceCacheContext, _nuGetLog, CancellationToken.None); var pairs3x = versions3x .Select(x => new KeyValuePair <NuGetVersion, NuGetRelease>(x, NuGetRelease.Version3x)); return(pairs2x .Concat(pairs3x) .ToDictionary(x => x.Key, x => x.Value)); } }); _versions = new Lazy <Task <Dictionary <string, NuGetVersion> > >(async() => { var releases = await _releases.Value; return(releases .ToDictionary( x => x.Key.ToNormalizedString(), x => x.Key, StringComparer.OrdinalIgnoreCase)); }); _versionStrings = new Lazy <Task <List <string> > >(async() => { var versions = await _versions.Value; return(versions .OrderByDescending(x => x.Value) .Select(x => x.Key) .ToList()); }); }
public WindowsCompatReferenceAnalyzer( ITransitiveDependencyIdentifier transitiveIdentifier, IPackageLoader loader, IVersionComparer comparer, ILogger <WindowsCompatReferenceAnalyzer> logger) { _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _transitiveIdentifier = transitiveIdentifier ?? throw new ArgumentNullException(nameof(transitiveIdentifier)); _loader = loader ?? throw new ArgumentNullException(nameof(loader)); _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); }
public PackageMapReferenceAnalyzer( IOptions <ICollection <NuGetPackageMap[]> > packageMaps, IPackageLoader packageLoader, IVersionComparer comparer, ILogger <PackageMapReferenceAnalyzer> logger) { if (packageMaps is null) { throw new ArgumentNullException(nameof(packageMaps)); } _packageMaps = packageMaps.Value.SelectMany(p => p); _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public NuGetPackageLookup( IPackageLoader packages, IOptions <ICollection <LooseDependencyOptions> > options, ILogger <NuGetPackageLookup> logger) { _packages = packages; _logger = logger; _indexes = new Lazy <List <NuGetPackageLookupIndex> >(() => { var list = new List <NuGetPackageLookupIndex>(); foreach (var option in options.Value) { foreach (var path in option.Indexes) { try { var file = option.Files.GetFileInfo(path); if (!file.Exists) { logger.LogWarning("Could not find index file at {Path}", path); } else if (file.PhysicalPath is not null) { logger.LogDebug("Loading index file from {Path}", file.PhysicalPath); list.Add(new NuGetPackageLookupIndex(file.PhysicalPath)); } else { logger.LogDebug("Loading index file from {Path}", path); logger.LogWarning("Currently only physical paths are supported. Copying to a temporary path...."); list.Add(new TemporaryFileNuGetPackageLookupIndex(file)); logger.LogDebug("Done creating temporary copy"); } } catch (Exception e) { logger.LogError(e, "Could not load loose assembly index {Path}", path); throw; } } } return(list); }); }
public void LogPackage(IPackageInfo package, IPackageLoader loader) { }
/// <summary> /// Can open file. /// </summary> /// <param name="packageLoader"></param> public static bool CanOpenFile(this IPackageLoader packageLoader) => packageLoader is IPackageLoaderOpenFile pl ? pl.CanOpenFile : false;
public void Loader(IPackageLoader loader) { configurableActions = g => g.AddLoader(loader); }
public WindowsCompatReferenceAnalyzer(ILogger <WindowsCompatReferenceAnalyzer> logger, IPackageLoader loader) { _logger = logger; _loader = loader; }
public ModulesCatalog(IModulesDirectory modulesDirectory, IApplicationInfo applicationInfo, IPackageLoader packageLoader) { _modulesDirectory = modulesDirectory; _applicationInfo = applicationInfo; _packageLoader = packageLoader; }
public WinUIReferenceAnalyzer(IPackageLoader packageLoader, ILogger <WinUIReferenceAnalyzer> logger) { this._packageLoader = packageLoader; this._logger = logger; }
public NewtonsoftReferenceAnalyzer(IPackageLoader packageLoader, ILogger <NewtonsoftReferenceAnalyzer> logger) { _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// Add package loader. /// </summary> /// <param name="options"></param> /// <param name="loader"></param> /// <returns></returns> public static IPackageFileProviderOptions AddPackageLoader(this IPackageFileProviderOptions options, IPackageLoader loader) => options.SetPackageLoaders(options.PackageLoaders.Concat(Enumerable.Repeat(loader, 1).ToArray()));
public void Loader(IPackageLoader loader) { configure = g => g.AddLoader(loader); }
public MyDotAnalyzer(IPackageLoader packageLoader, ILogger <MyDotAnalyzer> logger) { _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public MyDotAnalyzer(ITransitiveDependencyIdentifier transitiveIdentifier, IPackageLoader packageLoader, ILogger <MyDotAnalyzer> logger) { _transitiveIdentifier = transitiveIdentifier ?? throw new ArgumentNullException(nameof(transitiveIdentifier)); _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public void LogPackage(IPackageInfo package, IPackageLoader loader) { throw new NotImplementedException(); }
public TargetCompatibilityReferenceAnalyzer(IPackageLoader packageLoader, ITargetTFMSelector tfmSelector, ILogger <TargetCompatibilityReferenceAnalyzer> logger) { _packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader)); _tfmSelector = tfmSelector ?? throw new ArgumentNullException(nameof(tfmSelector)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public void AddLoader(IPackageLoader loader) { _loaders.Add(loader); _diagnostics.LogObject(loader, currentProvenance); }
public void Loader(IPackageLoader loader) { addConfigurableAction(g => g.AddLoader(loader)); }
public void LogPackage(IPackageInfo package, IPackageLoader loader) { _log.LogObject(package, "Loaded by " + loader); _log.LogFor(loader).AddChild(package); }
public void LogPackage(IPackageInfo package, IPackageLoader loader) { LogObject(package, "Loaded by " + loader); LogFor(loader).AddChild(package); }
/// <summary> /// Create load capability error. /// </summary> /// <param name="filesystem">(optional) associated filesystem</param> /// <param name="path">(optional) associated path</param> /// <param name="message">(optional) message</param> /// <param name="innerException">(optional) inner exception</param> /// <param name="packageLoader">(optional) associated package loader</param> public NoSuitableLoadCapability(IFileSystem filesystem = null, string path = null, string message = "", Exception innerException = null, IPackageLoader packageLoader = null) : base(filesystem, path, message, innerException) { this.packageLoader = packageLoader; }
/// <summary> /// Create file related error. /// </summary> /// <param name="filesystem">(optional) associated filesystem</param> /// <param name="path">(optional) associated path</param> /// <param name="message">(optional) message</param> /// <param name="innerException">(optional) inner exception</param> /// <param name="packageLoader">(optional) associated package loader</param> public FileError(IFileSystem filesystem = null, string path = null, string message = "", Exception innerException = null, IPackageLoader packageLoader = null) : base(filesystem, path, message, innerException) { this.packageLoader = packageLoader; }