github.com/leg100/ots@v0.0.7-0.20210919080622-034055ced4bd/cmd/otsd/main.go

package main

import (
	"context"
	"fmt"
	"os"
	"time"

	"github.com/leg100/ots/agent"
	"github.com/leg100/ots/app"
	cmdutil "github.com/leg100/ots/cmd"
	"github.com/leg100/ots/filestore"
	"github.com/leg100/ots/http"
	"github.com/leg100/ots/inmem"
	"github.com/leg100/ots/sqlite"
	"github.com/leg100/zerologr"
	"github.com/mitchellh/go-homedir"
	"github.com/rs/zerolog"
	"github.com/spf13/cobra"
)

const (
	DefaultAddress  = ":8080"
	DefaultHostname = "localhost:8080"
	DefaultDBPath   = "ots.db"
	DefaultDataDir  = "~/.ots-data"
	DefaultLogLevel = "info"
)

var (
	// DBPath is the path to the sqlite database file
	DBPath string
	// DataDir is the path to the directory used for storing OTS-related data
	DataDir string
)

func main() {
	// Configure ^C to terminate program
	ctx, cancel := context.WithCancel(context.Background())
	cmdutil.CatchCtrlC(cancel)

	server := http.NewServer()

	cmd := &cobra.Command{
		Use:           "otsd",
		SilenceUsage:  true,
		SilenceErrors: true,
	}

	cmd.Flags().StringVar(&server.Addr, "address", DefaultAddress, "Listening address")
	cmd.Flags().BoolVar(&server.SSL, "ssl", false, "Toggle SSL")
	cmd.Flags().StringVar(&server.CertFile, "cert-file", "", "Path to SSL certificate (required if enabling SSL)")
	cmd.Flags().StringVar(&server.KeyFile, "key-file", "", "Path to SSL key (required if enabling SSL)")
	cmd.Flags().StringVar(&DBPath, "db-path", DefaultDBPath, "Path to SQLite database file")
	cmd.Flags().StringVar(&server.Hostname, "hostname", DefaultHostname, "Hostname used within absolute URL links")
	cmd.Flags().StringVar(&DataDir, "data-dir", DefaultDataDir, "Path to directory for storing OTS related data")
	logLevel := cmd.Flags().StringP("log-level", "l", DefaultLogLevel, "Logging level")

	cmdutil.SetFlagsFromEnvVariables(cmd.Flags())

	if err := cmd.ParseFlags(os.Args[1:]); err != nil {
		panic(err.Error())
	}

	// DataDir: Expand ~ to home dir
	var err error
	DataDir, err = homedir.Expand(DataDir)
	if err != nil {
		panic(err.Error())
	}

	// Setup logger
	zerologger, err := newLogger(*logLevel)
	if err != nil {
		panic(err.Error())
	}
	logger := zerologr.NewLogger(zerologger)
	server.Logger = logger

	// Validate SSL params
	if server.SSL {
		if server.CertFile == "" || server.KeyFile == "" {
			fmt.Fprintf(os.Stderr, "must provide both --cert-file and --key-file")
			os.Exit(1)
		}
	}

	// Setup filestore
	fs, err := filestore.NewFilestore(DataDir)
	if err != nil {
		panic(err.Error())
	}
	logger.Info("filestore started", "path", fs.Path)

	// Setup sqlite db
	db, err := sqlite.New(DBPath, sqlite.WithZeroLogger(zerologger))
	if err != nil {
		panic(err.Error())
	}

	organizationStore := sqlite.NewOrganizationDB(db)
	workspaceStore := sqlite.NewWorkspaceDB(db)
	stateVersionStore := sqlite.NewStateVersionDB(db)
	runStore := sqlite.NewRunDB(db)
	configurationVersionStore := sqlite.NewConfigurationVersionDB(db)

	eventService := inmem.NewEventService(logger)

	server.OrganizationService = app.NewOrganizationService(organizationStore, eventService)
	server.WorkspaceService = app.NewWorkspaceService(workspaceStore, server.OrganizationService, eventService)
	server.StateVersionService = app.NewStateVersionService(stateVersionStore, server.WorkspaceService, fs)
	server.ConfigurationVersionService = app.NewConfigurationVersionService(configurationVersionStore, server.WorkspaceService, fs)
	server.RunService = app.NewRunService(runStore, server.WorkspaceService, server.ConfigurationVersionService, fs, eventService)
	server.PlanService = app.NewPlanService(runStore, fs)
	server.ApplyService = app.NewApplyService(runStore)

	scheduler, err := inmem.NewScheduler(server.WorkspaceService, server.RunService, eventService, logger)
	if err != nil {
		panic(fmt.Sprintf("unable to start scheduler: %s", err.Error()))
	}

	// Run scheduler in background
	go scheduler.Start(ctx)

	// Run poller in background
	agent, err := agent.NewAgent(
		logger,
		server.ConfigurationVersionService,
		server.StateVersionService,
		server.RunService,
		eventService,
	)
	if err != nil {
		panic(fmt.Sprintf("unable to start agent: %s", err.Error()))
	}
	go agent.Start(ctx)

	if err := server.Open(); err != nil {
		server.Close()
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	logger.Info("server started", "address", server.Addr, "ssl", server.SSL)

	// Block until Ctrl-C received.
	if err := server.Wait(ctx); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func newLogger(lvl string) (*zerolog.Logger, error) {
	zlvl, err := zerolog.ParseLevel(lvl)
	if err != nil {
		return nil, err
	}

	// Setup logger
	consoleWriter := zerolog.ConsoleWriter{
		Out:        os.Stdout,
		TimeFormat: time.RFC3339,
	}
	zerolog.DurationFieldInteger = true

	logger := zerolog.New(consoleWriter).Level(zlvl).With().Timestamp().Logger()

	if logger.GetLevel() < zerolog.InfoLevel {
		// Inform the user that logging lower than INFO threshold has been
		// enabled
		logger.WithLevel(logger.GetLevel()).Msg("custom log level enabled")
	}

	return &logger, nil
}