Enable HTTP persistence when using Session with Invoke-WebRequest and Invoke-RestMethod

src/Microsoft.PowerShell.Commands.Utility/commands/utility/WebCmdlet/Common/WebRequestPSCmdlet.Common.cs

@@ -437,6 +437,11 @@ public virtual string CustomMethod
         /// </summary>
         private string _originalFilePath;
 
+        /// <summary>
+        /// True if the web session was created specifically by this request
+        /// </summary>
+        private bool _noWebSession;
+
         #endregion Input
 
         #region Output
@@ -578,15 +583,15 @@ protected override void ProcessRecord()
                                     // Disable writing to the OutFile.
                                     OutFile = null;
                                 }
-                                
+
                                 // Detect insecure redirection
                                 if (!AllowInsecureRedirect && response.RequestMessage.RequestUri.Scheme == "https" && response.Headers.Location?.Scheme == "http")
                                 {
-                                        ErrorRecord er = new(new InvalidOperationException(), "InsecureRedirection", ErrorCategory.InvalidOperation, request);
-                                        er.ErrorDetails = new ErrorDetails(WebCmdletStrings.InsecureRedirection);
-                                        ThrowTerminatingError(er);
+                                    ErrorRecord er = new(new InvalidOperationException(), "InsecureRedirection", ErrorCategory.InvalidOperation, request);
+                                    er.ErrorDetails = new ErrorDetails(WebCmdletStrings.InsecureRedirection);
+                                    ThrowTerminatingError(er);
                                 }
-                                
+
                                 if (ShouldCheckHttpStatus && !_isSuccess)
                                 {
                                     string message = string.Format(
@@ -837,6 +842,7 @@ internal virtual void ValidateParameters()
         internal virtual void PrepareSession()
         {
             // Make sure we have a valid WebRequestSession object to work with
+            _noWebSession = WebSession is null;
             WebSession ??= new WebRequestSession();
 
             if (SessionVariable is not null)
@@ -894,30 +900,53 @@ internal virtual void PrepareSession()
                 // Store the UserAgent string
                 WebSession.UserAgent = UserAgent;
             }
-
-            if (Proxy is not null)
+            // Proxy and NoProxy parameters are mutually exclusive
+            // If NoProxy is provided, WebSession will turn off the proxy
+            // and if Proxy is provided NoProxy will be turned off
+            if (NoProxy.IsPresent)
             {
-                WebProxy webProxy = new(Proxy);
-                webProxy.BypassProxyOnLocal = false;
-                if (ProxyCredential is not null)
-                {
-                    webProxy.Credentials = ProxyCredential.GetNetworkCredential();
-                }
-                else if (ProxyUseDefaultCredentials)
+                WebSession.NoProxy = true;
+            }
+            else
+            {
+                if (Proxy is not null)
                 {
-                    // If both ProxyCredential and ProxyUseDefaultCredentials are passed,
-                    // UseDefaultCredentials will overwrite the supplied credentials.
-                    webProxy.UseDefaultCredentials = true;
+                    WebProxy webProxy = new(Proxy);
+                    webProxy.BypassProxyOnLocal = false;
+                    if (ProxyCredential is not null)
+                    {
+                        webProxy.Credentials = ProxyCredential.GetNetworkCredential();
+                    }
+                    else if (ProxyUseDefaultCredentials)
+                    {
+                        // If both ProxyCredential and ProxyUseDefaultCredentials are passed,
+                        // UseDefaultCredentials will overwrite the supplied credentials.
+                        webProxy.UseDefaultCredentials = true;
+                    }
+                    // We don't want to update the WebSession unless the proxies are different
+                    // as that will require us to create a new HttpClientHandler and lose connection
+                    // persistence
+                    if (!webProxy.Equals(WebSession.Proxy))
+                    {
+                        WebSession.Proxy = webProxy;
+                    }
                 }
-
-                WebSession.Proxy = webProxy;
+            }
+            if (MyInvocation.BoundParameters.ContainsKey("SslProtocol"))
+            {
+                // SslProtocol parameter is a struct and we only want to switch back to the default
+                // if it is explicitly provided on the command line. Otherwise we keep the value in
+                // the WebSession from any previous invocation.
+                WebSession.SslProtocol = SslProtocol;
             }
 
             if (MaximumRedirection > -1)
             {
                 WebSession.MaximumRedirection = MaximumRedirection;
             }
 
+            WebSession.SkipCertificateCheck = SkipCertificateCheck.IsPresent;
+
             // Store the other supplied headers
             if (Headers is not null)
             {
@@ -943,57 +972,75 @@ internal virtual void PrepareSession()
                 WebSession.RetryIntervalInSeconds = RetryIntervalSec;
             }
         }
-        
+
         internal virtual HttpClient GetHttpClient(bool handleRedirect)
         {
-            HttpClientHandler handler = new();
-            handler.CookieContainer = WebSession.Cookies;
-            handler.AutomaticDecompression = DecompressionMethods.All;
+            var handler = WebSession.Handler;
 
-            // Set the credentials used by this request
-            if (WebSession.UseDefaultCredentials)
+            // This indicates GetResponse will handle redirects.
+            if (handleRedirect || WebSession.MaximumRedirection == 0)
             {
-                // The UseDefaultCredentials flag overrides other supplied credentials
-                handler.UseDefaultCredentials = true;
+                WebSession.AllowAutoRedirect = false;
             }
-            else if (WebSession.Credentials is not null)
+            else if (WebSession.MaximumRedirection > 0)
             {
-                handler.Credentials = WebSession.Credentials;
+                WebSession.MaxAutomaticRedirections = WebSession.MaximumRedirection;
             }
-
-            if (NoProxy)
+            if (handler is not null && WebSession.Changed)
             {
-                handler.UseProxy = false;
+                // None of the handler properties can be set after the handler has been used.
+                // Any options that are different to those used to construct the handler
+                // will cause the handler to be reconstructed.
+                WriteWarning("WebSession properties changed: new Http connection will be required");
+                handler.Dispose();
+                handler = null;
             }
-            else if (WebSession.Proxy is not null)
+            if (handler is null)
             {
-                handler.Proxy = WebSession.Proxy;
-            }
+                WebSession.Handler = handler = new();
 
-            if (WebSession.Certificates is not null)
-            {
-                handler.ClientCertificates.AddRange(WebSession.Certificates);
-            }
+                handler.CookieContainer = WebSession.Cookies;
+                handler.AutomaticDecompression = DecompressionMethods.All;
 
-            if (SkipCertificateCheck)
-            {
-                handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
-                handler.ClientCertificateOptions = ClientCertificateOption.Manual;
-            }
+                // Set the credentials used by this request
+                if (WebSession.UseDefaultCredentials)
+                {
+                    // The UseDefaultCredentials flag overrides other supplied credentials
+                    handler.UseDefaultCredentials = true;
+                }
+                else if (WebSession.Credentials is not null)
+                {
+                    handler.Credentials = WebSession.Credentials;
+                }
 
-            // This indicates GetResponse will handle redirects.
-            if (handleRedirect || WebSession.MaximumRedirection == 0)
-            {
-                handler.AllowAutoRedirect = false;
-            }
-            else if (WebSession.MaximumRedirection > 0)
-            {
-                handler.MaxAutomaticRedirections = WebSession.MaximumRedirection;
-            }
+                if (WebSession.NoProxy)
+                {
+                    handler.UseProxy = false;
+                }
+                else if (WebSession.Proxy is not null)
+                {
+                    handler.Proxy = WebSession.Proxy;
+                }
 
-            handler.SslProtocols = (SslProtocols)SslProtocol;
+                if (WebSession.Certificates is not null)
+                {
+                    handler.ClientCertificates.AddRange(WebSession.Certificates);
+                }
 
-            HttpClient httpClient = new(handler);
+                if (WebSession.SkipCertificateCheck)
+                {
+                    handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
+                    handler.ClientCertificateOptions = ClientCertificateOption.Manual;
+                }
+                handler.AllowAutoRedirect = WebSession.AllowAutoRedirect;
+                if (WebSession.AllowAutoRedirect && WebSession.MaximumRedirection > 0)
+                {
+                    handler.MaxAutomaticRedirections = WebSession.MaxAutomaticRedirections;
+                }
+                handler.SslProtocols = (SslProtocols)WebSession.SslProtocol;
+            }
+            // Only dispose the httpClientHandler if we are not trying to use a persistent one
+            HttpClient httpClient = new(handler, _noWebSession && string.IsNullOrEmpty(SessionVariable));
 
             // Check timeout setting (in seconds instead of milliseconds as in HttpWebRequest)
             httpClient.Timeout = TimeoutSec is 0 ? TimeSpan.FromMilliseconds(Timeout.Infinite) : new TimeSpan(0, 0, TimeoutSec);
@@ -1287,7 +1334,7 @@ internal virtual HttpResponseMessage GetResponse(HttpClient client, HttpRequestM
                             requestWithoutRange.Version,
                             requestWithoutRange.Method,
                             requestContentLength);
-                        
+
                         WriteVerbose(reqVerboseMsg);
 
                         response.Dispose();
@@ -1304,9 +1351,9 @@ internal virtual HttpResponseMessage GetResponse(HttpClient client, HttpRequestM
 
                     // If the status code is 429 get the retry interval from the Headers.
                     // Ignore broken header and its value.
-                    if (response.StatusCode is HttpStatusCode.Conflict && response.Headers.TryGetValues(HttpKnownHeaderNames.RetryAfter, out IEnumerable<string> retryAfter)) 
+                    if (response.StatusCode is HttpStatusCode.Conflict && response.Headers.TryGetValues(HttpKnownHeaderNames.RetryAfter, out IEnumerable<string> retryAfter))
                     {
-                        try 
+                        try
                         {
                             IEnumerator<string> enumerator = retryAfter.GetEnumerator();
                             if (enumerator.MoveNext())
@@ -1319,7 +1366,7 @@ internal virtual HttpResponseMessage GetResponse(HttpClient client, HttpRequestM
                             // Ignore broken header.
                         }
                     }
-                    
+
                     string retryMessage = string.Format(
                         CultureInfo.CurrentCulture,
                         WebCmdletStrings.RetryVerboseMsg,
@@ -1389,7 +1436,7 @@ private static Uri CheckProtocol(Uri uri)
         }
 
         private string QualifyFilePath(string path) => PathUtils.ResolveFilePath(filePath: path, command: this, isLiteralPath: true);
-        
+
         private static string FormatDictionary(IDictionary content)
         {
             ArgumentNullException.ThrowIfNull(content);
@@ -1486,7 +1533,7 @@ internal void SetRequestContent(HttpRequestMessage request, string content)
         {
             ArgumentNullException.ThrowIfNull(request);
             ArgumentNullException.ThrowIfNull(content);
-            
+
             Encoding encoding = null;
             if (ContentType is not null)
             {
@@ -1566,7 +1613,7 @@ internal void SetRequestContent(HttpRequestMessage request, MultipartFormDataCon
         {
             ArgumentNullException.ThrowIfNull(request);
             ArgumentNullException.ThrowIfNull(multipartContent);
-            
+
             // Content headers will be set by MultipartFormDataContent which will throw unless we clear them first
             WebSession.ContentHeaders.Clear();
 
@@ -1681,7 +1728,6 @@ private void AddMultipartContent(object fieldName, object fieldValue, MultipartF
         private static StringContent GetMultipartStringContent(object fieldName, object fieldValue)
         {
             ContentDispositionHeaderValue contentDisposition = new("form-data");
-
             // .NET does not enclose field names in quotes, however, modern browsers and curl do.
             contentDisposition.Name = "\"" + LanguagePrimitives.ConvertTo<string>(fieldName) + "\"";
 
@@ -1736,7 +1782,8 @@ private static string FormatErrorMessage(string error, string contentType)
                     XmlDocument doc = new();
                     doc.LoadXml(error);
 
-                    XmlWriterSettings settings = new XmlWriterSettings {
+                    XmlWriterSettings settings = new XmlWriterSettings
+                    {
                         Indent = true,
                         NewLineOnAttributes = true,
                         OmitXmlDeclaration = true
@@ -1767,7 +1814,6 @@ private static string FormatErrorMessage(string error, string contentType)
             {
                 // Ignore errors
             }
-
             if (string.IsNullOrEmpty(formattedError))
             {
                 // Remove HTML tags making it easier to read

src/Microsoft.PowerShell.Commands.Utility/commands/utility/WebCmdlet/CoreCLR/WebProxy.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.PowerShell.Commands
 {
-    internal class WebProxy : IWebProxy
+    internal class WebProxy : IWebProxy, IEquatable<WebProxy>
     {
         private ICredentials _credentials;
         private readonly Uri _proxyAddress;
@@ -18,6 +18,32 @@ internal WebProxy(Uri address)
             _proxyAddress = address;
         }
 
+        public override bool Equals(object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+            {
+                return false;
+            }
+
+            return Equals(obj as WebProxy);
+        }
+
+        public override int GetHashCode() => (_proxyAddress.GetHashCode() * 17) + (_credentials?.GetHashCode() ?? 0);
+
+        public bool Equals(WebProxy other)
+        {
+            if (other is null)
+            {
+                return false;
+            }
+
+            // _proxyAddress cannot be null as it is set in the constructor            
+            return GetHashCode() == other.GetHashCode() 
+                && other._credentials == _credentials
+                && _proxyAddress.Equals(other._proxyAddress)
+                && BypassProxyOnLocal == other.BypassProxyOnLocal;
+        }
+
         public ICredentials Credentials
         {
             get => _credentials;