Refactored .NET HttpCommandExecutor for future HTTP client expansion

Author: jimevans

dotnet/src/webdriver/Remote/CommandInfo.cs

@@ -1,4 +1,4 @@
-// <copyright file="CommandInfo.cs" company="WebDriver Committers">
+// <copyright file="CommandInfo.cs" company="WebDriver Committers">
 // Licensed to the Software Freedom Conservancy (SFC) under one
 // or more contributor license agreements. See the NOTICE file
 // distributed with this work for additional information
@@ -75,14 +75,16 @@ public string Method
         }
 
         /// <summary>
-        /// Creates a web request for your command
+        /// Creates the full URI associated with this command, substituting command
+        /// parameters for tokens in the URI template.
         /// </summary>
-        /// <param name="baseUri">Uri that will have the command run against</param>
-        /// <param name="commandToExecute">Command to execute</param>
-        /// <returns>A web request of what has been run</returns>
-        public HttpWebRequest CreateWebRequest(Uri baseUri, Command commandToExecute)
+        /// <param name="baseUri">The base URI associated with the command.</param>
+        /// <param name="commandToExecute">The command containing the parameters with which
+        /// to substitute the tokens in the template.</param>
+        /// <returns>The full URI for the command, with the parameters of the command
+        /// substituted for the tokens in the template.</returns>
+        public Uri CreateCommandUri(Uri baseUri, Command commandToExecute)
         {
-            HttpWebRequest request = null;
             string[] urlParts = this.resourcePath.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
             for (int i = 0; i < urlParts.Length; i++)
             {
@@ -97,17 +99,12 @@ public HttpWebRequest CreateWebRequest(Uri baseUri, Command commandToExecute)
             string relativeUrlString = string.Join("/", urlParts);
             Uri relativeUri = new Uri(relativeUrlString, UriKind.Relative);
             bool uriCreateSucceeded = Uri.TryCreate(baseUri, relativeUri, out fullUri);
-            if (uriCreateSucceeded)
-            {
-                request = HttpWebRequest.Create(fullUri) as HttpWebRequest;
-                request.Method = this.method;
-            }
-            else
+            if (!uriCreateSucceeded)
             {
                 throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Unable to create URI from base {0} and relative path {1}", baseUri == null ? string.Empty : baseUri.ToString(), relativeUrlString));
             }
 
-            return request;
+            return fullUri;
         }
 
         private static string GetCommandPropertyValue(string propertyName, Command commandToExecute)

dotnet/src/webdriver/Remote/HttpCommandExecutor.cs

@@ -1,4 +1,4 @@
-// <copyright file="HttpCommandExecutor.cs" company="WebDriver Committers">
+// <copyright file="HttpCommandExecutor.cs" company="WebDriver Committers">
 // Licensed to the Software Freedom Conservancy (SFC) under one
 // or more contributor license agreements. See the NOTICE file
 // distributed with this work for additional information
@@ -17,6 +17,7 @@
 // </copyright>
 
 using System;
+using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Net;
@@ -30,8 +31,10 @@ namespace OpenQA.Selenium.Remote
     internal class HttpCommandExecutor : ICommandExecutor
     {
         private const string JsonMimeType = "application/json";
-        private const string ContentTypeHeader = JsonMimeType + ";charset=utf-8";
-        private const string RequestAcceptHeader = JsonMimeType + ", image/png";
+        private const string PngMimeType = "image/png";
+        private const string CharsetType = "charset=utf-8";
+        private const string ContentTypeHeader = JsonMimeType + ";" + CharsetType;
+        private const string RequestAcceptHeader = JsonMimeType + ", " + PngMimeType;
         private Uri remoteServerUri;
         private TimeSpan serverResponseTimeout;
         private bool enableKeepAlive;
@@ -71,6 +74,7 @@ public HttpCommandExecutor(Uri addressOfRemoteServer, TimeSpan timeout, bool ena
             this.enableKeepAlive = enableKeepAlive;
 
             ServicePointManager.Expect100Continue = false;
+            ServicePointManager.DefaultConnectionLimit = 2000;
 
             // In the .NET Framework, HttpWebRequest responses with an error code are limited
             // to 64k by default. Since the remote server error responses include a screenshot,
@@ -80,12 +84,12 @@ public HttpCommandExecutor(Uri addressOfRemoteServer, TimeSpan timeout, bool ena
             {
                 HttpWebRequest.DefaultMaximumErrorResponseLength = -1;
             }
-        }
+    }
 
-        /// <summary>
-        /// Gets the repository of objects containin information about commands.
-        /// </summary>
-        public CommandInfoRepository CommandInfoRepository
+    /// <summary>
+    /// Gets the repository of objects containin information about commands.
+    /// </summary>
+    public CommandInfoRepository CommandInfoRepository
         {
             get { return this.commandInfoRepository; }
         }
@@ -103,22 +107,11 @@ public virtual Response Execute(Command commandToExecute)
             }
 
             CommandInfo info = this.commandInfoRepository.GetCommandInfo(commandToExecute.Name);
-            HttpWebRequest request = info.CreateWebRequest(this.remoteServerUri, commandToExecute);
-            request.Timeout = (int)this.serverResponseTimeout.TotalMilliseconds;
-            request.Accept = RequestAcceptHeader;
-            request.KeepAlive = this.enableKeepAlive;
-            request.ServicePoint.ConnectionLimit = 2000;
-            if (request.Method == CommandInfo.PostCommand)
-            {
-                string payload = commandToExecute.ParametersAsJsonString;
-                byte[] data = Encoding.UTF8.GetBytes(payload);
-                request.ContentType = ContentTypeHeader;
-                Stream requestStream = request.GetRequestStream();
-                requestStream.Write(data, 0, data.Length);
-                requestStream.Close();
-            }
+            HttpRequestInfo requestInfo = new HttpRequestInfo(this.remoteServerUri, commandToExecute, info);
 
-            Response toReturn = this.CreateResponse(request);
+            HttpResponseInfo responseInfo = this.MakeHttpRequest(requestInfo);
+
+            Response toReturn = this.CreateResponse(responseInfo);
             if (commandToExecute.Name == DriverCommand.NewSession && toReturn.IsSpecificationCompliant)
             {
                 // If we are creating a new session, sniff the response to determine
@@ -153,9 +146,25 @@ private static string GetTextOfWebResponse(HttpWebResponse webResponse)
             return responseString;
         }
 
-        private Response CreateResponse(WebRequest request)
+        private HttpResponseInfo MakeHttpRequest(HttpRequestInfo requestInfo)
         {
-            Response commandResponse = new Response();
+            HttpWebRequest request = HttpWebRequest.Create(requestInfo.FullUri) as HttpWebRequest;
+            request.Method = requestInfo.HttpMethod;
+            request.Timeout = (int)this.serverResponseTimeout.TotalMilliseconds;
+            request.Accept = RequestAcceptHeader;
+            request.KeepAlive = this.enableKeepAlive;
+            request.ServicePoint.ConnectionLimit = 2000;
+            if (request.Method == CommandInfo.PostCommand)
+            {
+                string payload = requestInfo.RequestBody;
+                byte[] data = Encoding.UTF8.GetBytes(payload);
+                request.ContentType = ContentTypeHeader;
+                Stream requestStream = request.GetRequestStream();
+                requestStream.Write(data, 0, data.Length);
+                requestStream.Close();
+            }
+
+            HttpResponseInfo responseInfo = new HttpResponseInfo();
             HttpWebResponse webResponse = null;
             try
             {
@@ -182,58 +191,87 @@ private Response CreateResponse(WebRequest request)
             }
             else
             {
-                string responseString = GetTextOfWebResponse(webResponse);
-                if (webResponse.ContentType != null && webResponse.ContentType.StartsWith(JsonMimeType, StringComparison.OrdinalIgnoreCase))
-                {
-                    commandResponse = Response.FromJson(responseString);
-                }
-                else
+                responseInfo.Body = GetTextOfWebResponse(webResponse);
+                responseInfo.ContentType = webResponse.ContentType;
+                responseInfo.StatusCode = webResponse.StatusCode;
+            }
+
+            return responseInfo;
+        }
+
+        private Response CreateResponse(HttpResponseInfo stuff)
+        {
+            Response commandResponse = new Response();
+            string responseString = stuff.Body;
+            if (stuff.ContentType != null && stuff.ContentType.StartsWith(JsonMimeType, StringComparison.OrdinalIgnoreCase))
+            {
+                commandResponse = Response.FromJson(responseString);
+            }
+            else
+            {
+                commandResponse.Value = responseString;
+            }
+
+            if (this.commandInfoRepository.SpecificationLevel < 1 && (stuff.StatusCode < HttpStatusCode.OK || stuff.StatusCode >= HttpStatusCode.BadRequest))
+            {
+                // 4xx represents an unknown command or a bad request.
+                if (stuff.StatusCode >= HttpStatusCode.BadRequest && stuff.StatusCode < HttpStatusCode.InternalServerError)
                 {
-                    commandResponse.Value = responseString;
+                    commandResponse.Status = WebDriverResult.UnhandledError;
                 }
-
-                if (this.commandInfoRepository.SpecificationLevel < 1 && (webResponse.StatusCode < HttpStatusCode.OK || webResponse.StatusCode >= HttpStatusCode.BadRequest))
+                else if (stuff.StatusCode >= HttpStatusCode.InternalServerError)
                 {
-                    // 4xx represents an unknown command or a bad request.
-                    if (webResponse.StatusCode >= HttpStatusCode.BadRequest && webResponse.StatusCode < HttpStatusCode.InternalServerError)
+                    // 5xx represents an internal server error. The response status should already be set, but
+                    // if not, set it to a general error code. The exception is a 501 (NotImplemented) response,
+                    // which indicates that the command hasn't been implemented on the server.
+                    if (stuff.StatusCode == HttpStatusCode.NotImplemented)
                     {
-                        commandResponse.Status = WebDriverResult.UnhandledError;
+                        commandResponse.Status = WebDriverResult.UnknownCommand;
                     }
-                    else if (webResponse.StatusCode >= HttpStatusCode.InternalServerError)
+                    else
                     {
-                        // 5xx represents an internal server error. The response status should already be set, but
-                        // if not, set it to a general error code. The exception is a 501 (NotImplemented) response,
-                        // which indicates that the command hasn't been implemented on the server.
-                        if (webResponse.StatusCode == HttpStatusCode.NotImplemented)
-                        {
-                            commandResponse.Status = WebDriverResult.UnknownCommand;
-                        }
-                        else
+                        if (commandResponse.Status == WebDriverResult.Success)
                         {
-                            if (commandResponse.Status == WebDriverResult.Success)
-                            {
-                                commandResponse.Status = WebDriverResult.UnhandledError;
-                            }
+                            commandResponse.Status = WebDriverResult.UnhandledError;
                         }
                     }
-                    else
-                    {
-                        commandResponse.Status = WebDriverResult.UnhandledError;
-                    }
                 }
-
-                if (commandResponse.Value is string)
+                else
                 {
-                    // First, collapse all \r\n pairs to \n, then replace all \n with
-                    // System.Environment.NewLine. This ensures the consistency of
-                    // the values.
-                    commandResponse.Value = ((string)commandResponse.Value).Replace("\r\n", "\n").Replace("\n", System.Environment.NewLine);
+                    commandResponse.Status = WebDriverResult.UnhandledError;
                 }
+            }
 
-                webResponse.Close();
+            if (commandResponse.Value is string)
+            {
+                // First, collapse all \r\n pairs to \n, then replace all \n with
+                // System.Environment.NewLine. This ensures the consistency of
+                // the values.
+                commandResponse.Value = ((string)commandResponse.Value).Replace("\r\n", "\n").Replace("\n", System.Environment.NewLine);
             }
 
             return commandResponse;
         }
+
+        private class HttpRequestInfo
+        {
+            public HttpRequestInfo(Uri serverUri, Command commandToExecute, CommandInfo commandInfo)
+            {
+                this.FullUri = commandInfo.CreateCommandUri(serverUri, commandToExecute);
+                this.HttpMethod = commandInfo.Method;
+                this.RequestBody = commandToExecute.ParametersAsJsonString;
+            }
+
+            public Uri FullUri { get; set; }
+            public string HttpMethod { get; set; }
+            public string RequestBody { get; set; }
+        }
+
+        private class HttpResponseInfo
+        {
+            public HttpStatusCode StatusCode { get; set; }
+            public string Body { get; set; }
+            public string ContentType { get; set; }
+        }
     }
 }