modify mask&flag

file.go

@@ -5,13 +5,50 @@ import (
 	"sync"
 )
 
-type File struct {
+type Paper struct {
 	file *os.File
 	sync.Mutex
 }
 
-func (f *File) Write(p []byte) (n int, err error) {
+func NewPaperFromFile(file *os.File) *Paper {
+	return &Paper{
+		file:  file,
+		Mutex: sync.Mutex{},
+	}
+}
+
+func (f *Paper) SetFile(file *os.File) {
 	f.Lock()
 	defer f.Unlock()
-	return f.file.Write(p)
+	if f.file != nil {
+		_ = f.file.Close()
+	}
+	if file != nil {
+		f.file = file
+	}
+}
+
+func (f *Paper) WriteString(s string) {
+	f.Lock()
+	defer f.Unlock()
+	if f.file != nil {
+		_, _ = f.file.WriteString(s)
+	}
+}
+
+func (f *Paper) Ready() bool {
+	f.Lock()
+	defer f.Unlock()
+	return f.file != nil
+}
+
+func (f *Paper) Close() error {
+	f.Lock()
+	defer f.Unlock()
+	var err error = nil
+	if f.file != nil {
+		err = f.file.Close()
+		f.file = nil
+	}
+	return err
 }

glog.go

@@ -2,12 +2,12 @@ package glog
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"path"
 	"path/filepath"
 	"runtime"
-	"sync"
+	"strings"
+	"sync/atomic"
 	"time"
 )
 
@@ -19,8 +19,8 @@ const (
 	MaskWARNING
 	MaskERROR
 	MaskFATAL
-	MaskStdMask = MaskINFO | MaskWARNING | MaskERROR | MaskFATAL
-	MaskStdAll  = MaskUNKNOWN | MaskDEBUG | MaskTRACE | MaskINFO | MaskWARNING | MaskERROR | MaskFATAL
+	MaskStd = MaskINFO | MaskWARNING | MaskERROR | MaskFATAL
+	MaskAll = MaskUNKNOWN | MaskDEBUG | MaskTRACE | MaskINFO | MaskWARNING | MaskERROR | MaskFATAL
 )
 
 const (
@@ -28,8 +28,10 @@ const (
 	FlagTime
 	FlagLongFile
 	FlagShortFile
+	FlagFunc
 	FlagPrefix
-	FlagStdFlag = FlagDate | FlagTime | FlagPrefix
+	FlagStd = FlagDate | FlagTime | FlagPrefix
+	FlagAll = FlagDate | FlagTime | FlagShortFile | FlagFunc | FlagPrefix
 )
 
 var (
@@ -42,33 +44,27 @@ var (
 	prefixFATAL   = "[FATAL  ] "
 )
 
-var mask = MaskStdAll
-var flag = FlagStdFlag
+var mask uint32 = MaskStd
+var flag uint32 = FlagStd
 
-var consoleStdout *File
-var consoleStderr *File
-var file *File
-var lock sync.RWMutex
+var stdout = NewPaperFromFile(os.Stdout)
+var stderr = NewPaperFromFile(os.Stderr)
+var file = NewPaperFromFile(nil)
 
-func init() {
-	consoleStdout = new(File)
-	consoleStdout.file = os.Stdout
-	consoleStderr = new(File)
-	consoleStderr.file = os.Stderr
-	file = nil
-	lock = sync.RWMutex{}
+func SetMask(m uint32) {
+	atomic.StoreUint32(&mask, m)
 }
 
-func SetMask(m int) {
-	lock.Lock()
-	defer lock.Unlock()
-	mask = m
+func GetMask() uint32 {
+	return atomic.LoadUint32(&mask)
 }
 
-func SetFlag(f int) {
-	lock.Lock()
-	defer lock.Unlock()
-	flag = f
+func SetFlag(f uint32) {
+	atomic.StoreUint32(&flag, f)
+}
+
+func GetFlag() uint32 {
+	return atomic.LoadUint32(&flag)
 }
 
 func SetLogFile(path string) error {
@@ -76,137 +72,139 @@ func SetLogFile(path string) error {
 	if err != nil {
 		return err
 	}
-	lock.Lock()
-	defer lock.Unlock()
-	file = new(File)
-	file.file = f
+	file.SetFile(f)
 	return nil
 }
 
 func CloseFile() {
-	lock.Lock()
-	defer lock.Unlock()
-	if file == nil {
-		return
-	}
-	err := file.file.Close()
+	err := file.Close()
 	if err != nil {
-		write(os.Stderr, prefixERROR, "failed to close log file")
+		Error("failed to close log file: %v", err)
 	}
-	file = nil
 }
 
-func write(w io.Writer, prefix string, format string, values ...any) {
+func CloseStdout() {
+	err := stdout.Close()
+	if err != nil {
+		Error("failed to close log stdout: %v", err)
+	}
+}
+
+func CloseStderr() {
+	err := stderr.Close()
+	if err != nil {
+		Error("failed to close log stderr: %v", err)
+	}
+}
+
+func Close() {
+	CloseFile()
+	CloseStdout()
+	CloseStderr()
+}
+
+func write(w *Paper, prefix string, format string, values ...any) {
+	if !w.Ready() {
+		return
+	}
+	log := strings.Builder{}
 	now := ""
-	if (flag&FlagDate) != 0 && (flag&FlagTime) != 0 {
+	flg := GetFlag()
+	
+	if (flg&FlagDate) != 0 && (flg&FlagTime) != 0 {
 		now = time.Now().Format("2006-01-02 15:04:05 ")
-	} else if (flag & FlagDate) != 0 {
+	} else if (flg & FlagDate) != 0 {
 		now = time.Now().Format("2006-01-02 ")
-	} else if (flag & FlagTime) != 0 {
+	} else if (flg & FlagTime) != 0 {
 		now = time.Now().Format("15:04:05 ")
 	}
-	if (flag & FlagPrefix) != 0 {
-		_, _ = w.Write([]byte(now))
-		_, _ = w.Write([]byte(prefix))
+	if (flg & FlagPrefix) != 0 {
+		log.WriteString(now)
+		log.WriteString(prefix)
 	} else {
-		_, _ = w.Write([]byte(prefix))
-		_, _ = w.Write([]byte(now))
+		log.WriteString(prefix)
+		log.WriteString(now)
 	}
-
-	if (flag & FlagLongFile) != 0 {
-		_, p, l, ok := runtime.Caller(2)
+	
+	if (flg & FlagFunc) != 0 {
+		c, _, _, ok := runtime.Caller(2)
 		if ok {
-			_, _ = fmt.Fprintf(w, "%s:%d ", p, l)
+			log.WriteString(runtime.FuncForPC(c).Name())
+			log.WriteString(" ")
 		} else {
-			_, _ = w.Write([]byte("?:? "))
-		}
-	} else if (flag & FlagShortFile) != 0 {
-		_, p, l, ok := runtime.Caller(2)
-		if ok {
-			_, _ = fmt.Fprintf(w, "%s:%d ", path.Base(p), l)
-		} else {
-			_, _ = w.Write([]byte("?:? "))
+			log.WriteString("? ")
 		}
 	}
-	_, _ = w.Write([]byte("| "))
-	_, _ = fmt.Fprintf(w, format, values...)
-	_, _ = w.Write([]byte("\n"))
+	
+	if (flg & FlagLongFile) != 0 {
+		_, p, l, ok := runtime.Caller(2)
+		if ok {
+			log.WriteString(fmt.Sprintf("%s:%d ", p, l))
+		} else {
+			log.WriteString("?:? ")
+		}
+	} else if (flg & FlagShortFile) != 0 {
+		_, p, l, ok := runtime.Caller(2)
+		if ok {
+			log.WriteString(fmt.Sprintf("%s:%d ", path.Base(p), l))
+		} else {
+			log.WriteString("?:? ")
+		}
+	}
+	
+	log.WriteString("| ")
+	log.WriteString(fmt.Sprintf(format, values...))
+	log.WriteString("\n")
+	w.WriteString(log.String())
 }
 
 func Unknown(format string, values ...any) {
-	if (mask & MaskUNKNOWN) != 0 {
-		lock.Lock()
-		defer lock.Unlock()
-		if file != nil {
-			write(file, prefixUNKNOWN, format, values...)
-		}
-		write(consoleStdout, prefixUNKNOWN, format, values...)
+	if (GetMask() & MaskUNKNOWN) != 0 {
+		write(file, prefixUNKNOWN, format, values...)
+		write(stdout, prefixUNKNOWN, format, values...)
 	}
 }
 
 func Debug(format string, values ...any) {
-	if (mask & MaskDEBUG) != 0 {
-		lock.Lock()
-		defer lock.Unlock()
-		if file != nil {
-			write(file, prefixDEBUG, format, values...)
-		}
-		write(consoleStdout, prefixDEBUG, format, values...)
+	if (GetMask() & MaskDEBUG) != 0 {
+		write(file, prefixDEBUG, format, values...)
+		write(stdout, prefixDEBUG, format, values...)
 	}
 }
 
 func Trace(format string, values ...any) {
-	if (mask & MaskTRACE) != 0 {
-		lock.Lock()
-		defer lock.Unlock()
-		if file != nil {
-			write(file, prefixTRACE, format, values...)
-		}
-		write(consoleStdout, prefixTRACE, format, values...)
+	if (GetMask() & MaskTRACE) != 0 {
+		write(file, prefixTRACE, format, values...)
+		write(stdout, prefixTRACE, format, values...)
 	}
 }
 
 func Info(format string, values ...any) {
-	if (mask & MaskINFO) != 0 {
-		lock.Lock()
-		defer lock.Unlock()
-		if file != nil {
-			write(file, prefixINFO, format, values...)
-		}
-		write(consoleStdout, prefixINFO, format, values...)
+	if (GetMask() & MaskINFO) != 0 {
+		write(file, prefixINFO, format, values...)
+		write(stdout, prefixINFO, format, values...)
 	}
 }
 
 func Warning(format string, values ...any) {
-	if (mask & MaskWARNING) != 0 {
-		lock.Lock()
-		defer lock.Unlock()
-		if file != nil {
-			write(file, prefixWARNING, format, values...)
-		}
-		write(consoleStdout, prefixWARNING, format, values...)
+	if (GetMask() & MaskWARNING) != 0 {
+		write(file, prefixWARNING, format, values...)
+		write(stdout, prefixWARNING, format, values...)
 	}
 }
 
 func Error(format string, values ...any) {
-	if (mask & MaskERROR) != 0 {
-		lock.Lock()
-		defer lock.Unlock()
-		if file != nil {
-			write(file, prefixERROR, format, values...)
-		}
-		write(consoleStderr, prefixERROR, format, values...)
+	if (GetMask() & MaskERROR) != 0 {
+		write(file, prefixERROR, format, values...)
+		write(stderr, prefixERROR, format, values...)
 	}
 }
 
 func Fatal(format string, values ...any) {
-	if (mask & MaskFATAL) != 0 {
-		lock.Lock()
-		defer lock.Unlock()
-		if file != nil {
-			write(file, prefixFATAL, format, values...)
-		}
-		write(consoleStderr, prefixFATAL, format, values...)
+	if (GetMask() & MaskFATAL) != 0 {
+		write(file, prefixFATAL, format, values...)
+		write(stderr, prefixFATAL, format, values...)
+		CloseFile()
 		os.Exit(0)
 	}
 }

glog_test.go

@@ -0,0 +1,27 @@
+package glog
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestGlog(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("expected os.Exit(0)")
+		} else {
+			if fmt.Sprint(r) != "unexpected call to os.Exit(0) during test" {
+				t.Errorf("expected os.Exit(0) got %v", r)
+			}
+		}
+	}()
+	SetMask(MaskAll)
+	SetFlag(FlagAll)
+	Unknown("test %s", "Unknown")
+	Debug("test %s", "Debug")
+	Trace("test %s", "Trace")
+	Info("test %s", "Info")
+	Warning("test %s", "Warning")
+	Error("test %s", "Error")
+	Fatal("test %s", "Fatal")
+}