Enable install specific version

Closes #3

README.md

@@ -39,17 +39,18 @@ Simply run `dotnet commands` to see the options, which are similar to this:
 
 ````
 .NET Commands
+
   Usage:
-    dotnet commands install <command> [--force] [--pre] [--verbose]
+    dotnet commands install <command>[@<version>] [--force] [--pre] [--verbose]
     dotnet commands uninstall <command> [ --verbose]
     dotnet commands update (<command> | all) [--pre] [--verbose]
-    dotnet commands list [--verbose]
-    dotnet commands ls [--verbose]
+    dotnet commands (list|ls) [--verbose]
     dotnet commands --help
     dotnet commands --version
+
   Options:
     --force                    Installs even if package was already installed. Optional.
-    --pre                      Include pre-release versions. Optional.
+    --pre                      Include pre-release versions. Ignored if version is supplied. Optional.
     --verbose                  Verbose. Optional.
     --help -h                  Show this screen.
     --version -v               Show version.

src/dotnet-commands/CommandDirectory.cs

@@ -1,3 +1,4 @@
+using NuGet.Versioning;
 using System.IO;
 
 namespace DotNetCommands
@@ -23,10 +24,10 @@ public CommandDirectory(string baseDir)
                 Directory.CreateDirectory(binDir);
         }
 
-        public string GetDirectoryForPackage(string packageName, string packageVersion = null) =>
+        public string GetDirectoryForPackage(string packageName, SemanticVersion packageVersion = null) =>
             packageVersion == null
             ? Path.Combine(PackagesDir, packageName)
-            : Path.Combine(PackagesDir, packageName, packageVersion);
+            : Path.Combine(PackagesDir, packageName, packageVersion.ToString());
 
         public string GetBinFile(string fileName) =>
             Path.Combine(binDir, fileName.Replace('/', Path.DirectorySeparatorChar));

src/dotnet-commands/Installer.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.InteropServices;
+using NuGet.Versioning;
 
 namespace DotNetCommands
 {
@@ -17,15 +18,15 @@ public Installer(CommandDirectory commandDirectory)
             this.commandDirectory = commandDirectory;
         }
 
-        public async Task<bool> InstallAsync(string packageName, bool force, bool includePreRelease)
+        public async Task<bool> InstallAsync(string packageName, SemanticVersion packageVersion, bool force, bool includePreRelease)
         {
             WriteLineIfVerbose($"Installing {packageName}...");
             PackageInfo packageInfo;
             try
             {
                 using (var downloader = new NugetDownloader(commandDirectory))
                 {
-                    packageInfo = await downloader.DownloadAndExtractNugetAsync(packageName, force, includePreRelease);
+                    packageInfo = await downloader.DownloadAndExtractNugetAsync(packageName, packageVersion, force, includePreRelease);
                     if (packageInfo == null) return false;
                 }
             }

src/dotnet-commands/NugetDownloader.cs

@@ -16,7 +16,7 @@ namespace DotNetCommands
     public sealed class NugetDownloader : IDisposable
     {
         private readonly CommandDirectory commandDirectory;
-        private IList<SourceInfo> sourceInfos;
+        private readonly IList<SourceInfo> sourceInfos;
 
         public NugetDownloader(CommandDirectory commandDirectory)
         {
@@ -59,6 +59,39 @@ public async Task<string> GetLatestVersionAsync(string packageName, bool include
             return (await GetLatestVersionAndSourceInfoAsync(packageName, includePreRelease))?.Version.ToString();
         }
 
+        private async Task<NugetVersion> GetSpecificVersionAndSourceInfoAsync(string packageName, SemanticVersion packageVersion)
+        {
+            foreach (var sourceInfo in sourceInfos)
+            {
+                WriteLineIfVerbose($"Searching for '{packageName}@{packageVersion.ToString()}' on '{sourceInfo.Source.Name}'...");
+                NugetVersion latestNugetVersion;
+                try
+                {
+                    latestNugetVersion = await sourceInfo.GetPackageAsync(packageName, packageVersion, true);
+                }
+                catch (Exception ex)
+                {
+                    WriteLine($"Error when getting '{packageName}@{packageVersion.ToString()}'. Source used: '{sourceInfo.Source.Name}'.");
+                    WriteLineIfVerbose($"Error details: {ex.ToString()}'.");
+                    return null;
+                }
+                if (latestNugetVersion == null)
+                {
+                    WriteLineIfVerbose($"Could not get a version for '{packageName}@{packageVersion.ToString()}' on '{sourceInfo.Source.Name}'.");
+                    continue;
+                }
+                else
+                {
+                    WriteLineIfVerbose($"Found version '{latestNugetVersion.Version}' for '{packageName}@{packageVersion.ToString()}' on '{sourceInfo.Source.Name}'.");
+                    return latestNugetVersion;
+                }
+            }
+            WriteLine($"Package '{packageName}' not found. Sources used:");
+            foreach (var source in sourceInfos.Select(p => p.Source))
+                WriteLine($" - {source.Name}: {source.Source}");
+            return null;
+        }
+
         private async Task<NugetVersion> GetLatestVersionAndSourceInfoAsync(string packageName, bool includePreRelease)
         {
             NugetVersion currentNugetVersion = null;
@@ -68,7 +101,7 @@ private async Task<NugetVersion> GetLatestVersionAndSourceInfoAsync(string packa
                 NugetVersion latestNugetVersion;
                 try
                 {
-                    latestNugetVersion = await sourceInfo.GetLatestVersionAsync(packageName, includePreRelease);
+                    latestNugetVersion = await sourceInfo.GetPackageAsync(packageName, null, includePreRelease);
                 }
                 catch (Exception ex)
                 {
@@ -103,17 +136,20 @@ private async Task<NugetVersion> GetLatestVersionAndSourceInfoAsync(string packa
         /// Downloads the specified nupkg and extracts it to a directory
         /// </summary>
         /// <param name="packageName">The command to download, i.e. "dotnet-foo".</param>
+        /// <param name="packageVersion">The version to install. If null, then latest will be used.</param>
         /// <param name="force">Force the download be made again if it was already downloaded earlier.</param>
         /// <param name="includePreRelease">Allow pre-release versions.</param>
         /// <returns>The directory where it is extracted</returns>
-        public async Task<PackageInfo> DownloadAndExtractNugetAsync(string packageName, bool force, bool includePreRelease)
+        public async Task<PackageInfo> DownloadAndExtractNugetAsync(string packageName, SemanticVersion packageVersion, bool force, bool includePreRelease)
         {
             if (!sourceInfos.Any())
             {
                 WriteLine("No NuGet sources found.");
                 return null;
             }
-            var nugetVersion = await GetLatestVersionAndSourceInfoAsync(packageName, includePreRelease);
+            var nugetVersion = packageVersion == null
+                ? await GetLatestVersionAndSourceInfoAsync(packageName, includePreRelease)
+                : await GetSpecificVersionAndSourceInfoAsync(packageName, packageVersion);
             if (nugetVersion == null)
             {
                 WriteLineIfVerbose($"Could not get latest version for package '{packageName}'.");
@@ -134,7 +170,7 @@ public async Task<PackageInfo> DownloadAndExtractNugetAsync(string packageName,
             WriteLineIfVerbose($"Saving to '{tempFilePath}'.");
             using (var tempFileStream = File.OpenWrite(tempFilePath))
                 await nupkgResponse.Content.CopyToAsync(tempFileStream);
-            var destinationDir = commandDirectory.GetDirectoryForPackage(nugetVersion.PackageName, nugetVersion.Version.ToString());
+            var destinationDir = commandDirectory.GetDirectoryForPackage(nugetVersion.PackageName, nugetVersion.Version);
             if (force)
                 Directory.Delete(destinationDir, true);
             var shouldExtract = force || !Directory.Exists(destinationDir);
@@ -185,6 +221,14 @@ private class ServiceData
             public string Id { get; set; }
             [JsonProperty("version")]
             public string Version { get; set; }
+            [JsonProperty("versions")]
+            public IList<ServiceDataVersion> Versions { get; set; }
+        }
+
+        private class ServiceDataVersion
+        {
+            [JsonProperty("version")]
+            public string Version { get; set; }
         }
 
         private class SourceInfo : IDisposable
@@ -213,7 +257,7 @@ public async Task<Feed> GetFeedAsync()
                 return feed;
             }
 
-            public async Task<NugetVersion> GetLatestVersionAsync(string packageName, bool includePreRelease)
+            public async Task<NugetVersion> GetPackageAsync(string packageName, SemanticVersion packageVersion, bool includePreRelease)
             {
                 var currentFeed = await GetFeedAsync();
                 if (currentFeed == null)
@@ -254,14 +298,27 @@ public async Task<NugetVersion> GetLatestVersionAsync(string packageName, bool i
                 var serviceData = supportsQueryById
                     ? service.Data.FirstOrDefault()
                     : service.Data.FirstOrDefault(sd => string.Compare(sd.Id, packageName, true) == 0);
-                var version = serviceData?.Version;
-                if (version == null)
+                var latest = serviceData?.Version;
+                if (latest == null)
                 {
-                    WriteLineIfVerbose($"There was no version info for '{packageName}' on '{Source.Name}'.");
+                    WriteLineIfVerbose($"There was no package info for '{packageName}' on '{Source.Name}'.");
                     return null;
                 }
-                WriteLineIfVerbose($"Found version {version}.");
-                var currentSemanticVersion = SemanticVersion.Parse(version);
+                WriteLineIfVerbose($"Found package '{packageName}' with latest version {latest}.");
+                var currentSemanticVersion = SemanticVersion.Parse(latest);
+                if (packageVersion != null)
+                {
+                    var versionExists = serviceData.Versions.Any(v => v.Version == packageVersion.ToString());
+                    if (versionExists)
+                    {
+                        currentSemanticVersion = packageVersion;
+                    }
+                    else
+                    {
+                        WriteLineIfVerbose($"Version '{packageVersion.ToString()}' was not found for '{packageName}' on '{Source.Name}'.");
+                        return null;
+                    }
+                }
                 var nugetVersion = new NugetVersion(currentSemanticVersion, this, serviceData.Id);
                 return nugetVersion;
             }

src/dotnet-commands/Program.cs

@@ -18,7 +18,7 @@ private async static Task<int> RunAsync(string[] args)
             const string usage = @".NET Commands
 
   Usage:
-    dotnet commands install <command> [--force] [--pre] [--verbose]
+    dotnet commands install <command>[@<version>] [--force] [--pre] [--verbose]
     dotnet commands uninstall <command> [ --verbose]
     dotnet commands update (<command> | all) [--pre] [--verbose]
     dotnet commands (list|ls) [--verbose]
@@ -27,7 +27,7 @@ dotnet commands --version
 
   Options:
     --force                    Installs even if package was already installed. Optional.
-    --pre                      Include pre-release versions. Optional.
+    --pre                      Include pre-release versions. Ignored if version is supplied. Optional.
     --verbose                  Verbose. Optional.
     --help -h                  Show this screen.
     --version -v               Show version.
@@ -38,7 +38,7 @@ dotnet commands --version
             if (args.Length == 1 && args[0] == "bootstrap")
             {
                 var installer = new Installer(commandDirectory);
-                var success = await installer.InstallAsync("dotnet-commands", force: true, includePreRelease: true);
+                var success = await installer.InstallAsync("dotnet-commands", null, force: true, includePreRelease: true);
                 return (int)(success ? ExitCodes.Success : ExitCodes.BootstrapFailed);
             }
             var argsWithRun = args;
@@ -59,16 +59,37 @@ dotnet commands --version
             {
                 WriteLineIfVerbose("Request to update .NET Commands.");
                 var updater = new Updater(commandDirectory);
-                var updateNeeded = await updater.IsUpdateNeeded(command, arguments["--pre"].IsTrue);
+                var updateNeeded = await updater.IsUpdateNeededAsync(command, arguments["--pre"].IsTrue);
                 var exitCode = updateNeeded == Updater.UpdateNeeded.Yes ? ExitCodes.StartUpdate : ExitCodes.Success;
                 WriteLineIfVerbose($"Should update .NET Commands: {updateNeeded}, exit code is going to be {exitCode} ({(int)exitCode}).");
                 return (int)exitCode;
             }
             if (arguments["install"].IsTrue)
             {
-
+                var commandParts = command.Split('@');
+                NuGet.Versioning.SemanticVersion packageVersion = null;
+                switch (commandParts.Length)
+                {
+                    case 1:
+                        break;
+                    case 2:
+                        command = commandParts[0];
+                        try
+                        {
+                            packageVersion = NuGet.Versioning.SemanticVersion.Parse(commandParts[0]);
+                        }
+                        catch (ArgumentException)
+                        {
+                            Console.WriteLine($"Invalid version.\n{usage}");
+                            return (int)ExitCodes.InvalidVersion;
+                        }
+                        break;
+                    default:
+                        Console.WriteLine($"Invalid version.\n{usage}");
+                        return (int)ExitCodes.InvalidVersion;
+                }
                 var installer = new Installer(commandDirectory);
-                var success = await installer.InstallAsync(command, arguments["--force"].IsTrue, arguments["--pre"].IsTrue);
+                var success = await installer.InstallAsync(command, packageVersion, arguments["--force"].IsTrue, arguments["--pre"].IsTrue);
                 return (int)(success ? ExitCodes.Success : ExitCodes.InstallFailed);
             }
             if (arguments["uninstall"].IsTrue)
@@ -119,6 +140,7 @@ enum ExitCodes : byte // 0 and from 64-113 according to http://tldp.org/LDP/abs/
             InstallFailed = 69,
             UninstallFailed = 70,
             CantUninstallDotNetCommands = 71,
+            InvalidVersion = 72,
             StartUpdate = 113
         }
     }

src/dotnet-commands/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "dotnet-commands": {
       "commandName": "Project",
-      "commandLineArgs": "install dotnet-foo"
+      "commandLineArgs": "install dotnet-foo@1.0.1"
     }
   }
 }

src/dotnet-commands/Updater.cs

@@ -18,18 +18,18 @@ public Updater(CommandDirectory commandDirectory)
 
         public async Task<UpdateResult> UpdateAsync(string packageName, bool force, bool includePreRelease)
         {
-            var updateNeeded = await IsUpdateNeeded(packageName, includePreRelease);
+            var updateNeeded = await IsUpdateNeededAsync(packageName, includePreRelease);
             if (updateNeeded == UpdateNeeded.No) return UpdateResult.NotNeeded;
             if (updateNeeded == UpdateNeeded.PackageNotFound) return UpdateResult.PackageNotFound;
             var uninstaller = new Uninstaller(commandDirectory);
             var uninstalled = await uninstaller.UninstallAsync(packageName);
             if (!uninstalled) return UpdateResult.CouldntUninstall;
             var installer = new Installer(commandDirectory);
-            var installed = await installer.InstallAsync(packageName, force, includePreRelease);
+            var installed = await installer.InstallAsync(packageName, null, force, includePreRelease);
             return installed ? UpdateResult.Success : UpdateResult.UninstalledAndNotReinstalled;
         }
 
-        public async Task<UpdateNeeded> IsUpdateNeeded(string packageName, bool includePreRelease)
+        public async Task<UpdateNeeded> IsUpdateNeededAsync(string packageName, bool includePreRelease)
         {
             SemanticVersion largestAvailableVersion;
             try

src/dotnet-commands/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.4.2",
+    "version": "0.5.0",
     "description": "A .NET CLI Commands library.",
     "dependencies": {
         "Microsoft.NETCore.App": {

src/dotnet-foo/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "1.0.1-*",
+    "version": "1.0.2-*",
     "description": "A sample package only to validate that the tools installer works.",
     "dependencies": {
         "Microsoft.NETCore": "5.0.2"

test/IntegrationTests/CommandDirectoryTests.cs

@@ -1,5 +1,6 @@
 using DotNetCommands;
 using FluentAssertions;
+using NuGet.Versioning;
 using NUnit.Framework;
 using System.IO;
 
@@ -28,7 +29,7 @@ public void ClassInitialize()
         public void GetBinFile() => commandDirectory.GetBinFile("foo.cmd").Should().Be(Path.Combine(baseDir, "bin", "foo.cmd"));
 
         [Test]
-        public void GetDirectoryForPackage() => commandDirectory.GetDirectoryForPackage("foo", "1.2.3").Should().Be(Path.Combine(baseDir, "packages", "foo", "1.2.3"));
+        public void GetDirectoryForPackage() => commandDirectory.GetDirectoryForPackage("foo", SemanticVersion.Parse("1.2.3")).Should().Be(Path.Combine(baseDir, "packages", "foo", "1.2.3"));
 
         [Test]
         public void MakeRelativeToBaseDir() => commandDirectory.MakeRelativeToBaseDir(Path.Combine(baseDir, "foo", "bar")).Should().Be(Path.Combine("..", "foo", "bar"));

test/IntegrationTests/DownloadNugetTest.cs

@@ -30,7 +30,7 @@ public void ClassCleanup()
         [Test, Retry]
         public async Task DownloadDotNetFooAsync()
         {
-            var packageInfo = await downloader.DownloadAndExtractNugetAsync("dotnet-foo", force: false, includePreRelease: false);
+            var packageInfo = await downloader.DownloadAndExtractNugetAsync("dotnet-foo", null, force: false, includePreRelease: false);
             Directory.Exists(packageInfo.PackageDir).Should().BeTrue();
             var cmd = Directory.EnumerateFiles(packageInfo.PackageDir, "dotnet-foo.cmd", SearchOption.AllDirectories).FirstOrDefault();
             cmd.Should().NotBeNull();

test/IntegrationTests/DownloadNugetTestWithoutPackageSources.cs

@@ -46,7 +46,7 @@ public void ClassCleanup()
         [Test, Retry]
         public async Task DownloadDotNetFooWithoutPackageSourcesAsync()
         {
-            var packageInfo = await downloader.DownloadAndExtractNugetAsync("dotnet-foo", force: false, includePreRelease: false);
+            var packageInfo = await downloader.DownloadAndExtractNugetAsync("dotnet-foo", null, force: false, includePreRelease: false);
             Directory.Exists(packageInfo.PackageDir).Should().BeTrue();
             var cmd = Directory.EnumerateFiles(packageInfo.PackageDir, "dotnet-foo.cmd", SearchOption.AllDirectories).FirstOrDefault();
             cmd.Should().NotBeNull();

test/IntegrationTests/GlobalSuppressions.cs

@@ -0,0 +1 @@
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "CC0061:Async method can be terminating with 'Async' name.", Justification = "Tests don't need to end in Async.")]

test/IntegrationTests/InstallerTestForDotNetTool.cs

@@ -26,7 +26,7 @@ public async Task SetupAsync()
             commandDirectoryCleanup = new CommandDirectoryCleanup();
             baseDir = commandDirectoryCleanup.CommandDirectory.BaseDir;
             installer = new Installer(commandDirectoryCleanup.CommandDirectory);
-            installed = await installer.InstallAsync(packageName, force: false, includePreRelease: true);
+            installed = await installer.InstallAsync(packageName, null, force: false, includePreRelease: true);
             installed.Should().BeTrue();
         }