internal virtual Runspace OpenRunspace()
{
HostedSolutionLog.LogStart("OpenRunspace");
if (runspaceConfiguration == null)
{
runspaceConfiguration = RunspaceConfiguration.Create();
PSSnapInException exception = null;
PSSnapInInfo info = runspaceConfiguration.AddPSSnapIn(SharepointSnapInName, out exception);
HostedSolutionLog.LogInfo("Sharepoint snapin loaded");
if (exception != null)
{
HostedSolutionLog.LogWarning("SnapIn error", exception);
}
}
Runspace runSpace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
//
runSpace.Open();
//
runSpace.SessionStateProxy.SetVariable("ConfirmPreference", "none");
HostedSolutionLog.LogEnd("OpenRunspace");
return runSpace;
}
/// <summary>
/// Default Constructor copies all the data from the "default" RunspaceConfiguration
/// </summary>
public PoshRunspaceConfiguration()
{
_baseConfig = RunspaceConfiguration.Create();
// AuthorizationManager = baseConfig.AuthorizationManager;
// ToDo: Add the HuddledControls assembly to the Assemeblies
Assemblies.Append(_baseConfig.Assemblies);
Cmdlets.Append(_baseConfig.Cmdlets);
Formats.Append(_baseConfig.Formats);
InitializationScripts.Append(_baseConfig.InitializationScripts);
Providers.Append(_baseConfig.Providers);
Scripts.Append(_baseConfig.Scripts);
Types.Append(_baseConfig.Types);
// TODO: uncomment this if we start really using it
//foreach (var t in System.Reflection.Assembly.GetEntryAssembly().GetTypes())
//{
// var cmdlets = t.GetCustomAttributes(typeof(System.Management.Automation.CmdletAttribute), false) as System.Management.Automation.CmdletAttribute[];
// if (cmdlets != null)
// {
// foreach (var cmdlet in cmdlets)
// {
// Cmdlets.Append(new CmdletConfigurationEntry(
// string.Format("{0}-{1}", cmdlet.VerbName, cmdlet.NounName), t,
// string.Format("{0}.xml", t.Name)));
// }
// }
//}
}
private static string GetAndCheckFullFileName(
string psSnapinName,
Hashtable fullFileNameHash,
RunspaceConfiguration runspaceConfiguration,
string baseFolder,
string baseFileName,
Collection <string> independentErrors)
{
string path = !Path.IsPathRooted(baseFileName) ? Path.Combine(baseFolder, baseFileName) : baseFileName;
if (!File.Exists(path))
{
string str = ResourceManagerCache.FormatResourceString("TypesXml", "FileNotFound", (object)psSnapinName, (object)path);
independentErrors.Add(str);
return((string)null);
}
string str1 = (string)fullFileNameHash[(object)path];
if (str1 != null)
{
string str2 = ResourceManagerCache.FormatResourceString("TypesXml", "DuplicateFile", (object)psSnapinName, (object)path, (object)str1);
independentErrors.Add(str2);
return((string)null);
}
if (!path.EndsWith(".ps1xml", StringComparison.OrdinalIgnoreCase))
{
string str2 = ResourceManagerCache.FormatResourceString("TypesXml", "EntryShouldBeMshXml", (object)psSnapinName, (object)path);
independentErrors.Add(str2);
return((string)null);
}
fullFileNameHash.Add((object)path, (object)psSnapinName);
return(path);
}
internal static Collection <PSSnapInTypeAndFormatErrors> GetFormatAndTypesErrors(
RunspaceConfiguration runspaceConfiguration,
PSHost host,
IEnumerable <RunspaceConfigurationEntry> configurationEntryCollection,
Collection <string> independentErrors,
Collection <int> entryIndicesToRemove)
{
Collection <PSSnapInTypeAndFormatErrors> returnValue = new Collection <PSSnapInTypeAndFormatErrors>();
string baseFolder = GetBaseFolder(runspaceConfiguration, independentErrors);
var psHome = Utils.GetApplicationBase(Utils.DefaultPowerShellShellID);
// this hashtable will be used to check whether this is duplicated file for types or formats.
HashSet <string> fullFileNameSet = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
int index = -1;
foreach (var configurationEntry in configurationEntryCollection)
{
string fileName;
string psSnapinName = configurationEntry.PSSnapIn == null ? runspaceConfiguration.ShellId : configurationEntry.PSSnapIn.Name;
index++;
var typeEntry = configurationEntry as TypeConfigurationEntry;
if (typeEntry != null)
{
fileName = typeEntry.FileName;
if (fileName == null)
{
returnValue.Add(new PSSnapInTypeAndFormatErrors(psSnapinName, typeEntry.TypeData, typeEntry.IsRemove));
continue;
}
}
else
{
FormatConfigurationEntry formatEntry = (FormatConfigurationEntry)configurationEntry;
fileName = formatEntry.FileName;
if (fileName == null)
{
returnValue.Add(new PSSnapInTypeAndFormatErrors(psSnapinName, formatEntry.FormatData));
continue;
}
}
bool checkFileExists = configurationEntry.PSSnapIn == null || string.Equals(psHome, configurationEntry.PSSnapIn.AbsoluteModulePath, StringComparison.OrdinalIgnoreCase);
bool needToRemoveEntry = false;
string fullFileName = GetAndCheckFullFileName(psSnapinName, fullFileNameSet, baseFolder, fileName, independentErrors, ref needToRemoveEntry, checkFileExists);
if (fullFileName == null)
{
if (needToRemoveEntry)
{
entryIndicesToRemove.Add(index);
}
continue;
}
returnValue.Add(new PSSnapInTypeAndFormatErrors(psSnapinName, fullFileName));
}
return(returnValue);
}
/// <summary>
/// The principal constructor that most hosts will use when creating
/// an instance of the automation engine. It allows you to pass in an
/// instance of PSHost that provides the host-specific I/O routines, etc.
/// </summary>
internal AutomationEngine(PSHost hostInterface, RunspaceConfiguration runspaceConfiguration, InitialSessionState iss)
{
#if !CORECLR// There is no control panel items in CSS
// Update the env variable PathEXT to contain .CPL
var pathext = Environment.GetEnvironmentVariable("PathEXT");
pathext = pathext ?? string.Empty;
bool cplExist = false;
if (pathext != string.Empty)
{
string[] entries = pathext.Split(Utils.Separators.Semicolon);
foreach (string entry in entries)
{
string ext = entry.Trim();
if (ext.Equals(".CPL", StringComparison.OrdinalIgnoreCase))
{
cplExist = true;
break;
}
}
}
if (!cplExist)
{
pathext = (pathext == string.Empty) ? ".CPL" :
pathext.EndsWith(";", StringComparison.OrdinalIgnoreCase)
? (pathext + ".CPL") : (pathext + ";.CPL");
Environment.SetEnvironmentVariable("PathEXT", pathext);
}
#endif
if (runspaceConfiguration != null)
{
Context = new ExecutionContext(this, hostInterface, runspaceConfiguration);
}
else
{
Context = new ExecutionContext(this, hostInterface, iss);
}
EngineParser = new Language.Parser();
CommandDiscovery = new CommandDiscovery(Context);
// Initialize providers before loading types so that any ScriptBlocks in the
// types.ps1xml file can be parsed.
// Bind the execution context with RunspaceConfiguration.
// This has the side effect of initializing cmdlet cache and providers from runspace configuration.
if (runspaceConfiguration != null)
{
runspaceConfiguration.Bind(Context);
}
else
{
// Load the iss, resetting everything to it's defaults...
iss.Bind(Context, /*updateOnly*/ false);
}
InitialSessionState.SetSessionStateDrive(Context, true);
InitialSessionState.CreateQuestionVariable(Context);
}
public ExecutionContext(PSHost host, RunspaceConfiguration config)
: this()
{
RunspaceConfiguration = config;
LocalHost = host;
SessionStateGlobal = new SessionStateGlobal(this);
SessionState = new SessionState(SessionStateGlobal);
}
public static Runspace CreateRunspace(PSHost host)
{
if (host == null)
{
throw PSTraceSource.NewArgumentNullException("host");
}
return(CreateRunspace(host, RunspaceConfiguration.Create()));
}
/// <summary>
/// Initializes a new instance of the MyHost class. Keep
/// a reference to the host application object so that it
/// can be informed of when to exit.
/// </summary>
public ScriptingHost(ApplicationSettings settings, RunspaceConfiguration runspaceConfiguration)
{
this.runspaceConfiguration = runspaceConfiguration;
ui = new ScriptingHostUserInterface(settings);
pushedRunspaces = new Stack<Runspace>();
privateData = new ScriptingHostPrivateData(this);
CloseRunner = false;
}
public static Runspace CreateRunspace(RunspaceConfiguration runspaceConfiguration)
{
if (runspaceConfiguration == null)
{
throw RunspaceFactory._tracer.NewArgumentNullException(nameof(runspaceConfiguration));
}
return(RunspaceFactory.CreateRunspace((PSHost) new DefaultHost(Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.CurrentUICulture), runspaceConfiguration));
}
// TODO: make sure to implement a Singleton DefaultRunspace pattern
//internal static LocalRunspace DefaultRunspace { get; private set; }
public LocalRunspace(PSHost host, RunspaceConfiguration configuration)
{
DefaultRunspace = this;
PSHost = host;
_runspaceConfiguration = configuration;
ExecutionContext = new ExecutionContext(host, configuration);
ExecutionContext.CurrentRunspace = this;
}
public static Runspace CreateRunspace(RunspaceConfiguration runspaceConfiguration)
{
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
PSHost host = new DefaultHost(Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.CurrentUICulture);
return CreateRunspace(host, runspaceConfiguration);
}
internal RunspacePool(
int minRunspaces,
int maxRunspaces,
RunspaceConfiguration runspaceConfiguration,
PSHost host)
{
using (RunspacePool.tracer.TraceConstructor((object)this))
this.internalPool = new RunspacePoolInternal(minRunspaces, maxRunspaces, runspaceConfiguration, host);
}
private static RunspacePool CreateRunspacePool(
int minRunspaces,
int maxRunspaces,
RunspaceConfiguration runspaceConfiguration,
PSHost host)
{
using (RunspaceFactory._tracer.TraceMethod())
return(new RunspacePool(minRunspaces, maxRunspaces, runspaceConfiguration, host));
}
internal ExecutionContext(AutomationEngine engine, PSHost hostInterface, System.Management.Automation.Runspaces.RunspaceConfiguration runspaceConfiguration)
{
this.ignoreScriptDebug = true;
this.logContextCache = new System.Management.Automation.LogContextCache();
this._questionMarkVariableValue = true;
this._runspaceConfiguration = runspaceConfiguration;
this._authorizationManager = runspaceConfiguration.AuthorizationManager;
this.InitializeCommon(engine, hostInterface);
}
public Host(string name, Version version, PSHostUserInterface hostUI,
RunspaceConfiguration runspaceConfiguration)
{
_pushedRunspaces = new Stack<Runspace>();
_name = name;
_version = version;
_hostUI = hostUI;
_runspaceConfiguration = runspaceConfiguration;
_exitEvent = new ManualResetEvent(false);
}
/// <summary>
/// Constructor which creates a RunspacePool using the
/// supplied <paramref name="configuration"/>,
/// <paramref name="minRunspaces"/> and <paramref name="maxRunspaces"/>
/// </summary>
/// <param name="minRunspaces">
/// The minimum number of Runspaces that can exist in this pool.
/// Should be greater than or equal to 1.
/// </param>
/// <param name="maxRunspaces">
/// The maximum number of Runspaces that can exist in this pool.
/// Should be greater than or equal to 1.
/// </param>
/// <param name="runspaceConfiguration">
/// RunspaceConfiguration to use when creating a new Runspace.
/// </param>
/// <param name="host">
/// The explicit PSHost implementation.
/// </param>
/// <exception cref="ArgumentNullException">
/// RunspaceConfiguration is null.
/// Host is null.
/// </exception>
/// <exception cref="ArgumentException">
/// Maximum runspaces is less than 1.
/// Minimum runspaces is less than 1.
/// </exception>
internal RunspacePool(int minRunspaces, int maxRunspaces,
RunspaceConfiguration runspaceConfiguration, PSHost host)
{
// Currently we support only Local Runspace Pool..
// this needs to be changed once remote runspace pool
// is implemented
_internalPool = new RunspacePoolInternal(minRunspaces,
maxRunspaces, runspaceConfiguration, host);
}
/// <summary>
/// Creates a RunspacePool using default RunspaceConfiguration
/// with MaxRunspaces 1 and MinRunspaces 1.
/// </summary>
public static RunspacePool CreateRunspacePool()
{
return(CreateRunspacePool(1, 1,
RunspaceConfiguration.Create(),
new DefaultHost
(
CultureInfo.CurrentCulture,
CultureInfo.CurrentUICulture
)));
}
public static Runspace CreateRunspace(RunspaceConfiguration runspaceConfiguration)
{
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
PSHost host = new DefaultHost(Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.CurrentUICulture);
return(CreateRunspace(host, runspaceConfiguration));
}
/// <summary>
/// Creates a RunspacePool using default RunspaceConfiguration.
/// <paramref name="maxRunspaces"/>
/// limits the number of Runspaces that can exist in this
/// pool. The minimum pool size is set to <paramref name="minPoolSoze"/>.
/// </summary>
/// <param name="minRunspaces">
/// The minimum number of Runspaces that exist in this
/// pool. Should be greater than or equal to 1.
/// </param>
/// <param name="maxRunspaces">
/// The maximum number of Runspaces that can exist in this
/// pool. Should be greater than or equal to 1.
/// </param>
/// <exception cref="ArgumentException">
/// Maximum runspaces is less than 1.
/// Minimum runspaces is less than 1.
/// </exception>
public static RunspacePool CreateRunspacePool(int minRunspaces, int maxRunspaces)
{
return(CreateRunspacePool(minRunspaces, maxRunspaces,
RunspaceConfiguration.Create(),
new DefaultHost
(
CultureInfo.CurrentCulture,
CultureInfo.CurrentUICulture
)));
}
public static Runspace CreateRunspace(
PSHost host,
RunspaceConfiguration runspaceConfiguration)
{
if (host == null)
{
throw RunspaceFactory._tracer.NewArgumentNullException(nameof(host));
}
return(runspaceConfiguration != null ? (Runspace) new LocalRunspace(host, runspaceConfiguration) : throw RunspaceFactory._tracer.NewArgumentNullException(nameof(runspaceConfiguration)));
}
private void InitializeScript()
{
rspaceconfig = RunspaceConfiguration.Create();
host = new psfhost(frm);
hostinterface = (psfhostinterface)host.UI;
hostinterface.WriteProgressUpdate += WriteProgressUpdate;
hostinterface.WriteUpdate += WriteUpdate;
rspace = RunspaceFactory.CreateRunspace(host, rspaceconfig);
rspace.Open();
InitializeSessionVars();
}
internal LocalRunspace(PSHost host, RunspaceConfiguration configuration, InitialSessionState initialSessionState)
{
DefaultRunspace = this;
PSHost = host;
if (configuration == null)
_runspaceConfiguration = RunspaceFactory.DefaultRunspaceConfiguration;
else
_runspaceConfiguration = configuration;
ExecutionContext = new ExecutionContext(host, configuration);
ExecutionContext.CurrentRunspace = this;
_initialSessionState = initialSessionState;
}
internal static int Start(RunspaceConfiguration configuration, string bannerText, string helpText, string preStartWarning, string[] args)
{
if (args != null)
{
ConsoleControl.UpdateLocaleSpecificFont();
return ConsoleHost.Start(configuration, bannerText, helpText, preStartWarning, args);
}
else
{
throw PSTraceSource.NewArgumentNullException("args");
}
}
public static Runspace CreateRunspace(PSHost host, RunspaceConfiguration runspaceConfiguration)
{
if (host == null)
{
throw PSTraceSource.NewArgumentNullException("host");
}
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
return(new LocalRunspace(host, runspaceConfiguration));
}
/// <summary>
/// Creates a RunspaceInvoke for invoking commands. Underlying Runspace is created using
/// specified RunspaceConfiguration
/// </summary>
/// <param name="runspaceConfiguration">RunspaceConfiguration used for creating the runspace
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when runspaceConfiguration is null
/// </exception>
public RunspaceInvoke(RunspaceConfiguration runspaceConfiguration)
{
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
_runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
_runspace.Open();
if (Runspace.DefaultRunspace == null)
{
Runspace.DefaultRunspace = _runspace;
}
}
protected RunspaceBase(PSHost host, RunspaceConfiguration runspaceConfiguration)
{
if (host == null)
{
throw RunspaceBase._trace.NewArgumentNullException(nameof(host));
}
if (runspaceConfiguration == null)
{
throw RunspaceBase._trace.NewArgumentNullException(nameof(runspaceConfiguration));
}
this._host = host;
this._runspaceConfiguration = runspaceConfiguration;
}
internal LocalRunspace(PSHost host, RunspaceConfiguration configuration, InitialSessionState initialSessionState)
{
//TODO: we should support both RunspaceConfigurations and IntialSessionStates properly
_runningPipelines = new List<Pipeline>();
DefaultRunspace = this;
PSHost = host;
if (configuration == null)
_runspaceConfiguration = RunspaceFactory.DefaultRunspaceConfiguration;
else
_runspaceConfiguration = configuration;
ExecutionContext = new ExecutionContext(host, configuration);
ExecutionContext.CurrentRunspace = this;
_initialSessionState = initialSessionState;
}
/// <summary>
/// Construct an instance of an Runspace using a custom
/// implementation of PSHost.
/// </summary>
/// <param name="host">The explicit PSHost implementation</param>
/// <exception cref="System.ArgumentNullException">
/// Host is null.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// host is null.
/// </exception>
/// <param name="runspaceConfiguration">
/// configuration information for this minshell.
/// </param>
protected RunspaceBase(PSHost host, RunspaceConfiguration runspaceConfiguration)
{
if (host == null)
{
throw PSTraceSource.NewArgumentNullException("host");
}
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
Host = host;
RunspaceConfiguration = runspaceConfiguration;
}
internal static Collection <PSSnapInTypeAndFormatErrors> GetFormatAndTypesErrors(
RunspaceConfiguration runspaceConfiguration,
PSHost host,
IEnumerable configurationEntryCollection,
RunspaceConfigurationCategory category,
Collection <string> independentErrors)
{
Collection <PSSnapInTypeAndFormatErrors> collection = new Collection <PSSnapInTypeAndFormatErrors>();
string baseFolder = FormatAndTypeDataHelper.GetBaseFolder(runspaceConfiguration, independentErrors);
Hashtable fullFileNameHash = new Hashtable((IEqualityComparer)StringComparer.OrdinalIgnoreCase);
foreach (object configurationEntry1 in configurationEntryCollection)
{
string fileName;
string str;
if (category == RunspaceConfigurationCategory.Types)
{
TypeConfigurationEntry configurationEntry2 = (TypeConfigurationEntry)configurationEntry1;
fileName = configurationEntry2.FileName;
str = configurationEntry2.PSSnapIn == null ? runspaceConfiguration.ShellId : configurationEntry2.PSSnapIn.Name;
}
else
{
FormatConfigurationEntry configurationEntry2 = (FormatConfigurationEntry)configurationEntry1;
fileName = configurationEntry2.FileName;
str = configurationEntry2.PSSnapIn == null ? runspaceConfiguration.ShellId : configurationEntry2.PSSnapIn.Name;
}
string checkFullFileName1 = FormatAndTypeDataHelper.GetAndCheckFullFileName(str, fullFileNameHash, runspaceConfiguration, baseFolder, fileName, independentErrors);
if (checkFullFileName1 != null)
{
if (checkFullFileName1.EndsWith("filelist.ps1xml", StringComparison.OrdinalIgnoreCase))
{
foreach (string readFile in runspaceConfiguration.TypeTable.ReadFiles(str, checkFullFileName1, independentErrors, runspaceConfiguration.AuthorizationManager, host))
{
string checkFullFileName2 = FormatAndTypeDataHelper.GetAndCheckFullFileName(str, fullFileNameHash, runspaceConfiguration, baseFolder, readFile, independentErrors);
if (checkFullFileName2 != null)
{
collection.Add(new PSSnapInTypeAndFormatErrors(str, checkFullFileName2));
}
}
}
else
{
collection.Add(new PSSnapInTypeAndFormatErrors(str, checkFullFileName1));
}
}
}
return(collection);
}
public RunspacePoolInternal(int minRunspaces, int maxRunspaces, System.Management.Automation.Runspaces.RunspaceConfiguration runspaceConfiguration, PSHost host) : this(minRunspaces, maxRunspaces)
{
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
if (host == null)
{
throw PSTraceSource.NewArgumentNullException("host");
}
this.rsConfig = runspaceConfiguration;
this.host = host;
this.pool = new Stack <Runspace>();
this.runspaceRequestQueue = new Queue <GetRunspaceAsyncResult>();
this.ultimateRequestQueue = new Queue <GetRunspaceAsyncResult>();
}
private static string GetBaseFolder(RunspaceConfiguration runspaceConfiguration, Collection<string> independentErrors)
{
string shellPathFromRegistry = CommandDiscovery.GetShellPathFromRegistry(runspaceConfiguration.ShellId);
if (shellPathFromRegistry == null)
{
return Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName);
}
if (OSHelper.IsWindows) shellPathFromRegistry = Path.GetDirectoryName(shellPathFromRegistry);
if (!Directory.Exists(shellPathFromRegistry))
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string item = StringUtil.Format(TypesXmlStrings.CannotFindRegistryKeyPath, new object[] { shellPathFromRegistry, Utils.GetRegistryConfigurationPath(runspaceConfiguration.ShellId), @"\Path", directoryName });
independentErrors.Add(item);
shellPathFromRegistry = directoryName;
}
return shellPathFromRegistry;
}
internal AutomationEngine(PSHost hostInterface, RunspaceConfiguration runspaceConfiguration, InitialSessionState iss)
{
string str = Environment.GetEnvironmentVariable("PathEXT") ?? string.Empty;
bool flag = false;
if (str != string.Empty)
{
foreach (string str2 in str.Split(new char[] { ';' }))
{
if (str2.Trim().Equals(".CPL", StringComparison.OrdinalIgnoreCase))
{
flag = true;
break;
}
}
}
if (!flag)
{
str = (str == string.Empty) ? ".CPL" : (str.EndsWith(";", StringComparison.OrdinalIgnoreCase) ? (str + ".CPL") : (str + ";.CPL"));
Environment.SetEnvironmentVariable("PathEXT", str);
}
if (runspaceConfiguration != null)
{
this._context = new ExecutionContext(this, hostInterface, runspaceConfiguration);
}
else
{
this._context = new ExecutionContext(this, hostInterface, iss);
}
this.EngineNewParser = new Parser();
this.commandDiscovery = new System.Management.Automation.CommandDiscovery(this._context);
if (runspaceConfiguration != null)
{
runspaceConfiguration.Bind(this._context);
}
else
{
iss.Bind(this._context, false);
}
InitialSessionState.SetSessionStateDrive(this._context, true);
InitialSessionState.CreateQuestionVariable(this._context);
}
private static RunspaceConfiguration Create(Assembly assembly)
{
using (RunspaceConfiguration.tracer.TraceMethod())
{
object[] objArray = assembly != null?assembly.GetCustomAttributes(typeof(RunspaceConfigurationTypeAttribute), false) : throw RunspaceConfiguration.tracer.NewArgumentNullException(nameof(assembly));
if (objArray == null || objArray.Length == 0)
{
throw new RunspaceConfigurationAttributeException("RunspaceConfigurationAttributeNotExist", assembly.FullName);
}
RunspaceConfigurationTypeAttribute configurationTypeAttribute = objArray.Length <= 1 ? (RunspaceConfigurationTypeAttribute)objArray[0] : throw new RunspaceConfigurationAttributeException("RunspaceConfigurationAttributeDuplicate", assembly.FullName);
try
{
return(RunspaceConfiguration.Create(assembly.GetType(configurationTypeAttribute.RunspaceConfigurationType, true)));
}
catch (SecurityException ex)
{
throw new RunspaceConfigurationTypeException(assembly.FullName, configurationTypeAttribute.RunspaceConfigurationType);
}
}
}
private static string GetBaseFolder(RunspaceConfiguration runspaceConfiguration, Collection <string> independentErrors)
{
string shellPathFromRegistry = CommandDiscovery.GetShellPathFromRegistry(runspaceConfiguration.ShellId);
if (shellPathFromRegistry == null)
{
return(Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName));
}
if (OSHelper.IsWindows)
{
shellPathFromRegistry = Path.GetDirectoryName(shellPathFromRegistry);
}
if (!Directory.Exists(shellPathFromRegistry))
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string item = StringUtil.Format(TypesXmlStrings.CannotFindRegistryKeyPath, new object[] { shellPathFromRegistry, Utils.GetRegistryConfigurationPath(runspaceConfiguration.ShellId), @"\Path", directoryName });
independentErrors.Add(item);
shellPathFromRegistry = directoryName;
}
return(shellPathFromRegistry);
}
private static string GetBaseFolder(
RunspaceConfiguration runspaceConfiguration,
Collection<string> independentErrors)
{
string returnValue = CommandDiscovery.GetShellPathFromRegistry(runspaceConfiguration.ShellId);
if (returnValue == null)
{
returnValue = Path.GetDirectoryName(PsUtils.GetMainModule(System.Diagnostics.Process.GetCurrentProcess()).FileName);
}
else
{
returnValue = Path.GetDirectoryName(returnValue);
if (!Directory.Exists(returnValue))
{
string newReturnValue = Path.GetDirectoryName(typeof(FormatAndTypeDataHelper).GetTypeInfo().Assembly.Location);
string error = StringUtil.Format(TypesXmlStrings.CannotFindRegistryKeyPath, returnValue,
Utils.GetRegistryConfigurationPath(runspaceConfiguration.ShellId), "\\Path", newReturnValue);
independentErrors.Add(error);
returnValue = newReturnValue;
}
}
return returnValue;
}
public static RunspaceConfiguration Create(string assemblyName)
{
using (RunspaceConfiguration.tracer.TraceMethod())
{
if (string.IsNullOrEmpty(assemblyName))
{
throw RunspaceConfiguration.tracer.NewArgumentNullException(nameof(assemblyName));
}
Assembly assembly1 = (Assembly)null;
foreach (Assembly assembly2 in AppDomain.CurrentDomain.GetAssemblies())
{
if (string.Equals(assembly2.GetName().Name, assemblyName, StringComparison.OrdinalIgnoreCase))
{
assembly1 = assembly2;
break;
}
}
if (assembly1 == null)
{
assembly1 = Assembly.Load(assemblyName);
}
return(RunspaceConfiguration.Create(assembly1));
}
}
private static string GetBaseFolder(
RunspaceConfiguration runspaceConfiguration,
Collection <string> independentErrors)
{
string returnValue = CommandDiscovery.GetShellPathFromRegistry(runspaceConfiguration.ShellId);
if (returnValue == null)
{
returnValue = Path.GetDirectoryName(PsUtils.GetMainModule(System.Diagnostics.Process.GetCurrentProcess()).FileName);
}
else
{
returnValue = Path.GetDirectoryName(returnValue);
if (!Directory.Exists(returnValue))
{
string newReturnValue = Path.GetDirectoryName(typeof(FormatAndTypeDataHelper).GetTypeInfo().Assembly.Location);
string error = StringUtil.Format(TypesXmlStrings.CannotFindRegistryKeyPath, returnValue,
Utils.GetRegistryConfigurationPath(runspaceConfiguration.ShellId), "\\Path", newReturnValue);
independentErrors.Add(error);
returnValue = newReturnValue;
}
}
return(returnValue);
}
Start(RunspaceConfiguration configuration,
string bannerText,
string helpText,
string preStartWarning,
string[] args)
{
if (args == null)
{
throw PSTraceSource.NewArgumentNullException("args");
}
// The default font face used for Powershell Console is Lucida Console.
// However certain CJK locales dont support Lucida Console font. Hence for such
// locales the console font is updated to Raster dynamically.
// For NanoServer:
// 1. There is no GetCurrentConsoleFontEx / SetCurrentConsoleFontEx on NanoServer;
// 2. We don't handle CJK locales on NanoServer due to lack of win32 API supports on NanoServer.
#if !CORECLR
ConsoleControl.UpdateLocaleSpecificFont();
#endif
return ConsoleHost.Start(configuration, bannerText, helpText, preStartWarning, args);
}
private static string GetBaseFolder(
RunspaceConfiguration runspaceConfiguration,
Collection <string> independentErrors)
{
string pathFromRegistry = CommandDiscovery.GetShellPathFromRegistry(runspaceConfiguration.ShellId);
string path;
if (pathFromRegistry == null)
{
path = Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName);
}
else
{
path = Path.GetDirectoryName(pathFromRegistry);
if (!Directory.Exists(path))
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string str = ResourceManagerCache.FormatResourceString("TypesXml", "CannotFindRegistryKeyPath", (object)path, (object)Utils.GetRegistryConfigurationPath(runspaceConfiguration.ShellId), (object)"\\Path", (object)directoryName);
independentErrors.Add(str);
path = directoryName;
}
}
return(path);
}
public static Runspace CreateRunspace(RunspaceConfiguration runspaceConfiguration)
{
return(CreateRunspace(new LocalHost(), runspaceConfiguration));
}
public RunspacePoolInternal(int minRunspaces, int maxRunspaces, System.Management.Automation.Runspaces.RunspaceConfiguration runspaceConfiguration, PSHost host) : this(minRunspaces, maxRunspaces)
{
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
if (host == null)
{
throw PSTraceSource.NewArgumentNullException("host");
}
this.rsConfig = runspaceConfiguration;
this.host = host;
this.pool = new Stack<Runspace>();
this.runspaceRequestQueue = new Queue<GetRunspaceAsyncResult>();
this.ultimateRequestQueue = new Queue<GetRunspaceAsyncResult>();
}
internal static Collection<PSSnapInTypeAndFormatErrors> GetFormatAndTypesErrors(RunspaceConfiguration runspaceConfiguration, PSHost host, IEnumerable configurationEntryCollection, RunspaceConfigurationCategory category, Collection<string> independentErrors, Collection<int> entryIndicesToRemove)
{
Collection<PSSnapInTypeAndFormatErrors> collection = new Collection<PSSnapInTypeAndFormatErrors>();
string baseFolder = GetBaseFolder(runspaceConfiguration, independentErrors);
HashSet<string> fullFileNameSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
int item = -1;
foreach (object obj2 in configurationEntryCollection)
{
string fileName;
string str3;
bool flag;
item++;
if (category == RunspaceConfigurationCategory.Types)
{
TypeConfigurationEntry entry = (TypeConfigurationEntry) obj2;
fileName = entry.FileName;
str3 = (entry.PSSnapIn == null) ? runspaceConfiguration.ShellId : entry.PSSnapIn.Name;
if (fileName != null)
{
goto Label_00DD;
}
collection.Add(new PSSnapInTypeAndFormatErrors(str3, entry.TypeData, entry.IsRemove));
continue;
}
FormatConfigurationEntry entry2 = (FormatConfigurationEntry) obj2;
fileName = entry2.FileName;
str3 = (entry2.PSSnapIn == null) ? runspaceConfiguration.ShellId : entry2.PSSnapIn.Name;
if (fileName == null)
{
collection.Add(new PSSnapInTypeAndFormatErrors(str3, entry2.FormatData));
continue;
}
Label_00DD:
flag = false;
string xmlFileListFileName = GetAndCheckFullFileName(str3, fullFileNameSet, baseFolder, fileName, independentErrors, ref flag);
if (xmlFileListFileName == null)
{
if (flag)
{
entryIndicesToRemove.Add(item);
}
}
else if (xmlFileListFileName.EndsWith("filelist.ps1xml", StringComparison.OrdinalIgnoreCase))
{
bool flag2;
foreach (string str5 in runspaceConfiguration.TypeTable.ReadFiles(str3, xmlFileListFileName, independentErrors, runspaceConfiguration.AuthorizationManager, host, out flag2))
{
string fullPath = GetAndCheckFullFileName(str3, fullFileNameSet, baseFolder, str5, independentErrors, ref flag);
if (fullPath != null)
{
collection.Add(new PSSnapInTypeAndFormatErrors(str3, fullPath));
}
}
}
else
{
collection.Add(new PSSnapInTypeAndFormatErrors(str3, xmlFileListFileName));
}
}
return collection;
}
public ExecutionContext(PSHost host, RunspaceConfiguration config)
: this()
{
RunspaceConfiguration = config;
LocalHost = host;
}
internal virtual Runspace OpenRunspace()
{
HostedSolutionLog.LogStart("OpenRunspace");
if (runspaceConfiguration == null)
{
runspaceConfiguration = RunspaceConfiguration.Create();
}
Runspace runSpace = RunspaceFactory.CreateRunspace(runspaceConfiguration);
//
runSpace.Open();
//
runSpace.SessionStateProxy.SetVariable("ConfirmPreference", "none");
ImportGroupPolicyMolude(runSpace);
HostedSolutionLog.LogEnd("OpenRunspace");
return runSpace;
}
public static Runspace CreateRunspace(RunspaceConfiguration runspaceConfiguration)
{
return CreateRunspace(new LocalHost(), runspaceConfiguration);
}
public static RunspacePool CreateRunspacePool(
int minRunspaces,
int maxRunspaces,
PSHost host)
{
using (RunspaceFactory._tracer.TraceMethod())
return(RunspaceFactory.CreateRunspacePool(minRunspaces, maxRunspaces, RunspaceConfiguration.Create(), host));
}
internal LocalRunspace(PSHost host, RunspaceConfiguration runspaceConfig)
: base(host, runspaceConfig)
{
}
internal LocalRunspace(PSHost host, RunspaceConfiguration runspaceConfig)
: base(host, runspaceConfig)
{
}
public static RunspacePool CreateRunspacePool(int minRunspaces, int maxRunspaces)
{
using (RunspaceFactory._tracer.TraceMethod())
return(RunspaceFactory.CreateRunspacePool(minRunspaces, maxRunspaces, RunspaceConfiguration.Create(), (PSHost) new DefaultHost(Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.CurrentUICulture)));
}
public static RunspacePool CreateRunspacePool(int minRunspaces, int maxRunspaces, PSHost host)
{
return(CreateRunspacePool(minRunspaces, maxRunspaces, RunspaceConfiguration.Create(), host));
}
public static Runspace CreateRunspace(PSHost host)
{
using (RunspaceFactory._tracer.TraceMethod())
return(host != null?RunspaceFactory.CreateRunspace(host, RunspaceConfiguration.Create()) : throw RunspaceFactory._tracer.NewArgumentNullException(nameof(host)));
}
/// <summary>
/// Creates a RunspacePool using the supplied <paramref name="configuration"/>,
/// <paramref name="minRunspaces"/> and <paramref name="maxRunspaces"/>
/// </summary>
/// <param name="minRunspaces">
/// The minimum number of Runspaces that can exist in this pool.
/// Should be greater than or equal to 1.
/// </param>
/// <param name="maxRunspaces">
/// The maximum number of Runspaces that can exist in this pool.
/// Should be greater than or equal to 1.
/// </param>
/// <param name="runspaceConfiguration">
/// RunspaceConfiguration to use when creating a new Runspace in the
/// pool.
/// </param>
/// <exception cref="ArgumentNullException">
/// RunspaceConfiguration is null.
/// </exception>
/// <param name="host">
/// The explicit PSHost implementation.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="runspaceConfiguration"/> is null.
/// <paramref name="host"/> is null.
/// </exception>
/// <exception cref="ArgumentException">
/// Maximum runspaces is less than 1.
/// Minimum runspaces is less than 1.
/// </exception>
private static RunspacePool CreateRunspacePool(int minRunspaces, int maxRunspaces,
RunspaceConfiguration runspaceConfiguration, PSHost host)
{
return(new RunspacePool(minRunspaces,
maxRunspaces, runspaceConfiguration, host));
}
public static Runspace CreateRunspace(PSHost host, RunspaceConfiguration runspaceConfiguration)
{
return(new LocalRunspace(host, runspaceConfiguration));
}
static Runspace CreateRunspace(PSHost host, RunspaceConfiguration runspaceConfiguration)
{
if (host == null)
{
throw PSTraceSource.NewArgumentNullException("host");
}
if (runspaceConfiguration == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceConfiguration");
}
return new LocalRunspace(host, runspaceConfiguration);
}
/// <summary>
/// main initialisation routine for the <see cref="Runspace"/>
/// </summary>
/// <param name="snapin"><see cref="SnapIn"/> to be initialized together with the <see cref="Runspace"/></param>
private void InitRunSpace(SnapIn snapin)
{
const string MethodName = "InitRunSpace";
Debug.WriteLine(MethodName + "(" + snapin + ")" + ":entry", ClassName);
// create a new config from scratch
PSSnapInException snapOutput = null;
this.runSpaceConfig = RunspaceConfiguration.Create();
switch (snapin)
{
case SnapIn.Exchange:
var serverVersion = GetExchangeServerVersion();
switch (serverVersion)
{
case ExchangeVersion.E2007:
// used for force load of the exchange dll's
AppDomain.CurrentDomain.AssemblyResolve +=
new ResolveEventHandler(ExchangeUtility.AssemblyResolver2007);
this.runSpaceConfig.AddPSSnapIn(Exchange2007SnapIn, out snapOutput);
break;
case ExchangeVersion.E2010:
// used for force load of the exchange dll's
AppDomain.CurrentDomain.AssemblyResolve +=
new ResolveEventHandler(ExchangeUtility.AssemblyResolver2010);
this.runSpaceConfig.AddPSSnapIn(Exchange2010SnapIn, out snapOutput);
break;
}
break;
}
// check snapOutput
if (snapOutput != null)
{
throw snapOutput;
}
// create the real Runspace and open it for processing
this.runSpace = RunspaceFactory.CreateRunspace(this.runSpaceConfig);
this.runSpace.Open();
this.runSpaceInvoke = new RunspaceInvoke(this.runSpace);
Debug.WriteLine(MethodName + ":exit", ClassName);
}
/// <summary>
/// Creates a RunspacePool using the supplied <paramref name="configuration"/>,
/// <paramref name="minRunspaces"/> and <paramref name="maxRunspaces"/>
/// </summary>
/// <param name="minRunspaces">
/// The minimum number of Runspaces that can exist in this pool.
/// Should be greater than or equal to 1.
/// </param>
/// <param name="maxRunspaces">
/// The maximum number of Runspaces that can exist in this pool.
/// Should be greater than or equal to 1.
/// </param>
/// <param name="runspaceConfiguration">
/// RunspaceConfiguration to use when creating a new Runspace in the
/// pool.
/// </param>
/// <exception cref="ArgumentNullException">
/// RunspaceConfiguration is null.
/// </exception>
/// <param name="host">
/// The explicit PSHost implementation.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="runspaceConfiguration"/> is null.
/// <paramref name="host"/> is null.
/// </exception>
/// <exception cref="ArgumentException">
/// Maximum runspaces is less than 1.
/// Minimum runspaces is less than 1.
/// </exception>
private static RunspacePool CreateRunspacePool(int minRunspaces, int maxRunspaces,
RunspaceConfiguration runspaceConfiguration, PSHost host)
{
return new RunspacePool(minRunspaces,
maxRunspaces, runspaceConfiguration, host);
}
internal void CloseRunspace(Runspace runspace)
{
try
{
if (runspace != null && runspace.RunspaceStateInfo.State == RunspaceState.Opened)
{
runspace.Close();
runspaceConfiguration = null;
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("Runspace error", ex);
}
}
internal RunspacePool(int minRunspaces, int maxRunspaces, RunspaceConfiguration runspaceConfiguration, PSHost host)
{
throw new NotImplementedException();
}
public static Runspace CreateRunspace(PSHost host, RunspaceConfiguration runspaceConfiguration)
{
return new LocalRunspace(host, runspaceConfiguration);
}
// TODO: make sure to implement a Singleton DefaultRunspace pattern
//internal static LocalRunspace DefaultRunspace { get; private set; }
public LocalRunspace(PSHost host, RunspaceConfiguration configuration)
: this(host, configuration, null)
{
}
