コード例 #1
0
        internal static V1beta1CustomResourceDefinition Convert(this V1CustomResourceDefinition crd)
        {
            var crdVersion = crd.Spec.Versions.First();
            var betaCrd    = new V1beta1CustomResourceDefinition(
                new V1beta1CustomResourceDefinitionSpec(),
                $"{V1beta1CustomResourceDefinition.KubeGroup}/{V1beta1CustomResourceDefinition.KubeApiVersion}",
                V1beta1CustomResourceDefinition.KubeKind,
                crd.Metadata);

            betaCrd.Spec.Group = crd.Spec.Group;
            betaCrd.Spec.Names = new V1beta1CustomResourceDefinitionNames
            {
                Kind     = crd.Spec.Names.Kind,
                ListKind = crd.Spec.Names.ListKind,
                Singular = crd.Spec.Names.Singular,
                Plural   = crd.Spec.Names.Plural,
            };
            betaCrd.Spec.Scope    = crd.Spec.Scope;
            betaCrd.Spec.Version  = crdVersion.Name;
            betaCrd.Spec.Versions = new List <V1beta1CustomResourceDefinitionVersion>
            {
                new V1beta1CustomResourceDefinitionVersion(crdVersion.Name, true, true),
            };

            if (crdVersion.Subresources != null)
            {
                betaCrd.Spec.Subresources = new V1beta1CustomResourceSubresources(null, new { });
            }

            betaCrd.Spec.Validation = new V1beta1CustomResourceValidation(crdVersion.Schema.OpenAPIV3Schema.Convert());

            return(betaCrd);
        }
コード例 #2
0
        public CustomResourceDefinitionContext BuildDefinition(Type resourceType)
        {
            if (!resourceType.Implements <CustomResource>())
            {
                throw new ArgumentException("Custom Resource Definitions can only be generated for custom resources", nameof(resourceType));
            }

            try
            {
                var apiVersion = GetAttribute <ApiVersionAttribute>(resourceType).ApiVersion;
                var plural     = GetAttribute <PluralNameAttribute>(resourceType).PluralName.ToLower();
                var scope      = GetAttribute <ResourceScopeAttribute>(resourceType).ResourceScope;
                var kind       = GetAttribute <KindAttribute>(resourceType).Kind;
                var shortNames = new List <string> {
                    GetAttribute <ShortNameAttribute>(resourceType).ShortName
                };

                var crd = new V1beta1CustomResourceDefinition
                {
                    ApiVersion = "apiextensions.k8s.io/v1beta1",
                    Kind       = "CustomResourceDefinition",
                    Metadata   = new V1ObjectMeta
                    {
                        Name = $"{plural}.{apiVersion.Group}"
                    },
                    Spec = new V1beta1CustomResourceDefinitionSpec
                    {
                        Group    = apiVersion.Group,
                        Scope    = scope.ToString(),
                        Names    = new V1beta1CustomResourceDefinitionNames(kind, plural, shortNames: shortNames, singular: kind.ToLower()),
                        Versions = new List <V1beta1CustomResourceDefinitionVersion>
                        {
                            BuildVersion(apiVersion, resourceType)
                        }
                    },
                };

                if (resourceType.Implements <IStatusEnabledCustomResource>())
                {
                    crd.Spec.Subresources = new V1beta1CustomResourceSubresources(status: new object());
                }

                return(new CustomResourceDefinitionContext <V1beta1CustomResourceDefinition>(crd.Metadata.Name, crd));
            }
            catch (ArgumentException argEx)
            {
                throw new MissingMetadataAttributeException(argEx.Message, argEx);
            }
        }
コード例 #3
0
        private async Task OnCrdEvent(WatchEventType eventType, V1beta1CustomResourceDefinition item)
        {
            if (eventType != WatchEventType.Added && eventType != WatchEventType.Modified)
            {
                return;
            }
            if (item.Spec?.Names == null)
            {
                return;
            }

            if (item.Spec.Group != CertManagerConstants.CrdGroup ||
                item.Spec.Names.Kind != CertManagerConstants.CertificateKind)
            {
                return;
            }

            if (_currentVersion == item.Spec.Version)
            {
                return;
            }

            _logger.LogInformation("Certificates definition set to version {version}", item.Spec.Version);
            _currentVersion = item.Spec.Version;
            if (_certificatesMonitor.IsMonitoring)
            {
                await _certificatesMonitor.Stop();
            }
            if (_secretsMonitor.IsMonitoring)
            {
                await _secretsMonitor.Stop();
            }
            _certificatesMonitor.CertificatesVersion = _currentVersion;
            await _certificatesMonitor.Start();

            await _secretsMonitor.Start();
        }