public static Task <VsInstance> Launch(VsHive hive, TimeSpan timeout, IDiagnostics diagnostics)
{
Process process = null;
KillProcessJob killProcessJob = null;
return(diagnostics.RunAsync("Launching Instance", async output =>
{
try
{
process = VisualStudioUtil.StartProcess(hive);
killProcessJob = new KillProcessJob(process);
var dte = await VisualStudioUtil.GetDTE(process, timeout);
var invoker = (IRemoteComInvoker)dte.GetObject("VsixTesting.Invoker");
InvokeRemote(invoker, nameof(Remote.AutoKillWhenProcessExits), Process.GetCurrentProcess().Id);
killProcessJob.Release();
return new VsInstance(hive.Version, process, dte, invoker);
}
catch
{
process?.Kill();
process?.Dispose();
throw;
}
}));
}
public static async Task Prepare(VsHive hive, IEnumerable <string> extensionsToInstall, bool resetSettings, IDiagnostics diagnostics)
{
await diagnostics.RunAsync("Preparing Instance", async output =>
{
var installResult = default((int InstallCount, bool HasSettingsFile, string Output));
var invokerAssembly = Assembly.GetExecutingAssembly();
using (var invoker = new TempFile(EmbeddedResourceUtil.ExtractResource(invokerAssembly, "VsixTesting.Invoker.vsix")))
{
EmbeddedResourceUtil.ApplyDateTime(invoker.Path, invokerAssembly, "VsixTesting.Invoker.vsix");
installResult = await VisualStudioUtil.InstallExtensionsAsync(
hive,
extensionsToInstall.Concat(new[] { invoker.Path }));
output.WriteLine(installResult.Output);
if (installResult.InstallCount > 0)
{
output.WriteLine("Clearing cache");
await VisualStudioUtil.ClearCacheAsync(hive);
output.WriteLine("Updating configuration");
await VisualStudioUtil.UpdateConfigurationAsync(hive);
}
}
if (!installResult.HasSettingsFile || resetSettings)
{
output.WriteLine("Resetting settings");
await VisualStudioUtil.ResetSettingsAsync(hive);
}
});
}
public static Task AttachDebugger(Process process, bool debugMixedMode, IDiagnostics diagnostics)
{
return(diagnostics.RunAsync("Attaching Debugger", output =>
{
var dte = VisualStudioUtil.GetDteFromDebuggedProcess(Process.GetCurrentProcess());
if (dte != null)
{
VisualStudioUtil.AttachDebugger(dte, process, debugMixedMode ? "Managed/Native" : "Managed");
}
}));
}
private static void GetInstalledVisualStudios(VisualStudioVersion vsVersion, Dictionary <VisualStudioVersion, VisualStudioPath[]> versions)
{
var requiredWorkloads = new[] { "Microsoft.VisualStudio.Workload.ManagedGame" };
var raw = VisualStudioUtil.FindVisualStudioDevEnvPaths((int)vsVersion, requiredWorkloads);
var visualStudioPaths = VisualStudioUtil.ParseRawDevEnvPaths(raw)
.Where(vs => !requiredWorkloads.Except(vs.Workloads).Any()) // All required workloads must be present
.Select(vs => new VisualStudioPath(vs.DevEnvPath, vs.Edition))
.ToArray();
if (visualStudioPaths.Length != 0)
{
versions[vsVersion] = visualStudioPaths;
}
}
void FilterInstallations_PreferSpecificInstallation(string version, string expectedName)
{
var installationPath = "C:\\Program Files (x86)\\Microsoft Visual Studio 15.0";
var installations = new[]
{
new VsInstallation(new Version(14, 0, 0), string.Empty, "VisualStudio/14.0.0"),
new VsInstallation(new Version(15, 0, 3), string.Empty, "VisualStudio/15.0.3"),
new VsInstallation(new Version(15, 0, 2), installationPath, "VisualStudio/15.0.2"),
new VsInstallation(new Version(15, 0, 1), string.Empty, "VisualStudio/15.0.1"),
};
var applicationPath = VisualStudioUtil.GetApplicationPath(installationPath);
var installation = VsTestCaseFactory.FilterInstallations(installations, new VsTestSettings {
Version = version
}, preferedAppPath: applicationPath).First();
Assert.Equal(expectedName, installation.Name);
}
// Usage: <parentProcessId> <childProcessId> <engine>
// Common engines:
// - "{2E36F1D4-B23C-435D-AB41-18E608940038}" = .NET Core
// - "{449EC4CC-30D2-4032-9256-EE18EB41B62B}" = .NET Framework
static int Main(string[] args)
{
if (args.Length != 3)
{
return(1);
}
if (!int.TryParse(args[0], out var parentProcessId))
{
return(2);
}
if (!int.TryParse(args[1], out var childProcessId))
{
return(3);
}
var engine = args[2];
var parentProcess = Process.GetProcessById(parentProcessId);
if (parentProcess == null)
{
return(4);
}
var childProcess = Process.GetProcessById(childProcessId);
if (childProcess == null)
{
return(5);
}
try
{
VisualStudioUtil.AttachDebugger(parentProcess, childProcess, engine);
}
catch
{
return(6);
}
return(0);
}
public async Task LaunchAndDebug(IMessageBus messageBus, CancellationTokenSource cancellationTokenSource)
{
await ThreadUtil.RunOnStaThreadAsync(async() =>
{
using (var retryFilter = new RetryMessageFilter())
{
var diagnostics = new VisualDiagnostics(this, DiagnosticMessageSink, messageBus, cancellationTokenSource);
var extensionsToInstall = VsInstance.GetExtensionsToInstall(ExtensionDirectories);
var installation = VisualStudioUtil.FindInstallations().First(i => i.ApplicationPath == ApplicationPath);
var hive = new VsHive(installation, RootSuffix);
await VsInstance.Prepare(hive, extensionsToInstall, resetSettings: false, diagnostics, installInvoker: false);
var process = await diagnostics.RunAsync("Launching Instance", () => Task.FromResult(VisualStudioUtil.StartProcess(hive)));
if (Debugger.IsAttached)
{
await VsInstance.AttachDebugger(process, DebugMixedMode, diagnostics);
}
}
});
}
private static int StartProcess(string filename)
{
var executablePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filename);
File.Copy(Process.GetCurrentProcess().MainModule.FileName, executablePath, true);
using (var retryFilter = new RetryMessageFilter())
{
var dte = VisualStudioUtil.GetDteFromDebuggedProcess(Process.GetCurrentProcess());
var process = Process.Start(new ProcessStartInfo
{
FileName = executablePath,
Arguments = Environment.CommandLine,
UseShellExecute = false,
});
if (dte != null)
{
VisualStudioUtil.AttachDebugger(dte, process);
}
process.WaitForExit();
FileUtil.TryDelete(executablePath);
return(process.ExitCode);
}
}
public static async Task Prepare(VsHive hive, IEnumerable <string> extensionsToInstall, bool resetSettings, IDiagnostics diagnostics, bool installInvoker = true)
{
await diagnostics.RunAsync("Preparing Instance", async output =>
{
var invokerAssembly = Assembly.GetExecutingAssembly();
var resourceName = $"VsixTesting.Invoker{(hive.Version.Major >= 17 ? ".17" : string.Empty)}.vsix";
using (var invoker = new TempFile(EmbeddedResourceUtil.ExtractResource(invokerAssembly, resourceName)))
{
EmbeddedResourceUtil.ApplyDateTime(invoker.Path, invokerAssembly, resourceName);
if (installInvoker)
{
extensionsToInstall = extensionsToInstall.Concat(new[] { invoker.Path });
}
var installResult = await VisualStudioUtil.InstallExtensionsAsync(hive, extensionsToInstall);
output.WriteLine(installResult.Output);
if (installResult.InstallCount > 0)
{
output.WriteLine("Clearing cache");
await VisualStudioUtil.ClearCacheAsync(hive);
output.WriteLine("Updating configuration");
await VisualStudioUtil.UpdateConfigurationAsync(hive);
}
}
if (resetSettings)
{
output.WriteLine("Resetting settings");
await VisualStudioUtil.ResetSettingsAsync(hive);
}
});
}
void FactRunningInsideVisualStudio() => Assert.NotNull(VisualStudioUtil.GetDTE(Process.GetCurrentProcess()));
void TheoryRunningInsideVisualStudio(int zero)
{
Assert.NotNull(VisualStudioUtil.GetDTE(Process.GetCurrentProcess()));
Assert.Equal(0, zero);
}
private static IDictionary <VisualStudioVersion, VisualStudioPath[]> GetInstalledVisualStudios()
{
Dictionary <VisualStudioVersion, VisualStudioPath[]> dictionary = new Dictionary <VisualStudioVersion, VisualStudioPath[]>();
if (SyncVS.SolutionSynchronizationSettings.IsWindows)
{
IEnumerator enumerator = Enum.GetValues(typeof(VisualStudioVersion)).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
VisualStudioVersion visualStudioVersion = (VisualStudioVersion)enumerator.Current;
if (visualStudioVersion <= VisualStudioVersion.VisualStudio2015)
{
try
{
string text = Environment.GetEnvironmentVariable(string.Format("VS{0}0COMNTOOLS", (int)visualStudioVersion));
if (!string.IsNullOrEmpty(text))
{
string path = Paths.Combine(new string[]
{
text,
"..",
"IDE",
"devenv.exe"
});
if (File.Exists(path))
{
dictionary[visualStudioVersion] = new VisualStudioPath[]
{
new VisualStudioPath(path, "")
};
continue;
}
}
text = SyncVS.GetRegistryValue(string.Format("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\{0}.0", (int)visualStudioVersion), "InstallDir");
if (string.IsNullOrEmpty(text))
{
text = SyncVS.GetRegistryValue(string.Format("HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\Microsoft\\VisualStudio\\{0}.0", (int)visualStudioVersion), "InstallDir");
}
if (!string.IsNullOrEmpty(text))
{
string path2 = Paths.Combine(new string[]
{
text,
"devenv.exe"
});
if (File.Exists(path2))
{
dictionary[visualStudioVersion] = new VisualStudioPath[]
{
new VisualStudioPath(path2, "")
};
continue;
}
}
text = SyncVS.GetRegistryValue(string.Format("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\{0}.0\\Debugger", (int)visualStudioVersion), "FEQARuntimeImplDll");
if (!string.IsNullOrEmpty(text))
{
string text2 = SyncVS.DeriveVisualStudioPath(text);
if (!string.IsNullOrEmpty(text2) && File.Exists(text2))
{
dictionary[visualStudioVersion] = new VisualStudioPath[]
{
new VisualStudioPath(SyncVS.DeriveVisualStudioPath(text), "")
};
}
}
}
catch
{
}
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
string[] array = VisualStudioUtil.FindVisualStudioDevEnvPaths(15, "Microsoft.VisualStudio.Workload.ManagedGame");
if (array != null && array.Length > 0)
{
VisualStudioPath[] array2 = new VisualStudioPath[array.Length / 2];
for (int i = 0; i < array.Length / 2; i++)
{
array2[i] = new VisualStudioPath(array[i * 2], array[i * 2 + 1]);
}
dictionary[VisualStudioVersion.VisualStudio2017] = array2;
}
}
return(dictionary);
}
private int Run(string applicationPath, string rootSuffix, string[] args)
{
try
{
if (!ExtensionManagerUtil.IsValidProcessFileName(applicationPath, out var expectedFileName))
{
return(StartProcess(expectedFileName));
}
var commands = new Dictionary <string, Func <int> >
{
{
"Install", () =>
{
var extensionPaths = CommandLineParser.Many(args, "Install");
return(Installer.Install(applicationPath, rootSuffix, extensionPaths, allUsers: false));
}
},
{
"InstallAndStart", () =>
{
var extensionPaths = CommandLineParser.Many(args, "InstallAndStart");
var result = Installer.Install(applicationPath, rootSuffix, extensionPaths, allUsers: false);
using (var retryFilter = new RetryMessageFilter())
{
var dte = VisualStudioUtil.GetDteFromDebuggedProcess(Process.GetCurrentProcess());
var process = Process.Start(applicationPath, $"/RootSuffix {rootSuffix}");
if (dte != null)
{
VisualStudioUtil.AttachDebugger(dte, process);
}
return(result);
}
}
},
{
"Uninstall", () =>
{
var extensionIds = CommandLineParser.Many(args, "Uninstall");
return(Installer.Uninstall(applicationPath, rootSuffix, extensionIds, skipGlobal: false));
}
},
{
"IsProfileInitialized", () =>
{
using (var externalSettingsManager = ExternalSettingsManager.CreateForApplication(applicationPath, rootSuffix))
{
var settings = externalSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
var isProfileInitialized = settings.CollectionExists("Profile") && settings.GetPropertyNames("Profile").Contains("LastResetSettingsFile");
return(Convert.ToInt32(isProfileInitialized));
}
}
},
};
foreach (var cmd in commands)
{
if (CommandLineParser.Contains(args, cmd.Key))
{
return(cmd.Value());
}
}
throw new Exception($@"Invalid command");
}
catch (Exception e)
{
Console.Error.Write(e.ToString());
return(-1);
}
}
/// <summary>
/// Detects Visual Studio installations using the Windows registry
/// </summary>
/// <returns>
/// The detected Visual Studio installations
/// </returns>
private static IDictionary <VisualStudioVersion, VisualStudioPath[]> GetInstalledVisualStudios()
{
var versions = new Dictionary <VisualStudioVersion, VisualStudioPath[]>();
if (SolutionSynchronizationSettings.IsWindows)
{
foreach (VisualStudioVersion version in Enum.GetValues(typeof(VisualStudioVersion)))
{
if (version > VisualStudioVersion.VisualStudio2015)
{
continue;
}
try
{
// Try COMNTOOLS environment variable first
string key = Environment.GetEnvironmentVariable(string.Format("VS{0}0COMNTOOLS", (int)version));
if (!string.IsNullOrEmpty(key))
{
string path = UnityEditor.Utils.Paths.Combine(key, "..", "IDE", "devenv.exe");
if (File.Exists(path))
{
versions[version] = new[] { new VisualStudioPath(path) };
continue;
}
}
// Try the proper registry key
key = GetRegistryValue(
string.Format(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\{0}.0", (int)version), "InstallDir");
// Try to fallback to the 32bits hive
if (string.IsNullOrEmpty(key))
{
key = GetRegistryValue(
string.Format(@"HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\VisualStudio\{0}.0", (int)version), "InstallDir");
}
if (!string.IsNullOrEmpty(key))
{
string path = UnityEditor.Utils.Paths.Combine(key, "devenv.exe");
if (File.Exists(path))
{
versions[version] = new[] { new VisualStudioPath(path) };
continue;
}
}
// Fallback to debugger key
key = GetRegistryValue(
// VS uses this key for the local debugger path
string.Format(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\{0}.0\Debugger", (int)version), "FEQARuntimeImplDll");
if (!string.IsNullOrEmpty(key))
{
string path = DeriveVisualStudioPath(key);
if (!string.IsNullOrEmpty(path) && File.Exists(path))
{
versions[version] = new[] { new VisualStudioPath(DeriveVisualStudioPath(key)) }
}
;
}
}
catch
{
// This can happen with a registry lookup failure
}
}
var requiredWorkloads = new[] { "Microsoft.VisualStudio.Workload.ManagedGame" };
var raw = VisualStudioUtil.FindVisualStudioDevEnvPaths((int)VisualStudioVersion.VisualStudio2017, requiredWorkloads);
var visualStudioPaths = VisualStudioUtil.ParseRawDevEnvPaths(raw)
.Where(vs => !requiredWorkloads.Except(vs.Workloads).Any()) // All required workloads must be present
.Select(vs => new VisualStudioPath(vs.DevEnvPath, vs.Edition))
.ToArray();
if (visualStudioPaths.Length != 0)
{
versions[VisualStudioVersion.VisualStudio2017] = visualStudioPaths;
}
}
return(versions);
}
void ThrowOnBadProcessNameWorks()
{
VisualStudioUtil.ThrowOnBadProcessName("DEVenv");
Assert.Throws <ArgumentException>(() => VisualStudioUtil.ThrowOnBadProcessName("devenv2"));
Assert.Throws <NotSupportedException>(() => VisualStudioUtil.ThrowOnBadProcessName("wdexpress"));
}
