app.go

package app

import (
	"context"
	"os"

	"go.uber.org/atomic"
	"go.uber.org/zap"
)

var instance = &Application{}

type Application struct {
	started            atomic.Bool
	config             Config
	terminationSignals []os.Signal
}

func (app *Application) WithConfig(config Config) *Application {
	app.checkStarted(false)

	app.config = config

	return app
}

func (app *Application) WithTerminationSignals(signals ...os.Signal) *Application {
	app.checkStarted(false)

	app.terminationSignals = signals

	return app
}

func (app *Application) Run(appCallback func(appCtx context.Context, logger *zap.SugaredLogger)) {
	app.checkStarted(true)

	logger := LoadConfig(app.config)

	defer logger.Sync()

	appCtx := NewCliContext(app.terminationSignals...)

	appCtx.StartWorker(func() {
		logger.Info("running the application")
		appCallback(appCtx.ctx, logger)
	})

	signalLogged := make(chan struct{})

	go func() {
		<-appCtx.Done()

		logger.Info("received termination signal, application should terminate soon")

		close(signalLogged)
	}()

	appCtx.WaitForWorkers()

	if appCtx.Err() != nil {
		<-signalLogged
	}

	logger.Info("application finished, exiting now")
}

func (app *Application) Start(appCallback func(appCtx Context, logger *zap.SugaredLogger)) {
	app.checkStarted(true)

	logger := LoadConfig(app.config)

	defer logger.Sync()

	appCtx := NewCliContext(app.terminationSignals...)

	appCtx.StartWorker(func() {
		appCallback(appCtx, logger)
		logger.Info("application started")
	})

	shutdownLogged := make(chan struct{})

	appCtx.StartWorker(func() {
		<-appCtx.Done()

		logger.Info("application is shutting down")

		close(shutdownLogged)
	})

	appCtx.WaitForWorkers()

	if appCtx.Err() != nil {
		<-shutdownLogged
	}

	logger.Info("workers finished, exiting now")
}

func (app *Application) checkStarted(doStart bool) {
	if doStart {
		if app.started.CAS(false, true) {
			return
		}
	} else if !app.started.Load() {
		return
	}

	panic("Application has already been started")
}

func WithConfig(config Config) *Application {
	return instance.WithConfig(config)
}

func WithTerminationSignals(signals ...os.Signal) *Application {
	return instance.WithTerminationSignals(signals...)
}

func Run(appCallback func(appCtx context.Context, logger *zap.SugaredLogger)) {
	instance.Run(appCallback)
}

func Start(appCallback func(appCtx Context, logger *zap.SugaredLogger)) {
	instance.Start(appCallback)
}