public InvokeParallelTests()
{
_iss = CreateInitialSessionState();
m_runspacePool = RunspaceFactory.CreateRunspacePool(_iss);
m_runspacePool.SetMaxRunspaces(10);
m_runspacePool.Open();
}
// ---------- CONSTRUCTORS ----------
/// <summary>
/// Inititalizes the PowerShellScript environment.
/// </summary>
/// <param name="log">An event log to log exceptions to. May be null if no exception logging is desired.</param>
/// <param name="pool">A runspace pool for the scripting environment to use. May be null if a new Runspace pool is desired.</param>
public PowerShellScript(EventLog.EventLog log, RunspacePool pool)
{
RunspacePool = null;
Log = log;
if (pool != null)
{
RunspacePool = pool;
// Open the Runspace Pool so it's ready for use.
if (RunspacePool.RunspacePoolStateInfo.State != RunspacePoolState.Opened)
{
RunspacePool.Open();
}
}
else
{
InitializeRunspacePool();
}
}
/// <summary>
/// Creates a new pool of Runspaces for this script to utilize.
/// </summary>
public void InitializeRunspacePool()
{
RunspacePool = RunspaceFactory.CreateRunspacePool();
// Open the Runspace Pool so it's ready for use.
RunspacePool.Open();
}
internal RestService(string serviceName, List<string> urls, List<RestCommand> commands, IEnumerable<string> modules)
: base(serviceName, typeof(DynamicPowershell).Assembly)
{
// we have to give it at least one assembly, even if there isn't any services in it.
// so I'm giving it a really small assembly
_serviceName = serviceName;
_activeCommands = commands;
_listenOnUrls = urls;
ReverseLookup.Clear();
var ss = InitialSessionState.CreateDefault();
ss.ImportPSModule(modules.ToArray());
RunspacePool = RunspaceFactory.CreateRunspacePool(ss);
RunspacePool.Open();
}
/// <summary>
/// Runs a PowerShell command/script asynchronously.
/// </summary>
/// <param name="commandText">The text of the command to run.</param>
/// <param name="pool">An open PowerShell Runspace pool this script will use to invoke its pipeline.</param>
/// <param name="callback">The callback function used to process the results of the asynchronous run.</param>
/// <param name="log">[Optional] The event log to log execptions to. May be null for no logging.</param>
/// <param name="input">[Optional] A collection of strings representing command-line input sent to the script during execution.</param>
/// <param name="stateValues">[Optional] A collection of named state values that should be passed through the invocation to the callback function.</param>
/// <param name="parameterList">An array of key/value objects defining additional parameters to supply to the PowerShell script.</param>
/// <returns>An WaitHandle object that can be used to determine when the scrip has completed execution. Null if an error occurred while processing the command / script.</returns>
public static WaitHandle RunAsynchronously(string commandText, ref RunspacePool pool, ProcessResults callback, EventLog.EventLog log = null, PSDataCollection<string> input = null, Dictionary<String, Object> stateValues = null, params KeyValuePair<String, Object>[] parameterList)
{
try
{
// Create the script object.
PS script = PS.Create();
// Use the runspace pool supplied or create a new one if not supplied.
if (pool == null)
{
pool = RunspaceFactory.CreateRunspacePool(DEFAULT_MIN_RUNSPACES_IN_POOL, DEFAULT_MAX_RUNSPACES_IN_POOL, CreateRunspaceConnectionInfo());
}
// Verify that the pool is open, otherwise open it.
if (pool.RunspacePoolStateInfo.State != RunspacePoolState.Opened)
{
pool.Open();
}
// Add the runspace pool to the script object.
script.RunspacePool = pool;
// Create the PowerShell command object.
Command command = new Command(commandText, true);
// Add parameters to the command.
if (parameterList != null)
{
foreach (KeyValuePair<string, object> param in parameterList)
{
command.Parameters.Add(new CommandParameter(param.Key, param.Value));
}
}
// Add the command to the script object.
script.Commands.AddCommand(command);
// Initialize the script input object if nothing was supplied.
if (input == null)
{
input = new PSDataCollection<string>();
}
// Initialize the state object to maintain data across the invocation.
PowerShellScriptState state = new PowerShellScriptState(script);
// Add the callback function used to process the results of the script invocation.
state.StateVariables.Add(PROCESS_RESULTS_CALLBACK, callback);
// Add any state values passed into the method.
if (stateValues != null)
{
foreach (string key in stateValues.Keys)
{
state.StateVariables.Add(key, stateValues[key]);
}
}
// Invoke the command asyncronously.
return (script.BeginInvoke(input, new PSInvocationSettings(), ProcessAsynchronousResults, state)).AsyncWaitHandle;
}
catch (Exception e)
{
LogException(e, log);
return null;
}
}
internal RestService(string serviceName, List<string> urls, List<RestCommand> commands, IEnumerable<string> modules)
: base(serviceName, GetActiveAssemblies().ToArray()) {
_serviceName = serviceName;
_activeCommands = commands;
_listenOnUrls = urls;
ReverseLookup.Clear();
var ss = InitialSessionState.CreateDefault();
ss.ImportPSModule(modules.ToArray());
RunspacePool = RunspaceFactory.CreateRunspacePool(ss);
RunspacePool.Open();
}