Adding first structure for webhook service.

Rewrote webhook conversion for ExternalSecrets

Signed-off-by: Gustavo Carvalho <gustavo.carvalho@container-solutions.com>

apis/externalsecrets/v1alpha1/externalsecret_conversion.go

@@ -15,6 +15,8 @@ limitations under the License.
 package v1alpha1
 
 import (
+	"encoding/json"
+
 	"sigs.k8s.io/controller-runtime/pkg/conversion"
 
 	esv1beta1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1beta1"
@@ -22,8 +24,8 @@ import (
 
 func (alpha *ExternalSecret) ConvertTo(betaRaw conversion.Hub) error {
 	beta := betaRaw.(*esv1beta1.ExternalSecret)
-
-	v1beta1DataFrom := make([]esv1beta1.ExternalSecretDataFromRemoteRef, len(alpha.Spec.DataFrom))
+	// Actual converted code thatn eeds to be like this
+	v1beta1DataFrom := make([]esv1beta1.ExternalSecretDataFromRemoteRef, 0)
 	for _, v1alpha1RemoteRef := range alpha.Spec.DataFrom {
 		v1beta1RemoteRef := esv1beta1.ExternalSecretDataFromRemoteRef{
 			Extract: esv1beta1.ExternalSecretDataRemoteRef{
@@ -35,82 +37,46 @@ func (alpha *ExternalSecret) ConvertTo(betaRaw conversion.Hub) error {
 		v1beta1DataFrom = append(v1beta1DataFrom, v1beta1RemoteRef)
 	}
 	beta.Spec.DataFrom = v1beta1DataFrom
-
-	v1beta1Data := make([]esv1beta1.ExternalSecretData, len(alpha.Spec.Data))
-	for _, v1alpha1SecretData := range alpha.Spec.Data {
-		v1beta1SecretData := esv1beta1.ExternalSecretData{
-			RemoteRef: esv1beta1.ExternalSecretDataRemoteRef{
-				Key:      v1alpha1SecretData.RemoteRef.Key,
-				Property: v1alpha1SecretData.RemoteRef.Property,
-				Version:  v1alpha1SecretData.RemoteRef.Version,
-			},
-			SecretKey: v1alpha1SecretData.SecretKey,
-		}
-		v1beta1Data = append(v1beta1Data, v1beta1SecretData)
+	tmp, err := json.Marshal(alpha.Spec.Data)
+	if err != nil {
+		return err
 	}
-	beta.Spec.Data = v1beta1Data
-
-	esv1beta1TemplateFrom := make([]esv1beta1.TemplateFrom, len(alpha.Spec.Target.Template.TemplateFrom))
-	for _, esv1alpha1TemplateFrom := range alpha.Spec.Target.Template.TemplateFrom {
-		esv1beta1ConfigMapItems := make([]esv1beta1.TemplateRefItem, len(esv1alpha1TemplateFrom.ConfigMap.Items))
-		for _, esv1alpha1ConfigMapItem := range esv1alpha1TemplateFrom.ConfigMap.Items {
-			esv1beta1ConfigMapItem := esv1beta1.TemplateRefItem(esv1alpha1ConfigMapItem)
-			esv1beta1ConfigMapItems = append(esv1beta1ConfigMapItems, esv1beta1ConfigMapItem)
-		}
-		esv1beta1SecretItems := make([]esv1beta1.TemplateRefItem, len(esv1alpha1TemplateFrom.Secret.Items))
-		for _, esv1alpha1SecretItem := range esv1alpha1TemplateFrom.Secret.Items {
-			esv1beta1SecretItem := esv1beta1.TemplateRefItem(esv1alpha1SecretItem)
-			esv1beta1SecretItems = append(esv1beta1SecretItems, esv1beta1SecretItem)
-		}
-		esv1beta1TemplateFromItem := esv1beta1.TemplateFrom{
-			ConfigMap: &esv1beta1.TemplateRef{
-				Name:  esv1alpha1TemplateFrom.ConfigMap.Name,
-				Items: esv1beta1ConfigMapItems,
-			},
-			Secret: &esv1beta1.TemplateRef{
-				Name:  esv1alpha1TemplateFrom.Secret.Name,
-				Items: esv1beta1SecretItems,
-			},
-		}
-		esv1beta1TemplateFrom = append(esv1beta1TemplateFrom, esv1beta1TemplateFromItem)
+	data := make([]esv1beta1.ExternalSecretData, 0)
+	err = json.Unmarshal(tmp, &data)
+	if err != nil {
+		return err
 	}
-	esv1beta1Template := esv1beta1.ExternalSecretTemplate{
-		Type:         alpha.Spec.Target.Template.Type,
-		Metadata:     esv1beta1.ExternalSecretTemplateMetadata(alpha.Spec.Target.Template.Metadata),
-		Data:         alpha.Spec.Target.Template.Data,
-		TemplateFrom: esv1beta1TemplateFrom,
+	beta.Spec.Data = data
+
+	tmp, err = json.Marshal(alpha.Spec.Target)
+	if err != nil {
+		return err
 	}
-	beta.Spec.Target = esv1beta1.ExternalSecretTarget{
-		Name:           alpha.Spec.Target.Name,
-		CreationPolicy: esv1beta1.ExternalSecretCreationPolicy(alpha.Spec.Target.CreationPolicy),
-		Immutable:      alpha.Spec.Target.Immutable,
-		Template:       &esv1beta1Template,
+	target := esv1beta1.ExternalSecretTarget{}
+	err = json.Unmarshal(tmp, &target)
+	if err != nil {
+		return err
 	}
+	beta.Spec.Target = target
 	beta.Spec.RefreshInterval = alpha.Spec.RefreshInterval
 	beta.Spec.SecretStoreRef = esv1beta1.SecretStoreRef(alpha.Spec.SecretStoreRef)
 	beta.ObjectMeta = alpha.ObjectMeta
-	esv1beta1Conditions := make([]esv1beta1.ExternalSecretStatusCondition, len(alpha.Status.Conditions))
-	for _, esv1alpha1Condition := range alpha.Status.Conditions {
-		esv1beta1Condition := esv1beta1.ExternalSecretStatusCondition{
-			Type:               esv1beta1.ExternalSecretConditionType(esv1alpha1Condition.Type),
-			Status:             esv1alpha1Condition.Status,
-			Reason:             esv1alpha1Condition.Reason,
-			Message:            esv1alpha1Condition.Message,
-			LastTransitionTime: esv1alpha1Condition.LastTransitionTime,
-		}
-		esv1beta1Conditions = append(esv1beta1Conditions, esv1beta1Condition)
+	tmp, err = json.Marshal(alpha.Status)
+	if err != nil {
+		return err
 	}
-	beta.Status = esv1beta1.ExternalSecretStatus{
-		RefreshTime:           alpha.Status.RefreshTime,
-		SyncedResourceVersion: alpha.Status.SyncedResourceVersion,
-		Conditions:            esv1beta1Conditions,
+	status := esv1beta1.ExternalSecretStatus{}
+	err = json.Unmarshal(tmp, &status)
+	if err != nil {
+		return err
 	}
+	beta.Status = status
 	return nil
 }
 
 func (alpha *ExternalSecret) ConvertFrom(betaRaw conversion.Hub) error {
 	beta := betaRaw.(*esv1beta1.ExternalSecret)
-	v1alpha1DataFrom := make([]ExternalSecretDataRemoteRef, len(beta.Spec.DataFrom))
+	v1alpha1DataFrom := make([]ExternalSecretDataRemoteRef, 0)
 	for _, v1beta1RemoteRef := range beta.Spec.DataFrom {
 		if v1beta1RemoteRef.Extract.Key != "" {
 			v1alpha1RemoteRef := ExternalSecretDataRemoteRef{
@@ -123,72 +89,39 @@ func (alpha *ExternalSecret) ConvertFrom(betaRaw conversion.Hub) error {
 	}
 	alpha.Spec.DataFrom = v1alpha1DataFrom
 
-	v1alpha1Data := make([]ExternalSecretData, len(beta.Spec.Data))
-	for _, v1beta1SecretData := range beta.Spec.Data {
-		v1alpha1SecretData := ExternalSecretData{
-			RemoteRef: ExternalSecretDataRemoteRef(v1beta1SecretData.RemoteRef),
-			SecretKey: v1beta1SecretData.SecretKey,
-		}
-		v1alpha1Data = append(v1alpha1Data, v1alpha1SecretData)
+	tmp, err := json.Marshal(beta.Spec.Data)
+	if err != nil {
+		return err
 	}
-	alpha.Spec.Data = v1alpha1Data
-
-	esv1alpha1TemplateFrom := make([]TemplateFrom, len(beta.Spec.Target.Template.TemplateFrom))
-	for _, esv1beta1TemplateFrom := range beta.Spec.Target.Template.TemplateFrom {
-		esv1alpha1ConfigMapItems := make([]TemplateRefItem, len(esv1beta1TemplateFrom.ConfigMap.Items))
-		for _, esv1beta1ConfigMapItem := range esv1beta1TemplateFrom.ConfigMap.Items {
-			esv1alpha1ConfigMapItem := TemplateRefItem(esv1beta1ConfigMapItem)
-			esv1alpha1ConfigMapItems = append(esv1alpha1ConfigMapItems, esv1alpha1ConfigMapItem)
-		}
-		esv1alpha1SecretItems := make([]TemplateRefItem, len(esv1beta1TemplateFrom.Secret.Items))
-		for _, esv1beta1SecretItem := range esv1beta1TemplateFrom.Secret.Items {
-			esv1alpha1SecretItem := TemplateRefItem(esv1beta1SecretItem)
-			esv1alpha1SecretItems = append(esv1alpha1SecretItems, esv1alpha1SecretItem)
-		}
-		esv1alpha1TemplateFromItem := TemplateFrom{
-			ConfigMap: &TemplateRef{
-				Name:  esv1beta1TemplateFrom.ConfigMap.Name,
-				Items: esv1alpha1ConfigMapItems,
-			},
-			Secret: &TemplateRef{
-				Name:  esv1beta1TemplateFrom.Secret.Name,
-				Items: esv1alpha1SecretItems,
-			},
-		}
-		esv1alpha1TemplateFrom = append(esv1alpha1TemplateFrom, esv1alpha1TemplateFromItem)
+	data := make([]ExternalSecretData, 0)
+	err = json.Unmarshal(tmp, &data)
+	if err != nil {
+		return err
 	}
-	esv1alpha1Template := ExternalSecretTemplate{
-		Type:         beta.Spec.Target.Template.Type,
-		Metadata:     ExternalSecretTemplateMetadata(beta.Spec.Target.Template.Metadata),
-		Data:         beta.Spec.Target.Template.Data,
-		TemplateFrom: esv1alpha1TemplateFrom,
+	alpha.Spec.Data = data
+
+	tmp, err = json.Marshal(beta.Spec.Target)
+	if err != nil {
+		return err
 	}
-	alpha.Spec.Target = ExternalSecretTarget{
-		Name:           beta.Spec.Target.Name,
-		CreationPolicy: ExternalSecretCreationPolicy(beta.Spec.Target.CreationPolicy),
-		Immutable:      beta.Spec.Target.Immutable,
-		Template:       &esv1alpha1Template,
+	target := ExternalSecretTarget{}
+	err = json.Unmarshal(tmp, &target)
+	if err != nil {
+		return err
 	}
+	alpha.Spec.Target = target
 	alpha.Spec.RefreshInterval = beta.Spec.RefreshInterval
 	alpha.Spec.SecretStoreRef = SecretStoreRef(beta.Spec.SecretStoreRef)
-
 	alpha.ObjectMeta = beta.ObjectMeta
-	esv1alpha1Conditions := make([]ExternalSecretStatusCondition, len(beta.Status.Conditions))
-	for _, esv1beta1Condition := range beta.Status.Conditions {
-		esv1alpha1Condition := ExternalSecretStatusCondition{
-			Type:               ExternalSecretConditionType(esv1beta1Condition.Type),
-			Status:             esv1beta1Condition.Status,
-			Reason:             esv1beta1Condition.Reason,
-			Message:            esv1beta1Condition.Message,
-			LastTransitionTime: esv1beta1Condition.LastTransitionTime,
-		}
-		esv1alpha1Conditions = append(esv1alpha1Conditions, esv1alpha1Condition)
+	tmp, err = json.Marshal(beta.Status)
+	if err != nil {
+		return err
 	}
-	alpha.Status = ExternalSecretStatus{
-		RefreshTime:           beta.Status.RefreshTime,
-		SyncedResourceVersion: beta.Status.SyncedResourceVersion,
-		Conditions:            esv1alpha1Conditions,
+	status := ExternalSecretStatus{}
+	err = json.Unmarshal(tmp, &status)
+	if err != nil {
+		return err
 	}
-
+	alpha.Status = status
 	return nil
 }

deploy/charts/external-secrets/templates/deployment.yaml

@@ -65,10 +65,18 @@ spec:
             {{- end }}
           {{- end }}
           {{- end }}
+          {{- if .Values.webhook.enabled }}
+          volumeMounts:
+          - name: certs
+            mountPath: /tmp/k8s-webhook-server/serving-certs
+          {{- end }}
           ports:
             - containerPort: {{ .Values.prometheus.service.port }}
               protocol: TCP
               name: metrics
+            - containerPort: 9443
+              protocol: TCP
+              name: webhook
           {{- with .Values.extraEnv }}
           env:
             {{- toYaml . | nindent 12 }}
@@ -77,6 +85,12 @@ spec:
           resources:
             {{- toYaml . | nindent 12 }}
           {{- end }}
+      {{- if .Values.webhook.enabled }}
+      volumes:
+      - name: certs
+        secret:
+          secretName: {{ .Values.webhook.secretName }}
+      {{- end }}
       {{- with .Values.nodeSelector }}
       nodeSelector:
         {{- toYaml . | nindent 8 }}

deploy/charts/external-secrets/templates/webhook-service.yaml

@@ -0,0 +1,18 @@
+{{- if .Values.webhook.enabled }}
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ include "external-secrets.name" . }}-webhook
+  labels:
+    {{- include "external-secrets.labels" . | nindent 4 }}
+    external-secrets.io/component : conversion-webhook
+spec:
+  type: ClusterIP
+  ports:
+    - port: 443
+      targetPort: 9443
+      protocol: TCP
+      name: webhook
+  selector:
+    {{- include "external-secrets.selectorLabels" . | nindent 4 }}
+{{- end }}

deploy/charts/external-secrets/values.yaml

@@ -78,6 +78,10 @@ prometheus:
   service:
     port: 8080
 
+webhook:
+  enabled: true
+  secretName: secret-certificate
+
 nodeSelector: {}
 
 tolerations: []