public async Task GetComponent_WithGithubLicenseResolutionDisabled_DoesntResolveGithubLicense()
{
var mockResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<licenseUrl>https://www.example.com/license</licenseUrl>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond("application/xml", mockResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(
new MockFileSystem(),
new List <string>(),
null,
client);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3", Component.ComponentScope.Required).ConfigureAwait(false);
Assert.Collection(component.Licenses,
item => {
Assert.Null(item.License.Id);
Assert.Null(item.License.Name);
Assert.Equal("https://www.example.com/license", item.License.Url);
});
}
public async Task GetComponent_FromNugetOrg_ReturnsComponentWithHash()
{
var mockNuspecResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<name>testpackage</name>
</metadata>
</package>";
var mockNugetResponseContent = @"123464dfdgfgr87rgDSGSGGDgdg4s58g6f7g5d;';243'2;446";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/testpackage/1.0.0/testpackage.nuspec")
.Respond("application/xml", mockNuspecResponseContent);
mockHttp.When("https://api.nuget.org/v3-flatcontainer/testpackage/1.0.0/testpackage.1.0.0.nupkg")
.Respond("application/xml", mockNugetResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(
new MockFileSystem(),
new List <string>(),
new Mock <IGithubService>().Object,
client);
var component = await nugetService.GetComponentAsync("testpackage", "1.0.0", Component.ComponentScope.Required).ConfigureAwait(false);
byte[] hashBytes;
using (SHA512 sha = new SHA512Managed())
{
hashBytes = sha.ComputeHash(Encoding.UTF8.GetBytes(mockNugetResponseContent));
}
Assert.Equal("testpackage", component.Name);
Assert.Equal(Hash.HashAlgorithm.SHA_512, component.Hashes[0].Alg);
Assert.Equal(BitConverter.ToString(hashBytes).Replace("-", string.Empty), component.Hashes[0].Content);
}
public async Task GetComponent_FromNugetOrg_DoNotReturnsHash_WhenDisabled()
{
var mockNuspecResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<name>testpackage</name>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/testpackage/1.0.0/testpackage.nuspec")
.Respond("application/xml", mockNuspecResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(
new MockFileSystem(),
new List <string>(),
new Mock <IGithubService>().Object,
client,
disableHashComputation: true);
var component = await nugetService.GetComponentAsync("testpackage", "1.0.0", Component.ComponentScope.Required).ConfigureAwait(false);
Assert.Equal("testpackage", component.Name);
Assert.Null(component.Hashes);
}
public async Task GetComponent_FromCachedNugetFile_ReturnsComponentWithHash()
{
var nuspecFileContents = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<id>testpackage</id>
</metadata>
</package>";
var nugetFileContent = "FooBarBaz";
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\nugetcache\testpackage\1.0.0\testpackage.nuspec"), new MockFileData(nuspecFileContents) },
{ XFS.Path(@"c:\nugetcache\testpackage\1.0.0\testpackage.1.0.0.nupkg"), new MockFileData(nugetFileContent) },
});
var nugetService = new NugetService(
mockFileSystem,
new List <string> {
XFS.Path(@"c:\nugetcache")
},
new Mock <IGithubService>().Object,
new HttpClient());
var component = await nugetService.GetComponentAsync("testpackage", "1.0.0", Component.ComponentScope.Required).ConfigureAwait(false);
byte[] hashBytes;
using (SHA512 sha = new SHA512Managed())
{
hashBytes = sha.ComputeHash(Encoding.UTF8.GetBytes(nugetFileContent));
}
Assert.Equal(Hash.HashAlgorithm.SHA_512, component.Hashes[0].Alg);
Assert.Equal(BitConverter.ToString(hashBytes).Replace("-", string.Empty), component.Hashes[0].Content);
}
public async Task GetComponent_FromCachedNugetFile_DoNotReturnsHash_WhenDisabled()
{
var nuspecFileContents = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<id>testpackage</id>
</metadata>
</package>";
var nugetFileContent = "FooBarBaz";
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\nugetcache\testpackage\1.0.0\testpackage.nuspec"), new MockFileData(nuspecFileContents) },
{ XFS.Path(@"c:\nugetcache\testpackage\1.0.0\testpackage.1.0.0.nupkg"), new MockFileData(nugetFileContent) },
});
var nugetService = new NugetService(
mockFileSystem,
new List <string> {
XFS.Path(@"c:\nugetcache")
},
new Mock <IGithubService>().Object,
new HttpClient(),
disableHashComputation: true);
var component = await nugetService.GetComponentAsync("testpackage", "1.0.0", Component.ComponentScope.Required).ConfigureAwait(false);
Assert.Null(component.Hashes);
}
public async Task GetComponent_FromCachedNugetHashFile_ReturnsComponentWithHash()
{
var nuspecFileContents = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<id>testpackage</id>
</metadata>
</package>";
byte[] sampleHash = new byte[] { 1, 2, 3, 4, 5, 6, 78, 125, 200 };
var nugetHashFileContents = Convert.ToBase64String(sampleHash);
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\nugetcache\testpackage\1.0.0\testpackage.nuspec"), new MockFileData(nuspecFileContents) },
{ XFS.Path(@"c:\nugetcache\testpackage\1.0.0\testpackage.1.0.0.nupkg.sha512"), new MockFileData(nugetHashFileContents) },
});
var nugetService = new NugetService(
mockFileSystem,
new List <string> {
XFS.Path(@"c:\nugetcache")
},
new Mock <IGithubService>().Object,
new HttpClient());
var component = await nugetService.GetComponentAsync("testpackage", "1.0.0", Component.ComponentScope.Required).ConfigureAwait(false);
Assert.Equal(Hash.HashAlgorithm.SHA_512, component.Hashes[0].Alg);
Assert.Equal(BitConverter.ToString(sampleHash).Replace("-", string.Empty), component.Hashes[0].Content);
}
public NugetServiceTests([NotNull] BaseFixture baseFixture)
{
_baseFixture = baseFixture ?? throw new ArgumentNullException(nameof(baseFixture));
_snapFilesystem = new SnapFilesystem();
_nugetService = new NugetService(_snapFilesystem, new NugetLogger(new LogProvider.NoOpLogger()));
_snapFilesystem = new SnapFilesystem();
}
public void StartAndStopTest()
{
Topshelf.HostControl hostControl = null;
NugetService service = new NugetService();
service.Start(hostControl);
service.Stop(hostControl);
}
static void Main(string[] args)
{
var nugetSolutionPath = Path.Combine(basePath, nugetSolutionName);
var testsSolutionPath = Path.Combine(basePath, testSolutionName);
// Get all files in test solution
var files = SolutionService.GetFilesFromTestSolution(testsSolutionPath, excludes);
// Create list for succeeded file writes
var succeededFilePaths = new List <string>();
// Ensure content folder exists and is empty
var contentFolderPath = Path.Combine(nugetSolutionPath, "content");
if (Directory.Exists(contentFolderPath))
{
Directory.Delete(contentFolderPath, true);
}
Directory.CreateDirectory(contentFolderPath);
// Ensure contentFiles folder exists and is empty
var contentFilesFolderPath = Path.Combine(nugetSolutionPath, "contentFiles");
if (Directory.Exists(contentFilesFolderPath))
{
Directory.Delete(contentFilesFolderPath, true);
}
Directory.CreateDirectory(contentFilesFolderPath);
// Write tests to nuget solution
foreach (var file in files)
{
var ppText = NugetService.AddReplacementPlaceholdersToFile(file, testSolutionName);
var relativePath = SolutionService.WriteFileToNugetSolution(file, ppText, nugetSolutionPath, testsSolutionPath);
if (string.IsNullOrWhiteSpace(relativePath))
{
Console.WriteLine($"Could not write the file {file.FullName} to nuget solution");
continue;
}
succeededFilePaths.Add(relativePath);
}
// Update .nuspec file
if (!NugetService.AddContentFilesToNuspec(nugetSolutionPath, succeededFilePaths, targets.Values))
{
Console.WriteLine("Failed to write .nuspecfile");
}
else
{
Console.WriteLine("Nuget project and .nuspec file successfully updated");
}
// TODO: Update .sln and .csproj file
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void Initialize()
{
this.mockVisualStudioService = new Mock<IVisualStudioService>();
this.mockDTEService = new Mock<IDTEService>();
this.mockVisualStudioService.SetupGet(x => x.DTEService).Returns(this.mockDTEService.Object);
this.service = new NugetService();
}
public NugetServiceSpecs()
{
service = new NugetService(
new Mock <IRegistryService>().Object,
fileSystem.Object,
new Mock <IChocolateyPackageInformationService>().Object, filesService.Object,
new Mock <IPackageDownloader>().Object
);
}
public override void Context()
{
fileSystem.ResetCalls();
nugetLogger.ResetCalls();
packageInfoService.ResetCalls();
filesService.ResetCalls();
package.ResetCalls();
service = new NugetService(fileSystem.Object, nugetLogger.Object, packageInfoService.Object, filesService.Object, packageDownloader.Object);
}
public async Task GetImplicitVersionComponent_ReturnsNull()
{
var mockHttp = new MockHttpMessageHandler();
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(client, new Mock <IGithubService>().Object);
var component = await nugetService.GetComponentAsync("PackageName", "");
Assert.Null(component);
}
public async Task GetImaginaryComponent_ReturnsComponent()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond(System.Net.HttpStatusCode.NotFound);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(client, new Mock <IGithubService>().Object);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3");
Assert.Equal("PackageName", component.Name);
Assert.Equal("1.2.3", component.Version);
}
public async Task GetComponent_FromNugetOrgWhichDoesntExist_ReturnsComponent()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/testpackage/1.0.0/testpackage.nuspec")
.Respond(HttpStatusCode.NotFound);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(
new MockFileSystem(),
new List <string>(),
new Mock <IGithubService>().Object,
client);
var component = await nugetService.GetComponentAsync("testpackage", "1.0.0", Component.ComponentScope.Required).ConfigureAwait(false);
Assert.Equal("testpackage", component.Name);
}
public async Task GetComponent_ReturnsPublisher()
{
var mockResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<authors>Authors</authors>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond("application/xml", mockResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(client, new Mock <IGithubService>().Object);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3");
Assert.Equal("Authors", component.Publisher);
}
public async Task GetComponent_WithoutDescription_ReturnsNugetTitle()
{
var mockResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<title>Package title</title>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond("application/xml", mockResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(httpClient: client);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3");
Assert.Equal("Package title", component.Description);
}
public async Task GetComponent_ReturnsLicenseUrl()
{
var mockResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<licenseUrl>https://www.example.com/license</licenseUrl>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond("application/xml", mockResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(httpClient: client);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3");
Assert.Collection(component.Licenses,
item => Assert.Equal("https://www.example.com/license", item.Url));
}
public async Task GetComponent_ReturnsDependencies()
{
var mockResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<dependencies>
<dependency id=""Dependency1"" version=""1.2.3""/>
<dependency id=""Dependency2"" version=""1.0.0""/>
<dependency id=""Dependency3"" version=""3.0.1""/>
</dependencies>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond("application/xml", mockResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(client, new Mock <IGithubService>().Object);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3");
var orderedDependencies = new List <Models.NugetPackage>(component.Dependencies);
orderedDependencies.Sort();
Assert.Collection(orderedDependencies,
item => {
Assert.Equal("Dependency1", item.Name);
Assert.Equal("1.2.3", item.Version);
},
item => {
Assert.Equal("Dependency2", item.Name);
Assert.Equal("1.0.0", item.Version);
},
item => {
Assert.Equal("Dependency3", item.Name);
Assert.Equal("3.0.1", item.Version);
});
}
public async Task GetComponent_WithGithubLicense_ReturnsGithubLicense()
{
var mockResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<licenseUrl>https://www.example.com/license</licenseUrl>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond("application/xml", mockResponseContent);
var client = mockHttp.ToHttpClient();
var mockGithubService = new Mock <IGithubService>();
mockGithubService
.Setup(service => service.GetLicenseAsync(It.IsAny <string>()))
.ReturnsAsync(new Models.v1_3.License
{
Id = "TestLicenseId",
Name = "Test License",
Url = "https://www.example.com/LICENSE"
});
var nugetService = new NugetService(
new MockFileSystem(),
new List <string>(),
mockGithubService.Object,
client);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3", Component.ComponentScope.Required).ConfigureAwait(false);
Assert.Collection(component.Licenses,
item => {
Assert.Equal("TestLicenseId", item.License.Id);
Assert.Equal("Test License", item.License.Name);
Assert.Equal("https://www.example.com/LICENSE", item.License.Url);
});
}
public async Task GetComponent_ReturnsLicense()
{
var mockResponseContent = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<license type=""expression"">Apache-2.0</license>
</metadata>
</package>";
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("https://api.nuget.org/v3-flatcontainer/PackageName/1.2.3/PackageName.nuspec")
.Respond("application/xml", mockResponseContent);
var client = mockHttp.ToHttpClient();
var nugetService = new NugetService(client, new Mock <IGithubService>().Object);
var component = await nugetService.GetComponentAsync("PackageName", "1.2.3");
Assert.Collection(component.Licenses,
item => {
Assert.Equal("Apache-2.0", item.Id);
Assert.Equal("Apache-2.0", item.Name);
});
}
public void GetCachedNuspecFilename_ReturnsFullPath()
{
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\nugetcache1\dummypackage\1.2.3\dummypackage.nuspec"), "" },
{ XFS.Path(@"c:\nugetcache2\testpackage\1.2.3\testpackage.nuspec"), "" },
});
var cachePaths = new List <string>
{
XFS.Path(@"c:\nugetcache1"),
XFS.Path(@"c:\nugetcache2"),
};
var mockGithubService = new Mock <IGithubService>();
var nugetService = new NugetService(
mockFileSystem,
cachePaths,
mockGithubService.Object,
new HttpClient());
var nuspecFilename = nugetService.GetCachedNuspecFilename("TestPackage", "1.2.3");
Assert.Equal(XFS.Path(@"c:\nugetcache2\testpackage\1.2.3\testpackage.nuspec"), nuspecFilename);
}
public async Task GetComponent_FromCachedNuspecFile_ReturnsComponent()
{
var nuspecFileContents = @"<?xml version=""1.0"" encoding=""utf-8""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
<metadata>
<id>testpackage</id>
</metadata>
</package>";
var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ XFS.Path(@"c:\nugetcache\testpackage\1.0.0\testpackage.nuspec"), new MockFileData(nuspecFileContents) },
});
var nugetService = new NugetService(
mockFileSystem,
new List <string> {
XFS.Path(@"c:\nugetcache")
},
new Mock <IGithubService>().Object,
new HttpClient());
var component = await nugetService.GetComponentAsync("testpackage", "1.0.0", "required").ConfigureAwait(false);
Assert.Equal("testpackage", component.Name);
}
static int MainImplAsync([NotNull] string[] args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
using var cts = new CancellationTokenSource();
ISnapOs snapOs;
try
{
snapOs = SnapOs.AnyOs;
}
catch (PlatformNotSupportedException)
{
SnapLogger.Error($"Platform is not supported: {RuntimeInformation.OSDescription}");
return(1);
}
catch (Exception e)
{
SnapLogger.ErrorException("Exception thrown while initializing snap os", e);
return(1);
}
snapOs.InstallExitSignalHandler(async() =>
{
cts.Cancel();
await OnExitAsync();
});
var workingDirectory = Environment.CurrentDirectory;
if (!workingDirectory.EndsWith(snapOs.Filesystem.DirectorySeparator))
{
workingDirectory += snapOs.Filesystem.DirectorySeparator;
}
var toolWorkingDirectory = snapOs.Filesystem.PathGetDirectoryName(typeof(Program).Assembly.Location);
var snapCryptoProvider = new SnapCryptoProvider();
var snapEmbeddedResources = new SnapEmbeddedResources();
snapEmbeddedResources.ExtractCoreRunLibAsync(snapOs.Filesystem, snapCryptoProvider,
toolWorkingDirectory, snapOs.OsPlatform).GetAwaiter().GetResult();
var snapXEmbeddedResources = new SnapxEmbeddedResources();
var coreRunLib = new CoreRunLib(snapOs.Filesystem, snapOs.OsPlatform, toolWorkingDirectory);
var snapAppReader = new SnapAppReader();
var snapAppWriter = new SnapAppWriter();
var snapPack = new SnapPack(snapOs.Filesystem, snapAppReader, snapAppWriter, snapCryptoProvider, snapEmbeddedResources);
var snapExtractor = new SnapExtractor(snapOs.Filesystem, snapPack, snapEmbeddedResources);
var snapSpecsReader = new SnapAppReader();
var snapNetworkTimeProvider = new SnapNetworkTimeProvider("time.cloudflare.com", 123);
var snapHttpClient = new SnapHttpClient(new HttpClient());
var nugetServiceCommandPack = new NugetService(snapOs.Filesystem, new NugetLogger(SnapPackLogger));
var nugetServiceCommandPromote = new NugetService(snapOs.Filesystem, new NugetLogger(SnapPromoteLogger));
var nugetServiceCommandDemote = new NugetService(snapOs.Filesystem, new NugetLogger(SnapDemoteLogger));
var nugetServiceCommandRestore = new NugetService(snapOs.Filesystem, new NugetLogger(SnapRestoreLogger));
var nugetServiceNoopLogger = new NugetService(snapOs.Filesystem, new NugetLogger(new LogProvider.NoOpLogger()));
var snapPackageRestorer = new SnapPackageManager(snapOs.Filesystem, snapOs.SpecialFolders,
nugetServiceCommandPack, snapHttpClient,
snapCryptoProvider, snapExtractor, snapAppReader, snapPack);
var distributedMutexClient = new DistributedMutexClient(new JsonServiceClient("https://snapx.dev"));
Console.CancelKeyPress += async(sender, eventArgs) =>
{
eventArgs.Cancel = !cts.IsCancellationRequested;
cts.Cancel();
await OnExitAsync();
};
return(MainAsync(args, coreRunLib, snapOs, snapExtractor, snapOs.Filesystem,
snapSpecsReader, snapCryptoProvider,
snapPack, snapAppWriter, snapXEmbeddedResources, snapPackageRestorer, snapNetworkTimeProvider,
nugetServiceCommandPack, nugetServiceCommandPromote, nugetServiceCommandDemote,
nugetServiceCommandRestore, nugetServiceNoopLogger, distributedMutexClient,
toolWorkingDirectory, workingDirectory, cts.Token));
}
async Task <int> OnExecuteAsync()
{
Console.WriteLine();
// check parameter values
if (string.IsNullOrEmpty(SolutionOrProjectFile))
{
Console.Error.WriteLine($"A path is required");
return((int)ExitCode.SolutionOrProjectFileParameterMissing);
}
if (string.IsNullOrEmpty(outputDirectory))
{
Console.Error.WriteLine($"The output directory is required");
return((int)ExitCode.OutputDirectoryParameterMissing);
}
if ((string.IsNullOrEmpty(githubUsername) ^ string.IsNullOrEmpty(githubToken)) ||
(string.IsNullOrEmpty(githubUsernameDeprecated) ^ string.IsNullOrEmpty(githubTokenDeprecated)))
{
Console.Error.WriteLine($"Both GitHub username and token are required");
return((int)ExitCode.GitHubParameterMissing);
}
dotnetCommandService.TimeoutMilliseconds = dotnetCommandTimeout;
// retrieve nuget package cache paths
var packageCachePathsResult = dotnetUtilsService.GetPackageCachePaths();
if (!packageCachePathsResult.Success)
{
Console.Error.WriteLine("Unable to find local package cache locations...");
Console.Error.WriteLine(packageCachePathsResult.ErrorMessage);
return((int)ExitCode.LocalPackageCacheError);
}
Console.WriteLine("Found the following local nuget package cache locations:");
foreach (var path in packageCachePathsResult.Result)
{
Console.WriteLine($" {path}");
}
// instantiate services
var fileDiscoveryService = new FileDiscoveryService(Program.fileSystem);
GithubService githubService = null;
if (!(disableGithubLicenses || disableGithubLicensesDeprecated))
{
// GitHubService requires its own HttpClient as it adds a default authorization header
if (!string.IsNullOrEmpty(githubBearerToken))
{
githubService = new GithubService(new HttpClient(), githubBearerToken);
}
else if (!string.IsNullOrEmpty(githubBearerTokenDeprecated))
{
githubService = new GithubService(new HttpClient(), githubBearerTokenDeprecated);
}
else if (!string.IsNullOrEmpty(githubUsername))
{
githubService = new GithubService(new HttpClient(), githubUsername, githubToken);
}
else if (!string.IsNullOrEmpty(githubUsernameDeprecated))
{
githubService = new GithubService(new HttpClient(), githubUsernameDeprecated, githubTokenDeprecated);
}
else
{
githubService = new GithubService(new HttpClient());
}
}
var nugetService = new NugetService(
Program.fileSystem,
packageCachePathsResult.Result,
githubService,
Program.httpClient,
baseUrl);
var packages = new HashSet <NugetPackage>();
// determine what we are analyzing and do the analysis
var fullSolutionOrProjectFilePath = Program.fileSystem.Path.GetFullPath(SolutionOrProjectFile);
var attr = Program.fileSystem.File.GetAttributes(fullSolutionOrProjectFilePath);
try
{
if (SolutionOrProjectFile.ToLowerInvariant().EndsWith(".sln", StringComparison.OrdinalIgnoreCase))
{
packages = await solutionFileService.GetSolutionNugetPackages(fullSolutionOrProjectFilePath).ConfigureAwait(false);
}
else if (Core.Utils.IsSupportedProjectType(SolutionOrProjectFile) && scanProjectReferences)
{
packages = await projectFileService.RecursivelyGetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath).ConfigureAwait(false);
}
else if (Core.Utils.IsSupportedProjectType(SolutionOrProjectFile))
{
packages = await projectFileService.GetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath).ConfigureAwait(false);
}
else if (Program.fileSystem.Path.GetFileName(SolutionOrProjectFile).ToLowerInvariant().Equals("packages.config", StringComparison.OrdinalIgnoreCase))
{
packages = await packagesFileService.GetNugetPackagesAsync(fullSolutionOrProjectFilePath).ConfigureAwait(false);
}
else if (attr.HasFlag(FileAttributes.Directory))
{
packages = await packagesFileService.RecursivelyGetNugetPackagesAsync(fullSolutionOrProjectFilePath).ConfigureAwait(false);
}
else
{
Console.Error.WriteLine($"Only .sln, .csproj, .vbproj, and packages.config files are supported");
return((int)ExitCode.InvalidOptions);
}
}
catch (DotnetRestoreException)
{
return((int)ExitCode.DotnetRestoreFailed);
}
// get all the components from the NuGet packages
var components = new HashSet <Component>();
try
{
foreach (var package in packages)
{
var component = await nugetService.GetComponentAsync(package).ConfigureAwait(false);
if (component != null &&
(component.Scope != "excluded" || !excludeDev)
)
{
components.Add(component);
}
}
}
catch (InvalidGitHubApiCredentialsException)
{
return((int)ExitCode.InvalidGitHubApiCredentials);
}
catch (GitHubApiRateLimitExceededException)
{
return((int)ExitCode.GitHubApiRateLimitExceeded);
}
catch (GitHubLicenseResolutionException)
{
return((int)ExitCode.GitHubLicenseResolutionFailed);
}
// create the BOM
Console.WriteLine();
Console.WriteLine("Creating CycloneDX BOM");
var bom = new Bom();
if (!(noSerialNumber || noSerialNumberDeprecated))
{
bom.SerialNumber = "urn:uuid:" + System.Guid.NewGuid().ToString();
}
bom.Components = components;
var bomContents = BomService.CreateDocument(bom, json);
// check if the output directory exists and create it if needed
var bomPath = Program.fileSystem.Path.GetFullPath(outputDirectory);
if (!Program.fileSystem.Directory.Exists(bomPath))
{
Program.fileSystem.Directory.CreateDirectory(bomPath);
}
// write the BOM to disk
var bomFilename = Program.fileSystem.Path.Combine(bomPath, json ? "bom.json" : "bom.xml");
Console.WriteLine("Writing to: " + bomFilename);
Program.fileSystem.File.WriteAllText(bomFilename, bomContents);
return(0);
}
static async Task <(int exitCode, SnapInstallerType installerType)> MainImplAsync([NotNull] ISnapInstallerEnvironment snapInstallerEnvironment,
[NotNull] ILog snapInstallerLogger, bool headless)
{
if (snapInstallerEnvironment == null)
{
throw new ArgumentNullException(nameof(snapInstallerEnvironment));
}
if (snapInstallerLogger == null)
{
throw new ArgumentNullException(nameof(snapInstallerLogger));
}
var snapOs = snapInstallerEnvironment.Container.GetInstance <ISnapOs>();
var snapEmbeddedResources = snapInstallerEnvironment.Container.GetInstance <ISnapEmbeddedResources>();
var snapCryptoProvider = snapInstallerEnvironment.Container.GetInstance <ISnapCryptoProvider>();
var thisExeWorkingDirectory = snapInstallerEnvironment.Io.ThisExeWorkingDirectory;
var workingDirectory = snapInstallerEnvironment.Io.WorkingDirectory;
TplHelper.RunSync(() => snapEmbeddedResources.ExtractCoreRunLibAsync(snapOs.Filesystem, snapCryptoProvider, thisExeWorkingDirectory, snapOs.OsPlatform));
var coreRunLib = new CoreRunLib(snapOs.Filesystem, snapOs.OsPlatform, thisExeWorkingDirectory);
var snapInstaller = snapInstallerEnvironment.Container.GetInstance <ISnapInstaller>();
var snapInstallerEmbeddedResources = snapInstallerEnvironment.Container.GetInstance <ISnapInstallerEmbeddedResources>();
var snapPack = snapInstallerEnvironment.Container.GetInstance <ISnapPack>();
var snapAppReader = snapInstallerEnvironment.Container.GetInstance <ISnapAppReader>();
var snapAppWriter = snapInstallerEnvironment.Container.GetInstance <ISnapAppWriter>();
var snapFilesystem = snapInstallerEnvironment.Container.GetInstance <ISnapFilesystem>();
snapFilesystem.DirectoryCreateIfNotExists(snapOs.SpecialFolders.InstallerCacheDirectory);
var snapPackageManager = snapInstallerEnvironment.Container.GetInstance <ISnapPackageManager>();
var snapExtractor = snapInstallerEnvironment.Container.GetInstance <ISnapExtractor>();
var nugetServiceCommandInstall = new NugetService(snapOs.Filesystem, new NugetLogger(snapInstallerLogger));
Task <(int exitCode, SnapInstallerType installerType)> RunInstallerAsync()
{
return(InstallAsync(snapInstallerEnvironment, snapInstallerEmbeddedResources,
snapInstaller, snapFilesystem, snapPack, snapOs, coreRunLib, snapAppReader,
snapAppWriter, nugetServiceCommandInstall, snapPackageManager, snapExtractor, snapInstallerLogger,
headless));
}
try
{
var mutexName = snapCryptoProvider.Sha256(Encoding.UTF8.GetBytes(workingDirectory));
_mutexSingleInstanceWorkingDirectory = new Mutex(true, $"Global\\{mutexName}", out var createdNew);
if (!createdNew)
{
snapInstallerLogger.Error("Setup is already running, exiting...");
return(1, SnapInstallerType.None);
}
_mutexIsTaken = true;
}
catch (Exception e)
{
snapInstallerLogger.ErrorException("Error creating installer mutex, exiting...", e);
return(1, SnapInstallerType.None);
}
return(await RunInstallerAsync());
}
async Task <int> OnExecute()
{
Console.WriteLine();
// check parameter values
if (string.IsNullOrEmpty(SolutionOrProjectFile))
{
Console.Error.WriteLine($"A path is required");
return((int)ExitCode.SolutionOrProjectFileParameterMissing);
}
if (string.IsNullOrEmpty(outputDirectory))
{
Console.Error.WriteLine($"The output directory is required");
return((int)ExitCode.OutputDirectoryParameterMissing);
}
if (string.IsNullOrEmpty(githubUsername) ^ string.IsNullOrEmpty(githubToken))
{
Console.Error.WriteLine($"Both GitHub username and token are required");
return((int)ExitCode.GitHubParameterMissing);
}
// instantiate services
var fileDiscoveryService = new FileDiscoveryService(Program.fileSystem);
// GitHubService requires its own HttpClient as it adds a default authorization header
GithubService githubService;
if (string.IsNullOrEmpty(githubUsername) || string.IsNullOrEmpty(githubToken))
{
githubService = new GithubService(new HttpClient());
}
else
{
githubService = new GithubService(new HttpClient(), githubUsername, githubToken);
}
var nugetService = new NugetService(Program.httpClient, githubService, baseUrl);
var packagesFileService = new PackagesFileService(Program.fileSystem);
var projectFileService = new ProjectFileService(Program.fileSystem);
var solutionFileService = new SolutionFileService(Program.fileSystem);
var packages = new HashSet <NugetPackage>();
// determine what we are analyzing and do the analysis
var fullSolutionOrProjectFilePath = Program.fileSystem.Path.GetFullPath(SolutionOrProjectFile);
var attr = Program.fileSystem.File.GetAttributes(fullSolutionOrProjectFilePath);
if (SolutionOrProjectFile.ToLowerInvariant().EndsWith(".sln", StringComparison.OrdinalIgnoreCase))
{
packages = await solutionFileService.GetSolutionNugetPackages(fullSolutionOrProjectFilePath);
}
else if (Utils.IsSupportedProjectType(SolutionOrProjectFile) && scanProjectReferences)
{
packages = await projectFileService.RecursivelyGetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else if (Utils.IsSupportedProjectType(SolutionOrProjectFile))
{
packages = await projectFileService.GetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else if (Program.fileSystem.Path.GetFileName(SolutionOrProjectFile).ToLowerInvariant().Equals("packages.config", StringComparison.OrdinalIgnoreCase))
{
packages = await packagesFileService.GetNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else if (attr.HasFlag(FileAttributes.Directory))
{
packages = await packagesFileService.RecursivelyGetNugetPackagesAsync(fullSolutionOrProjectFilePath);
}
else
{
Console.Error.WriteLine($"Only .sln, .csproj, .vbproj, and packages.config files are supported");
return((int)ExitCode.InvalidOptions);
}
// get all the components from the NuGet packages
var components = new HashSet <Component>();
try
{
foreach (var package in packages)
{
var component = await nugetService.GetComponentAsync(package);
if (component != null)
{
components.Add(component);
}
}
}
catch (InvalidGitHubApiCredentialsException)
{
return((int)ExitCode.InvalidGitHubApiCredentials);
}
catch (GitHubApiRateLimitExceededException)
{
return((int)ExitCode.GitHubApiRateLimitExceeded);
}
// create the BOM
Console.WriteLine();
Console.WriteLine("Creating CycloneDX BoM");
var bomXml = BomService.CreateXmlDocument(components, noSerialNumber);
// check if the output directory exists and create it if needed
var bomPath = Program.fileSystem.Path.GetFullPath(outputDirectory);
if (!Program.fileSystem.Directory.Exists(bomPath))
{
Program.fileSystem.Directory.CreateDirectory(bomPath);
}
// write the BOM to disk
var bomFile = Program.fileSystem.Path.Combine(bomPath, "bom.xml");
Console.WriteLine("Writing to: " + bomFile);
using (var fileStream = Program.fileSystem.FileStream.Create(bomFile, FileMode.Create))
using (var writer = new StreamWriter(fileStream, new UTF8Encoding(false))) {
bomXml.Save(writer);
}
return(0);
}
async Task <int> OnExecuteAsync()
{
if (version)
{
Console.WriteLine(Assembly.GetExecutingAssembly().GetName().Version?.ToString());
return(0);
}
Console.WriteLine();
// check parameter values
if (string.IsNullOrEmpty(SolutionOrProjectFile))
{
Console.Error.WriteLine($"A path is required");
return((int)ExitCode.SolutionOrProjectFileParameterMissing);
}
if (string.IsNullOrEmpty(outputDirectory))
{
Console.Error.WriteLine($"The output directory is required");
return((int)ExitCode.OutputDirectoryParameterMissing);
}
if ((string.IsNullOrEmpty(githubUsername) ^ string.IsNullOrEmpty(githubToken)) ||
(string.IsNullOrEmpty(githubUsernameDeprecated) ^ string.IsNullOrEmpty(githubTokenDeprecated)))
{
Console.Error.WriteLine($"Both GitHub username and token are required");
return((int)ExitCode.GitHubParameterMissing);
}
dotnetCommandService.TimeoutMilliseconds = dotnetCommandTimeout;
projectFileService.DisablePackageRestore = disablePackageRestore;
// retrieve nuget package cache paths
var packageCachePathsResult = dotnetUtilsService.GetPackageCachePaths();
if (!packageCachePathsResult.Success)
{
Console.Error.WriteLine("Unable to find local package cache locations...");
Console.Error.WriteLine(packageCachePathsResult.ErrorMessage);
return((int)ExitCode.LocalPackageCacheError);
}
Console.WriteLine("Found the following local nuget package cache locations:");
foreach (var path in packageCachePathsResult.Result)
{
Console.WriteLine($" {path}");
}
// instantiate services
var fileDiscoveryService = new FileDiscoveryService(Program.fileSystem);
GithubService githubService = null;
if (!(disableGithubLicenses || disableGithubLicensesDeprecated))
{
// GitHubService requires its own HttpClient as it adds a default authorization header
if (!string.IsNullOrEmpty(githubBearerToken))
{
githubService = new GithubService(new HttpClient(), githubBearerToken);
}
else if (!string.IsNullOrEmpty(githubBearerTokenDeprecated))
{
githubService = new GithubService(new HttpClient(), githubBearerTokenDeprecated);
}
else if (!string.IsNullOrEmpty(githubUsername))
{
githubService = new GithubService(new HttpClient(), githubUsername, githubToken);
}
else if (!string.IsNullOrEmpty(githubUsernameDeprecated))
{
githubService = new GithubService(new HttpClient(), githubUsernameDeprecated, githubTokenDeprecated);
}
else
{
githubService = new GithubService(new HttpClient());
}
}
var nugetService = new NugetService(
Program.fileSystem,
packageCachePathsResult.Result,
githubService,
Program.httpClient,
baseUrl,
disableHashComputation);
var packages = new HashSet <NugetPackage>();
// determine what we are analyzing and do the analysis
var fullSolutionOrProjectFilePath = Program.fileSystem.Path.GetFullPath(SolutionOrProjectFile);
var topLevelComponent = new Component
{
// name is set below
Version = string.IsNullOrEmpty(setVersion) ? "0.0.0" : setVersion,
Type = setType == Component.Classification.Null ? Component.Classification.Application : setType,
};
try
{
if (SolutionOrProjectFile.ToLowerInvariant().EndsWith(".sln", StringComparison.OrdinalIgnoreCase))
{
packages = await solutionFileService.GetSolutionNugetPackages(fullSolutionOrProjectFilePath, baseIntermediateOutputPath, excludetestprojects).ConfigureAwait(false);
topLevelComponent.Name = fileSystem.Path.GetFileNameWithoutExtension(SolutionOrProjectFile);
}
else if (Utils.IsSupportedProjectType(SolutionOrProjectFile) && scanProjectReferences)
{
packages = await projectFileService.RecursivelyGetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath, baseIntermediateOutputPath, excludetestprojects).ConfigureAwait(false);
topLevelComponent.Name = fileSystem.Path.GetFileNameWithoutExtension(SolutionOrProjectFile);
}
else if (Utils.IsSupportedProjectType(SolutionOrProjectFile))
{
packages = await projectFileService.GetProjectNugetPackagesAsync(fullSolutionOrProjectFilePath, baseIntermediateOutputPath, excludetestprojects).ConfigureAwait(false);
topLevelComponent.Name = fileSystem.Path.GetFileNameWithoutExtension(SolutionOrProjectFile);
}
else if (Program.fileSystem.Path.GetFileName(SolutionOrProjectFile).ToLowerInvariant().Equals("packages.config", StringComparison.OrdinalIgnoreCase))
{
packages = await packagesFileService.GetNugetPackagesAsync(fullSolutionOrProjectFilePath).ConfigureAwait(false);
topLevelComponent.Name = fileSystem.Path.GetDirectoryName(fullSolutionOrProjectFilePath);
}
else if (fileSystem.Directory.Exists(fullSolutionOrProjectFilePath))
{
packages = await packagesFileService.RecursivelyGetNugetPackagesAsync(fullSolutionOrProjectFilePath).ConfigureAwait(false);
topLevelComponent.Name = fileSystem.Path.GetDirectoryName(fullSolutionOrProjectFilePath);
}
else
{
Console.Error.WriteLine($"Only .sln, .csproj, .vbproj, and packages.config files are supported");
return((int)ExitCode.InvalidOptions);
}
}
catch (DotnetRestoreException)
{
return((int)ExitCode.DotnetRestoreFailed);
}
if (!string.IsNullOrEmpty(setName))
{
topLevelComponent.Name = setName;
}
// get all the components and depdency graph from the NuGet packages
var components = new HashSet <Component>();
var dependencies = new List <Dependency>();
var directDependencies = new Dependency {
Dependencies = new List <Dependency>()
};
var transitiveDepencies = new HashSet <string>();
try
{
var bomRefLookup = new Dictionary <(string, string), string>();
foreach (var package in packages)
{
var component = await nugetService.GetComponentAsync(package).ConfigureAwait(false);
if (component != null &&
(component.Scope != Component.ComponentScope.Excluded || !excludeDev)
)
{
components.Add(component);
}
bomRefLookup[(component.Name.ToLower(CultureInfo.InvariantCulture), (component.Version.ToLower(CultureInfo.InvariantCulture)))] = component.BomRef;
public NugetServiceTests(BaseWebApplicationFactory <TestStartup> applicationFactory, ITestOutputHelper helper)
{
_nugetService = applicationFactory.Services.GetService <NugetService>();
}
public NugetServiceV2Tests(BaseFixture baseFixture)
{
_baseFixture = baseFixture;
_snapFilesystem = new SnapFilesystem();
_nugetService = new NugetService(_snapFilesystem, new NugetLogger(new LogProvider.NoOpLogger()));
}
