polycule-connect/polyculeconnect/cmd/serve/serve.go

package serve

import (
	"context"
	"os"
	"os/signal"
	"time"

	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/cmd"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/cmd/utils"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/connector"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/logger"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/server"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/services"
	dex_server "github.com/dexidp/dex/server"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/spf13/cobra"
)

var configPath string

const stopTimeout = 10 * time.Second

// serveCmd represents the serve command
var serveCmd = &cobra.Command{
	Use:   "serve",
	Short: "Start the web server",
	Long: `Start the PolyculeConnect web server using the configuration defined through environment
variables`,
	Run: func(cmd *cobra.Command, args []string) {
		serve()
	},
}

func serve() {
	mainCtx, cancel := context.WithCancel(context.Background())

	conf := utils.InitConfig(configPath)
	logger.Init(conf.LogLevel)
	logger.L.Infof("Initialized logger with level %v", conf.LogLevel)

	storageType := utils.InitStorage(conf)
	logger.L.Infof("Initialized storage backend %q", conf.StorageType)
	dexConf := dex_server.Config{
		Web: dex_server.WebConfig{
			Dir:   conf.StaticDir,
			Theme: "default",
		},
		Storage:                storageType,
		Issuer:                 conf.OpenConnectConfig.Issuer,
		SupportedResponseTypes: []string{"code"},
		SkipApprovalScreen:     false,
		AllowedOrigins:         []string{"*"},
		Logger:                 logger.L,
		PrometheusRegistry:     prometheus.NewRegistry(),
	}

	logger.L.Info("Initializing authentication backends")

	dex_server.ConnectorsConfig[connector.TypeRefuseAll] = func() dex_server.ConnectorConfig { return new(connector.RefuseAllConfig) }
	connectors, err := dexConf.Storage.ListConnectors()
	if err != nil {
		logger.L.Fatalf("Failed to get existing connectors: %s", err.Error())
	}
	var connectorIDs []string
	for _, conn := range connectors {
		connectorIDs = append(connectorIDs, conn.ID)
	}

	if err := services.AddDefaultBackend(storageType); err != nil {
		logger.L.Errorf("Failed to add connector for backend RefuseAll to stage: %s", err.Error())
	}

	for _, backend := range conf.OpenConnectConfig.BackendConfigs {
		if err := services.CreateConnector(backend, &dexConf, connectorIDs); err != nil {
			logger.L.Errorf("Failed to add connector for backend %q to stage: %s", backend.Name, err.Error())
			continue
		}
	}

	logger.L.Info("Initializing clients")
	for _, client := range conf.OpenConnectConfig.ClientConfigs {
		if err := dexConf.Storage.CreateClient(*client); err != nil {
			logger.L.Errorf("Failed to add client to storage: %s", err.Error())
		}
	}

	dexSrv, err := dex_server.NewServer(mainCtx, dexConf)
	if err != nil {
		logger.L.Fatalf("Failed to init dex server: %s", err.Error())
	}

	logger.L.Info("Initializing server")
	s, err := server.New(conf, dexSrv, logger.L)
	if err != nil {
		logger.L.Fatalf("Failed to initialize server: %s", err.Error())
	}

	go s.Run(mainCtx)

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)

	logger.L.Info("Application successfully started")

	logger.L.Debug("Waiting for stop signal")
	select {
	case <-s.Done():
		logger.L.Fatal("Unexpected exit from server")
	case <-c:
		logger.L.Info("Stopping main application")
		cancel()
	}

	logger.L.Debugf("Waiting %v for all daemons to stop", stopTimeout)
	select {
	case <-time.After(stopTimeout):
		logger.L.Fatalf("Failed to stop all daemons in the expected time")
	case <-s.Done():
		logger.L.Info("web server successfully stopped")
	}

	logger.L.Info("Application successfully stopped")
	os.Exit(0)

}

func init() {
	cmd.RootCmd.AddCommand(serveCmd)

	// Here you will define your flags and configuration settings.

	// Cobra supports Persistent Flags which will work for this command
	// and all subcommands, e.g.:
	// serveCmd.PersistentFlags().String("foo", "", "A help for foo")

	// Cobra supports local flags which will only run when this command
	// is called directly, e.g.:
	// serveCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
	serveCmd.Flags().StringVarP(&configPath, "config", "c", "config.json", "Path to the JSON configuration file")
}