cocos/cmd/manager/main.go

// Copyright (c) Ultraviolet
// SPDX-License-Identifier: Apache-2.0

package main

import (
	"context"
	"fmt"
	"log"
	"log/slog"
	"net/url"
	"os"
	"strings"

	mglog "github.com/absmach/supermq/logger"
	"github.com/absmach/supermq/pkg/jaeger"
	"github.com/absmach/supermq/pkg/prometheus"
	smqserver "github.com/absmach/supermq/pkg/server"
	grpcserver "github.com/absmach/supermq/pkg/server/grpc"
	httpserver "github.com/absmach/supermq/pkg/server/http"
	"github.com/absmach/supermq/pkg/uuid"
	"github.com/caarlos0/env/v11"
	"github.com/go-chi/chi/v5"
	"github.com/ultravioletrs/cocos/manager"
	"github.com/ultravioletrs/cocos/manager/api"
	managergrpc "github.com/ultravioletrs/cocos/manager/api/grpc"
	"github.com/ultravioletrs/cocos/manager/api/http"
	"github.com/ultravioletrs/cocos/manager/qemu"
	"github.com/ultravioletrs/cocos/manager/tracing"
	"go.opentelemetry.io/otel/trace"
	"golang.org/x/sync/errgroup"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

const (
	svcName        = "manager"
	envPrefixGRPC  = "MANAGER_GRPC_"
	envPrefixHTTP  = "MANAGER_HTTP_"
	envPrefixQemu  = "MANAGER_QEMU_"
	defSvcHTTPPort = "7003"
)

type config struct {
	LogLevel                    string  `env:"MANAGER_LOG_LEVEL"                  envDefault:"info"`
	JaegerURL                   url.URL `env:"COCOS_JAEGER_URL"                   envDefault:"http://localhost:4318"`
	TraceRatio                  float64 `env:"COCOS_JAEGER_TRACE_RATIO"           envDefault:"1.0"`
	InstanceID                  string  `env:"MANAGER_INSTANCE_ID"                envDefault:""`
	AttestationPolicyBinaryPath string  `env:"MANAGER_ATTESTATION_POLICY_BINARY_PATH" envDefault:"../../build"`
	PcrValues                   string  `env:"MANAGER_PCR_VALUES"                 envDefault:""`
	EosVersion                  string  `env:"MANAGER_EOS_VERSION"                envDefault:""`
	MaxVMs                      int     `env:"MANAGER_MAX_VMS"                    envDefault:"10"`
	SigningKeyPath              string  `env:"MANAGER_CORIM_SIGNING_KEY"          envDefault:""`
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	g, ctx := errgroup.WithContext(ctx)

	var cfg config
	if err := env.Parse(&cfg); err != nil {
		log.Fatalf("failed to load %s configuration : %s", svcName, err)
	}

	logger, err := mglog.New(os.Stdout, cfg.LogLevel)
	if err != nil {
		log.Fatal(err.Error())
	}

	var exitCode int
	defer mglog.ExitWithError(&exitCode)

	if cfg.InstanceID == "" {
		if cfg.InstanceID, err = uuid.New().ID(); err != nil {
			logger.Error(fmt.Sprintf("Failed to generate instance ID: %s", err))
			exitCode = 1
			return
		}
	}

	tp, err := jaeger.NewProvider(ctx, svcName, cfg.JaegerURL, cfg.InstanceID, cfg.TraceRatio)
	if err != nil {
		logger.Error(fmt.Sprintf("Failed to init Jaeger: %s", err))
	}
	defer func() {
		if err := tp.Shutdown(ctx); err != nil {
			logger.Error(fmt.Sprintf("Error shutting down tracer provider: %v", err))
		}
	}()
	tracer := tp.Tracer(svcName)

	qemuCfg, err := qemu.NewConfig()
	if err != nil {
		logger.Error(fmt.Sprintf("failed to create config: %v", err))
		exitCode = 1
		return
	}

	if qemuCfg.EnableTDX {
		logger.Info("Manager started with TDX enabled")
	} else if qemuCfg.EnableSEVSNP {
		logger.Info("Manager started with SEV-SNP enabled")
	} else {
		logger.Info("Manager started without confidential computing support")
	}

	if err := env.ParseWithOptions(qemuCfg, env.Options{Prefix: envPrefixQemu}); err != nil {
		logger.Error(fmt.Sprintf("failed to load QEMU configuration: %s", err))
		exitCode = 1
		return
	}
	args := qemuCfg.ConstructQemuArgs()
	logger.Info(strings.Join(args, " "))

	managerGRPCConfig := smqserver.Config{}
	if err := env.ParseWithOptions(&managerGRPCConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
		exitCode = 1
		return
	}

	httpServerConfig := smqserver.Config{Port: defSvcHTTPPort}
	if err := env.ParseWithOptions(&httpServerConfig, env.Options{Prefix: envPrefixHTTP}); err != nil {
		logger.Error(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err))
	}

	svc, err := newService(logger, tracer, *qemuCfg, cfg.AttestationPolicyBinaryPath, cfg.PcrValues, cfg.SigningKeyPath, cfg.EosVersion, cfg.MaxVMs)
	if err != nil {
		logger.Error(err.Error())
		exitCode = 1
		return
	}

	defer func() {
		if err := svc.Shutdown(); err != nil {
			logger.Error(err.Error())
			exitCode = 1
			return
		}
	}()

	registerManagerServiceServer := func(srv *grpc.Server) {
		reflection.Register(srv)
		manager.RegisterManagerServiceServer(srv, managergrpc.NewServer(svc))
	}

	gs := grpcserver.NewServer(ctx, cancel, svcName, managerGRPCConfig, registerManagerServiceServer, logger)

	hs := httpserver.NewServer(ctx, cancel, svcName, httpServerConfig, http.MakeHandler(chi.NewMux(), svcName, cfg.InstanceID), logger)

	g.Go(func() error {
		return gs.Start()
	})

	g.Go(func() error {
		return hs.Start()
	})

	g.Go(func() error {
		return smqserver.StopSignalHandler(ctx, cancel, logger, svcName, gs, hs)
	})

	if err := g.Wait(); err != nil {
		logger.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
	}
}

func newService(logger *slog.Logger, tracer trace.Tracer, qemuCfg qemu.Config, attestationPolicyBinaryPath string, pcrValuesFilePath string, signingKeyPath string, eosVersion string, maxVMs int) (manager.Service, error) {
	svc, err := manager.New(qemuCfg, attestationPolicyBinaryPath, pcrValuesFilePath, signingKeyPath, logger, qemu.NewVM, eosVersion, maxVMs)
	if err != nil {
		return nil, err
	}
	svc = api.LoggingMiddleware(svc, logger)
	counter, latency := prometheus.MakeMetrics(svcName, "api")
	svc = api.MetricsMiddleware(svc, counter, latency)
	svc = tracing.New(svc, tracer)

	return svc, nil
}