garm-provider-edge-connect/provider/provider.go

// Copyright 2023 Cloudbase Solutions SRL
//
//    Licensed under the Apache License, Version 2.0 (the "License"); you may
//    not use this file except in compliance with the License. You may obtain
//    a copy of the License at
//
//         http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
//    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
//    License for the specific language governing permissions and limitations
//    under the License.

package provider

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"net/http"
	"strings"
	"time"

	edgeconnect "edp.buildth.ing/DevFW-CICD/edge-connect-client/v2/sdk/edgeconnect/v2"
	"edp.buildth.ing/DevFW-CICD/garm-provider-edge-connect/config"
	"edp.buildth.ing/DevFW-CICD/garm-provider-edge-connect/internal/spec"

	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	execution "github.com/cloudbase/garm-provider-common/execution/v0.1.0"
	"github.com/cloudbase/garm-provider-common/params"
	"k8s.io/utils/ptr"
)

var Version = "v0.0.0-unknown"

type GitHubScopeDetails struct {
	BaseURL    string
	Repo       string
	Org        string
	Enterprise string
}

func NewEdgeConnectProvider(configPath, controllerID string) (execution.ExternalProvider, string, error) {
	conf, err := config.NewConfig(configPath)
	if err != nil {
		return nil, "", fmt.Errorf("error loading config: %w", err)
	}

	creds, err := config.NewCredentials(conf.CredentialsFile)
	if err != nil {
		return nil, "", fmt.Errorf("error loading config: %w", err)
	}

	client := edgeconnect.NewClientWithCredentials(
		conf.EdgeConnect.URL,
		creds.Username,
		creds.Password,
		edgeconnect.WithHTTPClient(&http.Client{Timeout: 30 * time.Second}),
	)

	return &edgeConnectProvider{
		client:       client,
		controllerID: controllerID,
		cfg:          conf,
	}, conf.LogFile, nil
}

type edgeConnectProvider struct {
	client       *edgeconnect.Client
	controllerID string
	cfg          *config.Config
}

// CreateInstance creates a new compute instance in the provider.
func (a *edgeConnectProvider) CreateInstance(ctx context.Context, bootstrapParams params.BootstrapInstance) (params.ProviderInstance, error) {
	log.Printf("Executing CreateInstance with RepoURL %v\n", bootstrapParams.RepoURL)
	log.Printf("Executing CreateInstance with ExtraSpecs %s\n", bootstrapParams.ExtraSpecs)

	instancename := fmt.Sprintf("garm-%v-%v", bootstrapParams.PoolID[:8], strings.ToLower(bootstrapParams.Name))

	gitHubScopeDetails, err := spec.ExtractGitHubScopeDetails(bootstrapParams.RepoURL)
	if err != nil {
		return params.ProviderInstance{}, err
	}

	podSpec := spec.GetPodSpec(gitHubScopeDetails, bootstrapParams)

	if podSpec.Containers[0].Image != bootstrapParams.Image {
		log.Printf("Overriding PodSpec image %s with bootstrap image %s\n", podSpec.Containers[0].Image, bootstrapParams.Image)
		podSpec.Containers[0].Image = bootstrapParams.Image
	}

	log.Printf("Executing CreateInstance with PodSpec %v\n", &podSpec)

	deployment := appsv1.Deployment{
		TypeMeta: metav1.TypeMeta{
			Kind:       "Deployment",
			APIVersion: "apps/v1",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:   instancename,
			Labels: map[string]string{"app": instancename},
		},
		Spec: appsv1.DeploymentSpec{
			Replicas: ptr.To(int32(1)),
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{"app": instancename},
			},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{"app": instancename},
					Annotations: map[string]string{
						"container.apparmor.security.beta.kubernetes.io/buildkitd": "unconfined",
					},
				},
				Spec: podSpec,
			},
		},
	}

	manifest, err := json.Marshal(deployment)
	if err != nil {
		return params.ProviderInstance{}, err
	}

	_, err = a.client.ShowApp(ctx, edgeconnect.AppKey{
		Organization: a.cfg.EdgeConnect.Organization,
		Name:         instancename,
		Version:      "1",
	}, a.cfg.EdgeConnect.Region)
	if err != nil && !errors.Is(err, edgeconnect.ErrResourceNotFound) {
		return params.ProviderInstance{}, err
	}
	if errors.Is(err, edgeconnect.ErrResourceNotFound) {
		err = a.client.CreateApp(ctx, &edgeconnect.NewAppInput{
			Region: a.cfg.EdgeConnect.Region,
			App: edgeconnect.App{
				Key: edgeconnect.AppKey{
					Organization: a.cfg.EdgeConnect.Organization,
					Name:         instancename,
					Version:      "1",
				},
				Deployment:       "kubernetes",
				ImageType:        "Docker",
				ImagePath:        bootstrapParams.Image,
				AllowServerless:  true,
				ServerlessConfig: struct{}{},
				DefaultFlavor: edgeconnect.Flavor{
					Name: a.cfg.EdgeConnect.DefaultFlavor,
				},
				DeploymentGenerator: "kubernetes-basic",
				DeploymentManifest:  string(manifest),
				RequiredOutboundConnections: []edgeconnect.SecurityRule{
					{
						PortRangeMax: 65535,
						PortRangeMin: 1,
						Protocol:     "TCP",
						RemoteCIDR:   "0.0.0.0/0",
					},
					{
						PortRangeMax: 65535,
						PortRangeMin: 1,
						Protocol:     "UDP",
						RemoteCIDR:   "0.0.0.0/0",
					},
				},
			},
		})
		if err != nil {
			return params.ProviderInstance{}, err
		}
	}

	_, err = a.client.ShowAppInstance(ctx, edgeconnect.AppInstanceKey{
		Organization: a.cfg.EdgeConnect.Organization,
		Name:         instancename,
		CloudletKey:  edgeconnect.CloudletKey(a.cfg.EdgeConnect.CloudletKey),
	}, a.cfg.EdgeConnect.Region)
	if err != nil && !errors.Is(err, edgeconnect.ErrResourceNotFound) {
		return params.ProviderInstance{}, err
	}
	if errors.Is(err, edgeconnect.ErrResourceNotFound) {
		err = a.client.CreateAppInstance(ctx, &edgeconnect.NewAppInstanceInput{
			Region: a.cfg.EdgeConnect.Region,
			AppInst: edgeconnect.AppInstance{
				Key: edgeconnect.AppInstanceKey{
					Organization: a.cfg.EdgeConnect.Organization,
					Name:         instancename,
					CloudletKey:  edgeconnect.CloudletKey(a.cfg.EdgeConnect.CloudletKey),
				},
				AppKey: edgeconnect.AppKey{
					Organization: a.cfg.EdgeConnect.Organization,
					Name:         instancename,
					Version:      "1",
				},
				Flavor: edgeconnect.Flavor{
					Name: a.cfg.EdgeConnect.DefaultFlavor,
				},
			},
		})
		if err != nil {
			return params.ProviderInstance{}, err
		}
	}

	instance := params.ProviderInstance{
		ProviderID: instancename,
		Name:       instancename,
		OSType:     params.Linux,
		OSArch:     params.Amd64,
		OSName:     "lala",
		OSVersion:  "lalatest",
		Status:     params.InstanceRunning,
	}

	return instance, nil
}

// Delete instance will delete the instance in a provider.
func (a *edgeConnectProvider) DeleteInstance(ctx context.Context, instance string) error {
	log.Printf("Executing DeleteInstance %s\n", instance)

	appsinstances, err := a.client.ShowAppInstances(ctx, edgeconnect.AppInstanceKey{
		Organization: a.cfg.EdgeConnect.Organization,
	}, a.cfg.EdgeConnect.Region)
	if err != nil {
		log.Printf("Error in method DeleteInstance() ShowAppInstances")
		return err
	}

	log.Printf("got %d appinstances", len(appsinstances))

	myappintances := filter(appsinstances, func(app edgeconnect.AppInstance) bool {
		return strings.HasSuffix(app.Key.Name, strings.ToLower(instance))
	})

	log.Printf("filtered %d appinstances", len(myappintances))

	for _, v := range myappintances {
		err = a.client.DeleteAppInstance(ctx, v.Key, a.cfg.EdgeConnect.Region)
		if err != nil {
			return err
		}
	}

	apps, err := a.client.ShowApps(ctx, edgeconnect.AppKey{
		Organization: a.cfg.EdgeConnect.Organization,
	}, a.cfg.EdgeConnect.Region)
	if err != nil {
		log.Printf("Error in method DeleteInstance() ShowApps")
		return err
	}

	myapps := filter(apps, func(app edgeconnect.App) bool {
		return strings.HasSuffix(app.Key.Name, strings.ToLower(instance))
	})

	for _, v := range myapps {
		err = a.client.DeleteApp(ctx, v.Key, a.cfg.EdgeConnect.Region)
		if err != nil {
			log.Printf("Error in method DeleteInstance() DeleteApp")
			return err
		}
	}

	return nil
}

// GetInstance will return details about one instance.
func (a *edgeConnectProvider) GetInstance(ctx context.Context, instance string) (params.ProviderInstance, error) {
	log.Printf("Executing GetInstance %s\n", instance)
	providerInstance := params.ProviderInstance{
		ProviderID: a.controllerID,
		Name:       instance,
		OSType:     params.Linux,
		OSArch:     params.Amd64,
		OSName:     "lala",
		OSVersion:  "lalatest",
		Status:     params.InstanceStatusUnknown,
	}

	appinstances, err := a.client.ShowAppInstances(ctx, edgeconnect.AppInstanceKey{
		Organization: a.cfg.EdgeConnect.Organization,
	}, a.cfg.EdgeConnect.Region)
	if err != nil {
		return params.ProviderInstance{}, err
	}

	myappintances := filter(appinstances, func(app edgeconnect.AppInstance) bool {
		return strings.HasSuffix(app.Key.Name, strings.ToLower(instance))
	})

	if len(myappintances) == 0 {
		return params.ProviderInstance{}, fmt.Errorf("AppInstance not found!")
	}

	appinst := myappintances[0]

	if appinst.State == "Ready" {
		providerInstance.Status = params.InstanceRunning
	}

	return providerInstance, nil
}

// ListInstances will list all instances for a provider.
func (a *edgeConnectProvider) ListInstances(ctx context.Context, poolID string) ([]params.ProviderInstance, error) {
	log.Printf("Executing ListInstances for PoolID %s\n", poolID)

	apps, err := a.client.ShowAppInstances(ctx, edgeconnect.AppInstanceKey{
		Organization: a.cfg.EdgeConnect.Organization,
	}, a.cfg.EdgeConnect.Region)
	if err != nil {
		return nil, err
	}

	myappintances := filter(apps, func(app edgeconnect.AppInstance) bool {
		return strings.HasPrefix(app.Key.Name, fmt.Sprintf("garm-%v-%v", a.controllerID[:8], poolID[:8]))
	})

	providerinstances := []params.ProviderInstance{}

	for _, v := range myappintances {
		providerInstance := params.ProviderInstance{
			ProviderID: a.controllerID,
			Name:       v.Key.Name,
			OSType:     params.Linux,
			OSArch:     params.Amd64,
			OSName:     "lala",
			OSVersion:  "lalatest",
			Status:     params.InstanceStatusUnknown,
		}

		if v.State == "Ready" {
			providerInstance.Status = params.InstanceRunning
		}

		providerinstances = append(providerinstances, providerInstance)
	}

	return providerinstances, nil
}

func filter[T any](s []T, predicate func(T) bool) []T {
	result := make([]T, 0, len(s)) // Pre-allocate for efficiency
	for _, v := range s {
		if predicate(v) {
			result = append(result, v)
		}
	}
	return result
}

// RemoveAllInstances will remove all instances created by this provider.
func (a *edgeConnectProvider) RemoveAllInstances(ctx context.Context) error {
	log.Printf("Executing RemoveAllInstances\n")

	apps, err := a.client.ShowAppInstances(ctx, edgeconnect.AppInstanceKey{
		Organization: a.cfg.EdgeConnect.Organization,
	}, a.cfg.EdgeConnect.Region)
	if err != nil {
		return err
	}

	myappintances := filter(apps, func(app edgeconnect.AppInstance) bool {
		return strings.HasPrefix(app.Key.Name, fmt.Sprintf("garm-%v", a.controllerID[:8]))
	})

	for _, v := range myappintances {
		err = a.DeleteInstance(ctx, v.Key.Name)

		if err != nil {
			return err
		}
	}

	return nil
}

// Stop shuts down the instance.
func (a *edgeConnectProvider) Stop(ctx context.Context, instance string, force bool) error {
	log.Printf("Executing Stop %s\n", instance)
	panic(fmt.Sprintf("Stop() not implemented, called with instance: %s, force: %t", instance, force))
}

// Start boots up an instance.
func (a *edgeConnectProvider) Start(ctx context.Context, instance string) error {
	log.Printf("Executing Start %s\n", instance)
	panic(fmt.Sprintf("Start() not implemented, called with instance: %s", instance))
}

// GetVersion returns the version of the provider.
func (a *edgeConnectProvider) GetVersion(ctx context.Context) string {
	return Version
}