diff --git a/gen/KubernetesWatchGenerator/KubernetesWatchGenerator.csproj b/gen/KubernetesWatchGenerator/KubernetesWatchGenerator.csproj index c020db5..f6c1011 100644 --- a/gen/KubernetesWatchGenerator/KubernetesWatchGenerator.csproj +++ b/gen/KubernetesWatchGenerator/KubernetesWatchGenerator.csproj @@ -22,6 +22,12 @@ PreserveNewest + + PreserveNewest + + + PreserveNewest + diff --git a/gen/KubernetesWatchGenerator/ModelOperators.cs.template b/gen/KubernetesWatchGenerator/ModelOperators.cs.template new file mode 100644 index 0000000..029adea --- /dev/null +++ b/gen/KubernetesWatchGenerator/ModelOperators.cs.template @@ -0,0 +1,15 @@ +using k8s.Versioning; + +namespace k8s.Models +{ +{{#.}} + public partial class {{GetTuple . index="0"}} + { + public static explicit operator {{GetTuple . index="0"}}({{GetTuple . index="1"}} s) => VersionConverter.Mapper.Map<{{GetTuple . index="0"}}>(s); + } + public partial class {{GetTuple . index="1"}} + { + public static explicit operator {{GetTuple . index="1"}}({{GetTuple . index="0"}} s) => VersionConverter.Mapper.Map<{{GetTuple . index="1"}}>(s); + } +{{/.}} +} diff --git a/gen/KubernetesWatchGenerator/Program.cs b/gen/KubernetesWatchGenerator/Program.cs index ac71147..1649a49 100644 --- a/gen/KubernetesWatchGenerator/Program.cs +++ b/gen/KubernetesWatchGenerator/Program.cs @@ -5,6 +5,8 @@ using System; using System.Collections.Generic; using System.IO; using System.Linq; +using System.Runtime.CompilerServices; +using System.Text.RegularExpressions; using System.Threading.Tasks; namespace KubernetesWatchGenerator @@ -101,6 +103,7 @@ namespace KubernetesWatchGenerator Helpers.Register(nameof(GetApiVersion), GetApiVersion); Helpers.Register(nameof(GetKind), GetKind); Helpers.Register(nameof(GetPlural), GetPlural); + Helpers.Register(nameof(GetTuple), GetTuple); // Generate the Watcher operations // We skip operations where the name of the class in the C# client could not be determined correctly. @@ -134,10 +137,40 @@ namespace KubernetesWatchGenerator .Select(x => x.Class) .ToHashSet(); - Render.FileToFile("ModelExtensions.cs.template", definitions, - Path.Combine(outputDirectory, "ModelExtensions.cs")); + Render.FileToFile("ModelExtensions.cs.template", definitions, Path.Combine(outputDirectory, "ModelExtensions.cs")); + + // generate version converter maps + var allGeneratedModelClassNames = Directory + .EnumerateFiles(Path.Combine(outputDirectory, "Models")) + .Select(Path.GetFileNameWithoutExtension) + .ToList(); + + var versionRegex = @"(^V|v)[0-9]+((alpha|beta)[0-9]+)?"; + var typePairs = allGeneratedModelClassNames + .OrderBy(x => x) + .Select(x => new { Version = Regex.Match(x, versionRegex).Value?.ToLower(), Kinda = Regex.Replace(x, versionRegex, string.Empty), Type = x }) + .Where(x => !string.IsNullOrEmpty(x.Version)) + .GroupBy(x => x.Kinda) + .Where(x => x.Count() > 1) + .SelectMany(x => x.SelectMany((value, index) => x.Skip(index + 1), (first, second) => new { first, second })) + .OrderBy(x => x.first.Kinda) + .ThenBy(x => x.first.Version) + .Select(x => (ITuple)Tuple.Create(x.first.Type, x.second.Type)) + .ToList(); + + var versionFile = File.ReadAllText(Path.Combine(outputDirectory, "..", "Versioning", "VersionConverter.cs")); + var manualMaps = Regex.Matches(versionFile, @"\.CreateMap<(?.+?),\s?(?.+?)>") + .Select(x => Tuple.Create(x.Groups["T1"].Value, x.Groups["T2"].Value)) + .ToList(); + var versionConverterPairs = typePairs.Except(manualMaps).ToList(); + + Render.FileToFile("VersionConverter.cs.template", versionConverterPairs, Path.Combine(outputDirectory, "VersionConverter.cs")); + Render.FileToFile("ModelOperators.cs.template", typePairs, Path.Combine(outputDirectory, "ModelOperators.cs")); + } + + static void ToXmlDoc(RenderContext context, IList arguments, IDictionary options, RenderBlock fn, RenderBlock inverse) { @@ -166,6 +199,18 @@ namespace KubernetesWatchGenerator } } + static void GetTuple(RenderContext context, IList arguments, IDictionary options, RenderBlock fn, RenderBlock inverse) + { + if (arguments != null && arguments.Count > 0 && arguments[0] is ITuple && options.TryGetValue("index", out var indexObj) && int.TryParse(indexObj?.ToString(), out var index)) + { + var pair = (ITuple)arguments[0]; + var value = pair[index]; + context.Write(value.ToString()); + } + } + + + static void GetClassName(RenderContext context, IList arguments, IDictionary options, RenderBlock fn, RenderBlock inverse) { @@ -343,6 +388,7 @@ namespace KubernetesWatchGenerator } } + static string GetMethodName(SwaggerOperation watchOperation) { var tag = watchOperation.Tags[0]; diff --git a/gen/KubernetesWatchGenerator/VersionConverter.cs.template b/gen/KubernetesWatchGenerator/VersionConverter.cs.template new file mode 100644 index 0000000..d39cc02 --- /dev/null +++ b/gen/KubernetesWatchGenerator/VersionConverter.cs.template @@ -0,0 +1,19 @@ +using AutoMapper; +using k8s.Models; + +namespace k8s.Versioning +{ + + + public static partial class VersionConverter + { + private static void AutoConfigurations(IMapperConfigurationExpression cfg) + { + {{#.}} + cfg.CreateMap<{{GetTuple . index="0"}}, {{GetTuple . index="1"}}>().ReverseMap(); + {{/.}} + } + } + + +} diff --git a/src/KubernetesClient/Extensions.cs b/src/KubernetesClient/Extensions.cs new file mode 100644 index 0000000..cb4eb6c --- /dev/null +++ b/src/KubernetesClient/Extensions.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Concurrent; +using System.Linq; +using System.Net; +using System.Net.Http; +using System.Reflection; +using System.Text.RegularExpressions; +using System.Threading.Tasks; +using k8s.Models; +using Microsoft.Rest; +using Microsoft.Rest.TransientFaultHandling; +using Newtonsoft.Json.Converters; +using VersionConverter = k8s.Versioning.VersionConverter; + +namespace k8s +{ + public static class Extensions + { + + public static KubernetesEntityAttribute GetKubernetesTypeMetadata(this T obj) where T : IKubernetesObject => + obj.GetType().GetKubernetesTypeMetadata(); + public static KubernetesEntityAttribute GetKubernetesTypeMetadata(this Type currentType) + { + var attr = currentType.GetCustomAttribute(); + if (attr == null) + { + throw new InvalidOperationException($"Custom resource must have {nameof(KubernetesEntityAttribute)} applied to it"); + } + return attr; + } + + public static T Initialize(this T obj) where T : IKubernetesObject + { + var metadata = obj.GetKubernetesTypeMetadata(); + obj.ApiVersion = !string.IsNullOrEmpty(metadata.Group) ? $"{metadata.Group}/{metadata.ApiVersion}" : metadata.ApiVersion; + obj.Kind = metadata.Kind ?? obj.GetType().Name; + if (obj is IMetadata withMetadata && withMetadata.Metadata == null) + { + withMetadata.Metadata = new V1ObjectMeta(); + } + + return obj; + } + + internal static bool IsValidKubernetesName(this string value) => !Regex.IsMatch(value, "^[a-z0-9-]+$"); + + + } +} diff --git a/src/KubernetesClient/KubernetesClient.csproj b/src/KubernetesClient/KubernetesClient.csproj index 0d403ff..fe87790 100644 --- a/src/KubernetesClient/KubernetesClient.csproj +++ b/src/KubernetesClient/KubernetesClient.csproj @@ -27,6 +27,8 @@ + + @@ -41,6 +43,7 @@ - + + diff --git a/src/KubernetesClient/Versioning/KubernetesVersionComparitor.cs b/src/KubernetesClient/Versioning/KubernetesVersionComparitor.cs new file mode 100644 index 0000000..e2443f5 --- /dev/null +++ b/src/KubernetesClient/Versioning/KubernetesVersionComparitor.cs @@ -0,0 +1,65 @@ +using System; +using System.Collections.Generic; +using System.Text.RegularExpressions; + +namespace k8s.Versioning +{ + public class KubernetesVersionComparer : IComparer + { + public static KubernetesVersionComparer Instance { get; private set; } + static readonly Regex _kubernetesVersionRegex; + + static KubernetesVersionComparer() + { + _kubernetesVersionRegex = new Regex(@"^v(?[0-9]+)((?alpha|beta)(?[0-9]+))?$", RegexOptions.Compiled); + Instance = new KubernetesVersionComparer(); + } + + internal KubernetesVersionComparer() + { + } + + public int Compare(string x, string y) + { + if (x == null || y == null) + { + return StringComparer.CurrentCulture.Compare(x, y); + } + + var matchX = _kubernetesVersionRegex.Match(x); + if (!matchX.Success) + { + return StringComparer.CurrentCulture.Compare(x, y); + } + + var matchY = _kubernetesVersionRegex.Match(y); + if (!matchY.Success) + { + return StringComparer.CurrentCulture.Compare(x, y); + } + + var versionX = ExtractVersion(matchX); + var versionY = ExtractVersion(matchY); + return versionX.CompareTo(versionY); + } + + private Version ExtractVersion(Match match) + { + var major = int.Parse(match.Groups["major"].Value); + if (!Enum.TryParse(match.Groups["stream"].Value, true, out var stream)) + { + stream = Stream.Final; + } + + int.TryParse(match.Groups["minor"].Value, out var minor); + return new Version(major, (int)stream, minor); + } + + private enum Stream + { + Alpha = 1, + Beta = 2, + Final = 3 + } + } +} diff --git a/src/KubernetesClient/Versioning/ModelConvertionOperators.cs b/src/KubernetesClient/Versioning/ModelConvertionOperators.cs new file mode 100644 index 0000000..a94053e --- /dev/null +++ b/src/KubernetesClient/Versioning/ModelConvertionOperators.cs @@ -0,0 +1,726 @@ +// using k8s.Versioning; +// namespace k8s.Models +// { +// public partial class V1MutatingWebhookConfiguration +// { +// public static explicit operator V1MutatingWebhookConfiguration(V1beta1MutatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1MutatingWebhookConfiguration +// { +// public static explicit operator V1beta1MutatingWebhookConfiguration(V1MutatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1MutatingWebhookConfigurationList +// { +// public static explicit operator V1MutatingWebhookConfigurationList(V1beta1MutatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1MutatingWebhookConfigurationList +// { +// public static explicit operator V1beta1MutatingWebhookConfigurationList(V1MutatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ValidatingWebhookConfiguration +// { +// public static explicit operator V1ValidatingWebhookConfiguration(V1beta1ValidatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ValidatingWebhookConfiguration +// { +// public static explicit operator V1beta1ValidatingWebhookConfiguration(V1ValidatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ValidatingWebhookConfigurationList +// { +// public static explicit operator V1ValidatingWebhookConfigurationList(V1beta1ValidatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ValidatingWebhookConfigurationList +// { +// public static explicit operator V1beta1ValidatingWebhookConfigurationList(V1ValidatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1TokenReview +// { +// public static explicit operator V1TokenReview(V1beta1TokenReview s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1TokenReview +// { +// public static explicit operator V1beta1TokenReview(V1TokenReview s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1LocalSubjectAccessReview +// { +// public static explicit operator V1LocalSubjectAccessReview(V1beta1LocalSubjectAccessReview s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1LocalSubjectAccessReview +// { +// public static explicit operator V1beta1LocalSubjectAccessReview(V1LocalSubjectAccessReview s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SelfSubjectAccessReview +// { +// public static explicit operator V1SelfSubjectAccessReview(V1beta1SelfSubjectAccessReview s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SelfSubjectAccessReview +// { +// public static explicit operator V1beta1SelfSubjectAccessReview(V1SelfSubjectAccessReview s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SelfSubjectRulesReview +// { +// public static explicit operator V1SelfSubjectRulesReview(V1beta1SelfSubjectRulesReview s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SelfSubjectRulesReview +// { +// public static explicit operator V1beta1SelfSubjectRulesReview(V1SelfSubjectRulesReview s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SubjectAccessReview +// { +// public static explicit operator V1SubjectAccessReview(V1beta1SubjectAccessReview s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SubjectAccessReview +// { +// public static explicit operator V1beta1SubjectAccessReview(V1SubjectAccessReview s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1Lease +// { +// public static explicit operator V1Lease(V1beta1Lease s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1Lease +// { +// public static explicit operator V1beta1Lease(V1Lease s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1LeaseList +// { +// public static explicit operator V1LeaseList(V1beta1LeaseList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1LeaseList +// { +// public static explicit operator V1beta1LeaseList(V1LeaseList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1Event +// { +// public static explicit operator V1Event(V1beta1Event s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1Event +// { +// public static explicit operator V1beta1Event(V1Event s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1EventList +// { +// public static explicit operator V1EventList(V1beta1EventList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1EventList +// { +// public static explicit operator V1beta1EventList(V1EventList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ClusterRole +// { +// public static explicit operator V1ClusterRole(V1beta1ClusterRole s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ClusterRole +// { +// public static explicit operator V1beta1ClusterRole(V1ClusterRole s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ClusterRoleBinding +// { +// public static explicit operator V1ClusterRoleBinding(V1beta1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ClusterRoleBinding +// { +// public static explicit operator V1beta1ClusterRoleBinding(V1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ClusterRoleBindingList +// { +// public static explicit operator V1ClusterRoleBindingList(V1beta1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ClusterRoleBindingList +// { +// public static explicit operator V1beta1ClusterRoleBindingList(V1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ClusterRoleList +// { +// public static explicit operator V1ClusterRoleList(V1beta1ClusterRoleList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ClusterRoleList +// { +// public static explicit operator V1beta1ClusterRoleList(V1ClusterRoleList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1Role +// { +// public static explicit operator V1Role(V1beta1Role s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1Role +// { +// public static explicit operator V1beta1Role(V1Role s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1RoleBinding +// { +// public static explicit operator V1RoleBinding(V1beta1RoleBinding s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1RoleBinding +// { +// public static explicit operator V1beta1RoleBinding(V1RoleBinding s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1RoleBindingList +// { +// public static explicit operator V1RoleBindingList(V1beta1RoleBindingList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1RoleBindingList +// { +// public static explicit operator V1beta1RoleBindingList(V1RoleBindingList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1RoleList +// { +// public static explicit operator V1RoleList(V1beta1RoleList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1RoleList +// { +// public static explicit operator V1beta1RoleList(V1RoleList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1PriorityClass +// { +// public static explicit operator V1PriorityClass(V1beta1PriorityClass s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1PriorityClass +// { +// public static explicit operator V1beta1PriorityClass(V1PriorityClass s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1PriorityClassList +// { +// public static explicit operator V1PriorityClassList(V1beta1PriorityClassList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1PriorityClassList +// { +// public static explicit operator V1beta1PriorityClassList(V1PriorityClassList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CSIDriver +// { +// public static explicit operator V1CSIDriver(V1beta1CSIDriver s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CSIDriver +// { +// public static explicit operator V1beta1CSIDriver(V1CSIDriver s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CSIDriverList +// { +// public static explicit operator V1CSIDriverList(V1beta1CSIDriverList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CSIDriverList +// { +// public static explicit operator V1beta1CSIDriverList(V1CSIDriverList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CSINode +// { +// public static explicit operator V1CSINode(V1beta1CSINode s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CSINode +// { +// public static explicit operator V1beta1CSINode(V1CSINode s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CSINodeList +// { +// public static explicit operator V1CSINodeList(V1beta1CSINodeList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CSINodeList +// { +// public static explicit operator V1beta1CSINodeList(V1CSINodeList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1StorageClass +// { +// public static explicit operator V1StorageClass(V1beta1StorageClass s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1StorageClass +// { +// public static explicit operator V1beta1StorageClass(V1StorageClass s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1StorageClassList +// { +// public static explicit operator V1StorageClassList(V1beta1StorageClassList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1StorageClassList +// { +// public static explicit operator V1beta1StorageClassList(V1StorageClassList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1VolumeAttachment +// { +// public static explicit operator V1VolumeAttachment(V1beta1VolumeAttachment s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1VolumeAttachment +// { +// public static explicit operator V1beta1VolumeAttachment(V1VolumeAttachment s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1VolumeAttachmentList +// { +// public static explicit operator V1VolumeAttachmentList(V1beta1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1VolumeAttachmentList +// { +// public static explicit operator V1beta1VolumeAttachmentList(V1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceDefinition +// { +// public static explicit operator V1CustomResourceDefinition(V1beta1CustomResourceDefinition s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceDefinition +// { +// public static explicit operator V1beta1CustomResourceDefinition(V1CustomResourceDefinition s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceDefinitionList +// { +// public static explicit operator V1CustomResourceDefinitionList(V1beta1CustomResourceDefinitionList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceDefinitionList +// { +// public static explicit operator V1beta1CustomResourceDefinitionList(V1CustomResourceDefinitionList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1APIService +// { +// public static explicit operator V1APIService(V1beta1APIService s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1APIService +// { +// public static explicit operator V1beta1APIService(V1APIService s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1APIServiceList +// { +// public static explicit operator V1APIServiceList(V1beta1APIServiceList s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1APIServiceList +// { +// public static explicit operator V1beta1APIServiceList(V1APIServiceList s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1AggregationRule +// { +// public static explicit operator V1AggregationRule(V1beta1AggregationRule s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1AggregationRule +// { +// public static explicit operator V1beta1AggregationRule(V1AggregationRule s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1APIServiceCondition +// { +// public static explicit operator V1APIServiceCondition(V1beta1APIServiceCondition s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1APIServiceCondition +// { +// public static explicit operator V1beta1APIServiceCondition(V1APIServiceCondition s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1APIServiceSpec +// { +// public static explicit operator V1APIServiceSpec(V1beta1APIServiceSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1APIServiceSpec +// { +// public static explicit operator V1beta1APIServiceSpec(V1APIServiceSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1APIServiceStatus +// { +// public static explicit operator V1APIServiceStatus(V1beta1APIServiceStatus s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1APIServiceStatus +// { +// public static explicit operator V1beta1APIServiceStatus(V1APIServiceStatus s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CSIDriverSpec +// { +// public static explicit operator V1CSIDriverSpec(V1beta1CSIDriverSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CSIDriverSpec +// { +// public static explicit operator V1beta1CSIDriverSpec(V1CSIDriverSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CSINodeDriver +// { +// public static explicit operator V1CSINodeDriver(V1beta1CSINodeDriver s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CSINodeDriver +// { +// public static explicit operator V1beta1CSINodeDriver(V1CSINodeDriver s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CSINodeSpec +// { +// public static explicit operator V1CSINodeSpec(V1beta1CSINodeSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CSINodeSpec +// { +// public static explicit operator V1beta1CSINodeSpec(V1CSINodeSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceColumnDefinition +// { +// public static explicit operator V1CustomResourceColumnDefinition(V1beta1CustomResourceColumnDefinition s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceColumnDefinition +// { +// public static explicit operator V1beta1CustomResourceColumnDefinition(V1CustomResourceColumnDefinition s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceConversion +// { +// public static explicit operator V1CustomResourceConversion(V1beta1CustomResourceConversion s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceConversion +// { +// public static explicit operator V1beta1CustomResourceConversion(V1CustomResourceConversion s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceDefinitionCondition +// { +// public static explicit operator V1CustomResourceDefinitionCondition(V1beta1CustomResourceDefinitionCondition s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceDefinitionCondition +// { +// public static explicit operator V1beta1CustomResourceDefinitionCondition(V1CustomResourceDefinitionCondition s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceDefinitionNames +// { +// public static explicit operator V1CustomResourceDefinitionNames(V1beta1CustomResourceDefinitionNames s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceDefinitionNames +// { +// public static explicit operator V1beta1CustomResourceDefinitionNames(V1CustomResourceDefinitionNames s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceDefinitionSpec +// { +// public static explicit operator V1CustomResourceDefinitionSpec(V1beta1CustomResourceDefinitionSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceDefinitionSpec +// { +// public static explicit operator V1beta1CustomResourceDefinitionSpec(V1CustomResourceDefinitionSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceDefinitionStatus +// { +// public static explicit operator V1CustomResourceDefinitionStatus(V1beta1CustomResourceDefinitionStatus s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceDefinitionStatus +// { +// public static explicit operator V1beta1CustomResourceDefinitionStatus(V1CustomResourceDefinitionStatus s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceDefinitionVersion +// { +// public static explicit operator V1CustomResourceDefinitionVersion(V1beta1CustomResourceDefinitionVersion s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceDefinitionVersion +// { +// public static explicit operator V1beta1CustomResourceDefinitionVersion(V1CustomResourceDefinitionVersion s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceSubresources +// { +// public static explicit operator V1CustomResourceSubresources(V1beta1CustomResourceSubresources s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceSubresources +// { +// public static explicit operator V1beta1CustomResourceSubresources(V1CustomResourceSubresources s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceSubresourceScale +// { +// public static explicit operator V1CustomResourceSubresourceScale(V1beta1CustomResourceSubresourceScale s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceSubresourceScale +// { +// public static explicit operator V1beta1CustomResourceSubresourceScale(V1CustomResourceSubresourceScale s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1CustomResourceValidation +// { +// public static explicit operator V1CustomResourceValidation(V1beta1CustomResourceValidation s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1CustomResourceValidation +// { +// public static explicit operator V1beta1CustomResourceValidation(V1CustomResourceValidation s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1EndpointPort +// { +// public static explicit operator V1EndpointPort(V1beta1EndpointPort s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1EndpointPort +// { +// public static explicit operator V1beta1EndpointPort(V1EndpointPort s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1EventSeries +// { +// public static explicit operator V1EventSeries(V1beta1EventSeries s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1EventSeries +// { +// public static explicit operator V1beta1EventSeries(V1EventSeries s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ExternalDocumentation +// { +// public static explicit operator V1ExternalDocumentation(V1beta1ExternalDocumentation s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ExternalDocumentation +// { +// public static explicit operator V1beta1ExternalDocumentation(V1ExternalDocumentation s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1JSONSchemaProps +// { +// public static explicit operator V1JSONSchemaProps(V1beta1JSONSchemaProps s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1JSONSchemaProps +// { +// public static explicit operator V1beta1JSONSchemaProps(V1JSONSchemaProps s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1LeaseSpec +// { +// public static explicit operator V1LeaseSpec(V1beta1LeaseSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1LeaseSpec +// { +// public static explicit operator V1beta1LeaseSpec(V1LeaseSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1MutatingWebhook +// { +// public static explicit operator V1MutatingWebhook(V1beta1MutatingWebhook s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1MutatingWebhook +// { +// public static explicit operator V1beta1MutatingWebhook(V1MutatingWebhook s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1NonResourceAttributes +// { +// public static explicit operator V1NonResourceAttributes(V1beta1NonResourceAttributes s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1NonResourceAttributes +// { +// public static explicit operator V1beta1NonResourceAttributes(V1NonResourceAttributes s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1NonResourceRule +// { +// public static explicit operator V1NonResourceRule(V1beta1NonResourceRule s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1NonResourceRule +// { +// public static explicit operator V1beta1NonResourceRule(V1NonResourceRule s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1PolicyRule +// { +// public static explicit operator V1PolicyRule(V1beta1PolicyRule s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1PolicyRule +// { +// public static explicit operator V1beta1PolicyRule(V1PolicyRule s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ResourceAttributes +// { +// public static explicit operator V1ResourceAttributes(V1beta1ResourceAttributes s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ResourceAttributes +// { +// public static explicit operator V1beta1ResourceAttributes(V1ResourceAttributes s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ResourceRule +// { +// public static explicit operator V1ResourceRule(V1beta1ResourceRule s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ResourceRule +// { +// public static explicit operator V1beta1ResourceRule(V1ResourceRule s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1RoleRef +// { +// public static explicit operator V1RoleRef(V1beta1RoleRef s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1RoleRef +// { +// public static explicit operator V1beta1RoleRef(V1RoleRef s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1RuleWithOperations +// { +// public static explicit operator V1RuleWithOperations(V1beta1RuleWithOperations s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1RuleWithOperations +// { +// public static explicit operator V1beta1RuleWithOperations(V1RuleWithOperations s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SelfSubjectAccessReviewSpec +// { +// public static explicit operator V1SelfSubjectAccessReviewSpec(V1beta1SelfSubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SelfSubjectAccessReviewSpec +// { +// public static explicit operator V1beta1SelfSubjectAccessReviewSpec(V1SelfSubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SelfSubjectRulesReviewSpec +// { +// public static explicit operator V1SelfSubjectRulesReviewSpec(V1beta1SelfSubjectRulesReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SelfSubjectRulesReviewSpec +// { +// public static explicit operator V1beta1SelfSubjectRulesReviewSpec(V1SelfSubjectRulesReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1Subject +// { +// public static explicit operator V1Subject(V1beta1Subject s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1Subject +// { +// public static explicit operator V1beta1Subject(V1Subject s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SubjectAccessReviewSpec +// { +// public static explicit operator V1SubjectAccessReviewSpec(V1beta1SubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SubjectAccessReviewSpec +// { +// public static explicit operator V1beta1SubjectAccessReviewSpec(V1SubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SubjectAccessReviewStatus +// { +// public static explicit operator V1SubjectAccessReviewStatus(V1beta1SubjectAccessReviewStatus s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SubjectAccessReviewStatus +// { +// public static explicit operator V1beta1SubjectAccessReviewStatus(V1SubjectAccessReviewStatus s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1SubjectRulesReviewStatus +// { +// public static explicit operator V1SubjectRulesReviewStatus(V1beta1SubjectRulesReviewStatus s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1SubjectRulesReviewStatus +// { +// public static explicit operator V1beta1SubjectRulesReviewStatus(V1SubjectRulesReviewStatus s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1TokenReviewSpec +// { +// public static explicit operator V1TokenReviewSpec(V1beta1TokenReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1TokenReviewSpec +// { +// public static explicit operator V1beta1TokenReviewSpec(V1TokenReviewSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1TokenReviewStatus +// { +// public static explicit operator V1TokenReviewStatus(V1beta1TokenReviewStatus s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1TokenReviewStatus +// { +// public static explicit operator V1beta1TokenReviewStatus(V1TokenReviewStatus s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1UserInfo +// { +// public static explicit operator V1UserInfo(V1beta1UserInfo s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1UserInfo +// { +// public static explicit operator V1beta1UserInfo(V1UserInfo s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1ValidatingWebhook +// { +// public static explicit operator V1ValidatingWebhook(V1beta1ValidatingWebhook s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1ValidatingWebhook +// { +// public static explicit operator V1beta1ValidatingWebhook(V1ValidatingWebhook s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1VolumeAttachmentSource +// { +// public static explicit operator V1VolumeAttachmentSource(V1beta1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1VolumeAttachmentSource +// { +// public static explicit operator V1beta1VolumeAttachmentSource(V1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1VolumeAttachmentSpec +// { +// public static explicit operator V1VolumeAttachmentSpec(V1beta1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1VolumeAttachmentSpec +// { +// public static explicit operator V1beta1VolumeAttachmentSpec(V1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1VolumeAttachmentStatus +// { +// public static explicit operator V1VolumeAttachmentStatus(V1beta1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1VolumeAttachmentStatus +// { +// public static explicit operator V1beta1VolumeAttachmentStatus(V1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1VolumeError +// { +// public static explicit operator V1VolumeError(V1beta1VolumeError s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1VolumeError +// { +// public static explicit operator V1beta1VolumeError(V1VolumeError s) => VersionConverter.Mapper.Map(s); +// } +// +// public partial class V1VolumeNodeResources +// { +// public static explicit operator V1VolumeNodeResources(V1beta1VolumeNodeResources s) => VersionConverter.Mapper.Map(s); +// } +// public partial class V1beta1VolumeNodeResources +// { +// public static explicit operator V1beta1VolumeNodeResources(V1VolumeNodeResources s) => VersionConverter.Mapper.Map(s); +// } +// +// +// +// } diff --git a/src/KubernetesClient/Versioning/VersionConverter.cs b/src/KubernetesClient/Versioning/VersionConverter.cs new file mode 100644 index 0000000..7e82ad6 --- /dev/null +++ b/src/KubernetesClient/Versioning/VersionConverter.cs @@ -0,0 +1,416 @@ +// WARNING: DO NOT LEAVE COMMENTED CODE IN THIS FILE. IT GETS SCANNED BY GEN PROJECT SO IT CAN EXCLUDE ANY MANUALLY DEFINED MAPS + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using AutoMapper; +using k8s.Models; +using Newtonsoft.Json; + +namespace k8s.Versioning +{ + /// + /// Provides mappers that converts Kubernetes models between different versions + /// + public static partial class VersionConverter + { + static VersionConverter() + { + UpdateMappingConfiguration(expression => { }); + } + + public static IMapper Mapper { get; private set; } + internal static MapperConfiguration MapperConfiguration { get; private set; } + + /// + /// Two level lookup of model types by Kind and then Version + /// + internal static Dictionary> KindVersionsMap { get; private set; } + + public static Type GetTypeForVersion(string version) + { + return GetTypeForVersion(typeof(T), version); + } + + public static Type GetTypeForVersion(Type type, string version) + { + return KindVersionsMap[type.GetKubernetesTypeMetadata().Kind][version]; + } + + public static void UpdateMappingConfiguration(Action configuration) + { + MapperConfiguration = new MapperConfiguration(cfg => + { + GetConfigurations(cfg); + configuration(cfg); + }); + Mapper = MapperConfiguration.CreateMapper(); + KindVersionsMap = MapperConfiguration + .GetAllTypeMaps() + .SelectMany(x => new[] { x.Types.SourceType, x.Types.DestinationType }) + .Where(x => x.GetCustomAttribute() != null) + .Select(x => + { + var attr = GetKubernetesEntityAttribute(x); + return new { attr.Kind, attr.ApiVersion, Type = x }; + }) + .GroupBy(x => x.Kind) + .ToDictionary(x => x.Key, kindGroup => kindGroup + .GroupBy(x => x.ApiVersion) + .ToDictionary(x => x.Key, + versionGroup => versionGroup.Select(x => x.Type).Distinct().Single())); // should only be one type for each Kind/Version combination + } + + public static object ConvertToVersion(object source, string apiVersion) + { + var type = source.GetType(); + var attr = GetKubernetesEntityAttribute(type); + if (attr.ApiVersion == apiVersion) + { + return source; + } + + if (!KindVersionsMap.TryGetValue(attr.Kind, out var kindVersions)) + { + throw new InvalidOperationException($"Version converter does not have any registered types for Kind `{attr.Kind}`"); + } + + if (!kindVersions.TryGetValue(apiVersion, out var targetType) || !kindVersions.TryGetValue(attr.ApiVersion, out var sourceType) || MapperConfiguration.FindTypeMapFor(sourceType, targetType) == null) + { + throw new InvalidOperationException($"There is no conversion mapping registered for Kind `{attr.Kind}` from ApiVersion {attr.ApiVersion} to {apiVersion}"); + } + + return Mapper.Map(source, sourceType, targetType); + } + + private static KubernetesEntityAttribute GetKubernetesEntityAttribute(Type type) + { + if (type == null) + { + throw new ArgumentNullException(nameof(type)); + } + + var attr = type.GetCustomAttribute(); + if (attr == null) + { + throw new InvalidOperationException($"Type {type} does not have {nameof(KubernetesEntityAttribute)}"); + } + + return attr; + } + + internal static void GetConfigurations(IMapperConfigurationExpression cfg) + { + AutoConfigurations(cfg); + ManualConfigurations(cfg); + } + + private static void ManualConfigurations(IMapperConfigurationExpression cfg) + { + cfg.AllowNullCollections = true; + cfg.DisableConstructorMapping(); + cfg.ForAllMaps((typeMap, opt) => + { + if (!typeof(IKubernetesObject).IsAssignableFrom(typeMap.Types.DestinationType)) + { + return; + } + + var metadata = typeMap.Types.DestinationType.GetKubernetesTypeMetadata(); + opt.ForMember(nameof(IKubernetesObject.ApiVersion), x => x.Ignore()); + opt.ForMember(nameof(IKubernetesObject.Kind), x => x.Ignore()); + opt.AfterMap((from, to) => + { + var obj = (IKubernetesObject)to; + obj.ApiVersion = !string.IsNullOrEmpty(metadata.Group) ? $"{metadata.Group}/{metadata.ApiVersion}" : metadata.ApiVersion; + obj.Kind = metadata.Kind; + }); + }); + cfg.CreateMap() + .ForMember(dest => dest.ApiVersion, opt => opt.Ignore()) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.ApiVersion, opt => opt.Ignore()) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.Handler, opt => opt.MapFrom(src => src.Spec.RuntimeHandler)) + .ForMember(dest => dest.Overhead, opt => opt.MapFrom(src => src.Spec.Overhead)) + .ForMember(dest => dest.Scheduling, opt => opt.MapFrom(src => src.Spec.Scheduling)) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.AverageValue, opt => opt.MapFrom(src => src.CurrentAverageValue)) + .ForMember(dest => dest.AverageUtilization, opt => opt.MapFrom(src => src.CurrentAverageUtilization)) + .ForMember(dest => dest.Value, opt => opt.Ignore()); + cfg.CreateMap() + .ForMember(dest => dest.Current, opt => opt.MapFrom(src => src)); + cfg.CreateMap() + .ForMember(dest => dest.CurrentAverageValue, opt => opt.MapFrom(src => src.Current.AverageValue)) + .ForMember(dest => dest.CurrentAverageUtilization, opt => opt.MapFrom(src => src.Current.AverageUtilization)); + cfg.CreateMap() + .ForMember(dest => dest.AverageValue, opt => opt.MapFrom(src => src.TargetAverageValue)) + .ForMember(dest => dest.Value, opt => opt.Ignore()) +#if NET452 + .ForMember(dest => dest.Type, opt => opt.ResolveUsing(src => src.TargetAverageValue != null ? "AverageValue" : "Utilization" )) +#else + .ForMember(dest => dest.Type, opt => opt.MapFrom((src, dest) => src.TargetAverageValue != null ? "AverageValue" : "Utilization")) +#endif + .ForMember(dest => dest.AverageUtilization, opt => opt.MapFrom(src => src.TargetAverageUtilization)); + cfg.CreateMap() + .ForMember(dest => dest.Target, opt => opt.MapFrom(src => src)); + cfg.CreateMap() + .ForMember(dest => dest.TargetAverageUtilization, opt => opt.MapFrom(src => src.Target.AverageUtilization)) + .ForMember(dest => dest.TargetAverageValue, opt => opt.MapFrom(src => src.Target.Value)); + cfg.CreateMap() + .ForMember(dest => dest.AverageValue, opt => opt.MapFrom(src => src.CurrentAverageValue)) + .ForMember(dest => dest.Value, opt => opt.Ignore()) + .ForMember(dest => dest.AverageUtilization, opt => opt.Ignore()); + cfg.CreateMap() + .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.MetricName)) + .ForMember(dest => dest.Selector, opt => opt.MapFrom(src => src.Selector)); + cfg.CreateMap() + .ForMember(dest => dest.Current, opt => opt.MapFrom(src => src)) + .ForMember(dest => dest.Metric, opt => opt.MapFrom(src => src)); + cfg.CreateMap() + .ForMember(dest => dest.Selector, opt => opt.MapFrom(src => src.Metric.Selector)) + .ForMember(dest => dest.CurrentAverageValue, opt => opt.MapFrom(src => src.Current.AverageValue)) + .ForMember(dest => dest.MetricName, opt => opt.MapFrom(src => src.Metric.Name)); + cfg.CreateMap() + .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.MetricName)) + .ForMember(dest => dest.Selector, opt => opt.MapFrom(src => src.Selector)) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.AverageValue, opt => opt.MapFrom(src => src.TargetAverageValue)) +#if NET452 + .ForMember(dest => dest.Type, opt => opt.UseValue("AverageValue")) +#else + .ForMember(dest => dest.Type, opt => opt.MapFrom((src, dest) => "AverageValue")) +#endif + .ForMember(dest => dest.Value, opt => opt.Ignore()) + .ForMember(dest => dest.AverageUtilization, opt => opt.Ignore()); + cfg.CreateMap() + .ForMember(dest => dest.Metric, opt => opt.MapFrom(src => src)) + .ForMember(dest => dest.Target, opt => opt.MapFrom(src => src)); + cfg.CreateMap() + .ForMember(x => x.Selector, opt => opt.MapFrom(src => src.Metric.Selector)) + .ForMember(x => x.MetricName, opt => opt.MapFrom(src => src.Metric.Name)) + .ForMember(x => x.TargetAverageValue, opt => opt.MapFrom(src => src.Target.AverageValue)); + cfg.CreateMap() + .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.MetricName)) + .ForMember(dest => dest.Selector, opt => opt.MapFrom(src => src.Selector)) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.Value, opt => opt.MapFrom(src => src.CurrentValue)) + .ForMember(dest => dest.AverageValue, opt => opt.MapFrom(src => src.AverageValue)) + .ForMember(dest => dest.AverageUtilization, opt => opt.Ignore()) + .ReverseMap(); + cfg.CreateMap() + .ForMember(x => x.Current, opt => opt.MapFrom(src => src)) + .ForMember(x => x.Metric, opt => opt.MapFrom(src => src)) + .ForMember(x => x.DescribedObject, opt => opt.MapFrom(src => src.Target)); + cfg.CreateMap() + .ForMember(x => x.CurrentValue, opt => opt.MapFrom(src => src.Current.Value)) + .ForMember(x => x.AverageValue, opt => opt.MapFrom(src => src.Current.AverageValue)) + .ForMember(x => x.MetricName, opt => opt.MapFrom(src => src.Metric.Name)) + .ForMember(x => x.Target, opt => opt.MapFrom(src => src.DescribedObject)) + .ForMember(x => x.Selector, opt => opt.MapFrom(src => src.Metric.Selector)); + cfg.CreateMap() + .ForMember(x => x.Value, opt => opt.MapFrom(src => src.TargetValue)) + .ForMember(x => x.AverageValue, opt => opt.MapFrom(src => src.TargetAverageValue)) + .ForMember(x => x.AverageUtilization, opt => opt.Ignore()) +#if NET452 + .ForMember(x => x.Type, opt => opt.ResolveUsing(src => src.TargetValue != null ? "Value" : "AverageValue")); +#else + .ForMember(x => x.Type, opt => opt.MapFrom((src, dest) => src.TargetValue != null ? "Value" : "AverageValue")); +#endif + cfg.CreateMap() + .ForMember(x => x.Metric, opt => opt.MapFrom(src => src)) + .ForMember(x => x.Target, opt => opt.MapFrom(src => src)); + cfg.CreateMap() + .ForMember(x => x.TargetValue, opt => opt.MapFrom(src => src.Target.Value)) + .ForMember(x => x.TargetAverageValue, opt => opt.MapFrom(src => src.Target.AverageValue)) + .ForMember(x => x.MetricName, opt => opt.MapFrom(src => src.Metric.Name)) + .ForMember(x => x.MetricSelector, opt => opt.MapFrom(src => src.Metric.Selector)); + cfg.CreateMap() + .ForMember(x => x.Current, opt => opt.MapFrom(src => src)) + .ForMember(x => x.Metric, opt => opt.MapFrom(src => src)); + cfg.CreateMap() + .ForMember(x => x.CurrentValue, opt => opt.MapFrom(src => src.Current.Value)) + .ForMember(x => x.CurrentAverageValue, opt => opt.MapFrom(src => src.Current.AverageValue)) + .ForMember(x => x.MetricName, opt => opt.MapFrom(src => src.Metric.Name)) + .ForMember(x => x.MetricSelector, opt => opt.MapFrom(src => src.Metric.Selector)); + cfg.CreateMap() + .ForMember(x => x.Name, opt => opt.MapFrom(src => src.MetricName)) + .ForMember(x => x.Selector, opt => opt.MapFrom(src => src.MetricSelector)) + .ReverseMap(); + cfg.CreateMap() + .ForMember(x => x.Value, opt => opt.MapFrom(src => src.CurrentValue)) + .ForMember(x => x.AverageValue, opt => opt.MapFrom(src => src.CurrentAverageValue)) + .ForMember(x => x.AverageUtilization, opt => opt.Ignore()) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.Value, opt => opt.MapFrom(src => src.TargetValue)) + .ForMember(dest => dest.AverageUtilization, opt => opt.Ignore()) + .ForMember(dest => dest.AverageValue, opt => opt.MapFrom(src => src.AverageValue)) +#if NET452 + .ForMember(dest => dest.Type, opt => opt.ResolveUsing(src => src.TargetValue != null ? "Value" : "AverageValue")); +#else + .ForMember(dest => dest.Type, opt => opt.MapFrom((src, dest) => src.TargetValue != null ? "Value" : "AverageValue")); +#endif + cfg.CreateMap() + .ForMember(dest => dest.Metric, opt => opt.MapFrom(src => src)) + .ForMember(dest => dest.Target, opt => opt.MapFrom(src => src)) + .ForMember(dest => dest.DescribedObject, opt => opt.MapFrom(src => src.Target)); + cfg.CreateMap() + .ForMember(dest => dest.Target, opt => opt.MapFrom(src => src.DescribedObject)) + .ForMember(dest => dest.MetricName, opt => opt.MapFrom(src => src.Metric.Name)) + .ForMember(dest => dest.TargetValue, opt => opt.MapFrom(src => src.Target.Value)) + .ForMember(dest => dest.AverageValue, opt => opt.MapFrom(src => src.Target.AverageValue)) + .ForMember(dest => dest.Selector, opt => opt.MapFrom(src => src.Metric.Selector)); + cfg.CreateMap() + .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.MetricName)) + .ForMember(dest => dest.Selector, opt => opt.MapFrom(src => src.Selector)) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.MetricName)) + .ForMember(dest => dest.Selector, opt => opt.MapFrom(src => src.MetricSelector)); + cfg.CreateMap() // todo: not needed + .ForMember(dest => dest.MetricName, opt => opt.Ignore()) + .ForMember(dest => dest.MetricSelector, opt => opt.Ignore()) + .ForMember(dest => dest.TargetValue, opt => opt.MapFrom(src => src.Value)) + .ForMember(dest => dest.TargetValue, opt => opt.MapFrom(src => src.Value)) + .ForMember(dest => dest.TargetAverageValue, opt => opt.MapFrom(src => src.AverageValue)); + cfg.CreateMap() + .ForMember(dest => dest.ClientConfig, opt => opt.MapFrom(src => src.WebhookClientConfig)) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.Group, opt => opt.MapFrom(src => src.Groups)) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.AdditionalPrinterColumns, opt => opt.Ignore()) + .ForMember(dest => dest.Subresources, opt => opt.Ignore()) + .ForMember(dest => dest.Validation, opt => opt.Ignore()) + .ForMember(dest => dest.Version, opt => opt.Ignore()) + .AfterMap((from, to) => + { + // in v1beta1, if all versions share the same common attributes, they should be declared once at parent level + if (to.Versions == null) + { + return; + } + + if (to.Versions.Select(x => JsonConvert.SerializeObject(x.Schema)).Distinct().Count() == 1) + { + to.Validation = to.Versions.First().Schema; + foreach (var version in to.Versions) + { + version.Schema = null; + } + } + + var allPrintColumnsInAllVersionsTheSame = to.Versions + .GroupBy(x => x.Name) + .Select(v => v + .OrderBy(x => x.Name) + .Select(x => x.AdditionalPrinterColumns) + .Select(JsonConvert.SerializeObject) + .Aggregate(new StringBuilder(), (sb, s) => sb.Append(s), sb => sb.ToString())) + .Distinct() + .Count() == 1; + + if (allPrintColumnsInAllVersionsTheSame) + { + to.AdditionalPrinterColumns = to.Versions[0].AdditionalPrinterColumns; + foreach (var version in to.Versions) + { + version.AdditionalPrinterColumns = null; + } + } + + var allSubresourcesInAllVersionsTheSame = to.Versions + .GroupBy(x => x.Name) + .Select(v => v + .OrderBy(x => x.Name) + .Select(x => x.Subresources) + .Select(JsonConvert.SerializeObject) + .Aggregate(new StringBuilder(), (sb, s) => sb.Append(s), sb => sb.ToString())) + .Distinct() + .Count() == 1; + + if (allSubresourcesInAllVersionsTheSame) + { + to.Subresources = to.Versions[0].Subresources; + foreach (var version in to.Versions) + { + version.Subresources = null; + } + } + }) + .ReverseMap() + .AfterMap((from, to) => + { + if (from.Validation?.OpenAPIV3Schema != null) + { + foreach (var version in to.Versions) + { + version.Schema = (V1CustomResourceValidation)@from.Validation; + } + } + + if (from.Subresources != null) + { + foreach (var version in to.Versions) + { + version.Subresources = (V1CustomResourceSubresources)@from.Subresources; + } + } + + if (from.AdditionalPrinterColumns != null) + { + foreach (var version in to.Versions) + { + version.AdditionalPrinterColumns = @from.AdditionalPrinterColumns.Select(x => (V1CustomResourceColumnDefinition)x).ToList(); + } + } + }); + + cfg.CreateMap() + .ForMember(dest => dest.ConversionReviewVersions, opt => opt.MapFrom(src => src.Webhook.ConversionReviewVersions)) + .ForMember(dest => dest.WebhookClientConfig, opt => opt.MapFrom(src => src.Webhook.ClientConfig)) + .ReverseMap(); + + cfg.CreateMap() + .ForMember(dest => dest.Metrics, opt => opt.Ignore()) + .ForMember(dest => dest.Behavior, opt => opt.Ignore()) + .ReverseMap(); + + cfg.CreateMap() + .ForMember(dest => dest.Metrics, opt => opt.Ignore()) + .ReverseMap(); + + cfg.CreateMap() + .ForMember(dest => dest.Behavior, opt => opt.Ignore()) + .ReverseMap(); + + cfg.CreateMap() + .ForMember(dest => dest.Conditions, opt => opt.Ignore()) + .ForMember(dest => dest.CurrentMetrics, opt => opt.Ignore()) + .ReverseMap(); + cfg.CreateMap() + .ForMember(dest => dest.Conditions, opt => opt.Ignore()) + .ForMember(dest => dest.CurrentMetrics, opt => opt.Ignore()) + .ReverseMap(); + + cfg.CreateMap() + .ForMember(dest => dest.DeprecatedCount, opt => opt.Ignore()) + .ForMember(dest => dest.DeprecatedFirstTimestamp, opt => opt.MapFrom(src => src.FirstTimestamp)) + .ForMember(dest => dest.DeprecatedLastTimestamp, opt => opt.MapFrom(src => src.LastTimestamp)) + .ForMember(dest => dest.DeprecatedSource, opt => opt.MapFrom(src => src.Source)) + .ForMember(dest => dest.Note, opt => opt.MapFrom(src => src.Message)) + .ForMember(dest => dest.Regarding, opt => opt.MapFrom(src => src.InvolvedObject)) + .ForMember(dest => dest.ReportingController, opt => opt.MapFrom(src => src.ReportingComponent)) + .ReverseMap(); + } + } +} diff --git a/src/KubernetesClient/generated/ModelOperators.cs b/src/KubernetesClient/generated/ModelOperators.cs new file mode 100644 index 0000000..13a909c --- /dev/null +++ b/src/KubernetesClient/generated/ModelOperators.cs @@ -0,0 +1,1269 @@ +using k8s.Versioning; + +namespace k8s.Models +{ + public partial class Admissionregistrationv1beta1ServiceReference + { + public static explicit operator Admissionregistrationv1beta1ServiceReference(Admissionregistrationv1ServiceReference s) => VersionConverter.Mapper.Map(s); + } + public partial class Admissionregistrationv1ServiceReference + { + public static explicit operator Admissionregistrationv1ServiceReference(Admissionregistrationv1beta1ServiceReference s) => VersionConverter.Mapper.Map(s); + } + public partial class Admissionregistrationv1beta1WebhookClientConfig + { + public static explicit operator Admissionregistrationv1beta1WebhookClientConfig(Admissionregistrationv1WebhookClientConfig s) => VersionConverter.Mapper.Map(s); + } + public partial class Admissionregistrationv1WebhookClientConfig + { + public static explicit operator Admissionregistrationv1WebhookClientConfig(Admissionregistrationv1beta1WebhookClientConfig s) => VersionConverter.Mapper.Map(s); + } + public partial class V1AggregationRule + { + public static explicit operator V1AggregationRule(V1alpha1AggregationRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1AggregationRule + { + public static explicit operator V1alpha1AggregationRule(V1AggregationRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1AggregationRule + { + public static explicit operator V1AggregationRule(V1beta1AggregationRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1AggregationRule + { + public static explicit operator V1beta1AggregationRule(V1AggregationRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1AggregationRule + { + public static explicit operator V1alpha1AggregationRule(V1beta1AggregationRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1AggregationRule + { + public static explicit operator V1beta1AggregationRule(V1alpha1AggregationRule s) => VersionConverter.Mapper.Map(s); + } + public partial class Apiextensionsv1beta1ServiceReference + { + public static explicit operator Apiextensionsv1beta1ServiceReference(Apiextensionsv1ServiceReference s) => VersionConverter.Mapper.Map(s); + } + public partial class Apiextensionsv1ServiceReference + { + public static explicit operator Apiextensionsv1ServiceReference(Apiextensionsv1beta1ServiceReference s) => VersionConverter.Mapper.Map(s); + } + public partial class Apiextensionsv1beta1WebhookClientConfig + { + public static explicit operator Apiextensionsv1beta1WebhookClientConfig(Apiextensionsv1WebhookClientConfig s) => VersionConverter.Mapper.Map(s); + } + public partial class Apiextensionsv1WebhookClientConfig + { + public static explicit operator Apiextensionsv1WebhookClientConfig(Apiextensionsv1beta1WebhookClientConfig s) => VersionConverter.Mapper.Map(s); + } + public partial class Apiregistrationv1beta1ServiceReference + { + public static explicit operator Apiregistrationv1beta1ServiceReference(Apiregistrationv1ServiceReference s) => VersionConverter.Mapper.Map(s); + } + public partial class Apiregistrationv1ServiceReference + { + public static explicit operator Apiregistrationv1ServiceReference(Apiregistrationv1beta1ServiceReference s) => VersionConverter.Mapper.Map(s); + } + public partial class V1APIService + { + public static explicit operator V1APIService(V1beta1APIService s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1APIService + { + public static explicit operator V1beta1APIService(V1APIService s) => VersionConverter.Mapper.Map(s); + } + public partial class V1APIServiceCondition + { + public static explicit operator V1APIServiceCondition(V1beta1APIServiceCondition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1APIServiceCondition + { + public static explicit operator V1beta1APIServiceCondition(V1APIServiceCondition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1APIServiceList + { + public static explicit operator V1APIServiceList(V1beta1APIServiceList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1APIServiceList + { + public static explicit operator V1beta1APIServiceList(V1APIServiceList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1APIServiceSpec + { + public static explicit operator V1APIServiceSpec(V1beta1APIServiceSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1APIServiceSpec + { + public static explicit operator V1beta1APIServiceSpec(V1APIServiceSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1APIServiceStatus + { + public static explicit operator V1APIServiceStatus(V1beta1APIServiceStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1APIServiceStatus + { + public static explicit operator V1beta1APIServiceStatus(V1APIServiceStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRole + { + public static explicit operator V1alpha1ClusterRole(V1beta1ClusterRole s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRole + { + public static explicit operator V1beta1ClusterRole(V1alpha1ClusterRole s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRole + { + public static explicit operator V1alpha1ClusterRole(V1ClusterRole s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRole + { + public static explicit operator V1ClusterRole(V1alpha1ClusterRole s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRole + { + public static explicit operator V1beta1ClusterRole(V1ClusterRole s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRole + { + public static explicit operator V1ClusterRole(V1beta1ClusterRole s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRoleBinding + { + public static explicit operator V1alpha1ClusterRoleBinding(V1beta1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRoleBinding + { + public static explicit operator V1beta1ClusterRoleBinding(V1alpha1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRoleBinding + { + public static explicit operator V1alpha1ClusterRoleBinding(V1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRoleBinding + { + public static explicit operator V1ClusterRoleBinding(V1alpha1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRoleBinding + { + public static explicit operator V1beta1ClusterRoleBinding(V1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRoleBinding + { + public static explicit operator V1ClusterRoleBinding(V1beta1ClusterRoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRoleBindingList + { + public static explicit operator V1alpha1ClusterRoleBindingList(V1beta1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRoleBindingList + { + public static explicit operator V1beta1ClusterRoleBindingList(V1alpha1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRoleBindingList + { + public static explicit operator V1alpha1ClusterRoleBindingList(V1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRoleBindingList + { + public static explicit operator V1ClusterRoleBindingList(V1alpha1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRoleBindingList + { + public static explicit operator V1beta1ClusterRoleBindingList(V1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRoleBindingList + { + public static explicit operator V1ClusterRoleBindingList(V1beta1ClusterRoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRoleList + { + public static explicit operator V1alpha1ClusterRoleList(V1beta1ClusterRoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRoleList + { + public static explicit operator V1beta1ClusterRoleList(V1alpha1ClusterRoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1ClusterRoleList + { + public static explicit operator V1alpha1ClusterRoleList(V1ClusterRoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRoleList + { + public static explicit operator V1ClusterRoleList(V1alpha1ClusterRoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ClusterRoleList + { + public static explicit operator V1beta1ClusterRoleList(V1ClusterRoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ClusterRoleList + { + public static explicit operator V1ClusterRoleList(V1beta1ClusterRoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CronJob + { + public static explicit operator V1beta1CronJob(V2alpha1CronJob s) => VersionConverter.Mapper.Map(s); + } + public partial class V2alpha1CronJob + { + public static explicit operator V2alpha1CronJob(V1beta1CronJob s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CronJobList + { + public static explicit operator V1beta1CronJobList(V2alpha1CronJobList s) => VersionConverter.Mapper.Map(s); + } + public partial class V2alpha1CronJobList + { + public static explicit operator V2alpha1CronJobList(V1beta1CronJobList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CronJobSpec + { + public static explicit operator V1beta1CronJobSpec(V2alpha1CronJobSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2alpha1CronJobSpec + { + public static explicit operator V2alpha1CronJobSpec(V1beta1CronJobSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CronJobStatus + { + public static explicit operator V1beta1CronJobStatus(V2alpha1CronJobStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2alpha1CronJobStatus + { + public static explicit operator V2alpha1CronJobStatus(V1beta1CronJobStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CrossVersionObjectReference + { + public static explicit operator V1CrossVersionObjectReference(V2beta1CrossVersionObjectReference s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1CrossVersionObjectReference + { + public static explicit operator V2beta1CrossVersionObjectReference(V1CrossVersionObjectReference s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CrossVersionObjectReference + { + public static explicit operator V1CrossVersionObjectReference(V2beta2CrossVersionObjectReference s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2CrossVersionObjectReference + { + public static explicit operator V2beta2CrossVersionObjectReference(V1CrossVersionObjectReference s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1CrossVersionObjectReference + { + public static explicit operator V2beta1CrossVersionObjectReference(V2beta2CrossVersionObjectReference s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2CrossVersionObjectReference + { + public static explicit operator V2beta2CrossVersionObjectReference(V2beta1CrossVersionObjectReference s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CSIDriver + { + public static explicit operator V1beta1CSIDriver(V1CSIDriver s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CSIDriver + { + public static explicit operator V1CSIDriver(V1beta1CSIDriver s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CSIDriverList + { + public static explicit operator V1beta1CSIDriverList(V1CSIDriverList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CSIDriverList + { + public static explicit operator V1CSIDriverList(V1beta1CSIDriverList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CSIDriverSpec + { + public static explicit operator V1beta1CSIDriverSpec(V1CSIDriverSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CSIDriverSpec + { + public static explicit operator V1CSIDriverSpec(V1beta1CSIDriverSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CSINode + { + public static explicit operator V1beta1CSINode(V1CSINode s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CSINode + { + public static explicit operator V1CSINode(V1beta1CSINode s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CSINodeDriver + { + public static explicit operator V1beta1CSINodeDriver(V1CSINodeDriver s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CSINodeDriver + { + public static explicit operator V1CSINodeDriver(V1beta1CSINodeDriver s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CSINodeList + { + public static explicit operator V1beta1CSINodeList(V1CSINodeList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CSINodeList + { + public static explicit operator V1CSINodeList(V1beta1CSINodeList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CSINodeSpec + { + public static explicit operator V1beta1CSINodeSpec(V1CSINodeSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CSINodeSpec + { + public static explicit operator V1CSINodeSpec(V1beta1CSINodeSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceColumnDefinition + { + public static explicit operator V1beta1CustomResourceColumnDefinition(V1CustomResourceColumnDefinition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceColumnDefinition + { + public static explicit operator V1CustomResourceColumnDefinition(V1beta1CustomResourceColumnDefinition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceConversion + { + public static explicit operator V1beta1CustomResourceConversion(V1CustomResourceConversion s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceConversion + { + public static explicit operator V1CustomResourceConversion(V1beta1CustomResourceConversion s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceDefinition + { + public static explicit operator V1beta1CustomResourceDefinition(V1CustomResourceDefinition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceDefinition + { + public static explicit operator V1CustomResourceDefinition(V1beta1CustomResourceDefinition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceDefinitionCondition + { + public static explicit operator V1beta1CustomResourceDefinitionCondition(V1CustomResourceDefinitionCondition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceDefinitionCondition + { + public static explicit operator V1CustomResourceDefinitionCondition(V1beta1CustomResourceDefinitionCondition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceDefinitionList + { + public static explicit operator V1beta1CustomResourceDefinitionList(V1CustomResourceDefinitionList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceDefinitionList + { + public static explicit operator V1CustomResourceDefinitionList(V1beta1CustomResourceDefinitionList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceDefinitionNames + { + public static explicit operator V1beta1CustomResourceDefinitionNames(V1CustomResourceDefinitionNames s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceDefinitionNames + { + public static explicit operator V1CustomResourceDefinitionNames(V1beta1CustomResourceDefinitionNames s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceDefinitionSpec + { + public static explicit operator V1beta1CustomResourceDefinitionSpec(V1CustomResourceDefinitionSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceDefinitionSpec + { + public static explicit operator V1CustomResourceDefinitionSpec(V1beta1CustomResourceDefinitionSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceDefinitionStatus + { + public static explicit operator V1beta1CustomResourceDefinitionStatus(V1CustomResourceDefinitionStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceDefinitionStatus + { + public static explicit operator V1CustomResourceDefinitionStatus(V1beta1CustomResourceDefinitionStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceDefinitionVersion + { + public static explicit operator V1beta1CustomResourceDefinitionVersion(V1CustomResourceDefinitionVersion s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceDefinitionVersion + { + public static explicit operator V1CustomResourceDefinitionVersion(V1beta1CustomResourceDefinitionVersion s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceSubresources + { + public static explicit operator V1beta1CustomResourceSubresources(V1CustomResourceSubresources s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceSubresources + { + public static explicit operator V1CustomResourceSubresources(V1beta1CustomResourceSubresources s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceSubresourceScale + { + public static explicit operator V1beta1CustomResourceSubresourceScale(V1CustomResourceSubresourceScale s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceSubresourceScale + { + public static explicit operator V1CustomResourceSubresourceScale(V1beta1CustomResourceSubresourceScale s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1CustomResourceValidation + { + public static explicit operator V1beta1CustomResourceValidation(V1CustomResourceValidation s) => VersionConverter.Mapper.Map(s); + } + public partial class V1CustomResourceValidation + { + public static explicit operator V1CustomResourceValidation(V1beta1CustomResourceValidation s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1EndpointPort + { + public static explicit operator V1beta1EndpointPort(V1EndpointPort s) => VersionConverter.Mapper.Map(s); + } + public partial class V1EndpointPort + { + public static explicit operator V1EndpointPort(V1beta1EndpointPort s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1Event + { + public static explicit operator V1beta1Event(V1Event s) => VersionConverter.Mapper.Map(s); + } + public partial class V1Event + { + public static explicit operator V1Event(V1beta1Event s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1EventList + { + public static explicit operator V1beta1EventList(V1EventList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1EventList + { + public static explicit operator V1EventList(V1beta1EventList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1EventSeries + { + public static explicit operator V1beta1EventSeries(V1EventSeries s) => VersionConverter.Mapper.Map(s); + } + public partial class V1EventSeries + { + public static explicit operator V1EventSeries(V1beta1EventSeries s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ExternalDocumentation + { + public static explicit operator V1beta1ExternalDocumentation(V1ExternalDocumentation s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ExternalDocumentation + { + public static explicit operator V1ExternalDocumentation(V1beta1ExternalDocumentation s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1ExternalMetricSource + { + public static explicit operator V2beta1ExternalMetricSource(V2beta2ExternalMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2ExternalMetricSource + { + public static explicit operator V2beta2ExternalMetricSource(V2beta1ExternalMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1ExternalMetricStatus + { + public static explicit operator V2beta1ExternalMetricStatus(V2beta2ExternalMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2ExternalMetricStatus + { + public static explicit operator V2beta2ExternalMetricStatus(V2beta1ExternalMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscaler + { + public static explicit operator V1HorizontalPodAutoscaler(V2beta1HorizontalPodAutoscaler s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscaler + { + public static explicit operator V2beta1HorizontalPodAutoscaler(V1HorizontalPodAutoscaler s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscaler + { + public static explicit operator V1HorizontalPodAutoscaler(V2beta2HorizontalPodAutoscaler s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscaler + { + public static explicit operator V2beta2HorizontalPodAutoscaler(V1HorizontalPodAutoscaler s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscaler + { + public static explicit operator V2beta1HorizontalPodAutoscaler(V2beta2HorizontalPodAutoscaler s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscaler + { + public static explicit operator V2beta2HorizontalPodAutoscaler(V2beta1HorizontalPodAutoscaler s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscalerCondition + { + public static explicit operator V2beta1HorizontalPodAutoscalerCondition(V2beta2HorizontalPodAutoscalerCondition s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscalerCondition + { + public static explicit operator V2beta2HorizontalPodAutoscalerCondition(V2beta1HorizontalPodAutoscalerCondition s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscalerList + { + public static explicit operator V1HorizontalPodAutoscalerList(V2beta1HorizontalPodAutoscalerList s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscalerList + { + public static explicit operator V2beta1HorizontalPodAutoscalerList(V1HorizontalPodAutoscalerList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscalerList + { + public static explicit operator V1HorizontalPodAutoscalerList(V2beta2HorizontalPodAutoscalerList s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscalerList + { + public static explicit operator V2beta2HorizontalPodAutoscalerList(V1HorizontalPodAutoscalerList s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscalerList + { + public static explicit operator V2beta1HorizontalPodAutoscalerList(V2beta2HorizontalPodAutoscalerList s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscalerList + { + public static explicit operator V2beta2HorizontalPodAutoscalerList(V2beta1HorizontalPodAutoscalerList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscalerSpec + { + public static explicit operator V1HorizontalPodAutoscalerSpec(V2beta1HorizontalPodAutoscalerSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscalerSpec + { + public static explicit operator V2beta1HorizontalPodAutoscalerSpec(V1HorizontalPodAutoscalerSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscalerSpec + { + public static explicit operator V1HorizontalPodAutoscalerSpec(V2beta2HorizontalPodAutoscalerSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscalerSpec + { + public static explicit operator V2beta2HorizontalPodAutoscalerSpec(V1HorizontalPodAutoscalerSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscalerSpec + { + public static explicit operator V2beta1HorizontalPodAutoscalerSpec(V2beta2HorizontalPodAutoscalerSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscalerSpec + { + public static explicit operator V2beta2HorizontalPodAutoscalerSpec(V2beta1HorizontalPodAutoscalerSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscalerStatus + { + public static explicit operator V1HorizontalPodAutoscalerStatus(V2beta1HorizontalPodAutoscalerStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscalerStatus + { + public static explicit operator V2beta1HorizontalPodAutoscalerStatus(V1HorizontalPodAutoscalerStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1HorizontalPodAutoscalerStatus + { + public static explicit operator V1HorizontalPodAutoscalerStatus(V2beta2HorizontalPodAutoscalerStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscalerStatus + { + public static explicit operator V2beta2HorizontalPodAutoscalerStatus(V1HorizontalPodAutoscalerStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1HorizontalPodAutoscalerStatus + { + public static explicit operator V2beta1HorizontalPodAutoscalerStatus(V2beta2HorizontalPodAutoscalerStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2HorizontalPodAutoscalerStatus + { + public static explicit operator V2beta2HorizontalPodAutoscalerStatus(V2beta1HorizontalPodAutoscalerStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1JobTemplateSpec + { + public static explicit operator V1beta1JobTemplateSpec(V2alpha1JobTemplateSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2alpha1JobTemplateSpec + { + public static explicit operator V2alpha1JobTemplateSpec(V1beta1JobTemplateSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1JSONSchemaProps + { + public static explicit operator V1beta1JSONSchemaProps(V1JSONSchemaProps s) => VersionConverter.Mapper.Map(s); + } + public partial class V1JSONSchemaProps + { + public static explicit operator V1JSONSchemaProps(V1beta1JSONSchemaProps s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1Lease + { + public static explicit operator V1beta1Lease(V1Lease s) => VersionConverter.Mapper.Map(s); + } + public partial class V1Lease + { + public static explicit operator V1Lease(V1beta1Lease s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1LeaseList + { + public static explicit operator V1beta1LeaseList(V1LeaseList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1LeaseList + { + public static explicit operator V1LeaseList(V1beta1LeaseList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1LeaseSpec + { + public static explicit operator V1beta1LeaseSpec(V1LeaseSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1LeaseSpec + { + public static explicit operator V1LeaseSpec(V1beta1LeaseSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1LocalSubjectAccessReview + { + public static explicit operator V1beta1LocalSubjectAccessReview(V1LocalSubjectAccessReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1LocalSubjectAccessReview + { + public static explicit operator V1LocalSubjectAccessReview(V1beta1LocalSubjectAccessReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1MetricSpec + { + public static explicit operator V2beta1MetricSpec(V2beta2MetricSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2MetricSpec + { + public static explicit operator V2beta2MetricSpec(V2beta1MetricSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1MetricStatus + { + public static explicit operator V2beta1MetricStatus(V2beta2MetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2MetricStatus + { + public static explicit operator V2beta2MetricStatus(V2beta1MetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1MutatingWebhook + { + public static explicit operator V1beta1MutatingWebhook(V1MutatingWebhook s) => VersionConverter.Mapper.Map(s); + } + public partial class V1MutatingWebhook + { + public static explicit operator V1MutatingWebhook(V1beta1MutatingWebhook s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1MutatingWebhookConfiguration + { + public static explicit operator V1beta1MutatingWebhookConfiguration(V1MutatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); + } + public partial class V1MutatingWebhookConfiguration + { + public static explicit operator V1MutatingWebhookConfiguration(V1beta1MutatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1MutatingWebhookConfigurationList + { + public static explicit operator V1beta1MutatingWebhookConfigurationList(V1MutatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1MutatingWebhookConfigurationList + { + public static explicit operator V1MutatingWebhookConfigurationList(V1beta1MutatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1NonResourceAttributes + { + public static explicit operator V1beta1NonResourceAttributes(V1NonResourceAttributes s) => VersionConverter.Mapper.Map(s); + } + public partial class V1NonResourceAttributes + { + public static explicit operator V1NonResourceAttributes(V1beta1NonResourceAttributes s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1NonResourceRule + { + public static explicit operator V1beta1NonResourceRule(V1NonResourceRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1NonResourceRule + { + public static explicit operator V1NonResourceRule(V1beta1NonResourceRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1ObjectMetricSource + { + public static explicit operator V2beta1ObjectMetricSource(V2beta2ObjectMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2ObjectMetricSource + { + public static explicit operator V2beta2ObjectMetricSource(V2beta1ObjectMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1ObjectMetricStatus + { + public static explicit operator V2beta1ObjectMetricStatus(V2beta2ObjectMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2ObjectMetricStatus + { + public static explicit operator V2beta2ObjectMetricStatus(V2beta1ObjectMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1Overhead + { + public static explicit operator V1alpha1Overhead(V1beta1Overhead s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1Overhead + { + public static explicit operator V1beta1Overhead(V1alpha1Overhead s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1PodsMetricSource + { + public static explicit operator V2beta1PodsMetricSource(V2beta2PodsMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2PodsMetricSource + { + public static explicit operator V2beta2PodsMetricSource(V2beta1PodsMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1PodsMetricStatus + { + public static explicit operator V2beta1PodsMetricStatus(V2beta2PodsMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2PodsMetricStatus + { + public static explicit operator V2beta2PodsMetricStatus(V2beta1PodsMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1PolicyRule + { + public static explicit operator V1alpha1PolicyRule(V1beta1PolicyRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1PolicyRule + { + public static explicit operator V1beta1PolicyRule(V1alpha1PolicyRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1PolicyRule + { + public static explicit operator V1alpha1PolicyRule(V1PolicyRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1PolicyRule + { + public static explicit operator V1PolicyRule(V1alpha1PolicyRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1PolicyRule + { + public static explicit operator V1beta1PolicyRule(V1PolicyRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1PolicyRule + { + public static explicit operator V1PolicyRule(V1beta1PolicyRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1PriorityClass + { + public static explicit operator V1alpha1PriorityClass(V1beta1PriorityClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1PriorityClass + { + public static explicit operator V1beta1PriorityClass(V1alpha1PriorityClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1PriorityClass + { + public static explicit operator V1alpha1PriorityClass(V1PriorityClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1PriorityClass + { + public static explicit operator V1PriorityClass(V1alpha1PriorityClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1PriorityClass + { + public static explicit operator V1beta1PriorityClass(V1PriorityClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1PriorityClass + { + public static explicit operator V1PriorityClass(V1beta1PriorityClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1PriorityClassList + { + public static explicit operator V1alpha1PriorityClassList(V1beta1PriorityClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1PriorityClassList + { + public static explicit operator V1beta1PriorityClassList(V1alpha1PriorityClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1PriorityClassList + { + public static explicit operator V1alpha1PriorityClassList(V1PriorityClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1PriorityClassList + { + public static explicit operator V1PriorityClassList(V1alpha1PriorityClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1PriorityClassList + { + public static explicit operator V1beta1PriorityClassList(V1PriorityClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1PriorityClassList + { + public static explicit operator V1PriorityClassList(V1beta1PriorityClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ResourceAttributes + { + public static explicit operator V1beta1ResourceAttributes(V1ResourceAttributes s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ResourceAttributes + { + public static explicit operator V1ResourceAttributes(V1beta1ResourceAttributes s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1ResourceMetricSource + { + public static explicit operator V2beta1ResourceMetricSource(V2beta2ResourceMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2ResourceMetricSource + { + public static explicit operator V2beta2ResourceMetricSource(V2beta1ResourceMetricSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta1ResourceMetricStatus + { + public static explicit operator V2beta1ResourceMetricStatus(V2beta2ResourceMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V2beta2ResourceMetricStatus + { + public static explicit operator V2beta2ResourceMetricStatus(V2beta1ResourceMetricStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ResourceRule + { + public static explicit operator V1beta1ResourceRule(V1ResourceRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ResourceRule + { + public static explicit operator V1ResourceRule(V1beta1ResourceRule s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1Role + { + public static explicit operator V1alpha1Role(V1beta1Role s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1Role + { + public static explicit operator V1beta1Role(V1alpha1Role s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1Role + { + public static explicit operator V1alpha1Role(V1Role s) => VersionConverter.Mapper.Map(s); + } + public partial class V1Role + { + public static explicit operator V1Role(V1alpha1Role s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1Role + { + public static explicit operator V1beta1Role(V1Role s) => VersionConverter.Mapper.Map(s); + } + public partial class V1Role + { + public static explicit operator V1Role(V1beta1Role s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleBinding + { + public static explicit operator V1alpha1RoleBinding(V1beta1RoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleBinding + { + public static explicit operator V1beta1RoleBinding(V1alpha1RoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleBinding + { + public static explicit operator V1alpha1RoleBinding(V1RoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleBinding + { + public static explicit operator V1RoleBinding(V1alpha1RoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleBinding + { + public static explicit operator V1beta1RoleBinding(V1RoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleBinding + { + public static explicit operator V1RoleBinding(V1beta1RoleBinding s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleBindingList + { + public static explicit operator V1alpha1RoleBindingList(V1beta1RoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleBindingList + { + public static explicit operator V1beta1RoleBindingList(V1alpha1RoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleBindingList + { + public static explicit operator V1alpha1RoleBindingList(V1RoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleBindingList + { + public static explicit operator V1RoleBindingList(V1alpha1RoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleBindingList + { + public static explicit operator V1beta1RoleBindingList(V1RoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleBindingList + { + public static explicit operator V1RoleBindingList(V1beta1RoleBindingList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleList + { + public static explicit operator V1alpha1RoleList(V1beta1RoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleList + { + public static explicit operator V1beta1RoleList(V1alpha1RoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleList + { + public static explicit operator V1alpha1RoleList(V1RoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleList + { + public static explicit operator V1RoleList(V1alpha1RoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleList + { + public static explicit operator V1beta1RoleList(V1RoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleList + { + public static explicit operator V1RoleList(V1beta1RoleList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleRef + { + public static explicit operator V1alpha1RoleRef(V1beta1RoleRef s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleRef + { + public static explicit operator V1beta1RoleRef(V1alpha1RoleRef s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RoleRef + { + public static explicit operator V1alpha1RoleRef(V1RoleRef s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleRef + { + public static explicit operator V1RoleRef(V1alpha1RoleRef s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RoleRef + { + public static explicit operator V1beta1RoleRef(V1RoleRef s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RoleRef + { + public static explicit operator V1RoleRef(V1beta1RoleRef s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RuleWithOperations + { + public static explicit operator V1beta1RuleWithOperations(V1RuleWithOperations s) => VersionConverter.Mapper.Map(s); + } + public partial class V1RuleWithOperations + { + public static explicit operator V1RuleWithOperations(V1beta1RuleWithOperations s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RuntimeClass + { + public static explicit operator V1alpha1RuntimeClass(V1beta1RuntimeClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RuntimeClass + { + public static explicit operator V1beta1RuntimeClass(V1alpha1RuntimeClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1RuntimeClassList + { + public static explicit operator V1alpha1RuntimeClassList(V1beta1RuntimeClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1RuntimeClassList + { + public static explicit operator V1beta1RuntimeClassList(V1alpha1RuntimeClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1Scheduling + { + public static explicit operator V1alpha1Scheduling(V1beta1Scheduling s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1Scheduling + { + public static explicit operator V1beta1Scheduling(V1alpha1Scheduling s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SelfSubjectAccessReview + { + public static explicit operator V1beta1SelfSubjectAccessReview(V1SelfSubjectAccessReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SelfSubjectAccessReview + { + public static explicit operator V1SelfSubjectAccessReview(V1beta1SelfSubjectAccessReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SelfSubjectAccessReviewSpec + { + public static explicit operator V1beta1SelfSubjectAccessReviewSpec(V1SelfSubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SelfSubjectAccessReviewSpec + { + public static explicit operator V1SelfSubjectAccessReviewSpec(V1beta1SelfSubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SelfSubjectRulesReview + { + public static explicit operator V1beta1SelfSubjectRulesReview(V1SelfSubjectRulesReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SelfSubjectRulesReview + { + public static explicit operator V1SelfSubjectRulesReview(V1beta1SelfSubjectRulesReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SelfSubjectRulesReviewSpec + { + public static explicit operator V1beta1SelfSubjectRulesReviewSpec(V1SelfSubjectRulesReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SelfSubjectRulesReviewSpec + { + public static explicit operator V1SelfSubjectRulesReviewSpec(V1beta1SelfSubjectRulesReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1StorageClass + { + public static explicit operator V1beta1StorageClass(V1StorageClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1StorageClass + { + public static explicit operator V1StorageClass(V1beta1StorageClass s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1StorageClassList + { + public static explicit operator V1beta1StorageClassList(V1StorageClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1StorageClassList + { + public static explicit operator V1StorageClassList(V1beta1StorageClassList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1Subject + { + public static explicit operator V1beta1Subject(V1Subject s) => VersionConverter.Mapper.Map(s); + } + public partial class V1Subject + { + public static explicit operator V1Subject(V1beta1Subject s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SubjectAccessReview + { + public static explicit operator V1beta1SubjectAccessReview(V1SubjectAccessReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SubjectAccessReview + { + public static explicit operator V1SubjectAccessReview(V1beta1SubjectAccessReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SubjectAccessReviewSpec + { + public static explicit operator V1beta1SubjectAccessReviewSpec(V1SubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SubjectAccessReviewSpec + { + public static explicit operator V1SubjectAccessReviewSpec(V1beta1SubjectAccessReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SubjectAccessReviewStatus + { + public static explicit operator V1beta1SubjectAccessReviewStatus(V1SubjectAccessReviewStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SubjectAccessReviewStatus + { + public static explicit operator V1SubjectAccessReviewStatus(V1beta1SubjectAccessReviewStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1SubjectRulesReviewStatus + { + public static explicit operator V1beta1SubjectRulesReviewStatus(V1SubjectRulesReviewStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1SubjectRulesReviewStatus + { + public static explicit operator V1SubjectRulesReviewStatus(V1beta1SubjectRulesReviewStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1TokenReview + { + public static explicit operator V1beta1TokenReview(V1TokenReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1TokenReview + { + public static explicit operator V1TokenReview(V1beta1TokenReview s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1TokenReviewSpec + { + public static explicit operator V1beta1TokenReviewSpec(V1TokenReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1TokenReviewSpec + { + public static explicit operator V1TokenReviewSpec(V1beta1TokenReviewSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1TokenReviewStatus + { + public static explicit operator V1beta1TokenReviewStatus(V1TokenReviewStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1TokenReviewStatus + { + public static explicit operator V1TokenReviewStatus(V1beta1TokenReviewStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1UserInfo + { + public static explicit operator V1beta1UserInfo(V1UserInfo s) => VersionConverter.Mapper.Map(s); + } + public partial class V1UserInfo + { + public static explicit operator V1UserInfo(V1beta1UserInfo s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ValidatingWebhook + { + public static explicit operator V1beta1ValidatingWebhook(V1ValidatingWebhook s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ValidatingWebhook + { + public static explicit operator V1ValidatingWebhook(V1beta1ValidatingWebhook s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ValidatingWebhookConfiguration + { + public static explicit operator V1beta1ValidatingWebhookConfiguration(V1ValidatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ValidatingWebhookConfiguration + { + public static explicit operator V1ValidatingWebhookConfiguration(V1beta1ValidatingWebhookConfiguration s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1ValidatingWebhookConfigurationList + { + public static explicit operator V1beta1ValidatingWebhookConfigurationList(V1ValidatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1ValidatingWebhookConfigurationList + { + public static explicit operator V1ValidatingWebhookConfigurationList(V1beta1ValidatingWebhookConfigurationList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachment + { + public static explicit operator V1alpha1VolumeAttachment(V1beta1VolumeAttachment s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachment + { + public static explicit operator V1beta1VolumeAttachment(V1alpha1VolumeAttachment s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachment + { + public static explicit operator V1alpha1VolumeAttachment(V1VolumeAttachment s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachment + { + public static explicit operator V1VolumeAttachment(V1alpha1VolumeAttachment s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachment + { + public static explicit operator V1beta1VolumeAttachment(V1VolumeAttachment s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachment + { + public static explicit operator V1VolumeAttachment(V1beta1VolumeAttachment s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentList + { + public static explicit operator V1alpha1VolumeAttachmentList(V1beta1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentList + { + public static explicit operator V1beta1VolumeAttachmentList(V1alpha1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentList + { + public static explicit operator V1alpha1VolumeAttachmentList(V1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentList + { + public static explicit operator V1VolumeAttachmentList(V1alpha1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentList + { + public static explicit operator V1beta1VolumeAttachmentList(V1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentList + { + public static explicit operator V1VolumeAttachmentList(V1beta1VolumeAttachmentList s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentSource + { + public static explicit operator V1alpha1VolumeAttachmentSource(V1beta1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentSource + { + public static explicit operator V1beta1VolumeAttachmentSource(V1alpha1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentSource + { + public static explicit operator V1alpha1VolumeAttachmentSource(V1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentSource + { + public static explicit operator V1VolumeAttachmentSource(V1alpha1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentSource + { + public static explicit operator V1beta1VolumeAttachmentSource(V1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentSource + { + public static explicit operator V1VolumeAttachmentSource(V1beta1VolumeAttachmentSource s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentSpec + { + public static explicit operator V1alpha1VolumeAttachmentSpec(V1beta1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentSpec + { + public static explicit operator V1beta1VolumeAttachmentSpec(V1alpha1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentSpec + { + public static explicit operator V1alpha1VolumeAttachmentSpec(V1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentSpec + { + public static explicit operator V1VolumeAttachmentSpec(V1alpha1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentSpec + { + public static explicit operator V1beta1VolumeAttachmentSpec(V1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentSpec + { + public static explicit operator V1VolumeAttachmentSpec(V1beta1VolumeAttachmentSpec s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentStatus + { + public static explicit operator V1alpha1VolumeAttachmentStatus(V1beta1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentStatus + { + public static explicit operator V1beta1VolumeAttachmentStatus(V1alpha1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeAttachmentStatus + { + public static explicit operator V1alpha1VolumeAttachmentStatus(V1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentStatus + { + public static explicit operator V1VolumeAttachmentStatus(V1alpha1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeAttachmentStatus + { + public static explicit operator V1beta1VolumeAttachmentStatus(V1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeAttachmentStatus + { + public static explicit operator V1VolumeAttachmentStatus(V1beta1VolumeAttachmentStatus s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeError + { + public static explicit operator V1alpha1VolumeError(V1beta1VolumeError s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeError + { + public static explicit operator V1beta1VolumeError(V1alpha1VolumeError s) => VersionConverter.Mapper.Map(s); + } + public partial class V1alpha1VolumeError + { + public static explicit operator V1alpha1VolumeError(V1VolumeError s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeError + { + public static explicit operator V1VolumeError(V1alpha1VolumeError s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeError + { + public static explicit operator V1beta1VolumeError(V1VolumeError s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeError + { + public static explicit operator V1VolumeError(V1beta1VolumeError s) => VersionConverter.Mapper.Map(s); + } + public partial class V1beta1VolumeNodeResources + { + public static explicit operator V1beta1VolumeNodeResources(V1VolumeNodeResources s) => VersionConverter.Mapper.Map(s); + } + public partial class V1VolumeNodeResources + { + public static explicit operator V1VolumeNodeResources(V1beta1VolumeNodeResources s) => VersionConverter.Mapper.Map(s); + } +} diff --git a/src/KubernetesClient/generated/VersionConverter.cs b/src/KubernetesClient/generated/VersionConverter.cs new file mode 100644 index 0000000..31ba503 --- /dev/null +++ b/src/KubernetesClient/generated/VersionConverter.cs @@ -0,0 +1,160 @@ +using AutoMapper; +using k8s.Models; + +namespace k8s.Versioning +{ + + + public static partial class VersionConverter + { + private static void AutoConfigurations(IMapperConfigurationExpression cfg) + { + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + cfg.CreateMap().ReverseMap(); + } + } + + +} diff --git a/tests/KubernetesClient.Tests/VersionConverterTests.cs b/tests/KubernetesClient.Tests/VersionConverterTests.cs new file mode 100644 index 0000000..05a9e02 --- /dev/null +++ b/tests/KubernetesClient.Tests/VersionConverterTests.cs @@ -0,0 +1,55 @@ +using System.Collections.Generic; +using k8s.Models; +using Xunit; +using FluentAssertions; +using k8s.Versioning; +using AutoMapper; + +namespace k8s.Tests +{ + public class VersionConverterTests + { + [Fact] + public void CanExplicitlyConvert() + { + var a = new V1APIService { Spec = new V1APIServiceSpec { Group = "blah" } }; + var b = (V1beta1APIService)a; + b.Spec.Group.Should().Be("blah"); + } + + [Fact] + public void ConfigurationsAreValid() + { + var config = new MapperConfiguration(VersionConverter.GetConfigurations); + config.AssertConfigurationIsValid(); + } + + [Theory] + [InlineData("v1", "v1beta1", 1)] + [InlineData("v1beta1", "v1", -1)] + [InlineData("v1beta1", "v1alpha1", 1)] + [InlineData("v1alpha1", "v1beta1", -1)] + [InlineData("v1", "v1alpha1", 1)] + [InlineData("v2alpha1", "v1", 1)] + [InlineData("v1", "v2alpha1", -1)] + [InlineData("v1", "v1", 0)] + [InlineData("v2", "v2", 0)] + [InlineData("v1beta1", "v1beta1", 0)] + [InlineData("v1beta2", "v1beta2", 0)] + [InlineData("v2beta2", "v2beta2", 0)] + public void KubernetesVersionCompare(string x, string y, int expected) + { + KubernetesVersionComparer.Instance.Compare(x, y).Should().Be(expected); + } + + [Fact] + public void ConvertToVersion() + { + var src = new V1beta1APIService().Initialize(); + src.ApiVersion.Should().Be("apiregistration.k8s.io/v1beta1"); + var sut = (V1APIService)VersionConverter.ConvertToVersion(src, "v1"); + sut.Should().NotBeNull(); + sut.ApiVersion.Should().Be("apiregistration.k8s.io/v1"); + } + } +}