private static string FindMostRecentNupkg(string nupkgDirectory, string id)
{
var info = LocalFolderUtility.GetPackagesV2(nupkgDirectory, new TestLogger());
return(info.Where(t => t.Identity.Id.Equals(id, StringComparison.OrdinalIgnoreCase))
.Where(t => !Path.GetExtension(Path.GetFileNameWithoutExtension(t.Path)).Equals(".symbols"))
.OrderByDescending(p => p.LastWriteTimeUtc)
.First().Path);
}
public async Task RunToolWithCreateConfigVerifySuccess()
{
using (var testContext = new SleetTestContext())
{
var dir = Path.Combine(testContext.Root, "project");
Directory.CreateDirectory(dir);
var dotnetExe = GetDotnetPath();
var exeFile = new FileInfo(dotnetExe);
var nupkgsFolder = Path.Combine(exeFile.Directory.Parent.FullName, "artifacts", "nupkgs");
var sleetNupkg = LocalFolderUtility.GetPackagesV2(nupkgsFolder, "Sleet", NullLogger.Instance)
.OrderByDescending(e => e.Nuspec.GetVersion())
.First();
var sleetVersion = sleetNupkg.Nuspec.GetVersion().ToNormalizedString();
var result = await CmdRunner.RunAsync(dotnetExe, dir, "new classlib");
result.Success.Should().BeTrue();
var projectPath = Path.Combine(dir, "project.csproj");
var pathContext = NuGetPathContext.Create(dir);
var pathResolver = new FallbackPackagePathResolver(pathContext);
// Delete restore assets file
var toolInstallPath = Path.Combine(pathContext.UserPackageFolder, ".tools", "sleet");
Delete(new DirectoryInfo(toolInstallPath));
// Delete the tool package itself if it exists
var toolPackagePath = Path.Combine(pathContext.UserPackageFolder, "sleet", sleetVersion);
Delete(new DirectoryInfo(toolPackagePath));
// Add a reference to the tool
var xml = XDocument.Load(projectPath);
xml.Root.Add(new XElement(XName.Get("ItemGroup"),
new XElement(XName.Get("DotNetCliToolReference"),
new XAttribute("Include", "Sleet"),
new XAttribute("Version", sleetVersion))));
xml.Save(projectPath);
// Restore the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"restore --source {nupkgsFolder}");
result.Success.Should().BeTrue();
// Run the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"sleet createconfig");
result.Success.Should().BeTrue();
File.Exists(Path.Combine(dir, "sleet.json")).Should().BeTrue();
}
}
public override IEnumerable <LocalPackageInfo> GetPackages(ILogger logger, CancellationToken cancellationToken)
{
if (_delay.HasValue)
{
// intentional delay
Thread.Sleep(_delay.Value);
}
var packages = LocalFolderUtility.GetPackagesV2(Root, logger, cancellationToken);
// Filter out any duplicates that may appear in the folder multiple times.
return(LocalFolderUtility.GetDistinctPackages(packages));
}
IEnumerable <LocalPackageInfo> GetAllPackagesInFolder(string rootPath, NuGetDirectoryStructure nuGetDirectoryStructure)
{
var logger = new Logger(NuGet.Common.LogLevel.Information);
switch (nuGetDirectoryStructure)
{
case NuGetDirectoryStructure.V2:
return(LocalFolderUtility.GetPackagesV2(root: rootPath, log: logger));
case NuGetDirectoryStructure.V3:
return(LocalFolderUtility.GetPackagesV3(root: rootPath, log: logger));
}
return(new List <LocalPackageInfo>());
}
public static IEnumerable <LocalPackageInfo> GetPackages(string packagesPath, ILogger log = null)
{
var logger = log ?? NullLogger.Instance;
var type = LocalFolderUtility.GetLocalFeedType(packagesPath, logger);
switch (type)
{
case FeedType.FileSystemV2:
return(LocalFolderUtility.GetPackagesV2(packagesPath, logger));
case FeedType.FileSystemV3:
return(LocalFolderUtility.GetPackagesV3(packagesPath, logger));
default:
break;
}
return(new List <LocalPackageInfo>());
}
public async Task VerifyPackagesAreDownloadedInV2Structure()
{
// Arrange
using (var cache = new LocalCache())
using (var cacheContext = new SourceCacheContext())
using (var workingDir = new TestFolder())
{
var beforeDate = DateTimeOffset.UtcNow;
var catalogLog = new TestLogger();
var log = new TestLogger();
var baseUri = Sleet.UriUtility.CreateUri("https://localhost:8080/testFeed/");
var feedFolder = Path.Combine(workingDir, "feed");
var nupkgsFolder = Path.Combine(workingDir, "nupkgs");
var nupkgsOutFolder = Path.Combine(workingDir, "nupkgsout");
Directory.CreateDirectory(feedFolder);
Directory.CreateDirectory(nupkgsFolder);
Directory.CreateDirectory(nupkgsOutFolder);
var packageA = new TestNupkg("a", "1.0.0");
TestNupkg.Save(nupkgsFolder, packageA);
await CatalogReaderTestHelpers.CreateCatalogAsync(workingDir, feedFolder, nupkgsFolder, baseUri, catalogLog);
var feedUri = Sleet.UriUtility.CreateUri(baseUri.AbsoluteUri + "index.json");
var httpSource = CatalogReaderTestHelpers.GetHttpSource(cache, feedFolder, baseUri);
var args = new string[] { "nupkgs", "-o", nupkgsOutFolder, "--folder-format", "v2", feedUri.AbsoluteUri, "--delay", "0" };
var exitCode = await NuGetMirror.Program.MainCore(args, httpSource, log);
exitCode.Should().Be(0);
var results = LocalFolderUtility.GetPackagesV2(nupkgsOutFolder, catalogLog).ToList();
results.Select(e => e.Identity).ShouldBeEquivalentTo(new[] { new PackageIdentity("a", NuGetVersion.Parse("1.0.0")) });
var afterDate = DateTimeOffset.UtcNow;
var cursor = MirrorUtility.LoadCursor(new DirectoryInfo(nupkgsOutFolder));
(cursor <= afterDate && cursor >= beforeDate).Should().BeTrue("the cursor should match the catalog");
var errorLog = Path.Combine(nupkgsOutFolder, "lastRunErrors.txt");
File.Exists(errorLog).Should().BeFalse();
}
}
public async Task InstallToolVerifySuccess()
{
using (var testContext = new SleetTestContext())
{
var dir = Path.Combine(testContext.Root, "tooloutput");
Directory.CreateDirectory(dir);
var dotnetExe = GetDotnetPath();
var exeFile = new FileInfo(dotnetExe);
var nupkgsFolder = Path.Combine(exeFile.Directory.Parent.FullName, "artifacts", "nupkgs");
var packages = LocalFolderUtility.GetPackagesV2(nupkgsFolder, "Sleet", NullLogger.Instance).ToList();
if (packages.Count < 1)
{
throw new Exception("Run build.ps1 first to create the nupkgs.");
}
var sleetNupkg = packages
.OrderByDescending(e => e.Nuspec.GetVersion())
.First();
var sleetVersion = sleetNupkg.Nuspec.GetVersion().ToNormalizedString();
var result = await CmdRunner.RunAsync(dotnetExe, testContext.Root, $"tool install sleet --version {sleetVersion} --add-source {nupkgsFolder} --tool-path {dir}");
result.Success.Should().BeTrue(result.AllOutput);
var sleetDllPath = Path.Combine(dir, ".store", "sleet", sleetVersion, "sleet", sleetVersion, "tools", "net5.0", "any", "Sleet.dll");
if (!File.Exists(sleetDllPath))
{
throw new Exception("Tool did not install to the expected location: " + sleetDllPath);
}
// Run the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"{sleetDllPath} createconfig");
result.Success.Should().BeTrue(result.AllOutput);
File.Exists(Path.Combine(dir, "sleet.json")).Should().BeTrue("sleet should have generated the config file");
}
}
public async Task RunToolVerifySuccess()
{
using (var testContext = new TestFolder())
{
var dir = Path.Combine(testContext.Root, "tooloutput");
Directory.CreateDirectory(dir);
var dotnetExe = GetDotnetPath();
var exeFile = new FileInfo(dotnetExe);
var nupkgsFolder = Path.Combine(exeFile.Directory.Parent.FullName, "artifacts", "nupkgs");
var packages = LocalFolderUtility.GetPackagesV2(nupkgsFolder, "NupkgWrench", NullLogger.Instance).ToList();
if (packages.Count < 1)
{
throw new Exception("Run build.ps1 first to create the nupkgs.");
}
var nupkg = packages
.OrderByDescending(e => e.Nuspec.GetVersion())
.First();
var version = nupkg.Nuspec.GetVersion().ToNormalizedString();
var result = await CmdRunner.RunAsync(dotnetExe, testContext.Root, $"tool install nupkgwrench --version {version} --add-source {nupkgsFolder} --tool-path {dir}");
result.Success.Should().BeTrue(result.AllOutput);
var dllPath = Path.Combine(dir, ".store", "nupkgwrench", version, "nupkgwrench", version, "tools", "netcoreapp2.1", "any", "NupkgWrench.dll");
if (!File.Exists(dllPath))
{
throw new Exception("Tool did not install to the expected location: " + dllPath);
}
// Run the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"{dllPath} list");
result.Errors.Should().BeNullOrEmpty(result.Errors);
result.Success.Should().BeTrue(result.AllOutput);
}
}
public IReadOnlyCollection <IOptionalSdkTemplatePackageInfo> GetDotnetSdkTemplatePackages(string sdkVersion)
{
if (_dotnetSdkTemplatesLocation == null)
{
return(Array.Empty <IOptionalSdkTemplatePackageInfo>());
}
IEnumerable <LocalPackageInfo> packages = LocalFolderUtility
.GetPackagesV2(_dotnetSdkTemplatesLocation.FullName, new NullLogger());
if (packages == null)
{
return(Array.Empty <IOptionalSdkTemplatePackageInfo>());
}
else
{
return(packages
.Select(l => new OptionalSdkTemplatePackageInfo(l)).ToArray());
}
}
/// <summary>
/// Asynchronously gets installed packages.
/// </summary>
/// <remarks>This is used only for the install command, not in PM.</remarks>
/// <param name="token">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns an
/// <see cref="IEnumerable{PackageReference}" />.</returns>
public Task <IEnumerable <PackageReference> > GetFolderPackagesAsync(CancellationToken token)
{
var packages = Enumerable.Empty <LocalPackageInfo>();
if (Directory.Exists(Root))
{
if (_packagePathResolver.UseSideBySidePaths)
{
// Id.Version
packages = LocalFolderUtility.GetPackagesConfigFolderPackages(Root, NullLogger.Instance);
}
else
{
// Id
packages = LocalFolderUtility.GetPackagesV2(Root, NullLogger.Instance);
}
}
return(Task.FromResult <IEnumerable <PackageReference> >(
LocalFolderUtility.GetDistinctPackages(packages)
.Select(e => new PackageReference(e.Identity, _framework))
.ToList()));
}
private Action <HttpListenerResponse> ServerHandlerV3(HttpListenerRequest request)
{
try
{
var path = GetRequestUrlAbsolutePath(request);
var parts = request.Url.AbsolutePath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (path.StartsWith("/flat/") && path.EndsWith("/index.json"))
{
return(new Action <HttpListenerResponse>(response =>
{
response.ContentType = "application/javascript";
var versionsJson = JObject.Parse(@"{ ""versions"": [] }");
var array = versionsJson["versions"] as JArray;
var id = parts[parts.Length - 2];
foreach (var pkg in LocalFolderUtility.GetPackagesV2(_packageDirectory, id, NullLogger.Instance))
{
array.Add(pkg.Identity.Version.ToNormalizedString());
}
SetResponseContent(response, versionsJson.ToString());
}));
}
else if (path.StartsWith("/flat/") && path.EndsWith(".nupkg"))
{
var file = new FileInfo(Path.Combine(_packageDirectory, parts.Last()));
if (file.Exists)
{
return(new Action <HttpListenerResponse>(response =>
{
response.ContentType = "application/zip";
using (var stream = file.OpenRead())
{
var content = ReadAllBytes(stream);
SetResponseContent(response, content);
}
}));
}
else
{
return(new Action <HttpListenerResponse>(response =>
{
response.StatusCode = 404;
}));
}
}
else if (path == "/nuget")
{
return(new Action <HttpListenerResponse>(response =>
{
response.StatusCode = 200;
}));
}
else if (path.StartsWith("/reg/") && path.EndsWith("/index.json"))
{
var id = parts[parts.Length - 2];
var packages = LocalFolderUtility.GetPackagesV2(_packageDirectory, id, NullLogger.Instance);
if (packages.Any())
{
return(new Action <HttpListenerResponse>(response =>
{
response.ContentType = "text/javascript";
var packageToListedMapping = packages.Select(e => new KeyValuePair <PackageIdentity, bool>(e.Identity, !UnlistedPackages.Contains(e.Identity))).ToArray();
MockResponse mockResponse = _builder.BuildRegistrationIndexResponse(ServiceIndexUri, packageToListedMapping);
SetResponseContent(response, mockResponse.Content);
}));
}
else
{
return(new Action <HttpListenerResponse>(response =>
{
response.StatusCode = 404;
}));
}
}
else
{
throw new Exception("This test needs to be updated to support: " + path);
}
}
catch (Exception)
{
// Debug here
throw;
}
}
private Action <HttpListenerResponse> ServerHandlerV3(
HttpListenerRequest request,
MockServer server,
JObject indexJson,
string repositoryPath)
{
try
{
var path = server.GetRequestUrlAbsolutePath(request);
var parts = request.Url.AbsolutePath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (path == "/index.json")
{
return(new Action <HttpListenerResponse>(response =>
{
response.StatusCode = 200;
response.ContentType = "text/javascript";
MockServer.SetResponseContent(response, indexJson.ToString());
}));
}
else if (path.StartsWith("/flat/") && path.EndsWith("/index.json"))
{
return(new Action <HttpListenerResponse>(response =>
{
response.ContentType = "text/javascript";
var versionsJson = JObject.Parse(@"{ ""versions"": [] }");
var array = versionsJson["versions"] as JArray;
var id = parts[parts.Length - 2];
foreach (var pkg in LocalFolderUtility.GetPackagesV2(repositoryPath, id, new TestLogger()))
{
array.Add(pkg.Identity.Version.ToNormalizedString());
}
MockServer.SetResponseContent(response, versionsJson.ToString());
}));
}
else if (path.StartsWith("/flat/") && path.EndsWith(".nupkg"))
{
var file = new FileInfo(Path.Combine(repositoryPath, parts.Last()));
if (file.Exists)
{
return(new Action <HttpListenerResponse>(response =>
{
response.ContentType = "application/zip";
using (var stream = file.OpenRead())
{
var content = stream.ReadAllBytes();
MockServer.SetResponseContent(response, content);
}
}));
}
else
{
return(new Action <HttpListenerResponse>(response =>
{
response.StatusCode = 404;
}));
}
}
else if (path == "/nuget")
{
return(new Action <HttpListenerResponse>(response =>
{
response.StatusCode = 200;
}));
}
throw new Exception("This test needs to be updated to support: " + path);
}
catch (Exception)
{
// Debug here
throw;
}
}
private void AddPackagesFromDropFolder()
{
_logger.Info("Start adding packages from drop folder.");
using (LockAndSuppressFileSystemWatcher())
{
try
{
var localPackages = LocalFolderUtility.GetPackagesV2(_fileSystem.Root, _logAdapter);
var serverPackages = new HashSet <ServerPackage>(PackageEqualityComparer.IdAndVersion);
foreach (var package in localPackages)
{
try
{
//TODO ignoring symbols packages
// // Is it a symbols package?
// if (IgnoreSymbolsPackages && package.IsSymbolsPackage())
// {
// var message = string.Format("Package {0} is a symbols package (it contains .pdb files and a /src folder). The server is configured to ignore symbols packages.", package);
// _logger.Error(message);
// continue;
// }
// Allow overwriting package? If not, skip this one.
if (!AllowOverrideExistingPackageOnPush && _expandedPackageRepository.Exists(package.Identity.Id, package.Identity.Version))
{
var message = string.Format("Package {0} already exists. The server is configured to not allow overwriting packages that already exist.", package);
_logger.Error(message);
continue;
}
// Copy to correct filesystem location
var added = _expandedPackageRepository.AddPackage(package);
_fileSystem.DeleteFile(package.Path);
// Mark for addition to metadata store
serverPackages.Add(CreateServerPackage(added, EnableDelisting));
}
catch (UnauthorizedAccessException ex)
{
// The file may be in use (still being copied) - ignore the error
_logger.ErrorFormat("Error adding package file {0} from drop folder: {1}", package.Path, ex.Message);
}
catch (IOException ex)
{
// The file may be in use (still being copied) - ignore the error
_logger.ErrorFormat("Error adding package file {0} from drop folder: {1}", package.Path, ex.Message);
}
}
// Add packages to metadata store in bulk
_serverPackageStore.StoreRange(serverPackages);
_serverPackageStore.PersistIfDirty();
_logger.Info("Finished adding packages from drop folder.");
}
finally
{
//OptimizedZipPackage.PurgeCache();
}
}
}
