static void Main(string[] args)
{
var configuration = new ClientConfiguration
(
requestsAndResponsesAssembly: typeof(EchoRequest).Assembly,
containerImplementation: typeof(Container)
);
configuration.Initialize();
var factory = IoC.Container.Resolve <IRequestDispatcherFactory>();
using (var dispatcher = factory.CreateRequestDispatcher())
{
var response = dispatcher.Get <EchoResponse>(new EchoRequest {
Message = "Hi melkio"
});
Console.WriteLine(response.Message);
}
using (var dispatcher = factory.CreateRequestDispatcher())
{
var request = new InstallRequest
{
ApplicationName = "LittleJohn",
Location = @"D:\temp\LittleJohn",
NugetSource = "http://192.168.1.147:10016/nuget"
};
var response = dispatcher.Get <InstallResponse>(request);
Console.WriteLine("installazione terminata");
}
Console.ReadLine();
}
public async Task CanUninstall_Success()
{
MockInstallerFactory factory = new MockInstallerFactory();
MockManagedTemplatePackageProvider provider = new MockManagedTemplatePackageProvider();
string installPath = _environmentSettingsHelper.CreateTemporaryFolder();
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
FolderInstaller folderInstaller = new FolderInstaller(engineEnvironmentSettings, factory);
InstallRequest request = new InstallRequest(installPath);
InstallResult result = await folderInstaller.InstallAsync(request, provider, CancellationToken.None).ConfigureAwait(false);
Assert.True(result.Success);
Assert.Equal(request, result.InstallRequest);
Assert.Equal(InstallerErrorCode.Success, result.Error);
result.ErrorMessage.Should().BeNullOrEmpty();
var source = (FolderManagedTemplatePackage)result.TemplatePackage;
source.Should().NotBeNull();
source.MountPointUri.Should().Be(installPath);
Directory.Exists(installPath);
UninstallResult uninstallResult = await folderInstaller.UninstallAsync(source, provider, CancellationToken.None).ConfigureAwait(false);
Assert.True(uninstallResult.Success);
Assert.Equal(source, uninstallResult.TemplatePackage);
Assert.Equal(InstallerErrorCode.Success, result.Error);
result.ErrorMessage.Should().BeNullOrEmpty();
//directory is not removed
Directory.Exists(installPath);
}
internal async Task CanReInstallRemotePackage_WhenForceIsSpecified()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
InstallRequest installRequest = new InstallRequest("Microsoft.DotNet.Common.ProjectTemplates.5.0", version: "5.0.0");
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
Assert.Equal(InstallerErrorCode.Success, result[0].Error);
Assert.True(string.IsNullOrEmpty(result[0].ErrorMessage));
Assert.Equal(installRequest, result[0].InstallRequest);
InstallRequest repeatedInstallRequest = new InstallRequest("Microsoft.DotNet.Common.ProjectTemplates.5.0", version: "5.0.0", force: true);
result = await bootstrapper.InstallTemplatePackagesAsync(new[] { repeatedInstallRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
Assert.Equal(InstallerErrorCode.Success, result[0].Error);
result[0].ErrorMessage.Should().BeNullOrEmpty();
Assert.Equal(repeatedInstallRequest, result[0].InstallRequest);
InstallRequest repeatedInstallRequestWithoutForce = new InstallRequest("Microsoft.DotNet.Common.ProjectTemplates.5.0", version: "5.0.0");
result = await bootstrapper.InstallTemplatePackagesAsync(new[] { repeatedInstallRequestWithoutForce }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.False(result[0].Success);
Assert.Equal(InstallerErrorCode.AlreadyInstalled, result[0].Error);
}
internal async Task CanInstall_Folder()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
string templateLocation = TestUtils.GetTestTemplateLocation("TemplateWithSourceName");
InstallRequest installRequest = new InstallRequest(Path.GetFullPath(templateLocation));
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
Assert.Equal(InstallerErrorCode.Success, result[0].Error);
result[0].ErrorMessage.Should().BeNullOrEmpty();
Assert.Equal(installRequest, result[0].InstallRequest);
IManagedTemplatePackage source = result[0].TemplatePackage;
Assert.Equal(Path.GetFullPath(templateLocation), source.Identifier);
Assert.Equal("Global Settings", source.Provider.Factory.DisplayName);
Assert.Equal("Folder", source.Installer.Factory.Name);
source.Version.Should().BeNullOrEmpty();
IReadOnlyList <IManagedTemplatePackage> managedTemplatesPackages = await bootstrapper.GetManagedTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, managedTemplatesPackages.Count);
managedTemplatesPackages[0].Should().BeEquivalentTo(source);
IReadOnlyList <ITemplatePackage> templatePackages = await bootstrapper.GetTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, templatePackages.Count);
Assert.IsAssignableFrom <IManagedTemplatePackage>(templatePackages[0]);
templatePackages[0].Should().BeEquivalentTo((ITemplatePackage)source);
}
public async Task CanInstall_Directory()
{
MockInstallerFactory factory = new MockInstallerFactory();
MockManagedTemplatePackageProvider provider = new MockManagedTemplatePackageProvider();
string installPath = _environmentSettingsHelper.CreateTemporaryFolder();
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
FolderInstaller folderInstaller = new FolderInstaller(engineEnvironmentSettings, factory);
InstallRequest request = new InstallRequest(installPath);
Assert.True(await folderInstaller.CanInstallAsync(request, CancellationToken.None).ConfigureAwait(false));
InstallResult result = await folderInstaller.InstallAsync(request, provider, CancellationToken.None).ConfigureAwait(false);
Assert.True(result.Success);
Assert.Equal(request, result.InstallRequest);
Assert.Equal(InstallerErrorCode.Success, result.Error);
result.ErrorMessage.Should().BeNullOrEmpty();
var source = (FolderManagedTemplatePackage)result.TemplatePackage;
source.MountPointUri.Should().Be(installPath);
source.Version.Should().BeNullOrEmpty();
source.DisplayName.Should().Be(installPath);
source.Identifier.Should().Be(installPath);
source.Installer.Should().Be(folderInstaller);
source.Provider.Should().Be(provider);
}
public Task <bool> CanInstallAsync(InstallRequest installationRequest, CancellationToken cancellationToken)
{
try
{
ReadPackageInformation(installationRequest.PackageIdentifier);
}
catch (Exception)
{
_logger.LogDebug($"{installationRequest.PackageIdentifier} is not a local NuGet package.");
//check if identifier is a valid package ID
bool validPackageId = PackageIdValidator.IsValidPackageId(installationRequest.PackageIdentifier);
//check if version is specified it is correct version
bool hasValidVersion = NuGetVersionHelper.IsSupportedVersionString(installationRequest.Version);
if (!validPackageId)
{
_logger.LogDebug($"{installationRequest.PackageIdentifier} is not a valid NuGet package ID.");
}
if (!hasValidVersion)
{
_logger.LogDebug($"{installationRequest.Version} is not a valid NuGet package version.");
}
if (validPackageId && hasValidVersion)
{
_logger.LogDebug($"{installationRequest.DisplayName} is identified as the downloadable NuGet package.");
}
//not a local package file
return(Task.FromResult(validPackageId && hasValidVersion));
}
_logger.LogDebug($"{installationRequest.PackageIdentifier} is identified as the local NuGet package.");
return(Task.FromResult(true));
}
internal async Task CanUninstall_NuGetPackage()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
InstallRequest installRequest = new InstallRequest("Microsoft.DotNet.Common.ProjectTemplates.5.0", "5.0.0");
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
IManagedTemplatePackage source = result[0].TemplatePackage;
IReadOnlyList <IManagedTemplatePackage> managedTemplatesPackages = await bootstrapper.GetManagedTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, managedTemplatesPackages.Count);
managedTemplatesPackages[0].Should().BeEquivalentTo(source);
IReadOnlyList <UninstallResult> uninstallResults = await bootstrapper.UninstallTemplatePackagesAsync(new[] { source }, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, uninstallResults.Count);
Assert.True(uninstallResults[0].Success);
Assert.Equal(InstallerErrorCode.Success, uninstallResults[0].Error);
uninstallResults[0].ErrorMessage.Should().BeNullOrEmpty();
Assert.Equal(source, uninstallResults[0].TemplatePackage);
IReadOnlyList <ITemplatePackage> templatePackages = await bootstrapper.GetTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(0, templatePackages.Count);
}
public Task <bool> CanInstallAsync(InstallRequest installationRequest, CancellationToken cancellationToken)
{
try
{
ReadPackageInformation(installationRequest.PackageIdentifier);
}
catch (Exception)
{
_environmentSettings.Host.LogDiagnosticMessage($"{installationRequest.PackageIdentifier} is not a local NuGet package.", DebugLogCategory);
//check if identifier is a valid package ID
bool validPackageId = PackageIdValidator.IsValidPackageId(installationRequest.PackageIdentifier);
//check if version is specified it is correct version
bool hasValidVersion = string.IsNullOrWhiteSpace(installationRequest.Version) || NuGetVersion.TryParse(installationRequest.Version, out _);
if (!validPackageId)
{
_environmentSettings.Host.LogDiagnosticMessage($"{installationRequest.PackageIdentifier} is not a valid NuGet package ID.", DebugLogCategory);
}
if (!hasValidVersion)
{
_environmentSettings.Host.LogDiagnosticMessage($"{installationRequest.Version} is not a valid NuGet package version.", DebugLogCategory);
}
if (validPackageId && hasValidVersion)
{
_environmentSettings.Host.LogDiagnosticMessage($"{installationRequest.DisplayName} is identified as the downloadable NuGet package.", DebugLogCategory);
}
//not a local package file
return(Task.FromResult(validPackageId && hasValidVersion));
}
_environmentSettings.Host.LogDiagnosticMessage($"{installationRequest.PackageIdentifier} is identified as the local NuGet package.", DebugLogCategory);
return(Task.FromResult(true));
}
internal async Task CanUninstall_Folder()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
string templateLocation = TestUtils.GetTestTemplateLocation("TemplateWithSourceName");
InstallRequest installRequest = new InstallRequest(Path.GetFullPath(templateLocation));
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
IManagedTemplatePackage source = result[0].TemplatePackage;
Assert.Equal(templateLocation, source.MountPointUri);
IReadOnlyList <IManagedTemplatePackage> managedTemplatesPackages = await bootstrapper.GetManagedTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, managedTemplatesPackages.Count);
managedTemplatesPackages[0].Should().BeEquivalentTo(source);
IReadOnlyList <UninstallResult> uninstallResults = await bootstrapper.UninstallTemplatePackagesAsync(new[] { source }, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, uninstallResults.Count);
Assert.True(uninstallResults[0].Success);
Assert.Equal(InstallerErrorCode.Success, uninstallResults[0].Error);
uninstallResults[0].ErrorMessage.Should().BeNullOrEmpty();
Assert.Equal(source, uninstallResults[0].TemplatePackage);
IReadOnlyList <ITemplatePackage> templatePackages = await bootstrapper.GetTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(0, templatePackages.Count);
Directory.Exists(templateLocation);
}
internal async Task CanInstall_LocalNuGetPackage()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
string packageLocation = await _packageManager.GetNuGetPackage("Microsoft.DotNet.Common.ProjectTemplates.5.0").ConfigureAwait(false);
InstallRequest installRequest = new InstallRequest(Path.GetFullPath(packageLocation));
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
Assert.Equal(InstallerErrorCode.Success, result[0].Error);
result[0].ErrorMessage.Should().BeNullOrEmpty();
Assert.Equal(installRequest, result[0].InstallRequest);
IManagedTemplatePackage source = result[0].TemplatePackage;
Assert.Equal("Microsoft.DotNet.Common.ProjectTemplates.5.0", source.Identifier);
Assert.Equal("Global Settings", source.Provider.Factory.DisplayName);
Assert.Equal("NuGet", source.Installer.Factory.Name);
Assert.Equal("Microsoft", source.GetDetails()["Author"]);
source.Version.Should().NotBeNullOrEmpty();
IReadOnlyList <IManagedTemplatePackage> managedTemplatesPackages = await bootstrapper.GetManagedTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, managedTemplatesPackages.Count);
managedTemplatesPackages[0].Should().BeEquivalentTo(source);
IReadOnlyList <ITemplatePackage> templatePackages = await bootstrapper.GetTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, templatePackages.Count);
Assert.IsAssignableFrom <IManagedTemplatePackage>(templatePackages[0]);
templatePackages[0].Should().BeEquivalentTo((ITemplatePackage)source);
}
internal async Task CanReInstallFolder_WhenForceIsSpecified()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
string templateLocation = TestUtils.GetTestTemplateLocation("TemplateWithSourceName");
InstallRequest installRequest = new InstallRequest(Path.GetFullPath(templateLocation));
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
Assert.Equal(InstallerErrorCode.Success, result[0].Error);
result[0].ErrorMessage.Should().BeNullOrEmpty();
Assert.Equal(installRequest, result[0].InstallRequest);
InstallRequest repeatedInstallRequest = new InstallRequest(Path.GetFullPath(templateLocation), force: true);
result = await bootstrapper.InstallTemplatePackagesAsync(new[] { repeatedInstallRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
Assert.Equal(InstallerErrorCode.Success, result[0].Error);
result[0].ErrorMessage.Should().BeNullOrEmpty();
Assert.Equal(repeatedInstallRequest, result[0].InstallRequest);
InstallRequest repeatedInstallRequestWithoutForce = new InstallRequest(Path.GetFullPath(templateLocation));
result = await bootstrapper.InstallTemplatePackagesAsync(new[] { repeatedInstallRequestWithoutForce }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.False(result[0].Success);
Assert.Equal(InstallerErrorCode.AlreadyInstalled, result[0].Error);
}
public async Task <UpdateResult> UpdateAsync(UpdateRequest updateRequest, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = updateRequest ?? throw new ArgumentNullException(nameof(updateRequest));
_ = provider ?? throw new ArgumentNullException(nameof(provider));
if (string.IsNullOrWhiteSpace(updateRequest.Version))
{
throw new ArgumentException("Version cannot be null or empty", nameof(updateRequest.Version));
}
//ensure uninstall is performed
UninstallResult uninstallResult = await UninstallAsync(updateRequest.TemplatePackage, provider, cancellationToken).ConfigureAwait(false);
if (!uninstallResult.Success)
{
if (uninstallResult.ErrorMessage is null)
{
throw new InvalidOperationException($"{nameof(uninstallResult.ErrorMessage)} cannot be null when {nameof(uninstallResult.Success)} is 'true'");
}
return(UpdateResult.CreateFailure(updateRequest, uninstallResult.Error, uninstallResult.ErrorMessage));
}
var nuGetManagedSource = updateRequest.TemplatePackage as NuGetManagedTemplatePackage;
Dictionary <string, string> installationDetails = new Dictionary <string, string>();
if (nuGetManagedSource != null && !string.IsNullOrWhiteSpace(nuGetManagedSource.NuGetSource))
{
installationDetails.Add(InstallerConstants.NuGetSourcesKey, nuGetManagedSource.NuGetSource !);
}
InstallRequest installRequest = new InstallRequest(updateRequest.TemplatePackage.Identifier, updateRequest.Version, details: installationDetails);
return(UpdateResult.FromInstallResult(updateRequest, await InstallAsync(installRequest, provider, cancellationToken).ConfigureAwait(false)));
}
public Task <InstallResult> InstallAsync(InstallRequest installRequest, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = installRequest ?? throw new ArgumentNullException(nameof(installRequest));
_ = provider ?? throw new ArgumentNullException(nameof(provider));
if (Directory.Exists(installRequest.PackageIdentifier))
{
return(Task.FromResult(InstallResult.CreateSuccess(installRequest, new FolderManagedTemplatePackage(_settings, this, provider, installRequest.PackageIdentifier))));
}
else
{
return(Task.FromResult(InstallResult.CreateFailure(installRequest, InstallerErrorCode.PackageNotFound, $"The folder {installRequest.PackageIdentifier} doesn't exist")));
}
}
public Task <InstallResult> InstallAsync(InstallRequest installRequest, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = installRequest ?? throw new ArgumentNullException(nameof(installRequest));
_ = provider ?? throw new ArgumentNullException(nameof(provider));
if (_settings.Host.FileSystem.DirectoryExists(installRequest.PackageIdentifier))
{
//on installation we update last modification date to trigger package rebuild.
//on folder package update the date may not change.
return(Task.FromResult(InstallResult.CreateSuccess(installRequest, new FolderManagedTemplatePackage(_settings, this, provider, installRequest.PackageIdentifier, DateTime.UtcNow))));
}
else
{
return(Task.FromResult(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.PackageNotFound,
string.Format(LocalizableStrings.FolderInstaller_InstallResult_Error_FolderDoesNotExist, installRequest.PackageIdentifier))));
}
}
public int Install([FromForm] InstallRequest request)
{
if (string.IsNullOrEmpty(request.TestSuiteName))
{
throw new ArgumentNullException(nameof(request.TestSuiteName));
}
if (request.Package == null)
{
throw new ArgumentNullException(nameof(request.Package));
}
string packageName = request.Package.FileName;
var packageStream = request.Package.OpenReadStream();
int id = PTMKernelService.InstallTestSuite(request.TestSuiteName, packageName, packageStream, request.Description);
return(id);
}
public IActionResult Update(int id, [FromForm] InstallRequest request)
{
if (string.IsNullOrEmpty(request.TestSuiteName))
{
throw new ArgumentNullException(nameof(request.TestSuiteName));
}
if (request.Package == null)
{
throw new ArgumentNullException(nameof(request.Package));
}
var packageName = request.Package.FileName;
var packageStream = request.Package.OpenReadStream();
PTMKernelService.UpdateTestSuite(id, request.TestSuiteName, packageName, packageStream, request.Description);
return(Ok());
}
public async Task CannotInstall_NotExist()
{
MockInstallerFactory factory = new MockInstallerFactory();
MockManagedTemplatePackageProvider provider = new MockManagedTemplatePackageProvider();
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
FolderInstaller folderInstaller = new FolderInstaller(engineEnvironmentSettings, factory);
InstallRequest request = new InstallRequest("not found");
Assert.False(await folderInstaller.CanInstallAsync(request, CancellationToken.None).ConfigureAwait(false));
InstallResult result = await folderInstaller.InstallAsync(request, provider, CancellationToken.None).ConfigureAwait(false);
Assert.False(result.Success);
Assert.Equal(request, result.InstallRequest);
Assert.Equal(InstallerErrorCode.PackageNotFound, result.Error);
result.ErrorMessage.Should().NotBeNullOrEmpty();
result.TemplatePackage.Should().BeNull();
}
internal async Task CanCheckForLatestVersion_NuGetPackage()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
InstallRequest installRequest = new InstallRequest("Microsoft.DotNet.Common.ProjectTemplates.5.0", "5.0.0");
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
IManagedTemplatePackage source = result[0].TemplatePackage;
IReadOnlyList <CheckUpdateResult> checkUpdateResults = await bootstrapper.GetLatestVersionsAsync(new[] { source }, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, checkUpdateResults.Count);
Assert.True(checkUpdateResults[0].Success);
Assert.Equal(InstallerErrorCode.Success, checkUpdateResults[0].Error);
Assert.True(string.IsNullOrEmpty(checkUpdateResults[0].ErrorMessage));
Assert.Equal(source, checkUpdateResults[0].TemplatePackage);
Assert.False(checkUpdateResults[0].IsLatestVersion);
Assert.NotEqual("5.0.0", checkUpdateResults[0].LatestVersion);
}
public async Task <ActionResult <BoolResult> > Install([FromBody] InstallRequest request)
{
if (request.SecurityKey != _settingsManager.SecurityKey)
{
return(Unauthorized());
}
var(success, errorMessage) = await _databaseManager.InstallAsync(request.UserName, request.AdminPassword, request.Email, request.Mobile);
if (!success)
{
return(this.Error(errorMessage));
}
await FileUtils.WriteTextAsync(_pathManager.GetRootPath("index.html"), Constants.Html5Empty);
return(new BoolResult
{
Value = true
});
}
internal async Task CanInstall_RemoteNuGetPackage()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
InstallRequest installRequest = new InstallRequest(
"Take.Blip.Client.Templates",
"0.5.135",
details: new Dictionary <string, string>
{
{ InstallerConstants.NuGetSourcesKey, "https://api.nuget.org/v3/index.json" }
});
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
Assert.Equal(InstallerErrorCode.Success, result[0].Error);
Assert.True(string.IsNullOrEmpty(result[0].ErrorMessage));
Assert.Equal(installRequest, result[0].InstallRequest);
IManagedTemplatePackage source = result[0].TemplatePackage;
Assert.Equal("Take.Blip.Client.Templates", source.Identifier);
Assert.Equal("Global Settings", source.Provider.Factory.DisplayName);
Assert.Equal("NuGet", source.Installer.Factory.Name);
source.GetDetails()["Author"].Should().NotBeNullOrEmpty();
Assert.Equal("https://api.nuget.org/v3/index.json", source.GetDetails()["NuGetSource"]);
Assert.Equal("0.5.135", source.Version);
IReadOnlyList <IManagedTemplatePackage> managedTemplatesPackages = await bootstrapper.GetManagedTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, managedTemplatesPackages.Count);
managedTemplatesPackages[0].Should().BeEquivalentTo(source);
IReadOnlyList <ITemplatePackage> templatePackages = await bootstrapper.GetTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, templatePackages.Count);
Assert.IsAssignableFrom <IManagedTemplatePackage>(templatePackages[0]);
templatePackages[0].Should().BeEquivalentTo((ITemplatePackage)source);
}
internal async Task CanCheckForLatestVersion_Folder()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
string templateLocation = TestUtils.GetTestTemplateLocation("TemplateWithSourceName");
InstallRequest installRequest = new InstallRequest(Path.GetFullPath(templateLocation));
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
IManagedTemplatePackage source = result[0].TemplatePackage;
IReadOnlyList <CheckUpdateResult> checkUpdateResults = await bootstrapper.GetLatestVersionsAsync(new[] { source }, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, checkUpdateResults.Count);
Assert.True(checkUpdateResults[0].Success);
Assert.Equal(InstallerErrorCode.Success, checkUpdateResults[0].Error);
Assert.True(string.IsNullOrEmpty(checkUpdateResults[0].ErrorMessage));
Assert.Equal(source, checkUpdateResults[0].TemplatePackage);
Assert.True(checkUpdateResults[0].IsLatestVersion);
}
private NuGetPackageInfo InstallLocalPackage(InstallRequest installRequest)
{
_ = installRequest ?? throw new ArgumentNullException(nameof(installRequest));
NuGetPackageInfo packageInfo;
try
{
packageInfo = ReadPackageInformation(installRequest.PackageIdentifier);
}
catch (Exception ex)
{
_environmentSettings.Host.OnCriticalError(null, string.Format(LocalizableStrings.NuGetInstaller_Error_FailedToReadPackage, installRequest.PackageIdentifier), null, 0);
_environmentSettings.Host.LogDiagnosticMessage($"Details: {ex.ToString()}.", DebugLogCategory);
throw new InvalidNuGetPackageException(installRequest.PackageIdentifier, ex);
}
string targetPackageLocation = Path.Combine(_installPath, packageInfo.PackageIdentifier + "." + packageInfo.PackageVersion + ".nupkg");
if (_environmentSettings.Host.FileSystem.FileExists(targetPackageLocation))
{
_environmentSettings.Host.OnCriticalError(null, string.Format(LocalizableStrings.NuGetInstaller_Error_CopyFailed, installRequest.PackageIdentifier, targetPackageLocation), null, 0);
_environmentSettings.Host.OnCriticalError(null, string.Format(LocalizableStrings.NuGetInstaller_Error_FileAlreadyExists, targetPackageLocation), null, 0);
throw new DownloadException(packageInfo.PackageIdentifier, packageInfo.PackageVersion, installRequest.PackageIdentifier);
}
try
{
_environmentSettings.Host.FileSystem.FileCopy(installRequest.PackageIdentifier, targetPackageLocation, overwrite: false);
packageInfo = packageInfo.WithFullPath(targetPackageLocation);
}
catch (Exception ex)
{
_environmentSettings.Host.OnCriticalError(null, string.Format(LocalizableStrings.NuGetInstaller_Error_CopyFailed, installRequest.PackageIdentifier, targetPackageLocation), null, 0);
_environmentSettings.Host.LogDiagnosticMessage($"Details: {ex.ToString()}.", DebugLogCategory);
throw new DownloadException(packageInfo.PackageIdentifier, packageInfo.PackageVersion, installRequest.PackageIdentifier);
}
return(packageInfo);
}
internal async Task CanUpdate_NuGetPackage()
{
using Bootstrapper bootstrapper = BootstrapperFactory.GetBootstrapper();
InstallRequest installRequest = new InstallRequest("Microsoft.DotNet.Common.ProjectTemplates.5.0", "5.0.0");
IReadOnlyList <InstallResult> result = await bootstrapper.InstallTemplatePackagesAsync(new[] { installRequest }, InstallationScope.Global, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, result.Count);
Assert.True(result[0].Success);
IManagedTemplatePackage source = result[0].TemplatePackage;
UpdateRequest updateRequest = new UpdateRequest(source, "5.0.1");
IReadOnlyList <UpdateResult> updateResults = await bootstrapper.UpdateTemplatePackagesAsync(new[] { updateRequest }, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, updateResults.Count);
Assert.True(updateResults[0].Success);
Assert.Equal(InstallerErrorCode.Success, updateResults[0].Error);
Assert.True(string.IsNullOrEmpty(updateResults[0].ErrorMessage));
Assert.Equal(updateRequest, updateResults[0].UpdateRequest);
IManagedTemplatePackage updatedSource = updateResults[0].TemplatePackage;
Assert.Equal("Global Settings", updatedSource.Provider.Factory.DisplayName);
Assert.Equal("NuGet", updatedSource.Installer.Factory.Name);
Assert.Equal("5.0.1", updatedSource.Version);
IReadOnlyList <IManagedTemplatePackage> managedTemplatesPackages = await bootstrapper.GetManagedTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, managedTemplatesPackages.Count);
managedTemplatesPackages[0].Should().BeEquivalentTo(updatedSource);
IReadOnlyList <ITemplatePackage> templatePackages = await bootstrapper.GetTemplatePackages(CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, templatePackages.Count);
Assert.IsAssignableFrom <IManagedTemplatePackage>(templatePackages[0]);
templatePackages[0].Should().BeEquivalentTo((ITemplatePackage)updatedSource);
}
public async Task <InstallResult> InstallAsync(InstallRequest installRequest, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = installRequest ?? throw new ArgumentNullException(nameof(installRequest));
_ = provider ?? throw new ArgumentNullException(nameof(provider));
if (!await CanInstallAsync(installRequest, cancellationToken).ConfigureAwait(false))
{
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.UnsupportedRequest,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_PackageNotSupported, installRequest.DisplayName, Factory.Name)));
}
try
{
bool isLocalPackage = IsLocalPackage(installRequest);
NuGetPackageInfo nuGetPackageInfo;
if (isLocalPackage)
{
nuGetPackageInfo = InstallLocalPackage(installRequest);
}
else
{
string[] additionalNuGetSources = Array.Empty <string>();
if (installRequest.Details != null && installRequest.Details.TryGetValue(InstallerConstants.NuGetSourcesKey, out string nugetSources))
{
additionalNuGetSources = nugetSources.Split(InstallerConstants.NuGetSourcesSeparator);
}
nuGetPackageInfo = await _packageDownloader.DownloadPackageAsync(
_installPath,
installRequest.PackageIdentifier,
installRequest.Version,
additionalNuGetSources,
force : installRequest.Force,
cancellationToken)
.ConfigureAwait(false);
}
NuGetManagedTemplatePackage package = new NuGetManagedTemplatePackage(
_environmentSettings,
installer: this,
provider,
nuGetPackageInfo.FullPath,
nuGetPackageInfo.PackageIdentifier)
{
Author = nuGetPackageInfo.Author,
NuGetSource = nuGetPackageInfo.NuGetSource,
Version = nuGetPackageInfo.PackageVersion.ToString(),
IsLocalPackage = isLocalPackage
};
return(InstallResult.CreateSuccess(installRequest, package));
}
catch (DownloadException e)
{
string?packageLocation = e.SourcesList == null
? e.PackageLocation
: string.Join(", ", e.SourcesList);
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.DownloadFailed,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_DownloadFailed, installRequest.DisplayName, packageLocation)));
}
catch (PackageNotFoundException e)
{
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.PackageNotFound,
string.Format(LocalizableStrings.NuGetInstaller_Error_FailedToReadPackage, e.PackageIdentifier, string.Join(", ", e.SourcesList))));
}
catch (InvalidNuGetSourceException e)
{
string message = e.SourcesList == null || !e.SourcesList.Any()
? LocalizableStrings.NuGetInstaller_InstallResut_Error_InvalidSources_None
: string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_InvalidSources, string.Join(", ", e.SourcesList));
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.InvalidSource,
message));
}
catch (InvalidNuGetPackageException e)
{
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.InvalidPackage,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_InvalidPackage, e.PackageLocation)));
}
catch (OperationCanceledException)
{
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.GenericError,
LocalizableStrings.NuGetInstaller_InstallResut_Error_OperationCancelled));
}
catch (Exception e)
{
_logger.LogDebug($"Installing {installRequest.DisplayName} failed. Details:{e.ToString()}");
return(InstallResult.CreateFailure(
installRequest,
InstallerErrorCode.GenericError,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_InstallGeneric, installRequest.DisplayName, e.Message)));
}
}
public async Task <InstallResult> InstallAsync(InstallRequest installRequest, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = installRequest ?? throw new ArgumentNullException(nameof(installRequest));
_ = provider ?? throw new ArgumentNullException(nameof(provider));
if (!await CanInstallAsync(installRequest, cancellationToken).ConfigureAwait(false))
{
return(InstallResult.CreateFailure(installRequest, InstallerErrorCode.UnsupportedRequest, $"The install request {installRequest} cannot be processed by installer {Factory.Name}"));
}
try
{
bool isLocalPackage = IsLocalPackage(installRequest);
NuGetPackageInfo nuGetPackageInfo;
if (isLocalPackage)
{
nuGetPackageInfo = InstallLocalPackage(installRequest);
}
else
{
string[] additionalNuGetSources = Array.Empty <string>();
if (installRequest.Details != null && installRequest.Details.TryGetValue(InstallerConstants.NuGetSourcesKey, out string nugetSources))
{
additionalNuGetSources = nugetSources.Split(InstallerConstants.NuGetSourcesSeparator);
}
nuGetPackageInfo = await _packageDownloader.DownloadPackageAsync(
_installPath,
installRequest.PackageIdentifier,
installRequest.Version,
additionalNuGetSources,
cancellationToken)
.ConfigureAwait(false);
}
NuGetManagedTemplatePackage package = new NuGetManagedTemplatePackage(
_environmentSettings,
installer: this,
provider,
nuGetPackageInfo.FullPath,
nuGetPackageInfo.PackageIdentifier)
{
Author = nuGetPackageInfo.Author,
NuGetSource = nuGetPackageInfo.NuGetSource,
Version = nuGetPackageInfo.PackageVersion.ToString(),
LocalPackage = isLocalPackage
};
return(InstallResult.CreateSuccess(installRequest, package));
}
catch (DownloadException e)
{
return(InstallResult.CreateFailure(installRequest, InstallerErrorCode.DownloadFailed, e.Message));
}
catch (PackageNotFoundException e)
{
return(InstallResult.CreateFailure(installRequest, InstallerErrorCode.PackageNotFound, e.Message));
}
catch (InvalidNuGetSourceException e)
{
return(InstallResult.CreateFailure(installRequest, InstallerErrorCode.InvalidSource, e.Message));
}
catch (InvalidNuGetPackageException e)
{
return(InstallResult.CreateFailure(installRequest, InstallerErrorCode.InvalidPackage, e.Message));
}
catch (Exception e)
{
_environmentSettings.Host.LogDiagnosticMessage($"Installing {installRequest.DisplayName} failed.", DebugLogCategory);
_environmentSettings.Host.LogDiagnosticMessage($"Details:{e.ToString()}", DebugLogCategory);
return(InstallResult.CreateFailure(installRequest, InstallerErrorCode.GenericError, $"Failed to install the package {installRequest.DisplayName}, reason: {e.Message}"));
}
}
public Task <bool> CanInstallAsync(InstallRequest installationRequest, CancellationToken cancellationToken)
{
_ = installationRequest ?? throw new ArgumentNullException(nameof(installationRequest));
return(Task.FromResult(_settings.Host.FileSystem.DirectoryExists(installationRequest.PackageIdentifier)));
}
private async Task <InstallResult> InstallAsync(List <TemplatePackageData> packages, InstallRequest installRequest, IInstaller installer, CancellationToken cancellationToken)
{
_ = installRequest ?? throw new ArgumentNullException(nameof(installRequest));
_ = installer ?? throw new ArgumentNullException(nameof(installer));
(InstallerErrorCode result, string message) = await EnsureInstallPrerequisites(
packages,
installRequest.PackageIdentifier,
installRequest.Version,
installer,
cancellationToken,
forceUpdate : installRequest.Force).ConfigureAwait(false);
if (result != InstallerErrorCode.Success)
{
return(InstallResult.CreateFailure(installRequest, result, message));
}
InstallResult installResult = await installer.InstallAsync(installRequest, this, cancellationToken).ConfigureAwait(false);
if (!installResult.Success)
{
return(installResult);
}
if (installResult.TemplatePackage is null)
{
throw new InvalidOperationException($"{nameof(installResult.TemplatePackage)} cannot be null when {nameof(installResult.Success)} is 'true'");
}
lock (packages)
{
packages.Add(((ISerializableInstaller)installer).Serialize(installResult.TemplatePackage));
}
return(installResult);
}
private bool IsLocalPackage(InstallRequest installRequest)
{
return(_environmentSettings.Host.FileSystem.FileExists(installRequest.PackageIdentifier));
}
