/// <summary>
/// Executes the specified command application.
/// </summary>
/// <param name="cmdApp">The command application.</param>
/// <param name="logErrorAction">The log error action.</param>
/// <returns>Error Code</returns>
protected override async Task <int> Execute(CommandLineApplication cmdApp, Action <string> logErrorAction)
{
if (_package.Values.Count == 0)
{
logErrorAction($"Missed packages list");
return(1);
}
if (MissedOption(_productPath, logErrorAction))
{
return(1);
}
if (MissedOption(_framework, logErrorAction))
{
return(1);
}
if (MissedOption(_source, logErrorAction))
{
return(1);
}
var packageIds = new List <PackageId>();
foreach (var packageValue in _package.Values)
{
var parts = packageValue.Split('/');
if (parts.Length == 1)
{
packageIds.Add(new PackageId(parts[0], string.Empty, false));
}
else
{
var allowPrerelease = parts[1].Contains("-") ||
(parts.Length == 3 && parts[2].Contains("allow-prerelease"));
packageIds.Add(new PackageId(parts[0], parts[1], allowPrerelease));
}
}
var engine = GetDeploymentEngine(cmdApp);
var options = new InstallationOptions
{
AllowDowngrades = _allowDowngrades.HasValue(),
UpdatePackages = _updatePackages.HasValue()
};
await engine.InstallPackages(packageIds, options);
return(0);
}
/// <summary>
/// Installs provided packages
/// </summary>
/// <param name="packages">Packages to install</param>
/// <param name="options">Additional options</param>
/// <returns>Task</returns>
public async Task InstallPackages(ICollection <PackageId> packages, InstallationOptions options)
{
Logger.Info("Installing packages...");
DeploymentContext.RaiseDeploymentEvent(new BeforeMaintenanceEvent());
NuGetEngine.AllowDowngrades = options.AllowDowngrades;
NuGetEngine.UpdatePackages = options.UpdatePackages;
try
{
var productPackages = DeploymentContext.ProductConfigurationProvider.GetPackages();
Logger.Info(
$"{productPackages.Count} product package(s) found and {packages.Count} new package(s) requested");
var versionedPackages = await PackageDiscoverer.Discover(productPackages, packages);
Logger.Info($"Versions are confirmed");
var installationPlan = await PackageDeployer.PlanInstallation(productPackages, versionedPackages);
Logger.Info($"{installationPlan.TargetPackageGraph.Count} package(s) are resolved");
Logger.Info($"\t{installationPlan.InstallCount} package(s) to install");
Logger.Info($"\t{installationPlan.UpdateCount} package(s) to update");
var remainingPackages = new List <ProductPackageInfo>();
foreach (var packageId in installationPlan.RemainingPackages)
{
var info = new ProductPackageInfo();
info.Files.AddRange(DeploymentContext.ProductConfigurationProvider.GetInstalledFiles(packageId, false));
info.Configuration = DeploymentContext.ProductConfigurationProvider.GetPackageConfiguration(packageId);
remainingPackages.Add(info);
}
using (var transaction = TransactionSource.NewTransaction(DeploymentContext))
{
foreach (var deploymentAction in installationPlan.Actions)
{
deploymentAction.Execute(transaction);
}
var newPackages = transaction.InstalledPackages.Union(remainingPackages).ToList();
if (ReconfiguringPackages(newPackages, installationPlan.TargetPackageGraph))
{
transaction.Commit();
}
}
}
catch (Exception e)
{
Logger.TraceException(e.Message, e);
throw;
}
if (DontCachePackages)
{
try
{
Directory.Delete(PackagesFolderPath, true);
}
catch
{
Logger.Warn($"Failed to delete packages folder: {PackagesFolderPath}");
}
}
DeploymentContext.RaiseDeploymentEvent(new AfterMaintenanceEvent());
Logger.Info("Installation complete.");
}
public HomeController(IOptions <InstallationOptions> installationOptions)
{
_installationOptions = installationOptions.Value;
}
