/// <summary>
/// Adds refresh files to the specified project for all assemblies references belonging to the packages
/// specified by packageNames.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="repositoryPath">The file system pointing to 'packages' folder under the solution.</param>
/// <param name="packageNames">The package names.</param>
private void AddRefreshFilesForReferences(EnvDTE.Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (repositoryPath == null)
{
throw new ArgumentNullException("repositoryPath");
}
if (!packageNames.Any())
{
return;
}
VSAPIProjectContext context = new VSAPIProjectContext(skipAssemblyReferences: true, bindingRedirectsDisabled: true);
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
context.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
new LoggerAdapter(context),
signedPackageVerifier,
SignedPackageVerifierSettings.GetDefault());
WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context);
foreach (var packageName in packageNames)
{
string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version);
DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath));
PackageFolderReader reader = new PackageFolderReader(packageFolder);
var frameworkGroups = reader.GetReferenceItems();
var groups = reader.GetReferenceItems();
var fwComparer = new NuGetFrameworkFullComparer();
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework));
if (targetGroupFramework != null)
{
var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault();
foreach (string refItem in refGroup.Items)
{
string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar));
// create one refresh file for each assembly reference, as per required by Website projects
// projectSystem.CreateRefreshFile(assemblyPath);
RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath);
}
}
}
}
public void PackageFolderReader_Basic()
{
using (var packageFile = TestPackages.GetLegacyTestPackage())
{
using (var zip = new ZipArchive(File.OpenRead(packageFile)))
using (var zipReader = new PackageArchiveReader(zip))
{
var folder = Path.Combine(Path.GetDirectoryName(packageFile), Guid.NewGuid().ToString());
using (var zipFile = new ZipArchive(File.OpenRead(packageFile)))
{
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count());
Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First());
}
}
}
}
public void PackageFolderReader_NuspecCountNone()
{
// Arrange
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
zip.AddEntry("lib/net45/a.dll", new byte[0]);
}
stream.Seek(0, SeekOrigin.Begin);
var zipFile = new ZipArchive(stream, ZipArchiveMode.Read);
zipFile.ExtractAll(workingDir);
var reader = new PackageFolderReader(workingDir);
var threwPackagingException = false;
// Act
try
{
var nuspec = reader.GetNuspec();
}
catch (PackagingException)
{
threwPackagingException = true;
}
// Assert
Assert.True(threwPackagingException);
}
}
public void GetNuspec_ThrowsForNoNuspecWithCorrectExtension()
{
// Arrange
using (var workingDir = TestDirectory.Create())
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
zip.AddEntry("lib/net45/a.dll", new byte[0]);
zip.AddEntry("nuspec.blah", new byte[0]);
zip.AddEntry("blahnuspec", new byte[0]);
zip.AddEntry("blah/nuspec", new byte[0]);
zip.AddEntry("blah-nuspec", new byte[0]);
zip.AddEntry("blah.nuspecc", new byte[0]);
}
ExtractAll(stream, workingDir);
using (var reader = new PackageFolderReader(workingDir))
{
// Act
var exception = Assert.Throws <PackagingException>(() => reader.GetNuspec());
// Assert
Assert.Equal("Nuspec file does not exist in package.", exception.Message);
}
}
}
private IEnumerable <string> GetPackageAssemblyNames(string path)
{
var compatibilityProvider = new DefaultCompatibilityProvider();
var folderReader = new PackageFolderReader(Path.Combine(path, _fileSystem.PackagesFolder));
var nupkgFiles = folderReader.GetFiles().Where(x => Path.GetExtension(x).ToLowerInvariant() == ".nupkg");
var packagesConfig = XDocument.Parse(File.ReadAllText(Path.Combine(path, _fileSystem.PackagesFile)));
var reader = new PackagesConfigReader(packagesConfig);
var contents = reader.GetPackages();
var result = new List <string>();
foreach (var nupkg in nupkgFiles)
{
var stream = folderReader.GetStream(nupkg);
var packageReader = new PackageReader(stream);
var identity = packageReader.GetIdentity();
var packagesConfigReference = contents.FirstOrDefault(x => x.PackageIdentity.Id == identity.Id && x.PackageIdentity.Version == identity.Version);
if (packagesConfigReference == null)
{
break;
}
var packageContents = packageReader.GetLibItems().Where(x => compatibilityProvider.IsCompatible(x.TargetFramework, packagesConfigReference.TargetFramework)).
SelectMany(x => x.Items.Where(i => Path.GetExtension(i).ToLowerInvariant() == ".dll"));
result.AddRange(packageContents);
}
return(result);
}
public void GetNuspec_ThrowsForMultipleRootNuspecs()
{
// Arrange
using (var workingDir = TestDirectory.Create())
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
zip.AddEntry("lib" + Path.DirectorySeparatorChar + "net45" + Path.DirectorySeparatorChar + "a.dll", new byte[0]);
zip.AddEntry("package.NUSPEC", new byte[0]);
zip.AddEntry("package2.nuspec", new byte[0]);
}
ExtractAll(stream, workingDir);
using (var reader = new PackageFolderReader(workingDir))
{
// Act
var exception = Assert.Throws <PackagingException>(() => reader.GetNuspec());
// Assert
Assert.Equal("Package contains multiple nuspec files.", exception.Message);
}
}
}
public void PackageFolderReader_NuspecCountNested()
{
// Arrange
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
zip.AddEntry("lib/net45/a.dll", new byte[0]);
zip.AddEntry("package.nuspec", new byte[5]);
zip.AddEntry("content/package.nuspec", new byte[0]);
}
stream.Seek(0, SeekOrigin.Begin);
var zipFile = new ZipArchive(stream, ZipArchiveMode.Read);
zipFile.ExtractAll(workingDir);
var folderReader = new PackageFolderReader(workingDir);
// Act
using (var nuspec = folderReader.GetNuspec())
{
// Assert
Assert.NotNull(nuspec);
Assert.Equal(5, nuspec.Length);
}
}
}
public async Task <IEnumerable <string> > ExtractPackageAsync(string packagePath, DirectoryPath targetFolder)
{
await using FileStream packageStream = File.OpenRead(packagePath);
PackageFolderReader packageReader = new PackageFolderReader(targetFolder.Value);
PackageExtractionContext packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
null,
_logger);
NuGetPackagePathResolver packagePathResolver = new NuGetPackagePathResolver(targetFolder.Value);
CancellationToken cancellationToken = CancellationToken.None;
var allFilesInPackage = await PackageExtractor.ExtractPackageAsync(
targetFolder.Value,
packageStream,
packagePathResolver,
packageExtractionContext,
cancellationToken);
if (!OperatingSystem.IsWindows())
{
foreach (FilePath filePath in FindAllFilesNeedExecutablePermission(allFilesInPackage, targetFolder.Value))
{
_filePermissionSetter.Set755Permission(filePath.Value);
}
}
return(allFilesInPackage);
}
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path, string correctedPackageName)
{
var lockFileLib = new LockFileLibrary();
// package.Id is read from nuspec and it might be in wrong casing.
// correctedPackageName should be the package name used by dependency graph and
// it has the correct casing that runtime needs during dependency resolution.
lockFileLib.Name = correctedPackageName ?? package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Type = LibraryType.Package;
lockFileLib.Sha512 = sha512;
// This is the relative path, appended to the global packages folder path. All
// of the paths in the in the Files property should be appended to this path along
// with the global packages folder path to get the absolute path to each file in the
// package.
lockFileLib.Path = path;
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
lockFileLib.Files = packageReader
.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList();
}
return(lockFileLib);
}
public void GetNuspec_SupportsEscapingInFileName()
{
// Arrange
using (var workingDir = TestDirectory.Create())
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
zip.AddEntry("lib/net45/a.dll", new byte[0]);
zip.AddEntry("package%20.nuspec", new byte[5]);
}
ExtractAll(stream, workingDir);
using (var reader = new PackageFolderReader(workingDir))
{
// Act
using (var nuspec = reader.GetNuspec())
{
// Assert
Assert.NotNull(nuspec);
Assert.Equal(5, nuspec.Length);
}
}
}
}
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path)
{
var lockFileLib = new LockFileLibrary();
lockFileLib.Name = package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Type = LibraryType.Package;
lockFileLib.Sha512 = sha512;
// This is the relative path, appended to the global packages folder path. All
// of the paths in the in the Files property should be appended to this path along
// with the global packages folder path to get the absolute path to each file in the
// package.
lockFileLib.Path = path;
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
lockFileLib.Files = packageReader
.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList();
}
return(lockFileLib);
}
private static DownloadResourceResult CreateDownloadResourceResult(string nupkgPath, string installPath)
{
Stream stream = null;
PackageReaderBase packageReader = null;
try
{
stream = File.Open(nupkgPath, FileMode.Open, FileAccess.Read, FileShare.Read);
packageReader = new PackageFolderReader(installPath);
return(new DownloadResourceResult(stream, packageReader, source: null)
{
SignatureVerified = true
});
}
catch
{
if (stream != null)
{
stream.Dispose();
}
if (packageReader != null)
{
packageReader.Dispose();
}
throw;
}
}
public void PackageFolderReader_NuspecCountEscapingInName()
{
// Arrange
using (var workingDir = TestDirectory.Create())
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
zip.AddEntry("lib/net45/a.dll", new byte[0]);
zip.AddEntry("package%20.nuspec", new byte[5]);
}
stream.Seek(0, SeekOrigin.Begin);
var zipFile = new ZipArchive(stream, ZipArchiveMode.Read);
zipFile.ExtractAll(workingDir);
var reader = new PackageFolderReader(workingDir);
// Act
using (var nuspec = reader.GetNuspec())
{
// Assert
Assert.NotNull(nuspec);
Assert.Equal(5, nuspec.Length);
}
}
}
public void GetNuspec_ThrowsForNoNuspecWithCorrectExtension()
{
// Arrange
using (var workingDir = TestDirectory.Create())
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
zip.AddEntry("lib/net45/a.dll", new byte[0]);
zip.AddEntry("nuspec.blah", new byte[0]);
zip.AddEntry("blahnuspec", new byte[0]);
zip.AddEntry("blah/nuspec", new byte[0]);
zip.AddEntry("blah-nuspec", new byte[0]);
zip.AddEntry("blah.nuspecc", new byte[0]);
}
ExtractAll(stream, workingDir);
using (var reader = new PackageFolderReader(workingDir))
{
// Act
var exception = Assert.Throws <PackagingException>(() => reader.GetNuspec());
// Assert
var log = exception.AsLogMessage();
Assert.Equal(NuGetLogCode.NU5037, log.Code);
Assert.Contains("The package is missing the required nuspec file.", log.Message);
}
}
}
public void PackageFolderReader_Basic()
{
using (var packageFile = TestPackagesCore.GetLegacyTestPackage())
{
using (var zip = new ZipArchive(File.OpenRead(packageFile)))
using (var zipReader = new PackageArchiveReader(zip))
using (var testDirectory = TestDirectory.Create())
using (var zipFile = new ZipArchive(File.OpenRead(packageFile)))
{
zipFile.ExtractAll(testDirectory);
using (var folderReader = new PackageFolderReader(testDirectory))
{
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
var referenceItems = zipReader.GetReferenceItems();
var folderItems = folderReader.GetReferenceItems();
Assert.Equal(referenceItems.Count(), folderItems.Count());
Assert.Equal(referenceItems.First().Items.First(), folderItems.First().Items.First());
}
}
}
}
private static CommandSpec ConfigureCommandFromPackage(string commandName, string args, string packageDir)
{
var commandPackage = new PackageFolderReader(packageDir);
var files = commandPackage.GetFiles();
return(ConfigureCommandFromPackage(commandName, args, files, packageDir));
}
private async Task BrowseImpl(IOwinContext context, DirectoryInfo root, string path)
{
var s = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (s.Any(x => x.Length > 0 && x.All(c => c == '.')))
{
await context.Response.Error(404, new ErrorModel("Illegal Path")).ConfigureAwait(false);
return;
}
using (var package = new PackageFolderReader(root))
{
if (path == "" || path.EndsWith("/", StringComparison.Ordinal))
{
var dir = new DirectoryInfo(Path.Combine(root.FullName, Path.Combine(s)));
if (!dir.Exists)
{
goto NOT_FOUND;
}
await context.Response.View(new Views.FileList(), new FileListModel
{
Identity = package.GetIdentity(),
Breadcrumbs = s,
Directories = dir.EnumerateDirectories().Where(d => !d.Attributes.HasFlag(FileAttributes.Hidden)),
Files = dir.EnumerateFiles().Where(f => !f.Attributes.HasFlag(FileAttributes.Hidden))
}).ConfigureAwait(false);
}
else
{
var file = new FileInfo(Path.Combine(root.FullName, Path.Combine(s)));
if (!file.Exists)
{
goto NOT_FOUND;
}
var gen = new FilePreviewGenerator(file);
if (gen.NeedsGenerate)
{
await gen.GenerateHtml(context, new HeaderModel
{
Identity = package.GetIdentity(),
Breadcrumbs = s
}).ConfigureAwait(false);
}
context.Request.CallCancelled.ThrowIfCancellationRequested();
await this.filePreviewApp(context.Environment).ConfigureAwait(false);
}
}
GC.Collect(); // to release a handle of nuspec file
return;
NOT_FOUND:
await this.Next.Invoke(context).ConfigureAwait(false);
}
public async Task <bool> InstallPackage(PackageIdentity identity)
{
await Download(identity);
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = getLocal(p.Id);
await InstallPackage(local.Identity);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
CopyDir.Copy(installedPath + @"\build", Destinationfolder);
}
return(true);
}
public bool IsPackageInstalled(LocalPackageInfo package)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.Identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
string source = "";
string f2 = "";
string filename = "";
string dir = "";
string target = "";
try
{
source = System.IO.Path.Combine(installedPath, f);
f2 = f.Substring(f.IndexOf("/", 4) + 1);
filename = System.IO.Path.GetFileName(f2);
dir = System.IO.Path.GetDirectoryName(f2);
target = System.IO.Path.Combine(Destinationfolder, dir, filename);
if (!System.IO.Directory.Exists(System.IO.Path.Combine(Destinationfolder, dir)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(Destinationfolder, dir));
}
if (!System.IO.File.Exists(source))
{
return(false);
}
if (!System.IO.File.Exists(target))
{
return(false);
}
var infoOld = new System.IO.FileInfo(source);
var infoNew = new System.IO.FileInfo(target);
if (infoNew.LastWriteTime != infoOld.LastWriteTime)
{
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
return(true);
}
public static DownloadResourceResult GetPackage(PackageIdentity packageIdentity, string globalPackagesFolder)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (globalPackagesFolder == null)
{
throw new ArgumentNullException(nameof(globalPackagesFolder));
}
var defaultPackagePathResolver = new VersionFolderPathResolver(globalPackagesFolder);
var hashPath = defaultPackagePathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version);
if (File.Exists(hashPath))
{
var installPath = defaultPackagePathResolver.GetInstallPath(
packageIdentity.Id,
packageIdentity.Version);
var nupkgPath = defaultPackagePathResolver.GetPackageFilePath(
packageIdentity.Id,
packageIdentity.Version);
Stream stream = null;
PackageReaderBase packageReader = null;
try
{
stream = File.Open(nupkgPath, FileMode.Open, FileAccess.Read, FileShare.Read);
packageReader = new PackageFolderReader(installPath);
return(new DownloadResourceResult(stream, packageReader)
{
SignatureVerified = true
});
}
catch
{
if (stream != null)
{
stream.Dispose();
}
if (packageReader != null)
{
packageReader.Dispose();
}
throw;
}
}
return(null);
}
public NuspecReader GetNuspecReaderInPackagesInstallFolder(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
return(packageReader.NuspecReader);
}
public void UninstallPackage(PackageIdentity identity)
{
var package = getLocal(identity.Id);
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.Identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(Destinationfolder, filename);
if (System.IO.File.Exists(target))
{
try
{
System.IO.File.Delete(target);
}
catch (Exception)
{
}
}
}
}
}
}
/// <summary>
/// Read files from a package folder.
/// </summary>
private IReadOnlyList <string> GetFiles()
{
using (var packageReader = new PackageFolderReader(ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
return(packageReader.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList());
}
}
/// <summary>
/// Adds refresh files to the specified project for all assemblies references belonging to the packages specified by packageNames.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="packagesFileSystem">The file system pointing to 'packages' folder under the solution.</param>
/// <param name="packageNames">The package names.</param>
private void AddRefreshFilesForReferences(Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (repositoryPath == null)
{
throw new ArgumentNullException("repositoryPath");
}
if (!packageNames.Any())
{
return;
}
VSAPIProjectContext context = new VSAPIProjectContext();
WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(project, context);
var root = EnvDTEProjectUtility.GetFullPath(project);
foreach (var packageName in packageNames)
{
string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version);
DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath));
PackageFolderReader reader = new PackageFolderReader(packageFolder);
var frameworkGroups = reader.GetReferenceItems();
var groups = reader.GetReferenceItems();
var fwComparer = new NuGetFrameworkFullComparer();
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework));
if (targetGroupFramework != null)
{
var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault();
foreach (string refItem in refGroup.Items)
{
string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar));
// create one refresh file for each assembly reference, as per required by Website projects
// projectSystem.CreateRefreshFile(assemblyPath);
RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath, context);
}
}
}
}
internal static PackageReaderTest Create(TestPackagesCore.TempFile tempFile)
{
var directory = TestDirectory.Create();
using (tempFile)
using (var zipFile = new ZipArchive(File.OpenRead(tempFile)))
{
zipFile.ExtractAll(directory.Path);
}
var reader = new PackageFolderReader(directory.Path);
return(new PackageReaderTest(reader, directory));
}
public async Task <bool> ExecutePackageInitScriptAsync(
PackageIdentity packageIdentity,
string packageInstallPath,
INuGetProjectContext projectContext,
bool throwOnFailure,
CancellationToken token)
{
var scriptExecutor = _scriptExecutor.Value;
Assumes.Present(scriptExecutor);
using (var packageReader = new PackageFolderReader(packageInstallPath))
{
var toolItemGroups = packageReader.GetToolItems();
if (toolItemGroups != null)
{
// Init.ps1 must be found at the root folder, target frameworks are not recognized here,
// since this is run for the solution.
var toolItemGroup = toolItemGroups
.FirstOrDefault(group => group.TargetFramework.IsAny);
if (toolItemGroup != null)
{
var initPS1RelativePath = toolItemGroup
.Items
.FirstOrDefault(p => p.StartsWith(
PowerShellScripts.InitPS1RelativePath,
StringComparison.OrdinalIgnoreCase));
if (!string.IsNullOrEmpty(initPS1RelativePath))
{
initPS1RelativePath = PathUtility.ReplaceAltDirSeparatorWithDirSeparator(
initPS1RelativePath);
return(await scriptExecutor.ExecuteAsync(
packageIdentity,
packageInstallPath,
initPS1RelativePath,
_vsProjectAdapter.Project,
projectContext,
throwOnFailure));
}
}
}
}
return(false);
}
public override async Threading.Task <bool> ExecuteInitScriptAsync(
PackageIdentity identity,
string packageInstallPath,
INuGetProjectContext projectContext,
bool throwOnFailure)
{
if (ScriptExecutor != null)
{
var packageReader = new PackageFolderReader(packageInstallPath);
var toolItemGroups = packageReader.GetToolItems();
if (toolItemGroups != null)
{
// Init.ps1 must be found at the root folder, target frameworks are not recognized here,
// since this is run for the solution.
var toolItemGroup = toolItemGroups
.Where(group => group.TargetFramework.IsAny)
.FirstOrDefault();
if (toolItemGroup != null)
{
var initPS1RelativePath = toolItemGroup.Items
.Where(p => p.StartsWith(
PowerShellScripts.InitPS1RelativePath,
StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
if (!string.IsNullOrEmpty(initPS1RelativePath))
{
initPS1RelativePath =
ProjectManagement.PathUtility
.ReplaceAltDirSeparatorWithDirSeparator(initPS1RelativePath);
return(await ScriptExecutor.ExecuteAsync(
identity,
packageInstallPath,
initPS1RelativePath,
EnvDTEProject,
this,
projectContext,
throwOnFailure));
}
}
}
}
return(false);
}
public async Task <IEnumerable <string> > ExtractPackageAsync(string packagePath, DirectoryPath targetFolder)
{
await using FileStream packageStream = File.OpenRead(packagePath);
PackageFolderReader packageReader = new PackageFolderReader(targetFolder.Value);
PackageExtractionContext packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
null,
_verboseLogger);
NuGetPackagePathResolver packagePathResolver = new NuGetPackagePathResolver(targetFolder.Value);
CancellationToken cancellationToken = CancellationToken.None;
var allFilesInPackage = await PackageExtractor.ExtractPackageAsync(
targetFolder.Value,
packageStream,
packagePathResolver,
packageExtractionContext,
cancellationToken);
if (!OperatingSystem.IsWindows())
{
string workloadUnixFilePermissions = allFilesInPackage.SingleOrDefault(p =>
Path.GetRelativePath(targetFolder.Value, p).Equals("data/UnixFilePermissions.xml",
StringComparison.OrdinalIgnoreCase));
if (workloadUnixFilePermissions != default)
{
var permissionList = WorkloadUnixFilePermissions.FileList.Deserialize(workloadUnixFilePermissions);
foreach (var fileAndPermission in permissionList.File)
{
_filePermissionSetter
.SetPermission(
Path.Combine(targetFolder.Value, fileAndPermission.Path),
fileAndPermission.Permission);
}
}
else
{
// https://github.com/dotnet/sdk/issues/18239
foreach (FilePath filePath in FindAllFilesNeedExecutablePermission(allFilesInPackage,
targetFolder.Value))
{
_filePermissionSetter.SetPermission(filePath.Value, "755");
}
}
}
return(allFilesInPackage);
}
/// <summary>
/// Возвращает наименьшую поддерживаемую версию фреймворка для указанного пакета.
/// </summary>
/// <param name="packageIdentity">Идентификатор пакета.</param>
private NuGetFramework GetPackageLowestSupportedFramework(PackageIdentity packageIdentity)
{
var packagePath = GetPackagePath(packageIdentity);
using (var reader = new PackageFolderReader(packagePath))
{
// Выбираются только поддерживаемые TargetFramework, содержащие файлы в каталоге 'lib'
return(reader.GetLibItems()
.OrderBy(i => i.TargetFramework, NuGetFrameworkComparer)
.FirstOrDefault(i => NuGetFrameworkComparer.Compare(i.TargetFramework, NuGetFramework.AnyFramework) != 0 &&
!i.TargetFramework.IsUnsupported &&
i.Items != null &&
i.Items.Any())?.TargetFramework);
}
}
public async Task <List <PackageSearchItem> > GetLocal(Project project, PackageIdentity identity)
{
var result = new List <PackageSearchItem>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = DefaultSourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
DefaultSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, NullLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath != null)
{
// per project or joined ?
// string TargetFolder = System.IO.Path.Combine(project.Path, "extensions");
string TargetFolder = System.IO.Path.Combine(Interfaces.Extensions.ProjectsDirectory, "extensions");
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
result.Add(new PackageSearchItem(project, packageReader));
}
}
}
return(result);
}
public void PackageFolderReader_Basic()
{
var packageNupkg = TestPackages.GetLegacyTestPackage();
var zip = new ZipArchive(packageNupkg.OpenRead());
PackageReader zipReader = new PackageReader(zip);
var folder = Path.Combine(packageNupkg.Directory.FullName, Guid.NewGuid().ToString());
var zipFile = new ZipArchive(File.OpenRead(packageNupkg.FullName));
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count());
Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First());
}
