.gitignore

@@ -16,7 +16,7 @@
 *.out
 
 # Dependency directories (remove the comment below to include it)
-vendor/
+# vendor/
 
 # Go workspace file
 go.work

README.md

@@ -1,64 +1,2 @@
 # godaemon
 
-A simple daemon library for Go.
-
-Features:
-- provide a daemon process
-- can use command to start/stop/restart the daemon
-
-Usage:
-```go
-import (
-	"time"
-
-	"git.kingecg.top/kingecg/godaemon"
-	"git.kingecg.top/kingecg/gologger"
-)
-
-var daemon *godaemon.GoDaemon
-
-func main() {
-	gologger.Configure(gologger.LoggersConfig{
-		Appenders: map[string]gologger.LogAppenderConfig{
-			"flog": {
-				Type: "console",
-			},
-		},
-		Categories: map[string]gologger.LogConfig{
-			"default": {
-				Appenders: []string{"flog"},
-				Level:     "debug",
-			},
-		},
-	})
-	daemon := godaemon.NewGoDaemon(start, stop)
-	daemon.Start()
-}
-
-func start(g *godaemon.GoDaemon) {
-	l := gologger.GetLogger("task")
-	for {
-		time.Sleep(time.Second * 1)
-		l.Debug("task running:", g.GetPid())
-	}
-}
-
-func stop(g *godaemon.GoDaemon) {
-	l := gologger.GetLogger("task")
-	l.Debug("called stop")
-	if g == nil {
-		l.Debug("Daemon is nil")
-		return
-	}
-	if g.Running == nil {
-		l.Debug("task is nil")
-		return
-	}
-
-}
-```
-
-命令：
-- <app> without arguments: start the daemon
-- <app> -s quit: stop the daemon
-- <app> -s restart: restart the daemon

go.mod

@@ -1,5 +1,5 @@
-module git.kingecg.top/kingecg/godaemon
+module git.pyer.club/kingecg/godaemon
 
 go 1.19
 
-require git.kingecg.top/kingecg/gologger v1.0.10
+require git.pyer.club/kingecg/gologger v1.0.1 // indirect

go.sum

@@ -1,2 +1,2 @@
-git.kingecg.top/kingecg/gologger v1.0.10 h1:o6CNJ3TM9wOnKsV0hNasSSmZXEOMl5mBXZDnKJnC0a0=
-git.kingecg.top/kingecg/gologger v1.0.10/go.mod h1:auMA7VGipqttnF0jmtclhbaIr08gqtVPj6BSMknHTOE=
+git.pyer.club/kingecg/gologger v1.0.1 h1:snCb0ePlfDUglX+CHwNzq5MRK5uNTnPUks1Dnapl/p8=
+git.pyer.club/kingecg/gologger v1.0.1/go.mod h1:SNSl2jRHPzIpHSzdKOoVG798rtYMjPDPFyxUrEgivkY=

godaemon.go

@@ -1,5 +1,3 @@
-// Package godaemon provides a simple daemon library for Go applications.
-// It allows applications to run as daemon processes with start/stop/restart capabilities.
 package godaemon
 
 import (
@@ -13,35 +11,28 @@ import (
 	"strings"
 	"syscall"
 
-	"git.kingecg.top/kingecg/gologger"
+	"git.pyer.club/kingecg/gologger"
 )
 
-// Constants defining environment variable keys and values used for process identification
 const (
-	daemon_env_key  = "_go_daemon" // Environment variable key for process role identification
-	daemon_process  = "g_daemon"   // Value indicating daemon process role
-	daemon_task     = "g_dtask"    // Value indicating task process role
-	daemon_taskargs = "g_args"     // Environment variable key for storing task arguments
+	daemon_env_key  = "_go_daemon"
+	daemon_process  = "g_daemon"
+	daemon_task     = "g_dtask"
+	daemon_taskargs = "g_args"
 )
 
-// GoDaemon represents a daemon process manager
 type GoDaemon struct {
-	pidFile          string         // Path to file storing daemon process PID
-	taskPidFile      string         // Path to file storing task process PID
-	flag             *string        // Command line flag for signal control
-	sigChan          chan os.Signal // Channel for receiving OS signals
-	state            string         // Current state of the daemon ("running", "stopped", etc.)
-	*gologger.Logger                // Embedded logger for logging
-	Running          *exec.Cmd      // Currently running task process
+	pidFile string
+	flag    *string
+	sigChan chan os.Signal
+	state   string
+	gologger.Logger
+	Running *exec.Cmd
 
-	StartFn func(*GoDaemon) // Function called when task starts
-	StopFn  func(*GoDaemon) // Function called when task stops
+	StartFn func(*GoDaemon)
+	StopFn  func(*GoDaemon)
 }
 
-// GetPid retrieves the daemon process ID from the PID file
-//
-// Returns:
-//   - int: process ID if found and valid, 0 otherwise
 func (g *GoDaemon) GetPid() int {
 	pids, ferr := os.ReadFile(g.pidFile)
 	pid, err := strconv.Atoi(string(pids))
@@ -51,25 +42,6 @@ func (g *GoDaemon) GetPid() int {
 	return pid
 }
 
-// GetTaskPid retrieves the task process ID from the task PID file
-//
-// Returns:
-//   - int: process ID if found and valid, 0 otherwise
-func (g *GoDaemon) GetTaskPid() int {
-	pids, ferr := os.ReadFile(g.taskPidFile)
-	pid, err := strconv.Atoi(string(pids))
-	if err != nil || ferr != nil {
-		return 0
-	}
-	return pid
-}
-
-// Start begins the daemon process management based on the current process role
-//
-// Behavior depends on process role:
-//   - Master: starts the daemon process or sends signals to running daemon
-//   - Daemon: manages task process lifecycle
-//   - Task: executes the user-provided StartFn
 func (g *GoDaemon) Start() {
 	if g.flag == nil {
 		g.flag = flag.String("s", "", "send signal to daemon. support: reload and quit")
@@ -103,7 +75,7 @@ func (g *GoDaemon) Start() {
 		pid := os.Getpid()
 
 		os.WriteFile(g.pidFile, []byte(strconv.Itoa(pid)), 0644)
-		g.sigChan = make(chan os.Signal, 1)
+		g.sigChan = make(chan os.Signal)
 
 		signal.Notify(g.sigChan, syscall.SIGTERM, syscall.SIGHUP)
 		go g.serveSignal()
@@ -121,20 +93,11 @@ func (g *GoDaemon) Start() {
 		}
 
 	} else {
-		waiter := make(chan os.Signal, 1)
+
 		g.StartFn(g)
-		g.Info("daemon task is started")
-		<-waiter
-		g.Info("daemon task will be stopped")
-		g.StopFn(g)
 	}
 }
 
-// serveSignal handles incoming OS signals for the daemon process
-//
-// Signals handled:
-//   - SIGTERM: stops the daemon
-//   - SIGHUP: restarts the task process
 func (g *GoDaemon) serveSignal() {
 	sig := <-g.sigChan
 	if sig == syscall.SIGTERM {
@@ -143,13 +106,10 @@ func (g *GoDaemon) serveSignal() {
 		g.state = "restart"
 	}
 
-	g.Running.Process.Signal(syscall.SIGTERM)
+	g.Debug("Stop it")
+	g.StopFn(g)
 }
 
-// getDaemonProcess retrieves the daemon process instance if it's running
-//
-// Returns:
-//   - *os.Process: running daemon process if found, nil otherwise
 func (g *GoDaemon) getDaemonProcess() *os.Process {
 	pid := g.GetPid()
 	if pid == 0 {
@@ -166,9 +126,6 @@ func (g *GoDaemon) getDaemonProcess() *os.Process {
 	return p
 }
 
-// startDaemon starts a new daemon process in the background
-//
-// Checks if daemon is already running before starting a new instance
 func (g *GoDaemon) startDaemon() {
 	dp := g.getDaemonProcess()
 
@@ -185,10 +142,6 @@ func (g *GoDaemon) startDaemon() {
 	cmd.Start()
 }
 
-// startTask starts a new task process with the configured arguments
-//
-// Returns:
-//   - *exec.Cmd: the started command representing the task process
 func (g *GoDaemon) startTask() *exec.Cmd {
 	extraArgs, _ := os.LookupEnv(daemon_taskargs)
 	var cmd *exec.Cmd
@@ -199,48 +152,25 @@ func (g *GoDaemon) startTask() *exec.Cmd {
 	} else {
 		cmd = exec.Command(execName)
 	}
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
 	cmd.Env = append(cmd.Env, daemon_env_key+"="+daemon_task)
 	cmd.Start()
 	return cmd
 }
-
-// IsMaster checks if the current process is the master process
-//
-// Returns:
-//   - bool: true if this is the master process, false otherwise
 func IsMaster() bool {
 	goDaemonEnv, _ := os.LookupEnv(daemon_env_key)
 	return goDaemonEnv == ""
 }
 
-// IsDaemon checks if the current process is the daemon process
-//
-// Returns:
-//   - bool: true if this is the daemon process, false otherwise
 func IsDaemon() bool {
 	goDaemonEnv, _ := os.LookupEnv(daemon_env_key)
 	return goDaemonEnv == daemon_process
 }
 
-// IsDaemonTask checks if the current process is the task process
-//
-// Returns:
-//   - bool: true if this is the task process, false otherwise
 func IsDaemonTask() bool {
 	goDaemonEnv, _ := os.LookupEnv(daemon_env_key)
 	return goDaemonEnv == daemon_task
 }
 
-// NewGoDaemon creates a new GoDaemon instance
-//
-// Parameters:
-//   - start: function to be called when the task process starts
-//   - stop: function to be called when the task process stops
-//
-// Returns:
-//   - *GoDaemon: initialized GoDaemon instance
 func NewGoDaemon(start, stop func(*GoDaemon)) *GoDaemon {
 	godaemon := &GoDaemon{
 		Logger: gologger.GetLogger("daemon"),
@@ -251,7 +181,6 @@ func NewGoDaemon(start, stop func(*GoDaemon)) *GoDaemon {
 		execName = strings.TrimSuffix(execName, filepath.Ext(execName))
 	}
 	godaemon.pidFile = execName + ".pid"
-	godaemon.taskPidFile = execName + ".task.pid"
 	godaemon.StartFn = start
 	godaemon.StopFn = stop
 	return godaemon

test/main.go

@@ -3,8 +3,8 @@ package main
 import (
 	"time"
 
-	"git.kingecg.top/kingecg/godaemon"
-	"git.kingecg.top/kingecg/gologger"
+	"git.pyer.club/kingecg/godaemon"
+	"git.pyer.club/kingecg/gologger"
 )
 
 var daemon *godaemon.GoDaemon
@@ -13,7 +13,10 @@ func main() {
 	gologger.Configure(gologger.LoggersConfig{
 		Appenders: map[string]gologger.LogAppenderConfig{
 			"flog": {
-				Type: "console",
+				Type: "file",
+				Options: map[string]interface{}{
+					"file": "flog.log",
+				},
 			},
 		},
 		Categories: map[string]gologger.LogConfig{
@@ -31,7 +34,7 @@ func start(g *godaemon.GoDaemon) {
 	l := gologger.GetLogger("task")
 	for {
 		time.Sleep(time.Second * 1)
-		l.Debug("task running:", g.GetPid())
+		l.Debug("task running")
 	}
 }
 
@@ -46,5 +49,8 @@ func stop(g *godaemon.GoDaemon) {
 		l.Debug("task is nil")
 		return
 	}
-
+	if g != nil && g.Running != nil {
+		l.Debug("To kill")
+		g.Running.Process.Kill()
+	}
 }

vendor/git.pyer.club/kingecg/gologger/.gitignore

@@ -0,0 +1,17 @@
+# ---> Go
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+

vendor/git.pyer.club/kingecg/gologger/README.md

@@ -0,0 +1,3 @@
+# gologger
+
+a logger used in go

vendor/git.pyer.club/kingecg/gologger/console.go

@@ -0,0 +1,44 @@
+package gologger
+
+import (
+	"fmt"
+)
+
+const (
+	ErrorTemplate = "\033[1;31m%s\033[0m"
+	WarnTemplate  = "\033[1;33m%s\033[0m"
+	InfoTemplate  = "\033[1;32m%s\033[0m"
+	DebugTemplate = "\033[1;34m%s\033[0m"
+	TraceTemplate = "\033[1;35m%s\033[0m"
+)
+
+type ConsoleAppender struct {
+}
+
+func (c *ConsoleAppender) GetName() string {
+	return "console"
+}
+
+func (c *ConsoleAppender) Append(logEvent LogEvent) {
+
+	logMsg := format(logEvent)
+	switch logEvent.Level {
+	case Error:
+		fmt.Printf(ErrorTemplate, logMsg)
+	case Warn:
+		fmt.Printf(WarnTemplate, logMsg)
+	case Info:
+		fmt.Printf(InfoTemplate, logMsg)
+	case Debug:
+		fmt.Printf(DebugTemplate, logMsg)
+	case Trace:
+		fmt.Printf(TraceTemplate, logMsg)
+	}
+}
+func makeConsoleAppender(appenderConfig LogAppenderConfig) LoggerAppender {
+	var appender LoggerAppender = &ConsoleAppender{}
+	return appender
+}
+func init() {
+	RegistAppender("console", makeConsoleAppender)
+}

vendor/git.pyer.club/kingecg/gologger/file.go

@@ -0,0 +1,47 @@
+package gologger
+
+import (
+	"os"
+	"path/filepath"
+)
+
+type FileAppender struct {
+	filePath string
+	file     *os.File
+}
+
+func (f *FileAppender) GetName() string {
+	return "FileAppender:" + f.filePath
+}
+
+func (f *FileAppender) Append(logEvent LogEvent) {
+	if f.file == nil || int(f.file.Fd()) == -1 {
+		dirName := filepath.Dir(f.filePath)
+		_, err := os.Stat(dirName)
+		if err != nil && os.IsNotExist(err) {
+			os.MkdirAll(dirName, 0755)
+		}
+		f.file, _ = os.OpenFile(f.filePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	}
+
+	logMsg := format(logEvent)
+	f.file.WriteString(logMsg)
+
+}
+
+func makeFileAppender(appenderConfig LogAppenderConfig) LoggerAppender {
+	var logfile interface{}
+	var ok bool
+	logfile, ok = appenderConfig.Options["file"]
+	if !ok {
+		logfile = "default.log"
+	}
+	var ret LoggerAppender = &FileAppender{
+		filePath: logfile.(string),
+	}
+	return ret
+}
+
+func init() {
+	RegistAppender("file", makeFileAppender)
+}

vendor/git.pyer.club/kingecg/gologger/format.go

@@ -0,0 +1,23 @@
+package gologger
+
+import (
+	"fmt"
+)
+
+const logTemplate = "[%s] %s : %s - %s\n"
+
+func format(logEvent LogEvent) string {
+	data := logEvent.Ts.Format("2006-01-02 15:04:05")
+	msg := fmt.Sprint(logEvent.Data...)
+	ret := fmt.Sprintf(logTemplate, data, logEvent.Category, getLogLevelStr(logEvent.Level), msg)
+	return ret
+}
+
+func getLogLevelStr(level int) string {
+	for name, slevel := range logLevelMap {
+		if slevel == level {
+			return name
+		}
+	}
+	return "Unknown"
+}

vendor/git.pyer.club/kingecg/gologger/main.go

@@ -0,0 +1,151 @@
+package gologger
+
+import (
+	"strings"
+	"time"
+)
+
+const (
+	NoLog = iota
+	Error
+	Warn
+	Info
+	Debug
+	Trace
+)
+
+var logLevelMap map[string]int = map[string]int{
+	"off":   NoLog,
+	"error": Error,
+	"warn":  Warn,
+	"info":  Info,
+	"debug": Debug,
+	"trace": Trace,
+}
+var loggerMap map[string]Logger = map[string]Logger{}
+var appenderFactoryMap map[string]func(LogAppenderConfig) LoggerAppender = map[string]func(LogAppenderConfig) LoggerAppender{}
+var appenders map[string]LoggerAppender = map[string]LoggerAppender{}
+var loggerConfig LoggersConfig
+
+type LogAppenderConfig struct {
+	Type    string                 `json:"type"`
+	Options map[string]interface{} `json:"options"`
+}
+type LogConfig struct {
+	Level     string   `json:"level"`
+	Appenders []string `json:"appenders"`
+}
+
+type LoggersConfig struct {
+	Appenders  map[string]LogAppenderConfig `json:"appenders"`
+	Categories map[string]LogConfig         `json:"categories"`
+}
+type Logger struct {
+	category  string
+	level     int
+	appenders []LoggerAppender
+}
+
+type LogEvent struct {
+	Category string
+	Ts       time.Time
+	Level    int
+	Data     []interface{}
+}
+
+type LoggerAppender interface {
+	GetName() string
+	Append(logEvent LogEvent)
+}
+
+var consoleAppender LoggerAppender = &ConsoleAppender{}
+var defaultLogger = &Logger{
+
+	level:     Error,
+	appenders: []LoggerAppender{consoleAppender},
+}
+
+func (l *Logger) log(Level int, msg []interface{}) {
+
+	if Level <= l.level {
+		now := time.Now()
+		logEvent := LogEvent{l.category, now, Level, msg}
+		for _, appender := range l.appenders {
+			appender.Append(logEvent)
+		}
+		// l.Appender.Append(logEvent)
+		// fmt.Println(now.Format("2006-01-02 15:04:05"), " ", l.Name, ": ", msg)
+	}
+}
+
+func (l *Logger) Error(msg ...interface{}) {
+	l.log(Error, msg)
+}
+
+func (l *Logger) Warn(msg ...interface{}) {
+	l.log(Warn, msg)
+}
+
+func (l *Logger) Info(msg ...interface{}) {
+	l.log(Info, msg)
+}
+
+func (l *Logger) Debug(msg ...interface{}) {
+	l.log(Debug, msg)
+}
+
+func (l *Logger) Trace(msg ...interface{}) {
+	l.log(Trace, msg)
+}
+func GetLogger(name string) Logger {
+	if logger, ok := loggerMap[name]; ok {
+		return logger
+	} else {
+		logConfig, ok := loggerConfig.Categories[name]
+		if ok {
+			return makeLogger(name, logConfig)
+		}
+		if name == "default" {
+			return *defaultLogger
+		}
+		ret := GetLogger("default")
+		ret.category = name
+		return ret
+	}
+}
+
+func makeLogger(name string, config LogConfig) Logger {
+	logger := &Logger{category: name}
+	levelstr := strings.ToLower(config.Level)
+	logger.level = logLevelMap[levelstr]
+
+	if config.Appenders == nil || len(config.Appenders) == 0 {
+		logger.appenders = []LoggerAppender{consoleAppender}
+	} else {
+		logger.appenders = make([]LoggerAppender, len(config.Appenders))
+		for i, appenderName := range config.Appenders {
+			logger.appenders[i] = appenders[appenderName]
+		}
+	}
+	loggerMap[name] = *logger
+	return *logger
+}
+func Configure(config LoggersConfig) {
+	loggerConfig = config
+	for name, appenderConfig := range loggerConfig.Appenders {
+		appenderFactory, ok := appenderFactoryMap[appenderConfig.Type]
+		if ok {
+			appenders[name] = appenderFactory(appenderConfig)
+		} else {
+			appenders[name] = &ConsoleAppender{}
+		}
+	}
+	for name, _ := range loggerConfig.Categories {
+		GetLogger(name)
+	}
+}
+
+func RegistAppender(typeName string, appenderCreatCb func(LogAppenderConfig) LoggerAppender) {
+
+	appenderFactoryMap[typeName] = appenderCreatCb
+}

vendor/modules.txt

@@ -1,3 +1,3 @@
-# git.kingecg.top/kingecg/gologger v1.0.10
+# git.pyer.club/kingecg/gologger v1.0.1
 ## explicit; go 1.19
-git.kingecg.top/kingecg/gologger
+git.pyer.club/kingecg/gologger