diff --git a/pkg/apis/addtoscheme_jenkins_v1alpha1.go b/pkg/apis/addtoscheme_jenkins_v1alpha1.go deleted file mode 100644 index 37fad995..00000000 --- a/pkg/apis/addtoscheme_jenkins_v1alpha1.go +++ /dev/null @@ -1,10 +0,0 @@ -package apis - -import ( - "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha1" -) - -func init() { - // Register the types with the Scheme so the components can map objects to GroupVersionKinds and back - AddToSchemes = append(AddToSchemes, v1alpha1.SchemeBuilder.AddToScheme) -} diff --git a/pkg/apis/apis.go b/pkg/apis/apis.go index 07dc9616..5b42c520 100644 --- a/pkg/apis/apis.go +++ b/pkg/apis/apis.go @@ -1,6 +1,9 @@ package apis import ( + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha1" + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2" + "k8s.io/apimachinery/pkg/runtime" ) @@ -11,3 +14,10 @@ var AddToSchemes runtime.SchemeBuilder func AddToScheme(s *runtime.Scheme) error { return AddToSchemes.AddToScheme(s) } + +func init() { + // Register the types with the Scheme so the components can map objects to GroupVersionKinds and back + AddToSchemes = append(AddToSchemes, v1alpha1.SchemeBuilder.AddToScheme) + // Register the types with the Scheme so the components can map objects to GroupVersionKinds and back + AddToSchemes = append(AddToSchemes, v1alpha2.SchemeBuilder.AddToScheme) +} diff --git a/pkg/apis/jenkins/v1alpha2/doc.go b/pkg/apis/jenkins/v1alpha2/doc.go new file mode 100644 index 00000000..5f149aee --- /dev/null +++ b/pkg/apis/jenkins/v1alpha2/doc.go @@ -0,0 +1,4 @@ +// Package v1alpha2 contains API Schema definitions for the jenkins.io v1alpha2 API group +// +k8s:deepcopy-gen=package,register +// +groupName=jenkins.io +package v1alpha2 diff --git a/pkg/apis/jenkins/v1alpha2/jenkins_types.go b/pkg/apis/jenkins/v1alpha2/jenkins_types.go new file mode 100644 index 00000000..e541a50a --- /dev/null +++ b/pkg/apis/jenkins/v1alpha2/jenkins_types.go @@ -0,0 +1,166 @@ +package v1alpha2 + +import ( + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// EDIT THIS FILE! THIS IS SCAFFOLDING FOR YOU TO OWN! +// NOTE: json tags are required. Any new fields you add must have json tags for the fields to be serialized. + +// JenkinsSpec defines the desired state of Jenkins +// +k8s:openapi-gen=true +type JenkinsSpec struct { + // INSERT ADDITIONAL SPEC FIELDS - desired state of cluster + // Important: Run "operator-sdk generate k8s" to regenerate code after modifying this file + Master JenkinsMaster `json:"master,omitempty"` + SeedJobs []SeedJob `json:"seedJobs,omitempty"` + Service Service `json:"service,omitempty"` + SlaveService Service `json:"slaveService,omitempty"` +} + +// Container defines Kubernetes container attributes +type Container struct { + Name string `json:"name"` + Image string `json:"image"` + Command []string `json:"command,omitempty"` + Args []string `json:"args,omitempty"` + WorkingDir string `json:"workingDir,omitempty"` + Ports []corev1.ContainerPort `json:"ports,omitempty"` + EnvFrom []corev1.EnvFromSource `json:"envFrom,omitempty"` + Env []corev1.EnvVar `json:"env,omitempty"` + Resources corev1.ResourceRequirements `json:"resources,omitempty"` + VolumeMounts []corev1.VolumeMount `json:"volumeMounts,omitempty"` + LivenessProbe *corev1.Probe `json:"livenessProbe,omitempty"` + ReadinessProbe *corev1.Probe `json:"readinessProbe,omitempty"` + Lifecycle *corev1.Lifecycle `json:"lifecycle,omitempty"` + ImagePullPolicy corev1.PullPolicy `json:"imagePullPolicy,omitempty"` + SecurityContext *corev1.SecurityContext `json:"securityContext,omitempty"` +} + +// JenkinsMaster defines the Jenkins master pod attributes and plugins, +// every single change requires Jenkins master pod restart +type JenkinsMaster struct { + Container //TODO move to containers + + // pod properties + Annotations map[string]string `json:"masterAnnotations,omitempty"` + NodeSelector map[string]string `json:"nodeSelector,omitempty"` + Containers []Container `json:"containers,omitempty"` + Volumes []corev1.Volume `json:"volumes,omitempty"` + + // OperatorPlugins contains plugins required by operator + OperatorPlugins map[string][]string `json:"basePlugins,omitempty"` + // Plugins contains plugins required by user + Plugins map[string][]string `json:"plugins,omitempty"` +} + +// Service defines Kubernetes service attributes which Operator will manage +type Service struct { + Annotations map[string]string `json:"annotations,omitempty"` + Labels map[string]string `json:"labels,omitempty"` + Type corev1.ServiceType `json:"type,omitempty"` + Port int32 `json:"port,omitempty"` + NodePort int32 `json:"nodePort,omitempty"` + LoadBalancerSourceRanges []string `json:"loadBalancerSourceRanges,omitempty"` + LoadBalancerIP string `json:"loadBalancerIP,omitempty"` +} + +// JenkinsStatus defines the observed state of Jenkins +// +k8s:openapi-gen=true +type JenkinsStatus struct { + // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster + // Important: Run "operator-sdk generate k8s" to regenerate code after modifying this file + OperatorVersion string `json:"operatorVersion,omitempty"` + ProvisionStartTime *metav1.Time `json:"provisionStartTime,omitempty"` + BaseConfigurationCompletedTime *metav1.Time `json:"baseConfigurationCompletedTime,omitempty"` + UserConfigurationCompletedTime *metav1.Time `json:"userConfigurationCompletedTime,omitempty"` + Builds []Build `json:"builds,omitempty"` +} + +// BuildStatus defines type of Jenkins build job status +type BuildStatus string + +const ( + // BuildSuccessStatus - the build had no errors + BuildSuccessStatus BuildStatus = "success" + // BuildUnstableStatus - the build had some errors but they were not fatal. For example, some tests failed + BuildUnstableStatus BuildStatus = "unstable" + // BuildNotBuildStatus - this status code is used in a multi-stage build (like maven2) where a problem in earlier stage prevented later stages from building + BuildNotBuildStatus BuildStatus = "not_build" + // BuildFailureStatus - the build had a fatal error + BuildFailureStatus BuildStatus = "failure" + // BuildAbortedStatus - the build was manually aborted + BuildAbortedStatus BuildStatus = "aborted" + // BuildRunningStatus - this is custom build status for running build, not present in jenkins build result + BuildRunningStatus BuildStatus = "running" + // BuildExpiredStatus - this is custom build status for expired build, not present in jenkins build result + BuildExpiredStatus BuildStatus = "expired" +) + +// Build defines Jenkins Build status with corresponding metadata +type Build struct { + JobName string `json:"jobName,omitempty"` + Hash string `json:"hash,omitempty"` + Number int64 `json:"number,omitempty"` + Status BuildStatus `json:"status,omitempty"` + Retires int `json:"retries,omitempty"` + CreateTime *metav1.Time `json:"createTime,omitempty"` + LastUpdateTime *metav1.Time `json:"lastUpdateTime,omitempty"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Jenkins is the Schema for the jenkins API +// +k8s:openapi-gen=true +// +kubebuilder:subresource:status +type Jenkins struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + Spec JenkinsSpec `json:"spec,omitempty"` + Status JenkinsStatus `json:"status,omitempty"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// JenkinsList contains a list of Jenkins +type JenkinsList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []Jenkins `json:"items"` +} + +// JenkinsCredentialType defines type of Jenkins credential used to seed job mechanisms +type JenkinsCredentialType string + +const ( + // NoJenkinsCredentialCredentialType define none Jenkins credential type + NoJenkinsCredentialCredentialType JenkinsCredentialType = "" + // BasicSSHCredentialType define basic SSH Jenkins credential type + BasicSSHCredentialType JenkinsCredentialType = "basicSSHUserPrivateKey" + // UsernamePasswordCredentialType define username & password Jenkins credential type + UsernamePasswordCredentialType JenkinsCredentialType = "usernamePassword" +) + +// AllowedJenkinsCredentialMap contains all allowed Jenkins credentials types +var AllowedJenkinsCredentialMap = map[string]string{ + string(NoJenkinsCredentialCredentialType): "", + string(BasicSSHCredentialType): "", + string(UsernamePasswordCredentialType): "", +} + +// SeedJob defined configuration for seed jobs and deploy keys +type SeedJob struct { + ID string `json:"id,omitempty"` + CredentialID string `json:"credentialID,omitempty"` + Description string `json:"description,omitempty"` + Targets string `json:"targets,omitempty"` + RepositoryBranch string `json:"repositoryBranch,omitempty"` + RepositoryURL string `json:"repositoryUrl,omitempty"` + JenkinsCredentialType JenkinsCredentialType `json:"credentialType,omitempty"` +} + +func init() { + SchemeBuilder.Register(&Jenkins{}, &JenkinsList{}) +} diff --git a/pkg/apis/jenkins/v1alpha2/register.go b/pkg/apis/jenkins/v1alpha2/register.go new file mode 100644 index 00000000..16a6256e --- /dev/null +++ b/pkg/apis/jenkins/v1alpha2/register.go @@ -0,0 +1,27 @@ +// NOTE: Boilerplate only. Ignore this file. + +// Package v1alpha2 contains API Schema definitions for the jenkins.io v1alpha2 API group +// +k8s:deepcopy-gen=package,register +// +groupName=jenkins.io +package v1alpha2 + +import ( + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/controller-runtime/pkg/runtime/scheme" +) + +const ( + // Kind defines Jenkins CRD kind name + Kind = "Jenkins" +) + +var ( + // SchemeGroupVersion is group version used to register these objects + SchemeGroupVersion = schema.GroupVersion{Group: "jenkins.io", Version: "v1alpha2"} + + // SchemeBuilder is used to add go types to the GroupVersionKind scheme + SchemeBuilder = &scheme.Builder{GroupVersion: SchemeGroupVersion} +) + +// GetObjectKind returns Jenkins object kind +func (in *Jenkins) GetObjectKind() schema.ObjectKind { return in } diff --git a/pkg/apis/jenkins/v1alpha2/zz_generated.deepcopy.go b/pkg/apis/jenkins/v1alpha2/zz_generated.deepcopy.go new file mode 100644 index 00000000..61dd8a73 --- /dev/null +++ b/pkg/apis/jenkins/v1alpha2/zz_generated.deepcopy.go @@ -0,0 +1,299 @@ +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1alpha2 + +import ( + v1 "k8s.io/api/core/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Build) DeepCopyInto(out *Build) { + *out = *in + if in.CreateTime != nil { + in, out := &in.CreateTime, &out.CreateTime + *out = (*in).DeepCopy() + } + if in.LastUpdateTime != nil { + in, out := &in.LastUpdateTime, &out.LastUpdateTime + *out = (*in).DeepCopy() + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Build. +func (in *Build) DeepCopy() *Build { + if in == nil { + return nil + } + out := new(Build) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Jenkins) DeepCopyInto(out *Jenkins) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Jenkins. +func (in *Jenkins) DeepCopy() *Jenkins { + if in == nil { + return nil + } + out := new(Jenkins) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Jenkins) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JenkinsList) DeepCopyInto(out *JenkinsList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Jenkins, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JenkinsList. +func (in *JenkinsList) DeepCopy() *JenkinsList { + if in == nil { + return nil + } + out := new(JenkinsList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *JenkinsList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JenkinsMaster) DeepCopyInto(out *JenkinsMaster) { + *out = *in + if in.NodeSelector != nil { + in, out := &in.NodeSelector, &out.NodeSelector + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.Annotations != nil { + in, out := &in.Annotations, &out.Annotations + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + in.Resources.DeepCopyInto(&out.Resources) + if in.Env != nil { + in, out := &in.Env, &out.Env + *out = make([]v1.EnvVar, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.LivenessProbe != nil { + in, out := &in.LivenessProbe, &out.LivenessProbe + *out = new(v1.Probe) + (*in).DeepCopyInto(*out) + } + if in.ReadinessProbe != nil { + in, out := &in.ReadinessProbe, &out.ReadinessProbe + *out = new(v1.Probe) + (*in).DeepCopyInto(*out) + } + if in.OperatorPlugins != nil { + in, out := &in.OperatorPlugins, &out.OperatorPlugins + *out = make(map[string][]string, len(*in)) + for key, val := range *in { + var outVal []string + if val == nil { + (*out)[key] = nil + } else { + in, out := &val, &outVal + *out = make([]string, len(*in)) + copy(*out, *in) + } + (*out)[key] = outVal + } + } + if in.Plugins != nil { + in, out := &in.Plugins, &out.Plugins + *out = make(map[string][]string, len(*in)) + for key, val := range *in { + var outVal []string + if val == nil { + (*out)[key] = nil + } else { + in, out := &val, &outVal + *out = make([]string, len(*in)) + copy(*out, *in) + } + (*out)[key] = outVal + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JenkinsMaster. +func (in *JenkinsMaster) DeepCopy() *JenkinsMaster { + if in == nil { + return nil + } + out := new(JenkinsMaster) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JenkinsSpec) DeepCopyInto(out *JenkinsSpec) { + *out = *in + in.Master.DeepCopyInto(&out.Master) + if in.SeedJobs != nil { + in, out := &in.SeedJobs, &out.SeedJobs + *out = make([]SeedJob, len(*in)) + copy(*out, *in) + } + in.Service.DeepCopyInto(&out.Service) + in.SlaveService.DeepCopyInto(&out.SlaveService) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JenkinsSpec. +func (in *JenkinsSpec) DeepCopy() *JenkinsSpec { + if in == nil { + return nil + } + out := new(JenkinsSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JenkinsStatus) DeepCopyInto(out *JenkinsStatus) { + *out = *in + if in.ProvisionStartTime != nil { + in, out := &in.ProvisionStartTime, &out.ProvisionStartTime + *out = (*in).DeepCopy() + } + if in.BaseConfigurationCompletedTime != nil { + in, out := &in.BaseConfigurationCompletedTime, &out.BaseConfigurationCompletedTime + *out = (*in).DeepCopy() + } + if in.UserConfigurationCompletedTime != nil { + in, out := &in.UserConfigurationCompletedTime, &out.UserConfigurationCompletedTime + *out = (*in).DeepCopy() + } + if in.Builds != nil { + in, out := &in.Builds, &out.Builds + *out = make([]Build, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JenkinsStatus. +func (in *JenkinsStatus) DeepCopy() *JenkinsStatus { + if in == nil { + return nil + } + out := new(JenkinsStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SeedJob) DeepCopyInto(out *SeedJob) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SeedJob. +func (in *SeedJob) DeepCopy() *SeedJob { + if in == nil { + return nil + } + out := new(SeedJob) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Service) DeepCopyInto(out *Service) { + *out = *in + if in.Annotations != nil { + in, out := &in.Annotations, &out.Annotations + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.Labels != nil { + in, out := &in.Labels, &out.Labels + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.LoadBalancerSourceRanges != nil { + in, out := &in.LoadBalancerSourceRanges, &out.LoadBalancerSourceRanges + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Service. +func (in *Service) DeepCopy() *Service { + if in == nil { + return nil + } + out := new(Service) + in.DeepCopyInto(out) + return out +} diff --git a/pkg/apis/jenkins/v1alpha2/zz_generated.openapi.go b/pkg/apis/jenkins/v1alpha2/zz_generated.openapi.go new file mode 100644 index 00000000..da1df4c1 --- /dev/null +++ b/pkg/apis/jenkins/v1alpha2/zz_generated.openapi.go @@ -0,0 +1,153 @@ +// +build !ignore_autogenerated + +// Code generated by openapi-gen. DO NOT EDIT. + +// This file was autogenerated by openapi-gen. Do not edit it manually! + +package v1alpha2 + +import ( + spec "github.com/go-openapi/spec" + common "k8s.io/kube-openapi/pkg/common" +) + +func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition { + return map[string]common.OpenAPIDefinition{ + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.Jenkins": schema_pkg_apis_jenkins_v1alpha2_Jenkins(ref), + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsSpec": schema_pkg_apis_jenkins_v1alpha2_JenkinsSpec(ref), + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsStatus": schema_pkg_apis_jenkins_v1alpha2_JenkinsStatus(ref), + } +} + +func schema_pkg_apis_jenkins_v1alpha2_Jenkins(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Jenkins is the Schema for the jenkins API", + Properties: map[string]spec.Schema{ + "kind": { + SchemaProps: spec.SchemaProps{ + Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds", + Type: []string{"string"}, + Format: "", + }, + }, + "apiVersion": { + SchemaProps: spec.SchemaProps{ + Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources", + Type: []string{"string"}, + Format: "", + }, + }, + "metadata": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"), + }, + }, + "spec": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsSpec"), + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsStatus"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsSpec", "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"}, + } +} + +func schema_pkg_apis_jenkins_v1alpha2_JenkinsSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "JenkinsSpec defines the desired state of Jenkins", + Properties: map[string]spec.Schema{ + "master": { + SchemaProps: spec.SchemaProps{ + Description: "INSERT ADDITIONAL SPEC FIELDS - desired state of cluster Important: Run \"operator-sdk generate k8s\" to regenerate code after modifying this file", + Ref: ref("github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsMaster"), + }, + }, + "seedJobs": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.SeedJob"), + }, + }, + }, + }, + }, + "service": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.Service"), + }, + }, + "slaveService": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.Service"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.JenkinsMaster", "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.SeedJob", "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.Service"}, + } +} + +func schema_pkg_apis_jenkins_v1alpha2_JenkinsStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "JenkinsStatus defines the observed state of Jenkins", + Properties: map[string]spec.Schema{ + "operatorVersion": { + SchemaProps: spec.SchemaProps{ + Description: "INSERT ADDITIONAL STATUS FIELD - define observed state of cluster Important: Run \"operator-sdk generate k8s\" to regenerate code after modifying this file", + Type: []string{"string"}, + Format: "", + }, + }, + "provisionStartTime": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "baseConfigurationCompletedTime": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "userConfigurationCompletedTime": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "builds": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.Build"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/jenkinsci/kubernetes-operator/pkg/apis/jenkins/v1alpha2.Build", "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +}