/// <summary>
/// NeedToLogProviderLifecycleEvent: check whether logging Provider lifecycle event is necessary.
/// Whether to log Provider lifecycle event is controled by session variable "LogProviderLifecycleEvent"
/// The default value for this is true.
/// </summary>
/// <param name="logProvider"></param>
/// <param name="executionContext"></param>
/// <returns></returns>
private static bool NeedToLogProviderLifecycleEvent(LogProvider logProvider, ExecutionContext executionContext)
{
if (!logProvider.UseLoggingVariables())
{
return(true);
}
return(LanguagePrimitives.IsTrue(executionContext.GetVariableValue(SpecialVariables.LogProviderLifecycleEventVarPath, true)));
}
/// <summary>
/// Gets PSLogUserData from execution context.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
protected static string GetPSLogUserData(ExecutionContext context)
{
if (context == null)
{
return(String.Empty);
}
object logData = context.GetVariableValue(SpecialVariables.PSLogUserDataPath);
if (logData == null)
{
return(String.Empty);
}
return(logData.ToString());
}
private void GetSplattedVariable(VariableExpressionAst variableAst)
{
if (_context == null)
{
throw new PSInvalidOperationException(AutomationExceptions.CantConvertScriptBlockWithNoContext);
}
// Process the contents of a splatted variable into the arguments for this
// command. If the variable contains a hashtable, distribute the key/value pairs
// If it's an enumerable, then distribute the values as $args and finally
// if it's a scalar, then the effect is equivalent to $var
object splattedValue = _context.GetVariableValue(variableAst.VariablePath);
foreach (var splattedParameter in PipelineOps.Splat(splattedValue, variableAst))
{
CommandParameter publicParameter = CommandParameter.FromCommandParameterInternal(splattedParameter);
_powershell.AddParameter(publicParameter.Name, publicParameter.Value);
}
}
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);
}
/// <summary>
/// Get a Hashtable object out of a PowerShell data file (.psd1)
/// </summary>
/// <param name="parameterName">
/// Name of the parameter that takes the specified .psd1 file as a value
/// </param>
/// <param name="psDataFilePath">
/// Path to the powershell data file
/// </param>
/// <param name="context">
/// ExecutionContext to use
/// </param>
/// <param name="allowedCommands">
/// Set of command names that are allowed to use in the .psd1 file
/// </param>
/// <param name="allowedVariables">
/// Set of variable names that are allowed to use in the .psd1 file
/// </param>
/// <param name="allowEnvironmentVariables">
/// If true, allow to use environment variables in the .psd1 file
/// </param>
/// <param name="skipPathValidation">
/// If true, caller guarantees the path is valid
/// </param>
/// <returns></returns>
internal static Hashtable EvaluatePowerShellDataFile(
string parameterName,
string psDataFilePath,
ExecutionContext context,
IEnumerable <string> allowedCommands,
IEnumerable <string> allowedVariables,
bool allowEnvironmentVariables,
bool skipPathValidation)
{
if (!skipPathValidation && string.IsNullOrEmpty(parameterName))
{
throw PSTraceSource.NewArgumentNullException("parameterName");
}
if (string.IsNullOrEmpty(psDataFilePath))
{
throw PSTraceSource.NewArgumentNullException("psDataFilePath");
}
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
string resolvedPath;
if (skipPathValidation)
{
resolvedPath = psDataFilePath;
}
else
{
#region "ValidatePowerShellDataFilePath"
bool isPathValid = true;
// File extension needs to be .psd1
string pathExt = Path.GetExtension(psDataFilePath);
if (string.IsNullOrEmpty(pathExt) ||
!StringLiterals.PowerShellDataFileExtension.Equals(pathExt, StringComparison.OrdinalIgnoreCase))
{
isPathValid = false;
}
ProviderInfo provider;
var resolvedPaths = context.SessionState.Path.GetResolvedProviderPathFromPSPath(psDataFilePath, out provider);
// ConfigPath should be resolved as FileSystem provider
if (provider == null || !Microsoft.PowerShell.Commands.FileSystemProvider.ProviderName.Equals(provider.Name, StringComparison.OrdinalIgnoreCase))
{
isPathValid = false;
}
// ConfigPath should be resolved to a single path
if (resolvedPaths.Count != 1)
{
isPathValid = false;
}
if (!isPathValid)
{
throw PSTraceSource.NewArgumentException(
parameterName,
ParserStrings.CannotResolvePowerShellDataFilePath,
psDataFilePath);
}
resolvedPath = resolvedPaths[0];
#endregion "ValidatePowerShellDataFilePath"
}
#region "LoadAndEvaluatePowerShellDataFile"
object evaluationResult;
try
{
// Create the scriptInfo for the .psd1 file
string dataFileName = Path.GetFileName(resolvedPath);
var dataFileScriptInfo = new ExternalScriptInfo(dataFileName, resolvedPath, context);
ScriptBlock scriptBlock = dataFileScriptInfo.ScriptBlock;
// Validate the scriptblock
scriptBlock.CheckRestrictedLanguage(allowedCommands, allowedVariables, allowEnvironmentVariables);
// Evaluate the scriptblock
object oldPsScriptRoot = context.GetVariableValue(SpecialVariables.PSScriptRootVarPath);
try
{
// Set the $PSScriptRoot before the evaluation
context.SetVariable(SpecialVariables.PSScriptRootVarPath, Path.GetDirectoryName(resolvedPath));
evaluationResult = PSObject.Base(scriptBlock.InvokeReturnAsIs());
}
finally
{
context.SetVariable(SpecialVariables.PSScriptRootVarPath, oldPsScriptRoot);
}
}
catch (RuntimeException ex)
{
throw PSTraceSource.NewInvalidOperationException(
ex,
ParserStrings.CannotLoadPowerShellDataFile,
psDataFilePath,
ex.Message);
}
var retResult = evaluationResult as Hashtable;
if (retResult == null)
{
throw PSTraceSource.NewInvalidOperationException(
ParserStrings.InvalidPowerShellDataFile,
psDataFilePath);
}
#endregion "LoadAndEvaluatePowerShellDataFile"
return(retResult);
}