/// <summary> /// Constructs the parameter binder with the specified type metadata. The binder is only valid /// for a single instance of a bindable runtime-defined parameter collection and only for the duration of a command. /// </summary> /// /// <param name="target"> /// The target runtime-defined parameter collection that the parameter values will be bound to. /// </param> /// /// <param name="command"> /// An instance of the command so that attributes can access the context. /// </param> /// /// <param name="commandLineParameters"> /// The Command line parameter collection to update... /// </param> /// internal RuntimeDefinedParameterBinder( RuntimeDefinedParameterDictionary target, InternalCommand command, CommandLineParameters commandLineParameters) : base(target, command.MyInvocation, command.Context, command) { // NTRAID#Windows Out Of Band Releases-927103-2006/01/25-JonN foreach (var pair in target) { string key = pair.Key; RuntimeDefinedParameter pp = pair.Value; string ppName = (null == pp) ? null : pp.Name; if (null == pp || key != ppName) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, command.MyInvocation, null, ppName, null, null, ParameterBinderStrings.RuntimeDefinedParameterNameMismatch, "RuntimeDefinedParameterNameMismatch", key); throw bindingException; } } this.CommandLineParameters = commandLineParameters; }
internal bool RecordFailure(Exception e, InternalCommand command) { bool stopping = false; lock (this.StopReasonLock) { if (this.firstTerminatingError == null) { RuntimeException.LockStackTrace(e); this.firstTerminatingError = e; } else if ((!(this.firstTerminatingError is PipelineStoppedException) && (command != null)) && (command.Context != null)) { Exception innerException = e; while (((innerException is TargetInvocationException) || (innerException is CmdletInvocationException)) && (innerException.InnerException != null)) { innerException = innerException.InnerException; } if (!(innerException is PipelineStoppedException)) { InvalidOperationException exception = new InvalidOperationException(StringUtil.Format(PipelineStrings.SecondFailure, new object[] { this.firstTerminatingError.GetType().Name, this.firstTerminatingError.StackTrace, innerException.GetType().Name, innerException.StackTrace }), innerException); MshLog.LogCommandHealthEvent(command.Context, exception, Severity.Warning); } } stopping = this.stopping; this.stopping = true; } return(!stopping); }
public void Begin(InternalCommand command) { if ((command == null) || (command.MyInvocation == null)) { throw new ArgumentNullException("command"); } this.Begin(command.MyInvocation.ExpectingInput, command.commandRuntime); }
internal MshCommandRuntime(System.Management.Automation.ExecutionContext context, CommandInfo commandInfo, InternalCommand thisCommand) { this.context = context; this.host = context.EngineHostInterface; this.CBhost = context.EngineHostInterface; this.commandInfo = commandInfo; this.thisCommand = thisCommand; this.shouldLogPipelineExecutionDetail = this.InitShouldLogPipelineExecutionDetail(); }
internal ParameterBinderBase(System.Management.Automation.InvocationInfo invocationInfo, System.Management.Automation.ExecutionContext context, InternalCommand command) { this.RecordBoundParameters = true; bindingTracer.ShowHeaders = false; this.command = command; this.invocationInfo = invocationInfo; this.context = context; this.engine = context.EngineIntrinsics; }
/// <summary> /// Constructs a ScriptParameterBinder with the specified context /// </summary> /// /// <param name="script"> /// The script block representing the code being run /// </param> /// /// <param name="invocationInfo"> /// The invocation information about the code that is being run. /// </param> /// /// <param name="context"> /// The context under which the shell function is executing. /// </param> /// /// <param name="command"> /// The command instance that represents the script in a pipeline. May be null. /// </param> /// /// <param name="localScope"> /// If binding in a new local scope, the scope to set variables in. If dotting, the value is null. /// </param> internal ScriptParameterBinder( ScriptBlock script, InvocationInfo invocationInfo, ExecutionContext context, InternalCommand command, SessionStateScope localScope) : base(invocationInfo, context, command) { Diagnostics.Assert(script != null, "caller to verify script is not null."); this.Script = script; this.LocalScope = localScope; }
internal ScriptParameterBinderController(ScriptBlock script, InvocationInfo invocationInfo, ExecutionContext context, InternalCommand command, SessionStateScope localScope) : base(invocationInfo, context, new ScriptParameterBinder(script, invocationInfo, context, command, localScope)) { this.DollarArgs = new List<object>(); if (script.HasDynamicParameters) { base.UnboundParameters = base.BindableParameters.ReplaceMetadata(script.ParameterMetadata); } else { base._bindableParameters = script.ParameterMetadata; base.UnboundParameters = new List<MergedCompiledCommandParameter>(base._bindableParameters.BindableParameters.Values); } }
internal ProviderIntrinsics(Cmdlet cmdlet) { if (cmdlet == null) { throw PSTraceSource.NewArgumentNullException("cmdlet"); } this.cmdlet = cmdlet; this.item = new ItemCmdletProviderIntrinsics(cmdlet); this.childItem = new ChildItemCmdletProviderIntrinsics(cmdlet); this.content = new ContentCmdletProviderIntrinsics(cmdlet); this.property = new PropertyCmdletProviderIntrinsics(cmdlet); this.securityDescriptor = new SecurityDescriptorCmdletProviderIntrinsics(cmdlet); }
internal RuntimeDefinedParameterBinder(RuntimeDefinedParameterDictionary target, InternalCommand command, CommandLineParameters commandLineParameters) : base(target, command.MyInvocation, command.Context, command) { foreach (string str in target.Keys) { RuntimeDefinedParameter parameter = target[str]; string parameterName = (parameter == null) ? null : parameter.Name; if ((parameter == null) || (str != parameterName)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, command.MyInvocation, null, parameterName, null, null, "ParameterBinderStrings", "RuntimeDefinedParameterNameMismatch", new object[] { str }); throw exception; } } base.CommandLineParameters = commandLineParameters; }
/// <summary> /// Initializes the cmdlet parameter binder controller for /// the specified cmdlet and engine context /// </summary> /// /// <param name="script"> /// The script that contains the parameter metadata. /// </param> /// <param name="invocationInfo"> /// The invocation information about the code being run. /// </param> /// <param name="context"> /// The engine context the cmdlet is run in. /// </param> /// <param name="command"> /// The command that the parameters will be bound to. /// </param> /// <param name="localScope"> /// The scope that the parameter binder will use to set parameters. /// </param> internal ScriptParameterBinderController( ScriptBlock script, InvocationInfo invocationInfo, ExecutionContext context, InternalCommand command, SessionStateScope localScope) : base(invocationInfo, context, new ScriptParameterBinder(script, invocationInfo, context, command, localScope)) { this.DollarArgs = new List<object>(); // Add the script parameter metadata to the bindable parameters // And add them to the unbound parameters list if (script.HasDynamicParameters) { UnboundParameters = this.BindableParameters.ReplaceMetadata(script.ParameterMetadata); } else { _bindableParameters = script.ParameterMetadata; UnboundParameters = new List<MergedCompiledCommandParameter>(_bindableParameters.BindableParameters.Values); } }
/// <summary> /// Constructor for InvocationInfo object when the associated command object is present. /// </summary> /// <param name="command"></param> internal InvocationInfo(InternalCommand command) : this(command.CommandInfo, command.InvocationExtent ?? PositionUtilities.EmptyExtent) { CommandOrigin = command.CommandOrigin; }
internal ScriptParameterBinder(ScriptBlock script, InvocationInfo invocationInfo, ExecutionContext context, InternalCommand command, SessionStateScope localScope) : base(invocationInfo, context, command) { this._copyMutableValueSite = CallSite<Func<CallSite, object, object>>.Create(PSVariableAssignmentBinder.Get()); this.Script = script; this.LocalScope = localScope; }
internal void EnterNestedPrompt(InternalCommand callingCommand) { LocalRunspace runspace = null; try { runspace = this.Runspace as LocalRunspace; } catch (PSNotImplementedException) { } if (runspace != null) { Pipeline currentlyRunningPipeline = this.Runspace.GetCurrentlyRunningPipeline(); if ((currentlyRunningPipeline != null) && (currentlyRunningPipeline == runspace.PulsePipeline)) { throw new InvalidOperationException(); } } if (this.nestedPromptCount < 0) { throw PSTraceSource.NewInvalidOperationException("InternalHostStrings", "EnterExitNestedPromptOutOfSync", new object[0]); } this.nestedPromptCount++; this.executionContext.SetVariable(SpecialVariables.NestedPromptCounterVarPath, this.nestedPromptCount); PromptContextData item = new PromptContextData { SavedContextData = this.executionContext.SaveContextData(), SavedCurrentlyExecutingCommandVarValue = this.executionContext.GetVariableValue(SpecialVariables.CurrentlyExecutingCommandVarPath), SavedPSBoundParametersVarValue = this.executionContext.GetVariableValue(SpecialVariables.PSBoundParametersVarPath), RunspaceAvailability = this.Context.CurrentRunspace.RunspaceAvailability, LanguageMode = this.executionContext.LanguageMode }; PSPropertyInfo info = null; PSPropertyInfo info2 = null; object obj2 = null; object obj3 = null; if (callingCommand != null) { PSObject newValue = PSObject.AsPSObject(callingCommand); info = newValue.Properties["CommandInfo"]; if (info == null) { newValue.Properties.Add(new PSNoteProperty("CommandInfo", callingCommand.CommandInfo)); } else { obj2 = info.Value; info.Value = callingCommand.CommandInfo; } info2 = newValue.Properties["StackTrace"]; if (info2 == null) { newValue.Properties.Add(new PSNoteProperty("StackTrace", new StackTrace())); } else { obj3 = info2.Value; info2.Value = new StackTrace(); } this.executionContext.SetVariable(SpecialVariables.CurrentlyExecutingCommandVarPath, newValue); } this.contextStack.Push(item); this.executionContext.PSDebugTraceStep = false; this.executionContext.PSDebugTraceLevel = 0; this.executionContext.ResetShellFunctionErrorOutputPipe(); if (this.executionContext.HasRunspaceEverUsedConstrainedLanguageMode) { this.executionContext.LanguageMode = PSLanguageMode.ConstrainedLanguage; } this.Context.CurrentRunspace.UpdateRunspaceAvailability(RunspaceAvailability.AvailableForNestedCommand, true); try { this.externalHostRef.Value.EnterNestedPrompt(); } catch { this.ExitNestedPromptHelper(); throw; } finally { if (info != null) { info.Value = obj2; } if (info2 != null) { info2.Value = obj3; } } }
internal ItemCmdletProviderIntrinsics(Cmdlet cmdlet) { _cmdlet = cmdlet; }
public StopUpstreamCommandsException(InternalCommand requestingCommand) { this.RequestingCommandProcessor = requestingCommand.Context.CurrentCommandProcessor; }
internal AllowWrite(InternalCommand permittedToWrite, bool permittedToWriteToPipeline) { if (permittedToWrite == null) { throw PSTraceSource.NewArgumentNullException("permittedToWrite"); } MshCommandRuntime commandRuntime = permittedToWrite.commandRuntime as MshCommandRuntime; if (commandRuntime == null) { throw PSTraceSource.NewArgumentNullException("permittedToWrite.CommandRuntime"); } this._pp = commandRuntime.PipelineProcessor; if (this._pp == null) { throw PSTraceSource.NewArgumentNullException("permittedToWrite.CommandRuntime.PipelineProcessor"); } this._wasPermittedToWrite = this._pp._permittedToWrite; this._wasPermittedToWriteToPipeline = this._pp._permittedToWriteToPipeline; this._wasPermittedToWriteThread = this._pp._permittedToWriteThread; this._pp._permittedToWrite = permittedToWrite; this._pp._permittedToWriteToPipeline = permittedToWriteToPipeline; this._pp._permittedToWriteThread = Thread.CurrentThread; }
internal ParameterBinderController NewParameterBinderController(InternalCommand command) { ParameterBinderBase base2; Cmdlet cmdlet = command as Cmdlet; if (cmdlet == null) { throw PSTraceSource.NewArgumentException("command"); } IScriptCommandInfo commandInfo = base.CommandInfo as IScriptCommandInfo; if (commandInfo != null) { base2 = new ScriptParameterBinder(commandInfo.ScriptBlock, cmdlet.MyInvocation, base._context, cmdlet, base.CommandScope); } else { base2 = new ReflectionParameterBinder(cmdlet, cmdlet); } this._cmdletParameterBinderController = new System.Management.Automation.CmdletParameterBinderController(cmdlet, base.CommandInfo.CommandMetadata, base2); return this._cmdletParameterBinderController; }
/// <summary> /// Begin the scope where WriteObject/WriteError is permitted. /// </summary> internal AllowWrite(InternalCommand permittedToWrite, bool permittedToWriteToPipeline) { if (null == permittedToWrite) throw PSTraceSource.NewArgumentNullException("permittedToWrite"); MshCommandRuntime mcr = permittedToWrite.commandRuntime as MshCommandRuntime; if (mcr == null) throw PSTraceSource.NewArgumentNullException("permittedToWrite.CommandRuntime"); _pp = mcr.PipelineProcessor; if (_pp == null) throw PSTraceSource.NewArgumentNullException("permittedToWrite.CommandRuntime.PipelineProcessor"); _wasPermittedToWrite = _pp._permittedToWrite; _wasPermittedToWriteToPipeline = _pp._permittedToWriteToPipeline; _wasPermittedToWriteThread = _pp._permittedToWriteThread; _pp._permittedToWrite = permittedToWrite; _pp._permittedToWriteToPipeline = permittedToWriteToPipeline; _pp._permittedToWriteThread = Thread.CurrentThread; }
internal MshCommandRuntime(ExecutionContext context, CommandInfo commandInfo, InternalCommand thisCommand) { Context = context; Host = context.EngineHostInterface; this.CBhost = (InternalHost)context.EngineHostInterface; _commandInfo = commandInfo; _thisCommand = thisCommand; LogPipelineExecutionDetail = InitShouldLogPipelineExecutionDetail(); }
/// <summary> /// Gets a new instance of a ParameterBinderController using a NativeCommandParameterBinder /// </summary> /// /// <param name="command"> /// The native command to be run. /// </param> /// /// <returns> /// A new parameter binder controller for the specified command. /// </returns> /// internal ParameterBinderController NewParameterBinderController(InternalCommand command) { Dbg.Assert(_isPreparedCalled, "parameter binder should not be created before prepared is called"); if (_isMiniShell) { _nativeParameterBinderController = new MinishellParameterBinderController( this.nativeCommand); } else { _nativeParameterBinderController = new NativeCommandParameterBinderController( this.nativeCommand); } return _nativeParameterBinderController; }
internal ParameterBinderController NewParameterBinderController(InternalCommand command) { if (this.isMiniShell) { this.nativeParameterBinderController = new MinishellParameterBinderController(this.nativeCommand); } else { this.nativeParameterBinderController = new NativeCommandParameterBinderController(this.nativeCommand); } return this.nativeParameterBinderController; }
internal ProcessInputWriter(InternalCommand command) { this.command = command; }
internal PropertyCmdletProviderIntrinsics(Cmdlet cmdlet) { _cmdlet = cmdlet; }
internal SecurityDescriptorCmdletProviderIntrinsics(Cmdlet cmdlet) { _cmdlet = cmdlet; }
/// <summary> /// Creates an instance of ProcessInputWriter /// </summary> internal ProcessInputWriter(InternalCommand command) { Dbg.Assert(command != null, "Caller should validate the parameter"); _command = command; }
// CommandProcessor #endregion ctor #region internal members /// <summary> /// Returns a CmdletParameterBinderController for the specified command /// </summary> /// /// <param name="command"> /// The cmdlet to bind parameters to. /// </param> /// /// <returns> /// A new instance of a CmdletParameterBinderController. /// </returns> /// /// <exception cref="ArgumentException"> /// if <paramref name="command"/> is not a Cmdlet. /// </exception> /// internal ParameterBinderController NewParameterBinderController(InternalCommand command) { Cmdlet cmdlet = command as Cmdlet; if (cmdlet == null) { throw PSTraceSource.NewArgumentException("command"); } ParameterBinderBase parameterBinder; IScriptCommandInfo scriptCommandInfo = CommandInfo as IScriptCommandInfo; if (scriptCommandInfo != null) { parameterBinder = new ScriptParameterBinder(scriptCommandInfo.ScriptBlock, cmdlet.MyInvocation, this._context, cmdlet, CommandScope); } else { parameterBinder = new ReflectionParameterBinder(cmdlet, cmdlet); } _cmdletParameterBinderController = new CmdletParameterBinderController(cmdlet, CommandInfo.CommandMetadata, parameterBinder); return _cmdletParameterBinderController; }
internal bool RecordFailure(Exception e, InternalCommand command) { bool stopping = false; lock (this.StopReasonLock) { if (this.firstTerminatingError == null) { RuntimeException.LockStackTrace(e); this.firstTerminatingError = e; } else if ((!(this.firstTerminatingError is PipelineStoppedException) && (command != null)) && (command.Context != null)) { Exception innerException = e; while (((innerException is TargetInvocationException) || (innerException is CmdletInvocationException)) && (innerException.InnerException != null)) { innerException = innerException.InnerException; } if (!(innerException is PipelineStoppedException)) { InvalidOperationException exception = new InvalidOperationException(StringUtil.Format(PipelineStrings.SecondFailure, new object[] { this.firstTerminatingError.GetType().Name, this.firstTerminatingError.StackTrace, innerException.GetType().Name, innerException.StackTrace }), innerException); MshLog.LogCommandHealthEvent(command.Context, exception, Severity.Warning); } } stopping = this.stopping; this.stopping = true; } return !stopping; }
/// <summary> /// Makes an internal note of the exception, but only if this is /// the first error. /// </summary> /// <param name="e">error which terminated the pipeline</param> /// <param name="command">command against which to log SecondFailure</param> /// <returns>true iff the pipeline was not already stopped</returns> internal bool RecordFailure(Exception e, InternalCommand command) { bool wasStopping = false; lock (_stopReasonLock) { if (null == _firstTerminatingError) { _firstTerminatingError = ExceptionDispatchInfo.Capture(e); } // 905900-2005/05/12 // Drop5: Error Architecture: Log/trace second and subsequent RecordFailure // Note that the pipeline could have been stopped asynchronously // before hitting the error, therefore we check whether // firstTerminatingError is PipelineStoppedException. else if ((!(_firstTerminatingError.SourceException is PipelineStoppedException)) && null != command && null != command.Context) { Exception ex = e; while ((ex is TargetInvocationException || ex is CmdletInvocationException) && (null != ex.InnerException)) { ex = ex.InnerException; } if (!(ex is PipelineStoppedException)) { string message = StringUtil.Format(PipelineStrings.SecondFailure, _firstTerminatingError.GetType().Name, _firstTerminatingError.SourceException.StackTrace, ex.GetType().Name, ex.StackTrace ); InvalidOperationException ioe = new InvalidOperationException(message, ex); MshLog.LogCommandHealthEvent( command.Context, ioe, Severity.Warning); } } wasStopping = _stopping; _stopping = true; } return !wasStopping; }