// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using OpenTap.Cli;
|
using OpenTap.Package.PackageInstallHelpers;
|
|
#pragma warning disable 1591 // TODO: Add XML Comments in this file, then remove this
|
namespace OpenTap.Package
|
{
|
[Display("install", Group: "package", Description: "Install one or more packages.")]
|
public class PackageInstallAction : IsolatedPackageAction
|
{
|
static readonly TraceSource Log = OpenTap.Log.CreateSource("Install");
|
|
[Obsolete("Use Force instead.")]
|
public bool ForceInstall { get => Force; set => Force = value; }
|
|
[CommandLineArgument("dependencies", Description = "Install dependencies without asking. This is always enabled when installing bundle packages.", ShortName = "y")]
|
public bool InstallDependencies { get; set; }
|
|
[Obsolete("It is no longer supported to ignore dependencies as it causes a broken installation when used.")]
|
[CommandLineArgument("no-dependencies", Description = "Don't install dependencies. This is implied when using --force.")]
|
public bool IgnoreDependencies { get; set; }
|
|
[CommandLineArgument("overwrite", Description = "Overwrite files that already exist without asking. This is implied when using --force.")]
|
public bool Overwrite { get; set; }
|
|
[CommandLineArgument("repository", Description = CommandLineArgumentRepositoryDescription, ShortName = "r")]
|
public string[] Repository { get; set; }
|
|
[CommandLineArgument("no-cache", Description = CommandLineArgumentNoCacheDescription)]
|
public bool NoCache { get; set; }
|
|
[CommandLineArgument("version", Description = CommandLineArgumentVersionDescription)]
|
public string Version { get; set; }
|
|
[CommandLineArgument("os", Description = CommandLineArgumentOsDescription)]
|
public string OS { get; set; }
|
|
[CommandLineArgument("architecture", Description = CommandLineArgumentArchitectureDescription)]
|
public CpuArchitecture Architecture { get; set; }
|
|
/// <summary>
|
/// This is used when specifying the install action through the CLI. If you need to specify multiple packages with different version numbers, use <see cref="PackageReferences"/>
|
/// </summary>
|
[UnnamedCommandLineArgument("package(s)", Required = true, Description = "One or more packages to install. A package can refer to a .TapPackage file, or a name to be resolved from the specified repositories.")]
|
public string[] Packages { get; set; }
|
|
[CommandLineArgument("check-only", Description = "Checks if the selected package(s) can be installed, but does not install or download them.")]
|
public bool CheckOnly { get; set; }
|
|
[Obsolete("Interactive is the default. Use --non-interactive to disable.")]
|
[CommandLineArgument("interactive", Description = "More user responsive.")]
|
[Browsable(false)]
|
public bool Interactive { get; set; }
|
|
/// <summary>
|
/// Never prompt for user input.
|
/// </summary>
|
[CommandLineArgument("non-interactive", Description = "Never prompt for user input.")]
|
public bool NonInteractive { get; set; } = false;
|
|
[CommandLineArgument("no-downgrade", Description = "Don't install if the same or a newer version is already installed.")]
|
public bool NoDowngrade { get; set; }
|
|
[CommandLineArgument("unpack-only", Description = "Only unpack the package payload into the installation directory and\n" +
|
"skip any additional install actions the package might have defined.\n" +
|
"This can leave the installed package unusable.")]
|
public bool UnpackOnly { get; set; }
|
|
// This is set when system wide packages are being installed.
|
public bool SystemWideOnly { get; set; }
|
|
/// <summary>
|
/// This is used when specifying multiple packages with different version numbers. In that case <see cref="Packages"/> can be left null.
|
/// </summary>
|
public PackageSpecifier[] PackageReferences { get; set; }
|
|
|
private string DefaultOs;
|
|
/// <summary>
|
/// This will be set only if the install action was started by <see cref="PackageInstallStep"/>
|
/// This is supposed to solve an issue where OpenTAP fails to detect that the process was elevated.
|
/// If one level of elevation was already attempted, it is unlikely that further attempts will cause the check to succeed.
|
/// In this instance, it is better to just try the installation with the current privileges, and fail with whatever
|
/// error if those privileges are not sufficient.
|
/// </summary>
|
internal bool AlreadyElevated { get; set; }
|
|
public PackageInstallAction()
|
{
|
Architecture = ArchitectureHelper.GuessBaseArchitecture;
|
OS = GuessHostOS();
|
|
DefaultOs = OS;
|
}
|
|
private int DoExecute(CancellationToken cancellationToken)
|
{
|
if (Target == null)
|
Target = FileSystemHelper.GetCurrentInstallationDirectory();
|
|
|
if (TryFindParentInstallation(Target, out var parent))
|
{
|
log.Error($"OpenTAP installation detected in directory '{parent}'. Nested installations are not supported.");
|
return 1;
|
}
|
|
var targetInstallation = new Installation(Target);
|
|
|
if (NoCache) PackageManagerSettings.Current.UseLocalPackageCache = false;
|
Repository = ExtractRepositoryTokens(Repository, true);
|
List<IPackageRepository> repositories = PackageManagerSettings.Current.GetEnabledRepositories(Repository);
|
if (!NonInteractive)
|
Packages = AutoCorrectPackageNames.Correct(Packages, repositories);
|
|
bool installError = false;
|
var installer = new Installer(Target, cancellationToken)
|
{ DoSleep = false, ForceInstall = Force, UnpackOnly = UnpackOnly };
|
installer.ProgressUpdate += RaiseProgressUpdate;
|
installer.Error += RaiseError;
|
installer.Error += ex => installError = true;
|
|
try
|
{
|
Log.Debug("Fetching package information...");
|
|
RaiseProgressUpdate(5, "Gathering packages.");
|
|
// If exact version is specified, check if it's already installed
|
if (Version != null && SemanticVersion.TryParse(Version, out var vs) && Force == false)
|
{
|
foreach (var pkg in Packages)
|
{
|
// We should always install when it's a file, this could be part of development
|
if (File.Exists(pkg))
|
break;
|
|
PackageIdentifier pid = new PackageIdentifier(pkg, vs, Architecture, OS);
|
var installedPackage = targetInstallation.GetPackages(validOnly: true).FirstOrDefault(p => p.Name == pid.Name);
|
if (installedPackage != null && pid.Version.Equals(installedPackage.Version))
|
{
|
Log.Info($"Package '{pid.Name}' '{installedPackage.Version}' is already installed.");
|
return (int)ExitCodes.Success;
|
}
|
}
|
}
|
|
// Get package information
|
bool askToInstallDependencies = !NonInteractive;
|
if (Force)
|
askToInstallDependencies = false;
|
|
List<PackageDef> packagesToInstall;
|
try
|
{
|
packagesToInstall = PackageActionHelpers.GatherPackagesAndDependencyDefs(
|
targetInstallation, PackageReferences, Packages, Version, Architecture, OS, repositories, Force,
|
NoDowngrade);
|
}
|
catch (ImageResolveException ex) when (ex.Result is FailedImageResolution fir)
|
{
|
// If the problem is exactly that we failed to resolve a compatible release version of a package,
|
// ask the user to retry the resolution with a pre-release instead.
|
// We could also ask for an RC / Any, but if there are no releases, then it is likely also the case that there are no RCs.
|
// 'any' would be the most likely specifier to succeed, but it is probably a bit too extreme to suggest something so bleeding edge.
|
// A beta version strikes a good middle ground. It is pretty likely to resolve, and probably won't be too unstable.
|
if (NonInteractive) throw;
|
if (Packages.Length != 1) throw;
|
if (fir.resolveProblems.Count != 1) throw;
|
|
var problem = fir.resolveProblems[0];
|
if (problem.Version != VersionSpecifier.AnyRelease) throw;
|
// Only show the beta option if the resolution problem was with the package we are trying to install
|
if (problem.Name != Packages[0]) throw;
|
|
// Try to resolve a beta version instead, but only offer the beta version if the user wants it
|
try
|
{
|
packagesToInstall = PackageActionHelpers.GatherPackagesAndDependencyDefs(
|
targetInstallation, PackageReferences, Packages, "beta", Architecture, OS, repositories,
|
Force, NoDowngrade);
|
}
|
catch
|
{
|
// throw original exception if beta resolution fails
|
throw ex;
|
}
|
|
// If the beta resolution succeeded, ask the user if they want to install the beta version
|
var betaVersion = packagesToInstall.First(p => p.Name == problem.Name).Version;
|
|
var req = new AskAboutPrerelease($"Package '{problem.Name}' has no compatible release version, but the beta version '{betaVersion.ToString(4)}' is compatible.\nInstall this version instead?");
|
UserInput.Request(req);
|
if (req.Response == UseBetaQuestion.No) throw;
|
|
}
|
|
if (SystemWideOnly)
|
{
|
// the current process is for installing system wide packages only.
|
packagesToInstall = packagesToInstall.Where(x => x.IsSystemWide()).ToList();
|
}
|
|
if (packagesToInstall?.Any() != true)
|
{
|
if (NoDowngrade)
|
{
|
Log.Info("No package(s) were upgraded.");
|
return (int)ExitCodes.Success;
|
}
|
|
Log.Info("Could not find one or more packages.");
|
return (int)PackageExitCodes.PackageDependencyError;
|
}
|
|
foreach (var pkg in packagesToInstall)
|
{
|
// print a warning if the selected package is incompatible with the host platform.
|
// or return an error if the package does not match.
|
var platformCompatible =
|
pkg.IsPlatformCompatible(targetInstallation.Architecture, targetInstallation.OS);
|
|
if (!Force)
|
{
|
// print a warning if necessary.
|
// --os and --architecture are not really supported when --force is not enabled.
|
// we only allow resolving to installable packages.
|
var differentArch = ArchitectureHelper.GuessBaseArchitecture != Architecture;
|
|
bool printedWarning = false;
|
void maybePrintWarning()
|
{
|
if (printedWarning) return;
|
printedWarning = true;
|
Log.Warning("OS or Architecture were specified without --force. Only compatible packages will be selected.");
|
|
}
|
foreach (var package in packagesToInstall)
|
{
|
if (differentArch)
|
{
|
if (package.Architecture != CpuArchitecture.AnyCPU && Architecture != package.Architecture)
|
{
|
maybePrintWarning();
|
Log.Warning("Selected package {2} architecture {0} instead of {1}", package.Architecture, Architecture, package.Name);
|
}
|
}
|
|
if (OS != DefaultOs)
|
{
|
if (!package.IsOsCompatible(OS))
|
{
|
maybePrintWarning();
|
Log.Warning("Selected package {2} for {0} instead of {1}", package.Name, package.OS, OS);
|
}
|
}
|
}
|
|
}
|
|
if (!platformCompatible)
|
{
|
var selectedPlatformCompatible = pkg.IsPlatformCompatible(Architecture, OS);
|
var message =
|
$"Selected package {pkg.Name} for {pkg.OS}, {pkg.Architecture} is incompatible with the host platform {targetInstallation.OS}, {targetInstallation.Architecture}.";
|
if (selectedPlatformCompatible || Force)
|
// --OS [arg] was used or --force is specified. Try to install it anyway.
|
Log.Warning(message);
|
else
|
{
|
Log.Error(message);
|
return (int)ExitCodes.ArgumentError;
|
}
|
}
|
}
|
|
var installationPackages = targetInstallation.GetPackages(validOnly: true);
|
|
var overWriteCheckExitCode = CheckForOverwrittenPackages(installationPackages, packagesToInstall,
|
Force || Overwrite, !(NonInteractive || Overwrite));
|
if (overWriteCheckExitCode == InstallationQuestion.Cancel)
|
{
|
Log.Info("Install cancelled by user.");
|
return (int)ExitCodes.UserCancelled;
|
}
|
|
if (overWriteCheckExitCode == InstallationQuestion.OverwriteFile)
|
Log.Warning("Overwriting files. (--{0} option specified).", Overwrite ? "overwrite" : "force");
|
|
RaiseProgressUpdate(10, "Gathering dependencies.");
|
|
if (!SystemWideOnly)
|
{
|
// Sometimes system wide packages depends on non-system wide packages.
|
// when installing system wide packages in a sub-process we dont need to check the dependencies
|
// because that has already been done.
|
|
bool checkDependencies = !Force || CheckOnly;
|
var installedToCheck =
|
installationPackages.Where(p =>
|
p.IsSystemWide() ==
|
false); // don't use system-wide to check, as that would prevent installing older stuff, if a system-wide package depends on newer versions.
|
var issue = DependencyChecker.CheckDependencies(installedToCheck, packagesToInstall,
|
Force ? LogEventType.Information :
|
checkDependencies ? LogEventType.Error : LogEventType.Warning);
|
|
if (checkDependencies)
|
{
|
if (issue == DependencyChecker.Issue.BrokenPackages)
|
{
|
Log.Info("To fix the package conflict uninstall or update the conflicted packages.");
|
Log.Info(
|
"To install packages despite the conflicts, use the --force option. Note that this can break the installation.");
|
return (int)PackageExitCodes.PackageDependencyError;
|
}
|
|
if (CheckOnly)
|
{
|
Log.Info("Check completed with no problems detected.");
|
return (int)ExitCodes.Success;
|
}
|
}
|
}
|
|
// Download the packages
|
// We divide the progress by 2 in the progress update because we assume downloading the packages
|
// accounts for half the installation progress. So when all the packages have finished downloading,
|
// we have finished 10 + (100/2)% of the installation process.
|
packagesToInstall = packagesToInstall.OrderBy(p => p.IsSystemWide()).ToList();
|
|
var downloadedPackageFiles = PackageActionHelpers.DownloadPackages(
|
PackageCacheHelper.PackageCacheDirectory, packagesToInstall,
|
progressUpdate: (progress, msg) => RaiseProgressUpdate(10 + progress / 2, msg),
|
ignoreCache: NoCache);
|
|
// The downloaded package files will arrive in the same order as the packagesToInstall list.
|
// We need to split the list into two parts, one for regular packages and one for systemwide packages.
|
var cutoff = packagesToInstall.FindIndex(p => p.IsSystemWide());
|
if (cutoff == -1) cutoff = packagesToInstall.Count;
|
|
var regularPackages = downloadedPackageFiles.Take(cutoff).ToList();
|
var systemwidePackages = downloadedPackageFiles.Skip(cutoff).ToArray();
|
|
// We need to elevate if
|
// 1. Elevation was not already attempted, and
|
// 2. we need to install systemWide packages, and
|
// 3. We are not already running as admin
|
bool needElevation = !AlreadyElevated && systemwidePackages.Any() && SubProcessHost.IsAdmin() == false;
|
|
// Warn the user if elevation was already attempted, and we are not currently running as admin
|
if (AlreadyElevated && SubProcessHost.IsAdmin() == false)
|
{
|
log.Warning($"Process elevation failed. Installation will continue without elevation.");
|
}
|
|
// If we need to install system-wide packages and we are not admin, we should install them in an elevated sub-process
|
if (needElevation)
|
{
|
RaiseProgressUpdate(20, "Installing system-wide packages.");
|
var installStep = new PackageInstallStep()
|
{
|
Packages = systemwidePackages,
|
Repositories = Array.Empty<string>(),
|
Target = PackageDef.SystemWideInstallationDirectory,
|
Force = Force,
|
SystemWideOnly = true
|
};
|
|
var processRunner = new SubProcessHost
|
{
|
ForwardLogs = true,
|
MutedSources =
|
{
|
"CLI", "Session", "Resolver", "AssemblyFinder", "PluginManager", "TestPlan",
|
"UpdateCheck",
|
"Installation"
|
},
|
// The current install action is a locking package action.
|
// Setting this flag lets the child process bypass the lock on the installation.
|
Unlocked = true,
|
};
|
|
var result = processRunner.Run(installStep, true, cancellationToken);
|
if (result != Verdict.Pass)
|
{
|
var ex = new Exception(
|
$"Failed installing system-wide packages. Try running the command as administrator.");
|
RaiseError(ex);
|
throw ex;
|
}
|
|
var pct = ((double)systemwidePackages.Length / (systemwidePackages.Length + packagesToInstall.Count)) * 100;
|
RaiseProgressUpdate((int)pct, "Installed system-wide packages.");
|
}
|
// Otherwise if we are admin and we need to install system-wide packages, we can install them in the current process
|
else if (systemwidePackages.Any())
|
{
|
installer.PackagePaths.AddRange(systemwidePackages);
|
}
|
|
installer.PackagePaths.AddRange(regularPackages);
|
}
|
catch (OperationCanceledException e)
|
{
|
Log.Info(e.Message);
|
return (int)ExitCodes.UserCancelled;
|
}
|
catch (ImageResolveException ex)
|
{
|
if (Packages != null && Packages.Length > 0)
|
{
|
Log.Error("Could not install {0}{1}",
|
string.Join(", ", Packages.Select(x => $"{x}")),
|
string.IsNullOrWhiteSpace(Version) ? "" : $" v{Version}");
|
|
// If the requested package is a bundle, the easiest way to resolve the resolution error is to uninstall the bundle.
|
if (Packages.Length == 1 &&
|
targetInstallation.GetPackages().FirstOrDefault(p => p.Name == Packages[0]) is PackageDef pkg &&
|
pkg.IsBundle())
|
{
|
Log.Error( $"Please try manually uninstalling '{Packages[0]}' and re-installing it.");
|
return (int)PackageExitCodes.PackageDependencyError;
|
}
|
}
|
else
|
{
|
Log.Error("Could not resolve one or more packages.");
|
}
|
|
var unsatisfiedDependencies = ex.InstalledPackages.Where(x => false == x.Dependencies.All(dep =>
|
ex.InstalledPackages.Any(x2 =>
|
x2.Name == dep.Name && dep.Version.IsSatisfiedBy(x2.Version.AsExactSpecifier())))).ToArray();
|
if (unsatisfiedDependencies.Any())
|
{
|
Log.Warning("This might be because of the following conflicts:");
|
|
var missingDeps = unsatisfiedDependencies.SelectMany(x => x.Dependencies.Where(dep =>
|
!ex.InstalledPackages.Any(x2 =>
|
x2.Name == dep.Name && dep.Version.IsSatisfiedBy(x2.Version.AsExactSpecifier()))))
|
.ToArray();
|
|
foreach (var grouping in missingDeps.GroupBy(d => d.Name))
|
{
|
var versions = grouping.ToArray();
|
var highest = versions.FindMax(dep => dep.Version);
|
var dependers =
|
unsatisfiedDependencies.Where(dep => dep.Dependencies.Any(d => d.Name == grouping.Key));
|
|
// Omit the warnings for packages that would have been satisfied by the specified version
|
if (Packages[0] == grouping.Key && !string.IsNullOrWhiteSpace(Version) && VersionSpecifier.TryParse(Version, out var filter))
|
{
|
dependers = dependers.Where(dep =>
|
false == dep.Dependencies.First(d => d.Name == grouping.Key).Version
|
.IsSatisfiedBy(filter));
|
}
|
var dependString = string.Join(", ", dependers.Select(d => d.Name));
|
Log.Info($"{grouping.Key} version {highest.Version} required by {dependString}");
|
}
|
}
|
|
// If the problem is not generic, then there are additional details about the resolution problem.
|
if (ex.Result is FailedImageResolution f && f.resolveProblems is not GenericResolutionProblem)
|
log.Info(f.resolveProblems.Description());
|
|
Log.Debug("{0}", ex.Message);
|
return (int)ExitCodes.PackageResolutionError;
|
}
|
catch (Exception e)
|
{
|
Log.Info("Could not download one or more packages.");
|
Log.Info(e.Message);
|
Log.Debug(e);
|
RaiseError(e);
|
return (int)ExitCodes.NetworkError;
|
}
|
|
// This happens in cases where only system-wide packages were requested.
|
if (installer.PackagePaths.Count == 0)
|
return 0;
|
|
Log.Info("Installing to {0}", Path.GetFullPath(Target));
|
|
// Uninstall old packages before
|
var status = UninstallExisting(targetInstallation, installer.PackagePaths, cancellationToken);
|
if (status != (int)ExitCodes.Success)
|
return status;
|
|
var toInstall = ReorderPackages(installer.PackagePaths);
|
installer.PackagePaths.Clear();
|
installer.PackagePaths.AddRange(toInstall);
|
|
// Install the package
|
installer.InstallThread();
|
|
if (installError)
|
return (int)PackageExitCodes.PackageInstallError;
|
|
return 0;
|
}
|
|
protected override int LockedExecute(CancellationToken cancellationToken)
|
{
|
var currentInterface = UserInput.GetInterface();
|
if (NonInteractive)
|
UserInput.SetInterface(new NonInteractiveUserInputInterface());
|
|
try
|
{
|
return DoExecute(cancellationToken);
|
}
|
finally
|
{
|
IncrementChangeId(Target);
|
UserInput.SetInterface(currentInterface);
|
}
|
}
|
|
private int UninstallExisting(Installation installation, List<string> packagePaths, CancellationToken cancellationToken)
|
{
|
var installed = installation.GetPackages();
|
|
var packages = packagePaths.Select(PackageDef.FromPackage).Select(x => x.Name).ToHashSet();
|
var existingPackages = installed.Where(kvp => packages.Contains(kvp.Name)).Select(x => (x.PackageSource as XmlPackageDefSource)?.PackageDefFilePath).ToList();
|
|
if (existingPackages.Count == 0) return (int)ExitCodes.Success;
|
|
var newInstaller = new Installer(Target, cancellationToken);
|
|
//newInstaller.ProgressUpdate += RaiseProgressUpdate;
|
newInstaller.Error += RaiseError;
|
newInstaller.DoSleep = false;
|
|
newInstaller.PackagePaths.AddRange(existingPackages);
|
return newInstaller.UninstallThread();
|
}
|
|
/// <summary>
|
/// Reorder packages to ensure that dependencies are installed before a package needing it.
|
/// </summary>
|
/// <param name="packagePaths"></param>
|
/// <returns></returns>
|
private List<string> ReorderPackages(List<string> packagePaths)
|
{
|
var toInstall = new List<string>();
|
|
var packages = packagePaths.ToDictionary(k => k, k => PackageDef.FromPackage(k));
|
|
while (packages.Count > 0)
|
{
|
var next = packages.FirstOrDefault(pkg => pkg.Value.Dependencies.All(dep => !packages.Values.Any(p => p.Name == dep.Name)));
|
|
if (next.Value == null) next = packages.First(); // This doesn't matter at this point
|
|
toInstall.Add(next.Key);
|
packages.Remove(next.Key);
|
}
|
|
return toInstall;
|
}
|
|
|
public enum InstallationQuestion
|
{
|
//KeepExitingFiles = 3,
|
[Display("Cancel", Order: 2)]
|
Cancel = 2,
|
[Display("Overwrite Files", Order: 1)]
|
OverwriteFile = 1,
|
|
[Browsable(false)]
|
Success = 0,
|
}
|
|
class AskAboutInstallingAnyway
|
{
|
public string Name { get; } = "Overwrite Files?";
|
|
[Browsable(true)]
|
[Layout(LayoutMode.FullRow)]
|
public string Message { get; private set; }
|
|
public AskAboutInstallingAnyway(string message) => Message = message;
|
|
[Layout(LayoutMode.FloatBottom | LayoutMode.FullRow)]
|
[Submit] public InstallationQuestion Response { get; set; } = InstallationQuestion.Cancel;
|
}
|
|
internal enum UseBetaQuestion
|
{
|
[Display("Yes")]
|
Beta = 0,
|
[Display("No")]
|
No = 1,
|
}
|
|
class AskAboutPrerelease
|
{
|
[Browsable(true)]
|
[Layout(LayoutMode.FullRow)]
|
public string Message { get; private set; }
|
public AskAboutPrerelease(string message) => Message = message;
|
[Layout(LayoutMode.FloatBottom | LayoutMode.FullRow)]
|
[Submit] public UseBetaQuestion Response { get; set; } = UseBetaQuestion.No;
|
}
|
|
internal static InstallationQuestion CheckForOverwrittenPackages(IEnumerable<PackageDef> installedPackages,
|
IEnumerable<PackageDef> packagesToInstall, bool force, bool interactive = false)
|
{
|
var conflicts = VerifyPackageHashes.CalculatePackageInstallConflicts(installedPackages, packagesToInstall);
|
|
void buildMessage(Action<string> addLine)
|
{
|
foreach (var conflictGroup in conflicts.ToLookup(x => x.OffendingPackage))
|
{
|
addLine($" These files will be overwritten if package '{conflictGroup.Key.Name}' is installed:");
|
foreach (var conflict in conflictGroup)
|
{
|
addLine($" {conflict.File.FileName} (from package '{conflict.Package.Name}').");
|
}
|
}
|
}
|
|
if (conflicts.Any())
|
{
|
if (interactive)
|
{
|
StringBuilder message = new StringBuilder();
|
buildMessage(line => message.AppendLine(line));
|
var question = new AskAboutInstallingAnyway(message.ToString());
|
UserInput.Request(question);
|
return question.Response;
|
}
|
|
buildMessage(line => Log.Info(line));
|
|
if (force)
|
{
|
return InstallationQuestion.OverwriteFile;
|
}
|
|
Log.Error(
|
"Installing these packages will overwrite existing files. " +
|
"Use --overwrite to overwrite existing files, possibly breaking installed packages.");
|
return InstallationQuestion.Cancel;
|
}
|
|
return InstallationQuestion.Success;
|
}
|
}
|
}
|
