util.go

package util

import (
	"fmt"
	"net"
	"strings"
	"time"

	"github.com/pingcap/tidb/kv"
	"github.com/pingcap/tidb/model"
	"github.com/pingcap/tidb/types"
	"github.com/pingcap/tidb/util/logutil"
	"github.com/pkg/errors"
	log "github.com/sirupsen/logrus"
	"gopkg.in/natefinch/lumberjack.v2"
)

// DefaultIP get a default non local ip, err is not nil, ip return 127.0.0.1
func DefaultIP() (ip string, err error) {
	ip = "127.0.0.1"

	ifaces, err := net.Interfaces()
	if err != nil {
		return
	}

	for _, i := range ifaces {
		addrs, err := i.Addrs()
		if err != nil {
			continue
		}

		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}
			if ip.IsUnspecified() || ip.IsLoopback() {
				continue
			}

			ip = ip.To4()
			if ip == nil {
				continue
			}

			return ip.String(), nil
		}
	}

	err = errors.New("no ip found")
	return
}

// DefaultListenAddr returns default listen address with appointed port.
func DefaultListenAddr(port int32) string {
	defaultIP, err := DefaultIP()
	if err != nil {
		log.Infof("get default ip err: %v, use: %s", err, defaultIP)
	}
	return fmt.Sprintf("%s:%d", defaultIP, port)
}

// IsValidateListenHost judge the host is validate listen host or not.
func IsValidateListenHost(host string) bool {
	if host == "127.0.0.1" || host == "localhost" || host == "0.0.0.0" {
		return false
	}
	return true
}

// NewStdLogger return an instance of samara.StdLogger
func NewStdLogger(prefix string) *log.Entry {
	return log.StandardLogger().WithField("logger", prefix)
}

// InitLogger configures the standard logger, using the same strategy as TiDB's logger
func InitLogger(level string, logFile string, rotateBy string) {
	logutil.InitLogger(&logutil.LogConfig{
		Level: level,
		File: logutil.FileLogConfig{
			Filename:  logFile,
			LogRotate: true,
		},
	})

	// see https://github.com/natefinch/lumberjack/issues/17#issuecomment-185846531 for how to do time-based rotation
	if rotateLog, ok := log.StandardLogger().Out.(*lumberjack.Logger); ok {
		var interval time.Duration
		if rotateBy == "hour" {
			interval = time.Hour
		} else {
			interval = 24 * time.Hour
		}
		go func() {
			for range time.Tick(interval) {
				rotateLog.Rotate()
			}
		}()
	}
}

// ToColumnTypeMap return a map index by column id
func ToColumnTypeMap(columns []*model.ColumnInfo) map[int64]*types.FieldType {
	colTypeMap := make(map[int64]*types.FieldType)
	for _, col := range columns {
		colTypeMap[col.ID] = &col.FieldType
	}

	return colTypeMap
}

// RetryOnError defines a action with retry when fn returns error
func RetryOnError(retryCount int, sleepTime time.Duration, errStr string, fn func() error) error {
	var err error
	for i := 0; i < retryCount; i++ {
		err = fn()
		if err == nil {
			break
		}

		log.Errorf("%s: %v", errStr, err)
		time.Sleep(sleepTime)
	}

	return errors.Trace(err)
}

// QueryLatestTsFromPD returns the latest ts
func QueryLatestTsFromPD(tiStore kv.Storage) (int64, error) {
	version, err := tiStore.CurrentVersion()
	if err != nil {
		log.Errorf("get current version error: %v", err)
		return 0, errors.Trace(err)
	}

	return int64(version.Ver), nil
}

// AlreadyExistsf represents an error with an already exists message.
func AlreadyExistsf(format string, args ...interface{}) error {
	return errors.Errorf(format+" already exists", args...)
}

// NewNotFound wraps an error with a not found message.
func NewNotFound(err error, msg string) error {
	return errors.Annotate(err, msg+" not found")
}

// IsNotFound checks if an error is created via errors.NotFoundf.
func IsNotFound(err error) bool {
	return err != nil && strings.Contains(err.Error(), " not found")
}

// IsAlreadyExists checks if an error is created via errors.AlreadyExistsf.
func IsAlreadyExists(err error) bool {
	return err != nil && strings.Contains(err.Error(), " already exists")
}