public static string InvokeAutomation(string cmd)
{
Runspace newrunspace = RunspaceFactory.CreateRunspace();
newrunspace.Open();
// transcript evasion
RunspaceInvoke scriptInvoker = new RunspaceInvoke(newrunspace);
var cmdin = new System.Management.Automation.PSVariable("c");
newrunspace.SessionStateProxy.PSVariable.Set(cmdin);
var output = new System.Management.Automation.PSVariable("o");
newrunspace.SessionStateProxy.PSVariable.Set(output);
Pipeline pipeline = newrunspace.CreatePipeline();
newrunspace.SessionStateProxy.SetVariable("c", cmd);
pipeline.Commands.AddScript("$o = IEX $c | Out-String");
Collection <PSObject> results = pipeline.Invoke();
newrunspace.Close();
StringBuilder stringBuilder = new StringBuilder();
foreach (PSObject obj in results)
{
stringBuilder.Append(obj);
}
return(stringBuilder.ToString().Trim());
}
internal override void SetSessionStateItem(string name, object value, bool writeItem)
{
Path path = PathIntrinsics.RemoveDriveName(name);
name = path.TrimStartSlash();
PSVariable variable = null;
if (value != null)
{
variable = value as PSVariable;
if (variable == null)
{
variable = new PSVariable(name, value);
}
else if (String.Compare(name, variable.Name, true, System.Globalization.CultureInfo.CurrentCulture) != 0)
{
PSVariable var = new PSVariable(name, variable.Value, variable.Options, variable.Attributes);
var.Description = variable.Description;
variable = var;
}
}
else
{
variable = new PSVariable(name, null);
}
// TODO: can be Force'ed
SessionState.PSVariable.Set(variable);
PSVariable item = SessionState.PSVariable.Get(variable.Name);
if (writeItem && (item != null))
{
WriteItemObject(item, item.Name, false);
}
}
public static void Set__variable(this PSVariableProperty source, PSVariable value)
{
if (source == null)
throw new ArgumentNullException("source");
FieldSetterDelegate__variable.Set(source, value);
}
protected override void ProcessRecord()
{
// TODO: deal with Force
// TODO: deal with ShouldProcess
PSVariable variable = new PSVariable(Name, Value, Option);
if (Description != null)
{
variable.Description = Description;
}
//TODO: check if variable already exists and check if force has influence on behavior
//implement also an overloaded Get method in PSVariableIntrniscs that allow to pass a scope
try
{
//TODO: create a new overloaded method in PSVariableIntrinsics that allows to pass (bool)this.Force
SessionState.PSVariable.Set(variable);
}
catch (Exception ex)
{
WriteError(new ErrorRecord(ex, "", ErrorCategory.InvalidOperation, variable));
return;
}
if (PassThru.ToBool())
{
WriteObject(variable);
}
}
internal override void SetSessionStateItem(string name, object value, bool writeItem)
{
PSVariable variable = null;
if (value != null)
{
variable = value as PSVariable;
if (variable == null)
{
variable = new PSVariable(name, value);
}
else if (!string.Equals(name, variable.Name, StringComparison.OrdinalIgnoreCase))
{
variable = new PSVariable(name, variable.Value, variable.Options, variable.Attributes) {
Description = variable.Description
};
}
}
else
{
variable = new PSVariable(name, null);
}
PSVariable item = base.SessionState.Internal.SetVariable(variable, (bool) base.Force, base.Context.Origin) as PSVariable;
if (writeItem && (item != null))
{
base.WriteItemObject(item, item.Name, false);
}
}
/// <summary>
/// Add an new SessionStateVariable entry to this session state object...
/// </summary>
/// <param name="entry">The entry to add</param>
internal void AddSessionStateEntry(SessionStateVariableEntry entry)
{
PSVariable v = new PSVariable(entry.Name, entry.Value,
entry.Options, entry.Attributes, entry.Description);
v.Visibility = entry.Visibility;
this.SetVariableAtScope(v, "global", true, CommandOrigin.Internal);
}
internal override void SetSessionStateItem(Path name, object value, bool writeItem)
{
PSVariable variable = null;
if (value != null)
{
variable = value as PSVariable;
if (variable == null)
{
variable = new PSVariable(name, value);
}
else if (String.Compare(name, variable.Name, true, System.Globalization.CultureInfo.CurrentCulture) != 0)
{
PSVariable var = new PSVariable(name, variable.Value, variable.Options, variable.Attributes);
var.Description = variable.Description;
variable = var;
}
}
else
{
variable = new PSVariable(name, null);
}
// TODO: can be Force'ed
PSVariable item = base.SessionState.SessionStateGlobal.SetVariable(variable) as PSVariable;
if (writeItem && (item != null))
{
WriteItemObject(item, item.Name, false);
}
}
protected override void ProcessRecord()
{
if (this.Force == 0)
{
PSVariable atScope = null;
if (string.IsNullOrEmpty(base.Scope))
{
atScope = base.SessionState.PSVariable.GetAtScope(this.name, "local");
}
else
{
atScope = base.SessionState.PSVariable.GetAtScope(this.name, base.Scope);
}
if (atScope != null)
{
SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(this.name, SessionStateCategory.Variable, "VariableAlreadyExists", SessionStateStrings.VariableAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
return;
}
}
string newVariableAction = VariableCommandStrings.NewVariableAction;
string target = StringUtil.Format(VariableCommandStrings.NewVariableTarget, this.Name, this.Value);
if (base.ShouldProcess(target, newVariableAction))
{
PSVariable variable = new PSVariable(this.name, this._value, this.options);
if (this._visibility.HasValue)
{
variable.Visibility = this._visibility.Value;
}
if (this.description != null)
{
variable.Description = this.description;
}
try
{
if (string.IsNullOrEmpty(base.Scope))
{
base.SessionState.Internal.NewVariable(variable, (bool) this.Force);
}
else
{
base.SessionState.Internal.NewVariableAtScope(variable, base.Scope, (bool) this.Force);
}
}
catch (SessionStateException exception2)
{
base.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2));
return;
}
catch (PSArgumentException exception3)
{
base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3));
return;
}
if (this.passThru)
{
base.WriteObject(variable);
}
}
}
protected override void ProcessRecord()
{
// TODO: deal with scope
// TODO: deal with Force
// TODO: deal with ShouldProcess
PSVariable variable = new PSVariable(Name, Value, Option);
if (Description != null)
{
variable.Description = Description;
}
try
{
SessionState.SessionStateGlobal.NewVariable(variable, (bool)this.Force);
}
catch (Exception ex)
{
WriteError(new ErrorRecord(ex, "", ErrorCategory.InvalidOperation, variable));
return;
}
if (PassThru.ToBool())
{
WriteObject(variable);
}
}
protected internal void CheckVariableCanBeChanged(PSVariable variable, bool force)
{
if ((variable.ItemOptions.HasFlag(ScopedItemOptions.ReadOnly) && !force) ||
variable.ItemOptions.HasFlag(ScopedItemOptions.Constant))
{
throw SessionStateUnauthorizedAccessException.CreateVariableNotWritableError(variable);
}
}
private void CheckVariableCanBeRemoved(PSVariable variable)
{
if ((variable.ItemOptions.HasFlag(ScopedItemOptions.ReadOnly) && !Force) ||
variable.ItemOptions.HasFlag(ScopedItemOptions.Constant))
{
throw SessionStateUnauthorizedAccessException.CreateVariableNotRemovableError(variable);
}
}
public PSVariableProperty(PSVariable variable) : base((variable != null) ? variable.Name : null, null)
{
if (variable == null)
{
throw PSTraceSource.NewArgumentException("variable");
}
this._variable = variable;
}
public void Remove(PSVariable variable)
{
//no scope specified when passing an object: we only care about the local scope
if (variable == null)
{
throw new ArgumentNullException("The variable is null.");
}
//add the local scope specifier to make sure we don't screw up with other variables
Remove("local:" + variable.Name);
}
private PSVariable ClearValue(PSVariable matchingVariable)
{
PSVariable variable = matchingVariable;
if (base.Scope != null)
{
matchingVariable.Value = null;
return variable;
}
base.SessionState.PSVariable.Set(matchingVariable.Name, null);
return base.SessionState.PSVariable.Get(matchingVariable.Name);
}
public static void startrunspace()
{
newrunspace = RunspaceFactory.CreateRunspace();
newrunspace.Open();
var cmd = new System.Management.Automation.PSVariable("c");
newrunspace.SessionStateProxy.PSVariable.Set(cmd);
var output = new System.Management.Automation.PSVariable("o");
newrunspace.SessionStateProxy.PSVariable.Set(output);
}
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 bool TryGetLocalVariable(string name, bool fromNewOrSet, out PSVariable result)
{
int index;
name = VariableAnalysis.GetUnaliasedVariableName(name);
if (_nameToIndexMap.TryGetValue(name, out index) && (fromNewOrSet || IsValueSet(index)))
{
result = new LocalVariable(name, this, index);
return true;
}
result = null;
return false;
}
/// <summary>
/// Invoke a <see cref="ScriptBlock"/>, binding it to the module, if possible.
/// </summary>
/// <param name="sb">The <see cref="ScriptBlock"/></param>
/// <param name="variables">Variables to set before invoking</param>
/// <param name="args">Arguments to the <see cref="ScriptBlock"/></param>
/// <returns>A collection of <see cref="PSObject"/></returns>
internal static ICollection<PSObject> Invoke(ScriptBlock sb, PSVariable[] variables, params object[] args)
{
if (variables == null)
throw new ArgumentNullException("variables");
foreach (var v in variables) SetScriptVariable(v);
if (_module != null)
{
sb = _module.NewBoundScriptBlock(sb);
}
return sb.Invoke(args);
}
public void Set(PSVariable variable)
{
if (variable == null)
{
throw new ArgumentNullException("The variable is null.");
}
var original = _scope.GetLocal(variable.Name);
if (original == null)
{
_scope.SetLocal(variable, true);
return;
}
original.Value = variable.Value;
original.Description = variable.Description;
original.Options = variable.Options;
_scope.SetLocal(original, true);
}
internal override void BindParameter(string name, object value)
{
if ((value == AutomationNull.Value) || (value == UnboundParameter.Value))
{
value = null;
}
VariablePath variablePath = new VariablePath(name, VariablePathFlags.Variable);
if (((this.LocalScope == null) || !variablePath.IsAnyLocal()) || !this.LocalScope.TrySetLocalParameterValue(variablePath.UnqualifiedPath, this.CopyMutableValues(value)))
{
RuntimeDefinedParameter parameter;
PSVariable newValue = new PSVariable(variablePath.UnqualifiedPath, value, variablePath.IsPrivate ? ScopedItemOptions.Private : ScopedItemOptions.None);
base.Context.EngineSessionState.SetVariable(variablePath, newValue, false, CommandOrigin.Internal);
if (this.Script.RuntimeDefinedParameters.TryGetValue(name, out parameter))
{
newValue.AddParameterAttributesNoChecks(parameter.Attributes);
}
}
}
/// <summary> A SessionState extension method that adds a service connection. </summary>
/// <exception cref="ArgumentNullException">Thrown when one or more required arguments are null. </exception>
/// <param name="sessionState"> . </param>
/// <param name="connectionName"> The connection Name. </param>
/// <param name="connection"> The connection. </param>
/// <returns> A St2ClientConnection. </returns>
public static St2ClientConnection AddServiceConnection(this SessionState sessionState,
string connectionName, St2ClientConnection connection)
{
if (sessionState == null)
throw new ArgumentNullException("sessionState");
if (connection == null)
throw new ArgumentNullException("connection");
if (string.IsNullOrEmpty(connectionName))
throw new ArgumentNullException("connectionName");
Dictionary<string, St2ClientConnection> connections;
PSVariable connectionsVariable = sessionState.PSVariable.Get(VariableNames.ServiceSessions);
if (connectionsVariable == null)
{
connectionsVariable = new PSVariable(
VariableNames.ServiceSessions, connections = new Dictionary<string, St2ClientConnection>(),
ScopedItemOptions.AllScope
);
sessionState.PSVariable.Set(connectionsVariable);
}
else
{
connections = (Dictionary<string, St2ClientConnection>)connectionsVariable.Value;
if (connections == null)
{
connectionsVariable.Value = connections = new Dictionary<string, St2ClientConnection>();
sessionState.PSVariable.Set(connectionsVariable);
}
}
if (!connections.ContainsKey(connectionName))
connections.Add(connectionName, connection);
else
connections[connectionName] = connection;
if (string.IsNullOrEmpty(_defaultComputeServiceConnectionName) || connections.Count().Equals(1))
_defaultComputeServiceConnectionName = connectionName;
return connection;
}
protected override void EndProcessing()
{
foreach (string name in Name)
{
foreach (object value in _values)
{
PSVariable variable = SessionState.PSVariable.Get(name);
if (variable == null)
{
variable = new PSVariable(name, value);
}
else
{
variable.Value = value;
}
SessionState.PSVariable.Set(variable);
}
}
}
static SessionStateUnauthorizedAccessException CreateError(
PSVariable variable,
string message,
string errorId)
{
var ex = new SessionStateUnauthorizedAccessException(
message,
variable.Name,
SessionStateCategory.Variable);
var error = new ErrorRecord(
new ParentContainsErrorRecordException(ex),
errorId,
ErrorCategory.WriteError,
variable.Name);
ex.ErrorRecord = error;
ex.Source = typeof(PSVariable).Namespace;
return ex;
}
protected override void ProcessRecord()
{
// TODO: deal with ShouldProcess
var variable = new PSVariable(Name, Value, Option);
variable.Visibility = Visibility;
if (Description != null)
{
variable.Description = Description;
}
try
{
if (!Force && VariableAlreadyExists(variable))
{
WriteVariableAlreadyExistsError(variable);
return;
}
SessionState.PSVariable.SetAtScope(variable, Scope, Force);
}
catch (SessionStateUnauthorizedAccessException ex)
{
WriteError(ex.ErrorRecord);
return;
}
catch (Exception ex)
{
WriteError(new ErrorRecord(ex, "", ErrorCategory.InvalidOperation, variable));
return;
}
if (PassThru.ToBool())
{
WriteObject(variable);
}
}
private PSVariable SetVariable(string name, object value)
{
PSVariable variable = SessionState.PSVariable.GetAtScope(name, Scope);
if (variable == null)
{
variable = new PSVariable(name, value, Option);
variable.Visibility = Visibility;
}
else
{
CheckVariableCanBeChanged(variable, Force);
variable.Value = value;
SetVariableOptions(variable);
}
variable.Description = Description ?? String.Empty;
SessionState.PSVariable.SetAtScope(variable, Scope, Force);
return variable;
}
private void CheckVariableOptionCanBeChanged(PSVariable variable)
{
CheckVariableCanBeChanged(variable, Force);
if (_option == ScopedItemOptions.Constant)
{
throw SessionStateUnauthorizedAccessException.CreateVariableCannotBeMadeConstantError(variable);
}
}
internal void RemoveVariable(PSVariable variable)
{
RemoveVariable(variable.Name);
}
internal object SetVariable(string name, object value)
{
PSVariable variable = GetVariable(name);
if (variable != null)
RemoveVariable(variable);
variable = new PSVariable(name, value);
_variables.Add(variable.Name, variable);
return variable;
}
public void Remove(PSVariable variable)
{
_sessionState.RemoveVariable(variable);
}
public static bool ImportVariables(
SettingsCmdletBase cmdlet,
IEnumerable<XElement> variablesCollection)
{
bool result = false;
foreach (XElement element in variablesCollection) {
string variableName = string.Empty;
try {
variableName =
element.Attribute((XName)"name").Value;
cmdlet.WriteVerbose(cmdlet, "importing the '" + variableName + "' variable");
string variableValue =
string.Empty;
try {
variableValue =
element.Attribute((XName)"value").Value;
}
catch {
// nothing to do
}
//ScopedItemOptions.AllScope
//ScopedItemOptions.Constant
//ScopedItemOptions.None
//ScopedItemOptions.Private
//ScopedItemOptions.ReadOnly
//ScopedItemOptions.Unspecified
PSVariable variable =
new PSVariable(
variableName,
variableValue);
cmdlet.SessionState.PSVariable.Set(variable);
}
catch (Exception eLoadingVariable) {
cmdlet.WriteError(
cmdlet,
"Unable to load variable '" +
variableName +
"'. " +
eLoadingVariable.Message,
"FailedToLoadVariable",
ErrorCategory.InvalidData,
false);
}
}
return result;
}
internal static Exception CreateVariableCannotBeMadeConstantError(PSVariable variable)
{
string message = String.Format("Existing variable {0} cannot be made constant. Variables can be made constant only at creation time.", variable.Name);
return(CreateError(variable, message, "VariableCannotBeMadeConstant"));
}
internal static object SetVariableValue(VariablePath variablePath, object value, ExecutionContext executionContext, AttributeBaseAst[] attributeAsts)
{
SessionStateInternal sessionState = executionContext.EngineSessionState;
CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin;
if (!variablePath.IsVariable)
{
sessionState.SetVariable(variablePath, value, true, origin);
return(value);
}
// Variable assignment is traced only if trace level 2 is specified.
if (executionContext.PSDebugTraceLevel > 1)
{
executionContext.Debugger.TraceVariableSet(variablePath.UnqualifiedPath, value);
}
if (variablePath.IsUnscopedVariable)
{
variablePath = variablePath.CloneAndSetLocal();
}
SessionStateScope scope;
PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin);
if (var == null)
{
var attributes = attributeAsts == null
? new Collection <Attribute>()
: GetAttributeCollection(attributeAsts);
var = new PSVariable(variablePath.UnqualifiedPath, value, ScopedItemOptions.None, attributes);
sessionState.SetVariable(variablePath, var, false, origin);
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
}
}
else if (attributeAsts != null)
{
var.Attributes.Clear();
var attributes = GetAttributeCollection(attributeAsts);
value = PSVariable.TransformValue(attributes, value);
if (!PSVariable.IsValidValue(attributes, value))
{
ValidationMetadataException e = new ValidationMetadataException(
"ValidateSetFailure",
null,
Metadata.InvalidValueFailure,
var.Name,
((value != null) ? value.ToString() : "$null"));
throw e;
}
var.SetValueRaw(value, true);
var.AddParameterAttributesNoChecks(attributes);
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
}
}
else
{
// The setter will handle checking for variable writes.
var.Value = value;
}
return(value);
}
internal static SessionStateUnauthorizedAccessException CreateVariableNotRemovableError(PSVariable variable)
{
string message = String.Format("Cannot remove variable {0} because it is constant or read-only. If the variable is read-only, try the operation again specifying the Force option.", variable.Name);
return(CreateError(variable, message, "VariableNotRemovable"));
}
internal static SessionStateUnauthorizedAccessException CreateVariableNotWritableError(PSVariable variable)
{
string message = String.Format("Cannot overwrite variable {0} because it is read-only or constant.", variable.Name);
return(CreateError(variable, message, "VariableNotWritable"));
}
public void Set(PSVariable variable)
{
_sessionState.SetVariable(variable);
}
private void SetVariableOptions(PSVariable variable)
{
if (_option.HasValue && variable.Options != _option.Value)
{
CheckVariableOptionCanBeChanged(variable);
variable.Options = _option.Value;
}
}
internal static object SetVariableValue(VariablePath variablePath, object value, ExecutionContext executionContext, AttributeBaseAst[] attributeAsts)
{
SessionStateInternal sessionState = executionContext.EngineSessionState;
CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin;
if (!variablePath.IsVariable)
{
sessionState.SetVariable(variablePath, value, true, origin);
return(value);
}
// Variable assignment is traced only if trace level 2 is specified.
if (executionContext.PSDebugTraceLevel > 1)
{
executionContext.Debugger.TraceVariableSet(variablePath.UnqualifiedPath, value);
}
if (variablePath.IsUnscopedVariable)
{
variablePath = variablePath.CloneAndSetLocal();
}
SessionStateScope scope;
PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin);
if (var == null)
{
var attributes = attributeAsts == null
? new Collection <Attribute>()
: GetAttributeCollection(attributeAsts);
var = new PSVariable(variablePath.UnqualifiedPath, value, ScopedItemOptions.None, attributes);
sessionState.SetVariable(variablePath, var, false, origin);
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
}
}
else if (attributeAsts != null)
{
// Use bytewise operation directly instead of 'var.IsReadOnly || var.IsConstant' on
// a hot path (setting variable with type constraint) to get better performance.
if ((var.Options & (ScopedItemOptions.ReadOnly | ScopedItemOptions.Constant)) != ScopedItemOptions.None)
{
SessionStateUnauthorizedAccessException e =
new SessionStateUnauthorizedAccessException(
var.Name,
SessionStateCategory.Variable,
"VariableNotWritable",
SessionStateStrings.VariableNotWritable);
throw e;
}
var attributes = GetAttributeCollection(attributeAsts);
value = PSVariable.TransformValue(attributes, value);
if (!PSVariable.IsValidValue(attributes, value))
{
ValidationMetadataException e = new ValidationMetadataException(
"ValidateSetFailure",
null,
Metadata.InvalidValueFailure,
var.Name,
((value != null) ? value.ToString() : "$null"));
throw e;
}
var.SetValueRaw(value, true);
// Don't update the PSVariable's attributes until we successfully set the value
var.Attributes.Clear();
var.AddParameterAttributesNoChecks(attributes);
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableWrite(variablePath.UnqualifiedPath);
}
}
else
{
// The setter will handle checking for variable writes.
var.Value = value;
}
return(value);
}
internal void RemoveAtScope(PSVariable variable, string scope)
{
this.sessionState.RemoveVariableAtScope(variable, scope);
}
public void Set(PSVariable variable)
{
this.sessionState.SetVariable(variable, false, CommandOrigin.Internal);
}
internal void NewVariable(PSVariable variable, bool force)
{
throw new NotImplementedException();
}
/// <summary>
/// Add the variables that must always be present in a SessionState instance...
/// </summary>
internal void InitializeFixedVariables()
{
//
// BUGBUG
//
// String resources for aliases are currently associated with Runspace init
//
// $Host
PSVariable v = new PSVariable(
SpecialVariables.Host,
ExecutionContext.EngineHostInterface,
ScopedItemOptions.Constant | ScopedItemOptions.AllScope,
RunspaceInit.PSHostDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $HOME - indicate where a user's home directory is located in the file system.
// -- %USERPROFILE% on windows
// -- %HOME% on unix
string home = Environment.GetEnvironmentVariable(Platform.CommonEnvVariableNames.Home) ?? string.Empty;
v = new PSVariable(SpecialVariables.Home,
home,
ScopedItemOptions.ReadOnly | ScopedItemOptions.AllScope,
RunspaceInit.HOMEDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $ExecutionContext
v = new PSVariable(SpecialVariables.ExecutionContext,
ExecutionContext.EngineIntrinsics,
ScopedItemOptions.Constant | ScopedItemOptions.AllScope,
RunspaceInit.ExecutionContextDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $PSVersionTable
v = new PSVariable(SpecialVariables.PSVersionTable,
PSVersionInfo.GetPSVersionTable(),
ScopedItemOptions.Constant | ScopedItemOptions.AllScope,
RunspaceInit.PSVersionTableDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $PSEdition
v = new PSVariable(SpecialVariables.PSEdition,
PSVersionInfo.PSEditionValue,
ScopedItemOptions.Constant | ScopedItemOptions.AllScope,
RunspaceInit.PSEditionDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $PID
Process currentProcess = Process.GetCurrentProcess();
v = new PSVariable(
SpecialVariables.PID,
currentProcess.Id,
ScopedItemOptions.Constant | ScopedItemOptions.AllScope,
RunspaceInit.PIDDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $PSCulture
v = new PSCultureVariable();
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $PSUICulture
v = new PSUICultureVariable();
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $?
v = new QuestionMarkVariable(this.ExecutionContext);
this.GlobalScope.SetVariableForce(v, this);
// $ShellId - if there is no runspace config, use the default string
string shellId = ExecutionContext.ShellID;
v = new PSVariable(SpecialVariables.ShellId, shellId,
ScopedItemOptions.Constant | ScopedItemOptions.AllScope,
RunspaceInit.MshShellIdDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
// $PSHOME
// This depends on the shellId. If we cannot read the application base
// registry key, set the variable to empty string
string applicationBase = "";
try
{
applicationBase = Utils.GetApplicationBase(shellId);
}
catch (SecurityException)
{
}
v = new PSVariable(SpecialVariables.PSHome, applicationBase,
ScopedItemOptions.Constant | ScopedItemOptions.AllScope,
RunspaceInit.PSHOMEDescription);
this.GlobalScope.SetVariable(v.Name, v, false, true, this, CommandOrigin.Internal, fastPath: true);
}
internal object SetVariable(PSVariable variable)
{
// TODO: deal with scopes
RemoveVariable(variable);
_variables.Add(variable.Name, variable);
return variable;
}
/// <summary>
/// Utility to check the visibility of an object based on the current
/// command origin. If the object implements IHasSessionStateEntryVisibility
/// then the check will be made. If the check fails, then an exception will be thrown...
/// </summary>
/// <param name="origin">The command origin value to check against...</param>
/// <param name="valueToCheck">The object to check.</param>
public static void ThrowIfNotVisible(CommandOrigin origin, object valueToCheck)
{
SessionStateException exception;
if (!IsVisible(origin, valueToCheck))
{
PSVariable sv = valueToCheck as PSVariable;
if (sv != null)
{
exception =
new SessionStateException(
sv.Name,
SessionStateCategory.Variable,
"VariableIsPrivate",
SessionStateStrings.VariableIsPrivate,
ErrorCategory.PermissionDenied);
throw exception;
}
CommandInfo cinfo = valueToCheck as CommandInfo;
if (cinfo != null)
{
string commandName = cinfo.Name;
if (commandName != null)
{
// If we have a name, use it in the error message
exception =
new SessionStateException(
commandName,
SessionStateCategory.Command,
"NamedCommandIsPrivate",
SessionStateStrings.NamedCommandIsPrivate,
ErrorCategory.PermissionDenied);
}
else
{
exception =
new SessionStateException(
string.Empty,
SessionStateCategory.Command,
"CommandIsPrivate",
SessionStateStrings.CommandIsPrivate,
ErrorCategory.PermissionDenied);
}
throw exception;
}
// Catch all error for other types of resources...
exception =
new SessionStateException(
null,
SessionStateCategory.Resource,
"ResourceIsPrivate",
SessionStateStrings.ResourceIsPrivate,
ErrorCategory.PermissionDenied);
throw exception;
}
}
public PSVariableProperty(PSVariable variable)
: base(variable?.Name, (object)null)
=> this._variable = variable != null ? variable : throw PSVariableProperty.tracer.NewArgumentException(nameof(variable));
internal PSVariableAttributeCollection(PSVariable variable) => this.variable = variable != null ? variable : throw PSVariableAttributeCollection.tracer.NewArgumentNullException(nameof(variable));