public Task <UpdateResult> UpdateAsync(UpdateRequest updateRequest, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = updateRequest ?? throw new ArgumentNullException(nameof(updateRequest));
// update installation date
return(Task.FromResult(UpdateResult.CreateSuccess(updateRequest, new FolderManagedTemplatePackage(_settings, this, provider, updateRequest.TemplatePackage.Identifier, DateTime.UtcNow))));
}
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)));
}
private NuGetManagedTemplatePackage(
IEngineEnvironmentSettings settings,
IInstaller installer,
IManagedTemplatePackageProvider provider,
string mountPointUri,
IReadOnlyDictionary <string, string> details)
{
if (string.IsNullOrWhiteSpace(mountPointUri))
{
throw new ArgumentException($"{nameof(mountPointUri)} cannot be null or empty", nameof(mountPointUri));
}
MountPointUri = mountPointUri;
Installer = installer ?? throw new ArgumentNullException(nameof(installer));
ManagedProvider = provider ?? throw new ArgumentNullException(nameof(provider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
Details = details?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value) ?? throw new ArgumentNullException(nameof(details));
if (Details.TryGetValue(PackageIdKey, out string packageId))
{
if (string.IsNullOrWhiteSpace(packageId))
{
throw new ArgumentException($"{nameof(details)} should contain key {PackageIdKey} with non-empty value", nameof(details));
}
}
else
{
throw new ArgumentException($"{nameof(details)} should contain key {PackageIdKey}", nameof(details));
}
_logger = settings.Host.LoggerFactory.CreateLogger <NuGetInstaller>();
}
public IManagedTemplatePackage Deserialize(IManagedTemplatePackageProvider provider, TemplatePackageData data)
{
_ = provider ?? throw new ArgumentNullException(nameof(provider));
if (data.InstallerId != Factory.Id)
{
throw new ArgumentException($"{nameof(NuGetInstaller)} can only deserialize packages with {nameof(data.InstallerId)} {Factory.Id}", nameof(data));
}
return(NuGetManagedTemplatePackage.Deserialize(_environmentSettings, this, provider, data.MountPointUri, data.Details));
}
public IManagedTemplatePackage Deserialize(IManagedTemplatePackageProvider provider, TemplatePackageData data)
{
_ = provider ?? throw new ArgumentNullException(nameof(provider));
if (data.InstallerId != Factory.Id)
{
throw new ArgumentException($"{nameof(FolderInstaller)} can only deserialize packages with {nameof(data.InstallerId)} {Factory.Id}", nameof(data));
}
return(new FolderManagedTemplatePackage(_settings, this, provider, data.MountPointUri, data.LastChangeTime));
}
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 NuGetManagedTemplatePackage(
IEngineEnvironmentSettings settings,
IInstaller installer,
IManagedTemplatePackageProvider provider,
string mountPointUri,
string packageIdentifier)
{
if (string.IsNullOrWhiteSpace(mountPointUri))
{
throw new ArgumentException($"{nameof(mountPointUri)} cannot be null or empty", nameof(mountPointUri));
}
if (string.IsNullOrWhiteSpace(packageIdentifier))
{
throw new ArgumentException($"{nameof(packageIdentifier)} cannot be null or empty", nameof(packageIdentifier));
}
MountPointUri = mountPointUri;
Installer = installer ?? throw new ArgumentNullException(nameof(installer));
ManagedProvider = provider ?? throw new ArgumentNullException(nameof(provider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
Details = new Dictionary <string, string>();
Details[PackageIdKey] = packageIdentifier;
}
public Task <UninstallResult> UninstallAsync(IManagedTemplatePackage templatePackage, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = templatePackage ?? throw new ArgumentNullException(nameof(templatePackage));
return(Task.FromResult(UninstallResult.CreateSuccess(templatePackage)));
}
public FolderManagedTemplatePackage(IEngineEnvironmentSettings settings, IInstaller installer, IManagedTemplatePackageProvider provider, string mountPointUri, DateTime lastChangeTime)
{
if (string.IsNullOrWhiteSpace(mountPointUri))
{
throw new ArgumentException($"{nameof(mountPointUri)} cannot be null or empty", nameof(mountPointUri));
}
MountPointUri = mountPointUri;
_currentLastChangedDateTime = lastChangeTime;
Installer = installer ?? throw new ArgumentNullException(nameof(installer));
ManagedProvider = provider ?? throw new ArgumentNullException(nameof(provider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_logger = settings.Host.LoggerFactory.CreateLogger <FolderManagedTemplatePackage>();
}
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 <UninstallResult> UninstallAsync(IManagedTemplatePackage templatePackage, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = templatePackage ?? throw new ArgumentNullException(nameof(templatePackage));
if (!(templatePackage is NuGetManagedTemplatePackage))
{
return(Task.FromResult(UninstallResult.CreateFailure(
templatePackage,
InstallerErrorCode.UnsupportedRequest,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_PackageNotSupported, templatePackage.DisplayName, Factory.Name))));
}
try
{
_environmentSettings.Host.FileSystem.FileDelete(templatePackage.MountPointUri);
return(Task.FromResult(UninstallResult.CreateSuccess(templatePackage)));
}
catch (Exception e)
{
_logger.LogDebug("Uninstalling {0} failed. Details:{1}", templatePackage.DisplayName, e);
return(Task.FromResult(UninstallResult.CreateFailure(
templatePackage,
InstallerErrorCode.GenericError,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_UninstallGeneric, templatePackage.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,
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 <IReadOnlyList <CheckUpdateResult> > GetLatestVersionAsync(IEnumerable <IManagedTemplatePackage> packages, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = packages ?? throw new ArgumentNullException(nameof(packages));
return(await Task.WhenAll(packages.Select(async package =>
{
if (package is NuGetManagedTemplatePackage nugetPackage)
{
try
{
(string latestVersion, bool isLatestVersion) = await _updateChecker.GetLatestVersionAsync(nugetPackage.Identifier, nugetPackage.Version, nugetPackage.NuGetSource, cancellationToken).ConfigureAwait(false);
return CheckUpdateResult.CreateSuccess(package, latestVersion, isLatestVersion);
}
catch (PackageNotFoundException e)
{
return CheckUpdateResult.CreateFailure(
package,
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 CheckUpdateResult.CreateFailure(
package,
InstallerErrorCode.InvalidSource,
message);
}
catch (OperationCanceledException)
{
return CheckUpdateResult.CreateFailure(
package,
InstallerErrorCode.GenericError,
LocalizableStrings.NuGetInstaller_InstallResut_Error_OperationCancelled);
}
catch (Exception e)
{
_logger.LogDebug($"Retrieving latest version for package {package.DisplayName} failed. Details: {e}.");
return CheckUpdateResult.CreateFailure(
package,
InstallerErrorCode.GenericError,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_UpdateCheckGeneric, package.DisplayName, e.Message));
}
}
else
{
return CheckUpdateResult.CreateFailure(
package,
InstallerErrorCode.UnsupportedRequest,
string.Format(LocalizableStrings.NuGetInstaller_InstallResut_Error_PackageNotSupported, package.DisplayName, Factory.Name));
}
})).ConfigureAwait(false));
}
public FolderManagedTemplatePackage(IEngineEnvironmentSettings settings, IInstaller installer, IManagedTemplatePackageProvider provider, string mountPointUri)
{
if (string.IsNullOrWhiteSpace(mountPointUri))
{
throw new ArgumentException($"{nameof(mountPointUri)} cannot be null or empty", nameof(mountPointUri));
}
MountPointUri = mountPointUri;
Installer = installer ?? throw new ArgumentNullException(nameof(installer));
ManagedProvider = provider ?? throw new ArgumentNullException(nameof(provider));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public Task <UninstallResult> UninstallAsync(IManagedTemplatePackage templatePackage, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = templatePackage ?? throw new ArgumentNullException(nameof(templatePackage));
if (!(templatePackage is NuGetManagedTemplatePackage))
{
return(Task.FromResult(UninstallResult.CreateFailure(templatePackage, InstallerErrorCode.UnsupportedRequest, $"{templatePackage.Identifier} is not supported by {Factory.Name}")));
}
try
{
_environmentSettings.Host.FileSystem.FileDelete(templatePackage.MountPointUri);
return(Task.FromResult(UninstallResult.CreateSuccess(templatePackage)));
}
catch (Exception ex)
{
_environmentSettings.Host.LogDiagnosticMessage($"Uninstalling {templatePackage.DisplayName} failed.", DebugLogCategory);
_environmentSettings.Host.LogDiagnosticMessage($"Details:{ex.ToString()}", DebugLogCategory);
return(Task.FromResult(UninstallResult.CreateFailure(templatePackage, InstallerErrorCode.GenericError, $"Failed to uninstall {templatePackage.DisplayName}, reason: {ex.Message}")));
}
}
public async Task <IReadOnlyList <CheckUpdateResult> > GetLatestVersionAsync(IEnumerable <IManagedTemplatePackage> packages, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = packages ?? throw new ArgumentNullException(nameof(packages));
return(await Task.WhenAll(packages.Select(async package =>
{
if (package is NuGetManagedTemplatePackage nugetPackage)
{
try
{
(string latestVersion, bool isLatestVersion) = await _updateChecker.GetLatestVersionAsync(nugetPackage.Identifier, nugetPackage.Version, nugetPackage.NuGetSource, cancellationToken).ConfigureAwait(false);
return CheckUpdateResult.CreateSuccess(package, latestVersion, isLatestVersion);
}
catch (PackageNotFoundException e)
{
return CheckUpdateResult.CreateFailure(package, InstallerErrorCode.PackageNotFound, e.Message);
}
catch (InvalidNuGetSourceException e)
{
return CheckUpdateResult.CreateFailure(package, InstallerErrorCode.InvalidSource, e.Message);
}
catch (OperationCanceledException)
{
return CheckUpdateResult.CreateFailure(package, InstallerErrorCode.GenericError, "Operation canceled");
}
catch (Exception e)
{
_environmentSettings.Host.LogDiagnosticMessage($"Retrieving latest version for package {package.DisplayName} failed.", DebugLogCategory);
_environmentSettings.Host.LogDiagnosticMessage($"Details:{e}", DebugLogCategory);
return CheckUpdateResult.CreateFailure(package, InstallerErrorCode.GenericError, $"Failed to check the update for the package {package.Identifier}, reason: {e.Message}");
}
}
else
{
return CheckUpdateResult.CreateFailure(package, InstallerErrorCode.UnsupportedRequest, $"package {package.Identifier} is not supported by installer {Factory.Name}");
}
})).ConfigureAwait(false));
}
public Task <IReadOnlyList <CheckUpdateResult> > GetLatestVersionAsync(IEnumerable <IManagedTemplatePackage> packages, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = packages ?? throw new ArgumentNullException(nameof(packages));
return(Task.FromResult <IReadOnlyList <CheckUpdateResult> >(packages.Select(s => CheckUpdateResult.CreateSuccess(s, null, true)).ToList()));
}
public Task <UpdateResult> UpdateAsync(UpdateRequest updateRequest, IManagedTemplatePackageProvider provider, CancellationToken cancellationToken)
{
_ = updateRequest ?? throw new ArgumentNullException(nameof(updateRequest));
return(Task.FromResult(UpdateResult.CreateSuccess(updateRequest, updateRequest.TemplatePackage)));
}