poseidon/internal/environment/kubernetes_environment.go

package environment

import (
	"context"
	"fmt"
	poseidonK8s "github.com/openHPI/poseidon/internal/kubernetes"
	"github.com/openHPI/poseidon/internal/runner"
	"github.com/openHPI/poseidon/pkg/dto"
	"github.com/openHPI/poseidon/pkg/monitoring"
	"github.com/openHPI/poseidon/pkg/storage"
	appsv1 "k8s.io/api/apps/v1"
	"time"
)

type KubernetesEnvironment struct {
	apiClient   *poseidonK8s.ExecutorAPI
	jobHCL      string
	deployment  *appsv1.Deployment
	idleRunners storage.Storage[runner.Runner]
	ctx         context.Context
	cancel      context.CancelFunc
}

func (k KubernetesEnvironment) MarshalJSON() ([]byte, error) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) ID() dto.EnvironmentID {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) SetID(id dto.EnvironmentID) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) PrewarmingPoolSize() uint {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) SetPrewarmingPoolSize(count uint) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) ApplyPrewarmingPoolSize() error {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) CPULimit() uint {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) SetCPULimit(limit uint) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) MemoryLimit() uint {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) SetMemoryLimit(limit uint) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) Image() string {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) SetImage(image string) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) NetworkAccess() (bool, []uint16) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) SetNetworkAccess(allow bool, ports []uint16) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) SetConfigFrom(environment runner.ExecutionEnvironment) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) Register() error {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) Delete(reason runner.DestroyReason) error {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) Sample() (r runner.Runner, ok bool) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) AddRunner(r runner.Runner) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) DeleteRunner(id string) (r runner.Runner, ok bool) {
	//TODO implement me
	panic("implement me")
}

func (k KubernetesEnvironment) IdleRunnerCount() uint {
	//TODO implement me
	panic("implement me")
}

func NewKubernetesEnvironmentFromRequest(
	apiClient poseidonK8s.ExecutorAPI, jobHCL string, id dto.EnvironmentID, request dto.ExecutionEnvironmentRequest) (
	*KubernetesEnvironment, error) {
	environment, err := NewKubernetesEnvironment(id, apiClient, jobHCL)
	if err != nil {
		return nil, err
	}
	environment.SetID(id)

	// Set options according to request
	environment.SetPrewarmingPoolSize(request.PrewarmingPoolSize)
	environment.SetCPULimit(request.CPULimit)
	environment.SetMemoryLimit(request.MemoryLimit)
	environment.SetImage(request.Image)
	environment.SetNetworkAccess(request.NetworkAccess, request.ExposedPorts)
	return environment, nil
}

func NewKubernetesEnvironment(id dto.EnvironmentID, apiClient poseidonK8s.ExecutorAPI, jobHCL string) (*KubernetesEnvironment, error) {
	job, err := parseDeployment(jobHCL)
	if err != nil {
		return nil, fmt.Errorf("error parsing Nomad job: %w", err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	e := &KubernetesEnvironment{&apiClient, jobHCL, job, nil, ctx, cancel}
	e.idleRunners = storage.NewMonitoredLocalStorage[runner.Runner](monitoring.MeasurementIdleRunnerNomad,
		runner.MonitorEnvironmentID[runner.Runner](id), time.Minute, ctx)
	return e, nil
}

// TODO MISSING IMPLEMENTATION
func parseDeployment(jobHCL string) (*appsv1.Deployment, error) {

	deployment := appsv1.Deployment{}

	// jobConfig := jobspec2.ParseConfig{
	// 	Body:    []byte(jobHCL),
	// 	AllowFS: false,
	// 	Strict:  true,
	// }
	// job, err := jobspec2.ParseWithConfig(&jobConfig)
	// if err != nil {
	// 	return job, fmt.Errorf("couldn't parse job HCL: %w", err)
	// }
	return &deployment, nil
}