internal PowerShellTask(string script)
{
this.pipeline = RunspaceFactory.CreateRunspace().CreatePipeline();
this.pipeline.Commands.AddScript(script);
this.pipeline.Runspace.Open();
this.pipeline.Runspace.SessionStateProxy.SetVariable("log", this.Log);
}
public IEnumerable<String> ProcessRecord(PSObject record)
{
if (record == null)
{
yield break;
}
if (_raw)
{
yield return record.ToString();
}
else
{
if (_pipeline == null)
{
_pipeline = CreatePipeline();
_pipeline.InvokeAsync();
}
_pipeline.Input.Write(record);
foreach (PSObject result in _pipeline.Output.NonBlockingRead())
{
yield return result.ToString();
}
}
}
internal ExecutionCmdletHelperComputerName(System.Management.Automation.RemoteRunspace remoteRunspace, Pipeline pipeline, bool invokeAndDisconnect = false)
{
this.invokeAndDisconnect = invokeAndDisconnect;
this.remoteRunspace = remoteRunspace;
remoteRunspace.StateChanged += new EventHandler<RunspaceStateEventArgs>(this.HandleRunspaceStateChanged);
base.pipeline = pipeline;
pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(this.HandlePipelineStateChanged);
}
public PipelineExecutor(Runspace runSpace, string command)
{
this.pipeline = runSpace.CreatePipeline(command);
this.pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
this.pipeline.Output.DataReady += this.OutputDataReady;
this.pipeline.Error.DataReady += this.ErrorDataReady;
}
/// <summary>
/// Initializes a new instance of pipeline wrapper wrapping the
/// specified pipeline.
/// </summary>
/// <param name="pipeline">
/// The pipeline to wrap.
/// </param>
public PipelineWrapper(Pipeline pipeline)
{
if (pipeline == null)
{
throw new ArgumentNullException("pipeline");
}
_pipeline = pipeline;
}
public void Run(String command)
{
log.Info("Running command: " + command);
_PipeLine = _RunSpace.CreatePipeline(command);
_PipeLine.Input.Close();
_OutPut = _PipeLine.Output;
_OutPut.DataReady += _Output_DataReady;
_PipeLine.InvokeAsync();
}
public void Run(String command)
{
this.Log().Info("Running command: {0}", command);
_pipeLine = _runSpace.CreatePipeline(command);
_pipeLine.Input.Close();
_outPut = _pipeLine.Output;
_outPut.DataReady += OutputDataReady;
_pipeLine.InvokeAsync();
}
// void ContinueCommand(RemoteRunspace remoteRunspace, Pipeline cmd, PSHost host, bool inDebugMode, ExecutionContext context)
public static void ContinueCommand(Runspace remoteRunspace, Pipeline cmd, PSHost host, bool inDebugMode,
Runspace oldRunspace)
{
var remoteRunspaceType = typeof(EnterPSSessionCommand).Assembly.GetType("System.Management.Automation.RemoteRunspace");
var executionContextType = typeof(EnterPSSessionCommand).Assembly.GetType("System.Management.Automation.ExecutionContext");
var executionContext = typeof (Runspace).GetProperty("ExecutionContext", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(true).Invoke(remoteRunspace, new object[]{});
var method = typeof(EnterPSSessionCommand).GetMethod("ContinueCommand",
BindingFlags.NonPublic | BindingFlags.Static, null, new[] { remoteRunspaceType, typeof(Pipeline), typeof(PSHost), typeof(bool), executionContextType }, null);
method.Invoke(null, new[] { remoteRunspace, cmd, host, inDebugMode, executionContext});
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (this.pipeline.Runspace != null)
{
this.pipeline.Runspace.Dispose();
this.pipeline = null;
}
}
}
internal void PushPipeline(Pipeline pipeline)
{
// TODO: make sure that the "CurrentPipeline" is in the stack
_pipelineStack.Push(pipeline);
// TODO: create a new pipeline and replace the current one with it
if (pipeline is LocalPipeline)
{
((LocalPipeline)pipeline).RerouteExecutionContext(this);
}
}
public void Dispose()
{
if (_pipeline != null)
{
_pipeline.Dispose();
_pipeline = null;
}
if (_runspace != null)
{
_runspace.Dispose();
_runspace = null;
}
}
public IEnumerable<String> EndProcessing()
{
if (_runspace == null || _pipeline == null)
{
yield break;
}
_pipeline.Input.Close();
foreach (PSObject obj in _pipeline.Output.ReadToEnd())
{
yield return obj.ToString();
}
_pipeline.Dispose();
_pipeline = null;
}
public PipelineExecutor(Runspace runSpace,ISynchronizeInvoke invoker,string command)
{
this.invoker = invoker;
// initialize delegates
synchDataReady = new DataReadyDelegate(SynchDataReady);
synchDataEnd = new DataEndDelegate(SynchDataEnd);
synchErrorReady = new ErrorReadyDelegate(SynchErrorReady);
// initialize event members
stopEvent = new ManualResetEvent(false);
waitHandles = new WaitHandle[] { null, stopEvent };
// create a pipeline and feed it the script text
pipeline = runSpace.CreatePipeline(command);
// we'll listen for script output data by way of the DataReady event
pipeline.Output.DataReady += new EventHandler(Output_DataReady);
pipeline.Error.DataReady += new EventHandler(Error_DataReady);
}
public static void Main()
{
const int SW_HIDE = 0;
const int SW_SHOW = 5;
var handle = Win32.GetConsoleWindow();
// Show Window
Win32.ShowWindow(handle, SW_SHOW);
var amsi = new Amsi();
amsi.Bypass();
string commandArrayString = "FIXME_FUNCTIONS";
List <string> commandArray = new List <string>(commandArrayString.Split(','));
System.Management.Automation.Runspaces.Runspace runspace = System.Management.Automation.Runspaces.RunspaceFactory.CreateRunspace();
runspace.Open();
System.Management.Automation.Runspaces.Pipeline pipeline = runspace.CreatePipeline();
pipeline.Commands.AddScript(ApplicationData.runApp());
foreach (var command in commandArray)
{
pipeline.Commands.AddScript(command);
}
runspace.SessionStateProxy.SetVariable("FormatEnumerationLimit", -1);
pipeline.Commands.Add("Out-String");
System.Collections.ObjectModel.Collection <System.Management.Automation.PSObject> results = pipeline.Invoke();
runspace.Close();
System.Text.StringBuilder stringBuilder = new System.Text.StringBuilder();
foreach (System.Management.Automation.PSObject obj in results)
{
stringBuilder.AppendLine(obj.ToString());
}
System.Console.WriteLine(stringBuilder.ToString());
}
public string Execute(RunnerArgs args)
{
_pipeline = Runspace.CreatePipeline();
_pipeline.Commands.AddScript(args.Script);
_pipeline.Commands.Add("Out-String");
Collection<PSObject> psObjects;
try
{
psObjects = _pipeline.Invoke();
} catch(Exception e)
{
return e.Message;
}
if(_pipeline.Error.Count > 0)
{
var firstOrDefault = _pipeline.Error.ReadToEnd().FirstOrDefault();
if (firstOrDefault != null)
{
return firstOrDefault.ToString();
}
}
if(_pipeline.Output.Count > 0)
{
var firstOrDefault = _pipeline.Output.ReadToEnd().FirstOrDefault();
if (firstOrDefault != null)
{
return firstOrDefault.ToString();
}
}
var sb = new StringBuilder();
foreach (var psObject in psObjects)
{
sb.AppendLine(psObject.ToString());
}
return sb.ToString();
}
private void ConfigureConDepNodeModule(Pipeline pipeline, RemoteScriptFolders folders, PowerShellModulesToLoad modules)
{
if (modules.LoadConDepNodeModule)
{
var conDepNodeModule = string.Format(@"Import-Module {0}", folders.NodeScriptFolder);
Logger.Verbose(conDepNodeModule);
pipeline.Commands.AddScript(conDepNodeModule);
}
}
internal PipelineAbstraction(Pipeline pipeline, Runspace runspace) : base(runspace)
{
this.Pipeline = pipeline;
}
private static void ConfigureCommand(string commandOrScript, IEnumerable<CommandParameter> parameters, Pipeline pipeline)
{
if (parameters != null)
{
var cmd = new Command(commandOrScript, true);
foreach (var param in parameters)
{
cmd.Parameters.Add(param);
}
pipeline.Commands.Add(cmd);
}
else
{
pipeline.Commands.AddScript(commandOrScript);
}
Logger.Verbose(commandOrScript);
}
private void ConfigureConDepDotNetLibrary(Pipeline pipeline, RemoteScriptFolders folders, PowerShellModulesToLoad modules)
{
if (modules.LoadConDepDotNetLibrary)
{
var netLibraryCmd = string.Format(@"Add-Type -Path ""{0}""",
Path.Combine(folders.PSTempFolder, "ConDep.Dsl.Remote.Helpers.dll"));
Logger.Verbose(netLibraryCmd);
pipeline.Commands.AddScript(netLibraryCmd);
}
}
/// <summary>
/// Internal constructor
/// </summary>
/// <param name="pipeline">pipeline object associated with this operation</param>
internal ExecutionCmdletHelperRunspace(Pipeline pipeline)
{
this.pipeline = pipeline;
PipelineRunspace = pipeline.Runspace;
this.pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(HandlePipelineStateChanged);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="remoteRunspace">RemoteRunspace that is associated
/// with this operation</param>
/// <param name="pipeline">pipeline created from the remote runspace</param>
/// <param name="invokeAndDisconnect">Indicates if pipeline should be disconnected after invoking command.</param>
internal ExecutionCmdletHelperComputerName(RemoteRunspace remoteRunspace, Pipeline pipeline, bool invokeAndDisconnect = false)
{
Dbg.Assert(remoteRunspace != null,
"RemoteRunspace reference cannot be null");
PipelineRunspace = remoteRunspace;
_invokeAndDisconnect = invokeAndDisconnect;
RemoteRunspace = remoteRunspace;
remoteRunspace.StateChanged +=
new EventHandler<RunspaceStateEventArgs>(HandleRunspaceStateChanged);
Dbg.Assert(pipeline != null,
"Pipeline cannot be null or empty");
this.pipeline = pipeline;
pipeline.StateChanged +=
new EventHandler<PipelineStateEventArgs>(HandlePipelineStateChanged);
} // IREHelperComputerName
public static bool CloseRunspace()
{
bool result = false;
try {
try {
pipeline.Stop();
}
catch (Exception) {
// Console.WriteLine(eClosingPipeline.Message);
}
testRunSpace.Close();
testRunSpace.Dispose();
testRunSpace = null;
pipeline = null;
result = true;
}
catch (Exception) {
//
// Console.WriteLine("The runspace could not be disposed. {0}", eClosingRunspace.Message);
}
return result;
}
protected void CreateHelpersForSpecifiedRunspaces()
{
RemoteRunspace[] remoteRunspaces;
Pipeline[] pipelines;
// extract RemoteRunspace out of the PSSession objects
int length = Session.Length;
remoteRunspaces = new RemoteRunspace[length];
for (int i = 0; i < length; i++)
{
remoteRunspaces[i] = (RemoteRunspace)Session[i].Runspace;
}
// create the set of pipelines from the RemoteRunspace objects and
// create IREHelperRunspace helper class to create operations
pipelines = new Pipeline[length];
for (int i = 0; i < length; i++)
{
pipelines[i] = CreatePipeline(remoteRunspaces[i]);
// create the operation object
IThrottleOperation operation = new ExecutionCmdletHelperRunspace(pipelines[i]);
Operations.Add(operation);
}
} // CreateHelpersForSpecifiedRunspaces
internal void StopNestedPipelines(Pipeline pipeline)
{
List<Pipeline> list = null;
lock (this._runningPipelines.SyncRoot)
{
if (!this._runningPipelines.Contains(pipeline) || (this.GetCurrentlyRunningPipeline() == pipeline))
{
return;
}
list = new List<Pipeline>();
for (int i = this._runningPipelines.Count - 1; i >= 0; i--)
{
if (this._runningPipelines[i] == pipeline)
{
break;
}
list.Add((Pipeline) this._runningPipelines[i]);
}
}
if (list != null)
{
foreach (Pipeline pipeline2 in list)
{
try
{
pipeline2.Stop();
}
catch (InvalidPipelineStateException)
{
}
}
}
}
public string ExecuteCommand(string command)
{
pipeline = Runspace.CreatePipeline(command, true);
return executePipeline();
}
internal void RemoveFromRunningPipelineList(PipelineBase pipeline)
{
lock (this._runningPipelines.SyncRoot)
{
this._runningPipelines.Remove(pipeline);
if (this._runningPipelines.Count == 0)
{
this.currentlyRunningPipeline = null;
}
else
{
this.currentlyRunningPipeline = (Pipeline) this._runningPipelines[this._runningPipelines.Count - 1];
}
pipeline.PipelineFinishedEvent.Set();
}
}
internal void AddToRunningPipelineList(PipelineBase pipeline)
{
lock (this._runningPipelines.SyncRoot)
{
if (!this._bypassRunspaceStateCheck && (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.Opened))
{
InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, this.RunspaceState.ToString()), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.Opened);
throw exception;
}
this._runningPipelines.Add(pipeline);
this.currentlyRunningPipeline = pipeline;
}
}
private void InvokeCoreAsync(Pipeline pipeline, IEnumerable<object> inputs, EventHandler<PipelineStateEventArgs> pipelineStateChanged)
{
bool hadTheLockAlready = IHaveTheLock;
pipeline.StateChanged += (sender, e) =>
{
// Release the lock ASAP
bool finished = e.PipelineStateInfo.State == PipelineState.Completed ||
e.PipelineStateInfo.State == PipelineState.Failed ||
e.PipelineStateInfo.State == PipelineState.Stopped;
if (finished && !hadTheLockAlready)
{
// Release the dispatcher lock
_dispatcherLock.Release();
}
pipelineStateChanged.Raise(sender, e);
// Dispose Pipeline object upon completion
if (finished)
{
((Pipeline)sender).Dispose();
}
};
if (inputs != null)
{
foreach (var input in inputs)
{
pipeline.Input.Write(input);
}
}
// Take the dispatcher lock and invoke the pipeline
// REVIEW: This could probably be done in a Task so that we can return to the caller before even taking the dispatcher lock
if (IHaveTheLock)
{
pipeline.InvokeAsync();
}
else
{
_dispatcherLock.Wait();
try
{
IHaveTheLock = true;
pipeline.InvokeAsync();
}
catch
{
// Don't care about the exception, rethrow it, but first release the lock
IHaveTheLock = false;
_dispatcherLock.Release();
throw;
}
}
}
public string ExecuteScripts(IEnumerable<string> scripts)
{
var scriptStr = string.Join(Environment.NewLine, scripts);
pipeline = Runspace.CreatePipeline(scriptStr);
return executePipeline();
}
public Pipeline(System.Management.Automation.Runspaces.Pipeline pipeline)
{
this.pipeline = pipeline;
}
private void InitializePS(ref OperationResult Result, Pipeline pipeline)
{
Command initProcess = new Command("Import-Module");
initProcess.Parameters.Add("Name", "ActiveDirectory");
pipeline.Commands.Add(initProcess);
try
{
pipeline.Invoke();
Result.Status = Statics.Result.Success;
}
catch (Exception ex)
{
if (!ex.Message.Contains("Unable to find a default server with Active Directory Web Services"))
{
Result.Status = Statics.Result.Error;
Result.Errors.Add(ex.Message);
}
else
{
Result.Status = Statics.Result.Success;
}
}
}
private Collection<PSObject> InvokeCore(Pipeline pipeline, IEnumerable<object> inputs)
{
Collection<PSObject> output = null;
WithLock(() =>
{
output = inputs == null ? pipeline.Invoke() : pipeline.Invoke(inputs);
});
return output;
}
