debug

zhangqian

2023-12-08 84fb8e390b83dc9482524c12d7af6c93405c3fc1

 pkg/snowflake/snowflake.go

@@ -2,61 +2,189 @@

import (
   "apsClient/pkg/logx"
   "errors"
   "fmt"
   "github.com/bwmarrin/snowflake"
   "hash/fnv"
   "net"
   "strconv"
   "sync"
   "time"
)

var Node *snowflake.Node
var idGenerater *IdWorker

func Init(nodeId string) error {
   // Create a new Node with a Node number of 1
   var err error
   nodeIdInt, err := StringToNumber(nodeId)
func init() {
   // 使用 LookupIP 获取主机的 IP 地址列表
   // 获取本机所有网络接口
   interfaces, err := net.Interfaces()
   if err != nil {
      logx.Errorf("snowflake Init error:%v", err)
      return err
      logx.Errorf("snowflake InitWithIP error:%v", err)
      return
   }
   Node, err = snowflake.NewNode(nodeIdInt)

   var ip string
   // 遍历所有网络接口
   for _, iface := range interfaces {
      // 排除一些特殊的接口，例如 loopback 接口
      if iface.Flags&net.FlagUp != 0 && iface.Flags&net.FlagLoopback == 0 {
         // 获取接口的所有地址
         addrs, err := iface.Addrs()
         if err != nil {
            logx.Errorf("snowflake InitWithIP error:%v", err)
            continue
         }
         // 遍历接口的所有地址
         for _, addr := range addrs {
            // 检查地址类型是否是 IP 地址
            if ipNet, ok := addr.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
               // 判断 IP 地址的版本是 IPv4 还是 IPv6
               if ipNet.IP.To4() != nil {
                  fmt.Printf("IPv4 Address: %s\n", ipNet.IP.String())
                  if ipNet.IP.String() != "127.0.0.1" {
                     ip = ipNet.IP.String()
                     goto getIpOK
                  }
               } else {
                  fmt.Printf("IPv6 Address: %s\n", ipNet.IP.String())
               }
            }
         }
      }
   }
getIpOK:
   if ip == "" {
      logx.Errorf("snowflake InitWithIP can not find Ip")
      return
   }
   ipNumber, err := ipToNumber(ip)
   if err != nil {
      logx.Errorf("snowflake NewNode error:%v", err)
      return err
      logx.Errorf("snowflake can not generate, init error, ip to number error :%v", err)
      panic(fmt.Sprintf("snowflake can not generate, init error, ip to number error :%v", err))
   }
   return nil
   idGenerater, err = NewIdWorker(ipNumber)
   if err != nil {
      logx.Errorf("snowflake can not generate, init error :%v", err)
      panic(fmt.Sprintf("snowflake can not generate, init error :%v", err))
   }
}

func StringToNumber(input string) (int64, error) {
func ipToNumber(ip string) (int64, error) {
   // 将 IP 地址字符串解析为 net.IP 类型
   parsedIP := net.ParseIP(ip)
   if parsedIP == nil {
      return 0, fmt.Errorf("invalid IP address:%v", ip)
   }

   // 使用 FNV-1a 散列算法计算哈希值
   hash := fnv.New32a()
   _, err := hash.Write([]byte(input))
   if err != nil {
   hash.Write(parsedIP)
   return int64(hash.Sum32() % 1024), nil // 取余数确保结果在 1 到 1023 之间
}

const (
   CEpoch         = 1474802888000
   CWorkerIdBits  = 10 // Num of WorkerId Bits
   CSenquenceBits = 12 // Num of Sequence Bits

   CWorkerIdShift  = 12
   CTimeStampShift = 22

   CSequenceMask = 0xfff // equal as getSequenceMask()
   CMaxWorker    = 0x3ff // equal as getMaxWorkerId()
)

type IdWorker struct {
   workerId      int64
   lastTimeStamp int64
   sequence      int64
   maxWorkerId   int64
   lock          *sync.Mutex
}

func NewIdWorker(workerId int64) (iw *IdWorker, err error) {
   iw = new(IdWorker)

   iw.maxWorkerId = getMaxWorkerId()

   if workerId > iw.maxWorkerId || workerId < 0 {
      return nil, errors.New("worker not fit")
   }
   iw.workerId = workerId
   iw.lastTimeStamp = -1
   iw.sequence = 0
   iw.lock = new(sync.Mutex)
   return iw, nil
}

func getMaxWorkerId() int64 {
   return -1 ^ -1<<CWorkerIdBits
}

func getSequenceMask() int64 {
   return -1 ^ -1<<CSenquenceBits
}

// return in ms
func (iw *IdWorker) timeGen() int64 {
   return time.Now().UnixNano() / 1000 / 1000
}

func (iw *IdWorker) timeReGen(last int64) int64 {
   ts := time.Now().UnixNano() / 1000 / 1000
   for {
      if ts <= last {
         ts = iw.timeGen()
      } else {
         break
      }
   }
   return ts
}

func (iw *IdWorker) NextId() (ts int64, err error) {
   iw.lock.Lock()
   defer iw.lock.Unlock()
   ts = iw.timeGen()
   if ts == iw.lastTimeStamp {
      iw.sequence = (iw.sequence + 1) & CSequenceMask
      if iw.sequence == 0 {
         ts = iw.timeReGen(ts)
      }
   } else {
      iw.sequence = 0
   }

   if ts < iw.lastTimeStamp {
      err = errors.New("Clock moved backwards, Refuse gen id")
      return 0, err
   }
   hashValue := int64(hash.Sum32())
   return hashValue, nil
   iw.lastTimeStamp = ts
   ts = (ts-CEpoch)<<CTimeStampShift | iw.workerId<<CWorkerIdShift | iw.sequence
   return ts, nil
}

func ParseId(id int64) (t time.Time, ts int64, workerId int64, seq int64) {
   seq = id & CSequenceMask
   workerId = (id >> CWorkerIdShift) & CMaxWorker
   ts = (id >> CTimeStampShift) + CEpoch
   t = time.Unix(ts/1000, (ts%1000)*1000000)
   return
}

func GenerateID() int64 {
   if Node == nil {
      // 使用 LookupIP 获取主机的 IP 地址列表
      addrs, err := net.LookupIP("localhost")
      if err != nil {
         logx.Infof("snowflake can not generate, init error, get ip error:%v", err)
         panic(fmt.Sprintf("snowflake can not generate, init error, get ip error:%v", err))
      }
      var ip string
      // 遍历 IP 地址列表
      for _, addr := range addrs {
         // 判断 IP 地址的版本是 IPv4 还是 IPv6
         if ipNet := addr.To4(); ipNet != nil {
            ip = ipNet.String()
            fmt.Printf("IPv4 Address: %s\n", ipNet.String())
         }
      }
      err = Init(ip)
      if err != nil {
         panic(fmt.Sprintf("snowflake can not generate, init error,:%v", err))
      }
start:
   id, err := idGenerater.NextId()
   if err != nil {
      goto start
   }
   return int64(Node.Generate())
   return id
}

func GenerateIdStr() string {
start:
   id, err := idGenerater.NextId()
   if err != nil {
      goto start
   }
   return strconv.FormatInt(id, 10)
}