mirror of https://github.com/dnomd343/XProxy.git
Dnomd343
11 months ago
17 changed files with 572 additions and 198 deletions
@ -1,7 +1,7 @@ |
|||||
package assets |
package assets |
||||
|
|
||||
import ( |
import ( |
||||
"XProxy/next/logger" |
"XProxy/logger" |
||||
"github.com/robfig/cron" |
"github.com/robfig/cron" |
||||
urlpkg "net/url" |
urlpkg "net/url" |
||||
"os" |
"os" |
||||
@ -1,7 +1,7 @@ |
|||||
package assets |
package assets |
||||
|
|
||||
import ( |
import ( |
||||
"XProxy/next/logger" |
"XProxy/logger" |
||||
"bytes" |
"bytes" |
||||
"compress/bzip2" |
"compress/bzip2" |
||||
"github.com/gabriel-vasile/mimetype" |
"github.com/gabriel-vasile/mimetype" |
||||
@ -1,7 +1,7 @@ |
|||||
package assets |
package assets |
||||
|
|
||||
import ( |
import ( |
||||
"XProxy/next/logger" |
"XProxy/logger" |
||||
"bytes" |
"bytes" |
||||
"errors" |
"errors" |
||||
"github.com/andybalholm/brotli" |
"github.com/andybalholm/brotli" |
||||
@ -1,7 +1,7 @@ |
|||||
package assets |
package assets |
||||
|
|
||||
import ( |
import ( |
||||
"XProxy/next/logger" |
"XProxy/logger" |
||||
urlpkg "net/url" |
urlpkg "net/url" |
||||
"os" |
"os" |
||||
"path" |
"path" |
||||
@ -0,0 +1,99 @@ |
|||||
|
package logger |
||||
|
|
||||
|
import ( |
||||
|
"XProxy/mocks" |
||||
|
"fmt" |
||||
|
"github.com/magiconair/properties/assert" |
||||
|
"github.com/petermattis/goid" |
||||
|
"github.com/stretchr/testify/mock" |
||||
|
"go.uber.org/zap/zapcore" |
||||
|
"runtime" |
||||
|
"strings" |
||||
|
"testing" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
var testTime = time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC) |
||||
|
|
||||
|
// zapCaller build fake caller with the absolute path of current code.
|
||||
|
func zapCaller() zapcore.EntryCaller { |
||||
|
_, srcPath, _, _ := runtime.Caller(0) |
||||
|
return zapcore.EntryCaller{ |
||||
|
File: srcPath, |
||||
|
Line: 0, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// encoderTest is a helper function to test buffer output of mock encoder.
|
||||
|
func encoderTest(t *testing.T, exec func(*mocks.PrimitiveArrayEncoder), expect string) { |
||||
|
encoder := mocks.NewPrimitiveArrayEncoder(t) |
||||
|
encoder.On("AppendInt64", mock.Anything).Maybe() // only enroll used method
|
||||
|
encoder.On("AppendString", mock.Anything).Maybe() |
||||
|
|
||||
|
exec(encoder) |
||||
|
var values []string |
||||
|
for _, call := range encoder.Calls { |
||||
|
values = append(values, fmt.Sprintf("%v", call.Arguments.Get(0))) |
||||
|
} |
||||
|
assert.Equal(t, strings.Join(values, " "), expect) |
||||
|
} |
||||
|
|
||||
|
func Test_getCaller(t *testing.T) { |
||||
|
caller := zapCaller() |
||||
|
caller.File = "Invalid Path" |
||||
|
assert.Equal(t, getCaller(caller, true), "unknown") |
||||
|
assert.Equal(t, getCaller(caller, false), "unknown") |
||||
|
|
||||
|
assert.Equal(t, getCaller(zapCaller(), false), "logger/encoder_test") |
||||
|
assert.Equal(t, getCaller(zapCaller(), true), "logger/encoder_test.go:0") |
||||
|
} |
||||
|
|
||||
|
func Test_timeEncoder(t *testing.T) { |
||||
|
encoderTest(t, func(encoder *mocks.PrimitiveArrayEncoder) { |
||||
|
timeEncoder(testTime, encoder) |
||||
|
}, "2000-01-01 00:00:00.000") |
||||
|
|
||||
|
encoderTest(t, func(encoder *mocks.PrimitiveArrayEncoder) { |
||||
|
timeColoredEncoder(testTime, encoder) |
||||
|
}, "\x1b[36m"+logger.prefix+"\x1b[0m \x1b[90m2000-01-01 00:00:00.000\x1b[0m") |
||||
|
} |
||||
|
|
||||
|
func Test_callerEncoder(t *testing.T) { |
||||
|
verboseVal := logger.verbose |
||||
|
callerTest := func(entry func(zapcore.EntryCaller, zapcore.PrimitiveArrayEncoder), expect string) { |
||||
|
encoderTest(t, func(encoder *mocks.PrimitiveArrayEncoder) { |
||||
|
entry(zapCaller(), encoder) |
||||
|
}, expect) |
||||
|
} |
||||
|
|
||||
|
logger.verbose = false |
||||
|
callerTest(callerEncoder, "[logger/encoder_test]") |
||||
|
callerTest(callerColoredEncoder, "\x1b[35m[logger/encoder_test]\x1b[0m") |
||||
|
|
||||
|
logger.verbose = true |
||||
|
gid := fmt.Sprintf("[%d]", goid.Get()) |
||||
|
callerTest(callerEncoder, gid+" [logger/encoder_test.go:0]") |
||||
|
callerTest(callerColoredEncoder, "\x1b[34m"+gid+"\x1b[0m \x1b[35m[logger/encoder_test.go:0]\x1b[0m") |
||||
|
|
||||
|
logger.verbose = verboseVal |
||||
|
} |
||||
|
|
||||
|
func Test_levelEncoder(t *testing.T) { |
||||
|
levelTest := func(entry func(zapcore.Level, zapcore.PrimitiveArrayEncoder), level zapcore.Level, expect string) { |
||||
|
encoderTest(t, func(encoder *mocks.PrimitiveArrayEncoder) { |
||||
|
entry(level, encoder) |
||||
|
}, expect) |
||||
|
} |
||||
|
|
||||
|
levelTest(levelEncoder, zapcore.DebugLevel, "[DEBUG]") |
||||
|
levelTest(levelEncoder, zapcore.InfoLevel, "[INFO]") |
||||
|
levelTest(levelEncoder, zapcore.WarnLevel, "[WARN]") |
||||
|
levelTest(levelEncoder, zapcore.ErrorLevel, "[ERROR]") |
||||
|
levelTest(levelEncoder, zapcore.PanicLevel, "[PANIC]") |
||||
|
|
||||
|
levelTest(levelColoredEncoder, zapcore.DebugLevel, "\x1b[39m[DEBUG]\x1b[0m") |
||||
|
levelTest(levelColoredEncoder, zapcore.InfoLevel, "\x1b[32m[INFO]\x1b[0m") |
||||
|
levelTest(levelColoredEncoder, zapcore.WarnLevel, "\x1b[33m[WARN]\x1b[0m") |
||||
|
levelTest(levelColoredEncoder, zapcore.ErrorLevel, "\x1b[31m[ERROR]\x1b[0m") |
||||
|
levelTest(levelColoredEncoder, zapcore.PanicLevel, "\x1b[91m[PANIC]\x1b[0m") |
||||
|
} |
||||
@ -0,0 +1,65 @@ |
|||||
|
package logger |
||||
|
|
||||
|
import ( |
||||
|
"go.uber.org/zap/zapcore" |
||||
|
"io" |
||||
|
) |
||||
|
|
||||
|
type Level = zapcore.Level |
||||
|
|
||||
|
const ( |
||||
|
DebugLevel = zapcore.DebugLevel |
||||
|
InfoLevel = zapcore.InfoLevel |
||||
|
WarnLevel = zapcore.WarnLevel |
||||
|
ErrorLevel = zapcore.ErrorLevel |
||||
|
PanicLevel = zapcore.PanicLevel |
||||
|
) |
||||
|
|
||||
|
func Debugf(template string, args ...interface{}) { |
||||
|
logger.entry.Debugf(template, args...) |
||||
|
} |
||||
|
|
||||
|
func Infof(template string, args ...interface{}) { |
||||
|
logger.entry.Infof(template, args...) |
||||
|
} |
||||
|
|
||||
|
func Warnf(template string, args ...interface{}) { |
||||
|
logger.entry.Warnf(template, args...) |
||||
|
} |
||||
|
|
||||
|
func Errorf(template string, args ...interface{}) { |
||||
|
logger.entry.Errorf(template, args...) |
||||
|
} |
||||
|
|
||||
|
func Panicf(template string, args ...interface{}) { |
||||
|
logger.entry.Panicf(template, args...) |
||||
|
} |
||||
|
|
||||
|
// GetLevel return the current logger level.
|
||||
|
func GetLevel() Level { |
||||
|
return logger.level.Level() |
||||
|
} |
||||
|
|
||||
|
// SetLevel configure logger output level. Note that debug level will output
|
||||
|
// more information and reduce performance.
|
||||
|
func SetLevel(level Level) { |
||||
|
logger.level.SetLevel(level) |
||||
|
if level == DebugLevel { |
||||
|
logger.verbose = true |
||||
|
} else { |
||||
|
logger.verbose = false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// AddWriters add more writers to target log channel.
|
||||
|
func AddWriters(colored bool, writers ...io.Writer) { |
||||
|
var syncWriters []zapcore.WriteSyncer |
||||
|
for _, writer := range writers { |
||||
|
syncWriters = append(syncWriters, zapcore.AddSync(writer)) |
||||
|
} |
||||
|
if !colored { |
||||
|
logger.addPlainWrites(syncWriters...) |
||||
|
} else { |
||||
|
logger.addColoredWrites(syncWriters...) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,101 @@ |
|||||
|
package logger |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
"go.uber.org/zap" |
||||
|
"go.uber.org/zap/zapcore" |
||||
|
"os" |
||||
|
"regexp" |
||||
|
"strings" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
var Levels = []Level{DebugLevel, InfoLevel, WarnLevel, ErrorLevel, PanicLevel} |
||||
|
|
||||
|
func Test_level(t *testing.T) { |
||||
|
assert.Equal(t, DebugLevel, zap.DebugLevel) |
||||
|
assert.Equal(t, InfoLevel, zap.InfoLevel) |
||||
|
assert.Equal(t, WarnLevel, zap.WarnLevel) |
||||
|
assert.Equal(t, ErrorLevel, zap.ErrorLevel) |
||||
|
assert.Equal(t, PanicLevel, zap.PanicLevel) |
||||
|
|
||||
|
for _, level := range Levels { |
||||
|
SetLevel(level) |
||||
|
assert.Equal(t, GetLevel(), level) |
||||
|
assert.Equal(t, logger.verbose, level == DebugLevel) // verbose only for DEBUG level
|
||||
|
} |
||||
|
SetLevel(InfoLevel) // revert to INFO level
|
||||
|
} |
||||
|
|
||||
|
func Test_logger(t *testing.T) { |
||||
|
var plainBuf, plainTeeBuf bytes.Buffer |
||||
|
var coloredBuf, coloredTeeBuf bytes.Buffer |
||||
|
logger.plain.writers = []zapcore.WriteSyncer{} // clear slice
|
||||
|
logger.colored.writers = []zapcore.WriteSyncer{} |
||||
|
AddWriters(false, &plainBuf, &plainTeeBuf) |
||||
|
AddWriters(true, &coloredBuf, &coloredTeeBuf) |
||||
|
logger.update() // apply test writers
|
||||
|
|
||||
|
printLogs := func(usingLevel Level) { |
||||
|
SetLevel(usingLevel) |
||||
|
Debugf("Here is %s level", "DEBUG") |
||||
|
Infof("Here is %s level", "INFO") |
||||
|
Warnf("Here is %s level", "WARN") |
||||
|
Errorf("Here is %s level", "ERROR") |
||||
|
assert.Panics(t, func() { |
||||
|
Panicf("Here is %s level", "PANIC") |
||||
|
}) |
||||
|
} |
||||
|
printLogs(DebugLevel) // output into buffer
|
||||
|
printLogs(InfoLevel) |
||||
|
printLogs(WarnLevel) |
||||
|
printLogs(ErrorLevel) |
||||
|
printLogs(PanicLevel) |
||||
|
|
||||
|
assertLine := func(log string, level Level, colored bool, verbose bool) { |
||||
|
regex := `^([\d.:\- ]+) \[(\S+)] (\[\d+] )?\[(\S+)] Here is (\S+) level$` |
||||
|
if colored { |
||||
|
regex = `^\x1b\[36m\[XProxy]\x1b\[0m \x1b\[90m([\d.:\- ]+)\x1b\[0m ` + |
||||
|
`\x1b\[\d\dm\[(\S+)]\x1b\[0m (\x1b\[34m\[\d+]\x1b\[0m )?` + |
||||
|
`\x1b\[35m\[(\S+)]\x1b\[0m Here is (\S+) level$` |
||||
|
} |
||||
|
matches := regexp.MustCompile(regex).FindStringSubmatch(log) |
||||
|
timeRegex := regexp.MustCompile(`^\d{4}(-\d\d){2} \d{2}(:\d\d){2}\.\d{3}$`) |
||||
|
|
||||
|
assert.NotEmpty(t, matches) // valid log line
|
||||
|
assert.Regexp(t, timeRegex, matches[1]) // valid time format
|
||||
|
assert.Equal(t, level.CapitalString(), matches[2]) // valid level string
|
||||
|
assert.Equal(t, level.CapitalString(), matches[5]) |
||||
|
if !verbose { |
||||
|
assert.Equal(t, "logger/interface_test", matches[4]) |
||||
|
} else { |
||||
|
assert.Regexp(t, regexp.MustCompile(`^logger/interface_test.go:\d+$`), matches[4]) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
assertLogs := func(buffer string, colored bool) { |
||||
|
var line string |
||||
|
logs := strings.Split(buffer, "\n") |
||||
|
for _, limit := range Levels { |
||||
|
for _, level := range Levels { |
||||
|
if level >= limit { |
||||
|
line, logs = logs[0], logs[1:] |
||||
|
assertLine(line, level, colored, limit == DebugLevel) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
assert.Equal(t, len(logs), 1) |
||||
|
assert.Equal(t, logs[0], "") // last line is empty
|
||||
|
} |
||||
|
|
||||
|
assertLogs(plainBuf.String(), false) |
||||
|
assertLogs(coloredBuf.String(), true) |
||||
|
assert.Equal(t, plainBuf.String(), plainTeeBuf.String()) |
||||
|
assert.Equal(t, coloredBuf.String(), coloredTeeBuf.String()) |
||||
|
|
||||
|
logger.plain.writers = []zapcore.WriteSyncer{} // revert logger configure
|
||||
|
logger.colored.writers = []zapcore.WriteSyncer{os.Stdout} |
||||
|
logger.level.SetLevel(InfoLevel) |
||||
|
logger.update() |
||||
|
} |
||||
@ -0,0 +1,95 @@ |
|||||
|
package logger |
||||
|
|
||||
|
import ( |
||||
|
"go.uber.org/zap" |
||||
|
"go.uber.org/zap/zapcore" |
||||
|
"os" |
||||
|
"path" |
||||
|
"runtime" |
||||
|
) |
||||
|
|
||||
|
var project string // project absolute path
|
||||
|
var logger *logCore // singleton logger handle
|
||||
|
|
||||
|
// logChannel handle multiple writers with unified format.
|
||||
|
type logChannel struct { |
||||
|
encoder zapcore.Encoder |
||||
|
writers []zapcore.WriteSyncer |
||||
|
} |
||||
|
|
||||
|
// logCore manage log level, channels and other interfaces.
|
||||
|
type logCore struct { |
||||
|
prefix string // custom output prefix
|
||||
|
verbose bool // show verbose information
|
||||
|
|
||||
|
plain logChannel // log channel with plain text
|
||||
|
colored logChannel // log channel with colored text
|
||||
|
|
||||
|
level *zap.AtomicLevel // zap log level pointer
|
||||
|
entry *zap.SugaredLogger // zap sugared logger entry
|
||||
|
} |
||||
|
|
||||
|
func init() { |
||||
|
_, src, _, _ := runtime.Caller(0) // absolute path of current code
|
||||
|
project = path.Join(path.Dir(src), "../") |
||||
|
|
||||
|
zapLevel := zap.NewAtomicLevelAt(InfoLevel) // using info level in default
|
||||
|
logger = &logCore{ |
||||
|
verbose: false, |
||||
|
level: &zapLevel, |
||||
|
prefix: "[XProxy]", |
||||
|
plain: buildChannel(false), |
||||
|
colored: buildChannel(true), |
||||
|
} |
||||
|
logger.addColoredWrites(os.Stderr) // output into stderr in default
|
||||
|
} |
||||
|
|
||||
|
// buildChannel generate logChannel with `colored` option.
|
||||
|
func buildChannel(colored bool) logChannel { |
||||
|
config := zapcore.EncoderConfig{ |
||||
|
ConsoleSeparator: " ", |
||||
|
MessageKey: "msg", |
||||
|
LevelKey: "level", |
||||
|
TimeKey: "time", |
||||
|
CallerKey: "caller", |
||||
|
EncodeTime: timeEncoder, |
||||
|
EncodeLevel: levelEncoder, |
||||
|
EncodeCaller: callerEncoder, |
||||
|
} |
||||
|
if colored { // using colored version
|
||||
|
config.EncodeTime = timeColoredEncoder |
||||
|
config.EncodeLevel = levelColoredEncoder |
||||
|
config.EncodeCaller = callerColoredEncoder |
||||
|
} |
||||
|
return logChannel{ |
||||
|
encoder: zapcore.NewConsoleEncoder(config), |
||||
|
writers: []zapcore.WriteSyncer{}, // without any writer
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// update refreshes the binding of the log core to the writers.
|
||||
|
func (handle *logCore) update() { |
||||
|
buildCore := func(channel *logChannel) zapcore.Core { // build zap core from logChannel
|
||||
|
return zapcore.NewCore( |
||||
|
channel.encoder, |
||||
|
zap.CombineWriteSyncers(channel.writers...), |
||||
|
handle.level, |
||||
|
) |
||||
|
} |
||||
|
handle.entry = zap.New( |
||||
|
zapcore.NewTee(buildCore(&handle.plain), buildCore(&handle.colored)), |
||||
|
zap.AddCaller(), zap.AddCallerSkip(1), |
||||
|
).Named("xproxy").Sugar() |
||||
|
} |
||||
|
|
||||
|
// addPlainWrites adds plain text writers to the logCore.
|
||||
|
func (handle *logCore) addPlainWrites(writers ...zapcore.WriteSyncer) { |
||||
|
handle.plain.writers = append(handle.plain.writers, writers...) |
||||
|
handle.update() |
||||
|
} |
||||
|
|
||||
|
// addColoredWrites adds colored text writers to the logCore.
|
||||
|
func (handle *logCore) addColoredWrites(writers ...zapcore.WriteSyncer) { |
||||
|
handle.colored.writers = append(handle.colored.writers, writers...) |
||||
|
handle.update() |
||||
|
} |
||||
@ -0,0 +1,47 @@ |
|||||
|
package logger |
||||
|
|
||||
|
import ( |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
"go.uber.org/zap/zapcore" |
||||
|
"os" |
||||
|
"path" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
func Test_init(t *testing.T) { |
||||
|
pwd := path.Dir(zapCaller().File) |
||||
|
assert.Equal(t, path.Join(pwd, "../"), project) |
||||
|
|
||||
|
assert.NotNil(t, logger) |
||||
|
assert.NotNil(t, logger.entry) |
||||
|
assert.NotNil(t, logger.level) |
||||
|
|
||||
|
assert.Equal(t, logger.verbose, false) |
||||
|
assert.Equal(t, logger.prefix, "[XProxy]") |
||||
|
assert.Equal(t, logger.level.Level(), InfoLevel) |
||||
|
|
||||
|
assert.Equal(t, len(logger.plain.writers), 0) |
||||
|
assert.Equal(t, len(logger.colored.writers), 1) |
||||
|
|
||||
|
for _, level := range []zapcore.Level{DebugLevel, InfoLevel, WarnLevel, ErrorLevel, PanicLevel} { |
||||
|
logger.level.SetLevel(level) |
||||
|
assert.Equal(t, logger.entry.Level(), level) |
||||
|
} |
||||
|
logger.level.SetLevel(InfoLevel) // revert to INFO level
|
||||
|
} |
||||
|
|
||||
|
func Test_addWrites(t *testing.T) { |
||||
|
core := new(logCore) |
||||
|
assert.Equal(t, len(core.plain.writers), 0) |
||||
|
assert.Equal(t, len(core.colored.writers), 0) |
||||
|
|
||||
|
core.entry = nil |
||||
|
core.addPlainWrites(os.Stdout, os.Stdout, os.Stdout) |
||||
|
assert.NotNil(t, core.entry) |
||||
|
assert.Equal(t, len(core.plain.writers), 3) |
||||
|
|
||||
|
core.entry = nil |
||||
|
core.addColoredWrites(os.Stderr, os.Stderr, os.Stderr) |
||||
|
assert.NotNil(t, core.entry) |
||||
|
assert.Equal(t, len(core.plain.writers), 3) |
||||
|
} |
||||
@ -1,6 +1,6 @@ |
|||||
package main |
package main |
||||
|
|
||||
import "XProxy/next/assets" |
import "XProxy/assets" |
||||
|
|
||||
func main() { |
func main() { |
||||
remoteAssets := map[string]string{ |
remoteAssets := map[string]string{ |
||||
@ -0,0 +1,114 @@ |
|||||
|
// Code generated by mockery v2.40.1. DO NOT EDIT.
|
||||
|
|
||||
|
package mocks |
||||
|
|
||||
|
import mock "github.com/stretchr/testify/mock" |
||||
|
|
||||
|
// PrimitiveArrayEncoder is an autogenerated mock type for the PrimitiveArrayEncoder type
|
||||
|
type PrimitiveArrayEncoder struct { |
||||
|
mock.Mock |
||||
|
} |
||||
|
|
||||
|
// AppendBool provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendBool(_a0 bool) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendByteString provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendByteString(_a0 []byte) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendComplex128 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendComplex128(_a0 complex128) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendComplex64 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendComplex64(_a0 complex64) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendFloat32 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendFloat32(_a0 float32) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendFloat64 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendFloat64(_a0 float64) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendInt provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendInt(_a0 int) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendInt16 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendInt16(_a0 int16) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendInt32 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendInt32(_a0 int32) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendInt64 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendInt64(_a0 int64) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendInt8 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendInt8(_a0 int8) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendString provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendString(_a0 string) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendUint provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendUint(_a0 uint) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendUint16 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendUint16(_a0 uint16) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendUint32 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendUint32(_a0 uint32) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendUint64 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendUint64(_a0 uint64) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendUint8 provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendUint8(_a0 uint8) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// AppendUintptr provides a mock function with given fields: _a0
|
||||
|
func (_m *PrimitiveArrayEncoder) AppendUintptr(_a0 uintptr) { |
||||
|
_m.Called(_a0) |
||||
|
} |
||||
|
|
||||
|
// NewPrimitiveArrayEncoder creates a new instance of PrimitiveArrayEncoder. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
||||
|
// The first argument is typically a *testing.T value.
|
||||
|
func NewPrimitiveArrayEncoder(t interface { |
||||
|
mock.TestingT |
||||
|
Cleanup(func()) |
||||
|
}) *PrimitiveArrayEncoder { |
||||
|
mock := &PrimitiveArrayEncoder{} |
||||
|
mock.Mock.Test(t) |
||||
|
|
||||
|
t.Cleanup(func() { mock.AssertExpectations(t) }) |
||||
|
|
||||
|
return mock |
||||
|
} |
||||
@ -1,59 +0,0 @@ |
|||||
package logger |
|
||||
|
|
||||
import ( |
|
||||
"go.uber.org/zap/zapcore" |
|
||||
"io" |
|
||||
) |
|
||||
|
|
||||
const ( |
|
||||
DebugLevel = zapcore.DebugLevel |
|
||||
InfoLevel = zapcore.InfoLevel |
|
||||
WarnLevel = zapcore.WarnLevel |
|
||||
ErrorLevel = zapcore.ErrorLevel |
|
||||
PanicLevel = zapcore.PanicLevel |
|
||||
) |
|
||||
|
|
||||
func Debugf(template string, args ...interface{}) { |
|
||||
logHandle.sugar.Debugf(template, args...) |
|
||||
} |
|
||||
|
|
||||
func Infof(template string, args ...interface{}) { |
|
||||
logHandle.sugar.Infof(template, args...) |
|
||||
} |
|
||||
|
|
||||
func Warnf(template string, args ...interface{}) { |
|
||||
logHandle.sugar.Warnf(template, args...) |
|
||||
} |
|
||||
|
|
||||
func Errorf(template string, args ...interface{}) { |
|
||||
logHandle.sugar.Errorf(template, args...) |
|
||||
} |
|
||||
|
|
||||
func Panicf(template string, args ...interface{}) { |
|
||||
logHandle.sugar.Panicf(template, args...) |
|
||||
} |
|
||||
|
|
||||
// GetLevel return the current logger level.
|
|
||||
func GetLevel() zapcore.Level { |
|
||||
return logHandle.level.Level() |
|
||||
} |
|
||||
|
|
||||
// SetLevel configure logger output level. Note that debug level
|
|
||||
// will output more information and reduce performance.
|
|
||||
func SetLevel(level zapcore.Level) { |
|
||||
logHandle.level.SetLevel(level) |
|
||||
if level == DebugLevel { |
|
||||
logHandle.verbose = true |
|
||||
} else { |
|
||||
logHandle.verbose = false |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// AddOutputs adds more plain output channel to the logger module.
|
|
||||
func AddOutputs(outputs ...io.Writer) { |
|
||||
var writers []zapcore.WriteSyncer |
|
||||
for _, output := range outputs { |
|
||||
writers = append(writers, zapcore.AddSync(output)) |
|
||||
} |
|
||||
addWrites(writers...) |
|
||||
} |
|
||||
@ -1,78 +0,0 @@ |
|||||
package logger |
|
||||
|
|
||||
import ( |
|
||||
"go.uber.org/zap" |
|
||||
"go.uber.org/zap/zapcore" |
|
||||
"os" |
|
||||
"path" |
|
||||
"runtime" |
|
||||
) |
|
||||
|
|
||||
type logger struct { |
|
||||
logger *zap.Logger |
|
||||
level *zap.AtomicLevel |
|
||||
sugar *zap.SugaredLogger |
|
||||
writers []zapcore.WriteSyncer |
|
||||
stderr zapcore.Core // fixed stderr output
|
|
||||
prefix string // custom output prefix
|
|
||||
path string // project absolute path
|
|
||||
verbose bool // show goroutine id and caller line
|
|
||||
} |
|
||||
|
|
||||
var logHandle *logger // singleton logger handle
|
|
||||
|
|
||||
// logConfig generates log config for XProxy.
|
|
||||
func logConfig(colored bool) zapcore.EncoderConfig { |
|
||||
config := zapcore.EncoderConfig{ |
|
||||
ConsoleSeparator: " ", |
|
||||
MessageKey: "msg", |
|
||||
LevelKey: "level", |
|
||||
TimeKey: "time", |
|
||||
CallerKey: "caller", |
|
||||
EncodeTime: timeEncoder, |
|
||||
EncodeLevel: levelEncoder, |
|
||||
EncodeCaller: callerEncoder, |
|
||||
} |
|
||||
if colored { |
|
||||
config.EncodeTime = timeColoredEncoder |
|
||||
config.EncodeLevel = levelColoredEncoder |
|
||||
config.EncodeCaller = callerColoredEncoder |
|
||||
} |
|
||||
return config |
|
||||
} |
|
||||
|
|
||||
func init() { |
|
||||
zapLevel := zap.NewAtomicLevelAt(InfoLevel) // using info level in default
|
|
||||
zapCore := zapcore.NewCore( |
|
||||
zapcore.NewConsoleEncoder(logConfig(true)), // colorful output
|
|
||||
zapcore.Lock(os.Stderr), |
|
||||
zapLevel, |
|
||||
) |
|
||||
zapLogger := zap.New(zapCore, zap.AddCaller(), zap.AddCallerSkip(1)) |
|
||||
_, src, _, _ := runtime.Caller(0) // absolute path of current code
|
|
||||
logHandle = &logger{ |
|
||||
logger: zapLogger, |
|
||||
level: &zapLevel, |
|
||||
stderr: zapCore, |
|
||||
sugar: zapLogger.Sugar(), |
|
||||
writers: []zapcore.WriteSyncer{}, |
|
||||
path: path.Join(path.Dir(src), "../"), |
|
||||
prefix: "[XProxy]", |
|
||||
verbose: false, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// addWrites adds more plain log writers.
|
|
||||
func addWrites(writers ...zapcore.WriteSyncer) { |
|
||||
logHandle.writers = append(logHandle.writers, writers...) |
|
||||
plainCore := zapcore.NewCore( |
|
||||
zapcore.NewConsoleEncoder(logConfig(false)), // without colored
|
|
||||
zap.CombineWriteSyncers(logHandle.writers...), |
|
||||
logHandle.level, |
|
||||
) |
|
||||
logHandle.logger = zap.New( |
|
||||
zapcore.NewTee(logHandle.stderr, plainCore), |
|
||||
zap.AddCaller(), zap.AddCallerSkip(1), |
|
||||
) |
|
||||
logHandle.sugar = logHandle.logger.Sugar() |
|
||||
} |
|
||||
Loading…
Reference in new issue