public static void DownloadPackage(string packageId, NuGetVersion version, Uri feedUri, ICredentials feedCredentials, string targetFilePath)
{
ILogger logger = new NugetLogger();
var sourceRepository = Repository.Factory.GetCoreV3(feedUri.AbsoluteUri);
if (feedCredentials != null)
{
var cred = feedCredentials.GetCredential(feedUri, "basic");
sourceRepository.PackageSource.Credentials = new PackageSourceCredential("octopus", cred.UserName, cred.Password, true);
}
var providers = new SourceRepositoryDependencyProvider(sourceRepository, logger, new SourceCacheContext());
var libraryIdentity = new LibraryIdentity(packageId, version, LibraryType.Package);
var targetPath = Directory.GetParent(targetFilePath).FullName;
if (!Directory.Exists(targetPath))
{
Directory.CreateDirectory(targetPath);
}
string targetTempNupkg = Path.Combine(targetPath, Path.GetRandomFileName());
using (var nupkgStream = new FileStream(targetTempNupkg, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite | FileShare.Delete, 4096, true))
{
providers.CopyToAsync(libraryIdentity, nupkgStream, CancellationToken.None)
.GetAwaiter()
.GetResult();
}
File.Move(targetTempNupkg, targetFilePath);
}
public NugetWrapper(bool log = false)
{
List <Lazy <INuGetResourceProvider> > providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
PackageSource packageSource = new PackageSource(PACKAGE_SOURCE_URL);
SourceRepository = new SourceRepository(packageSource, providers);
// Setup SeriLog
_logger = new LoggerConfiguration()
.MinimumLevel.Information()
.WriteToIf(log, c => c.RollingFile("log-nuget.txt"))
.CreateLogger();
_nugetLogger = new NugetLogger(_logger);
}
// t h a n k you daveaglick
public PackageSearchMetadata GetLatestVersionForPackage(string package)
{
var logger = new NugetLogger();
var providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3());
var packageSource = new PackageSource("https://api.nuget.org/v3/index.json");
var sourceRepository = new SourceRepository(packageSource, providers);
var packageMetadataResource = sourceRepository.GetResourceAsync <PackageMetadataResource>().Result;
var searchMetadata =
packageMetadataResource.GetMetadataAsync(package, true, true, logger, CancellationToken.None).Result;
return
(searchMetadata
.OfType <PackageSearchMetadata>()
.OrderByDescending(x => x.Published)
.First());
}
/// <summary>
/// Uninstalls a package.
/// </summary>
/// <param name="packageId">The package identifier for the package to be uninstalled.</param>
/// <param name="applicationPath">The application path.</param>
public void Uninstall(string packageId, string applicationPath)
{
string solutionPath;
string extensionFullPath = string.Empty;
if (packageId.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme)))
{
extensionFullPath = _virtualPathProvider.MapPath("~/Themes/" + packageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme).Length));
}
else if (packageId.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module)))
{
extensionFullPath = _virtualPathProvider.MapPath("~/Modules/" + packageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module).Length));
}
if (string.IsNullOrEmpty(extensionFullPath) ||
!Directory.Exists(extensionFullPath))
{
throw new OrchardException(T("Package not found: {0}", packageId));
}
// if we can access the parent directory, and the solution is inside, NuGet-uninstall the package here
if (TryGetSolutionPath(applicationPath, out solutionPath))
{
// this logger is used to render NuGet's log on the notifier
var logger = new NugetLogger(_notifier);
var installedPackagesPath = Path.Combine(solutionPath, PackagesPath);
var sourcePackageRepository = new LocalPackageRepository(installedPackagesPath);
try {
var project = new FileBasedProjectSystem(applicationPath)
{
Logger = logger
};
var projectManager = new ProjectManager(
sourcePackageRepository,
new DefaultPackagePathResolver(installedPackagesPath),
project,
new ExtensionReferenceRepository(project, sourcePackageRepository, _extensionManager)
)
{
Logger = logger
};
// add the package to the project
projectManager.RemovePackageReference(packageId);
}
catch {
// Uninstalling the package at the solution level failed
}
try {
var packageManager = new NuGetPackageManager(
sourcePackageRepository,
new DefaultPackagePathResolver(applicationPath),
new PhysicalFileSystem(installedPackagesPath)
{
Logger = logger
}
)
{
Logger = logger
};
packageManager.UninstallPackage(packageId);
}
catch {
// Package doesnt exist anymore
}
}
// If the package was not installed through nuget we still need to try to uninstall it by removing its directory
if (Directory.Exists(extensionFullPath))
{
Directory.Delete(extensionFullPath, true);
}
}
/// <summary>
/// Executes a package installation.
/// </summary>
/// <param name="package">The package to install.</param>
/// <param name="packageRepository">The repository for the package.</param>
/// <param name="sourceLocation">The source location.</param>
/// <param name="targetPath">The path where to install the package.</param>
/// <returns>The package information.</returns>
protected PackageInfo ExecuteInstall(IPackage package, IPackageRepository packageRepository, string sourceLocation, string targetPath)
{
// this logger is used to render NuGet's log on the notifier
var logger = new NugetLogger(_notifier);
bool installed = false;
// if we can access the parent directory, and the solution is inside, NuGet-install the package here
string solutionPath;
var installedPackagesPath = String.Empty;
if (TryGetSolutionPath(targetPath, out solutionPath))
{
installedPackagesPath = Path.Combine(solutionPath, PackagesPath);
try {
var packageManager = new NuGetPackageManager(
packageRepository,
new DefaultPackagePathResolver(sourceLocation),
new PhysicalFileSystem(installedPackagesPath)
{
Logger = logger
}
)
{
Logger = logger
};
packageManager.InstallPackage(package, true);
installed = true;
}
catch {
// installing the package at the solution level failed
}
}
// if the package got installed successfully, use it, otherwise use the previous repository
var sourceRepository = installed
? new LocalPackageRepository(installedPackagesPath)
: packageRepository;
var project = new FileBasedProjectSystem(targetPath)
{
Logger = logger
};
var projectManager = new ProjectManager(
sourceRepository, // source repository for the package to install
new DefaultPackagePathResolver(targetPath),
project,
new ExtensionReferenceRepository(project, sourceRepository, _extensionManager)
)
{
Logger = logger
};
// add the package to the project
projectManager.AddPackageReference(package.Id, package.Version);
return(new PackageInfo {
ExtensionName = package.Title ?? package.Id,
ExtensionVersion = package.Version.ToString(),
ExtensionType = package.Id.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme)) ? DefaultExtensionTypes.Theme : DefaultExtensionTypes.Module,
ExtensionPath = targetPath
});
}
public async Task PreProcess(string directive, ScriptExecutionContext context, Action <string> logger)
{
var actionLogger = new NugetLogger(logger);
var nugetDirective = NugetPreProcessorDirective.Parse(directive);
string frameworkName = Assembly.GetEntryAssembly() !.GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault() !;
NuGetFramework framework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
using var cache = new SourceCacheContext();
var packagesPath = Path.Combine(Path.GetTempPath(), "packages");
await CreateEmptyNugetConfig(packagesPath, nugetDirective.FeedUrl);
var settings = Settings.LoadImmutableSettingsGivenConfigPaths(new[] { Path.Combine(packagesPath, "empty.config") }, new SettingsLoadingContext());
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
#pragma warning disable CS0618 // Type or member is obsolete
var repositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
#pragma warning restore CS0618 // Type or member is obsolete
var repository = repositoryProvider.GetRepositories().FirstOrDefault();
var packageMetadataResource = await repository.GetResourceAsync <PackageMetadataResource>(CancellationToken.None);
var searchMetadata = await packageMetadataResource.GetMetadataAsync(
nugetDirective.PackageId,
includePrerelease : false,
includeUnlisted : false,
cache,
actionLogger,
CancellationToken.None);
if (!searchMetadata.Any())
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var latest = searchMetadata.OrderByDescending(a => a.Identity.Version).FirstOrDefault();
if (latest is null)
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var packageId = latest.Identity;
var dependencyResource = await repository.GetResourceAsync <DependencyInfoResource>();
await GetPackageDependencies(
packageId,
framework,
cache,
repository,
dependencyResource,
availablePackages, actionLogger);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { nugetDirective.PackageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
new[] { repository.PackageSource },
actionLogger);
var resolver = new PackageResolver();
var toInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(a => availablePackages.Single(b => PackageIdentityComparer.Default.Equals(b, a)));
var pathResolver = new PackagePathResolver(packagesPath);
var extractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, actionLogger),
actionLogger);
var libraries = new List <string>();
var frameworkReducer = new FrameworkReducer();
var downloadResource = await repository.GetResourceAsync <DownloadResource>(CancellationToken.None);
foreach (var package in toInstall)
{
libraries.AddRange(await Install(downloadResource, package, pathResolver, extractionContext, frameworkReducer, framework, packagesPath, actionLogger));
}
foreach (var path in libraries)
{
var assembly = Assembly.LoadFrom(path);
if (context.TryAddReferenceAssembly(assembly))
{
foreach (var ns in assembly.GetTypes().Where(a => a.Namespace != null).Select(a => a.Namespace).Distinct())
{
context.AddImport(ns);
}
}
}
}
