/// <summary>
/// Runs the file with the provided settings as a user with
/// administrative permissions. The window is always hidden and output
/// is provided to the redirector when the process terminates.
/// </summary>
/// <param name="filename">Executable file to run.</param>
/// <param name="arguments">Arguments to pass.</param>
/// <param name="workingDirectory">Starting directory.</param>
/// <param name="redirector">
/// An object to receive redirected output.
/// </param>
/// <param name="quoteArgs"></param>
/// <returns>A <see cref="ProcessOutput"/> object.</returns>
public static ProcessOutput RunElevated(
string filename,
IEnumerable <string> arguments,
string workingDirectory,
Redirector redirector,
bool quoteArgs = true,
Encoding outputEncoding = null,
Encoding errorEncoding = null
)
{
var outFile = Path.GetTempFileName();
var errFile = Path.GetTempFileName();
var psi = new ProcessStartInfo("cmd.exe")
{
WindowStyle = ProcessWindowStyle.Hidden,
Verb = "runas",
CreateNoWindow = true,
UseShellExecute = true,
Arguments = string.Format(@"/S /C pushd {0} & ""{1} {2} >>{3} 2>>{4}""",
QuoteSingleArgument(workingDirectory),
QuoteSingleArgument(filename),
GetArguments(arguments, quoteArgs),
QuoteSingleArgument(outFile),
QuoteSingleArgument(errFile))
};
var process = new Process
{
StartInfo = psi
};
var result = new ProcessOutput(process, redirector);
if (redirector != null)
{
result.Exited += (s, e) =>
{
try
{
try
{
var lines = File.ReadAllLines(outFile, outputEncoding ?? Encoding.Default);
foreach (var line in lines)
{
redirector.WriteLine(line);
}
}
catch (Exception ex)
{
if (IsCriticalException(ex))
{
throw;
}
redirector.WriteErrorLine("Failed to obtain standard output from elevated process.");
#if DEBUG
foreach (var line in SplitLines(ex.ToString()))
{
redirector.WriteErrorLine(line);
}
#else
Trace.TraceError("Failed to obtain standard output from elevated process.");
Trace.TraceError(ex.ToString());
#endif
}
try
{
var lines = File.ReadAllLines(errFile, errorEncoding ?? outputEncoding ?? Encoding.Default);
foreach (var line in lines)
{
redirector.WriteErrorLine(line);
}
}
catch (Exception ex)
{
if (IsCriticalException(ex))
{
throw;
}
redirector.WriteErrorLine("Failed to obtain standard error from elevated process.");
#if DEBUG
foreach (var line in SplitLines(ex.ToString()))
{
redirector.WriteErrorLine(line);
}
#else
Trace.TraceError("Failed to obtain standard error from elevated process.");
Trace.TraceError(ex.ToString());
#endif
}
}
finally
{
try
{
File.Delete(outFile);
}
catch { }
try
{
File.Delete(errFile);
}
catch { }
}
};
}
return(result);
}
private static void DumpOutput(ProcessOutput process) {
Console.WriteLine(process.Arguments);
foreach (var line in process.StandardOutputLines) {
Console.WriteLine(line);
}
foreach (var line in process.StandardErrorLines) {
Console.Error.WriteLine(line);
}
}
public void StartServer() {
_process = ProcessOutput.Run(
IisExpressPath,
new[] { "/config:" + Path.Combine(_dir, "applicationHost.config"), "/systray:false" },
null,
null,
false,
new OutputRedirector("IIS")
);
Console.WriteLine("Server started: {0}", _process.Arguments);
}
private void RunTestCase(VisualStudioApp app, IFrameworkHandle frameworkHandle, IRunContext runContext, TestCase test, Dictionary<string, NodejsProjectSettings> sourceToSettings) {
var testResult = new TestResult(test);
frameworkHandle.RecordStart(test);
testResult.StartTime = DateTimeOffset.Now;
NodejsProjectSettings settings;
if (!sourceToSettings.TryGetValue(test.Source, out settings)) {
sourceToSettings[test.Source] = settings = LoadProjectSettings(test.Source);
}
if (settings == null) {
frameworkHandle.SendMessage(
TestMessageLevel.Error,
"Unable to determine interpreter to use for " + test.Source);
RecordEnd(
frameworkHandle,
test,
testResult,
null,
"Unable to determine interpreter to use for " + test.Source,
TestOutcome.Failed);
return;
}
NodejsTestInfo testInfo = new NodejsTestInfo(test.FullyQualifiedName);
List<string> args = new List<string>();
int port = 0;
if (runContext.IsBeingDebugged && app != null) {
app.GetDTE().Debugger.DetachAll();
args.AddRange(GetDebugArgs(settings, out port));
}
var workingDir = Path.GetDirectoryName(CommonUtils.GetAbsoluteFilePath(settings.WorkingDir, testInfo.ModulePath));
args.AddRange(GetInterpreterArgs(test, workingDir, settings.ProjectRootDir));
//Debug.Fail("attach debugger");
if (!File.Exists(settings.NodeExePath)) {
frameworkHandle.SendMessage(TestMessageLevel.Error, "Interpreter path does not exist: " + settings.NodeExePath);
return;
}
lock (_syncObject) {
_nodeProcess = ProcessOutput.Run(
settings.NodeExePath,
args,
workingDir,
null,
false,
null,
false);
#if DEBUG
frameworkHandle.SendMessage(TestMessageLevel.Informational, "cd " + workingDir);
frameworkHandle.SendMessage(TestMessageLevel.Informational, _nodeProcess.Arguments);
#endif
_nodeProcess.Wait(TimeSpan.FromMilliseconds(500));
if (runContext.IsBeingDebugged && app != null) {
try {
//the '#ping=0' is a special flag to tell VS node debugger not to connect to the port,
//because a connection carries the consequence of setting off --debug-brk, and breakpoints will be missed.
string qualifierUri = string.Format("tcp://localhost:{0}#ping=0", port);
while (!app.AttachToProcess(_nodeProcess, NodejsRemoteDebugPortSupplierUnsecuredId, qualifierUri)) {
if (_nodeProcess.Wait(TimeSpan.FromMilliseconds(500))) {
break;
}
}
#if DEBUG
} catch (COMException ex) {
frameworkHandle.SendMessage(TestMessageLevel.Error, "Error occurred connecting to debuggee.");
frameworkHandle.SendMessage(TestMessageLevel.Error, ex.ToString());
KillNodeProcess();
}
#else
} catch (COMException) {
frameworkHandle.SendMessage(TestMessageLevel.Error, "Error occurred connecting to debuggee.");
KillNodeProcess();
}
#endif
}
}
/// <summary>
/// Runs the file with the provided settings as a user with
/// administrative permissions. The window is always hidden and output
/// is provided to the redirector when the process terminates.
/// </summary>
/// <param name="filename">Executable file to run.</param>
/// <param name="arguments">Arguments to pass.</param>
/// <param name="workingDirectory">Starting directory.</param>
/// <param name="redirector">
/// An object to receive redirected output.
/// </param>
/// <param name="quoteArgs"></param>
/// <returns>A <see cref="ProcessOutput"/> object.</returns>
public static ProcessOutput RunElevated(
string filename,
IEnumerable<string> arguments,
string workingDirectory,
Redirector redirector,
bool quoteArgs = true,
Encoding outputEncoding = null,
Encoding errorEncoding = null
) {
var outFile = Path.GetTempFileName();
var errFile = Path.GetTempFileName();
var psi = new ProcessStartInfo("cmd.exe");
psi.CreateNoWindow = true;
psi.WindowStyle = ProcessWindowStyle.Hidden;
psi.UseShellExecute = true;
psi.Verb = "runas";
string args;
if (quoteArgs) {
args = string.Join(" ", arguments.Where(a => a != null).Select(QuoteSingleArgument));
} else {
args = string.Join(" ", arguments.Where(a => a != null));
}
psi.Arguments = string.Format("/S /C \"{0} {1} >>{2} 2>>{3}\"",
QuoteSingleArgument(filename),
args,
QuoteSingleArgument(outFile),
QuoteSingleArgument(errFile)
);
psi.WorkingDirectory = workingDirectory;
psi.CreateNoWindow = true;
psi.UseShellExecute = true;
var process = new Process();
process.StartInfo = psi;
var result = new ProcessOutput(process, redirector);
if (redirector != null) {
result.Exited += (s, e) => {
try {
try {
var lines = File.ReadAllLines(outFile, outputEncoding ?? Encoding.Default);
foreach (var line in lines) {
redirector.WriteLine(line);
}
} catch (Exception ex) {
if (IsCriticalException(ex)) {
throw;
}
redirector.WriteErrorLine("Failed to obtain standard output from elevated process.");
#if DEBUG
foreach (var line in SplitLines(ex.ToString())) {
redirector.WriteErrorLine(line);
}
#else
Trace.TraceError("Failed to obtain standard output from elevated process.");
Trace.TraceError(ex.ToString());
#endif
}
try {
var lines = File.ReadAllLines(errFile, errorEncoding ?? outputEncoding ?? Encoding.Default);
foreach (var line in lines) {
redirector.WriteErrorLine(line);
}
} catch (Exception ex) {
if (IsCriticalException(ex)) {
throw;
}
redirector.WriteErrorLine("Failed to obtain standard error from elevated process.");
#if DEBUG
foreach (var line in SplitLines(ex.ToString())) {
redirector.WriteErrorLine(line);
}
#else
Trace.TraceError("Failed to obtain standard error from elevated process.");
Trace.TraceError(ex.ToString());
#endif
}
} finally {
try {
File.Delete(outFile);
} catch { }
try {
File.Delete(errFile);
} catch { }
}
};
}
return result;
}
public bool AttachToProcess(ProcessOutput proc, Guid portSupplier, string transportQualifierUri) {
var debugger3 = (EnvDTE90.Debugger3)DTE.Debugger;
var transports = debugger3.Transports;
EnvDTE80.Transport transport = null;
for (int i = 1; i <= transports.Count; ++i) {
var t = transports.Item(i);
if (Guid.Parse(t.ID) == portSupplier) {
transport = t;
break;
}
}
if (transport == null) {
return false;
}
var processes = debugger3.GetProcesses(transport, transportQualifierUri);
if (processes.Count < 1) {
return false;
}
// Retry the attach itself 3 times before displaying a Retry/Cancel
// dialog to the user.
DTE.SuppressUI = true;
try {
try {
processes.Item(1).Attach();
return true;
} catch (COMException) {
if (proc.Wait(TimeSpan.FromMilliseconds(500))) {
// Process exited while we were trying
return false;
}
}
} finally {
DTE.SuppressUI = false;
}
// Another attempt, but display UI.
processes.Item(1).Attach();
return true;
}
public bool AttachToProcess(ProcessOutput processOutput, EnvDTE.Process process, Guid[] engines = null) {
// Retry the attach itself 3 times before displaying a Retry/Cancel
// dialog to the user.
var dte = GetDTE();
dte.SuppressUI = true;
try {
try {
if (engines == null) {
process.Attach();
} else {
var process3 = process as EnvDTE90.Process3;
if (process3 == null) {
return false;
}
process3.Attach2(engines.Select(engine => engine.ToString("B")).ToArray());
}
return true;
} catch (COMException) {
if (processOutput.Wait(TimeSpan.FromMilliseconds(500))) {
// Process exited while we were trying
return false;
}
}
} finally {
dte.SuppressUI = false;
}
// Another attempt, but display UI.
process.Attach();
return true;
}
public bool AttachToProcess(ProcessOutput processOutput, Guid[] engines) {
var debugger3 = (EnvDTE90.Debugger3)GetDTE().Debugger;
var processes = debugger3.LocalProcesses;
for (int i = 1; i < processes.Count; ++i) {
var process = processes.Item(i);
if (process.ProcessID == processOutput.ProcessId) {
return AttachToProcess(processOutput, process, engines);
}
}
return false;
}
public bool AttachToProcess(ProcessOutput processOutput, Guid portSupplier, string transportQualifierUri) {
var debugger3 = (EnvDTE90.Debugger3)GetDTE().Debugger;
var transports = debugger3.Transports;
EnvDTE80.Transport transport = null;
for (int i = 1; i <= transports.Count; ++i) {
var t = transports.Item(i);
if (Guid.Parse(t.ID) == portSupplier) {
transport = t;
break;
}
}
if (transport == null) {
return false;
}
var processes = debugger3.GetProcesses(transport, transportQualifierUri);
if (processes.Count < 1) {
return false;
}
var process = processes.Item(1);
return AttachToProcess(processOutput, process);
}
/// <summary>
/// Runs the file with the provided settings as a user with
/// administrative permissions. The window is always hidden and output
/// is provided to the redirector when the process terminates.
/// </summary>
/// <param name="filename">Executable file to run.</param>
/// <param name="arguments">Arguments to pass.</param>
/// <param name="workingDirectory">Starting directory.</param>
/// <param name="redirector">
/// An object to receive redirected output.
/// </param>
/// <param name="quoteArgs"></param>
/// <returns>A <see cref="ProcessOutput"/> object.</returns>
public static ProcessOutput RunElevated(string filename,
IEnumerable <string> arguments,
string workingDirectory,
Redirector redirector,
bool quoteArgs = true)
{
var outFile = Path.GetTempFileName();
var errFile = Path.GetTempFileName();
var psi = new ProcessStartInfo("cmd.exe");
psi.CreateNoWindow = true;
psi.WindowStyle = ProcessWindowStyle.Hidden;
psi.UseShellExecute = true;
psi.Verb = "runas";
string args;
if (quoteArgs)
{
args = string.Join(" ", arguments.Where(a => a != null).Select(QuoteSingleArgument));
}
else
{
args = string.Join(" ", arguments.Where(a => a != null));
}
psi.Arguments = string.Format("/S /C \"{0} {1} >>{2} 2>>{3}\"",
QuoteSingleArgument(filename),
args,
QuoteSingleArgument(outFile),
QuoteSingleArgument(errFile)
);
psi.WorkingDirectory = workingDirectory;
psi.CreateNoWindow = true;
psi.UseShellExecute = true;
var process = new Process();
process.StartInfo = psi;
var result = new ProcessOutput(process, redirector);
if (redirector != null)
{
result.Exited += (s, e) => {
try {
try {
var lines = File.ReadAllLines(outFile);
foreach (var line in lines)
{
redirector.WriteLine(line);
}
} catch (Exception) {
redirector.WriteErrorLine("Failed to obtain standard output from elevated process.");
}
try {
var lines = File.ReadAllLines(errFile);
foreach (var line in lines)
{
redirector.WriteErrorLine(line);
}
} catch (Exception) {
redirector.WriteErrorLine("Failed to obtain standard error from elevated process.");
}
} finally {
try {
File.Delete(outFile);
} catch { }
try {
File.Delete(errFile);
} catch { }
}
};
}
return(result);
}