From ecba5e76ff40b149286c4565c94ed0604bbe3f12 Mon Sep 17 00:00:00 2001 From: 兔子 Date: Thu, 22 Oct 2020 16:42:21 +0800 Subject: [PATCH] newgen --- starlog.go | 175 +++++++++++++++++++++++++++++++++++++++++++++--- starlog_test.go | 1 - 2 files changed, 164 insertions(+), 12 deletions(-) diff --git a/starlog.go b/starlog.go index 71f1974..5b10393 100644 --- a/starlog.go +++ b/starlog.go @@ -13,6 +13,8 @@ import ( "sync" "time" + "b612.me/starmap" + "github.com/mattn/go-colorable" ) @@ -48,6 +50,8 @@ var ( LvPanic: []Attr{FgRed, Bold}, LvFatal: []Attr{FgRed}, } + stdLock sync.Mutex + logmaps sync.Map ) type StarLogger struct { @@ -63,14 +67,21 @@ type StarLogger struct { DoShow bool switching bool isStd bool - //HandleFunc - waiting chan int + //handleFunc + stopChan chan int + setChan chan int outshow io.Writer LogLevel int - HandleFunc func([]Attr, string) + handleFunc func([]Attr, string) StdFuncColor bool logbuf string BufSize int + stacks starmap.StarStack +} + +type logTran struct { + color []Attr + log string } var Std = New(nil) @@ -80,7 +91,9 @@ func init() { Std.DoShow = true Std.Flag = "MAN" Std.isStd = true + logmaps.Store("std", Std) } + func Close() error { if StdFile == nil { return errors.New("File not Open") @@ -107,9 +120,23 @@ func New(out io.Writer) *StarLogger { logger.StdFuncColor = true logger.BufSize = 0 logger.Flag = "MAN" + logger.stopChan, logger.setChan = make(chan int), make(chan int) + go logger.runTransfer() + logmaps.Store(fmt.Sprint(time.Now().UnixNano()), logger) return logger } +func (logger *StarLogger) SetHandleFunc(funcs func([]Attr, string)) { + if logger.handleFunc == nil { + logger.setChan <- 1 + } + logger.handleFunc = funcs +} + +func (logger *StarLogger) GetHandleFunc() func([]Attr, string) { + return logger.handleFunc +} + func (logger *StarLogger) Flush() error { logger.mu.Lock() defer logger.mu.Unlock() @@ -118,6 +145,46 @@ func (logger *StarLogger) Flush() error { return nil } +func (logger *StarLogger) Close() error { + logger.stopChan <- 1 + logmaps.Range(func(k, v interface{}) bool { + if v.(*StarLogger) == logger { + logmaps.Delete(k) + return false + } + return true + }) + logger = nil + return nil +} +func (logger *StarLogger) runTransfer() { + if logger.handleFunc == nil { + select { + case <-logger.stopChan: + return + case <-logger.setChan: + } + } + for { + select { + case <-logger.stopChan: + return + default: + } + if logger.handleFunc == nil { + time.Sleep(time.Millisecond * 100) + continue + } + poped := logger.stacks.MustPop() + if poped == nil { + time.Sleep(time.Millisecond * 20) + continue + } + val := poped.(logTran) + logger.handleFunc(val.color, val.log) + } +} + func NewFlag() *StarLogger { return Std.NewFlag() } @@ -135,9 +202,13 @@ func (logger *StarLogger) NewFlag() *StarLogger { logger2.mu = logger.mu logger2.lock = logger.lock logger2.Flag = string([]byte{uint8(rand.Intn(26) + 65), uint8(rand.Intn(26) + 65), uint8(rand.Intn(26) + 65)}) + logger2.stopChan, logger2.setChan = make(chan int), make(chan int) + logger2.handleFunc = logger.handleFunc + go logger2.runTransfer() if logger2.Flag == "MAN" { logger2.Flag = "RYZ" } + logmaps.Store(fmt.Sprint(time.Now().UnixNano()), logger2) return logger2 } @@ -202,8 +273,9 @@ func (logger *StarLogger) output(level int, logstr string) { logcolor := NewColor(Colors[level]...) logcolor.Fprint(logger.outshow, logs) } - if logger.HandleFunc != nil { - go logger.HandleFunc(Colors[level], logs) + if logger.handleFunc != nil { + //logger.handleFunc(Colors[level], logs) + logger.stacks.Push(logTran{Colors[level], logs}) } if logger.DoWrite { if logger.BufSize == 0 { @@ -223,6 +295,8 @@ func (logger *StarLogger) Debug(str ...interface{}) { } func Debug(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Debug(str...) } @@ -233,6 +307,8 @@ func (logger *StarLogger) Debugf(format string, str ...interface{}) { } func Debugf(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Debugf(format, str...) } @@ -243,6 +319,8 @@ func (logger *StarLogger) Debugln(str ...interface{}) { } func Debugln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Debugln(str...) } @@ -253,6 +331,8 @@ func (logger *StarLogger) Info(str ...interface{}) { } func Info(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Info(str...) } @@ -263,6 +343,8 @@ func (logger *StarLogger) Infof(format string, str ...interface{}) { } func Infof(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Infof(format, str...) } @@ -273,6 +355,8 @@ func (logger *StarLogger) Infoln(str ...interface{}) { } func Infoln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Infoln(str...) } @@ -283,6 +367,8 @@ func (logger *StarLogger) Notice(str ...interface{}) { } func Notice(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Notice(str...) } @@ -293,6 +379,8 @@ func (logger *StarLogger) Noticef(format string, str ...interface{}) { } func Noticef(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Noticef(format, str...) } @@ -303,6 +391,8 @@ func (logger *StarLogger) Noticeln(str ...interface{}) { } func Noticeln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Noticeln(str...) } @@ -313,6 +403,8 @@ func (logger *StarLogger) Warning(str ...interface{}) { } func Warning(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Warning(str...) } @@ -323,6 +415,8 @@ func (logger *StarLogger) Warningf(format string, str ...interface{}) { } func Warningf(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Warningf(format, str...) } @@ -333,6 +427,8 @@ func (logger *StarLogger) Warningln(str ...interface{}) { } func Warningln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Warningln(str...) } @@ -343,6 +439,8 @@ func (logger *StarLogger) Error(str ...interface{}) { } func Error(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Error(str...) } @@ -353,6 +451,8 @@ func (logger *StarLogger) Errorf(format string, str ...interface{}) { } func Errorf(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Errorf(format, str...) } @@ -363,6 +463,8 @@ func (logger *StarLogger) Errorln(str ...interface{}) { } func Errorln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Errorln(str...) } @@ -373,6 +475,8 @@ func (logger *StarLogger) Critical(str ...interface{}) { } func Critical(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Critical(str...) } @@ -383,6 +487,8 @@ func (logger *StarLogger) Criticalf(format string, str ...interface{}) { } func Criticalf(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Criticalf(format, str...) } @@ -393,6 +499,8 @@ func (logger *StarLogger) Criticalln(str ...interface{}) { } func Criticalln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Criticalln(str...) } @@ -404,6 +512,8 @@ func (logger *StarLogger) Fatal(str ...interface{}) { } func Fatal(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Fatal(str...) } @@ -415,6 +525,8 @@ func (logger *StarLogger) Fatalf(format string, str ...interface{}) { } func Fatalf(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Fatalf(format, str...) } @@ -426,6 +538,8 @@ func (logger *StarLogger) Fatalln(str ...interface{}) { } func Fatalln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Fatalln(str...) } @@ -437,6 +551,8 @@ func (logger *StarLogger) Panic(str ...interface{}) { } func Panic(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Panic(str...) } @@ -448,6 +564,8 @@ func (logger *StarLogger) Panicf(format string, str ...interface{}) { } func Panicf(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Panicf(format, str...) } @@ -459,6 +577,8 @@ func (logger *StarLogger) Panicln(str ...interface{}) { } func Panicln(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Panicln(str...) } @@ -471,6 +591,8 @@ func (logger *StarLogger) Print(str ...interface{}) { } func Print(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Print(str...) } @@ -483,6 +605,8 @@ func (logger *StarLogger) Printf(format string, str ...interface{}) { } func Printf(format string, str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Printf(format, str...) } @@ -495,6 +619,8 @@ func (logger *StarLogger) Println(str ...interface{}) { } func Println(str ...interface{}) { + stdLock.Lock() + defer stdLock.Unlock() Std.isStd = true Std.Println(str...) } @@ -504,8 +630,8 @@ func StdPrint(c []Attr, str ...interface{}) { defer Std.lock.Unlock() colorstr := NewColor(c...) colorstr.Print(str...) - if Std.StdFuncColor && Std.HandleFunc != nil { - go Std.HandleFunc(c, fmt.Sprint(str...)) + if Std.StdFuncColor && Std.handleFunc != nil { + go Std.handleFunc(c, fmt.Sprint(str...)) } } @@ -514,8 +640,8 @@ func StdPrintf(c []Attr, format string, str ...interface{}) { defer Std.lock.Unlock() colorstr := NewColor(c...) colorstr.Printf(format, str...) - if Std.StdFuncColor && Std.HandleFunc != nil { - go Std.HandleFunc(c, fmt.Sprintf(format, str...)) + if Std.StdFuncColor && Std.handleFunc != nil { + go Std.handleFunc(c, fmt.Sprintf(format, str...)) } } @@ -524,8 +650,8 @@ func StdPrintln(c []Attr, str ...interface{}) { defer Std.lock.Unlock() colorstr := NewColor(c...) colorstr.Println(str...) - if Std.StdFuncColor && Std.HandleFunc != nil { - go Std.HandleFunc(c, fmt.Sprintln(str...)) + if Std.StdFuncColor && Std.handleFunc != nil { + go Std.handleFunc(c, fmt.Sprintln(str...)) } } @@ -537,6 +663,33 @@ func (logger *StarLogger) SwitchOut(out io.Writer) { logger.switching = false } +func (logger *StarLogger) SetSwitching(out bool) { + logger.lock.Lock() + defer logger.lock.Unlock() + logger.switching = out +} + +func SetSwitchingAll(out bool) { + logmaps.Range(func(k, v interface{}) bool { + v.(*StarLogger).SetSwitching(out) + return true + }) +} + +func SwitchOutAll(out io.Writer) { + logmaps.Range(func(k, v interface{}) bool { + v.(*StarLogger).SwitchOut(out) + return true + }) +} + +func SethandleFuncAll(fn func([]Attr, string)) { + logmaps.Range(func(k, v interface{}) bool { + v.(*StarLogger).handleFunc = fn + return true + }) +} + func SetLogFile(path string) error { var err error StdFile, err = os.Create(path) diff --git a/starlog_test.go b/starlog_test.go index 1eed3b3..b7e5516 100644 --- a/starlog_test.go +++ b/starlog_test.go @@ -5,5 +5,4 @@ import ( ) func Test_LOG(t *testing.T) { - }