fix SA1312 SA1306

tg123 · tg123 · commit 7baf350ca93c · 2020-10-07T03:42:04.000-07:00
diff --git a/src/KubernetesClient/Kubernetes.Watch.cs b/src/KubernetesClient/Kubernetes.Watch.cs
@@ -21,11 +21,11 @@ public async Task<Watcher<T>> WatchObjectAsync<T>(string path, string @continue
             CancellationToken cancellationToken = default(CancellationToken))
         {
             // Tracing
-            bool _shouldTrace = ServiceClientTracing.IsEnabled;
-            string _invocationId = null;
-            if (_shouldTrace)
+            bool shouldTrace = ServiceClientTracing.IsEnabled;
+            string invocationId = null;
+            if (shouldTrace)
             {
-                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
+                invocationId = ServiceClientTracing.NextInvocationId.ToString();
                 Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                 tracingParameters.Add("path", path);
                 tracingParameters.Add("continue", @continue);
@@ -36,7 +36,7 @@ public async Task<Watcher<T>> WatchObjectAsync<T>(string path, string @continue
                 tracingParameters.Add("pretty", pretty);
                 tracingParameters.Add("timeoutSeconds", timeoutSeconds);
                 tracingParameters.Add("resourceVersion", resourceVersion);
-                ServiceClientTracing.Enter(_invocationId, this, nameof(WatchObjectAsync), tracingParameters);
+                ServiceClientTracing.Enter(invocationId, this, nameof(WatchObjectAsync), tracingParameters);
             }
 
             // Construct URL
@@ -124,19 +124,19 @@ public async Task<Watcher<T>> WatchObjectAsync<T>(string path, string @continue
             }
 
             // Send Request
-            if (_shouldTrace)
+            if (shouldTrace)
             {
-                ServiceClientTracing.SendRequest(_invocationId, httpRequest);
+                ServiceClientTracing.SendRequest(invocationId, httpRequest);
             }
 
             cancellationToken.ThrowIfCancellationRequested();
             var httpResponse = await HttpClient
                 .SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
                 .ConfigureAwait(false);
 
-            if (_shouldTrace)
+            if (shouldTrace)
             {
-                ServiceClientTracing.ReceiveResponse(_invocationId, httpResponse);
+                ServiceClientTracing.ReceiveResponse(invocationId, httpResponse);
             }
 
             cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/KubernetesClient/Kubernetes.WebSocket.cs b/src/KubernetesClient/Kubernetes.WebSocket.cs
@@ -90,11 +90,11 @@ public virtual Task<WebSocket> WebSocketNamespacedPodExecAsync(string name, stri
             }
 
             // Tracing
-            bool _shouldTrace = ServiceClientTracing.IsEnabled;
-            string _invocationId = null;
-            if (_shouldTrace)
+            bool shouldTrace = ServiceClientTracing.IsEnabled;
+            string invocationId = null;
+            if (shouldTrace)
             {
-                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
+                invocationId = ServiceClientTracing.NextInvocationId.ToString();
                 Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                 tracingParameters.Add("command", command);
                 tracingParameters.Add("container", container);
@@ -106,7 +106,7 @@ public virtual Task<WebSocket> WebSocketNamespacedPodExecAsync(string name, stri
                 tracingParameters.Add("tty", tty);
                 tracingParameters.Add("webSocketSubProtol", webSocketSubProtol);
                 tracingParameters.Add("cancellationToken", cancellationToken);
-                ServiceClientTracing.Enter(_invocationId, this, nameof(WebSocketNamespacedPodExecAsync),
+                ServiceClientTracing.Enter(invocationId, this, nameof(WebSocketNamespacedPodExecAsync),
                     tracingParameters);
             }
 
@@ -143,7 +143,7 @@ public virtual Task<WebSocket> WebSocketNamespacedPodExecAsync(string name, stri
             uriBuilder.Query =
                 query.ToString(1, query.Length - 1); // UriBuilder.Query doesn't like leading '?' chars, so trim it
 
-            return this.StreamConnectAsync(uriBuilder.Uri, _invocationId, webSocketSubProtol, customHeaders,
+            return this.StreamConnectAsync(uriBuilder.Uri, invocationId, webSocketSubProtol, customHeaders,
                 cancellationToken);
         }
 
@@ -169,18 +169,18 @@ public Task<WebSocket> WebSocketNamespacedPodPortForwardAsync(string name, strin
             }
 
             // Tracing
-            bool _shouldTrace = ServiceClientTracing.IsEnabled;
-            string _invocationId = null;
-            if (_shouldTrace)
+            bool shouldTrace = ServiceClientTracing.IsEnabled;
+            string invocationId = null;
+            if (shouldTrace)
             {
-                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
+                invocationId = ServiceClientTracing.NextInvocationId.ToString();
                 Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                 tracingParameters.Add("name", name);
                 tracingParameters.Add("@namespace", @namespace);
                 tracingParameters.Add("ports", ports);
                 tracingParameters.Add("webSocketSubProtocol", webSocketSubProtocol);
                 tracingParameters.Add("cancellationToken", cancellationToken);
-                ServiceClientTracing.Enter(_invocationId, this, nameof(WebSocketNamespacedPodPortForwardAsync),
+                ServiceClientTracing.Enter(invocationId, this, nameof(WebSocketNamespacedPodPortForwardAsync),
                     tracingParameters);
             }
 
@@ -208,7 +208,7 @@ public Task<WebSocket> WebSocketNamespacedPodPortForwardAsync(string name, strin
 
             uriBuilder.Query = q.ToString();
 
-            return StreamConnectAsync(uriBuilder.Uri, _invocationId, webSocketSubProtocol, customHeaders,
+            return StreamConnectAsync(uriBuilder.Uri, invocationId, webSocketSubProtocol, customHeaders,
                 cancellationToken);
         }
 
@@ -229,11 +229,11 @@ public Task<WebSocket> WebSocketNamespacedPodAttachAsync(string name, string @na
             }
 
             // Tracing
-            bool _shouldTrace = ServiceClientTracing.IsEnabled;
-            string _invocationId = null;
-            if (_shouldTrace)
+            bool shouldTrace = ServiceClientTracing.IsEnabled;
+            string invocationId = null;
+            if (shouldTrace)
             {
-                _invocationId = ServiceClientTracing.NextInvocationId.ToString();
+                invocationId = ServiceClientTracing.NextInvocationId.ToString();
                 Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                 tracingParameters.Add("container", container);
                 tracingParameters.Add("name", name);
@@ -244,7 +244,7 @@ public Task<WebSocket> WebSocketNamespacedPodAttachAsync(string name, string @na
                 tracingParameters.Add("tty", tty);
                 tracingParameters.Add("webSocketSubProtol", webSocketSubProtol);
                 tracingParameters.Add("cancellationToken", cancellationToken);
-                ServiceClientTracing.Enter(_invocationId, this, nameof(WebSocketNamespacedPodAttachAsync),
+                ServiceClientTracing.Enter(invocationId, this, nameof(WebSocketNamespacedPodAttachAsync),
                     tracingParameters);
             }
 
@@ -268,25 +268,25 @@ public Task<WebSocket> WebSocketNamespacedPodAttachAsync(string name, string @na
             uriBuilder.Query =
                 query.ToString(1, query.Length - 1); // UriBuilder.Query doesn't like leading '?' chars, so trim it
 
-            return StreamConnectAsync(uriBuilder.Uri, _invocationId, webSocketSubProtol, customHeaders,
+            return StreamConnectAsync(uriBuilder.Uri, invocationId, webSocketSubProtol, customHeaders,
                 cancellationToken);
         }
 
         protected async Task<WebSocket> StreamConnectAsync(Uri uri, string invocationId = null,
             string webSocketSubProtocol = null, Dictionary<string, List<string>> customHeaders = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            bool _shouldTrace = ServiceClientTracing.IsEnabled;
+            bool shouldTrace = ServiceClientTracing.IsEnabled;
 
             // Create WebSocket transport objects
             WebSocketBuilder webSocketBuilder = this.CreateWebSocketBuilder();
 
             // Set Headers
             if (customHeaders != null)
             {
-                foreach (var _header in customHeaders)
+                foreach (var header in customHeaders)
                 {
-                    webSocketBuilder.SetRequestHeader(_header.Key, string.Join(" ", _header.Value));
+                    webSocketBuilder.SetRequestHeader(header.Key, string.Join(" ", header.Value));
                 }
             }
 
@@ -306,9 +306,9 @@ protected async Task<WebSocket> StreamConnectAsync(Uri uri, string invocationId
                 HttpRequestMessage message = new HttpRequestMessage();
                 await this.Credentials.ProcessHttpRequestAsync(message, cancellationToken).ConfigureAwait(false);
 
-                foreach (var _header in message.Headers)
+                foreach (var header in message.Headers)
                 {
-                    webSocketBuilder.SetRequestHeader(_header.Key, string.Join(" ", _header.Value));
+                    webSocketBuilder.SetRequestHeader(header.Key, string.Join(" ", header.Value));
                 }
             }
 
@@ -392,7 +392,7 @@ wse.InnerException is WebSocketException &&
             }
             catch (Exception ex)
             {
-                if (_shouldTrace)
+                if (shouldTrace)
                 {
                     ServiceClientTracing.Error(invocationId, ex);
                 }
@@ -401,7 +401,7 @@ wse.InnerException is WebSocketException &&
             }
             finally
             {
-                if (_shouldTrace)
+                if (shouldTrace)
                 {
                     ServiceClientTracing.Exit(invocationId, null);
                 }
diff --git a/src/KubernetesClient/KubernetesClientConfiguration.InCluster.cs b/src/KubernetesClient/KubernetesClientConfiguration.InCluster.cs
@@ -7,7 +7,7 @@ namespace k8s
 {
     public partial class KubernetesClientConfiguration
     {
-        private static string ServiceAccountPath =
+        private static string serviceAccountPath =
             Path.Combine(new string[]
             {
                 $"{Path.DirectorySeparatorChar}var", "run", "secrets", "kubernetes.io", "serviceaccount",
@@ -25,13 +25,13 @@ public static Boolean IsInCluster()
                 return false;
             }
 
-            var tokenPath = Path.Combine(ServiceAccountPath, ServiceAccountTokenKeyFileName);
+            var tokenPath = Path.Combine(serviceAccountPath, ServiceAccountTokenKeyFileName);
             if (!File.Exists(tokenPath))
             {
                 return false;
             }
 
-            var certPath = Path.Combine(ServiceAccountPath, ServiceAccountRootCAKeyFileName);
+            var certPath = Path.Combine(serviceAccountPath, ServiceAccountRootCAKeyFileName);
             return File.Exists(certPath);
         }
 
@@ -43,14 +43,14 @@ public static KubernetesClientConfiguration InClusterConfig()
                     "unable to load in-cluster configuration, KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT must be defined");
             }
 
-            var rootCAFile = Path.Combine(ServiceAccountPath, ServiceAccountRootCAKeyFileName);
+            var rootCAFile = Path.Combine(serviceAccountPath, ServiceAccountRootCAKeyFileName);
             var host = Environment.GetEnvironmentVariable("KUBERNETES_SERVICE_HOST");
             var port = Environment.GetEnvironmentVariable("KUBERNETES_SERVICE_PORT");
 
             return new KubernetesClientConfiguration
             {
                 Host = new UriBuilder("https", host, Convert.ToInt32(port)).ToString(),
-                TokenProvider = new TokenFileAuth(Path.Combine(ServiceAccountPath, ServiceAccountTokenKeyFileName)),
+                TokenProvider = new TokenFileAuth(Path.Combine(serviceAccountPath, ServiceAccountTokenKeyFileName)),
                 SslCaCerts = CertUtils.LoadPemFileCert(rootCAFile),
             };
         }
diff --git a/tests/KubernetesClient.Tests/WebSocketTestBase.cs b/tests/KubernetesClient.Tests/WebSocketTestBase.cs
@@ -24,7 +24,7 @@ public abstract class WebSocketTestBase : IDisposable
         /// <summary>
         ///     The next server port to use.
         /// </summary>
-        private static int NextPort = 13255;
+        private static int nextPort = 13255;
 
         private readonly ITestOutputHelper testOutput;
 
@@ -38,7 +38,7 @@ protected WebSocketTestBase(ITestOutputHelper testOutput)
         {
             this.testOutput = testOutput;
 
-            int port = Interlocked.Increment(ref NextPort);
+            int port = Interlocked.Increment(ref nextPort);
 
             // Useful to diagnose test timeouts.
             TestCancellation.Register(

Original file line number	Diff line number	Diff line change
`@@ -21,11 +21,11 @@ public async Task<Watcher<T>> WatchObjectAsync<T>(string path, string @continue`
`21`	`21`	`CancellationToken cancellationToken = default(CancellationToken))`
`22`	`22`	`{`
`23`	`23`	`// Tracing`
`24`		`- bool _shouldTrace = ServiceClientTracing.IsEnabled;`
`25`		`- string _invocationId = null;`
`26`		`- if (_shouldTrace)`
	`24`	`+ bool shouldTrace = ServiceClientTracing.IsEnabled;`
	`25`	`+ string invocationId = null;`
	`26`	`+ if (shouldTrace)`
`27`	`27`	`{`
`28`		`- _invocationId = ServiceClientTracing.NextInvocationId.ToString();`
	`28`	`+ invocationId = ServiceClientTracing.NextInvocationId.ToString();`
`29`	`29`	`Dictionary<string, object> tracingParameters = new Dictionary<string, object>();`
`30`	`30`	`tracingParameters.Add("path", path);`
`31`	`31`	`tracingParameters.Add("continue", @continue);`
`@@ -36,7 +36,7 @@ public async Task<Watcher<T>> WatchObjectAsync<T>(string path, string @continue`
`36`	`36`	`tracingParameters.Add("pretty", pretty);`
`37`	`37`	`tracingParameters.Add("timeoutSeconds", timeoutSeconds);`
`38`	`38`	`tracingParameters.Add("resourceVersion", resourceVersion);`
`39`		`- ServiceClientTracing.Enter(_invocationId, this, nameof(WatchObjectAsync), tracingParameters);`
	`39`	`+ ServiceClientTracing.Enter(invocationId, this, nameof(WatchObjectAsync), tracingParameters);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`// Construct URL`
`@@ -124,19 +124,19 @@ public async Task<Watcher<T>> WatchObjectAsync<T>(string path, string @continue`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`// Send Request`
`127`		`- if (_shouldTrace)`
	`127`	`+ if (shouldTrace)`
`128`	`128`	`{`
`129`		`- ServiceClientTracing.SendRequest(_invocationId, httpRequest);`
	`129`	`+ ServiceClientTracing.SendRequest(invocationId, httpRequest);`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`cancellationToken.ThrowIfCancellationRequested();`
`133`	`133`	`var httpResponse = await HttpClient`
`134`	`134`	`.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, cancellationToken)`
`135`	`135`	`.ConfigureAwait(false);`
`136`	`136`
`137`		`- if (_shouldTrace)`
	`137`	`+ if (shouldTrace)`
`138`	`138`	`{`
`139`		`- ServiceClientTracing.ReceiveResponse(_invocationId, httpResponse);`
	`139`	`+ ServiceClientTracing.ReceiveResponse(invocationId, httpResponse);`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`cancellationToken.ThrowIfCancellationRequested();`
Original file line number	Diff line number	Diff line change
`@@ -90,11 +90,11 @@ public virtual Task<WebSocket> WebSocketNamespacedPodExecAsync(string name, stri`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`// Tracing`
`93`		`- bool _shouldTrace = ServiceClientTracing.IsEnabled;`
`94`		`- string _invocationId = null;`
`95`		`- if (_shouldTrace)`
	`93`	`+ bool shouldTrace = ServiceClientTracing.IsEnabled;`
	`94`	`+ string invocationId = null;`
	`95`	`+ if (shouldTrace)`
`96`	`96`	`{`
`97`		`- _invocationId = ServiceClientTracing.NextInvocationId.ToString();`
	`97`	`+ invocationId = ServiceClientTracing.NextInvocationId.ToString();`
`98`	`98`	`Dictionary<string, object> tracingParameters = new Dictionary<string, object>();`
`99`	`99`	`tracingParameters.Add("command", command);`
`100`	`100`	`tracingParameters.Add("container", container);`
`@@ -106,7 +106,7 @@ public virtual Task<WebSocket> WebSocketNamespacedPodExecAsync(string name, stri`
`106`	`106`	`tracingParameters.Add("tty", tty);`
`107`	`107`	`tracingParameters.Add("webSocketSubProtol", webSocketSubProtol);`
`108`	`108`	`tracingParameters.Add("cancellationToken", cancellationToken);`
`109`		`- ServiceClientTracing.Enter(_invocationId, this, nameof(WebSocketNamespacedPodExecAsync),`
	`109`	`+ ServiceClientTracing.Enter(invocationId, this, nameof(WebSocketNamespacedPodExecAsync),`
`110`	`110`	`tracingParameters);`
`111`	`111`	`}`
`112`	`112`
`@@ -143,7 +143,7 @@ public virtual Task<WebSocket> WebSocketNamespacedPodExecAsync(string name, stri`
`143`	`143`	`uriBuilder.Query =`
`144`	`144`	`query.ToString(1, query.Length - 1); // UriBuilder.Query doesn't like leading '?' chars, so trim it`
`145`	`145`
`146`		`- return this.StreamConnectAsync(uriBuilder.Uri, _invocationId, webSocketSubProtol, customHeaders,`
	`146`	`+ return this.StreamConnectAsync(uriBuilder.Uri, invocationId, webSocketSubProtol, customHeaders,`
`147`	`147`	`cancellationToken);`
`148`	`148`	`}`
`149`	`149`
`@@ -169,18 +169,18 @@ public Task<WebSocket> WebSocketNamespacedPodPortForwardAsync(string name, strin`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`// Tracing`
`172`		`- bool _shouldTrace = ServiceClientTracing.IsEnabled;`
`173`		`- string _invocationId = null;`
`174`		`- if (_shouldTrace)`
	`172`	`+ bool shouldTrace = ServiceClientTracing.IsEnabled;`
	`173`	`+ string invocationId = null;`
	`174`	`+ if (shouldTrace)`
`175`	`175`	`{`
`176`		`- _invocationId = ServiceClientTracing.NextInvocationId.ToString();`
	`176`	`+ invocationId = ServiceClientTracing.NextInvocationId.ToString();`
`177`	`177`	`Dictionary<string, object> tracingParameters = new Dictionary<string, object>();`
`178`	`178`	`tracingParameters.Add("name", name);`
`179`	`179`	`tracingParameters.Add("@namespace", @namespace);`
`180`	`180`	`tracingParameters.Add("ports", ports);`
`181`	`181`	`tracingParameters.Add("webSocketSubProtocol", webSocketSubProtocol);`
`182`	`182`	`tracingParameters.Add("cancellationToken", cancellationToken);`
`183`		`- ServiceClientTracing.Enter(_invocationId, this, nameof(WebSocketNamespacedPodPortForwardAsync),`
	`183`	`+ ServiceClientTracing.Enter(invocationId, this, nameof(WebSocketNamespacedPodPortForwardAsync),`
`184`	`184`	`tracingParameters);`
`185`	`185`	`}`
`186`	`186`
`@@ -208,7 +208,7 @@ public Task<WebSocket> WebSocketNamespacedPodPortForwardAsync(string name, strin`
`208`	`208`
`209`	`209`	`uriBuilder.Query = q.ToString();`
`210`	`210`
`211`		`- return StreamConnectAsync(uriBuilder.Uri, _invocationId, webSocketSubProtocol, customHeaders,`
	`211`	`+ return StreamConnectAsync(uriBuilder.Uri, invocationId, webSocketSubProtocol, customHeaders,`
`212`	`212`	`cancellationToken);`
`213`	`213`	`}`
`214`	`214`
`@@ -229,11 +229,11 @@ public Task<WebSocket> WebSocketNamespacedPodAttachAsync(string name, string @na`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`// Tracing`
`232`		`- bool _shouldTrace = ServiceClientTracing.IsEnabled;`
`233`		`- string _invocationId = null;`
`234`		`- if (_shouldTrace)`
	`232`	`+ bool shouldTrace = ServiceClientTracing.IsEnabled;`
	`233`	`+ string invocationId = null;`
	`234`	`+ if (shouldTrace)`
`235`	`235`	`{`
`236`		`- _invocationId = ServiceClientTracing.NextInvocationId.ToString();`
	`236`	`+ invocationId = ServiceClientTracing.NextInvocationId.ToString();`
`237`	`237`	`Dictionary<string, object> tracingParameters = new Dictionary<string, object>();`
`238`	`238`	`tracingParameters.Add("container", container);`
`239`	`239`	`tracingParameters.Add("name", name);`
`@@ -244,7 +244,7 @@ public Task<WebSocket> WebSocketNamespacedPodAttachAsync(string name, string @na`
`244`	`244`	`tracingParameters.Add("tty", tty);`
`245`	`245`	`tracingParameters.Add("webSocketSubProtol", webSocketSubProtol);`
`246`	`246`	`tracingParameters.Add("cancellationToken", cancellationToken);`
`247`		`- ServiceClientTracing.Enter(_invocationId, this, nameof(WebSocketNamespacedPodAttachAsync),`
	`247`	`+ ServiceClientTracing.Enter(invocationId, this, nameof(WebSocketNamespacedPodAttachAsync),`
`248`	`248`	`tracingParameters);`
`249`	`249`	`}`
`250`	`250`
`@@ -268,25 +268,25 @@ public Task<WebSocket> WebSocketNamespacedPodAttachAsync(string name, string @na`
`268`	`268`	`uriBuilder.Query =`
`269`	`269`	`query.ToString(1, query.Length - 1); // UriBuilder.Query doesn't like leading '?' chars, so trim it`
`270`	`270`
`271`		`- return StreamConnectAsync(uriBuilder.Uri, _invocationId, webSocketSubProtol, customHeaders,`
	`271`	`+ return StreamConnectAsync(uriBuilder.Uri, invocationId, webSocketSubProtol, customHeaders,`
`272`	`272`	`cancellationToken);`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`protected async Task<WebSocket> StreamConnectAsync(Uri uri, string invocationId = null,`
`276`	`276`	`string webSocketSubProtocol = null, Dictionary<string, List<string>> customHeaders = null,`
`277`	`277`	`CancellationToken cancellationToken = default(CancellationToken))`
`278`	`278`	`{`
`279`		`- bool _shouldTrace = ServiceClientTracing.IsEnabled;`
	`279`	`+ bool shouldTrace = ServiceClientTracing.IsEnabled;`
`280`	`280`
`281`	`281`	`// Create WebSocket transport objects`
`282`	`282`	`WebSocketBuilder webSocketBuilder = this.CreateWebSocketBuilder();`
`283`	`283`
`284`	`284`	`// Set Headers`
`285`	`285`	`if (customHeaders != null)`
`286`	`286`	`{`
`287`		`- foreach (var _header in customHeaders)`
	`287`	`+ foreach (var header in customHeaders)`
`288`	`288`	`{`
`289`		`- webSocketBuilder.SetRequestHeader(_header.Key, string.Join(" ", _header.Value));`
	`289`	`+ webSocketBuilder.SetRequestHeader(header.Key, string.Join(" ", header.Value));`
`290`	`290`	`}`
`291`	`291`	`}`
`292`	`292`
`@@ -306,9 +306,9 @@ protected async Task<WebSocket> StreamConnectAsync(Uri uri, string invocationId`
`306`	`306`	`HttpRequestMessage message = new HttpRequestMessage();`
`307`	`307`	`await this.Credentials.ProcessHttpRequestAsync(message, cancellationToken).ConfigureAwait(false);`
`308`	`308`
`309`		`- foreach (var _header in message.Headers)`
	`309`	`+ foreach (var header in message.Headers)`
`310`	`310`	`{`
`311`		`- webSocketBuilder.SetRequestHeader(_header.Key, string.Join(" ", _header.Value));`
	`311`	`+ webSocketBuilder.SetRequestHeader(header.Key, string.Join(" ", header.Value));`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
`@@ -392,7 +392,7 @@ wse.InnerException is WebSocketException &&`
`392`	`392`	`}`
`393`	`393`	`catch (Exception ex)`
`394`	`394`	`{`
`395`		`- if (_shouldTrace)`
	`395`	`+ if (shouldTrace)`
`396`	`396`	`{`
`397`	`397`	`ServiceClientTracing.Error(invocationId, ex);`
`398`	`398`	`}`
`@@ -401,7 +401,7 @@ wse.InnerException is WebSocketException &&`
`401`	`401`	`}`
`402`	`402`	`finally`
`403`	`403`	`{`
`404`		`- if (_shouldTrace)`
	`404`	`+ if (shouldTrace)`
`405`	`405`	`{`
`406`	`406`	`ServiceClientTracing.Exit(invocationId, null);`
`407`	`407`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace k8s`
`7`	`7`	`{`
`8`	`8`	`public partial class KubernetesClientConfiguration`
`9`	`9`	`{`
`10`		`- private static string ServiceAccountPath =`
	`10`	`+ private static string serviceAccountPath =`
`11`	`11`	`Path.Combine(new string[]`
`12`	`12`	`{`
`13`	`13`	`$"{Path.DirectorySeparatorChar}var", "run", "secrets", "kubernetes.io", "serviceaccount",`
`@@ -25,13 +25,13 @@ public static Boolean IsInCluster()`
`25`	`25`	`return false;`
`26`	`26`	`}`
`27`	`27`
`28`		`- var tokenPath = Path.Combine(ServiceAccountPath, ServiceAccountTokenKeyFileName);`
	`28`	`+ var tokenPath = Path.Combine(serviceAccountPath, ServiceAccountTokenKeyFileName);`
`29`	`29`	`if (!File.Exists(tokenPath))`
`30`	`30`	`{`
`31`	`31`	`return false;`
`32`	`32`	`}`
`33`	`33`
`34`		`- var certPath = Path.Combine(ServiceAccountPath, ServiceAccountRootCAKeyFileName);`
	`34`	`+ var certPath = Path.Combine(serviceAccountPath, ServiceAccountRootCAKeyFileName);`
`35`	`35`	`return File.Exists(certPath);`
`36`	`36`	`}`
`37`	`37`
`@@ -43,14 +43,14 @@ public static KubernetesClientConfiguration InClusterConfig()`
`43`	`43`	`"unable to load in-cluster configuration, KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT must be defined");`
`44`	`44`	`}`
`45`	`45`
`46`		`- var rootCAFile = Path.Combine(ServiceAccountPath, ServiceAccountRootCAKeyFileName);`
	`46`	`+ var rootCAFile = Path.Combine(serviceAccountPath, ServiceAccountRootCAKeyFileName);`
`47`	`47`	`var host = Environment.GetEnvironmentVariable("KUBERNETES_SERVICE_HOST");`
`48`	`48`	`var port = Environment.GetEnvironmentVariable("KUBERNETES_SERVICE_PORT");`
`49`	`49`
`50`	`50`	`return new KubernetesClientConfiguration`
`51`	`51`	`{`
`52`	`52`	`Host = new UriBuilder("https", host, Convert.ToInt32(port)).ToString(),`
`53`		`- TokenProvider = new TokenFileAuth(Path.Combine(ServiceAccountPath, ServiceAccountTokenKeyFileName)),`
	`53`	`+ TokenProvider = new TokenFileAuth(Path.Combine(serviceAccountPath, ServiceAccountTokenKeyFileName)),`
`54`	`54`	`SslCaCerts = CertUtils.LoadPemFileCert(rootCAFile),`
`55`	`55`	`};`
`56`	`56`	`}`