MshCommandRuntime.cs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma warning disable 1634, 1691

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Threading;
using System.Security;
using System.Management.Automation.Host;
using System.Management.Automation.Internal.Host;
using System.Management.Automation.Internal;
using System.Management.Automation.Remoting;
using System.Management.Automation.Runspaces;

using Dbg = System.Management.Automation.Diagnostics;

namespace System.Management.Automation
{
    /// <summary>
    /// Monad internal implementation of the ICommandRuntime2 interface
    /// used for execution in the monad engine environment.
    ///
    /// There will be one instance of this class for each cmdlet added to
    /// a pipeline. When the cmdlet calls its WriteObject API, that API will call
    /// the WriteObject implementation in this class which, in turn, calls
    /// the downstream cmdlet.
    /// </summary>
    internal class MshCommandRuntime : ICommandRuntime2
    {
        #region private_members

        /// <summary>
        /// Gets/Set the execution context value for this runtime object.
        /// </summary>
        internal ExecutionContext Context { get; set; }

        private SessionState _state = null;
        internal InternalHost CBhost;

        /// <summary>
        /// The host object for this object
        /// </summary>
        public PSHost Host { get; }

        // Output pipes.
        private Pipe _inputPipe;
        private Pipe _outputPipe;
        private Pipe _errorOutputPipe;

        /// <summary>
        /// IsClosed indicates to the Cmdlet whether its upstream partner
        /// could still write more data to its incoming queue.
        /// Note that there may still be data in the incoming queue.
        /// </summary>
        internal bool IsClosed { get; set; }

        /// <summary>
        /// True if we're not closed and the input pipe is non-null...
        /// </summary>
        internal bool IsPipelineInputExpected
        {
            get
            {
                // No objects in the input pipe
                // The pipe is closed. So there can't be any more object
                if (IsClosed && (_inputPipe == null || _inputPipe.Empty))
                {
                    return false;
                }
                return true;
            }
        }

        /// <summary>
        /// This allows all success output to be set to a variable.  Similar to the way -errorvariable sets
        /// all errors to a variable name.  Semantically this is equivalent to :  cmd |set-var varname -passthru
        /// but it should be MUCH faster as there is no binding that takes place
        /// </summary>
        /// <exception cref="System.ArgumentNullException">
        /// may not be set to null
        /// </exception>
        /// <remarks>
        /// This is a common parameter via class CommonParameters.
        /// </remarks>
        internal string OutVariable { get; set; }

        internal IList OutVarList { get { return _outVarList; } set { _outVarList = value; } }
        private IList _outVarList = null;

        internal PipelineProcessor PipelineProcessor { get; set; }

        private CommandInfo _commandInfo;
        private InternalCommand _thisCommand;

        #endregion private_members

        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>
        /// for diagnostic purposes
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            if (_commandInfo != null)
                return _commandInfo.ToString();
            return "<NullCommandInfo>"; // does not require localization
        }

        private InvocationInfo _myInvocation;
        /// <summary>
        /// Return the invocation data object for this command.
        /// </summary>
        /// <value>The invocation object for this command.</value>
        internal InvocationInfo MyInvocation
        {
            get { return _myInvocation ?? (_myInvocation = _thisCommand.MyInvocation); }
        }

        /// <summary>
        /// Internal helper. Indicates whether stop has been requested on this command.
        /// </summary>
        internal bool IsStopping
        {
            get { return (this.PipelineProcessor != null && this.PipelineProcessor.Stopping); }
        }

        #region Write

        // Trust: WriteObject needs to respect EmitTrustCategory

        /// <summary>
        /// Writes the object to the output pipe.
        /// </summary>
        /// <param name="sendToPipeline">
        /// The object that needs to be written.  This will be written as
        /// a single object, even if it is an enumeration.
        /// </param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread.
        /// WriteObject may only be called during a call to this Cmdlet's
        /// implementation of ProcessRecord, BeginProcessing or EndProcessing,
        /// and only from that thread.
        /// </exception>
        /// <seealso cref="System.Management.Automation.ICommandRuntime.WriteObject(object,bool)"/>
        /// <seealso cref="System.Management.Automation.ICommandRuntime.WriteError(ErrorRecord)"/>
        public void WriteObject(object sendToPipeline)
        {
            // This check will be repeated in _WriteObjectSkipAllowCheck,
            // but we want PipelineStoppedException to take precedence
            // over InvalidOperationException if the pipeline has been
            // closed.
            ThrowIfStopping();

#if CORECLR
            // SecurityContext is not supported in CoreCLR
            DoWriteObject(sendToPipeline);
#else
            if (UseSecurityContextRun)
            {
                if (PipelineProcessor == null || PipelineProcessor.SecurityContext == null)
                    throw PSTraceSource.NewInvalidOperationException(PipelineStrings.WriteNotPermitted);
                ContextCallback delegateCallback =
                    new ContextCallback(DoWriteObject);

                SecurityContext.Run(
                    PipelineProcessor.SecurityContext.CreateCopy(),
                    delegateCallback,
                    sendToPipeline);
            }
            else
            {
                DoWriteObject(sendToPipeline);
            }
#endif
        }

        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread
        /// </exception>
        private void DoWriteObject(object sendToPipeline)
        {
            ThrowIfWriteNotPermitted(true);
            _WriteObjectSkipAllowCheck(sendToPipeline);
        }

        /// <summary>
        /// Writes one or more objects to the output pipe.
        /// If the object is a collection and the enumerateCollection flag
        /// is true, the objects in the collection
        /// will be written individually.
        /// </summary>
        /// <param name="sendToPipeline">
        /// The object that needs to be written to the pipeline.
        /// </param>
        /// <param name="enumerateCollection">
        /// true if the collection should be enumerated
        /// </param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread.
        /// WriteObject may only be called during a call to this Cmdlet's
        /// implementation of ProcessRecord, BeginProcessing or EndProcessing,
        /// and only from that thread.
        /// </exception>
        /// <seealso cref="System.Management.Automation.ICommandRuntime.WriteObject(object)"/>
        /// <seealso cref="System.Management.Automation.ICommandRuntime.WriteError(ErrorRecord)"/>
        public void WriteObject(object sendToPipeline, bool enumerateCollection)
        {
            if (!enumerateCollection)
            {
                WriteObject(sendToPipeline);
                return;
            }

            // This check will be repeated in _WriteObjectsSkipAllowCheck,
            // but we want PipelineStoppedException to take precedence
            // over InvalidOperationException if the pipeline has been
            // closed.
            ThrowIfStopping();

#if CORECLR
            // SecurityContext is not supported in CoreCLR
            DoWriteObjects(sendToPipeline);
#else
            if (UseSecurityContextRun)
            {
                if (PipelineProcessor == null || PipelineProcessor.SecurityContext == null)
                    throw PSTraceSource.NewInvalidOperationException(PipelineStrings.WriteNotPermitted);
                ContextCallback delegateCallback =
                    new ContextCallback(DoWriteObjects);
                SecurityContext.Run(
                    PipelineProcessor.SecurityContext.CreateCopy(),
                    delegateCallback,
                    sendToPipeline);
            }
            else
            {
                DoWriteObjects(sendToPipeline);
            }
#endif
        }

        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread
        /// </exception>
        private void DoWriteObjects(object sendToPipeline)
        {
            // NOTICE-2004/06/08-JonN 959638
            ThrowIfWriteNotPermitted(true);
            _WriteObjectsSkipAllowCheck(sendToPipeline);
        }
        // Trust:  public void WriteObject(object sendToPipeline, DataTrustCategory trustCategory);     // enumerateCollection defaults to false
        // Trust:  public void WriteObject(object sendToPipeline, bool enumerateCollection, DataTrustCategory trustCategory);

        // Variables needed to generate a unique SourceId for
        // WriteProgress(ProgressRecord).
        private static Int64 s_lastUsedSourceId /* = 0 */;
        private Int64 _sourceId /* = 0 */;

        /// <summary>
        /// Display progress information
        /// </summary>
        /// <param name="progressRecord">progress information</param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread.
        /// WriteProgress may only be called during a call to this Cmdlet's
        /// implementation of ProcessRecord, BeginProcessing or EndProcessing,
        /// and only from that thread.
        /// </exception>
        /// <remarks>
        /// Use WriteProgress to display progress information about
        /// the activity of your Cmdlet, when the operation of your Cmdlet
        /// could potentially take a long time.
        ///
        /// By default, progress output will
        /// be displayed, although this can be configured with the
        /// ProgressPreference shell variable.
        /// </remarks>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteDebug(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteWarning(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteVerbose(string)"/>
        public void WriteProgress(ProgressRecord progressRecord)
        {
            this.WriteProgress(progressRecord, false);
        }

        internal void WriteProgress(ProgressRecord progressRecord, bool overrideInquire)
        {
            // NTRAID#Windows Out Of Band Releases-918023-2005/08/22-JonN
            ThrowIfStopping();

            //
            // WriteError/WriteObject have a check that prevents them to be called from outside
            // Begin/Process/End. This is done because the Pipeline needs to be ready before these
            // functions can be called.
            //
            // WriteDebug/Warning/Verbose/Process used to do the same check, even though it is not
            // strictly needed. If we ever implement pipelines for these objects we may need to
            // enforce the check again.
            //
            // See bug 583774 in the Windows 7 database for more details.
            //
            ThrowIfWriteNotPermitted(false);

            // Bug909439: We need a unique sourceId to send to
            // WriteProgress. The following logic ensures that
            // there is a unique id for each Cmdlet instance.

            if (0 == _sourceId)
            {
                _sourceId = Interlocked.Increment(ref s_lastUsedSourceId);
            }

            this.WriteProgress(_sourceId, progressRecord, overrideInquire);
        }

        /// <summary>
        /// Displays progress output if enabled
        /// </summary>
        /// <param name="sourceId">
        /// Identifies which command is reporting progress
        /// </param>
        /// <param name="progressRecord">
        /// Progress status to be displayed
        /// </param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <remarks>
        /// If the pipeline is terminated due to ActionPreference.Stop
        /// or ActionPreference.Inquire, this method will throw
        /// <see cref="System.Management.Automation.PipelineStoppedException"/>,
        /// but the command failure will ultimately be
        /// <see cref="System.Management.Automation.ActionPreferenceStopException"/>,
        /// </remarks>
        public void WriteProgress(
            Int64 sourceId,
            ProgressRecord progressRecord)
        {
            WriteProgress(sourceId, progressRecord, false);
        } //WriteProgress

        internal void WriteProgress(
                Int64 sourceId,
                ProgressRecord progressRecord,
                bool overrideInquire)
        {
            if (progressRecord == null)
            {
                throw PSTraceSource.NewArgumentNullException("progressRecord");
            }

            if (Host == null || Host.UI == null)
            {
                Diagnostics.Assert(false, "No host in CommandBase.WriteProgress()");
                throw PSTraceSource.NewInvalidOperationException();
            }

            InternalHostUserInterface ui = Host.UI as InternalHostUserInterface;

            ActionPreference preference = ProgressPreference;
            if (overrideInquire && preference == ActionPreference.Inquire)
            {
                preference = ActionPreference.Continue;
            }

            if (WriteHelper_ShouldWrite(
                preference, lastProgressContinueStatus))
            {
                ui.WriteProgress(sourceId, progressRecord);
            }

            lastProgressContinueStatus = WriteHelper(
                null,
                null,
                preference,
                lastProgressContinueStatus,
                "ProgressPreference",
                progressRecord.Activity);
        } //WriteProgress

        /// <summary>
        /// Display debug information
        /// </summary>
        /// <param name="text">debug output</param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread.
        /// WriteDebug may only be called during a call to this Cmdlet's
        /// implementation of ProcessRecord, BeginProcessing or EndProcessing,
        /// and only from that thread.
        /// </exception>
        /// <remarks>
        /// Use WriteDebug to display debug information on the inner workings
        /// of your Cmdlet.  By default, debug output will
        /// not be displayed, although this can be configured with the
        /// DebugPreference shell variable or the -Debug command-line option.
        /// </remarks>
        /// <remarks>
        /// If the pipeline is terminated due to ActionPreference.Stop
        /// or ActionPreference.Inquire, this method will throw
        /// <see cref="System.Management.Automation.PipelineStoppedException"/>,
        /// but the command failure will ultimately be
        /// <see cref="System.Management.Automation.ActionPreferenceStopException"/>,
        /// </remarks>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteVerbose(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteWarning(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteProgress(ProgressRecord)"/>
        public void WriteDebug(string text)
        {
            WriteDebug(new DebugRecord(text));
        }

        /// <summary>
        /// Display debug information
        /// </summary>
        internal void WriteDebug(DebugRecord record, bool overrideInquire = false)
        {
            ActionPreference preference = DebugPreference;
            if (overrideInquire && preference == ActionPreference.Inquire)
                preference = ActionPreference.Continue;

            if (WriteHelper_ShouldWrite(preference, lastDebugContinueStatus))
            {
                if (record.InvocationInfo == null)
                {
                    record.SetInvocationInfo(MyInvocation);
                }

                if (DebugOutputPipe != null)
                {
                    if (CBhost != null && CBhost.InternalUI != null &&
                        DebugOutputPipe.NullPipe)
                    {
                        // If redirecting to a null pipe, still write to
                        // information buffers.
                        CBhost.InternalUI.WriteDebugInfoBuffers(record);
                    }

                    // Add note property so that the debug output is formatted correctly.
                    PSObject debugWrap = PSObject.AsPSObject(record);
                    if (debugWrap.Members["WriteDebugStream"] == null)
                    {
                        debugWrap.Properties.Add(new PSNoteProperty("WriteDebugStream", true));
                    }

                    DebugOutputPipe.Add(debugWrap);
                }
                else
                {
                    //
                    // If no pipe, write directly to host.
                    //
                    if (Host == null || Host.UI == null)
                    {
                        Diagnostics.Assert(false, "No host in CommandBase.WriteDebug()");
                        throw PSTraceSource.NewInvalidOperationException();
                    }

                    CBhost.InternalUI.TranscribeResult(StringUtil.Format(InternalHostUserInterfaceStrings.DebugFormatString, record.Message));
                    CBhost.InternalUI.WriteDebugRecord(record);
                }
            }

            lastDebugContinueStatus = WriteHelper(
                null,
                null,
                preference,
                lastDebugContinueStatus,
                "DebugPreference",
                record.Message);
        }

        /// <summary>
        /// Display verbose information
        /// </summary>
        /// <param name="text">verbose output</param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread.
        /// WriteVerbose may only be called during a call to this Cmdlet's
        /// implementation of ProcessRecord, BeginProcessing or EndProcessing,
        /// and only from that thread.
        /// </exception>
        /// <remarks>
        /// Use WriteVerbose to display more detailed information about
        /// the activity of your Cmdlet.  By default, verbose output will
        /// not be displayed, although this can be configured with the
        /// VerbosePreference shell variable
        /// or the -Verbose and -Debug command-line options.
        /// </remarks>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteDebug(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteWarning(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteProgress(ProgressRecord)"/>
        public void WriteVerbose(string text)
        {
            WriteVerbose(new VerboseRecord(text));
        }

        /// <summary>
        /// Display verbose information
        /// </summary>
        internal void WriteVerbose(VerboseRecord record, bool overrideInquire = false)
        {
            ActionPreference preference = VerbosePreference;
            if (overrideInquire && preference == ActionPreference.Inquire)
                preference = ActionPreference.Continue;

            if (WriteHelper_ShouldWrite(preference, lastVerboseContinueStatus))
            {
                if (record.InvocationInfo == null)
                {
                    record.SetInvocationInfo(MyInvocation);
                }

                if (VerboseOutputPipe != null)
                {
                    if (CBhost != null && CBhost.InternalUI != null &&
                        VerboseOutputPipe.NullPipe)
                    {
                        // If redirecting to a null pipe, still write to
                        // information buffers.
                        CBhost.InternalUI.WriteVerboseInfoBuffers(record);
                    }

                    // Add note property so that the verbose output is formatted correctly.
                    PSObject verboseWrap = PSObject.AsPSObject(record);
                    if (verboseWrap.Members["WriteVerboseStream"] == null)
                    {
                        verboseWrap.Properties.Add(new PSNoteProperty("WriteVerboseStream", true));
                    }

                    VerboseOutputPipe.Add(verboseWrap);
                }
                else
                {
                    //
                    // If no pipe, write directly to host.
                    //
                    if (Host == null || Host.UI == null)
                    {
                        Diagnostics.Assert(false, "No host in CommandBase.WriteVerbose()");
                        throw PSTraceSource.NewInvalidOperationException();
                    }

                    CBhost.InternalUI.TranscribeResult(StringUtil.Format(InternalHostUserInterfaceStrings.VerboseFormatString, record.Message));
                    CBhost.InternalUI.WriteVerboseRecord(record);
                }
            }

            lastVerboseContinueStatus = WriteHelper(
                null,
                null,
                preference,
                lastVerboseContinueStatus,
                "VerbosePreference",
                record.Message);
        }

        /// <summary>
        /// Display warning information
        /// </summary>
        /// <param name="text">warning output</param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.
        /// The Cmdlet should generally just allow PipelineStoppedException
        /// to percolate up to the caller of ProcessRecord etc.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Not permitted at this time or from this thread.
        /// WriteWarning may only be called during a call to this Cmdlet's
        /// implementation of ProcessRecord, BeginProcessing or EndProcessing,
        /// and only from that thread.
        /// </exception>
        /// <remarks>
        /// Use WriteWarning to display warnings about
        /// the activity of your Cmdlet.  By default, warning output will
        /// be displayed, although this can be configured with the
        /// WarningPreference shell variable
        /// or the -Verbose and -Debug command-line options.
        /// </remarks>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteDebug(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteVerbose(string)"/>
        /// <seealso cref="System.Management.Automation.Cmdlet.WriteProgress(ProgressRecord)"/>
        public void WriteWarning(string text)
        {
            WriteWarning(new WarningRecord(text));
        }

        /// <summary>
        /// Display warning information
        /// </summary>
        internal void WriteWarning(WarningRecord record, bool overrideInquire = false)
        {
            ActionPreference preference = WarningPreference;
            if (overrideInquire && preference == ActionPreference.Inquire)
                preference = ActionPreference.Continue;

            if (WriteHelper_ShouldWrite(preference, lastWarningContinueStatus))
            {
                if (record.InvocationInfo == null)
                {
                    record.SetInvocationInfo(MyInvocation);
                }

                if (WarningOutputPipe != null)
                {
                    if (CBhost != null && CBhost.InternalUI != null &&
                        WarningOutputPipe.NullPipe)
                    {
                        // If redirecting to a null pipe, still write to
                        // information buffers.
                        CBhost.InternalUI.WriteWarningInfoBuffers(record);
                    }

                    // Add note property so that the warning output is formatted correctly.
                    PSObject warningWrap = PSObject.AsPSObject(record);
                    if (warningWrap.Members["WriteWarningStream"] == null)
                    {
                        warningWrap.Properties.Add(new PSNoteProperty("WriteWarningStream", true));
                    }

                    WarningOutputPipe.AddWithoutAppendingOutVarList(warningWrap);
                }
                else
                {
                    //
                    // If no pipe, write directly to host.
                    //
                    if (Host == null || Host.UI == null)
                    {
                        Diagnostics.Assert(false, "No host in CommandBase.WriteWarning()");
                        throw PSTraceSource.NewInvalidOperationException();
                    }

                    CBhost.InternalUI.TranscribeResult(StringUtil.Format(InternalHostUserInterfaceStrings.WarningFormatString, record.Message));
                    CBhost.InternalUI.WriteWarningRecord(record);
                }
            }

            AppendWarningVarList(record);

            lastWarningContinueStatus = WriteHelper(
                null,
                null,
                preference,
                lastWarningContinueStatus,
                "WarningPreference",
                record.Message);
        }

        /// <summary>
        /// Display tagged object information
        /// </summary>
        public void WriteInformation(InformationRecord informationRecord)
        {
            WriteInformation(informationRecord, false);
        }

        /// <summary>
        /// Display tagged object information
        /// </summary>
        internal void WriteInformation(InformationRecord record, bool overrideInquire = false)
        {
            ActionPreference preference = InformationPreference;
            if (overrideInquire && preference == ActionPreference.Inquire)
                preference = ActionPreference.Continue;

            if (preference != ActionPreference.Ignore)
            {
                if (InformationOutputPipe != null)
                {
                    if (CBhost != null && CBhost.InternalUI != null &&
                        InformationOutputPipe.NullPipe)
                    {
                        // If redirecting to a null pipe, still write to
                        // information buffers.
                        CBhost.InternalUI.WriteInformationInfoBuffers(record);
                    }

                    // Add note property so that the information output is formatted correctly.
                    PSObject informationWrap = PSObject.AsPSObject(record);
                    if (informationWrap.Members["WriteInformationStream"] == null)
                    {
                        informationWrap.Properties.Add(new PSNoteProperty("WriteInformationStream", true));
                    }

                    InformationOutputPipe.Add(informationWrap);
                }
                else
                {
                    //
                    // If no pipe, write directly to host.
                    //
                    if (Host == null || Host.UI == null)
                    {
                        throw PSTraceSource.NewInvalidOperationException("No host in CommandBase.WriteInformation()");
                    }

                    CBhost.InternalUI.WriteInformationRecord(record);

                    if ((record.Tags.Contains("PSHOST") && (!record.Tags.Contains("FORWARDED")))
                        || (preference == ActionPreference.Continue))
                    {
                        HostInformationMessage hostOutput = record.MessageData as HostInformationMessage;
                        if (hostOutput != null)
                        {
                            string message = hostOutput.Message;
                            ConsoleColor? foregroundColor = null;
                            ConsoleColor? backgroundColor = null;
                            bool noNewLine = false;

                            if (hostOutput.ForegroundColor.HasValue)
                            {
                                foregroundColor = hostOutput.ForegroundColor.Value;
                            }

                            if (hostOutput.BackgroundColor.HasValue)
                            {
                                backgroundColor = hostOutput.BackgroundColor.Value;
                            }

                            if (hostOutput.NoNewLine.HasValue)
                            {
                                noNewLine = hostOutput.NoNewLine.Value;
                            }

                            if (foregroundColor.HasValue || backgroundColor.HasValue)
                            {
                                // It is possible for either one or the other to be empty if run from a
                                // non-interactive host, but only one was specified in Write-Host.
                                // So fill them with defaults if they are empty.
                                if (!foregroundColor.HasValue)
                                {
                                    foregroundColor = ConsoleColor.Gray;
                                }

                                if (!backgroundColor.HasValue)
                                {
                                    backgroundColor = ConsoleColor.Black;
                                }

                                if (noNewLine)
                                {
                                    CBhost.InternalUI.Write(foregroundColor.Value, backgroundColor.Value, message);
                                }
                                else
                                {
                                    CBhost.InternalUI.WriteLine(foregroundColor.Value, backgroundColor.Value, message);
                                }
                            }
                            else
                            {
                                if (noNewLine)
                                {
                                    CBhost.InternalUI.Write(message);
                                }
                                else
                                {
                                    CBhost.InternalUI.WriteLine(message);
                                }
                            }
                        }
                        else
                        {
                            CBhost.InternalUI.WriteLine(record.ToString());
                        }
                    }
                }

                // Both informational and PSHost-targeted messages are transcribed here.
                // The only difference between these two is that PSHost-targeted messages are transcribed
                // even if InformationAction is SilentlyContinue.
                if (record.Tags.Contains("PSHOST") || (preference != ActionPreference.SilentlyContinue))
                {
                    CBhost.InternalUI.TranscribeResult(record.ToString());
                }
            }

            AppendInformationVarList(record);

            lastInformationContinueStatus = WriteHelper(
                null,
                null,
                preference,
                lastInformationContinueStatus,
                "InformationPreference",
                record.ToString());
        }

        /// <summary>
        /// Write text into pipeline execution log.
        /// </summary>
        /// <param name="text">text to be written to log</param>
        /// <remarks>
        /// Use WriteCommandDetail to write important information about cmdlet execution to
        /// pipeline execution log.
        ///
        /// If LogPipelineExecutionDetail is turned on, this information will be written
        /// to monad log under log category "Pipeline execution detail"
        /// </remarks>
        /// <seealso cref="System.Management.Automation.ICommandRuntime.WriteDebug(string)"/>
        /// <seealso cref="System.Management.Automation.ICommandRuntime.WriteVerbose(string)"/>
        /// <seealso cref="System.Management.Automation.ICommandRuntime.WriteProgress(ProgressRecord)"/>
        public void WriteCommandDetail(string text)
        {
            this.PipelineProcessor.LogExecutionInfo(_thisCommand.MyInvocation, text);
        }

        internal bool LogPipelineExecutionDetail { get; } = false;

        private bool InitShouldLogPipelineExecutionDetail()
        {
            CmdletInfo cmdletInfo = _commandInfo as CmdletInfo;

            if (cmdletInfo != null)
            {
                if (String.Equals("Add-Type", cmdletInfo.Name, StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }

                if (cmdletInfo.Module == null && cmdletInfo.PSSnapIn != null)
                {
                    return cmdletInfo.PSSnapIn.LogPipelineExecutionDetails;
                }

                if (cmdletInfo.PSSnapIn == null && cmdletInfo.Module != null)
                {
                    return cmdletInfo.Module.LogPipelineExecutionDetails;
                }

                return false;
            }

            // Logging should be enabled for functions from modules also
            FunctionInfo functionInfo = _commandInfo as FunctionInfo;
            if (functionInfo != null && functionInfo.Module != null)
            {
                return functionInfo.Module.LogPipelineExecutionDetails;
            }

            return false;
        }

        /// <summary>
        /// This allows all success output to be set to a variable, where the variable is reset for each item returned by
        /// the cmdlet. Semantically this is equivalent to :  cmd | % { $pipelineVariable = $_; (...) }
        /// </summary>
        internal string PipelineVariable { get; set; }
        private PSVariable _pipelineVarReference = null;

        internal void SetupOutVariable()
        {
            if (String.IsNullOrEmpty(this.OutVariable))
            {
                return;
            }

            EnsureVariableParameterAllowed();

            // Handle the creation of OutVariable in the case of Out-Default specially,
            // as it needs to handle much of its OutVariable support itself.
            if (
                (!String.IsNullOrEmpty(this.OutVariable)) &&
                (!(this.OutVariable.StartsWith("+", StringComparison.Ordinal))) &&
                String.Equals("Out-Default", _thisCommand.CommandInfo.Name, StringComparison.OrdinalIgnoreCase))
            {
                if (_state == null)
                    _state = new SessionState(Context.EngineSessionState);

                IList oldValue = null;
                oldValue = PSObject.Base(_state.PSVariable.GetValue(this.OutVariable)) as IList;

                _outVarList = oldValue ?? new ArrayList();

                if (!(_thisCommand is PSScriptCmdlet))
                {
                    this.OutputPipe.AddVariableList(VariableStreamKind.Output, _outVarList);
                }

                _state.PSVariable.Set(this.OutVariable, _outVarList);
            }
            else
            {
                SetupVariable(VariableStreamKind.Output, this.OutVariable, ref _outVarList);
            }
        }

        internal void SetupPipelineVariable()
        {
            // This can't use the common SetupVariable implementation, as this needs to persist for an entire
            // pipeline.

            if (String.IsNullOrEmpty(this.PipelineVariable))
            {
                return;
            }

            EnsureVariableParameterAllowed();

            if (_state == null)
                _state = new SessionState(Context.EngineSessionState);

            // Create the pipeline variable
            _pipelineVarReference = new PSVariable(this.PipelineVariable);
            _state.PSVariable.Set(_pipelineVarReference);

            // Get the reference again in case we re-used one from the
            // same scope.
            _pipelineVarReference = _state.PSVariable.Get(this.PipelineVariable);

            if (!(_thisCommand is PSScriptCmdlet))
            {
                this.OutputPipe.SetPipelineVariable(_pipelineVarReference);
            }
        }

        /// <summary>
        /// Configures the number of objects to buffer before calling the downstream Cmdlet
        /// </summary>
        /// <remarks>
        /// This is a common parameter via class CommonParameters.
        /// </remarks>
        internal int OutBuffer
        {
            get { return OutputPipe.OutBufferCount; }
            set { OutputPipe.OutBufferCount = value; }
        }

        #endregion Write

        #region Should
        #region ShouldProcess
        /// <summary>
        /// Confirm the operation with the user.  Cmdlets which make changes
        /// (e.g. delete files, stop services etc.) should call ShouldProcess
        /// to give the user the opportunity to confirm that the operation
        /// should actually be performed.
        /// </summary>
        /// <param name="target">
        /// Name of the target resource being acted upon. This will
        /// potentially be displayed to the user.
        /// </param>
        /// <exception cref="System.Management.Automation.PipelineStoppedException">
        /// The pipeline has already been terminated, or was terminated
        /// during the execution of this method.