feat: proxy bootstrapping from configuration

internal/admin/init.go

@@ -2,12 +2,22 @@ package admin
 
 import (
 	"context"
+	"time"
 
+	"forge.cadoles.com/cadoles/bouncer/internal/config"
+	"forge.cadoles.com/cadoles/bouncer/internal/schema"
 	"forge.cadoles.com/cadoles/bouncer/internal/setup"
+	"forge.cadoles.com/cadoles/bouncer/internal/store"
+	"github.com/bsm/redislock"
 	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
 )
 
 func (s *Server) initRepositories(ctx context.Context) error {
+	if err := s.initRedisClient(ctx); err != nil {
+		return errors.WithStack(err)
+	}
+
 	if err := s.initLayerRepository(ctx); err != nil {
 		return errors.WithStack(err)
 	}
@@ -19,8 +29,16 @@ func (s *Server) initRepositories(ctx context.Context) error {
 	return nil
 }
 
+func (s *Server) initRedisClient(ctx context.Context) error {
+	client := setup.NewRedisClient(ctx, s.redisConfig)
+
+	s.redisClient = client
+
+	return nil
+}
+
 func (s *Server) initLayerRepository(ctx context.Context) error {
-	layerRepository, err := setup.NewLayerRepository(ctx, s.redisConfig)
+	layerRepository, err := setup.NewLayerRepository(ctx, s.redisClient)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -31,7 +49,7 @@ func (s *Server) initLayerRepository(ctx context.Context) error {
 }
 
 func (s *Server) initProxyRepository(ctx context.Context) error {
-	proxyRepository, err := setup.NewProxyRepository(ctx, s.redisConfig)
+	proxyRepository, err := setup.NewProxyRepository(ctx, s.redisClient)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -40,3 +58,112 @@ func (s *Server) initProxyRepository(ctx context.Context) error {
 
 	return nil
 }
+
+const bootstrapLockKey = "bouncer-bootstrap"
+
+func (s *Server) bootstrapProxies(ctx context.Context) error {
+	if err := s.validateBootstrap(ctx); err != nil {
+		return errors.Wrap(err, "could not validate bootstrapped proxies")
+	}
+
+	proxyRepo := s.proxyRepository
+	layerRepo := s.layerRepository
+
+	locker := redislock.New(s.redisClient)
+
+	backoff := redislock.ExponentialBackoff(time.Second, time.Duration(s.bootstrapConfig.LockTimeout)*2)
+
+	logger.Debug(ctx, "acquiring proxies bootstrap lock", logger.F("lockTimeout", s.bootstrapConfig.LockTimeout))
+
+	lock, err := locker.Obtain(ctx, bootstrapLockKey, time.Duration(s.bootstrapConfig.LockTimeout), &redislock.Options{
+		RetryStrategy: backoff,
+	})
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	defer func() {
+		if err := lock.Release(ctx); err != nil {
+			logger.Error(ctx, "could not release lock", logger.E(errors.WithStack(err)))
+		}
+	}()
+
+	logger.Info(ctx, "bootstrapping proxies")
+
+	for proxyName, proxyConfig := range s.bootstrapConfig.Proxies {
+		_, err := s.proxyRepository.GetProxy(ctx, proxyName)
+		if !errors.Is(err, store.ErrNotFound) {
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			logger.Info(ctx, "ignoring existing proxy", logger.F("proxyName", proxyName))
+			continue
+		}
+
+		logger.Info(ctx, "creating proxy", logger.F("proxyName", proxyName))
+
+		if _, err := proxyRepo.CreateProxy(ctx, proxyName, string(proxyConfig.To), proxyConfig.From...); err != nil {
+			return errors.WithStack(err)
+		}
+
+		_, err = proxyRepo.UpdateProxy(
+			ctx, proxyName,
+			store.WithProxyUpdateEnabled(bool(proxyConfig.Enabled)),
+			store.WithProxyUpdateWeight(int(proxyConfig.Weight)),
+		)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
+		for layerName, layerConfig := range proxyConfig.Layers {
+			layerType := store.LayerType(layerConfig.Type)
+			layerOptions := store.LayerOptions(layerConfig.Options)
+
+			if _, err := layerRepo.CreateLayer(ctx, proxyName, layerName, layerType, layerOptions); err != nil {
+				return errors.WithStack(err)
+			}
+
+			_, err := layerRepo.UpdateLayer(
+				ctx,
+				proxyName, layerName,
+				store.WithLayerUpdateEnabled(bool(layerConfig.Enabled)),
+				store.WithLayerUpdateOptions(layerOptions),
+				store.WithLayerUpdateWeight(int(layerConfig.Weight)),
+			)
+			if err != nil {
+				return errors.WithStack(err)
+			}
+		}
+	}
+
+	return nil
+}
+
+const validateErrMessage = "could not validate proxy '%s': could not validate layer '%s'"
+
+func (s *Server) validateBootstrap(ctx context.Context) error {
+	for proxyName, proxyConf := range s.bootstrapConfig.Proxies {
+		for layerName, layerConf := range proxyConf.Layers {
+			layerType := store.LayerType(layerConf.Type)
+			if !setup.LayerTypeExists(layerType) {
+				return errors.Errorf(validateErrMessage+": could not find layer type '%s'", proxyName, layerName, layerType)
+			}
+
+			layerOptionsSchema, err := setup.GetLayerOptionsSchema(layerType)
+			if err != nil {
+				return errors.Wrapf(err, validateErrMessage, proxyName, layerName)
+			}
+
+			rawOptions := func(opts config.InterpolatedMap) map[string]any {
+				return opts
+			}(layerConf.Options)
+
+			if err := schema.Validate(ctx, layerOptionsSchema, rawOptions); err != nil {
+				return errors.Wrapf(err, validateErrMessage, proxyName, layerName)
+			}
+		}
+	}
+
+	return nil
+}