public TestWrapCommand(IFileSystem fileSystem,IPackageResolver resolver, IEnvironment environment, IPackageExporter exporter)
{
_fileSystem = fileSystem;
_exporter = exporter;
_resolver = resolver;
_environment = environment;
}
/// <summary>
/// Initializes an instance of <see cref="UpdateManager"/>.
/// </summary>
public UpdateManager(AssemblyMetadata updatee, IPackageResolver resolver, IPackageExtractor extractor)
{
#if NETSTANDARD2_0
// Ensure that this is only used on Windows
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
throw new PlatformNotSupportedException("Onova only supports Windows.");
}
#endif
_updatee = updatee.GuardNotNull(nameof(updatee));
_resolver = resolver.GuardNotNull(nameof(resolver));
_extractor = extractor.GuardNotNull(nameof(extractor));
// Set storage directory path
_storageDirPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Onova", _updatee.Name);
// Set updater executable file path
_updaterFilePath = Path.Combine(_storageDirPath, $"{_updatee.Name}.Updater.exe");
// Set lock file path
_lockFilePath = Path.Combine(_storageDirPath, "Onova.lock");
}
public TestWrapCommand(IFileSystem fileSystem, IPackageResolver resolver, IEnvironment environment, IPackageExporter exporter, IPackageManager manager)
{
_fileSystem = fileSystem;
_exporter = exporter;
_manager = manager;
_resolver = resolver;
_environment = environment;
}
/// <summary>
/// Initializes an instance of <see cref="UpdateManager"/>.
/// </summary>
public UpdateManager(AssemblyMetadata updatee, IPackageResolver resolver, IPackageExtractor extractor)
{
_updatee = updatee.GuardNotNull(nameof(updatee));
_resolver = resolver.GuardNotNull(nameof(resolver));
_extractor = extractor.GuardNotNull(nameof(extractor));
_storageDirPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Onova",
_updatee.Name);
}
protected override void ExecuteCore()
{
var lockFileCache = new LockFileCache(BuildEngine4);
LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath);
IEnumerable <string> excludeFromPublishPackageIds = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences);
IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath);
HashSet <PackageIdentity> packagestoBeFiltered = null;
if (TargetManifestFiles != null && TargetManifestFiles.Length > 0)
{
packagestoBeFiltered = new HashSet <PackageIdentity>();
foreach (var manifestFile in TargetManifestFiles)
{
Log.LogMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, Strings.ParsingFiles, manifestFile));
var packagesSpecified = StoreArtifactParser.Parse(manifestFile);
foreach (var pkg in packagesSpecified)
{
Log.LogMessage(MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, Strings.PackageInfoLog, pkg.Id, pkg.Version));
}
packagestoBeFiltered.UnionWith(packagesSpecified);
}
}
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName,
IsSelfContained);
projectContext.PackagesToBeFiltered = packagestoBeFiltered;
var assemblyResolver =
new PublishAssembliesResolver(packageResolver)
.WithExcludeFromPublish(excludeFromPublishPackageIds)
.WithPreserveStoreLayout(PreserveStoreLayout);
IEnumerable <ResolvedFile> resolvedAssemblies = assemblyResolver.Resolve(projectContext);
foreach (ResolvedFile resolvedAssembly in resolvedAssemblies)
{
TaskItem item = new TaskItem(resolvedAssembly.SourcePath);
item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath);
item.SetMetadata("AssetType", resolvedAssembly.Asset.ToString().ToLower());
_assembliesToPublish.Add(item);
}
foreach (var resolvedPkg in assemblyResolver.GetResolvedPackages())
{
TaskItem item = new TaskItem(resolvedPkg.Id);
item.SetMetadata("Version", resolvedPkg.Version.ToString());
_packagesResolved.Add(item);
}
}
protected override void ExecuteCore()
{
var lockFileCache = new LockFileCache(this);
LockFile lockFile = lockFileCache.GetLockFile(AssetsFilePath);
IEnumerable <string> excludeFromPublishPackageIds = PackageReferenceConverter.GetPackageIds(ExcludeFromPublishPackageReferences);
IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath);
HashSet <PackageIdentity> packagestoBeFiltered = null;
if (RuntimeStorePackages != null && RuntimeStorePackages.Length > 0)
{
packagestoBeFiltered = new HashSet <PackageIdentity>();
foreach (var package in RuntimeStorePackages)
{
packagestoBeFiltered.Add(ItemUtilities.GetPackageIdentity(package));
}
}
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName,
RuntimeFrameworks,
IsSelfContained);
projectContext.PackagesToBeFiltered = packagestoBeFiltered;
var assemblyResolver =
new PublishAssembliesResolver(packageResolver)
.WithExcludeFromPublish(excludeFromPublishPackageIds)
.WithPreserveStoreLayout(PreserveStoreLayout);
IEnumerable <ResolvedFile> resolvedAssemblies = assemblyResolver.Resolve(projectContext);
foreach (ResolvedFile resolvedAssembly in resolvedAssemblies)
{
TaskItem item = new TaskItem(resolvedAssembly.SourcePath);
item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath);
item.SetMetadata("AssetType", resolvedAssembly.Asset.ToString().ToLower());
item.SetMetadata(MetadataKeys.PackageName, resolvedAssembly.Package.Id.ToString());
item.SetMetadata(MetadataKeys.PackageVersion, resolvedAssembly.Package.Version.ToString().ToLower());
if (resolvedAssembly.Asset == AssetType.Resources)
{
// For resources, the DestinationSubDirectory is set to the locale. Set the Culture
// metadata on the generated item to this value so that the satellite assemblies can
// be filtered by culture.
item.SetMetadata(MetadataKeys.Culture, resolvedAssembly.DestinationSubDirectory);
}
_assembliesToPublish.Add(item);
}
}
/// <summary>
/// Initializes an instance of <see cref="UpdateManager"/>.
/// </summary>
public UpdateManager(AssemblyMetadata updatee, IPackageResolver resolver, IPackageExtractor extractor)
{
_updatee = updatee.GuardNotNull(nameof(updatee));
_resolver = resolver.GuardNotNull(nameof(resolver));
_extractor = extractor.GuardNotNull(nameof(extractor));
// Set storage directory path
_storageDirPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Onova", _updatee.Name);
// Set updater executable file path
_updaterFilePath = Path.Combine(_storageDirPath, $"{_updatee.Name}.Updater.dll");
_runtimeconfigFilePath = Path.Combine(_storageDirPath, $"{_updatee.Name}.Updater.runtimeconfig.json");
// Set lock file path
_lockFilePath = Path.Combine(_storageDirPath, "Onova.lock");
}
/// <summary>
/// Initializes an instance of <see cref="UpdateManager"/>.
/// </summary>
public UpdateManager(AssemblyMetadata updatee, IPackageResolver resolver, IPackageExtractor extractor)
{
Platform.EnsureWindows();
Updatee = updatee;
_resolver = resolver;
_extractor = extractor;
// Set storage directory path
_storageDirPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Onova", updatee.Name);
// Set updater executable file path
_updaterFilePath = Path.Combine(_storageDirPath, $"{updatee.Name}.Updater.exe");
// Set lock file path
_lockFilePath = Path.Combine(_storageDirPath, "Onova.lock");
}
protected override void ExecuteCore()
{
LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath);
IEnumerable <string> privateAssetsPackageIds = PackageReferenceConverter.GetPackageIds(PrivateAssetsPackageReferences);
IPackageResolver packageResolver = NuGetPackageResolver.CreateResolver(lockFile, ProjectPath);
ProjectContext projectContext = lockFile.CreateProjectContext(
NuGetUtils.ParseFrameworkName(TargetFramework),
RuntimeIdentifier,
PlatformLibraryName);
IEnumerable <ResolvedFile> resolvedAssemblies =
new PublishAssembliesResolver(packageResolver)
.WithPrivateAssets(privateAssetsPackageIds)
.Resolve(projectContext);
foreach (ResolvedFile resolvedAssembly in resolvedAssemblies)
{
TaskItem item = new TaskItem(resolvedAssembly.SourcePath);
item.SetMetadata("DestinationSubPath", resolvedAssembly.DestinationSubPath);
_assembliesToPublish.Add(item);
}
}
/// <summary>
/// Initializes an instance of <see cref="UpdateManager"/> on the entry assembly.
/// </summary>
public UpdateManager(IPackageResolver resolver, IPackageExtractor extractor)
: this(new AssemblyMetadata(Assembly.GetEntryAssembly()), resolver, extractor)
{
}
public ResolvePackageDependencies(LockFile lockFile, IPackageResolver packageResolver)
: this()
{
_lockFile = lockFile;
_packageResolver = packageResolver;
}
public TestRunnerManager(IEnumerable<ITestRunnerFactory> factories, IEnvironment environment, IPackageResolver resolver)
{
_factories = factories;
_environment = environment;
_resolver = resolver;
}
/// <summary>
/// Initializes an instance of <see cref="UpdateManager"/> on the entry assembly.
/// </summary>
public UpdateManager(IPackageResolver resolver, IPackageExtractor extractor)
: this(AssemblyMetadata.FromEntryAssembly(), resolver, extractor)
{
}
public PublishAssembliesResolver(IPackageResolver packageResolver)
{
_packageResolver = packageResolver;
}
public DefaultPackageManager(IPackageDeployer deployer, IPackageResolver resolver, IPackageExporter exporter)
{
_deployer = deployer;
_resolver = resolver;
_exporter = exporter;
}
public UpdateManager(IPackageResolver packageResolver)
{
PackageResolver = packageResolver;
}
public AssetsFileResolver(IPackageResolver packageResolver)
{
_packageResolver = packageResolver;
}
public DefaultPackageManager(IPackageDeployer deployer, IPackageResolver resolver, IPackageExporter exporter)
{
_deployer = deployer;
_exporter = exporter;
_resolver = resolver;
}
