first commit

Author: joaojeronimo

.gitignore

@@ -0,0 +1 @@
+test

LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright 2011-2012 The "Radix" Authors. All rights reserved.
+
+BSD 2-Clause License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,59 @@
+# Go Redis Cluster
+
+A [Redis](http://redis.io/) [Cluster](http://redis.io/topics/cluster-spec) Client for the Go Programming Language.
+
+(Well, not really. It's only a thin wrapper above the amazing [Radix](https://github.com/fzzbt/radix/) module. It even uses the Radix module, borrows heavily from it, and the Radix guys did 99% of the work. This is only a thin wrapper that discovers your cluster, connects to all the nodes, and does client-side sharding.)
+
+## Installing it
+
+Since this is a wrapper above Radix, you'll need to install it:
+```
+go get github.com/fzzbt/radix/redis
+```
+And then you can install Go Redis Cluster:
+```
+go get github.com/joaojeronimo/go-redis-cluster
+```
+
+## Using it
+
+You'll need the link of one member of the cluster, and the rest will be automatically discovered, and everything will be dealt with (slots, etc). After that, you can use it pretty much like you use the [Radix](https://github.com/fzzbt/radix/) module, except you cannot use the obvious commands that (a) [affect multiple keys](http://redis.io/topics/transactions) (b) [Publish/Subscribe](http://redis.io/topics/pubsub).
+
+Redis Cluster only implements a subset of the commands: "all the **single keys** commands available in the non distributed version of Redis" (read more about this in the **Implemented subset** section of the [Cluster Spec](http://redis.io/topics/cluster-spec))
+
+Other than that, it's almost exactly the same as using the Radix module, even the commands' names are the same:
+
+```go
+package main
+
+import (
+	"github.com/joaojeronimo/go-redis-cluster"
+)
+
+func main() {
+	cc := rediscluster.NewCluster("localhost:6379") // Connect to the whole cluster only knowing the link of one member
+	defer cc.Close()                                // Close it when main returns
+
+	// the usual commands:
+	cc.Hset("someHash", "someKey", "someValue")
+	theValue := cc.Hget("someHash", "someKey").String()
+	if theValue == "someValue" {
+		println("OK")
+	}
+
+	// Async stuff too:
+	cc.Sadd("someSet", "value1", "value2", "value3")
+	future := cc.AsyncScard("someSet")
+	card, err := (<-future).Int()
+	if err != nil {
+		panic(err)
+	}
+	if 3 == card {
+		println("OK")
+	}
+}
+```
+
+## Other stuff
+
+I also created a [similar module for Node.JS](https://github.com/joaojeronimo/node_redis_cluster), we use both of them in production, as well as Redis 3.0 that is unstable but passes the tests. So far so good :)

cluster.go

@@ -0,0 +1,116 @@
+package rediscluster
+
+import (
+	"github.com/fzzbt/radix/redis"
+	"github.com/joaojeronimo/go-crc16"
+	"strconv"
+	"strings"
+)
+
+func clusterSlot(key string) int {
+	return (int(crc16.Crc16(key)) % 4096)
+}
+
+type SlotInterval struct {
+	LowerLimit int
+	UpperLimit int
+}
+
+func ParseNode(unparsedNode string) (node Node) {
+	parts := strings.Split(unparsedNode, " ")
+	node.Name = parts[0]
+	node.Address = parts[1]
+	node.Flags = parts[2]
+	//node.LastPingSent, _ = strconv.Atoi(parts[4])
+	//node.LastPongReceived, _ = strconv.Atoi(parts[5])
+	node.State = parts[6]
+
+	slots := strings.Split(parts[7], "-")
+	var slotInterval SlotInterval
+	slotInterval.LowerLimit, _ = strconv.Atoi(slots[0])
+	slotInterval.UpperLimit, _ = strconv.Atoi(slots[1])
+	node.Slots = slotInterval
+	return
+}
+
+type Node struct {
+	Name             string
+	Address          string
+	Client           *redis.Client
+	Flags            string
+	LastPingSent     int
+	LastPongReceived int
+	State            string
+	Slots            SlotInterval
+}
+
+type Cluster struct {
+	nodes []Node
+}
+
+func (n *Node) Connect() {
+	conf := redis.DefaultConfig()
+	conf.Address = n.Address
+	n.Client = redis.NewClient(conf)
+}
+
+func discoverNodes(firstLink string) (cluster Cluster) {
+	conf := redis.DefaultConfig()
+	conf.Address = firstLink
+	c := redis.NewClient(conf)
+	s, err := c.Cluster("nodes").Str()
+	if err != nil {
+		return
+	}
+	unparsedNodes := strings.Split(s, "\n")
+	var parsedNodes []Node
+	for i := 0; i < len(unparsedNodes)-1; i++ { // -1 because the last line is empty
+		parsedNode := ParseNode(unparsedNodes[i])
+		if parsedNode.Address == ":0" {
+			parsedNode.Address = firstLink
+			parsedNode.Client = c
+		} else {
+			parsedNode.Connect()
+		}
+		parsedNodes = append(parsedNodes, parsedNode)
+	}
+	cluster.nodes = parsedNodes
+	return
+}
+
+func NewCluster(firstLink string) (cc Cluster) {
+	return discoverNodes(firstLink)
+}
+
+func (cc *Cluster) Call(command string, args ...interface{}) (reply *redis.Reply) {
+	slot := clusterSlot(args[0].(string))
+	var slots SlotInterval
+	for i := 0; i < len(cc.nodes); i++ {
+		slots = cc.nodes[i].Slots
+		if slot > slots.LowerLimit && slot < slots.UpperLimit {
+			reply = cc.nodes[i].Client.Call(command, args...)
+			return
+		}
+	}
+	return
+}
+
+func (cc *Cluster) AsyncCall(command string, args ...interface{}) (future redis.Future) {
+	slot := clusterSlot(args[0].(string))
+	var slots SlotInterval
+	for i := 0; i < len(cc.nodes); i++ {
+		slots = cc.nodes[i].Slots
+		if slot > slots.LowerLimit && slot < slots.UpperLimit {
+			future = cc.nodes[i].Client.AsyncCall(command, args...)
+			return
+		}
+	}
+	return
+}
+
+func (cc *Cluster) Close() bool {
+	for i := 0; i < len(cc.nodes); i++ {
+		cc.nodes[i].Client.Close()
+	}
+	return true
+}