add KubernetesClient.Aot to support Aot (#1498)

* init aot

* fix ca2007

* xUnit1031

* fix ca2007

* fix ca2007

* remove deprecated ctor

* fix xUnit1031

* fix missing doc

* fix missing dispose

* wait for warnings fix

* fix space

* move aot code to dedicated proj

* Remove commented out code

* eliminate know warnings

* add e2e test for aot

* rever on field convert annotation

* add e2e aot gh

* Add KubernetesClient.Aot project reference

* move CA1812 rule violation to file

.github/workflows/buildtest.yaml

@@ -80,7 +80,16 @@ jobs:
             cat skip.log
             echo "CASES MUST NOT BE SKIPPED"
             exit 1
-          fi
+          fi    
+      - name: AOT Test
+        run: |
+          true > skip.log
+          env K8S_E2E_MINIKUBE=1 dotnet test tests/E2E.Aot.Tests --logger "SkipTestLogger;file=$PWD/skip.log"
+          if [ -s skip.log ]; then
+            cat skip.log
+            echo "CASES MUST NOT BE SKIPPED"
+            exit 1
+          fi              
 
 on:
   pull_request:

examples/Directory.Build.targets

@@ -1,5 +1,5 @@
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <ProjectReference Include="$(MSBuildThisFileDirectory)\..\src\KubernetesClient\KubernetesClient.csproj" />
+    <ProjectReference Include="$(MSBuildThisFileDirectory)\..\src\KubernetesClient\KubernetesClient.csproj" Condition="'$(PublishAot)' != 'true'" />
   </ItemGroup>
 </Project>

examples/aot/Program.cs

@@ -0,0 +1,16 @@
+using k8s;
+
+var config = KubernetesClientConfiguration.BuildDefaultConfig();
+IKubernetes client = new Kubernetes(config);
+Console.WriteLine("Starting Request!");
+
+var list = client.CoreV1.ListNamespacedPod("default");
+foreach (var item in list.Items)
+{
+    Console.WriteLine(item.Metadata.Name);
+}
+
+if (list.Items.Count == 0)
+{
+    Console.WriteLine("Empty!");
+}

examples/aot/aot.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <PublishAot>true</PublishAot>
+    </PropertyGroup>
+    <ItemGroup>
+        <ProjectReference Include="..\..\src\KubernetesClient.Aot\KubernetesClient.Aot.csproj"/>
+      </ItemGroup>
+</Project>

src/KubernetesClient.Aot/Global.cs

@@ -0,0 +1,10 @@
+global using k8s.Autorest;
+global using k8s.Models;
+global using System;
+global using System.Collections.Generic;
+global using System.IO;
+global using System.Linq;
+global using System.Text.Json;
+global using System.Text.Json.Serialization;
+global using System.Threading;
+global using System.Threading.Tasks;

src/KubernetesClient.Aot/KubeConfigModels/AuthProvider.cs

@@ -0,0 +1,23 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// Contains information that describes identity information.  This is use to tell the kubernetes cluster who you are.
+    /// </summary>
+    [YamlSerializable]
+    public class AuthProvider
+    {
+        /// <summary>
+        /// Gets or sets the nickname for this auth provider.
+        /// </summary>
+        [YamlMember(Alias = "name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the configuration for this auth provider
+        /// </summary>
+        [YamlMember(Alias = "config")]
+        public Dictionary<string, string> Config { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/Cluster.cs

@@ -0,0 +1,23 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// Relates nicknames to cluster information.
+    /// </summary>
+    [YamlSerializable]
+    public class Cluster
+    {
+        /// <summary>
+        /// Gets or sets the cluster information.
+        /// </summary>
+        [YamlMember(Alias = "cluster")]
+        public ClusterEndpoint ClusterEndpoint { get; set; }
+
+        /// <summary>
+        /// Gets or sets the nickname for this Cluster.
+        /// </summary>
+        [YamlMember(Alias = "name")]
+        public string Name { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/ClusterEndpoint.cs

@@ -0,0 +1,42 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// Contains information about how to communicate with a kubernetes cluster
+    /// </summary>
+    [YamlSerializable]
+    public class ClusterEndpoint
+    {
+        /// <summary>
+        /// Gets or sets the path to a cert file for the certificate authority.
+        /// </summary>
+        [YamlMember(Alias = "certificate-authority", ApplyNamingConventions = false)]
+        public string CertificateAuthority { get; set; }
+
+        /// <summary>
+        /// Gets or sets =PEM-encoded certificate authority certificates. Overrides <see cref="CertificateAuthority"/>.
+        /// </summary>
+        [YamlMember(Alias = "certificate-authority-data", ApplyNamingConventions = false)]
+        public string CertificateAuthorityData { get; set; }
+
+        /// <summary>
+        /// Gets or sets the address of the kubernetes cluster (https://hostname:port).
+        /// </summary>
+        [YamlMember(Alias = "server")]
+        public string Server { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value to override the TLS server name.
+        /// </summary>
+        [YamlMember(Alias = "tls-server-name", ApplyNamingConventions = false)]
+        public string TlsServerName { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to skip the validity check for the server's certificate.
+        /// This will make your HTTPS connections insecure.
+        /// </summary>
+        [YamlMember(Alias = "insecure-skip-tls-verify", ApplyNamingConventions = false)]
+        public bool SkipTlsVerify { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/Context.cs

@@ -0,0 +1,23 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// Relates nicknames to context information.
+    /// </summary>
+    [YamlSerializable]
+    public class Context
+    {
+        /// <summary>
+        /// Gets or sets the context information.
+        /// </summary>
+        [YamlMember(Alias = "context")]
+        public ContextDetails ContextDetails { get; set; }
+
+        /// <summary>
+        /// Gets or sets the nickname for this context.
+        /// </summary>
+        [YamlMember(Alias = "name")]
+        public string Name { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/ContextDetails.cs

@@ -0,0 +1,30 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// Represents a tuple of references to a cluster (how do I communicate with a kubernetes cluster),
+    /// a user (how do I identify myself), and a namespace (what subset of resources do I want to work with)
+    /// </summary>
+    [YamlSerializable]
+    public class ContextDetails
+    {
+        /// <summary>
+        /// Gets or sets the name of the cluster for this context.
+        /// </summary>
+        [YamlMember(Alias = "cluster")]
+        public string Cluster { get; set; }
+
+        /// <summary>
+        /// Gets or sets the name of the user for this context.
+        /// </summary>
+        [YamlMember(Alias = "user")]
+        public string User { get; set; }
+
+        /// <summary>
+        /// /Gets or sets the default namespace to use on unspecified requests.
+        /// </summary>
+        [YamlMember(Alias = "namespace")]
+        public string Namespace { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/ExecCredentialResponse.cs

@@ -0,0 +1,31 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    [YamlSerializable]
+    public class ExecCredentialResponse
+    {
+        public class ExecStatus
+        {
+#nullable enable
+            public DateTime? ExpirationTimestamp { get; set; }
+            public string? Token { get; set; }
+            public string? ClientCertificateData { get; set; }
+            public string? ClientKeyData { get; set; }
+#nullable disable
+
+            public bool IsValid()
+            {
+                return !string.IsNullOrEmpty(Token) ||
+                        (!string.IsNullOrEmpty(ClientCertificateData) && !string.IsNullOrEmpty(ClientKeyData));
+            }
+        }
+
+        [JsonPropertyName("apiVersion")]
+        public string ApiVersion { get; set; }
+        [JsonPropertyName("kind")]
+        public string Kind { get; set; }
+        [JsonPropertyName("status")]
+        public ExecStatus Status { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/ExternalExecution.cs

@@ -0,0 +1,42 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    [YamlSerializable]
+    public class ExternalExecution
+    {
+        [YamlMember(Alias = "apiVersion")]
+        public string ApiVersion { get; set; }
+
+        /// <summary>
+        /// The command to execute. Required.
+        /// </summary>
+        [YamlMember(Alias = "command")]
+        public string Command { get; set; }
+
+        /// <summary>
+        /// Environment variables to set when executing the plugin. Optional.
+        /// </summary>
+        [YamlMember(Alias = "env")]
+        public IList<Dictionary<string, string>> EnvironmentVariables { get; set; }
+
+        /// <summary>
+        /// Arguments to pass when executing the plugin. Optional.
+        /// </summary>
+        [YamlMember(Alias = "args")]
+        public IList<string> Arguments { get; set; }
+
+        /// <summary>
+        /// Text shown to the user when the executable doesn't seem to be present. Optional.
+        /// </summary>
+        [YamlMember(Alias = "installHint")]
+        public string InstallHint { get; set; }
+
+        /// <summary>
+        /// Whether or not to provide cluster information to this exec plugin as a part of
+        /// the KUBERNETES_EXEC_INFO environment variable. Optional.
+        /// </summary>
+        [YamlMember(Alias = "provideClusterInfo")]
+        public bool ProvideClusterInfo { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/K8SConfiguration.cs

@@ -0,0 +1,65 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// kubeconfig configuration model. Holds the information needed to build connect to remote
+    /// Kubernetes clusters as a given user.
+    /// </summary>
+    /// <remarks>
+    /// Should be kept in sync with https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/client-go/tools/clientcmd/api/v1/types.go
+    /// Should update MergeKubeConfig in KubernetesClientConfiguration.ConfigFile.cs if updated.
+    /// </remarks>
+    [YamlSerializable]
+    public class K8SConfiguration
+    {
+        // /// <summary>
+        // /// Gets or sets general information to be use for CLI interactions
+        // /// </summary>
+        // [YamlMember(Alias = "preferences")]
+        // public IDictionary<string, object> Preferences { get; set; }
+
+        [YamlMember(Alias = "apiVersion")]
+        public string ApiVersion { get; set; }
+
+        [YamlMember(Alias = "kind")]
+        public string Kind { get; set; }
+
+        /// <summary>
+        /// Gets or sets the name of the context that you would like to use by default.
+        /// </summary>
+        [YamlMember(Alias = "current-context", ApplyNamingConventions = false)]
+        public string CurrentContext { get; set; }
+
+        /// <summary>
+        /// Gets or sets a map of referencable names to context configs.
+        /// </summary>
+        [YamlMember(Alias = "contexts")]
+        public List<Context> Contexts { get; set; } = new List<Context>();
+
+        /// <summary>
+        /// Gets or sets a map of referencable names to cluster configs.
+        /// </summary>
+        [YamlMember(Alias = "clusters")]
+        public List<Cluster> Clusters { get; set; } = new List<Cluster>();
+
+        /// <summary>
+        /// Gets or sets a map of referencable names to user configs
+        /// </summary>
+        [YamlMember(Alias = "users")]
+        public List<User> Users { get; set; } = new List<User>();
+
+        // /// <summary>
+        // /// Gets or sets additional information. This is useful for extenders so that reads and writes don't clobber unknown fields.
+        // /// </summary>
+        // [YamlMember(Alias = "extensions")]
+        // public List<NamedExtension> Extensions { get; set; }
+
+        /// <summary>
+        /// Gets or sets the name of the Kubernetes configuration file. This property is set only when the configuration
+        /// was loaded from disk, and can be used to resolve relative paths.
+        /// </summary>
+        [YamlIgnore]
+        public string FileName { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/StaticContext.cs

@@ -0,0 +1,8 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels;
+
+[YamlStaticContext]
+public partial class StaticContext : YamlDotNet.Serialization.StaticContext
+{
+}

src/KubernetesClient.Aot/KubeConfigModels/User.cs

@@ -0,0 +1,23 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// Relates nicknames to auth information.
+    /// </summary>
+    [YamlSerializable]
+    public class User
+    {
+        /// <summary>
+        /// Gets or sets the auth information.
+        /// </summary>
+        [YamlMember(Alias = "user")]
+        public UserCredentials UserCredentials { get; set; }
+
+        /// <summary>
+        /// Gets or sets the nickname for this auth information.
+        /// </summary>
+        [YamlMember(Alias = "name")]
+        public string Name { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubeConfigModels/UserCredentials.cs

@@ -0,0 +1,83 @@
+using YamlDotNet.Serialization;
+
+namespace k8s.KubeConfigModels
+{
+    /// <summary>
+    /// Contains information that describes identity information.  This is use to tell the kubernetes cluster who you are.
+    /// </summary>
+    [YamlSerializable]
+    public class UserCredentials
+    {
+        /// <summary>
+        /// Gets or sets PEM-encoded data from a client cert file for TLS. Overrides <see cref="ClientCertificate"/>.
+        /// </summary>
+        [YamlMember(Alias = "client-certificate-data", ApplyNamingConventions = false)]
+        public string ClientCertificateData { get; set; }
+
+        /// <summary>
+        /// Gets or sets the path to a client cert file for TLS.
+        /// </summary>
+        [YamlMember(Alias = "client-certificate", ApplyNamingConventions = false)]
+        public string ClientCertificate { get; set; }
+
+        /// <summary>
+        /// Gets or sets PEM-encoded data from a client key file for TLS. Overrides <see cref="ClientKey"/>.
+        /// </summary>
+        [YamlMember(Alias = "client-key-data", ApplyNamingConventions = false)]
+        public string ClientKeyData { get; set; }
+
+        /// <summary>
+        /// Gets or sets the path to a client key file for TLS.
+        /// </summary>
+        [YamlMember(Alias = "client-key", ApplyNamingConventions = false)]
+        public string ClientKey { get; set; }
+
+        /// <summary>
+        /// Gets or sets the bearer token for authentication to the kubernetes cluster.
+        /// </summary>
+        [YamlMember(Alias = "token")]
+        public string Token { get; set; }
+
+        /// <summary>
+        /// Gets or sets the username to impersonate. The name matches the flag.
+        /// </summary>
+        [YamlMember(Alias = "as")]
+        public string Impersonate { get; set; }
+
+        /// <summary>
+        /// Gets or sets the groups to impersonate.
+        /// </summary>
+        [YamlMember(Alias = "as-groups", ApplyNamingConventions = false)]
+        public IEnumerable<string> ImpersonateGroups { get; set; } = new string[0];
+
+        /// <summary>
+        /// Gets or sets additional information for impersonated user.
+        /// </summary>
+        [YamlMember(Alias = "as-user-extra", ApplyNamingConventions = false)]
+        public Dictionary<string, string> ImpersonateUserExtra { get; set; } = new Dictionary<string, string>();
+
+        /// <summary>
+        /// Gets or sets the username for basic authentication to the kubernetes cluster.
+        /// </summary>
+        [YamlMember(Alias = "username")]
+        public string UserName { get; set; }
+
+        /// <summary>
+        /// Gets or sets the password for basic authentication to the kubernetes cluster.
+        /// </summary>
+        [YamlMember(Alias = "password")]
+        public string Password { get; set; }
+
+        /// <summary>
+        /// Gets or sets custom authentication plugin for the kubernetes cluster.
+        /// </summary>
+        [YamlMember(Alias = "auth-provider", ApplyNamingConventions = false)]
+        public AuthProvider AuthProvider { get; set; }
+
+        /// <summary>
+        /// Gets or sets external command and its arguments to receive user credentials
+        /// </summary>
+        [YamlMember(Alias = "exec")]
+        public ExternalExecution ExternalExecution { get; set; }
+    }
+}

src/KubernetesClient.Aot/KubernetesClient.Aot.csproj

@@ -0,0 +1,111 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net8.0</TargetFrameworks>
+    <RootNamespace>k8s</RootNamespace>
+    <PublishAot>true</PublishAot>
+    <IsAotCompatible>true</IsAotCompatible>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Fractions" Version="7.3.0" />
+    <PackageReference Include="YamlDotNet" Version="13.7.1" />
+    <PackageReference Include="Vecc.YamlDotNet.Analyzers.StaticGenerator" Version="13.7.0" ReferenceOutputAssembly="false"  />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\KubernetesClient\Models\ContainerMetrics.cs" />
+    <Compile Include="..\KubernetesClient\Extensions.cs" />
+    <Compile Include="..\KubernetesClient\FloatEmitter.cs" />
+    <Compile Include="..\KubernetesClient\Models\GeneratedModelVersion.cs" />
+    <Compile Include="..\KubernetesClient\IItems.cs" />
+    <Compile Include="..\KubernetesClient\IKubernetesObject.cs" />
+    <Compile Include="..\KubernetesClient\IMetadata.cs" />
+    <Compile Include="..\KubernetesClient\Models\IntOrStringJsonConverter.cs" />
+    <Compile Include="..\KubernetesClient\Models\IntOrStringYamlConverter.cs" />
+    <Compile Include="..\KubernetesClient\Models\IntstrIntOrString.cs" />
+    <Compile Include="..\KubernetesClient\ISpec.cs" />
+    <Compile Include="..\KubernetesClient\IStatus.cs" />
+    <Compile Include="..\KubernetesClient\IValidate.cs" />
+    <Compile Include="..\KubernetesClient\Models\KubernetesEntityAttribute.cs" />
+    <Compile Include="..\KubernetesClient\Models\KubernetesList.cs" />
+    <Compile Include="..\KubernetesClient\KubernetesObject.cs" />
+    <Compile Include="..\KubernetesClient\Models\ModelExtensions.cs" />
+    <Compile Include="..\KubernetesClient\Models\ModelVersionConverter.cs" />
+    <Compile Include="..\KubernetesClient\Models\NodeMetrics.cs" />
+    <Compile Include="..\KubernetesClient\Models\NodeMetricsList.cs" />
+    <Compile Include="..\KubernetesClient\Models\PodMetrics.cs" />
+    <Compile Include="..\KubernetesClient\Models\PodMetricsList.cs" />
+    <Compile Include="..\KubernetesClient\Models\ResourceQuantity.cs" />
+    <Compile Include="..\KubernetesClient\Models\ResourceQuantityJsonConverter.cs" />
+    <Compile Include="..\KubernetesClient\Models\ResourceQuantityYamlConverter.cs" />
+    <Compile Include="..\KubernetesClient\StringQuotingEmitter.cs" />
+    <Compile Include="..\KubernetesClient\Models\V1Patch.cs" />
+    <Compile Include="..\KubernetesClient\Models\V1PodTemplateSpec.cs" />
+    <Compile Include="..\KubernetesClient\Models\V1Status.cs" />
+
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\KubernetesClient\AbstractKubernetes.cs" />
+    <Compile Include="..\KubernetesClient\GeneratedApiVersion.cs" />
+
+    <Compile Include="..\KubernetesClient\Autorest\HttpExtensions.cs" />
+    <Compile Include="..\KubernetesClient\Autorest\HttpMessageWrapper.cs" />
+    <Compile Include="..\KubernetesClient\Autorest\HttpOperationException.cs" />
+    <Compile Include="..\KubernetesClient\Autorest\HttpOperationResponse.cs" />
+    <Compile Include="..\KubernetesClient\Autorest\HttpRequestMessageWrapper.cs" />
+    <Compile Include="..\KubernetesClient\Autorest\HttpResponseMessageWrapper.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\KubernetesClient\CertUtils.cs" />
+
+    <Compile Include="..\KubernetesClient\FileSystem.cs" />
+    <Compile Include="..\KubernetesClient\IKubernetes.cs" />
+    <Compile Include="..\KubernetesClient\Kubernetes.ConfigInit.cs" />
+    <Compile Include="..\KubernetesClient\Kubernetes.cs" />
+    <Compile Include="..\KubernetesClient\KubernetesClientConfiguration.InCluster.cs" />
+    <Compile Include="..\KubernetesClient\KubernetesClientConfiguration.cs" />
+    <Compile Include="..\KubernetesClient\KubernetesException.cs" />
+
+    <Compile Include="..\KubernetesClient\ChannelIndex.cs" />
+    <Compile Include="..\KubernetesClient\IStreamDemuxer.cs" />
+    <Compile Include="..\KubernetesClient\ByteBuffer.cs" />
+    <Compile Include="..\KubernetesClient\StreamDemuxer.cs" />
+    <Compile Include="..\KubernetesClient\MuxedStream.cs" />
+    <Compile Include="..\KubernetesClient\StreamType.cs" />
+    <Compile Include="..\KubernetesClient\IKubernetes.WebSocket.cs" />
+    <Compile Include="..\KubernetesClient\Kubernetes.WebSocket.cs" />
+    <Compile Include="..\KubernetesClient\WebSocketBuilder.cs" />
+    <Compile Include="..\KubernetesClient\WebSocketProtocol.cs" />
+    <Compile Include="..\KubernetesClient\Utilities.cs" />
+    <Compile Include="..\KubernetesClient\ExecAsyncCallback.cs" />
+    <Compile Include="..\KubernetesClient\IKubernetes.Exec.cs" />
+    <Compile Include="..\KubernetesClient\Kubernetes.Exec.cs" />
+
+    <!-- <Compile Include="..\KubernetesClient\Watcher.cs" /> -->
+    <!-- <Compile Include="..\KubernetesClient\WatcherExt.cs" /> -->
+    <Compile Include="..\KubernetesClient\LineSeparatedHttpContent.cs" />
+
+    <Compile Include="..\KubernetesClient\Exceptions\KubeConfigException.cs" />
+    <Compile Include="..\KubernetesClient\Exceptions\KubernetesClientException.cs" />
+
+    <Compile Include="..\KubernetesClient\Authentication\ExecTokenProvider.cs" />
+    <Compile Include="..\KubernetesClient\Authentication\TokenFileAuth.cs" />
+    <Compile Include="..\KubernetesClient\Authentication\BasicAuthenticationCredentials.cs" />
+    <Compile Include="..\KubernetesClient\Authentication\ITokenProvider.cs" />
+    <Compile Include="..\KubernetesClient\Authentication\ServiceClientCredentials.cs" />
+    <Compile Include="..\KubernetesClient\Authentication\StringTokenProvider.cs" />
+    <Compile Include="..\KubernetesClient\Authentication\TokenCredentials.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="System.Net.Http" Condition="'$(TargetFramework)' == 'net48'" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LibKubernetesGenerator\generators\LibKubernetesGenerator\LibKubernetesGenerator.csproj"
+      OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+  </ItemGroup>
+</Project>

src/KubernetesClient.Aot/KubernetesClientConfiguration.ConfigFile.cs

@@ -0,0 +1,760 @@
+using k8s.Authentication;
+using k8s.Exceptions;
+using k8s.KubeConfigModels;
+using System.Diagnostics;
+using System.Net;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography.X509Certificates;
+
+namespace k8s
+{
+    public partial class KubernetesClientConfiguration
+    {
+        /// <summary>
+        ///     kubeconfig Default Location
+        /// </summary>
+        public static readonly string KubeConfigDefaultLocation =
+            RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                ? Path.Combine(Environment.GetEnvironmentVariable("USERPROFILE") ?? @"\", @".kube\config")
+                : Path.Combine(Environment.GetEnvironmentVariable("HOME") ?? "/", ".kube/config");
+
+        /// <summary>
+        ///     Gets CurrentContext
+        /// </summary>
+        public string CurrentContext { get; private set; }
+
+        // For testing
+        internal static string KubeConfigEnvironmentVariable { get; set; } = "KUBECONFIG";
+
+        /// <summary>
+        ///     Exec process timeout
+        /// </summary>
+        public static TimeSpan ExecTimeout { get; set; } = TimeSpan.FromMinutes(2);
+
+        /// <summary>
+        ///     Exec process Standard Errors
+        /// </summary>
+        public static event EventHandler<DataReceivedEventArgs> ExecStdError;
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="KubernetesClientConfiguration" /> from default locations
+        ///     If the KUBECONFIG environment variable is set, then that will be used.
+        ///     Next, it looks for a config file at <see cref="KubeConfigDefaultLocation"/>.
+        ///     Then, it checks whether it is executing inside a cluster and will use <see cref="InClusterConfig()" />.
+        ///     Finally, if nothing else exists, it creates a default config with localhost:8080 as host.
+        /// </summary>
+        /// <remarks>
+        ///     If multiple kubeconfig files are specified in the KUBECONFIG environment variable,
+        ///     merges the files, where first occurrence wins. See https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#merging-kubeconfig-files.
+        /// </remarks>
+        /// <returns>Instance of the<see cref="KubernetesClientConfiguration"/> class</returns>
+        public static KubernetesClientConfiguration BuildDefaultConfig()
+        {
+            var kubeconfig = Environment.GetEnvironmentVariable(KubeConfigEnvironmentVariable);
+            if (kubeconfig != null)
+            {
+                var configList = kubeconfig.Split(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ';' : ':')
+                    .Select((s) => new FileInfo(s.Trim('"')));
+                var k8sConfig = LoadKubeConfig(configList.ToArray());
+                return BuildConfigFromConfigObject(k8sConfig);
+            }
+
+            if (File.Exists(KubeConfigDefaultLocation))
+            {
+                return BuildConfigFromConfigFile(KubeConfigDefaultLocation);
+            }
+
+            if (IsInCluster())
+            {
+                return InClusterConfig();
+            }
+
+            var config = new KubernetesClientConfiguration
+            {
+                Host = "http://localhost:8080",
+            };
+
+            return config;
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="KubernetesClientConfiguration" /> from config file
+        /// </summary>
+        /// <param name="kubeconfigPath">Explicit file path to kubeconfig. Set to null to use the default file path</param>
+        /// <param name="currentContext">override the context in config file, set null if do not want to override</param>
+        /// <param name="masterUrl">kube api server endpoint</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the<see cref="KubernetesClientConfiguration"/> class</returns>
+        public static KubernetesClientConfiguration BuildConfigFromConfigFile(
+            string kubeconfigPath = null,
+            string currentContext = null, string masterUrl = null, bool useRelativePaths = true)
+        {
+            return BuildConfigFromConfigFile(new FileInfo(kubeconfigPath ?? KubeConfigDefaultLocation), currentContext,
+                masterUrl, useRelativePaths);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KubernetesClientConfiguration" /> from config file
+        /// </summary>
+        /// <param name="kubeconfig">Fileinfo of the kubeconfig, cannot be null</param>
+        /// <param name="currentContext">override the context in config file, set null if do not want to override</param>
+        /// <param name="masterUrl">override the kube api server endpoint, set null if do not want to override</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the<see cref="KubernetesClientConfiguration"/> class</returns>
+        public static KubernetesClientConfiguration BuildConfigFromConfigFile(
+            FileInfo kubeconfig,
+            string currentContext = null, string masterUrl = null, bool useRelativePaths = true)
+        {
+            return BuildConfigFromConfigFileAsync(kubeconfig, currentContext, masterUrl, useRelativePaths).GetAwaiter()
+                .GetResult();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KubernetesClientConfiguration" /> from config file
+        /// </summary>
+        /// <param name="kubeconfig">Fileinfo of the kubeconfig, cannot be null</param>
+        /// <param name="currentContext">override the context in config file, set null if do not want to override</param>
+        /// <param name="masterUrl">override the kube api server endpoint, set null if do not want to override</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the<see cref="KubernetesClientConfiguration"/> class</returns>
+        public static async Task<KubernetesClientConfiguration> BuildConfigFromConfigFileAsync(
+            FileInfo kubeconfig,
+            string currentContext = null, string masterUrl = null, bool useRelativePaths = true)
+        {
+            if (kubeconfig == null)
+            {
+                throw new NullReferenceException(nameof(kubeconfig));
+            }
+
+            var k8SConfig = await LoadKubeConfigAsync(kubeconfig, useRelativePaths).ConfigureAwait(false);
+            var k8SConfiguration = GetKubernetesClientConfiguration(currentContext, masterUrl, k8SConfig);
+
+            return k8SConfiguration;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KubernetesClientConfiguration" /> from config file
+        /// </summary>
+        /// <param name="kubeconfig">Stream of the kubeconfig, cannot be null</param>
+        /// <param name="currentContext">Override the current context in config, set null if do not want to override</param>
+        /// <param name="masterUrl">Override the Kubernetes API server endpoint, set null if do not want to override</param>
+        /// <returns>Instance of the<see cref="KubernetesClientConfiguration"/> class</returns>
+        public static KubernetesClientConfiguration BuildConfigFromConfigFile(
+            Stream kubeconfig,
+            string currentContext = null, string masterUrl = null)
+        {
+            return BuildConfigFromConfigFileAsync(kubeconfig, currentContext, masterUrl).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KubernetesClientConfiguration" /> from config file
+        /// </summary>
+        /// <param name="kubeconfig">Stream of the kubeconfig, cannot be null</param>
+        /// <param name="currentContext">Override the current context in config, set null if do not want to override</param>
+        /// <param name="masterUrl">Override the Kubernetes API server endpoint, set null if do not want to override</param>
+        /// <returns>Instance of the<see cref="KubernetesClientConfiguration"/> class</returns>
+        public static async Task<KubernetesClientConfiguration> BuildConfigFromConfigFileAsync(
+            Stream kubeconfig,
+            string currentContext = null, string masterUrl = null)
+        {
+            if (kubeconfig == null)
+            {
+                throw new NullReferenceException(nameof(kubeconfig));
+            }
+
+            if (!kubeconfig.CanSeek)
+            {
+                throw new Exception("Stream don't support seeking!");
+            }
+
+            kubeconfig.Position = 0;
+
+            var k8SConfig = await KubernetesYaml.LoadFromStreamAsync<K8SConfiguration>(kubeconfig).ConfigureAwait(false);
+            var k8SConfiguration = GetKubernetesClientConfiguration(currentContext, masterUrl, k8SConfig);
+
+            return k8SConfiguration;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="KubernetesClientConfiguration"/> from pre-loaded config object.
+        /// </summary>
+        /// <param name="k8SConfig">A <see cref="K8SConfiguration"/>, for example loaded from <see cref="LoadKubeConfigAsync(string, bool)" /></param>
+        /// <param name="currentContext">Override the current context in config, set null if do not want to override</param>
+        /// <param name="masterUrl">Override the Kubernetes API server endpoint, set null if do not want to override</param>
+        /// <returns>Instance of the<see cref="KubernetesClientConfiguration"/> class</returns>
+        public static KubernetesClientConfiguration BuildConfigFromConfigObject(
+            K8SConfiguration k8SConfig,
+            string currentContext = null, string masterUrl = null)
+            => GetKubernetesClientConfiguration(currentContext, masterUrl, k8SConfig);
+
+        private static KubernetesClientConfiguration GetKubernetesClientConfiguration(
+            string currentContext,
+            string masterUrl, K8SConfiguration k8SConfig)
+        {
+            if (k8SConfig == null)
+            {
+                throw new ArgumentNullException(nameof(k8SConfig));
+            }
+
+            var k8SConfiguration = new KubernetesClientConfiguration();
+
+            currentContext = currentContext ?? k8SConfig.CurrentContext;
+            // only init context if context is set
+            if (currentContext != null)
+            {
+                k8SConfiguration.InitializeContext(k8SConfig, currentContext);
+            }
+
+            if (!string.IsNullOrWhiteSpace(masterUrl))
+            {
+                k8SConfiguration.Host = masterUrl;
+            }
+
+            if (string.IsNullOrWhiteSpace(k8SConfiguration.Host))
+            {
+                throw new KubeConfigException("Cannot infer server host url either from context or masterUrl");
+            }
+
+            return k8SConfiguration;
+        }
+
+        /// <summary>
+        ///     Validates and Initializes Client Configuration
+        /// </summary>
+        /// <param name="k8SConfig">Kubernetes Configuration</param>
+        /// <param name="currentContext">Current Context</param>
+        private void InitializeContext(K8SConfiguration k8SConfig, string currentContext)
+        {
+            // current context
+            var activeContext =
+                k8SConfig.Contexts.FirstOrDefault(
+                    c => c.Name.Equals(currentContext, StringComparison.OrdinalIgnoreCase));
+            if (activeContext == null)
+            {
+                throw new KubeConfigException($"CurrentContext: {currentContext} not found in contexts in kubeconfig");
+            }
+
+            if (string.IsNullOrEmpty(activeContext.ContextDetails?.Cluster))
+            {
+                // This serves as validation for any of the properties of ContextDetails being set.
+                // Other locations in code assume that ContextDetails is non-null.
+                throw new KubeConfigException($"Cluster not set for context `{currentContext}` in kubeconfig");
+            }
+
+            CurrentContext = activeContext.Name;
+
+            // cluster
+            SetClusterDetails(k8SConfig, activeContext);
+
+            // user
+            SetUserDetails(k8SConfig, activeContext);
+
+            // namespace
+            Namespace = activeContext.ContextDetails?.Namespace;
+        }
+
+        private void SetClusterDetails(K8SConfiguration k8SConfig, Context activeContext)
+        {
+            var clusterDetails =
+                k8SConfig.Clusters.FirstOrDefault(c => c.Name.Equals(
+                    activeContext.ContextDetails.Cluster,
+                    StringComparison.OrdinalIgnoreCase));
+
+            if (clusterDetails?.ClusterEndpoint == null)
+            {
+                throw new KubeConfigException($"Cluster not found for context `{activeContext}` in kubeconfig");
+            }
+
+            if (string.IsNullOrWhiteSpace(clusterDetails.ClusterEndpoint.Server))
+            {
+                throw new KubeConfigException($"Server not found for current-context `{activeContext}` in kubeconfig");
+            }
+
+            Host = clusterDetails.ClusterEndpoint.Server;
+            SkipTlsVerify = clusterDetails.ClusterEndpoint.SkipTlsVerify;
+            TlsServerName = clusterDetails.ClusterEndpoint.TlsServerName;
+
+            if (!Uri.TryCreate(Host, UriKind.Absolute, out var uri))
+            {
+                throw new KubeConfigException($"Bad server host URL `{Host}` (cannot be parsed)");
+            }
+
+            if (IPAddress.TryParse(uri.Host, out var ipAddress))
+            {
+                if (IPAddress.Equals(IPAddress.Any, ipAddress))
+                {
+                    var builder = new UriBuilder(Host)
+                    {
+                        Host = $"{IPAddress.Loopback}",
+                    };
+                    Host = builder.ToString();
+                }
+                else if (IPAddress.Equals(IPAddress.IPv6Any, ipAddress))
+                {
+                    var builder = new UriBuilder(Host)
+                    {
+                        Host = $"{IPAddress.IPv6Loopback}",
+                    };
+                    Host = builder.ToString();
+                }
+            }
+
+            if (uri.Scheme == "https")
+            {
+                if (!string.IsNullOrEmpty(clusterDetails.ClusterEndpoint.CertificateAuthorityData))
+                {
+                    // This null password is to change the constructor to fix this KB:
+                    // https://support.microsoft.com/en-us/topic/kb5025823-change-in-how-net-applications-import-x-509-certificates-bf81c936-af2b-446e-9f7a-016f4713b46b
+                    string nullPassword = null;
+                    var data = clusterDetails.ClusterEndpoint.CertificateAuthorityData;
+                    SslCaCerts = new X509Certificate2Collection(new X509Certificate2(Convert.FromBase64String(data), nullPassword));
+                }
+                else if (!string.IsNullOrEmpty(clusterDetails.ClusterEndpoint.CertificateAuthority))
+                {
+                    SslCaCerts = new X509Certificate2Collection(new X509Certificate2(GetFullPath(
+                        k8SConfig,
+                        clusterDetails.ClusterEndpoint.CertificateAuthority)));
+                }
+            }
+        }
+
+        private void SetUserDetails(K8SConfiguration k8SConfig, Context activeContext)
+        {
+            if (string.IsNullOrWhiteSpace(activeContext.ContextDetails.User))
+            {
+                return;
+            }
+
+            var userDetails = k8SConfig.Users.FirstOrDefault(c => c.Name.Equals(
+                activeContext.ContextDetails.User,
+                StringComparison.OrdinalIgnoreCase));
+
+            if (userDetails == null)
+            {
+                throw new KubeConfigException($"User not found for context {activeContext.Name} in kubeconfig");
+            }
+
+            if (userDetails.UserCredentials == null)
+            {
+                throw new KubeConfigException($"User credentials not found for user: {userDetails.Name} in kubeconfig");
+            }
+
+            var userCredentialsFound = false;
+
+            // Basic and bearer tokens are mutually exclusive
+            if (!string.IsNullOrWhiteSpace(userDetails.UserCredentials.Token))
+            {
+                AccessToken = userDetails.UserCredentials.Token;
+                userCredentialsFound = true;
+            }
+            else if (!string.IsNullOrWhiteSpace(userDetails.UserCredentials.UserName) &&
+                     !string.IsNullOrWhiteSpace(userDetails.UserCredentials.Password))
+            {
+                Username = userDetails.UserCredentials.UserName;
+                Password = userDetails.UserCredentials.Password;
+                userCredentialsFound = true;
+            }
+
+            // Token and cert based auth can co-exist
+            if (!string.IsNullOrWhiteSpace(userDetails.UserCredentials.ClientCertificateData) &&
+                !string.IsNullOrWhiteSpace(userDetails.UserCredentials.ClientKeyData))
+            {
+                ClientCertificateData = userDetails.UserCredentials.ClientCertificateData;
+                ClientCertificateKeyData = userDetails.UserCredentials.ClientKeyData;
+                userCredentialsFound = true;
+            }
+
+            if (!string.IsNullOrWhiteSpace(userDetails.UserCredentials.ClientCertificate) &&
+                !string.IsNullOrWhiteSpace(userDetails.UserCredentials.ClientKey))
+            {
+                ClientCertificateFilePath = GetFullPath(k8SConfig, userDetails.UserCredentials.ClientCertificate);
+                ClientKeyFilePath = GetFullPath(k8SConfig, userDetails.UserCredentials.ClientKey);
+                userCredentialsFound = true;
+            }
+
+            if (userDetails.UserCredentials.AuthProvider != null)
+            {
+                if (userDetails.UserCredentials.AuthProvider.Config != null
+                    && (userDetails.UserCredentials.AuthProvider.Config.ContainsKey("access-token")
+                        || userDetails.UserCredentials.AuthProvider.Config.ContainsKey("id-token")))
+                {
+                    switch (userDetails.UserCredentials.AuthProvider.Name)
+                    {
+                        case "azure":
+                            throw new Exception("Please use the https://github.com/Azure/kubelogin credential plugin instead. See https://kubernetes.io/docs/reference/access-authn-authz/authentication/#client-go-credential-plugins for further details`");
+
+                        case "gcp":
+                            throw new Exception("Please use the \"gke-gcloud-auth-plugin\" credential plugin instead. See https://cloud.google.com/blog/products/containers-kubernetes/kubectl-auth-changes-in-gke for further details");
+                    }
+                }
+            }
+
+            if (userDetails.UserCredentials.ExternalExecution != null)
+            {
+                if (string.IsNullOrWhiteSpace(userDetails.UserCredentials.ExternalExecution.Command))
+                {
+                    throw new KubeConfigException(
+                        "External command execution to receive user credentials must include a command to execute");
+                }
+
+                if (string.IsNullOrWhiteSpace(userDetails.UserCredentials.ExternalExecution.ApiVersion))
+                {
+                    throw new KubeConfigException("External command execution missing ApiVersion key");
+                }
+
+                var response = ExecuteExternalCommand(userDetails.UserCredentials.ExternalExecution);
+                AccessToken = response.Status.Token;
+                // When reading ClientCertificateData from a config file it will be base64 encoded, and code later in the system (see CertUtils.GeneratePfx)
+                // expects ClientCertificateData and ClientCertificateKeyData to be base64 encoded because of this. However the string returned by external
+                // auth providers is the raw certificate and key PEM text, so we need to take that and base64 encoded it here so it can be decoded later.
+                ClientCertificateData = response.Status.ClientCertificateData == null ? null : Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(response.Status.ClientCertificateData));
+                ClientCertificateKeyData = response.Status.ClientKeyData == null ? null : Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(response.Status.ClientKeyData));
+
+                userCredentialsFound = true;
+
+                // TODO: support client certificates here too.
+                if (AccessToken != null)
+                {
+                    TokenProvider = new ExecTokenProvider(userDetails.UserCredentials.ExternalExecution);
+                }
+            }
+
+            if (!userCredentialsFound)
+            {
+                throw new KubeConfigException(
+                    $"User: {userDetails.Name} does not have appropriate auth credentials in kubeconfig");
+            }
+        }
+
+        public static Process CreateRunnableExternalProcess(ExternalExecution config, EventHandler<DataReceivedEventArgs> captureStdError = null)
+        {
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            var process = new Process();
+
+            process.StartInfo.EnvironmentVariables.Add("KUBERNETES_EXEC_INFO", $"{{ \"apiVersion\":\"{config.ApiVersion}\",\"kind\":\"ExecCredentials\",\"spec\":{{ \"interactive\":{Environment.UserInteractive.ToString().ToLower()} }} }}");
+            if (config.EnvironmentVariables != null)
+            {
+                foreach (var configEnvironmentVariable in config.EnvironmentVariables)
+                {
+                    if (configEnvironmentVariable.ContainsKey("name") && configEnvironmentVariable.ContainsKey("value"))
+                    {
+                        var name = configEnvironmentVariable["name"];
+                        process.StartInfo.EnvironmentVariables[name] = configEnvironmentVariable["value"];
+                    }
+                    else
+                    {
+                        var badVariable = string.Join(",", configEnvironmentVariable.Select(x => $"{x.Key}={x.Value}"));
+                        throw new KubeConfigException($"Invalid environment variable defined: {badVariable}");
+                    }
+                }
+            }
+
+            process.StartInfo.FileName = config.Command;
+            if (config.Arguments != null)
+            {
+                process.StartInfo.Arguments = string.Join(" ", config.Arguments);
+            }
+
+            process.StartInfo.RedirectStandardOutput = true;
+            process.StartInfo.RedirectStandardError = captureStdError != null;
+            process.StartInfo.UseShellExecute = false;
+            process.StartInfo.CreateNoWindow = true;
+
+            return process;
+        }
+
+        /// <summary>
+        /// Implementation of the proposal for out-of-tree client
+        /// authentication providers as described here --
+        /// https://github.com/kubernetes/community/blob/master/contributors/design-proposals/auth/kubectl-exec-plugins.md
+        /// Took inspiration from python exec_provider.py --
+        /// https://github.com/kubernetes-client/python-base/blob/master/config/exec_provider.py
+        /// </summary>
+        /// <param name="config">The external command execution configuration</param>
+        /// <returns>
+        /// The token, client certificate data, and the client key data received from the external command execution
+        /// </returns>
+        public static ExecCredentialResponse ExecuteExternalCommand(ExternalExecution config)
+        {
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            var captureStdError = ExecStdError;
+            var process = CreateRunnableExternalProcess(config, captureStdError);
+
+            try
+            {
+                process.Start();
+                if (captureStdError != null)
+                {
+                    process.ErrorDataReceived += captureStdError.Invoke;
+                    process.BeginErrorReadLine();
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new KubeConfigException($"external exec failed due to: {ex.Message}");
+            }
+
+            try
+            {
+                if (!process.WaitForExit((int)(ExecTimeout.TotalMilliseconds)))
+                {
+                    throw new KubeConfigException("external exec failed due to timeout");
+                }
+
+                var responseObject = KubernetesJson.Deserialize<ExecCredentialResponse>(process.StandardOutput.ReadToEnd());
+                if (responseObject == null || responseObject.ApiVersion != config.ApiVersion)
+                {
+                    throw new KubeConfigException(
+                        $"external exec failed because api version {responseObject.ApiVersion} does not match {config.ApiVersion}");
+                }
+
+                if (responseObject.Status.IsValid())
+                {
+                    return responseObject;
+                }
+                else
+                {
+                    throw new KubeConfigException($"external exec failed missing token or clientCertificateData field in plugin output");
+                }
+            }
+            catch (JsonException ex)
+            {
+                throw new KubeConfigException($"external exec failed due to failed deserialization process: {ex}");
+            }
+            catch (Exception ex)
+            {
+                throw new KubeConfigException($"external exec failed due to uncaught exception: {ex}");
+            }
+        }
+
+        /// <summary>
+        ///     Loads entire Kube Config from default or explicit file path
+        /// </summary>
+        /// <param name="kubeconfigPath">Explicit file path to kubeconfig. Set to null to use the default file path</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        public static async Task<K8SConfiguration> LoadKubeConfigAsync(
+            string kubeconfigPath = null,
+            bool useRelativePaths = true)
+        {
+            var fileInfo = new FileInfo(kubeconfigPath ?? KubeConfigDefaultLocation);
+
+            return await LoadKubeConfigAsync(fileInfo, useRelativePaths).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        ///     Loads entire Kube Config from default or explicit file path
+        /// </summary>
+        /// <param name="kubeconfigPath">Explicit file path to kubeconfig. Set to null to use the default file path</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        public static K8SConfiguration LoadKubeConfig(string kubeconfigPath = null, bool useRelativePaths = true)
+        {
+            return LoadKubeConfigAsync(kubeconfigPath, useRelativePaths).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        ///     Loads Kube Config
+        /// </summary>
+        /// <param name="kubeconfig">Kube config file contents</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        public static async Task<K8SConfiguration> LoadKubeConfigAsync(
+            FileInfo kubeconfig,
+            bool useRelativePaths = true)
+        {
+            if (kubeconfig == null)
+            {
+                throw new ArgumentNullException(nameof(kubeconfig));
+            }
+
+
+            if (!kubeconfig.Exists)
+            {
+                throw new KubeConfigException($"kubeconfig file not found at {kubeconfig.FullName}");
+            }
+
+            using (var stream = kubeconfig.OpenRead())
+            {
+                var config = await KubernetesYaml.LoadFromStreamAsync<K8SConfiguration>(stream).ConfigureAwait(false);
+
+                if (useRelativePaths)
+                {
+                    config.FileName = kubeconfig.FullName;
+                }
+
+                return config;
+            }
+        }
+
+        /// <summary>
+        ///     Loads Kube Config
+        /// </summary>
+        /// <param name="kubeconfig">Kube config file contents</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        public static K8SConfiguration LoadKubeConfig(FileInfo kubeconfig, bool useRelativePaths = true)
+        {
+            return LoadKubeConfigAsync(kubeconfig, useRelativePaths).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        ///     Loads Kube Config
+        /// </summary>
+        /// <param name="kubeconfigStream">Kube config file contents stream</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        public static async Task<K8SConfiguration> LoadKubeConfigAsync(Stream kubeconfigStream)
+        {
+            return await KubernetesYaml.LoadFromStreamAsync<K8SConfiguration>(kubeconfigStream).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        ///     Loads Kube Config
+        /// </summary>
+        /// <param name="kubeconfigStream">Kube config file contents stream</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        public static K8SConfiguration LoadKubeConfig(Stream kubeconfigStream)
+        {
+            return LoadKubeConfigAsync(kubeconfigStream).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        ///     Loads Kube Config
+        /// </summary>
+        /// <param name="kubeConfigs">List of kube config file contents</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        /// <remarks>
+        ///     The kube config files will be merges into a single <see cref="K8SConfiguration"/>, where first occurrence wins.
+        ///     See https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#merging-kubeconfig-files.
+        /// </remarks>
+        internal static K8SConfiguration LoadKubeConfig(FileInfo[] kubeConfigs, bool useRelativePaths = true)
+        {
+            return LoadKubeConfigAsync(kubeConfigs, useRelativePaths).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        ///     Loads Kube Config
+        /// </summary>
+        /// <param name="kubeConfigs">List of kube config file contents</param>
+        /// <param name="useRelativePaths">When <see langword="true"/>, the paths in the kubeconfig file will be considered to be relative to the directory in which the kubeconfig
+        /// file is located. When <see langword="false"/>, the paths will be considered to be relative to the current working directory.</param>
+        /// <returns>Instance of the <see cref="K8SConfiguration"/> class</returns>
+        /// <remarks>
+        ///     The kube config files will be merges into a single <see cref="K8SConfiguration"/>, where first occurrence wins.
+        ///     See https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#merging-kubeconfig-files.
+        /// </remarks>
+        internal static async Task<K8SConfiguration> LoadKubeConfigAsync(
+            FileInfo[] kubeConfigs,
+            bool useRelativePaths = true)
+        {
+            var basek8SConfig = await LoadKubeConfigAsync(kubeConfigs[0], useRelativePaths).ConfigureAwait(false);
+
+            for (var i = 1; i < kubeConfigs.Length; i++)
+            {
+                var mergek8SConfig = await LoadKubeConfigAsync(kubeConfigs[i], useRelativePaths).ConfigureAwait(false);
+                MergeKubeConfig(basek8SConfig, mergek8SConfig);
+            }
+
+            return basek8SConfig;
+        }
+
+        /// <summary>
+        /// Tries to get the full path to a file referenced from the Kubernetes configuration.
+        /// </summary>
+        /// <param name="configuration">
+        /// The Kubernetes configuration.
+        /// </param>
+        /// <param name="path">
+        /// The path to resolve.
+        /// </param>
+        /// <returns>
+        /// When possible a fully qualified path to the file.
+        /// </returns>
+        /// <remarks>
+        /// For example, if the configuration file is at "C:\Users\me\kube.config" and path is "ca.crt",
+        /// this will return "C:\Users\me\ca.crt". Similarly, if path is "D:\ca.cart", this will return
+        /// "D:\ca.crt".
+        /// </remarks>
+        private static string GetFullPath(K8SConfiguration configuration, string path)
+        {
+            // If we don't have a file name,
+            if (string.IsNullOrWhiteSpace(configuration.FileName) || Path.IsPathRooted(path))
+            {
+                return path;
+            }
+            else
+            {
+                return Path.Combine(Path.GetDirectoryName(configuration.FileName), path);
+            }
+        }
+
+        /// <summary>
+        /// Merges kube config files together, preferring configuration present in the base config over the merge config.
+        /// </summary>
+        /// <param name="basek8SConfig">The <see cref="K8SConfiguration"/> to merge into</param>
+        /// <param name="mergek8SConfig">The <see cref="K8SConfiguration"/> to merge from</param>
+        private static void MergeKubeConfig(K8SConfiguration basek8SConfig, K8SConfiguration mergek8SConfig)
+        {
+            // For scalar values, prefer local values
+            basek8SConfig.CurrentContext = basek8SConfig.CurrentContext ?? mergek8SConfig.CurrentContext;
+            basek8SConfig.FileName = basek8SConfig.FileName ?? mergek8SConfig.FileName;
+
+            // Kinds must match in kube config, otherwise throw.
+            if (basek8SConfig.Kind != mergek8SConfig.Kind)
+            {
+                throw new KubeConfigException(
+                    $"kubeconfig \"kind\" are different between {basek8SConfig.FileName} and {mergek8SConfig.FileName}");
+            }
+
+            // Note, Clusters, Contexts, and Extensions are map-like in config despite being represented as a list here:
+            // https://github.com/kubernetes/client-go/blob/ede92e0fe62deed512d9ceb8bf4186db9f3776ff/tools/clientcmd/api/types.go#L238
+            // basek8SConfig.Extensions = MergeLists(basek8SConfig.Extensions, mergek8SConfig.Extensions, (s) => s.Name).ToList();
+            basek8SConfig.Clusters = MergeLists(basek8SConfig.Clusters, mergek8SConfig.Clusters, (s) => s.Name).ToList();
+            basek8SConfig.Users = MergeLists(basek8SConfig.Users, mergek8SConfig.Users, (s) => s.Name).ToList();
+            basek8SConfig.Contexts = MergeLists(basek8SConfig.Contexts, mergek8SConfig.Contexts, (s) => s.Name).ToList();
+        }
+
+        private static IEnumerable<T> MergeLists<T>(IEnumerable<T> baseList, IEnumerable<T> mergeList,
+            Func<T, string> getNameFunc)
+        {
+            if (mergeList != null && mergeList.Any())
+            {
+                var mapping = new Dictionary<string, T>();
+                foreach (var item in baseList)
+                {
+                    mapping[getNameFunc(item)] = item;
+                }
+
+                foreach (var item in mergeList)
+                {
+                    var name = getNameFunc(item);
+                    if (!mapping.ContainsKey(name))
+                    {
+                        mapping[name] = item;
+                    }
+                }
+
+                return mapping.Values;
+            }
+
+            return baseList;
+        }
+    }
+}

src/KubernetesClient.Aot/KubernetesJson.cs

@@ -0,0 +1,98 @@
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.Xml;
+
+namespace k8s
+{
+    internal static class KubernetesJson
+    {
+        internal sealed class Iso8601TimeSpanConverter : JsonConverter<TimeSpan>
+        {
+            public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                var str = reader.GetString();
+                return XmlConvert.ToTimeSpan(str);
+            }
+
+            public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+            {
+                var iso8601TimeSpanString = XmlConvert.ToString(value); // XmlConvert for TimeSpan uses ISO8601, so delegate serialization to it
+                writer.WriteStringValue(iso8601TimeSpanString);
+            }
+        }
+
+        internal sealed class KubernetesDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
+        {
+            private const string RFC3339MicroFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.ffffffK";
+            private const string RFC3339NanoFormat = "yyyy-MM-dd'T'HH':'mm':'ss.fffffffK";
+            private const string RFC3339Format = "yyyy'-'MM'-'dd'T'HH':'mm':'ssK";
+
+            public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                var str = reader.GetString();
+
+                if (DateTimeOffset.TryParseExact(str, new[] { RFC3339Format, RFC3339MicroFormat }, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
+                {
+                    return result;
+                }
+
+                // try RFC3339NanoLenient by trimming 1-9 digits to 7 digits
+                var originalstr = str;
+                str = Regex.Replace(str, @"\.\d+", m => (m.Value + "000000000").Substring(0, 7 + 1)); // 7 digits + 1 for the dot
+                if (DateTimeOffset.TryParseExact(str, new[] { RFC3339NanoFormat }, CultureInfo.InvariantCulture, DateTimeStyles.None, out result))
+                {
+                    return result;
+                }
+
+                throw new FormatException($"Unable to parse {originalstr} as RFC3339 RFC3339Micro or RFC3339Nano");
+            }
+
+            public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options)
+            {
+                writer.WriteStringValue(value.ToString(RFC3339MicroFormat));
+            }
+        }
+
+        internal sealed class KubernetesDateTimeConverter : JsonConverter<DateTime>
+        {
+            private static readonly JsonConverter<DateTimeOffset> UtcConverter = new KubernetesDateTimeOffsetConverter();
+            public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                return UtcConverter.Read(ref reader, typeToConvert, options).UtcDateTime;
+            }
+
+            public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
+            {
+                UtcConverter.Write(writer, value, options);
+            }
+        }
+
+        /// <summary>
+        /// Configures <see cref="JsonSerializerOptions"/> for the <see cref="JsonSerializer"/>.
+        /// To override existing converters, add them to the top of the <see cref="JsonSerializerOptions.Converters"/> list
+        /// e.g. as follows: <code>options.Converters.Insert(index: 0, new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));</code>
+        /// </summary>
+        /// <param name="configure">An <see cref="Action"/> to configure the <see cref="JsonSerializerOptions"/>.</param>
+        public static void AddJsonOptions(Action<JsonSerializerOptions> configure)
+        {
+        }
+
+        public static TValue Deserialize<TValue>(string json, JsonSerializerOptions jsonSerializerOptions = null)
+        {
+            var info = SourceGenerationContext.Default.GetTypeInfo(typeof(TValue));
+            return (TValue)JsonSerializer.Deserialize(json, info);
+        }
+
+        public static TValue Deserialize<TValue>(Stream json, JsonSerializerOptions jsonSerializerOptions = null)
+        {
+            var info = SourceGenerationContext.Default.GetTypeInfo(typeof(TValue));
+            return (TValue)JsonSerializer.Deserialize(json, info);
+        }
+
+        public static string Serialize(object value, JsonSerializerOptions jsonSerializerOptions = null)
+        {
+            var info = SourceGenerationContext.Default.GetTypeInfo(value.GetType());
+            return JsonSerializer.Serialize(value, info);
+        }
+    }
+}

src/KubernetesClient.Aot/KubernetesYaml.cs

@@ -0,0 +1,160 @@
+using System.Text;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace k8s
+{
+    /// <summary>
+    /// This is a utility class that helps you load objects from YAML files.
+    /// </summary>
+    internal static class KubernetesYaml
+    {
+        private static StaticDeserializerBuilder CommonDeserializerBuilder =>
+            new StaticDeserializerBuilder(new k8s.KubeConfigModels.StaticContext())
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeConverter(new IntOrStringYamlConverter())
+                .WithTypeConverter(new ByteArrayStringYamlConverter())
+                .WithTypeConverter(new ResourceQuantityYamlConverter())
+                .WithAttemptingUnquotedStringTypeDeserialization()
+                ;
+
+        private static readonly IDeserializer Deserializer =
+            CommonDeserializerBuilder
+            .IgnoreUnmatchedProperties()
+            .Build();
+        private static IDeserializer GetDeserializer(bool strict) => Deserializer;
+
+        private static readonly IValueSerializer Serializer =
+            new StaticSerializerBuilder(new k8s.KubeConfigModels.StaticContext())
+                .DisableAliases()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeConverter(new IntOrStringYamlConverter())
+                .WithTypeConverter(new ByteArrayStringYamlConverter())
+                .WithTypeConverter(new ResourceQuantityYamlConverter())
+                .WithEventEmitter(e => new StringQuotingEmitter(e))
+                .WithEventEmitter(e => new FloatEmitter(e))
+                .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull)
+                .BuildValueSerializer();
+
+        private class ByteArrayStringYamlConverter : IYamlTypeConverter
+        {
+            public bool Accepts(Type type)
+            {
+                return type == typeof(byte[]);
+            }
+
+            public object ReadYaml(IParser parser, Type type)
+            {
+                if (parser?.Current is Scalar scalar)
+                {
+                    try
+                    {
+                        if (string.IsNullOrEmpty(scalar.Value))
+                        {
+                            return null;
+                        }
+
+                        return Encoding.UTF8.GetBytes(scalar.Value);
+                    }
+                    finally
+                    {
+                        parser.MoveNext();
+                    }
+                }
+
+                throw new InvalidOperationException(parser.Current?.ToString());
+            }
+
+            public void WriteYaml(IEmitter emitter, object value, Type type)
+            {
+                var obj = (byte[])value;
+                emitter?.Emit(new Scalar(Encoding.UTF8.GetString(obj)));
+            }
+        }
+
+        public static async Task<T> LoadFromStreamAsync<T>(Stream stream, bool strict = false)
+        {
+            var reader = new StreamReader(stream);
+            var content = await reader.ReadToEndAsync().ConfigureAwait(false);
+            return Deserialize<T>(content, strict);
+        }
+
+        public static async Task<T> LoadFromFileAsync<T>(string file, bool strict = false)
+        {
+            using (var fs = File.OpenRead(file))
+            {
+                return await LoadFromStreamAsync<T>(fs, strict).ConfigureAwait(false);
+            }
+        }
+
+        [Obsolete("use Deserialize")]
+        public static T LoadFromString<T>(string content, bool strict = false)
+        {
+            return Deserialize<T>(content, strict);
+        }
+
+        [Obsolete("use Serialize")]
+        public static string SaveToString<T>(T value)
+        {
+            return Serialize(value);
+        }
+
+        public static TValue Deserialize<TValue>(string yaml, bool strict = false)
+        {
+            using var reader = new StringReader(yaml);
+            return GetDeserializer(strict).Deserialize<TValue>(new MergingParser(new Parser(reader)));
+        }
+
+        public static TValue Deserialize<TValue>(Stream yaml, bool strict = false)
+        {
+            using var reader = new StreamReader(yaml);
+            return GetDeserializer(strict).Deserialize<TValue>(new MergingParser(new Parser(reader)));
+        }
+
+        public static string SerializeAll(IEnumerable<object> values)
+        {
+            if (values == null)
+            {
+                return "";
+            }
+
+            var stringBuilder = new StringBuilder();
+            var writer = new StringWriter(stringBuilder);
+            var emitter = new Emitter(writer);
+
+            emitter.Emit(new StreamStart());
+
+            foreach (var value in values)
+            {
+                if (value != null)
+                {
+                    emitter.Emit(new DocumentStart());
+                    Serializer.SerializeValue(emitter, value, value.GetType());
+                    emitter.Emit(new DocumentEnd(true));
+                }
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public static string Serialize(object value)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            var stringBuilder = new StringBuilder();
+            var writer = new StringWriter(stringBuilder);
+            var emitter = new Emitter(writer);
+
+            emitter.Emit(new StreamStart());
+            emitter.Emit(new DocumentStart());
+            Serializer.SerializeValue(emitter, value, value.GetType());
+
+            return stringBuilder.ToString();
+        }
+    }
+}

src/KubernetesClient.Aot/SourceGenerationContext.cs

@@ -0,0 +1,12 @@
+using static k8s.KubernetesJson;
+
+namespace k8s;
+
+[JsonSourceGenerationOptions(
+    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
+    Converters = new[] { typeof(Iso8601TimeSpanConverter), typeof(KubernetesDateTimeConverter), typeof(KubernetesDateTimeOffsetConverter) })
+    ]
+internal partial class SourceGenerationContext : JsonSerializerContext
+{
+}

src/KubernetesClient.Aot/V1PatchJsonConverter.cs

@@ -0,0 +1,29 @@
+namespace k8s.Models
+{
+#pragma warning disable CA1812 // Avoid uninstantiated internal classes
+    internal sealed class V1PatchJsonConverter : JsonConverter<V1Patch>
+#pragma warning restore CA1812 // Avoid uninstantiated internal classes
+    {
+        public override V1Patch Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(Utf8JsonWriter writer, V1Patch value, JsonSerializerOptions options)
+        {
+            if (writer == null)
+            {
+                throw new ArgumentNullException(nameof(writer));
+            }
+
+            var content = value?.Content;
+            if (content is string s)
+            {
+                writer.WriteRawValue(s);
+                return;
+            }
+
+            throw new NotSupportedException("only string json patch is supported");
+        }
+    }
+}

src/KubernetesClient/Watcher.cs

@@ -4,6 +4,9 @@ using System.Runtime.Serialization;
 namespace k8s
 {
     /// <summary>Describes the type of a watch event.</summary>
+#if NET8_0_OR_GREATER
+    [JsonConverter(typeof(JsonStringEnumConverter<WatchEventType>))]
+#endif
     public enum WatchEventType
     {
         /// <summary>Emitted when an object is created, modified to match a watch's filter, or when a watch is first opened.</summary>

src/nuget.proj

@@ -2,6 +2,7 @@
   <ItemGroup>
     <ProjectReference Include="KubernetesClient/KubernetesClient.csproj" />
     <ProjectReference Include="KubernetesClient.Classic/KubernetesClient.Classic.csproj" />
+    <ProjectReference Include="KubernetesClient.Aot/KubernetesClient.Aot.csproj" />
     <ProjectReference Include="KubernetesClient.ModelConverter/KubernetesClient.ModelConverter.csproj" />
   </ItemGroup>
 </Project>

tests/E2E.Aot.Tests/E2E.Aot.Tests.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <RootNamespace>k8s.E2E</RootNamespace>
+    <TargetFrameworks>net8.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+
+    <PackageReference Include="JsonPatch.Net" Version="2.1.0" />
+    <PackageReference Include="SharpZipLib" Version="1.4.2" />
+
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+
+    <PackageReference Include="Nito.AsyncEx.Coordination" Version="5.1.2" />
+    <PackageReference Include="xunit" Version="2.6.5" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.6">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\KubernetesClient.Aot\KubernetesClient.Aot.csproj" />
+    <ProjectReference Include="..\SkipTestLogger\SkipTestLogger.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Update="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.3.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\E2E.Tests\MinikubeFactAttribute.cs" />
+    <Compile Include="..\E2E.Tests\Onebyone.cs" />
+  </ItemGroup>
+</Project>

tests/E2E.Aot.Tests/MinikubeTests.cs

@@ -0,0 +1,378 @@
+using ICSharpCode.SharpZipLib.Tar;
+using k8s.Autorest;
+using k8s.Models;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace k8s.E2E
+{
+    [Collection(nameof(Onebyone))]
+    public class MinikubeTests
+    {
+        [MinikubeFact]
+        public void SimpleTest()
+        {
+            var namespaceParameter = "default";
+            var podName = "k8scsharp-e2e-pod";
+
+            using var client = CreateClient();
+
+            void Cleanup()
+            {
+                var pods = client.CoreV1.ListNamespacedPod(namespaceParameter);
+                while (pods.Items.Any(p => p.Metadata.Name == podName))
+                {
+                    try
+                    {
+                        client.CoreV1.DeleteNamespacedPod(podName, namespaceParameter);
+                    }
+                    catch (HttpOperationException e)
+                    {
+                        if (e.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+
+            try
+            {
+                Cleanup();
+
+                client.CoreV1.CreateNamespacedPod(
+                    new V1Pod()
+                    {
+                        Metadata = new V1ObjectMeta { Name = podName, },
+                        Spec = new V1PodSpec
+                        {
+                            Containers = new[] { new V1Container() { Name = "k8scsharp-e2e", Image = "nginx", }, },
+                        },
+                    },
+                    namespaceParameter);
+
+                var pods = client.CoreV1.ListNamespacedPod(namespaceParameter);
+                Assert.Contains(pods.Items, p => p.Metadata.Name == podName);
+            }
+            finally
+            {
+                Cleanup();
+            }
+        }
+
+        [MinikubeFact]
+        public async Task LogStreamTestAsync()
+        {
+            var namespaceParameter = "default";
+            var podName = "k8scsharp-e2e-logstream-pod";
+
+            using var client = CreateClient();
+
+            void Cleanup()
+            {
+                var pods = client.CoreV1.ListNamespacedPod(namespaceParameter);
+                while (pods.Items.Any(p => p.Metadata.Name == podName))
+                {
+                    try
+                    {
+                        client.CoreV1.DeleteNamespacedPod(podName, namespaceParameter);
+                    }
+                    catch (HttpOperationException e)
+                    {
+                        if (e.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+
+            try
+            {
+                Cleanup();
+
+                client.CoreV1.CreateNamespacedPod(
+                    new V1Pod()
+                    {
+                        Metadata = new V1ObjectMeta { Name = podName, },
+                        Spec = new V1PodSpec
+                        {
+                            Containers = new[]
+                            {
+                                new V1Container()
+                                {
+                                    Name = "k8scsharp-e2e-logstream",
+                                    Image = "busybox",
+                                    Command = new[] { "ping" },
+                                    Args = new[] { "-i", "10",  "127.0.0.1" },
+                                },
+                            },
+                        },
+                    },
+                    namespaceParameter);
+
+                var lines = new List<string>();
+                var started = new ManualResetEvent(false);
+
+                async Task<V1Pod> Pod()
+                {
+                    var pods = client.CoreV1.ListNamespacedPod(namespaceParameter);
+                    var pod = pods.Items.First(p => p.Metadata.Name == podName);
+                    while (pod.Status.Phase != "Running")
+                    {
+                        await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
+                        return await Pod().ConfigureAwait(false);
+                    }
+
+                    return pod;
+                }
+
+                var pod = await Pod().ConfigureAwait(false);
+                var stream = client.CoreV1.ReadNamespacedPodLog(pod.Metadata.Name, pod.Metadata.NamespaceProperty, follow: true);
+                using var reader = new StreamReader(stream);
+
+                var copytask = Task.Run(() =>
+                {
+                    for (; ; )
+                    {
+                        try
+                        {
+                            lines.Add(reader.ReadLine());
+                        }
+                        finally
+                        {
+                            started.Set();
+                        }
+                    }
+                });
+
+                Assert.True(started.WaitOne(TimeSpan.FromMinutes(2)));
+                await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
+                Assert.Null(copytask.Exception);
+                Assert.Equal(2, lines.Count);
+                await Task.Delay(TimeSpan.FromSeconds(11)).ConfigureAwait(false);
+                Assert.Equal(3, lines.Count);
+            }
+            finally
+            {
+                Cleanup();
+            }
+        }
+
+        [MinikubeFact]
+        public async Task DatetimeFieldTest()
+        {
+            using var kubernetes = CreateClient();
+
+            await kubernetes.CoreV1.CreateNamespacedEventAsync(
+                new Corev1Event(
+                    new V1ObjectReference(
+                        "v1alpha1",
+                        kind: "Test",
+                        name: "test",
+                        namespaceProperty: "default",
+                        resourceVersion: "1",
+                        uid: "1"),
+                    new V1ObjectMeta()
+                    {
+                        GenerateName = "started-",
+                    },
+                    action: "STARTED",
+                    type: "Normal",
+                    reason: "STARTED",
+                    message: "Started",
+                    eventTime: DateTime.Now,
+                    firstTimestamp: DateTime.Now,
+                    lastTimestamp: DateTime.Now,
+                    reportingComponent: "37",
+                    reportingInstance: "38"), "default").ConfigureAwait(false);
+        }
+
+        [MinikubeFact]
+        public async Task CopyToPodTestAsync()
+        {
+            var namespaceParameter = "default";
+            var podName = "k8scsharp-e2e-cp-pod";
+
+            using var client = CreateClient();
+
+            async Task<int> CopyFileToPodAsync(string name, string @namespace, string container, Stream inputFileStream, string destinationFilePath, CancellationToken cancellationToken = default(CancellationToken))
+            {
+                // The callback which processes the standard input, standard output and standard error of exec method
+                var handler = new ExecAsyncCallback(async (stdIn, stdOut, stdError) =>
+                {
+                    var fileInfo = new FileInfo(destinationFilePath);
+                    try
+                    {
+                        using (var memoryStream = new MemoryStream())
+                        {
+                            using (var tarOutputStream = new TarOutputStream(memoryStream, Encoding.Default))
+                            {
+                                tarOutputStream.IsStreamOwner = false;
+
+                                var fileSize = inputFileStream.Length;
+                                var entry = TarEntry.CreateTarEntry(fileInfo.Name);
+
+                                entry.Size = fileSize;
+
+                                tarOutputStream.PutNextEntry(entry);
+                                await inputFileStream.CopyToAsync(tarOutputStream).ConfigureAwait(false);
+                                tarOutputStream.CloseEntry();
+                            }
+
+                            memoryStream.Position = 0;
+
+                            await memoryStream.CopyToAsync(stdIn).ConfigureAwait(false);
+                            await memoryStream.FlushAsync().ConfigureAwait(false);
+                            stdIn.Close();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new IOException($"Copy command failed: {ex.Message}");
+                    }
+
+                    using StreamReader streamReader = new StreamReader(stdError);
+                    while (streamReader.EndOfStream == false)
+                    {
+                        string error = await streamReader.ReadToEndAsync().ConfigureAwait(false);
+                        throw new IOException($"Copy command failed: {error}");
+                    }
+                });
+
+                string destinationFolder = Path.GetDirectoryName(destinationFilePath).Replace("\\", "/");
+
+                return await client.NamespacedPodExecAsync(
+                    name,
+                    @namespace,
+                    container,
+                    new string[] { "tar", "-xmf", "-", "-C", destinationFolder },
+                    false,
+                    handler,
+                    cancellationToken).ConfigureAwait(false);
+            }
+
+
+            void Cleanup()
+            {
+                var pods = client.CoreV1.ListNamespacedPod(namespaceParameter);
+                while (pods.Items.Any(p => p.Metadata.Name == podName))
+                {
+                    try
+                    {
+                        client.CoreV1.DeleteNamespacedPod(podName, namespaceParameter);
+                    }
+                    catch (HttpOperationException e)
+                    {
+                        if (e.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+
+            try
+            {
+                Cleanup();
+
+                client.CoreV1.CreateNamespacedPod(
+                    new V1Pod()
+                    {
+                        Metadata = new V1ObjectMeta { Name = podName, },
+                        Spec = new V1PodSpec
+                        {
+                            Containers = new[]
+                            {
+                                new V1Container()
+                                {
+                                    Name = "container",
+                                    Image = "ubuntu",
+                                    // Image = "busybox", // TODO not work with busybox
+                                    Command = new[] { "sleep" },
+                                    Args = new[] { "infinity" },
+                                },
+                            },
+                        },
+                    },
+                    namespaceParameter);
+
+                var lines = new List<string>();
+                var started = new ManualResetEvent(false);
+
+                async Task<V1Pod> Pod()
+                {
+                    var pods = client.CoreV1.ListNamespacedPod(namespaceParameter);
+                    var pod = pods.Items.First(p => p.Metadata.Name == podName);
+                    while (pod.Status.Phase != "Running")
+                    {
+                        await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
+                        return await Pod().ConfigureAwait(false);
+                    }
+
+                    return pod;
+                }
+
+                var pod = await Pod().ConfigureAwait(false);
+
+
+                async Task AssertMd5sumAsync(string file, byte[] orig)
+                {
+                    var ws = await client.WebSocketNamespacedPodExecAsync(
+                       pod.Metadata.Name,
+                       pod.Metadata.NamespaceProperty,
+                       new string[] { "md5sum", file },
+                       "container").ConfigureAwait(false);
+
+                    var demux = new StreamDemuxer(ws);
+                    demux.Start();
+
+                    var buff = new byte[4096];
+                    var stream = demux.GetStream(1, 1);
+                    var read = stream.Read(buff, 0, 4096);
+                    var remotemd5 = Encoding.Default.GetString(buff);
+                    remotemd5 = remotemd5.Substring(0, 32);
+
+                    var md5 = MD5.Create().ComputeHash(orig);
+                    var localmd5 = BitConverter.ToString(md5).Replace("-", string.Empty).ToLower();
+
+                    Assert.Equal(localmd5, remotemd5);
+                }
+
+
+                //
+                {
+                    // small
+                    var content = new byte[1 * 1024 * 1024];
+                    new Random().NextBytes(content);
+                    await CopyFileToPodAsync(pod.Metadata.Name, pod.Metadata.NamespaceProperty, "container", new MemoryStream(content), "/tmp/test").ConfigureAwait(false);
+                    await AssertMd5sumAsync("/tmp/test", content).ConfigureAwait(false);
+                }
+
+                {
+                    // big
+                    var content = new byte[40 * 1024 * 1024];
+                    new Random().NextBytes(content);
+                    await CopyFileToPodAsync(pod.Metadata.Name, pod.Metadata.NamespaceProperty, "container", new MemoryStream(content), "/tmp/test").ConfigureAwait(false);
+                    await AssertMd5sumAsync("/tmp/test", content).ConfigureAwait(false);
+                }
+            }
+            finally
+            {
+                Cleanup();
+            }
+        }
+
+        public static IKubernetes CreateClient()
+        {
+            return new Kubernetes(KubernetesClientConfiguration.BuildDefaultConfig());
+        }
+    }
+}

tests/E2E.Tests/E2E.Tests.csproj

@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <IsPackable>false</IsPackable>
-    <SignAssembly>true</SignAssembly>
     <RootNamespace>k8s.E2E</RootNamespace>
     <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
   </PropertyGroup>