sequence

In this paper, we study the dubbo – go ConsistentHashLoadBalance

ConsistentHashLoadBalance

Dubbo – go – v1.4.2 / cluster/loadbalance consistent_hash. Go

const (
	// ConsistentHash ...
	ConsistentHash = "consistenthash"
	// HashNodes ...
	HashNodes = "hash.nodes"
	// HashArguments ...
	HashArguments = "hash.arguments"
)

var (
	selectors = make(map[string]*ConsistentHashSelector)
	re        = regexp.MustCompile(constant.COMMA_SPLIT_PATTERN)
)

func init() {
	extension.SetLoadbalance(ConsistentHash, NewConsistentHashLoadBalance)
}

// ConsistentHashLoadBalance ...
type ConsistentHashLoadBalance struct {
}

// NewConsistentHashLoadBalance ...
func NewConsistentHashLoadBalance() cluster.LoadBalance {
	return &ConsistentHashLoadBalance{}
}
Copy the code
  • ConsistentHashLoadBalance init method set up called consistenthash ConsistentHashLoadBalance into the extension

Select

Dubbo – go – v1.4.2 / cluster/loadbalance consistent_hash. Go

// Select ... func (lb *ConsistentHashLoadBalance) Select(invokers []protocol.Invoker, invocation protocol.Invocation) protocol.Invoker { methodName := invocation.MethodName() key := invokers[0].GetUrl().ServiceKey() + "." + methodName // hash the invokers bs := make([]byte, 0) for _, invoker := range invokers { b, err := json.Marshal(invoker) if err ! = nil { return nil } bs = append(bs, b...) } hashCode := crc32.ChecksumIEEE(bs) selector, ok := selectors[key] if ! ok || selector.hashCode ! = hashCode { selectors[key] = newConsistentHashSelector(invokers, methodName, hashCode) selector = selectors[key] } return selector.Select(invocation) }Copy the code
  • Json.marshal (invoker) executes json.marshal (invoker) one by one, adds bytes[] to bs, and calculates hashCode through crc32.checkSumIEEE (BS). Then compare the selectors [key] hashCode and calculated hashCode are consistent, inconsistent by newConsistentHashSelector resetting a, finally implement the selector. The Select (invocation)

ConsistentHashSelector

Dubbo – go – v1.4.2 / cluster/loadbalance consistent_hash. Go

// ConsistentHashSelector ...
type ConsistentHashSelector struct {
	hashCode        uint32
	replicaNum      int
	virtualInvokers map[uint32]protocol.Invoker
	keys            Uint32Slice
	argumentIndex   []int
}
Copy the code
  • ConsistentHashSelector defines the hashCode, replicaNum, virtualInvokers, keys, and argumentIndex attributes

newConsistentHashSelector

Dubbo – go – v1.4.2 / cluster/loadbalance consistent_hash. Go

func newConsistentHashSelector(invokers []protocol.Invoker, methodName string, hashCode uint32) *ConsistentHashSelector { selector := &ConsistentHashSelector{} selector.virtualInvokers = make(map[uint32]protocol.Invoker) selector.hashCode = hashCode url := invokers[0].GetUrl() selector.replicaNum = int(url.GetMethodParamInt(methodName, HashNodes, 160)) indices := re.Split(url.GetMethodParam(methodName, HashArguments, "0"), -1) for _, index := range indices { i, err := strconv.Atoi(index) if err ! = nil { return nil } selector.argumentIndex = append(selector.argumentIndex, i) } for _, invoker := range invokers { u := invoker.GetUrl() address := u.Ip + ":" + u.Port for i := 0; i < selector.replicaNum/4; i++ { digest := md5.Sum([]byte(address + strconv.Itoa(i))) for j := 0; j < 4; j++ { key := selector.hash(digest, j) selector.keys = append(selector.keys, key) selector.virtualInvokers[key] = invoker } } } sort.Sort(selector.keys) return selector }Copy the code
  • Instantiation ConsistentHashSelector newConsistentHashSelector method, and initialize virtualInvokers, hashCode, argumentIndex, keys, virtualInvokers properties

Select

Dubbo – go – v1.4.2 / cluster/loadbalance consistent_hash. Go

// Select ... func (c *ConsistentHashSelector) Select(invocation protocol.Invocation) protocol.Invoker { key := c.toKey(invocation.Arguments()) digest := md5.Sum([]byte(key)) return c.selectForKey(c.hash(digest, 0)) } func (c *ConsistentHashSelector) toKey(args []interface{}) string { var sb strings.Builder for i := range c.argumentIndex { if i >= 0 && i < len(args) { fmt.Fprint(&sb, args[i].(string)) } } return sb.String() } func (c *ConsistentHashSelector) selectForKey(hash uint32) protocol.Invoker {  idx := sort.Search(len(c.keys), func(i int) bool { return c.keys[i] >= hash }) if idx == len(c.keys) { idx = 0 } return c.virtualInvokers[c.keys[idx]] }  func (c *ConsistentHashSelector) hash(digest [16]byte, i int) uint32 { return uint32((digest[3+i*4]&0xFF)<<24) | uint32((digest[2+i*4]&0xFF)<<16) | uint32((digest[1+i*4]&0xFF)<<8) | uint32(digest[i*4]&0xFF)&0xFFFFFFF }Copy the code
  • The Select method obtains the key from the C. Key(Invocation.Arguments()) invocation and calculates the digest from the MD5.sum ([]byte(key)) Finally, select Invoker with c.select for Key(C. Hash (Digest, 0))

summary

ConsistentHashLoadBalance Select method of traverse invokers each execution json. Marshal (invoker), will be bytes [] added to the bs, Crc32.checksumieee (BS) calculates the hashCode and compares the calculated hashCode by the selectors[key]. Inconsistent by newConsistentHashSelector resetting a, finally implement the selector. Select (invocation)

doc

  • consistent_hash