116 lines
3.1 KiB
Go
116 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"kra/internal/conf"
|
|
"kra/internal/worker"
|
|
"kra/pkg/logging"
|
|
|
|
"github.com/go-kratos/kratos/v3"
|
|
"github.com/go-kratos/kratos/v3/config"
|
|
"github.com/go-kratos/kratos/v3/config/file"
|
|
"github.com/go-kratos/kratos/v3/log"
|
|
kratoshttp "github.com/go-kratos/kratos/v3/transport/http"
|
|
|
|
_ "go.uber.org/automaxprocs"
|
|
)
|
|
|
|
// go build -ldflags "-X main.Version=x.y.z"
|
|
var (
|
|
// Name is the name of the compiled software.
|
|
Name string
|
|
// Version is the version of the compiled software.
|
|
Version string
|
|
// flagconf is the config flag.
|
|
flagconf string
|
|
|
|
id, _ = os.Hostname()
|
|
)
|
|
|
|
func init() {
|
|
flag.StringVar(&flagconf, "conf", "../../configs", "config path, eg: -conf config.yaml")
|
|
}
|
|
|
|
func newApp(logger *slog.Logger, hs *kratoshttp.Server, scheduler *worker.TaskScheduler) *kratos.App {
|
|
return kratos.New(
|
|
kratos.ID(id),
|
|
kratos.Name(Name),
|
|
kratos.Version(Version),
|
|
kratos.Metadata(map[string]string{}),
|
|
kratos.Logger(logger),
|
|
kratos.Server(
|
|
hs,
|
|
scheduler,
|
|
),
|
|
)
|
|
}
|
|
|
|
func zapSettings(admin *conf.AdminBackend) (string, logging.Options) {
|
|
options := logging.Options{Level: "info", Format: "json", EncodeLevel: "LowercaseLevelEncoder", LogInConsole: true, ShowLine: true, RetentionDay: 7}
|
|
root := "logs"
|
|
if admin == nil || admin.Zap == nil {
|
|
return root, options
|
|
}
|
|
zapConfig := admin.Zap
|
|
options = logging.Options{Level: zapConfig.Level, Format: zapConfig.Format, EncodeLevel: zapConfig.EncodeLevel, Prefix: zapConfig.Prefix, StacktraceKey: zapConfig.StacktraceKey, LogInConsole: zapConfig.LogInConsole, ShowLine: zapConfig.ShowLine, RetentionDay: int(zapConfig.RetentionDay), FileOnlyModules: zapConfig.FileOnlyModules}
|
|
if zapConfig.Director != "" {
|
|
root = zapConfig.Director
|
|
}
|
|
return root, options
|
|
}
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
c := config.New(
|
|
config.WithSource(
|
|
file.NewSource(flagconf),
|
|
),
|
|
)
|
|
defer c.Close()
|
|
|
|
if err := c.Load(); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
var bc conf.Bootstrap
|
|
if err := c.Scan(&bc); err != nil {
|
|
panic(err)
|
|
}
|
|
logRoot, logOptions := zapSettings(bc.Admin)
|
|
loggerAttrs := []any{slog.String("service.id", id), slog.String("service.name", Name), slog.String("service.version", Version)}
|
|
if bc.Admin != nil && bc.Admin.App != nil {
|
|
loggerAttrs = append(loggerAttrs, slog.String("node", bc.Admin.App.Node), slog.String("app_id", bc.Admin.App.AppId), slog.String("env", bc.Admin.App.Env))
|
|
}
|
|
logger, loggerControl := logging.NewReloadableZapLogger(logRoot, "application.log", logOptions, loggerAttrs...)
|
|
defer loggerControl.Close()
|
|
log.SetDefault(logger)
|
|
if bc.Admin != nil {
|
|
bc.Admin.ConfigPath = flagconf
|
|
if info, err := os.Stat(flagconf); err == nil && info.IsDir() {
|
|
bc.Admin.ConfigPath = filepath.Join(flagconf, "config.yaml")
|
|
}
|
|
}
|
|
|
|
runtime := conf.NewRuntime(bc.Data, bc.Admin)
|
|
unsubscribeLogger := runtime.Subscribe(func(_ *conf.Data, admin *conf.AdminBackend) {
|
|
root, options := zapSettings(admin)
|
|
loggerControl.Reload(root, options)
|
|
})
|
|
defer unsubscribeLogger()
|
|
|
|
app, cleanup, err := wireApp(bc.Server, runtime, logger)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer cleanup()
|
|
|
|
// start and wait for stop signal
|
|
if err := app.Run(); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|