diff --git a/common/common.go b/common/common.go new file mode 100644 index 0000000000000000000000000000000000000000..99da0ae49592ac35b83e0f55212231876230fd2f --- /dev/null +++ b/common/common.go @@ -0,0 +1,10 @@ +package common + +const ( + DATE_FORMAT = "2006-01-02" + DATE_TIME_FORMAT = "2006-01-02 15:04:05" +) + +const ( + +) diff --git a/go.mod b/go.mod new file mode 100644 index 0000000000000000000000000000000000000000..cf975c09e3b3108bcba46978ba51a8711ad5de5e --- /dev/null +++ b/go.mod @@ -0,0 +1,3 @@ +module standard-lib + +go 1.17 diff --git a/http/client.go b/http/client.go new file mode 100644 index 0000000000000000000000000000000000000000..fdaaef9d8d1868bd4397ee242569a956bae64066 --- /dev/null +++ b/http/client.go @@ -0,0 +1,31 @@ +package http + +import ( + "context" + "fmt" + "net/http" +) + +var ( + ErrNoConnection = fmt.Errorf("http: no connection") + ErrNoAvailableNode = fmt.Errorf("http: no available node") + ErrRetryTooManyTimes = fmt.Errorf("http retried too many times") + ErrNeedRetry = fmt.Errorf("http: need retry") +) + +type Client interface { + Do(ctx context.Context, req *http.Request) (*http.Response, error) +} + +type defaultClient struct { + ctx context.Context + config *Config +} + +func newDefaultClient(ctx context.Context, config *Config) Client { + if config.Retry < 0 { + config.Retry = 0 + } + return nil + +} \ No newline at end of file diff --git a/http/config.go b/http/config.go new file mode 100644 index 0000000000000000000000000000000000000000..248e6bd48993f24f884c8351ae663b89eface975 --- /dev/null +++ b/http/config.go @@ -0,0 +1,13 @@ +package http + +import "time" + +type Config struct { + ServiceName string `toml:"service_name" yaml:"service_name"` + VipAddr string `toml:"vip_addr" yaml:"vip_addr"` + Scheme string `toml:"scheme" yaml:"scheme"` + SocketTimeout time.Duration `toml:"socket_timeout" yaml:"socket_timeout"` + ConnTimeout time.Duration `toml:"conn_timeout" yaml:"conn_timeout"` + Retry int `toml:"retry" yaml:"retry"` + Tolerance int `toml:"tolerance" yaml:"tolerance"` +} diff --git a/logger/config.go b/logger/config.go new file mode 100644 index 0000000000000000000000000000000000000000..d3e05c5ffc0a1dca9909eab4ce772b8dcf17670a --- /dev/null +++ b/logger/config.go @@ -0,0 +1,40 @@ +package logger + +const ( + DEFAULT_FILE_PATH = "./log/all.log" + DEFAULT_ERROR_FILE_PATH = "./log/error.log" + DEFAULT_LEVEL = "debug" + DEFAULT_FORMATTER = "json" + + DEFAULT_MAX_SIZE_MB = 1024 * 1024 * 1024 +) + +type Config struct { + FilePath string `toml:"file_path"` + ErrorFilePath string `toml:"error_file_path"` + Level string `toml:"level"` + MaxSizeMB int `toml:"max_size_mb"` + MaxBackups int `toml:"max_backups"` + Formatter string `toml:"formatter"` + ShowFileLine bool `toml:"show_file_line"` + Debug bool `toml:"debug"` +} + +func Init(config *Config) { + if config.FilePath == "" { + config.FilePath = DEFAULT_FILE_PATH + } + if config.ErrorFilePath == "" { + config.ErrorFilePath = DEFAULT_ERROR_FILE_PATH + } + if config.Level == "" { + config.Level = DEFAULT_LEVEL + } + if config.Formatter == "" { + config.Formatter = DEFAULT_FORMATTER + } + if config.MaxSizeMB == 0 { + config.MaxSizeMB = DEFAULT_MAX_SIZE_MB + } + +} diff --git a/logger/default_logger.go b/logger/default_logger.go new file mode 100644 index 0000000000000000000000000000000000000000..8fd3c581c4824dfc1ff921ee3e22047331b45c98 --- /dev/null +++ b/logger/default_logger.go @@ -0,0 +1,90 @@ +package logger + +import ( + "io" + "sync/atomic" +) + +type defaultLogger struct { + addWriter chan levelWriter + queue chan interface{} + close chan struct{} + exit chan struct{} + + maxLevel Level + showFileLine bool + callerSkip int + formatter string + closed int32 +} + +func newDefaultLogger(maxLevel Level, writer io.Writer) *defaultLogger { + l := &defaultLogger{ + addWriter: make(chan levelWriter), + queue: make(chan interface{}), + close: make(chan struct{}), + maxLevel: maxLevel, + } + go l.loop() + l.AddWriter(PrintLevel, writer) + return l +} + +func (l *defaultLogger) AddWriter(maxLevel Level, writer io.Writer) { + wc, ok := writer.(io.WriteCloser) + if !ok { + wc = nopWriterCloser{ + writer: writer, + } + } + + l.addWriter <- levelWriter{ + maxLevel: maxLevel, + writer: wc, + } +} + +func (l *defaultLogger) SetShowFileLine(enabled bool) { + l.showFileLine = enabled +} + +func (l *defaultLogger) SetFormatter(formatter string) { + l.formatter = formatter +} + +func (l *defaultLogger) SetSkip(skip int) { + l.callerSkip = skip +} + +func (l *defaultLogger) SetMaxLevel(maxLevel Level) { + l.maxLevel = maxLevel +} + +func (l *defaultLogger) Close() error { + if !atomic.CompareAndSwapInt32(&l.closed, 0, 1) { + return nil + } + close(l.close) + select { + case <-l.exit: + } + + return nil +} + +func (l *defaultLogger) loop() { + +} + +func (l *defaultLogger) IsDebugEnable() bool { + return l.maxLevel <= DEBUG +} + +func (l *defaultLogger) Write(p []byte) (n int, err error) { + n = len(p) + + + return +} + + diff --git a/logger/entry.go b/logger/entry.go new file mode 100644 index 0000000000000000000000000000000000000000..90c66f6273f1a95f0c014b24d9aeb2c0b7532172 --- /dev/null +++ b/logger/entry.go @@ -0,0 +1 @@ +package logger diff --git a/logger/level.go b/logger/level.go new file mode 100644 index 0000000000000000000000000000000000000000..a2977c2d60369bf2e656d62816150c1ed129ae93 --- /dev/null +++ b/logger/level.go @@ -0,0 +1,61 @@ +package logger + +import "strings" + +type Level int + +const ( + PANIC Level = iota + FATAL + ERROR + WARN + INFO + DEBUG + TRACE + + PrintLevel +) + +func (l Level) String() string { + switch l { + case PANIC: + return "PANIC" + case FATAL: + return "FATAL" + case ERROR: + return "ERROR" + case WARN: + return "WARN" + case INFO: + return "INFO" + case DEBUG: + return "DEBUG" + case TRACE: + return "TRACE" + case PrintLevel: + return "" + default: + return "" + } +} + +func ParseLevel(l string) (level Level, ok bool) { + switch strings.ToUpper(l) { + case "PANIC": + return PANIC, true + case "FATAL": + return FATAL, true + case "ERROR": + return ERROR, true + case "WARN": + return WARN, true + case "INFO": + return INFO, true + case "DEBUG": + return DEBUG, true + case "TRACE": + return TRACE, true + default: + return DEBUG, false + } +} \ No newline at end of file diff --git a/logger/level_writer.go b/logger/level_writer.go new file mode 100644 index 0000000000000000000000000000000000000000..dd5223cdf166f5df9fafc4d66e7ba28f8e687794 --- /dev/null +++ b/logger/level_writer.go @@ -0,0 +1,9 @@ +package logger + +import "io" + +type levelWriter struct { + maxLevel Level + writer io.WriteCloser +} + diff --git a/logger/log.go b/logger/log.go new file mode 100644 index 0000000000000000000000000000000000000000..47ba2ceb0e25fd697d3d9de75b8ebe69cd48870e --- /dev/null +++ b/logger/log.go @@ -0,0 +1,30 @@ +package logger + +import ( + "context" + "io" +) + +type Logger interface { + io.Closer + + Printf(format string, args ...interface{}) + Tracef(format string, args ...interface{}) + Debugf(format string, args ...interface{}) + Infof(format string, args ...interface{}) + Warmf(format string, args ...interface{}) + Errorf(format string, args ...interface{}) + Fatalf(format string, args ...interface{}) + Panicf(format string, args ...interface{}) + + TraceWithCtx(ctx context.Context, prefix string, fmt string, args ...interface{}) + DebugWithCtx(ctx context.Context, prefix string, fmt string, args ...interface{}) + WarmWithCtx(ctx context.Context, prefix string, fmt string, args ...interface{}) + InfoWithCtx(ctx context.Context, prefix string, fmt string, args ...interface{}) + ErrorWithCtx(ctx context.Context, prefix string, fmt string, args ...interface{}) + FatalWithCtx(ctx context.Context, prefix string, fmt string, args ...interface{}) + + IsDebugEnable() bool +} + + diff --git a/logger/nop_write_closer.go b/logger/nop_write_closer.go new file mode 100644 index 0000000000000000000000000000000000000000..302c856da973ddd3869a80181e08d758f02dfbb6 --- /dev/null +++ b/logger/nop_write_closer.go @@ -0,0 +1,16 @@ +package logger + +import "io" + +type nopWriterCloser struct { + writer io.Writer +} + +func (n2 nopWriterCloser) Write(p []byte) (n int, err error) { + panic("implement me") +} + +func (n2 nopWriterCloser) Close() error { + panic("implement me") +} +