Added KillCommand

VisualStudio.Tests/CommandFactoryTests.cs

@@ -35,11 +35,15 @@ public void when_creating_command_with_help_argument_then_throws_show_usage()
         [InlineData("where", typeof(WhereCommand))]
         [InlineData("modify", typeof(ModifyCommand))]
         [InlineData("update", typeof(UpdateCommand))]
-
+        [InlineData("config", typeof(ConfigCommand))]
+        [InlineData("log", typeof(LogCommand))]
+        [InlineData("kill", typeof(KillCommand))]
         public void when_creating_builtin_command_then_then_command_is_created(string commandName, Type expectedCommandType)
         {
             var commandFactory = new CommandFactory();
 
+            Assert.True(commandFactory.IsCommandRegistered(commandName));
+
             var command = commandFactory.CreateCommand(commandName, Enumerable.Empty<string>());
 
             Assert.NotNull(command);

VisualStudio/AllOption.cs

@@ -0,0 +1,23 @@
+using System;
+using Mono.Options;
+
+namespace VisualStudio
+{
+    public class AllOption : OptionSet
+    {
+        public AllOption(string verb)
+        {
+            Add("all", $"{verb} all instances.", e => All = e != null);
+        }
+
+        protected override bool Parse(string argument, OptionContext c)
+        {
+            if ("all".Equals(argument, StringComparison.OrdinalIgnoreCase))
+                argument = "--all";
+
+            return base.Parse(argument, c);
+        }
+
+        public bool All { get; private set; }
+    }
+}

VisualStudio/Chooser.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.IO;
+using vswhere;
+using System.Diagnostics;
+
+namespace VisualStudio
+{
+    class Chooser
+    {
+        readonly string title;
+
+        public Chooser(string verb = "run") => title = $"Multiple instances found. Select the one to {verb}:";
+
+        public T Choose<T>(IEnumerable<T> instances, TextWriter output)
+        {
+            var instancesAsList = instances.ToList();
+
+            if (instancesAsList.Count > 1)
+            {
+                output.WriteLine(title);
+                for (int i = 0; i < instancesAsList.Count; i++)
+                    output.WriteLine($"{i + 1}: {GetItemDescription(instancesAsList[i])}");
+
+                if (int.TryParse(Console.ReadLine(), out var index) && index > 0 && index <= instancesAsList.Count)
+                    return instancesAsList[index - 1];
+
+                return default;
+            }
+
+            return instances.FirstOrDefault();
+        }
+
+        string GetItemDescription(object value)
+        {
+            if (value is VisualStudioInstance visualStudioInstance)
+                return $"{ visualStudioInstance.DisplayName} - Version { visualStudioInstance.Catalog.ProductDisplayVersion}";
+            else if (value is Process process)
+                return $"{process.MainWindowTitle} ({process.Id})";
+
+            return value.ToString();
+        }
+    }
+}

VisualStudio/CommandFactory.cs

@@ -21,6 +21,7 @@ public CommandFactory()
             RegisterCommand<ModifyCommandDescriptor>("modify", x => new ModifyCommand(x, whereService, installerService));
             RegisterCommand<ConfigCommandDescriptor>("config", x => new ConfigCommand(x, whereService));
             RegisterCommand<LogCommandDescriptor>("log", x => new LogCommand(x, whereService));
+            RegisterCommand<KillCommandDescriptor>("kill", x => new KillCommand(x, whereService));
         }
 
         public IEnumerable<string> RegisteredCommands => factories.Keys;

VisualStudio/ConfigCommand.cs

@@ -17,7 +17,7 @@ public ConfigCommand(ConfigCommandDescriptor descriptor, WhereService whereServi
         public override async Task ExecuteAsync(TextWriter output)
         {
             var instances = await whereService.GetAllInstancesAsync(Descriptor.Sku, Descriptor.Channel);
-            var instance = new VisualStudioInstanceChooser().Choose(instances, output);
+            var instance = new Chooser().Choose(instances, output);
 
             if (instance != null)
             {

VisualStudio/KillCommand.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Linq;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+using vswhere;
+
+namespace VisualStudio
+{
+    class KillCommand : Command<KillCommandDescriptor>
+    {
+        readonly WhereService whereService;
+
+        public KillCommand(KillCommandDescriptor descriptor, WhereService whereService) : base(descriptor) =>
+            this.whereService = whereService;
+
+        public override async Task ExecuteAsync(TextWriter output)
+        {
+            var devenvProcesses = Process.GetProcessesByName("devenv").ToList();
+            var targetProcesses =
+                (from instance in await whereService.GetAllInstancesAsync(Descriptor.Sku, Descriptor.Channel)
+                 from devenvProcess in devenvProcesses
+                 where Match(devenvProcess, instance)
+                 select devenvProcess).Distinct().ToList();
+
+            if (!Descriptor.KillAll)
+            {
+                var process = new Chooser("kill").Choose(targetProcesses, output);
+
+                targetProcesses.Clear();
+                if (process != null)
+                    targetProcesses.Add(process);
+            }
+
+            foreach (var process in targetProcesses)
+            {
+                output.WriteLine($"Killing {process.MainWindowTitle} ({process.Id})...");
+                process.Kill();
+            }
+        }
+
+        bool Match(Process devenvProcess, VisualStudioInstance instance) =>
+            devenvProcess.MainModule.FileName.StartsWith(instance.InstallationPath, StringComparison.OrdinalIgnoreCase) &&
+            (!Descriptor.IsExperimental || devenvProcess.GetCommandLine().Contains("/rootSuffix Exp", StringComparison.OrdinalIgnoreCase));
+    }
+}

VisualStudio/KillCommandDescriptor.cs

@@ -0,0 +1,21 @@
+using System;
+using Mono.Options;
+
+namespace VisualStudio
+{
+    class KillCommandDescriptor : CommandDescriptor
+    {
+        readonly VisualStudioOptions options = new VisualStudioOptions(channelVerb: "Kill", showNickname: false, showExp: true);
+        readonly AllOption allOption = new AllOption("Kill");
+
+        public KillCommandDescriptor() => OptionSet = new CompositeOptionSet(options, allOption);
+
+        public Channel? Channel => options.Channel;
+
+        public Sku? Sku => options.Sku;
+
+        public bool IsExperimental => options.IsExperimental;
+
+        public bool KillAll => allOption.All;
+    }
+}

VisualStudio/LogCommand.cs

@@ -17,12 +17,12 @@ public LogCommand(LogCommandDescriptor descriptor, WhereService whereService) :
         public override async Task ExecuteAsync(TextWriter output)
         {
             var instances = await whereService.GetAllInstancesAsync(Descriptor.Sku, Descriptor.Channel);
-            var instance = new VisualStudioInstanceChooser().Choose(instances, output);
+            var instance = new Chooser().Choose(instances, output);
 
             if (instance != null)
             {
                 var instanceDir = instance.InstallationVersion.Major + ".0_" + instance.InstanceId;
-                if (Descriptor.Experimental)
+                if (Descriptor.IsExperimental)
                     instanceDir += "Exp";
 
                 var path = Path.Combine(

VisualStudio/LogCommandDescriptor.cs

@@ -5,18 +5,14 @@ namespace VisualStudio
 {
     class LogCommandDescriptor : CommandDescriptor
     {
-        readonly VisualStudioOptions options = new VisualStudioOptions(channelVerb: "Open", showNickname: false);
-        bool exp;
+        readonly VisualStudioOptions options = new VisualStudioOptions(channelVerb: "Open", showNickname: false, showExp: true);
 
-        public LogCommandDescriptor() => OptionSet = new CompositeOptionSet(options, new OptionSet
-            {
-                { "exp", "Use experimental instance instead of regular.", e => exp = e != null },
-            });
+        public LogCommandDescriptor() => OptionSet = new CompositeOptionSet(options);
 
         public Channel? Channel => options.Channel;
 
         public Sku? Sku => options.Sku;
 
-        public bool Experimental => exp;
+        public bool IsExperimental => options.IsExperimental;
     }
 }

VisualStudio/ModifyCommand.cs

@@ -22,7 +22,7 @@ public override async Task ExecuteAsync(TextWriter output)
         {
             var instances = await whereService.GetAllInstancesAsync(Descriptor.Sku, Descriptor.Channel);
 
-            var instance = new VisualStudioInstanceChooser().Choose(instances, output);
+            var instance = new Chooser().Choose(instances, output);
 
             if (instance != null)
             {

VisualStudio/ProcessExtensions.cs

@@ -1,5 +1,8 @@
-using System.Diagnostics;
+using System;
+using System.Linq;
+using System.Diagnostics;
 using System.IO;
+using System.Management;
 
 namespace VisualStudio
 {
@@ -19,5 +22,19 @@ public static void Log(this ProcessStartInfo info, TextWriter output)
         }
 
         static string Quote(string value) => value.Contains(' ') ? "\"" + value + "\"" : value;
+
+        public static string GetCommandLine(this Process process)
+        {
+            try
+            {
+                using (var searcher = new ManagementObjectSearcher("SELECT CommandLine FROM Win32_Process WHERE ProcessId = " + process.Id))
+                using (var objects = searcher.Get())
+                    return objects.OfType<ManagementBaseObject>().FirstOrDefault()?["CommandLine"]?.ToString();
+            }
+            catch
+            {
+                return string.Empty;
+            }
+        }
     }
 }

VisualStudio/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "VisualStudio": {
       "commandName": "Project",
-      "commandLineArgs": "config -pre -exp"
+      "commandLineArgs": "kill all exp"
     }
   }
-}
+}

VisualStudio/UpdateCommand.cs

@@ -21,7 +21,7 @@ public override async Task ExecuteAsync(TextWriter output)
         {
             var instances = await whereService.GetAllInstancesAsync(Descriptor.Sku, Descriptor.Channel);
 
-            var instance = new VisualStudioInstanceChooser().Choose(instances, output);
+            var instance = new Chooser().Choose(instances, output);
 
             if (instance != null)
             {

VisualStudio/VisualStudio.csproj

@@ -21,6 +21,7 @@
     <PackageReference Include="vswhere" Version="2.8.4" PrivateAssets="all"  />
     <PackageReference Include="Mono.Options" Version="6.6.0.161" />
     <PackageReference Include="MSBuilder.ThisAssembly.Metadata" Version="0.1.4" PrivateAssets="all" />
+    <PackageReference Include="System.Management" Version="5.0.0-preview.3.20214.6" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

VisualStudio/VisualStudioOptions.cs

@@ -12,8 +12,14 @@ public class VisualStudioOptions : OptionSet
     {
         string[] channelShortcuts = new[] { "pre", "preview", "int", "internal", "master" };
         string[] skuShortcuts = new[] { "e", "ent", "enterprise", "p", "pro", "professional", "c", "com", "community" };
+        string[] experimentalShortcuts = new[] { "exp", "experimental" };
 
-        public VisualStudioOptions(string channelVerb = "Install", bool showChannel = true, bool showSku = true, bool showNickname = true)
+        public VisualStudioOptions(
+            string channelVerb = "Install",
+            bool showChannel = true,
+            bool showSku = true,
+            bool showNickname = true,
+            bool showExp = false)
         {
             if (showChannel)
             {
@@ -34,6 +40,11 @@ public VisualStudioOptions(string channelVerb = "Install", bool showChannel = tr
                 // Nickname
                 Add("nick|nickname:", "Optional nickname to use", n => Nickname = n);
             }
+
+            if (showExp)
+            {
+                Add("exp|experimental", $"{channelVerb} experimental instance instead of regular.", e => IsExperimental = e != null);
+            }
         }
 
         Sku ParseSku(string sku)
@@ -56,6 +67,9 @@ protected override bool Parse(string argument, OptionContext c)
             if (skuShortcuts.Contains(argument.ToLowerInvariant()))
                 argument = "--sku=" + argument;
 
+            if (experimentalShortcuts.Contains(argument.ToLowerInvariant()))
+                argument = "--" + argument;
+
             return base.Parse(argument, c);
         }
 
@@ -64,5 +78,7 @@ protected override bool Parse(string argument, OptionContext c)
         public Sku? Sku { get; private set; }
 
         public string Nickname { get; private set; }
+
+        public bool IsExperimental { get; private set; }
     }
 }