架构师课程第五周 作业

package consistenthash
//https://github.com/golang/groupcache/blob/master/consistenthash/consistenthash.go
import (
	"hash/crc32"
	"sort"
	"strconv"
)
// Hash comment
type Hash func(data []byte) uint32
// Map struct
type Map struct {
	hash     Hash
	replicas int
	keys     []int // Sorted
	hashMap  map[int]string
}
// New for create Map struct
func New(replicas int) *Map {
	m := &Map{
		replicas: replicas,
		hash:     crc32.ChecksumIEEE,
		hashMap:  make(map[int]string),
	}
	return m
}
// Add some keys to the hash.
func (m *Map) Add(keys ...string) {
	for _, key := range keys {
		for i := 0; i < m.replicas; i++ {
			hash := int(m.hash([]byte(strconv.Itoa(i) + key)))
			m.keys = append(m.keys, hash)
			m.hashMap[hash] = key
		}
	}
	sort.Ints(m.keys)
}
// Remove keys from the hash
func (m *Map) Remove(keys ...string) {
	for _, key := range keys {
		for i := 0; i < m.replicas; i++ {
			hash := int(m.hash([]byte(strconv.Itoa(i) + key)))
			if _, ok := m.hashMap[hash]; ok {
				delete(m.hashMap, hash)
			}
			for k, v := range m.keys {
				if v == hash {
					m.keys = append(m.keys[:k], m.keys[k+1:]...)
				}
			}
		}
	}
}
// Get gets the closest item in the hash to the provided key.
func (m *Map) Get(key string) string {
	hash := int(m.hash([]byte(key)))
	// Binary search for appropriate replica.
	idx := sort.Search(len(m.keys), func(i int) bool { return m.keys[i] >= hash })
	// Means we have cycled back to the first replica.
	if idx == len(m.keys) {
		idx = 0
	}
  
	return m.hashMap[m.keys[idx]]
}

package main
import (
	"fmt"
	redis "github.com/go-redis/redis/v7"
	"os"
	"test5/consistenthash"
	"time"
)
const VNUM int = 160
func Get(k string, node string) string {
	rdb := redis.NewClient(&redis.Options{
		Addr: node,
	})
	defer rdb.Close()
	rsp := rdb.Get(k)
	return rsp.Val()
}
func Set(v map[string]string, node string) string {
	rdb := redis.NewClient(&redis.Options{
		Addr: node,
	})
	defer rdb.Close()
	rsp := rdb.Set(v["key"], v["value"], time.Duration(3600)*time.Second)
	return rsp.Val()
}
func main() {
	var rsp string
	NODE := []string{
		"127.0.0.1:7000",
		"127.0.0.1:7001",
		"127.0.0.1:7002",
		"127.0.0.1:7003",
		"127.0.0.1:7004",
		"127.0.0.1:7005",
		"127.0.0.1:7006",
		"127.0.0.1:7007",
		"127.0.0.1:7008",
		"127.0.0.1:7009",
	}
	h := consistenthash.New(VNUM)
	h.Add(NODE...)
	lag := os.Args
	method := lag[1]
	key := lag[2]
	node := h.Get(key)
	if method == "set" {
		v := make(map[string]string)
		v["key"] = lag[2]
		v["value"] = lag[3]
		rsp = Set(v, node)
	}
	if method == "get" {
		rsp = Get(lag[2], node)
	}
	fmt.Println(rsp)
}

package consistenthash
import (
	"crypto/rand"
	"fmt"
	"github.com/grd/statistics"
	"math/big"
	"strconv"
	"testing"
)
func TestStandardDeviation(t *testing.T) {
	var data statistics.Int64
	m := make(map[int]int64)
	hash := New(160)
	hash.Add("121", "35677", "212", "7019", "2245", "156", "21", "6", "111", "10345")
	for i := 0; i < 1000000; i++ {
		j, _ := rand.Int(rand.Reader, big.NewInt(100000))
		k, _ := strconv.Atoi(hash.Get(string(j.Int64())))
		m[k]++
	}
	for _, v := range m {
		data = append(data, v)
	}
	sd := statistics.Sd(&data)
	fmt.Printf("Sd: %v\n", sd)
	fmt.Println("Distribution", data)
}

Sd: 10768.69476254615
Distribution [104362 91171 98839 81994 117707 86753 104651 100618 109544 104361]
PASS
ok  	test5/consistenthash	1.738s