Move one-time initialization out of psm1

Author: lzybkr

PSReadLine/Completion.cs

@@ -21,7 +21,7 @@ public partial class PSConsoleReadLine
         // Tab completion state
         private int _tabCommandCount;
         private CommandCompletion _tabCompletions;
-        private Runspace _remoteRunspace;
+        private Runspace _runspace;
 
         // Stub helper method so completion can be mocked
         [ExcludeFromCodeCoverage]
@@ -211,14 +211,14 @@ private CommandCompletion GetCompletions()
                     // input for coloring) but that overload is a little more complicated in passing in the
                     // cursor position.
                     System.Management.Automation.PowerShell ps;
-                    if (_remoteRunspace == null)
+                    if (!_mockableMethods.RunspaceIsRemote(_runspace))
                     {
                         ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace);
                     }
                     else
                     {
                         ps = System.Management.Automation.PowerShell.Create();
-                        ps.Runspace = _remoteRunspace;
+                        ps.Runspace = _runspace;
                     }
                     _tabCompletions = _mockableMethods.CompleteInput(_buffer.ToString(), _current, null, ps);
 

PSReadLine/PSReadLine.psm1

@@ -1,47 +1,5 @@
-
-[bool]$firstTime = $true
-
-#
-# .SYNOPSIS
-#
-#     This function is called by the console host when reading input to execute commands.
-#
 function PSConsoleHostReadline
 {
-    if ($firstTime)
-    {
-        # This initialization is delayed until the first call so that
-        # a profile with something like:
-        #
-        #     ipmo PSReadline
-        #     Set-PSReadlineOption -HistorySaveStyle ??????
-        #
-        # PSReadline will then handle the history choice in a reasonable way
-        # regardless of the style.
-
-        $script:firstTime = $false
-
-        $options = [Microsoft.PowerShell.PSConsoleReadLine]::GetOptions()
-
-        # Honor $MaximumHistoryCount, but get it safely in case it was removed in the profile.
-        $MaximumHistoryCount = Get-Variable -ea Ignore -ValueOnly MaximumHistoryCount
-        if ($MaximumHistoryCount -gt 0)
-        {
-            $options.MaximumHistoryCount = $MaximumHistoryCount
-        }
-
-        if ($options.HistorySaveStyle -eq [Microsoft.PowerShell.HistorySaveStyle]::SaveNothing)
-        {
-            # PSReadline isn't saving history, but we might still have history to reuse
-            Get-History | ForEach-Object { [Microsoft.PowerShell.PSConsoleReadLine]::AddToHistory($_.CommandLine) }
-        }
-    }
-
-    # PSHost doesn't expose it's runspace.  The InternalHost does, but that won't
-    # work for arbitrary hosts, so we turn off strict mode.
-    Set-StrictMode -Off
-    $remoteRunspace = if ($host.IsRunspacePushed) { $host.Runspace } else { $null }
-
-    [Microsoft.PowerShell.PSConsoleReadLine]::ReadLine($remoteRunspace, $ExecutionContext)
+    Microsoft.PowerShell.Core\Set-StrictMode -Off
+    [Microsoft.PowerShell.PSConsoleReadLine]::ReadLine($host.Runspace, $ExecutionContext)
 }
- 

PSReadLine/PublicAPI.cs

@@ -7,6 +7,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Management.Automation;
 using System.Management.Automation.Language;
+using System.Management.Automation.Runspaces;
 
 namespace Microsoft.PowerShell
 {
@@ -24,6 +25,8 @@ public interface IPSConsoleReadLineMockableMethods
             void Ding();
             /// <summary/>
             CommandCompletion CompleteInput(string input, int cursorIndex, Hashtable options, System.Management.Automation.PowerShell powershell);
+            /// <summary/>
+            bool RunspaceIsRemote(Runspace runspace);
         }
     }
 

PSReadLine/ReadLine.cs

@@ -13,6 +13,7 @@
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
+using Microsoft.PowerShell.Commands;
 using Microsoft.PowerShell.Internal;
 
 [module: SuppressMessage("Microsoft.Design", "CA1014:MarkAssembliesWithClsCompliant")]
@@ -25,13 +26,14 @@ class ExitException : Exception { }
 
     public partial class PSConsoleReadLine : IPSConsoleReadLineMockableMethods
     {
-        private static readonly PSConsoleReadLine _singleton;
+        private static readonly PSConsoleReadLine _singleton = new PSConsoleReadLine();
+
         private bool _delayedOneTimeInitCompleted;
 
         private IPSConsoleReadLineMockableMethods _mockableMethods;
 
         private EngineIntrinsics _engineIntrinsics;
-        private static readonly GCHandle _breakHandlerGcHandle;
+        private static GCHandle _breakHandlerGcHandle;
         private Thread _readKeyThread;
         private AutoResetEvent _readKeyWaitHandle;
         private AutoResetEvent _keyReadWaitHandle;
@@ -51,9 +53,10 @@ public partial class PSConsoleReadLine : IPSConsoleReadLineMockableMethods
         private bool _inputAccepted;
         private readonly Queue<ConsoleKeyInfo> _queuedKeys;
         private Stopwatch _lastRenderTime;
+        private static Stopwatch _readkeyStopwatch = new Stopwatch();
 
         // Save a fixed # of keys so we can reconstruct a repro after a crash
-        private readonly static HistoryQueue<ConsoleKeyInfo> _lastNKeys;
+        private readonly static HistoryQueue<ConsoleKeyInfo> _lastNKeys = new HistoryQueue<ConsoleKeyInfo>(200);
 
         // Tokens etc.
         private Token[] _tokens;
@@ -74,32 +77,41 @@ bool IPSConsoleReadLineMockableMethods.KeyAvailable()
             return Console.KeyAvailable;
         }
 
+        bool IPSConsoleReadLineMockableMethods.RunspaceIsRemote(Runspace runspace)
+        {
+            return runspace != null && runspace.ConnectionInfo != null;
+        }
+
+        private void ReadOneOrMoreKeys()
+        {
+            _readkeyStopwatch.Restart();
+            while (_mockableMethods.KeyAvailable())
+            {
+                _queuedKeys.Enqueue(_mockableMethods.ReadKey());
+                if (_readkeyStopwatch.ElapsedMilliseconds > 2)
+                {
+                    // Don't spend too long in this loop if there are lots of queued keys
+                    break;
+                }
+            }
+
+            if (_queuedKeys.Count == 0)
+            {
+                var key = _mockableMethods.ReadKey();
+                _queuedKeys.Enqueue(key);
+            }
+        }
+
         private void ReadKeyThreadProc()
         {
-            var stopwatch = new Stopwatch();
             while (true)
             {
                 // Wait until ReadKey tells us to read a key (or it's time to exit).
                 int handleId = WaitHandle.WaitAny(_singleton._threadProcWaitHandles);
                 if (handleId == 1) // It was the _closingWaitHandle that was signaled.
                     break;
 
-                stopwatch.Restart();
-                while (_mockableMethods.KeyAvailable())
-                {
-                    _queuedKeys.Enqueue(_mockableMethods.ReadKey());
-                    if (stopwatch.ElapsedMilliseconds > 2)
-                    {
-                        // Don't spend too long in this loop if there are lots of queued keys
-                        break;
-                    }
-                }
-
-                if (_queuedKeys.Count == 0)
-                {
-                    var key = _mockableMethods.ReadKey();
-                    _queuedKeys.Enqueue(key);
-                }
+                ReadOneOrMoreKeys();
 
                 // One or more keys were read - let ReadKey know we're done.
                 _keyReadWaitHandle.Set();
@@ -207,6 +219,7 @@ private static ConsoleKeyInfo ReadKey()
 
                 throw new OperationCanceledException();
             }
+
             var key = _singleton._queuedKeys.Dequeue();
             return key;
         }
@@ -457,38 +470,6 @@ void ProcessOneKey(ConsoleKeyInfo key, Dictionary<ConsoleKeyInfo, KeyHandler> di
             }
         }
 
-        static PSConsoleReadLine()
-        {
-            _singleton = new PSConsoleReadLine();
-
-            _breakHandlerGcHandle = GCHandle.Alloc(new BreakHandler(_singleton.BreakHandler));
-            NativeMethods.SetConsoleCtrlHandler((BreakHandler) _breakHandlerGcHandle.Target, true);
-            _singleton._readKeyWaitHandle = new AutoResetEvent(false);
-            _singleton._keyReadWaitHandle = new AutoResetEvent(false);
-            _singleton._closingWaitHandle = new ManualResetEvent(false);
-            _singleton._requestKeyWaitHandles = new WaitHandle[] { _singleton._keyReadWaitHandle, _singleton._closingWaitHandle };
-            _singleton._threadProcWaitHandles = new WaitHandle[] { _singleton._readKeyWaitHandle, _singleton._closingWaitHandle };
-
-            // This is only used for post-mortem debugging - 200 keys should be enough to reconstruct most command lines.
-            _lastNKeys = new HistoryQueue<ConsoleKeyInfo>(200);
-
-            // This is for a "being hosted in an alternate appdomain scenario" (the
-            // DomainUnload event is not raised for the default appdomain). It allows us
-            // to exit cleanly when the appdomain is unloaded but the process is not going
-            // away.
-            if (!AppDomain.CurrentDomain.IsDefaultAppDomain())
-            {
-                AppDomain.CurrentDomain.DomainUnload += (x, y) =>
-                {
-                    _singleton._closingWaitHandle.Set();
-                    _singleton._readKeyThread.Join(); // may need to wait for history to be written
-                };
-            }
-
-            _singleton._readKeyThread = new Thread(_singleton.ReadKeyThreadProc) {IsBackground = true};
-            _singleton._readKeyThread.Start();
-        }
-
         private PSConsoleReadLine()
         {
             _mockableMethods = this;
@@ -501,19 +482,23 @@ private PSConsoleReadLine()
             _queuedKeys = new Queue<ConsoleKeyInfo>();
 
             string hostName = null;
-            try
+            // This works mostly by luck - we're not doing anything to guarantee the constructor for our
+            // singleton is called on a thread with a runspace, but it is happening by coincidence.
+            using (var ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace))
             {
-                var ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace)
-                    .AddCommand("Get-Variable").AddParameter("Name", "host").AddParameter("ValueOnly");
-                var results = ps.Invoke();
-                dynamic host = results.Count == 1 ? results[0] : null;
-                if (host != null)
+                try
+                {
+                    ps.AddCommand("Get-Variable").AddParameter("Name", "host").AddParameter("ValueOnly");
+                    var results = ps.Invoke();
+                    dynamic host = results.Count == 1 ? results[0] : null;
+                    if (host != null)
+                    {
+                        hostName = host.Name as string;
+                    }
+                }
+                catch
                 {
-                    hostName = host.Name as string;
                 }
-            }
-            catch
-            {
             }
             if (hostName == null)
             {
@@ -522,15 +507,17 @@ private PSConsoleReadLine()
             _options = new PSConsoleReadlineOptions(hostName);
         }
 
-        private void Initialize(Runspace remoteRunspace, EngineIntrinsics engineIntrinsics)
+        private void Initialize(Runspace runspace, EngineIntrinsics engineIntrinsics)
         {
+            _engineIntrinsics = engineIntrinsics;
+            _runspace = runspace;
+
             if (!_delayedOneTimeInitCompleted)
             {
                 DelayedOneTimeInitialize();
                 _delayedOneTimeInitCompleted = true;
             }
 
-            _engineIntrinsics = engineIntrinsics;
             _buffer.Clear();
             _edits = new List<EditItem>();
             _undoEditIndex = 0;
@@ -553,7 +540,6 @@ private void Initialize(Runspace remoteRunspace, EngineIntrinsics engineIntrinsi
             _yankLastArgCommandCount = 0;
             _tabCommandCount = 0;
             _visualSelectionCommandCount = 0;
-            _remoteRunspace = remoteRunspace;
             _statusIsErrorMessage = false;
 
             _consoleBuffer = ReadBufferLines(_initialY, 1 + Options.ExtraPromptLineCount);
@@ -595,15 +581,68 @@ private void DelayedOneTimeInitialize()
             // specifies a custom history save file, we don't want to try reading
             // from the default one.
 
+            var historyCountVar = _engineIntrinsics.SessionState.PSVariable.Get("MaximumHistoryCount");
+            if (historyCountVar != null && historyCountVar.Value is int)
+            {
+                _options.MaximumHistoryCount = (int)historyCountVar.Value;
+            }
+
             _historyFileMutex = new Mutex(false, GetHistorySaveFileMutexName());
 
             _history = new HistoryQueue<HistoryItem>(Options.MaximumHistoryCount);
             _currentHistoryIndex = 0;
 
-            ReadHistoryFile();
+            bool readHistoryFile = true;
+            try
+            {
+                if (_options.HistorySaveStyle == HistorySaveStyle.SaveNothing && Runspace.DefaultRunspace != null)
+                {
+                    using (var ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace))
+                    {
+                        ps.AddCommand("Microsoft.PowerShell.Core\\Get-History");
+                        foreach (var historyInfo in ps.Invoke<HistoryInfo>())
+                        {
+                            AddToHistory(historyInfo.CommandLine);
+                        }
+                        readHistoryFile = false;
+                    }
+                }
+            }
+            catch
+            {
+            }
+
+            if (readHistoryFile)
+            {
+                ReadHistoryFile();
+            }
 
             _killIndex = -1; // So first add indexes 0.
             _killRing = new List<string>(Options.MaximumKillRingCount);
+
+            _breakHandlerGcHandle = GCHandle.Alloc(new BreakHandler(_singleton.BreakHandler));
+            NativeMethods.SetConsoleCtrlHandler((BreakHandler)_breakHandlerGcHandle.Target, true);
+            _singleton._readKeyWaitHandle = new AutoResetEvent(false);
+            _singleton._keyReadWaitHandle = new AutoResetEvent(false);
+            _singleton._closingWaitHandle = new ManualResetEvent(false);
+            _singleton._requestKeyWaitHandles = new WaitHandle[] {_singleton._keyReadWaitHandle, _singleton._closingWaitHandle};
+            _singleton._threadProcWaitHandles = new WaitHandle[] {_singleton._readKeyWaitHandle, _singleton._closingWaitHandle};
+
+            // This is for a "being hosted in an alternate appdomain scenario" (the
+            // DomainUnload event is not raised for the default appdomain). It allows us
+            // to exit cleanly when the appdomain is unloaded but the process is not going
+            // away.
+            if (!AppDomain.CurrentDomain.IsDefaultAppDomain())
+            {
+                AppDomain.CurrentDomain.DomainUnload += (x, y) =>
+                {
+                    _singleton._closingWaitHandle.Set();
+                    _singleton._readKeyThread.Join(); // may need to wait for history to be written
+                };
+            }
+
+            _singleton._readKeyThread = new Thread(_singleton.ReadKeyThreadProc) {IsBackground = true};
+            _singleton._readKeyThread.Start();
         }
 
         [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed")]

UnitTestPSReadLine/UnitTestReadLine.cs

@@ -75,6 +75,11 @@ public CommandCompletion CompleteInput(string input, int cursorIndex, Hashtable
         {
             return UnitTest.MockedCompleteInput(input, cursorIndex, options, powershell);
         }
+
+        public bool RunspaceIsRemote(Runspace runspace)
+        {
+            return false;
+        }
     }
 
     [TestClass]