RemoteRunspacePoolInternal.cs

/********************************************************************++
Copyright (c) Microsoft Corporation. All rights reserved.
--********************************************************************/

using System.Collections.Generic;
using System.Globalization;
using System.Management.Automation.Tracing;
using System.Threading;
using Dbg = System.Management.Automation.Diagnostics;
using System.Management.Automation.Remoting;
using System.Management.Automation.Internal;
using System.Management.Automation.Host;
using System.Collections.ObjectModel;
using System.Management.Automation.Remoting.Client;
#if LEGACYTELEMETRY
using Microsoft.PowerShell.Telemetry.Internal;
#endif

namespace System.Management.Automation.Runspaces.Internal
{
    /// <summary>
    /// Class which supports pooling remote powerShell runspaces
    /// on the client
    /// </summary>
    internal class RemoteRunspacePoolInternal : RunspacePoolInternal, IDisposable
    {
        #region Constructor

        /// <summary>
        /// Constructor which creates a RunspacePool using the
        /// supplied <paramref name="connectionInfo"/>, <paramref name="minRunspaces"/>
        /// and <paramref name="maxRunspaces"/>
        /// </summary>
        /// <param name="maxRunspaces">
        /// The maximum number of Runspaces that can exist in this pool.
        /// Should be greater than or equal to 1.
        /// </param>
        /// <param name="minRunspaces">
        /// The minimum number of Runspaces that can exist in this pool.
        /// Should be greater than or equal to 1.
        /// </param>
        /// <param name="typeTable">
        /// The TypeTable to use while deserializing/serializing remote objects.
        /// TypeTable has the following information used by serializer:
        ///   1. SerializationMethod
        ///   2. SerializationDepth
        ///   3. SpecificSerializationProperties
        /// TypeTable has the following information used by deserializer:
        ///   1. TargetTypeForDeserialization
        ///   2. TypeConverter
        /// </param>
        /// <param name="host">Host associated with this runspacepool</param>
        /// <param name="applicationArguments">
        /// Application arguments the server can see in <see cref="System.Management.Automation.Remoting.PSSenderInfo.ApplicationArguments"/>
        /// </param>
        /// <param name="connectionInfo">The RunspaceConnectionInfo object
        /// which identifies this runspace pools connection to the server
        /// </param>
        /// <param name="name">Session name.</param>
        /// <exception cref="ArgumentException">
        /// Maximum runspaces is less than 1.
        /// Minimum runspaces is less than 1.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// ConnectionInfo specified is null
        /// </exception>
        internal RemoteRunspacePoolInternal(int minRunspaces,
            int maxRunspaces, TypeTable typeTable, PSHost host, PSPrimitiveDictionary applicationArguments, RunspaceConnectionInfo connectionInfo, string name = null)
            : base(minRunspaces, maxRunspaces)
        {
            if (connectionInfo == null)
            {
                throw PSTraceSource.NewArgumentNullException("WSManConnectionInfo");
            }

            PSEtwLog.LogOperationalVerbose(PSEventId.RunspacePoolConstructor,
                    PSOpcode.Constructor, PSTask.CreateRunspace,
                    PSKeyword.UseAlwaysOperational,
                    instanceId.ToString(),
                    minPoolSz.ToString(CultureInfo.InvariantCulture),
                    maxPoolSz.ToString(CultureInfo.InvariantCulture));

            _connectionInfo = connectionInfo.InternalCopy();

            this.host = host;
            ApplicationArguments = applicationArguments;
            AvailableForConnection = false;
            DispatchTable = new DispatchTable<object>();
            _runningPowerShells = new System.Collections.Concurrent.ConcurrentStack<PowerShell>();

            if (!string.IsNullOrEmpty(name))
            {
                this.Name = name;
            }

            CreateDSHandler(typeTable);
        }

        /// <summary>
        /// Create a runspacepool object in the disconnected state.
        /// </summary>
        /// <param name="instanceId">Identifies remote session to connect.</param>
        /// <param name="name">Friendly name for runspace pool.</param>
        /// <param name="isDisconnected">Indicates whether the runspacepool is disconnected.</param>
        /// <param name="connectCommands">Array of commands associated with this runspace pool.</param>
        /// <param name="connectionInfo">Connection information for remote server.</param>
        /// <param name="host">PSHost object.</param>
        /// <param name="typeTable">TypeTable for object serialization/deserialization.</param>
        internal RemoteRunspacePoolInternal(Guid instanceId, string name, bool isDisconnected,
            ConnectCommandInfo[] connectCommands, RunspaceConnectionInfo connectionInfo, PSHost host, TypeTable typeTable)
            : base(1, 1)
        {
            if (instanceId == null)
            {
                throw PSTraceSource.NewArgumentNullException("RunspacePool Guid");
            }
            if (connectCommands == null)
            {
                throw PSTraceSource.NewArgumentNullException("ConnectCommandInfo[]");
            }
            if (connectionInfo == null)
            {
                throw PSTraceSource.NewArgumentNullException("WSManConnectionInfo");
            }

            if (connectionInfo is WSManConnectionInfo)
            {
                _connectionInfo = connectionInfo.InternalCopy();
            }
            else
            {
                Dbg.Assert(false, "ConnectionInfo must be WSManConnectionInfo");
            }

            // Create the runspace pool object to have the same instanceId as the remote session.
            this.instanceId = instanceId;

            // This indicates that this is a disconnected remote runspace pool and min/max values
            // are currently unknown. These values will be updated once the object is connected.
            this.minPoolSz = -1;
            this.maxPoolSz = -1;

            PSEtwLog.LogOperationalVerbose(PSEventId.RunspacePoolConstructor,
                    PSOpcode.Constructor, PSTask.CreateRunspace,
                    PSKeyword.UseAlwaysOperational,
                    instanceId.ToString(),
                    minPoolSz.ToString(CultureInfo.InvariantCulture),
                    maxPoolSz.ToString(CultureInfo.InvariantCulture));

            ConnectCommands = connectCommands;
            this.Name = name;
            this.host = host;
            DispatchTable = new DispatchTable<object>();
            _runningPowerShells = new System.Collections.Concurrent.ConcurrentStack<PowerShell>();

            // Create this object in the disconnected state.
            SetRunspacePoolState(new RunspacePoolStateInfo(RunspacePoolState.Disconnected, null));

            CreateDSHandler(typeTable);

            AvailableForConnection = isDisconnected;
        }

        /// <summary>
        /// Helper method to create the dispatchTable and dataStructureHandler objects.
        /// </summary>
        private void CreateDSHandler(TypeTable typeTable)
        {
            DataStructureHandler = new ClientRunspacePoolDataStructureHandler(this, typeTable);

            // register for events from the data structure handler
            DataStructureHandler.RemoteHostCallReceived +=
                new EventHandler<RemoteDataEventArgs<RemoteHostCall>>(HandleRemoteHostCalls);
            DataStructureHandler.StateInfoReceived +=
                new EventHandler<RemoteDataEventArgs<RunspacePoolStateInfo>>(HandleStateInfoReceived);
            DataStructureHandler.RSPoolInitInfoReceived +=
                new EventHandler<RemoteDataEventArgs<RunspacePoolInitInfo>>(HandleInitInfoReceived);
            DataStructureHandler.ApplicationPrivateDataReceived +=
                new EventHandler<RemoteDataEventArgs<PSPrimitiveDictionary>>(HandleApplicationPrivateDataReceived);
            DataStructureHandler.SessionClosing +=
                new EventHandler<RemoteDataEventArgs<Exception>>(HandleSessionClosing);
            DataStructureHandler.SessionClosed +=
                new EventHandler<RemoteDataEventArgs<Exception>>(HandleSessionClosed);
            DataStructureHandler.SetMaxMinRunspacesResponseReceived +=
                new EventHandler<RemoteDataEventArgs<PSObject>>(HandleResponseReceived);
            DataStructureHandler.URIRedirectionReported +=
                new EventHandler<RemoteDataEventArgs<Uri>>(HandleURIDirectionReported);
            DataStructureHandler.PSEventArgsReceived +=
                new EventHandler<RemoteDataEventArgs<PSEventArgs>>(HandlePSEventArgsReceived);
            DataStructureHandler.SessionDisconnected +=
                new EventHandler<RemoteDataEventArgs<Exception>>(HandleSessionDisconnected);
            DataStructureHandler.SessionReconnected +=
                new EventHandler<RemoteDataEventArgs<Exception>>(HandleSessionReconnected);
            DataStructureHandler.SessionRCDisconnecting +=
                new EventHandler<RemoteDataEventArgs<Exception>>(HandleSessionRCDisconnecting);
            DataStructureHandler.SessionCreateCompleted +=
                new EventHandler<CreateCompleteEventArgs>(HandleSessionCreateCompleted);
        }

        #endregion Constructors

        #region Properties

        /// <summary>
        /// the connection associated with this runspace pool
        /// </summary>
        public override RunspaceConnectionInfo ConnectionInfo
        {
            get
            {
                return _connectionInfo;
            }
        }

        /// <summary>
        /// The ClientRunspacePoolDataStructureHandler associated with this
        /// runspace pool
        /// </summary>
        internal ClientRunspacePoolDataStructureHandler DataStructureHandler { get; private set; }

        /// <summary>
        /// List of CommandConnectInfo objects for each remote running command
        /// associated with this remote runspace pool.
        /// </summary>
        internal ConnectCommandInfo[] ConnectCommands { get; set; } = null;

        /// <summary>
        /// Gets and sets the name string for this runspace pool object.
        /// </summary>
        internal string Name
        {
            get { return _friendlyName; }
            set { _friendlyName = value ?? string.Empty; }
        }

        /// <summary>
        /// Indicates whether this runspace pools viable/available for connection.
        /// </summary>
        internal bool AvailableForConnection { get; private set; }

        /// <summary>
        /// Returns robust connection maximum retry time in milliseconds.
        /// </summary>
        internal int MaxRetryConnectionTime
        {
            get
            {
                return (DataStructureHandler != null) ? DataStructureHandler.MaxRetryConnectionTime : 0;
            }
        }

        /// <summary>
        /// Returns runspace pool availability.
        /// </summary>
        public override RunspacePoolAvailability RunspacePoolAvailability
        {
            get
            {
                RunspacePoolAvailability availability;
                if (stateInfo.State == RunspacePoolState.Disconnected)
                {
                    // Set availability for disconnected runspace pool in the
                    // same way it is set for runspaces.
                    availability = (AvailableForConnection) ?
                            RunspacePoolAvailability.None :     // Disconnected runspacepool available for connection.
                            RunspacePoolAvailability.Busy;      // Disconnected runspacepool unavailable for connection.
                }
                else
                {
                    availability = base.RunspacePoolAvailability;
                }

                return availability;
            }
        }

        /// <summary>
        /// Property to indicate that the debugger associated to this
        /// remote runspace is in debug stop mode.
        /// </summary>
        internal bool IsRemoteDebugStop
        {
            set;
            get;
        }

        #endregion

        #region internal Methods

        /// <summary>
        /// Resets the runspace state on a runspace pool with a single
        /// runspace.
        /// This is currently supported *only* for remote runspaces.
        /// </summary>
        /// <returns>True if successful</returns>
        internal override bool ResetRunspaceState()
        {
            // Version check.  Reset Runspace is supported only on PSRP protocol
            // version 2.3 or greater.
            Version remoteProtocolVersionDeclaredByServer = PSRemotingProtocolVersion;
            if ((remoteProtocolVersionDeclaredByServer == null) ||
                (remoteProtocolVersionDeclaredByServer < RemotingConstants.ProtocolVersionWin10RTM))
            {
                throw PSTraceSource.NewInvalidOperationException(RunspacePoolStrings.ResetRunspaceStateNotSupportedOnServer);
            }

            long callId = 0;

            lock (syncObject)
            {
                callId = DispatchTable.CreateNewCallId();
                DataStructureHandler.SendResetRunspaceStateToServer(callId);
            }

            // This call blocks until the response is received.
            object response = DispatchTable.GetResponse(callId, false);
            return (bool)response;
        }

        /// <summary>
        /// Sets the maximum number of Runspaces that can be active concurrently
        /// in the pool. All requests above that number remain queued until
        /// runspaces become available.
        /// </summary>
        /// <param name="maxRunspaces">
        /// The maximum number of runspaces in the pool.
        /// </param>
        /// <returns>
        /// true if the change is successful; otherwise, false.
        /// </returns>
        /// <remarks>
        /// You cannot set the number of runspaces to a number smaller than
        /// the minimum runspaces.
        /// </remarks>
        internal override bool SetMaxRunspaces(int maxRunspaces)
        {
            bool isSizeIncreased = false;
            long callId = 0;

            lock (syncObject)
            {
                if (maxRunspaces < minPoolSz || maxRunspaces == maxPoolSz || stateInfo.State == RunspacePoolState.Closed
                    || stateInfo.State == RunspacePoolState.Closing || stateInfo.State == RunspacePoolState.Broken)
                {
                    return false;
                }

                // if the runspace pool is not opened as yet, or is in Disconnected state.
                // just change the value locally. No need to
                // send a message
                if (stateInfo.State == RunspacePoolState.BeforeOpen ||
                    stateInfo.State == RunspacePoolState.Disconnected)
                {
                    maxPoolSz = maxRunspaces;
                    return true;
                }

                // sending the message should be done withing the lock
                // to ensure that multiple calls to SetMaxRunspaces
                // will be executed on the server in the order in which
                // they were called in the client
                callId = DispatchTable.CreateNewCallId();

                DataStructureHandler.SendSetMaxRunspacesToServer(maxRunspaces, callId);
            } // lock ...

            // this call blocks until the response is received
            object response = DispatchTable.GetResponse(callId, false);

            isSizeIncreased = (bool)response;

            if (isSizeIncreased)
            {
                lock (syncObject)
                {
                    maxPoolSz = maxRunspaces;
                }
            }

            return isSizeIncreased;
        }

        /// <summary>
        /// Sets the minimum number of Runspaces that the pool maintains
        /// in anticipation of new requests.
        /// </summary>
        /// <param name="minRunspaces">
        /// The minimum number of runspaces in the pool.
        /// </param>
        /// <returns>
        /// true if the change is successful; otherwise, false.
        /// </returns>
        /// <remarks>
        /// You cannot set the number of idle runspaces to a number smaller than
        /// 1 or greater than maximum number of active runspaces.
        /// </remarks>
        internal override bool SetMinRunspaces(int minRunspaces)
        {
            bool isSizeDecreased = false;
            long callId = 0;

            lock (syncObject)
            {
                if ((minRunspaces < 1) || (minRunspaces > maxPoolSz) || (minRunspaces == minPoolSz)
                    || stateInfo.State == RunspacePoolState.Closed || stateInfo.State == RunspacePoolState.Closing ||
                    stateInfo.State == RunspacePoolState.Broken)
                {
                    return false;
                }

                // if the runspace pool is not opened as yet, or is in Disconnected state.
                // just change the value locally. No need to
                // send a message
                if (stateInfo.State == RunspacePoolState.BeforeOpen ||
                    stateInfo.State == RunspacePoolState.Disconnected)
                {
                    minPoolSz = minRunspaces;
                    return true;
                }

                // sending the message should be done withing the lock
                // to ensure that multiple calls to SetMinRunspaces
                // will be executed on the server in the order in which
                // they were called in the client
                callId = DispatchTable.CreateNewCallId();

                DataStructureHandler.SendSetMinRunspacesToServer(minRunspaces, callId);
            } // lock ...

            // this call blocks until the response is received
            object response = DispatchTable.GetResponse(callId, false);

            isSizeDecreased = (bool)response;

            if (isSizeDecreased)
            {
                lock (syncObject)
                {
                    minPoolSz = minRunspaces;
                }
            }

            return isSizeDecreased;
        }

        /// <summary>
        /// Retrieves the number of runspaces available at the time of calling
        /// this method from the remote server
        /// </summary>
        /// <returns>The number of runspaces available in the pool</returns>
        internal override int GetAvailableRunspaces()
        {
            int availableRunspaces = 0;
            long callId = 0;

            lock (syncObject)
            {
                // if the runspace pool is opened we need to
                // get the value from the server, else
                // return maxrunspaces
                if (stateInfo.State == RunspacePoolState.Opened)
                {
                    // sending the message should be done withing the lock
                    // to ensure that multiple calls to GetAvailableRunspaces
                    // will be executed on the server in the order in which
                    // they were called in the client
                    callId = DispatchTable.CreateNewCallId();
                }
                else if (stateInfo.State != RunspacePoolState.BeforeOpen && stateInfo.State != RunspacePoolState.Opening)
                {
                    throw new InvalidOperationException(HostInterfaceExceptionsStrings.RunspacePoolNotOpened);
                }
                else
                {
                    return maxPoolSz;
                }

                DataStructureHandler.SendGetAvailableRunspacesToServer(callId);
            } // lock ...

            // this call blocks until the response is received
            object response = DispatchTable.GetResponse(callId, 0);
            availableRunspaces = (int)response;

            return availableRunspaces;
        }

        /// <summary>
        /// The server sent application private data.  Store the data so that user
        /// can get it later.
        /// </summary>
        /// <param name="eventArgs">argument describing this event</param>
        /// <param name="sender">sender of this event</param>
        internal void HandleApplicationPrivateDataReceived(object sender,
            RemoteDataEventArgs<PSPrimitiveDictionary> eventArgs)
        {
            this.SetApplicationPrivateData(eventArgs.Data);
        }

        internal void HandleInitInfoReceived(object sender,
                        RemoteDataEventArgs<RunspacePoolInitInfo> eventArgs)
        {
            RunspacePoolStateInfo info = new RunspacePoolStateInfo(RunspacePoolState.Opened, null);

            bool raiseEvents = false;

            lock (syncObject)
            {
                minPoolSz = eventArgs.Data.MinRunspaces;
                maxPoolSz = eventArgs.Data.MaxRunspaces;
                if (stateInfo.State == RunspacePoolState.Connecting)
                {
                    ResetDisconnectedOnExpiresOn();

                    raiseEvents = true;
                    SetRunspacePoolState(info);
                }
            }

            if (raiseEvents)
            {
                // Private application data is sent after (post) connect.  We need
                // to wait for application data before raising the state change
                // Connecting -> Opened event.
                ThreadPool.QueueUserWorkItem(WaitAndRaiseConnectEventsProc, info);
            }
        }

        /// <summary>
        /// The state of the server RunspacePool has changed. Handle
        /// the same and reflect local states accordingly
        /// </summary>
        /// <param name="eventArgs">argument describing this event</param>
        /// <param name="sender">sender of this event</param>
        internal void HandleStateInfoReceived(object sender,
            RemoteDataEventArgs<RunspacePoolStateInfo> eventArgs)
        {
            RunspacePoolStateInfo newStateInfo = eventArgs.Data;
            bool raiseEvents = false;

            Dbg.Assert(newStateInfo != null, "state information should not be null");

            if (newStateInfo.State == RunspacePoolState.Opened)
            {
                lock (syncObject)
                {
                    if (stateInfo.State == RunspacePoolState.Opening)
                    {
                        SetRunspacePoolState(newStateInfo);
                        raiseEvents = true;
                    }
                }

                if (raiseEvents)
                {
                    // this needs to be done outside the lock to avoid a
                    // deadlock scenario
                    RaiseStateChangeEvent(stateInfo);
                    SetOpenAsCompleted();
                }
            }
            else if (newStateInfo.State == RunspacePoolState.Closed || newStateInfo.State == RunspacePoolState.Broken)
            {
                bool doClose = false;

                lock (syncObject)
                {
                    if (stateInfo.State == RunspacePoolState.Closed || stateInfo.State == RunspacePoolState.Broken)
                    {
                        // there is nothing to do here
                        return;
                    }

                    if (stateInfo.State == RunspacePoolState.Opening
                     || stateInfo.State == RunspacePoolState.Opened
                     || stateInfo.State == RunspacePoolState.Closing)
                    {
                        doClose = true;
                        SetRunspacePoolState(newStateInfo);
                    }
                }

                if (doClose)
                {
                    // if closeAsyncResult is null, BeginClose is not called. That means
                    // we are getting close event from server, in this case release the
                    // local resources
                    if (null == _closeAsyncResult)
                    {
                        // Close the local resources.
                        DataStructureHandler.CloseRunspacePoolAsync();
                    }

                    // Delay notifying upper layers of finished state change event
                    // until after transport close ack is received (HandleSessionClosed handler).
                }
            } // else if ...
        }

        /// <summary>
        /// A host call has been proxied from the server which needs to
        /// be executed
        /// </summary>
        /// <param name="sender">sender of this event</param>
        /// <param name="eventArgs">arguments describing this event</param>
        internal void HandleRemoteHostCalls(object sender,
            RemoteDataEventArgs<RemoteHostCall> eventArgs)
        {
            if (HostCallReceived != null)
            {
                HostCallReceived.SafeInvoke(sender, eventArgs);
            }
            else
            {
                RemoteHostCall hostCall = eventArgs.Data;

                if (hostCall.IsVoidMethod)
                {
                    hostCall.ExecuteVoidMethod(host);
                }
                else
                {
                    RemoteHostResponse remoteHostResponse = hostCall.ExecuteNonVoidMethod(host);
                    DataStructureHandler.SendHostResponseToServer(remoteHostResponse);
                }
            }
        }

        internal PSHost Host
        {
            get
            {
                return host;
            }
        }

        /// <summary>
        /// Application arguments to use when opening a remote session
        /// </summary>
        internal PSPrimitiveDictionary ApplicationArguments { get; }

        /// <summary>
        /// Private data to be used by applications built on top of PowerShell.
        ///
        /// Remote runspace pool gets its application private data from the server (when creating the remote runspace pool)
        /// - calling this method on a remote runspace will block until the data is received from the server.
        /// - unless the runspace is disconnected and data hasn't been received in which case it returns null immediately.
        /// </summary>
        internal override PSPrimitiveDictionary GetApplicationPrivateData()
        {
            if (this.RunspacePoolStateInfo.State == RunspacePoolState.Disconnected &&
                !_applicationPrivateDataReceived.WaitOne(0))
            {
                // Runspace pool was disconnected before application data was returned.  Application
                // data cannot be returned with the runspace pool disconnected so return null.
                return null;
            }

            return _applicationPrivateData;
        }

        internal void SetApplicationPrivateData(PSPrimitiveDictionary applicationPrivateData)
        {
            lock (this.syncObject)
            {
                if (_applicationPrivateDataReceived.WaitOne(0))
                {
                    return; // ignore server's attempt to set application private data if it has already been set
                }

                _applicationPrivateData = applicationPrivateData;
                _applicationPrivateDataReceived.Set();

                foreach (Runspace runspace in this.runspaceList)
                {
                    runspace.SetApplicationPrivateData(applicationPrivateData);
                }
            }
        }

        internal override void PropagateApplicationPrivateData(Runspace runspace)
        {
            if (_applicationPrivateDataReceived.WaitOne(0))
            {
                runspace.SetApplicationPrivateData(this.GetApplicationPrivateData());
            }
        }

        private PSPrimitiveDictionary _applicationPrivateData;
        private ManualResetEvent _applicationPrivateDataReceived = new ManualResetEvent(false);

        /// <summary>
        /// This event is raised, when a host call is for a remote runspace
        /// which this runspace pool wraps
        /// </summary>
        internal event EventHandler<RemoteDataEventArgs<RemoteHostCall>> HostCallReceived;

        /// <summary>
        /// EventHandler used to report connection URI redirections to the application
        /// </summary>
        internal event EventHandler<RemoteDataEventArgs<Uri>> URIRedirectionReported;

        /// <summary>
        /// Notifies the successful creation of the runspace session.
        /// </summary>
        internal event EventHandler<CreateCompleteEventArgs> SessionCreateCompleted;

        /// <summary>
        ///
        /// </summary>
        /// <param name="shell"></param>
        internal void CreatePowerShellOnServerAndInvoke(ClientRemotePowerShell shell)
        {
            DataStructureHandler.CreatePowerShellOnServerAndInvoke(shell);

            // send any input that may be available
            if (!shell.NoInput)
            {
                shell.SendInput();
            }
        }

        /// <summary>
        /// Add a ClientPowerShellDataStructureHandler to ClientRunspaceDataStructureHandler list.
        /// </summary>
        /// <param name="psShellInstanceId">PowerShell Instance Id.</param>
        /// <param name="psDSHandler">ClientPowerShellDataStructureHandler for PowerShell.</param>
        internal void AddRemotePowerShellDSHandler(Guid psShellInstanceId, ClientPowerShellDataStructureHandler psDSHandler)
        {
            DataStructureHandler.AddRemotePowerShellDSHandler(psShellInstanceId, psDSHandler);
        }

        /// <summary>
        /// Returns true if Runspace supports disconnect.
        /// </summary>
        internal bool CanDisconnect
        {
            get
            {
                Version remoteProtocolVersionDeclaredByServer = PSRemotingProtocolVersion;
                if (remoteProtocolVersionDeclaredByServer != null && DataStructureHandler != null)
                {
                    // Disconnect/Connect support is currently only provided by the WSMan transport
                    // that is running PSRP protocol version 2.2 and greater.
                    return (remoteProtocolVersionDeclaredByServer >= RemotingConstants.ProtocolVersionWin8RTM &&
                            DataStructureHandler.EndpointSupportsDisconnect);
                }

                return false;
            }
        }

        /// <summary>
        /// Returns the WinRM protocol version object for this runspace
        /// pool connection.
        /// </summary>
        internal Version PSRemotingProtocolVersion
        {
            get
            {
                Version winRMProtocolVersion = null;

                PSPrimitiveDictionary psPrimitiveDictionary = GetApplicationPrivateData();
                if (psPrimitiveDictionary != null)
                {
                    PSPrimitiveDictionary.TryPathGet(
                        psPrimitiveDictionary,
                        out winRMProtocolVersion,
                        PSVersionInfo.PSVersionTableName,
                        PSVersionInfo.PSRemotingProtocolVersionName);
                }

                return winRMProtocolVersion;
            }
        }

        /// <summary>
        /// Push a running PowerShell onto the stack.
        /// </summary>
        /// <param name="ps">PowerShell</param>
        internal void PushRunningPowerShell(PowerShell ps)
        {
            Dbg.Assert(ps != null, "Caller should not pass in null reference.");
            _runningPowerShells.Push(ps);
        }

        /// <summary>
        /// Pop the currently running PowerShell from stack.
        /// </summary>
        /// <returns>PowerShell</returns>
        internal PowerShell PopRunningPowerShell()
        {
            PowerShell powershell;
            if (_runningPowerShells.TryPop(out powershell))
            {
                return powershell;
            }

            return null;
        }

        /// <summary>
        /// Return the current running PowerShell.
        /// </summary>
        /// <returns>PowerShell</returns>
        internal PowerShell GetCurrentRunningPowerShell()
        {
            PowerShell powershell;
            if (_runningPowerShells.TryPeek(out powershell))
            {
                return powershell;
            }

            return null;
        }

        #endregion Internal Methods

        #region Protected Methods

        /// <summary>
        /// Opens the runspacepool synchronously / asynchronously.
        /// Runspace pool must be opened before it can be used.
        /// </summary>
        /// <param name="isAsync">
        /// true to open asynchronously
        /// </param>
        /// <param name="callback">
        /// A AsyncCallback to call once the BeginOpen completes.
        /// </param>
        /// <param name="asyncState">
        /// A user supplied state to call the <paramref name="callback"/>
        /// with.
        /// </param>
        /// <returns>
        /// asyncResult object to monitor status of the async
        /// open operation. This is returned only if <paramref name="isAsync"/>
        /// is true.
        /// </returns>
        /// <exception cref="InvalidRunspacePoolStateException">
        /// Cannot open RunspacePool because RunspacePool is not in
        /// the BeforeOpen state.
        /// </exception>
        /// <exception cref="OutOfMemoryException">
        /// There is not enough memory available to start this asynchronously.
        /// </exception>
        protected override IAsyncResult CoreOpen(bool isAsync, AsyncCallback callback,
            object asyncState)
        {
            PSEtwLog.SetActivityIdForCurrentThread(this.InstanceId);
            PSEtwLog.LogOperationalVerbose(PSEventId.RunspacePoolOpen, PSOpcode.Open,
                            PSTask.CreateRunspace, PSKeyword.UseAlwaysOperational);

#if LEGACYTELEMETRY
            TelemetryAPI.ReportRemoteSessionCreated(_connectionInfo);
#endif

            lock (syncObject)
            {
                AssertIfStateIsBeforeOpen();

                stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Opening, null);
            }

            // BUGBUG: the following comment needs to be validated
            // only one thread will reach here, so no need
            // to lock
            RaiseStateChangeEvent(stateInfo);

            RunspacePoolAsyncResult asyncResult = new RunspacePoolAsyncResult(
                    instanceId, callback, asyncState, true);

            _openAsyncResult = asyncResult;


            // send a message using the data structure handler to open the RunspacePool
            // on the remote server
            DataStructureHandler.CreateRunspacePoolAndOpenAsync();

            return asyncResult;
        }

        #endregion Protected Methods

        #region Public Methods

        /// <summary>
        /// Synchronous open
        /// </summary>
        public override void Open()
        {
            IAsyncResult asyncResult = BeginOpen(null, null);

            EndOpen(asyncResult);
        }

        /// <summary>
        /// Closes the RunspacePool and cleans all the internal
        /// resources. This will close all the runspaces in the
        /// runspacepool and release all the async operations
        /// waiting for a runspace. If the pool is already closed
        /// or broken or closing this will just return.
        /// </summary>
        /// <exception cref="InvalidRunspacePoolStateException">
        /// Cannot close the RunspacePool because RunspacePool is
        /// in Closing state.
        /// </exception>
        public override void Close()
        {
            // close and wait
            IAsyncResult asyncResult = BeginClose(null, null);
            EndClose(asyncResult);
        }

        /// <summary>
        /// Closes the RunspacePool asynchronously. To get the exceptions
        /// that might have occurred, call EndOpen
        /// </summary>
        /// <param name="callback">
        /// An AsyncCallback to call once the BeginClose completes
        /// </param>
        /// <param name="asyncState">
        /// A user supplied state to call the <paramref name="callback"/>
        /// with
        /// </param>
        /// <returns>
        /// An AsyncResult object to monitor the state of the async
        /// operation
        /// </returns>
        public override IAsyncResult BeginClose(AsyncCallback callback, object asyncState)
        {
            bool raiseEvents = false;
            bool skipClosing = false;
            RunspacePoolStateInfo copyState = new RunspacePoolStateInfo(RunspacePoolState.BeforeOpen, null);
            RunspacePoolAsyncResult asyncResult = null;

            lock (syncObject)
            {
                if ((stateInfo.State == RunspacePoolState.Closed) ||
                    (stateInfo.State == RunspacePoolState.Broken))
                {
                    skipClosing = true;
                    asyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
                }
                else if (stateInfo.State == RunspacePoolState.BeforeOpen)
                {
                    copyState = stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closed, null);
                    raiseEvents = true;
                    skipClosing = true;
                    _closeAsyncResult = null;
                    asyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
                }
                else if (stateInfo.State == RunspacePoolState.Opened ||
                         stateInfo.State == RunspacePoolState.Opening)
                {
                    copyState = stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closing, null);
                    _closeAsyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
                    asyncResult = _closeAsyncResult;
                    raiseEvents = true;
                }
                else if (stateInfo.State == RunspacePoolState.Disconnected ||
                         stateInfo.State == RunspacePoolState.Disconnecting ||
                         stateInfo.State == RunspacePoolState.Connecting)
                {
                    // Continue with closing so the PSRP layer is aware that the client side session is
                    // being closed.  This will result in a broken session on the client.
                    _closeAsyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
                    asyncResult = _closeAsyncResult;
                }
                else if (stateInfo.State == RunspacePoolState.Closing)
                {
                    return _closeAsyncResult;
                }
            }

            // raise the events outside the lock
            if (raiseEvents)
            {
                RaiseStateChangeEvent(copyState);
            }

            if (!skipClosing)
            {
                //SetRunspacePoolState(new RunspacePoolStateInfo(RunspacePoolState.Closing, null), true);

                // send a message using the data structure handler to close the RunspacePool
                // on the remote server
                DataStructureHandler.CloseRunspacePoolAsync();
            }
            else
            {
                // signal the wait handle
                asyncResult.SetAsCompleted(null);
            }

            return asyncResult;
        }

        /// <summary>