Work around Hashing and tests (#2)

* Work around Hashing and tests

* fixes

* add TravisCI

* fix lint

* so slow

* add badges

* work on README

* Improved tests and get rid of fnv (#3)

Author: im-kulikov

.travis.yml

@@ -0,0 +1,16 @@
+language: go
+go:
+  - 1.11.x
+env:
+  - GO111MODULE=on
+install:
+  - go get -v golang.org/x/lint/golint
+  - go mod tidy -v
+script:
+  - golint -set_exit_status ./...
+  - go test -race -coverprofile=coverage.txt -covermode=atomic ./...
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
+matrix:
+  allow_failures:
+    - go: tip

README.md

@@ -1 +1,56 @@
-# Golang simple HRW implementation
+# Golang HRW implementation
+
+[![Build Status](https://travis-ci.org/im-kulikov/hrw.svg?branch=master)](https://travis-ci.org/im-kulikov/hrw)
+[![codecov](https://codecov.io/gh/im-kulikov/hrw/badge.svg)](https://codecov.io/gh/im-kulikov/hrw)
+[![Report](https://goreportcard.com/badge/github.com/im-kulikov/hrw)](https://goreportcard.com/report/github.com/im-kulikov/hrw)
+[![GitHub release](https://img.shields.io/github/release/im-kulikov/hrw.svg)](https://github.com/im-kulikov/hrw)
+
+[Rendezvous or highest random weight](https://en.wikipedia.org/wiki/Rendezvous_hashing) (HRW) hashing is an algorithm that allows clients to achieve distributed agreement on a set of k options out of a possible set of n options. A typical application is when clients need to agree on which sites (or proxies) objects are assigned to. When k is 1, it subsumes the goals of consistent hashing, using an entirely different method.
+
+## Install
+
+`go get github.com/im-kulikov/hrw`
+
+## Example
+
+```go
+package main
+
+import (
+	"fmt"
+	
+	"github.com/im-kulikov/hrw"
+)
+
+func main() {
+	// given a set of servers
+	servers := []string{
+		"one.example.com",
+		"two.example.com",
+		"three.example.com",
+		"four.example.com",
+		"five.example.com",
+		"six.example.com",
+	}
+
+	// HRW can consistently select a uniformly-distributed set of servers for
+	// any given key
+	var (
+		key = []byte("/examples/object-key")
+		h   = hrw.Hash(key)
+	)
+
+	hrw.SortSliceByValue(servers, h)
+	for id := range servers {
+		fmt.Printf("trying GET %s%s\n", servers[id], key)
+	}
+
+	// Output:
+	// trying GET four.example.com/examples/object-key
+	// trying GET three.example.com/examples/object-key
+	// trying GET one.example.com/examples/object-key
+	// trying GET two.example.com/examples/object-key
+	// trying GET six.example.com/examples/object-key
+	// trying GET five.example.com/examples/object-key
+}
+```

go.mod

@@ -1,3 +1,3 @@
 module github.com/im-kulikov/hrw
 
-require github.com/reusee/mmh3 v0.0.0-20140820141314-64b85163255b
+require github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72

go.sum

@@ -1,2 +1,2 @@
-github.com/reusee/mmh3 v0.0.0-20140820141314-64b85163255b h1:GQkEnyBFqzQXb3RFqGt5z2QcBZJVQxgzXKF/sPCFh7w=
-github.com/reusee/mmh3 v0.0.0-20140820141314-64b85163255b/go.mod h1:ADBBIMrt68BC/v967NyoiPZMwPVq44r8QJ5oRyXJHJs=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=

hrw.go

@@ -3,16 +3,17 @@
 package hrw
 
 import (
-	"errors"
-	"hash/fnv"
+	"encoding/binary"
 	"reflect"
 	"sort"
-	"strconv"
+
+	"github.com/spaolacci/murmur3"
 )
 
 type (
 	swapper func(i, j int)
 
+	// Hasher interface used by SortSliceByValue
 	Hasher interface{ Hash() uint64 }
 
 	hashed struct {
@@ -38,6 +39,12 @@ func (h hashed) Len() int           { return h.length }
 func (h hashed) Less(i, j int) bool { return h.weight[h.sorted[i]] < h.weight[h.sorted[j]] }
 func (h hashed) Swap(i, j int)      { h.sorted[i], h.sorted[j] = h.sorted[j], h.sorted[i] }
 
+// Hash uses murmur3 hash to return uint64
+func Hash(key []byte) uint64 {
+	return murmur3.Sum64(key)
+}
+
+// SortByWeight receive nodes and hash, and sort it by weight
 func SortByWeight(nodes []uint64, hash uint64) []uint64 {
 	var (
 		l = len(nodes)
@@ -57,10 +64,11 @@ func SortByWeight(nodes []uint64, hash uint64) []uint64 {
 	return h.sorted
 }
 
-func SortSliceByValue(slice interface{}, hash uint64) error {
+// SortSliceByValue received []T and hash to sort by value-weight
+func SortSliceByValue(slice interface{}, hash uint64) {
 	t := reflect.TypeOf(slice)
 	if t.Kind() != reflect.Slice {
-		return errors.New("must be slice")
+		return
 	}
 
 	var (
@@ -71,29 +79,24 @@ func SortSliceByValue(slice interface{}, hash uint64) error {
 	)
 
 	if length == 0 {
-		return nil
+		return
 	}
 
 	switch slice := slice.(type) {
 	case []int:
-		hasher := fnv.New64()
+		var key = make([]byte, 16)
 		for i := 0; i < length; i++ {
-			hasher.Reset()
-			// error always nil
-			_, _ = hasher.Write([]byte(strconv.Itoa(slice[i])))
-			rule = append(rule, weight(hash, hasher.Sum64()))
+			binary.BigEndian.PutUint64(key, uint64(slice[i]))
+			rule = append(rule, weight(Hash(key), hash))
 		}
 	case []string:
-		hasher := fnv.New64()
 		for i := 0; i < length; i++ {
-			hasher.Reset()
-			// error always nil
-			_, _ = hasher.Write([]byte(slice[i]))
-			rule = append(rule, weight(hash, hasher.Sum64()))
+			rule = append(rule, weight(hash,
+				Hash([]byte(slice[i]))))
 		}
 	default:
 		if _, ok := val.Index(0).Interface().(Hasher); !ok {
-			return errors.New("unknown type")
+			return
 		}
 
 		for i := 0; i < length; i++ {
@@ -103,36 +106,44 @@ func SortSliceByValue(slice interface{}, hash uint64) error {
 	}
 
 	rule = SortByWeight(rule, hash)
-	sortByRule(swap, uint64(length), rule)
-
-	return nil
+	sortByRuleInverse(swap, uint64(length), rule)
 }
 
+// SortSliceByIndex received []T and hash to sort by index-weight
 func SortSliceByIndex(slice interface{}, hash uint64) {
 	length := uint64(reflect.ValueOf(slice).Len())
 	swap := reflect.Swapper(slice)
-
 	rule := make([]uint64, 0, length)
 	for i := uint64(0); i < length; i++ {
 		rule = append(rule, i)
 	}
-
 	rule = SortByWeight(rule, hash)
-	sortByRule(swap, length, rule)
+	sortByRuleInverse(swap, length, rule)
 }
 
-func sortByRule(swap swapper, length uint64, rule []uint64) {
+func sortByRuleDirect(swap swapper, length uint64, rule []uint64) {
 	done := make([]bool, length)
 	for i := uint64(0); i < length; i++ {
 		if done[i] {
 			continue
 		}
-
-		done[i] = true
-
 		for j := rule[i]; !done[rule[j]]; j = rule[j] {
 			swap(int(i), int(j))
 			done[j] = true
 		}
 	}
 }
+
+func sortByRuleInverse(swap swapper, length uint64, rule []uint64) {
+	done := make([]bool, length)
+	for i := uint64(0); i < length; i++ {
+		if done[i] {
+			continue
+		}
+
+		for j := i; !done[rule[j]]; j = rule[j] {
+			swap(int(j), int(rule[j]))
+			done[j] = true
+		}
+	}
+}