优化结构
This commit is contained in:
Yvan
@@ -1,151 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"flag"
|
||||
"log/slog"
|
||||
"net"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"kra/app/system/dto"
|
||||
"kra/app/system/service"
|
||||
"kra/app/system/worker"
|
||||
"kra/internal/conf"
|
||||
"kra/internal/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, audit *service.AuditRecorder, loggerControl *logging.ReloadableLogger) *kratos.App {
|
||||
if audit != nil && loggerControl != nil {
|
||||
loggerControl.SetErrorSink(logging.ErrorSinkFunc(func(ctx context.Context, entry logging.ErrorEntry) error {
|
||||
return audit.CreateErrorRequest(ctx, &dto.ErrorRecordRequest{Form: entry.Form, Info: entry.Info, Level: entry.Level, RequestID: entry.RequestID, TraceID: entry.TraceID})
|
||||
}))
|
||||
}
|
||||
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 httpAddress(server *conf.Server) string {
|
||||
if server != nil && server.Http != nil && server.Http.Addr != "" {
|
||||
return server.Http.Addr
|
||||
}
|
||||
return ":8000"
|
||||
}
|
||||
|
||||
func swaggerAddress(server *conf.Server, admin *conf.AdminBackend) string {
|
||||
address := httpAddress(server)
|
||||
if strings.HasPrefix(address, ":") {
|
||||
address = "127.0.0.1" + address
|
||||
} else if host, port, err := net.SplitHostPort(address); err == nil && (host == "" || host == "0.0.0.0" || host == "::") {
|
||||
address = net.JoinHostPort("127.0.0.1", port)
|
||||
}
|
||||
prefix := ""
|
||||
if admin != nil {
|
||||
prefix = strings.Trim(admin.RouterPrefix, "/")
|
||||
}
|
||||
if prefix != "" {
|
||||
prefix = "/" + prefix
|
||||
}
|
||||
return "http://" + address + prefix + "/swagger/index.html"
|
||||
}
|
||||
|
||||
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()
|
||||
slog.SetDefault(logger)
|
||||
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, loggerControl, Version)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer cleanup()
|
||||
logger.Info("Kra administration service initialized", "mod", "system", "version", Version, "http_address", httpAddress(bc.Server), "swagger", swaggerAddress(bc.Server, bc.Admin), "admin_frontend", "http://127.0.0.1:8080")
|
||||
|
||||
// start and wait for stop signal
|
||||
if err := app.Run(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"kra/internal/conf"
|
||||
)
|
||||
|
||||
func TestSwaggerAddress(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
server *conf.Server
|
||||
admin *conf.AdminBackend
|
||||
want string
|
||||
}{
|
||||
{name: "default", want: "http://127.0.0.1:8000/swagger/index.html"},
|
||||
{name: "wildcard with prefix", server: &conf.Server{Http: &conf.Server_HTTP{Addr: "0.0.0.0:9000"}}, admin: &conf.AdminBackend{RouterPrefix: "/admin/"}, want: "http://127.0.0.1:9000/admin/swagger/index.html"},
|
||||
{name: "host", server: &conf.Server{Http: &conf.Server_HTTP{Addr: "example.test:8080"}}, want: "http://example.test:8080/swagger/index.html"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
if got := swaggerAddress(test.server, test.admin); got != test.want {
|
||||
t.Fatalf("swaggerAddress() = %q, want %q", got, test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
//go:build wireinject
|
||||
// +build wireinject
|
||||
|
||||
// The build tag makes sure the stub is not built in the final build.
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
|
||||
"kra/app/admin"
|
||||
"kra/app/system/biz"
|
||||
"kra/app/system/data"
|
||||
"kra/app/system/initialize"
|
||||
"kra/app/system/integration"
|
||||
"kra/app/system/integration/cache"
|
||||
"kra/app/system/service"
|
||||
"kra/app/system/transport/server"
|
||||
"kra/app/system/worker"
|
||||
"kra/internal/conf"
|
||||
"kra/internal/logging"
|
||||
platformtask "kra/pkg/task"
|
||||
|
||||
"github.com/go-kratos/kratos/v3"
|
||||
"github.com/google/wire"
|
||||
)
|
||||
|
||||
// wireApp init kratos application.
|
||||
func wireApp(*conf.Server, *conf.Runtime, *slog.Logger, *logging.ReloadableLogger, string) (*kratos.App, func(), error) {
|
||||
panic(wire.Build(
|
||||
server.ProviderSet,
|
||||
worker.ProviderSet,
|
||||
app.Catalog,
|
||||
app.TaskRegistry,
|
||||
app.Runtime,
|
||||
data.ProviderSet,
|
||||
integration.ProviderSet,
|
||||
initialize.ProviderSet,
|
||||
wire.Bind(new(initialize.Backend), new(*data.Data)),
|
||||
wire.Bind(new(cache.RedisProvider), new(*data.Data)),
|
||||
wire.Bind(new(biz.TaskMethodRegistry), new(*platformtask.Registry)),
|
||||
biz.ProviderSet,
|
||||
service.ProviderSet,
|
||||
newApp,
|
||||
))
|
||||
}
|
||||
Generated
-156
@@ -1,156 +0,0 @@
|
||||
// Code generated by Wire. DO NOT EDIT.
|
||||
|
||||
//go:generate go run -mod=mod github.com/google/wire/cmd/wire
|
||||
//go:build !wireinject
|
||||
// +build !wireinject
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"github.com/go-kratos/kratos/v3"
|
||||
"kra/app/admin"
|
||||
"kra/app/system/biz"
|
||||
"kra/app/system/data"
|
||||
"kra/app/system/data/payment"
|
||||
"kra/app/system/data/repository"
|
||||
"kra/app/system/initialize"
|
||||
"kra/app/system/integration/cache"
|
||||
"kra/app/system/integration/email"
|
||||
"kra/app/system/integration/storage"
|
||||
"kra/app/system/service"
|
||||
"kra/app/system/transport/handler"
|
||||
"kra/app/system/transport/server"
|
||||
"kra/app/system/worker"
|
||||
"kra/internal/conf"
|
||||
"kra/internal/logging"
|
||||
"log/slog"
|
||||
)
|
||||
|
||||
import (
|
||||
_ "go.uber.org/automaxprocs"
|
||||
)
|
||||
|
||||
// Injectors from wire.go:
|
||||
|
||||
// wireApp init kratos application.
|
||||
func wireApp(confServer *conf.Server, runtime *conf.Runtime, logger *slog.Logger, reloadableLogger *logging.ReloadableLogger, string2 string) (*kratos.App, func(), error) {
|
||||
reloadable, err := storage.NewFileStorage(runtime)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
catalog := app.Catalog()
|
||||
dataData, cleanup, err := data.NewData(runtime, logger, reloadable, catalog)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
authorityAccessRepo := system.NewAuthorityAccessRepo(dataData)
|
||||
apiRepo := system.NewAPIRepo(dataData)
|
||||
accessControlUsecase := biz.NewAccessControlUsecase(authorityAccessRepo, apiRepo)
|
||||
accessControlService := service.NewAccessControlService(accessControlUsecase)
|
||||
userRepo := system.NewUserRepo(dataData)
|
||||
userUsecase := biz.NewUserUsecase(userRepo)
|
||||
securityRepo := system.NewSecurityRepo(dataData)
|
||||
bizCache := cache.New(dataData)
|
||||
runtimeSettings := system.NewRuntimeSettings(runtime)
|
||||
apiTokenRepo := system.NewAPITokenRepo(dataData)
|
||||
tokenUsecase := biz.NewTokenUsecase(apiTokenRepo)
|
||||
securityUsecase := biz.NewSecurityUsecase(securityRepo, bizCache, runtimeSettings, tokenUsecase)
|
||||
tokenIssuer := system.NewTokenIssuer(runtimeSettings)
|
||||
auditRecordRepo := system.NewAuditRecorderRepo(dataData)
|
||||
authenticationUsecase := biz.NewAuthenticationUsecase(userUsecase, securityUsecase, tokenIssuer, auditRecordRepo)
|
||||
authService := service.NewAuthService(authenticationUsecase)
|
||||
securityService := service.NewSecurityService(securityUsecase)
|
||||
auditRecorderUsecase := biz.NewAuditRecorderUsecase(auditRecordRepo)
|
||||
auditRecorder := service.NewAuditRecorder(auditRecorderUsecase)
|
||||
authorityUsecase := biz.NewAuthorityUsecase(authorityAccessRepo)
|
||||
authorityService := service.NewAuthorityService(authorityUsecase)
|
||||
authority := handler.NewAuthority(authorityService)
|
||||
menuRepo := system.NewMenuRepo(dataData)
|
||||
menuUsecase := biz.NewMenuUsecase(menuRepo)
|
||||
menuService := service.NewMenuService(menuUsecase)
|
||||
menu := handler.NewMenu(menuService)
|
||||
apiUsecase := biz.NewAPIUsecase(apiRepo)
|
||||
apiService := service.NewAPIService(apiUsecase, runtimeSettings)
|
||||
api := handler.NewAPI(apiService)
|
||||
permissionRepo := system.NewPermissionRepo(dataData)
|
||||
permissionUsecase := biz.NewPermissionUsecase(permissionRepo)
|
||||
permissionService := service.NewPermissionService(permissionUsecase)
|
||||
permission := handler.NewPermission(permissionService)
|
||||
departmentRepo := system.NewDepartmentRepo(dataData)
|
||||
departmentUsecase := biz.NewDepartmentUsecase(departmentRepo)
|
||||
departmentService := service.NewDepartmentService(departmentUsecase)
|
||||
positionRepo := system.NewPositionRepo(dataData)
|
||||
positionUsecase := biz.NewPositionUsecase(positionRepo)
|
||||
positionService := service.NewPositionService(positionUsecase)
|
||||
organization := handler.NewOrganization(departmentService, positionService)
|
||||
announcementRepo := system.NewAnnouncementRepo(dataData)
|
||||
announcementUsecase := biz.NewAnnouncementUsecase(announcementRepo)
|
||||
announcementService := service.NewAnnouncementService(announcementUsecase)
|
||||
announcement := handler.NewAnnouncement(announcementService)
|
||||
emailRepo := email.NewEmailRepo(runtime)
|
||||
emailUsecase := biz.NewEmailUsecase(emailRepo)
|
||||
emailService := service.NewEmailService(emailUsecase)
|
||||
handlerEmail := handler.NewEmail(emailService)
|
||||
paymentRepo := payment.NewPaymentRepo(dataData)
|
||||
paymentOrderRepo := payment.NewPaymentOrderRepo(dataData)
|
||||
paymentUsecase := biz.NewPaymentUsecase(paymentRepo, paymentOrderRepo, logger)
|
||||
paymentService := service.NewPaymentService(paymentUsecase)
|
||||
handlerPayment := handler.NewPayment(paymentService)
|
||||
taskRepo := system.NewTaskRepo(dataData)
|
||||
registry := app.TaskRegistry(catalog)
|
||||
taskUsecase := biz.NewTaskUsecaseWithRegistry(taskRepo, registry)
|
||||
mediaRepo := system.NewMediaRepo(dataData)
|
||||
mediaUsecase := biz.NewMediaUsecase(mediaRepo, reloadable, runtimeSettings)
|
||||
taskExecutor := worker.NewTaskExecutorWithRegistry(taskUsecase, mediaUsecase, runtime, registry)
|
||||
taskScheduler := worker.NewTaskScheduler(taskUsecase, authorityUsecase, taskExecutor, logger)
|
||||
taskRuntime := worker.NewTaskRuntime(taskScheduler)
|
||||
taskApplicationUsecase := biz.NewTaskApplicationUsecase(taskUsecase, taskRuntime)
|
||||
taskService := service.NewTaskService(taskApplicationUsecase)
|
||||
task := handler.NewTask(taskService)
|
||||
mediaService := service.NewMediaService(mediaUsecase, runtimeSettings)
|
||||
media := handler.NewMedia(mediaService)
|
||||
auditQueryRepo := system.NewAuditRepo(dataData)
|
||||
auditUsecase := biz.NewAuditUsecase(auditQueryRepo)
|
||||
auditService := service.NewAuditService(auditUsecase)
|
||||
logFileRepo := system.NewLogFileRepo(dataData)
|
||||
logViewerUsecase := biz.NewLogViewerUsecase(logFileRepo)
|
||||
logViewerService := service.NewLogViewerService(logViewerUsecase)
|
||||
audit := handler.NewAudit(auditService, auditRecorder, logViewerService, logger)
|
||||
exportRepo := system.NewExportRepo(dataData)
|
||||
exportUsecase := biz.NewExportUsecase(exportRepo)
|
||||
exportService := service.NewExportService(exportUsecase, bizCache)
|
||||
export := handler.NewExport(exportService)
|
||||
versionRepo := system.NewVersionRepo(dataData)
|
||||
versionUsecase := biz.NewVersionUsecase(versionRepo)
|
||||
versionService := service.NewVersionService(versionUsecase)
|
||||
version := handler.NewVersion(versionService)
|
||||
dictionaryRepo := system.NewDictionaryRepo(dataData)
|
||||
dictionaryUsecase := biz.NewDictionaryUsecase(dictionaryRepo)
|
||||
dictionaryService := service.NewDictionaryService(dictionaryUsecase)
|
||||
dictionary := handler.NewDictionary(dictionaryService)
|
||||
parameterRepo := system.NewParameterRepo(dataData)
|
||||
parameterUsecase := biz.NewParameterUsecase(parameterRepo)
|
||||
parameterService := service.NewParameterService(parameterUsecase)
|
||||
parameter := handler.NewParameter(parameterService)
|
||||
tokenService := service.NewTokenService(tokenUsecase, tokenIssuer)
|
||||
apiToken := handler.NewAPIToken(tokenService)
|
||||
initializationRepo := initialize.NewRepo(dataData, catalog)
|
||||
systemConfigUsecase := biz.NewSystemConfigUsecase(initializationRepo, taskRuntime)
|
||||
systemConfigService := service.NewSystemConfigService(systemConfigUsecase, runtimeSettings)
|
||||
systemConfig := handler.NewSystemConfig(systemConfigService, securityService)
|
||||
public := handler.NewPublic(authService, systemConfigService, securityService)
|
||||
userService := service.NewUserService(userUsecase, securityService)
|
||||
user := handler.NewUser(userService, authService)
|
||||
navigation := handler.NewNavigation(userService)
|
||||
session := handler.NewSession(tokenService)
|
||||
set := handler.NewSet(authority, menu, api, permission, organization, announcement, handlerEmail, handlerPayment, task, media, audit, export, version, dictionary, parameter, apiToken, systemConfig, public, user, navigation, session)
|
||||
routes := server.NewRoutes(set)
|
||||
taskMethods := worker.NewTaskMethods(taskUsecase, mediaUsecase, runtime)
|
||||
moduleRuntime := app.Runtime(routes, taskMethods, registry)
|
||||
engine := server.NewGinEngineWithRuntime(runtime, accessControlService, authService, securityService, auditRecorder, logger, string2, moduleRuntime)
|
||||
httpServer := server.NewGinServer(confServer, engine)
|
||||
kratosApp := newApp(logger, httpServer, taskScheduler, auditRecorder, reloadableLogger)
|
||||
return kratosApp, func() {
|
||||
cleanup()
|
||||
}, nil
|
||||
}
|
||||
Reference in New Issue
Block a user