luet/pkg/logger/logger.go

package logger

import (
	"fmt"
	"os"
	"path"
	"regexp"
	"runtime"
	"strings"

	"sync"

	. "github.com/mudler/luet/pkg/config"

	"github.com/kyokomi/emoji"
	. "github.com/logrusorgru/aurora"
	"github.com/pterm/pterm"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

var s *pterm.SpinnerPrinter
var z *zap.Logger = nil
var aurora Aurora = nil
var spinnerLock = sync.Mutex{}

func NewSpinner() {
	if s == nil {
		s = pterm.DefaultSpinner.WithShowTimer(false).WithRemoveWhenDone(true)
	}
}

func InitAurora() {
	if aurora == nil {
		aurora = NewAurora(LuetCfg.GetLogging().Color)
	}
}

func GetAurora() Aurora {
	return aurora
}

func NoColor() {
	pterm.DisableColor()
}

func Ask() bool {
	var input string

	Info("Do you want to continue with this operation? [y/N]: ")
	_, err := fmt.Scanln(&input)
	if err != nil {
		return false
	}
	input = strings.ToLower(input)

	if input == "y" || input == "yes" {
		return true
	}
	return false
}

func ZapLogger() error {
	var err error
	if z == nil {
		// TODO: test permission for open logfile.
		cfg := zap.NewProductionConfig()
		cfg.OutputPaths = []string{LuetCfg.GetLogging().Path}
		cfg.Level = level2AtomicLevel(LuetCfg.GetLogging().Level)
		cfg.ErrorOutputPaths = []string{}
		if LuetCfg.GetLogging().JsonFormat {
			cfg.Encoding = "json"
		} else {
			cfg.Encoding = "console"
		}
		cfg.DisableCaller = true
		cfg.DisableStacktrace = true
		cfg.EncoderConfig.TimeKey = "time"
		cfg.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder

		z, err = cfg.Build()
		if err != nil {
			fmt.Fprint(os.Stderr, "Error on initialize file logger: "+err.Error()+"\n")
			return err
		}
	}

	return nil
}

func Spinner(i int) {
	spinnerLock.Lock()
	defer spinnerLock.Unlock()
	var confLevel int
	if LuetCfg.GetGeneral().Debug {
		confLevel = 3
	} else {
		confLevel = level2Number(LuetCfg.GetLogging().Level)
	}
	if 2 > confLevel {
		return
	}
	if i > 43 {
		i = 43
	}

	if s != nil && !s.IsActive {
		//	s.UpdateCharSet(spinner.CharSets[i])
		//s.Start() // Start the spinner
		//		time.Sleep(second)
		// for i := 14; i > 0; i-- {
		// 	if i > 1 {
		// 		introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " seconds...")
		// 	} else {
		// 		introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " second...")
		// 	}
		// 	time.Sleep(second)
		// }
		//	s = introSpinner
		s, _ = s.Start()
		//introSpinner.Stop()
	}
}

func Screen(text string) {
	pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(2).Println(text)
	//pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint(text))
}

func SpinnerText(suffix, prefix string) {
	if s != nil {
		spinnerLock.Lock()
		defer spinnerLock.Unlock()
		if LuetCfg.GetGeneral().Debug {
			fmt.Println(fmt.Sprintf("%s %s",
				Bold(Cyan(prefix)).String(),
				Bold(Magenta(suffix)).BgBlack().String(),
			))
		} else {
			s.UpdateText(suffix + prefix)

		}
	}
}

func SpinnerStop() {
	spinnerLock.Lock()
	defer spinnerLock.Unlock()
	var confLevel int
	if LuetCfg.GetGeneral().Debug {
		confLevel = 3
	} else {
		confLevel = level2Number(LuetCfg.GetLogging().Level)
	}
	if 2 > confLevel {
		return
	}
	if s != nil {
		s.Success()
	}
}

func level2Number(level string) int {
	switch level {
	case "error":
		return 0
	case "warning":
		return 1
	case "info":
		return 2
	case "success":
		return 3
	default:
		return 4
	}
}

func log2File(level, msg string) {
	switch level {
	case "error":
		z.Error(msg)
	case "warning":
		z.Warn(msg)
	case "info", "success":
		z.Info(msg)
	default:
		z.Debug(msg)
	}
}

func level2AtomicLevel(level string) zap.AtomicLevel {
	switch level {
	case "error":
		return zap.NewAtomicLevelAt(zap.ErrorLevel)
	case "warning":
		return zap.NewAtomicLevelAt(zap.WarnLevel)
	case "info", "success":
		return zap.NewAtomicLevelAt(zap.InfoLevel)
	default:
		return zap.NewAtomicLevelAt(zap.DebugLevel)
	}
}

func init() {
	InitAurora()
}

func Msg(level string, withoutColor, ln bool, msg ...interface{}) {
	var message string
	var confLevel, msgLevel int

	if LuetCfg.GetGeneral().Debug {
		confLevel = 3
	} else {
		confLevel = level2Number(LuetCfg.GetLogging().Level)
	}
	msgLevel = level2Number(level)
	if msgLevel > confLevel {
		return
	}

	for _, m := range msg {
		message += " " + fmt.Sprintf("%v", m)
	}

	var levelMsg string

	if withoutColor || !LuetCfg.GetLogging().Color {
		levelMsg = message
	} else {
		switch level {
		case "warning":
			levelMsg = Yellow(":construction: warning" + message).BgBlack().String()
		case "debug":
			levelMsg = White(message).BgBlack().String()
		case "info", "success":
			levelMsg = message
		case "error":
			levelMsg = Red(message).String()
		}
	}

	if LuetCfg.GetLogging().EnableEmoji {
		levelMsg = emoji.Sprint(levelMsg)
	} else {
		re := regexp.MustCompile(`[:][\w]+[:]`)
		levelMsg = re.ReplaceAllString(levelMsg, "")
	}

	if z != nil {
		log2File(level, message)
	}

	if ln {
		switch level {
		case "info":
			pterm.Info.Println(levelMsg)
		case "success":
			pterm.Success.Println(levelMsg)
		case "warning":
			pterm.Warning.Println(levelMsg)
		case "error":
			pterm.Error.Println(levelMsg)
		case "fatal":
			pterm.Fatal.Println(levelMsg)
		default:
			fmt.Println(levelMsg)
		}
		//
	} else {
		switch level {
		case "success":
			pterm.Success.Print(levelMsg)
		case "info":
			pterm.Info.Print(levelMsg)
		case "warning":
			pterm.Warning.Print(levelMsg)
		case "error":
			pterm.Error.Print(levelMsg)
		case "fatal":
			pterm.Fatal.Print(levelMsg)
		default:
			fmt.Print(levelMsg)
		}

	}

}

func Warning(mess ...interface{}) {
	Msg("warning", false, true, mess...)
	if LuetCfg.GetGeneral().FatalWarns {
		os.Exit(2)
	}
}

func Debug(mess ...interface{}) {
	pc, file, line, ok := runtime.Caller(1)
	if ok {
		mess = append([]interface{}{fmt.Sprintf("DEBUG (%s:#%d:%v)",
			path.Base(file), line, runtime.FuncForPC(pc).Name())}, mess...)
	}
	Msg("debug", false, true, mess...)
}

func DebugC(mess ...interface{}) {
	Msg("debug", true, true, mess...)
}

func Info(mess ...interface{}) {
	Msg("info", false, true, mess...)
}

func Success(mess ...interface{}) {
	Msg("success", false, true, mess...)
}

func InfoC(mess ...interface{}) {
	Msg("info", true, true, mess...)
}

func Error(mess ...interface{}) {
	Msg("error", false, true, mess...)
}

func Fatal(mess ...interface{}) {
	Error(mess...)
	os.Exit(1)
}