Commit for module "core" at 2023-08-15 00:30.

core/go.mod

@@ -0,0 +1,3 @@
+module git.swzry.com/zry/zry-go-program-framework/core
+
+go 1.20

core/intf.go

@@ -0,0 +1,85 @@
+package core
+
+import "context"
+
+type ILogger interface {
+	Fatal(module string, d ...interface{})
+	FatalF(module string, format string, d ...interface{})
+	FatalC(module string, data map[string]string)
+
+	Panic(module string, d ...interface{})
+	PanicF(module string, format string, d ...interface{})
+	PanicC(module string, data map[string]string)
+
+	Error(module string, d ...interface{})
+	ErrorF(module string, format string, d ...interface{})
+	ErrorC(module string, data map[string]string)
+
+	Warn(module string, d ...interface{})
+	WarnF(module string, format string, d ...interface{})
+	WarnC(module string, data map[string]string)
+
+	Info(module string, d ...interface{})
+	InfoF(module string, format string, d ...interface{})
+	InfoC(module string, data map[string]string)
+
+	Verbose(module string, d ...interface{})
+	VerboseF(module string, format string, d ...interface{})
+	VerboseC(module string, data map[string]string)
+
+	Debug(module string, d ...interface{})
+	DebugF(module string, format string, d ...interface{})
+	DebugC(module string, data map[string]string)
+
+	GetModuleLogger(module string) IModuleLogger
+}
+
+type IModuleLogger interface {
+	Fatal(d ...interface{})
+	FatalF(format string, d ...interface{})
+	FatalC(data map[string]string)
+
+	Panic(d ...interface{})
+	PanicF(format string, d ...interface{})
+	PanicC(data map[string]string)
+
+	Error(d ...interface{})
+	ErrorF(format string, d ...interface{})
+	ErrorC(data map[string]string)
+
+	Warn(d ...interface{})
+	WarnF(format string, d ...interface{})
+	WarnC(data map[string]string)
+
+	Info(d ...interface{})
+	InfoF(format string, d ...interface{})
+	InfoC(data map[string]string)
+
+	Verbose(d ...interface{})
+	VerboseF(format string, d ...interface{})
+	VerboseC(data map[string]string)
+
+	Debug(d ...interface{})
+	DebugF(format string, d ...interface{})
+	DebugC(data map[string]string)
+
+	GetModuleName() string
+	GetSubLog(suffix string) IModuleLogger
+}
+
+type IModuleLogLevelLimiter interface {
+	// LimitLogLevel limit log level for this module logger
+	// level parameter:
+	//   0 - no limit
+	//   1 - under DEBUG (VERBOSE, INFO, WARN, ERROR, PANIC, FATAL) will be emit
+	//   2 - under VERBOSE (INFO, WARN, ERROR, PANIC, FATAL) will be emit
+	//   3 - under INFO (WARN, ERROR, PANIC, FATAL) will be emit
+	//   4 - under WARN (ERROR, PANIC, FATAL) will be emit
+	//   other value will performance as 0
+	LimitLogLevel(level uint8)
+}
+
+type IAppFramework interface {
+	ILogger
+	GetContext() context.Context
+}

core/mod_log.go

@@ -0,0 +1,157 @@
+package core
+
+import "fmt"
+
+var _ IModuleLogger = (*ModuleLogger)(nil)
+var _ IModuleLogLevelLimiter = (*ModuleLogger)(nil)
+
+type ModuleLogger struct {
+	module     string
+	levelLimit uint8
+	baseLogger ILogger
+}
+
+func (ml *ModuleLogger) LimitLogLevel(level uint8) {
+	if level > 4 {
+		ml.levelLimit = 0
+		return
+	}
+	ml.levelLimit = level
+}
+
+func (ml *ModuleLogger) GetModuleName() string {
+	return ml.module
+}
+
+func (ml *ModuleLogger) GetSubLog(suffix string) IModuleLogger {
+	prefix := ml.module
+	name := fmt.Sprintf("%s/%s", prefix, suffix)
+	return ml.baseLogger.GetModuleLogger(name)
+}
+
+func NewModuleLogger(module string, base ILogger) *ModuleLogger {
+	return &ModuleLogger{
+		module:     module,
+		baseLogger: base,
+	}
+}
+
+func (ml *ModuleLogger) Fatal(d ...interface{}) {
+	ml.baseLogger.Fatal(ml.module, d...)
+}
+
+func (ml *ModuleLogger) FatalF(format string, d ...interface{}) {
+	ml.baseLogger.FatalF(ml.module, format, d...)
+}
+
+func (ml *ModuleLogger) FatalC(data map[string]string) {
+	ml.baseLogger.FatalC(ml.module, data)
+}
+
+func (ml *ModuleLogger) Panic(d ...interface{}) {
+	ml.baseLogger.Panic(ml.module, d...)
+}
+
+func (ml *ModuleLogger) PanicF(format string, d ...interface{}) {
+	ml.baseLogger.PanicF(ml.module, format, d...)
+}
+
+func (ml *ModuleLogger) PanicC(data map[string]string) {
+	ml.baseLogger.PanicC(ml.module, data)
+}
+
+func (ml *ModuleLogger) Error(d ...interface{}) {
+	ml.baseLogger.Error(ml.module, d...)
+}
+
+func (ml *ModuleLogger) ErrorF(format string, d ...interface{}) {
+	ml.baseLogger.ErrorF(ml.module, format, d...)
+}
+
+func (ml *ModuleLogger) ErrorC(data map[string]string) {
+	ml.baseLogger.ErrorC(ml.module, data)
+}
+
+func (ml *ModuleLogger) Warn(d ...interface{}) {
+	if ml.levelLimit > 3 {
+		return
+	}
+	ml.baseLogger.Warn(ml.module, d...)
+}
+
+func (ml *ModuleLogger) WarnF(format string, d ...interface{}) {
+	if ml.levelLimit > 3 {
+		return
+	}
+	ml.baseLogger.WarnF(ml.module, format, d...)
+}
+
+func (ml *ModuleLogger) WarnC(data map[string]string) {
+	if ml.levelLimit > 3 {
+		return
+	}
+	ml.baseLogger.WarnC(ml.module, data)
+}
+
+func (ml *ModuleLogger) Info(d ...interface{}) {
+	if ml.levelLimit > 2 {
+		return
+	}
+	ml.baseLogger.Info(ml.module, d...)
+}
+
+func (ml *ModuleLogger) InfoF(format string, d ...interface{}) {
+	if ml.levelLimit > 2 {
+		return
+	}
+	ml.baseLogger.InfoF(ml.module, format, d...)
+}
+
+func (ml *ModuleLogger) InfoC(data map[string]string) {
+	if ml.levelLimit > 2 {
+		return
+	}
+	ml.baseLogger.InfoC(ml.module, data)
+}
+
+func (ml *ModuleLogger) Verbose(d ...interface{}) {
+	if ml.levelLimit > 1 {
+		return
+	}
+	ml.baseLogger.Verbose(ml.module, d...)
+}
+
+func (ml *ModuleLogger) VerboseF(format string, d ...interface{}) {
+	if ml.levelLimit > 1 {
+		return
+	}
+	ml.baseLogger.VerboseF(ml.module, format, d...)
+}
+
+func (ml *ModuleLogger) VerboseC(data map[string]string) {
+	if ml.levelLimit > 1 {
+		return
+	}
+	ml.baseLogger.VerboseC(ml.module, data)
+}
+
+func (ml *ModuleLogger) Debug(d ...interface{}) {
+	if ml.levelLimit > 0 {
+		return
+	}
+	ml.baseLogger.Debug(ml.module, d...)
+}
+
+func (ml *ModuleLogger) DebugF(format string, d ...interface{}) {
+	if ml.levelLimit > 0 {
+		return
+	}
+	ml.baseLogger.DebugF(ml.module, format, d...)
+}
+
+func (ml *ModuleLogger) DebugC(data map[string]string) {
+	if ml.levelLimit > 0 {
+		return
+	}
+	ml.baseLogger.DebugC(ml.module, data)
+}

core/subsvc.go

@@ -0,0 +1,34 @@
+package core
+
+type ISubService interface {
+	Prepare(ctx *SubServiceContext) error
+	Run(ctx *SubServiceContext) error
+	Stop(ctx *SubServiceContext)
+}
+
+type SubServiceWrapper struct {
+	subSvc ISubService
+	name   string
+	ctx    *SubServiceContext
+}
+
+func NewSubServiceWrapper(frame IAppFramework, name string, svc ISubService) *SubServiceWrapper {
+	w := &SubServiceWrapper{
+		subSvc: svc,
+		name:   name,
+		ctx:    NewSubServiceContext(name, frame),
+	}
+	return w
+}
+
+func (w *SubServiceWrapper) Prepare() error {
+	return w.subSvc.Prepare(w.ctx)
+}
+
+func (w *SubServiceWrapper) Run() error {
+	return w.subSvc.Run(w.ctx)
+}
+
+func (w *SubServiceWrapper) Stop(xerr error) {
+	w.subSvc.Stop(w.ctx)
+}

core/subsvc_ctx.go

@@ -0,0 +1,22 @@
+package core
+
+import "context"
+
+var _ IModuleLogger = (*SubServiceContext)(nil)
+
+type SubServiceContext struct {
+	fw IAppFramework
+	IModuleLogger
+}
+
+func NewSubServiceContext(name string, fw IAppFramework) *SubServiceContext {
+	c := &SubServiceContext{
+		fw:            fw,
+		IModuleLogger: fw.GetModuleLogger(name),
+	}
+	return c
+}
+
+func (c *SubServiceContext) GetParentContext() context.Context {
+	return c.fw.GetContext()
+}