/// <summary>
/// Execute the logic for this activity...
/// </summary>
/// <param name="context"></param>
protected override void Execute(NativeActivityContext context)
{
// Retrieve our host overrides
HostParameterDefaults hostValues = context.GetExtension <HostParameterDefaults>();
SetHostValuesByVariableName(context, hostValues);
SetHostValuesByProperty(context, hostValues);
}
private void SetHostValuesByVariableName(NativeActivityContext context, HostParameterDefaults hostValues)
{
// Set the Command / host metadata
string variableName = null;
if (OtherVariableName.Get(context) != null)
{
if (OtherVariableName.Expression != null)
{
string value = OtherVariableName.Get(context);
if (!string.IsNullOrWhiteSpace(value))
{
variableName = value;
}
}
if (String.Equals(variableName, "Position", StringComparison.OrdinalIgnoreCase))
{
HostSettingCommandMetadata metadata = hostValues.HostCommandMetadata;
// The position should come in as line:column:command
string positionMessage = (string)Value.Get(context);
string[] positionElements = positionMessage.Split(new char[] { ':' }, 3);
string line = positionElements[0].Trim();
string column = positionElements[1].Trim();
string commandName = positionElements[2].Trim();
if (!String.IsNullOrEmpty(line))
{
metadata.StartLineNumber = Int32.Parse(line, CultureInfo.InvariantCulture);
}
if (!String.IsNullOrEmpty(column))
{
metadata.StartColumnNumber = Int32.Parse(line, CultureInfo.InvariantCulture);
}
if (!String.IsNullOrEmpty(commandName))
{
metadata.CommandName = commandName;
}
}
else
{
if (Value.Get(context) == null)
{
hostValues.Parameters.Remove(variableName);
}
else
{
hostValues.Parameters[variableName] = Value.Get(context);
}
}
}
}
private void SetHostValuesByProperty(NativeActivityContext context, HostParameterDefaults hostValues)
{
Type currentType = this.GetType();
// Populate any of our parameters into the host defaults.
foreach (PropertyInfo field in currentType.GetProperties())
{
// See if it's an argument
if (typeof(Argument).IsAssignableFrom(field.PropertyType))
{
// Skip the ones that are specific to this activity
if (String.Equals("VariableToSet", field.Name, StringComparison.OrdinalIgnoreCase) ||
String.Equals("OtherVariableName", field.Name, StringComparison.OrdinalIgnoreCase) ||
String.Equals("Value", field.Name, StringComparison.OrdinalIgnoreCase))
{
continue;
}
// Handle Bookmark timeouts, but don't set them as a host default.
if (String.Equals("PSBookmarkTimeoutSec", field.Name, StringComparison.OrdinalIgnoreCase))
{
// See if this is trying to change the bookmark timeout
if (PSBookmarkTimeoutSec.Get(context).HasValue)
{
SafelySetResumeBookmarkTimeout(TimeSpan.FromSeconds(PSBookmarkTimeoutSec.Get(context).Value));
}
else
{
SafelySetResumeBookmarkTimeout(TimeSpan.FromSeconds(0));
}
continue;
}
// Get the argument
Argument currentArgument = (Argument)field.GetValue(this, null);
if (currentArgument.Expression != null)
{
if (currentArgument.Get(context) == null)
{
hostValues.Parameters.Remove(field.Name);
}
else
{
hostValues.Parameters[field.Name] = currentArgument.Get(context);
}
}
}
}
}
private void ConfigureAllExtensions()
{
// declaring instance store
this.workflowApplication.InstanceStore = _stores.CreateInstanceStore();
var IOParticipant = _stores.CreatePersistenceIOParticipant();
if (IOParticipant != null)
this.workflowApplication.Extensions.Add(IOParticipant);
// adding the tracking participants
this.workflowApplication.Extensions.Add(this.GetTrackingParticipant());
// adding the custom extensions
IEnumerable<object> extensions = this.Runtime.Configuration.CreateWorkflowExtensions();
if (extensions != null)
{
foreach (object extension in extensions)
{
this.workflowApplication.Extensions.Add(extension);
}
}
// adding the custom extension creation functions
IEnumerable<Func<object>> extensionFunctions = this.Runtime.Configuration.CreateWorkflowExtensionCreationFunctions<object>();
if (extensionFunctions != null)
{
foreach(Func<object> extensionFunc in extensionFunctions)
{
this.workflowApplication.Extensions.Add<object>(extensionFunc);
}
}
_paramDefaults = new HostParameterDefaults();
if (this.PSWorkflowContext.PSWorkflowCommonParameters != null)
{
foreach (KeyValuePair<string, object> param in this.PSWorkflowContext.PSWorkflowCommonParameters)
{
if (param.Key != Constants.PSRunningTime && param.Key != Constants.PSElapsedTime)
{
_paramDefaults.Parameters.Add(param.Key, param.Value);
}
}
}
if (this.PSWorkflowContext.PrivateMetadata != null)
{
_paramDefaults.Parameters[Constants.PrivateMetadata] = this.PSWorkflowContext.PrivateMetadata;
}
// Job related parameters
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataName))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataName)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataName];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataInstanceId))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataInstanceId)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataInstanceId];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataSessionId))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataSessionId)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataSessionId];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataCommand))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataCommand)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataCommand];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataParentName))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataParentName)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataParentName];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataParentInstanceId))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataParentInstanceId)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataParentInstanceId];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataParentSessionId))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataParentSessionId)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataParentSessionId];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey(Constants.JobMetadataParentCommand))
{
_paramDefaults.Parameters[TranslateMetaDataName(Constants.JobMetadataParentCommand)] =
this.PSWorkflowContext.JobMetadata[Constants.JobMetadataParentCommand];
}
_paramDefaults.Parameters["WorkflowInstanceId"] = this.InstanceId;
_paramDefaults.Parameters["Input"] = this.Streams.InputStream;
_paramDefaults.Parameters["Result"] = this.Streams.OutputStream;
_paramDefaults.Parameters["PSError"] = this.Streams.ErrorStream;
_paramDefaults.Parameters["PSWarning"] = this.Streams.WarningStream;
_paramDefaults.Parameters["PSProgress"] = this.Streams.ProgressStream;
_paramDefaults.Parameters["PSVerbose"] = this.Streams.VerboseStream;
_paramDefaults.Parameters["PSDebug"] = this.Streams.DebugStream;
_paramDefaults.Parameters["PSInformation"] = this.Streams.InformationStream;
// Assign PSActivityHost here
_paramDefaults.Runtime = Runtime;
_paramDefaults.JobInstanceId = _job.InstanceId;
// Assign PSHostPersistDelegate here
Func<bool> hostDelegate = this.CheckForPersistenceAfterPSActivity;
_paramDefaults.HostPersistenceDelegate = hostDelegate;
Action<object> activateDelegate = this.ReactivateWorkflow;
_paramDefaults.ActivateDelegate = activateDelegate;
_paramDefaults.AsyncExecutionCollection = this.asyncExecutionCollection;
_paramDefaults.RemoteActivityState = this.RemoteActivityState;
System.Activities.Hosting.SymbolResolver resolver = new System.Activities.Hosting.SymbolResolver();
resolver.Add("ParameterDefaults", _paramDefaults);
this.workflowApplication.Extensions.Add(resolver);
this.workflowApplication.Extensions.Add(_paramDefaults);
}
/// <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);
}
}
}
protected override void Dispose(bool disposing)
{
if (!disposing || base.Disposed)
{
return;
}
else
{
lock (base.SyncLock)
{
if (!base.Disposed)
{
base.Disposed = true;
lock (this.ReactivateSync)
{
this.IsTerminalStateAction = true;
this.PersistIdleTimerInProgressOrTriggered = false;
this.InternalUnloaded = false;
}
this.ConfigureTimerOnUnload();
WorkflowApplication workflowApplication = this.workflowApplication;
this.DisposeWorkflowApplication();
if (this._job.JobStateInfo.State == JobState.Running && workflowApplication != null)
{
try
{
workflowApplication.Abort("Disposing the job");
}
catch (Exception exception)
{
}
}
if (this._paramDefaults != null)
{
this._paramDefaults.Dispose();
this._paramDefaults = null;
}
if (this._streams != null)
{
this.UnregisterHandlersForDataAdding(this._streams);
this._streams.Dispose();
}
if (this._timers != null)
{
this._timers.Dispose();
}
this.DisposePersistUnloadTimer();
base.Dispose(disposing);
}
}
return;
}
}
private void SetHostValuesByVariableName(NativeActivityContext context, HostParameterDefaults hostValues)
{
// Set the Command / host metadata
string variableName = null;
if (OtherVariableName.Get(context) != null)
{
if (OtherVariableName.Expression != null)
{
string value = OtherVariableName.Get(context);
if (!string.IsNullOrWhiteSpace(value))
{
variableName = value;
}
}
if (String.Equals(variableName, "Position", StringComparison.OrdinalIgnoreCase))
{
HostSettingCommandMetadata metadata = hostValues.HostCommandMetadata;
// The position should come in as line:column:command
string positionMessage = (string)Value.Get(context);
string[] positionElements = positionMessage.Split(new char[] { ':' }, 3);
string line = positionElements[0].Trim();
string column = positionElements[1].Trim();
string commandName = positionElements[2].Trim();
if (!String.IsNullOrEmpty(line))
{
metadata.StartLineNumber = Int32.Parse(line, CultureInfo.InvariantCulture);
}
if (!String.IsNullOrEmpty(column))
{
metadata.StartColumnNumber = Int32.Parse(line, CultureInfo.InvariantCulture);
}
if (!String.IsNullOrEmpty(commandName))
{
metadata.CommandName = commandName;
}
}
else
{
if (Value.Get(context) == null)
{
hostValues.Parameters.Remove(variableName);
}
else
{
hostValues.Parameters[variableName] = Value.Get(context);
}
}
}
}
private void ConfigureAllExtensions()
{
this.workflowApplication.InstanceStore = this._stores.CreateInstanceStore();
PersistenceIOParticipant persistenceIOParticipant = this._stores.CreatePersistenceIOParticipant();
if (persistenceIOParticipant != null)
{
this.workflowApplication.Extensions.Add(persistenceIOParticipant);
}
this.workflowApplication.Extensions.Add(this.GetTrackingParticipant());
IEnumerable<object> objs = base.Runtime.Configuration.CreateWorkflowExtensions();
if (objs != null)
{
foreach (object obj in objs)
{
this.workflowApplication.Extensions.Add(obj);
}
}
IEnumerable<Func<object>> funcs = base.Runtime.Configuration.CreateWorkflowExtensionCreationFunctions<object>();
if (funcs != null)
{
foreach (Func<object> func in funcs)
{
this.workflowApplication.Extensions.Add<object>(func);
}
}
this._paramDefaults = new HostParameterDefaults();
if (this.PSWorkflowContext.PSWorkflowCommonParameters != null)
{
foreach (KeyValuePair<string, object> pSWorkflowCommonParameter in this.PSWorkflowContext.PSWorkflowCommonParameters)
{
if (!(pSWorkflowCommonParameter.Key != "PSRunningTimeoutSec") || !(pSWorkflowCommonParameter.Key != "PSElapsedTimeoutSec"))
{
continue;
}
this._paramDefaults.Parameters.Add(pSWorkflowCommonParameter.Key, pSWorkflowCommonParameter.Value);
}
}
if (this.PSWorkflowContext.PrivateMetadata != null)
{
this._paramDefaults.Parameters["PSPrivateMetadata"] = this.PSWorkflowContext.PrivateMetadata;
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("Name"))
{
this._paramDefaults.Parameters["JobName"] = this.PSWorkflowContext.JobMetadata["Name"];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("InstanceId"))
{
this._paramDefaults.Parameters["JobInstanceId"] = this.PSWorkflowContext.JobMetadata["InstanceId"];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("Id"))
{
this._paramDefaults.Parameters["JobId"] = this.PSWorkflowContext.JobMetadata["Id"];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("Command"))
{
this._paramDefaults.Parameters["JobCommandName"] = this.PSWorkflowContext.JobMetadata["Command"];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("ParentName"))
{
this._paramDefaults.Parameters["ParentJobName"] = this.PSWorkflowContext.JobMetadata["ParentName"];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("ParentInstanceId"))
{
this._paramDefaults.Parameters["ParentJobInstanceId"] = this.PSWorkflowContext.JobMetadata["ParentInstanceId"];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("ParentSessionId"))
{
this._paramDefaults.Parameters["ParentJobId"] = this.PSWorkflowContext.JobMetadata["ParentSessionId"];
}
if (this.PSWorkflowContext.JobMetadata.ContainsKey("ParentCommand"))
{
this._paramDefaults.Parameters["ParentCommandName"] = this.PSWorkflowContext.JobMetadata["ParentCommand"];
}
this._paramDefaults.Parameters["WorkflowInstanceId"] = this.InstanceId;
this._paramDefaults.Parameters["Input"] = this.Streams.InputStream;
this._paramDefaults.Parameters["Result"] = this.Streams.OutputStream;
this._paramDefaults.Parameters["PSError"] = this.Streams.ErrorStream;
this._paramDefaults.Parameters["PSWarning"] = this.Streams.WarningStream;
this._paramDefaults.Parameters["PSProgress"] = this.Streams.ProgressStream;
this._paramDefaults.Parameters["PSVerbose"] = this.Streams.VerboseStream;
this._paramDefaults.Parameters["PSDebug"] = this.Streams.DebugStream;
this._paramDefaults.Runtime = base.Runtime;
this._paramDefaults.JobInstanceId = this._job.InstanceId;
Func<bool> func1 = new Func<bool>(this.CheckForPersistenceAfterPSActivity);
this._paramDefaults.HostPersistenceDelegate = func1;
Action<object> action = new Action<object>(this.ReactivateWorkflow);
this._paramDefaults.ActivateDelegate = action;
this._paramDefaults.AsyncExecutionCollection = this.asyncExecutionCollection;
SymbolResolver symbolResolvers = new SymbolResolver();
symbolResolvers.Add("ParameterDefaults", this._paramDefaults);
this.workflowApplication.Extensions.Add(symbolResolvers);
this.workflowApplication.Extensions.Add(this._paramDefaults);
}
private void SetHostValuesByProperty(NativeActivityContext context, HostParameterDefaults hostValues)
{
Type currentType = this.GetType();
// Populate any of our parameters into the host defaults.
foreach (PropertyInfo field in currentType.GetProperties())
{
// See if it's an argument
if (typeof(Argument).IsAssignableFrom(field.PropertyType))
{
// Skip the ones that are specific to this activity
if (String.Equals("VariableToSet", field.Name, StringComparison.OrdinalIgnoreCase) ||
String.Equals("OtherVariableName", field.Name, StringComparison.OrdinalIgnoreCase) ||
String.Equals("Value", field.Name, StringComparison.OrdinalIgnoreCase))
{
continue;
}
// Handle Bookmark timeouts, but don't set them as a host default.
if (String.Equals("PSBookmarkTimeoutSec", field.Name, StringComparison.OrdinalIgnoreCase))
{
// See if this is trying to change the bookmark timeout
if (PSBookmarkTimeoutSec.Get(context).HasValue)
{
SafelySetResumeBookmarkTimeout(TimeSpan.FromSeconds(PSBookmarkTimeoutSec.Get(context).Value));
}
else
{
SafelySetResumeBookmarkTimeout(TimeSpan.FromSeconds(0));
}
continue;
}
// Get the argument
Argument currentArgument = (Argument)field.GetValue(this, null);
if (currentArgument.Expression != null)
{
if (currentArgument.Get(context) == null)
{
hostValues.Parameters.Remove(field.Name);
}
else
{
hostValues.Parameters[field.Name] = currentArgument.Get(context);
}
}
}
}
}
/// <summary>
/// Execute the logic for this activity...
/// </summary>
/// <param name="context"></param>
protected override void Execute(NativeActivityContext context)
{
// Retrieve our host overrides
HostParameterDefaults hostValues = context.GetExtension <HostParameterDefaults>();
PropertyDescriptorCollection col = context.DataContext.GetProperties();
string variableName = null;
if (VariableToRetrieve != PSWorkflowRuntimeVariable.Other)
{
// Get the symbolic name for the enum
variableName = LanguagePrimitives.ConvertTo <string>(VariableToRetrieve);
}
else
{
if (OtherVariableName.Expression != null)
{
string value = OtherVariableName.Get(context);
if (!string.IsNullOrWhiteSpace(value))
{
variableName = value;
}
}
}
//BUGBUG need a better exception here, could also do this as a custom validator
// Make sure we have a variable here...
if (string.IsNullOrWhiteSpace(variableName))
{
throw new InvalidOperationException("OtherVariable");
}
object valueToReturn = null;
PSDataCollection <PSObject> outputStream = null;
foreach (System.ComponentModel.PropertyDescriptor property in context.DataContext.GetProperties())
{
if (string.Equals(property.Name, "ParameterDefaults", StringComparison.OrdinalIgnoreCase))
{
foreach (var parameter in ((Microsoft.PowerShell.Activities.HostParameterDefaults)property.GetValue(context.DataContext)).Parameters)
{
if (parameter.Key.Equals(variableName, StringComparison.OrdinalIgnoreCase))
{
valueToReturn = parameter.Value;
}
else if (parameter.Key.Equals("Result"))
{
outputStream = parameter.Value as PSDataCollection <PSObject>;
}
}
//
// If the property to return was all, then just return the entire collection as a hashtable.
// (We still needed to loop to find the output stream to write into.)
//
if (VariableToRetrieve == PSWorkflowRuntimeVariable.All)
{
System.Collections.Hashtable workflowRuntimeVariables = new System.Collections.Hashtable(StringComparer.OrdinalIgnoreCase);
string[] enumNames = VariableToRetrieve.GetType().GetEnumNames();
// Skipping last two enum names, Other and All, as they are not actual variable names
//
for (int i = 0; i < (enumNames.Length - 2); i++)
{
workflowRuntimeVariables.Add(enumNames[i], null);
}
Dictionary <String, Object> dictionaryParam = ((Microsoft.PowerShell.Activities.HostParameterDefaults)property.GetValue(context.DataContext)).Parameters;
foreach (string varKey in dictionaryParam.Keys)
{
// We need to get the values of required runtime variables only, not evrything from DataContext parameters
//
if (workflowRuntimeVariables.ContainsKey(varKey))
{
Object value = null;
dictionaryParam.TryGetValue(varKey, out value);
workflowRuntimeVariables[varKey] = value;
}
}
valueToReturn = workflowRuntimeVariables;
}
break;
}
}
if (this.Result.Expression != null)
{
this.Result.Set(context, valueToReturn);
}
else if (outputStream != null)
{
if (valueToReturn != null)
{
outputStream.Add(PSObject.AsPSObject(valueToReturn));
}
}
else
{
//BUGBUG need a better exception here...
throw new InvalidOperationException("Result");
}
}
/// <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 PopulateSteamsData(PSResumableActivityContext arguments, NativeActivityContext context, HostParameterDefaults hostValues)
{
if (arguments.Streams.OutputStream != null)
{
if (base.Result.Expression == null)
{
if (hostValues.Parameters["Result"] != null && hostValues.Parameters["Result"].GetType() == typeof(PSDataCollection<PSObject>))
{
PSDataCollection<PSObject> item = hostValues.Parameters["Result"] as PSDataCollection<PSObject>;
if (item != arguments.Streams.OutputStream && item != null && item.IsOpen)
{
foreach (PSObject outputStream in arguments.Streams.OutputStream)
{
item.Add(outputStream);
}
}
}
}
else
{
base.Result.Set(context, arguments.Streams.OutputStream);
}
}
if (arguments.Streams.InputStream != null)
{
if (base.Input.Expression == null)
{
if (hostValues.Parameters["Input"] != null && hostValues.Parameters["Input"].GetType() == typeof(PSDataCollection<PSObject>))
{
hostValues.Parameters["Input"] = arguments.Streams.InputStream;
}
}
else
{
base.Input.Set(context, arguments.Streams.InputStream);
}
}
if (arguments.Streams.ErrorStream != null)
{
if (this.PSError.Expression == null)
{
if (hostValues.Parameters["PSError"] != null && hostValues.Parameters["PSError"].GetType() == typeof(PSDataCollection<ErrorRecord>))
{
PSDataCollection<ErrorRecord> errorRecords = hostValues.Parameters["PSError"] as PSDataCollection<ErrorRecord>;
if (errorRecords != arguments.Streams.ErrorStream && errorRecords != null && errorRecords.IsOpen)
{
foreach (ErrorRecord errorStream in arguments.Streams.ErrorStream)
{
errorRecords.Add(errorStream);
}
}
}
}
else
{
this.PSError.Set(context, arguments.Streams.ErrorStream);
}
}
if (arguments.Streams.WarningStream != null)
{
if (this.PSWarning.Expression == null)
{
if (hostValues.Parameters["PSWarning"] != null && hostValues.Parameters["PSWarning"].GetType() == typeof(PSDataCollection<WarningRecord>))
{
PSDataCollection<WarningRecord> warningRecords = hostValues.Parameters["PSWarning"] as PSDataCollection<WarningRecord>;
if (warningRecords != arguments.Streams.WarningStream && warningRecords != null && warningRecords.IsOpen)
{
foreach (WarningRecord warningStream in arguments.Streams.WarningStream)
{
warningRecords.Add(warningStream);
}
}
}
}
else
{
this.PSWarning.Set(context, arguments.Streams.WarningStream);
}
}
if (arguments.Streams.ProgressStream != null)
{
if (this.PSProgress.Expression == null)
{
if (hostValues.Parameters["PSProgress"] != null && hostValues.Parameters["PSProgress"].GetType() == typeof(PSDataCollection<ProgressRecord>))
{
PSDataCollection<ProgressRecord> progressRecords = hostValues.Parameters["PSProgress"] as PSDataCollection<ProgressRecord>;
if (progressRecords != arguments.Streams.ProgressStream && progressRecords != null && progressRecords.IsOpen)
{
foreach (ProgressRecord progressStream in arguments.Streams.ProgressStream)
{
progressRecords.Add(progressStream);
}
}
}
}
else
{
this.PSProgress.Set(context, arguments.Streams.ProgressStream);
}
}
if (arguments.Streams.VerboseStream != null)
{
if (this.PSVerbose.Expression == null)
{
if (hostValues.Parameters["PSVerbose"] != null && hostValues.Parameters["PSVerbose"].GetType() == typeof(PSDataCollection<VerboseRecord>))
{
PSDataCollection<VerboseRecord> verboseRecords = hostValues.Parameters["PSVerbose"] as PSDataCollection<VerboseRecord>;
if (verboseRecords != arguments.Streams.VerboseStream && verboseRecords != null && verboseRecords.IsOpen)
{
foreach (VerboseRecord verboseStream in arguments.Streams.VerboseStream)
{
verboseRecords.Add(verboseStream);
}
}
}
}
else
{
this.PSVerbose.Set(context, arguments.Streams.VerboseStream);
}
}
if (arguments.Streams.DebugStream != null)
{
if (this.PSDebug.Expression == null)
{
if (hostValues.Parameters["PSDebug"] != null && hostValues.Parameters["PSDebug"].GetType() == typeof(PSDataCollection<DebugRecord>))
{
PSDataCollection<DebugRecord> debugRecords = hostValues.Parameters["PSDebug"] as PSDataCollection<DebugRecord>;
if (debugRecords != arguments.Streams.DebugStream && debugRecords != null && debugRecords.IsOpen)
{
foreach (DebugRecord debugStream in arguments.Streams.DebugStream)
{
debugRecords.Add(debugStream);
}
}
}
}
else
{
this.PSDebug.Set(context, arguments.Streams.DebugStream);
return;
}
}
}
internal static PSWorkflowHost GetWorkflowHost(HostParameterDefaults defaults)
{
PSWorkflowHost instance = null;
if (defaults != null && defaults.Runtime != null)
{
PSWorkflowHost runtime = defaults.Runtime;
Interlocked.CompareExchange<PSWorkflowHost>(ref instance, runtime, null);
}
if (instance == null)
{
instance = DefaultWorkflowHost.Instance;
}
return instance;
}