public void TestHandle()
{
var runner = new ImpersonationProcessRunner();
var spec = new ProcessRunSpec()
{
ExecutablePath = "powershell",
Arguments = new[] { "-Command", "$x = [Console]::In.ReadLine()" },
BufferedInputOutput = true,
Credentials = creds
};
var proc = runner.Run(spec);
Assert.NotNull(proc.Handle);
var pid = GetProcessId(proc.Handle);
var realProc = Process.GetProcessById(pid);
try
{
Assert.NotNull(realProc);
Assert.Equal("powershell", realProc.ProcessName);
}
finally
{
realProc.Kill();
}
}
public IProcess Run(ProcessRunSpec runSpec)
{
Guid processKey = Guid.NewGuid();
var defaultEnvironmentBlock = EnvironmentBlock.CreateSystemDefault();
var environment = defaultEnvironmentBlock.Merge(runSpec.Environment).ToDictionary();
CreateProcessParams @params = new CreateProcessParams
{
key = processKey,
executablePath = runSpec.ExecutablePath,
arguments = runSpec.Arguments,
environment = environment,
workingDirectory = runSpec.WorkingDirectory
};
var processDataCallback = BuildProcessDataCallback(runSpec.OutputCallback, runSpec.ErrorCallback);
hostClient.SubscribeToProcessData(processKey, processDataCallback);
var result = hostClient.CreateProcess(@params);
var process = new ConstrainedProcess(hostClient, processKey, result.id, environment);
return(process);
}
public Task <CreateProcessResult> ExecuteAsync(CreateProcessParams p)
{
var runSpec = new ProcessRunSpec
{
ExecutablePath = p.executablePath,
Arguments = p.arguments,
Environment = p.environment,
WorkingDirectory = p.workingDirectory,
OutputCallback = (data) =>
{
processTracker.HandleProcessData(p.key, ProcessDataType.STDOUT, data);
},
ErrorCallback = (data) =>
{
processTracker.HandleProcessData(p.key, ProcessDataType.STDERR, data);
},
};
var process = processRunner.Run(runSpec);
processTracker.TrackProcess(p.key, process);
var result = new CreateProcessResult
{
id = process.Id,
};
return(Task.FromResult(result));
}
public IContainerHostClient StartContainerHost(string containerId, IContainerDirectory directory, JobObject jobObject, NetworkCredential credentials)
{
CopyHostToContainer(directory);
var hostRunSpec = new ProcessRunSpec
{
ExecutablePath = directory.MapBinPath(dependencyHelper.ContainerHostExe),
Arguments = new[] { containerId },
BufferedInputOutput = true,
WorkingDirectory = directory.UserPath,
Credentials = credentials,
};
// Order here is important.
// - Start the process
// - Add the process to the job object
// - Verify that the process is healthy
// - Start the RPC message pump
//
// We need to ensure that the host process cannot create any new processes before
// it's added to the job object.
var hostProcess = processRunner.Run(hostRunSpec);
jobObject.AssignProcessToJob(hostProcess.Handle);
WaitForProcessToStart(hostProcess, HostProcessStartTimeout);
var messageTransport = MessageTransport.Create(hostProcess.StandardOutput, hostProcess.StandardInput);
var messagingClient = MessagingClient.Create(async message =>
{
await messageTransport.PublishRequestAsync(message);
});
messageTransport.SubscribeResponse(message =>
{
messagingClient.PublishResponse(message);
return(Task.FromResult(0));
});
messageTransport.SubscribeEvent(@event =>
{
try
{
messagingClient.PublishEvent(@event);
}
catch (Exception e)
{
log.Log(LogLevel.Error, e.ToString(), e);
}
return(Task.FromResult(0));
});
var containerHostClient = new ContainerHostClient(hostProcess, messageTransport, messagingClient, jobObject);
messageTransport.Start();
return(containerHostClient);
}
public void TestStdout()
{
var runner = new ImpersonationProcessRunner();
var spec = new ProcessRunSpec()
{
ExecutablePath = "whoami",
BufferedInputOutput = true,
Credentials = creds
};
var proc = runner.Run(spec);
Assert.Matches(new Regex(username), proc.StandardOutput.ReadToEnd());
}
public void TestStderr()
{
var runner = new ImpersonationProcessRunner();
var spec = new ProcessRunSpec()
{
ExecutablePath = "powershell",
Arguments = new[] { "-Command", "[Console]::Error.WriteLine('hi')" },
BufferedInputOutput = true,
Credentials = creds
};
var proc = runner.Run(spec);
Assert.Equal("hi", proc.StandardError.ReadToEnd().Trim());
}
public void TestExited()
{
var exited = false;
var runner = new ImpersonationProcessRunner();
var spec = new ProcessRunSpec()
{
ExecutablePath = "whoami",
BufferedInputOutput = true,
Credentials = creds,
ExitHandler = (sender, args) => exited = true
};
var process = runner.Run(spec);
process.WaitForExit();
Assert.True(exited);
}
public void SetsDefaultEnvironmentBlock()
{
var spec = new ProcessRunSpec
{
ExecutablePath = "exe",
Arguments = new[] { "arg1", "arg2" },
WorkingDirectory = @"\WorkdirDir",
Environment = new Dictionary <string, string>(),
};
Runner.Run(spec);
Client.Received(1).CreateProcess(
Arg.Is <CreateProcessParams>(actual =>
actual.environment.ContainsKey("TEMP") &&
actual.environment.ContainsKey("PATH")
)
);
}
public Run()
{
Spec = new ProcessSpec
{
ExecutablePath = "/.iishost/iishost.exe",
Arguments = new[] { "-p", "3000", "-r", @"/www" },
};
var containerUserPath = @"C:\Containers\handle\user\";
ExpectedRunSpec = new ProcessRunSpec
{
ExecutablePath = @"C:\Containers\handle\user\.iishost\iishost.exe",
Arguments = Spec.Arguments,
WorkingDirectory = containerUserPath,
};
Directory.MapUserPath("/.iishost/iishost.exe").Returns(ExpectedRunSpec.ExecutablePath);
Directory.MapUserPath("/").Returns(containerUserPath);
}
public IContainerProcess Run(ProcessSpec spec, IProcessIO io)
{
lock (_ioLock)
{
ThrowIfNotActive();
var runner = spec.Privileged
? processRunner
: constrainedProcessRunner;
var executablePath = !spec.DisablePathMapping
? directory.MapUserPath(spec.ExecutablePath)
: spec.ExecutablePath;
var specEnvironment = spec.Environment ?? new Dictionary <string, string>();
var processEnvironment = this.defaultEnvironment.Merge(specEnvironment);
Action <string> stdOut = io == null || io.StandardOutput == null
? (Action <string>)null
: data => io.StandardOutput.Write(data);
Action <string> stdErr = io == null || io.StandardError == null
? (Action <string>)null
: data => io.StandardError.Write(data);
var runSpec = new ProcessRunSpec
{
ExecutablePath = executablePath,
Arguments = spec.Arguments,
Environment = processEnvironment,
WorkingDirectory = directory.MapUserPath(spec.WorkingDirectory ?? DefaultWorkingDirectory),
OutputCallback = stdOut,
ErrorCallback = stdErr,
};
var process = runner.Run(runSpec);
return(new ContainerProcess(process));
}
}
public void SendsCreateProcessMessage()
{
var spec = new ProcessRunSpec
{
ExecutablePath = "exe",
Arguments = new[] { "arg1", "arg2" },
WorkingDirectory = @"\WorkdirDir",
Environment = new Dictionary <string, string> {
{ "env1", "val1" }
},
};
Runner.Run(spec);
Client.Received(1).CreateProcess(
Arg.Is <CreateProcessParams>(actual =>
actual.executablePath == spec.ExecutablePath &&
actual.arguments == spec.Arguments &&
actual.environment.ContainsKey("env1") &&
actual.workingDirectory == spec.WorkingDirectory &&
actual.key != Guid.Empty
)
);
}
public void ReturnsProcessWithEnvironment()
{
int expectedId = 123;
Client.CreateProcess(Arg.Any <CreateProcessParams>()).Returns(
new CreateProcessResult()
{
id = expectedId
}
);
var spec = new ProcessRunSpec
{
Environment = new Dictionary <string, string> {
{ "FOO", "BAR" }
}
};
var process = Runner.Run(spec);
Assert.NotNull(process.Environment);
Assert.True(process.Environment.Count > 0);
Assert.Equal("BAR", process.Environment["FOO"]);
}
