public_git
/
kubernetes-operator
mirror of https://github.com/jenkinsci/kubernetes-operator.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Small refactoring

This commit is contained in:
Tomasz Sęk 2019-01-16 10:05:09 +01:00
parent 79112b50dc
commit 3aacf99536
No known key found for this signature in database
GPG Key ID: DC356D23F6A644D0
3 changed files with 60 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
pkg/controller/jenkins/configuration/base/reconcile.go
View File

@ -53,80 +53,80 @@ func New(client client.Client, scheme *runtime.Scheme, logger logr.Logger,
} }
// Reconcile takes care of base configuration // Reconcile takes care of base configuration
func (r *ReconcileJenkinsBaseConfiguration) Reconcile() (*reconcile.Result, jenkinsclient.Jenkins, error) { func (r *ReconcileJenkinsBaseConfiguration) Reconcile() (reconcile.Result, jenkinsclient.Jenkins, error) {
metaObject := resources.NewResourceObjectMeta(r.jenkins) metaObject := resources.NewResourceObjectMeta(r.jenkins)
if err := r.createOperatorCredentialsSecret(metaObject); err != nil { if err := r.createOperatorCredentialsSecret(metaObject); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("Operator credentials secret is present") r.logger.V(log.VDebug).Info("Operator credentials secret is present")
if err := r.createScriptsConfigMap(metaObject); err != nil { if err := r.createScriptsConfigMap(metaObject); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("Scripts config map is present") r.logger.V(log.VDebug).Info("Scripts config map is present")
if err := r.createInitConfigurationConfigMap(metaObject); err != nil { if err := r.createInitConfigurationConfigMap(metaObject); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("Init configuration config map is present") r.logger.V(log.VDebug).Info("Init configuration config map is present")
if err := r.createBaseConfigurationConfigMap(metaObject); err != nil { if err := r.createBaseConfigurationConfigMap(metaObject); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("Base configuration config map is present") r.logger.V(log.VDebug).Info("Base configuration config map is present")
if err := r.createUserConfigurationConfigMap(metaObject); err != nil { if err := r.createUserConfigurationConfigMap(metaObject); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("User configuration config map is present") r.logger.V(log.VDebug).Info("User configuration config map is present")
if err := r.createRBAC(metaObject); err != nil { if err := r.createRBAC(metaObject); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("User configuration config map is present") r.logger.V(log.VDebug).Info("User configuration config map is present")
if err := r.createService(metaObject); err != nil { if err := r.createService(metaObject); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("Service is present") r.logger.V(log.VDebug).Info("Service is present")
result, err := r.createJenkinsMasterPod(metaObject) result, err := r.createJenkinsMasterPod(metaObject)
if err != nil { if err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
if result != nil { if result.Requeue {
return result, nil, nil return result, nil, nil
} }
r.logger.V(log.VDebug).Info("Jenkins master pod is present") r.logger.V(log.VDebug).Info("Jenkins master pod is present")
result, err = r.waitForJenkins(metaObject) result, err = r.waitForJenkins(metaObject)
if err != nil { if err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
if result != nil { if result.Requeue {
return result, nil, nil return result, nil, nil
} }
r.logger.V(log.VDebug).Info("Jenkins master pod is ready") r.logger.V(log.VDebug).Info("Jenkins master pod is ready")
jenkinsClient, err := r.getJenkinsClient(metaObject) jenkinsClient, err := r.getJenkinsClient(metaObject)
if err != nil { if err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
r.logger.V(log.VDebug).Info("Jenkins API client set") r.logger.V(log.VDebug).Info("Jenkins API client set")
ok, err := r.verifyBasePlugins(jenkinsClient) ok, err := r.verifyBasePlugins(jenkinsClient)
if err != nil { if err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
if !ok { if !ok {
r.logger.V(log.VWarn).Info("Please correct Jenkins CR (spec.master.plugins)") r.logger.V(log.VWarn).Info("Please correct Jenkins CR (spec.master.plugins)")
currentJenkinsMasterPod, err := r.getJenkinsMasterPod(metaObject) currentJenkinsMasterPod, err := r.getJenkinsMasterPod(metaObject)
if err != nil { if err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
if err := r.k8sClient.Delete(context.TODO(), currentJenkinsMasterPod); err != nil { if err := r.k8sClient.Delete(context.TODO(), currentJenkinsMasterPod); err != nil {
return &reconcile.Result{}, nil, err return reconcile.Result{}, nil, err
} }
} }
@ -271,7 +271,7 @@ func (r *ReconcileJenkinsBaseConfiguration) getJenkinsMasterPod(meta metav1.Obje
return currentJenkinsMasterPod, nil return currentJenkinsMasterPod, nil
} }
func (r *ReconcileJenkinsBaseConfiguration) createJenkinsMasterPod(meta metav1.ObjectMeta) (*reconcile.Result, error) { func (r *ReconcileJenkinsBaseConfiguration) createJenkinsMasterPod(meta metav1.ObjectMeta) (reconcile.Result, error) {
// Check if this Pod already exists // Check if this Pod already exists
currentJenkinsMasterPod, err := r.getJenkinsMasterPod(meta) currentJenkinsMasterPod, err := r.getJenkinsMasterPod(meta)
if err != nil && errors.IsNotFound(err) { if err != nil && errors.IsNotFound(err) {
@ -279,16 +279,16 @@ func (r *ReconcileJenkinsBaseConfiguration) createJenkinsMasterPod(meta metav1.O
r.logger.Info(fmt.Sprintf("Creating a new Jenkins Master Pod %s/%s", jenkinsMasterPod.Namespace, jenkinsMasterPod.Name)) r.logger.Info(fmt.Sprintf("Creating a new Jenkins Master Pod %s/%s", jenkinsMasterPod.Namespace, jenkinsMasterPod.Name))
err = r.createResource(jenkinsMasterPod) err = r.createResource(jenkinsMasterPod)
if err != nil { if err != nil {
return nil, err return reconcile.Result{}, err
} }
r.jenkins.Status = virtuslabv1alpha1.JenkinsStatus{} r.jenkins.Status = virtuslabv1alpha1.JenkinsStatus{}
err = r.updateResource(r.jenkins) err = r.updateResource(r.jenkins)
if err != nil { if err != nil {
return nil, err return reconcile.Result{}, err
} }
return nil, nil return reconcile.Result{}, nil
} else if err != nil && !errors.IsNotFound(err) { } else if err != nil && !errors.IsNotFound(err) {
return nil, err return reconcile.Result{}, err
} }
// Recreate pod // Recreate pod
@ -323,38 +323,38 @@ func (r *ReconcileJenkinsBaseConfiguration) createJenkinsMasterPod(meta metav1.O
if currentJenkinsMasterPod != nil && recreatePod && currentJenkinsMasterPod.ObjectMeta.DeletionTimestamp == nil { if currentJenkinsMasterPod != nil && recreatePod && currentJenkinsMasterPod.ObjectMeta.DeletionTimestamp == nil {
r.logger.Info(fmt.Sprintf("Terminating Jenkins Master Pod %s/%s", currentJenkinsMasterPod.Namespace, currentJenkinsMasterPod.Name)) r.logger.Info(fmt.Sprintf("Terminating Jenkins Master Pod %s/%s", currentJenkinsMasterPod.Namespace, currentJenkinsMasterPod.Name))
if err := r.k8sClient.Delete(context.TODO(), currentJenkinsMasterPod); err != nil { if err := r.k8sClient.Delete(context.TODO(), currentJenkinsMasterPod); err != nil {
return nil, err return reconcile.Result{}, err
} }
return &reconcile.Result{Requeue: true}, nil return reconcile.Result{Requeue: true}, nil
} }
return nil, nil return reconcile.Result{}, nil
} }
func (r *ReconcileJenkinsBaseConfiguration) waitForJenkins(meta metav1.ObjectMeta) (*reconcile.Result, error) { func (r *ReconcileJenkinsBaseConfiguration) waitForJenkins(meta metav1.ObjectMeta) (reconcile.Result, error) {
jenkinsMasterPodStatus, err := r.getJenkinsMasterPod(meta) jenkinsMasterPodStatus, err := r.getJenkinsMasterPod(meta)
if err != nil { if err != nil {
return nil, err return reconcile.Result{}, err
} }
if jenkinsMasterPodStatus.ObjectMeta.DeletionTimestamp != nil { if jenkinsMasterPodStatus.ObjectMeta.DeletionTimestamp != nil {
r.logger.V(log.VDebug).Info("Jenkins master pod is terminating") r.logger.V(log.VDebug).Info("Jenkins master pod is terminating")
return &reconcile.Result{Requeue: true, RequeueAfter: time.Second * 5}, nil return reconcile.Result{Requeue: true, RequeueAfter: time.Second * 5}, nil
} }
if jenkinsMasterPodStatus.Status.Phase != corev1.PodRunning { if jenkinsMasterPodStatus.Status.Phase != corev1.PodRunning {
r.logger.V(log.VDebug).Info("Jenkins master pod not ready") r.logger.V(log.VDebug).Info("Jenkins master pod not ready")
return &reconcile.Result{Requeue: true, RequeueAfter: time.Second * 5}, nil return reconcile.Result{Requeue: true, RequeueAfter: time.Second * 5}, nil
} }
for _, containerStatus := range jenkinsMasterPodStatus.Status.ContainerStatuses { for _, containerStatus := range jenkinsMasterPodStatus.Status.ContainerStatuses {
if !containerStatus.Ready { if !containerStatus.Ready {
r.logger.V(log.VDebug).Info("Jenkins master pod not ready, readiness probe failed") r.logger.V(log.VDebug).Info("Jenkins master pod not ready, readiness probe failed")
return &reconcile.Result{Requeue: true, RequeueAfter: time.Second * 5}, nil return reconcile.Result{Requeue: true, RequeueAfter: time.Second * 5}, nil
} }
} }
return nil, nil return reconcile.Result{}, nil
} }
func (r *ReconcileJenkinsBaseConfiguration) getJenkinsClient(meta metav1.ObjectMeta) (jenkinsclient.Jenkins, error) { func (r *ReconcileJenkinsBaseConfiguration) getJenkinsClient(meta metav1.ObjectMeta) (jenkinsclient.Jenkins, error) {
@ -418,28 +418,28 @@ func (r *ReconcileJenkinsBaseConfiguration) getJenkinsClient(meta metav1.ObjectM
string(credentialsSecret.Data[resources.OperatorCredentialsSecretTokenKey])) string(credentialsSecret.Data[resources.OperatorCredentialsSecretTokenKey]))
} }
func (r *ReconcileJenkinsBaseConfiguration) baseConfiguration(jenkinsClient jenkinsclient.Jenkins) (*reconcile.Result, error) { func (r *ReconcileJenkinsBaseConfiguration) baseConfiguration(jenkinsClient jenkinsclient.Jenkins) (reconcile.Result, error) {
groovyClient := groovy.New(jenkinsClient, r.k8sClient, r.logger, fmt.Sprintf("%s-base-configuration", constants.OperatorName), resources.JenkinsBaseConfigurationVolumePath) groovyClient := groovy.New(jenkinsClient, r.k8sClient, r.logger, fmt.Sprintf("%s-base-configuration", constants.OperatorName), resources.JenkinsBaseConfigurationVolumePath)
err := groovyClient.ConfigureGroovyJob() err := groovyClient.ConfigureGroovyJob()
if err != nil { if err != nil {
return &reconcile.Result{}, err return reconcile.Result{}, err
} }
configuration := &corev1.ConfigMap{} configuration := &corev1.ConfigMap{}
namespaceName := types.NamespacedName{Namespace: r.jenkins.Namespace, Name: resources.GetBaseConfigurationConfigMapName(r.jenkins)} namespaceName := types.NamespacedName{Namespace: r.jenkins.Namespace, Name: resources.GetBaseConfigurationConfigMapName(r.jenkins)}
err = r.k8sClient.Get(context.TODO(), namespaceName, configuration) err = r.k8sClient.Get(context.TODO(), namespaceName, configuration)
if err != nil { if err != nil {
return &reconcile.Result{}, err return reconcile.Result{}, err
} }
done, err := groovyClient.EnsureGroovyJob(configuration.Data, r.jenkins) done, err := groovyClient.EnsureGroovyJob(configuration.Data, r.jenkins)
if err != nil { if err != nil {
return &reconcile.Result{}, err return reconcile.Result{}, err
} }
if !done { if !done {
return &reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil return reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil
} }
return nil, nil return reconcile.Result{}, nil
} }

33
pkg/controller/jenkins/configuration/user/reconcile.go
View File

@ -40,61 +40,64 @@ func New(k8sClient k8s.Client, jenkinsClient jenkinsclient.Jenkins, logger logr.
} }
// Reconcile it's a main reconciliation loop for user supplied configuration // Reconcile it's a main reconciliation loop for user supplied configuration
func (r *ReconcileUserConfiguration) Reconcile() (*reconcile.Result, error) { func (r *ReconcileUserConfiguration) Reconcile() (reconcile.Result, error) {
// reconcile seed jobs // reconcile seed jobs
result, err := r.reconcileSeedJobs() result, err := r.reconcileSeedJobs()
if err != nil || result != nil { if err != nil {
return result, err return reconcile.Result{}, err
}
if result.Requeue {
return result, nil
} }
return r.userConfiguration(r.jenkinsClient) return r.userConfiguration(r.jenkinsClient)
} }
func (r *ReconcileUserConfiguration) reconcileSeedJobs() (*reconcile.Result, error) { func (r *ReconcileUserConfiguration) reconcileSeedJobs() (reconcile.Result, error) {
seedJobs := seedjobs.New(r.jenkinsClient, r.k8sClient, r.logger) seedJobs := seedjobs.New(r.jenkinsClient, r.k8sClient, r.logger)
done, err := seedJobs.EnsureSeedJobs(r.jenkins) done, err := seedJobs.EnsureSeedJobs(r.jenkins)
if err != nil { if err != nil {
// build failed and can be recovered - retry build and requeue reconciliation loop with timeout // build failed and can be recovered - retry build and requeue reconciliation loop with timeout
if err == jobs.ErrorBuildFailed { if err == jobs.ErrorBuildFailed {
return &reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil return reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil
} }
// build failed and cannot be recovered // build failed and cannot be recovered
if err == jobs.ErrorUnrecoverableBuildFailed { if err == jobs.ErrorUnrecoverableBuildFailed {
return nil, nil return reconcile.Result{}, nil
} }
// unexpected error - requeue reconciliation loop // unexpected error - requeue reconciliation loop
return &reconcile.Result{}, err return reconcile.Result{}, err
} }
// build not finished yet - requeue reconciliation loop with timeout // build not finished yet - requeue reconciliation loop with timeout
if !done { if !done {
return &reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil return reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil
} }
return nil, nil return reconcile.Result{}, nil
} }
func (r *ReconcileUserConfiguration) userConfiguration(jenkinsClient jenkinsclient.Jenkins) (*reconcile.Result, error) { func (r *ReconcileUserConfiguration) userConfiguration(jenkinsClient jenkinsclient.Jenkins) (reconcile.Result, error) {
groovyClient := groovy.New(jenkinsClient, r.k8sClient, r.logger, fmt.Sprintf("%s-user-configuration", constants.OperatorName), resources.JenkinsUserConfigurationVolumePath) groovyClient := groovy.New(jenkinsClient, r.k8sClient, r.logger, fmt.Sprintf("%s-user-configuration", constants.OperatorName), resources.JenkinsUserConfigurationVolumePath)
err := groovyClient.ConfigureGroovyJob() err := groovyClient.ConfigureGroovyJob()
if err != nil { if err != nil {
return &reconcile.Result{}, err return reconcile.Result{}, err
} }
configuration := &corev1.ConfigMap{} configuration := &corev1.ConfigMap{}
namespaceName := types.NamespacedName{Namespace: r.jenkins.Namespace, Name: resources.GetUserConfigurationConfigMapName(r.jenkins)} namespaceName := types.NamespacedName{Namespace: r.jenkins.Namespace, Name: resources.GetUserConfigurationConfigMapName(r.jenkins)}
err = r.k8sClient.Get(context.TODO(), namespaceName, configuration) err = r.k8sClient.Get(context.TODO(), namespaceName, configuration)
if err != nil { if err != nil {
return &reconcile.Result{}, err return reconcile.Result{}, err
} }
done, err := groovyClient.EnsureGroovyJob(configuration.Data, r.jenkins) done, err := groovyClient.EnsureGroovyJob(configuration.Data, r.jenkins)
if err != nil { if err != nil {
return &reconcile.Result{}, err return reconcile.Result{}, err
} }
if !done { if !done {
return &reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil return reconcile.Result{Requeue: true, RequeueAfter: time.Second * 10}, nil
} }
return nil, nil return reconcile.Result{}, nil
} }

10
pkg/controller/jenkins/jenkins_controller.go
View File

@ -139,9 +139,10 @@ func (r *ReconcileJenkins) reconcile(request reconcile.Request, logger logr.Logg
if err != nil { if err != nil {
return reconcile.Result{}, err return reconcile.Result{}, err
} }
if result != nil { if result.Requeue {
return *result, nil return result, nil
} }
if jenkins.Status.BaseConfigurationCompletedTime == nil { if jenkins.Status.BaseConfigurationCompletedTime == nil {
logger.Info("Base configuration phase is complete") logger.Info("Base configuration phase is complete")
now := metav1.Now() now := metav1.Now()
@ -169,9 +170,10 @@ func (r *ReconcileJenkins) reconcile(request reconcile.Request, logger logr.Logg
if err != nil { if err != nil {
return reconcile.Result{}, err return reconcile.Result{}, err
} }
if result != nil { if result.Requeue {
return *result, nil return result, nil
} }
if jenkins.Status.UserConfigurationCompletedTime == nil { if jenkins.Status.UserConfigurationCompletedTime == nil {
logger.Info("User configuration phase is complete") logger.Info("User configuration phase is complete")
now := metav1.Now() now := metav1.Now()