feat: remove docker registry dependency

pluralsh · Aug 29, 2022 · 568325a · 568325a
1 parent 6cf1bcf
commit 568325a
Show file tree

Hide file tree

Showing 13 changed files with 3 additions and 759 deletions.
diff --git a/api-server/controllers/controllersv1/cluster.go b/api-server/controllers/controllersv1/cluster.go
@@ -15,7 +15,6 @@ import (
 	"k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/client-go/tools/cache"
 
-	"github.com/bentoml/yatai-schemas/modelschemas"
 	"github.com/bentoml/yatai-schemas/schemasv1"
 	"github.com/bentoml/yatai/api-server/models"
 	"github.com/bentoml/yatai/api-server/services"
@@ -176,17 +175,6 @@ func (c *clusterController) List(ctx *gin.Context, schema *ListClusterSchema) (*
 	}, err
 }
 
-func (c *clusterController) GetDockerRegistryRef(ctx *gin.Context, schema *GetClusterSchema) (*modelschemas.DockerRegistryRefSchema, error) {
-	cluster, err := schema.GetCluster(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if err = c.canView(ctx, cluster); err != nil {
-		return nil, err
-	}
-	return services.ClusterService.GetDockerRegistryRef(ctx, cluster)
-}
-
 func (c *clusterController) WsPods(ctx *gin.Context, schema *GetClusterSchema) (err error) {
 	ctx.Request.Header.Del("Origin")
 	conn, err := wsUpgrader.Upgrade(ctx.Writer, ctx.Request, nil)

diff --git a/api-server/controllers/controllersv1/organization.go b/api-server/controllers/controllersv1/organization.go
@@ -133,17 +133,6 @@ func (c *organizationController) GetMajorCluster(ctx *gin.Context, schema *GetOr
 	return transformersv1.ToClusterFullSchema(ctx, cluster)
 }
 
-func (c *organizationController) GetDockerRegistry(ctx *gin.Context, schema *GetOrganizationSchema) (*modelschemas.DockerRegistrySchema, error) {
-	organization, err := schema.GetOrganization(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if err = c.canOperate(ctx, organization); err != nil {
-		return nil, err
-	}
-	return services.OrganizationService.GetDockerRegistry(ctx, organization)
-}
-
 type ListEventOperationNames struct {
 	GetOrganizationSchema
 	ResourceType modelschemas.ResourceType `query:"resource_type"`

diff --git a/api-server/routes/routes.go b/api-server/routes/routes.go
@@ -466,11 +466,6 @@ func clusterRoutes(grp *fizz.RouterGroup) {
 		fizz.Summary("Update a cluster"),
 	}, tonic.Handler(controllersv1.ClusterController.Update, 200))
 
-	resourceGrp.GET("/docker_registry_ref", []fizz.OperationOption{
-		fizz.ID("Get a cluster docker registry ref"),
-		fizz.Summary("Get a cluster docker registry ref"),
-	}, tonic.Handler(controllersv1.ClusterController.GetDockerRegistryRef, 200))
-
 	resourceGrp.GET("/members", []fizz.OperationOption{
 		fizz.ID("List cluster members"),
 		fizz.Summary("List cluster members"),

diff --git a/api-server/services/bento.go b/api-server/services/bento.go
@@ -324,28 +324,6 @@ func (s *bentoService) getS3ObjectName(ctx context.Context, bento *models.Bento)
 	return objectName, nil
 }
 
-func (s *bentoService) GetImageName(ctx context.Context, bento *models.Bento, inCluster bool) (string, error) {
-	bentoRepository, err := BentoRepositoryService.GetAssociatedBentoRepository(ctx, bento)
-	if err != nil {
-		return "", err
-	}
-	org, err := OrganizationService.GetAssociatedOrganization(ctx, bentoRepository)
-	if err != nil {
-		return "", err
-	}
-	dockerRegistry, err := OrganizationService.GetDockerRegistry(ctx, org)
-	if err != nil {
-		return "", err
-	}
-	var imageName string
-	if inCluster {
-		imageName = fmt.Sprintf("%s:yatai.%s.%s.%s", dockerRegistry.BentosRepositoryURIInCluster, org.Name, bentoRepository.Name, bento.Version)
-	} else {
-		imageName = fmt.Sprintf("%s:yatai.%s.%s.%s", dockerRegistry.BentosRepositoryURI, org.Name, bentoRepository.Name, bento.Version)
-	}
-	return imageName, nil
-}
-
 func (s *bentoService) GetS3BucketName(ctx context.Context, bento *models.Bento) (string, error) {
 	bentoRepository, err := BentoRepositoryService.GetAssociatedBentoRepository(ctx, bento)
 	if err != nil {

diff --git a/api-server/services/cluster.go b/api-server/services/cluster.go
@@ -1,19 +1,14 @@
 package services
 
 import (
-	"bytes"
 	"context"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"strings"
 
 	"github.com/ghodss/yaml"
 	"github.com/pkg/errors"
 	"gorm.io/gorm"
-	corev1 "k8s.io/api/core/v1"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/validation"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
@@ -367,64 +362,6 @@ func (s *clusterService) GetKubeCliSet(ctx context.Context, c *models.Cluster) (
 	return clientSet, restConfig, nil
 }
 
-func (s *clusterService) GetDockerRegistryRef(ctx context.Context, cluster *models.Cluster) (ref *modelschemas.DockerRegistryRefSchema, err error) {
-	namespace := consts.KubeNamespaceYataiOperators
-	name := "yatai-docker-registry-config"
-	key := "config"
-	ref = &modelschemas.DockerRegistryRefSchema{
-		Namespace: namespace,
-		Name:      name,
-		Key:       key,
-	}
-	org, err := OrganizationService.GetAssociatedOrganization(ctx, cluster)
-	if err != nil {
-		return ref, errors.Wrap(err, "get associated organization")
-	}
-	dockerRegistry, err := OrganizationService.GetDockerRegistry(ctx, org)
-	if err != nil {
-		return ref, errors.Wrap(err, "get docker registry")
-	}
-	content, err := json.Marshal(dockerRegistry)
-	if err != nil {
-		return ref, errors.Wrap(err, "marshal docker registry")
-	}
-	secret := corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      name,
-			Namespace: namespace,
-		},
-		Data: map[string][]byte{
-			key: content,
-		},
-	}
-	clientSet, _, err := s.GetKubeCliSet(ctx, cluster)
-	if err != nil {
-		return ref, errors.Wrap(err, "get kube cli set")
-	}
-	secretCli := clientSet.CoreV1().Secrets(namespace)
-	oldSecret, err := secretCli.Get(ctx, name, metav1.GetOptions{})
-	isNotFound := apierrors.IsNotFound(err)
-	if err != nil && !isNotFound {
-		return ref, errors.Wrap(err, "get secret")
-	}
-	if !isNotFound {
-		if bytes.Equal(content, oldSecret.Data[key]) {
-			return ref, nil
-		}
-		oldSecret.Data[key] = content
-		_, err = secretCli.Update(ctx, oldSecret, metav1.UpdateOptions{})
-		if err != nil {
-			return ref, errors.Wrap(err, "update secret")
-		}
-	} else {
-		_, err = secretCli.Create(ctx, &secret, metav1.CreateOptions{})
-		if err != nil {
-			return ref, errors.Wrap(err, "create secret")
-		}
-	}
-	return ref, nil
-}
-
 func (s *clusterService) GenerateGrafanaHostname(ctx context.Context, cluster *models.Cluster) (string, error) {
 	clientset, _, err := s.GetKubeCliSet(ctx, cluster)
 	if err != nil {
@@ -482,152 +419,6 @@ func (s *clusterService) GetGrafana(ctx context.Context, cluster *models.Cluster
 	}, err
 }
 
-func (s *clusterService) MakeSureDockerConfigSecret(ctx context.Context, cluster *models.Cluster, namespace string) (dockerConfigSecret *corev1.Secret, err error) {
-	org, err := OrganizationService.GetAssociatedOrganization(ctx, cluster)
-	if err != nil {
-		return nil, err
-	}
-
-	dockerRegistry, err := OrganizationService.GetDockerRegistry(ctx, org)
-	if err != nil {
-		return nil, err
-	}
-
-	dockerConfigCMKubeName := "docker-config"
-	dockerConfigObj := struct {
-		Auths map[string]struct {
-			Auth string `json:"auth"`
-		} `json:"auths,omitempty"`
-	}{}
-
-	if dockerRegistry.Username != "" {
-		dockerConfigObj.Auths = map[string]struct {
-			Auth string `json:"auth"`
-		}{
-			dockerRegistry.Server: {
-				Auth: base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", dockerRegistry.Username, dockerRegistry.Password))),
-			},
-		}
-	}
-
-	dockerConfigContent, err := json.Marshal(dockerConfigObj)
-	if err != nil {
-		return nil, err
-	}
-
-	kubeCli, _, err := s.GetKubeCliSet(ctx, cluster)
-	if err != nil {
-		return nil, err
-	}
-
-	secretsCli := kubeCli.CoreV1().Secrets(namespace)
-
-	dockerConfigSecret, err = secretsCli.Get(ctx, dockerConfigCMKubeName, metav1.GetOptions{})
-	dockerConfigIsNotFound := apierrors.IsNotFound(err)
-	// nolint: gocritic
-	if err != nil && !dockerConfigIsNotFound {
-		return nil, err
-	}
-	err = nil
-	if dockerConfigIsNotFound {
-		dockerConfigSecret = &corev1.Secret{
-			ObjectMeta: metav1.ObjectMeta{Name: dockerConfigCMKubeName},
-			StringData: map[string]string{
-				"config.json": string(dockerConfigContent),
-			},
-		}
-		_, err_ := secretsCli.Create(ctx, dockerConfigSecret, metav1.CreateOptions{})
-		if err_ != nil {
-			dockerConfigSecret, err = secretsCli.Get(ctx, dockerConfigCMKubeName, metav1.GetOptions{})
-			dockerConfigIsNotFound = apierrors.IsNotFound(err)
-			if err != nil && !dockerConfigIsNotFound {
-				return nil, err
-			}
-			if dockerConfigIsNotFound {
-				return nil, err_
-			}
-			if err != nil {
-				err = nil
-			}
-		}
-	} else {
-		dockerConfigSecret.Data["config.json"] = dockerConfigContent
-		_, err = secretsCli.Update(ctx, dockerConfigSecret, metav1.UpdateOptions{})
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return
-}
-
-func (s *clusterService) MakeSureDockerRegcred(ctx context.Context, cluster *models.Cluster, namespace string) (secret *corev1.Secret, err error) {
-	org, err := OrganizationService.GetAssociatedOrganization(ctx, cluster)
-	if err != nil {
-		return
-	}
-
-	dockerRegistry, err := OrganizationService.GetDockerRegistry(ctx, org)
-	if err != nil {
-		return
-	}
-
-	if dockerRegistry.Username != "" {
-		var kubeCli *kubernetes.Clientset
-		kubeCli, _, err = ClusterService.GetKubeCliSet(ctx, cluster)
-		if err != nil {
-			return
-		}
-		secretsCli := kubeCli.CoreV1().Secrets(namespace)
-		secret, err = secretsCli.Get(ctx, consts.KubeSecretNameRegcred, metav1.GetOptions{})
-		isNotFound := apierrors.IsNotFound(err)
-		if err != nil && !isNotFound {
-			return
-		}
-		dockerConfig := struct {
-			Auths map[string]struct {
-				Auth string `json:"auth"`
-			} `json:"auths"`
-		}{
-			Auths: map[string]struct {
-				Auth string `json:"auth"`
-			}{
-				dockerRegistry.Server: {
-					Auth: base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", dockerRegistry.Username, dockerRegistry.Password))),
-				},
-			},
-		}
-		var dockerConfigContent []byte
-		dockerConfigContent, err = json.Marshal(&dockerConfig)
-		if err != nil {
-			return
-		}
-		if isNotFound {
-			secret = &corev1.Secret{
-				Type: corev1.SecretTypeDockerConfigJson,
-				ObjectMeta: metav1.ObjectMeta{
-					Name:      consts.KubeSecretNameRegcred,
-					Namespace: namespace,
-				},
-				Data: map[string][]byte{
-					".dockerconfigjson": dockerConfigContent,
-				},
-			}
-			_, err = secretsCli.Create(ctx, secret, metav1.CreateOptions{})
-			if err != nil {
-				return
-			}
-		} else {
-			secret.Data[".dockerconfigjson"] = dockerConfigContent
-			_, err = secretsCli.Update(ctx, secret, metav1.UpdateOptions{})
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
 type IClusterAssociate interface {
 	GetAssociatedClusterId() uint
 	GetAssociatedClusterCache() *models.Cluster