Improvements for nuget.exe install

* Allow updating packages when -ExcludeVersion is used
* Improved detection of already installed packages when -ExcludeVersion is used
* Adding -Framework switch to allow setting the target framework used when resolving dependencies.
* Remove NU1000 code from packages.config restore errors.
* Avoid unneeded downloads when a version is not given and the package is cached.
* Disable parallel for mono
* Display errors and return a non-zero exit when install on packages.config fails
* Remove old files during upgrades with -ExcludeVersion

Fixes NuGet/Home#5743
Fixes NuGet/Home#5737
Fixes NuGet/Home#5736
Fixes NuGet/Home#5741
Fixes NuGet/Home#5017
Fixes NuGet/Home#3957
Fixes NuGet/Home#2405

Author: emgarten

src/NuGet.Clients/NuGet.CommandLine/Commands/DownloadCommandBase.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -45,6 +45,11 @@ public ICollection<string> Source
         [Option(typeof(NuGetCommand), "CommandPackageSaveMode")]
         public string PackageSaveMode { get; set; }
 
+        /// <summary>
+        /// If true the global packages folder NOT will be added as a source.
+        /// </summary>
+        internal bool ExcludeCacheAsSource { get; set; }
+
         internal void CalculateEffectivePackageSaveMode()
         {
             string packageSaveModeValue = PackageSaveMode;
@@ -117,7 +122,7 @@ internal void CalculateEffectivePackageSaveMode()
             var availableSources = SourceProvider.LoadPackageSources().Where(source => source.IsEnabled);
             var packageSources = new List<Configuration.PackageSource>();
 
-            if (!NoCache)
+            if (!NoCache && !ExcludeCacheAsSource)
             {
                 // Add the v3 global packages folder
                 var globalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);

src/NuGet.Clients/NuGet.CommandLine/Commands/InstallCommand.cs

@@ -2,6 +2,8 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.Globalization;
 using System.IO;
@@ -10,6 +12,7 @@
 using System.Threading.Tasks;
 using NuGet.Common;
 using NuGet.Configuration;
+using NuGet.Frameworks;
 using NuGet.PackageManagement;
 using NuGet.Packaging;
 using NuGet.Packaging.Core;
@@ -36,6 +39,9 @@ public class InstallCommand : DownloadCommandBase
         [Option(typeof(NuGetCommand), "InstallCommandDependencyVersion")]
         public string DependencyVersion { get; set; }
 
+        [Option(typeof(NuGetCommand), "InstallCommandFrameworkDescription")]
+        public string Framework { get; set; }
+
         [Option(typeof(NuGetCommand), "InstallCommandExcludeVersionDescription", AltName = "x")]
         public bool ExcludeVersion { get; set; }
 
@@ -51,24 +57,25 @@ public class InstallCommand : DownloadCommandBase
         [ImportingConstructor]
         protected internal InstallCommand()
         {
-            // On mono, parallel builds are broken for some reason. See https://gist.github.com/4201936 for the errors
-            // That are thrown.
-            DisableParallelProcessing = RuntimeEnvironmentHelper.IsMono;
         }
 
         public override Task ExecuteCommandAsync()
         {
+            // On mono, parallel builds are broken for some reason. See https://gist.github.com/4201936 for the errors
+            // That are thrown.
+            DisableParallelProcessing |= RuntimeEnvironmentHelper.IsMono;
+
             if (DisableParallelProcessing)
             {
                 HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
             }
 
             CalculateEffectivePackageSaveMode();
             CalculateEffectiveSettings();
-            string installPath = ResolveInstallPath();
+            var installPath = ResolveInstallPath();
 
-            string configFilePath = Path.GetFullPath(Arguments.Count == 0 ? Constants.PackageReferenceFile : Arguments[0]);
-            string configFileName = Path.GetFileName(configFilePath);
+            var configFilePath = Path.GetFullPath(Arguments.Count == 0 ? Constants.PackageReferenceFile : Arguments[0]);
+            var configFileName = Path.GetFileName(configFilePath);
 
             // If the first argument is a packages.xxx.config file, install everything it lists
             // Otherwise, treat the first argument as a package Id
@@ -80,27 +87,27 @@ public override Task ExecuteCommandAsync()
                 if (Console != null && RequireConsent &&
                     new PackageRestoreConsent(Settings).IsGranted)
                 {
-                    string message = String.Format(
+                    var message = string.Format(
                         CultureInfo.CurrentCulture,
                         LocalizedResourceManager.GetString("RestoreCommandPackageRestoreOptOutMessage"),
                         NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
                     Console.WriteLine(message);
                 }
 
-                return PerformV2Restore(configFilePath, installPath);
+                return PerformV2RestoreAsync(configFilePath, installPath);
             }
             else
             {
                 var packageId = Arguments[0];
                 var version = Version != null ? new NuGetVersion(Version) : null;
-                return InstallPackage(packageId, version, installPath);
+                return InstallPackageAsync(packageId, version, installPath);
             }
         }
 
         private void CalculateEffectiveSettings()
         {
             // If the SolutionDir is specified, use the .nuget directory under it to determine the solution-level settings
-            if (!String.IsNullOrEmpty(SolutionDirectory))
+            if (!string.IsNullOrEmpty(SolutionDirectory))
             {
                 var path = Path.Combine(SolutionDirectory.TrimEnd(Path.DirectorySeparatorChar), NuGetConstants.NuGetSolutionSettingsFolder);
 
@@ -119,20 +126,20 @@ private void CalculateEffectiveSettings()
 
         internal string ResolveInstallPath()
         {
-            if (!String.IsNullOrEmpty(OutputDirectory))
+            if (!string.IsNullOrEmpty(OutputDirectory))
             {
                 // Use the OutputDirectory if specified.
                 return OutputDirectory;
             }
 
-            string installPath = SettingsUtility.GetRepositoryPath(Settings);
-            if (!String.IsNullOrEmpty(installPath))
+            var installPath = SettingsUtility.GetRepositoryPath(Settings);
+            if (!string.IsNullOrEmpty(installPath))
             {
                 // If a value is specified in config, use that.
                 return installPath;
             }
 
-            if (!String.IsNullOrEmpty(SolutionDirectory))
+            if (!string.IsNullOrEmpty(SolutionDirectory))
             {
                 // For package restore scenarios, deduce the path of the packages directory from the solution directory.
                 return Path.Combine(SolutionDirectory, CommandLineConstants.PackagesDirectoryName);
@@ -142,7 +149,7 @@ internal string ResolveInstallPath()
             return CurrentDirectory;
         }
 
-        private async Task PerformV2Restore(string packagesConfigFilePath, string installPath)
+        private async Task PerformV2RestoreAsync(string packagesConfigFilePath, string installPath)
         {
             var sourceRepositoryProvider = GetSourceRepositoryProvider();
             var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath, ExcludeVersion);
@@ -158,15 +165,17 @@ private async Task PerformV2Restore(string packagesConfigFilePath, string instal
                     isMissing: true));
 
             var packageSources = GetPackageSources(Settings);
-            
+
             Console.PrintPackageSources(packageSources);
 
+            var failedEvents = new ConcurrentQueue<PackageRestoreFailedEventArgs>();
+
             var packageRestoreContext = new PackageRestoreContext(
                 nuGetPackageManager,
                 packageRestoreData,
                 CancellationToken.None,
                 packageRestoredEvent: null,
-                packageRestoreFailedEvent: null,
+                packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); },
                 sourceRepositories: packageSources.Select(sourceRepositoryProvider.CreateRepository),
                 maxNumberOfParallelTasks: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism);
 
@@ -189,7 +198,7 @@ private async Task PerformV2Restore(string packagesConfigFilePath, string instal
 
                 var downloadContext = new PackageDownloadContext(cacheContext, installPath, DirectDownload);
 
-                await PackageRestoreManager.RestoreMissingPackagesAsync(
+                var result = await PackageRestoreManager.RestoreMissingPackagesAsync(
                     packageRestoreContext,
                     new ConsoleProjectContext(Console),
                     downloadContext);
@@ -198,6 +207,17 @@ await PackageRestoreManager.RestoreMissingPackagesAsync(
                 {
                     GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext);
                 }
+
+                if (!result.Restored || failedEvents.Count > 0)
+                {
+                    // Log errors if they exist
+                    foreach (var message in failedEvents.Select(e => new RestoreLogMessage(LogLevel.Error, NuGetLogCode.Undefined, e.Exception.Message)))
+                    {
+                        await Console.LogAsync(message);
+                    }
+
+                    throw new ExitCodeException(1);
+                }
             }
         }
 
@@ -221,9 +241,9 @@ private DependencyBehavior TryGetDependencyBehavior(string behaviorStr)
         private DependencyBehavior GetDependencyBehavior()
         {
             // If dependencyVersion is not set by either the config or commandline, default dependency behavior is 'Lowest'.
-            DependencyBehavior dependencyBehavior = DependencyBehavior.Lowest;
+            var dependencyBehavior = DependencyBehavior.Lowest;
 
-            string settingsDependencyVersion = SettingsUtility.GetConfigValue(Settings, "dependencyVersion");
+            var settingsDependencyVersion = SettingsUtility.GetConfigValue(Settings, "dependencyVersion");
 
             // Check to see if commandline flag is set. Else check for dependencyVersion in .config.
             if (!string.IsNullOrEmpty(DependencyVersion))
@@ -238,28 +258,33 @@ private DependencyBehavior GetDependencyBehavior()
             return dependencyBehavior;
         }
 
-        private async Task InstallPackage(
+        private async Task InstallPackageAsync(
             string packageId,
             NuGetVersion version,
             string installPath)
         {
             if (version == null)
             {
-                NoCache = true;
+                // Avoid searching for the highest version in the global packages folder,
+                // it needs to come from the feeds instead. Once found it may come from
+                // the global packages folder unless NoCache is true.
+                ExcludeCacheAsSource = true;
             }
 
-            var folderProject = new FolderNuGetProject(
-                installPath,
-                new PackagePathResolver(installPath, !ExcludeVersion));
+            var framework = GetTargetFramework();
+
+            // Create the project and set the framework if available.
+            var project = new InstallCommandProject(
+                root: installPath,
+                packagePathResolver: new PackagePathResolver(installPath, !ExcludeVersion),
+                targetFramework: framework);
 
             var sourceRepositoryProvider = GetSourceRepositoryProvider();
             var packageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath);
 
             var packageSources = GetPackageSources(Settings);
-
-            Console.PrintPackageSources(packageSources);
-
             var primaryRepositories = packageSources.Select(sourceRepositoryProvider.CreateRepository);
+            Console.PrintPackageSources(packageSources);
 
             var allowPrerelease = Prerelease || (version != null && version.IsPrerelease);
 
@@ -273,10 +298,15 @@ private async Task InstallPackage(
 
             if (version == null)
             {
+                // Write out a helpful message before the http messages are shown
+                Console.Log(LogLevel.Minimal, string.Format(
+                    CultureInfo.CurrentCulture,
+                    LocalizedResourceManager.GetString("InstallPackageMessage"), packageId, installPath));
+
                 // Find the latest version using NuGetPackageManager
                 var resolvePackage = await NuGetPackageManager.GetLatestVersionAsync(
                     packageId,
-                    folderProject,
+                    project,
                     resolutionContext,
                     primaryRepositories,
                     Console,
@@ -295,9 +325,23 @@ private async Task InstallPackage(
                 version = resolvePackage.LatestVersion;
             }
 
+            // Get a list of packages already in the folder.
+            var installedPackages = await project.GetFolderPackagesAsync(CancellationToken.None);
+
+            // Find existing versions of the package
+            var alreadyInstalledVersions = new HashSet<NuGetVersion>(installedPackages
+                .Where(e => StringComparer.OrdinalIgnoreCase.Equals(packageId, e.PackageIdentity.Id))
+                .Select(e => e.PackageIdentity.Version));
+
             var packageIdentity = new PackageIdentity(packageId, version);
 
-            if (folderProject.PackageExists(packageIdentity))
+            // Check if the package already exists or a higher version exists already.
+            var skipInstall = project.PackageExists(packageIdentity);
+
+            // For SxS allow other versions to install. For non-SxS skip if a higher version exists.
+            skipInstall |= (ExcludeVersion && alreadyInstalledVersions.Any(e => e >= version));
+
+            if (skipInstall)
             {
                 var message = string.Format(
                     CultureInfo.CurrentCulture,
@@ -318,15 +362,15 @@ private async Task InstallPackage(
                     projectContext.PackageExtractionContext.PackageSaveMode = EffectivePackageSaveMode;
                 }
 
-                using(var cacheContext = new SourceCacheContext())
+                using (var cacheContext = new SourceCacheContext())
                 {
                     cacheContext.NoCache = NoCache;
                     cacheContext.DirectDownload = DirectDownload;
 
                     var downloadContext = new PackageDownloadContext(cacheContext, installPath, DirectDownload);
 
                     await packageManager.InstallPackageAsync(
-                        folderProject,
+                        project,
                         packageIdentity,
                         resolutionContext,
                         projectContext,
@@ -342,5 +386,30 @@ await packageManager.InstallPackageAsync(
                 }
             }
         }
+
+        /// <summary>
+        /// Parse the Framework parameter or use Any as the default framework.
+        /// </summary>
+        private NuGetFramework GetTargetFramework()
+        {
+            var targetFramework = NuGetFramework.AnyFramework;
+
+            if (!string.IsNullOrEmpty(Framework))
+            {
+                targetFramework = NuGetFramework.Parse(Framework);
+            }
+
+            if (targetFramework.IsUnsupported)
+            {
+                // Fail with a helpful message if the user provided an invalid framework.
+                var message = string.Format(CultureInfo.CurrentCulture,
+                    LocalizedResourceManager.GetString("UnsupportedFramework"),
+                    Framework);
+
+                throw new ArgumentException(message);
+            }
+
+            return targetFramework;
+        }
     }
 }

src/NuGet.Clients/NuGet.CommandLine/Commands/RestoreCommand.cs

@@ -333,7 +333,7 @@ private async Task<RestoreSummary> PerformNuGetV2RestoreAsync(PackageRestoreInpu
                     Settings.Priority.Select(x => Path.Combine(x.Root, x.FileName)),
                     packageSources.Select(x => x.Source),
                     installCount,
-                    collectorLogger.Errors.Concat(failedEvents.Select(e => new RestoreLogMessage(LogLevel.Error, e.Exception.Message))));
+                    collectorLogger.Errors.Concat(failedEvents.Select(e => new RestoreLogMessage(LogLevel.Error, NuGetLogCode.Undefined, e.Exception.Message))));
             }
         }