github.com/1aal/kubeblocks@v0.0.0-20231107070852-e1c03e598921/pkg/controller/plan/service_descriptor_utils.go

/*
Copyright (C) 2022-2023 ApeCloud Co., Ltd

This file is part of KubeBlocks project

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package plan

import (
	"fmt"
	"regexp"
	"strings"

	"golang.org/x/exp/slices"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/types"
	"sigs.k8s.io/controller-runtime/pkg/client"

	appsv1alpha1 "github.com/1aal/kubeblocks/apis/apps/v1alpha1"
	"github.com/1aal/kubeblocks/pkg/constant"
	"github.com/1aal/kubeblocks/pkg/controller/builder"
	"github.com/1aal/kubeblocks/pkg/controller/component"
	intctrlutil "github.com/1aal/kubeblocks/pkg/controllerutil"
)

func GenServiceReferences(reqCtx intctrlutil.RequestCtx,
	cli client.Client,
	cluster *appsv1alpha1.Cluster,
	clusterCompDef *appsv1alpha1.ClusterComponentDefinition,
	clusterCompSpec *appsv1alpha1.ClusterComponentSpec,
) (map[string]*appsv1alpha1.ServiceDescriptor, error) {
	if cluster == nil || clusterCompDef == nil || clusterCompSpec == nil {
		return nil, nil
	}

	if len(clusterCompDef.ServiceRefDeclarations) == 0 {
		return nil, nil
	}

	serviceReferences := make(map[string]*appsv1alpha1.ServiceDescriptor, len(clusterCompDef.ServiceRefDeclarations))
	for _, serviceRefDecl := range clusterCompDef.ServiceRefDeclarations {
		for _, serviceRef := range clusterCompSpec.ServiceRefs {
			if serviceRef.Name != serviceRefDecl.Name {
				continue
			}
			targetNamespace := cluster.Namespace
			if serviceRef.Namespace != "" {
				targetNamespace = serviceRef.Namespace
			}
			// if service reference is another KubeBlocks Cluster, then it is necessary to generate a service connection credential from the cluster connection credential secret
			if serviceRef.Cluster != "" {
				if err := handleClusterTypeServiceRef(reqCtx, cli, targetNamespace, cluster, serviceRef, serviceRefDecl, serviceReferences); err != nil {
					return nil, err
				}
				// serviceRef.Cluster takes precedence, and if serviceRef.Cluster is set, serviceRef.ServiceDescriptor will be ignored
				break
			}

			if serviceRef.ServiceDescriptor != "" {
				if err := handleServiceDescriptorTypeServiceRef(reqCtx, cli, targetNamespace, serviceRef, serviceRefDecl, serviceReferences); err != nil {
					return nil, err
				}
			}
		}
		// _, exist := serviceReferences[serviceRefDecl.Name]
		// if !exist {
		//	 return nil, fmt.Errorf("componentDef %s's serviceRefDeclaration %s has not been defined, please check if there is corresponding service definition and binding in Cluster.spec.componentSpecs[*].serviceRefs", clusterCompDef.Name, serviceRefDecl.Name)
		// }
	}
	if len(serviceReferences) == 0 {
		return nil, nil
	}
	return serviceReferences, nil
}

// handleClusterTypeServiceRef handles the service reference is another KubeBlocks Cluster.
func handleClusterTypeServiceRef(reqCtx intctrlutil.RequestCtx,
	cli client.Client,
	namespace string,
	cluster *appsv1alpha1.Cluster,
	serviceRef appsv1alpha1.ServiceRef,
	serviceRefDecl appsv1alpha1.ServiceRefDeclaration,
	serviceReferences map[string]*appsv1alpha1.ServiceDescriptor) error {
	if serviceRef.Cluster == cluster.Name {
		return fmt.Errorf("cluster %s cannot reference itself", cluster.Name)
	}
	referencedCluster := &appsv1alpha1.Cluster{}
	if err := cli.Get(reqCtx.Ctx, types.NamespacedName{Namespace: namespace, Name: serviceRef.Cluster}, referencedCluster); err != nil {
		return err
	}

	// get the connection credential secret of the referenced cluster
	secretRef := &corev1.Secret{}
	secretRefName := component.GenerateConnCredential(referencedCluster.Name)
	if err := cli.Get(reqCtx.Ctx, types.NamespacedName{Namespace: namespace, Name: secretRefName}, secretRef); err != nil {
		return err
	}

	handleSecretKey := func(secretRef *corev1.Secret, sdBuilder *builder.ServiceDescriptorBuilder, key string, setter func(appsv1alpha1.CredentialVar) *builder.ServiceDescriptorBuilder) {
		if _, ok := secretRef.Data[key]; ok {
			setter(appsv1alpha1.CredentialVar{
				ValueFrom: &corev1.EnvVarSource{
					SecretKeyRef: &corev1.SecretKeySelector{
						LocalObjectReference: corev1.LocalObjectReference{Name: secretRef.Name},
						Key:                  key,
					},
				},
			})
		}
	}

	// TODO: Second-stage optimization: Cluster-type references no longer perform conversion on the connection credential field. Instead, the configMap or secret is directly passed through to the serviceDescriptor.
	sdBuilder := builder.NewServiceDescriptorBuilder(namespace, component.GenerateDefaultServiceDescriptorName(cluster.Name))
	sdBuilder.SetServiceKind("")
	sdBuilder.SetServiceVersion("")
	handleSecretKey(secretRef, sdBuilder, constant.ServiceDescriptorEndpointKey, sdBuilder.SetEndpoint)
	handleSecretKey(secretRef, sdBuilder, constant.ServiceDescriptorPortKey, sdBuilder.SetPort)
	_, uOk := secretRef.Data[constant.ServiceDescriptorUsernameKey]
	_, pOk := secretRef.Data[constant.ServiceDescriptorPasswordKey]
	if uOk && pOk {
		sdBuilder.SetAuth(appsv1alpha1.ConnectionCredentialAuth{
			Username: &appsv1alpha1.CredentialVar{
				ValueFrom: &corev1.EnvVarSource{
					SecretKeyRef: &corev1.SecretKeySelector{
						LocalObjectReference: corev1.LocalObjectReference{Name: secretRef.Name},
						Key:                  constant.ServiceDescriptorUsernameKey,
					},
				},
			},
			Password: &appsv1alpha1.CredentialVar{
				ValueFrom: &corev1.EnvVarSource{
					SecretKeyRef: &corev1.SecretKeySelector{
						LocalObjectReference: corev1.LocalObjectReference{Name: secretRef.Name},
						Key:                  constant.ServiceDescriptorPasswordKey,
					},
				},
			},
		})
	}
	serviceReferences[serviceRefDecl.Name] = sdBuilder.GetObject()
	return nil
}

// handleServiceDescriptorTypeServiceRef handles the service reference is provided by external ServiceDescriptor object.
func handleServiceDescriptorTypeServiceRef(reqCtx intctrlutil.RequestCtx,
	cli client.Client,
	namespace string,
	serviceRef appsv1alpha1.ServiceRef,
	serviceRefDecl appsv1alpha1.ServiceRefDeclaration,
	serviceReferences map[string]*appsv1alpha1.ServiceDescriptor) error {
	// verify service kind and version
	verifyServiceKindAndVersion := func(serviceDescriptor appsv1alpha1.ServiceDescriptor, serviceRefDeclSpecs ...appsv1alpha1.ServiceRefDeclarationSpec) bool {
		for _, serviceRefDeclSpec := range serviceRefDecl.ServiceRefDeclarationSpecs {
			if getWellKnownServiceKindAliasMapping(serviceRefDeclSpec.ServiceKind) != getWellKnownServiceKindAliasMapping(serviceDescriptor.Spec.ServiceKind) {
				continue
			}
			versionMatch := verifyServiceVersion(serviceDescriptor.Spec.ServiceVersion, serviceRefDeclSpec.ServiceVersion)
			if versionMatch {
				return true
			}
		}
		return false
	}
	serviceDescriptor := &appsv1alpha1.ServiceDescriptor{}
	if err := cli.Get(reqCtx.Ctx, client.ObjectKey{Namespace: namespace, Name: serviceRef.ServiceDescriptor}, serviceDescriptor); err != nil {
		return err
	}
	if serviceDescriptor.Status.Phase != appsv1alpha1.AvailablePhase {
		return fmt.Errorf("service descriptor %s status is not available", serviceDescriptor.Name)
	}
	match := verifyServiceKindAndVersion(*serviceDescriptor, serviceRefDecl.ServiceRefDeclarationSpecs...)
	if !match {
		return fmt.Errorf("service descriptor %s kind or version is not match with service reference declaration %s", serviceDescriptor.Name, serviceRefDecl.Name)
	}
	serviceReferences[serviceRefDecl.Name] = serviceDescriptor
	return nil
}

func verifyServiceVersion(serviceDescriptorVersion, serviceRefDeclarationServiceVersion string) bool {
	isRegex := false
	regex, err := regexp.Compile(serviceRefDeclarationServiceVersion)
	if err == nil {
		isRegex = true
	}
	if !isRegex {
		return serviceDescriptorVersion == serviceRefDeclarationServiceVersion
	}
	return regex.MatchString(serviceDescriptorVersion)
}

func getWellKnownServiceKindAliasMapping(serviceKind string) string {
	lowerServiceKind := strings.ToLower(serviceKind)
	switch {
	case slices.Contains(constant.GetZookeeperAlias(), lowerServiceKind):
		return constant.ServiceKindZookeeper
	case slices.Contains(constant.GetElasticSearchAlias(), lowerServiceKind):
		return constant.ServiceKindElasticSearch
	case slices.Contains(constant.GetMongoDBAlias(), lowerServiceKind):
		return constant.ServiceKindMongoDB
	case slices.Contains(constant.GetPostgreSQLAlias(), lowerServiceKind):
		return constant.ServiceKindPostgreSQL
	case slices.Contains(constant.GetClickHouseAlias(), lowerServiceKind):
		return constant.ServiceKindClickHouse
	default:
		return lowerServiceKind
	}
}