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 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 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 void Loader(IPackageLoader loader)
{
configure = g => g.AddLoader(loader);
}
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 AddLoader(IPackageLoader loader)
{
_loaders.Add(loader);
_diagnostics.LogObject(loader, currentProvenance);
}
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;
}
public void Loader(IPackageLoader loader)
{
addConfigurableAction(g => g.AddLoader(loader));
}
/// <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;
}
