Address frequent PortReserver failures

- related to aspnet#11 (3 of 4 additions)
- reduce work done within inner loop
- add messages for `Exception`s this class `throw`s
- release acquired `Mutex`es
- reduce timeout for acquiring global `Mutex`

Author: dougbu

test/Microsoft.TestCommon/PortReserver.cs

@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
-using System.Linq;
 using System.Net;
 using System.Net.NetworkInformation;
 using System.Threading;
@@ -14,18 +13,19 @@ namespace Microsoft.TestCommon
 {
     /// <summary>
     /// This class allocates ports while ensuring that:
-    /// 1. Ports that are permanentaly taken (or taken for the duration of the test) are not being attempted to be used.
+    /// 1. Ports that are permanently taken (or taken for the duration of the test) are not being attempted to be used.
     /// 2. Ports are not shared across different tests (but you can allocate two different ports in the same test).
-    /// 
+    ///
     /// Gotcha: If another application grabs a port during the test, we have a race condition.
     /// </summary>
     [DebuggerDisplay("Port: {PortNumber}, Port count for this app domain: {_appDomainOwnedPorts.Count}")]
     public class PortReserver : IDisposable
     {
         private Mutex _portMutex;
+        private Thread _acquiredOn;
 
         // We use this list to hold on to all the ports used because the Mutex will be blown through on the same thread.
-        // Theoretically we can do a thread local hashset, but that makes dispose thread dependant, or requires more complicated concurrency checks.
+        // Theoretically we can do a thread local HashSet, but that makes dispose thread-dependent, or requires more complicated concurrency checks.
         // Since practically there is no perf issue or concern here, this keeps the code the simplest possible.
         private static HashSet<int> _appDomainOwnedPorts = new HashSet<int>();
 
@@ -39,16 +39,21 @@ public PortReserver(int basePort = 50231)
         {
             if (basePort <= 0)
             {
-                throw new InvalidOperationException();
+                throw new ArgumentOutOfRangeException("basePort", "Argument must be greater than 0.");
             }
 
             // Grab a cross appdomain/cross process/cross thread lock, to ensure only one port is reserved at a time.
             using (Mutex mutex = GetGlobalMutex())
             {
                 try
                 {
-                    int port = basePort - 1;
+                    var usedTCPPorts = new HashSet<int>();
+                    foreach (var endPoint in ListUsedTCPPort())
+                    {
+                        usedTCPPorts.Add(endPoint.Port);
+                    }
 
+                    int port = basePort - 1;
                     while (true)
                     {
                         port++;
@@ -60,18 +65,19 @@ public PortReserver(int basePort = 50231)
 
                         // AppDomainOwnedPorts check enables reserving two ports from the same thread in sequence.
                         // ListUsedTCPPort prevents port contention with other apps.
-                        if (_appDomainOwnedPorts.Contains(port) ||
-                            ListUsedTCPPort().Any(endPoint => endPoint.Port == port))
+                        if (_appDomainOwnedPorts.Contains(port) || usedTCPPorts.Contains(port))
                         {
                             continue;
                         }
 
-                        string mutexName = "WebStack-Port-" + port.ToString(CultureInfo.InvariantCulture); // Create a well known mutex
+                        // Create a well known mutex
+                        string mutexName = "WebStack-Port-" + port.ToString(CultureInfo.InvariantCulture);
                         _portMutex = new Mutex(initiallyOwned: false, name: mutexName);
 
                         // If no one else is using this port grab it.
                         if (_portMutex.WaitOne(millisecondsTimeout: 0))
                         {
+                            _acquiredOn = Thread.CurrentThread;
                             break;
                         }
 
@@ -108,26 +114,43 @@ public void Dispose()
 
             using (Mutex mutex = GetGlobalMutex())
             {
-                _portMutex.Dispose();
-                _appDomainOwnedPorts.Remove(PortNumber);
-                PortNumber = -1;
+                try
+                {
+                    using (_portMutex)
+                    {
+                        if (_acquiredOn == Thread.CurrentThread)
+                        {
+                            _portMutex.ReleaseMutex();
+                        }
+
+                        _portMutex = null;
+                    }
+
+                    _appDomainOwnedPorts.Remove(PortNumber);
+                    PortNumber = -1;
+                }
+                finally
+                {
+                    mutex.ReleaseMutex();
+                }
             }
         }
 
         private static Mutex GetGlobalMutex()
         {
+            const int timeoutInSeconds = 20;
+
             Mutex mutex = new Mutex(initiallyOwned: false, name: "WebStack-RandomPortAcquisition");
-            if (!mutex.WaitOne(30000))
+            if (!mutex.WaitOne(TimeSpan.FromSeconds(timeoutInSeconds)))
             {
-                throw new InvalidOperationException();
+                throw new InvalidOperationException($"Unable to reserve global Mutex within {timeoutInSeconds} seconds.");
             }
 
             return mutex;
         }
 
         private static IPEndPoint[] ListUsedTCPPort()
         {
-            var usedPort = new HashSet<int>();
             IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
 
             return ipGlobalProperties.GetActiveTcpListeners();