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 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_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());
}
}
}
}
public void PackagesEndedWithResourcesShouldBeProcessed()
{
var packageName = "solution.resources";
using (var packageFile = TestPackagesCore.GetLegacyResourcesPackage(packageName))
{
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());
var libs1 = zipReader.GetLibItems().Count();
var libs2 = folderReader.GetLibItems().Count();
Assert.Equal(libs1, libs2);
var group1 = zipReader.GetReferenceItems();
var group2 = folderReader.GetReferenceItems();
Assert.Equal(group1.Count(), group2.Count());
// Check that assemblies with the 'resource' in a title are not filtered out.
Assert.True(group1.First().Items.Any(p => p.EndsWith("resources.dll")));
// Check that resource assembly not filtered out.
Assert.True(group2.First().Items.Any(p => p.EndsWith("resources.dll")));
foreach (var item in group1)
{
Assert.False(item.Items.Any(p => p.EndsWith(packageName)));
}
foreach (var item in group2)
{
Assert.False(item.Items.Any(p => p.EndsWith(packageName)));
}
}
}
}
}
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());
}
public void PackageFolderReader_Basic()
{
FileInfo packageNupkg = TestPackages.GetLegacyTestPackage();
var zip = new ZipArchive(packageNupkg.OpenRead());
PackageReader zipReader = new PackageReader(zip);
string 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());
}
private static void Run(CommandLineApplication cmd, ILogger log)
{
cmd.Description = "Create a nupkg from a folder.";
cmd.HelpOption(Constants.HelpOption);
var output = cmd.Option("-o|--output", "Output folder, the nupkg will be added here.", CommandOptionType.SingleValue);
var argRoot = cmd.Argument(
"[root]",
"Nupkg folder path",
multipleValues: false);
var required = new List <CommandOption>()
{
output
};
cmd.OnExecute(() =>
{
// Validate parameters
foreach (var requiredOption in required)
{
if (!requiredOption.HasValue())
{
throw new ArgumentException($"Missing required parameter --{requiredOption.LongName}.");
}
}
// Normalize dir ending
var inputFolder = argRoot.Value.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar;
if (string.IsNullOrEmpty(inputFolder) || !Directory.Exists(inputFolder))
{
throw new ArgumentException("Specify the path to a folder containg nupkg files.");
}
Directory.CreateDirectory(output.Value());
var folderReader = new PackageFolderReader(inputFolder);
var identity = folderReader.GetIdentity();
var nupkgName = $"{identity.Id}.{identity.Version.ToString()}.nupkg";
var outputPath = Path.Combine(output.Value(), nupkgName);
log.LogMinimal($"compressing {inputFolder} -> {outputPath}");
using (var stream = File.Create(outputPath))
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create))
{
foreach (var file in Directory.GetFiles(inputFolder, "*", SearchOption.AllDirectories))
{
log.LogInformation($"adding {file}");
var zipPath = file.Substring(inputFolder.Length).Replace("\\", "/");
var entry = zip.CreateEntry(zipPath, CompressionLevel.Optimal);
using (var entryStream = entry.Open())
using (var inputStream = File.OpenRead(file))
{
inputStream.CopyTo(entryStream);
}
}
}
return(0);
});
}
public override async Task Invoke(IOwinContext context)
{
if (context.RespondNotModified())
{
return;
}
var q = context.Request.Query;
var hash = q["hash"];
var source = q["source"];
var packageId = q["packageId"];
var version = q["version"];
var targetFramework = q["targetFramework"];
var model = new CompatibilityModel
{
PackageSelector = new PackageSelectorModel
{
DefaultSource = source,
DefaultPackageId = packageId,
DefaultVersion = version,
DefaultTargetFramework = targetFramework
}
};
var statusCode = 200;
try
{
PackageFolderReader package;
if (string.IsNullOrEmpty(hash))
{
if (string.IsNullOrWhiteSpace(packageId))
{
// Homepage of NuGetCalc Online
await context.Response.View(new Views.CompatibilityStatic(), model.PackageSelector).ConfigureAwait(false);
return;
}
if (string.IsNullOrWhiteSpace(targetFramework))
{
statusCode = 400;
model.Error = "Target Framework is required.";
goto RESPOND;
}
NuGetVersion nugetVersion = null;
if (!string.IsNullOrWhiteSpace(version) && !NuGetVersion.TryParse(version, out nugetVersion))
{
statusCode = 400;
model.Error = "Version is not valid as NuGetVersion.";
goto RESPOND;
}
var packageDir = NuGetUtility.GetPackage(source, packageId, nugetVersion).Result; // avoid compile error on mono
package = new PackageFolderReader(packageDir);
}
else
{
package = new PackageFolderReader(NuGetUtility.GetUploadedPackage(hash));
model.PackageSelector.UploadHash = hash;
model.PackageSelector.UploadedPackage = package.GetIdentity();
}
using (package)
{
context.Request.CallCancelled.ThrowIfCancellationRequested();
var identity = package.GetIdentity();
model.PackageSelector.DefaultPackageId = identity.Id;
model.PackageSelector.DefaultVersion = identity.Version.ToString();
// NuGetFramework.Parse will throw only ArgumentNullException
var nugetFramework = NuGetFramework.Parse(targetFramework);
var referenceItems = NuGetUtility.FindMostCompatibleReferenceGroup(package, nugetFramework);
if (referenceItems != null)
{
model.ReferenceAssemblies = referenceItems.Items;
}
var depenencyItems = NuGetUtility.FindMostCompatibleDependencyGroup(package, nugetFramework);
if (depenencyItems != null)
{
model.Dependencies = depenencyItems.Packages;
}
}
GC.Collect(); // to release a handle of nuspec file
}
catch (NuGetUtilityException ex)
{
statusCode = 500;
model.Error = ex.Message;
if (ex.InnerException != null)
{
model.Exception = ex.InnerException;
}
}
RESPOND:
context.Response.StatusCode = statusCode;
await context.Response.View(new Views.Compatibility(), model).ConfigureAwait(false);
}