softplayer-backend/internal/controllers/applications.go

package controllers

import (
	"bytes"
	"context"
	b64 "encoding/base64"
	"fmt"
	"os"
	"strings"
	"text/template"

	"git.badhouseplants.net/softplayer/softplayer-backend/internal/consts"
	"git.badhouseplants.net/softplayer/softplayer-backend/internal/helpers/helm"
	"git.badhouseplants.net/softplayer/softplayer-backend/internal/helpers/kube"
	"git.badhouseplants.net/softplayer/softplayer-backend/internal/types/helmrelease"
	"github.com/go-logr/logr"
	"github.com/go-logr/zapr"
	"github.com/google/uuid"
	"go.uber.org/zap"
	"gopkg.in/yaml.v2"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	corev1 "k8s.io/api/core/v1"
	"k8s.io/client-go/rest"
	ctrl "sigs.k8s.io/controller-runtime"
)

type Application struct {
	Controller ctrl.Manager
	UserID     string
	Data       *ApplicationData
	Token      string
}

type ApplicationData struct {
	UUID        string
	Name        string
	Description string
	Application string
	Version     string
	Environemnt string
	Config      map[string]string
	RawConfig   string
}

// Create environment should create a new configmap in the user's namespace
// using a token that belongs to the user.
func (app *Application) Create(ctx context.Context) error {
	log, err := logr.FromContext(ctx)
	if err != nil {
		zapLog, err := zap.NewDevelopment()
		if err != nil {
			panic(fmt.Sprintf("who watches the watchmen (%v)?", err))
		}
		log = zapr.NewLogger(zapLog)
	}

	app.Data.UUID = uuid.New().String()

	app.Controller.GetClient()
	conf := &rest.Config{
		Host:        "https://kubernetes.default.svc.cluster.local:443",
		BearerToken: app.Token,
		TLSClientConfig: rest.TLSClientConfig{
			Insecure: true,
		},
	}

	controller, err := ctrl.NewManager(conf, ctrl.Options{})

	if err != nil {
		return err
	}

	helmEntry := helm.NewHelm()
	// TODO: It should be possible to use other repos
	release := &helm.ReleaseData{
		Name:           app.Data.Name,
		Chart:          app.Data.Application,
		Version:        app.Data.Version,
		RepositoryURL:  "oci://registry.badhouseplants.net/softplayer/helm",
		RepositoryKind: "oci",
		RepositoryName: "softplayer",
	}
	formattedName := strings.ToLower(
		b64.StdEncoding.EncodeToString(
			[]byte(app.Data.Application + app.Data.Name + app.Data.Name + app.Data.Environemnt),
		),
	)[0:20]

	goPath := os.TempDir() + "/softplayer/" + formattedName
	if err := os.MkdirAll(goPath, 0777); err != nil {
		return err
	}

	path, err := helmEntry.PullChart(goPath, release)
	if err != nil {
		log.Error(err, "Couldn't pull the chart")
		return consts.ErrSystemError
	}

	prettyCfgSupport := true
	cfgSchema := map[string]*helmrelease.PrettyConfigSchema{}
	cfgSchemaPath, err := os.ReadFile(fmt.Sprintf("%s/%s/config.yaml", goPath, path))
	if err != nil {
		log.Error(err, "Couldn't find the config file")
		prettyCfgSupport = false
	} else {
		err = yaml.Unmarshal(cfgSchemaPath, cfgSchema)
		if err != nil {
			log.Error(err, "Couldn't parse the pretty config")
			return err
		}
	}

	cfg := &helmrelease.HelmRelease{
		Helm: helmrelease.Helm{
			Release: app.Data.Name,
			Chart: helmrelease.Chart{
				Name:    app.Data.Application,
				Version: app.Data.Version,
			},
			Repo: helmrelease.Repo{
				URL:  release.RepositoryURL,
				Type: release.RepositoryKind,
			},
		},
		Config: helmrelease.Config{},
	}

	if len(app.Data.Config) > 0 && prettyCfgSupport {
		for key, val := range app.Data.Config {
			value, ok := cfgSchema[key]
			if !ok {
				return fmt.Errorf("unsuported config entry: %s", key)
			}
			tmpl, err := template.New("prettyconfig").Parse(val)
			if err != nil {
				log.Error(err, "Coudln't build a tempalte for prettyconfig")
				return consts.ErrSystemError
			}
			var tmplRes bytes.Buffer
			if err := tmpl.Execute(&tmplRes, app.Data); err != nil {
				log.Error(err, "Couldn't execute the prettyconfig template")
				return consts.ErrSystemError
			}

			cfg.Config.Pretty = append(cfg.Config.Pretty, helmrelease.PrettyConfig{
				Key:   key,
				Path:  value.Path,
				Value: tmplRes.String(),
			})
		}
	} else if len(app.Data.RawConfig) > 0 {
		cfg.Config.Raw = app.Data.RawConfig
	}

	cfgYaml, err := yaml.Marshal(cfg)
	if err != nil {
		log.Error(err, "Couldn't marshall a pretty config into a struct")
		return consts.ErrSystemError
	}

	appSecret := corev1.Secret{
		ObjectMeta: metav1.ObjectMeta{
			Name:      formattedName[0:20],
			Namespace: app.UserID,
			Labels: map[string]string{
				"component":   "install",
				"kind":        "action",
				"environment": app.Data.Environemnt,
				"uuid":        app.Data.UUID,
			},
		},
		StringData: map[string]string{
			"values.yaml": string(cfgYaml),
		},
	}

	if err := kube.Create(ctx, controller.GetClient(), &appSecret, false); err != nil {
		log.Error(err, "Couldn't create a configmap")
		return consts.ErrSystemError
	}

	return nil
}

// func (env *Environemnt) Update(ctx context.Context) error {
// 	if err := env.isNsVerified(ctx); err != nil {
// 		log.Println("Can't verify ns")
// 		return err
// 	}

// 	env.Controller.GetClient()
// 	conf := &rest.Config{
// 		Host:        "https://kubernetes.default.svc.cluster.local:443",
// 		BearerToken: env.Token,
// 		TLSClientConfig: rest.TLSClientConfig{
// 			Insecure: true,
// 		},
// 	}

// 	controller, err := ctrl.NewManager(conf, ctrl.Options{})

// 	if err != nil {
// 		return err
// 	}
// 	oldEnv := &Environemnt{
// 		Controller: env.Controller,
// 		UserID:     env.UserID,
// 		Token:      env.Token,
// 		Data: &ApplicationData{
// 			UUID: env.Data.UUID,
// 		},
// 	}

// 	if err := oldEnv.Get(ctx); err != nil {
// 		return err
// 	}

// 	// Check whter immutable fields are changed

// 	if oldEnv.Data.Provider != env.Data.Provider {
// 		return errors.New("provider can't be changed")
// 	}
// 	if oldEnv.Data.Location != env.Data.Location {
// 		return errors.New("location can't be changed")
// 	}

// 	vars, err := env.Data.buildVars()
// 	if err != nil {
// 		return err
// 	}
// 	obj := corev1.ConfigMap{
// 		ObjectMeta: metav1.ObjectMeta{
// 			Name:      env.Data.UUID,
// 			Namespace: env.UserID,
// 			Labels: map[string]string{
// 				"component": "bootstrap",
// 				"kind":      "environment",
// 			},
// 		},
// 		Data: map[string]string{
// 			"name":        env.Data.Name,
// 			"description": env.Data.Description,
// 			"vars":        vars,
// 		},
// 	}

// 	if err := kube.Update(ctx, controller.GetClient(), &obj); err != nil {
// 		return err
// 	}

// 	return nil
// }
// func (env *Environemnt) Delete(ctx context.Context) error {
// 	env.Controller.GetClient()
// 	conf := &rest.Config{
// 		Host:        "https://kubernetes.default.svc.cluster.local:443",
// 		BearerToken: env.Token,
// 		TLSClientConfig: rest.TLSClientConfig{
// 			Insecure: true,
// 		},
// 	}

// 	controller, err := ctrl.NewManager(conf, ctrl.Options{})

// 	if err != nil {
// 		return err
// 	}
// 	obj := corev1.ConfigMap{
// 		ObjectMeta: metav1.ObjectMeta{
// 			Name:      env.Data.UUID,
// 			Namespace: env.UserID,
// 			Labels: map[string]string{
// 				"component": "bootstrap",
// 			},
// 		},
// 	}
// 	if err := kube.Delete(ctx, controller.GetClient(), &obj, false); err != nil {
// 		return err
// 	}

// 	return nil
// }

// func (env *Environemnt) ListEnvs(ctx context.Context) ([]*Environemnt, error) {
// 	env.Controller.GetClient()
// 	conf := &rest.Config{
// 		Host:        "https://kubernetes.default.svc.cluster.local:443",
// 		BearerToken: env.Token,
// 		TLSClientConfig: rest.TLSClientConfig{
// 			Insecure: true,
// 		},
// 	}
// 	clientset, err := kubernetes.NewForConfig(conf)
// 	if err != nil {
// 		return nil, err
// 	}
// 	configmaps, err := clientset.CoreV1().ConfigMaps(env.UserID).List(ctx, metav1.ListOptions{LabelSelector: "kind=environment"})
// 	if err != nil {
// 		return nil, err
// 	}

// 	result := []*Environemnt{}
// 	for _, cm := range configmaps.Items {
// 		i := &Environemnt{}
// 		data := &ApplicationData{
// 			UUID: cm.GetName(),
// 		}
// 		i.Token = env.Token
// 		i.UserID = env.UserID
// 		i.Data = data
// 		i.Controller = env.Controller
// 		if err := i.Get(ctx); err != nil {
// 			return nil, err
// 		}
// 		result = append(result, i)
// 	}
// 	return result, nil
// }

// func (env *Environemnt) Get(ctx context.Context) error {
// 	env.Controller.GetClient()
// 	conf := &rest.Config{
// 		Host:        "https://kubernetes.default.svc.cluster.local:443",
// 		BearerToken: env.Token,
// 		TLSClientConfig: rest.TLSClientConfig{
// 			Insecure: true,
// 		},
// 	}
// 	clientset, err := kubernetes.NewForConfig(conf)
// 	if err != nil {
// 		return err
// 	}
// 	envData, err := clientset.CoreV1().ConfigMaps(env.UserID).Get(ctx, env.Data.UUID, metav1.GetOptions{})
// 	if err != nil {
// 		return err
// 	}

// 	res, err := godotenv.Unmarshal(envData.Data["vars"])
// 	if err != nil {
// 		return err
// 	}

// 	if val, ok := envData.Data["name"]; ok {
// 		env.Data.Name = val
// 	} else {
// 		env.Data.Name = ""
// 	}

// 	if val, ok := envData.Data["description"]; ok {
// 		env.Data.Description = val
// 	} else {
// 		env.Data.Description = ""
// 	}

// 	if val, ok := res["SP_PROVIDER"]; ok {
// 		env.Data.Provider = val
// 	} else {
// 		env.Data.Provider = ""
// 	}
// 	if val, ok := res["SP_KUBERNETES"]; ok {
// 		env.Data.Kubernetes = val
// 	} else {
// 		env.Data.Kubernetes = ""
// 	}
// 	if val, ok := res["SP_SERVER_TYPE"]; ok {
// 		env.Data.ServerType = val
// 	} else {
// 		env.Data.ServerType = ""
// 	}
// 	if val, ok := res["SP_SERVER_LOCATION"]; ok {
// 		env.Data.Location = val
// 	} else {
// 		env.Data.Location = ""
// 	}

// 	return nil
// }