internal static PSDataCollection <object> Serialize(IEnumerable collection)
{
PSDataCollection <object> psdataCollection = new PSDataCollection <object>();
if (collection != null)
{
foreach (object obj in collection)
{
if (MonadCommand.CanSerialize(obj))
{
psdataCollection.Add(MonadCommand.Serialize(obj));
}
else if (obj is Enum)
{
psdataCollection.Add(obj.ToString());
}
else
{
psdataCollection.Add(obj);
}
}
}
psdataCollection.Complete();
return(psdataCollection);
}
public void ProcessData_WhenSenderIsPSDataCollection_RemovesItemFromCollection()
{
var sender = new PSDataCollection <string>();
var expected = "string0";
sender.Add(expected);
sender.Add("string1");
PwshRunner.ProcessData <string>(sender, 0, o => { });
Assert.Single(sender);
Assert.DoesNotContain(sender, o => expected.Equals(o));
}
private void ValidateAndThrowRunspaceOpenModuleLoadException(PowerShell pse, List <ErrorRecord> errors, bool startLifeCycleEventWritten, string moduleName, RunspaceOpenModuleLoadException exception)
{
if (this.InitialSessionState.ThrowOnRunspaceOpenError)
{
RunspaceOpenModuleLoadException exception2 = null;
if (exception != null)
{
exception2 = exception;
}
else if ((pse.Streams.Error.Count > 0) || (errors.Count > 0))
{
ErrorRecord record;
Exception exception3;
PSDataCollection <ErrorRecord> datas = new PSDataCollection <ErrorRecord>();
if (errors.Count > 0)
{
record = errors[0];
exception3 = record.Exception;
foreach (ErrorRecord record2 in errors)
{
datas.Add(record2);
}
}
else
{
record = pse.Streams.Error[0];
exception3 = record.Exception;
foreach (ErrorRecord record3 in pse.Streams.Error)
{
datas.Add(record3);
}
}
runspaceInitTracer.WriteLine("Runspace open failed while loading module '{0}': First error {1}", new object[] { moduleName, exception3 });
exception2 = new RunspaceOpenModuleLoadException(moduleName, datas);
}
if (exception2 != null)
{
this.LogEngineHealthEvent(exception2);
if (startLifeCycleEventWritten)
{
MshLog.LogEngineLifecycleEvent(this._engine.Context, EngineState.Stopped);
}
base.SetRunspaceState(RunspaceState.Broken, exception2);
base.RaiseRunspaceStateEvents();
throw exception2;
}
}
}
public static string ExtractErrorFromErrorRecord(this Runspace runspace, ErrorRecord record)
{
Pipeline pipeline = runspace.CreatePipeline("$input", false);
pipeline.Commands.Add("out-string");
Collection<PSObject> result;
using (PSDataCollection<object> inputCollection = new PSDataCollection<object>())
{
inputCollection.Add(record);
inputCollection.Complete();
result = pipeline.Invoke(inputCollection);
}
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
// Remove \r\n, which is added by the Out-String cmdlet.
return str.Substring(0, str.Length - 2);
}
}
return String.Empty;
}
public async void RunScript_ReadsDataFromInputStream()
{
var lf = TestLoggerFactory.Create();
var script = @"$Input | ForEach { Write-Output $_ }";
var expected = new[] { 32, 120, 71, 89, 20 };
var input = new PSDataCollection <PSObject>(5);
_ = Task.Run(
() =>
{
foreach (var num in expected)
{
input.Add(num);
Thread.Sleep(num);
}
input.Complete();
}
);
var result = await PwshRunner.RunScript(script, lf.CreateLogger("Test"), null, input);
var actual = result.Select(o => (int)o.BaseObject).ToArray();
Assert.Equal(expected, actual);
}
/// <summary>
/// Processes records from the input pipeline.
/// For each input object, the command encrypts
/// and exports the object.
/// </summary>
protected override void ProcessRecord()
{
if (string.Equals("ByContent", this.ParameterSetName, StringComparison.OrdinalIgnoreCase))
{
_inputObjects.Add(Content);
}
}
public string ExtractErrorFromErrorRecord(ErrorRecord record)
{
Pipeline pipeline = _runspace.CreatePipeline(command: "$input", addToHistory: false);
pipeline.Commands.Add("out-string");
Collection <PSObject> result;
using (var inputCollection = new PSDataCollection <object>())
{
inputCollection.Add(record);
inputCollection.Complete();
result = InvokeCore(pipeline, inputCollection);
}
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
// Remove \r\n, which is added by the Out-String cmdlet.
return(str.TrimEnd(new[] { '\r', '\n' }));
}
}
return(String.Empty);
}
/// <summary>
/// InjectInput
/// </summary>
/// <param name="psObject"></param>
public void InjectInput(PSObject psObject)
{
if (psObject != null)
{
_input.Add(psObject);
}
}
public static string ExtractErrorFromErrorRecord(this Runspace runspace, ErrorRecord record)
{
Pipeline pipeline = runspace.CreatePipeline("$input", false);
pipeline.Commands.Add("out-string");
Collection <PSObject> result;
using (PSDataCollection <object> inputCollection = new PSDataCollection <object>()) {
inputCollection.Add(record);
inputCollection.Complete();
result = pipeline.Invoke(inputCollection);
}
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
// Remove \r\n, which is added by the Out-String cmdlet.
return(str.Substring(0, str.Length - 2));
}
}
return(String.Empty);
}
/// <summary>
/// Starts the pipeline script async.
/// </summary>
public void BeginInvoke(Queue<PSObject> queue, int count)
{
var input = new PSDataCollection<PSObject>(count);
while (--count >= 0)
input.Add(queue.Dequeue());
input.Complete();
_async = _posh.BeginInvoke(input);
}
/// <inheritdoc />
protected override async Task <Result <Array <Entity>, IError> > Run(
IStateMonad stateMonad,
CancellationToken cancellationToken)
{
var script = await Script.Run(stateMonad, cancellationToken).Map(x => x.GetStringAsync());
if (script.IsFailure)
{
return(script.ConvertFailure <Array <Entity> >());
}
Entity?vars = null;
if (Variables != null)
{
var variables = await Variables.Run(stateMonad, cancellationToken);
if (variables.IsFailure)
{
return(variables.ConvertFailure <Array <Entity> >());
}
vars = variables.Value;
}
PSDataCollection <PSObject>?input = null;
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
async ValueTask <Result <Unit, IError> > AddObject(Entity x, CancellationToken ct)
{
input.Add(PwshRunner.PSObjectFromEntity(x));
return(Unit.Default);
}
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
if (Input != null)
{
var inputStream = await Input.Run(stateMonad, cancellationToken);
if (inputStream.IsFailure)
{
return(inputStream.ConvertFailure <Array <Entity> >());
}
input = new PSDataCollection <PSObject>();
_ = inputStream.Value.ForEach(AddObject, cancellationToken)
.ContinueWith(_ => input.Complete(), cancellationToken);
}
var stream = PwshRunner.GetEntityEnumerable(script.Value, stateMonad.Logger, vars, input)
.ToSCLArray();
return(stream);
}
/// <summary>
/// To display an exception using the display formatter,
/// run a second pipeline passing in the error record.
/// The runtime will bind this to the $input variable,
/// which is why $input is being piped to the Out-String
/// cmdlet. The WriteErrorLine method is called to make sure
/// the error gets displayed in the correct error color.
/// </summary>
/// <param name="e">The exception to display.</param>
private void ReportException(Exception e)
{
if (e != null)
{
object error;
IContainsErrorRecord icer = e as IContainsErrorRecord;
if (icer != null)
{
error = icer.ErrorRecord;
}
else
{
error = (object)new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null);
}
lock (this.instanceLock)
{
this.currentPowerShell = PowerShell.Create();
}
this.currentPowerShell.Runspace = this.myRunSpace;
try
{
this.currentPowerShell.AddScript("$input").AddCommand("out-string");
// Do not merge errors, this function will swallow errors.
Collection <PSObject> result;
PSDataCollection <object> inputCollection = new PSDataCollection <object>();
inputCollection.Add(error);
inputCollection.Complete();
result = this.currentPowerShell.Invoke(inputCollection);
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
// Remove \r\n, which is added by the Out-String cmdlet.
this.myHost.UI.WriteErrorLine(str.Substring(0, str.Length - 2));
}
}
}
finally
{
// Dispose of the pipeline and set it to null, locking it because
// currentPowerShell may be accessed by the ctrl-C handler.
lock (this.instanceLock)
{
this.currentPowerShell.Dispose();
this.currentPowerShell = null;
}
}
}
}
/// <summary>
/// Starts the pipeline script async.
/// </summary>
public void BeginInvoke(Queue <PSObject> queue, int count)
{
var input = new PSDataCollection <PSObject>(count);
while (--count >= 0)
{
input.Add(queue.Dequeue());
}
input.Complete();
_async = _posh.BeginInvoke(input);
}
public void ProcessData_WhenSenderIsPSDataCollection_InvokesAction()
{
var sender = new PSDataCollection <object>();
var str = "";
var mock = new Mock <Action <object> >();
sender.Add(str);
PwshRunner.ProcessData <object>(sender, 0, mock.Object);
mock.Verify(m => m.Invoke(str));
}
void Debug_DataAdded(object sender, DataAddedEventArgs e)
{
PSDataCollection <DebugRecord> collection = sender as PSDataCollection <DebugRecord>;
lastDebug = collection[e.Index];
PSObject psObj = new PSObject(lastDebug);
PSPropertyInfo propInfo = new PSNoteProperty("TimeStamp", DateTime.Now);
psObj.Properties.Add(new PSNoteProperty("Stream", "Debug"));
psObj.Properties.Add(propInfo);
timeStampedOutput.Add(psObj);
if (Dispatcher != null)
{
RunOnUIThread(
new DispatcherOperationCallback(
delegate
{
NotifyDebugChanged();
return(null);
}),
true);
}
else
{
NotifyDebugChanged();
}
}
private void ReportException(Exception e)
{
if (e != null)
{
object error;
IContainsErrorRecord icer = e as IContainsErrorRecord;
if (icer != null)
{
error = icer.ErrorRecord;
}
else
{
error = (object)new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null);
}
lock (this.instanceLock)
{
this.currentPowerShell = PowerShell.Create();
}
this.currentPowerShell.Runspace = this.myRunSpace;
try
{
this.currentPowerShell.AddScript("$input").AddCommand("out-string");
Collection <PSObject> result;
PSDataCollection <object> inputCollection = new PSDataCollection <object>();
inputCollection.Add(error);
inputCollection.Complete();
result = this.currentPowerShell.Invoke(inputCollection);
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
this.myHost.UI.WriteErrorLine(str.Substring(0, str.Length - 2));
}
}
}
finally
{
lock (this.instanceLock)
{
this.currentPowerShell.Dispose();
this.currentPowerShell = null;
}
}
}
}
void CallPasswordScript(PasswordOperation Action, CSEntry csentry, SecureString oldPassword, SecureString newPassword, PasswordOptions options)
{
Tracer.Enter("callpasswordscript");
PSDataCollection <PSObject> passwordPipeline = new PSDataCollection <PSObject>();
try
{
Command cmd = new Command(Path.GetFullPath(PasswordManagementScript));
cmd.Parameters.Add(new CommandParameter("Username", Username));
cmd.Parameters.Add(new CommandParameter("Password", Password));
cmd.Parameters.Add(new CommandParameter("Credentials", GetSecureCredentials(Username, SecureStringPassword)));
cmd.Parameters.Add(new CommandParameter("AuxUsernameAux", UsernameAux));
cmd.Parameters.Add(new CommandParameter("AuxPasswordAux", PasswordAux));
cmd.Parameters.Add(new CommandParameter("AuxCredentialsAux", GetSecureCredentials(UsernameAux, SecureStringPasswordAux)));
cmd.Parameters.Add(new CommandParameter("ConfigurationParameter", ConfigurationParameter));
cmd.Parameters.Add(new CommandParameter("Action", Action.ToString()));
if (options.HasFlag(PasswordOptions.UnlockAccount))
{
cmd.Parameters.Add(new CommandParameter("UnlockAccount"));
}
if (options.HasFlag(PasswordOptions.ForceChangeAtLogOn))
{
cmd.Parameters.Add(new CommandParameter("ForceChangeAtLogOn"));
}
if (options.HasFlag(PasswordOptions.ValidatePassword))
{
cmd.Parameters.Add(new CommandParameter("ValidatePassword"));
}
cmd.Parameters.Add(new CommandParameter("NewPassword", newPassword.ConvertToUnsecureString()));
if (Action == PasswordOperation.Change)
{
cmd.Parameters.Add(new CommandParameter("OldPassword", oldPassword.ConvertToUnsecureString()));
}
passwordPipeline.Add(new PSObject(csentry));
passwordResults = InvokePowerShellScript(cmd, passwordPipeline);
}
catch (Exception ex)
{
Tracer.TraceError("callpasswordscript", ex);
throw;
}
finally
{
passwordPipeline = null;
Tracer.TraceInformation("callpasswordscript");
}
}
private void HandleResultsDataAdding(object sender, DataAddingEventArgs dataAddingArgs)
{
if (_debugCollection.IsOpen)
{
PSStreamObject streamObject = dataAddingArgs.ItemAdded as PSStreamObject;
if (streamObject != null)
{
try
{
_debugCollection.Add(streamObject);
}
catch (PSInvalidOperationException) { }
}
}
}
private PSDataCollection <T> CopyResults <T>(ICollection <T> fromResults)
{
if (fromResults != null && fromResults.Count > 0)
{
PSDataCollection <T> returnResults = new PSDataCollection <T>();
foreach (var item in fromResults)
{
returnResults.Add(item);
}
return(returnResults);
}
return(null);
}
private PSDataCollection <T> CopyResults <T>(ICollection <T> fromResults)
{
if (fromResults == null || fromResults.Count <= 0)
{
return(null);
}
else
{
PSDataCollection <T> ts = new PSDataCollection <T>();
foreach (T fromResult in fromResults)
{
ts.Add(fromResult);
}
return(ts);
}
}
private void AddToDebugBlockingCollection(PSStreamObject streamItem)
{
if (!_debugBlockingCollection.IsOpen)
{
return;
}
if (streamItem != null)
{
try
{
_debugBlockingCollection.Add(streamItem);
}
catch (PSInvalidOperationException) { }
}
}
private void OnData(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action != NotifyCollectionChangedAction.Add)
{
return;
}
PSDataCollection <object> input = new PSDataCollection <object>();
foreach (var ci in e.NewItems)
{
input.Add(ci);
}
Interlocked.Exchange(ref _currentInput, input);
RaiseTrigger();
}
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;
}
private void ReportException(Exception e)
{
object error;
if (e is IContainsErrorRecord)
{
error = (e as IContainsErrorRecord).ErrorRecord;
}
else
{
error = new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null);
}
try
{
using (var ps = _host.CreatePowerShell())
{
ps.AddScript("$input").AddCommand("Out-String");
// Do not merge errors, this function will swallow errors.
Collection <PSObject> result;
PSDataCollection <object> inputCollection = new PSDataCollection <object>();
inputCollection.Add(error);
inputCollection.Complete();
result = ps.Invoke(inputCollection);
if (result.Any())
{
var str = result.First().BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
_host.UI.WriteErrorLine(str.Substring(0, str.Length - 2));
}
}
}
}
catch (Exception ex) // exception reporting might fail, depends on runspace state - just ignore any exception
{
logger.Error(ex);
}
}
private void HandlePowerShellPStreamItem(PSStreamObject streamItem)
{
if (!_debugger.InBreakpoint)
{
// First write any accumulated items.
foreach (var item in _debugAccumulateCollection.ReadAll())
{
AddToDebugBlockingCollection(item);
}
// Handle new item.
if ((_debugBlockingCollection != null) && (_debugBlockingCollection.IsOpen))
{
AddToDebugBlockingCollection(streamItem);
}
}
else if (_debugAccumulateCollection.IsOpen)
{
// Add to accumulator if debugger is stopped in breakpoint.
_debugAccumulateCollection.Add(streamItem);
}
}
private void HookupHostDataDelegates(ThreadJobHost host)
{
ThreadJobHostUI hostUI = host.UI as ThreadJobHostUI;
System.Diagnostics.Debug.Assert(hostUI != null, "Host UI cannot be null.");
hostUI.Output.DataAdded += (sender, dataAddedEventArgs) =>
{
Collection <PSObject> output = hostUI.Output.ReadAll();
foreach (var item in output)
{
_output.Add(item);
}
};
hostUI.Error.DataAdded += (sender, dataAddedEventArgs) =>
{
Collection <ErrorRecord> error = hostUI.Error.ReadAll();
foreach (var item in error)
{
Error.Add(item);
}
};
}
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);
}
protected virtual DebuggerCommandResults HandlePromptCommand(PSDataCollection<PSObject> output)
{
// Nested debugged runspace prompt should look like:
// [ComputerName]: [DBG]: [Process:<id>]: [RunspaceName]: PS C:\>
string computerName = (_runspace.ConnectionInfo != null) ? _runspace.ConnectionInfo.ComputerName : null;
string processPartPattern = "{0}[{1}:{2}]:{3}";
string processPart = StringUtil.Format(processPartPattern,
@"""",
DebuggerStrings.NestedRunspaceDebuggerPromptProcessName,
@"$($PID)",
@"""");
string locationPart = @"""PS $($executionContext.SessionState.Path.CurrentLocation)> """;
string promptScript = "'[DBG]: '" + " + " + processPart + " + " + "' [" + CodeGeneration.EscapeSingleQuotedStringContent(_runspace.Name) + "]: '" + " + " + locationPart;
// Get the command prompt from the wrapped debugger.
PSCommand promptCommand = new PSCommand();
promptCommand.AddScript(promptScript);
PSDataCollection<PSObject> promptOutput = new PSDataCollection<PSObject>();
_wrappedDebugger.ProcessCommand(promptCommand, promptOutput);
string promptString = (promptOutput.Count == 1) ? promptOutput[0].BaseObject as string : string.Empty;
var nestedPromptString = new System.Text.StringBuilder();
// For remote runspaces display computer name in prompt.
if (!string.IsNullOrEmpty(computerName))
{
nestedPromptString.Append("[" + computerName + "]:");
}
nestedPromptString.Append(promptString);
// Fix up for non-remote runspaces since the runspace is not in a nested prompt
// but the root runspace is.
if (string.IsNullOrEmpty(computerName))
{
nestedPromptString.Insert(nestedPromptString.Length - 1, ">");
}
output.Add(nestedPromptString.ToString());
return new DebuggerCommandResults(null, true);
}
protected override DebuggerCommandResults HandleCallStack(PSDataCollection<PSObject> output)
{
// First get call stack from wrapped debugger
PSCommand cmd = new PSCommand();
cmd.AddCommand("Get-PSCallStack");
PSDataCollection<PSObject> callStackOutput = new PSDataCollection<PSObject>();
_wrappedDebugger.ProcessCommand(cmd, callStackOutput);
// Next get call stack from parent debugger.
PSDataCollection<CallStackFrame> callStack = _rootDebugger.GetCallStack().ToArray();
// Combine call stack info.
foreach (var item in callStack)
{
callStackOutput.Add(new PSObject(item));
}
// Display call stack info as formatted.
using (PowerShell ps = PowerShell.Create())
{
ps.AddCommand("Out-String").AddParameter("Stream", true);
ps.Invoke(callStackOutput, output);
}
return new DebuggerCommandResults(null, true);
}
private static void PowerShellInvocation_ErrorAdding(object sender, DataAddingEventArgs e, HostSettingCommandMetadata commandMetadata, PSDataCollection<PSObject> output)
{
ErrorRecord itemAdded = e.ItemAdded as ErrorRecord;
if (itemAdded != null)
{
if (commandMetadata != null)
{
ScriptPosition scriptPosition = new ScriptPosition(commandMetadata.CommandName, commandMetadata.StartLineNumber, commandMetadata.StartColumnNumber, null);
ScriptPosition scriptPosition1 = new ScriptPosition(commandMetadata.CommandName, commandMetadata.EndLineNumber, commandMetadata.EndColumnNumber, null);
ScriptExtent scriptExtent = new ScriptExtent(scriptPosition, scriptPosition1);
if (itemAdded.InvocationInfo != null)
{
itemAdded.InvocationInfo.DisplayScriptPosition = scriptExtent;
}
}
if (output != null)
{
output.Add(PSObject.AsPSObject(itemAdded));
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="name"></param>
/// <param name="command"></param>
/// <param name="sb"></param>
/// <param name="filePath"></param>
/// <param name="initSb"></param>
/// <param name="argumentList"></param>
/// <param name="inputObject"></param>
/// <param name="psCmdlet"></param>
/// <param name="currentLocationPath"></param>
/// <param name="streamingHost"></param>
public ThreadJob(
string name,
string command,
ScriptBlock sb,
string filePath,
ScriptBlock initSb,
object[] argumentList,
PSObject inputObject,
PSCmdlet psCmdlet,
string currentLocationPath,
PSHost streamingHost)
: base(command, name)
{
_sb = sb;
_filePath = filePath;
_initSb = initSb;
_argumentList = argumentList;
_input = new PSDataCollection <object>();
if (inputObject != null)
{
_input.Add(inputObject);
}
_output = new PSDataCollection <PSObject>();
_streamingHost = streamingHost;
_currentLocationPath = currentLocationPath;
this.PSJobTypeName = "ThreadJob";
// Get script block to run.
if (!string.IsNullOrEmpty(_filePath))
{
_sb = GetScriptBlockFromFile(_filePath, psCmdlet);
if (_sb == null)
{
throw new InvalidOperationException(Properties.Resources.CannotParseScriptFile);
}
}
else if (_sb == null)
{
throw new PSArgumentNullException(Properties.Resources.NoScriptToRun);
}
// Create Runspace/PowerShell object and state callback.
// The job script/command will run in a separate thread associated with the Runspace.
var iss = InitialSessionState.CreateDefault2();
// Determine session language mode for Windows platforms
WarningRecord lockdownWarning = null;
if (Environment.OSVersion.Platform.ToString().Equals("Win32NT", StringComparison.OrdinalIgnoreCase))
{
bool enforceLockdown = (SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce);
if (enforceLockdown && !string.IsNullOrEmpty(_filePath))
{
// If script source is a file, check to see if it is trusted by the lock down policy
enforceLockdown = (SystemPolicy.GetLockdownPolicy(_filePath, null) == SystemEnforcementMode.Enforce);
if (!enforceLockdown && (_initSb != null))
{
// Even if the script file is trusted, an initialization script cannot be trusted, so we have to enforce
// lock down. Otherwise untrusted script could be run in FullLanguage mode along with the trusted file script.
enforceLockdown = true;
lockdownWarning = new WarningRecord(
string.Format(
CultureInfo.InvariantCulture,
Properties.Resources.CannotRunTrustedFileInFL,
_filePath));
}
}
iss.LanguageMode = enforceLockdown ? PSLanguageMode.ConstrainedLanguage : PSLanguageMode.FullLanguage;
}
if (_streamingHost != null)
{
_rs = RunspaceFactory.CreateRunspace(_streamingHost, iss);
}
else
{
_rs = RunspaceFactory.CreateRunspace(iss);
}
_ps = PowerShell.Create();
_ps.Runspace = _rs;
_ps.InvocationStateChanged += (sender, psStateChanged) =>
{
var newStateInfo = psStateChanged.InvocationStateInfo;
// Update Job state.
switch (newStateInfo.State)
{
case PSInvocationState.Running:
SetJobState(JobState.Running);
break;
case PSInvocationState.Stopped:
SetJobState(JobState.Stopped, newStateInfo.Reason, disposeRunspace: true);
break;
case PSInvocationState.Failed:
SetJobState(JobState.Failed, newStateInfo.Reason, disposeRunspace: true);
break;
case PSInvocationState.Completed:
if (_runningInitScript)
{
// Begin running main script.
_runningInitScript = false;
RunScript();
}
else
{
SetJobState(JobState.Completed, newStateInfo.Reason, disposeRunspace: true);
}
break;
}
};
// Get any using variables.
var usingAsts = _sb.Ast.FindAll(ast => ast is UsingExpressionAst, searchNestedScriptBlocks: true).Cast <UsingExpressionAst>();
if (usingAsts != null &&
usingAsts.FirstOrDefault() != null)
{
// Get using variables as dictionary, since we now only support PowerShell version 5.1 and greater
_usingValuesMap = GetUsingValuesAsDictionary(usingAsts, psCmdlet);
}
// Hook up data streams.
this.Output = _output;
this.Output.EnumeratorNeverBlocks = true;
this.Error = _ps.Streams.Error;
this.Error.EnumeratorNeverBlocks = true;
this.Progress = _ps.Streams.Progress;
this.Progress.EnumeratorNeverBlocks = true;
this.Verbose = _ps.Streams.Verbose;
this.Verbose.EnumeratorNeverBlocks = true;
this.Warning = _ps.Streams.Warning;
this.Warning.EnumeratorNeverBlocks = true;
if (lockdownWarning != null)
{
this.Warning.Add(lockdownWarning);
}
this.Debug = _ps.Streams.Debug;
this.Debug.EnumeratorNeverBlocks = true;
this.Information = _ps.Streams.Information;
this.Information.EnumeratorNeverBlocks = true;
// Create the JobManager job definition and job specification, and add to the JobManager.
ThreadJobDefinition = new JobDefinition(typeof(ThreadJobSourceAdapter), "", Name);
Dictionary <string, object> parameterCollection = new Dictionary <string, object>();
parameterCollection.Add("NewJob", this);
var jobSpecification = new JobInvocationInfo(ThreadJobDefinition, parameterCollection);
var newJob = psCmdlet.JobManager.NewJob(jobSpecification);
System.Diagnostics.Debug.Assert(newJob == this, "JobManager must return this job");
}
public string ExtractErrorFromErrorRecord(ErrorRecord record)
{
Pipeline pipeline = _runspace.CreatePipeline(command: "$input", addToHistory: false);
pipeline.Commands.Add("out-string");
Collection<PSObject> result;
using (var inputCollection = new PSDataCollection<object>())
{
inputCollection.Add(record);
inputCollection.Complete();
result = InvokeCore(pipeline, inputCollection);
}
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
// Remove \r\n, which is added by the Out-String cmdlet.
return str.TrimEnd(new[] { '\r', '\n' });
}
}
return String.Empty;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="name"></param>
/// <param name="command"></param>
/// <param name="sb"></param>
/// <param name="filePath"></param>
/// <param name="initSb"></param>
/// <param name="argumentList"></param>
/// <param name="inputObject"></param>
/// <param name="psCmdlet"></param>
public ThreadJob(
string name,
string command,
ScriptBlock sb,
string filePath,
ScriptBlock initSb,
object[] argumentList,
PSObject inputObject,
PSCmdlet psCmdlet)
: base(command, name)
{
_sb = sb;
_filePath = filePath;
_initSb = initSb;
_argumentList = argumentList;
_input = new PSDataCollection <object>();
if (inputObject != null)
{
_input.Add(inputObject);
}
_output = new PSDataCollection <PSObject>();
this.PSJobTypeName = "ThreadJob";
// Create host object for thread jobs.
ThreadJobHost host = new ThreadJobHost();
HookupHostDataDelegates(host);
// Create Runspace/PowerShell object and state callback.
// The job script/command will run in a separate thread associated with the Runspace.
_rs = RunspaceFactory.CreateRunspace(host);
_ps = PowerShell.Create();
_ps.Runspace = _rs;
_ps.InvocationStateChanged += (sender, psStateChanged) =>
{
var newStateInfo = psStateChanged.InvocationStateInfo;
// Update Job state.
switch (newStateInfo.State)
{
case PSInvocationState.Running:
SetJobState(JobState.Running);
break;
case PSInvocationState.Stopped:
SetJobState(JobState.Stopped, newStateInfo.Reason, disposeRunspace: true);
break;
case PSInvocationState.Failed:
SetJobState(JobState.Failed, newStateInfo.Reason, disposeRunspace: true);
break;
case PSInvocationState.Completed:
if (_runningInitScript)
{
// Begin running main script.
_runningInitScript = false;
RunScript();
}
else
{
SetJobState(JobState.Completed, newStateInfo.Reason, disposeRunspace: true);
}
break;
}
};
// Get script block to run.
if (!string.IsNullOrEmpty(_filePath))
{
_sb = GetScriptBlockFromFile(_filePath, psCmdlet);
if (_sb == null)
{
throw new InvalidOperationException(Properties.Resources.ResourceManager.GetString("CannotParseScriptFile"));
}
}
else if (_sb == null)
{
throw new PSArgumentNullException(Properties.Resources.ResourceManager.GetString("NoScriptToRun"));
}
// Get any using variables.
var usingAsts = _sb.Ast.FindAll(ast => ast is UsingExpressionAst, searchNestedScriptBlocks: true).Cast <UsingExpressionAst>();
if (usingAsts != null &&
usingAsts.FirstOrDefault() != null)
{
// Get using variables as an array or dictionary, depending on PowerShell version.
if (psCmdlet.Host.Version.Major >= 5)
{
_usingValuesMap = GetUsingValuesAsDictionary(usingAsts, psCmdlet);
}
else if (psCmdlet.Host.Version.Major == 3 || psCmdlet.Host.Version.Major == 4)
{
_usingValuesArray = GetUsingValuesAsArray(usingAsts, psCmdlet);
}
}
// Hook up data streams.
this.Output = _output;
this.Output.EnumeratorNeverBlocks = true;
this.Error = _ps.Streams.Error;
this.Error.EnumeratorNeverBlocks = true;
this.Progress = _ps.Streams.Progress;
this.Progress.EnumeratorNeverBlocks = true;
this.Verbose = _ps.Streams.Verbose;
this.Verbose.EnumeratorNeverBlocks = true;
this.Warning = _ps.Streams.Warning;
this.Warning.EnumeratorNeverBlocks = true;
this.Debug = _ps.Streams.Debug;
this.Debug.EnumeratorNeverBlocks = true;
// Create the JobManager job definition and job specification, and add to the JobManager.
ThreadJobDefinition = new JobDefinition(typeof(ThreadJobSourceAdapter), "", Name);
Dictionary <string, object> parameterCollection = new Dictionary <string, object>();
parameterCollection.Add("NewJob", this);
var jobSpecification = new JobInvocationInfo(ThreadJobDefinition, parameterCollection);
var newJob = psCmdlet.JobManager.NewJob(jobSpecification);
System.Diagnostics.Debug.Assert(newJob == this, "JobManager must return this job");
}
internal static void ContinueCommand(RemoteRunspace remoteRunspace, Pipeline cmd, PSHost host, bool inDebugMode, System.Management.Automation.ExecutionContext context)
{
RemotePipeline remotePipeline = cmd as RemotePipeline;
if (remotePipeline != null)
{
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
PSInvocationSettings settings = new PSInvocationSettings()
{
Host = host
};
PSDataCollection<PSObject> input = new PSDataCollection<PSObject>();
CommandInfo commandInfo = new CmdletInfo("Out-Default", typeof(OutDefaultCommand), null, null, context);
Command outDefaultCommand = new Command(commandInfo);
ps.AddCommand(outDefaultCommand);
IAsyncResult async = ps.BeginInvoke<PSObject>(input, settings, null, null);
RemoteDebugger remoteDebugger = remoteRunspace.Debugger as RemoteDebugger;
if (remoteDebugger != null)
{
// Update client with breakpoint information from pushed runspace.
// Information will be passed to the client via the Debugger.BreakpointUpdated event.
remoteDebugger.SendBreakpointUpdatedEvents();
if (!inDebugMode)
{
// Enter debug mode if remote runspace is in debug stop mode.
remoteDebugger.CheckStateAndRaiseStopEvent();
}
}
// Wait for debugged cmd to complete.
while (!remotePipeline.Output.EndOfPipeline)
{
remotePipeline.Output.WaitHandle.WaitOne();
while (remotePipeline.Output.Count > 0)
{
input.Add(remotePipeline.Output.Read());
}
}
input.Complete();
ps.EndInvoke(async);
}
}
}
private void ValidateAndThrowRunspaceOpenModuleLoadException(PowerShell pse, List<ErrorRecord> errors, bool startLifeCycleEventWritten, string moduleName, RunspaceOpenModuleLoadException exception)
{
if (this.InitialSessionState.ThrowOnRunspaceOpenError)
{
RunspaceOpenModuleLoadException exception2 = null;
if (exception != null)
{
exception2 = exception;
}
else if ((pse.Streams.Error.Count > 0) || (errors.Count > 0))
{
ErrorRecord record;
Exception exception3;
PSDataCollection<ErrorRecord> datas = new PSDataCollection<ErrorRecord>();
if (errors.Count > 0)
{
record = errors[0];
exception3 = record.Exception;
foreach (ErrorRecord record2 in errors)
{
datas.Add(record2);
}
}
else
{
record = pse.Streams.Error[0];
exception3 = record.Exception;
foreach (ErrorRecord record3 in pse.Streams.Error)
{
datas.Add(record3);
}
}
runspaceInitTracer.WriteLine("Runspace open failed while loading module '{0}': First error {1}", new object[] { moduleName, exception3 });
exception2 = new RunspaceOpenModuleLoadException(moduleName, datas);
}
if (exception2 != null)
{
this.LogEngineHealthEvent(exception2);
if (startLifeCycleEventWritten)
{
MshLog.LogEngineLifecycleEvent(this._engine.Context, EngineState.Stopped);
}
base.SetRunspaceState(RunspaceState.Broken, exception2);
base.RaiseRunspaceStateEvents();
throw exception2;
}
}
}
/// <summary>
/// Process debugger command.
/// </summary>
/// <param name="command">Debugger PSCommand</param>
/// <param name="output">Output</param>
/// <returns>DebuggerCommandResults</returns>
public override DebuggerCommandResults ProcessCommand(PSCommand command, PSDataCollection<PSObject> output)
{
CheckForValidateState();
_detachCommand = false;
if (command == null)
{
throw new PSArgumentNullException("command");
}
if (output == null)
{
throw new PSArgumentNullException("output");
}
if (!DebuggerStopped)
{
throw new PSInvalidOperationException(
DebuggerStrings.CannotProcessDebuggerCommandNotStopped,
null,
Debugger.CannotProcessCommandNotStopped,
ErrorCategory.InvalidOperation,
null);
}
DebuggerCommandResults results = null;
// Execute command on server.
bool executionError = false;
using (_psDebuggerCommand = GetNestedPowerShell())
{
foreach (var cmd in command.Commands)
{
cmd.MergeMyResults(PipelineResultTypes.All, PipelineResultTypes.Output);
_psDebuggerCommand.AddCommand(cmd);
}
PSDataCollection<PSObject> internalOutput = new PSDataCollection<PSObject>();
internalOutput.DataAdded += (sender, args) =>
{
foreach (var item in internalOutput.ReadAll())
{
if (item == null) { return; }
DebuggerCommand dbgCmd = item.BaseObject as DebuggerCommand;
if (dbgCmd != null)
{
bool executedByDebugger = (dbgCmd.ResumeAction != null || dbgCmd.ExecutedByDebugger);
results = new DebuggerCommandResults(dbgCmd.ResumeAction, executedByDebugger);
}
else if (item.BaseObject is DebuggerCommandResults)
{
results = item.BaseObject as DebuggerCommandResults;
}
else
{
output.Add(item);
}
}
};
try
{
_psDebuggerCommand.Invoke(null, internalOutput, null);
}
catch (Exception e)
{
CommandProcessor.CheckForSevereException(e);
executionError = true;
RemoteException re = e as RemoteException;
if ((re != null) && (re.ErrorRecord != null))
{
// Allow the IncompleteParseException to throw so that the console
// can handle here strings and continued parsing.
if (re.ErrorRecord.CategoryInfo.Reason == typeof(IncompleteParseException).Name)
{
throw new IncompleteParseException(
(re.ErrorRecord.Exception != null) ? re.ErrorRecord.Exception.Message : null,
re.ErrorRecord.FullyQualifiedErrorId);
}
// Allow the RemoteException and InvalidRunspacePoolStateException to propagate so that the host can
// clean up the debug session.
if ((re.ErrorRecord.CategoryInfo.Reason == typeof(InvalidRunspacePoolStateException).Name) ||
(re.ErrorRecord.CategoryInfo.Reason == typeof(RemoteException).Name))
{
throw new PSRemotingTransportException(
(re.ErrorRecord.Exception != null) ? re.ErrorRecord.Exception.Message : string.Empty);
}
}
// Allow all PSRemotingTransportException and RemoteException errors to propagate as this
// indicates a broken debug session.
if ((e is PSRemotingTransportException) || (e is RemoteException))
{
throw;
}
output.Add(
new PSObject(
new ErrorRecord(
e,
"DebuggerError",
ErrorCategory.InvalidOperation,
null)));
}
}
executionError = executionError || _psDebuggerCommand.HadErrors;
_psDebuggerCommand = null;
// Special processing when the detach command is run.
_detachCommand = (!executionError) && (command.Commands.Count > 0) && (command.Commands[0].CommandText.Equals("Detach", StringComparison.OrdinalIgnoreCase));
return results ?? new DebuggerCommandResults(null, false);
}
/// <summary>
/// Default constructor for creating ServerPowerShellDrivers
/// </summary>
/// <param name="powershell">decoded powershell object</param>
/// <param name="extraPowerShell">extra pipeline to be run after <paramref name="powershell"/> completes</param>
/// <param name="noInput">whether there is input for this powershell</param>
/// <param name="clientPowerShellId">the client powershell id</param>
/// <param name="clientRunspacePoolId">the client runspacepool id</param>
/// <param name="runspacePoolDriver">runspace pool driver
/// which is creating this powershell driver</param>
/// <param name="apartmentState">apartment state for this powershell</param>
/// <param name="hostInfo">host info using which the host for
/// this powershell will be constructed</param>
/// <param name="streamOptions">serialization options for the streams in this powershell</param>
/// <param name="addToHistory">
/// true if the command is to be added to history list of the runspace. false, otherwise.
/// </param>
/// <param name="rsToUse">
/// If not null, this Runspace will be used to invoke Powershell.
/// If null, the RunspacePool pointed by <paramref name="runspacePoolDriver"/> will be used.
/// </param>
/// <param name="output">
/// If not null, this is used as another source of output sent to the client.
/// </param>
internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId,
Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver,
ApartmentState apartmentState, HostInfo hostInfo, RemoteStreamOptions streamOptions,
bool addToHistory, Runspace rsToUse, PSDataCollection<PSObject> output)
#endif
{
InstanceId = clientPowerShellId;
RunspacePoolId = clientRunspacePoolId;
RemoteStreamOptions = streamOptions;
#if !CORECLR // No ApartmentState In CoreCLR
this.apartmentState = apartmentState;
#endif
LocalPowerShell = powershell;
_extraPowerShell = extraPowerShell;
_localPowerShellOutput = new PSDataCollection<PSObject>();
_noInput = noInput;
_addToHistory = addToHistory;
_psDriverInvoker = runspacePoolDriver;
DataStructureHandler = runspacePoolDriver.DataStructureHandler.CreatePowerShellDataStructureHandler(clientPowerShellId, clientRunspacePoolId, RemoteStreamOptions, LocalPowerShell);
_remoteHost = DataStructureHandler.GetHostAssociatedWithPowerShell(hostInfo, runspacePoolDriver.ServerRemoteHost);
if (!noInput)
{
InputCollection = new PSDataCollection<object>();
InputCollection.ReleaseOnEnumeration = true;
InputCollection.IdleEvent += new EventHandler<EventArgs>(HandleIdleEvent);
}
RegisterPipelineOutputEventHandlers(_localPowerShellOutput);
if (LocalPowerShell != null)
{
RegisterPowerShellEventHandlers(LocalPowerShell);
_datasent[0] = false;
}
if (extraPowerShell != null)
{
RegisterPowerShellEventHandlers(extraPowerShell);
_datasent[1] = false;
}
RegisterDataStructureHandlerEventHandlers(DataStructureHandler);
// set the runspace pool and invoke this powershell
if (null != rsToUse)
{
LocalPowerShell.Runspace = rsToUse;
if (extraPowerShell != null)
{
extraPowerShell.Runspace = rsToUse;
}
}
else
{
LocalPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
if (extraPowerShell != null)
{
extraPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
}
}
if (output != null)
{
output.DataAdded += (sender, args) =>
{
if (_localPowerShellOutput.IsOpen)
{
var items = output.ReadAll();
foreach (var item in items)
{
_localPowerShellOutput.Add(item);
}
}
};
}
}
/// <summary>
/// Execution of PowerShell value activity.
/// PowerShell expression will be evaluated using PowerShell runspace and the value of Type T will be returned.
/// </summary>
/// <param name="context"></param>
protected override void Execute(NativeActivityContext context)
{
Token[] tokens;
ParseError[] errors;
ScriptBlockAst exprAst = Parser.ParseInput(Expression, out tokens, out errors);
bool hasErrorActionPreference = false;
bool hasWarningPreference = false;
bool hasInformationPreference = false;
// Custom activity participant tracker for updating debugger with current variables and sequence stop points.
// Regex looks for debugger sequence points like: Expression="'3:5:WFFunc1'".
// We specifically disallow TimeSpan values that look like sequence points: Expression="'00:00:01'".
bool isDebugSequencePoint = (!string.IsNullOrEmpty(Expression) && (System.Text.RegularExpressions.Regex.IsMatch(Expression, @"^'\d+:\d+:\S+'$")) &&
(typeof(T) != typeof(System.TimeSpan)));
var dataProperties = context.DataContext.GetProperties();
if (isDebugSequencePoint || (dataProperties.Count > 0))
{
System.Activities.Tracking.CustomTrackingRecord customRecord = new System.Activities.Tracking.CustomTrackingRecord("PSWorkflowCustomUpdateDebugVariablesTrackingRecord");
foreach (System.ComponentModel.PropertyDescriptor property in dataProperties)
{
if (String.Equals(property.Name, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
{
continue;
}
Object value = property.GetValue(context.DataContext);
if (value != null)
{
object tempValue = value;
PSDataCollection <PSObject> collectionObject = value as PSDataCollection <PSObject>;
if (collectionObject != null && collectionObject.Count == 1)
{
tempValue = collectionObject[0];
}
customRecord.Data.Add(property.Name, tempValue);
}
}
if (isDebugSequencePoint)
{
customRecord.Data.Add("DebugSequencePoint", Expression);
}
context.Track(customRecord);
}
if (tokens != null)
{
foreach (Token token in tokens)
{
VariableToken variable = token as VariableToken;
if (variable != null)
{
if (variable.Name.Equals("ErrorActionPreference", StringComparison.OrdinalIgnoreCase))
{
hasErrorActionPreference = true;
}
else if (variable.Name.Equals("WarningPreference", StringComparison.OrdinalIgnoreCase))
{
hasWarningPreference = true;
}
else if (variable.Name.Equals("InformationPreference", StringComparison.OrdinalIgnoreCase))
{
hasInformationPreference = true;
}
}
}
}
if (string.IsNullOrEmpty(Expression))
{
throw new ArgumentException(ActivityResources.NullArgumentExpression);
}
if (_ci == null)
{
lock (syncroot)
{
// Invoke using the CommandInfo for Invoke-Command directly, rather than going through
// command discovery (which is very slow).
if (_ci == null)
{
_ci = new CmdletInfo("Invoke-Command", typeof(Microsoft.PowerShell.Commands.InvokeCommandCommand));
}
}
}
Collection <PSObject> returnedvalue;
Runspace runspace = null;
bool borrowedRunspace = false;
PSWorkflowHost workflowHost = null;
if (typeof(ScriptBlock).IsAssignableFrom(typeof(T)))
{
Result.Set(context, ScriptBlock.Create(Expression));
return;
}
else if (typeof(ScriptBlock[]).IsAssignableFrom(typeof(T)))
{
Result.Set(context, new ScriptBlock[] { ScriptBlock.Create(Expression) });
return;
}
PropertyDescriptorCollection col = context.DataContext.GetProperties();
HostParameterDefaults hostValues = context.GetExtension <HostParameterDefaults>();
// Borrow a runspace from the host if we're not trying to create a ScriptBlock.
// If we are trying to create one, we need to keep it around so that it can be
// invoked multiple times.
if (hostValues != null)
{
workflowHost = hostValues.Runtime;
try
{
runspace = workflowHost.UnboundedLocalRunspaceProvider.GetRunspace(null, 0, 0);
borrowedRunspace = true;
}
catch (Exception)
{
// it is fine to catch generic exception here
// if the local runspace provider does not give us
// a runspace we will create one locally (fallback)
}
}
if (runspace == null)
{
// Not running with the PowerShell workflow host so directly create the runspace...
runspace = RunspaceFactory.CreateRunspace(InitialSessionState.CreateDefault2());
runspace.Open();
}
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
try
{
ps.Runspace = runspace;
// Subscribe to DataAdding on the error stream so that we can add position tracking information
if (hostValues != null)
{
HostSettingCommandMetadata sourceCommandMetadata = hostValues.HostCommandMetadata;
CommandMetadataTable.TryAdd(ps.InstanceId, sourceCommandMetadata);
ps.Streams.Error.DataAdding += HandleErrorDataAdding;
}
// First, set the variables from the host defaults
if ((hostValues != null) && (hostValues.Parameters != null))
{
if (hostValues.Parameters.ContainsKey("PSCurrentDirectory"))
{
string path = hostValues.Parameters["PSCurrentDirectory"] as string;
if (path != null)
{
ps.Runspace.SessionStateProxy.Path.SetLocation(path);
}
}
foreach (string hostDefault in hostValues.Parameters.Keys)
{
string mappedHostDefault = hostDefault;
if (hostDefault.Equals("ErrorAction", StringComparison.OrdinalIgnoreCase))
{
if (hasErrorActionPreference)
{
mappedHostDefault = "ErrorActionPreference";
}
else
{
continue;
}
}
else if (hostDefault.Equals("WarningAction", StringComparison.OrdinalIgnoreCase))
{
if (hasWarningPreference)
{
mappedHostDefault = "WarningPreference";
}
else
{
continue;
}
}
else if (hostDefault.Equals("InformationAction", StringComparison.OrdinalIgnoreCase))
{
if (hasInformationPreference)
{
mappedHostDefault = "InformationPreference";
}
else
{
continue;
}
}
object propertyValue = hostValues.Parameters[hostDefault];
if (propertyValue != null)
{
ps.Runspace.SessionStateProxy.PSVariable.Set(mappedHostDefault, propertyValue);
}
}
}
// Then, set the variables from the workflow
foreach (PropertyDescriptor p in col)
{
string name = p.Name;
object value = p.GetValue(context.DataContext);
if (value != null)
{
object tempValue = value;
PSDataCollection <PSObject> collectionObject = value as PSDataCollection <PSObject>;
if (collectionObject != null && collectionObject.Count == 1)
{
tempValue = collectionObject[0];
}
ps.Runspace.SessionStateProxy.PSVariable.Set(name, tempValue);
}
}
ps.AddCommand(_ci).AddParameter("NoNewScope").AddParameter("ScriptBlock", ExpressionScriptBlock);
// If this needs to consume input, take it from the host stream.
PSDataCollection <PSObject> inputStream = null;
if (UseDefaultInput)
{
// Retrieve our host overrides
hostValues = context.GetExtension <HostParameterDefaults>();
if (hostValues != null)
{
Dictionary <string, object> incomingArguments = hostValues.Parameters;
if (incomingArguments.ContainsKey("Input"))
{
inputStream = incomingArguments["Input"] as PSDataCollection <PSObject>;
}
}
}
// Now invoke the pipeline
try
{
if (inputStream != null)
{
returnedvalue = ps.Invoke(inputStream);
inputStream.Clear();
}
else
{
returnedvalue = ps.Invoke();
}
}
catch (CmdletInvocationException cie)
{
if (cie.ErrorRecord != null && cie.ErrorRecord.Exception != null)
{
throw cie.InnerException;
}
else
{
throw;
}
}
}
finally
{
if (hostValues != null)
{
ps.Streams.Error.DataAdding -= HandleErrorDataAdding;
HostSettingCommandMetadata removedValue;
CommandMetadataTable.TryRemove(ps.InstanceId, out removedValue);
}
if (borrowedRunspace)
{
workflowHost.UnboundedLocalRunspaceProvider.ReleaseRunspace(runspace);
}
else
{
// This will be disposed when the command is done with it.
runspace.Dispose();
runspace = null;
}
}
if (ps.Streams.Error != null && ps.Streams.Error.Count > 0)
{
PSDataCollection <ErrorRecord> errorStream = null;
// Retrieve our host overrides
hostValues = context.GetExtension <HostParameterDefaults>();
if (hostValues != null)
{
Dictionary <string, object> incomingArguments = hostValues.Parameters;
if (incomingArguments.ContainsKey("PSError"))
{
errorStream = incomingArguments["PSError"] as PSDataCollection <ErrorRecord>;
}
}
if (errorStream != null && errorStream.IsOpen)
{
foreach (ErrorRecord record in ps.Streams.Error)
{
errorStream.Add(record);
}
}
}
T valueToReturn = default(T);
if (returnedvalue != null && returnedvalue.Count > 0)
{
try
{
if (returnedvalue.Count == 1)
{
if (returnedvalue[0] != null)
{
Object result = returnedvalue[0];
Object baseObject = ((PSObject)result).BaseObject;
if (!(baseObject is PSCustomObject))
{
result = baseObject;
}
// Try regular PowerShell conversion
valueToReturn = LanguagePrimitives.ConvertTo <T>(result);
}
}
else
{
valueToReturn = LanguagePrimitives.ConvertTo <T>(returnedvalue);
}
}
catch (PSInvalidCastException)
{
// Handle the special case of emitting a PSDataCollection - use its array constructor.
// This special case is why we aren't using PowerShell.Invoke<T>
if (typeof(T) == typeof(PSDataCollection <PSObject>))
{
Object tempValueToReturn = new PSDataCollection <PSObject>(
new List <PSObject> {
LanguagePrimitives.ConvertTo <PSObject>(returnedvalue[0])
});
valueToReturn = (T)tempValueToReturn;
}
else
{
throw;
}
}
Result.Set(context, valueToReturn);
}
}
}
/// <summary>
/// Write
/// </summary>
/// <param name="value"></param>
public override void Write(string value)
{
_output.Add(
new PSObject(value));
}
private static void BeginSetVariablesInRemoteRunspace(RunCommandsArguments args)
{
Runspace runspace = args.ImplementationContext.PowerShellInstance.Runspace;
PSActivityEnvironment pSActivityEnvironment = args.ImplementationContext.PSActivityEnvironment;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
traceSource.WriteMessage("BEGIN BeginSetVariablesInRemoteRunspace");
PowerShell powerShell = PowerShell.Create();
powerShell.Runspace = runspace;
powerShell.AddScript("\r\n Get-Variable -Exclude input | Remove-Variable 2> $Null;$error.Clear();$input | Foreach-Object {$nvp=$_}; foreach($k in $nvp.keys){set-variable -name $k -value $nvp[$k]}\r\n ");
Dictionary<string, object> variablesToSetInRunspace = PSActivity.GetVariablesToSetInRunspace(pSActivityEnvironment);
PSDataCollection<object> objs = new PSDataCollection<object>();
objs.Add(variablesToSetInRunspace);
PSDataCollection<object> objs1 = objs;
objs1.Complete();
args.HelperCommand = powerShell;
args.HelperCommandInput = objs1;
PSActivity.BeginInvokeOnPowershellCommand(powerShell, objs1, null, new AsyncCallback(PSActivity.SetVariablesCallback), args);
traceSource.WriteMessage("END BeginSetVariablesInRemoteRunspace");
}
}
/// <summary>
/// WriteErrorLine
/// </summary>
/// <param name="value"></param>
public override void WriteErrorLine(string value)
{
_error.Add(
new ErrorRecord(new RuntimeException(value), null, ErrorCategory.NotSpecified, null));
}
protected void WriteProgressRecord(NativeActivityContext context, PSDataCollection<ProgressRecord> progress, string statusDescription, ProgressRecordType type)
{
string displayName;
int num = 0;
if (progress != null)
{
string str = null;
if (this.PSProgressMessage != null)
{
str = this.PSProgressMessage.Get(context);
if (this.PSProgressMessage.Expression != null && string.IsNullOrEmpty(str))
{
return;
}
}
if (str != null)
{
displayName = string.Concat(base.DisplayName, ": ", str);
}
else
{
displayName = base.DisplayName;
if (string.IsNullOrEmpty(displayName))
{
displayName = base.GetType().Name;
}
}
ProgressRecord progressRecord = new ProgressRecord(0, displayName, statusDescription);
progressRecord.RecordType = type;
string str1 = string.Concat(base.Id, ":");
HostParameterDefaults extension = context.GetExtension<HostParameterDefaults>();
if (extension != null)
{
HostSettingCommandMetadata hostCommandMetadata = extension.HostCommandMetadata;
if (hostCommandMetadata != null)
{
object[] commandName = new object[3];
commandName[0] = hostCommandMetadata.CommandName;
commandName[1] = hostCommandMetadata.StartLineNumber;
commandName[2] = hostCommandMetadata.StartColumnNumber;
str1 = string.Concat(str1, string.Format(CultureInfo.CurrentCulture, Resources.ProgressPositionMessage, commandName));
}
}
progressRecord.CurrentOperation = str1;
foreach (PropertyDescriptor property in context.DataContext.GetProperties())
{
if (!string.Equals(property.DisplayName, "PSParentActivityID", StringComparison.OrdinalIgnoreCase))
{
if (!string.Equals(property.DisplayName, "ProgressPreference", StringComparison.OrdinalIgnoreCase))
{
continue;
}
string value = property.GetValue(context.DataContext) as string;
if (string.IsNullOrEmpty(value) || !string.Equals(value, "SilentlyContinue", StringComparison.OrdinalIgnoreCase) && !string.Equals(value, "Ignore", StringComparison.OrdinalIgnoreCase))
{
continue;
}
return;
}
else
{
object obj = property.GetValue(context.DataContext);
if (obj == null || !LanguagePrimitives.TryConvertTo<int>(obj, CultureInfo.InvariantCulture, out num))
{
continue;
}
progressRecord.ParentActivityId = num;
}
}
progress.Add(progressRecord);
return;
}
else
{
return;
}
}
/// <summary>
/// ProcessCommand
/// </summary>
/// <param name="command">PowerShell command</param>
/// <param name="output">Output</param>
/// <returns>DebuggerCommandResults</returns>
public override DebuggerCommandResults ProcessCommand(PSCommand command, PSDataCollection<PSObject> output)
{
if (command == null)
{
throw new PSArgumentNullException("command");
}
if (output == null)
{
throw new PSArgumentNullException("output");
}
if (!DebuggerStopped)
{
throw new PSInvalidOperationException(
DebuggerStrings.CannotProcessDebuggerCommandNotStopped,
null,
Debugger.CannotProcessCommandNotStopped,
ErrorCategory.InvalidOperation,
null);
}
//
// Allow an active pushed debugger to process commands
//
DebuggerCommandResults results = ProcessCommandForActiveDebugger(command, output);
if (results != null)
{
return results;
}
//
// Otherwise let root script debugger handle it.
//
LocalRunspace localRunspace = _context.CurrentRunspace as LocalRunspace;
if (localRunspace == null)
{
throw new PSInvalidOperationException(
DebuggerStrings.CannotProcessDebuggerCommandNotStopped,
null,
Debugger.CannotProcessCommandNotStopped,
ErrorCategory.InvalidOperation,
null);
}
try
{
using (_psDebuggerCommand = PowerShell.Create())
{
if (localRunspace.GetCurrentlyRunningPipeline() != null)
{
_psDebuggerCommand.SetIsNested(true);
}
_psDebuggerCommand.Runspace = localRunspace;
_psDebuggerCommand.Commands = command;
foreach (var cmd in _psDebuggerCommand.Commands.Commands)
{
cmd.MergeMyResults(PipelineResultTypes.All, PipelineResultTypes.Output);
}
PSDataCollection<PSObject> internalOutput = new PSDataCollection<PSObject>();
internalOutput.DataAdded += (sender, args) =>
{
foreach (var item in internalOutput.ReadAll())
{
if (item == null) { continue; }
DebuggerCommand dbgCmd = item.BaseObject as DebuggerCommand;
if (dbgCmd != null)
{
bool executedByDebugger = (dbgCmd.ResumeAction != null || dbgCmd.ExecutedByDebugger);
results = new DebuggerCommandResults(dbgCmd.ResumeAction, executedByDebugger);
}
else
{
output.Add(item);
}
}
};
// Allow any exceptions to propagate.
_psDebuggerCommand.InvokeWithDebugger(null, internalOutput, null, false);
}
}
finally
{
_psDebuggerCommand = null;
}
return results ?? new DebuggerCommandResults(null, false);
}
private void SortStartParameters(DynamicActivity dynamicActivity, CommandParameterCollection parameters)
{
uint num = 0;
bool flag;
bool flag1;
string str;
object baseObject;
if (dynamicActivity == null)
{
flag = false;
}
else
{
flag = dynamicActivity.Properties.Contains("PSComputerName");
}
bool flag2 = flag;
if (dynamicActivity == null)
{
flag1 = false;
}
else
{
flag1 = dynamicActivity.Properties.Contains("PSPrivateMetadata");
}
bool flag3 = flag1;
this._jobMetadata.Add("WorkflowTakesPrivateMetadata", flag3);
if (parameters != null)
{
foreach (CommandParameter parameter in parameters)
{
PowerShellTraceSource powerShellTraceSource = this._tracer;
string str1 = "PSWorkflowJob";
string str2 = "SortStartParameters";
Guid workflowGuidForTraces = this.WorkflowGuidForTraces;
PSWorkflowJob pSWorkflowJob = this;
string str3 = "Found parameter; {0}; {1}";
string[] name = new string[2];
name[0] = parameter.Name;
string[] strArrays = name;
int num1 = 1;
if (parameter.Value == null)
{
str = null;
}
else
{
str = parameter.Value.ToString();
}
strArrays[num1] = str;
powerShellTraceSource.WriteMessage(str1, str2, workflowGuidForTraces, pSWorkflowJob, str3, name);
string name1 = parameter.Name;
string str4 = name1;
if (name1 != null)
{
if (str4 == "PSComputerName")
{
if (!flag2)
{
string value = parameter.Value as string;
this._location = value;
string[] strArrays1 = LanguagePrimitives.ConvertTo<string[]>(parameter.Value);
this._psWorkflowCommonParameters[parameter.Name] = strArrays1;
PSSQMAPI.NoteWorkflowCommonParametersValues(parameter.Name, (int)strArrays1.Length);
continue;
}
else
{
this._location = "localhost";
this._workflowParameters[parameter.Name] = LanguagePrimitives.ConvertTo<string[]>(parameter.Value);
continue;
}
}
else if (str4 == "PSPrivateMetadata")
{
Hashtable hashtables = parameter.Value as Hashtable;
if (hashtables == null)
{
continue;
}
IDictionaryEnumerator enumerator = hashtables.GetEnumerator();
while (enumerator.MoveNext())
{
this._privateMetadata.Add(enumerator.Key.ToString(), enumerator.Value);
}
if (flag3)
{
this._workflowParameters.Add(parameter.Name, parameter.Value);
}
PSSQMAPI.NoteWorkflowCommonParametersValues(parameter.Name, hashtables.Count);
continue;
}
else if (str4 == "PSInputCollection")
{
if (parameter.Value as PSObject != null)
{
baseObject = ((PSObject)parameter.Value).BaseObject;
}
else
{
baseObject = parameter.Value;
}
object obj = baseObject;
if (obj as PSDataCollection<PSObject> == null)
{
PSDataCollection<PSObject> pSObjects = new PSDataCollection<PSObject>();
IEnumerator enumerator1 = LanguagePrimitives.GetEnumerator(obj);
if (enumerator1 == null)
{
pSObjects.Add(PSObject.AsPSObject(parameter.Value));
}
else
{
while (enumerator1.MoveNext())
{
pSObjects.Add(PSObject.AsPSObject(enumerator1.Current));
}
}
this._inputCollection = pSObjects;
continue;
}
else
{
this._inputCollection = obj as PSDataCollection<PSObject>;
continue;
}
}
else if (str4 == "PSParameterCollection")
{
continue;
}
else if (str4 == "PSRunningTimeoutSec" || str4 == "PSElapsedTimeoutSec" || str4 == "PSConnectionRetryCount" || str4 == "PSActionRetryCount" || str4 == "PSConnectionRetryIntervalSec" || str4 == "PSActionRetryIntervalSec")
{
this._psWorkflowCommonParameters.Add(parameter.Name, parameter.Value);
if (!LanguagePrimitives.TryConvertTo<uint>(parameter.Value, out num))
{
continue;
}
PSSQMAPI.NoteWorkflowCommonParametersValues(parameter.Name, num);
continue;
}
else if (str4 == "PSPersist" || str4 == "PSCredential" || str4 == "PSPort" || str4 == "PSUseSSL" || str4 == "PSConfigurationName" || str4 == "PSApplicationName" || str4 == "PSConnectionURI" || str4 == "PSSessionOption" || str4 == "PSAuthentication" || str4 == "PSAuthenticationLevel" || str4 == "PSCertificateThumbprint" || str4 == "PSAllowRedirection" || str4 == "Verbose" || str4 == "Debug" || str4 == "ErrorAction" || str4 == "WarningAction" || str4 == "PSWorkflowErrorAction")
{
this._psWorkflowCommonParameters.Add(parameter.Name, parameter.Value);
PSSQMAPI.IncrementWorkflowCommonParameterPresent(parameter.Name);
continue;
}
else if (str4 == "PSSenderInfo" || str4 == "PSWorkflowRoot" || str4 == "PSCurrentDirectory")
{
this._psWorkflowCommonParameters.Add(parameter.Name, parameter.Value);
continue;
}
}
this._workflowParameters.Add(parameter.Name, parameter.Value);
if (parameter.Value == null)
{
continue;
}
PSSQMAPI.IncrementWorkflowSpecificParameterType(parameter.Value.GetType());
}
}
this._psWorkflowCommonParameters.Add("WorkflowCommandName", this._definition.Command);
}
/// <summary>
/// Create necessary dictionaries for WorkflowManager consumption based on StartParameters.
/// </summary>
private void SortStartParameters(DynamicActivity dynamicActivity, CommandParameterCollection parameters)
{
bool selfRemoting = dynamicActivity != null && dynamicActivity.Properties.Any(x => x.Name.Equals(Constants.ComputerName, StringComparison.CurrentCultureIgnoreCase));
bool takesPSPrivateMetadata = dynamicActivity != null && dynamicActivity.Properties.Contains(Constants.PrivateMetadata);
_jobMetadata.Add(Constants.WorkflowTakesPrivateMetadata, takesPSPrivateMetadata);
if (parameters != null)
{
foreach (var parameter in parameters)
{
_tracer.WriteMessage(ClassNameTrace, "SortStartParameters", WorkflowGuidForTraces, this, "Found parameter; {0}; {1}", parameter.Name,
parameter.Value == null ? null : parameter.Value.ToString());
switch (parameter.Name)
{
case Constants.ComputerName:
if (selfRemoting)
{
// If we're self-remoting, location becomes the default computer
// and the PSComputerNames is passed in as an argument instead
// of going to the ubiquitous parameters
_location = Constants.DefaultComputerName;
string parameterName = dynamicActivity.Properties.First(x => x.Name.Equals(Constants.ComputerName, StringComparison.CurrentCultureIgnoreCase)).Name;
_workflowParameters[parameterName] = LanguagePrimitives.ConvertTo<string[]>(parameter.Value);
}
else
{
// Set _location before adding parameter.
var computer = parameter.Value as string;
_location = computer;
string[] computerNames = LanguagePrimitives.ConvertTo<string[]>(parameter.Value);
_psWorkflowCommonParameters[parameter.Name] = computerNames;
}
break;
case Constants.PrivateMetadata:
Hashtable privateData = parameter.Value as Hashtable;
if (privateData != null)
{
IDictionaryEnumerator enumerator = privateData.GetEnumerator();
while (enumerator.MoveNext())
{
_privateMetadata.Add(enumerator.Key.ToString(), enumerator.Value);
}
// Make the combined object available within the workflow as well...
if (takesPSPrivateMetadata)
{
_workflowParameters.Add(parameter.Name, parameter.Value);
}
}
break;
case Constants.PSInputCollection:
{
// Remove the input collection so we can properly pass it to the workflow job
object baseObject = parameter.Value is PSObject
? ((PSObject)parameter.Value).BaseObject
: parameter.Value;
if (baseObject is PSDataCollection<PSObject>)
{
_inputCollection = baseObject as PSDataCollection<PSObject>;
}
else
{
var inputCollection = new PSDataCollection<PSObject>();
var e = LanguagePrimitives.GetEnumerator(baseObject);
if (e != null)
{
while (e.MoveNext())
{
inputCollection.Add(PSObject.AsPSObject(e.Current));
}
}
else
{
inputCollection.Add(PSObject.AsPSObject(parameter.Value));
}
_inputCollection = inputCollection;
}
}
break;
case Constants.PSParameterCollection:
// Remove this one from the parameter collection...
break;
case Constants.PSRunningTime:
case Constants.PSElapsedTime:
case Constants.ConnectionRetryCount:
case Constants.ActionRetryCount:
case Constants.ConnectionRetryIntervalSec:
case Constants.ActionRetryIntervalSec:
_psWorkflowCommonParameters.Add(parameter.Name, parameter.Value);
break;
case Constants.Persist:
case Constants.Credential:
case Constants.Port:
case Constants.UseSSL:
case Constants.ConfigurationName:
case Constants.ApplicationName:
case Constants.ConnectionURI:
case Constants.SessionOption:
case Constants.Authentication:
case Constants.AuthenticationLevel:
case Constants.CertificateThumbprint:
case Constants.AllowRedirection:
case Constants.Verbose:
case Constants.Debug:
case Constants.ErrorAction:
case Constants.WarningAction:
case Constants.InformationAction:
case Constants.PSWorkflowErrorAction:
case Constants.PSSuspendOnError:
case Constants.PSSenderInfo:
case Constants.ModulePath:
case Constants.PSCurrentDirectory:
// Note: We don't add ErrorVariable, WarningVariable, OutVariable, or OutBuffer
// here because they are interpreted by PowerShell in the function generated over
// the workflow definition.
_psWorkflowCommonParameters.Add(parameter.Name, parameter.Value);
break;
default:
_workflowParameters.Add(parameter.Name, parameter.Value);
break;
}
}
}
// Add in the workflow command name...
_psWorkflowCommonParameters.Add("WorkflowCommandName", _definition.Command);
}
private void ReportException(Exception e)
{
if (e != null)
{
object error;
IContainsErrorRecord icer = e as IContainsErrorRecord;
if (icer != null)
{
error = icer.ErrorRecord;
}
else
{
error = (object)new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null);
}
lock (this.instanceLock)
{
this.currentPowerShell = PowerShell.Create();
}
this.currentPowerShell.Runspace = this.myRunSpace;
try
{
this.currentPowerShell.AddScript("$input").AddCommand("out-string");
Collection<PSObject> result;
PSDataCollection<object> inputCollection = new PSDataCollection<object>();
inputCollection.Add(error);
inputCollection.Complete();
result = this.currentPowerShell.Invoke(inputCollection);
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
this.myHost.UI.WriteErrorLine(str.Substring(0, str.Length - 2));
}
}
}
finally
{
lock (this.instanceLock)
{
this.currentPowerShell.Dispose();
this.currentPowerShell = null;
}
}
}
}
/// <summary>
/// To display an exception using the display formatter,
/// run a second pipeline passing in the error record.
/// The runtime will bind this to the $input variable,
/// which is why $input is being piped to the Out-String
/// cmdlet. The WriteErrorLine method is called to make sure
/// the error gets displayed in the correct error color.
/// </summary>
/// <param name="e">The exception to display.</param>
private void ReportException(Exception e)
{
if (e != null)
{
object error;
IContainsErrorRecord icer = e as IContainsErrorRecord;
if (icer != null)
{
error = icer.ErrorRecord;
}
else
{
error = (object)new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null);
}
lock (this.instanceLock)
{
this.currentPowerShell = PowerShell.Create();
}
this.currentPowerShell.Runspace = this.myRunSpace;
try
{
this.currentPowerShell.AddScript("$input").AddCommand("out-string");
// Do not merge errors, this function will swallow errors.
Collection<PSObject> result;
PSDataCollection<object> inputCollection = new PSDataCollection<object>();
inputCollection.Add(error);
inputCollection.Complete();
result = this.currentPowerShell.Invoke(inputCollection);
if (result.Count > 0)
{
string str = result[0].BaseObject as string;
if (!string.IsNullOrEmpty(str))
{
// Remove \r\n, which is added by the Out-String cmdlet.
this.myHost.UI.WriteErrorLine(str.Substring(0, str.Length - 2));
}
}
}
finally
{
// Dispose of the pipeline and set it to null, locking it because
// currentPowerShell may be accessed by the ctrl-C handler.
lock (this.instanceLock)
{
this.currentPowerShell.Dispose();
this.currentPowerShell = null;
}
}
}
}
private void OnData(object sender, NotifyCollectionChangedEventArgs e)
{
if( e.Action != NotifyCollectionChangedAction.Add)
{
return;
}
PSDataCollection<object> input = new PSDataCollection<object>();
foreach (var ci in e.NewItems)
{
input.Add(ci);
}
Interlocked.Exchange( ref _currentInput, input );
RaiseTrigger();
}