414 lines
10 KiB
Go
414 lines
10 KiB
Go
package controllers
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/go-logr/logr"
|
|
"github.com/go-logr/zapr"
|
|
"github.com/google/uuid"
|
|
"github.com/joho/godotenv"
|
|
"go.uber.org/zap"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
"git.badhouseplants.net/softplayer/softplayer-backend/internal/consts"
|
|
"git.badhouseplants.net/softplayer/softplayer-backend/internal/helpers/kube"
|
|
corev1 "k8s.io/api/core/v1"
|
|
k8serrors "k8s.io/apimachinery/pkg/api/errors"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/client-go/kubernetes"
|
|
"k8s.io/client-go/rest"
|
|
ctrl "sigs.k8s.io/controller-runtime"
|
|
)
|
|
|
|
type Environemnt struct {
|
|
Controller ctrl.Manager
|
|
Config *rest.Config
|
|
UserID string
|
|
Data *EnvironemntData
|
|
Token string
|
|
}
|
|
|
|
type EnvironemntData struct {
|
|
UUID string
|
|
Name string
|
|
Description string
|
|
Provider string
|
|
Kubernetes string
|
|
Location string
|
|
ServerType string
|
|
DiskSize int
|
|
}
|
|
|
|
func (e *EnvironemntData) buildVars() (string, error) {
|
|
// Please make sure that the same variables are used by ansible
|
|
vars := fmt.Sprintf(`# -- Generated by the softplayer controller
|
|
SP_PROVIDER=%s
|
|
SP_KUBERNETES=%s
|
|
SP_SERVER_TYPE=%s
|
|
SP_SERVER_LOCATION=%s
|
|
SP_DISK_SIZE=%d`,
|
|
e.Provider,
|
|
e.Kubernetes,
|
|
e.ServerType,
|
|
e.Location,
|
|
e.DiskSize,
|
|
)
|
|
|
|
return vars, nil
|
|
}
|
|
|
|
// Check whether used has passed the email verification
|
|
func (env *Environemnt) isNsVerified(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)
|
|
}
|
|
|
|
clientset, err := kubernetes.NewForConfig(env.Config)
|
|
if err != nil {
|
|
log.Error(err, "Couldn't create a new clientset")
|
|
return consts.ErrSystemError
|
|
}
|
|
ns, err := clientset.CoreV1().Namespaces().Get(ctx, env.UserID, metav1.GetOptions{})
|
|
if err != nil {
|
|
log.Error(err, "Couldn't get a user's namespace")
|
|
if k8serrors.IsNotFound(err) {
|
|
err := errors.New("user not found by ID")
|
|
return status.Error(codes.NotFound, err.Error())
|
|
}
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
val, ok := ns.GetLabels()["email-verified"]
|
|
if !ok || val == "false" {
|
|
return errors.New("user email is not verified, can't create an new env")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Create environment should create a new configmap in the user's namespace
|
|
// using a token that belongs to the user.
|
|
func (env *Environemnt) 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)
|
|
}
|
|
|
|
if err := env.isNsVerified(ctx); err != nil {
|
|
return status.Error(codes.Unauthenticated, err.Error())
|
|
}
|
|
|
|
// Prepare a new ID for a enironment
|
|
env.Data.UUID = uuid.New().String()
|
|
|
|
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 {
|
|
log.Error(err, "Couldn't init a controller")
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
vars, err := env.Data.buildVars()
|
|
if err != nil {
|
|
log.Error(err, "Couldn't build the environment's dotenv file", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
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.Create(ctx, controller.GetClient(), &obj, false); err != nil {
|
|
log.Error(err, "Couln't create the environment's configmap", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (env *Environemnt) Update(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)
|
|
}
|
|
|
|
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 {
|
|
log.Error(err, "Couldn't init a controller")
|
|
return consts.ErrSystemError
|
|
}
|
|
oldEnv := &Environemnt{
|
|
Controller: env.Controller,
|
|
UserID: env.UserID,
|
|
Token: env.Token,
|
|
Data: &EnvironemntData{
|
|
UUID: env.Data.UUID,
|
|
},
|
|
}
|
|
|
|
if err := oldEnv.Get(ctx); err != nil {
|
|
log.Error(err, "Couldn't get environment's configmap", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
// 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 {
|
|
log.Error(err, "Couldn't build the environment's dotenv file", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
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 {
|
|
log.Error(err, "Couln't update the environment's configmap", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (env *Environemnt) Delete(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)
|
|
}
|
|
|
|
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 {
|
|
log.Error(err, "couldn't init a controller")
|
|
return consts.ErrSystemError
|
|
}
|
|
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 {
|
|
log.Error(err, "Couln't remove environment's configmap", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (env *Environemnt) List(ctx context.Context, searchString string) ([]*Environemnt, 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)
|
|
}
|
|
|
|
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 {
|
|
log.Error(err, "Couldn't create a new clientset")
|
|
return nil, consts.ErrSystemError
|
|
}
|
|
configmaps, err := clientset.CoreV1().ConfigMaps(env.UserID).List(ctx, metav1.ListOptions{LabelSelector: "kind=environment"})
|
|
if err != nil {
|
|
log.Error(err, "Couldn't list configmaps")
|
|
return nil, consts.ErrSystemError
|
|
}
|
|
|
|
result := []*Environemnt{}
|
|
for _, cm := range configmaps.Items {
|
|
i := &Environemnt{}
|
|
data := &EnvironemntData{
|
|
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 {
|
|
log.Error(err, "Couldn't get an environment", "environment_id", i.Data.UUID)
|
|
return nil, consts.ErrSystemError
|
|
}
|
|
if len(searchString) > 0 {
|
|
if strings.Contains(i.Data.Name, searchString) {
|
|
result = append(result, i)
|
|
}
|
|
if strings.Contains(i.Data.Description, searchString) {
|
|
result = append(result, i)
|
|
}
|
|
} else {
|
|
result = append(result, i)
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (env *Environemnt) Get(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)
|
|
}
|
|
|
|
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 {
|
|
log.Error(err, "Couldn't create a new clientset")
|
|
return consts.ErrSystemError
|
|
}
|
|
envData, err := clientset.CoreV1().ConfigMaps(env.UserID).Get(ctx, env.Data.UUID, metav1.GetOptions{})
|
|
if err != nil {
|
|
log.Error(err, "Couldn't get an environment's configmap", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
res, err := godotenv.Unmarshal(envData.Data["vars"])
|
|
if err != nil {
|
|
log.Error(err, "Couldn't parse environment's dotenv file from a configmap", "environment_id", env.Data.UUID)
|
|
return consts.ErrSystemError
|
|
}
|
|
|
|
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 = ""
|
|
}
|
|
if val, ok := res["SP_DISK_SIZE"]; ok {
|
|
intVal, err := strconv.Atoi(val)
|
|
if err != nil {
|
|
log.Error(err, "Couldn't parse disk size")
|
|
intVal = 0
|
|
}
|
|
env.Data.DiskSize = intVal
|
|
} else {
|
|
env.Data.Location = ""
|
|
}
|
|
|
|
return nil
|
|
}
|