certServiceK8sExternalProvider/src/cmpv2controller/certificate_request_controller.go

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * oom-certservice-k8s-external-provider
   4  * ================================================================================
   5  * Copyright 2019 The cert-manager authors.
   6  * Modifications copyright (C) 2020 Nokia. All rights reserved.
   7  * ================================================================================
   8  * This source code was copied from the following git repository:
   9  * https://github.com/smallstep/step-issuer
  10  * The source code was modified for usage in the ONAP project.
  11  * ================================================================================
  12  * Licensed under the Apache License, Version 2.0 (the "License");
  13  * you may not use this file except in compliance with the License.
  14  * You may obtain a copy of the License at
  15  *
  16  *      http://www.apache.org/licenses/LICENSE-2.0
  17  *
  18  * Unless required by applicable law or agreed to in writing, software
  19  * distributed under the License is distributed on an "AS IS" BASIS,
  20  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21  * See the License for the specific language governing permissions and
  22  * limitations under the License.
  23  * ============LICENSE_END=========================================================
  24  */
  25
  26 package cmpv2controller
  27
  28 import (
  29         "context"
  30         "fmt"
  31
  32         "github.com/go-logr/logr"
  33         apiutil "github.com/jetstack/cert-manager/pkg/api/util"
  34         cmapi "github.com/jetstack/cert-manager/pkg/apis/certmanager/v1"
  35         cmmeta "github.com/jetstack/cert-manager/pkg/apis/meta/v1"
  36         core "k8s.io/api/core/v1"
  37         apierrors "k8s.io/apimachinery/pkg/api/errors"
  38         "k8s.io/apimachinery/pkg/types"
  39         "k8s.io/client-go/tools/record"
  40         ctrl "sigs.k8s.io/controller-runtime"
  41         "sigs.k8s.io/controller-runtime/pkg/client"
  42
  43         "onap.org/oom-certservice/k8s-external-provider/src/cmpv2api"
  44         provisioners "onap.org/oom-certservice/k8s-external-provider/src/cmpv2provisioner"
  45 )
  46
  47 const (
  48         privateKeySecretNameAnnotation = "cert-manager.io/private-key-secret-name"
  49         privateKeySecretKey = "tls.key"
  50 )
  51
  52 // CertificateRequestController reconciles a CMPv2Issuer object.
  53 type CertificateRequestController struct {
  54         client.Client
  55         Log      logr.Logger
  56         Recorder record.EventRecorder
  57 }
  58
  59 // Reconcile will read and validate a CMPv2Issuer resource associated to the
  60 // CertificateRequest resource, and it will sign the CertificateRequest with the
  61 // provisioner in the CMPv2Issuer.
  62 func (controller *CertificateRequestController) Reconcile(k8sRequest ctrl.Request) (ctrl.Result, error) {
  63         ctx := context.Background()
  64         log := controller.Log.WithValues("certificate-request-controller", k8sRequest.NamespacedName)
  65
  66         // 1. Fetch the CertificateRequest resource being reconciled.
  67         certificateRequest := new(cmapi.CertificateRequest)
  68         log.Info("Registered new certificate sign request: ", "cert-name", certificateRequest.Name)
  69         if err := controller.Client.Get(ctx, k8sRequest.NamespacedName, certificateRequest); err != nil {
  70                 err = handleErrorResourceNotFound(log, err)
  71                 return ctrl.Result{}, err
  72         }
  73
  74         // 2. Check if CertificateRequest is meant for CMPv2Issuer (if not ignore)
  75         if !isCMPv2CertificateRequest(certificateRequest) {
  76                 log.Info("Certificate request is not meant for CMPv2Issuer (ignoring)",
  77                         "group", certificateRequest.Spec.IssuerRef.Group,
  78                         "kind", certificateRequest.Spec.IssuerRef.Kind)
  79                 return ctrl.Result{}, nil
  80         }
  81
  82         // 3. If the certificate data is already set then we skip this request as it
  83         // has already been completed in the past.
  84         if len(certificateRequest.Status.Certificate) > 0 {
  85                 log.Info("Existing certificate data found in status, skipping already completed CertificateRequest")
  86                 return ctrl.Result{}, nil
  87         }
  88
  89         // 4. Fetch the CMPv2Issuer resource
  90         issuer := cmpv2api.CMPv2Issuer{}
  91         issuerNamespaceName := types.NamespacedName{
  92                 Namespace: k8sRequest.Namespace,
  93                 Name:      certificateRequest.Spec.IssuerRef.Name,
  94         }
  95         if err := controller.Client.Get(ctx, issuerNamespaceName, &issuer); err != nil {
  96                 controller.handleErrorGettingCMPv2Issuer(ctx, log, err, certificateRequest, issuerNamespaceName, k8sRequest)
  97                 return ctrl.Result{}, err
  98         }
  99
 100         // 5. Check if CMPv2Issuer is ready to sing certificates
 101         if !isCMPv2IssuerReady(issuer) {
 102                 err := controller.handleErrorCMPv2IssuerIsNotReady(ctx, log, issuerNamespaceName, certificateRequest, k8sRequest)
 103                 return ctrl.Result{}, err
 104         }
 105
 106         // 6. Load the provisioner that will sign the CertificateRequest
 107         provisioner, ok := provisioners.Load(issuerNamespaceName)
 108         if !ok {
 109                 err := controller.handleErrorCouldNotLoadCMPv2Provisioner(ctx, log, issuerNamespaceName, certificateRequest)
 110                 return ctrl.Result{}, err
 111         }
 112
 113         // 7. Get private key matching CertificateRequest
 114         privateKeySecretName := certificateRequest.ObjectMeta.Annotations[privateKeySecretNameAnnotation]
 115         privateKeySecretNamespaceName := types.NamespacedName{
 116                 Namespace: k8sRequest.Namespace,
 117                 Name:      privateKeySecretName,
 118         }
 119         var privateKeySecret core.Secret
 120         if err := controller.Client.Get(ctx, privateKeySecretNamespaceName, &privateKeySecret); err != nil {
 121                 controller.handleErrorGettingPrivateKey(ctx, log, err, certificateRequest, privateKeySecretNamespaceName)
 122                 return ctrl.Result{}, err
 123         }
 124         privateKeyBytes := privateKeySecret.Data[privateKeySecretKey]
 125
 126         // 8. Sign CertificateRequest
 127         signedPEM, trustedCAs, err := provisioner.Sign(ctx, certificateRequest, privateKeyBytes)
 128         if err != nil {
 129                 controller.handleErrorFailedToSignCertificate(ctx, log, err, certificateRequest)
 130                 return ctrl.Result{}, err
 131         }
 132
 133         // 9. Store signed certificates in CertificateRequest
 134         certificateRequest.Status.Certificate = signedPEM
 135         certificateRequest.Status.CA = trustedCAs
 136         if err := controller.updateCertificateRequestWithSignedCerficates(ctx, certificateRequest); err != nil {
 137                 return ctrl.Result{}, err
 138         }
 139
 140         return ctrl.Result{}, nil
 141 }
 142
 143 func (controller *CertificateRequestController) updateCertificateRequestWithSignedCerficates(ctx context.Context, certificateRequest *cmapi.CertificateRequest) error {
 144         return controller.setStatus(ctx, certificateRequest, cmmeta.ConditionTrue, cmapi.CertificateRequestReasonIssued, "Certificate issued")
 145 }
 146
 147 func (controller *CertificateRequestController) SetupWithManager(manager ctrl.Manager) error {
 148         return ctrl.NewControllerManagedBy(manager).
 149                 For(&cmapi.CertificateRequest{}).
 150                 Complete(controller)
 151 }
 152
 153 func (controller *CertificateRequestController) setStatus(ctx context.Context, certificateRequest *cmapi.CertificateRequest, status cmmeta.ConditionStatus, reason, message string, args ...interface{}) error {
 154         completeMessage := fmt.Sprintf(message, args...)
 155         apiutil.SetCertificateRequestCondition(certificateRequest, cmapi.CertificateRequestConditionReady, status, reason, completeMessage)
 156
 157         // Fire an Event to additionally inform users of the change
 158         eventType := core.EventTypeNormal
 159         if status == cmmeta.ConditionFalse {
 160                 eventType = core.EventTypeWarning
 161         }
 162         controller.Recorder.Event(certificateRequest, eventType, reason, completeMessage)
 163
 164         return controller.Client.Status().Update(ctx, certificateRequest)
 165 }
 166
 167 func isCMPv2IssuerReady(issuer cmpv2api.CMPv2Issuer) bool {
 168         condition := cmpv2api.CMPv2IssuerCondition{Type: cmpv2api.ConditionReady, Status: cmpv2api.ConditionTrue}
 169         return hasCondition(issuer, condition)
 170 }
 171
 172 func hasCondition(issuer cmpv2api.CMPv2Issuer, condition cmpv2api.CMPv2IssuerCondition) bool {
 173         existingConditions := issuer.Status.Conditions
 174         for _, cond := range existingConditions {
 175                 if condition.Type == cond.Type && condition.Status == cond.Status {
 176                         return true
 177                 }
 178         }
 179         return false
 180 }
 181
 182 func isCMPv2CertificateRequest(certificateRequest *cmapi.CertificateRequest) bool {
 183         return certificateRequest.Spec.IssuerRef.Group != "" &&
 184                 certificateRequest.Spec.IssuerRef.Group == cmpv2api.GroupVersion.Group &&
 185                 certificateRequest.Spec.IssuerRef.Kind == cmpv2api.CMPv2IssuerKind
 186
 187 }
 188
 189 // Error handling
 190
 191 func (controller *CertificateRequestController) handleErrorCouldNotLoadCMPv2Provisioner(ctx context.Context, log logr.Logger, issuerNamespaceName types.NamespacedName, certificateRequest *cmapi.CertificateRequest) error {
 192         err := fmt.Errorf("provisioner %s not found", issuerNamespaceName)
 193         log.Error(err, "Failed to load CMPv2 Provisioner resource")
 194         _ = controller.setStatus(ctx, certificateRequest, cmmeta.ConditionFalse, cmapi.CertificateRequestReasonPending, "Failed to load provisioner for CMPv2Issuer resource %s", issuerNamespaceName)
 195         return err
 196 }
 197
 198 func (controller *CertificateRequestController) handleErrorCMPv2IssuerIsNotReady(ctx context.Context, log logr.Logger, issuerNamespaceName types.NamespacedName, certificateRequest *cmapi.CertificateRequest, req ctrl.Request) error {
 199         err := fmt.Errorf("resource %s is not ready", issuerNamespaceName)
 200         log.Error(err, "CMPv2Issuer not ready", "namespace", req.Namespace, "name", certificateRequest.Spec.IssuerRef.Name)
 201         _ = controller.setStatus(ctx, certificateRequest, cmmeta.ConditionFalse, cmapi.CertificateRequestReasonPending, "CMPv2Issuer resource %s is not Ready", issuerNamespaceName)
 202         return err
 203 }
 204
 205 func (controller *CertificateRequestController) handleErrorGettingCMPv2Issuer(ctx context.Context, log logr.Logger, err error, certificateRequest *cmapi.CertificateRequest, issuerNamespaceName types.NamespacedName, req ctrl.Request) {
 206         log.Error(err, "Failed to retrieve CMPv2Issuer resource", "namespace", req.Namespace, "name", certificateRequest.Spec.IssuerRef.Name)
 207         _ = controller.setStatus(ctx, certificateRequest, cmmeta.ConditionFalse, cmapi.CertificateRequestReasonPending, "Failed to retrieve CMPv2Issuer resource %s: %v", issuerNamespaceName, err)
 208 }
 209
 210 func (controller *CertificateRequestController) handleErrorGettingPrivateKey(ctx context.Context, log logr.Logger, err error, certificateRequest *cmapi.CertificateRequest, pkSecretNamespacedName types.NamespacedName) {
 211         log.Error(err, "Failed to retrieve private key secret for certificate request", "namespace", pkSecretNamespacedName.Namespace, "name", pkSecretNamespacedName.Name)
 212         _ = controller.setStatus(ctx, certificateRequest, cmmeta.ConditionFalse, cmapi.CertificateRequestReasonPending, "Failed to retrieve private key secret: %v", err)
 213 }
 214
 215 func (controller *CertificateRequestController) handleErrorFailedToSignCertificate(ctx context.Context, log logr.Logger, err error, certificateRequest *cmapi.CertificateRequest) {
 216         log.Error(err, "Failed to sign certificate request")
 217         _ = controller.setStatus(ctx, certificateRequest, cmmeta.ConditionFalse, cmapi.CertificateRequestReasonFailed, "Failed to sign certificate request: %v", err)
 218 }
 219
 220 func handleErrorResourceNotFound(log logr.Logger, err error) error {
 221         if apierrors.IsNotFound(err) {
 222                 log.Error(err, "CertificateRequest resource not found")
 223         } else {
 224                 log.Error(err, "Failed to retrieve CertificateRequest resource")
 225         }
 226         return err
 227 }