/// <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();
}
public InvokeParallelTests()
{
var iss = InitialSessionState.Create();
iss.LanguageMode = PSLanguageMode.FullLanguage;
iss.Commands.Add(new []
{
new SessionStateCmdletEntry("Write-Error", typeof(WriteErrorCommand), null),
new SessionStateCmdletEntry("Write-Verbose", typeof(WriteVerboseCommand), null),
new SessionStateCmdletEntry("Write-Debug", typeof(WriteDebugCommand), null),
new SessionStateCmdletEntry("Write-Progress", typeof(WriteProgressCommand), null),
new SessionStateCmdletEntry("Write-Warning", typeof(WriteWarningCommand), null),
new SessionStateCmdletEntry("Write-Information", typeof(WriteInformationCommand), null),
new SessionStateCmdletEntry("Invoke-Parallel", typeof(InvokeParallelCommand), null),
});
iss.Providers.Add(new SessionStateProviderEntry("Function", typeof(FunctionProvider), null));
iss.Providers.Add(new SessionStateProviderEntry("Variable", typeof(VariableProvider), null));
iss.Variables.Add(new []
{
new SessionStateVariableEntry("ErrorActionPreference", ActionPreference.Continue, "Dictates the action taken when an error message is delivered"),
});
m_runspacePool = RunspaceFactory.CreateRunspacePool(iss);
m_runspacePool.SetMaxRunspaces(10);
m_runspacePool.Open();
}
/// <summary>
/// Initialize the runspace pool.
/// </summary>
/// <param name="minRunspaces"></param>
/// <param name="maxRunspaces"></param>
public void InitializeRunspaces(int minRunspaces, int maxRunspaces, string[] modulesToLoad)
{
// create the default session state.
// session state can be used to set things like execution policy, language constraints, etc.
// optionally load any modules (by name) that were supplied.
var defaultSessionState = InitialSessionState.CreateDefault();
defaultSessionState.ExecutionPolicy = Microsoft.PowerShell.ExecutionPolicy.Unrestricted;
foreach (var moduleName in modulesToLoad)
{
defaultSessionState.ImportPSModule(moduleName);
}
// use the runspace factory to create a pool of runspaces
// with a minimum and maximum number of runspaces to maintain.
RsPool = RunspaceFactory.CreateRunspacePool(defaultSessionState);
RsPool.SetMinRunspaces(minRunspaces);
RsPool.SetMaxRunspaces(maxRunspaces);
// set the pool options for thread use.
// we can throw away or re-use the threads depending on the usage scenario.
RsPool.ThreadOptions = PSThreadOptions.UseNewThread;
// open the pool.
// this will start by initializing the minimum number of runspaces.
RsPool.Open();
}
public static ExamplePowerShellService Create(int maxRunspaces)
{
RunspacePool runspacePool = RunspaceFactory.CreateRunspacePool(minRunspaces: 1, maxRunspaces);
runspacePool.Open();
return(new ExamplePowerShellService(runspacePool));
}
/// <summary>
/// Initialize the runspace pool.
/// </summary>
/// <param name="runspace">Contains runspace config parameters necessary for the script</param>
public void InitializeRunspaces(ScriptRunspace runspace)
{
// create the default session state.
// session state can be used to set things like execution policy, language constraints, etc.
var defaultSessionState = InitialSessionState.CreateDefault();
if (!String.IsNullOrEmpty(runspace.ExecutionPolicy))
{
defaultSessionState.ExecutionPolicy = runspace.ExecutionPolicy.ToEnum <Microsoft.PowerShell.ExecutionPolicy>();
}
// optionally load any modules (by name) that were supplied.
foreach (var moduleName in runspace.Modules)
{
defaultSessionState.ImportPSModule(moduleName);
}
// use the runspace factory to create a pool of runspaces with a minimum and maximum number of runspaces to maintain.
RsPool = RunspaceFactory.CreateRunspacePool(defaultSessionState);
RsPool.SetMinRunspaces(runspace.Min);
RsPool.SetMaxRunspaces(runspace.Max);
// set the pool options for thread use.
// we can throw away or re-use the threads depending on the usage scenario.
RsPool.ThreadOptions = PSThreadOptions.UseNewThread;
// open the pool. this will start by initializing the minimum number of runspaces.
RsPool.Open();
}
/// <summary>
/// Create a fresh command info cache instance.
/// </summary>
public CommandInfoCache(Helper pssaHelperInstance)
{
_commandInfoCache = new ConcurrentDictionary <CommandLookupKey, Lazy <CommandInfo> >();
_helperInstance = pssaHelperInstance;
_runspacePool = RunspaceFactory.CreateRunspacePool(1, 10);
_runspacePool.Open();
}
/// <summary>
/// Creates an instance of the AnalysisService class.
/// </summary>
/// <param name="settingsPath">Path to a PSScriptAnalyzer settings file.</param>
/// <param name="logger">An ILogger implementation used for writing log messages.</param>
public AnalysisService(string settingsPath, ILogger logger)
{
this.logger = logger;
try
{
this.SettingsPath = settingsPath;
scriptAnalyzerModuleInfo = FindPSScriptAnalyzerModule(logger);
var sessionState = InitialSessionState.CreateDefault2();
sessionState.ImportPSModulesFromPath(scriptAnalyzerModuleInfo.ModuleBase);
// runspacepool takes care of queuing commands for us so we do not
// need to worry about executing concurrent commands
this.analysisRunspacePool = RunspaceFactory.CreateRunspacePool(sessionState);
// having more than one runspace doesn't block code formatting if one
// runspace is occupied for diagnostics
this.analysisRunspacePool.SetMaxRunspaces(NumRunspaces);
this.analysisRunspacePool.ThreadOptions = PSThreadOptions.ReuseThread;
this.analysisRunspacePool.Open();
ActiveRules = IncludedRules.ToArray();
EnumeratePSScriptAnalyzerRules();
}
catch (Exception e)
{
var sb = new StringBuilder();
sb.AppendLine("PSScriptAnalyzer cannot be imported, AnalysisService will be disabled.");
sb.AppendLine(e.Message);
this.logger.Write(LogLevel.Warning, sb.ToString());
}
}
public InvokeParallelTests()
{
_iss = CreateInitialSessionState();
m_runspacePool = RunspaceFactory.CreateRunspacePool(_iss);
m_runspacePool.SetMaxRunspaces(10);
m_runspacePool.Open();
}
private static void InitSharedPool()
{
if (_sharedRunspacePool == null)
{
_sharedRunspacePool = new OnDisposable <RunspacePool>(RunspaceFactory.CreateRunspacePool());
_sharedRunspacePool.Value.Open();
}
}
public static PowerShellJob MakePowerShellJob(Action <PowerShell> configure,
Action <dynamic> process, Action <Exception> errors = null)
{
var pShell = new PowerShellJob((runspacePool) =>
{
try
{
using (var localRunspacePool = RunspaceFactory.CreateRunspacePool())
{
localRunspacePool.Open();
using (var engine = PowerShell.Create())
{
engine.RunspacePool = localRunspacePool;
engine.AddScript(@"");
//engine.AddScript(@"Import-Module RemoteDesktop");
//engine.Commands.AddCommand("Import-Module").AddArgument("ActiveDirectory");
var importResult = engine.BeginInvoke();
var result = engine.EndInvoke(importResult);
configure(engine);
var invokeResult = engine.BeginInvoke();
var commandIter = engine.EndInvoke(invokeResult);
if (engine.Streams.Error != null &&
engine.Streams.Error.Count > 0)
{
ErrorHelper.WriteErrorToEventLog(PowerShellJob.GetErrorMessage(engine.Streams.Error));
throw new Exception(PowerShellJob.GetErrorMessage(engine.Streams.Error));
}
foreach (dynamic psObject in commandIter)
{
if (process != null)
{
process(psObject);
}
}
}
}
return(true);
}
catch (Exception ex)
{
ErrorHelper.WriteErrorToEventLog(ex.Message);
if (errors != null)
{
errors(ex);
}
}
return(false);
});
pShell.ReOccuring = false;
return(pShell);
}
/// <summary>
/// Runs many commands with the help of a RunspacePool.
/// </summary>
/// <param name="args">This parameter is unused.</param>
private static void Main(string[] args)
{
// Creating and opening runspace pool. Use a minimum of 1 runspace and a maximum of
// 5 runspaces can be opened at the same time.
RunspacePool runspacePool = RunspaceFactory.CreateRunspacePool(1, 5);
runspacePool.Open();
using (runspacePool)
{
// Define the commands to be run.
List <PowerShell> powerShellCommands = new List <PowerShell>();
// The command results.
List <IAsyncResult> powerShellCommandResults = new List <IAsyncResult>();
// The maximum number of runspaces that can be opened at one time is
// 5, but we can queue up many more commands that will use the
// runspace pool.
for (int i = 0; i < 100; i++)
{
// Using a PowerShell object, run the commands.
PowerShell powershell = PowerShell.Create();
// Instead of setting the Runspace property of powershell,
// the RunspacePool property is used. That is the only difference
// between running commands with a runspace and running commands
// with a runspace pool.
powershell.RunspacePool = runspacePool;
// The script to be run outputs a sequence number and the number of available runspaces
// in the pool.
string script = String.Format(
"write-output ' Command: {0}, Available Runspaces: {1}'",
i,
runspacePool.GetAvailableRunspaces());
// The three lines below look the same running with a runspace or
// with a runspace pool.
powershell.AddScript(script);
powerShellCommands.Add(powershell);
powerShellCommandResults.Add(powershell.BeginInvoke());
}
// Collect the results.
for (int i = 0; i < 100; i++)
{
// EndInvoke will wait for each command to finish, so we will be getting the commands
// in the same 0 to 99 order that they have been invoked withy BeginInvoke.
PSDataCollection <PSObject> results = powerShellCommands[i].EndInvoke(powerShellCommandResults[i]);
// Print all the results. One PSObject with a plain string is the expected result.
PowerShell02.PrintCollection(results);
}
}
}
/// <summary>
/// Create a new runspace pool around a PSScriptAnalyzer module for asynchronous script analysis tasks.
/// This looks for the latest version of PSScriptAnalyzer on the path and loads that.
/// </summary>
/// <returns>A runspace pool with PSScriptAnalyzer loaded for running script analysis tasks.</returns>
private static RunspacePool CreatePssaRunspacePool(out PSModuleInfo pssaModuleInfo)
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Run `Get-Module -ListAvailable -Name "PSScriptAnalyzer"`
ps.AddCommand("Get-Module")
.AddParameter("ListAvailable")
.AddParameter("Name", PSSA_MODULE_NAME);
try
{
using (PSModulePathPreserver.Take())
{
// Get the latest version of PSScriptAnalyzer we can find
pssaModuleInfo = ps.Invoke <PSModuleInfo>()?
.OrderByDescending(moduleInfo => moduleInfo.Version)
.FirstOrDefault();
}
}
catch (Exception e)
{
throw new FileNotFoundException("Unable to find PSScriptAnalyzer module on the module path", e);
}
if (pssaModuleInfo == null)
{
throw new FileNotFoundException("Unable to find PSScriptAnalyzer module on the module path");
}
// Now that we know where the PSScriptAnalyzer we want to use is,
// create a base session state with PSScriptAnalyzer loaded
#if DEBUG
InitialSessionState sessionState = Environment.GetEnvironmentVariable("PSES_TEST_USE_CREATE_DEFAULT") == "1"
? InitialSessionState.CreateDefault()
: InitialSessionState.CreateDefault2();
#else
InitialSessionState sessionState = InitialSessionState.CreateDefault2();
#endif
sessionState.ImportPSModule(new [] { pssaModuleInfo.ModuleBase });
RunspacePool runspacePool = RunspaceFactory.CreateRunspacePool(sessionState);
runspacePool.SetMaxRunspaces(1);
runspacePool.ThreadOptions = PSThreadOptions.ReuseThread;
// Open the runspace pool here so we can deterministically handle the PSModulePath change issue
using (PSModulePathPreserver.Take())
{
runspacePool.Open();
}
return(runspacePool);
}
}
/// <summary>
/// Runs commmands or script in a new
/// PowerShell runspace pool.
/// </summary>
/// <param name="script"></param>
/// <param name="parameters"></param>
/// <returns>PSResults object: A collection of PSObjects that were returned from the script or command, and
/// the error and information streams.
/// </returns>
public static PSResults RunPowerShellScript(string script, Dictionary <String, Object> parameters)
{
Collection <PSObject> objects;
using (RunspacePool rsp = RunspaceFactory.CreateRunspacePool())
{
rsp.Open();
PowerShell instance = null;
try
{
instance = PowerShell.Create();
instance.RunspacePool = rsp;
instance.AddScript(script);
if (parameters != null)
{
foreach (var p in parameters)
{
instance.AddParameter(p.Key, p.Value);
}
}
objects = instance.Invoke();
var res = new PSResults();
res.ReturnedObjects = objects ?? new Collection <PSObject>();
if (instance.Streams.Error.Count > 0)
{
res.Errors = new ErrorRecord[instance.Streams.Error.Count];
instance.Streams.Error.CopyTo(res.Errors, 0);
}
else
{
res.Errors = new ErrorRecord[0];
}
if (instance.Streams.Information.Count > 0)
{
res.Information = new InformationRecord[instance.Streams.Information.Count];
instance.Streams.Information.CopyTo(res.Information, 0);
}
else
{
res.Information = new InformationRecord[0];
}
return(res);
}
finally
{
instance?.Dispose();
}
}
}
static PSControllerExtensions()
{
int maxWorkerThreads, maxIOThreads;
ThreadPool.GetMaxThreads(out maxWorkerThreads, out maxIOThreads);
_runspacePool = RunspaceFactory.CreateRunspacePool(1, maxWorkerThreads);
_runspacePool.Open();
_escapedNewLine = Uri.EscapeDataString(Environment.NewLine).ToLower();
}
public static (string, string) WSManConnectToExO(string admin, string pass)
{
using (var ps = PowerShell.Create())
{
var secureString = new SecureString();
pass.ToCharArray().ToList().ForEach(p => secureString.AppendChar(p));
var credential = new PSCredential(admin, secureString);
var connectionInfo = new WSManConnectionInfo(
new Uri("https://outlook.office365.com/powershell-liveid/"),
"http://schemas.microsoft.com/powershell/Microsoft.Exchange",
credential);
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Basic;
connectionInfo.MaximumConnectionRedirectionCount = 2;
var pool = RunspaceFactory.CreateRunspacePool(1, 5, connectionInfo);
pool.ThreadOptions = PSThreadOptions.UseNewThread;
pool.Open();
ps.RunspacePool = pool;
ps.AddCommand("Get-Mailbox");
ps.AddParameter("Identity", admin);
ps.AddCommand("Select-Object");
ps.AddParameter("ExpandProperty", "EmailAddresses");
List <PSObject> results = ps.Invoke().ToList();
string errors = "";
if (ps.Streams.Error.Count > 0)
{
errors = "!Errors! " + String.Join(" :: ", ps.StreamErrorsToErrorList());
}
if (!results.Any())
{
errors += "Identity not found";
}
var addressesArray = results.Select(psObject => psObject.Properties["ProxyAddressString"].Value.ToString()).ToList();
var aliasAddresses = (from address in addressesArray where address.StartsWith("smtp:", StringComparison.InvariantCulture) select address.Substring("smtp:".Length)).ToList();
var addresses = addressesArray.Where(a => !a.StartsWith("SMTP:")).ToList();
StringBuilder stb = new StringBuilder();
stb.AppendLine("Alias addresses: " + String.Join(",", aliasAddresses));
stb.AppendLine("SMTP: " + String.Join(",", addresses));
pool.Close();
return(errors, stb.ToString());
}
}
/// <summary>
/// Create a new runspace pool around a PSScriptAnalyzer module for asynchronous script analysis tasks.
/// This looks for the latest version of PSScriptAnalyzer on the path and loads that.
/// </summary>
/// <returns>A runspace pool with PSScriptAnalyzer loaded for running script analysis tasks.</returns>
private static RunspacePool CreatePssaRunspacePool(out PSModuleInfo pssaModuleInfo)
{
using (var ps = System.Management.Automation.PowerShell.Create(RunspaceMode.NewRunspace))
{
// Run `Get-Module -ListAvailable -Name "PSScriptAnalyzer"`
ps.AddCommand("Get-Module")
.AddParameter("ListAvailable")
.AddParameter("Name", PSSA_MODULE_NAME);
try
{
using (PSModulePathPreserver.Take())
{
// Get the latest version of PSScriptAnalyzer we can find
pssaModuleInfo = ps.Invoke <PSModuleInfo>()?
.OrderByDescending(moduleInfo => moduleInfo.Version)
.FirstOrDefault();
}
}
catch (Exception e)
{
throw new FileNotFoundException("Unable to find PSScriptAnalyzer module on the module path", e);
}
if (pssaModuleInfo == null)
{
throw new FileNotFoundException("Unable to find PSScriptAnalyzer module on the module path");
}
// Now that we know where the PSScriptAnalyzer we want to use is, create a base
// session state with PSScriptAnalyzer loaded
//
// We intentionally use `CreateDefault2()` as it loads `Microsoft.PowerShell.Core`
// only, which is a more minimal and therefore safer state.
InitialSessionState sessionState = InitialSessionState.CreateDefault2();
sessionState.ImportPSModule(new [] { pssaModuleInfo.ModuleBase });
RunspacePool runspacePool = RunspaceFactory.CreateRunspacePool(sessionState);
runspacePool.SetMaxRunspaces(1);
runspacePool.ThreadOptions = PSThreadOptions.ReuseThread;
// Open the runspace pool here so we can deterministically handle the PSModulePath change issue
using (PSModulePathPreserver.Take())
{
runspacePool.Open();
}
return(runspacePool);
}
}
public PowershellEngine()
{
var iss = InitialSessionState.CreateDefault2();
_runspace = RunspaceFactory.CreateRunspacePool(iss);
_runspace.Open();
using (var ps = CreateShell())
{
ps.AddScript("import-module Hyper-V -RequiredVersion 1.1");
ps.Invoke();
}
}
internal ServerRunspacePoolDriver(
Guid clientRunspacePoolId,
int minRunspaces,
int maxRunspaces,
PSThreadOptions threadOptions,
ApartmentState apartmentState,
HostInfo hostInfo,
InitialSessionState initialSessionState,
PSPrimitiveDictionary applicationPrivateData,
ConfigurationDataFromXML configData,
AbstractServerSessionTransportManager transportManager,
bool isAdministrator,
RemoteSessionCapability serverCapability)
{
using (ServerRunspacePoolDriver.tracer.TraceConstructor((object)this))
{
this.serverCapability = serverCapability;
ServerRemoteHost serverRemoteHost = new ServerRemoteHost(clientRunspacePoolId, Guid.Empty, hostInfo, (AbstractServerTransportManager)transportManager);
this.remoteHost = serverRemoteHost;
this.configData = configData;
this.applicationPrivateData = applicationPrivateData;
this.localRunspacePool = RunspaceFactory.CreateRunspacePool(minRunspaces, maxRunspaces, initialSessionState, (PSHost)serverRemoteHost);
PSThreadOptions psThreadOptions = configData.ShellThreadOptions.HasValue ? configData.ShellThreadOptions.Value : PSThreadOptions.UseCurrentThread;
if (threadOptions == PSThreadOptions.Default || threadOptions == psThreadOptions)
{
this.localRunspacePool.ThreadOptions = psThreadOptions;
}
else
{
if (!isAdministrator)
{
throw new InvalidOperationException(PSRemotingErrorInvariants.FormatResourceString(PSRemotingErrorId.MustBeAdminToOverrideThreadOptions));
}
this.localRunspacePool.ThreadOptions = threadOptions;
}
ApartmentState apartmentState1 = configData.ShellThreadApartmentState.HasValue ? configData.ShellThreadApartmentState.Value : ApartmentState.Unknown;
this.localRunspacePool.ApartmentState = apartmentState == ApartmentState.Unknown || apartmentState == apartmentState1 ? apartmentState1 : apartmentState;
this.clientRunspacePoolId = clientRunspacePoolId;
this.dsHandler = new ServerRunspacePoolDataStructureHandler(this, transportManager);
this.localRunspacePool.StateChanged += new EventHandler <RunspacePoolStateChangedEventArgs>(this.HandleRunspacePoolStateChanged);
this.localRunspacePool.ForwardEvent += new EventHandler <PSEventArgs>(this.HandleRunspacePoolForwardEvent);
this.localRunspacePool.RunspaceCreated += new EventHandler <RunspaceCreatedEventArgs>(this.HandleRunspaceCreated);
this.localRunspacePool.RunspaceCreated += new EventHandler <RunspaceCreatedEventArgs>(this.HandleRunspaceCreatedForTypeTable);
this.dsHandler.CreateAndInvokePowerShell += new EventHandler <RemoteDataEventArgs <RemoteDataObject <PSObject> > >(this.HandleCreateAndInvokePowerShell);
this.dsHandler.GetCommandMetadata += new EventHandler <RemoteDataEventArgs <RemoteDataObject <PSObject> > >(this.HandleGetCommandMetadata);
this.dsHandler.HostResponseReceived += new EventHandler <RemoteDataEventArgs <RemoteHostResponse> >(this.HandleHostResponseReceived);
this.dsHandler.SetMaxRunspacesReceived += new EventHandler <RemoteDataEventArgs <PSObject> >(this.HandleSetMaxRunspacesReceived);
this.dsHandler.SetMinRunspacesReceived += new EventHandler <RemoteDataEventArgs <PSObject> >(this.HandleSetMinRunspacesReceived);
this.dsHandler.GetAvailableRunspacesReceived += new EventHandler <RemoteDataEventArgs <PSObject> >(this.HandleGetAvailalbeRunspacesReceived);
}
}
protected override void BeginProcessing()
{
base.BeginProcessing();
sessionState = InitialSessionState.CreateDefault();
WriteVerbose("Created initial session state..");
runspacePool = RunspaceFactory.CreateRunspacePool(1, maxThreads, sessionState, this.Host);
runspacePool.Open();
WriteVerbose("Runspace pool created..");
scriptBlock = InvokeCommand.NewScriptBlock(string.Format("param($_)\r\n{0}", scriptBlock.ToString()));
WriteVerbose("Modified scriptblock..");
}
protected override void BeginProcessing()
{
// Build the results
ArrayList final = new ArrayList();
Hashtable rsColl = new Hashtable();
int c = 0;
using (RunspacePool runspacePool = RunspaceFactory.CreateRunspacePool(1, MaxThreads))
{
try
{
runspacePool.Open();
foreach (object obj in InputObject)
{
PowerShell powerShell = PowerShell.Create();
powerShell
.AddScript(ScriptBlock)
.AddArgument(obj);
try
{
powerShell.AddParameters(ArgumentList);
}
catch (Exception)
{
}
IAsyncResult psAsyncResult = powerShell.BeginInvoke();
rsColl.Add("psResult", psAsyncResult);
rsColl.Add("psPowerShell", powerShell);
//PSDataCollection<PSObject> psOutput = powerShell.EndInvoke(psAsyncResult);
//final.Add(psOutput);
//powerShell.Dispose();
} // End foreach
//runspacePool.Close();
//runspacePool.Dispose();
}
catch (Exception)
{
throw;
}
} // End using
// Output to console
WriteObject(final, true);
}
public PowershellPool(int poolSize, InitialSessionState initialSessionState, CancellationToken cancellationToken)
{
_poolMembers = new List <PowerShellPoolMember>(poolSize);
_processedCount = 0;
_cancellationToken = cancellationToken;
for (var i = 0; i < poolSize; i++)
{
var powerShellPoolMember = new PowerShellPoolMember(this, i + 1);
_poolMembers.Add(powerShellPoolMember);
_availablePoolMembers.Add(powerShellPoolMember);
}
_runspacePool = RunspaceFactory.CreateRunspacePool(initialSessionState);
_runspacePool.SetMaxRunspaces(poolSize);
}
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();
}
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);
}
public static PowerShellJob MakePowerShellJob <T>(Action <PowerShell> Configure,
Action <dynamic, List <T> > NewFunc, Func <List <T>, bool> SetList)
{
return(new PowerShellJob((runspacePool) =>
{
try
{
var curList = new List <T>();
using (var localRunspacePool = RunspaceFactory.CreateRunspacePool())
{
localRunspacePool.Open();
using (var engine = PowerShell.Create())
{
engine.RunspacePool = localRunspacePool;
engine.AddScript(@"Import-Module RemoteDesktop");
engine.Commands.AddCommand("Import-Module").AddArgument("ActiveDirectory");
var importResult = engine.BeginInvoke();
var result = engine.EndInvoke(importResult);
Configure(engine);
var invokeResult = engine.BeginInvoke();
var commandIter = engine.EndInvoke(invokeResult);
if (engine.Streams.Error.Count > 0)
{
ErrorHelper.WriteErrorToEventLog(PowerShellJob.GetErrorMessage(engine.Streams.Error));
throw new Exception(PowerShellJob.GetErrorMessage(engine.Streams.Error));
}
foreach (dynamic psObject in commandIter)
{
NewFunc(psObject, curList);
}
}
}
return SetList(curList);
}
catch (Exception ex)
{
ErrorHelper.WriteErrorToEventLog(ex.Message);
}
return false;
}, true));
}
/// <summary>
/// Create a new runspace pool around a PSScriptAnalyzer module for asynchronous script analysis tasks.
/// This looks for the latest version of PSScriptAnalyzer on the path and loads that.
/// </summary>
/// <returns>A runspace pool with PSScriptAnalyzer loaded for running script analysis tasks.</returns>
private static RunspacePool CreatePssaRunspacePool(out PSModuleInfo pssaModuleInfo)
{
using (var ps = System.Management.Automation.PowerShell.Create())
{
// Run `Get-Module -ListAvailable -Name "PSScriptAnalyzer"`
ps.AddCommand("Get-Module")
.AddParameter("ListAvailable")
.AddParameter("Name", PSSA_MODULE_NAME);
try
{
// Get the latest version of PSScriptAnalyzer we can find
pssaModuleInfo = ps.Invoke()?
.Select(psObj => psObj.BaseObject)
.OfType <PSModuleInfo>()
.OrderByDescending(moduleInfo => moduleInfo.Version)
.FirstOrDefault();
}
catch (Exception e)
{
throw new AnalysisServiceLoadException("Unable to find PSScriptAnalyzer module on the module path", e);
}
if (pssaModuleInfo == null)
{
throw new AnalysisServiceLoadException("Unable to find PSScriptAnalyzer module on the module path");
}
// Create a base session state with PSScriptAnalyzer loaded
InitialSessionState sessionState;
if (Environment.GetEnvironmentVariable("PSES_TEST_USE_CREATE_DEFAULT") == "1")
{
sessionState = InitialSessionState.CreateDefault();
}
else
{
sessionState = InitialSessionState.CreateDefault2();
}
sessionState.ImportPSModule(new [] { pssaModuleInfo.ModuleBase });
// RunspacePool takes care of queuing commands for us so we do not
// need to worry about executing concurrent commands
return(RunspaceFactory.CreateRunspacePool(sessionState));
}
}
public (string, string) InMemoryPfxRunspacePool()
{
// IApplicationEnvironment for ASP.NET Core
string asmPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string rootFolder = System.IO.Path.GetDirectoryName(asmPath);
var timer = Stopwatch.StartNew();
var defaultSessionState = InitialSessionState.CreateDefault();
defaultSessionState.ExecutionPolicy = Microsoft.PowerShell.ExecutionPolicy.Unrestricted;
defaultSessionState.ThrowOnRunspaceOpenError = true;
defaultSessionState.ImportPSModule(new string[] { "ExchangeOnlineManagement" });
defaultSessionState.Variables.Add(new SessionStateVariableEntry("exoAppId", AppId, "no description"));
defaultSessionState.Variables.Add(new SessionStateVariableEntry("exoOrganization", Organization, "no description"));
defaultSessionState.Variables.Add(new SessionStateVariableEntry("exoCertificate", Certificate, "no description"));
bool result = defaultSessionState.StartupScripts.Add(System.IO.Path.Combine(rootFolder, "ConnectExO.ps1"));
using (RunspacePool RsPool = RunspaceFactory.CreateRunspacePool(defaultSessionState))
{
RsPool.SetMinRunspaces(1);
RsPool.SetMaxRunspaces(3);
RsPool.ThreadOptions = PSThreadOptions.UseNewThread;
RsPool.Open();
var ts1 = timer.Elapsed;
using (var ps = PowerShell.Create())
{
ps.RunspacePool = RsPool;
// ps.Commands.Clear();
ps.Commands.AddCommand("Get-EXOMailBox")
.AddParameter("ResultSize", "unlimited");
// var pipelineObjects = await ps.InvokeAsync().ConfigureAwait(false);
List <PSObject> results = ps.Invoke().ToList();
var ts2 = timer.Elapsed;
return(FlattenErrors(ps), ResultsToSimpleString(results));
}
}
}
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();
}
static void Main(string[] args)
{
var connectionInfo = new WSManConnectionInfo()
{
Scheme = "https",
ComputerName = ConfigurationManager.AppSettings["ComputerName"],
Port = int.Parse(ConfigurationManager.AppSettings["Port"]),
Credential = new PSCredential(ConfigurationManager.AppSettings["UserName"],
ConfigurationManager.AppSettings["Password"]
.Aggregate(new SecureString(), (s, c) =>
{
s.AppendChar(c);
return(s);
})),
SkipCACheck = true
};
using (var rsPool = RunspaceFactory.CreateRunspacePool(1, 2, connectionInfo))
{
rsPool.Open();
var gpsCommand = PowerShell.Create().AddCommand("Get-Process");
gpsCommand.RunspacePool = rsPool;
var gpsCommandAsyncResult = gpsCommand.BeginInvoke();
var getServiceCommand = PowerShell.Create().AddCommand("Get-Service");
getServiceCommand.RunspacePool = rsPool;
var getServiceCommandAsyncResult = getServiceCommand.BeginInvoke();
var gpsCommandOutput = gpsCommand.EndInvoke(gpsCommandAsyncResult);
gpsCommandOutput.Select(result => string.Format("{0} {1}", result.Properties["ID"].Value, result.Properties["Name"].Value))
.ToList()
.ForEach(Console.WriteLine);
var getServiceCommandOutput = getServiceCommand.EndInvoke(getServiceCommandAsyncResult);
getServiceCommandOutput.Select(result => string.Format("{0} {1}", result.Properties["Status"].Value, result.Properties["Name"].Value))
.ToList()
.ForEach(Console.WriteLine);
rsPool.Close();
}
Console.ReadKey();
}
public void Start(int port = 3000, int minRunspaces = 1, int maxRunspaces = 1)
{
StopServer = false;
PowerShellPool = RunspaceFactory.CreateRunspacePool(minRunspaces, maxRunspaces);
PowerShellPool.Open();
Listener = InitListener(port);
Thread listenerThread = new Thread(async() => { await ListenerLoop(); });
listenerThread.Start();
// Loop until worker thread activates.
while (!listenerThread.IsAlive)
{
;
}
Log("App listening on Port: " + port + "!");
}
public async Task <object> CreateRunspacePool(object input)
{
var inputDict = input as IDictionary <string, object>;
if (inputDict == null)
{
throw new ArgumentException("input");
}
var runspaceKey = (string)inputDict["RunspaceKey"];
var startupScript = (string)inputDict["StartupScript"];
if (runspacePools.ContainsKey(runspaceKey))
{
throw new InvalidOperationException("Runspace already created with key" + runspaceKey);
}
if (string.IsNullOrEmpty(startupScript))
{
// Assign a dummy script if not provided.
startupScript = "Out-Null";
}
var initialState = InitialSessionState.CreateDefault();
var promptHandler = (Func <object, Task <object> >)inputDict["PromptHandler"];
PSEdgeRawUI rawUI = new PSEdgeRawUI();
PSEdgeHostUI hostUI = new PSEdgeHostUI(rawUI, promptHandler);
PSEdgeHost host = new PSEdgeHost(hostUI);
// inject the startup script in the runspace so it is invoked automatically.
initialState.Variables.Add(
new SessionStateVariableEntry("orbPrivate_RunspaceStartupScript", startupScript, "", ScopedItemOptions.AllScope));
var runspace = RunspaceFactory.CreateRunspacePool(MinRunspacesPerKey, MaxRunspacesPerKey, initialState, host);
await Task.Factory.FromAsync(runspace.BeginOpen, runspace.EndOpen, null);
runspacePools[runspaceKey] = runspace;
return(true);
}
