// In this function the activity action is performed
private void PerformWork(ActivityActionData data)
{
bool failed = false;
Exception exception = null;
try
{
// setting up the streams
data.command.Streams.Debug = data.streams.DebugStream;
data.command.Streams.Error = data.streams.ErrorStream;
data.command.Streams.Progress = data.streams.ProgressStream;
data.command.Streams.Verbose = data.streams.VerboseStream;
data.command.Streams.Warning = data.streams.WarningStream;
// Custom WinRM Workflow Endpoint details
// run CustomWorkflowEndpointSetup.ps1 in Powershell console as administrator, if you have not done.
//
WSManConnectionInfo connectionInfo = new WSManConnectionInfo();
connectionInfo.ShellUri = "http://schemas.microsoft.com/powershell/CustomeWorkflowEndpoint";
// Create runspace pool on custom workflow endpoint where command will be invoked
using (RunspacePool r = RunspaceFactory.CreateRunspacePool(1, 1, connectionInfo))
{
try
{
r.Open();
data.command.RunspacePool = r;
// now executing the powershell command.
data.command.Invoke(data.streams.InputStream, data.streams.OutputStream, new PSInvocationSettings());
}
finally
{
r.Close();
r.Dispose();
}
}
}
catch (Exception e)
{
// since work is getting performed on background thread so there should not be any exception.
failed = true;
exception = e;
}
// Now since activity action has already been performed so now we need to resume the execution of the
// workflow. This will be done by
PSWorkflowJob job = _runtime.JobManager.GetJob(data.jobInstanceId);
// Now resuming the job
if (failed)
{
job.ResumeBookmark(data.bookmark, this.SupportDisconnectedPSStreams, data.streams, exception);
}
else
{
job.ResumeBookmark(data.bookmark, this.SupportDisconnectedPSStreams, data.streams);
}
}
private static Collection <PSObject> runPowershellCommands(PSCommand commandsToRun)
{
if (pool.RunspacePoolStateInfo.State != RunspacePoolState.Opened)
{
pool.Close();
pool = RunspaceFactory.CreateRunspacePool(1, 5, connection);
pool.Open();
}
PowerShell powershell = PowerShell.Create();
powershell.Commands = commandsToRun;
powershell.RunspacePool = pool;
Collection <PSObject> results = powershell.Invoke();
powershell.Dispose();
return(results);
}
protected override void Dispose(bool disposing)
{
Stop();
RunspacePool.Close();
RunspacePool.Dispose();
RunspacePool = null;
base.Dispose(disposing);
}
public void Release()
{
if (null != _rsPool)
{
lock (this)
{
if (null != _rsPool)
{
_rsPool.Close();
_rsPool.Dispose();
_rsPool = null;
}
}
}
}
internal static void CleanupObjs(PSCmdlet invokeAll, FunctionInfo proxyFunctionInfo, RunspacePool runspacePool, bool isFromPipelineStoppedException,
bool isAsyncEnd = false, bool noFileLogging = false, bool quiet = false)
{
LogHelper.LogProgress("Completed", invokeAll, "Completed", quiet: quiet);
LogHelper.Log(fileVerboseLogTypes, "In Cleanup", invokeAll, noFileLogging);
if (!isFromPipelineStoppedException && proxyFunctionInfo != null)
{
ScriptBlock.Create(@"Remove-Item Function:" + proxyFunctionInfo.Name).Invoke();
}
if (!isAsyncEnd && runspacePool != null)
{
if (runspacePool.ConnectionInfo != null)
{
//runspacePool.Disconnect();
}
runspacePool.Close();
runspacePool.Dispose();
}
}
/// <summary>
/// Helper method to check any error condition after a stop call
/// and close the remote runspace/pool if the stop call failed due
/// to network outage problems.
/// </summary>
/// <param name="ex">Exception.</param>
private void CheckAndCloseRunspaceAfterStop(Exception ex)
{
PSRemotingTransportException transportException = ex as PSRemotingTransportException;
if (transportException != null &&
(transportException.ErrorCode == System.Management.Automation.Remoting.Client.WSManNativeApi.ERROR_WSMAN_SENDDATA_CANNOT_CONNECT ||
transportException.ErrorCode == System.Management.Automation.Remoting.Client.WSManNativeApi.ERROR_WSMAN_SENDDATA_CANNOT_COMPLETE ||
transportException.ErrorCode == System.Management.Automation.Remoting.Client.WSManNativeApi.ERROR_WSMAN_TARGETSESSION_DOESNOTEXIST))
{
object rsObject = shell.GetRunspaceConnection();
if (rsObject is Runspace)
{
Runspace runspace = (Runspace)rsObject;
if (runspace.RunspaceStateInfo.State == RunspaceState.Opened)
{
try
{
runspace.Close();
}
catch (PSRemotingTransportException)
{ }
}
}
else if (rsObject is RunspacePool)
{
RunspacePool runspacePool = (RunspacePool)rsObject;
if (runspacePool.RunspacePoolStateInfo.State == RunspacePoolState.Opened)
{
try
{
runspacePool.Close();
}
catch (PSRemotingTransportException)
{ }
}
}
}
}
private void CheckAndCloseRunspaceAfterStop(Exception ex)
{
PSRemotingTransportException exception = ex as PSRemotingTransportException;
if ((exception != null) && ((exception.ErrorCode == -2144108526) || (exception.ErrorCode == -2144108250)))
{
object runspaceConnection = this.shell.GetRunspaceConnection();
if (runspaceConnection is Runspace)
{
Runspace runspace = (Runspace)runspaceConnection;
if (runspace.RunspaceStateInfo.State == RunspaceState.Opened)
{
try
{
runspace.Close();
}
catch (PSRemotingTransportException)
{
}
}
}
else if (runspaceConnection is RunspacePool)
{
RunspacePool pool = (RunspacePool)runspaceConnection;
if (pool.RunspacePoolStateInfo.State == RunspacePoolState.Opened)
{
try
{
pool.Close();
}
catch (PSRemotingTransportException)
{
}
}
}
}
}
/// <summary>
/// This sample shows how to construct a remote RunspacePool and run
/// multiple commands concurrently using the runspaces of the pool.
/// </summary>
/// <param name="args">Parameter is not used.</param>
public static void Main(string[] args)
{
// Create a WSManConnectionInfo object using the default constructor to
// connexct to the "localhost". The WSManConnectionInfo object can also
// specify connections to remote computers.
WSManConnectionInfo connectionInfo = new WSManConnectionInfo();
// Create a remote runspace pool that uses the WSManConnectionInfo object.
// The minimum runspaces value of 1 and maximum runspaces value of 2 allows
// Windows PowerShell to open a maximum of 2 runspaces at the same time so
// that two commands can be run concurrently.
using (RunspacePool remoteRunspacePool =
RunspaceFactory.CreateRunspacePool(1, 2, connectionInfo))
{
// Call the Open() method to open a runspace and establish the connection.
remoteRunspacePool.Open();
// Call the Create() method to create a pipeline, call the AddCommand(string)
// method to add the "get-process" command, and then call the BeginInvoke()
// method to run the command asynchronously using the runspace pool.
PowerShell gpsCommand = PowerShell.Create().AddCommand("get-process");
gpsCommand.RunspacePool = remoteRunspacePool;
IAsyncResult gpsCommandAsyncResult = gpsCommand.BeginInvoke();
// The previous call does not block the current thread because it is
// running asynchronously. Because the remote runspace pool can open two
// runspaces, the second command can be run.
PowerShell getServiceCommand = PowerShell.Create().AddCommand("get-service");
getServiceCommand.RunspacePool = remoteRunspacePool;
IAsyncResult getServiceCommandAsyncResult = getServiceCommand.BeginInvoke();
// When you are ready to handle the output, wait for the command to complete
// before extracting results. A call to the EndInvoke() method will block and return
// the output.
PSDataCollection <PSObject> gpsCommandOutput = gpsCommand.EndInvoke(gpsCommandAsyncResult);
// Process the output as needed.
if ((gpsCommandOutput != null) && (gpsCommandOutput.Count > 0))
{
Console.WriteLine("The first output from running get-process command: ");
Console.WriteLine(
"Process Name: {0} Process Id: {1}",
gpsCommandOutput[0].Properties["ProcessName"].Value,
gpsCommandOutput[0].Properties["Id"].Value);
Console.WriteLine();
}
// Now process the output from second command. As discussed previously, wait
// for the command to complete before extracting the results.
PSDataCollection <PSObject> getServiceCommandOutput = getServiceCommand.EndInvoke(
getServiceCommandAsyncResult);
// Process the output of the second command as needed.
if ((getServiceCommandOutput != null) && (getServiceCommandOutput.Count > 0))
{
Console.WriteLine("The first output from running get-service command: ");
Console.WriteLine(
"Service Name: {0} Description: {1} State: {2}",
getServiceCommandOutput[0].Properties["ServiceName"].Value,
getServiceCommandOutput[0].Properties["DisplayName"].Value,
getServiceCommandOutput[0].Properties["Status"].Value);
}
// Once done with running all the commands, close the remote runspace pool.
// The Dispose() (called by using primitive) will call Close(), if it
// is not already called.
remoteRunspacePool.Close();
}
}
public void Stop()
{
StopServer = true;
PowerShellPool.Close();
Log("Server Stopped.");
}
protected override void BeginProcessing()
{
// Build the results
ArrayList final = new ArrayList();
int c = 0;
int count = InputObject.Count;
if (MaxThreads < 20)
{
MaxThreads = 20;
}
using (RunspacePool runspacePool = RunspaceFactory.CreateRunspacePool(1, MaxThreads))
{
try
{
runspacePool.Open();
ProgressRecord progressRecord = new ProgressRecord(1, "Action in progress...", "Processing...");
foreach (object obj in InputObject)
{
PowerShell powerShell = PowerShell.Create()
.AddScript(ScriptBlock)
.AddArgument(obj);
try
{
powerShell.AddParameters(ArgumentList);
}
catch (Exception)
{
}
powerShell.RunspacePool = runspacePool;
IAsyncResult psAsyncResult = powerShell.BeginInvoke();
c++;
int pVal = (c / count) * 100;
string sVal = String.Format("{0:N0}", pVal);
int perc = int.Parse(sVal);
string activity = c + " of " + count + " threads completed";
if (NoProgress.IsPresent == false)
{
progressRecord.PercentComplete = perc;
progressRecord.Activity = activity;
progressRecord.StatusDescription = perc + "% complete";
WriteProgress(progressRecord);
}
PSDataCollection <PSObject> psOutput = powerShell.EndInvoke(psAsyncResult);
final.Add(psOutput);
powerShell.Dispose();
} // End foreach
if (NoProgress.IsPresent == false)
{
progressRecord.PercentComplete = 100;
progressRecord.StatusDescription = "100% complete";
WriteProgress(progressRecord);
}
}
catch (Exception)
{
throw;
}
runspacePool.Close();
runspacePool.Dispose();
} // End using
// Output to console
WriteObject(final.ToArray(), true);
} // End begin
public void closeRunspacePool()
{
runspacePool.Close();
runspacePool.Dispose();
}