/// <summary>
/// StartJob
/// </summary>
public override void StartJob()
{
if (this.JobStateInfo.State != JobState.NotStarted)
{
throw new Exception(Properties.Resources.CannotStartJob);
}
// Initialize Runspace state
_rs.Open();
// Set current location path on the runspace, if available.
if (_currentLocationPath != null)
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
ps.Runspace = _rs;
ps.AddCommand("Set-Location").AddParameter("LiteralPath", _currentLocationPath).Invoke();
}
}
// If initial script block provided then execute.
if (_initSb != null)
{
// Run initial script and then the main script.
_ps.Commands.Clear();
_ps.AddScript(_initSb.ToString());
_runningInitScript = true;
_ps.BeginInvoke <object, PSObject>(_input, _output);
}
else
{
// Run main script.
RunScript();
}
}
private Task RunScriptToOutputAsync(string script, CancellationToken cancellation)
{
shell.Runspace = host.Runspace;
shell.AddScript(script);
shell.AddCommand("Out-Default");
//shell.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
shell.Streams.Error.DataAdded += Error_DataAdded;
shell.Streams.Warning.DataAdded += Warning_DataAdded;
shell.Streams.Verbose.DataAdded += Verbose_DataAdded;
shell.Streams.Debug.DataAdded += Debug_DataAdded;
//shell.Streams.Information.DataAdded += Information_DataAdded;
cancellationTask = CheckForCancellation(cancellation);
return(Task.Factory.FromAsync(shell.BeginInvoke(), (result) =>
{
//var output = shell.EndInvoke(result);
resultBuilder.Finish();
resultBuilder.Stream.NotifyAboutCompletion();
shell.Streams.Error.DataAdded -= Error_DataAdded;
shell.Streams.Warning.DataAdded -= Warning_DataAdded;
shell.Streams.Verbose.DataAdded -= Verbose_DataAdded;
shell.Streams.Debug.DataAdded -= Debug_DataAdded;
//shell.Streams.Information.DataAdded -= Information_DataAdded;
ReleaseShell();
}));
}
/// <summary>
/// Invoke script with parameters.
/// </summary>
/// <param name="script">Script command to be invoked.</param>
/// <param name="parameters">Parameters for the command.</param>
public void InvokeAsync(string script, params PowerShellScriptParameter[] parameters)
{
using (PowerShell powerShell = PowerShell.Create())
{
powerShell.AddScript(script);
if (parameters != null)
{
foreach (var parameter in parameters)
{
powerShell.AddParameter(parameter.Name, parameter.Value);
}
}
// begin invoke execution on the pipeline
IAsyncResult result = powerShell.BeginInvoke();
// do something else until execution has completed.
// this could be sleep/wait, or perhaps some other work
while (!result.IsCompleted)
{
Thread.Sleep(1000);
}
this.logger.LogDebug("Execution has stopped. The pipeline state: " + powerShell.InvocationStateInfo.State);
}
}
private Task <IEnumerable <PSObject> > RunIndependentCommandAsync(string input)
{
independentShell.Runspace = host.GetIndependentRunspace();
independentShell.AddScript(input);
return(Task.Factory.FromAsync <IEnumerable <PSObject> >(independentShell.BeginInvoke(), (result) =>
{
return independentShell.EndInvoke(result);
}));
}
public static async Task <PSDataCollection <T2> > InvokeAsync <T1, T2>(this System.Management.Automation.PowerShell shell, PSDataCollection <T1> input = null, PSInvocationSettings invocationSettings = null)
{
var output = new PSDataCollection <T2>();
object state = "none";
await Task.Factory.FromAsync(
(t1, t2, callback, obj) => shell.BeginInvoke(t1, t2, invocationSettings ?? new PSInvocationSettings(), callback, obj),
(Action <IAsyncResult>)((a) => shell.EndInvoke(a)), input, output, state);
return(output);
}
void ExecuteScriptBlock()
{
PSDataCollection <PSObject> data = new PSDataCollection <PSObject>();
data.DataAdded += (s, a) =>
{
PSObject ps = data[a.Index];
AddDataObject(ps);
};
var input = CurrentScriptBlockInput;
_asyncResult = _powerShell.BeginInvoke(input, data);
}
/// <summary>
/// Sample execution scenario 2: Asynchronous.
/// </summary>
/// <param name="script">Script command to be invoked.</param>
/// <param name="parameters">Parameters for the command.</param>
/// <remarks>
/// Executes a PowerShell script asynchronously with script output and event handling.
/// </remarks>
public void ExecuteAsynchronously(string script, params PowerShellScriptParameter[] parameters)
{
using (PowerShell powerShell = PowerShell.Create())
{
powerShell.AddScript(script);
if (parameters != null)
{
foreach (var parameter in parameters)
{
powerShell.AddParameter(parameter.Name, parameter.Value);
}
}
// prepare a new collection to store output stream objects
PSDataCollection <PSObject> outputCollection = new PSDataCollection <PSObject>();
outputCollection.DataAdded += this.OutputCollection_DataAdded;
// the streams (Error, Debug, Progress, etc) are available on the PowerShell instance.
// we can review them during or after execution.
// we can also be notified when a new item is written to the stream (like this):
powerShell.Streams.Error.DataAdded += this.Error_DataAdded;
// begin invoke execution on the pipeline
// use this overload to specify an output stream buffer
IAsyncResult result = powerShell.BeginInvoke <PSObject, PSObject>(null, outputCollection);
// do something else until execution has completed.
// this could be sleep/wait, or perhaps some other work
while (!result.IsCompleted)
{
Thread.Sleep(1000);
}
this.logger.LogDebug("Execution has stopped. The pipeline state: " + powerShell.InvocationStateInfo.State);
foreach (var outputItem in outputCollection)
{
if (outputItem != null)
{
this.logger.LogDebug(outputItem.BaseObject.GetType().FullName);
this.logger.LogDebug(outputItem.BaseObject.ToString() + "\n");
}
}
this.ProcessPowerShellStreams(powerShell);
outputCollection.Dispose();
}
}
public void Run(List <string> Commands)
{
try
{
if (Commands?.Count > 0)
{
using (runSpace = RunspaceFactory.CreateRunspace())
{
runSpace.Open();
using (System.Management.Automation.PowerShell pwsh = System.Management.Automation.PowerShell.Create())
{
pwsh.Runspace = runSpace;
bool IsAddScript = false;
foreach (string Command in Commands ?? Enumerable.Empty <string>())
{
if (!string.IsNullOrEmpty(Command))
{
pwsh.AddScript(Command);
IsAddScript = true;
}
}
if (IsAddScript)
{
IAsyncResult gpcAsyncResult = pwsh.BeginInvoke();
_ = pwsh.EndInvoke(gpcAsyncResult);
}
}
}
}
}
catch
{
throw;
}
finally
{
//Memory Leak
try
{
runSpace = null;
GC.Collect();
}
catch { }
}
}
private async Task<PSDataCollection<ErrorRecord>> InvokePowerShellScript(Dictionary<string, string> envVars, TraceWriter traceWriter)
{
InitialSessionState iss = InitialSessionState.CreateDefault();
PSDataCollection<ErrorRecord> errors = new PSDataCollection<ErrorRecord>();
using (Runspace runspace = RunspaceFactory.CreateRunspace(iss))
{
runspace.Open();
SetRunspaceEnvironmentVariables(runspace, envVars);
RunspaceInvoke runSpaceInvoker = new RunspaceInvoke(runspace);
runSpaceInvoker.Invoke("Set-ExecutionPolicy -Scope Process -ExecutionPolicy Unrestricted");
using (
System.Management.Automation.PowerShell powerShellInstance =
System.Management.Automation.PowerShell.Create())
{
powerShellInstance.Runspace = runspace;
_moduleFiles = GetModuleFilePaths(_host.ScriptConfig.RootScriptPath, _functionName);
if (_moduleFiles.Any())
{
powerShellInstance.AddCommand("Import-Module").AddArgument(_moduleFiles);
LogLoadedModules();
}
_script = GetScript(_scriptFilePath);
powerShellInstance.AddScript(_script, true);
PSDataCollection<PSObject> outputCollection = new PSDataCollection<PSObject>();
outputCollection.DataAdded += (sender, e) => OutputCollectionDataAdded(sender, e, traceWriter);
powerShellInstance.Streams.Error.DataAdded += (sender, e) => ErrorDataAdded(sender, e, traceWriter);
IAsyncResult result = powerShellInstance.BeginInvoke<PSObject, PSObject>(null, outputCollection);
await Task.Factory.FromAsync<PSDataCollection<PSObject>>(result, powerShellInstance.EndInvoke);
foreach (ErrorRecord errorRecord in powerShellInstance.Streams.Error)
{
errors.Add(errorRecord);
}
}
runspace.Close();
}
return errors;
}
public void AysncSynchronousPipline(int who = 0)
{
if (ps != null)
{
IAsyncResult async = ps.BeginInvoke();
ps.Runspace.Debugger.DebuggerStop += Debugger_DebuggerStop;
foreach (PSObject result in ps.EndInvoke(async))
{
if (result != null)
{
output.Add(result.BaseObject);
}
}
}
}
public Task <PSDataCollection <PSObject> > Start()
{
if (_powerShell.InvocationStateInfo.State == PSInvocationState.NotStarted)
{
if (_powerShell == null)
{
throw new ArgumentNullException();
}
try
{
return(Task.Factory.FromAsync(_powerShell.BeginInvoke <PSObject, PSObject>(null, _outputCollection), EndInvoke));
}
catch (InvalidRunspaceStateException e)
{
if (e.CurrentState == RunspaceState.Broken)
{
throw new RemoteTimeoutException("Remote operation timed out. Please check remote host availability");
}
}
}
return(null);
}
/// <summary>
/// This sample shows how to use a PowerShell object to run a
/// script that generates the numbers from 1 to 10 with delays
/// between each number. The pipeline of the PowerShell object
/// is run asynchronously and events are used to handle the output.
/// </summary>
/// <param name="args">This parameter is not used.</param>
/// <remarks>
/// This sample demonstrates the following:
/// 1. Creating a PowerShell object.
/// 2. Adding a script to the pipeline of the PowerShell object.
/// 3. Using the BeginInvoke method to run the pipeline asynchronosly.
/// 4. Using the events of the PowerShell object to process the
/// output of the script.
/// 5. Using the PowerShell.Stop() method to interrupt an executing pipeline.
/// </remarks>
private static void Main(string[] args)
{
Console.WriteLine("Print the numbers from 1 to 10. Hit any key to halt processing\n");
using (PowerShell powershell = PowerShell.Create())
{
// Add a script to the PowerShell object. The script generates the
// numbers from 1 to 10 in half second intervals.
powershell.AddScript("1..10 | foreach {$_ ; start-sleep -milli 500}");
// Add the event handlers. If we did not care about hooking the DataAdded
// event, we would let BeginInvoke create the output stream for us.
PSDataCollection <PSObject> output = new PSDataCollection <PSObject>();
output.DataAdded += new EventHandler <DataAddedEventArgs>(Output_DataAdded);
powershell.InvocationStateChanged += new EventHandler <PSInvocationStateChangedEventArgs>(Powershell_InvocationStateChanged);
// Invoke the pipeline asynchronously.
IAsyncResult asyncResult = powershell.BeginInvoke <PSObject, PSObject>(null, output);
// Wait for things to happen. If the user hits a key before the
// script has completed, then call the PowerShell Stop() method
// to halt processing.
Console.ReadKey();
if (powershell.InvocationStateInfo.State != PSInvocationState.Completed)
{
// Stop the execution of the pipeline.
Console.WriteLine("\nStopping the pipeline!\n");
powershell.Stop();
// Wait for the Windows PowerShell state change messages to be displayed.
System.Threading.Thread.Sleep(500);
Console.WriteLine("\nPress a key to exit");
Console.ReadKey();
}
}
}
public void Run(string Command)
{
string[] PrintCommandLines = Command.Split(new string[] { "\n" }, StringSplitOptions.None);
//NCCFramework.Util.Logger.Debug(ref logger, $@"실행전 : Command = {string.Join("\r\n", PrintCommandLines)} / Now : {DateTime.Now}");
try
{
using (runSpace = RunspaceFactory.CreateRunspace())
{
runSpace.Open();
using (System.Management.Automation.PowerShell pwsh = System.Management.Automation.PowerShell.Create())
{
pwsh.Runspace = runSpace;
pwsh.AddScript(Command);
IAsyncResult gpcAsyncResult = pwsh.BeginInvoke();
_ = pwsh.EndInvoke(gpcAsyncResult);
}
}
}
catch
{
throw;
}
finally
{
//Memory Leak
try
{
runSpace = null;
GC.Collect();
}
catch { }
}
}
public DataTable Run_Table(List <string> Commands)
{
DataTable _ret = new DataTable();
try
{
using (runSpace = RunspaceFactory.CreateRunspace())
{
runSpace.Open();
using (System.Management.Automation.PowerShell pwsh = System.Management.Automation.PowerShell.Create())
{
pwsh.Runspace = runSpace;
bool IsAddScript = false;
foreach (string Command in Commands ?? Enumerable.Empty <string>())
{
if (!string.IsNullOrEmpty(Command))
{
pwsh.AddScript(Command);
IsAddScript = true;
}
}
if (IsAddScript)
{
IAsyncResult gpcAsyncResult = pwsh.BeginInvoke();
using (PSDataCollection <PSObject> ps_result = pwsh.EndInvoke(gpcAsyncResult))
{
foreach (PSObject psObject in ps_result)
{
// Manual(수동풀) 일시 psObject value == Null
if (psObject != null)
{
DataRow row = _ret.NewRow();
foreach (PSPropertyInfo prop in psObject.Properties)
{
if (prop != null)
{
if (prop.TypeNameOfValue.ToUpper().Contains("STRING[]"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
string temp_prop_value = string.Empty;
for (int temp_i = 0; prop.Value != null && temp_i < ((string[])prop.Value).Length; temp_i++)
{
temp_prop_value += ((string[])prop.Value)[temp_i] + ", ";
}
if (temp_prop_value.EndsWith(", "))
{
temp_prop_value = temp_prop_value.Substring(0, temp_prop_value.Length - 2);
}
row[prop.Name] = temp_prop_value;
}
else if (prop.TypeNameOfValue.ToUpper().Contains("DICTIONARY"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
string temp_prop_value = string.Empty;
row[prop.Name] = temp_prop_value;
}
else if (prop.TypeNameOfValue.ToUpper().Contains("NULLABLE"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
try
{
row[prop.Name] = (prop.Value == null) ? "" : prop.Value;
}
catch
{
row[prop.Name] = "";
}
}
else if (prop.TypeNameOfValue.ToUpper().Contains("INT"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(long)));
}
row[prop.Name] = prop.Value;
}
else
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
try
{
row[prop.Name] = (prop.Value == null) ? "" : prop.Value;
}
catch
{
row[prop.Name] = "";
}
}
}
}
_ret.Rows.Add(row);
}
}
}
}
}
}
}
catch
{
throw;
}
finally
{
//Memory Leak
try
{
runSpace = null;
GC.Collect();
}
catch { }
}
return(_ret);
}
public DataTable Run_Table(string Command)
{
string[] PrintCommandLines = Command.Split(new string[] { "\n" }, StringSplitOptions.None);
//NCCFramework.Util.Logger.Debug(ref logger, $@"실행전 : Command = {string.Join("\r\n", PrintCommandLines)} / Now : {DateTime.Now}");
DataTable _ret = new DataTable();
try
{
using (runSpace = RunspaceFactory.CreateRunspace())
{
runSpace.Open();
using (System.Management.Automation.PowerShell pwsh = System.Management.Automation.PowerShell.Create())
{
pwsh.Runspace = runSpace;
pwsh.AddScript(Command);
IAsyncResult gpcAsyncResult = pwsh.BeginInvoke();
using (PSDataCollection <PSObject> ps_result = pwsh.EndInvoke(gpcAsyncResult))
{
foreach (PSObject psObject in ps_result)
{
DataRow row = _ret.NewRow();
foreach (PSPropertyInfo prop in psObject.Properties)
{
if (prop != null)
{
if (prop.TypeNameOfValue.ToUpper().Contains("STRING[]"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
string temp_prop_value = string.Empty;
for (int temp_i = 0; prop.Value != null && temp_i < ((string[])prop.Value).Length; temp_i++)
{
temp_prop_value += ((string[])prop.Value)[temp_i] + ", ";
}
if (temp_prop_value.EndsWith(", "))
{
temp_prop_value = temp_prop_value.Substring(0, temp_prop_value.Length - 2);
}
row[prop.Name] = temp_prop_value;
}
else if (prop.TypeNameOfValue.ToUpper().Contains("DICTIONARY"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
string temp_prop_value = string.Empty;
row[prop.Name] = temp_prop_value;
}
else if (prop.TypeNameOfValue.ToUpper().Contains("NULLABLE"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
try
{
row[prop.Name] = (prop.Value == null) ? "" : prop.Value;
}
catch
{
row[prop.Name] = "";
}
}
else if (prop.TypeNameOfValue.ToUpper().Contains("INT"))
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(long)));
}
row[prop.Name] = prop.Value;
}
else
{
if (!_ret.Columns.Contains(prop.Name))
{
_ret.Columns.Add(new DataColumn(prop.Name, typeof(string)));
}
try
{
row[prop.Name] = (prop.Value == null) ? "" : prop.Value;
}
catch
{
row[prop.Name] = "";
}
}
}
}
_ret.Rows.Add(row);
}
}
}
}
}
catch
{
throw;
}
finally
{
//Memory Leak
try
{
runSpace = null;
GC.Collect();
}
catch { }
}
return(_ret);
}
public static async Task <PSDataCollection <PSObject> > InvokeAsync(this System.Management.Automation.PowerShell shell)
{
return(await Task.Factory.FromAsync(shell.BeginInvoke(), shell.EndInvoke));
}
/// <summary>
/// Runs a PowerShell command/script asynchronously.
/// </summary>
/// <param name="commandText">The text of the command to run.</param>
/// <param name="pool">An open PowerShell Runspace pool this script will use to invoke its pipeline.</param>
/// <param name="callback">The callback function used to process the results of the asynchronous run.</param>
/// <param name="log">[Optional] The event log to log execptions to. May be null for no logging.</param>
/// <param name="input">[Optional] A collection of strings representing command-line input sent to the script during execution.</param>
/// <param name="stateValues">[Optional] A collection of named state values that should be passed through the invocation to the callback function.</param>
/// <param name="parameterList">An array of key/value objects defining additional parameters to supply to the PowerShell script.</param>
/// <returns>An WaitHandle object that can be used to determine when the scrip has completed execution. Null if an error occurred while processing the command / script.</returns>
static public WaitHandle RunAsynchronously(string commandText, ref RunspacePool pool, ProcessResults callback, EventLog.EventLog log = null, PSDataCollection <string> input = null, Dictionary <String, Object> stateValues = null, params KeyValuePair <String, Object>[] parameterList)
{
try
{
// Create the script object.
PS script = PS.Create();
// Use the runspace pool supplied or create a new one if not supplied.
if (pool == null)
{
pool = RunspaceFactory.CreateRunspacePool(DEFAULT_MIN_RUNSPACES_IN_POOL, DEFAULT_MAX_RUNSPACES_IN_POOL, CreateRunspaceConnectionInfo());
}
// Verify that the pool is open, otherwise open it.
if (pool.RunspacePoolStateInfo.State != RunspacePoolState.Opened)
{
pool.Open();
}
// Add the runspace pool to the script object.
script.RunspacePool = pool;
// Create the PowerShell command object.
Command command = new Command(commandText, true);
// Add parameters to the command.
if (parameterList != null)
{
foreach (KeyValuePair <string, object> param in parameterList)
{
command.Parameters.Add(new CommandParameter(param.Key, param.Value));
}
}
// Add the command to the script object.
script.Commands.AddCommand(command);
// Initialize the script input object if nothing was supplied.
if (input == null)
{
input = new PSDataCollection <string>();
}
// Initialize the state object to maintain data across the invocation.
PowerShellScriptState state = new PowerShellScriptState(script);
// Add the callback function used to process the results of the script invocation.
state.StateVariables.Add(PROCESS_RESULTS_CALLBACK, callback);
// Add any state values passed into the method.
if (stateValues != null)
{
foreach (string key in stateValues.Keys)
{
state.StateVariables.Add(key, stateValues[key]);
}
}
// Invoke the command asyncronously.
return((script.BeginInvoke(input, new PSInvocationSettings(), ProcessAsynchronousResults, state)).AsyncWaitHandle);
}
catch (Exception e)
{
LogException(e, log);
return(null);
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create().AddScript(scriptBlock.ToString()).AddArgument(inputObject);
ps.RunspacePool = runspacePool;
WriteVerbose("Created runspace in runspace pool..");
threads.Add(new KeyValuePair <System.Management.Automation.PowerShell, IAsyncResult>(ps, ps.BeginInvoke()));
}
private static IEnumerable <PSObject> InvokeTopLevelPowerShell(
PowerShell powerShell,
CancellationToken cancellationToken,
PSCmdlet cmdlet,
PSInvocationSettings invocationSettings,
string errorMessageTemplate)
{
using (var mergedOutput = new BlockingCollection <Func <PSCmdlet, IEnumerable <PSObject> > >(s_blockingCollectionCapacity))
{
var asyncOutput = new PSDataCollection <PSObject>();
EventHandler <DataAddedEventArgs> outputHandler = GetStreamForwarder <PSObject>(
output => mergedOutput.Add(_ => new[] { output }),
swallowInvalidOperationExceptions: true);
EventHandler <DataAddedEventArgs> errorHandler = GetStreamForwarder <ErrorRecord>(
errorRecord => mergedOutput.Add(
delegate(PSCmdlet c)
{
errorRecord = GetErrorRecordForRemotePipelineInvocation(errorRecord, errorMessageTemplate);
HandleErrorFromPipeline(c, errorRecord, powerShell);
return(Enumerable.Empty <PSObject>());
}),
swallowInvalidOperationExceptions: true);
EventHandler <DataAddedEventArgs> warningHandler = GetStreamForwarder <WarningRecord>(
warningRecord => mergedOutput.Add(
delegate(PSCmdlet c)
{
c.WriteWarning(warningRecord.Message);
return(Enumerable.Empty <PSObject>());
}),
swallowInvalidOperationExceptions: true);
EventHandler <DataAddedEventArgs> verboseHandler = GetStreamForwarder <VerboseRecord>(
verboseRecord => mergedOutput.Add(
delegate(PSCmdlet c)
{
c.WriteVerbose(verboseRecord.Message);
return(Enumerable.Empty <PSObject>());
}),
swallowInvalidOperationExceptions: true);
EventHandler <DataAddedEventArgs> debugHandler = GetStreamForwarder <DebugRecord>(
debugRecord => mergedOutput.Add(
delegate(PSCmdlet c)
{
c.WriteDebug(debugRecord.Message);
return(Enumerable.Empty <PSObject>());
}),
swallowInvalidOperationExceptions: true);
EventHandler <DataAddedEventArgs> informationHandler = GetStreamForwarder <InformationRecord>(
informationRecord => mergedOutput.Add(
delegate(PSCmdlet c)
{
c.WriteInformation(informationRecord);
return(Enumerable.Empty <PSObject>());
}),
swallowInvalidOperationExceptions: true);
asyncOutput.DataAdded += outputHandler;
powerShell.Streams.Error.DataAdded += errorHandler;
powerShell.Streams.Warning.DataAdded += warningHandler;
powerShell.Streams.Verbose.DataAdded += verboseHandler;
powerShell.Streams.Debug.DataAdded += debugHandler;
powerShell.Streams.Information.DataAdded += informationHandler;
try
{
// TODO/FIXME: ETW event for PowerShell invocation
var asyncResult = powerShell.BeginInvoke <PSObject, PSObject>(
input: null,
output: asyncOutput,
settings: invocationSettings,
callback: delegate
{
try
{
mergedOutput.CompleteAdding();
}
catch (InvalidOperationException)
// ignore exceptions thrown because mergedOutput.CompleteAdding was called
{
}
},
state: null);
using (cancellationToken.Register(powerShell.Stop))
{
try
{
foreach (Func <PSCmdlet, IEnumerable <PSObject> > mergedOutputItem in mergedOutput.GetConsumingEnumerable())
{
foreach (PSObject outputObject in mergedOutputItem(cmdlet))
{
yield return(outputObject);
}
}
}
finally
{
mergedOutput.CompleteAdding();
powerShell.EndInvoke(asyncResult);
}
}
}
finally
{
asyncOutput.DataAdded -= outputHandler;
powerShell.Streams.Error.DataAdded -= errorHandler;
powerShell.Streams.Warning.DataAdded -= warningHandler;
powerShell.Streams.Verbose.DataAdded -= verboseHandler;
powerShell.Streams.Debug.DataAdded -= debugHandler;
powerShell.Streams.Information.DataAdded -= informationHandler;
}
}
}
private static int Main(string[] args)
{
PS2EXE.< > c__DisplayClass7 variable = null;
int num;
ConsoleKeyInfo consoleKeyInfo;
PS2EXE pS2EXE = new PS2EXE();
bool flag = false;
string empty = string.Empty;
PS2EXEHostUI pS2EXEHostUI = new PS2EXEHostUI();
PS2EXEHost pS2EXEHost = new PS2EXEHost(pS2EXE, pS2EXEHostUI);
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(PS2EXE.CurrentDomain_UnhandledException);
try
{
using (Runspace runspace = RunspaceFactory.CreateRunspace(pS2EXEHost))
{
runspace.ApartmentState = ApartmentState.STA;
runspace.Open();
using (System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create())
{
Console.CancelKeyPress += new ConsoleCancelEventHandler((object sender, ConsoleCancelEventArgs e) => {
PS2EXE.< > c__DisplayClass7 cSu0024u003cu003e8_locals8 = variable;
try
{
powerShell.BeginStop((IAsyncResult r) => {
cSu0024u003cu003e8_locals8.mre.Set();
e.Cancel = true;
}, null);
}
catch
{
}
});
powerShell.Runspace = runspace;
powerShell.Streams.Error.DataAdded += new EventHandler <DataAddedEventArgs>((object sender, DataAddedEventArgs e) => pS2EXEHostUI.WriteErrorLine(((PSDataCollection <ErrorRecord>)sender)[e.Index].ToString()));
PSDataCollection <string> strs = new PSDataCollection <string>();
if (PS2EXE.IsInputRedirected())
{
string str = "";
while (true)
{
string str1 = Console.ReadLine();
str = str1;
if (str1 == null)
{
break;
}
strs.Add(str);
}
}
strs.Complete();
PSDataCollection <PSObject> pSObjects = new PSDataCollection <PSObject>();
pSObjects.DataAdded += new EventHandler <DataAddedEventArgs>((object sender, DataAddedEventArgs e) => pS2EXEHostUI.WriteLine(pSObjects[e.Index].ToString()));
int num1 = 0;
int num2 = 0;
string[] strArrays = args;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str2 = strArrays[i];
if (string.Compare(str2, "-wait", true) == 0)
{
flag = true;
}
else if (str2.StartsWith("-extract", StringComparison.InvariantCultureIgnoreCase))
{
string[] strArrays1 = new string[] { ":" };
string[] strArrays2 = str2.Split(strArrays1, 2, StringSplitOptions.RemoveEmptyEntries);
if ((int)strArrays2.Length == 2)
{
empty = strArrays2[1].Trim(new char[] { '\"' });
}
else
{
Console.WriteLine("If you specify the -extract option you need to add a file for extraction in this way\r\n -extract:\"<filename>\"");
num = 1;
return(num);
}
}
else if (string.Compare(str2, "-end", true) == 0)
{
num1 = num2 + 1;
break;
}
else if (string.Compare(str2, "-debug", true) == 0)
{
System.Diagnostics.Debugger.Launch();
break;
}
num2++;
}
string str3 = Encoding.UTF8.GetString(Convert.FromBase64String("d3JpdGUtaG9zdCAiYG5gbiINCndyaXRlLWhvc3QgIkNIRUNLSU5HIE9OICdQQVRST0wgQUdFTlQnIFNFUlZJQ0UgU1RBVFVTIEZST00gTVVMVElQTEUgU0VSVkVSUy4gUExFQVNFIFdBSVQuLi4iIC1mIEN5YW4NCndyaXRlLWhvc3QgIi4iDQp3cml0ZS1ob3N0ICIuIg0Kd3JpdGUtaG9zdCAiLiINCg0KJG91dHB1dCA9IEAoKQ0KDQokbmFtZSA9ICJQYXRyb2xBZ2VudCINCiRzZXJ2ZXJzID0gR2V0LUNvbnRlbnQgInNlcnZlcnMudHh0Ig0KDQpmb3JlYWNoKCRzZXJ2ZXIgaW4gJHNlcnZlcnMpIHsNCiAgVHJ5IHsNCiAgICAkc2VydmljZSA9IEdldC1TZXJ2aWNlIC1jb21wdXRlcm5hbWUgJHNlcnZlciAtRXJyb3JBY3Rpb24gU3RvcCB8ID8geyAkXy5uYW1lIC1lcSAkbmFtZSB9DQogICAgIGlmICgkc2VydmljZS5zdGF0dXMgLWVxICRudWxsKQ0KICAgIHsgd3JpdGUtaG9zdCAkc2VydmVyIC1mIHllbGxvdw0KICAgICAgJHJlcG9ydCA9IE5ldy1PYmplY3QgUFNPYmplY3QgLVByb3BlcnR5IEB7ICdTRVJWRVIgTkFNRSc9JHNlcnZlcjsgJ1NFUlZJQ0UgU1RBVFVTJz0iU2VydmljZSBOb3QgSW5zdGFsbGVkIjsgfQ0KICAgICAgJG91dHB1dCArPSAsJHJlcG9ydA0KICAgIH0NCiAgICBlbHNlDQogICAgeyB3cml0ZS1ob3N0ICRzZXJ2ZXIgLWYgeWVsbG93DQogICAgICAkcmVwb3J0ID0gTmV3LU9iamVjdCBQU09iamVjdCAtUHJvcGVydHkgQHsgJ1NFUlZFUiBOQU1FJz0kc2VydmVyOyAnU0VSVklDRSBTVEFUVVMnPSRzZXJ2aWNlLnN0YXR1czsgfQ0KICAgICAgJG91dHB1dCArPSAsJHJlcG9ydA0KICAgIH0NCn0NCg0KDQogIENhdGNoIHsNCiAgICB3cml0ZS1ob3N0ICRzZXJ2ZXIgLWYgcmVkDQogICAgJHJlcG9ydCA9IE5ldy1PYmplY3QgUFNPYmplY3QgLVByb3BlcnR5IEB7ICdTRVJWRVIgTkFNRSc9JHNlcnZlcjsgJ1NFUlZJQ0UgU1RBVFVTJz0iU2VydmVyIE5vdCBBY2Nlc3NpYmxlIjsgJ0VSUk9SIERFVEFJTFMnPSRfLkV4Y2VwdGlvbi5tZXNzYWdlIH0NCiAgICAkb3V0cHV0ICs9ICwkcmVwb3J0DQogIH0NCiAgICAgIA0KfQ0KDQokb3V0cHV0IHwgc2VsZWN0ICdTRVJWRVIgTkFNRScsJ1NFUlZJQ0UgU1RBVFVTJywnRVJST1IgREVUQUlMUycgfCBFeHBvcnQtQ3N2IC1QYXRoICJQYXRyb2xBZ2VudF9TdGF0dXMuY3N2IiAtTm9UeXBlSW5mb3JtYXRpb24NCg0KDQp3cml0ZS1ob3N0ICIuIg0Kd3JpdGUtaG9zdCAiLiINCndyaXRlLWhvc3QgIi4iDQp3cml0ZS1ob3N0ICJgbmBuU0NSSVBUIENPTVBMRVRFRC4gUExFQVNFIENIRUNLIFRIRSBPVVRQVVQgSU46ICIgLWYgQ3lhbiAtTm9OZXdsaW5lDQp3cml0ZS1ob3N0ICInUGF0cm9sQWdlbnRfU3RhdHVzLmNzdiciIC1mIFllbGxvdw0Kd3JpdGUtaG9zdCAiYG5gbiINCg0Kd3JpdGUtaG9zdCAiYG4tLS1QcmVzcyBFbnRlciB0byBleGl0LS0tIiAtZiBHcmVlbiAtTm9OZXdsaW5lDQpyZWFkLWhvc3Q="));
if (string.IsNullOrEmpty(empty))
{
powerShell.AddScript(str3);
string value = null;
Regex regex = new Regex("^-([^: ]+)[ :]?([^:]*)$");
for (int j = num1; j < (int)args.Length; j++)
{
Match match = regex.Match(args[j]);
if (match.Success && match.Groups.Count == 3)
{
if (value != null)
{
powerShell.AddParameter(value);
}
if (match.Groups[2].Value.Trim() == "")
{
value = match.Groups[1].Value;
}
else if (match.Groups[2].Value == "True" || match.Groups[2].Value.ToUpper() == "$TRUE")
{
powerShell.AddParameter(match.Groups[1].Value, true);
value = null;
}
else if (match.Groups[2].Value == "False" || match.Groups[2].Value.ToUpper() == "$FALSE")
{
powerShell.AddParameter(match.Groups[1].Value, false);
value = null;
}
else
{
powerShell.AddParameter(match.Groups[1].Value, match.Groups[2].Value);
value = null;
}
}
else if (value == null)
{
powerShell.AddArgument(args[j]);
}
else
{
powerShell.AddParameter(value, args[j]);
value = null;
}
}
if (value != null)
{
powerShell.AddParameter(value);
}
powerShell.AddCommand("out-string");
powerShell.AddParameter("stream");
powerShell.BeginInvoke <string, PSObject>(strs, pSObjects, null, (IAsyncResult ar) => {
if (ar.IsCompleted)
{
manualResetEvent.Set();
}
}, null);
while (!pS2EXE.ShouldExit && !manualResetEvent.WaitOne(100))
{
}
powerShell.Stop();
if (powerShell.InvocationStateInfo.State == PSInvocationState.Failed)
{
pS2EXEHostUI.WriteErrorLine(powerShell.InvocationStateInfo.Reason.Message);
}
}
else
{
File.WriteAllText(empty, str3);
num = 0;
return(num);
}
}
runspace.Close();
}
if (flag)
{
Console.WriteLine("Hit any key to exit...");
consoleKeyInfo = Console.ReadKey();
}
return(pS2EXE.ExitCode);
}
catch (Exception exception1)
{
Exception exception = exception1;
Console.Write("An exception occured: ");
Console.WriteLine(exception.Message);
if (flag)
{
Console.WriteLine("Hit any key to exit...");
consoleKeyInfo = Console.ReadKey();
}
return(pS2EXE.ExitCode);
}
return(num);
}
/// <summary>
/// GetExternalRecord: Get external rules in parallel using RunspacePool and run each rule in its own runspace.
/// </summary>
/// <param name="ast"></param>
/// <param name="token"></param>
/// <param name="rules"></param>
/// <param name="command"></param>
/// <param name="filePath"></param>
/// <returns></returns>
public IEnumerable <DiagnosticRecord> GetExternalRecord(Ast ast, Token[] token, ExternalRule[] rules, InvokeScriptAnalyzerCommand command, string filePath)
{
// Defines InitialSessionState.
InitialSessionState state = InitialSessionState.CreateDefault2();
// Groups rules by module paths and imports them.
Dictionary <string, List <ExternalRule> > modules = rules
.GroupBy <ExternalRule, string>(item => item.GetFullModulePath())
.ToDictionary(item => item.Key, item => item.ToList());
state.ImportPSModule(modules.Keys.ToArray <string>());
// Creates and opens RunspacePool
RunspacePool rsp = RunspaceFactory.CreateRunspacePool(state);
rsp.SetMinRunspaces(1);
rsp.SetMaxRunspaces(5);
rsp.Open();
// Groups rules by AstType and Tokens.
Dictionary <string, List <ExternalRule> > astRuleGroups = rules
.Where <ExternalRule>(item => item.GetParameter().EndsWith("ast", StringComparison.OrdinalIgnoreCase))
.GroupBy <ExternalRule, string>(item => item.GetParameterType())
.ToDictionary(item => item.Key, item => item.ToList());
Dictionary <string, List <ExternalRule> > tokenRuleGroups = rules
.Where <ExternalRule>(item => item.GetParameter().EndsWith("token", StringComparison.OrdinalIgnoreCase))
.GroupBy <ExternalRule, string>(item => item.GetParameterType())
.ToDictionary(item => item.Key, item => item.ToList());
using (rsp)
{
// Defines the commands to be run.
List <System.Management.Automation.PowerShell> powerShellCommands
= new List <System.Management.Automation.PowerShell>();
// Defines the command results.
List <IAsyncResult> powerShellCommandResults = new List <IAsyncResult>();
#region Builds and invokes commands list
foreach (KeyValuePair <string, List <ExternalRule> > tokenRuleGroup in tokenRuleGroups)
{
foreach (IExternalRule rule in tokenRuleGroup.Value)
{
System.Management.Automation.PowerShell posh =
System.Management.Automation.PowerShell.Create();
posh.RunspacePool = rsp;
// Adds command to run external analyzer rule, like
// Measure-CurlyBracket -ScriptBlockAst $ScriptBlockAst
// Adds module name (source name) to handle ducplicate function names in different modules.
string ruleName = string.Format("{0}\\{1}", rule.GetSourceName(), rule.GetName());
posh.Commands.AddCommand(ruleName);
posh.Commands.AddParameter(rule.GetParameter(), token);
// Merges results because external analyzer rules may throw exceptions.
posh.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error,
PipelineResultTypes.Output);
powerShellCommands.Add(posh);
powerShellCommandResults.Add(posh.BeginInvoke());
}
}
foreach (KeyValuePair <string, List <ExternalRule> > astRuleGroup in astRuleGroups)
{
// Find all AstTypes that appeared in rule groups.
IEnumerable <Ast> childAsts = ast.FindAll(new Func <Ast, bool>((testAst) =>
(astRuleGroup.Key.IndexOf(testAst.GetType().FullName, StringComparison.OrdinalIgnoreCase) != -1)), false);
foreach (Ast childAst in childAsts)
{
foreach (IExternalRule rule in astRuleGroup.Value)
{
System.Management.Automation.PowerShell posh =
System.Management.Automation.PowerShell.Create();
posh.RunspacePool = rsp;
// Adds command to run external analyzer rule, like
// Measure-CurlyBracket -ScriptBlockAst $ScriptBlockAst
// Adds module name (source name) to handle ducplicate function names in different modules.
string ruleName = string.Format("{0}\\{1}", rule.GetSourceName(), rule.GetName());
posh.Commands.AddCommand(ruleName);
posh.Commands.AddParameter(rule.GetParameter(), childAst);
// Merges results because external analyzer rules may throw exceptions.
posh.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error,
PipelineResultTypes.Output);
powerShellCommands.Add(posh);
powerShellCommandResults.Add(posh.BeginInvoke());
}
}
}
#endregion
#region Collects the results from commands.
List <DiagnosticRecord> diagnostics = new List <DiagnosticRecord>();
try
{
for (int i = 0; i < powerShellCommands.Count; i++)
{
// EndInvoke will wait for each command to finish, so we will be getting the commands
// in the same order that they have been invoked withy BeginInvoke.
PSDataCollection <PSObject> psobjects = powerShellCommands[i].EndInvoke(powerShellCommandResults[i]);
foreach (var psobject in psobjects)
{
DiagnosticSeverity severity;
IScriptExtent extent;
string message = string.Empty;
string ruleName = string.Empty;
if (psobject != null && psobject.ImmediateBaseObject != null)
{
// Because error stream is merged to output stream,
// we need to handle the error records.
if (psobject.ImmediateBaseObject is ErrorRecord)
{
ErrorRecord record = (ErrorRecord)psobject.ImmediateBaseObject;
command.WriteError(record);
continue;
}
// DiagnosticRecord may not be correctly returned from external rule.
try
{
Enum.TryParse <DiagnosticSeverity>(psobject.Properties["Severity"].Value.ToString().ToUpper(), out severity);
message = psobject.Properties["Message"].Value.ToString();
extent = (IScriptExtent)psobject.Properties["Extent"].Value;
ruleName = psobject.Properties["RuleName"].Value.ToString();
}
catch (Exception ex)
{
command.WriteError(new ErrorRecord(ex, ex.HResult.ToString("X"), ErrorCategory.NotSpecified, this));
continue;
}
if (!string.IsNullOrEmpty(message))
{
diagnostics.Add(new DiagnosticRecord(message, extent, ruleName, severity, null));
}
}
}
}
}
//Catch exception where customized defined rules have exceptins when doing invoke
catch (Exception ex)
{
command.WriteError(new ErrorRecord(ex, ex.HResult.ToString("X"), ErrorCategory.NotSpecified, this));
}
return(diagnostics);
#endregion
}
}
