Refactor sign-in page and IAM service lifecycle

Redesign the sign-in page to show email/password form inline
with OIDC provider buttons (with vendor icons) instead of
separate pages. Extract OIDCProvider type to its own file.

Replace errgroup with sync.WaitGroup + WithCancelCause for
graceful shutdown in IAM services. Refactor garbage collectors
to use functional options and time.Ticker instead of
time.After to avoid repeated allocations.

Signed-off-by: Bryan Frimin <bryan@getprobo.com>

pkg/iam/oidc/gc.go

@@ -28,22 +28,40 @@ const (
 	DefaultGarbageCollectionInterval = 1 * time.Hour
 )
 
-type GarbageCollector struct {
-	pg       *pg.Client
-	interval time.Duration
-	logger   *log.Logger
+type (
+	GarbageCollector struct {
+		pg       *pg.Client
+		interval time.Duration
+		logger   *log.Logger
+	}
+
+	GarbageCollectorOption func(*GarbageCollector)
+)
+
+func WithGarbageCollectionInterval(interval time.Duration) GarbageCollectorOption {
+	return func(gc *GarbageCollector) {
+		gc.interval = interval
+	}
 }
 
 func NewGarbageCollector(
-	pg *pg.Client,
-	interval time.Duration,
+	pgClient *pg.Client,
 	logger *log.Logger,
+	opts ...GarbageCollectorOption,
 ) *GarbageCollector {
-	return &GarbageCollector{
-		pg:       pg,
-		interval: interval,
-		logger:   logger.Named("oidc.garbage_collector").With(log.Duration("interval", interval)),
+	gc := &GarbageCollector{
+		pg:       pgClient,
+		interval: DefaultGarbageCollectionInterval,
+		logger:   logger.Named("oidc.garbage_collector"),
 	}
+
+	for _, opt := range opts {
+		opt(gc)
+	}
+
+	gc.logger = gc.logger.With(log.Duration("interval", gc.interval))
+
+	return gc
 }
 
 func (gc *GarbageCollector) Run(ctx context.Context) error {
@@ -53,12 +71,15 @@ func (gc *GarbageCollector) Run(ctx context.Context) error {
 		gc.logger.ErrorCtx(ctx, "cannot run initial cleanup", log.Error(err))
 	}
 
+	ticker := time.NewTicker(gc.interval)
+	defer ticker.Stop()
+
 	for {
 		select {
 		case <-ctx.Done():
 			gc.logger.InfoCtx(ctx, "oidc garbage collector shutting down")
 			return ctx.Err()
-		case <-time.After(gc.interval):
+		case <-ticker.C:
 			if err := gc.cleanup(ctx); err != nil {
 				gc.logger.ErrorCtx(ctx, "cannot run periodic cleanup", log.Error(err))
 			}
@@ -72,7 +93,8 @@ func (gc *GarbageCollector) cleanup(ctx context.Context) error {
 	return gc.pg.WithTx(
 		ctx,
 		func(tx pg.Conn) error {
-			deleted, err := coredata.DeleteExpiredOIDCStates(ctx, tx, now)
+			var state coredata.OIDCState
+			deleted, err := state.DeleteExpired(ctx, tx, now)
 			if err != nil {
 				return fmt.Errorf("cannot delete expired oidc states: %w", err)
 			}

pkg/iam/oidc/service.go

@@ -215,29 +215,25 @@ func NewService(
 }
 
 func (s *Service) Run(ctx context.Context) error {
-	gc := NewGarbageCollector(s.pg, DefaultGarbageCollectionInterval, s.logger)
+	wg := sync.WaitGroup{}
+	ctx, cancel := context.WithCancelCause(ctx)
+	defer cancel(context.Canceled)
 
-	gcCtx, stopGC := context.WithCancel(ctx)
-	defer stopGC()
-
-	errCh := make(chan error, 1)
-	go func() {
-		errCh <- gc.Run(gcCtx)
-	}()
-
-	select {
-	case <-ctx.Done():
-		stopGC()
-		<-errCh
-		return ctx.Err()
-	case err := <-errCh:
-		if err != nil {
-			s.logger.ErrorCtx(ctx, "oidc garbage collector failed", log.Error(err))
-			return err
+	gcCtx, stopGC := context.WithCancel(context.WithoutCancel(ctx))
+	gc := NewGarbageCollector(s.pg, s.logger)
+	wg.Go(func() {
+		if err := gc.Run(gcCtx); err != nil {
+			cancel(fmt.Errorf("oidc garbage collector crashed: %w", err))
 		}
+	})
 
-		return nil
-	}
+	<-ctx.Done()
+
+	stopGC()
+
+	wg.Wait()
+
+	return context.Cause(ctx)
 }
 
 func (s *Service) IsProviderEnabled(provider coredata.OIDCProvider) bool {