private void UnzipHelpContent(System.Management.Automation.ExecutionContext context, string srcPath, string destPath) { if (!Directory.Exists(destPath)) { Directory.CreateDirectory(destPath); } string directoryName = Path.GetDirectoryName(srcPath); if (!directoryName.EndsWith(@"\", StringComparison.Ordinal)) { directoryName = directoryName + @"\"; } if (!destPath.EndsWith(@"\", StringComparison.Ordinal)) { destPath = destPath + @"\"; } if (!CabinetExtractorFactory.GetCabinetExtractor().Extract(Path.GetFileName(srcPath), directoryName, destPath)) { throw new UpdatableHelpSystemException("UnableToExtract", StringUtil.Format(HelpDisplayStrings.UnzipFailure, new object[0]), ErrorCategory.InvalidOperation, null, null); } foreach (string str2 in Directory.GetFiles(destPath)) { if (System.IO.File.Exists(str2)) { FileInfo info = new FileInfo(str2); if ((info.Attributes & System.IO.FileAttributes.ReadOnly) == System.IO.FileAttributes.ReadOnly) { info.Attributes &= ~System.IO.FileAttributes.ReadOnly; } } } }
internal HtmlWebResponseObject(WebResponse response, MemoryStream contentStream, System.Management.Automation.ExecutionContext executionContext) : base(response, contentStream) { if (executionContext == null) { throw PSTraceSource.NewArgumentNullException("executionContext"); } this._executionContext = executionContext; this.InitializeContent(); this.InitializeRawContent(response); }
/// <summary> /// Constructor for HtmlWebResponseObject with memory stream /// </summary> /// <param name="response"></param> /// <param name="contentStream"></param> /// <param name="executionContext"></param> internal HtmlWebResponseObject(WebResponse response, Stream contentStream, ExecutionContext executionContext) : base(response, contentStream) { if (executionContext == null) { throw PSTraceSource.NewArgumentNullException("executionContext"); } _executionContext = executionContext; InitializeContent(); InitializeRawContent(response); }
internal void InstallHelpContent(UpdatableHelpCommandType commandType, System.Management.Automation.ExecutionContext context, string sourcePath, Collection <string> destPaths, string fileName, string tempPath, CultureInfo culture, string xsdPath, out Collection <string> installed) { if (this._stopping) { installed = new Collection <string>(); } else { if (!Directory.Exists(tempPath)) { Directory.CreateDirectory(tempPath); } try { this.OnProgressChanged(this, new UpdatableHelpProgressEventArgs(this._currentModule, commandType, StringUtil.Format(HelpDisplayStrings.UpdateProgressInstalling, new object[0]), 0)); string path = Path.Combine(sourcePath, fileName); if (!System.IO.File.Exists(path)) { throw new UpdatableHelpSystemException("HelpContentNotFound", StringUtil.Format(HelpDisplayStrings.HelpContentNotFound, new object[0]), ErrorCategory.ResourceUnavailable, null, null); } string str2 = Path.Combine(tempPath, Path.GetFileNameWithoutExtension(fileName)); if (Directory.Exists(str2)) { Directory.Delete(str2, true); } this.UnzipHelpContent(context, path, str2); this.ValidateAndCopyHelpContent(str2, destPaths, culture.Name, xsdPath, out installed); } finally { this.OnProgressChanged(this, new UpdatableHelpProgressEventArgs(this._currentModule, commandType, StringUtil.Format(HelpDisplayStrings.UpdateProgressInstalling, new object[0]), 100)); try { if (Directory.Exists(tempPath)) { Directory.Delete(tempPath); } } catch (IOException) { } catch (UnauthorizedAccessException) { } catch (ArgumentException) { } } } }
internal History(System.Management.Automation.ExecutionContext context) { Collection <Attribute> attributes = new Collection <Attribute> { new ValidateRangeAttribute(1, 0x7fff) }; PSVariable variable = new PSVariable("MaximumHistoryCount", 0x1000, ScopedItemOptions.None, attributes) { Description = SessionStateStrings.MaxHistoryCountDescription }; context.EngineSessionState.SetVariable(variable, false, CommandOrigin.Internal); this._capacity = 0x1000; this._buffer = new HistoryInfo[this._capacity]; }
internal History(System.Management.Automation.ExecutionContext context) { using (History._trace.TraceConstructor((object)this)) { this._context = context; context.EngineSessionState.SetVariable(new PSVariable("MaximumHistoryCount", (object)64, ScopedItemOptions.None, new Collection <Attribute>() { (Attribute) new ValidateRangeAttribute((object)1, (object)(int)short.MaxValue) }) { Description = ResourceManagerCache.GetResourceString("SessionStateStrings", "MaxHistoryCountDescription") }, false, CommandOrigin.Internal); this._capacity = 64; this._buffer = new HistoryInfo[this._capacity]; } }
private int GetHistorySize() { int num = 0; System.Management.Automation.ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS(); object valueToConvert = (executionContextFromTLS != null) ? executionContextFromTLS.GetVariableValue(SpecialVariables.HistorySizeVarPath) : null; if (valueToConvert != null) { try { num = (int)LanguagePrimitives.ConvertTo(valueToConvert, typeof(int), CultureInfo.InvariantCulture); } catch (InvalidCastException) { } } if (num <= 0) { num = 0x1000; } return(num); }
public object GetValue(ExecutionContext context) => (object)null;
public IAssignableValue GetAssignableValue( Array input, ExecutionContext context) { return((IAssignableValue)this); }
/// <summary> /// Get using values in the array form. /// </summary> internal static object[] GetUsingValuesAsArray(ScriptBlock scriptBlock, bool isTrustedInput, ExecutionContext context, Dictionary <string, object> variables) { return(GetUsingValues(scriptBlock.Ast, isTrustedInput, context, variables, false).Item2); }
/// <summary> /// Constructor for HtmlWebResponseObject /// </summary> /// <param name="response"></param> /// <param name="executionContext"></param> internal HtmlWebResponseObject(WebResponse response, ExecutionContext executionContext) : this(response, null, executionContext) { }
/// <summary> /// Get current engine state for the engine instance corresponding to executionContext /// passed in. /// /// Engine state is stored in ExecutionContext. /// </summary> /// <param name="executionContext"></param> /// <returns></returns> private static EngineState GetEngineState(ExecutionContext executionContext) { return(executionContext.EngineState); }
/// <summary> /// This is a variation of basic LogEngineLifeCycleEvent api which makes invocationInfo /// optional. /// </summary> /// <param name="executionContext"></param> /// <param name="engineState"></param> internal static void LogEngineLifecycleEvent(ExecutionContext executionContext, EngineState engineState) { LogEngineLifecycleEvent(executionContext, engineState, null); }
/// <summary> /// This is a variation of LogEngineHealthEvent api to make eventid, additionalInfo and newEngineState /// optional. /// /// A default event id for engine health event will be used. /// </summary> /// <param name="executionContext"></param> /// <param name="exception"></param> /// <param name="severity"></param> internal static void LogEngineHealthEvent(ExecutionContext executionContext, Exception exception, Severity severity) { LogEngineHealthEvent(executionContext, 100, exception, severity, null); }
private void RunClause(Action <FunctionContext> clause, object dollarUnderbar, object inputToProcess) { ExecutionContext.CheckStackDepth(); Pipe oldErrorOutputPipe = this.Context.ShellFunctionErrorOutputPipe; // If the script block has a different language mode than the current, // change the language mode. PSLanguageMode?oldLanguageMode = null; PSLanguageMode?newLanguageMode = null; if ((_scriptBlock.LanguageMode.HasValue) && (_scriptBlock.LanguageMode != Context.LanguageMode)) { oldLanguageMode = Context.LanguageMode; newLanguageMode = _scriptBlock.LanguageMode; } try { var oldScopeOrigin = this.Context.EngineSessionState.CurrentScope.ScopeOrigin; try { this.Context.EngineSessionState.CurrentScope.ScopeOrigin = this._dontUseScopeCommandOrigin ? CommandOrigin.Internal : this.Command.CommandOrigin; // Set the language mode. We do this before EnterScope(), so that the language // mode is appropriately applied for evaluation parameter defaults. if (newLanguageMode.HasValue) { Context.LanguageMode = newLanguageMode.Value; } bool?oldLangModeTransitionStatus = null; try { // If it's from ConstrainedLanguage to FullLanguage, indicate the transition before parameter binding takes place. if (oldLanguageMode == PSLanguageMode.ConstrainedLanguage && newLanguageMode == PSLanguageMode.FullLanguage) { oldLangModeTransitionStatus = Context.LanguageModeTransitionInParameterBinding; Context.LanguageModeTransitionInParameterBinding = true; } EnterScope(); } finally { if (oldLangModeTransitionStatus.HasValue) { // Revert the transition state to old value after doing the parameter binding Context.LanguageModeTransitionInParameterBinding = oldLangModeTransitionStatus.Value; } } if (commandRuntime.ErrorMergeTo == MshCommandRuntime.MergeDataStream.Output) { Context.RedirectErrorPipe(commandRuntime.OutputPipe); } else if (commandRuntime.ErrorOutputPipe.IsRedirected) { Context.RedirectErrorPipe(commandRuntime.ErrorOutputPipe); } if (dollarUnderbar != AutomationNull.Value) { _localsTuple.SetAutomaticVariable(AutomaticVariable.Underbar, dollarUnderbar, _context); } else if (_dollarUnderbar != AutomationNull.Value) { _localsTuple.SetAutomaticVariable(AutomaticVariable.Underbar, _dollarUnderbar, _context); } if (inputToProcess != AutomationNull.Value) { if (inputToProcess == null) { inputToProcess = MshCommandRuntime.StaticEmptyArray.GetEnumerator(); } else { IList list = inputToProcess as IList; inputToProcess = (list != null) ? list.GetEnumerator() : LanguagePrimitives.GetEnumerator(inputToProcess); } _localsTuple.SetAutomaticVariable(AutomaticVariable.Input, inputToProcess, _context); } clause(_functionContext); } catch (TargetInvocationException tie) { // DynamicInvoke wraps exceptions, unwrap them here. throw tie.InnerException; } finally { this.Context.RestoreErrorPipe(oldErrorOutputPipe); if (oldLanguageMode.HasValue) { Context.LanguageMode = oldLanguageMode.Value; } Context.EngineSessionState.CurrentScope.ScopeOrigin = oldScopeOrigin; } } catch (ExitException ee) { if (!this.FromScriptFile || _rethrowExitException) { throw; } this._exitWasCalled = true; int exitCode = (int)ee.Argument; this.Command.Context.SetVariable(SpecialVariables.LastExitCodeVarPath, exitCode); if (exitCode != 0) { this.commandRuntime.PipelineProcessor.ExecutionFailed = true; } } catch (FlowControlException) { throw; } catch (RuntimeException e) { ManageScriptException(e); // always throws // This quiets the compiler which wants to see a return value // in all codepaths. throw; } catch (Exception e) { // This cmdlet threw an exception, so // wrap it and bubble it up. throw ManageInvocationException(e); } }
internal DlrScriptCommandProcessor(ExternalScriptInfo scriptInfo, ExecutionContext context, bool useNewScope, SessionStateInternal sessionState) : base(scriptInfo, context, useNewScope, sessionState) { Init(); }
internal DlrScriptCommandProcessor(ScriptBlock scriptBlock, ExecutionContext context, bool useNewScope, CommandOrigin origin, SessionStateInternal sessionState) : base(scriptBlock, context, useNewScope, origin, sessionState) { Init(); }
/// <summary> /// Collect values for UsingExpressions, in the form of a dictionary and an array. /// - The dictionary form is used when the remote server is PSv5 and later version for handling UsingExpression in Invoke-Command/Start-Job /// - The array form is used when the remote server is PSv3 and PSv4 for handling UsingExpression in Invoke-Command. /// </summary> /// <remarks> /// We still keep the array-form using values because we want to avoid any breaking changes when running Invoke-Command /// targeting PSv3 or PSv4 remote end -- if UsingExpressions are all in the same scope, then we still pass an array of using /// values to the remote end; otherwise, we will handle UsingExpression as if the remote end is PSv2. /// </remarks> /// <returns> /// A tuple of the dictionary-form and the array-form using values. /// If the array-form using value is null, then there are UsingExpressions used in different scopes. /// </returns> private static Tuple <Dictionary <string, object>, object[]> GetUsingValues(Ast body, bool isTrustedInput, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables) { Diagnostics.Assert(context != null || variables != null, "can't retrieve variables with no context and no variables"); var usingAsts = UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(body).ToList(); var usingValueArray = new object[usingAsts.Count]; var usingValueMap = new Dictionary <string, object>(usingAsts.Count); HashSet <string> usingVarNames = (variables != null && filterNonUsingVariables) ? new HashSet <string>() : null; // Used to check if the PSv3/PSv4 way of handling UsingExpression can continue to be used. bool hasUsingExprInDifferentScope = false; ScriptBlockAst sbClosestToPreUsingExpr = null; UsingExpressionAst usingAst = null; Version oldStrictVersion = null; try { if (context != null) { oldStrictVersion = context.EngineSessionState.CurrentScope.StrictModeVersion; context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion; } for (int i = 0; i < usingAsts.Count; ++i) { usingAst = (UsingExpressionAst)usingAsts[i]; object value = null; // This happens only when GetUsingValues gets called outside the ScriptBlockToPowerShellConverter class if (!hasUsingExprInDifferentScope && HasUsingExpressionsInDifferentScopes(usingAst, body, ref sbClosestToPreUsingExpr)) { // If there are UsingExpressions in different scopes, the array-form using values will not be useful // even if the remote end is PSv3 or PSv4, because the way we handle using expression in PSv3 and PSv4 // doesn't support UsingExpression in different scopes. In this case, we will set the array-form using // value to be null before return. // // Note that this check only affect array-form using value. In PSv5, we change the way to handle UsingExpression // on both client and server sides. The dictionary-form using values is used and UsingExpression in different // scope is supported. hasUsingExprInDifferentScope = true; } if (variables != null) { var variableAst = usingAst.SubExpression as VariableExpressionAst; if (variableAst == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "CantGetUsingExpressionValueWithSpecifiedVariableDictionary", AutomationExceptions.CantGetUsingExpressionValueWithSpecifiedVariableDictionary, usingAst.Extent.Text); } string varName = variableAst.VariablePath.UserPath; if (varName != null && variables.TryGetValue(varName, out value) && usingVarNames != null) { usingVarNames.Add(varName); } } else { value = Compiler.GetExpressionValue(usingAst.SubExpression, isTrustedInput, context); } // Collect UsingExpression value as an array usingValueArray[i] = value; // Collect UsingExpression value as a dictionary string usingAstKey = PsUtils.GetUsingExpressionKey(usingAst); if (!usingValueMap.ContainsKey(usingAstKey)) { usingValueMap.Add(usingAstKey, value); } } } catch (RuntimeException rte) { if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "UsingVariableIsUndefined", AutomationExceptions.UsingVariableIsUndefined, rte.ErrorRecord.TargetObject); } else if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("CantGetUsingExpressionValueWithSpecifiedVariableDictionary", StringComparison.Ordinal)) { throw; } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = oldStrictVersion; } } if (usingVarNames != null) { string[] keys = variables.Keys.ToArray(); foreach (string key in keys) { if (!usingVarNames.Contains(key)) { variables.Remove(key); } } } if (hasUsingExprInDifferentScope) { usingValueArray = null; } return(Tuple.Create(usingValueMap, usingValueArray)); }
/// <summary> /// Constructor for HtmlWebResponseObject /// </summary> /// <param name="response"></param> /// <param name="executionContext"></param> internal HtmlWebResponseObject(HttpResponseMessage response, ExecutionContext executionContext) : this(response, null, executionContext) { }
/// <summary> /// Set current engine state for the engine instance corresponding to executionContext /// passed in. /// /// Engine state is stored in ExecutionContext. /// </summary> /// <param name="executionContext"></param> /// <param name="engineState"></param> private static void SetEngineState(ExecutionContext executionContext, EngineState engineState) { executionContext.EngineState = engineState; }
private Dictionary <string, UpdatableHelpModuleInfo> GetModuleInfo(System.Management.Automation.ExecutionContext context, string pattern, bool loaded, bool noErrors) { List <PSModuleInfo> modules = context.Modules.GetModules(new string[] { pattern }, false); Dictionary <string, UpdatableHelpModuleInfo> dictionary = new Dictionary <string, UpdatableHelpModuleInfo>(); if (modules.Count != 0) { base.WriteDebug(StringUtil.Format("Found {0} loaded modules.", modules.Count)); foreach (PSModuleInfo info in modules) { if (InitialSessionState.IsEngineModule(info.Name) && !InitialSessionState.IsNestedEngineModule(info.Name)) { base.WriteDebug(StringUtil.Format("Found engine module: {0}, {1}.", info.Name, info.Guid)); if (!dictionary.ContainsKey(info.Name)) { dictionary.Add(info.Name, new UpdatableHelpModuleInfo(info.Name, info.Guid, Utils.GetApplicationBase(context.ShellID), metadataCache[info.Name])); } } else if (!InitialSessionState.IsNestedEngineModule(info.Name)) { if (string.IsNullOrEmpty(info.HelpInfoUri)) { if (!noErrors) { this.ProcessException(info.Name, null, new UpdatableHelpSystemException("HelpInfoUriNotFound", StringUtil.Format(HelpDisplayStrings.HelpInfoUriNotFound, new object[0]), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!info.HelpInfoUri.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) { if (!noErrors) { this.ProcessException(info.Name, null, new UpdatableHelpSystemException("InvalidHelpInfoUriFormat", StringUtil.Format(HelpDisplayStrings.InvalidHelpInfoUriFormat, info.HelpInfoUri), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!dictionary.ContainsKey(info.Name)) { dictionary.Add(info.Name, new UpdatableHelpModuleInfo(info.Name, info.Guid, info.ModuleBase, info.HelpInfoUri)); } } } } WildcardOptions options = WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase; IEnumerable <WildcardPattern> patterns = SessionStateUtilities.CreateWildcardsFromStrings(new string[] { pattern }, options); if (!loaded) { Collection <PSObject> collection = base.InvokeCommand.InvokeScript("Get-Module -ListAvailable"); Collection <PSModuleInfo> collection2 = new Collection <PSModuleInfo>(); if (collection != null) { foreach (PSObject obj2 in collection) { try { collection2.Add((PSModuleInfo)LanguagePrimitives.ConvertTo(obj2, typeof(PSModuleInfo), CultureInfo.InvariantCulture)); } catch (PSInvalidCastException) { } } } base.WriteDebug(StringUtil.Format("Found {0} available (Get-Module -ListAvailable) modules.", collection2.Count)); foreach (PSModuleInfo info2 in collection2) { if (SessionStateUtilities.MatchesAnyWildcardPattern(info2.Name, patterns, true)) { if (InitialSessionState.IsEngineModule(info2.Name) && !InitialSessionState.IsNestedEngineModule(info2.Name)) { base.WriteDebug(StringUtil.Format("Found engine module: {0}, {1}.", info2.Name, info2.Guid)); if (!dictionary.ContainsKey(info2.Name)) { dictionary.Add(info2.Name, new UpdatableHelpModuleInfo(info2.Name, info2.Guid, Utils.GetApplicationBase(context.ShellID), metadataCache[info2.Name])); } } else if (!InitialSessionState.IsNestedEngineModule(info2.Name)) { if (string.IsNullOrEmpty(info2.HelpInfoUri)) { if (!noErrors) { this.ProcessException(info2.Name, null, new UpdatableHelpSystemException("HelpInfoUriNotFound", StringUtil.Format(HelpDisplayStrings.HelpInfoUriNotFound, new object[0]), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!info2.HelpInfoUri.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) { if (!noErrors) { this.ProcessException(info2.Name, null, new UpdatableHelpSystemException("InvalidHelpInfoUriFormat", StringUtil.Format(HelpDisplayStrings.InvalidHelpInfoUriFormat, info2.HelpInfoUri), ErrorCategory.NotSpecified, new Uri("HelpInfoUri", UriKind.Relative), null)); } } else if (!dictionary.ContainsKey(info2.Name)) { dictionary.Add(info2.Name, new UpdatableHelpModuleInfo(info2.Name, info2.Guid, info2.ModuleBase, info2.HelpInfoUri)); } } } } } foreach (KeyValuePair <string, string> pair in metadataCache) { if (SessionStateUtilities.MatchesAnyWildcardPattern(pair.Key, patterns, true)) { if (!pair.Key.Equals(InitialSessionState.CoreSnapin, StringComparison.OrdinalIgnoreCase)) { Collection <PSObject> collection3 = base.InvokeCommand.InvokeScript(StringUtil.Format("Get-Module {0} -ListAvailable", pair.Key)); Collection <PSModuleInfo> collection4 = new Collection <PSModuleInfo>(); if (collection3 != null) { foreach (PSObject obj3 in collection3) { try { collection4.Add((PSModuleInfo)LanguagePrimitives.ConvertTo(obj3, typeof(PSModuleInfo), CultureInfo.InvariantCulture)); } catch (PSInvalidCastException) { } } } foreach (PSModuleInfo info3 in collection4) { if (!dictionary.ContainsKey(info3.Name)) { base.WriteDebug(StringUtil.Format("Found engine module: {0}, {1}.", info3.Name, info3.Guid)); dictionary.Add(pair.Key, new UpdatableHelpModuleInfo(info3.Name, info3.Guid, Utils.GetApplicationBase(context.ShellID), metadataCache[info3.Name])); } } } else if (!dictionary.ContainsKey(pair.Key)) { dictionary.Add(pair.Key, new UpdatableHelpModuleInfo(pair.Key, Guid.Empty, Utils.GetApplicationBase(context.ShellID), pair.Value)); } } } return(dictionary); }
internal static List <string> GetDefaultAvailableModuleFiles(bool force, bool preferSystemModulePath, System.Management.Automation.ExecutionContext context) { Pipeline currentlyRunningPipeline = context.CurrentRunspace.GetCurrentlyRunningPipeline(); if (!force && (currentlyRunningPipeline != null)) { lock (cachedAvailableModuleFiles) { if ((currentlyRunningPipeline.InstanceId == pipelineInstanceIdForModuleFileCache) && (cachedAvailableModuleFiles.Count > 0)) { return(cachedAvailableModuleFiles); } } } List <string> availableModuleFiles = new List <string>(); List <string> modulePaths = new List <string>(); foreach (string str in ModuleIntrinsics.GetModulePath(preferSystemModulePath, context)) { if (Directory.Exists(str)) { GetDefaultAvailableModuleFiles(str, availableModuleFiles, modulePaths); } } if (currentlyRunningPipeline != null) { lock (cachedAvailableModuleFiles) { pipelineInstanceIdForModuleFileCache = currentlyRunningPipeline.InstanceId; cachedAvailableModuleFiles = availableModuleFiles; } } return(availableModuleFiles); }
internal CommandInvocationIntrinsics(ExecutionContext executionContext, PipelineCommandRuntime commandRuntime) { this.executionContext = executionContext; this.commandRuntime = commandRuntime; }
/// <summary> /// Initializes a new instance of the DscResourceInfo class /// </summary> /// <param name="name">Name of the DscResource.</param> /// <param name="friendlyName">FriendlyName of the DscResource.</param> /// <param name="path">Path of the DscResource.</param> /// <param name="parentPath">ParentPath of the DscResource.</param> /// <param name="context">The execution context for the DscResource.</param> internal DscResourceInfo(string name, string friendlyName, string path, string parentPath, ExecutionContext context) { this.Name = name; this.FriendlyName = friendlyName; this.Path = path; this.ParentPath = parentPath; this.Properties = new ReadOnlyCollection <DscResourcePropertyInfo>(new List <DscResourcePropertyInfo>()); }
/// <summary> /// NeedToLogPipelineExecutionDetailEvent: check whether logging pipeline execution detail event is necessary. /// /// Whether to log command lifecycle event is controled by PSSnapin set up. /// /// Should we use session variable "LogPipelineExecutionEvent" to control this also? /// /// Currently we return true always since pipeline processor already check for whether to log /// logic from PSSnapin already. This may need to be changed. /// </summary> /// <param name="logProvider"></param> /// <param name="executionContext"></param> /// <returns></returns> private static bool NeedToLogPipelineExecutionDetailEvent(LogProvider logProvider, ExecutionContext executionContext) { if (!logProvider.UseLoggingVariables()) { return(true); } return(true); // return LanguagePrimitives.IsTrue(executionContext.GetVariable("LogPipelineExecutionDetailEvent", false)); }
/// <summary> /// Constructor for InvocationInfo object /// </summary> /// <param name="commandInfo"> /// The command information the invocation info represents. /// </param> /// <param name="scriptPosition"> /// The position representing the invocation, or the position representing the error. /// </param> /// <param name="context"> /// The context in which the InvocationInfo is being created. /// </param> internal InvocationInfo(CommandInfo commandInfo, IScriptExtent scriptPosition, ExecutionContext context) { MyCommand = commandInfo; CommandOrigin = CommandOrigin.Internal; _scriptPosition = scriptPosition; ExecutionContext contextToUse = null; if ((commandInfo != null) && (commandInfo.Context != null)) { contextToUse = commandInfo.Context; } else if (context != null) { contextToUse = context; } // Populate the history ID of this command if (contextToUse != null) { Runspaces.LocalRunspace localRunspace = contextToUse.CurrentRunspace as Runspaces.LocalRunspace; if (localRunspace != null && localRunspace.History != null) { HistoryId = localRunspace.History.GetNextHistoryId(); } } }
/// <summary> /// Generate LogContext structure based on executionContext and invocationInfo passed in. /// /// LogContext structure is used in log provider interface. /// </summary> /// <param name="executionContext"></param> /// <param name="invocationInfo"></param> /// <returns></returns> internal static LogContext GetLogContext(ExecutionContext executionContext, InvocationInfo invocationInfo) { return(GetLogContext(executionContext, invocationInfo, Severity.Informational)); }
internal static PowerShell Convert(ScriptBlockAst body, ReadOnlyCollection <ParameterAst> functionParameters, bool isTrustedInput, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables, bool?createLocalScope, object[] args) { ExecutionContext.CheckStackDepth(); if (args == null) { args = Utils.EmptyArray <object>(); } // Perform validations on the ScriptBlock. GetSimplePipeline can allow for more than one // pipeline if the first parameter is true, but Invoke-Command doesn't yet support multiple // pipelines in a PowerShell (it just grabs the last command directly.) The rest of this // code properly supports multiple pipelines, so it should just work to change the false to true // if/when Invoke-Command can support multiple pipelines. string errorId; string errorMsg; body.GetSimplePipeline(true, out errorId, out errorMsg); if (errorId != null) { throw new ScriptBlockToPowerShellNotSupportedException(errorId, null, errorMsg); } var checker = new ScriptBlockToPowerShellChecker { ScriptBeingConverted = body }; if (functionParameters != null) { foreach (var parameter in functionParameters) { parameter.InternalVisit(checker); } } body.InternalVisit(checker); // When the context is null (or they haven't supplied any variables), throw, but only if we really need the // context (basically, if we have some variable reference to resolve). if (context == null && (checker.HasUsingExpr || checker.UsesParameter) && (variables == null)) { throw new PSInvalidOperationException(AutomationExceptions.CantConvertScriptBlockWithNoContext); } try { var converter = new ScriptBlockToPowerShellConverter { _context = context, _createLocalScope = createLocalScope }; if (checker.HasUsingExpr) { converter._usingValueMap = GetUsingValues(body, isTrustedInput, context, variables, filterNonUsingVariables).Item1; } if (checker.UsesParameter) { // If any parameters are used, we create a new scope and bind the parameters. var newScope = context.EngineSessionState.NewScope(false); context.EngineSessionState.CurrentScope = newScope; context.EngineSessionState.CurrentScope.ScopeOrigin = CommandOrigin.Internal; var locals = MutableTuple.MakeTuple(Compiler.DottedLocalsTupleType, Compiler.DottedLocalsNameIndexMap); // Get the parameter metadata for the script block. // If 'functionParameters' is not null, then the ScriptBlockAst is actually the body of a FunctionDefinitionAst, and it doesn't have a ParamBlock. // If 'functionParameters' is null, then the ScriptBlockAst may have parameters defined in its ParamBlock. bool usesCmdletBinding = false; var parameters = functionParameters != null ? Compiler.GetParameterMetaData(functionParameters, true, ref usesCmdletBinding) : ((IParameterMetadataProvider)body).GetParameterMetadata(true, ref usesCmdletBinding); object[] remainingArgs = ScriptBlock.BindArgumentsForScriptblockInvoke( (RuntimeDefinedParameter[])parameters.Data, args, context, false, null, locals); locals.SetAutomaticVariable(AutomaticVariable.Args, remainingArgs, context); newScope.LocalsTuple = locals; } foreach (var pipeline in body.EndBlock.Statements.OfType <PipelineAst>()) { converter._powershell.AddStatement(); converter.ConvertPipeline(pipeline, isTrustedInput); } return(converter._powershell); } finally { if (checker.UsesParameter) { context.EngineSessionState.RemoveScope(context.EngineSessionState.CurrentScope); } } }
internal static IEnumerable <CommandInfo> GetMatchingCommands(string pattern, System.Management.Automation.ExecutionContext context, CommandOrigin commandOrigin, bool rediscoverImportedModules = false) { return(new _GetMatchingCommands_d__a(-2) { __3__pattern = pattern, __3__context = context, __3__commandOrigin = commandOrigin, __3__rediscoverImportedModules = rediscoverImportedModules }); }
/// <summary> /// Generate LogContext structure based on executionContext and invocationInfo passed in. /// /// LogContext structure is used in log provider interface. /// </summary> /// <param name="executionContext"></param> /// <param name="invocationInfo"></param> /// <param name="severity"></param> /// <returns></returns> private static LogContext GetLogContext(ExecutionContext executionContext, InvocationInfo invocationInfo, Severity severity) { if (executionContext == null) { return(null); } LogContext logContext = new LogContext(); string shellId = executionContext.ShellID; logContext.ExecutionContext = executionContext; logContext.ShellId = shellId; logContext.Severity = severity.ToString(); if (executionContext.EngineHostInterface != null) { logContext.HostName = executionContext.EngineHostInterface.Name; logContext.HostVersion = executionContext.EngineHostInterface.Version.ToString(); logContext.HostId = (string)executionContext.EngineHostInterface.InstanceId.ToString(); } logContext.HostApplication = string.Join(" ", Environment.GetCommandLineArgs()); if (executionContext.CurrentRunspace != null) { logContext.EngineVersion = executionContext.CurrentRunspace.Version.ToString(); logContext.RunspaceId = executionContext.CurrentRunspace.InstanceId.ToString(); Pipeline currentPipeline = ((RunspaceBase)executionContext.CurrentRunspace).GetCurrentlyRunningPipeline(); if (currentPipeline != null) { logContext.PipelineId = currentPipeline.InstanceId.ToString(CultureInfo.CurrentCulture); } } logContext.SequenceNumber = NextSequenceNumber; try { if (executionContext.LogContextCache.User == null) { logContext.User = Environment.UserDomainName + "\\" + Environment.UserName; executionContext.LogContextCache.User = logContext.User; } else { logContext.User = executionContext.LogContextCache.User; } } catch (InvalidOperationException) { logContext.User = Logging.UnknownUserName; } System.Management.Automation.Remoting.PSSenderInfo psSenderInfo = executionContext.SessionState.PSVariable.GetValue("PSSenderInfo") as System.Management.Automation.Remoting.PSSenderInfo; if (psSenderInfo != null) { logContext.ConnectedUser = psSenderInfo.UserInfo.Identity.Name; } logContext.Time = DateTime.Now.ToString(CultureInfo.CurrentCulture); if (invocationInfo == null) { return(logContext); } logContext.ScriptName = invocationInfo.ScriptName; logContext.CommandLine = invocationInfo.Line; if (invocationInfo.MyCommand != null) { logContext.CommandName = invocationInfo.MyCommand.Name; logContext.CommandType = invocationInfo.MyCommand.CommandType.ToString(); switch (invocationInfo.MyCommand.CommandType) { case CommandTypes.Application: logContext.CommandPath = ((ApplicationInfo)invocationInfo.MyCommand).Path; break; case CommandTypes.ExternalScript: logContext.CommandPath = ((ExternalScriptInfo)invocationInfo.MyCommand).Path; break; } } return(logContext); }