penadisk/main.go

package main

import (
	"os"
	"os/signal"
	"syscall"
	"reflect"
	"strings"
	"strconv"
	"errors"

	"github.com/gofiber/fiber/v2"
	mwLogger "github.com/gofiber/fiber/v2/middleware/logger"
	"github.com/gofiber/fiber/v2/middleware/recover"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"gitea.pena/PenaSide/penadisk/api"
	"gitea.pena/PenaSide/penadisk/dal"
	"gitea.pena/PenaSide/penadisk/middleware"
	_ "gitea.pena/PenaSide/linters-golang/pkg/dummy"
)

type Env struct {
	Domain           string `env:"DOMAIN" default:"solweb.site"`
	MinioEndPoint    string `env:"MINIO_ENDPOINT" default:"storage.yandexcloud.net"`
	LogFile          string `env:"LOG_FILE" default:"./tmp/logs.log"`
	MinioAccessKeyID string `env:"MINIO_ACCESS_KEY_ID" default:"YCAJEOcqqTHpiwL4qFwLfHPNA"`
	MinioSecretKey   string `env:"MINIO_SECRET_KEY" default:"YCNIAIat0XqdDzycWsYKX3OU7mPor6S0WmMoG4Ry"`
}

func main() {
	opts := GetOpts()
	//ctx := context.Background()

	// Logger
	cfgLogger := zap.NewDevelopmentConfig()
	cfgLogger.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
	cfgLogger.EncoderConfig.ConsoleSeparator = "    "

	logger, err := cfgLogger.Build()

	logger.Info("OPTIONS", zap.Any("ENV", opts))

	if err != nil {
		panic(err)
	}

	// Minio client
	minioOpts := dal.NewMinioOptions(opts.MinioEndPoint, opts.MinioAccessKeyID, opts.MinioSecretKey, false)

	//err = dal.ShowServerInfo(ctx, logger, minioOpts)
	//
	//if err != nil {
	//	return
	//}

	apiHandlers := api.NewAPI(logger, minioOpts)

	srv := fiber.New(fiber.Config{
		AppName:      "PenaHub.Disk ver. 0.0.1",
		ErrorHandler: fiber.DefaultErrorHandler,
		BodyLimit:    50 << 20, // 50 MB
	})

	// Middlewares
	srv.Use(
		mwLogger.New(),
		recover.New(recover.Config{EnableStackTrace: true}),
		middleware.LocalJwt(),
		//middleware.JwtPlug(),
		middleware.Jwt(),
	)

	// Handlers
	apiGroup := srv.Group("/api")

	apiV1 := apiGroup.Group("/v1")

	// bucket
	apiV1.Get("/bucket", apiHandlers.GetBucket)
	apiV1.Put("/bucket/quota/set", apiHandlers.SetBucketQuota)
	apiV1.Put("/bucket/quota/unset", apiHandlers.UnsetBucketQuota)
	apiV1.Put("/bucket/versioning/enable", apiHandlers.EnableBucketVersioning)
	apiV1.Put("/bucket/versioning/suspend", apiHandlers.SuspendBucketVersioning)

	// resources
	apiV1.Get("/resources", apiHandlers.GetResources)
	apiV1.Put("/resources", apiHandlers.PutResources)
	apiV1.Delete("/resources", apiHandlers.DeleteResources)
	apiV1.Post("/resources/upload", apiHandlers.UploadResources)
	apiV1.Get("/resources/download", apiHandlers.DownloadResources)
	apiV1.Put("/resources/copy", apiHandlers.CopyResources)
	apiV1.Put("/resources/move", apiHandlers.MoveResources)
	apiV1.Put("/resources/publish", apiHandlers.PublishResources)
	apiV1.Put("/resources/unpublish", apiHandlers.UnpublishResources)
	apiV1.Get("/resources/public", apiHandlers.GetPublicResources)

	// Webserver
	go func() {
		err := srv.Listen(":80")
		if err != nil {
			logger.Fatal("CanNotServe", zap.Error(err))
		}
	}()
	/*
		fullCert := fmt.Sprintf("./cert/%v/fullchain.pem", opts.Domain)
		privCert := fmt.Sprintf("./cert/%v/privkey.pem", opts.Domain)

		go func() {
			err := srv.ListenTLS(":443", fullCert, privCert)
			if err != nil {
				logger.Fatal("CanNotServe", zap.Error(err))
			}
		}()
	*/

	// Graceful shutdown
	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)
	killSignal := <-interrupt
	switch killSignal {
	case os.Interrupt:
		logger.Info("AppInterrupted")
	case syscall.SIGTERM:
		logger.Info("AppTerminated")
	}

	err = srv.Shutdown()
	if err != nil {
		logger.Error("WebServerShutdown", zap.Error(err))
	}
}

func getEnv(mask interface{}) Env {
	r := reflect.ValueOf(mask)

	var argTypeRV reflect.Value
	argTypeRV = reflect.New(r.Type())

	for i := 0; i < r.NumField(); i++ {
		v := r.Type().Field(i).Tag.Get("env")
		d := r.Type().Field(i).Tag.Get("default")

		env, ok := os.LookupEnv(v)
		var val string
		if ok {
			val = env
		} else {
			val = d
		}

		switch t := r.Type().Field(i).Type.Name(); t {
		case "string":
			argTypeRV.Elem().Field(i).SetString(val)
		case "bool":
			if strings.ToLower(val) == "true" {
				argTypeRV.Elem().Field(i).SetBool(true)
			} else {
				argTypeRV.Elem().Field(i).SetBool(false)
			}
		case "uint64":
			num, err := strconv.ParseUint(val, 10, 64)
			if err != nil {
				panic(err)
			}
			argTypeRV.Elem().Field(i).SetUint(num)
		default:
			panic(errors.New("Something strange happend: " + t))
		}
	}

	return argTypeRV.Elem().Interface().(Env)
}

func GetOpts() Env {
	return getEnv(Env{})
}