/// <inheritdoc />
public void Install(IRepositoryInstalled repository, IPackage package)
{
if (!IsInstalled(repository, package))
{
repository.AddPackage((IPackage)package.Clone());
}
}
/// <summary>
/// Executes solver operation.
/// </summary>
/// <param name="installedRepository">The repository in which to check.</param>
/// <param name="operation">The operation instance.</param>
public virtual void Execute(IRepositoryInstalled installedRepository, IOperation operation)
{
void WaitDownload(IPackage package, IPackage previousPackage = null)
{
var type = previousPackage != null?previousPackage.GetPackageType() : package.GetPackageType();
var installer = GetInstaller(type);
installer.Download(package, previousPackage)?.Wait();
}
var method = GetExecuteMethod(operation.JobCommand);
if (operation.JobCommand == JobCommand.Install)
{
if (!(operation is OperationInstall operationInstall))
{
throw new UnexpectedException($"The Install operation must be {nameof(OperationInstall)} instance.");
}
WaitDownload(operationInstall.GetPackage());
}
else if (operation.JobCommand == JobCommand.Update)
{
if (!(operation is OperationUpdate operationUpdate))
{
throw new UnexpectedException($"The update operation must be {nameof(OperationUpdate)} instance.");
}
WaitDownload(operationUpdate.GetTargetPackage(), operationUpdate.GetInitialPackage());
}
method(installedRepository, operation);
}
/// <summary>
/// Executes update operation.
/// </summary>
/// <param name="installedRepository">The repository in which to check.</param>
/// <param name="operation">The operation instance.</param>
protected virtual void Update(IRepositoryInstalled installedRepository, IOperation operation)
{
if (!(operation is OperationUpdate operationUpdate))
{
throw new UnexpectedException($"The update operation must be {nameof(OperationUpdate)} instance.");
}
var initial = operationUpdate.GetInitialPackage();
var target = operationUpdate.GetTargetPackage();
var initialType = initial.GetPackageType();
var targetType = target.GetPackageType();
if (initialType == targetType)
{
var installer = GetInstaller(initialType);
installer.Update(installedRepository, initial, target);
MarkForNotification(target);
}
else
{
var installer = GetInstaller(initialType);
installer.Uninstall(installedRepository, initial);
installer = GetInstaller(targetType);
installer.Install(installedRepository, target);
}
}
/// <inheritdoc />
public void Uninstall(IRepositoryInstalled repository, IPackage package)
{
if (!IsInstalled(repository, package))
{
throw new InvalidArgumentException($"Package is not installed: {package}");
}
repository.RemovePackage(package);
}
/// <inheritdoc />
public virtual bool IsInstalled(IRepositoryInstalled repository, IPackage package)
{
if (!repository.HasPackage(package))
{
return(false);
}
return(fileSystem.Exists(GetInstallPath(package), FileSystemOptions.Directory));
}
/// <summary>
/// Checks whether provided package is installed in one of the registered installers.
/// </summary>
/// <param name="installedRepository">The repository in which to check.</param>
/// <param name="package">The package instance.</param>
/// <returns>True if the package is installed.</returns>
public virtual bool IsPackageInstalled(IRepositoryInstalled installedRepository, IPackage package)
{
if (package is PackageAlias packageAlias)
{
return(installedRepository.HasPackage(package) && IsPackageInstalled(installedRepository, packageAlias.GetAliasOf()));
}
return(GetInstaller(package.GetPackageType()).IsInstalled(installedRepository, package));
}
/// <inheritdoc />
public void Uninstall(IRepositoryInstalled repository, IPackage package)
{
if (!repository.HasPackage(package))
{
throw new InvalidArgumentException($"Package is not installed: {package}");
}
io.WriteError($" - Removing <info>{package.GetName()}</info> (<comment>{package.GetVersionPrettyFull()}</comment>)");
repository.RemovePackage(package);
}
/// <summary>
/// Purge packages that are not installed.
/// </summary>
protected virtual void PurgePackages(IRepositoryInstalled repositoryInstalled, InstallationManager installationManager)
{
foreach (var package in repositoryInstalled.GetPackages())
{
if (!installationManager.IsPackageInstalled(repositoryInstalled, package))
{
repositoryInstalled.RemovePackage(package);
}
}
}
/// <summary>
/// Executes marke alias uninstall operation.
/// </summary>
/// <param name="installedRepository">The repository in which to check.</param>
/// <param name="operation">The operation instance.</param>
protected virtual void MarkAliasUninstalled(IRepositoryInstalled installedRepository, IOperation operation)
{
if (!(operation is OperationMarkPackageAliasUninstall operationAliasUninstall))
{
throw new UnexpectedException($"The mark package aliased uninstalled operation must be {nameof(OperationMarkPackageAliasUninstall)} instance.");
}
var package = operationAliasUninstall.GetPackage();
installedRepository.RemovePackage(package);
}
/// <summary>
/// Executes uninstall operation.
/// </summary>
/// <param name="installedRepository">The repository in which to check.</param>
/// <param name="operation">The operation instance.</param>
protected virtual void Uninstall(IRepositoryInstalled installedRepository, IOperation operation)
{
if (!(operation is OperationUninstall operationUninstall))
{
throw new UnexpectedException($"The uninstall operation must be {nameof(OperationUninstall)} instance.");
}
var package = operationUninstall.GetPackage();
var installer = GetInstaller(package.GetPackageType());
installer.Uninstall(installedRepository, package);
}
/// <summary>
/// Executes marke alias installed operation.
/// </summary>
/// <param name="installedRepository">The repository in which to check.</param>
/// <param name="operation">The operation instance.</param>
protected virtual void MarkAliasInstalled(IRepositoryInstalled installedRepository, IOperation operation)
{
if (!(operation is OperationMarkPackageAliasInstalled operationAliasInstall))
{
throw new UnexpectedException($"The mark package aliased installed operation must be {nameof(OperationMarkPackageAliasInstalled)} instance.");
}
var package = operationAliasInstall.GetPackage();
if (!installedRepository.HasPackage(package))
{
installedRepository.AddPackage((IPackage)package.Clone());
}
}
/// <inheritdoc />
public override void Install(IRepositoryInstalled repository, IPackage package)
{
base.Install(repository, package);
try
{
GetBucket().GetPluginManager().ActivatePackages(package, true);
}
catch (SException)
{
// Rollback installation
GetIO().WriteError("Plugin installation failed, rolling back.");
Uninstall(repository, package);
throw;
}
}
/// <inheritdoc />
public void Update(IRepositoryInstalled repository, IPackage initial, IPackage target)
{
if (!repository.HasPackage(initial))
{
throw new InvalidArgumentException($"Package is not installed: {initial}");
}
var name = target.GetName();
var from = initial.GetVersionPrettyFull();
var to = target.GetVersionPrettyFull();
var actionName = VersionParser.IsUpgrade(initial.GetVersion(), target.GetVersion()) ? "Updating" : "Downgrading";
io.WriteError($" - {actionName} <info>{name}</info> (<comment>{from}</comment> => <comment>{to}</comment>)");
repository.RemovePackage(initial);
repository.AddPackage((IPackage)target.Clone());
}
/// <inheritdoc />
public virtual void Update(IRepositoryInstalled repository, IPackage initial, IPackage target)
{
if (!repository.HasPackage(initial))
{
throw new InvalidArgumentException($"Package is not installed: {initial}");
}
installerBinary.Remove(initial);
UpdateLibrary(initial, target);
installerBinary.Install(target, GetInstallPath(target));
repository.RemovePackage(initial);
if (!repository.HasPackage(target))
{
repository.AddPackage((IPackage)target.Clone());
}
}
/// <inheritdoc />
public override void Update(IRepositoryInstalled repository, IPackage initial, IPackage target)
{
base.Update(repository, initial, target);
try
{
GetBucket().GetPluginManager().DeactivatePackage(initial);
GetBucket().GetPluginManager().ActivatePackages(target, true);
}
catch (SException)
{
// Rollback installation
GetIO().WriteError("Plugin initialization failed, rolling back.");
Uninstall(repository, target);
Install(repository, initial);
throw;
}
}
/// <inheritdoc />
public virtual void Install(IRepositoryInstalled repository, IPackage package)
{
var installPath = GetInstallPath(package);
// remove the binaries if it appears the package files are missing.
if (!fileSystem.Exists(installPath, FileSystemOptions.Directory) &&
repository.HasPackage(package))
{
installerBinary.Remove(package);
}
InstallLibaray(package);
installerBinary.Install(package, installPath);
if (!repository.HasPackage(package))
{
repository.AddPackage((IPackage)package.Clone());
}
}
/// <inheritdoc />
public virtual void Uninstall(IRepositoryInstalled repository, IPackage package)
{
if (!repository.HasPackage(package))
{
throw new InvalidArgumentException($"Package is not installed: {package}");
}
RemoveLibrary(package);
installerBinary.Remove(package);
repository.RemovePackage(package);
var installPath = GetInstallPath(package);
// If the package comes with a vendor, we also need to
// check if the provider directory is empty.
if (package.GetName().Contains("/"))
{
var venderDir = Path.GetDirectoryName(installPath);
if (fileSystem.IsEmptyDirectory(venderDir))
{
fileSystem.Delete(venderDir);
}
}
}
/// <inheritdoc />
public void Update(IRepositoryInstalled repository, IPackage initial, IPackage target)
{
Uninstall(repository, initial);
Install(repository, target);
}
/// <inheritdoc />
public override void Uninstall(IRepositoryInstalled repository, IPackage package)
{
GetBucket().GetPluginManager().UninstallPackage(package);
base.Uninstall(repository, package);
}
protected override void PurgePackages(IRepositoryInstalled repositoryInstalled, InstallationManager installationManager)
{
// noop.
}
/// <inheritdoc />
public bool IsInstalled(IRepositoryInstalled repository, IPackage package)
{
return(repository.HasPackage(package));
}
/// <summary>
/// Sets local installed repository for the project.
/// </summary>
public virtual void SetLocalInstalledRepository(IRepositoryInstalled repository)
{
localRepository = repository;
}
/// <inheritdoc />
public void Install(IRepositoryInstalled repository, IPackage package)
{
io.WriteError($" - Installing <info>{package.GetName()}</info> (<comment>{package.GetVersionPrettyFull()}</comment>)");
repository.AddPackage((IPackage)package.Clone());
}
