Merge branch 'master' of github.com:toolkits/pkg

Author: UlricQin

i18n/i18n.go

@@ -70,8 +70,14 @@ func DictRegister(m map[string]map[string]string) {
 
 func langTag(l string) language.Tag {
 	switch strings.ToLower(l) {
-	case "zh", "cn":
+	case "zh", "cn", "zh_cn", "zh-cn":
 		return language.Chinese
+	case "zh_hk", "zh-hk", "zh_tw", "zh-tw":
+		return language.TraditionalChinese
+	case "ja", "jp", "ja_jp", "ja-jp":
+		return language.Japanese
+	case "ko", "kr", "ko_kr", "ko-kr":
+		return language.Korean
 	default:
 		return language.English
 	}

logger/config.go

@@ -16,6 +16,7 @@ type LogConfig struct {
 	FileFlushDuration time.Duration
 	RotateByHour      bool
 	KeepHours         uint // make sense when RotateByHour is T
+	OutputToOneFile   bool
 }
 
 func initFromConfig(log *Logger,
@@ -44,6 +45,7 @@ func initFromConfig(log *Logger,
 		fb.SetFlushDuration(config.FileFlushDuration)
 		fb.SetRotateByHour(config.RotateByHour)
 		fb.SetKeepHours(config.KeepHours)
+		fb.OutputToOneFile(config.OutputToOneFile)
 	} else {
 		return fmt.Errorf("unknown log type: %s", config.Type)
 	}

logger/file.go

@@ -55,17 +55,18 @@ func (self *syncBuffer) write(b []byte) {
 }
 
 type FileBackend struct {
-	mu            sync.Mutex
-	dir           string // directory for log files
-	files         [numSeverity]syncBuffer
-	flushInterval time.Duration
-	rotateNum     int
-	maxSize       uint64
-	fall          bool
-	rotateByHour  bool
-	lastCheck     uint64
-	reg           *regexp.Regexp // for rotatebyhour log del...
-	keepHours     uint           // keep how many hours old, only make sense when rotatebyhour is T
+	mu              sync.Mutex
+	dir             string // directory for log files
+	files           [numSeverity]syncBuffer
+	flushInterval   time.Duration
+	rotateNum       int
+	maxSize         uint64
+	fall            bool
+	rotateByHour    bool
+	lastCheck       uint64
+	reg             *regexp.Regexp // for rotatebyhour log del...
+	keepHours       uint           // keep how many hours old, only make sense when rotatebyhour is T
+	outputToOneFile bool
 }
 
 func (self *FileBackend) Flush() {
@@ -75,7 +76,6 @@ func (self *FileBackend) Flush() {
 		self.files[i].Flush()
 		self.files[i].Sync()
 	}
-
 }
 
 func (self *FileBackend) Close() {
@@ -123,7 +123,7 @@ func (self *FileBackend) rotateByHourDaemon() {
 			files, err := ioutil.ReadDir(self.dir)
 			if err == nil {
 				for _, file := range files {
-					// exactly match, then we
+					// exactly match, then remove
 					if file.Name() == self.reg.FindString(file.Name()) &&
 						shouldDel(file.Name(), self.keepHours) {
 						os.Remove(filepath.Join(self.dir, file.Name()))
@@ -138,35 +138,43 @@ func (self *FileBackend) monitorFiles() {
 	for range time.NewTicker(time.Second * 5).C {
 		for i := 0; i < numSeverity; i++ {
 			fileName := path.Join(self.dir, severityName[i]+".log")
-			if _, err := os.Stat(fileName); err != nil && os.IsNotExist(err) {
-				if f, err := os.OpenFile(fileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
-					self.mu.Lock()
-					self.files[i].close()
-					self.files[i].Writer = bufio.NewWriterSize(f, bufferSize)
-					self.files[i].file = f
-					self.mu.Unlock()
-				}
-			}
+			self.monitorFile(fileName, &self.files[i])
+		}
+	}
+}
+
+func (self *FileBackend) monitorFile(fileName string, sb *syncBuffer) {
+	if _, err := os.Stat(fileName); err != nil && os.IsNotExist(err) {
+		if f, err := os.OpenFile(fileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
+			self.mu.Lock()
+			sb.close()
+			sb.Writer = bufio.NewWriterSize(f, bufferSize)
+			sb.file = f
+			self.mu.Unlock()
 		}
 	}
 }
 
 func (self *FileBackend) Log(s Severity, msg []byte) {
 	self.mu.Lock()
-	switch s {
-	case FATAL:
-		self.files[FATAL].write(msg)
-	case ERROR:
-		self.files[ERROR].write(msg)
-	case WARNING:
-		self.files[WARNING].write(msg)
-	case INFO:
-		self.files[INFO].write(msg)
-	case DEBUG:
-		self.files[DEBUG].write(msg)
-	}
-	if self.fall && s < INFO {
-		self.files[INFO].write(msg)
+	if self.outputToOneFile {
+		self.files[ALL].write(msg)
+	} else {
+		switch s {
+		case FATAL:
+			self.files[FATAL].write(msg)
+		case ERROR:
+			self.files[ERROR].write(msg)
+		case WARNING:
+			self.files[WARNING].write(msg)
+		case INFO:
+			self.files[INFO].write(msg)
+		case DEBUG:
+			self.files[DEBUG].write(msg)
+		}
+		if self.fall && s < INFO {
+			self.files[INFO].write(msg)
+		}
 	}
 	self.mu.Unlock()
 	if s == FATAL {
@@ -203,6 +211,11 @@ func (self *FileBackend) SetFlushDuration(t time.Duration) {
 		self.flushInterval = time.Second
 	}
 }
+
+func (self *FileBackend) OutputToOneFile(flag bool) {
+	self.outputToOneFile = flag
+}
+
 func NewFileBackend(dir string) (*FileBackend, error) {
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return nil, err
@@ -215,21 +228,9 @@ func NewFileBackend(dir string) (*FileBackend, error) {
 		if err != nil {
 			return nil, err
 		}
-
-		count := uint64(0)
-		stat, err := f.Stat()
-		if err == nil {
-			count = uint64(stat.Size())
-		}
-		fb.files[i] = syncBuffer{
-			Writer:   bufio.NewWriterSize(f, bufferSize),
-			file:     f,
-			filePath: fileName,
-			parent:   &fb,
-			count:    count,
-		}
-
+		fb.files[i] = newSyncBuffer(f, &fb, fileName)
 	}
+
 	// default
 	fb.flushInterval = time.Second * 3
 	fb.rotateNum = 20
@@ -238,7 +239,7 @@ func NewFileBackend(dir string) (*FileBackend, error) {
 	fb.lastCheck = 0
 	// init reg to match files
 	// ONLY cover this centry...
-	fb.reg = regexp.MustCompile("(INFO|ERROR|WARNING|DEBUG|FATAL)\\.log\\.20[0-9]{8}")
+	fb.reg = regexp.MustCompile("(INFO|ERROR|WARNING|DEBUG|FATAL|ALL)\\.log\\.20[0-9]{8}")
 	fb.keepHours = 24 * 7
 
 	go fb.flushDaemon()
@@ -247,6 +248,21 @@ func NewFileBackend(dir string) (*FileBackend, error) {
 	return &fb, nil
 }
 
+func newSyncBuffer(f *os.File, fb *FileBackend, fileName string) syncBuffer {
+	count := uint64(0)
+	stat, err := f.Stat()
+	if err == nil {
+		count = uint64(stat.Size())
+	}
+	return syncBuffer{
+		Writer:   bufio.NewWriterSize(f, bufferSize),
+		file:     f,
+		filePath: fileName,
+		parent:   fb,
+		count:    count,
+	}
+}
+
 func Rotate(rotateNum1 int, maxSize1 uint64) {
 	if fileback != nil {
 		fileback.Rotate(rotateNum1, maxSize1)

logger/logger.go

@@ -18,6 +18,7 @@ const (
 	WARNING
 	INFO
 	DEBUG
+	ALL
 )
 
 var severityName = []string{
@@ -26,10 +27,11 @@ var severityName = []string{
 	WARNING: "WARNING",
 	INFO:    "INFO",
 	DEBUG:   "DEBUG",
+	ALL:     "ALL",
 }
 
 const (
-	numSeverity = 5
+	numSeverity = 6
 )
 
 type Backend interface {
@@ -56,7 +58,7 @@ type Logger struct {
 	logToStderr bool
 }
 
-//resued buffer for fast format the output string
+// resued buffer for fast format the output string
 type buffer struct {
 	bytes.Buffer
 	tmp  [64]byte
@@ -337,7 +339,7 @@ func (l *Logger) SetLogging(level interface{}, backend Backend) {
 	l.backend = backend
 }
 
-/////////////////////////////////////////////////////////////////
+// ///////////////////////////////////////////////////////////////
 // depth version, only a low level api
 func (l *Logger) LogDepth(s Severity, depth int, format string, args ...interface{}) {
 	l.printfDepth(s, depth+1, format, args...)

net/tcpx/tcpx.go

@@ -4,35 +4,85 @@ import (
 	"fmt"
 	"net"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 )
 
+type Config struct {
+	Hosts                []string
+	GlobalTimeout        time.Duration
+	TcpConnectionTimeout time.Duration
+	WaitBefore           time.Duration
+	WaitAfter            time.Duration
+	WaitSleepInterval    time.Duration
+}
+
 func WaitHosts() {
-	hosts := os.Getenv("WAIT_HOSTS")
-	if len(hosts) == 0 {
-		return
-	}
+	config := ConfigFromEnv()
+	Wait(config, func() { os.Exit(1) })
+}
 
+func ConfigFromEnv() *Config {
+	hosts := os.Getenv("WAIT_HOSTS")
 	hosts = strings.ReplaceAll(hosts, ",", " ")
-	array := strings.Fields(hosts)
+	return &Config{
+		Hosts:                strings.Fields(hosts),
+		GlobalTimeout:        envTimeParse("WAIT_TIMEOUT", time.Second*30),
+		TcpConnectionTimeout: envTimeParse("WAIT_HOST_CONNECT_TIMEOUT", time.Second*5),
+		WaitBefore:           envTimeParse("WAIT_BEFORE", 0),
+		WaitAfter:            envTimeParse("WAIT_AFTER", 0),
+		WaitSleepInterval:    envTimeParse("WAIT_SLEEP_INTERVAL", time.Second),
+	}
+}
 
-	for _, host := range array {
-		waitHost(host)
+func IsPortReachableWithTimeout(host string, tpcTimeout time.Duration) bool {
+	conn, err := net.DialTimeout("tcp", host, tpcTimeout)
+	if err != nil {
+		return false
 	}
+	_ = conn.Close()
+	return true
 }
 
-func waitHost(host string) {
-	for {
-		fmt.Printf("[%s] Waiting for host: %s\n", time.Now(), host)
+func Wait(config *Config, onTimeout func()) {
+	if config.WaitBefore > 0 {
+		time.Sleep(config.WaitBefore)
+	}
+	afterTime := time.After(config.GlobalTimeout)
 
-		conn, err := net.DialTimeout("tcp", host, time.Second)
-		if err == nil {
-			conn.Close()
-			fmt.Printf("[%s] Host is ready: %s\n", time.Now(), host)
-			return
+loopLabel:
+	for _, host := range config.Hosts {
+		for {
+			fmt.Printf("[%s] Waiting for host: %s\n", time.Now(), host)
+			reach := IsPortReachableWithTimeout(host, config.TcpConnectionTimeout)
+			if reach {
+				fmt.Printf("[%s] Host is ready: %s\n", time.Now(), host)
+				break
+			}
+			select {
+			case <-afterTime:
+				fmt.Printf("[%s] Wait for the host to time out: %s\n", time.Now(), host)
+				onTimeout()
+				break loopLabel
+			default:
+				time.Sleep(config.WaitSleepInterval)
+			}
 		}
+	}
+
+	if config.WaitAfter > 0 {
+		time.Sleep(config.WaitAfter)
+	}
+}
 
-		time.Sleep(time.Second)
+func envTimeParse(key string, defaultValue time.Duration) time.Duration {
+	timeoutEnv := os.Getenv(key)
+	if timeoutEnv != "" {
+		i, err := strconv.ParseInt(timeoutEnv, 10, 64)
+		if err == nil {
+			defaultValue = time.Second * time.Duration(i)
+		}
 	}
+	return defaultValue
 }