public CimActivityImplementationContext(ActivityImplementationContext activityImplementationContext, string computerName, PSCredential credential, string certificateThumbprint, AuthenticationMechanism? authenticationMechanism, bool useSsl, uint port, PSSessionOption sessionOption, CimSession session, CimSessionOptions cimSessionOptions, string moduleDefinition, Uri resourceUri)
{
if (activityImplementationContext != null)
{
base.PowerShellInstance = activityImplementationContext.PowerShellInstance;
this.ResourceUri = resourceUri;
this.ComputerName = computerName;
base.PSCredential = credential;
base.PSCertificateThumbprint = certificateThumbprint;
base.PSAuthentication = authenticationMechanism;
base.PSUseSsl = new bool?(useSsl);
base.PSPort = new uint?(port);
base.PSSessionOption = sessionOption;
this.Session = session;
this.SessionOptions = cimSessionOptions;
if (moduleDefinition != null)
{
CimActivityImplementationContext._moduleScriptBlock = ScriptBlock.Create(moduleDefinition);
this._moduleDefinition = moduleDefinition;
}
return;
}
else
{
throw new ArgumentNullException("activityImplementationContext");
}
}
public DirectExecutionActivitiesCommandRuntime(PSDataCollection<PSObject> output, ActivityImplementationContext implementationContext, Type cmdletType)
{
if (output != null)
{
if (implementationContext != null)
{
if (cmdletType != null)
{
this._output = output;
this._implementationContext = implementationContext;
this._cmdletType = cmdletType;
return;
}
else
{
throw new ArgumentNullException("cmdletType");
}
}
else
{
throw new ArgumentNullException("implementationContext");
}
}
else
{
throw new ArgumentNullException("output");
}
}
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
ActivityImplementationContext activityImplementationContext = new ActivityImplementationContext();
activityImplementationContext.PowerShellInstance = PowerShell.Create();
ActivityImplementationContext activityImplementationContext1 = activityImplementationContext;
return activityImplementationContext1;
}
/// <summary>
/// Creates and returns an empty powershell
/// </summary>
/// <param name="context">activity context</param>
/// <returns>A new activity implementation context</returns>
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
ActivityImplementationContext implementationContext = new ActivityImplementationContext
{
PowerShellInstance =
System.Management.Automation.PowerShell.
Create()
};
return implementationContext;
}
/// <summary>
/// Create an instance of the CIM activity implementation class
/// </summary>
/// <param name="activityImplementationContext"></param>
/// <param name="computerName"></param>
/// <param name="credential"></param>
/// <param name="certificateThumbprint"></param>
/// <param name="authenticationMechanism"></param>
/// <param name="useSsl"></param>
/// <param name="port"></param>
/// <param name="sessionOption"></param>
/// <param name="session"></param>
/// <param name="cimSessionOptions"></param>
/// <param name="moduleDefinition"></param>
/// <param name="resourceUri"></param>
public CimActivityImplementationContext(
ActivityImplementationContext activityImplementationContext,
string computerName,
PSCredential credential,
string certificateThumbprint,
AuthenticationMechanism?authenticationMechanism,
bool useSsl,
uint port,
PSSessionOption sessionOption,
CimSession session,
CimSessionOptions cimSessionOptions,
string moduleDefinition,
Uri resourceUri)
{
if (activityImplementationContext == null)
{
throw new ArgumentNullException("activityImplementationContext");
}
this.PowerShellInstance = activityImplementationContext.PowerShellInstance;
ResourceUri = resourceUri;
ComputerName = computerName;
PSCredential = credential;
PSCertificateThumbprint = certificateThumbprint;
PSAuthentication = authenticationMechanism;
PSUseSsl = useSsl;
PSPort = port;
PSSessionOption = sessionOption;
Session = session;
SessionOptions = cimSessionOptions;
if (moduleDefinition != null)
{
// Creating a script block forces the string into the compiled script cache so we
// don't need to reparse it at execution time. Locking the static _moduleDefinition is not
// required since the operation is idempotent.
_moduleScriptBlock = ScriptBlock.Create(moduleDefinition);
_moduleDefinition = moduleDefinition;
}
}
/// <summary>
/// Creates Powershell instance and adds the command to it
/// </summary>
/// <param name="context">The activity context to use</param>
/// <param name="connection">The wsman connection to use</param>
/// <param name="commands">The list of commands</param>
private void CreatePowerShellInstance(NativeActivityContext context, WSManConnectionInfo connection,
List <ActivityImplementationContext> commands)
{
// Create the PowerShell instance, and add the command to it.
ActivityImplementationContext implementationContext = GetPowerShell(context);
#if true
Runspace runspace;
if (connection != null)
{
implementationContext.ConnectionInfo = connection;
runspace = RunspaceFactory.CreateRunspace(connection);
implementationContext.PowerShellInstance.Runspace = runspace;
}
else
{
// if PSComputerName is "" or $null than connection is NULL
UpdateImplementationContextForLocalExecution(implementationContext, context);
}
#endif
// Add it to the queue of commands to execute.
commands.Add(implementationContext);
}
// InlineScript needs to handle these specially, since it might go through the PowerShell AddScript() API.
// If the parameter "CommandName" is in use, we add the preference configuration to the command parameters,
// otherwise, we add the preference configuration to the preference variable.
// All other activities have this set automatically by the infrastructure via parameters.
private void UpdatePreferenceVariables(ActivityImplementationContext implementationContext)
{
System.Management.Automation.PowerShell session = implementationContext.PowerShellInstance;
System.Management.Automation.Runspaces.Command command = null;
if (!_commandSpecified)
{
// "CommandName" and "Parameters" are in use
command = session.Commands.Commands[0];
}
if (implementationContext.Verbose != null)
{
if (command != null)
{
command.Parameters.Add("Verbose", implementationContext.Verbose);
}
else
{
// Map the boolean / switch to an actual action preference
ActionPreference preference = ActionPreference.SilentlyContinue;
if (implementationContext.Verbose.Value)
{
preference = ActionPreference.Continue;
}
implementationContext.PSActivityEnvironment.Variables["VerbosePreference"] = preference;
}
}
if (implementationContext.Debug != null)
{
if (command != null)
{
command.Parameters.Add("Debug", implementationContext.Debug);
}
else
{
// Map the boolean / switch to an actual action preference
ActionPreference preference = ActionPreference.SilentlyContinue;
if (implementationContext.Debug.Value)
{
preference = ActionPreference.Continue;
}
implementationContext.PSActivityEnvironment.Variables["DebugPreference"] = preference;
}
}
if (implementationContext.WhatIf != null && command != null)
{
command.Parameters.Add("WhatIf", implementationContext.WhatIf);
}
if (implementationContext.ErrorAction != null)
{
if (command != null)
{
command.Parameters.Add("ErrorAction", implementationContext.ErrorAction);
}
else
{
implementationContext.PSActivityEnvironment.Variables["ErrorActionPreference"] = implementationContext.ErrorAction;
}
}
if (implementationContext.WarningAction != null)
{
if (command != null)
{
command.Parameters.Add("WarningAction", implementationContext.WarningAction);
}
else
{
implementationContext.PSActivityEnvironment.Variables["WarningPreference"] = implementationContext.WarningAction;
}
}
if (implementationContext.InformationAction != null)
{
if (command != null)
{
command.Parameters.Add("InformationAction", implementationContext.InformationAction);
}
else
{
implementationContext.PSActivityEnvironment.Variables["InformationPreference"] = implementationContext.InformationAction;
}
}
}
/// <summary>
/// Adds the PSActivity variable to the active runspace, which is of type InlineScriptContext.
/// </summary>
/// <param name="implementationContext">The ActivityImplementationContext returned by the call to GetCommand.</param>
protected override void PrepareSession(ActivityImplementationContext implementationContext)
{
if (implementationContext.PSActivityEnvironment == null)
{
implementationContext.PSActivityEnvironment = new PSActivityEnvironment();
}
// Update the preference variables
UpdatePreferenceVariables(implementationContext);
System.Management.Automation.PowerShell session = implementationContext.PowerShellInstance;
implementationContext.PSActivityEnvironment.Variables["UserName"] = System.Environment.UserName;
string computerName = null;
if (implementationContext.ConnectionInfo != null)
{
computerName = implementationContext.ConnectionInfo.ComputerName;
}
if (string.IsNullOrEmpty(computerName))
{
computerName = "localhost";
}
implementationContext.PSActivityEnvironment.Variables["ComputerName"] = computerName;
implementationContext.PSActivityEnvironment.Variables["PSComputerName"] = computerName;
string workflowCommandName = null;
Dictionary <string, object> activityVariables = (Dictionary <string, object>)implementationContext.WorkflowContext;
if (activityVariables != null && activityVariables.ContainsKey("ParameterDefaults"))
{
HostParameterDefaults defaults = activityVariables["ParameterDefaults"] as HostParameterDefaults;
if (defaults != null)
{
workflowCommandName = defaults.Parameters["WorkflowCommandName"] as string;
}
}
if (string.IsNullOrEmpty(workflowCommandName))
{
workflowCommandName = "unknown";
}
implementationContext.PSActivityEnvironment.Variables["CommandName"] = workflowCommandName;
// Populate the default variables
InlineScriptContext inlineScriptContext = new InlineScriptContext(this);
// Populate the activity variables
foreach (KeyValuePair <string, object> entry in activityVariables)
{
if (String.Equals(entry.Key, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
{
System.Diagnostics.Debug.Assert(entry.Value is HostParameterDefaults, "ParameterDefaults does not contain a HostParameterDefaults object");
inlineScriptContext.Variables[entry.Key] = ((HostParameterDefaults)entry.Value).Parameters;
continue;
}
inlineScriptContext.Variables[entry.Key] = entry.Value;
}
// Set the PowerShell session variables...
foreach (KeyValuePair <string, object> entry in activityVariables)
{
var value = entry.Value;
if (String.Equals(entry.Key, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
{
continue;
}
implementationContext.PSActivityEnvironment.Variables[entry.Key] = value;
}
}
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
ValidateParameters();
System.Management.Automation.PowerShell invoker = null;
HashSet <string> allWorkflowVarNames = new HashSet <string>(StaticPotentialUsingVariableSet, StringComparer.OrdinalIgnoreCase);
Dictionary <string, object> defaults = this.ParameterDefaults.Get(context);
Dictionary <string, object> activityVariables = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
Dictionary <string, object> activityUsingVariables = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
string[] streams =
{
"Result", "PSError", "PSWarning", "PSVerbose", "PSDebug", "PSProgress", "PSInformation"
};
// First, set the variables from the user's variables
foreach (System.ComponentModel.PropertyDescriptor property in context.DataContext.GetProperties())
{
if (String.Equals(property.Name, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
{
continue;
}
// Add all user-defined variables/parameters in the same scope of the InlineScript activity
if (!allWorkflowVarNames.Contains(property.Name))
{
allWorkflowVarNames.Add(property.Name);
}
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];
}
activityVariables[property.Name] = tempValue;
}
}
// Then, set anything we received from parameters
foreach (PSActivityArgumentInfo currentArgument in GetActivityArguments())
{
string @default = currentArgument.Name;
if (streams.Any(item => string.Equals(item, @default, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
object argumentValue = currentArgument.Value.Get(context);
if (argumentValue != null && !activityVariables.ContainsKey(currentArgument.Name))
{
activityVariables[currentArgument.Name] = argumentValue;
}
}
// Then, set the variables from the host defaults
if (defaults != null)
{
foreach (string hostDefault in defaults.Keys)
{
string @default = hostDefault;
if (streams.Any(item => string.Equals(item, @default, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
object propertyValue = defaults[hostDefault];
if (propertyValue != null && !activityVariables.ContainsKey(hostDefault))
{
activityVariables[hostDefault] = propertyValue;
}
}
}
if (_commandSpecified)
{
string script = string.IsNullOrEmpty(Command) ? string.Empty : Command;
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity ID={0}: Inline Script: '{1}'.", context.ActivityInstanceId, script));
if (IsBlocked(script))
{
throw new PSInvalidOperationException(String.Format(CultureInfo.InvariantCulture, ActivityResources.CannotLaunchFormat, script));
}
string[] targetNodes = null;
if (this.PSComputerName.Expression != null)
{
targetNodes = this.PSComputerName.Get(context);
}
else
{
if (defaults != null && defaults.ContainsKey("PSComputerName"))
{
targetNodes = this.ParameterDefaults.Get(context)["PSComputerName"] as string[];
}
}
// See if this command will be run in process.
if ((targetNodes == null || targetNodes.Length == 0) && GetRunInProc(context))
{
if (_compiledScriptForInProc == null || _ci == null)
{
lock (Syncroot)
{
if (_compiledScriptForInProc == null)
{
if (_scriptWithoutUsing == null)
{
_scriptWithoutUsing = RemoveUsingPrefix(script, allWorkflowVarNames, out _usingVariables);
}
_compiledScriptForInProc = ScriptBlock.Create(_scriptWithoutUsing);
}
// Invoke using the CommandInfo for Invoke-Command directly, rather than going through
// the command discovery since this is much faster.
if (_ci == null)
{
_ci = new CmdletInfo("Invoke-Command", typeof(Microsoft.PowerShell.Commands.InvokeCommandCommand));
}
}
}
SetAvailableUsingVariables(activityVariables, activityUsingVariables);
Tracer.WriteMessage("PowerShell activity: executing InlineScript locally with ScriptBlock.");
invoker = System.Management.Automation.PowerShell.Create();
invoker.AddCommand(_ci).AddParameter("NoNewScope").AddParameter("ScriptBlock", _compiledScriptForInProc);
}
else
{
// Try to convert the ScriptBlock to a powershell instance
if (_compiledScriptForOutProc == null)
{
lock (Syncroot)
{
if (_compiledScriptForOutProc == null)
{
_compiledScriptForOutProc = ScriptBlock.Create(script);
}
}
}
try
{
// we trust the code inside inlinescript, set isTrusted as True.
invoker = _compiledScriptForOutProc.GetPowerShell(activityVariables, out activityUsingVariables, true);
Tracer.WriteMessage("PowerShell activity: executing InlineScript with ScriptBlock to powershell conversion.");
}
catch (Exception)
{
invoker = null;
}
if (invoker == null)
{
// Since scriptblocks aren't serialized with fidelity in the remote case, we need to
// use AddScript instead.
if (_scriptWithoutUsing == null)
{
lock (Syncroot)
{
if (_scriptWithoutUsing == null)
{
_scriptWithoutUsing = RemoveUsingPrefix(script, allWorkflowVarNames, out _usingVariables);
}
}
}
SetAvailableUsingVariables(activityVariables, activityUsingVariables);
Tracer.WriteMessage("PowerShell activity: executing InlineScript by using AddScript.");
invoker = System.Management.Automation.PowerShell.Create();
invoker.AddScript(_scriptWithoutUsing);
}
}
}
else
{
string commandName = CommandName.Get(context);
if (String.IsNullOrEmpty(commandName))
{
throw new ArgumentException(ActivityResources.CommandNameRequired);
}
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity ID={0}: Invoking command '{1}'.", context.ActivityInstanceId, commandName));
invoker = System.Management.Automation.PowerShell.Create();
invoker.AddCommand(commandName);
System.Collections.Hashtable parameters = Parameters.Get(context);
if (parameters != null && parameters.Count > 0)
{
foreach (var key in parameters.Keys)
{
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity: Adding parameter '-{0} {1}'.",
key, parameters[key]));
}
invoker.AddParameters(parameters);
}
}
var implementationContext = new ActivityImplementationContext
{
PowerShellInstance = invoker,
WorkflowContext = activityUsingVariables
};
return(implementationContext);
}
private static void UpdatePreferenceVariables(ActivityImplementationContext implementationContext)
{
Command item = implementationContext.PowerShellInstance.Commands.Commands[0];
bool? verbose = implementationContext.Verbose;
if (verbose.HasValue)
{
item.Parameters.Add("Verbose", implementationContext.Verbose);
}
bool? debug = implementationContext.Debug;
if (debug.HasValue)
{
item.Parameters.Add("Debug", implementationContext.Debug);
}
bool? whatIf = implementationContext.WhatIf;
if (whatIf.HasValue)
{
item.Parameters.Add("WhatIf", implementationContext.WhatIf);
}
ActionPreference? errorAction = implementationContext.ErrorAction;
if (errorAction.HasValue)
{
item.Parameters.Add("ErrorAction", implementationContext.ErrorAction);
}
ActionPreference? warningAction = implementationContext.WarningAction;
if (warningAction.HasValue)
{
item.Parameters.Add("WarningAction", implementationContext.WarningAction);
}
}
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
ValidateParameters();
System.Management.Automation.PowerShell invoker = null;
HashSet<string> allWorkflowVarNames = new HashSet<string>(StaticPotentialUsingVariableSet, StringComparer.OrdinalIgnoreCase);
Dictionary<string, object> defaults = this.ParameterDefaults.Get(context);
Dictionary<string, object> activityVariables = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
Dictionary<string, object> activityUsingVariables = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
string[] streams =
{
"Result", "PSError", "PSWarning", "PSVerbose", "PSDebug", "PSProgress", "PSInformation"
};
// First, set the variables from the user's variables
foreach (System.ComponentModel.PropertyDescriptor property in context.DataContext.GetProperties())
{
if (String.Equals(property.Name, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
continue;
// Add all user-defined variables/parameters in the same scope of the InlineScript activity
if (!allWorkflowVarNames.Contains(property.Name))
{
allWorkflowVarNames.Add(property.Name);
}
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];
}
activityVariables[property.Name] = tempValue;
}
}
// Then, set anything we received from parameters
foreach (PSActivityArgumentInfo currentArgument in GetActivityArguments())
{
string @default = currentArgument.Name;
if (streams.Any(item => string.Equals(item, @default, StringComparison.OrdinalIgnoreCase)))
continue;
object argumentValue = currentArgument.Value.Get(context);
if (argumentValue != null && !activityVariables.ContainsKey(currentArgument.Name))
{
activityVariables[currentArgument.Name] = argumentValue;
}
}
// Then, set the variables from the host defaults
if (defaults != null)
{
foreach (string hostDefault in defaults.Keys)
{
string @default = hostDefault;
if (streams.Any(item => string.Equals(item, @default, StringComparison.OrdinalIgnoreCase)))
continue;
object propertyValue = defaults[hostDefault];
if (propertyValue != null && !activityVariables.ContainsKey(hostDefault))
{
activityVariables[hostDefault] = propertyValue;
}
}
}
if (_commandSpecified)
{
string script = string.IsNullOrEmpty(Command) ? string.Empty : Command;
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity ID={0}: Inline Script: '{1}'.", context.ActivityInstanceId, script));
if (IsBlocked(script))
{
throw new PSInvalidOperationException(String.Format(CultureInfo.InvariantCulture, ActivityResources.CannotLaunchFormat, script));
}
string[] targetNodes = null;
if (this.PSComputerName.Expression != null)
{
targetNodes = this.PSComputerName.Get(context);
}
else
{
if (defaults != null && defaults.ContainsKey("PSComputerName"))
{
targetNodes = this.ParameterDefaults.Get(context)["PSComputerName"] as string[];
}
}
// See if this command will be run in process.
if ((targetNodes == null || targetNodes.Length == 0) && GetRunInProc(context))
{
if (_compiledScriptForInProc == null || _ci == null)
{
lock (Syncroot)
{
if (_compiledScriptForInProc == null)
{
if (_scriptWithoutUsing == null)
{
_scriptWithoutUsing = RemoveUsingPrefix(script, allWorkflowVarNames, out _usingVariables);
}
_compiledScriptForInProc = ScriptBlock.Create(_scriptWithoutUsing);
}
// Invoke using the CommandInfo for Invoke-Command directly, rather than going through
// the command discovery since this is much faster.
if (_ci == null)
{
_ci = new CmdletInfo("Invoke-Command", typeof(Microsoft.PowerShell.Commands.InvokeCommandCommand));
}
}
}
SetAvailableUsingVariables(activityVariables, activityUsingVariables);
Tracer.WriteMessage("PowerShell activity: executing InlineScript locally with ScriptBlock.");
invoker = System.Management.Automation.PowerShell.Create();
invoker.AddCommand(_ci).AddParameter("NoNewScope").AddParameter("ScriptBlock", _compiledScriptForInProc);
}
else
{
// Try to convert the ScriptBlock to a powershell instance
if (_compiledScriptForOutProc == null)
{
lock (Syncroot)
{
if (_compiledScriptForOutProc == null)
{
_compiledScriptForOutProc = ScriptBlock.Create(script);
}
}
}
try
{
// we trust the code inside inlinescript, set isTrusted as True.
invoker = _compiledScriptForOutProc.GetPowerShell(activityVariables, out activityUsingVariables, true);
Tracer.WriteMessage("PowerShell activity: executing InlineScript with ScriptBlock to powershell conversion.");
}
catch (Exception)
{
invoker = null;
}
if (invoker == null)
{
// Since scriptblocks aren't serialized with fidelity in the remote case, we need to
// use AddScript instead.
if (_scriptWithoutUsing == null)
{
lock (Syncroot)
{
if (_scriptWithoutUsing == null)
{
_scriptWithoutUsing = RemoveUsingPrefix(script, allWorkflowVarNames, out _usingVariables);
}
}
}
SetAvailableUsingVariables(activityVariables, activityUsingVariables);
Tracer.WriteMessage("PowerShell activity: executing InlineScript by using AddScript.");
invoker = System.Management.Automation.PowerShell.Create();
invoker.AddScript(_scriptWithoutUsing);
}
}
}
else
{
string commandName = CommandName.Get(context);
if (String.IsNullOrEmpty(commandName))
{
throw new ArgumentException(ActivityResources.CommandNameRequired);
}
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity ID={0}: Invoking command '{1}'.", context.ActivityInstanceId, commandName));
invoker = System.Management.Automation.PowerShell.Create();
invoker.AddCommand(commandName);
System.Collections.Hashtable parameters = Parameters.Get(context);
if (parameters != null && parameters.Count > 0)
{
foreach (var key in parameters.Keys)
{
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity: Adding parameter '-{0} {1}'.",
key, parameters[key]));
}
invoker.AddParameters(parameters);
}
}
var implementationContext = new ActivityImplementationContext
{
PowerShellInstance = invoker,
WorkflowContext = activityUsingVariables
};
return implementationContext;
}
// InlineScript needs to handle these specially, since it might go through the PowerShell AddScript() API.
// If the parameter "CommandName" is in use, we add the preference configuration to the command parameters,
// otherwise, we add the preference configuration to the preference variable.
// All other activities have this set automatically by the infrastructure via parameters.
private void UpdatePreferenceVariables(ActivityImplementationContext implementationContext)
{
System.Management.Automation.PowerShell session = implementationContext.PowerShellInstance;
System.Management.Automation.Runspaces.Command command = null;
if (!_commandSpecified)
{
// "CommandName" and "Parameters" are in use
command = session.Commands.Commands[0];
}
if (implementationContext.Verbose != null)
{
if (command != null)
{
command.Parameters.Add("Verbose", implementationContext.Verbose);
}
else
{
// Map the boolean / switch to an actual action preference
ActionPreference preference = ActionPreference.SilentlyContinue;
if (implementationContext.Verbose.Value)
preference = ActionPreference.Continue;
implementationContext.PSActivityEnvironment.Variables["VerbosePreference"] = preference;
}
}
if (implementationContext.Debug != null)
{
if (command != null)
{
command.Parameters.Add("Debug", implementationContext.Debug);
}
else
{
// Map the boolean / switch to an actual action preference
ActionPreference preference = ActionPreference.SilentlyContinue;
if (implementationContext.Debug.Value)
preference = ActionPreference.Continue;
implementationContext.PSActivityEnvironment.Variables["DebugPreference"] = preference;
}
}
if (implementationContext.WhatIf != null && command != null)
{
command.Parameters.Add("WhatIf", implementationContext.WhatIf);
}
if (implementationContext.ErrorAction != null)
{
if (command != null)
{
command.Parameters.Add("ErrorAction", implementationContext.ErrorAction);
}
else
{
implementationContext.PSActivityEnvironment.Variables["ErrorActionPreference"] = implementationContext.ErrorAction;
}
}
if (implementationContext.WarningAction != null)
{
if (command != null)
{
command.Parameters.Add("WarningAction", implementationContext.WarningAction);
}
else
{
implementationContext.PSActivityEnvironment.Variables["WarningPreference"] = implementationContext.WarningAction;
}
}
if (implementationContext.InformationAction != null)
{
if (command != null)
{
command.Parameters.Add("InformationAction", implementationContext.InformationAction);
}
else
{
implementationContext.PSActivityEnvironment.Variables["InformationPreference"] = implementationContext.InformationAction;
}
}
}
/// <summary>
/// Create an instance of the CIM activity implementation class
/// </summary>
/// <param name="activityImplementationContext"></param>
/// <param name="computerName"></param>
/// <param name="credential"></param>
/// <param name="certificateThumbprint"></param>
/// <param name="authenticationMechanism"></param>
/// <param name="useSsl"></param>
/// <param name="port"></param>
/// <param name="sessionOption"></param>
/// <param name="session"></param>
/// <param name="cimSessionOptions"></param>
/// <param name="moduleDefinition"></param>
/// <param name="resourceUri"></param>
public CimActivityImplementationContext(
ActivityImplementationContext activityImplementationContext,
string computerName,
PSCredential credential,
string certificateThumbprint,
AuthenticationMechanism? authenticationMechanism,
bool useSsl,
uint port,
PSSessionOption sessionOption,
CimSession session,
CimSessionOptions cimSessionOptions,
string moduleDefinition,
Uri resourceUri)
{
if (activityImplementationContext == null)
{
throw new ArgumentNullException("activityImplementationContext");
}
this.PowerShellInstance = activityImplementationContext.PowerShellInstance;
ResourceUri = resourceUri;
ComputerName = computerName;
PSCredential = credential;
PSCertificateThumbprint = certificateThumbprint;
PSAuthentication = authenticationMechanism;
PSUseSsl = useSsl;
PSPort = port;
PSSessionOption = sessionOption;
Session = session;
SessionOptions = cimSessionOptions;
if (moduleDefinition != null)
{
// Creating a script block forces the string into the compiled script cache so we
// don't need to reparse it at execution time. Locking the static _moduleDefinition is not
// required since the operation is idempotent.
_moduleScriptBlock = ScriptBlock.Create(moduleDefinition);
_moduleDefinition = moduleDefinition;
}
}
internal RunCommandsArguments(ActivityParameters activityParameters, PSDataCollection <PSObject> output, PSDataCollection <PSObject> input, PSActivityContext psActivityContext, PSWorkflowHost workflowHost, bool runInProc, Dictionary <string, object> parameterDefaults, Type activityType, PrepareSessionDelegate prepareSession, object activityObject, ActivityImplementationContext implementationContext)
{
this.ActivityParameters = activityParameters;
this.Output = output;
this.Input = input;
this.PSActivityContext = psActivityContext;
this.ParameterDefaults = parameterDefaults;
this.ActivityType = activityType;
this.Delegate = prepareSession;
this.ActivityObject = activityObject;
this.WorkflowHost = workflowHost;
this.ImplementationContext = implementationContext;
this.CommandExecutionType = RunCommandsArguments.DetermineCommandExecutionType(implementationContext.ConnectionInfo, runInProc, activityType, psActivityContext);
}
private static void PopulatePSComputerName(ActivityImplementationContext implementationContext, NativeActivityContext context, PSActivityArgumentInfo field, int index)
{
PropertyInfo property = implementationContext.GetType().GetProperty(field.Name);
string[] strArrays = (string[])field.Value.Get(context);
string[] strArrays1 = new string[1];
strArrays1[0] = strArrays[index];
property.SetValue(implementationContext, strArrays1, null);
}
private void PopulateActivityImplementationContext(ActivityImplementationContext implementationContext, NativeActivityContext context, int index)
{
foreach (PSActivityArgumentInfo activityArgument in this.GetActivityArguments())
{
PropertyInfo property = implementationContext.GetType().GetProperty(activityArgument.Name);
if (property != null)
{
if (!string.Equals(activityArgument.Name, "PSComputerName", StringComparison.OrdinalIgnoreCase) || index == -1)
{
property.SetValue(implementationContext, activityArgument.Value.Get(context), null);
}
else
{
PSActivity.PopulatePSComputerName(implementationContext, context, activityArgument, index);
}
}
else
{
throw new Exception(string.Concat("Could not find corresponding task context field for activity argument: ", activityArgument.Name));
}
}
}
private static void InitializeCmdletInstanceParameters(Command command, PSObject wrappedCmdlet, bool isGenericCim, PSActivityContext psActivityContext, CimSessionOptions cimSessionOptions, ActivityImplementationContext implementationContext)
{
PSActivity.PSActivity variable = new PSActivity.PSActivity();
variable.cimSessionOptions = cimSessionOptions;
bool flag = false;
foreach (CommandParameter parameter in command.Parameters)
{
if (PSActivity._commonCommandParameters.Contains(parameter.Name))
{
continue;
}
if (parameter.Name.Equals("CimSession"))
{
flag = true;
}
if (wrappedCmdlet.Properties[parameter.Name] == null)
{
wrappedCmdlet.Properties.Add(new PSNoteProperty(parameter.Name, parameter.Value));
}
else
{
wrappedCmdlet.Properties[parameter.Name].Value = parameter.Value;
}
}
string[] item = null;
variable.cimActivityImplementationContext = implementationContext as CimActivityImplementationContext;
if (variable.cimActivityImplementationContext == null || string.IsNullOrEmpty(variable.cimActivityImplementationContext.ComputerName))
{
if (psActivityContext.ParameterDefaults.ContainsKey("PSComputerName"))
{
item = psActivityContext.ParameterDefaults["PSComputerName"] as string[];
}
}
else
{
string[] computerName = new string[1];
computerName[0] = variable.cimActivityImplementationContext.ComputerName;
item = computerName;
}
if (item != null && (int)item.Length > 0)
{
if (!isGenericCim || wrappedCmdlet.Properties["CimSession"] == null)
{
if (wrappedCmdlet.Properties["ComputerName"] == null)
{
wrappedCmdlet.Properties.Add(new PSNoteProperty("ComputerName", item));
}
}
else
{
if (!flag)
{
if (variable.cimActivityImplementationContext != null)
{
bool value = false;
bool? pSUseSsl = variable.cimActivityImplementationContext.PSUseSsl;
if (pSUseSsl.HasValue)
{
bool? nullable = variable.cimActivityImplementationContext.PSUseSsl;
value = nullable.Value;
}
uint num = 0;
uint? pSPort = variable.cimActivityImplementationContext.PSPort;
if (pSPort.HasValue)
{
uint? pSPort1 = variable.cimActivityImplementationContext.PSPort;
num = pSPort1.Value;
}
AuthenticationMechanism authenticationMechanism = AuthenticationMechanism.Default;
AuthenticationMechanism? pSAuthentication = variable.cimActivityImplementationContext.PSAuthentication;
if (pSAuthentication.HasValue)
{
AuthenticationMechanism? pSAuthentication1 = variable.cimActivityImplementationContext.PSAuthentication;
authenticationMechanism = pSAuthentication1.Value;
}
List<CimSession> cimSessions = item.ToList<string>().ConvertAll<CimSession>((string computer) => CimConnectionManager.GetGlobalCimConnectionManager().GetSession(computer, LambdaVar9.PSCredential, LambdaVar9.PSCertificateThumbprint, authenticationMechanism, cimSessionOptions, value, num, LambdaVar9.PSSessionOption));
wrappedCmdlet.Properties["CimSession"].Value = cimSessions.ToArray<CimSession>();
variable.cimActivityImplementationContext.Session = cimSessions[0];
return;
}
else
{
throw new ArgumentException(Resources.InvalidImplementationContext);
}
}
}
}
}
private static void InitializeActivityEnvironmentAndAddRequiredModules(ActivityImplementationContext implementationContext, ActivityParameters activityParameters)
{
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
if (implementationContext.PSActivityEnvironment == null)
{
implementationContext.PSActivityEnvironment = new PSActivityEnvironment();
}
PSActivityEnvironment pSActivityEnvironment = implementationContext.PSActivityEnvironment;
string[] pSRequiredModules = activityParameters.PSRequiredModules;
string[] strArrays = pSRequiredModules;
if (pSRequiredModules == null)
{
strArrays = new string[0];
}
string[] strArrays1 = strArrays;
for (int i = 0; i < (int)strArrays1.Length; i++)
{
string str = strArrays1[i];
traceSource.WriteMessage(string.Concat("Adding dependent module to policy: ", str));
pSActivityEnvironment.Modules.Add(str);
}
}
}
private static bool HandleFailure(int attempts, uint? retryCount, uint? retryInterval, ActivityImplementationContext implementationContext, string errorId, Exception e, PSActivityContext psActivityContext)
{
bool flag = false;
if ((long)attempts <= (ulong)retryCount.GetValueOrDefault(0))
{
if (e != null)
{
PSActivity.WriteError(e, errorId, ErrorCategory.InvalidResult, implementationContext.PowerShellInstance.Runspace.ConnectionInfo, psActivityContext);
}
if (!psActivityContext.IsCanceled)
{
flag = true;
}
for (int i = 0; (long)i < (ulong)retryInterval.GetValueOrDefault(1) && !PSActivity.CheckForCancel(psActivityContext); i++)
{
Thread.Sleep(0x3e8);
}
}
else
{
if (implementationContext.PSComputerName == null || (int)implementationContext.PSComputerName.Length <= 1)
{
if (e != null)
{
lock (psActivityContext.exceptions)
{
psActivityContext.exceptions.Add(e);
}
}
}
else
{
if (e != null)
{
PSActivity.WriteError(e, errorId, ErrorCategory.InvalidResult, implementationContext.PowerShellInstance.Runspace.ConnectionInfo, psActivityContext);
}
}
}
return flag;
}
/// <summary>
/// Adds the PSActivity variable to the active runspace, which is of type InlineScriptContext.
/// </summary>
/// <param name="implementationContext">The ActivityImplementationContext returned by the call to GetCommand.</param>
protected override void PrepareSession(ActivityImplementationContext implementationContext)
{
if (implementationContext.PSActivityEnvironment == null)
{
implementationContext.PSActivityEnvironment = new PSActivityEnvironment();
}
// Update the preference variables
UpdatePreferenceVariables(implementationContext);
System.Management.Automation.PowerShell session = implementationContext.PowerShellInstance;
implementationContext.PSActivityEnvironment.Variables["UserName"] = System.Environment.UserName;
string computerName = null;
if (implementationContext.ConnectionInfo != null)
{
computerName = implementationContext.ConnectionInfo.ComputerName;
}
if (string.IsNullOrEmpty(computerName))
{
computerName = "localhost";
}
implementationContext.PSActivityEnvironment.Variables["ComputerName"] = computerName;
implementationContext.PSActivityEnvironment.Variables["PSComputerName"] = computerName;
string workflowCommandName = null;
Dictionary<string, object> activityVariables = (Dictionary<string, object>)implementationContext.WorkflowContext;
if (activityVariables != null && activityVariables.ContainsKey("ParameterDefaults"))
{
HostParameterDefaults defaults = activityVariables["ParameterDefaults"] as HostParameterDefaults;
if (defaults != null)
{
workflowCommandName = defaults.Parameters["WorkflowCommandName"] as string;
}
}
if (string.IsNullOrEmpty(workflowCommandName))
{
workflowCommandName = "unknown";
}
implementationContext.PSActivityEnvironment.Variables["CommandName"] = workflowCommandName;
// Populate the default variables
InlineScriptContext inlineScriptContext = new InlineScriptContext(this);
// Populate the activity variables
foreach (KeyValuePair<string, object> entry in activityVariables)
{
if (String.Equals(entry.Key, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
{
System.Diagnostics.Debug.Assert(entry.Value is HostParameterDefaults, "ParameterDefaults does not contain a HostParameterDefaults object");
inlineScriptContext.Variables[entry.Key] = ((HostParameterDefaults)entry.Value).Parameters;
continue;
}
inlineScriptContext.Variables[entry.Key] = entry.Value;
}
// Set the PowerShell session variables...
foreach (KeyValuePair<string, object> entry in activityVariables)
{
var value = entry.Value;
if (String.Equals(entry.Key, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
continue;
implementationContext.PSActivityEnvironment.Variables[entry.Key] = value;
}
}
private void PopulateRunspaceFromContext(ActivityImplementationContext implementationContext, PSActivityContext activityContext, NativeActivityContext context)
{
if (implementationContext.PowerShellInstance != null)
{
PropertyDescriptorCollection properties = context.DataContext.GetProperties();
foreach (PropertyDescriptor property in properties)
{
string name = property.Name;
object value = property.GetValue(context.DataContext);
if (value == null)
{
continue;
}
object item = value;
PSDataCollection<PSObject> pSObjects = value as PSDataCollection<PSObject>;
if (pSObjects != null && pSObjects.Count == 1)
{
item = pSObjects[0];
}
activityContext.UserVariables.Add(name, item);
}
}
}
protected override List <ActivityImplementationContext> GetImplementation(NativeActivityContext context)
{
string empty;
string str;
string empty1;
string str1;
typeof(GenericCimCmdletActivity).IsAssignableFrom(base.GetType());
string[] strArrays = this.PSComputerName.Get(context);
CimSession[] cimSessionArray = this.CimSession.Get(context);
Uri uri = null;
if (this.ResourceUri != null)
{
uri = this.ResourceUri.Get(context);
}
List <ActivityImplementationContext> activityImplementationContexts = new List <ActivityImplementationContext>();
if (strArrays == null || (int)strArrays.Length <= 0)
{
ActivityImplementationContext powerShell = this.GetPowerShell(context);
CimActivityImplementationContext cimActivityImplementationContext = new CimActivityImplementationContext(powerShell, null, null, null, new AuthenticationMechanism?(AuthenticationMechanism.Default), false, 0, null, null, null, this.ModuleDefinition, uri);
activityImplementationContexts.Add(cimActivityImplementationContext);
}
else
{
WSManSessionOptions wSManSessionOption = new WSManSessionOptions();
uint?nullable = base.PSActionRunningTimeoutSec.Get(context);
if (nullable.HasValue)
{
wSManSessionOption.Timeout = TimeSpan.FromSeconds((double)((float)nullable.Value));
}
bool?nullable1 = this.PSUseSsl.Get(context);
bool value = false;
if (nullable1.HasValue)
{
wSManSessionOption.UseSsl = nullable1.Value;
value = nullable1.Value;
}
uint?nullable2 = this.PSPort.Get(context);
uint num = 0;
if (nullable2.HasValue)
{
wSManSessionOption.DestinationPort = nullable2.Value;
num = nullable2.Value;
}
PSSessionOption pSSessionOption = this.PSSessionOption.Get(context);
if (pSSessionOption != null)
{
wSManSessionOption.NoEncryption = pSSessionOption.NoEncryption;
wSManSessionOption.CertCACheck = pSSessionOption.SkipCACheck;
wSManSessionOption.CertCNCheck = pSSessionOption.SkipCNCheck;
wSManSessionOption.CertRevocationCheck = pSSessionOption.SkipRevocationCheck;
if (pSSessionOption.UseUTF16)
{
wSManSessionOption.PacketEncoding = PacketEncoding.Utf16;
}
if (pSSessionOption.Culture != null)
{
wSManSessionOption.Culture = pSSessionOption.Culture;
}
if (pSSessionOption.UICulture != null)
{
wSManSessionOption.UICulture = pSSessionOption.UICulture;
}
if (pSSessionOption.ProxyCredential != null)
{
char[] chrArray = new char[1];
chrArray[0] = '\\';
string[] strArrays1 = pSSessionOption.ProxyCredential.UserName.Split(chrArray);
if ((int)strArrays1.Length >= 2)
{
empty = strArrays1[0];
str = strArrays1[1];
}
else
{
empty = string.Empty;
str = strArrays1[0];
}
wSManSessionOption.AddProxyCredentials(new CimCredential(PSGeneratedCIMActivity.ConvertPSAuthenticationMechanismToCimPasswordAuthenticationMechanism(pSSessionOption.ProxyAuthentication), empty, str, pSSessionOption.ProxyCredential.Password));
}
ProxyAccessType proxyAccessType = pSSessionOption.ProxyAccessType;
if (proxyAccessType == ProxyAccessType.IEConfig)
{
wSManSessionOption.ProxyType = ProxyType.InternetExplorer;
goto Label0;
}
else if (proxyAccessType == ProxyAccessType.WinHttpConfig)
{
wSManSessionOption.ProxyType = ProxyType.WinHttp;
goto Label0;
}
else if (proxyAccessType == (ProxyAccessType.IEConfig | ProxyAccessType.WinHttpConfig))
{
goto Label0;
}
else if (proxyAccessType == ProxyAccessType.AutoDetect)
{
wSManSessionOption.ProxyType = ProxyType.Auto;
goto Label0;
}
}
Label0:
PSCredential pSCredential = this.PSCredential.Get(context);
string str2 = this.PSCertificateThumbprint.Get(context);
if (pSCredential == null || str2 == null)
{
PasswordAuthenticationMechanism cimPasswordAuthenticationMechanism = PasswordAuthenticationMechanism.Default;
AuthenticationMechanism? nullable3 = this.PSAuthentication.Get(context);
if (nullable3.HasValue)
{
cimPasswordAuthenticationMechanism = PSGeneratedCIMActivity.ConvertPSAuthenticationMechanismToCimPasswordAuthenticationMechanism(nullable3.Value);
}
if (str2 != null)
{
wSManSessionOption.AddDestinationCredentials(new CimCredential(CertificateAuthenticationMechanism.Default, str2));
}
if (pSCredential != null)
{
char[] chrArray1 = new char[1];
chrArray1[0] = '\\';
string[] strArrays2 = pSCredential.UserName.Split(chrArray1);
if ((int)strArrays2.Length >= 2)
{
empty1 = strArrays2[0];
str1 = strArrays2[1];
}
else
{
empty1 = string.Empty;
str1 = strArrays2[0];
}
wSManSessionOption.AddDestinationCredentials(new CimCredential(cimPasswordAuthenticationMechanism, empty1, str1, pSCredential.Password));
}
if (cimSessionArray == null || (int)cimSessionArray.Length <= 0)
{
string[] strArrays3 = strArrays;
for (int i = 0; i < (int)strArrays3.Length; i++)
{
string str3 = strArrays3[i];
ActivityImplementationContext activityImplementationContext = this.GetPowerShell(context);
CimActivityImplementationContext cimActivityImplementationContext1 = new CimActivityImplementationContext(activityImplementationContext, str3, pSCredential, str2, nullable3, value, num, pSSessionOption, null, wSManSessionOption, this.ModuleDefinition, uri);
activityImplementationContexts.Add(cimActivityImplementationContext1);
}
}
else
{
CimSession[] cimSessionArray1 = cimSessionArray;
for (int j = 0; j < (int)cimSessionArray1.Length; j++)
{
CimSession cimSession = cimSessionArray1[j];
ActivityImplementationContext powerShell1 = this.GetPowerShell(context);
CimActivityImplementationContext cimActivityImplementationContext2 = new CimActivityImplementationContext(powerShell1, cimSession.ComputerName, pSCredential, str2, nullable3, value, num, pSSessionOption, cimSession, wSManSessionOption, this.ModuleDefinition, uri);
activityImplementationContexts.Add(cimActivityImplementationContext2);
}
}
}
else
{
throw new ArgumentException(Resources.CredentialParameterCannotBeSpecifiedWithPSCertificateThumbPrint);
}
}
return(activityImplementationContexts);
}
protected override List <ActivityImplementationContext> GetImplementation(NativeActivityContext context)
{
bool needRunspace = !typeof(GenericCimCmdletActivity).IsAssignableFrom(this.GetType());
string[] computernames = PSComputerName.Get(context);
CimSession[] sessions = this.CimSession.Get(context);
Uri resourceUri = null;
if (ResourceUri != null)
{
resourceUri = ResourceUri.Get(context);
}
List <ActivityImplementationContext> commands = new List <ActivityImplementationContext>();
// Configure the remote connectivity options...
if (computernames != null && computernames.Length > 0)
{
WSManSessionOptions sessionOptions = new WSManSessionOptions();
// Set a timeout on the connection...
uint?timeout = PSActionRunningTimeoutSec.Get(context);
if (timeout.HasValue)
{
sessionOptions.Timeout = TimeSpan.FromSeconds((double)(timeout.Value));
}
// See if we should use SSL or not...
bool?useSsl = PSUseSsl.Get(context);
bool sessionOptionUseSsl = false;
if (useSsl.HasValue)
{
sessionOptions.UseSsl = useSsl.Value;
sessionOptionUseSsl = useSsl.Value;
}
// Set the port to use
uint?port = PSPort.Get(context);
uint sessionOptionPort = 0;
if (port.HasValue)
{
sessionOptions.DestinationPort = port.Value;
sessionOptionPort = port.Value;
}
// Map over options from PSSessionConfig to WSManSessionOptions
PSSessionOption pso = PSSessionOption.Get(context);
if (pso != null)
{
sessionOptions.NoEncryption = pso.NoEncryption;
sessionOptions.CertCACheck = pso.SkipCACheck;
sessionOptions.CertCNCheck = pso.SkipCNCheck;
sessionOptions.CertRevocationCheck = pso.SkipRevocationCheck;
if (pso.UseUTF16)
{
sessionOptions.PacketEncoding = PacketEncoding.Utf16;
}
if (pso.Culture != null)
{
sessionOptions.Culture = pso.Culture;
}
if (pso.UICulture != null)
{
sessionOptions.UICulture = pso.UICulture;
}
if (pso.ProxyCredential != null)
{
string[] parts = pso.ProxyCredential.UserName.Split('\\');
string domain, userid;
if (parts.Length < 2)
{
domain = string.Empty;
userid = parts[0];
}
else
{
domain = parts[0];
userid = parts[1];
}
sessionOptions.AddProxyCredentials(
new CimCredential(ConvertPSAuthenticationMechanismToCimPasswordAuthenticationMechanism(pso.ProxyAuthentication),
domain, userid, pso.ProxyCredential.Password));
}
switch (pso.ProxyAccessType)
{
case ProxyAccessType.WinHttpConfig:
sessionOptions.ProxyType = ProxyType.WinHttp;
break;
case ProxyAccessType.AutoDetect:
sessionOptions.ProxyType = ProxyType.Auto;
break;
case ProxyAccessType.IEConfig:
sessionOptions.ProxyType = ProxyType.InternetExplorer;
break;
}
}
PSCredential pscreds = PSCredential.Get(context);
string certificateThumbprint = PSCertificateThumbprint.Get(context);
if (pscreds != null && certificateThumbprint != null)
{
throw new ArgumentException(Resources.CredentialParameterCannotBeSpecifiedWithPSCertificateThumbPrint);
}
PasswordAuthenticationMechanism passwordAuthenticationMechanism = PasswordAuthenticationMechanism.Default;
AuthenticationMechanism? authenticationMechanism = PSAuthentication.Get(context);
if (authenticationMechanism.HasValue)
{
passwordAuthenticationMechanism = ConvertPSAuthenticationMechanismToCimPasswordAuthenticationMechanism(authenticationMechanism.Value);
}
if (certificateThumbprint != null)
{
sessionOptions.AddDestinationCredentials(new CimCredential(CertificateAuthenticationMechanism.Default, certificateThumbprint));
}
if (pscreds != null)
{
string[] parts = pscreds.UserName.Split('\\');
string domain, userid;
if (parts.Length < 2)
{
domain = string.Empty;
userid = parts[0];
}
else
{
domain = parts[0];
userid = parts[1];
}
sessionOptions.AddDestinationCredentials(new CimCredential(passwordAuthenticationMechanism, domain, userid, pscreds.Password));
}
// Create the PowerShell instance, and add the script to it.
if (sessions != null && sessions.Length > 0)
{
foreach (CimSession session in sessions)
{
ActivityImplementationContext configuredCommand = GetPowerShell(context);
CimActivityImplementationContext activityImplementationContext =
new CimActivityImplementationContext(
configuredCommand,
session.ComputerName,
pscreds,
certificateThumbprint,
authenticationMechanism,
sessionOptionUseSsl,
sessionOptionPort,
pso,
session,
sessionOptions,
ModuleDefinition,
resourceUri);
commands.Add(activityImplementationContext);
//if (needRunspace)
// GetRunspaceForCimCmdlet(context, activityImplementationContext);
}
}
else if (this.PSCommandName.Equals("CimCmdlets\\New-CimSession", StringComparison.OrdinalIgnoreCase))
{
// NewCimSession activity is a special one as it creates the required sessions based on number of computers specified in one go.
ActivityImplementationContext baseContext = GetPowerShell(context);
CimActivityImplementationContext activityImplementationContext =
new CimActivityImplementationContext(baseContext,
null, // ComputerName
pscreds,
certificateThumbprint,
authenticationMechanism,
sessionOptionUseSsl,
sessionOptionPort,
pso,
null, // session
sessionOptions,
ModuleDefinition,
resourceUri);
commands.Add(activityImplementationContext);
}
else
{
foreach (string computer in computernames)
{
ActivityImplementationContext baseContext = GetPowerShell(context);
CimActivityImplementationContext activityImplementationContext =
new CimActivityImplementationContext(baseContext,
computer,
pscreds,
certificateThumbprint,
authenticationMechanism,
sessionOptionUseSsl,
sessionOptionPort,
pso,
null, // session
sessionOptions,
ModuleDefinition,
resourceUri);
commands.Add(activityImplementationContext);
}
}
}
// Configure the local invocation options
else
{
// Create the PowerShell instance, and add the script to it.
ActivityImplementationContext baseContext = GetPowerShell(context);
CimActivityImplementationContext activityImplementationContext =
new CimActivityImplementationContext(baseContext,
null, // ComputerName
null, // Credential
null, // CertificateThumbprint
AuthenticationMechanism.Default,
false, // UseSsl
0, // Port
null, // PSSessionOption
null, // Session
null, // CimSessionOptions
ModuleDefinition,
resourceUri);
commands.Add(activityImplementationContext);
}
return(commands);
}
protected virtual void PrepareSession(ActivityImplementationContext implementationContext)
{
}
internal RunCommandsArguments(ActivityParameters activityParameters, PSDataCollection<PSObject> output, PSDataCollection<PSObject> input, PSActivityContext psActivityContext, PSWorkflowHost workflowHost, bool runInProc, Dictionary<string, object> parameterDefaults, Type activityType, PrepareSessionDelegate prepareSession, object activityObject, ActivityImplementationContext implementationContext)
{
this.ActivityParameters = activityParameters;
this.Output = output;
this.Input = input;
this.PSActivityContext = psActivityContext;
this.ParameterDefaults = parameterDefaults;
this.ActivityType = activityType;
this.Delegate = prepareSession;
this.ActivityObject = activityObject;
this.WorkflowHost = workflowHost;
this.ImplementationContext = implementationContext;
this.CommandExecutionType = RunCommandsArguments.DetermineCommandExecutionType(implementationContext.ConnectionInfo, runInProc, activityType, psActivityContext);
}
private static void RunDirectExecutionActivity(System.Management.Automation.PowerShell commandToRun, PSDataCollection<PSObject> input, PSDataCollection<PSObject> output, PSActivityContext psActivityContext, ActivityImplementationContext implementationContext)
{
PSDataCollection<PSObject> pSObjects;
Type type;
CimSessionOptions sessionOptions;
Command item = commandToRun.Commands.Commands[0];
string commandText = item.CommandText;
Cmdlet invokeWmiMethod = null;
bool flag = false;
if (!string.Equals(commandText, "Get-WMIObject", StringComparison.OrdinalIgnoreCase))
{
if (string.Equals(commandText, "Invoke-WMIMethod", StringComparison.OrdinalIgnoreCase))
{
invokeWmiMethod = new InvokeWmiMethod();
flag = true;
}
}
else
{
invokeWmiMethod = new GetWmiObjectCommand();
}
if (!PSActivity.CheckForCancel(psActivityContext))
{
if (output != null)
{
pSObjects = output;
}
else
{
pSObjects = new PSDataCollection<PSObject>();
}
ActivityImplementationContext activityImplementationContext = implementationContext;
if (invokeWmiMethod != null)
{
type = invokeWmiMethod.GetType();
}
else
{
type = psActivityContext.TypeImplementingCmdlet;
}
DirectExecutionActivitiesCommandRuntime directExecutionActivitiesCommandRuntime = new DirectExecutionActivitiesCommandRuntime(pSObjects, activityImplementationContext, type);
directExecutionActivitiesCommandRuntime.Error = commandToRun.Streams.Error;
directExecutionActivitiesCommandRuntime.Warning = commandToRun.Streams.Warning;
directExecutionActivitiesCommandRuntime.Progress = commandToRun.Streams.Progress;
directExecutionActivitiesCommandRuntime.Verbose = commandToRun.Streams.Verbose;
directExecutionActivitiesCommandRuntime.Debug = commandToRun.Streams.Debug;
if (invokeWmiMethod == null)
{
CimActivityImplementationContext cimActivityImplementationContext = implementationContext as CimActivityImplementationContext;
if (cimActivityImplementationContext != null)
{
sessionOptions = cimActivityImplementationContext.SessionOptions;
}
else
{
sessionOptions = null;
}
CimSessionOptions cimSessionOption = sessionOptions;
if (psActivityContext.TypeImplementingCmdlet != null)
{
if (input == null || input.Count <= 0 && !input.IsOpen)
{
CimBaseCommand cimBaseCommand = (CimBaseCommand)Activator.CreateInstance(psActivityContext.TypeImplementingCmdlet);
using (cimBaseCommand)
{
cimBaseCommand.CommandRuntime = directExecutionActivitiesCommandRuntime;
PSObject pSObject = PSObject.AsPSObject(cimBaseCommand);
PSActivity.InitializeCmdletInstanceParameters(item, pSObject, true, psActivityContext, cimSessionOption, implementationContext);
cimBaseCommand.Invoke().GetEnumerator().MoveNext();
}
}
else
{
if (psActivityContext.TypeImplementingCmdlet.GetProperty("InputObject") != null)
{
foreach (PSObject pSObject1 in input)
{
try
{
CimBaseCommand cimBaseCommand1 = (CimBaseCommand)Activator.CreateInstance(psActivityContext.TypeImplementingCmdlet);
using (cimBaseCommand1)
{
cimBaseCommand1.CommandRuntime = directExecutionActivitiesCommandRuntime;
CimInstance cimInstance = LanguagePrimitives.ConvertTo<CimInstance>(pSObject1);
PSObject pSObject2 = PSObject.AsPSObject(cimBaseCommand1);
PSActivity.InitializeCmdletInstanceParameters(item, pSObject2, true, psActivityContext, cimSessionOption, implementationContext);
PSPropertyInfo pSPropertyInfo = pSObject2.Properties["InputObject"];
pSPropertyInfo.Value = cimInstance;
cimBaseCommand1.Invoke().GetEnumerator().MoveNext();
}
}
catch (PSInvalidCastException pSInvalidCastException1)
{
PSInvalidCastException pSInvalidCastException = pSInvalidCastException1;
if (pSInvalidCastException.ErrorRecord != null)
{
directExecutionActivitiesCommandRuntime.Error.Add(pSInvalidCastException.ErrorRecord);
}
}
if (!PSActivity.CheckForCancel(psActivityContext))
{
continue;
}
return;
}
}
else
{
object[] objArray = new object[1];
objArray[0] = commandText;
throw new NotImplementedException(string.Format(CultureInfo.CurrentCulture, Resources.CmdletDoesNotImplementInputObjectProperty, objArray));
}
}
}
else
{
throw new InvalidOperationException(commandText);
}
}
else
{
invokeWmiMethod.CommandRuntime = directExecutionActivitiesCommandRuntime;
PSObject pSObject3 = PSObject.AsPSObject(invokeWmiMethod);
PSActivity.InitializeCmdletInstanceParameters(item, pSObject3, false, psActivityContext, null, implementationContext);
if (!flag || input == null || input.Count <= 0 && !input.IsOpen)
{
invokeWmiMethod.Invoke().GetEnumerator().MoveNext();
return;
}
else
{
InvokeWmiMethod invokeWmiMethod1 = invokeWmiMethod as InvokeWmiMethod;
foreach (PSObject pSObject4 in input)
{
try
{
ManagementObject managementObject = LanguagePrimitives.ConvertTo<ManagementObject>(pSObject4);
invokeWmiMethod1.InputObject = managementObject;
invokeWmiMethod1.Invoke().GetEnumerator().MoveNext();
}
catch (PSInvalidCastException pSInvalidCastException3)
{
PSInvalidCastException pSInvalidCastException2 = pSInvalidCastException3;
if (pSInvalidCastException2.ErrorRecord != null)
{
directExecutionActivitiesCommandRuntime.Error.Add(pSInvalidCastException2.ErrorRecord);
}
}
if (!PSActivity.CheckForCancel(psActivityContext))
{
continue;
}
return;
}
}
}
return;
}
else
{
return;
}
}
public DirectExecutionActivitiesCommandRuntime(PSDataCollection <PSObject> output, ActivityImplementationContext implementationContext, Type cmdletType)
{
if (output != null)
{
if (implementationContext != null)
{
if (cmdletType != null)
{
this._output = output;
this._implementationContext = implementationContext;
this._cmdletType = cmdletType;
return;
}
else
{
throw new ArgumentNullException("cmdletType");
}
}
else
{
throw new ArgumentNullException("implementationContext");
}
}
else
{
throw new ArgumentNullException("output");
}
}
protected internal void UpdateImplementationContextForLocalExecution(ActivityImplementationContext implementationContext, ActivityContext context)
{
}
public void Cancel()
{
ActivityImplementationContext activityImplementationContext = null;
IAsyncResult asyncResult = null;
if (this.WorkflowHost != null)
{
if (this.commandQueue != null)
{
while (!this.commandQueue.IsEmpty)
{
bool flag = this.commandQueue.TryDequeue(out activityImplementationContext);
if (!flag)
{
continue;
}
PowerShell powerShellInstance = activityImplementationContext.PowerShellInstance;
object[] objArray = new object[1];
objArray[0] = powerShellInstance;
this._tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture, "PowerShell activity: Cancelling pending command {0}.", objArray));
powerShellInstance.Dispose();
}
}
PSResumableActivityHostController pSActivityHostController = this.WorkflowHost.PSActivityHostController as PSResumableActivityHostController;
if (pSActivityHostController == null)
{
PSOutOfProcessActivityController pSOutOfProcessActivityController = this.WorkflowHost.PSActivityHostController as PSOutOfProcessActivityController;
if (pSOutOfProcessActivityController != null)
{
while (this.AsyncResults.Count > 0)
{
this.AsyncResults.TryDequeue(out asyncResult);
pSOutOfProcessActivityController.CancelInvokePowerShell(asyncResult);
}
}
}
else
{
pSActivityHostController.StopAllResumablePSCommands(this.JobInstanceId);
}
while (this.runningCommands.Count > 0)
{
PowerShell powerShell = null;
lock (this.runningCommands)
{
Dictionary <PowerShell, RetryCount> .KeyCollection.Enumerator enumerator = this.runningCommands.Keys.GetEnumerator();
try
{
if (enumerator.MoveNext())
{
PowerShell current = enumerator.Current;
powerShell = current;
}
}
finally
{
enumerator.Dispose();
}
if (powerShell == null)
{
break;
}
}
if (powerShell.InvocationStateInfo.State == PSInvocationState.Running)
{
object[] objArray1 = new object[1];
objArray1[0] = powerShell;
this._tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture, "PowerShell activity: Stopping command {0}.", objArray1));
try
{
powerShell.Stop();
}
catch (NullReferenceException nullReferenceException)
{
}
catch (InvalidOperationException invalidOperationException)
{
}
}
if (powerShell.InvocationStateInfo.State != PSInvocationState.Completed || powerShell.HadErrors)
{
this.Failed = true;
}
int num = RunCommandsArguments.DetermineCommandExecutionType(powerShell.Runspace.ConnectionInfo as WSManConnectionInfo, this.RunInProc, this.ActivityType, this);
if (num != 1)
{
PSActivity.CloseRunspaceAndDisposeCommand(powerShell, this.WorkflowHost, this, num);
}
this.runningCommands.Remove(powerShell);
}
return;
}
else
{
throw new InvalidOperationException("WorkflowHost");
}
}
private static void UpdatePowerShell(ActivityImplementationContext implementationContext, PSActivityContext psActivityContext, Type ActivityType, PrepareSessionDelegate PrepareSession, object activityObject)
{
try
{
PrepareSession(implementationContext);
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
if (implementationContext.PSError != null)
{
powerShellInstance.Streams.Error = implementationContext.PSError;
}
if (implementationContext.PSProgress != null)
{
powerShellInstance.Streams.Progress = implementationContext.PSProgress;
}
if (implementationContext.PSVerbose != null)
{
powerShellInstance.Streams.Verbose = implementationContext.PSVerbose;
}
if (implementationContext.PSDebug != null)
{
powerShellInstance.Streams.Debug = implementationContext.PSDebug;
}
if (implementationContext.PSWarning != null)
{
powerShellInstance.Streams.Warning = implementationContext.PSWarning;
}
PSActivity pSActivity = activityObject as PSActivity;
if (pSActivity.UpdatePreferenceVariable)
{
PSActivity.UpdatePreferenceVariables(implementationContext);
}
}
catch (Exception exception1)
{
Exception exception = exception1;
lock (psActivityContext.exceptions)
{
psActivityContext.exceptions.Add(exception);
}
}
}
