howmuch/internal/howmuch/howmuch.go

// MIT License
//
// Copyright (c) 2024 vinchent <vinchent@vinchent.xyz>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

package howmuch

import (
	"errors"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/infra/datastore"
	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/infra/router"
	"git.vinchent.xyz/vinchent/howmuch/internal/howmuch/registry"
	"git.vinchent.xyz/vinchent/howmuch/internal/pkg/log"
	"git.vinchent.xyz/vinchent/howmuch/internal/pkg/token"
	"git.vinchent.xyz/vinchent/howmuch/pkg/version/verflag"
	"github.com/gin-gonic/gin"
	"github.com/jackc/pgx/v5"
	"github.com/redis/go-redis/v9"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
	"golang.org/x/net/context"
)

var cfgFile string

func errArgsForNoArgCommand(cmd string, args string) error {
	return fmt.Errorf("%q does not take any argument, got %q", cmd, args)
}

// NewHowMuchCommand creates the root command.
func NewHowMuchCommand() *cobra.Command {
	rootCmd := &cobra.Command{
		Use:   "howmuch",
		Short: "howmuch is a expense-sharing application",
		Long: `howmuch is a expense-sharing application that can help friends
to share their expense of an event or a trip`,
		RunE: func(cmd *cobra.Command, args []string) error {
			// print version and exit?
			verflag.PrintVersion()

			// init log
			log.Init(logOptions())
			// Sync flush the buffer
			defer log.Sync()

			return run()
		},
		Args: func(cmd *cobra.Command, args []string) error {
			for _, args := range args {
				if len(args) > 0 {
					return errArgsForNoArgCommand(cmd.CommandPath(), args)
				}
			}
			return nil
		},
		SilenceUsage: true,
	}
	cobra.OnInitialize(initConfig)

	// Here you will define your flags and configuration settings.
	// Cobra supports persistent flags, which, if defined here,
	// will be global for your application.

	rootCmd.PersistentFlags().
		StringVarP(&cfgFile, "config", "c", "", "path to config file. Default config if left empty")

	// Cobra also supports local flags, which will only run
	// when this action is called directly.
	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")

	// --version
	verflag.AddFlags(rootCmd.PersistentFlags())

	return rootCmd
}

func run() error {
	// Set Gin running mode
	isDev := viper.GetBool("dev-mode")
	if isDev {
		gin.SetMode(gin.DebugMode)
	} else {
		gin.SetMode(gin.ReleaseMode)
	}

	// Init DB
	dbConfString := fmt.Sprintf(
		"host=%s port=%d dbname=%s user=%s password=%s sslmode=%s",
		viper.GetString("db.host"),
		viper.GetInt("db.port"),
		viper.GetString("db.database"),
		viper.GetString("db.username"),
		viper.GetString("db.password"),
		viper.GetString("db.sslmode"),
	)
	dbConf, err := pgx.ParseConfig(dbConfString)
	if err != nil {
		log.FatalLog("DB connection config failure", "err", err, "cfg string", dbConfString)
	}
	dbConn, err := datastore.NewDB(dbConf)
	if err != nil {
		log.FatalLog("DB connection failure", "err", err)
	}
	defer dbConn.Close(context.Background())

	// Init Cache
	cache := datastore.NewCache(&redis.Options{
		Addr:     viper.GetString("cache.host"),
		Password: viper.GetString("cache.password"),
		DB:       0,
	})
	defer cache.Close()

	// Init token
	token.Init(viper.GetString("web.token-secret"), viper.GetDuration("web.token-expiry-time"))

	// Register the core service
	r := registry.NewRegistry(dbConn, cache)

	engine := gin.Default()

	engine = router.Routes(engine, r.NewAppController(), cache)

	server := http.Server{
		Addr:    viper.GetString("web.addr"),
		Handler: engine,
	}

	log.InfoLog("Server running", "port", viper.GetString("web.addr"))

	go func() {
		if err := server.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
			log.FatalLog(err.Error())
		}
	}()

	signalChan := make(chan os.Signal, 1)

	signal.Notify(signalChan, syscall.SIGTERM, syscall.SIGINT)
	<-signalChan

	shutdownTimeout := viper.GetDuration("web.shutdown-timeout")
	log.DebugLog("Shutdown", "timeout", shutdownTimeout)

	ctx, cancel := context.WithTimeout(
		context.Background(),
		shutdownTimeout*time.Second,
	)
	defer cancel()

	if err := server.Shutdown(ctx); err != nil {
		log.ErrorLog("Server forced shutdown", "err", err)
		return err
	}

	log.InfoLog("Ciao!")

	return nil
}