diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..298bed9b
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2013 The github.com/go-redis/redis Authors.
+All rights reserved.
+
+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
+OWNER 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.
diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..50fdc55a
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,19 @@
+all: testdeps
+	go test ./...
+	go test ./... -short -race
+	go vet
+
+testdeps: testdata/redis/src/redis-server
+
+bench: testdeps
+	go test ./... -test.run=NONE -test.bench=. -test.benchmem
+
+.PHONY: all test testdeps bench
+
+testdata/redis:
+	mkdir -p $@
+	wget -qO- https://github.com/antirez/redis/archive/unstable.tar.gz | tar xvz --strip-components=1 -C $@
+
+testdata/redis/src/redis-server: testdata/redis
+	sed -i 's/libjemalloc.a/libjemalloc.a -lrt/g' $</src/Makefile
+	cd $< && make all
diff --git a/README.md b/README.md
index 11782513..32877e68 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,142 @@
-Single core absolute fair environment set get bench: redis overall performance faster than xredis 10%  qps （because STL costs 10%） cd xredis/src/ make ./redis-server 127.0.0.1 6379 0 0 0
-xredis is s c++   compatible with redis or hiredis_client multithreading  , in-memory data structure store, used as a database, cache  It supports data structures such as set get hset hget hkeys keys  hgetall dbsize flushdb sync slaveof save quit info auth config  zadd zrange sadd scard zrevragne publish unsubscribe subscribe  detailed test method reference redis benchmark https://redis.io/topics/benchmarks  https://stackoverflow.com/questions/2873249/is-memcached-a-dinosaur-in-comparison-to-redis 
+# Redis client for Golang
 
+[![Build Status](https://travis-ci.org/go-redis/redis.png?branch=master)](https://travis-ci.org/go-redis/redis)
+[![GoDoc](https://godoc.org/github.com/go-redis/redis?status.svg)](https://godoc.org/github.com/go-redis/redis)
+
+Supports:
+
+- Redis 3 commands except QUIT, MONITOR, SLOWLOG and SYNC.
+- Automatic connection pooling with [circuit breaker](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern) support.
+- [Pub/Sub](https://godoc.org/github.com/go-redis/redis#PubSub).
+- [Transactions](https://godoc.org/github.com/go-redis/redis#Multi).
+- [Pipeline](https://godoc.org/github.com/go-redis/redis#example-Client-Pipeline) and [TxPipeline](https://godoc.org/github.com/go-redis/redis#example-Client-TxPipeline).
+- [Scripting](https://godoc.org/github.com/go-redis/redis#Script).
+- [Timeouts](https://godoc.org/github.com/go-redis/redis#Options).
+- [Redis Sentinel](https://godoc.org/github.com/go-redis/redis#NewFailoverClient).
+- [Redis Cluster](https://godoc.org/github.com/go-redis/redis#NewClusterClient).
+- [Ring](https://godoc.org/github.com/go-redis/redis#NewRing).
+- [Instrumentation](https://godoc.org/github.com/go-redis/redis#ex-package--Instrumentation).
+- [Cache friendly](https://github.com/go-redis/cache).
+- [Rate limiting](https://github.com/go-redis/rate).
+- [Distributed Locks](https://github.com/bsm/redis-lock).
+
+API docs: https://godoc.org/github.com/go-redis/redis.
+Examples: https://godoc.org/github.com/go-redis/redis#pkg-examples.
+
+## Installation
+
+Install:
+
+```shell
+go get -u github.com/go-redis/redis
+```
+
+Import:
+
+```go
+import "github.com/go-redis/redis"
+```
+
+## Quickstart
+
+```go
+func ExampleNewClient() {
+	client := redis.NewClient(&redis.Options{
+		Addr:     "localhost:6379",
+		Password: "", // no password set
+		DB:       0,  // use default DB
+	})
+
+	pong, err := client.Ping().Result()
+	fmt.Println(pong, err)
+	// Output: PONG <nil>
+}
+
+func ExampleClient() {
+	err := client.Set("key", "value", 0).Err()
+	if err != nil {
+		panic(err)
+	}
+
+	val, err := client.Get("key").Result()
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println("key", val)
+
+	val2, err := client.Get("key2").Result()
+	if err == redis.Nil {
+		fmt.Println("key2 does not exists")
+	} else if err != nil {
+		panic(err)
+	} else {
+		fmt.Println("key2", val2)
+	}
+	// Output: key value
+	// key2 does not exists
+}
+```
+
+## Howto
+
+Please go through [examples](https://godoc.org/github.com/go-redis/redis#pkg-examples) to get an idea how to use this package.
+
+## Look and feel
+
+Some corner cases:
+
+    SET key value EX 10 NX
+    set, err := client.SetNX("key", "value", 10*time.Second).Result()
+
+    SORT list LIMIT 0 2 ASC
+    vals, err := client.Sort("list", redis.Sort{Offset: 0, Count: 2, Order: "ASC"}).Result()
+
+    ZRANGEBYSCORE zset -inf +inf WITHSCORES LIMIT 0 2
+    vals, err := client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
+        Min: "-inf",
+        Max: "+inf",
+        Offset: 0,
+        Count: 2,
+    }).Result()
+
+    ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3 AGGREGATE SUM
+    vals, err := client.ZInterStore("out", redis.ZStore{Weights: []int64{2, 3}}, "zset1", "zset2").Result()
+
+    EVAL "return {KEYS[1],ARGV[1]}" 1 "key" "hello"
+    vals, err := client.Eval("return {KEYS[1],ARGV[1]}", []string{"key"}, "hello").Result()
+
+## Benchmark
+
+go-redis vs redigo:
+
+```
+BenchmarkSetGoRedis10Conns64Bytes-4 	  200000	      7621 ns/op	     210 B/op	       6 allocs/op
+BenchmarkSetGoRedis100Conns64Bytes-4	  200000	      7554 ns/op	     210 B/op	       6 allocs/op
+BenchmarkSetGoRedis10Conns1KB-4     	  200000	      7697 ns/op	     210 B/op	       6 allocs/op
+BenchmarkSetGoRedis100Conns1KB-4    	  200000	      7688 ns/op	     210 B/op	       6 allocs/op
+BenchmarkSetGoRedis10Conns10KB-4    	  200000	      9214 ns/op	     210 B/op	       6 allocs/op
+BenchmarkSetGoRedis100Conns10KB-4   	  200000	      9181 ns/op	     210 B/op	       6 allocs/op
+BenchmarkSetGoRedis10Conns1MB-4     	    2000	    583242 ns/op	    2337 B/op	       6 allocs/op
+BenchmarkSetGoRedis100Conns1MB-4    	    2000	    583089 ns/op	    2338 B/op	       6 allocs/op
+BenchmarkSetRedigo10Conns64Bytes-4  	  200000	      7576 ns/op	     208 B/op	       7 allocs/op
+BenchmarkSetRedigo100Conns64Bytes-4 	  200000	      7782 ns/op	     208 B/op	       7 allocs/op
+BenchmarkSetRedigo10Conns1KB-4      	  200000	      7958 ns/op	     208 B/op	       7 allocs/op
+BenchmarkSetRedigo100Conns1KB-4     	  200000	      7725 ns/op	     208 B/op	       7 allocs/op
+BenchmarkSetRedigo10Conns10KB-4     	  100000	     18442 ns/op	     208 B/op	       7 allocs/op
+BenchmarkSetRedigo100Conns10KB-4    	  100000	     18818 ns/op	     208 B/op	       7 allocs/op
+BenchmarkSetRedigo10Conns1MB-4      	    2000	    668829 ns/op	     226 B/op	       7 allocs/op
+BenchmarkSetRedigo100Conns1MB-4     	    2000	    679542 ns/op	     226 B/op	       7 allocs/op
+```
+
+Redis Cluster:
+
+```
+BenchmarkRedisPing-4                	  200000	      6983 ns/op	     116 B/op	       4 allocs/op
+BenchmarkRedisClusterPing-4         	  100000	     11535 ns/op	     117 B/op	       4 allocs/op
+```
+
+## See also
+
+- [Golang PostgreSQL ORM](https://github.com/go-pg/pg)
+- [Golang msgpack](https://github.com/vmihailenco/msgpack)
+- [Golang message task queue](https://github.com/go-msgqueue/msgqueue)
diff --git a/bench/client.cpp b/bench/client.cpp
deleted file mode 100755
index 7b769cdd..00000000
--- a/bench/client.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-#pragma once
-#include "all.h"
-
-#include "xTcpClient.h"
-#include "xTcpconnection.h"
-#include "xThreadPool.h"
-#include "xCurrentThread.h"
-#include "xLog.h"
-
-
-class client;
-
-class session:noncopyable
-{
-public:
-	session(xEventLoop *loop,
-		const char *ip,uint16_t port,client *owner)
-		:cli(loop,nullptr),
-		ip(ip),
-		port(port),
-		owner(owner),
-		bytesRead(0),
-		bytesWritten(0),
-		messagesRead(0)
-	{
-		cli.setConnectionCallback(std::bind(&session::connCallBack, this, std::placeholders::_1, std::placeholders::_2));
-		cli.setMessageCallback(std::bind(&session::readCallBack, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
-		cli.setConnectionErrorCallBack(std::bind(&session::connErrorCallBack, this));
-	}
-
-	void start()
-	{
-		cli.connect(ip,port);
-	}
-	void stop()
-	{
-		cli.disconnect();
-	}
-
-
-	int64_t getBytesRead() {  return bytesRead; }
-	int64_t getMessagesRead() { return messagesRead; }
-	
-private:
-
-	void connCallBack(const xTcpconnectionPtr& conn, void *data);
-	void connErrorCallBack()
-	{	
-		//LOG_WARN<<"tcp connect failure";
-	}
-
-	void readCallBack(const xTcpconnectionPtr& conn, xBuffer* buf, void *data)
-	{
-		++messagesRead;
-		bytesRead +=  buf->readableBytes();
-		bytesWritten +=  buf->readableBytes();
-		conn->send(buf);
-		buf->retrieveAll();
-	}
-	
-	xTcpClient cli;
-	const char *ip;
-	uint16_t port;
-	client * owner;
-	int64_t bytesRead;
-	int64_t bytesWritten;
-	int64_t messagesRead;
-  
-};
-
-class client:noncopyable
-{
-public:
-	client(xEventLoop *loop,const char *ip,uint16_t port,int blockSize,int sessionCount,
-		int timeOut,int threadCount)
-		:loop(loop),
-		threadPool(loop),
-		sessionCount(sessionCount),
-		timeOut(timeOut)
-	{
-		loop->runAfter(timeOut,nullptr,false, std::bind(&client::handlerTimeout, this,std::placeholders::_1));
-		if(threadCount > 1)
-		{
-			threadPool.setThreadNum(threadCount);
-		}
-		threadPool.start();
-
-		for(int i = 0; i < blockSize; i ++)
-		{
-			message.push_back(static_cast<char>(i % 128));
-		}
-
-		for(int i = 0 ; i < sessionCount; i ++)
-		{
-			std::shared_ptr<session> vsession (new session(threadPool.getNextLoop(),ip,port,this));
-			vsession->start();
-     			sessions.push_back(vsession);
-			numConencted++;
-		}
-	}
-
-	void onConnect()
-	{
-		if (numConencted  == sessionCount)
-		{
-			LOG_WARN << "all connected";
-		}
-	}
-
-	 
-	void onDisconnect(const xTcpconnectionPtr& conn)
-	{
-		numConencted--;
-		if (numConencted  == 0)
-		{
-			LOG_WARN << "all disconnected";
-
-			int64_t totalBytesRead = 0;
-			int64_t totalMessagesRead = 0;
-			for(auto it = sessions.begin(); it != sessions.end(); ++it)
-			{
-				totalBytesRead += (*it)->getBytesRead();
-				totalMessagesRead += (*it)->getMessagesRead();
-			}
-			LOG_WARN << totalBytesRead << " total bytes read";
-			LOG_WARN << totalMessagesRead << " total messages read";
-			LOG_WARN << static_cast<double>(totalBytesRead) / static_cast<double>(totalMessagesRead)<< " average message size";
-			LOG_WARN << static_cast<double>(totalBytesRead) / (timeOut * 1024 * 1024) << " MiB/s throughput";
-			conn->getLoop()->queueInLoop(std::bind(&client::quit, this));
-		}
-	}
-
-
-	const std::string &getMessage()const
-	{
-		return message;
-	}
-private:
-	void quit()
-	{
-		loop->queueInLoop(std::bind(&xEventLoop::quit,loop));
-		
-	}
-
-	void handlerTimeout(void * data)
-	{
-		 LOG_WARN << "stop";
-		 std::for_each(sessions.begin(),sessions.end(),std::mem_fn(&session::stop));
-	}
-	
-	xEventLoop *loop;
-	xThreadPool threadPool;
-	int sessionCount;
-	int timeOut;
-	std::vector<std::shared_ptr<session>> sessions;
-	std::string message;
-	std::atomic<int> numConencted;
-};
-
-
-void session::connCallBack(const xTcpconnectionPtr & conn,void * data)
-{
-	if (conn->connected())
-	{
-		conn->send(owner->getMessage());
-		owner->onConnect();
-	}
-	else
-	{
-		owner->onDisconnect(conn);
-	}
-}
-
-
-int main(int argc,char * argv[])
-{
-	if (argc != 7)
-	{
-		fprintf(stderr, "Usage: client <host_ip> <port> <threads> <blocksize> ");
-		fprintf(stderr, "<sessions> <time>\n");
-	}
-	else
-	{			
-		LOG_INFO << "ping pong client pid = " << getpid() << ", tid = " << xCurrentThread::tid();
-		const char* ip = argv[1];
-		uint16_t port = static_cast<uint16_t>(atoi(argv[2]));
-		int threadCount = atoi(argv[3]);
-		int blockSize = atoi(argv[4]);
-		int sessionCount = atoi(argv[5]);
-		int timeout = atoi(argv[6]);
-
-		xEventLoop loop;
-
-		client cli(&loop, ip,port, blockSize, sessionCount, timeout, threadCount);
-		loop.run();
-	
-	}
-	return 0;
-}
-
diff --git a/bench/server.cpp b/bench/server.cpp
deleted file mode 100755
index 2a3cef25..00000000
--- a/bench/server.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xTcpconnection.h"
-#include "xTcpServer.h"
-#include "xEventLoop.h"
-#include "xCurrentThread.h"
-#include "xLog.h"
-
-
-
-void onConnection(const xTcpconnectionPtr& conn,void * data)
-{
-	if (conn->connected())
-	{
-		
-	}
-}
-
-void onMessage(const xTcpconnectionPtr& conn, xBuffer* buf, void * data)
-{
- 	conn->send(buf);
-}
-
-
-int main(int argc, char* argv[])
-{
-	if (argc < 4)
-	{
-		fprintf(stderr, "Usage: server <address> <port> <threads>\n");
-	}
-	else
-	{
-		LOG_INFO << "ping pong server pid = " << getpid() << ", tid = " << xCurrentThread::tid();
-
-		const char* ip = argv[1];
-		uint16_t port = static_cast<uint16_t>(atoi(argv[2]));
-		int threadCount = atoi(argv[3]);
-
-		xEventLoop loop;
-
-		xTcpServer server;
-		server.init(&loop, ip,port,nullptr);
-		server.setConnectionCallback(onConnection);
-		server.setMessageCallback(onMessage);
-
-		if (threadCount > 1)
-		{
-		     server.setThreadNum(threadCount);
-		}
-
-		server.start();
-
-		loop.run();
-	}
-}
-
-
-
diff --git a/bench_test.go b/bench_test.go
new file mode 100644
index 00000000..f6b75c72
--- /dev/null
+++ b/bench_test.go
@@ -0,0 +1,216 @@
+package redis_test
+
+import (
+	"bytes"
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis"
+)
+
+func benchmarkRedisClient(poolSize int) *redis.Client {
+	client := redis.NewClient(&redis.Options{
+		Addr:         ":6379",
+		DialTimeout:  time.Second,
+		ReadTimeout:  time.Second,
+		WriteTimeout: time.Second,
+		PoolSize:     poolSize,
+	})
+	if err := client.FlushDB().Err(); err != nil {
+		panic(err)
+	}
+	return client
+}
+
+func BenchmarkRedisPing(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Ping().Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkRedisSetString(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	value := string(bytes.Repeat([]byte{'1'}, 10000))
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Set("key", value, 0).Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkRedisGetNil(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Get("key").Err(); err != redis.Nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func benchmarkSetRedis(b *testing.B, poolSize, payloadSize int) {
+	client := benchmarkRedisClient(poolSize)
+	defer client.Close()
+
+	value := string(bytes.Repeat([]byte{'1'}, payloadSize))
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Set("key", value, 0).Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkSetRedis10Conns64Bytes(b *testing.B) {
+	benchmarkSetRedis(b, 10, 64)
+}
+
+func BenchmarkSetRedis100Conns64Bytes(b *testing.B) {
+	benchmarkSetRedis(b, 100, 64)
+}
+
+func BenchmarkSetRedis10Conns1KB(b *testing.B) {
+	benchmarkSetRedis(b, 10, 1024)
+}
+
+func BenchmarkSetRedis100Conns1KB(b *testing.B) {
+	benchmarkSetRedis(b, 100, 1024)
+}
+
+func BenchmarkSetRedis10Conns10KB(b *testing.B) {
+	benchmarkSetRedis(b, 10, 10*1024)
+}
+
+func BenchmarkSetRedis100Conns10KB(b *testing.B) {
+	benchmarkSetRedis(b, 100, 10*1024)
+}
+
+func BenchmarkSetRedis10Conns1MB(b *testing.B) {
+	benchmarkSetRedis(b, 10, 1024*1024)
+}
+
+func BenchmarkSetRedis100Conns1MB(b *testing.B) {
+	benchmarkSetRedis(b, 100, 1024*1024)
+}
+
+func BenchmarkRedisSetGetBytes(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	value := bytes.Repeat([]byte{'1'}, 10000)
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Set("key", value, 0).Err(); err != nil {
+				b.Fatal(err)
+			}
+
+			got, err := client.Get("key").Bytes()
+			if err != nil {
+				b.Fatal(err)
+			}
+			if !bytes.Equal(got, value) {
+				b.Fatalf("got != value")
+			}
+		}
+	})
+}
+
+func BenchmarkRedisMGet(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	if err := client.MSet("key1", "hello1", "key2", "hello2").Err(); err != nil {
+		b.Fatal(err)
+	}
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.MGet("key1", "key2").Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkSetExpire(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Set("key", "hello", 0).Err(); err != nil {
+				b.Fatal(err)
+			}
+			if err := client.Expire("key", time.Second).Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkPipeline(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+				pipe.Set("key", "hello", 0)
+				pipe.Expire("key", time.Second)
+				return nil
+			})
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkZAdd(b *testing.B) {
+	client := benchmarkRedisClient(10)
+	defer client.Close()
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.ZAdd("key", redis.Z{float64(1), "hello"}).Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
diff --git a/cluster.go b/cluster.go
new file mode 100644
index 00000000..647a25be
--- /dev/null
+++ b/cluster.go
@@ -0,0 +1,1170 @@
+package redis
+
+import (
+	"fmt"
+	"math/rand"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+	"github.com/go-redis/redis/internal/hashtag"
+	"github.com/go-redis/redis/internal/pool"
+	"github.com/go-redis/redis/internal/proto"
+)
+
+var errClusterNoNodes = internal.RedisError("redis: cluster has no nodes")
+var errNilClusterState = internal.RedisError("redis: cannot load cluster slots")
+
+// ClusterOptions are used to configure a cluster client and should be
+// passed to NewClusterClient.
+type ClusterOptions struct {
+	// A seed list of host:port addresses of cluster nodes.
+	Addrs []string
+
+	// The maximum number of retries before giving up. Command is retried
+	// on network errors and MOVED/ASK redirects.
+	// Default is 16.
+	MaxRedirects int
+
+	// Enables read-only commands on slave nodes.
+	ReadOnly bool
+	// Allows routing read-only commands to the closest master or slave node.
+	RouteByLatency bool
+
+	// Following options are copied from Options struct.
+
+	OnConnect func(*Conn) error
+
+	MaxRetries      int
+	MinRetryBackoff time.Duration
+	MaxRetryBackoff time.Duration
+	Password        string
+
+	DialTimeout  time.Duration
+	ReadTimeout  time.Duration
+	WriteTimeout time.Duration
+
+	// PoolSize applies per cluster node and not for the whole cluster.
+	PoolSize           int
+	PoolTimeout        time.Duration
+	IdleTimeout        time.Duration
+	IdleCheckFrequency time.Duration
+}
+
+func (opt *ClusterOptions) init() {
+	if opt.MaxRedirects == -1 {
+		opt.MaxRedirects = 0
+	} else if opt.MaxRedirects == 0 {
+		opt.MaxRedirects = 16
+	}
+
+	if opt.RouteByLatency {
+		opt.ReadOnly = true
+	}
+
+	switch opt.MinRetryBackoff {
+	case -1:
+		opt.MinRetryBackoff = 0
+	case 0:
+		opt.MinRetryBackoff = 8 * time.Millisecond
+	}
+	switch opt.MaxRetryBackoff {
+	case -1:
+		opt.MaxRetryBackoff = 0
+	case 0:
+		opt.MaxRetryBackoff = 512 * time.Millisecond
+	}
+}
+
+func (opt *ClusterOptions) clientOptions() *Options {
+	const disableIdleCheck = -1
+
+	return &Options{
+		OnConnect: opt.OnConnect,
+
+		MaxRetries:      opt.MaxRetries,
+		MinRetryBackoff: opt.MinRetryBackoff,
+		MaxRetryBackoff: opt.MaxRetryBackoff,
+		Password:        opt.Password,
+		readOnly:        opt.ReadOnly,
+
+		DialTimeout:  opt.DialTimeout,
+		ReadTimeout:  opt.ReadTimeout,
+		WriteTimeout: opt.WriteTimeout,
+
+		PoolSize:    opt.PoolSize,
+		PoolTimeout: opt.PoolTimeout,
+		IdleTimeout: opt.IdleTimeout,
+
+		IdleCheckFrequency: disableIdleCheck,
+	}
+}
+
+//------------------------------------------------------------------------------
+
+type clusterNode struct {
+	Client  *Client
+	Latency time.Duration
+
+	loading    time.Time
+	generation uint32
+}
+
+func newClusterNode(clOpt *ClusterOptions, addr string) *clusterNode {
+	opt := clOpt.clientOptions()
+	opt.Addr = addr
+	node := clusterNode{
+		Client: NewClient(opt),
+	}
+
+	if clOpt.RouteByLatency {
+		node.updateLatency()
+	}
+
+	return &node
+}
+
+func (n *clusterNode) updateLatency() {
+	const probes = 10
+	for i := 0; i < probes; i++ {
+		start := time.Now()
+		n.Client.Ping()
+		n.Latency += time.Since(start)
+	}
+	n.Latency = n.Latency / probes
+}
+
+func (n *clusterNode) Loading() bool {
+	return !n.loading.IsZero() && time.Since(n.loading) < time.Minute
+}
+
+func (n *clusterNode) Generation() uint32 {
+	return n.generation
+}
+
+func (n *clusterNode) SetGeneration(gen uint32) {
+	if gen < n.generation {
+		panic("gen < n.generation")
+	}
+	n.generation = gen
+}
+
+//------------------------------------------------------------------------------
+
+type clusterNodes struct {
+	opt *ClusterOptions
+
+	mu     sync.RWMutex
+	addrs  []string
+	nodes  map[string]*clusterNode
+	closed bool
+
+	generation uint32
+}
+
+func newClusterNodes(opt *ClusterOptions) *clusterNodes {
+	return &clusterNodes{
+		opt:   opt,
+		nodes: make(map[string]*clusterNode),
+	}
+}
+
+func (c *clusterNodes) Close() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.closed {
+		return nil
+	}
+	c.closed = true
+
+	var firstErr error
+	for _, node := range c.nodes {
+		if err := node.Client.Close(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	c.addrs = nil
+	c.nodes = nil
+
+	return firstErr
+}
+
+func (c *clusterNodes) NextGeneration() uint32 {
+	c.generation++
+	return c.generation
+}
+
+// GC removes unused nodes.
+func (c *clusterNodes) GC(generation uint32) error {
+	var collected []*clusterNode
+	c.mu.Lock()
+	for i := 0; i < len(c.addrs); {
+		addr := c.addrs[i]
+		node := c.nodes[addr]
+		if node.Generation() >= generation {
+			i++
+			continue
+		}
+
+		c.addrs = append(c.addrs[:i], c.addrs[i+1:]...)
+		delete(c.nodes, addr)
+		collected = append(collected, node)
+	}
+	c.mu.Unlock()
+
+	var firstErr error
+	for _, node := range collected {
+		if err := node.Client.Close(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+
+	return firstErr
+}
+
+func (c *clusterNodes) All() ([]*clusterNode, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	if c.closed {
+		return nil, pool.ErrClosed
+	}
+
+	nodes := make([]*clusterNode, 0, len(c.nodes))
+	for _, node := range c.nodes {
+		nodes = append(nodes, node)
+	}
+	return nodes, nil
+}
+
+func (c *clusterNodes) GetOrCreate(addr string) (*clusterNode, error) {
+	var node *clusterNode
+	var ok bool
+
+	c.mu.RLock()
+	if !c.closed {
+		node, ok = c.nodes[addr]
+	}
+	c.mu.RUnlock()
+	if ok {
+		return node, nil
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.closed {
+		return nil, pool.ErrClosed
+	}
+
+	node, ok = c.nodes[addr]
+	if ok {
+		return node, nil
+	}
+
+	c.addrs = append(c.addrs, addr)
+	node = newClusterNode(c.opt, addr)
+	c.nodes[addr] = node
+	return node, nil
+}
+
+func (c *clusterNodes) Random() (*clusterNode, error) {
+	c.mu.RLock()
+	closed := c.closed
+	addrs := c.addrs
+	c.mu.RUnlock()
+
+	if closed {
+		return nil, pool.ErrClosed
+	}
+	if len(addrs) == 0 {
+		return nil, errClusterNoNodes
+	}
+
+	var nodeErr error
+	for i := 0; i <= c.opt.MaxRedirects; i++ {
+		n := rand.Intn(len(addrs))
+		node, err := c.GetOrCreate(addrs[n])
+		if err != nil {
+			return nil, err
+		}
+
+		nodeErr = node.Client.ClusterInfo().Err()
+		if nodeErr == nil {
+			return node, nil
+		}
+	}
+	return nil, nodeErr
+}
+
+//------------------------------------------------------------------------------
+
+type clusterState struct {
+	nodes   *clusterNodes
+	masters []*clusterNode
+	slaves  []*clusterNode
+
+	slots [][]*clusterNode
+
+	generation uint32
+}
+
+func newClusterState(nodes *clusterNodes, slots []ClusterSlot, origin string) (*clusterState, error) {
+	c := clusterState{
+		nodes:      nodes,
+		generation: nodes.NextGeneration(),
+
+		slots: make([][]*clusterNode, hashtag.SlotNumber),
+	}
+
+	isLoopbackOrigin := isLoopbackAddr(origin)
+	for _, slot := range slots {
+		var nodes []*clusterNode
+		for i, slotNode := range slot.Nodes {
+			addr := slotNode.Addr
+			if !isLoopbackOrigin && isLoopbackAddr(addr) {
+				addr = origin
+			}
+
+			node, err := c.nodes.GetOrCreate(addr)
+			if err != nil {
+				return nil, err
+			}
+
+			node.SetGeneration(c.generation)
+			nodes = append(nodes, node)
+
+			if i == 0 {
+				c.masters = appendNode(c.masters, node)
+			} else {
+				c.slaves = appendNode(c.slaves, node)
+			}
+		}
+
+		for i := slot.Start; i <= slot.End; i++ {
+			c.slots[i] = nodes
+		}
+	}
+
+	return &c, nil
+}
+
+func (c *clusterState) slotMasterNode(slot int) (*clusterNode, error) {
+	nodes := c.slotNodes(slot)
+	if len(nodes) > 0 {
+		return nodes[0], nil
+	}
+	return c.nodes.Random()
+}
+
+func (c *clusterState) slotSlaveNode(slot int) (*clusterNode, error) {
+	nodes := c.slotNodes(slot)
+	switch len(nodes) {
+	case 0:
+		return c.nodes.Random()
+	case 1:
+		return nodes[0], nil
+	case 2:
+		if slave := nodes[1]; !slave.Loading() {
+			return slave, nil
+		}
+		return nodes[0], nil
+	default:
+		var slave *clusterNode
+		for i := 0; i < 10; i++ {
+			n := rand.Intn(len(nodes)-1) + 1
+			slave = nodes[n]
+			if !slave.Loading() {
+				break
+			}
+		}
+		return slave, nil
+	}
+}
+
+func (c *clusterState) slotClosestNode(slot int) (*clusterNode, error) {
+	const threshold = time.Millisecond
+
+	nodes := c.slotNodes(slot)
+	if len(nodes) == 0 {
+		return c.nodes.Random()
+	}
+
+	var node *clusterNode
+	for _, n := range nodes {
+		if n.Loading() {
+			continue
+		}
+		if node == nil || node.Latency-n.Latency > threshold {
+			node = n
+		}
+	}
+	return node, nil
+}
+
+func (c *clusterState) slotNodes(slot int) []*clusterNode {
+	if slot >= 0 && slot < len(c.slots) {
+		return c.slots[slot]
+	}
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+// ClusterClient is a Redis Cluster client representing a pool of zero
+// or more underlying connections. It's safe for concurrent use by
+// multiple goroutines.
+type ClusterClient struct {
+	cmdable
+
+	opt    *ClusterOptions
+	nodes  *clusterNodes
+	_state atomic.Value
+
+	cmdsInfoOnce internal.Once
+	cmdsInfo     map[string]*CommandInfo
+
+	// Reports whether slots reloading is in progress.
+	reloading uint32
+}
+
+// NewClusterClient returns a Redis Cluster client as described in
+// http://redis.io/topics/cluster-spec.
+func NewClusterClient(opt *ClusterOptions) *ClusterClient {
+	opt.init()
+
+	c := &ClusterClient{
+		opt:   opt,
+		nodes: newClusterNodes(opt),
+	}
+	c.setProcessor(c.Process)
+
+	// Add initial nodes.
+	for _, addr := range opt.Addrs {
+		_, _ = c.nodes.GetOrCreate(addr)
+	}
+
+	// Preload cluster slots.
+	for i := 0; i < 10; i++ {
+		state, err := c.reloadState()
+		if err == nil {
+			c._state.Store(state)
+			break
+		}
+	}
+
+	if opt.IdleCheckFrequency > 0 {
+		go c.reaper(opt.IdleCheckFrequency)
+	}
+
+	return c
+}
+
+// Options returns read-only Options that were used to create the client.
+func (c *ClusterClient) Options() *ClusterOptions {
+	return c.opt
+}
+
+func (c *ClusterClient) state() *clusterState {
+	v := c._state.Load()
+	if v != nil {
+		return v.(*clusterState)
+	}
+	c.lazyReloadState()
+	return nil
+}
+
+func (c *ClusterClient) cmdInfo(name string) *CommandInfo {
+	err := c.cmdsInfoOnce.Do(func() error {
+		node, err := c.nodes.Random()
+		if err != nil {
+			return err
+		}
+
+		cmdsInfo, err := node.Client.Command().Result()
+		if err != nil {
+			return err
+		}
+
+		c.cmdsInfo = cmdsInfo
+		return nil
+	})
+	if err != nil {
+		return nil
+	}
+	return c.cmdsInfo[name]
+}
+
+func (c *ClusterClient) cmdSlotAndNode(state *clusterState, cmd Cmder) (int, *clusterNode, error) {
+	if state == nil {
+		node, err := c.nodes.Random()
+		return 0, node, err
+	}
+
+	cmdInfo := c.cmdInfo(cmd.Name())
+	firstKey := cmd.arg(cmdFirstKeyPos(cmd, cmdInfo))
+	slot := hashtag.Slot(firstKey)
+
+	if cmdInfo != nil && cmdInfo.ReadOnly && c.opt.ReadOnly {
+		if c.opt.RouteByLatency {
+			node, err := state.slotClosestNode(slot)
+			return slot, node, err
+		}
+
+		node, err := state.slotSlaveNode(slot)
+		return slot, node, err
+	}
+
+	node, err := state.slotMasterNode(slot)
+	return slot, node, err
+}
+
+func (c *ClusterClient) Watch(fn func(*Tx) error, keys ...string) error {
+	state := c.state()
+
+	var node *clusterNode
+	var err error
+	if state != nil && len(keys) > 0 {
+		node, err = state.slotMasterNode(hashtag.Slot(keys[0]))
+	} else {
+		node, err = c.nodes.Random()
+	}
+	if err != nil {
+		return err
+	}
+	return node.Client.Watch(fn, keys...)
+}
+
+// Close closes the cluster client, releasing any open resources.
+//
+// It is rare to Close a ClusterClient, as the ClusterClient is meant
+// to be long-lived and shared between many goroutines.
+func (c *ClusterClient) Close() error {
+	return c.nodes.Close()
+}
+
+func (c *ClusterClient) Process(cmd Cmder) error {
+	slot, node, err := c.cmdSlotAndNode(c.state(), cmd)
+	if err != nil {
+		cmd.setErr(err)
+		return err
+	}
+
+	var ask bool
+	for attempt := 0; attempt <= c.opt.MaxRedirects; attempt++ {
+		if attempt > 0 {
+			time.Sleep(node.Client.retryBackoff(attempt))
+		}
+
+		if ask {
+			pipe := node.Client.Pipeline()
+			pipe.Process(NewCmd("ASKING"))
+			pipe.Process(cmd)
+			_, err = pipe.Exec()
+			pipe.Close()
+			ask = false
+		} else {
+			err = node.Client.Process(cmd)
+		}
+
+		// If there is no error - we are done.
+		if err == nil {
+			return nil
+		}
+
+		// If slave is loading - read from master.
+		if c.opt.ReadOnly && internal.IsLoadingError(err) {
+			// TODO: race
+			node.loading = time.Now()
+			continue
+		}
+
+		// On network errors try random node.
+		if internal.IsRetryableError(err) || internal.IsClusterDownError(err) {
+			node, err = c.nodes.Random()
+			if err != nil {
+				cmd.setErr(err)
+				return err
+			}
+			continue
+		}
+
+		var moved bool
+		var addr string
+		moved, ask, addr = internal.IsMovedError(err)
+		if moved || ask {
+			state := c.state()
+			if state != nil && slot >= 0 {
+				master, _ := state.slotMasterNode(slot)
+				if moved && (master == nil || master.Client.getAddr() != addr) {
+					c.lazyReloadState()
+				}
+			}
+
+			node, err = c.nodes.GetOrCreate(addr)
+			if err != nil {
+				cmd.setErr(err)
+				return err
+			}
+
+			continue
+		}
+
+		break
+	}
+
+	return cmd.Err()
+}
+
+// ForEachMaster concurrently calls the fn on each master node in the cluster.
+// It returns the first error if any.
+func (c *ClusterClient) ForEachMaster(fn func(client *Client) error) error {
+	state := c.state()
+	if state == nil {
+		return errNilClusterState
+	}
+
+	var wg sync.WaitGroup
+	errCh := make(chan error, 1)
+	for _, master := range state.masters {
+		wg.Add(1)
+		go func(node *clusterNode) {
+			defer wg.Done()
+			err := fn(node.Client)
+			if err != nil {
+				select {
+				case errCh <- err:
+				default:
+				}
+			}
+		}(master)
+	}
+	wg.Wait()
+
+	select {
+	case err := <-errCh:
+		return err
+	default:
+		return nil
+	}
+}
+
+// ForEachSlave concurrently calls the fn on each slave node in the cluster.
+// It returns the first error if any.
+func (c *ClusterClient) ForEachSlave(fn func(client *Client) error) error {
+	state := c.state()
+	if state == nil {
+		return errNilClusterState
+	}
+
+	var wg sync.WaitGroup
+	errCh := make(chan error, 1)
+	for _, slave := range state.slaves {
+		wg.Add(1)
+		go func(node *clusterNode) {
+			defer wg.Done()
+			err := fn(node.Client)
+			if err != nil {
+				select {
+				case errCh <- err:
+				default:
+				}
+			}
+		}(slave)
+	}
+	wg.Wait()
+
+	select {
+	case err := <-errCh:
+		return err
+	default:
+		return nil
+	}
+}
+
+// ForEachNode concurrently calls the fn on each known node in the cluster.
+// It returns the first error if any.
+func (c *ClusterClient) ForEachNode(fn func(client *Client) error) error {
+	state := c.state()
+	if state == nil {
+		return errNilClusterState
+	}
+
+	var wg sync.WaitGroup
+	errCh := make(chan error, 1)
+	worker := func(node *clusterNode) {
+		defer wg.Done()
+		err := fn(node.Client)
+		if err != nil {
+			select {
+			case errCh <- err:
+			default:
+			}
+		}
+	}
+
+	for _, node := range state.masters {
+		wg.Add(1)
+		go worker(node)
+	}
+	for _, node := range state.slaves {
+		wg.Add(1)
+		go worker(node)
+	}
+
+	wg.Wait()
+	select {
+	case err := <-errCh:
+		return err
+	default:
+		return nil
+	}
+}
+
+// PoolStats returns accumulated connection pool stats.
+func (c *ClusterClient) PoolStats() *PoolStats {
+	var acc PoolStats
+
+	state := c.state()
+	if state == nil {
+		return &acc
+	}
+
+	for _, node := range state.masters {
+		s := node.Client.connPool.Stats()
+		acc.Requests += s.Requests
+		acc.Hits += s.Hits
+		acc.Timeouts += s.Timeouts
+		acc.TotalConns += s.TotalConns
+		acc.FreeConns += s.FreeConns
+	}
+
+	for _, node := range state.slaves {
+		s := node.Client.connPool.Stats()
+		acc.Requests += s.Requests
+		acc.Hits += s.Hits
+		acc.Timeouts += s.Timeouts
+		acc.TotalConns += s.TotalConns
+		acc.FreeConns += s.FreeConns
+	}
+
+	return &acc
+}
+
+func (c *ClusterClient) lazyReloadState() {
+	if !atomic.CompareAndSwapUint32(&c.reloading, 0, 1) {
+		return
+	}
+
+	go func() {
+		defer atomic.StoreUint32(&c.reloading, 0)
+
+		var state *clusterState
+		for {
+			var err error
+			state, err = c.reloadState()
+			if err == pool.ErrClosed {
+				return
+			}
+
+			if err != nil {
+				time.Sleep(time.Millisecond)
+				continue
+			}
+
+			c._state.Store(state)
+			break
+		}
+
+		time.Sleep(3 * time.Second)
+		c.nodes.GC(state.generation)
+	}()
+}
+
+// Not thread-safe.
+func (c *ClusterClient) reloadState() (*clusterState, error) {
+	node, err := c.nodes.Random()
+	if err != nil {
+		return nil, err
+	}
+
+	slots, err := node.Client.ClusterSlots().Result()
+	if err != nil {
+		return nil, err
+	}
+
+	return newClusterState(c.nodes, slots, node.Client.opt.Addr)
+}
+
+// reaper closes idle connections to the cluster.
+func (c *ClusterClient) reaper(idleCheckFrequency time.Duration) {
+	ticker := time.NewTicker(idleCheckFrequency)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		nodes, err := c.nodes.All()
+		if err != nil {
+			break
+		}
+
+		var n int
+		for _, node := range nodes {
+			nn, err := node.Client.connPool.(*pool.ConnPool).ReapStaleConns()
+			if err != nil {
+				internal.Logf("ReapStaleConns failed: %s", err)
+			} else {
+				n += nn
+			}
+		}
+
+		s := c.PoolStats()
+		internal.Logf(
+			"reaper: removed %d stale conns (TotalConns=%d FreeConns=%d Requests=%d Hits=%d Timeouts=%d)",
+			n, s.TotalConns, s.FreeConns, s.Requests, s.Hits, s.Timeouts,
+		)
+	}
+}
+
+func (c *ClusterClient) Pipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.pipelineExec,
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
+
+func (c *ClusterClient) Pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.Pipeline().pipelined(fn)
+}
+
+func (c *ClusterClient) pipelineExec(cmds []Cmder) error {
+	cmdsMap, err := c.mapCmdsByNode(cmds)
+	if err != nil {
+		return err
+	}
+
+	for i := 0; i <= c.opt.MaxRedirects; i++ {
+		failedCmds := make(map[*clusterNode][]Cmder)
+
+		for node, cmds := range cmdsMap {
+			cn, _, err := node.Client.getConn()
+			if err != nil {
+				setCmdsErr(cmds, err)
+				continue
+			}
+
+			err = c.pipelineProcessCmds(cn, cmds, failedCmds)
+			node.Client.releaseConn(cn, err)
+		}
+
+		if len(failedCmds) == 0 {
+			break
+		}
+		cmdsMap = failedCmds
+	}
+
+	var firstErr error
+	for _, cmd := range cmds {
+		if err := cmd.Err(); err != nil {
+			firstErr = err
+			break
+		}
+	}
+	return firstErr
+}
+
+func (c *ClusterClient) mapCmdsByNode(cmds []Cmder) (map[*clusterNode][]Cmder, error) {
+	state := c.state()
+	cmdsMap := make(map[*clusterNode][]Cmder)
+	for _, cmd := range cmds {
+		_, node, err := c.cmdSlotAndNode(state, cmd)
+		if err != nil {
+			return nil, err
+		}
+		cmdsMap[node] = append(cmdsMap[node], cmd)
+	}
+	return cmdsMap, nil
+}
+
+func (c *ClusterClient) pipelineProcessCmds(
+	cn *pool.Conn, cmds []Cmder, failedCmds map[*clusterNode][]Cmder,
+) error {
+	cn.SetWriteTimeout(c.opt.WriteTimeout)
+	if err := writeCmd(cn, cmds...); err != nil {
+		setCmdsErr(cmds, err)
+		return err
+	}
+
+	// Set read timeout for all commands.
+	cn.SetReadTimeout(c.opt.ReadTimeout)
+
+	return c.pipelineReadCmds(cn, cmds, failedCmds)
+}
+
+func (c *ClusterClient) pipelineReadCmds(
+	cn *pool.Conn, cmds []Cmder, failedCmds map[*clusterNode][]Cmder,
+) error {
+	var firstErr error
+	for _, cmd := range cmds {
+		err := cmd.readReply(cn)
+		if err == nil {
+			continue
+		}
+
+		if firstErr == nil {
+			firstErr = err
+		}
+
+		err = c.checkMovedErr(cmd, failedCmds)
+		if err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
+func (c *ClusterClient) checkMovedErr(cmd Cmder, failedCmds map[*clusterNode][]Cmder) error {
+	moved, ask, addr := internal.IsMovedError(cmd.Err())
+	if moved {
+		c.lazyReloadState()
+
+		node, err := c.nodes.GetOrCreate(addr)
+		if err != nil {
+			return err
+		}
+
+		failedCmds[node] = append(failedCmds[node], cmd)
+	}
+	if ask {
+		node, err := c.nodes.GetOrCreate(addr)
+		if err != nil {
+			return err
+		}
+
+		failedCmds[node] = append(failedCmds[node], NewCmd("ASKING"), cmd)
+	}
+	return nil
+}
+
+// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
+func (c *ClusterClient) TxPipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.txPipelineExec,
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
+
+func (c *ClusterClient) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.TxPipeline().pipelined(fn)
+}
+
+func (c *ClusterClient) txPipelineExec(cmds []Cmder) error {
+	cmdsMap, err := c.mapCmdsBySlot(cmds)
+	if err != nil {
+		return err
+	}
+
+	state := c.state()
+	if state == nil {
+		return errNilClusterState
+	}
+
+	for slot, cmds := range cmdsMap {
+		node, err := state.slotMasterNode(slot)
+		if err != nil {
+			setCmdsErr(cmds, err)
+			continue
+		}
+
+		cmdsMap := map[*clusterNode][]Cmder{node: cmds}
+		for i := 0; i <= c.opt.MaxRedirects; i++ {
+			failedCmds := make(map[*clusterNode][]Cmder)
+
+			for node, cmds := range cmdsMap {
+				cn, _, err := node.Client.getConn()
+				if err != nil {
+					setCmdsErr(cmds, err)
+					continue
+				}
+
+				err = c.txPipelineProcessCmds(node, cn, cmds, failedCmds)
+				node.Client.releaseConn(cn, err)
+			}
+
+			if len(failedCmds) == 0 {
+				break
+			}
+			cmdsMap = failedCmds
+		}
+	}
+
+	var firstErr error
+	for _, cmd := range cmds {
+		if err := cmd.Err(); err != nil {
+			firstErr = err
+			break
+		}
+	}
+	return firstErr
+}
+
+func (c *ClusterClient) mapCmdsBySlot(cmds []Cmder) (map[int][]Cmder, error) {
+	state := c.state()
+	cmdsMap := make(map[int][]Cmder)
+	for _, cmd := range cmds {
+		slot, _, err := c.cmdSlotAndNode(state, cmd)
+		if err != nil {
+			return nil, err
+		}
+		cmdsMap[slot] = append(cmdsMap[slot], cmd)
+	}
+	return cmdsMap, nil
+}
+
+func (c *ClusterClient) txPipelineProcessCmds(
+	node *clusterNode, cn *pool.Conn, cmds []Cmder, failedCmds map[*clusterNode][]Cmder,
+) error {
+	cn.SetWriteTimeout(c.opt.WriteTimeout)
+	if err := txPipelineWriteMulti(cn, cmds); err != nil {
+		setCmdsErr(cmds, err)
+		failedCmds[node] = cmds
+		return err
+	}
+
+	// Set read timeout for all commands.
+	cn.SetReadTimeout(c.opt.ReadTimeout)
+
+	if err := c.txPipelineReadQueued(cn, cmds, failedCmds); err != nil {
+		return err
+	}
+
+	_, err := pipelineReadCmds(cn, cmds)
+	return err
+}
+
+func (c *ClusterClient) txPipelineReadQueued(
+	cn *pool.Conn, cmds []Cmder, failedCmds map[*clusterNode][]Cmder,
+) error {
+	var firstErr error
+
+	// Parse queued replies.
+	var statusCmd StatusCmd
+	if err := statusCmd.readReply(cn); err != nil && firstErr == nil {
+		firstErr = err
+	}
+
+	for _, cmd := range cmds {
+		err := statusCmd.readReply(cn)
+		if err == nil {
+			continue
+		}
+
+		cmd.setErr(err)
+		if firstErr == nil {
+			firstErr = err
+		}
+
+		err = c.checkMovedErr(cmd, failedCmds)
+		if err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+
+	// Parse number of replies.
+	line, err := cn.Rd.ReadLine()
+	if err != nil {
+		if err == Nil {
+			err = TxFailedErr
+		}
+		return err
+	}
+
+	switch line[0] {
+	case proto.ErrorReply:
+		return proto.ParseErrorReply(line)
+	case proto.ArrayReply:
+		// ok
+	default:
+		err := fmt.Errorf("redis: expected '*', but got line %q", line)
+		return err
+	}
+
+	return firstErr
+}
+
+func (c *ClusterClient) pubSub(channels []string) *PubSub {
+	opt := c.opt.clientOptions()
+
+	var node *clusterNode
+	return &PubSub{
+		opt: opt,
+
+		newConn: func(channels []string) (*pool.Conn, error) {
+			if node == nil {
+				var slot int
+				if len(channels) > 0 {
+					slot = hashtag.Slot(channels[0])
+				} else {
+					slot = -1
+				}
+
+				masterNode, err := c.state().slotMasterNode(slot)
+				if err != nil {
+					return nil, err
+				}
+				node = masterNode
+			}
+			return node.Client.newConn()
+		},
+		closeConn: func(cn *pool.Conn) error {
+			return node.Client.connPool.CloseConn(cn)
+		},
+	}
+}
+
+// Subscribe subscribes the client to the specified channels.
+// Channels can be omitted to create empty subscription.
+func (c *ClusterClient) Subscribe(channels ...string) *PubSub {
+	pubsub := c.pubSub(channels)
+	if len(channels) > 0 {
+		_ = pubsub.Subscribe(channels...)
+	}
+	return pubsub
+}
+
+// PSubscribe subscribes the client to the given patterns.
+// Patterns can be omitted to create empty subscription.
+func (c *ClusterClient) PSubscribe(channels ...string) *PubSub {
+	pubsub := c.pubSub(channels)
+	if len(channels) > 0 {
+		_ = pubsub.PSubscribe(channels...)
+	}
+	return pubsub
+}
+
+func isLoopbackAddr(addr string) bool {
+	host, _, err := net.SplitHostPort(addr)
+	if err != nil {
+		return false
+	}
+
+	ip := net.ParseIP(host)
+	if ip == nil {
+		return false
+	}
+
+	return ip.IsLoopback()
+}
+
+func appendNode(nodes []*clusterNode, node *clusterNode) []*clusterNode {
+	for _, n := range nodes {
+		if n == node {
+			return nodes
+		}
+	}
+	return append(nodes, node)
+}
diff --git a/cluster_test.go b/cluster_test.go
new file mode 100644
index 00000000..324bd1ce
--- /dev/null
+++ b/cluster_test.go
@@ -0,0 +1,800 @@
+package redis_test
+
+import (
+	"bytes"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis"
+	"github.com/go-redis/redis/internal/hashtag"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+type clusterScenario struct {
+	ports     []string
+	nodeIds   []string
+	processes map[string]*redisProcess
+	clients   map[string]*redis.Client
+}
+
+func (s *clusterScenario) masters() []*redis.Client {
+	result := make([]*redis.Client, 3)
+	for pos, port := range s.ports[:3] {
+		result[pos] = s.clients[port]
+	}
+	return result
+}
+
+func (s *clusterScenario) slaves() []*redis.Client {
+	result := make([]*redis.Client, 3)
+	for pos, port := range s.ports[3:] {
+		result[pos] = s.clients[port]
+	}
+	return result
+}
+
+func (s *clusterScenario) addrs() []string {
+	addrs := make([]string, len(s.ports))
+	for i, port := range s.ports {
+		addrs[i] = net.JoinHostPort("127.0.0.1", port)
+	}
+	return addrs
+}
+
+func (s *clusterScenario) clusterClient(opt *redis.ClusterOptions) *redis.ClusterClient {
+	opt.Addrs = s.addrs()
+	return redis.NewClusterClient(opt)
+}
+
+func startCluster(scenario *clusterScenario) error {
+	// Start processes and collect node ids
+	for pos, port := range scenario.ports {
+		process, err := startRedis(port, "--cluster-enabled", "yes")
+		if err != nil {
+			return err
+		}
+
+		client := redis.NewClient(&redis.Options{
+			Addr: ":" + port,
+		})
+
+		info, err := client.ClusterNodes().Result()
+		if err != nil {
+			return err
+		}
+
+		scenario.processes[port] = process
+		scenario.clients[port] = client
+		scenario.nodeIds[pos] = info[:40]
+	}
+
+	// Meet cluster nodes.
+	for _, client := range scenario.clients {
+		err := client.ClusterMeet("127.0.0.1", scenario.ports[0]).Err()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Bootstrap masters.
+	slots := []int{0, 5000, 10000, 16384}
+	for pos, master := range scenario.masters() {
+		err := master.ClusterAddSlotsRange(slots[pos], slots[pos+1]-1).Err()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Bootstrap slaves.
+	for idx, slave := range scenario.slaves() {
+		masterId := scenario.nodeIds[idx]
+
+		// Wait until master is available
+		err := eventually(func() error {
+			s := slave.ClusterNodes().Val()
+			wanted := masterId
+			if !strings.Contains(s, wanted) {
+				return fmt.Errorf("%q does not contain %q", s, wanted)
+			}
+			return nil
+		}, 10*time.Second)
+		if err != nil {
+			return err
+		}
+
+		err = slave.ClusterReplicate(masterId).Err()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Wait until all nodes have consistent info.
+	for _, client := range scenario.clients {
+		err := eventually(func() error {
+			res, err := client.ClusterSlots().Result()
+			if err != nil {
+				return err
+			}
+			wanted := []redis.ClusterSlot{
+				{0, 4999, []redis.ClusterNode{{"", "127.0.0.1:8220"}, {"", "127.0.0.1:8223"}}},
+				{5000, 9999, []redis.ClusterNode{{"", "127.0.0.1:8221"}, {"", "127.0.0.1:8224"}}},
+				{10000, 16383, []redis.ClusterNode{{"", "127.0.0.1:8222"}, {"", "127.0.0.1:8225"}}},
+			}
+			return assertSlotsEqual(res, wanted)
+		}, 30*time.Second)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func assertSlotsEqual(slots, wanted []redis.ClusterSlot) error {
+outer_loop:
+	for _, s2 := range wanted {
+		for _, s1 := range slots {
+			if slotEqual(s1, s2) {
+				continue outer_loop
+			}
+		}
+		return fmt.Errorf("%v not found in %v", s2, slots)
+	}
+	return nil
+}
+
+func slotEqual(s1, s2 redis.ClusterSlot) bool {
+	if s1.Start != s2.Start {
+		return false
+	}
+	if s1.End != s2.End {
+		return false
+	}
+	if len(s1.Nodes) != len(s2.Nodes) {
+		return false
+	}
+	for i, n1 := range s1.Nodes {
+		if n1.Addr != s2.Nodes[i].Addr {
+			return false
+		}
+	}
+	return true
+}
+
+func stopCluster(scenario *clusterScenario) error {
+	for _, client := range scenario.clients {
+		if err := client.Close(); err != nil {
+			return err
+		}
+	}
+	for _, process := range scenario.processes {
+		if err := process.Close(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+var _ = Describe("ClusterClient", func() {
+	var opt *redis.ClusterOptions
+	var client *redis.ClusterClient
+
+	assertClusterClient := func() {
+		It("should GET/SET/DEL", func() {
+			val, err := client.Get("A").Result()
+			Expect(err).To(Equal(redis.Nil))
+			Expect(val).To(Equal(""))
+
+			val, err = client.Set("A", "VALUE", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("OK"))
+
+			Eventually(func() string {
+				return client.Get("A").Val()
+			}).Should(Equal("VALUE"))
+
+			cnt, err := client.Del("A").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cnt).To(Equal(int64(1)))
+		})
+
+		It("follows redirects", func() {
+			Expect(client.Set("A", "VALUE", 0).Err()).NotTo(HaveOccurred())
+
+			slot := hashtag.Slot("A")
+			client.SwapSlotNodes(slot)
+
+			Eventually(func() string {
+				return client.Get("A").Val()
+			}).Should(Equal("VALUE"))
+		})
+
+		It("distributes keys", func() {
+			for i := 0; i < 100; i++ {
+				err := client.Set(fmt.Sprintf("key%d", i), "value", 0).Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+
+			for _, master := range cluster.masters() {
+				Eventually(func() string {
+					return master.Info("keyspace").Val()
+				}, 5*time.Second).Should(Or(
+					ContainSubstring("keys=31"),
+					ContainSubstring("keys=29"),
+					ContainSubstring("keys=40"),
+				))
+			}
+		})
+
+		It("distributes keys when using EVAL", func() {
+			script := redis.NewScript(`
+				local r = redis.call('SET', KEYS[1], ARGV[1])
+				return r
+			`)
+
+			var key string
+			for i := 0; i < 100; i++ {
+				key = fmt.Sprintf("key%d", i)
+				err := script.Run(client, []string{key}, "value").Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+
+			for _, master := range cluster.masters() {
+				Eventually(func() string {
+					return master.Info("keyspace").Val()
+				}, 5*time.Second).Should(Or(
+					ContainSubstring("keys=31"),
+					ContainSubstring("keys=29"),
+					ContainSubstring("keys=40"),
+				))
+			}
+		})
+
+		It("supports Watch", func() {
+			var incr func(string) error
+
+			// Transactionally increments key using GET and SET commands.
+			incr = func(key string) error {
+				err := client.Watch(func(tx *redis.Tx) error {
+					n, err := tx.Get(key).Int64()
+					if err != nil && err != redis.Nil {
+						return err
+					}
+
+					_, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
+						pipe.Set(key, strconv.FormatInt(n+1, 10), 0)
+						return nil
+					})
+					return err
+				}, key)
+				if err == redis.TxFailedErr {
+					return incr(key)
+				}
+				return err
+			}
+
+			var wg sync.WaitGroup
+			for i := 0; i < 100; i++ {
+				wg.Add(1)
+				go func() {
+					defer GinkgoRecover()
+					defer wg.Done()
+
+					err := incr("key")
+					Expect(err).NotTo(HaveOccurred())
+				}()
+			}
+			wg.Wait()
+
+			n, err := client.Get("key").Int64()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(100)))
+		})
+
+		Describe("pipelining", func() {
+			var pipe *redis.Pipeline
+
+			assertPipeline := func() {
+				keys := []string{"A", "B", "C", "D", "E", "F", "G"}
+
+				It("follows redirects", func() {
+					for _, key := range keys {
+						slot := hashtag.Slot(key)
+						client.SwapSlotNodes(slot)
+					}
+
+					for i, key := range keys {
+						pipe.Set(key, key+"_value", 0)
+						pipe.Expire(key, time.Duration(i+1)*time.Hour)
+					}
+					cmds, err := pipe.Exec()
+					Expect(err).NotTo(HaveOccurred())
+					Expect(cmds).To(HaveLen(14))
+
+					if opt.RouteByLatency {
+						return
+					}
+
+					for _, key := range keys {
+						slot := hashtag.Slot(key)
+						client.SwapSlotNodes(slot)
+					}
+
+					for _, key := range keys {
+						pipe.Get(key)
+						pipe.TTL(key)
+					}
+					cmds, err = pipe.Exec()
+					Expect(err).NotTo(HaveOccurred())
+					Expect(cmds).To(HaveLen(14))
+
+					for i, key := range keys {
+						get := cmds[i*2].(*redis.StringCmd)
+						Expect(get.Val()).To(Equal(key + "_value"))
+
+						ttl := cmds[(i*2)+1].(*redis.DurationCmd)
+						dur := time.Duration(i+1) * time.Hour
+						Expect(ttl.Val()).To(BeNumerically("~", dur, 5*time.Second))
+					}
+				})
+
+				It("works with missing keys", func() {
+					pipe.Set("A", "A_value", 0)
+					pipe.Set("C", "C_value", 0)
+					_, err := pipe.Exec()
+					Expect(err).NotTo(HaveOccurred())
+
+					a := pipe.Get("A")
+					b := pipe.Get("B")
+					c := pipe.Get("C")
+					cmds, err := pipe.Exec()
+					Expect(err).To(Equal(redis.Nil))
+					Expect(cmds).To(HaveLen(3))
+
+					Expect(a.Err()).NotTo(HaveOccurred())
+					Expect(a.Val()).To(Equal("A_value"))
+
+					Expect(b.Err()).To(Equal(redis.Nil))
+					Expect(b.Val()).To(Equal(""))
+
+					Expect(c.Err()).NotTo(HaveOccurred())
+					Expect(c.Val()).To(Equal("C_value"))
+				})
+			}
+
+			Describe("with Pipeline", func() {
+				BeforeEach(func() {
+					pipe = client.Pipeline().(*redis.Pipeline)
+				})
+
+				AfterEach(func() {
+					Expect(pipe.Close()).NotTo(HaveOccurred())
+				})
+
+				assertPipeline()
+			})
+
+			Describe("with TxPipeline", func() {
+				BeforeEach(func() {
+					pipe = client.TxPipeline().(*redis.Pipeline)
+				})
+
+				AfterEach(func() {
+					Expect(pipe.Close()).NotTo(HaveOccurred())
+				})
+
+				assertPipeline()
+			})
+		})
+
+		It("supports PubSub", func() {
+			pubsub := client.Subscribe("mychannel")
+			defer pubsub.Close()
+
+			Eventually(func() error {
+				_, err := client.Publish("mychannel", "hello").Result()
+				if err != nil {
+					return err
+				}
+
+				msg, err := pubsub.ReceiveTimeout(time.Second)
+				if err != nil {
+					return err
+				}
+
+				_, ok := msg.(*redis.Message)
+				if !ok {
+					return fmt.Errorf("got %T, wanted *redis.Message", msg)
+				}
+
+				return nil
+			}, 30*time.Second).ShouldNot(HaveOccurred())
+		})
+	}
+
+	Describe("ClusterClient", func() {
+		BeforeEach(func() {
+			opt = redisClusterOptions()
+			client = cluster.clusterClient(opt)
+
+			_ = client.ForEachMaster(func(master *redis.Client) error {
+				return master.FlushDB().Err()
+			})
+		})
+
+		AfterEach(func() {
+			Expect(client.Close()).NotTo(HaveOccurred())
+		})
+
+		It("returns pool stats", func() {
+			Expect(client.PoolStats()).To(BeAssignableToTypeOf(&redis.PoolStats{}))
+		})
+
+		It("removes idle connections", func() {
+			stats := client.PoolStats()
+			Expect(stats.TotalConns).NotTo(BeZero())
+			Expect(stats.FreeConns).NotTo(BeZero())
+
+			time.Sleep(2 * time.Second)
+
+			stats = client.PoolStats()
+			Expect(stats.TotalConns).To(BeZero())
+			Expect(stats.FreeConns).To(BeZero())
+		})
+
+		It("returns an error when there are no attempts left", func() {
+			opt := redisClusterOptions()
+			opt.MaxRedirects = -1
+			client := cluster.clusterClient(opt)
+
+			slot := hashtag.Slot("A")
+			client.SwapSlotNodes(slot)
+
+			err := client.Get("A").Err()
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("MOVED"))
+
+			Expect(client.Close()).NotTo(HaveOccurred())
+		})
+
+		It("calls fn for every master node", func() {
+			for i := 0; i < 10; i++ {
+				Expect(client.Set(strconv.Itoa(i), "", 0).Err()).NotTo(HaveOccurred())
+			}
+
+			err := client.ForEachMaster(func(master *redis.Client) error {
+				return master.FlushDB().Err()
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			for _, client := range cluster.masters() {
+				size, err := client.DBSize().Result()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(size).To(Equal(int64(0)))
+			}
+		})
+
+		It("should CLUSTER SLOTS", func() {
+			res, err := client.ClusterSlots().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(HaveLen(3))
+
+			wanted := []redis.ClusterSlot{
+				{0, 4999, []redis.ClusterNode{{"", "127.0.0.1:8220"}, {"", "127.0.0.1:8223"}}},
+				{5000, 9999, []redis.ClusterNode{{"", "127.0.0.1:8221"}, {"", "127.0.0.1:8224"}}},
+				{10000, 16383, []redis.ClusterNode{{"", "127.0.0.1:8222"}, {"", "127.0.0.1:8225"}}},
+			}
+			Expect(assertSlotsEqual(res, wanted)).NotTo(HaveOccurred())
+		})
+
+		It("should CLUSTER NODES", func() {
+			res, err := client.ClusterNodes().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(res)).To(BeNumerically(">", 400))
+		})
+
+		It("should CLUSTER INFO", func() {
+			res, err := client.ClusterInfo().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(ContainSubstring("cluster_known_nodes:6"))
+		})
+
+		It("should CLUSTER KEYSLOT", func() {
+			hashSlot, err := client.ClusterKeySlot("somekey").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(hashSlot).To(Equal(int64(hashtag.Slot("somekey"))))
+		})
+
+		It("should CLUSTER COUNT-FAILURE-REPORTS", func() {
+			n, err := client.ClusterCountFailureReports(cluster.nodeIds[0]).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(0)))
+		})
+
+		It("should CLUSTER COUNTKEYSINSLOT", func() {
+			n, err := client.ClusterCountKeysInSlot(10).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(0)))
+		})
+
+		It("should CLUSTER SAVECONFIG", func() {
+			res, err := client.ClusterSaveConfig().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+		})
+
+		It("should CLUSTER SLAVES", func() {
+			nodesList, err := client.ClusterSlaves(cluster.nodeIds[0]).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(nodesList).Should(ContainElement(ContainSubstring("slave")))
+			Expect(nodesList).Should(HaveLen(1))
+		})
+
+		assertClusterClient()
+	})
+
+	Describe("ClusterClient failover", func() {
+		BeforeEach(func() {
+			opt = redisClusterOptions()
+			client = cluster.clusterClient(opt)
+
+			_ = client.ForEachMaster(func(master *redis.Client) error {
+				return master.FlushDB().Err()
+			})
+
+			_ = client.ForEachSlave(func(slave *redis.Client) error {
+				Eventually(func() int64 {
+					return client.DBSize().Val()
+				}, 30*time.Second).Should(Equal(int64(0)))
+				return slave.ClusterFailover().Err()
+			})
+		})
+
+		AfterEach(func() {
+			Expect(client.Close()).NotTo(HaveOccurred())
+		})
+
+		assertClusterClient()
+	})
+
+	Describe("ClusterClient with RouteByLatency", func() {
+		BeforeEach(func() {
+			opt = redisClusterOptions()
+			opt.RouteByLatency = true
+			client = cluster.clusterClient(opt)
+
+			_ = client.ForEachMaster(func(master *redis.Client) error {
+				return master.FlushDB().Err()
+			})
+		})
+
+		AfterEach(func() {
+			client.FlushDB()
+			Expect(client.Close()).NotTo(HaveOccurred())
+		})
+
+		assertClusterClient()
+	})
+})
+
+var _ = Describe("ClusterClient without nodes", func() {
+	var client *redis.ClusterClient
+
+	BeforeEach(func() {
+		client = redis.NewClusterClient(&redis.ClusterOptions{})
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("returns an error", func() {
+		err := client.Ping().Err()
+		Expect(err).To(MatchError("redis: cluster has no nodes"))
+	})
+
+	It("pipeline returns an error", func() {
+		_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+			pipe.Ping()
+			return nil
+		})
+		Expect(err).To(MatchError("redis: cluster has no nodes"))
+	})
+})
+
+var _ = Describe("ClusterClient without valid nodes", func() {
+	var client *redis.ClusterClient
+
+	BeforeEach(func() {
+		client = redis.NewClusterClient(&redis.ClusterOptions{
+			Addrs: []string{redisAddr},
+		})
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("returns an error", func() {
+		err := client.Ping().Err()
+		Expect(err).To(MatchError("ERR This instance has cluster support disabled"))
+	})
+
+	It("pipeline returns an error", func() {
+		_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+			pipe.Ping()
+			return nil
+		})
+		Expect(err).To(MatchError("ERR This instance has cluster support disabled"))
+	})
+})
+
+var _ = Describe("ClusterClient timeout", func() {
+	var client *redis.ClusterClient
+
+	AfterEach(func() {
+		_ = client.Close()
+	})
+
+	testTimeout := func() {
+		It("Ping timeouts", func() {
+			err := client.Ping().Err()
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+
+		It("Pipeline timeouts", func() {
+			_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+				pipe.Ping()
+				return nil
+			})
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+
+		It("Tx timeouts", func() {
+			err := client.Watch(func(tx *redis.Tx) error {
+				return tx.Ping().Err()
+			})
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+
+		It("Tx Pipeline timeouts", func() {
+			err := client.Watch(func(tx *redis.Tx) error {
+				_, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+					pipe.Ping()
+					return nil
+				})
+				return err
+			})
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+	}
+
+	Context("read timeout", func() {
+		BeforeEach(func() {
+			opt := redisClusterOptions()
+			opt.ReadTimeout = time.Nanosecond
+			opt.WriteTimeout = -1
+			client = cluster.clusterClient(opt)
+		})
+
+		testTimeout()
+	})
+
+	Context("write timeout", func() {
+		BeforeEach(func() {
+			opt := redisClusterOptions()
+			opt.ReadTimeout = time.Nanosecond
+			opt.WriteTimeout = -1
+			client = cluster.clusterClient(opt)
+		})
+
+		testTimeout()
+	})
+
+	Context("ClientPause timeout", func() {
+		const pause = time.Second
+
+		BeforeEach(func() {
+			opt := redisClusterOptions()
+			opt.ReadTimeout = pause / 10
+			opt.WriteTimeout = pause / 10
+			opt.MaxRedirects = -1
+			client = cluster.clusterClient(opt)
+
+			err := client.ForEachNode(func(client *redis.Client) error {
+				return client.ClientPause(pause).Err()
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		AfterEach(func() {
+			client.ForEachNode(func(client *redis.Client) error {
+				Eventually(func() error {
+					return client.Ping().Err()
+				}, 2*pause).ShouldNot(HaveOccurred())
+				return nil
+			})
+		})
+
+		testTimeout()
+	})
+})
+
+//------------------------------------------------------------------------------
+
+func BenchmarkRedisClusterPing(b *testing.B) {
+	if testing.Short() {
+		b.Skip("skipping in short mode")
+	}
+
+	cluster := &clusterScenario{
+		ports:     []string{"8220", "8221", "8222", "8223", "8224", "8225"},
+		nodeIds:   make([]string, 6),
+		processes: make(map[string]*redisProcess, 6),
+		clients:   make(map[string]*redis.Client, 6),
+	}
+
+	if err := startCluster(cluster); err != nil {
+		b.Fatal(err)
+	}
+	defer stopCluster(cluster)
+
+	client := cluster.clusterClient(redisClusterOptions())
+	defer client.Close()
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Ping().Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkRedisClusterSetString(b *testing.B) {
+	if testing.Short() {
+		b.Skip("skipping in short mode")
+	}
+
+	cluster := &clusterScenario{
+		ports:     []string{"8220", "8221", "8222", "8223", "8224", "8225"},
+		nodeIds:   make([]string, 6),
+		processes: make(map[string]*redisProcess, 6),
+		clients:   make(map[string]*redis.Client, 6),
+	}
+
+	if err := startCluster(cluster); err != nil {
+		b.Fatal(err)
+	}
+	defer stopCluster(cluster)
+
+	client := cluster.clusterClient(redisClusterOptions())
+	defer client.Close()
+
+	value := string(bytes.Repeat([]byte{'1'}, 10000))
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			if err := client.Set("key", value, 0).Err(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
diff --git a/command.go b/command.go
new file mode 100644
index 00000000..0e5b2016
--- /dev/null
+++ b/command.go
@@ -0,0 +1,956 @@
+package redis
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+	"github.com/go-redis/redis/internal/pool"
+	"github.com/go-redis/redis/internal/proto"
+)
+
+var (
+	_ Cmder = (*Cmd)(nil)
+	_ Cmder = (*SliceCmd)(nil)
+	_ Cmder = (*StatusCmd)(nil)
+	_ Cmder = (*IntCmd)(nil)
+	_ Cmder = (*DurationCmd)(nil)
+	_ Cmder = (*BoolCmd)(nil)
+	_ Cmder = (*StringCmd)(nil)
+	_ Cmder = (*FloatCmd)(nil)
+	_ Cmder = (*StringSliceCmd)(nil)
+	_ Cmder = (*BoolSliceCmd)(nil)
+	_ Cmder = (*StringStringMapCmd)(nil)
+	_ Cmder = (*StringIntMapCmd)(nil)
+	_ Cmder = (*ZSliceCmd)(nil)
+	_ Cmder = (*ScanCmd)(nil)
+	_ Cmder = (*ClusterSlotsCmd)(nil)
+)
+
+type Cmder interface {
+	args() []interface{}
+	arg(int) string
+	Name() string
+
+	readReply(*pool.Conn) error
+	setErr(error)
+
+	readTimeout() *time.Duration
+
+	Err() error
+	fmt.Stringer
+}
+
+func setCmdsErr(cmds []Cmder, e error) {
+	for _, cmd := range cmds {
+		cmd.setErr(e)
+	}
+}
+
+func writeCmd(cn *pool.Conn, cmds ...Cmder) error {
+	cn.Wb.Reset()
+	for _, cmd := range cmds {
+		if err := cn.Wb.Append(cmd.args()); err != nil {
+			return err
+		}
+	}
+
+	_, err := cn.Write(cn.Wb.Bytes())
+	return err
+}
+
+func cmdString(cmd Cmder, val interface{}) string {
+	var ss []string
+	for _, arg := range cmd.args() {
+		ss = append(ss, fmt.Sprint(arg))
+	}
+	s := strings.Join(ss, " ")
+	if err := cmd.Err(); err != nil {
+		return s + ": " + err.Error()
+	}
+	if val != nil {
+		switch vv := val.(type) {
+		case []byte:
+			return s + ": " + string(vv)
+		default:
+			return s + ": " + fmt.Sprint(val)
+		}
+	}
+	return s
+
+}
+
+func cmdFirstKeyPos(cmd Cmder, info *CommandInfo) int {
+	switch cmd.Name() {
+	case "eval", "evalsha":
+		if cmd.arg(2) != "0" {
+			return 3
+		} else {
+			return -1
+		}
+	case "publish":
+		return 1
+	}
+	if info == nil {
+		internal.Logf("info for cmd=%s not found", cmd.Name())
+		return -1
+	}
+	return int(info.FirstKeyPos)
+}
+
+//------------------------------------------------------------------------------
+
+type baseCmd struct {
+	_args []interface{}
+	err   error
+
+	_readTimeout *time.Duration
+}
+
+func (cmd *baseCmd) Err() error {
+	return cmd.err
+}
+
+func (cmd *baseCmd) args() []interface{} {
+	return cmd._args
+}
+
+func (cmd *baseCmd) arg(pos int) string {
+	if pos < 0 || pos >= len(cmd._args) {
+		return ""
+	}
+	s, _ := cmd._args[pos].(string)
+	return s
+}
+
+func (cmd *baseCmd) Name() string {
+	if len(cmd._args) > 0 {
+		// Cmd name must be lower cased.
+		s := internal.ToLower(cmd.arg(0))
+		cmd._args[0] = s
+		return s
+	}
+	return ""
+}
+
+func (cmd *baseCmd) readTimeout() *time.Duration {
+	return cmd._readTimeout
+}
+
+func (cmd *baseCmd) setReadTimeout(d time.Duration) {
+	cmd._readTimeout = &d
+}
+
+func (cmd *baseCmd) setErr(e error) {
+	cmd.err = e
+}
+
+//------------------------------------------------------------------------------
+
+type Cmd struct {
+	baseCmd
+
+	val interface{}
+}
+
+func NewCmd(args ...interface{}) *Cmd {
+	return &Cmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *Cmd) Val() interface{} {
+	return cmd.val
+}
+
+func (cmd *Cmd) Result() (interface{}, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *Cmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *Cmd) readReply(cn *pool.Conn) error {
+	cmd.val, cmd.err = cn.Rd.ReadReply(sliceParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	if b, ok := cmd.val.([]byte); ok {
+		// Bytes must be copied, because underlying memory is reused.
+		cmd.val = string(b)
+	}
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type SliceCmd struct {
+	baseCmd
+
+	val []interface{}
+}
+
+func NewSliceCmd(args ...interface{}) *SliceCmd {
+	return &SliceCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *SliceCmd) Val() []interface{} {
+	return cmd.val
+}
+
+func (cmd *SliceCmd) Result() ([]interface{}, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *SliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *SliceCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(sliceParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.([]interface{})
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type StatusCmd struct {
+	baseCmd
+
+	val string
+}
+
+func NewStatusCmd(args ...interface{}) *StatusCmd {
+	return &StatusCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *StatusCmd) Val() string {
+	return cmd.val
+}
+
+func (cmd *StatusCmd) Result() (string, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *StatusCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *StatusCmd) readReply(cn *pool.Conn) error {
+	cmd.val, cmd.err = cn.Rd.ReadStringReply()
+	return cmd.err
+}
+
+//------------------------------------------------------------------------------
+
+type IntCmd struct {
+	baseCmd
+
+	val int64
+}
+
+func NewIntCmd(args ...interface{}) *IntCmd {
+	return &IntCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *IntCmd) Val() int64 {
+	return cmd.val
+}
+
+func (cmd *IntCmd) Result() (int64, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *IntCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *IntCmd) readReply(cn *pool.Conn) error {
+	cmd.val, cmd.err = cn.Rd.ReadIntReply()
+	return cmd.err
+}
+
+//------------------------------------------------------------------------------
+
+type DurationCmd struct {
+	baseCmd
+
+	val       time.Duration
+	precision time.Duration
+}
+
+func NewDurationCmd(precision time.Duration, args ...interface{}) *DurationCmd {
+	return &DurationCmd{
+		baseCmd:   baseCmd{_args: args},
+		precision: precision,
+	}
+}
+
+func (cmd *DurationCmd) Val() time.Duration {
+	return cmd.val
+}
+
+func (cmd *DurationCmd) Result() (time.Duration, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *DurationCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *DurationCmd) readReply(cn *pool.Conn) error {
+	var n int64
+	n, cmd.err = cn.Rd.ReadIntReply()
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = time.Duration(n) * cmd.precision
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type TimeCmd struct {
+	baseCmd
+
+	val time.Time
+}
+
+func NewTimeCmd(args ...interface{}) *TimeCmd {
+	return &TimeCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *TimeCmd) Val() time.Time {
+	return cmd.val
+}
+
+func (cmd *TimeCmd) Result() (time.Time, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *TimeCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *TimeCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(timeParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.(time.Time)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type BoolCmd struct {
+	baseCmd
+
+	val bool
+}
+
+func NewBoolCmd(args ...interface{}) *BoolCmd {
+	return &BoolCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *BoolCmd) Val() bool {
+	return cmd.val
+}
+
+func (cmd *BoolCmd) Result() (bool, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *BoolCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+var ok = []byte("OK")
+
+func (cmd *BoolCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadReply(nil)
+	// `SET key value NX` returns nil when key already exists. But
+	// `SETNX key value` returns bool (0/1). So convert nil to bool.
+	// TODO: is this okay?
+	if cmd.err == Nil {
+		cmd.val = false
+		cmd.err = nil
+		return nil
+	}
+	if cmd.err != nil {
+		return cmd.err
+	}
+	switch v := v.(type) {
+	case int64:
+		cmd.val = v == 1
+		return nil
+	case []byte:
+		cmd.val = bytes.Equal(v, ok)
+		return nil
+	default:
+		cmd.err = fmt.Errorf("got %T, wanted int64 or string", v)
+		return cmd.err
+	}
+}
+
+//------------------------------------------------------------------------------
+
+type StringCmd struct {
+	baseCmd
+
+	val []byte
+}
+
+func NewStringCmd(args ...interface{}) *StringCmd {
+	return &StringCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *StringCmd) Val() string {
+	return internal.BytesToString(cmd.val)
+}
+
+func (cmd *StringCmd) Result() (string, error) {
+	return cmd.Val(), cmd.err
+}
+
+func (cmd *StringCmd) Bytes() ([]byte, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *StringCmd) Int64() (int64, error) {
+	if cmd.err != nil {
+		return 0, cmd.err
+	}
+	return strconv.ParseInt(cmd.Val(), 10, 64)
+}
+
+func (cmd *StringCmd) Uint64() (uint64, error) {
+	if cmd.err != nil {
+		return 0, cmd.err
+	}
+	return strconv.ParseUint(cmd.Val(), 10, 64)
+}
+
+func (cmd *StringCmd) Float64() (float64, error) {
+	if cmd.err != nil {
+		return 0, cmd.err
+	}
+	return strconv.ParseFloat(cmd.Val(), 64)
+}
+
+func (cmd *StringCmd) Scan(val interface{}) error {
+	if cmd.err != nil {
+		return cmd.err
+	}
+	return proto.Scan(cmd.val, val)
+}
+
+func (cmd *StringCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *StringCmd) readReply(cn *pool.Conn) error {
+	cmd.val, cmd.err = cn.Rd.ReadBytesReply()
+	return cmd.err
+}
+
+//------------------------------------------------------------------------------
+
+type FloatCmd struct {
+	baseCmd
+
+	val float64
+}
+
+func NewFloatCmd(args ...interface{}) *FloatCmd {
+	return &FloatCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *FloatCmd) Val() float64 {
+	return cmd.val
+}
+
+func (cmd *FloatCmd) Result() (float64, error) {
+	return cmd.Val(), cmd.Err()
+}
+
+func (cmd *FloatCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *FloatCmd) readReply(cn *pool.Conn) error {
+	cmd.val, cmd.err = cn.Rd.ReadFloatReply()
+	return cmd.err
+}
+
+//------------------------------------------------------------------------------
+
+type StringSliceCmd struct {
+	baseCmd
+
+	val []string
+}
+
+func NewStringSliceCmd(args ...interface{}) *StringSliceCmd {
+	return &StringSliceCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *StringSliceCmd) Val() []string {
+	return cmd.val
+}
+
+func (cmd *StringSliceCmd) Result() ([]string, error) {
+	return cmd.Val(), cmd.Err()
+}
+
+func (cmd *StringSliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *StringSliceCmd) ScanSlice(container interface{}) error {
+	return proto.ScanSlice(cmd.Val(), container)
+}
+
+func (cmd *StringSliceCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(stringSliceParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.([]string)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type BoolSliceCmd struct {
+	baseCmd
+
+	val []bool
+}
+
+func NewBoolSliceCmd(args ...interface{}) *BoolSliceCmd {
+	return &BoolSliceCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *BoolSliceCmd) Val() []bool {
+	return cmd.val
+}
+
+func (cmd *BoolSliceCmd) Result() ([]bool, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *BoolSliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *BoolSliceCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(boolSliceParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.([]bool)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type StringStringMapCmd struct {
+	baseCmd
+
+	val map[string]string
+}
+
+func NewStringStringMapCmd(args ...interface{}) *StringStringMapCmd {
+	return &StringStringMapCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *StringStringMapCmd) Val() map[string]string {
+	return cmd.val
+}
+
+func (cmd *StringStringMapCmd) Result() (map[string]string, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *StringStringMapCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *StringStringMapCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(stringStringMapParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.(map[string]string)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type StringIntMapCmd struct {
+	baseCmd
+
+	val map[string]int64
+}
+
+func NewStringIntMapCmd(args ...interface{}) *StringIntMapCmd {
+	return &StringIntMapCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *StringIntMapCmd) Val() map[string]int64 {
+	return cmd.val
+}
+
+func (cmd *StringIntMapCmd) Result() (map[string]int64, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *StringIntMapCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *StringIntMapCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(stringIntMapParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.(map[string]int64)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type ZSliceCmd struct {
+	baseCmd
+
+	val []Z
+}
+
+func NewZSliceCmd(args ...interface{}) *ZSliceCmd {
+	return &ZSliceCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *ZSliceCmd) Val() []Z {
+	return cmd.val
+}
+
+func (cmd *ZSliceCmd) Result() ([]Z, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *ZSliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *ZSliceCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(zSliceParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.([]Z)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type ScanCmd struct {
+	baseCmd
+
+	page   []string
+	cursor uint64
+
+	process func(cmd Cmder) error
+}
+
+func NewScanCmd(process func(cmd Cmder) error, args ...interface{}) *ScanCmd {
+	return &ScanCmd{
+		baseCmd: baseCmd{_args: args},
+		process: process,
+	}
+}
+
+func (cmd *ScanCmd) Val() (keys []string, cursor uint64) {
+	return cmd.page, cmd.cursor
+}
+
+func (cmd *ScanCmd) Result() (keys []string, cursor uint64, err error) {
+	return cmd.page, cmd.cursor, cmd.err
+}
+
+func (cmd *ScanCmd) String() string {
+	return cmdString(cmd, cmd.page)
+}
+
+func (cmd *ScanCmd) readReply(cn *pool.Conn) error {
+	cmd.page, cmd.cursor, cmd.err = cn.Rd.ReadScanReply()
+	return cmd.err
+}
+
+// Iterator creates a new ScanIterator.
+func (cmd *ScanCmd) Iterator() *ScanIterator {
+	return &ScanIterator{
+		cmd: cmd,
+	}
+}
+
+//------------------------------------------------------------------------------
+
+type ClusterNode struct {
+	Id   string
+	Addr string
+}
+
+type ClusterSlot struct {
+	Start int
+	End   int
+	Nodes []ClusterNode
+}
+
+type ClusterSlotsCmd struct {
+	baseCmd
+
+	val []ClusterSlot
+}
+
+func NewClusterSlotsCmd(args ...interface{}) *ClusterSlotsCmd {
+	return &ClusterSlotsCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *ClusterSlotsCmd) Val() []ClusterSlot {
+	return cmd.val
+}
+
+func (cmd *ClusterSlotsCmd) Result() ([]ClusterSlot, error) {
+	return cmd.Val(), cmd.Err()
+}
+
+func (cmd *ClusterSlotsCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *ClusterSlotsCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(clusterSlotsParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.([]ClusterSlot)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+// GeoLocation is used with GeoAdd to add geospatial location.
+type GeoLocation struct {
+	Name                      string
+	Longitude, Latitude, Dist float64
+	GeoHash                   int64
+}
+
+// GeoRadiusQuery is used with GeoRadius to query geospatial index.
+type GeoRadiusQuery struct {
+	Radius float64
+	// Can be m, km, ft, or mi. Default is km.
+	Unit        string
+	WithCoord   bool
+	WithDist    bool
+	WithGeoHash bool
+	Count       int
+	// Can be ASC or DESC. Default is no sort order.
+	Sort      string
+	Store     string
+	StoreDist string
+}
+
+type GeoLocationCmd struct {
+	baseCmd
+
+	q         *GeoRadiusQuery
+	locations []GeoLocation
+}
+
+func NewGeoLocationCmd(q *GeoRadiusQuery, args ...interface{}) *GeoLocationCmd {
+	args = append(args, q.Radius)
+	if q.Unit != "" {
+		args = append(args, q.Unit)
+	} else {
+		args = append(args, "km")
+	}
+	if q.WithCoord {
+		args = append(args, "withcoord")
+	}
+	if q.WithDist {
+		args = append(args, "withdist")
+	}
+	if q.WithGeoHash {
+		args = append(args, "withhash")
+	}
+	if q.Count > 0 {
+		args = append(args, "count", q.Count)
+	}
+	if q.Sort != "" {
+		args = append(args, q.Sort)
+	}
+	if q.Store != "" {
+		args = append(args, "store")
+		args = append(args, q.Store)
+	}
+	if q.StoreDist != "" {
+		args = append(args, "storedist")
+		args = append(args, q.StoreDist)
+	}
+	return &GeoLocationCmd{
+		baseCmd: baseCmd{_args: args},
+		q:       q,
+	}
+}
+
+func (cmd *GeoLocationCmd) Val() []GeoLocation {
+	return cmd.locations
+}
+
+func (cmd *GeoLocationCmd) Result() ([]GeoLocation, error) {
+	return cmd.locations, cmd.err
+}
+
+func (cmd *GeoLocationCmd) String() string {
+	return cmdString(cmd, cmd.locations)
+}
+
+func (cmd *GeoLocationCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(newGeoLocationSliceParser(cmd.q))
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.locations = v.([]GeoLocation)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type GeoPos struct {
+	Longitude, Latitude float64
+}
+
+type GeoPosCmd struct {
+	baseCmd
+
+	positions []*GeoPos
+}
+
+func NewGeoPosCmd(args ...interface{}) *GeoPosCmd {
+	return &GeoPosCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *GeoPosCmd) Val() []*GeoPos {
+	return cmd.positions
+}
+
+func (cmd *GeoPosCmd) Result() ([]*GeoPos, error) {
+	return cmd.Val(), cmd.Err()
+}
+
+func (cmd *GeoPosCmd) String() string {
+	return cmdString(cmd, cmd.positions)
+}
+
+func (cmd *GeoPosCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(geoPosSliceParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.positions = v.([]*GeoPos)
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+type CommandInfo struct {
+	Name        string
+	Arity       int8
+	Flags       []string
+	FirstKeyPos int8
+	LastKeyPos  int8
+	StepCount   int8
+	ReadOnly    bool
+}
+
+type CommandsInfoCmd struct {
+	baseCmd
+
+	val map[string]*CommandInfo
+}
+
+func NewCommandsInfoCmd(args ...interface{}) *CommandsInfoCmd {
+	return &CommandsInfoCmd{
+		baseCmd: baseCmd{_args: args},
+	}
+}
+
+func (cmd *CommandsInfoCmd) Val() map[string]*CommandInfo {
+	return cmd.val
+}
+
+func (cmd *CommandsInfoCmd) Result() (map[string]*CommandInfo, error) {
+	return cmd.Val(), cmd.Err()
+}
+
+func (cmd *CommandsInfoCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *CommandsInfoCmd) readReply(cn *pool.Conn) error {
+	var v interface{}
+	v, cmd.err = cn.Rd.ReadArrayReply(commandInfoSliceParser)
+	if cmd.err != nil {
+		return cmd.err
+	}
+	cmd.val = v.(map[string]*CommandInfo)
+	return nil
+}
diff --git a/command_test.go b/command_test.go
new file mode 100644
index 00000000..e42375ed
--- /dev/null
+++ b/command_test.go
@@ -0,0 +1,60 @@
+package redis_test
+
+import (
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Cmd", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("implements Stringer", func() {
+		set := client.Set("foo", "bar", 0)
+		Expect(set.String()).To(Equal("set foo bar: OK"))
+
+		get := client.Get("foo")
+		Expect(get.String()).To(Equal("get foo: bar"))
+	})
+
+	It("has val/err", func() {
+		set := client.Set("key", "hello", 0)
+		Expect(set.Err()).NotTo(HaveOccurred())
+		Expect(set.Val()).To(Equal("OK"))
+
+		get := client.Get("key")
+		Expect(get.Err()).NotTo(HaveOccurred())
+		Expect(get.Val()).To(Equal("hello"))
+
+		Expect(set.Err()).NotTo(HaveOccurred())
+		Expect(set.Val()).To(Equal("OK"))
+	})
+
+	It("has helpers", func() {
+		set := client.Set("key", "10", 0)
+		Expect(set.Err()).NotTo(HaveOccurred())
+
+		n, err := client.Get("key").Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(10)))
+
+		un, err := client.Get("key").Uint64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(un).To(Equal(uint64(10)))
+
+		f, err := client.Get("key").Float64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(f).To(Equal(float64(10)))
+	})
+
+})
diff --git a/commands.go b/commands.go
new file mode 100644
index 00000000..83b3824f
--- /dev/null
+++ b/commands.go
@@ -0,0 +1,2133 @@
+package redis
+
+import (
+	"io"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+)
+
+func readTimeout(timeout time.Duration) time.Duration {
+	if timeout == 0 {
+		return 0
+	}
+	return timeout + time.Second
+}
+
+func usePrecise(dur time.Duration) bool {
+	return dur < time.Second || dur%time.Second != 0
+}
+
+func formatMs(dur time.Duration) int64 {
+	if dur > 0 && dur < time.Millisecond {
+		internal.Logf(
+			"specified duration is %s, but minimal supported value is %s",
+			dur, time.Millisecond,
+		)
+	}
+	return int64(dur / time.Millisecond)
+}
+
+func formatSec(dur time.Duration) int64 {
+	if dur > 0 && dur < time.Second {
+		internal.Logf(
+			"specified duration is %s, but minimal supported value is %s",
+			dur, time.Second,
+		)
+	}
+	return int64(dur / time.Second)
+}
+
+type Cmdable interface {
+	Pipeline() Pipeliner
+	Pipelined(fn func(Pipeliner) error) ([]Cmder, error)
+
+	ClientGetName() *StringCmd
+	Echo(message interface{}) *StringCmd
+	Ping() *StatusCmd
+	Quit() *StatusCmd
+	Del(keys ...string) *IntCmd
+	Unlink(keys ...string) *IntCmd
+	Dump(key string) *StringCmd
+	Exists(keys ...string) *IntCmd
+	Expire(key string, expiration time.Duration) *BoolCmd
+	ExpireAt(key string, tm time.Time) *BoolCmd
+	Keys(pattern string) *StringSliceCmd
+	Migrate(host, port, key string, db int64, timeout time.Duration) *StatusCmd
+	Move(key string, db int64) *BoolCmd
+	ObjectRefCount(key string) *IntCmd
+	ObjectEncoding(key string) *StringCmd
+	ObjectIdleTime(key string) *DurationCmd
+	Persist(key string) *BoolCmd
+	PExpire(key string, expiration time.Duration) *BoolCmd
+	PExpireAt(key string, tm time.Time) *BoolCmd
+	PTTL(key string) *DurationCmd
+	RandomKey() *StringCmd
+	Rename(key, newkey string) *StatusCmd
+	RenameNX(key, newkey string) *BoolCmd
+	Restore(key string, ttl time.Duration, value string) *StatusCmd
+	RestoreReplace(key string, ttl time.Duration, value string) *StatusCmd
+	Sort(key string, sort Sort) *StringSliceCmd
+	SortInterfaces(key string, sort Sort) *SliceCmd
+	TTL(key string) *DurationCmd
+	Type(key string) *StatusCmd
+	Scan(cursor uint64, match string, count int64) *ScanCmd
+	SScan(key string, cursor uint64, match string, count int64) *ScanCmd
+	HScan(key string, cursor uint64, match string, count int64) *ScanCmd
+	ZScan(key string, cursor uint64, match string, count int64) *ScanCmd
+	Append(key, value string) *IntCmd
+	BitCount(key string, bitCount *BitCount) *IntCmd
+	BitOpAnd(destKey string, keys ...string) *IntCmd
+	BitOpOr(destKey string, keys ...string) *IntCmd
+	BitOpXor(destKey string, keys ...string) *IntCmd
+	BitOpNot(destKey string, key string) *IntCmd
+	BitPos(key string, bit int64, pos ...int64) *IntCmd
+	Decr(key string) *IntCmd
+	DecrBy(key string, decrement int64) *IntCmd
+	Get(key string) *StringCmd
+	GetBit(key string, offset int64) *IntCmd
+	GetRange(key string, start, end int64) *StringCmd
+	GetSet(key string, value interface{}) *StringCmd
+	Incr(key string) *IntCmd
+	IncrBy(key string, value int64) *IntCmd
+	IncrByFloat(key string, value float64) *FloatCmd
+	MGet(keys ...string) *SliceCmd
+	MSet(pairs ...interface{}) *StatusCmd
+	MSetNX(pairs ...interface{}) *BoolCmd
+	Set(key string, value interface{}, expiration time.Duration) *StatusCmd
+	SetBit(key string, offset int64, value int) *IntCmd
+	SetNX(key string, value interface{}, expiration time.Duration) *BoolCmd
+	SetXX(key string, value interface{}, expiration time.Duration) *BoolCmd
+	SetRange(key string, offset int64, value string) *IntCmd
+	StrLen(key string) *IntCmd
+	HDel(key string, fields ...string) *IntCmd
+	HExists(key, field string) *BoolCmd
+	HGet(key, field string) *StringCmd
+	HGetAll(key string) *StringStringMapCmd
+	HIncrBy(key, field string, incr int64) *IntCmd
+	HIncrByFloat(key, field string, incr float64) *FloatCmd
+	HKeys(key string) *StringSliceCmd
+	HLen(key string) *IntCmd
+	HMGet(key string, fields ...string) *SliceCmd
+	HMSet(key string, fields map[string]interface{}) *StatusCmd
+	HSet(key, field string, value interface{}) *BoolCmd
+	HSetNX(key, field string, value interface{}) *BoolCmd
+	HVals(key string) *StringSliceCmd
+	BLPop(timeout time.Duration, keys ...string) *StringSliceCmd
+	BRPop(timeout time.Duration, keys ...string) *StringSliceCmd
+	BRPopLPush(source, destination string, timeout time.Duration) *StringCmd
+	LIndex(key string, index int64) *StringCmd
+	LInsert(key, op string, pivot, value interface{}) *IntCmd
+	LInsertBefore(key string, pivot, value interface{}) *IntCmd
+	LInsertAfter(key string, pivot, value interface{}) *IntCmd
+	LLen(key string) *IntCmd
+	LPop(key string) *StringCmd
+	LPush(key string, values ...interface{}) *IntCmd
+	LPushX(key string, value interface{}) *IntCmd
+	LRange(key string, start, stop int64) *StringSliceCmd
+	LRem(key string, count int64, value interface{}) *IntCmd
+	LSet(key string, index int64, value interface{}) *StatusCmd
+	LTrim(key string, start, stop int64) *StatusCmd
+	RPop(key string) *StringCmd
+	RPopLPush(source, destination string) *StringCmd
+	RPush(key string, values ...interface{}) *IntCmd
+	RPushX(key string, value interface{}) *IntCmd
+	SAdd(key string, members ...interface{}) *IntCmd
+	SCard(key string) *IntCmd
+	SDiff(keys ...string) *StringSliceCmd
+	SDiffStore(destination string, keys ...string) *IntCmd
+	SInter(keys ...string) *StringSliceCmd
+	SInterStore(destination string, keys ...string) *IntCmd
+	SIsMember(key string, member interface{}) *BoolCmd
+	SMembers(key string) *StringSliceCmd
+	SMove(source, destination string, member interface{}) *BoolCmd
+	SPop(key string) *StringCmd
+	SPopN(key string, count int64) *StringSliceCmd
+	SRandMember(key string) *StringCmd
+	SRandMemberN(key string, count int64) *StringSliceCmd
+	SRem(key string, members ...interface{}) *IntCmd
+	SUnion(keys ...string) *StringSliceCmd
+	SUnionStore(destination string, keys ...string) *IntCmd
+	ZAdd(key string, members ...Z) *IntCmd
+	ZAddNX(key string, members ...Z) *IntCmd
+	ZAddXX(key string, members ...Z) *IntCmd
+	ZAddCh(key string, members ...Z) *IntCmd
+	ZAddNXCh(key string, members ...Z) *IntCmd
+	ZAddXXCh(key string, members ...Z) *IntCmd
+	ZIncr(key string, member Z) *FloatCmd
+	ZIncrNX(key string, member Z) *FloatCmd
+	ZIncrXX(key string, member Z) *FloatCmd
+	ZCard(key string) *IntCmd
+	ZCount(key, min, max string) *IntCmd
+	ZLexCount(key, min, max string) *IntCmd
+	ZIncrBy(key string, increment float64, member string) *FloatCmd
+	ZInterStore(destination string, store ZStore, keys ...string) *IntCmd
+	ZRange(key string, start, stop int64) *StringSliceCmd
+	ZRangeWithScores(key string, start, stop int64) *ZSliceCmd
+	ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
+	ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
+	ZRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd
+	ZRank(key, member string) *IntCmd
+	ZRem(key string, members ...interface{}) *IntCmd
+	ZRemRangeByRank(key string, start, stop int64) *IntCmd
+	ZRemRangeByScore(key, min, max string) *IntCmd
+	ZRemRangeByLex(key, min, max string) *IntCmd
+	ZRevRange(key string, start, stop int64) *StringSliceCmd
+	ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd
+	ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd
+	ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd
+	ZRevRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd
+	ZRevRank(key, member string) *IntCmd
+	ZScore(key, member string) *FloatCmd
+	ZUnionStore(dest string, store ZStore, keys ...string) *IntCmd
+	PFAdd(key string, els ...interface{}) *IntCmd
+	PFCount(keys ...string) *IntCmd
+	PFMerge(dest string, keys ...string) *StatusCmd
+	BgRewriteAOF() *StatusCmd
+	BgSave() *StatusCmd
+	ClientKill(ipPort string) *StatusCmd
+	ClientList() *StringCmd
+	ClientPause(dur time.Duration) *BoolCmd
+	ConfigGet(parameter string) *SliceCmd
+	ConfigResetStat() *StatusCmd
+	ConfigSet(parameter, value string) *StatusCmd
+	DBSize() *IntCmd
+	FlushAll() *StatusCmd
+	FlushAllAsync() *StatusCmd
+	FlushDB() *StatusCmd
+	FlushDBAsync() *StatusCmd
+	Info(section ...string) *StringCmd
+	LastSave() *IntCmd
+	Save() *StatusCmd
+	Shutdown() *StatusCmd
+	ShutdownSave() *StatusCmd
+	ShutdownNoSave() *StatusCmd
+	SlaveOf(host, port string) *StatusCmd
+	Time() *TimeCmd
+	Eval(script string, keys []string, args ...interface{}) *Cmd
+	EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd
+	ScriptExists(scripts ...string) *BoolSliceCmd
+	ScriptFlush() *StatusCmd
+	ScriptKill() *StatusCmd
+	ScriptLoad(script string) *StringCmd
+	DebugObject(key string) *StringCmd
+	PubSubChannels(pattern string) *StringSliceCmd
+	PubSubNumSub(channels ...string) *StringIntMapCmd
+	PubSubNumPat() *IntCmd
+	ClusterSlots() *ClusterSlotsCmd
+	ClusterNodes() *StringCmd
+	ClusterMeet(host, port string) *StatusCmd
+	ClusterForget(nodeID string) *StatusCmd
+	ClusterReplicate(nodeID string) *StatusCmd
+	ClusterResetSoft() *StatusCmd
+	ClusterResetHard() *StatusCmd
+	ClusterInfo() *StringCmd
+	ClusterKeySlot(key string) *IntCmd
+	ClusterCountFailureReports(nodeID string) *IntCmd
+	ClusterCountKeysInSlot(slot int) *IntCmd
+	ClusterDelSlots(slots ...int) *StatusCmd
+	ClusterDelSlotsRange(min, max int) *StatusCmd
+	ClusterSaveConfig() *StatusCmd
+	ClusterSlaves(nodeID string) *StringSliceCmd
+	ClusterFailover() *StatusCmd
+	ClusterAddSlots(slots ...int) *StatusCmd
+	ClusterAddSlotsRange(min, max int) *StatusCmd
+	GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd
+	GeoPos(key string, members ...string) *GeoPosCmd
+	GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
+	GeoRadiusRO(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
+	GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
+	GeoRadiusByMemberRO(key, member string, query *GeoRadiusQuery) *GeoLocationCmd
+	GeoDist(key string, member1, member2, unit string) *FloatCmd
+	GeoHash(key string, members ...string) *StringSliceCmd
+	Command() *CommandsInfoCmd
+}
+
+type StatefulCmdable interface {
+	Cmdable
+	Auth(password string) *StatusCmd
+	Select(index int) *StatusCmd
+	ClientSetName(name string) *BoolCmd
+	ReadOnly() *StatusCmd
+	ReadWrite() *StatusCmd
+}
+
+var _ Cmdable = (*Client)(nil)
+var _ Cmdable = (*Tx)(nil)
+var _ Cmdable = (*Ring)(nil)
+var _ Cmdable = (*ClusterClient)(nil)
+
+type cmdable struct {
+	process func(cmd Cmder) error
+}
+
+func (c *cmdable) setProcessor(fn func(Cmder) error) {
+	c.process = fn
+}
+
+type statefulCmdable struct {
+	cmdable
+	process func(cmd Cmder) error
+}
+
+func (c *statefulCmdable) setProcessor(fn func(Cmder) error) {
+	c.process = fn
+	c.cmdable.setProcessor(fn)
+}
+
+//------------------------------------------------------------------------------
+
+func (c *statefulCmdable) Auth(password string) *StatusCmd {
+	cmd := NewStatusCmd("auth", password)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Echo(message interface{}) *StringCmd {
+	cmd := NewStringCmd("echo", message)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Ping() *StatusCmd {
+	cmd := NewStatusCmd("ping")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Wait(numSlaves int, timeout time.Duration) *IntCmd {
+	cmd := NewIntCmd("wait", numSlaves, int(timeout/time.Millisecond))
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Quit() *StatusCmd {
+	panic("not implemented")
+}
+
+func (c *statefulCmdable) Select(index int) *StatusCmd {
+	cmd := NewStatusCmd("select", index)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) Del(keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "del"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Unlink(keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "unlink"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Dump(key string) *StringCmd {
+	cmd := NewStringCmd("dump", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Exists(keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "exists"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Expire(key string, expiration time.Duration) *BoolCmd {
+	cmd := NewBoolCmd("expire", key, formatSec(expiration))
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ExpireAt(key string, tm time.Time) *BoolCmd {
+	cmd := NewBoolCmd("expireat", key, tm.Unix())
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Keys(pattern string) *StringSliceCmd {
+	cmd := NewStringSliceCmd("keys", pattern)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Migrate(host, port, key string, db int64, timeout time.Duration) *StatusCmd {
+	cmd := NewStatusCmd(
+		"migrate",
+		host,
+		port,
+		key,
+		db,
+		formatMs(timeout),
+	)
+	cmd.setReadTimeout(readTimeout(timeout))
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Move(key string, db int64) *BoolCmd {
+	cmd := NewBoolCmd("move", key, db)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ObjectRefCount(key string) *IntCmd {
+	cmd := NewIntCmd("object", "refcount", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ObjectEncoding(key string) *StringCmd {
+	cmd := NewStringCmd("object", "encoding", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ObjectIdleTime(key string) *DurationCmd {
+	cmd := NewDurationCmd(time.Second, "object", "idletime", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Persist(key string) *BoolCmd {
+	cmd := NewBoolCmd("persist", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PExpire(key string, expiration time.Duration) *BoolCmd {
+	cmd := NewBoolCmd("pexpire", key, formatMs(expiration))
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PExpireAt(key string, tm time.Time) *BoolCmd {
+	cmd := NewBoolCmd(
+		"pexpireat",
+		key,
+		tm.UnixNano()/int64(time.Millisecond),
+	)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PTTL(key string) *DurationCmd {
+	cmd := NewDurationCmd(time.Millisecond, "pttl", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) RandomKey() *StringCmd {
+	cmd := NewStringCmd("randomkey")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Rename(key, newkey string) *StatusCmd {
+	cmd := NewStatusCmd("rename", key, newkey)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) RenameNX(key, newkey string) *BoolCmd {
+	cmd := NewBoolCmd("renamenx", key, newkey)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Restore(key string, ttl time.Duration, value string) *StatusCmd {
+	cmd := NewStatusCmd(
+		"restore",
+		key,
+		formatMs(ttl),
+		value,
+	)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) RestoreReplace(key string, ttl time.Duration, value string) *StatusCmd {
+	cmd := NewStatusCmd(
+		"restore",
+		key,
+		formatMs(ttl),
+		value,
+		"replace",
+	)
+	c.process(cmd)
+	return cmd
+}
+
+type Sort struct {
+	By            string
+	Offset, Count float64
+	Get           []string
+	Order         string
+	IsAlpha       bool
+	Store         string
+}
+
+func (sort *Sort) args(key string) []interface{} {
+	args := []interface{}{"sort", key}
+	if sort.By != "" {
+		args = append(args, "by", sort.By)
+	}
+	if sort.Offset != 0 || sort.Count != 0 {
+		args = append(args, "limit", sort.Offset, sort.Count)
+	}
+	for _, get := range sort.Get {
+		args = append(args, "get", get)
+	}
+	if sort.Order != "" {
+		args = append(args, sort.Order)
+	}
+	if sort.IsAlpha {
+		args = append(args, "alpha")
+	}
+	if sort.Store != "" {
+		args = append(args, "store", sort.Store)
+	}
+	return args
+}
+
+func (c *cmdable) Sort(key string, sort Sort) *StringSliceCmd {
+	cmd := NewStringSliceCmd(sort.args(key)...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SortInterfaces(key string, sort Sort) *SliceCmd {
+	cmd := NewSliceCmd(sort.args(key)...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) TTL(key string) *DurationCmd {
+	cmd := NewDurationCmd(time.Second, "ttl", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Type(key string) *StatusCmd {
+	cmd := NewStatusCmd("type", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Scan(cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"scan", cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(c.process, args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SScan(key string, cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"sscan", key, cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(c.process, args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HScan(key string, cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"hscan", key, cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(c.process, args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZScan(key string, cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"zscan", key, cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(c.process, args...)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) Append(key, value string) *IntCmd {
+	cmd := NewIntCmd("append", key, value)
+	c.process(cmd)
+	return cmd
+}
+
+type BitCount struct {
+	Start, End int64
+}
+
+func (c *cmdable) BitCount(key string, bitCount *BitCount) *IntCmd {
+	args := []interface{}{"bitcount", key}
+	if bitCount != nil {
+		args = append(
+			args,
+			bitCount.Start,
+			bitCount.End,
+		)
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) bitOp(op, destKey string, keys ...string) *IntCmd {
+	args := make([]interface{}, 3+len(keys))
+	args[0] = "bitop"
+	args[1] = op
+	args[2] = destKey
+	for i, key := range keys {
+		args[3+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) BitOpAnd(destKey string, keys ...string) *IntCmd {
+	return c.bitOp("and", destKey, keys...)
+}
+
+func (c *cmdable) BitOpOr(destKey string, keys ...string) *IntCmd {
+	return c.bitOp("or", destKey, keys...)
+}
+
+func (c *cmdable) BitOpXor(destKey string, keys ...string) *IntCmd {
+	return c.bitOp("xor", destKey, keys...)
+}
+
+func (c *cmdable) BitOpNot(destKey string, key string) *IntCmd {
+	return c.bitOp("not", destKey, key)
+}
+
+func (c *cmdable) BitPos(key string, bit int64, pos ...int64) *IntCmd {
+	args := make([]interface{}, 3+len(pos))
+	args[0] = "bitpos"
+	args[1] = key
+	args[2] = bit
+	switch len(pos) {
+	case 0:
+	case 1:
+		args[3] = pos[0]
+	case 2:
+		args[3] = pos[0]
+		args[4] = pos[1]
+	default:
+		panic("too many arguments")
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Decr(key string) *IntCmd {
+	cmd := NewIntCmd("decr", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) DecrBy(key string, decrement int64) *IntCmd {
+	cmd := NewIntCmd("decrby", key, decrement)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Get(key string) *StringCmd {
+	cmd := NewStringCmd("get", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GetBit(key string, offset int64) *IntCmd {
+	cmd := NewIntCmd("getbit", key, offset)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GetRange(key string, start, end int64) *StringCmd {
+	cmd := NewStringCmd("getrange", key, start, end)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GetSet(key string, value interface{}) *StringCmd {
+	cmd := NewStringCmd("getset", key, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Incr(key string) *IntCmd {
+	cmd := NewIntCmd("incr", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) IncrBy(key string, value int64) *IntCmd {
+	cmd := NewIntCmd("incrby", key, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) IncrByFloat(key string, value float64) *FloatCmd {
+	cmd := NewFloatCmd("incrbyfloat", key, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) MGet(keys ...string) *SliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "mget"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) MSet(pairs ...interface{}) *StatusCmd {
+	args := make([]interface{}, 1+len(pairs))
+	args[0] = "mset"
+	for i, pair := range pairs {
+		args[1+i] = pair
+	}
+	cmd := NewStatusCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) MSetNX(pairs ...interface{}) *BoolCmd {
+	args := make([]interface{}, 1+len(pairs))
+	args[0] = "msetnx"
+	for i, pair := range pairs {
+		args[1+i] = pair
+	}
+	cmd := NewBoolCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `SET key value [expiration]` command.
+//
+// Use expiration for `SETEX`-like behavior.
+// Zero expiration means the key has no expiration time.
+func (c *cmdable) Set(key string, value interface{}, expiration time.Duration) *StatusCmd {
+	args := make([]interface{}, 3, 4)
+	args[0] = "set"
+	args[1] = key
+	args[2] = value
+	if expiration > 0 {
+		if usePrecise(expiration) {
+			args = append(args, "px", formatMs(expiration))
+		} else {
+			args = append(args, "ex", formatSec(expiration))
+		}
+	}
+	cmd := NewStatusCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SetBit(key string, offset int64, value int) *IntCmd {
+	cmd := NewIntCmd(
+		"setbit",
+		key,
+		offset,
+		value,
+	)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `SET key value [expiration] NX` command.
+//
+// Zero expiration means the key has no expiration time.
+func (c *cmdable) SetNX(key string, value interface{}, expiration time.Duration) *BoolCmd {
+	var cmd *BoolCmd
+	if expiration == 0 {
+		// Use old `SETNX` to support old Redis versions.
+		cmd = NewBoolCmd("setnx", key, value)
+	} else {
+		if usePrecise(expiration) {
+			cmd = NewBoolCmd("set", key, value, "px", formatMs(expiration), "nx")
+		} else {
+			cmd = NewBoolCmd("set", key, value, "ex", formatSec(expiration), "nx")
+		}
+	}
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `SET key value [expiration] XX` command.
+//
+// Zero expiration means the key has no expiration time.
+func (c *cmdable) SetXX(key string, value interface{}, expiration time.Duration) *BoolCmd {
+	var cmd *BoolCmd
+	if expiration == 0 {
+		cmd = NewBoolCmd("set", key, value, "xx")
+	} else {
+		if usePrecise(expiration) {
+			cmd = NewBoolCmd("set", key, value, "px", formatMs(expiration), "xx")
+		} else {
+			cmd = NewBoolCmd("set", key, value, "ex", formatSec(expiration), "xx")
+		}
+	}
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SetRange(key string, offset int64, value string) *IntCmd {
+	cmd := NewIntCmd("setrange", key, offset, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) StrLen(key string) *IntCmd {
+	cmd := NewIntCmd("strlen", key)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) HDel(key string, fields ...string) *IntCmd {
+	args := make([]interface{}, 2+len(fields))
+	args[0] = "hdel"
+	args[1] = key
+	for i, field := range fields {
+		args[2+i] = field
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HExists(key, field string) *BoolCmd {
+	cmd := NewBoolCmd("hexists", key, field)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HGet(key, field string) *StringCmd {
+	cmd := NewStringCmd("hget", key, field)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HGetAll(key string) *StringStringMapCmd {
+	cmd := NewStringStringMapCmd("hgetall", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HIncrBy(key, field string, incr int64) *IntCmd {
+	cmd := NewIntCmd("hincrby", key, field, incr)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HIncrByFloat(key, field string, incr float64) *FloatCmd {
+	cmd := NewFloatCmd("hincrbyfloat", key, field, incr)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HKeys(key string) *StringSliceCmd {
+	cmd := NewStringSliceCmd("hkeys", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HLen(key string) *IntCmd {
+	cmd := NewIntCmd("hlen", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HMGet(key string, fields ...string) *SliceCmd {
+	args := make([]interface{}, 2+len(fields))
+	args[0] = "hmget"
+	args[1] = key
+	for i, field := range fields {
+		args[2+i] = field
+	}
+	cmd := NewSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HMSet(key string, fields map[string]interface{}) *StatusCmd {
+	args := make([]interface{}, 2+len(fields)*2)
+	args[0] = "hmset"
+	args[1] = key
+	i := 2
+	for k, v := range fields {
+		args[i] = k
+		args[i+1] = v
+		i += 2
+	}
+	cmd := NewStatusCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HSet(key, field string, value interface{}) *BoolCmd {
+	cmd := NewBoolCmd("hset", key, field, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HSetNX(key, field string, value interface{}) *BoolCmd {
+	cmd := NewBoolCmd("hsetnx", key, field, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) HVals(key string) *StringSliceCmd {
+	cmd := NewStringSliceCmd("hvals", key)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) BLPop(timeout time.Duration, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys)+1)
+	args[0] = "blpop"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	args[len(args)-1] = formatSec(timeout)
+	cmd := NewStringSliceCmd(args...)
+	cmd.setReadTimeout(readTimeout(timeout))
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) BRPop(timeout time.Duration, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys)+1)
+	args[0] = "brpop"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	args[len(keys)+1] = formatSec(timeout)
+	cmd := NewStringSliceCmd(args...)
+	cmd.setReadTimeout(readTimeout(timeout))
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) BRPopLPush(source, destination string, timeout time.Duration) *StringCmd {
+	cmd := NewStringCmd(
+		"brpoplpush",
+		source,
+		destination,
+		formatSec(timeout),
+	)
+	cmd.setReadTimeout(readTimeout(timeout))
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LIndex(key string, index int64) *StringCmd {
+	cmd := NewStringCmd("lindex", key, index)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LInsert(key, op string, pivot, value interface{}) *IntCmd {
+	cmd := NewIntCmd("linsert", key, op, pivot, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LInsertBefore(key string, pivot, value interface{}) *IntCmd {
+	cmd := NewIntCmd("linsert", key, "before", pivot, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LInsertAfter(key string, pivot, value interface{}) *IntCmd {
+	cmd := NewIntCmd("linsert", key, "after", pivot, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LLen(key string) *IntCmd {
+	cmd := NewIntCmd("llen", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LPop(key string) *StringCmd {
+	cmd := NewStringCmd("lpop", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LPush(key string, values ...interface{}) *IntCmd {
+	args := make([]interface{}, 2+len(values))
+	args[0] = "lpush"
+	args[1] = key
+	for i, value := range values {
+		args[2+i] = value
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LPushX(key string, value interface{}) *IntCmd {
+	cmd := NewIntCmd("lpushx", key, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LRange(key string, start, stop int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd(
+		"lrange",
+		key,
+		start,
+		stop,
+	)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LRem(key string, count int64, value interface{}) *IntCmd {
+	cmd := NewIntCmd("lrem", key, count, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LSet(key string, index int64, value interface{}) *StatusCmd {
+	cmd := NewStatusCmd("lset", key, index, value)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LTrim(key string, start, stop int64) *StatusCmd {
+	cmd := NewStatusCmd(
+		"ltrim",
+		key,
+		start,
+		stop,
+	)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) RPop(key string) *StringCmd {
+	cmd := NewStringCmd("rpop", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) RPopLPush(source, destination string) *StringCmd {
+	cmd := NewStringCmd("rpoplpush", source, destination)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) RPush(key string, values ...interface{}) *IntCmd {
+	args := make([]interface{}, 2+len(values))
+	args[0] = "rpush"
+	args[1] = key
+	for i, value := range values {
+		args[2+i] = value
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) RPushX(key string, value interface{}) *IntCmd {
+	cmd := NewIntCmd("rpushx", key, value)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) SAdd(key string, members ...interface{}) *IntCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "sadd"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SCard(key string) *IntCmd {
+	cmd := NewIntCmd("scard", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SDiff(keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "sdiff"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SDiffStore(destination string, keys ...string) *IntCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "sdiffstore"
+	args[1] = destination
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SInter(keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "sinter"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SInterStore(destination string, keys ...string) *IntCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "sinterstore"
+	args[1] = destination
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SIsMember(key string, member interface{}) *BoolCmd {
+	cmd := NewBoolCmd("sismember", key, member)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SMembers(key string) *StringSliceCmd {
+	cmd := NewStringSliceCmd("smembers", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SMove(source, destination string, member interface{}) *BoolCmd {
+	cmd := NewBoolCmd("smove", source, destination, member)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `SPOP key` command.
+func (c *cmdable) SPop(key string) *StringCmd {
+	cmd := NewStringCmd("spop", key)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `SPOP key count` command.
+func (c *cmdable) SPopN(key string, count int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd("spop", key, count)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `SRANDMEMBER key` command.
+func (c *cmdable) SRandMember(key string) *StringCmd {
+	cmd := NewStringCmd("srandmember", key)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `SRANDMEMBER key count` command.
+func (c *cmdable) SRandMemberN(key string, count int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd("srandmember", key, count)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SRem(key string, members ...interface{}) *IntCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "srem"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SUnion(keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "sunion"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SUnionStore(destination string, keys ...string) *IntCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "sunionstore"
+	args[1] = destination
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+// Z represents sorted set member.
+type Z struct {
+	Score  float64
+	Member interface{}
+}
+
+// ZStore is used as an arg to ZInterStore and ZUnionStore.
+type ZStore struct {
+	Weights []float64
+	// Can be SUM, MIN or MAX.
+	Aggregate string
+}
+
+func (c *cmdable) zAdd(a []interface{}, n int, members ...Z) *IntCmd {
+	for i, m := range members {
+		a[n+2*i] = m.Score
+		a[n+2*i+1] = m.Member
+	}
+	cmd := NewIntCmd(a...)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `ZADD key score member [score member ...]` command.
+func (c *cmdable) ZAdd(key string, members ...Z) *IntCmd {
+	const n = 2
+	a := make([]interface{}, n+2*len(members))
+	a[0], a[1] = "zadd", key
+	return c.zAdd(a, n, members...)
+}
+
+// Redis `ZADD key NX score member [score member ...]` command.
+func (c *cmdable) ZAddNX(key string, members ...Z) *IntCmd {
+	const n = 3
+	a := make([]interface{}, n+2*len(members))
+	a[0], a[1], a[2] = "zadd", key, "nx"
+	return c.zAdd(a, n, members...)
+}
+
+// Redis `ZADD key XX score member [score member ...]` command.
+func (c *cmdable) ZAddXX(key string, members ...Z) *IntCmd {
+	const n = 3
+	a := make([]interface{}, n+2*len(members))
+	a[0], a[1], a[2] = "zadd", key, "xx"
+	return c.zAdd(a, n, members...)
+}
+
+// Redis `ZADD key CH score member [score member ...]` command.
+func (c *cmdable) ZAddCh(key string, members ...Z) *IntCmd {
+	const n = 3
+	a := make([]interface{}, n+2*len(members))
+	a[0], a[1], a[2] = "zadd", key, "ch"
+	return c.zAdd(a, n, members...)
+}
+
+// Redis `ZADD key NX CH score member [score member ...]` command.
+func (c *cmdable) ZAddNXCh(key string, members ...Z) *IntCmd {
+	const n = 4
+	a := make([]interface{}, n+2*len(members))
+	a[0], a[1], a[2], a[3] = "zadd", key, "nx", "ch"
+	return c.zAdd(a, n, members...)
+}
+
+// Redis `ZADD key XX CH score member [score member ...]` command.
+func (c *cmdable) ZAddXXCh(key string, members ...Z) *IntCmd {
+	const n = 4
+	a := make([]interface{}, n+2*len(members))
+	a[0], a[1], a[2], a[3] = "zadd", key, "xx", "ch"
+	return c.zAdd(a, n, members...)
+}
+
+func (c *cmdable) zIncr(a []interface{}, n int, members ...Z) *FloatCmd {
+	for i, m := range members {
+		a[n+2*i] = m.Score
+		a[n+2*i+1] = m.Member
+	}
+	cmd := NewFloatCmd(a...)
+	c.process(cmd)
+	return cmd
+}
+
+// Redis `ZADD key INCR score member` command.
+func (c *cmdable) ZIncr(key string, member Z) *FloatCmd {
+	const n = 3
+	a := make([]interface{}, n+2)
+	a[0], a[1], a[2] = "zadd", key, "incr"
+	return c.zIncr(a, n, member)
+}
+
+// Redis `ZADD key NX INCR score member` command.
+func (c *cmdable) ZIncrNX(key string, member Z) *FloatCmd {
+	const n = 4
+	a := make([]interface{}, n+2)
+	a[0], a[1], a[2], a[3] = "zadd", key, "incr", "nx"
+	return c.zIncr(a, n, member)
+}
+
+// Redis `ZADD key XX INCR score member` command.
+func (c *cmdable) ZIncrXX(key string, member Z) *FloatCmd {
+	const n = 4
+	a := make([]interface{}, n+2)
+	a[0], a[1], a[2], a[3] = "zadd", key, "incr", "xx"
+	return c.zIncr(a, n, member)
+}
+
+func (c *cmdable) ZCard(key string) *IntCmd {
+	cmd := NewIntCmd("zcard", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZCount(key, min, max string) *IntCmd {
+	cmd := NewIntCmd("zcount", key, min, max)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZLexCount(key, min, max string) *IntCmd {
+	cmd := NewIntCmd("zlexcount", key, min, max)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZIncrBy(key string, increment float64, member string) *FloatCmd {
+	cmd := NewFloatCmd("zincrby", key, increment, member)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZInterStore(destination string, store ZStore, keys ...string) *IntCmd {
+	args := make([]interface{}, 3+len(keys))
+	args[0] = "zinterstore"
+	args[1] = destination
+	args[2] = len(keys)
+	for i, key := range keys {
+		args[3+i] = key
+	}
+	if len(store.Weights) > 0 {
+		args = append(args, "weights")
+		for _, weight := range store.Weights {
+			args = append(args, weight)
+		}
+	}
+	if store.Aggregate != "" {
+		args = append(args, "aggregate", store.Aggregate)
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) zRange(key string, start, stop int64, withScores bool) *StringSliceCmd {
+	args := []interface{}{
+		"zrange",
+		key,
+		start,
+		stop,
+	}
+	if withScores {
+		args = append(args, "withscores")
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRange(key string, start, stop int64) *StringSliceCmd {
+	return c.zRange(key, start, stop, false)
+}
+
+func (c *cmdable) ZRangeWithScores(key string, start, stop int64) *ZSliceCmd {
+	cmd := NewZSliceCmd("zrange", key, start, stop, "withscores")
+	c.process(cmd)
+	return cmd
+}
+
+type ZRangeBy struct {
+	Min, Max      string
+	Offset, Count int64
+}
+
+func (c *cmdable) zRangeBy(zcmd, key string, opt ZRangeBy, withScores bool) *StringSliceCmd {
+	args := []interface{}{zcmd, key, opt.Min, opt.Max}
+	if withScores {
+		args = append(args, "withscores")
+	}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRangeByScore(key string, opt ZRangeBy) *StringSliceCmd {
+	return c.zRangeBy("zrangebyscore", key, opt, false)
+}
+
+func (c *cmdable) ZRangeByLex(key string, opt ZRangeBy) *StringSliceCmd {
+	return c.zRangeBy("zrangebylex", key, opt, false)
+}
+
+func (c *cmdable) ZRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd {
+	args := []interface{}{"zrangebyscore", key, opt.Min, opt.Max, "withscores"}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewZSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRank(key, member string) *IntCmd {
+	cmd := NewIntCmd("zrank", key, member)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRem(key string, members ...interface{}) *IntCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "zrem"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRemRangeByRank(key string, start, stop int64) *IntCmd {
+	cmd := NewIntCmd(
+		"zremrangebyrank",
+		key,
+		start,
+		stop,
+	)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRemRangeByScore(key, min, max string) *IntCmd {
+	cmd := NewIntCmd("zremrangebyscore", key, min, max)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRemRangeByLex(key, min, max string) *IntCmd {
+	cmd := NewIntCmd("zremrangebylex", key, min, max)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRevRange(key string, start, stop int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd("zrevrange", key, start, stop)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd {
+	cmd := NewZSliceCmd("zrevrange", key, start, stop, "withscores")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) zRevRangeBy(zcmd, key string, opt ZRangeBy) *StringSliceCmd {
+	args := []interface{}{zcmd, key, opt.Max, opt.Min}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRevRangeByScore(key string, opt ZRangeBy) *StringSliceCmd {
+	return c.zRevRangeBy("zrevrangebyscore", key, opt)
+}
+
+func (c *cmdable) ZRevRangeByLex(key string, opt ZRangeBy) *StringSliceCmd {
+	return c.zRevRangeBy("zrevrangebylex", key, opt)
+}
+
+func (c *cmdable) ZRevRangeByScoreWithScores(key string, opt ZRangeBy) *ZSliceCmd {
+	args := []interface{}{"zrevrangebyscore", key, opt.Max, opt.Min, "withscores"}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewZSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZRevRank(key, member string) *IntCmd {
+	cmd := NewIntCmd("zrevrank", key, member)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZScore(key, member string) *FloatCmd {
+	cmd := NewFloatCmd("zscore", key, member)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ZUnionStore(dest string, store ZStore, keys ...string) *IntCmd {
+	args := make([]interface{}, 3+len(keys))
+	args[0] = "zunionstore"
+	args[1] = dest
+	args[2] = len(keys)
+	for i, key := range keys {
+		args[3+i] = key
+	}
+	if len(store.Weights) > 0 {
+		args = append(args, "weights")
+		for _, weight := range store.Weights {
+			args = append(args, weight)
+		}
+	}
+	if store.Aggregate != "" {
+		args = append(args, "aggregate", store.Aggregate)
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) PFAdd(key string, els ...interface{}) *IntCmd {
+	args := make([]interface{}, 2+len(els))
+	args[0] = "pfadd"
+	args[1] = key
+	for i, el := range els {
+		args[2+i] = el
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PFCount(keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "pfcount"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PFMerge(dest string, keys ...string) *StatusCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "pfmerge"
+	args[1] = dest
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewStatusCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) BgRewriteAOF() *StatusCmd {
+	cmd := NewStatusCmd("bgrewriteaof")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) BgSave() *StatusCmd {
+	cmd := NewStatusCmd("bgsave")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClientKill(ipPort string) *StatusCmd {
+	cmd := NewStatusCmd("client", "kill", ipPort)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClientList() *StringCmd {
+	cmd := NewStringCmd("client", "list")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClientPause(dur time.Duration) *BoolCmd {
+	cmd := NewBoolCmd("client", "pause", formatMs(dur))
+	c.process(cmd)
+	return cmd
+}
+
+// ClientSetName assigns a name to the connection.
+func (c *statefulCmdable) ClientSetName(name string) *BoolCmd {
+	cmd := NewBoolCmd("client", "setname", name)
+	c.process(cmd)
+	return cmd
+}
+
+// ClientGetName returns the name of the connection.
+func (c *cmdable) ClientGetName() *StringCmd {
+	cmd := NewStringCmd("client", "getname")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ConfigGet(parameter string) *SliceCmd {
+	cmd := NewSliceCmd("config", "get", parameter)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ConfigResetStat() *StatusCmd {
+	cmd := NewStatusCmd("config", "resetstat")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ConfigSet(parameter, value string) *StatusCmd {
+	cmd := NewStatusCmd("config", "set", parameter, value)
+	c.process(cmd)
+	return cmd
+}
+
+// Deperecated. Use DBSize instead.
+func (c *cmdable) DbSize() *IntCmd {
+	return c.DBSize()
+}
+
+func (c *cmdable) DBSize() *IntCmd {
+	cmd := NewIntCmd("dbsize")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) FlushAll() *StatusCmd {
+	cmd := NewStatusCmd("flushall")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) FlushAllAsync() *StatusCmd {
+	cmd := NewStatusCmd("flushall", "async")
+	c.process(cmd)
+	return cmd
+}
+
+// Deprecated. Use FlushDB instead.
+func (c *cmdable) FlushDb() *StatusCmd {
+	return c.FlushDB()
+}
+
+func (c *cmdable) FlushDB() *StatusCmd {
+	cmd := NewStatusCmd("flushdb")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) FlushDBAsync() *StatusCmd {
+	cmd := NewStatusCmd("flushdb", "async")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Info(section ...string) *StringCmd {
+	args := []interface{}{"info"}
+	if len(section) > 0 {
+		args = append(args, section[0])
+	}
+	cmd := NewStringCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) LastSave() *IntCmd {
+	cmd := NewIntCmd("lastsave")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) Save() *StatusCmd {
+	cmd := NewStatusCmd("save")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) shutdown(modifier string) *StatusCmd {
+	var args []interface{}
+	if modifier == "" {
+		args = []interface{}{"shutdown"}
+	} else {
+		args = []interface{}{"shutdown", modifier}
+	}
+	cmd := NewStatusCmd(args...)
+	c.process(cmd)
+	if err := cmd.Err(); err != nil {
+		if err == io.EOF {
+			// Server quit as expected.
+			cmd.err = nil
+		}
+	} else {
+		// Server did not quit. String reply contains the reason.
+		cmd.err = internal.RedisError(cmd.val)
+		cmd.val = ""
+	}
+	return cmd
+}
+
+func (c *cmdable) Shutdown() *StatusCmd {
+	return c.shutdown("")
+}
+
+func (c *cmdable) ShutdownSave() *StatusCmd {
+	return c.shutdown("save")
+}
+
+func (c *cmdable) ShutdownNoSave() *StatusCmd {
+	return c.shutdown("nosave")
+}
+
+func (c *cmdable) SlaveOf(host, port string) *StatusCmd {
+	cmd := NewStatusCmd("slaveof", host, port)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) SlowLog() {
+	panic("not implemented")
+}
+
+func (c *cmdable) Sync() {
+	panic("not implemented")
+}
+
+func (c *cmdable) Time() *TimeCmd {
+	cmd := NewTimeCmd("time")
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) Eval(script string, keys []string, args ...interface{}) *Cmd {
+	cmdArgs := make([]interface{}, 3+len(keys)+len(args))
+	cmdArgs[0] = "eval"
+	cmdArgs[1] = script
+	cmdArgs[2] = len(keys)
+	for i, key := range keys {
+		cmdArgs[3+i] = key
+	}
+	pos := 3 + len(keys)
+	for i, arg := range args {
+		cmdArgs[pos+i] = arg
+	}
+	cmd := NewCmd(cmdArgs...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd {
+	cmdArgs := make([]interface{}, 3+len(keys)+len(args))
+	cmdArgs[0] = "evalsha"
+	cmdArgs[1] = sha1
+	cmdArgs[2] = len(keys)
+	for i, key := range keys {
+		cmdArgs[3+i] = key
+	}
+	pos := 3 + len(keys)
+	for i, arg := range args {
+		cmdArgs[pos+i] = arg
+	}
+	cmd := NewCmd(cmdArgs...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ScriptExists(scripts ...string) *BoolSliceCmd {
+	args := make([]interface{}, 2+len(scripts))
+	args[0] = "script"
+	args[1] = "exists"
+	for i, script := range scripts {
+		args[2+i] = script
+	}
+	cmd := NewBoolSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ScriptFlush() *StatusCmd {
+	cmd := NewStatusCmd("script", "flush")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ScriptKill() *StatusCmd {
+	cmd := NewStatusCmd("script", "kill")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ScriptLoad(script string) *StringCmd {
+	cmd := NewStringCmd("script", "load", script)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) DebugObject(key string) *StringCmd {
+	cmd := NewStringCmd("debug", "object", key)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+// Publish posts the message to the channel.
+func (c *cmdable) Publish(channel, message string) *IntCmd {
+	cmd := NewIntCmd("PUBLISH", channel, message)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PubSubChannels(pattern string) *StringSliceCmd {
+	args := []interface{}{"pubsub", "channels"}
+	if pattern != "*" {
+		args = append(args, pattern)
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PubSubNumSub(channels ...string) *StringIntMapCmd {
+	args := make([]interface{}, 2+len(channels))
+	args[0] = "pubsub"
+	args[1] = "numsub"
+	for i, channel := range channels {
+		args[2+i] = channel
+	}
+	cmd := NewStringIntMapCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) PubSubNumPat() *IntCmd {
+	cmd := NewIntCmd("pubsub", "numpat")
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) ClusterSlots() *ClusterSlotsCmd {
+	cmd := NewClusterSlotsCmd("cluster", "slots")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterNodes() *StringCmd {
+	cmd := NewStringCmd("cluster", "nodes")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterMeet(host, port string) *StatusCmd {
+	cmd := NewStatusCmd("cluster", "meet", host, port)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterForget(nodeID string) *StatusCmd {
+	cmd := NewStatusCmd("cluster", "forget", nodeID)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterReplicate(nodeID string) *StatusCmd {
+	cmd := NewStatusCmd("cluster", "replicate", nodeID)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterResetSoft() *StatusCmd {
+	cmd := NewStatusCmd("cluster", "reset", "soft")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterResetHard() *StatusCmd {
+	cmd := NewStatusCmd("cluster", "reset", "hard")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterInfo() *StringCmd {
+	cmd := NewStringCmd("cluster", "info")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterKeySlot(key string) *IntCmd {
+	cmd := NewIntCmd("cluster", "keyslot", key)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterCountFailureReports(nodeID string) *IntCmd {
+	cmd := NewIntCmd("cluster", "count-failure-reports", nodeID)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterCountKeysInSlot(slot int) *IntCmd {
+	cmd := NewIntCmd("cluster", "countkeysinslot", slot)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterDelSlots(slots ...int) *StatusCmd {
+	args := make([]interface{}, 2+len(slots))
+	args[0] = "cluster"
+	args[1] = "delslots"
+	for i, slot := range slots {
+		args[2+i] = slot
+	}
+	cmd := NewStatusCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterDelSlotsRange(min, max int) *StatusCmd {
+	size := max - min + 1
+	slots := make([]int, size)
+	for i := 0; i < size; i++ {
+		slots[i] = min + i
+	}
+	return c.ClusterDelSlots(slots...)
+}
+
+func (c *cmdable) ClusterSaveConfig() *StatusCmd {
+	cmd := NewStatusCmd("cluster", "saveconfig")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterSlaves(nodeID string) *StringSliceCmd {
+	cmd := NewStringSliceCmd("cluster", "slaves", nodeID)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *statefulCmdable) ReadOnly() *StatusCmd {
+	cmd := NewStatusCmd("readonly")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *statefulCmdable) ReadWrite() *StatusCmd {
+	cmd := NewStatusCmd("readwrite")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterFailover() *StatusCmd {
+	cmd := NewStatusCmd("cluster", "failover")
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterAddSlots(slots ...int) *StatusCmd {
+	args := make([]interface{}, 2+len(slots))
+	args[0] = "cluster"
+	args[1] = "addslots"
+	for i, num := range slots {
+		args[2+i] = num
+	}
+	cmd := NewStatusCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) ClusterAddSlotsRange(min, max int) *StatusCmd {
+	size := max - min + 1
+	slots := make([]int, size)
+	for i := 0; i < size; i++ {
+		slots[i] = min + i
+	}
+	return c.ClusterAddSlots(slots...)
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd {
+	args := make([]interface{}, 2+3*len(geoLocation))
+	args[0] = "geoadd"
+	args[1] = key
+	for i, eachLoc := range geoLocation {
+		args[2+3*i] = eachLoc.Longitude
+		args[2+3*i+1] = eachLoc.Latitude
+		args[2+3*i+2] = eachLoc.Name
+	}
+	cmd := NewIntCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd {
+	cmd := NewGeoLocationCmd(query, "georadius", key, longitude, latitude)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GeoRadiusRO(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd {
+	cmd := NewGeoLocationCmd(query, "georadius_ro", key, longitude, latitude)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd {
+	cmd := NewGeoLocationCmd(query, "georadiusbymember", key, member)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GeoRadiusByMemberRO(key, member string, query *GeoRadiusQuery) *GeoLocationCmd {
+	cmd := NewGeoLocationCmd(query, "georadiusbymember_ro", key, member)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GeoDist(key string, member1, member2, unit string) *FloatCmd {
+	if unit == "" {
+		unit = "km"
+	}
+	cmd := NewFloatCmd("geodist", key, member1, member2, unit)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GeoHash(key string, members ...string) *StringSliceCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "geohash"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewStringSliceCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+func (c *cmdable) GeoPos(key string, members ...string) *GeoPosCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "geopos"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewGeoPosCmd(args...)
+	c.process(cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c *cmdable) Command() *CommandsInfoCmd {
+	cmd := NewCommandsInfoCmd("command")
+	c.process(cmd)
+	return cmd
+}
diff --git a/commands_test.go b/commands_test.go
new file mode 100644
index 00000000..4298cba6
--- /dev/null
+++ b/commands_test.go
@@ -0,0 +1,2942 @@
+package redis_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/go-redis/redis"
+)
+
+var _ = Describe("Commands", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	Describe("server", func() {
+
+		It("should Auth", func() {
+			_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+				pipe.Auth("password")
+				return nil
+			})
+			Expect(err).To(MatchError("ERR Client sent AUTH, but no password is set"))
+		})
+
+		It("should Echo", func() {
+			pipe := client.Pipeline()
+			echo := pipe.Echo("hello")
+			_, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(echo.Err()).NotTo(HaveOccurred())
+			Expect(echo.Val()).To(Equal("hello"))
+		})
+
+		It("should Ping", func() {
+			ping := client.Ping()
+			Expect(ping.Err()).NotTo(HaveOccurred())
+			Expect(ping.Val()).To(Equal("PONG"))
+		})
+
+		It("should Wait", func() {
+			// assume testing on single redis instance
+			start := time.Now()
+			wait := client.Wait(1, time.Second)
+			Expect(wait.Err()).NotTo(HaveOccurred())
+			Expect(wait.Val()).To(Equal(int64(0)))
+			Expect(time.Now()).To(BeTemporally("~", start.Add(time.Second), 800*time.Millisecond))
+		})
+
+		It("should Select", func() {
+			pipe := client.Pipeline()
+			sel := pipe.Select(1)
+			_, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(sel.Err()).NotTo(HaveOccurred())
+			Expect(sel.Val()).To(Equal("OK"))
+		})
+
+		It("should BgRewriteAOF", func() {
+			Skip("flaky test")
+
+			val, err := client.BgRewriteAOF().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(ContainSubstring("Background append only file rewriting"))
+		})
+
+		It("should BgSave", func() {
+			Skip("flaky test")
+
+			// workaround for "ERR Can't BGSAVE while AOF log rewriting is in progress"
+			Eventually(func() string {
+				return client.BgSave().Val()
+			}, "30s").Should(Equal("Background saving started"))
+		})
+
+		It("should ClientKill", func() {
+			r := client.ClientKill("1.1.1.1:1111")
+			Expect(r.Err()).To(MatchError("ERR No such client"))
+			Expect(r.Val()).To(Equal(""))
+		})
+
+		It("should ClientPause", func() {
+			err := client.ClientPause(time.Second).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			start := time.Now()
+			err = client.Ping().Err()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(time.Now()).To(BeTemporally("~", start.Add(time.Second), 800*time.Millisecond))
+		})
+
+		It("should ClientSetName and ClientGetName", func() {
+			pipe := client.Pipeline()
+			set := pipe.ClientSetName("theclientname")
+			get := pipe.ClientGetName()
+			_, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(BeTrue())
+
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("theclientname"))
+		})
+
+		It("should ConfigGet", func() {
+			val, err := client.ConfigGet("*").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).NotTo(BeEmpty())
+		})
+
+		It("should ConfigResetStat", func() {
+			r := client.ConfigResetStat()
+			Expect(r.Err()).NotTo(HaveOccurred())
+			Expect(r.Val()).To(Equal("OK"))
+		})
+
+		It("should ConfigSet", func() {
+			configGet := client.ConfigGet("maxmemory")
+			Expect(configGet.Err()).NotTo(HaveOccurred())
+			Expect(configGet.Val()).To(HaveLen(2))
+			Expect(configGet.Val()[0]).To(Equal("maxmemory"))
+
+			configSet := client.ConfigSet("maxmemory", configGet.Val()[1].(string))
+			Expect(configSet.Err()).NotTo(HaveOccurred())
+			Expect(configSet.Val()).To(Equal("OK"))
+		})
+
+		It("should DBSize", func() {
+			size, err := client.DBSize().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(size).To(Equal(int64(0)))
+		})
+
+		It("should Info", func() {
+			info := client.Info()
+			Expect(info.Err()).NotTo(HaveOccurred())
+			Expect(info.Val()).NotTo(Equal(""))
+		})
+
+		It("should Info cpu", func() {
+			info := client.Info("cpu")
+			Expect(info.Err()).NotTo(HaveOccurred())
+			Expect(info.Val()).NotTo(Equal(""))
+			Expect(info.Val()).To(ContainSubstring(`used_cpu_sys`))
+		})
+
+		It("should LastSave", func() {
+			lastSave := client.LastSave()
+			Expect(lastSave.Err()).NotTo(HaveOccurred())
+			Expect(lastSave.Val()).NotTo(Equal(0))
+		})
+
+		It("should Save", func() {
+			// workaround for "ERR Background save already in progress"
+			Eventually(func() string {
+				return client.Save().Val()
+			}, "10s").Should(Equal("OK"))
+		})
+
+		It("should SlaveOf", func() {
+			slaveOf := client.SlaveOf("localhost", "8888")
+			Expect(slaveOf.Err()).NotTo(HaveOccurred())
+			Expect(slaveOf.Val()).To(Equal("OK"))
+
+			slaveOf = client.SlaveOf("NO", "ONE")
+			Expect(slaveOf.Err()).NotTo(HaveOccurred())
+			Expect(slaveOf.Val()).To(Equal("OK"))
+		})
+
+		It("should Time", func() {
+			tm, err := client.Time().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(tm).To(BeTemporally("~", time.Now(), 3*time.Second))
+		})
+
+	})
+
+	Describe("debugging", func() {
+
+		It("should DebugObject", func() {
+			debug := client.DebugObject("foo")
+			Expect(debug.Err()).To(HaveOccurred())
+			Expect(debug.Err().Error()).To(Equal("ERR no such key"))
+
+			client.Set("foo", "bar", 0)
+			debug = client.DebugObject("foo")
+			Expect(debug.Err()).NotTo(HaveOccurred())
+			Expect(debug.Val()).To(ContainSubstring(`serializedlength:4`))
+		})
+
+	})
+
+	Describe("keys", func() {
+
+		It("should Del", func() {
+			err := client.Set("key1", "Hello", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.Set("key2", "World", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			n, err := client.Del("key1", "key2", "key3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(2)))
+		})
+
+		It("should Unlink", func() {
+			err := client.Set("key1", "Hello", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.Set("key2", "World", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			n, err := client.Unlink("key1", "key2", "key3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(2)))
+		})
+
+		It("should Dump", func() {
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			dump := client.Dump("key")
+			Expect(dump.Err()).NotTo(HaveOccurred())
+			Expect(dump.Val()).NotTo(BeEmpty())
+		})
+
+		It("should Exists", func() {
+			set := client.Set("key1", "Hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			n, err := client.Exists("key1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(1)))
+
+			n, err = client.Exists("key2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(0)))
+
+			n, err = client.Exists("key1", "key2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(1)))
+
+			n, err = client.Exists("key1", "key1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(2)))
+		})
+
+		It("should Expire", func() {
+			set := client.Set("key", "Hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			expire := client.Expire("key", 10*time.Second)
+			Expect(expire.Err()).NotTo(HaveOccurred())
+			Expect(expire.Val()).To(Equal(true))
+
+			ttl := client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val()).To(Equal(10 * time.Second))
+
+			set = client.Set("key", "Hello World", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			ttl = client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val() < 0).To(Equal(true))
+		})
+
+		It("should ExpireAt", func() {
+			set := client.Set("key", "Hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			n, err := client.Exists("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(1)))
+
+			expireAt := client.ExpireAt("key", time.Now().Add(-time.Hour))
+			Expect(expireAt.Err()).NotTo(HaveOccurred())
+			Expect(expireAt.Val()).To(Equal(true))
+
+			n, err = client.Exists("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(0)))
+		})
+
+		It("should Keys", func() {
+			mset := client.MSet("one", "1", "two", "2", "three", "3", "four", "4")
+			Expect(mset.Err()).NotTo(HaveOccurred())
+			Expect(mset.Val()).To(Equal("OK"))
+
+			keys := client.Keys("*o*")
+			Expect(keys.Err()).NotTo(HaveOccurred())
+			Expect(keys.Val()).To(ConsistOf([]string{"four", "one", "two"}))
+
+			keys = client.Keys("t??")
+			Expect(keys.Err()).NotTo(HaveOccurred())
+			Expect(keys.Val()).To(Equal([]string{"two"}))
+
+			keys = client.Keys("*")
+			Expect(keys.Err()).NotTo(HaveOccurred())
+			Expect(keys.Val()).To(ConsistOf([]string{"four", "one", "three", "two"}))
+		})
+
+		It("should Migrate", func() {
+			migrate := client.Migrate("localhost", redisSecondaryPort, "key", 0, 0)
+			Expect(migrate.Err()).NotTo(HaveOccurred())
+			Expect(migrate.Val()).To(Equal("NOKEY"))
+
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			migrate = client.Migrate("localhost", redisSecondaryPort, "key", 0, 0)
+			Expect(migrate.Err()).To(MatchError("IOERR error or timeout writing to target instance"))
+			Expect(migrate.Val()).To(Equal(""))
+		})
+
+		It("should Move", func() {
+			move := client.Move("key", 2)
+			Expect(move.Err()).NotTo(HaveOccurred())
+			Expect(move.Val()).To(Equal(false))
+
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			move = client.Move("key", 2)
+			Expect(move.Err()).NotTo(HaveOccurred())
+			Expect(move.Val()).To(Equal(true))
+
+			get := client.Get("key")
+			Expect(get.Err()).To(Equal(redis.Nil))
+			Expect(get.Val()).To(Equal(""))
+
+			pipe := client.Pipeline()
+			pipe.Select(2)
+			get = pipe.Get("key")
+			pipe.FlushDB()
+
+			_, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("hello"))
+		})
+
+		It("should Object", func() {
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			refCount := client.ObjectRefCount("key")
+			Expect(refCount.Err()).NotTo(HaveOccurred())
+			Expect(refCount.Val()).To(Equal(int64(1)))
+
+			err := client.ObjectEncoding("key").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			idleTime := client.ObjectIdleTime("key")
+			Expect(idleTime.Err()).NotTo(HaveOccurred())
+			Expect(idleTime.Val()).To(Equal(time.Duration(0)))
+		})
+
+		It("should Persist", func() {
+			set := client.Set("key", "Hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			expire := client.Expire("key", 10*time.Second)
+			Expect(expire.Err()).NotTo(HaveOccurred())
+			Expect(expire.Val()).To(Equal(true))
+
+			ttl := client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val()).To(Equal(10 * time.Second))
+
+			persist := client.Persist("key")
+			Expect(persist.Err()).NotTo(HaveOccurred())
+			Expect(persist.Val()).To(Equal(true))
+
+			ttl = client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val() < 0).To(Equal(true))
+		})
+
+		It("should PExpire", func() {
+			set := client.Set("key", "Hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			expiration := 900 * time.Millisecond
+			pexpire := client.PExpire("key", expiration)
+			Expect(pexpire.Err()).NotTo(HaveOccurred())
+			Expect(pexpire.Val()).To(Equal(true))
+
+			ttl := client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val()).To(Equal(time.Second))
+
+			pttl := client.PTTL("key")
+			Expect(pttl.Err()).NotTo(HaveOccurred())
+			Expect(pttl.Val()).To(BeNumerically("~", expiration, 10*time.Millisecond))
+		})
+
+		It("should PExpireAt", func() {
+			set := client.Set("key", "Hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			expiration := 900 * time.Millisecond
+			pexpireat := client.PExpireAt("key", time.Now().Add(expiration))
+			Expect(pexpireat.Err()).NotTo(HaveOccurred())
+			Expect(pexpireat.Val()).To(Equal(true))
+
+			ttl := client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val()).To(Equal(time.Second))
+
+			pttl := client.PTTL("key")
+			Expect(pttl.Err()).NotTo(HaveOccurred())
+			Expect(pttl.Val()).To(BeNumerically("~", expiration, 10*time.Millisecond))
+		})
+
+		It("should PTTL", func() {
+			set := client.Set("key", "Hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			expiration := time.Second
+			expire := client.Expire("key", expiration)
+			Expect(expire.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			pttl := client.PTTL("key")
+			Expect(pttl.Err()).NotTo(HaveOccurred())
+			Expect(pttl.Val()).To(BeNumerically("~", expiration, 10*time.Millisecond))
+		})
+
+		It("should RandomKey", func() {
+			randomKey := client.RandomKey()
+			Expect(randomKey.Err()).To(Equal(redis.Nil))
+			Expect(randomKey.Val()).To(Equal(""))
+
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			randomKey = client.RandomKey()
+			Expect(randomKey.Err()).NotTo(HaveOccurred())
+			Expect(randomKey.Val()).To(Equal("key"))
+		})
+
+		It("should Rename", func() {
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			status := client.Rename("key", "key1")
+			Expect(status.Err()).NotTo(HaveOccurred())
+			Expect(status.Val()).To(Equal("OK"))
+
+			get := client.Get("key1")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("hello"))
+		})
+
+		It("should RenameNX", func() {
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			renameNX := client.RenameNX("key", "key1")
+			Expect(renameNX.Err()).NotTo(HaveOccurred())
+			Expect(renameNX.Val()).To(Equal(true))
+
+			get := client.Get("key1")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("hello"))
+		})
+
+		It("should Restore", func() {
+			err := client.Set("key", "hello", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			dump := client.Dump("key")
+			Expect(dump.Err()).NotTo(HaveOccurred())
+
+			err = client.Del("key").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			restore, err := client.Restore("key", 0, dump.Val()).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(restore).To(Equal("OK"))
+
+			type_, err := client.Type("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(type_).To(Equal("string"))
+
+			val, err := client.Get("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("hello"))
+		})
+
+		It("should RestoreReplace", func() {
+			err := client.Set("key", "hello", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			dump := client.Dump("key")
+			Expect(dump.Err()).NotTo(HaveOccurred())
+
+			restore, err := client.RestoreReplace("key", 0, dump.Val()).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(restore).To(Equal("OK"))
+
+			type_, err := client.Type("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(type_).To(Equal("string"))
+
+			val, err := client.Get("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("hello"))
+		})
+
+		It("should Sort", func() {
+			size, err := client.LPush("list", "1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(size).To(Equal(int64(1)))
+
+			size, err = client.LPush("list", "3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(size).To(Equal(int64(2)))
+
+			size, err = client.LPush("list", "2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(size).To(Equal(int64(3)))
+
+			els, err := client.Sort("list", redis.Sort{
+				Offset: 0,
+				Count:  2,
+				Order:  "ASC",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(els).To(Equal([]string{"1", "2"}))
+		})
+
+		It("should Sort and Get", func() {
+			size, err := client.LPush("list", "1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(size).To(Equal(int64(1)))
+
+			size, err = client.LPush("list", "3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(size).To(Equal(int64(2)))
+
+			size, err = client.LPush("list", "2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(size).To(Equal(int64(3)))
+
+			err = client.Set("object_2", "value2", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			{
+				els, err := client.Sort("list", redis.Sort{
+					Get: []string{"object_*"},
+				}).Result()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(els).To(Equal([]string{"", "value2", ""}))
+			}
+
+			{
+				els, err := client.SortInterfaces("list", redis.Sort{
+					Get: []string{"object_*"},
+				}).Result()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(els).To(Equal([]interface{}{nil, "value2", nil}))
+			}
+		})
+
+		It("should TTL", func() {
+			ttl := client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val() < 0).To(Equal(true))
+
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			expire := client.Expire("key", 60*time.Second)
+			Expect(expire.Err()).NotTo(HaveOccurred())
+			Expect(expire.Val()).To(Equal(true))
+
+			ttl = client.TTL("key")
+			Expect(ttl.Err()).NotTo(HaveOccurred())
+			Expect(ttl.Val()).To(Equal(60 * time.Second))
+		})
+
+		It("should Type", func() {
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			type_ := client.Type("key")
+			Expect(type_.Err()).NotTo(HaveOccurred())
+			Expect(type_.Val()).To(Equal("string"))
+		})
+
+	})
+
+	Describe("scanning", func() {
+
+		It("should Scan", func() {
+			for i := 0; i < 1000; i++ {
+				set := client.Set(fmt.Sprintf("key%d", i), "hello", 0)
+				Expect(set.Err()).NotTo(HaveOccurred())
+			}
+
+			keys, cursor, err := client.Scan(0, "", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(keys).NotTo(BeEmpty())
+			Expect(cursor).NotTo(BeZero())
+		})
+
+		It("should SScan", func() {
+			for i := 0; i < 1000; i++ {
+				sadd := client.SAdd("myset", fmt.Sprintf("member%d", i))
+				Expect(sadd.Err()).NotTo(HaveOccurred())
+			}
+
+			keys, cursor, err := client.SScan("myset", 0, "", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(keys).NotTo(BeEmpty())
+			Expect(cursor).NotTo(BeZero())
+		})
+
+		It("should HScan", func() {
+			for i := 0; i < 1000; i++ {
+				sadd := client.HSet("myhash", fmt.Sprintf("key%d", i), "hello")
+				Expect(sadd.Err()).NotTo(HaveOccurred())
+			}
+
+			keys, cursor, err := client.HScan("myhash", 0, "", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(keys).NotTo(BeEmpty())
+			Expect(cursor).NotTo(BeZero())
+		})
+
+		It("should ZScan", func() {
+			for i := 0; i < 1000; i++ {
+				sadd := client.ZAdd("myset", redis.Z{float64(i), fmt.Sprintf("member%d", i)})
+				Expect(sadd.Err()).NotTo(HaveOccurred())
+			}
+
+			keys, cursor, err := client.ZScan("myset", 0, "", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(keys).NotTo(BeEmpty())
+			Expect(cursor).NotTo(BeZero())
+		})
+
+	})
+
+	Describe("strings", func() {
+
+		It("should Append", func() {
+			n, err := client.Exists("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(0)))
+
+			append := client.Append("key", "Hello")
+			Expect(append.Err()).NotTo(HaveOccurred())
+			Expect(append.Val()).To(Equal(int64(5)))
+
+			append = client.Append("key", " World")
+			Expect(append.Err()).NotTo(HaveOccurred())
+			Expect(append.Val()).To(Equal(int64(11)))
+
+			get := client.Get("key")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("Hello World"))
+		})
+
+		It("should BitCount", func() {
+			set := client.Set("key", "foobar", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			bitCount := client.BitCount("key", nil)
+			Expect(bitCount.Err()).NotTo(HaveOccurred())
+			Expect(bitCount.Val()).To(Equal(int64(26)))
+
+			bitCount = client.BitCount("key", &redis.BitCount{0, 0})
+			Expect(bitCount.Err()).NotTo(HaveOccurred())
+			Expect(bitCount.Val()).To(Equal(int64(4)))
+
+			bitCount = client.BitCount("key", &redis.BitCount{1, 1})
+			Expect(bitCount.Err()).NotTo(HaveOccurred())
+			Expect(bitCount.Val()).To(Equal(int64(6)))
+		})
+
+		It("should BitOpAnd", func() {
+			set := client.Set("key1", "1", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			set = client.Set("key2", "0", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			bitOpAnd := client.BitOpAnd("dest", "key1", "key2")
+			Expect(bitOpAnd.Err()).NotTo(HaveOccurred())
+			Expect(bitOpAnd.Val()).To(Equal(int64(1)))
+
+			get := client.Get("dest")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("0"))
+		})
+
+		It("should BitOpOr", func() {
+			set := client.Set("key1", "1", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			set = client.Set("key2", "0", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			bitOpOr := client.BitOpOr("dest", "key1", "key2")
+			Expect(bitOpOr.Err()).NotTo(HaveOccurred())
+			Expect(bitOpOr.Val()).To(Equal(int64(1)))
+
+			get := client.Get("dest")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("1"))
+		})
+
+		It("should BitOpXor", func() {
+			set := client.Set("key1", "\xff", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			set = client.Set("key2", "\x0f", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			bitOpXor := client.BitOpXor("dest", "key1", "key2")
+			Expect(bitOpXor.Err()).NotTo(HaveOccurred())
+			Expect(bitOpXor.Val()).To(Equal(int64(1)))
+
+			get := client.Get("dest")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("\xf0"))
+		})
+
+		It("should BitOpNot", func() {
+			set := client.Set("key1", "\x00", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			bitOpNot := client.BitOpNot("dest", "key1")
+			Expect(bitOpNot.Err()).NotTo(HaveOccurred())
+			Expect(bitOpNot.Val()).To(Equal(int64(1)))
+
+			get := client.Get("dest")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("\xff"))
+		})
+
+		It("should BitPos", func() {
+			err := client.Set("mykey", "\xff\xf0\x00", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			pos, err := client.BitPos("mykey", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(12)))
+
+			pos, err = client.BitPos("mykey", 1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(0)))
+
+			pos, err = client.BitPos("mykey", 0, 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(16)))
+
+			pos, err = client.BitPos("mykey", 1, 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(-1)))
+
+			pos, err = client.BitPos("mykey", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(16)))
+
+			pos, err = client.BitPos("mykey", 1, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(-1)))
+
+			pos, err = client.BitPos("mykey", 0, 2, 1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(-1)))
+
+			pos, err = client.BitPos("mykey", 0, 0, -3).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(-1)))
+
+			pos, err = client.BitPos("mykey", 0, 0, 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(Equal(int64(-1)))
+		})
+
+		It("should Decr", func() {
+			set := client.Set("key", "10", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			decr := client.Decr("key")
+			Expect(decr.Err()).NotTo(HaveOccurred())
+			Expect(decr.Val()).To(Equal(int64(9)))
+
+			set = client.Set("key", "234293482390480948029348230948", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			decr = client.Decr("key")
+			Expect(decr.Err()).To(MatchError("ERR value is not an integer or out of range"))
+			Expect(decr.Val()).To(Equal(int64(0)))
+		})
+
+		It("should DecrBy", func() {
+			set := client.Set("key", "10", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			decrBy := client.DecrBy("key", 5)
+			Expect(decrBy.Err()).NotTo(HaveOccurred())
+			Expect(decrBy.Val()).To(Equal(int64(5)))
+		})
+
+		It("should Get", func() {
+			get := client.Get("_")
+			Expect(get.Err()).To(Equal(redis.Nil))
+			Expect(get.Val()).To(Equal(""))
+
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			get = client.Get("key")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("hello"))
+		})
+
+		It("should GetBit", func() {
+			setBit := client.SetBit("key", 7, 1)
+			Expect(setBit.Err()).NotTo(HaveOccurred())
+			Expect(setBit.Val()).To(Equal(int64(0)))
+
+			getBit := client.GetBit("key", 0)
+			Expect(getBit.Err()).NotTo(HaveOccurred())
+			Expect(getBit.Val()).To(Equal(int64(0)))
+
+			getBit = client.GetBit("key", 7)
+			Expect(getBit.Err()).NotTo(HaveOccurred())
+			Expect(getBit.Val()).To(Equal(int64(1)))
+
+			getBit = client.GetBit("key", 100)
+			Expect(getBit.Err()).NotTo(HaveOccurred())
+			Expect(getBit.Val()).To(Equal(int64(0)))
+		})
+
+		It("should GetRange", func() {
+			set := client.Set("key", "This is a string", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			getRange := client.GetRange("key", 0, 3)
+			Expect(getRange.Err()).NotTo(HaveOccurred())
+			Expect(getRange.Val()).To(Equal("This"))
+
+			getRange = client.GetRange("key", -3, -1)
+			Expect(getRange.Err()).NotTo(HaveOccurred())
+			Expect(getRange.Val()).To(Equal("ing"))
+
+			getRange = client.GetRange("key", 0, -1)
+			Expect(getRange.Err()).NotTo(HaveOccurred())
+			Expect(getRange.Val()).To(Equal("This is a string"))
+
+			getRange = client.GetRange("key", 10, 100)
+			Expect(getRange.Err()).NotTo(HaveOccurred())
+			Expect(getRange.Val()).To(Equal("string"))
+		})
+
+		It("should GetSet", func() {
+			incr := client.Incr("key")
+			Expect(incr.Err()).NotTo(HaveOccurred())
+			Expect(incr.Val()).To(Equal(int64(1)))
+
+			getSet := client.GetSet("key", "0")
+			Expect(getSet.Err()).NotTo(HaveOccurred())
+			Expect(getSet.Val()).To(Equal("1"))
+
+			get := client.Get("key")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("0"))
+		})
+
+		It("should Incr", func() {
+			set := client.Set("key", "10", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			incr := client.Incr("key")
+			Expect(incr.Err()).NotTo(HaveOccurred())
+			Expect(incr.Val()).To(Equal(int64(11)))
+
+			get := client.Get("key")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("11"))
+		})
+
+		It("should IncrBy", func() {
+			set := client.Set("key", "10", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			incrBy := client.IncrBy("key", 5)
+			Expect(incrBy.Err()).NotTo(HaveOccurred())
+			Expect(incrBy.Val()).To(Equal(int64(15)))
+		})
+
+		It("should IncrByFloat", func() {
+			set := client.Set("key", "10.50", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			incrByFloat := client.IncrByFloat("key", 0.1)
+			Expect(incrByFloat.Err()).NotTo(HaveOccurred())
+			Expect(incrByFloat.Val()).To(Equal(10.6))
+
+			set = client.Set("key", "5.0e3", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			incrByFloat = client.IncrByFloat("key", 2.0e2)
+			Expect(incrByFloat.Err()).NotTo(HaveOccurred())
+			Expect(incrByFloat.Val()).To(Equal(float64(5200)))
+		})
+
+		It("should IncrByFloatOverflow", func() {
+			incrByFloat := client.IncrByFloat("key", 996945661)
+			Expect(incrByFloat.Err()).NotTo(HaveOccurred())
+			Expect(incrByFloat.Val()).To(Equal(float64(996945661)))
+		})
+
+		It("should MSetMGet", func() {
+			mSet := client.MSet("key1", "hello1", "key2", "hello2")
+			Expect(mSet.Err()).NotTo(HaveOccurred())
+			Expect(mSet.Val()).To(Equal("OK"))
+
+			mGet := client.MGet("key1", "key2", "_")
+			Expect(mGet.Err()).NotTo(HaveOccurred())
+			Expect(mGet.Val()).To(Equal([]interface{}{"hello1", "hello2", nil}))
+		})
+
+		It("should MSetNX", func() {
+			mSetNX := client.MSetNX("key1", "hello1", "key2", "hello2")
+			Expect(mSetNX.Err()).NotTo(HaveOccurred())
+			Expect(mSetNX.Val()).To(Equal(true))
+
+			mSetNX = client.MSetNX("key2", "hello1", "key3", "hello2")
+			Expect(mSetNX.Err()).NotTo(HaveOccurred())
+			Expect(mSetNX.Val()).To(Equal(false))
+		})
+
+		It("should Set with expiration", func() {
+			err := client.Set("key", "hello", 100*time.Millisecond).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			val, err := client.Get("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("hello"))
+
+			Eventually(func() error {
+				return client.Get("foo").Err()
+			}, "1s", "100ms").Should(Equal(redis.Nil))
+		})
+
+		It("should SetGet", func() {
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			get := client.Get("key")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("hello"))
+		})
+
+		It("should SetNX", func() {
+			setNX := client.SetNX("key", "hello", 0)
+			Expect(setNX.Err()).NotTo(HaveOccurred())
+			Expect(setNX.Val()).To(Equal(true))
+
+			setNX = client.SetNX("key", "hello2", 0)
+			Expect(setNX.Err()).NotTo(HaveOccurred())
+			Expect(setNX.Val()).To(Equal(false))
+
+			get := client.Get("key")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("hello"))
+		})
+
+		It("should SetNX with expiration", func() {
+			isSet, err := client.SetNX("key", "hello", time.Second).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(isSet).To(Equal(true))
+
+			isSet, err = client.SetNX("key", "hello2", time.Second).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(isSet).To(Equal(false))
+
+			val, err := client.Get("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("hello"))
+		})
+
+		It("should SetXX", func() {
+			isSet, err := client.SetXX("key", "hello2", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(isSet).To(Equal(false))
+
+			err = client.Set("key", "hello", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			isSet, err = client.SetXX("key", "hello2", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(isSet).To(Equal(true))
+
+			val, err := client.Get("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("hello2"))
+		})
+
+		It("should SetXX with expiration", func() {
+			isSet, err := client.SetXX("key", "hello2", time.Second).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(isSet).To(Equal(false))
+
+			err = client.Set("key", "hello", time.Second).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			isSet, err = client.SetXX("key", "hello2", time.Second).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(isSet).To(Equal(true))
+
+			val, err := client.Get("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("hello2"))
+		})
+
+		It("should SetRange", func() {
+			set := client.Set("key", "Hello World", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			range_ := client.SetRange("key", 6, "Redis")
+			Expect(range_.Err()).NotTo(HaveOccurred())
+			Expect(range_.Val()).To(Equal(int64(11)))
+
+			get := client.Get("key")
+			Expect(get.Err()).NotTo(HaveOccurred())
+			Expect(get.Val()).To(Equal("Hello Redis"))
+		})
+
+		It("should StrLen", func() {
+			set := client.Set("key", "hello", 0)
+			Expect(set.Err()).NotTo(HaveOccurred())
+			Expect(set.Val()).To(Equal("OK"))
+
+			strLen := client.StrLen("key")
+			Expect(strLen.Err()).NotTo(HaveOccurred())
+			Expect(strLen.Val()).To(Equal(int64(5)))
+
+			strLen = client.StrLen("_")
+			Expect(strLen.Err()).NotTo(HaveOccurred())
+			Expect(strLen.Val()).To(Equal(int64(0)))
+		})
+
+	})
+
+	Describe("hashes", func() {
+
+		It("should HDel", func() {
+			hSet := client.HSet("hash", "key", "hello")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+
+			hDel := client.HDel("hash", "key")
+			Expect(hDel.Err()).NotTo(HaveOccurred())
+			Expect(hDel.Val()).To(Equal(int64(1)))
+
+			hDel = client.HDel("hash", "key")
+			Expect(hDel.Err()).NotTo(HaveOccurred())
+			Expect(hDel.Val()).To(Equal(int64(0)))
+		})
+
+		It("should HExists", func() {
+			hSet := client.HSet("hash", "key", "hello")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+
+			hExists := client.HExists("hash", "key")
+			Expect(hExists.Err()).NotTo(HaveOccurred())
+			Expect(hExists.Val()).To(Equal(true))
+
+			hExists = client.HExists("hash", "key1")
+			Expect(hExists.Err()).NotTo(HaveOccurred())
+			Expect(hExists.Val()).To(Equal(false))
+		})
+
+		It("should HGet", func() {
+			hSet := client.HSet("hash", "key", "hello")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+
+			hGet := client.HGet("hash", "key")
+			Expect(hGet.Err()).NotTo(HaveOccurred())
+			Expect(hGet.Val()).To(Equal("hello"))
+
+			hGet = client.HGet("hash", "key1")
+			Expect(hGet.Err()).To(Equal(redis.Nil))
+			Expect(hGet.Val()).To(Equal(""))
+		})
+
+		It("should HGetAll", func() {
+			err := client.HSet("hash", "key1", "hello1").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.HSet("hash", "key2", "hello2").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			m, err := client.HGetAll("hash").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(m).To(Equal(map[string]string{"key1": "hello1", "key2": "hello2"}))
+		})
+
+		It("should HIncrBy", func() {
+			hSet := client.HSet("hash", "key", "5")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+
+			hIncrBy := client.HIncrBy("hash", "key", 1)
+			Expect(hIncrBy.Err()).NotTo(HaveOccurred())
+			Expect(hIncrBy.Val()).To(Equal(int64(6)))
+
+			hIncrBy = client.HIncrBy("hash", "key", -1)
+			Expect(hIncrBy.Err()).NotTo(HaveOccurred())
+			Expect(hIncrBy.Val()).To(Equal(int64(5)))
+
+			hIncrBy = client.HIncrBy("hash", "key", -10)
+			Expect(hIncrBy.Err()).NotTo(HaveOccurred())
+			Expect(hIncrBy.Val()).To(Equal(int64(-5)))
+		})
+
+		It("should HIncrByFloat", func() {
+			hSet := client.HSet("hash", "field", "10.50")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+			Expect(hSet.Val()).To(Equal(true))
+
+			hIncrByFloat := client.HIncrByFloat("hash", "field", 0.1)
+			Expect(hIncrByFloat.Err()).NotTo(HaveOccurred())
+			Expect(hIncrByFloat.Val()).To(Equal(10.6))
+
+			hSet = client.HSet("hash", "field", "5.0e3")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+			Expect(hSet.Val()).To(Equal(false))
+
+			hIncrByFloat = client.HIncrByFloat("hash", "field", 2.0e2)
+			Expect(hIncrByFloat.Err()).NotTo(HaveOccurred())
+			Expect(hIncrByFloat.Val()).To(Equal(float64(5200)))
+		})
+
+		It("should HKeys", func() {
+			hkeys := client.HKeys("hash")
+			Expect(hkeys.Err()).NotTo(HaveOccurred())
+			Expect(hkeys.Val()).To(Equal([]string{}))
+
+			hset := client.HSet("hash", "key1", "hello1")
+			Expect(hset.Err()).NotTo(HaveOccurred())
+			hset = client.HSet("hash", "key2", "hello2")
+			Expect(hset.Err()).NotTo(HaveOccurred())
+
+			hkeys = client.HKeys("hash")
+			Expect(hkeys.Err()).NotTo(HaveOccurred())
+			Expect(hkeys.Val()).To(Equal([]string{"key1", "key2"}))
+		})
+
+		It("should HLen", func() {
+			hSet := client.HSet("hash", "key1", "hello1")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+			hSet = client.HSet("hash", "key2", "hello2")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+
+			hLen := client.HLen("hash")
+			Expect(hLen.Err()).NotTo(HaveOccurred())
+			Expect(hLen.Val()).To(Equal(int64(2)))
+		})
+
+		It("should HMGet", func() {
+			err := client.HSet("hash", "key1", "hello1").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.HSet("hash", "key2", "hello2").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			vals, err := client.HMGet("hash", "key1", "key2", "_").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]interface{}{"hello1", "hello2", nil}))
+		})
+
+		It("should HMSet", func() {
+			ok, err := client.HMSet("hash", map[string]interface{}{
+				"key1": "hello1",
+				"key2": "hello2",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(ok).To(Equal("OK"))
+
+			v, err := client.HGet("hash", "key1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(v).To(Equal("hello1"))
+
+			v, err = client.HGet("hash", "key2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(v).To(Equal("hello2"))
+		})
+
+		It("should HSet", func() {
+			hSet := client.HSet("hash", "key", "hello")
+			Expect(hSet.Err()).NotTo(HaveOccurred())
+			Expect(hSet.Val()).To(Equal(true))
+
+			hGet := client.HGet("hash", "key")
+			Expect(hGet.Err()).NotTo(HaveOccurred())
+			Expect(hGet.Val()).To(Equal("hello"))
+		})
+
+		It("should HSetNX", func() {
+			hSetNX := client.HSetNX("hash", "key", "hello")
+			Expect(hSetNX.Err()).NotTo(HaveOccurred())
+			Expect(hSetNX.Val()).To(Equal(true))
+
+			hSetNX = client.HSetNX("hash", "key", "hello")
+			Expect(hSetNX.Err()).NotTo(HaveOccurred())
+			Expect(hSetNX.Val()).To(Equal(false))
+
+			hGet := client.HGet("hash", "key")
+			Expect(hGet.Err()).NotTo(HaveOccurred())
+			Expect(hGet.Val()).To(Equal("hello"))
+		})
+
+		It("should HVals", func() {
+			err := client.HSet("hash", "key1", "hello1").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.HSet("hash", "key2", "hello2").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			v, err := client.HVals("hash").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(v).To(Equal([]string{"hello1", "hello2"}))
+
+			var slice []string
+			err = client.HVals("hash").ScanSlice(&slice)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(slice).To(Equal([]string{"hello1", "hello2"}))
+		})
+
+	})
+
+	Describe("hyperloglog", func() {
+		It("should PFMerge", func() {
+			pfAdd := client.PFAdd("hll1", "1", "2", "3", "4", "5")
+			Expect(pfAdd.Err()).NotTo(HaveOccurred())
+
+			pfCount := client.PFCount("hll1")
+			Expect(pfCount.Err()).NotTo(HaveOccurred())
+			Expect(pfCount.Val()).To(Equal(int64(5)))
+
+			pfAdd = client.PFAdd("hll2", "a", "b", "c", "d", "e")
+			Expect(pfAdd.Err()).NotTo(HaveOccurred())
+
+			pfMerge := client.PFMerge("hllMerged", "hll1", "hll2")
+			Expect(pfMerge.Err()).NotTo(HaveOccurred())
+
+			pfCount = client.PFCount("hllMerged")
+			Expect(pfCount.Err()).NotTo(HaveOccurred())
+			Expect(pfCount.Val()).To(Equal(int64(10)))
+
+			pfCount = client.PFCount("hll1", "hll2")
+			Expect(pfCount.Err()).NotTo(HaveOccurred())
+			Expect(pfCount.Val()).To(Equal(int64(10)))
+		})
+	})
+
+	Describe("lists", func() {
+
+		It("should BLPop", func() {
+			rPush := client.RPush("list1", "a", "b", "c")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			bLPop := client.BLPop(0, "list1", "list2")
+			Expect(bLPop.Err()).NotTo(HaveOccurred())
+			Expect(bLPop.Val()).To(Equal([]string{"list1", "a"}))
+		})
+
+		It("should BLPopBlocks", func() {
+			started := make(chan bool)
+			done := make(chan bool)
+			go func() {
+				defer GinkgoRecover()
+
+				started <- true
+				bLPop := client.BLPop(0, "list")
+				Expect(bLPop.Err()).NotTo(HaveOccurred())
+				Expect(bLPop.Val()).To(Equal([]string{"list", "a"}))
+				done <- true
+			}()
+			<-started
+
+			select {
+			case <-done:
+				Fail("BLPop is not blocked")
+			case <-time.After(time.Second):
+				// ok
+			}
+
+			rPush := client.RPush("list", "a")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			select {
+			case <-done:
+				// ok
+			case <-time.After(time.Second):
+				Fail("BLPop is still blocked")
+			}
+		})
+
+		It("should BLPop timeout", func() {
+			val, err := client.BLPop(time.Second, "list1").Result()
+			Expect(err).To(Equal(redis.Nil))
+			Expect(val).To(BeNil())
+
+			Expect(client.Ping().Err()).NotTo(HaveOccurred())
+
+			stats := client.PoolStats()
+			Expect(stats.Requests).To(Equal(uint32(3)))
+			Expect(stats.Hits).To(Equal(uint32(1)))
+			Expect(stats.Timeouts).To(Equal(uint32(0)))
+		})
+
+		It("should BRPop", func() {
+			rPush := client.RPush("list1", "a", "b", "c")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			bRPop := client.BRPop(0, "list1", "list2")
+			Expect(bRPop.Err()).NotTo(HaveOccurred())
+			Expect(bRPop.Val()).To(Equal([]string{"list1", "c"}))
+		})
+
+		It("should BRPop blocks", func() {
+			started := make(chan bool)
+			done := make(chan bool)
+			go func() {
+				defer GinkgoRecover()
+
+				started <- true
+				brpop := client.BRPop(0, "list")
+				Expect(brpop.Err()).NotTo(HaveOccurred())
+				Expect(brpop.Val()).To(Equal([]string{"list", "a"}))
+				done <- true
+			}()
+			<-started
+
+			select {
+			case <-done:
+				Fail("BRPop is not blocked")
+			case <-time.After(time.Second):
+				// ok
+			}
+
+			rPush := client.RPush("list", "a")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			select {
+			case <-done:
+				// ok
+			case <-time.After(time.Second):
+				Fail("BRPop is still blocked")
+				// ok
+			}
+		})
+
+		It("should BRPopLPush", func() {
+			_, err := client.BRPopLPush("list1", "list2", time.Second).Result()
+			Expect(err).To(Equal(redis.Nil))
+
+			err = client.RPush("list1", "a", "b", "c").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			v, err := client.BRPopLPush("list1", "list2", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(v).To(Equal("c"))
+		})
+
+		It("should LIndex", func() {
+			lPush := client.LPush("list", "World")
+			Expect(lPush.Err()).NotTo(HaveOccurred())
+			lPush = client.LPush("list", "Hello")
+			Expect(lPush.Err()).NotTo(HaveOccurred())
+
+			lIndex := client.LIndex("list", 0)
+			Expect(lIndex.Err()).NotTo(HaveOccurred())
+			Expect(lIndex.Val()).To(Equal("Hello"))
+
+			lIndex = client.LIndex("list", -1)
+			Expect(lIndex.Err()).NotTo(HaveOccurred())
+			Expect(lIndex.Val()).To(Equal("World"))
+
+			lIndex = client.LIndex("list", 3)
+			Expect(lIndex.Err()).To(Equal(redis.Nil))
+			Expect(lIndex.Val()).To(Equal(""))
+		})
+
+		It("should LInsert", func() {
+			rPush := client.RPush("list", "Hello")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "World")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			lInsert := client.LInsert("list", "BEFORE", "World", "There")
+			Expect(lInsert.Err()).NotTo(HaveOccurred())
+			Expect(lInsert.Val()).To(Equal(int64(3)))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"Hello", "There", "World"}))
+		})
+
+		It("should LLen", func() {
+			lPush := client.LPush("list", "World")
+			Expect(lPush.Err()).NotTo(HaveOccurred())
+			lPush = client.LPush("list", "Hello")
+			Expect(lPush.Err()).NotTo(HaveOccurred())
+
+			lLen := client.LLen("list")
+			Expect(lLen.Err()).NotTo(HaveOccurred())
+			Expect(lLen.Val()).To(Equal(int64(2)))
+		})
+
+		It("should LPop", func() {
+			rPush := client.RPush("list", "one")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "two")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "three")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			lPop := client.LPop("list")
+			Expect(lPop.Err()).NotTo(HaveOccurred())
+			Expect(lPop.Val()).To(Equal("one"))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"two", "three"}))
+		})
+
+		It("should LPush", func() {
+			lPush := client.LPush("list", "World")
+			Expect(lPush.Err()).NotTo(HaveOccurred())
+			lPush = client.LPush("list", "Hello")
+			Expect(lPush.Err()).NotTo(HaveOccurred())
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
+		})
+
+		It("should LPushX", func() {
+			lPush := client.LPush("list", "World")
+			Expect(lPush.Err()).NotTo(HaveOccurred())
+
+			lPushX := client.LPushX("list", "Hello")
+			Expect(lPushX.Err()).NotTo(HaveOccurred())
+			Expect(lPushX.Val()).To(Equal(int64(2)))
+
+			lPushX = client.LPushX("list2", "Hello")
+			Expect(lPushX.Err()).NotTo(HaveOccurred())
+			Expect(lPushX.Val()).To(Equal(int64(0)))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
+
+			lRange = client.LRange("list2", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{}))
+		})
+
+		It("should LRange", func() {
+			rPush := client.RPush("list", "one")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "two")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "three")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			lRange := client.LRange("list", 0, 0)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"one"}))
+
+			lRange = client.LRange("list", -3, 2)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"one", "two", "three"}))
+
+			lRange = client.LRange("list", -100, 100)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"one", "two", "three"}))
+
+			lRange = client.LRange("list", 5, 10)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{}))
+		})
+
+		It("should LRem", func() {
+			rPush := client.RPush("list", "hello")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "hello")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "key")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "hello")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			lRem := client.LRem("list", -2, "hello")
+			Expect(lRem.Err()).NotTo(HaveOccurred())
+			Expect(lRem.Val()).To(Equal(int64(2)))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"hello", "key"}))
+		})
+
+		It("should LSet", func() {
+			rPush := client.RPush("list", "one")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "two")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "three")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			lSet := client.LSet("list", 0, "four")
+			Expect(lSet.Err()).NotTo(HaveOccurred())
+			Expect(lSet.Val()).To(Equal("OK"))
+
+			lSet = client.LSet("list", -2, "five")
+			Expect(lSet.Err()).NotTo(HaveOccurred())
+			Expect(lSet.Val()).To(Equal("OK"))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"four", "five", "three"}))
+		})
+
+		It("should LTrim", func() {
+			rPush := client.RPush("list", "one")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "two")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "three")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			lTrim := client.LTrim("list", 1, -1)
+			Expect(lTrim.Err()).NotTo(HaveOccurred())
+			Expect(lTrim.Val()).To(Equal("OK"))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"two", "three"}))
+		})
+
+		It("should RPop", func() {
+			rPush := client.RPush("list", "one")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "two")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "three")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			rPop := client.RPop("list")
+			Expect(rPop.Err()).NotTo(HaveOccurred())
+			Expect(rPop.Val()).To(Equal("three"))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"one", "two"}))
+		})
+
+		It("should RPopLPush", func() {
+			rPush := client.RPush("list", "one")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "two")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			rPush = client.RPush("list", "three")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+
+			rPopLPush := client.RPopLPush("list", "list2")
+			Expect(rPopLPush.Err()).NotTo(HaveOccurred())
+			Expect(rPopLPush.Val()).To(Equal("three"))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"one", "two"}))
+
+			lRange = client.LRange("list2", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"three"}))
+		})
+
+		It("should RPush", func() {
+			rPush := client.RPush("list", "Hello")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			Expect(rPush.Val()).To(Equal(int64(1)))
+
+			rPush = client.RPush("list", "World")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			Expect(rPush.Val()).To(Equal(int64(2)))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
+		})
+
+		It("should RPushX", func() {
+			rPush := client.RPush("list", "Hello")
+			Expect(rPush.Err()).NotTo(HaveOccurred())
+			Expect(rPush.Val()).To(Equal(int64(1)))
+
+			rPushX := client.RPushX("list", "World")
+			Expect(rPushX.Err()).NotTo(HaveOccurred())
+			Expect(rPushX.Val()).To(Equal(int64(2)))
+
+			rPushX = client.RPushX("list2", "World")
+			Expect(rPushX.Err()).NotTo(HaveOccurred())
+			Expect(rPushX.Val()).To(Equal(int64(0)))
+
+			lRange := client.LRange("list", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
+
+			lRange = client.LRange("list2", 0, -1)
+			Expect(lRange.Err()).NotTo(HaveOccurred())
+			Expect(lRange.Val()).To(Equal([]string{}))
+		})
+
+	})
+
+	Describe("sets", func() {
+
+		It("should SAdd", func() {
+			sAdd := client.SAdd("set", "Hello")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			Expect(sAdd.Val()).To(Equal(int64(1)))
+
+			sAdd = client.SAdd("set", "World")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			Expect(sAdd.Val()).To(Equal(int64(1)))
+
+			sAdd = client.SAdd("set", "World")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			Expect(sAdd.Val()).To(Equal(int64(0)))
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(ConsistOf([]string{"Hello", "World"}))
+		})
+
+		It("should SCard", func() {
+			sAdd := client.SAdd("set", "Hello")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			Expect(sAdd.Val()).To(Equal(int64(1)))
+
+			sAdd = client.SAdd("set", "World")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			Expect(sAdd.Val()).To(Equal(int64(1)))
+
+			sCard := client.SCard("set")
+			Expect(sCard.Err()).NotTo(HaveOccurred())
+			Expect(sCard.Val()).To(Equal(int64(2)))
+		})
+
+		It("should SDiff", func() {
+			sAdd := client.SAdd("set1", "a")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "b")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sAdd = client.SAdd("set2", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "d")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "e")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sDiff := client.SDiff("set1", "set2")
+			Expect(sDiff.Err()).NotTo(HaveOccurred())
+			Expect(sDiff.Val()).To(ConsistOf([]string{"a", "b"}))
+		})
+
+		It("should SDiffStore", func() {
+			sAdd := client.SAdd("set1", "a")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "b")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sAdd = client.SAdd("set2", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "d")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "e")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sDiffStore := client.SDiffStore("set", "set1", "set2")
+			Expect(sDiffStore.Err()).NotTo(HaveOccurred())
+			Expect(sDiffStore.Val()).To(Equal(int64(2)))
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(ConsistOf([]string{"a", "b"}))
+		})
+
+		It("should SInter", func() {
+			sAdd := client.SAdd("set1", "a")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "b")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sAdd = client.SAdd("set2", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "d")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "e")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sInter := client.SInter("set1", "set2")
+			Expect(sInter.Err()).NotTo(HaveOccurred())
+			Expect(sInter.Val()).To(Equal([]string{"c"}))
+		})
+
+		It("should SInterStore", func() {
+			sAdd := client.SAdd("set1", "a")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "b")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sAdd = client.SAdd("set2", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "d")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "e")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sInterStore := client.SInterStore("set", "set1", "set2")
+			Expect(sInterStore.Err()).NotTo(HaveOccurred())
+			Expect(sInterStore.Val()).To(Equal(int64(1)))
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(Equal([]string{"c"}))
+		})
+
+		It("should IsMember", func() {
+			sAdd := client.SAdd("set", "one")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sIsMember := client.SIsMember("set", "one")
+			Expect(sIsMember.Err()).NotTo(HaveOccurred())
+			Expect(sIsMember.Val()).To(Equal(true))
+
+			sIsMember = client.SIsMember("set", "two")
+			Expect(sIsMember.Err()).NotTo(HaveOccurred())
+			Expect(sIsMember.Val()).To(Equal(false))
+		})
+
+		It("should SMembers", func() {
+			sAdd := client.SAdd("set", "Hello")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "World")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(ConsistOf([]string{"Hello", "World"}))
+		})
+
+		It("should SMove", func() {
+			sAdd := client.SAdd("set1", "one")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "two")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sAdd = client.SAdd("set2", "three")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sMove := client.SMove("set1", "set2", "two")
+			Expect(sMove.Err()).NotTo(HaveOccurred())
+			Expect(sMove.Val()).To(Equal(true))
+
+			sMembers := client.SMembers("set1")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(Equal([]string{"one"}))
+
+			sMembers = client.SMembers("set2")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(ConsistOf([]string{"three", "two"}))
+		})
+
+		It("should SPop", func() {
+			sAdd := client.SAdd("set", "one")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "two")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "three")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sPop := client.SPop("set")
+			Expect(sPop.Err()).NotTo(HaveOccurred())
+			Expect(sPop.Val()).NotTo(Equal(""))
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(HaveLen(2))
+
+		})
+
+		It("should SPopN", func() {
+			sAdd := client.SAdd("set", "one")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "two")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "three")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "four")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sPopN := client.SPopN("set", 1)
+			Expect(sPopN.Err()).NotTo(HaveOccurred())
+			Expect(sPopN.Val()).NotTo(Equal([]string{""}))
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(HaveLen(3))
+
+			sPopN = client.SPopN("set", 4)
+			Expect(sPopN.Err()).NotTo(HaveOccurred())
+			Expect(sPopN.Val()).To(HaveLen(3))
+
+			sMembers = client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(HaveLen(0))
+		})
+
+		It("should SRandMember and SRandMemberN", func() {
+			err := client.SAdd("set", "one").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.SAdd("set", "two").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.SAdd("set", "three").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			members, err := client.SMembers("set").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(members).To(HaveLen(3))
+
+			member, err := client.SRandMember("set").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(member).NotTo(Equal(""))
+
+			members, err = client.SRandMemberN("set", 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(members).To(HaveLen(2))
+		})
+
+		It("should SRem", func() {
+			sAdd := client.SAdd("set", "one")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "two")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set", "three")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sRem := client.SRem("set", "one")
+			Expect(sRem.Err()).NotTo(HaveOccurred())
+			Expect(sRem.Val()).To(Equal(int64(1)))
+
+			sRem = client.SRem("set", "four")
+			Expect(sRem.Err()).NotTo(HaveOccurred())
+			Expect(sRem.Val()).To(Equal(int64(0)))
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(ConsistOf([]string{"three", "two"}))
+		})
+
+		It("should SUnion", func() {
+			sAdd := client.SAdd("set1", "a")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "b")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sAdd = client.SAdd("set2", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "d")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "e")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sUnion := client.SUnion("set1", "set2")
+			Expect(sUnion.Err()).NotTo(HaveOccurred())
+			Expect(sUnion.Val()).To(HaveLen(5))
+		})
+
+		It("should SUnionStore", func() {
+			sAdd := client.SAdd("set1", "a")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "b")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set1", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sAdd = client.SAdd("set2", "c")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "d")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+			sAdd = client.SAdd("set2", "e")
+			Expect(sAdd.Err()).NotTo(HaveOccurred())
+
+			sUnionStore := client.SUnionStore("set", "set1", "set2")
+			Expect(sUnionStore.Err()).NotTo(HaveOccurred())
+			Expect(sUnionStore.Val()).To(Equal(int64(5)))
+
+			sMembers := client.SMembers("set")
+			Expect(sMembers.Err()).NotTo(HaveOccurred())
+			Expect(sMembers.Val()).To(HaveLen(5))
+		})
+
+	})
+
+	Describe("sorted sets", func() {
+
+		It("should ZAdd", func() {
+			added, err := client.ZAdd("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			added, err = client.ZAdd("zset", redis.Z{1, "uno"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			added, err = client.ZAdd("zset", redis.Z{2, "two"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			added, err = client.ZAdd("zset", redis.Z{3, "two"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(0)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}, {1, "uno"}, {3, "two"}}))
+		})
+
+		It("should ZAdd bytes", func() {
+			added, err := client.ZAdd("zset", redis.Z{1, []byte("one")}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			added, err = client.ZAdd("zset", redis.Z{1, []byte("uno")}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			added, err = client.ZAdd("zset", redis.Z{2, []byte("two")}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			added, err = client.ZAdd("zset", redis.Z{3, []byte("two")}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(0)))
+
+			val, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{1, "one"}, {1, "uno"}, {3, "two"}}))
+		})
+
+		It("should ZAddNX", func() {
+			added, err := client.ZAddNX("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}}))
+
+			added, err = client.ZAddNX("zset", redis.Z{2, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(0)))
+
+			vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}}))
+		})
+
+		It("should ZAddXX", func() {
+			added, err := client.ZAddXX("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(0)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(BeEmpty())
+
+			added, err = client.ZAdd("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			added, err = client.ZAddXX("zset", redis.Z{2, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(0)))
+
+			vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{2, "one"}}))
+		})
+
+		It("should ZAddCh", func() {
+			changed, err := client.ZAddCh("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(changed).To(Equal(int64(1)))
+
+			changed, err = client.ZAddCh("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(changed).To(Equal(int64(0)))
+		})
+
+		It("should ZAddNXCh", func() {
+			changed, err := client.ZAddNXCh("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(changed).To(Equal(int64(1)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}}))
+
+			changed, err = client.ZAddNXCh("zset", redis.Z{2, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(changed).To(Equal(int64(0)))
+
+			vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}}))
+		})
+
+		It("should ZAddXXCh", func() {
+			changed, err := client.ZAddXXCh("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(changed).To(Equal(int64(0)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(BeEmpty())
+
+			added, err := client.ZAdd("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			changed, err = client.ZAddXXCh("zset", redis.Z{2, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(changed).To(Equal(int64(1)))
+
+			vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{2, "one"}}))
+		})
+
+		It("should ZIncr", func() {
+			score, err := client.ZIncr("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(score).To(Equal(float64(1)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}}))
+
+			score, err = client.ZIncr("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(score).To(Equal(float64(2)))
+
+			vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{2, "one"}}))
+		})
+
+		It("should ZIncrNX", func() {
+			score, err := client.ZIncrNX("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(score).To(Equal(float64(1)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}}))
+
+			score, err = client.ZIncrNX("zset", redis.Z{1, "one"}).Result()
+			Expect(err).To(Equal(redis.Nil))
+			Expect(score).To(Equal(float64(0)))
+
+			vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{1, "one"}}))
+		})
+
+		It("should ZIncrXX", func() {
+			score, err := client.ZIncrXX("zset", redis.Z{1, "one"}).Result()
+			Expect(err).To(Equal(redis.Nil))
+			Expect(score).To(Equal(float64(0)))
+
+			vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(BeEmpty())
+
+			added, err := client.ZAdd("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(added).To(Equal(int64(1)))
+
+			score, err = client.ZIncrXX("zset", redis.Z{1, "one"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(score).To(Equal(float64(2)))
+
+			vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{2, "one"}}))
+		})
+
+		It("should ZCard", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zCard := client.ZCard("zset")
+			Expect(zCard.Err()).NotTo(HaveOccurred())
+			Expect(zCard.Val()).To(Equal(int64(2)))
+		})
+
+		It("should ZCount", func() {
+			err := client.ZAdd("zset", redis.Z{1, "one"}).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.ZAdd("zset", redis.Z{2, "two"}).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.ZAdd("zset", redis.Z{3, "three"}).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			count, err := client.ZCount("zset", "-inf", "+inf").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(count).To(Equal(int64(3)))
+
+			count, err = client.ZCount("zset", "(1", "3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(count).To(Equal(int64(2)))
+
+			count, err = client.ZLexCount("zset", "-", "+").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(count).To(Equal(int64(3)))
+		})
+
+		It("should ZIncrBy", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zIncrBy := client.ZIncrBy("zset", 2, "one")
+			Expect(zIncrBy.Err()).NotTo(HaveOccurred())
+			Expect(zIncrBy.Val()).To(Equal(float64(3)))
+
+			val, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{2, "two"}, {3, "one"}}))
+		})
+
+		It("should ZInterStore", func() {
+			zAdd := client.ZAdd("zset1", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset1", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zAdd = client.ZAdd("zset2", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset2", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset3", redis.Z{3, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zInterStore := client.ZInterStore(
+				"out", redis.ZStore{Weights: []float64{2, 3}}, "zset1", "zset2")
+			Expect(zInterStore.Err()).NotTo(HaveOccurred())
+			Expect(zInterStore.Val()).To(Equal(int64(2)))
+
+			val, err := client.ZRangeWithScores("out", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{5, "one"}, {10, "two"}}))
+		})
+
+		It("should ZRange", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRange := client.ZRange("zset", 0, -1)
+			Expect(zRange.Err()).NotTo(HaveOccurred())
+			Expect(zRange.Val()).To(Equal([]string{"one", "two", "three"}))
+
+			zRange = client.ZRange("zset", 2, 3)
+			Expect(zRange.Err()).NotTo(HaveOccurred())
+			Expect(zRange.Val()).To(Equal([]string{"three"}))
+
+			zRange = client.ZRange("zset", -2, -1)
+			Expect(zRange.Err()).NotTo(HaveOccurred())
+			Expect(zRange.Val()).To(Equal([]string{"two", "three"}))
+		})
+
+		It("should ZRangeWithScores", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			val, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{1, "one"}, {2, "two"}, {3, "three"}}))
+
+			val, err = client.ZRangeWithScores("zset", 2, 3).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{3, "three"}}))
+
+			val, err = client.ZRangeWithScores("zset", -2, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{2, "two"}, {3, "three"}}))
+		})
+
+		It("should ZRangeByScore", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRangeByScore := client.ZRangeByScore("zset", redis.ZRangeBy{
+				Min: "-inf",
+				Max: "+inf",
+			})
+			Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByScore.Val()).To(Equal([]string{"one", "two", "three"}))
+
+			zRangeByScore = client.ZRangeByScore("zset", redis.ZRangeBy{
+				Min: "1",
+				Max: "2",
+			})
+			Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByScore.Val()).To(Equal([]string{"one", "two"}))
+
+			zRangeByScore = client.ZRangeByScore("zset", redis.ZRangeBy{
+				Min: "(1",
+				Max: "2",
+			})
+			Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByScore.Val()).To(Equal([]string{"two"}))
+
+			zRangeByScore = client.ZRangeByScore("zset", redis.ZRangeBy{
+				Min: "(1",
+				Max: "(2",
+			})
+			Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByScore.Val()).To(Equal([]string{}))
+		})
+
+		It("should ZRangeByLex", func() {
+			zAdd := client.ZAdd("zset", redis.Z{0, "a"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{0, "b"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{0, "c"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRangeByLex := client.ZRangeByLex("zset", redis.ZRangeBy{
+				Min: "-",
+				Max: "+",
+			})
+			Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByLex.Val()).To(Equal([]string{"a", "b", "c"}))
+
+			zRangeByLex = client.ZRangeByLex("zset", redis.ZRangeBy{
+				Min: "[a",
+				Max: "[b",
+			})
+			Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByLex.Val()).To(Equal([]string{"a", "b"}))
+
+			zRangeByLex = client.ZRangeByLex("zset", redis.ZRangeBy{
+				Min: "(a",
+				Max: "[b",
+			})
+			Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByLex.Val()).To(Equal([]string{"b"}))
+
+			zRangeByLex = client.ZRangeByLex("zset", redis.ZRangeBy{
+				Min: "(a",
+				Max: "(b",
+			})
+			Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
+			Expect(zRangeByLex.Val()).To(Equal([]string{}))
+		})
+
+		It("should ZRangeByScoreWithScoresMap", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			val, err := client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
+				Min: "-inf",
+				Max: "+inf",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{1, "one"}, {2, "two"}, {3, "three"}}))
+
+			val, err = client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
+				Min: "1",
+				Max: "2",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{1, "one"}, {2, "two"}}))
+
+			val, err = client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
+				Min: "(1",
+				Max: "2",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{2, "two"}}))
+
+			val, err = client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
+				Min: "(1",
+				Max: "(2",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{}))
+		})
+
+		It("should ZRank", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRank := client.ZRank("zset", "three")
+			Expect(zRank.Err()).NotTo(HaveOccurred())
+			Expect(zRank.Val()).To(Equal(int64(2)))
+
+			zRank = client.ZRank("zset", "four")
+			Expect(zRank.Err()).To(Equal(redis.Nil))
+			Expect(zRank.Val()).To(Equal(int64(0)))
+		})
+
+		It("should ZRem", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRem := client.ZRem("zset", "two")
+			Expect(zRem.Err()).NotTo(HaveOccurred())
+			Expect(zRem.Val()).To(Equal(int64(1)))
+
+			val, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{1, "one"}, {3, "three"}}))
+		})
+
+		It("should ZRemRangeByRank", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRemRangeByRank := client.ZRemRangeByRank("zset", 0, 1)
+			Expect(zRemRangeByRank.Err()).NotTo(HaveOccurred())
+			Expect(zRemRangeByRank.Val()).To(Equal(int64(2)))
+
+			val, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{3, "three"}}))
+		})
+
+		It("should ZRemRangeByScore", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRemRangeByScore := client.ZRemRangeByScore("zset", "-inf", "(2")
+			Expect(zRemRangeByScore.Err()).NotTo(HaveOccurred())
+			Expect(zRemRangeByScore.Val()).To(Equal(int64(1)))
+
+			val, err := client.ZRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{2, "two"}, {3, "three"}}))
+		})
+
+		It("should ZRemRangeByLex", func() {
+			zz := []redis.Z{
+				{0, "aaaa"},
+				{0, "b"},
+				{0, "c"},
+				{0, "d"},
+				{0, "e"},
+				{0, "foo"},
+				{0, "zap"},
+				{0, "zip"},
+				{0, "ALPHA"},
+				{0, "alpha"},
+			}
+			for _, z := range zz {
+				err := client.ZAdd("zset", z).Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+
+			n, err := client.ZRemRangeByLex("zset", "[alpha", "[omega").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(6)))
+
+			vals, err := client.ZRange("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]string{"ALPHA", "aaaa", "zap", "zip"}))
+		})
+
+		It("should ZRevRange", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRevRange := client.ZRevRange("zset", 0, -1)
+			Expect(zRevRange.Err()).NotTo(HaveOccurred())
+			Expect(zRevRange.Val()).To(Equal([]string{"three", "two", "one"}))
+
+			zRevRange = client.ZRevRange("zset", 2, 3)
+			Expect(zRevRange.Err()).NotTo(HaveOccurred())
+			Expect(zRevRange.Val()).To(Equal([]string{"one"}))
+
+			zRevRange = client.ZRevRange("zset", -2, -1)
+			Expect(zRevRange.Err()).NotTo(HaveOccurred())
+			Expect(zRevRange.Val()).To(Equal([]string{"two", "one"}))
+		})
+
+		It("should ZRevRangeWithScoresMap", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			val, err := client.ZRevRangeWithScores("zset", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{3, "three"}, {2, "two"}, {1, "one"}}))
+
+			val, err = client.ZRevRangeWithScores("zset", 2, 3).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{1, "one"}}))
+
+			val, err = client.ZRevRangeWithScores("zset", -2, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{2, "two"}, {1, "one"}}))
+		})
+
+		It("should ZRevRangeByScore", func() {
+			zadd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+			zadd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+			zadd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+
+			vals, err := client.ZRevRangeByScore(
+				"zset", redis.ZRangeBy{Max: "+inf", Min: "-inf"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]string{"three", "two", "one"}))
+
+			vals, err = client.ZRevRangeByScore(
+				"zset", redis.ZRangeBy{Max: "2", Min: "(1"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]string{"two"}))
+
+			vals, err = client.ZRevRangeByScore(
+				"zset", redis.ZRangeBy{Max: "(2", Min: "(1"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]string{}))
+		})
+
+		It("should ZRevRangeByLex", func() {
+			zadd := client.ZAdd("zset", redis.Z{0, "a"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+			zadd = client.ZAdd("zset", redis.Z{0, "b"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+			zadd = client.ZAdd("zset", redis.Z{0, "c"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+
+			vals, err := client.ZRevRangeByLex(
+				"zset", redis.ZRangeBy{Max: "+", Min: "-"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]string{"c", "b", "a"}))
+
+			vals, err = client.ZRevRangeByLex(
+				"zset", redis.ZRangeBy{Max: "[b", Min: "(a"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]string{"b"}))
+
+			vals, err = client.ZRevRangeByLex(
+				"zset", redis.ZRangeBy{Max: "(b", Min: "(a"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]string{}))
+		})
+
+		It("should ZRevRangeByScoreWithScores", func() {
+			zadd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+			zadd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+			zadd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zadd.Err()).NotTo(HaveOccurred())
+
+			vals, err := client.ZRevRangeByScoreWithScores(
+				"zset", redis.ZRangeBy{Max: "+inf", Min: "-inf"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]redis.Z{{3, "three"}, {2, "two"}, {1, "one"}}))
+		})
+
+		It("should ZRevRangeByScoreWithScoresMap", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			val, err := client.ZRevRangeByScoreWithScores(
+				"zset", redis.ZRangeBy{Max: "+inf", Min: "-inf"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{3, "three"}, {2, "two"}, {1, "one"}}))
+
+			val, err = client.ZRevRangeByScoreWithScores(
+				"zset", redis.ZRangeBy{Max: "2", Min: "(1"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{2, "two"}}))
+
+			val, err = client.ZRevRangeByScoreWithScores(
+				"zset", redis.ZRangeBy{Max: "(2", Min: "(1"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{}))
+		})
+
+		It("should ZRevRank", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zRevRank := client.ZRevRank("zset", "one")
+			Expect(zRevRank.Err()).NotTo(HaveOccurred())
+			Expect(zRevRank.Val()).To(Equal(int64(2)))
+
+			zRevRank = client.ZRevRank("zset", "four")
+			Expect(zRevRank.Err()).To(Equal(redis.Nil))
+			Expect(zRevRank.Val()).To(Equal(int64(0)))
+		})
+
+		It("should ZScore", func() {
+			zAdd := client.ZAdd("zset", redis.Z{1.001, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zScore := client.ZScore("zset", "one")
+			Expect(zScore.Err()).NotTo(HaveOccurred())
+			Expect(zScore.Val()).To(Equal(float64(1.001)))
+		})
+
+		It("should ZUnionStore", func() {
+			zAdd := client.ZAdd("zset1", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset1", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zAdd = client.ZAdd("zset2", redis.Z{1, "one"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset2", redis.Z{2, "two"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+			zAdd = client.ZAdd("zset2", redis.Z{3, "three"})
+			Expect(zAdd.Err()).NotTo(HaveOccurred())
+
+			zUnionStore := client.ZUnionStore(
+				"out", redis.ZStore{Weights: []float64{2, 3}}, "zset1", "zset2")
+			Expect(zUnionStore.Err()).NotTo(HaveOccurred())
+			Expect(zUnionStore.Val()).To(Equal(int64(3)))
+
+			val, err := client.ZRangeWithScores("out", 0, -1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal([]redis.Z{{5, "one"}, {9, "three"}, {10, "two"}}))
+		})
+
+	})
+
+	Describe("Geo add and radius search", func() {
+		BeforeEach(func() {
+			geoAdd := client.GeoAdd(
+				"Sicily",
+				&redis.GeoLocation{Longitude: 13.361389, Latitude: 38.115556, Name: "Palermo"},
+				&redis.GeoLocation{Longitude: 15.087269, Latitude: 37.502669, Name: "Catania"},
+			)
+			Expect(geoAdd.Err()).NotTo(HaveOccurred())
+			Expect(geoAdd.Val()).To(Equal(int64(2)))
+		})
+
+		It("should not add same geo location", func() {
+			geoAdd := client.GeoAdd(
+				"Sicily",
+				&redis.GeoLocation{Longitude: 13.361389, Latitude: 38.115556, Name: "Palermo"},
+			)
+			Expect(geoAdd.Err()).NotTo(HaveOccurred())
+			Expect(geoAdd.Val()).To(Equal(int64(0)))
+		})
+
+		It("should search geo radius", func() {
+			res, err := client.GeoRadius("Sicily", 15, 37, &redis.GeoRadiusQuery{
+				Radius: 200,
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(HaveLen(2))
+			Expect(res[0].Name).To(Equal("Palermo"))
+			Expect(res[1].Name).To(Equal("Catania"))
+		})
+
+		It("should search geo radius with options", func() {
+			res, err := client.GeoRadius("Sicily", 15, 37, &redis.GeoRadiusQuery{
+				Radius:      200,
+				Unit:        "km",
+				WithGeoHash: true,
+				WithCoord:   true,
+				WithDist:    true,
+				Count:       2,
+				Sort:        "ASC",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(HaveLen(2))
+			Expect(res[1].Name).To(Equal("Palermo"))
+			Expect(res[1].Dist).To(Equal(190.4424))
+			Expect(res[1].GeoHash).To(Equal(int64(3479099956230698)))
+			Expect(res[1].Longitude).To(Equal(13.361389338970184))
+			Expect(res[1].Latitude).To(Equal(38.115556395496299))
+			Expect(res[0].Name).To(Equal("Catania"))
+			Expect(res[0].Dist).To(Equal(56.4413))
+			Expect(res[0].GeoHash).To(Equal(int64(3479447370796909)))
+			Expect(res[0].Longitude).To(Equal(15.087267458438873))
+			Expect(res[0].Latitude).To(Equal(37.50266842333162))
+		})
+
+		It("should search geo radius with WithDist=false", func() {
+			res, err := client.GeoRadius("Sicily", 15, 37, &redis.GeoRadiusQuery{
+				Radius:      200,
+				Unit:        "km",
+				WithGeoHash: true,
+				WithCoord:   true,
+				Count:       2,
+				Sort:        "ASC",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(HaveLen(2))
+			Expect(res[1].Name).To(Equal("Palermo"))
+			Expect(res[1].Dist).To(Equal(float64(0)))
+			Expect(res[1].GeoHash).To(Equal(int64(3479099956230698)))
+			Expect(res[1].Longitude).To(Equal(13.361389338970184))
+			Expect(res[1].Latitude).To(Equal(38.115556395496299))
+			Expect(res[0].Name).To(Equal("Catania"))
+			Expect(res[0].Dist).To(Equal(float64(0)))
+			Expect(res[0].GeoHash).To(Equal(int64(3479447370796909)))
+			Expect(res[0].Longitude).To(Equal(15.087267458438873))
+			Expect(res[0].Latitude).To(Equal(37.50266842333162))
+		})
+
+		It("should search geo radius by member with options", func() {
+			res, err := client.GeoRadiusByMember("Sicily", "Catania", &redis.GeoRadiusQuery{
+				Radius:      200,
+				Unit:        "km",
+				WithGeoHash: true,
+				WithCoord:   true,
+				WithDist:    true,
+				Count:       2,
+				Sort:        "ASC",
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(HaveLen(2))
+			Expect(res[0].Name).To(Equal("Catania"))
+			Expect(res[0].Dist).To(Equal(0.0))
+			Expect(res[0].GeoHash).To(Equal(int64(3479447370796909)))
+			Expect(res[0].Longitude).To(Equal(15.087267458438873))
+			Expect(res[0].Latitude).To(Equal(37.50266842333162))
+			Expect(res[1].Name).To(Equal("Palermo"))
+			Expect(res[1].Dist).To(Equal(166.2742))
+			Expect(res[1].GeoHash).To(Equal(int64(3479099956230698)))
+			Expect(res[1].Longitude).To(Equal(13.361389338970184))
+			Expect(res[1].Latitude).To(Equal(38.115556395496299))
+		})
+
+		It("should search geo radius with no results", func() {
+			res, err := client.GeoRadius("Sicily", 99, 37, &redis.GeoRadiusQuery{
+				Radius:      200,
+				Unit:        "km",
+				WithGeoHash: true,
+				WithCoord:   true,
+				WithDist:    true,
+			}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(HaveLen(0))
+		})
+
+		It("should get geo distance with unit options", func() {
+			// From Redis CLI, note the difference in rounding in m vs
+			// km on Redis itself.
+			//
+			// GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+			// GEODIST Sicily Palermo Catania m
+			// "166274.15156960033"
+			// GEODIST Sicily Palermo Catania km
+			// "166.27415156960032"
+			dist, err := client.GeoDist("Sicily", "Palermo", "Catania", "km").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(dist).To(BeNumerically("~", 166.27, 0.01))
+
+			dist, err = client.GeoDist("Sicily", "Palermo", "Catania", "m").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(dist).To(BeNumerically("~", 166274.15, 0.01))
+		})
+
+		It("should get geo hash in string representation", func() {
+			hashes, err := client.GeoHash("Sicily", "Palermo", "Catania").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(hashes).To(ConsistOf([]string{"sqc8b49rny0", "sqdtr74hyu0"}))
+		})
+
+		It("should return geo position", func() {
+			pos, err := client.GeoPos("Sicily", "Palermo", "Catania", "NonExisting").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(pos).To(ConsistOf([]*redis.GeoPos{
+				{
+					Longitude: 13.361389338970184,
+					Latitude:  38.1155563954963,
+				},
+				{
+					Longitude: 15.087267458438873,
+					Latitude:  37.50266842333162,
+				},
+				nil,
+			}))
+		})
+	})
+
+	Describe("marshaling/unmarshaling", func() {
+
+		type convTest struct {
+			value  interface{}
+			wanted string
+			dest   interface{}
+		}
+
+		convTests := []convTest{
+			{nil, "", nil},
+			{"hello", "hello", new(string)},
+			{[]byte("hello"), "hello", new([]byte)},
+			{int(1), "1", new(int)},
+			{int8(1), "1", new(int8)},
+			{int16(1), "1", new(int16)},
+			{int32(1), "1", new(int32)},
+			{int64(1), "1", new(int64)},
+			{uint(1), "1", new(uint)},
+			{uint8(1), "1", new(uint8)},
+			{uint16(1), "1", new(uint16)},
+			{uint32(1), "1", new(uint32)},
+			{uint64(1), "1", new(uint64)},
+			{float32(1.0), "1", new(float32)},
+			{float64(1.0), "1", new(float64)},
+			{true, "1", new(bool)},
+			{false, "0", new(bool)},
+		}
+
+		It("should convert to string", func() {
+			for _, test := range convTests {
+				err := client.Set("key", test.value, 0).Err()
+				Expect(err).NotTo(HaveOccurred())
+
+				s, err := client.Get("key").Result()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(s).To(Equal(test.wanted))
+
+				if test.dest == nil {
+					continue
+				}
+
+				err = client.Get("key").Scan(test.dest)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(deref(test.dest)).To(Equal(test.value))
+			}
+		})
+
+	})
+
+	Describe("json marshaling/unmarshaling", func() {
+
+		BeforeEach(func() {
+			value := &numberStruct{Number: 42}
+			err := client.Set("key", value, 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It("should marshal custom values using json", func() {
+			s, err := client.Get("key").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(s).To(Equal(`{"Number":42}`))
+		})
+
+		It("should scan custom values using json", func() {
+			value := &numberStruct{}
+			err := client.Get("key").Scan(value)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(value.Number).To(Equal(42))
+		})
+
+	})
+
+	Describe("Command", func() {
+
+		It("returns map of commands", func() {
+			cmds, err := client.Command().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(cmds)).To(BeNumerically("~", 180, 10))
+
+			cmd := cmds["mget"]
+			Expect(cmd.Name).To(Equal("mget"))
+			Expect(cmd.Arity).To(Equal(int8(-2)))
+			Expect(cmd.Flags).To(ContainElement("readonly"))
+			Expect(cmd.FirstKeyPos).To(Equal(int8(1)))
+			Expect(cmd.LastKeyPos).To(Equal(int8(-1)))
+			Expect(cmd.StepCount).To(Equal(int8(1)))
+		})
+
+	})
+
+	Describe("Eval", func() {
+
+		It("returns keys and values", func() {
+			vals, err := client.Eval(
+				"return {KEYS[1],ARGV[1]}",
+				[]string{"key"},
+				"hello",
+			).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(vals).To(Equal([]interface{}{"key", "hello"}))
+		})
+
+	})
+
+})
+
+type numberStruct struct {
+	Number int
+}
+
+func (s *numberStruct) MarshalBinary() ([]byte, error) {
+	return json.Marshal(s)
+}
+
+func (s *numberStruct) UnmarshalBinary(b []byte) error {
+	return json.Unmarshal(b, s)
+}
+
+func deref(viface interface{}) interface{} {
+	v := reflect.ValueOf(viface)
+	for v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+	return v.Interface()
+}
diff --git a/doc.go b/doc.go
new file mode 100644
index 00000000..55262533
--- /dev/null
+++ b/doc.go
@@ -0,0 +1,4 @@
+/*
+Package redis implements a Redis client.
+*/
+package redis
diff --git a/example_instrumentation_test.go b/example_instrumentation_test.go
new file mode 100644
index 00000000..02051f9c
--- /dev/null
+++ b/example_instrumentation_test.go
@@ -0,0 +1,59 @@
+package redis_test
+
+import (
+	"fmt"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-redis/redis"
+)
+
+func Example_instrumentation() {
+	ring := redis.NewRing(&redis.RingOptions{
+		Addrs: map[string]string{
+			"shard1": ":6379",
+		},
+	})
+	ring.ForEachShard(func(client *redis.Client) error {
+		wrapRedisProcess(client)
+		return nil
+	})
+
+	for {
+		ring.Ping()
+	}
+}
+
+func wrapRedisProcess(client *redis.Client) {
+	const precision = time.Microsecond
+	var count, avgDur uint32
+
+	go func() {
+		for range time.Tick(3 * time.Second) {
+			n := atomic.LoadUint32(&count)
+			dur := time.Duration(atomic.LoadUint32(&avgDur)) * precision
+			fmt.Printf("%s: processed=%d avg_dur=%s\n", client, n, dur)
+		}
+	}()
+
+	client.WrapProcess(func(oldProcess func(redis.Cmder) error) func(redis.Cmder) error {
+		return func(cmd redis.Cmder) error {
+			start := time.Now()
+			err := oldProcess(cmd)
+			dur := time.Since(start)
+
+			const decay = float64(1) / 100
+			ms := float64(dur / precision)
+			for {
+				avg := atomic.LoadUint32(&avgDur)
+				newAvg := uint32((1-decay)*float64(avg) + decay*ms)
+				if atomic.CompareAndSwapUint32(&avgDur, avg, newAvg) {
+					break
+				}
+			}
+			atomic.AddUint32(&count, 1)
+
+			return err
+		}
+	})
+}
diff --git a/example_test.go b/example_test.go
new file mode 100644
index 00000000..7e04cd48
--- /dev/null
+++ b/example_test.go
@@ -0,0 +1,414 @@
+package redis_test
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/go-redis/redis"
+)
+
+var client *redis.Client
+
+func init() {
+	client = redis.NewClient(&redis.Options{
+		Addr:         ":6379",
+		DialTimeout:  10 * time.Second,
+		ReadTimeout:  30 * time.Second,
+		WriteTimeout: 30 * time.Second,
+		PoolSize:     10,
+		PoolTimeout:  30 * time.Second,
+	})
+	client.FlushDB()
+}
+
+func ExampleNewClient() {
+	client := redis.NewClient(&redis.Options{
+		Addr:     "localhost:6379",
+		Password: "", // no password set
+		DB:       0,  // use default DB
+	})
+
+	pong, err := client.Ping().Result()
+	fmt.Println(pong, err)
+	// Output: PONG <nil>
+}
+
+func ExampleParseURL() {
+	opt, err := redis.ParseURL("redis://:qwerty@localhost:6379/1")
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println("addr is", opt.Addr)
+	fmt.Println("db is", opt.DB)
+	fmt.Println("password is", opt.Password)
+
+	// Create client as usually.
+	_ = redis.NewClient(opt)
+
+	// Output: addr is localhost:6379
+	// db is 1
+	// password is qwerty
+}
+
+func ExampleNewFailoverClient() {
+	// See http://redis.io/topics/sentinel for instructions how to
+	// setup Redis Sentinel.
+	client := redis.NewFailoverClient(&redis.FailoverOptions{
+		MasterName:    "master",
+		SentinelAddrs: []string{":26379"},
+	})
+	client.Ping()
+}
+
+func ExampleNewClusterClient() {
+	// See http://redis.io/topics/cluster-tutorial for instructions
+	// how to setup Redis Cluster.
+	client := redis.NewClusterClient(&redis.ClusterOptions{
+		Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
+	})
+	client.Ping()
+}
+
+func ExampleNewRing() {
+	client := redis.NewRing(&redis.RingOptions{
+		Addrs: map[string]string{
+			"shard1": ":7000",
+			"shard2": ":7001",
+			"shard3": ":7002",
+		},
+	})
+	client.Ping()
+}
+
+func ExampleClient() {
+	err := client.Set("key", "value", 0).Err()
+	if err != nil {
+		panic(err)
+	}
+
+	val, err := client.Get("key").Result()
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println("key", val)
+
+	val2, err := client.Get("key2").Result()
+	if err == redis.Nil {
+		fmt.Println("key2 does not exists")
+	} else if err != nil {
+		panic(err)
+	} else {
+		fmt.Println("key2", val2)
+	}
+	// Output: key value
+	// key2 does not exists
+}
+
+func ExampleClient_Set() {
+	// Last argument is expiration. Zero means the key has no
+	// expiration time.
+	err := client.Set("key", "value", 0).Err()
+	if err != nil {
+		panic(err)
+	}
+
+	// key2 will expire in an hour.
+	err = client.Set("key2", "value", time.Hour).Err()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func ExampleClient_Incr() {
+	result, err := client.Incr("counter").Result()
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(result)
+	// Output: 1
+}
+
+func ExampleClient_BLPop() {
+	if err := client.RPush("queue", "message").Err(); err != nil {
+		panic(err)
+	}
+
+	// use `client.BLPop(0, "queue")` for infinite waiting time
+	result, err := client.BLPop(1*time.Second, "queue").Result()
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(result[0], result[1])
+	// Output: queue message
+}
+
+func ExampleClient_Scan() {
+	client.FlushDB()
+	for i := 0; i < 33; i++ {
+		err := client.Set(fmt.Sprintf("key%d", i), "value", 0).Err()
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	var cursor uint64
+	var n int
+	for {
+		var keys []string
+		var err error
+		keys, cursor, err = client.Scan(cursor, "", 10).Result()
+		if err != nil {
+			panic(err)
+		}
+		n += len(keys)
+		if cursor == 0 {
+			break
+		}
+	}
+
+	fmt.Printf("found %d keys\n", n)
+	// Output: found 33 keys
+}
+
+func ExampleClient_Pipelined() {
+	var incr *redis.IntCmd
+	_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+		incr = pipe.Incr("pipelined_counter")
+		pipe.Expire("pipelined_counter", time.Hour)
+		return nil
+	})
+	fmt.Println(incr.Val(), err)
+	// Output: 1 <nil>
+}
+
+func ExampleClient_Pipeline() {
+	pipe := client.Pipeline()
+
+	incr := pipe.Incr("pipeline_counter")
+	pipe.Expire("pipeline_counter", time.Hour)
+
+	// Execute
+	//
+	//     INCR pipeline_counter
+	//     EXPIRE pipeline_counts 3600
+	//
+	// using one client-server roundtrip.
+	_, err := pipe.Exec()
+	fmt.Println(incr.Val(), err)
+	// Output: 1 <nil>
+}
+
+func ExampleClient_TxPipelined() {
+	var incr *redis.IntCmd
+	_, err := client.TxPipelined(func(pipe redis.Pipeliner) error {
+		incr = pipe.Incr("tx_pipelined_counter")
+		pipe.Expire("tx_pipelined_counter", time.Hour)
+		return nil
+	})
+	fmt.Println(incr.Val(), err)
+	// Output: 1 <nil>
+}
+
+func ExampleClient_TxPipeline() {
+	pipe := client.TxPipeline()
+
+	incr := pipe.Incr("tx_pipeline_counter")
+	pipe.Expire("tx_pipeline_counter", time.Hour)
+
+	// Execute
+	//
+	//     MULTI
+	//     INCR pipeline_counter
+	//     EXPIRE pipeline_counts 3600
+	//     EXEC
+	//
+	// using one client-server roundtrip.
+	_, err := pipe.Exec()
+	fmt.Println(incr.Val(), err)
+	// Output: 1 <nil>
+}
+
+func ExampleClient_Watch() {
+	var incr func(string) error
+
+	// Transactionally increments key using GET and SET commands.
+	incr = func(key string) error {
+		err := client.Watch(func(tx *redis.Tx) error {
+			n, err := tx.Get(key).Int64()
+			if err != nil && err != redis.Nil {
+				return err
+			}
+
+			_, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
+				pipe.Set(key, strconv.FormatInt(n+1, 10), 0)
+				return nil
+			})
+			return err
+		}, key)
+		if err == redis.TxFailedErr {
+			return incr(key)
+		}
+		return err
+	}
+
+	var wg sync.WaitGroup
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			err := incr("counter3")
+			if err != nil {
+				panic(err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	n, err := client.Get("counter3").Int64()
+	fmt.Println(n, err)
+	// Output: 100 <nil>
+}
+
+func ExamplePubSub() {
+	pubsub := client.Subscribe("mychannel1")
+	defer pubsub.Close()
+
+	// Wait for subscription to be created before publishing message.
+	subscr, err := pubsub.ReceiveTimeout(time.Second)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(subscr)
+
+	err = client.Publish("mychannel1", "hello").Err()
+	if err != nil {
+		panic(err)
+	}
+
+	msg, err := pubsub.ReceiveMessage()
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(msg.Channel, msg.Payload)
+	// Output: subscribe: mychannel1
+	// mychannel1 hello
+}
+
+func ExamplePubSub_Receive() {
+	pubsub := client.Subscribe("mychannel2")
+	defer pubsub.Close()
+
+	for i := 0; i < 2; i++ {
+		// ReceiveTimeout is a low level API. Use ReceiveMessage instead.
+		msgi, err := pubsub.ReceiveTimeout(time.Second)
+		if err != nil {
+			break
+		}
+
+		switch msg := msgi.(type) {
+		case *redis.Subscription:
+			fmt.Println("subscribed to", msg.Channel)
+
+			_, err := client.Publish("mychannel2", "hello").Result()
+			if err != nil {
+				panic(err)
+			}
+		case *redis.Message:
+			fmt.Println("received", msg.Payload, "from", msg.Channel)
+		default:
+			panic("unreached")
+		}
+	}
+
+	// sent message to 1 client
+	// received hello from mychannel2
+}
+
+func ExampleScript() {
+	IncrByXX := redis.NewScript(`
+		if redis.call("GET", KEYS[1]) ~= false then
+			return redis.call("INCRBY", KEYS[1], ARGV[1])
+		end
+		return false
+	`)
+
+	n, err := IncrByXX.Run(client, []string{"xx_counter"}, 2).Result()
+	fmt.Println(n, err)
+
+	err = client.Set("xx_counter", "40", 0).Err()
+	if err != nil {
+		panic(err)
+	}
+
+	n, err = IncrByXX.Run(client, []string{"xx_counter"}, 2).Result()
+	fmt.Println(n, err)
+
+	// Output: <nil> redis: nil
+	// 42 <nil>
+}
+
+func Example_customCommand() {
+	Get := func(client *redis.Client, key string) *redis.StringCmd {
+		cmd := redis.NewStringCmd("get", key)
+		client.Process(cmd)
+		return cmd
+	}
+
+	v, err := Get(client, "key_does_not_exist").Result()
+	fmt.Printf("%q %s", v, err)
+	// Output: "" redis: nil
+}
+
+func ExampleScanIterator() {
+	iter := client.Scan(0, "", 0).Iterator()
+	for iter.Next() {
+		fmt.Println(iter.Val())
+	}
+	if err := iter.Err(); err != nil {
+		panic(err)
+	}
+}
+
+func ExampleScanCmd_Iterator() {
+	iter := client.Scan(0, "", 0).Iterator()
+	for iter.Next() {
+		fmt.Println(iter.Val())
+	}
+	if err := iter.Err(); err != nil {
+		panic(err)
+	}
+}
+
+func ExampleNewUniversalClient_simple() {
+	client := redis.NewUniversalClient(&redis.UniversalOptions{
+		Addrs: []string{":6379"},
+	})
+	defer client.Close()
+
+	client.Ping()
+}
+
+func ExampleNewUniversalClient_failover() {
+	client := redis.NewUniversalClient(&redis.UniversalOptions{
+		MasterName: "master",
+		Addrs:      []string{":26379"},
+	})
+	defer client.Close()
+
+	client.Ping()
+}
+
+func ExampleNewUniversalClient_cluster() {
+	client := redis.NewUniversalClient(&redis.UniversalOptions{
+		Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
+	})
+	defer client.Close()
+
+	client.Ping()
+}
diff --git a/export_test.go b/export_test.go
new file mode 100644
index 00000000..3b7965d7
--- /dev/null
+++ b/export_test.go
@@ -0,0 +1,36 @@
+package redis
+
+import (
+	"net"
+	"time"
+
+	"github.com/go-redis/redis/internal/pool"
+)
+
+func (c *baseClient) Pool() pool.Pooler {
+	return c.connPool
+}
+
+func (c *PubSub) SetNetConn(netConn net.Conn) {
+	c.cn = pool.NewConn(netConn)
+}
+
+func (c *PubSub) ReceiveMessageTimeout(timeout time.Duration) (*Message, error) {
+	return c.receiveMessage(timeout)
+}
+
+func (c *ClusterClient) SlotAddrs(slot int) []string {
+	var addrs []string
+	for _, n := range c.state().slotNodes(slot) {
+		addrs = append(addrs, n.Client.getAddr())
+	}
+	return addrs
+}
+
+// SwapSlot swaps a slot's master/slave address for testing MOVED redirects.
+func (c *ClusterClient) SwapSlotNodes(slot int) {
+	nodes := c.state().slots[slot]
+	if len(nodes) == 2 {
+		nodes[0], nodes[1] = nodes[1], nodes[0]
+	}
+}
diff --git a/internal/consistenthash/consistenthash.go b/internal/consistenthash/consistenthash.go
new file mode 100644
index 00000000..a9c56f07
--- /dev/null
+++ b/internal/consistenthash/consistenthash.go
@@ -0,0 +1,81 @@
+/*
+Copyright 2013 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package consistenthash provides an implementation of a ring hash.
+package consistenthash
+
+import (
+	"hash/crc32"
+	"sort"
+	"strconv"
+)
+
+type Hash func(data []byte) uint32
+
+type Map struct {
+	hash     Hash
+	replicas int
+	keys     []int // Sorted
+	hashMap  map[int]string
+}
+
+func New(replicas int, fn Hash) *Map {
+	m := &Map{
+		replicas: replicas,
+		hash:     fn,
+		hashMap:  make(map[int]string),
+	}
+	if m.hash == nil {
+		m.hash = crc32.ChecksumIEEE
+	}
+	return m
+}
+
+// Returns true if there are no items available.
+func (m *Map) IsEmpty() bool {
+	return len(m.keys) == 0
+}
+
+// Adds 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)
+}
+
+// Gets the closest item in the hash to the provided key.
+func (m *Map) Get(key string) string {
+	if m.IsEmpty() {
+		return ""
+	}
+
+	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]]
+}
diff --git a/internal/consistenthash/consistenthash_test.go b/internal/consistenthash/consistenthash_test.go
new file mode 100644
index 00000000..1a37fd7f
--- /dev/null
+++ b/internal/consistenthash/consistenthash_test.go
@@ -0,0 +1,110 @@
+/*
+Copyright 2013 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package consistenthash
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+)
+
+func TestHashing(t *testing.T) {
+
+	// Override the hash function to return easier to reason about values. Assumes
+	// the keys can be converted to an integer.
+	hash := New(3, func(key []byte) uint32 {
+		i, err := strconv.Atoi(string(key))
+		if err != nil {
+			panic(err)
+		}
+		return uint32(i)
+	})
+
+	// Given the above hash function, this will give replicas with "hashes":
+	// 2, 4, 6, 12, 14, 16, 22, 24, 26
+	hash.Add("6", "4", "2")
+
+	testCases := map[string]string{
+		"2":  "2",
+		"11": "2",
+		"23": "4",
+		"27": "2",
+	}
+
+	for k, v := range testCases {
+		if hash.Get(k) != v {
+			t.Errorf("Asking for %s, should have yielded %s", k, v)
+		}
+	}
+
+	// Adds 8, 18, 28
+	hash.Add("8")
+
+	// 27 should now map to 8.
+	testCases["27"] = "8"
+
+	for k, v := range testCases {
+		if hash.Get(k) != v {
+			t.Errorf("Asking for %s, should have yielded %s", k, v)
+		}
+	}
+
+}
+
+func TestConsistency(t *testing.T) {
+	hash1 := New(1, nil)
+	hash2 := New(1, nil)
+
+	hash1.Add("Bill", "Bob", "Bonny")
+	hash2.Add("Bob", "Bonny", "Bill")
+
+	if hash1.Get("Ben") != hash2.Get("Ben") {
+		t.Errorf("Fetching 'Ben' from both hashes should be the same")
+	}
+
+	hash2.Add("Becky", "Ben", "Bobby")
+
+	if hash1.Get("Ben") != hash2.Get("Ben") ||
+		hash1.Get("Bob") != hash2.Get("Bob") ||
+		hash1.Get("Bonny") != hash2.Get("Bonny") {
+		t.Errorf("Direct matches should always return the same entry")
+	}
+
+}
+
+func BenchmarkGet8(b *testing.B)   { benchmarkGet(b, 8) }
+func BenchmarkGet32(b *testing.B)  { benchmarkGet(b, 32) }
+func BenchmarkGet128(b *testing.B) { benchmarkGet(b, 128) }
+func BenchmarkGet512(b *testing.B) { benchmarkGet(b, 512) }
+
+func benchmarkGet(b *testing.B, shards int) {
+
+	hash := New(50, nil)
+
+	var buckets []string
+	for i := 0; i < shards; i++ {
+		buckets = append(buckets, fmt.Sprintf("shard-%d", i))
+	}
+
+	hash.Add(buckets...)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		hash.Get(buckets[i&(shards-1)])
+	}
+}
diff --git a/internal/error.go b/internal/error.go
new file mode 100644
index 00000000..90f6503a
--- /dev/null
+++ b/internal/error.go
@@ -0,0 +1,75 @@
+package internal
+
+import (
+	"io"
+	"net"
+	"strings"
+)
+
+const Nil = RedisError("redis: nil")
+
+type RedisError string
+
+func (e RedisError) Error() string { return string(e) }
+
+func IsRetryableError(err error) bool {
+	return IsNetworkError(err) || err.Error() == "ERR max number of clients reached"
+}
+
+func IsInternalError(err error) bool {
+	_, ok := err.(RedisError)
+	return ok
+}
+
+func IsNetworkError(err error) bool {
+	if err == io.EOF {
+		return true
+	}
+	_, ok := err.(net.Error)
+	return ok
+}
+
+func IsBadConn(err error, allowTimeout bool) bool {
+	if err == nil {
+		return false
+	}
+	if IsInternalError(err) {
+		return false
+	}
+	if allowTimeout {
+		if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+			return false
+		}
+	}
+	return true
+}
+
+func IsMovedError(err error) (moved bool, ask bool, addr string) {
+	if !IsInternalError(err) {
+		return
+	}
+
+	s := err.Error()
+	if strings.HasPrefix(s, "MOVED ") {
+		moved = true
+	} else if strings.HasPrefix(s, "ASK ") {
+		ask = true
+	} else {
+		return
+	}
+
+	ind := strings.LastIndex(s, " ")
+	if ind == -1 {
+		return false, false, ""
+	}
+	addr = s[ind+1:]
+	return
+}
+
+func IsLoadingError(err error) bool {
+	return strings.HasPrefix(err.Error(), "LOADING ")
+}
+
+func IsClusterDownError(err error) bool {
+	return strings.HasPrefix(err.Error(), "CLUSTERDOWN ")
+}
diff --git a/internal/hashtag/hashtag.go b/internal/hashtag/hashtag.go
new file mode 100644
index 00000000..2866488e
--- /dev/null
+++ b/internal/hashtag/hashtag.go
@@ -0,0 +1,73 @@
+package hashtag
+
+import (
+	"math/rand"
+	"strings"
+)
+
+const SlotNumber = 16384
+
+// CRC16 implementation according to CCITT standards.
+// Copyright 2001-2010 Georges Menie (www.menie.org)
+// Copyright 2013 The Go Authors. All rights reserved.
+// http://redis.io/topics/cluster-spec#appendix-a-crc16-reference-implementation-in-ansi-c
+var crc16tab = [256]uint16{
+	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+	0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+	0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+	0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+	0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+	0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+	0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+	0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+	0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+	0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+	0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+	0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+	0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+	0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+	0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+	0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+	0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+	0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+	0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+	0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+	0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+	0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+	0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+	0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+	0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+	0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+	0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+	0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+	0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+	0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+	0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+	0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
+}
+
+func Key(key string) string {
+	if s := strings.IndexByte(key, '{'); s > -1 {
+		if e := strings.IndexByte(key[s+1:], '}'); e > 0 {
+			return key[s+1 : s+e+1]
+		}
+	}
+	return key
+}
+
+// hashSlot returns a consistent slot number between 0 and 16383
+// for any given string key.
+func Slot(key string) int {
+	key = Key(key)
+	if key == "" {
+		return rand.Intn(SlotNumber)
+	}
+	return int(crc16sum(key)) % SlotNumber
+}
+
+func crc16sum(key string) (crc uint16) {
+	for i := 0; i < len(key); i++ {
+		crc = (crc << 8) ^ crc16tab[(byte(crc>>8)^key[i])&0x00ff]
+	}
+	return
+}
diff --git a/internal/hashtag/hashtag_test.go b/internal/hashtag/hashtag_test.go
new file mode 100644
index 00000000..7f0fedf3
--- /dev/null
+++ b/internal/hashtag/hashtag_test.go
@@ -0,0 +1,74 @@
+package hashtag
+
+import (
+	"math/rand"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestGinkgoSuite(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "hashtag")
+}
+
+var _ = Describe("CRC16", func() {
+
+	// http://redis.io/topics/cluster-spec#keys-distribution-model
+	It("should calculate CRC16", func() {
+		tests := []struct {
+			s string
+			n uint16
+		}{
+			{"123456789", 0x31C3},
+			{string([]byte{83, 153, 134, 118, 229, 214, 244, 75, 140, 37, 215, 215}), 21847},
+		}
+
+		for _, test := range tests {
+			Expect(crc16sum(test.s)).To(Equal(test.n), "for %s", test.s)
+		}
+	})
+
+})
+
+var _ = Describe("HashSlot", func() {
+
+	It("should calculate hash slots", func() {
+		tests := []struct {
+			key  string
+			slot int
+		}{
+			{"123456789", 12739},
+			{"{}foo", 9500},
+			{"foo{}", 5542},
+			{"foo{}{bar}", 8363},
+			{"", 10503},
+			{"", 5176},
+			{string([]byte{83, 153, 134, 118, 229, 214, 244, 75, 140, 37, 215, 215}), 5463},
+		}
+		// Empty keys receive random slot.
+		rand.Seed(100)
+
+		for _, test := range tests {
+			Expect(Slot(test.key)).To(Equal(test.slot), "for %s", test.key)
+		}
+	})
+
+	It("should extract keys from tags", func() {
+		tests := []struct {
+			one, two string
+		}{
+			{"foo{bar}", "bar"},
+			{"{foo}bar", "foo"},
+			{"{user1000}.following", "{user1000}.followers"},
+			{"foo{{bar}}zap", "{bar"},
+			{"foo{bar}{zap}", "bar"},
+		}
+
+		for _, test := range tests {
+			Expect(Slot(test.one)).To(Equal(Slot(test.two)), "for %s <-> %s", test.one, test.two)
+		}
+	})
+
+})
diff --git a/internal/internal.go b/internal/internal.go
new file mode 100644
index 00000000..ad3fc3c9
--- /dev/null
+++ b/internal/internal.go
@@ -0,0 +1,24 @@
+package internal
+
+import (
+	"math/rand"
+	"time"
+)
+
+// Retry backoff with jitter sleep to prevent overloaded conditions during intervals
+// https://www.awsarchitectureblog.com/2015/03/backoff.html
+func RetryBackoff(retry int, minBackoff, maxBackoff time.Duration) time.Duration {
+	if retry < 0 {
+		retry = 0
+	}
+
+	backoff := minBackoff << uint(retry)
+	if backoff > maxBackoff || backoff < minBackoff {
+		backoff = maxBackoff
+	}
+
+	if backoff == 0 {
+		return 0
+	}
+	return time.Duration(rand.Int63n(int64(backoff)))
+}
diff --git a/internal/internal_test.go b/internal/internal_test.go
new file mode 100644
index 00000000..56ff611e
--- /dev/null
+++ b/internal/internal_test.go
@@ -0,0 +1,18 @@
+package internal
+
+import (
+	"testing"
+	"time"
+
+	. "github.com/onsi/gomega"
+)
+
+func TestRetryBackoff(t *testing.T) {
+	RegisterTestingT(t)
+
+	for i := -1; i <= 16; i++ {
+		backoff := RetryBackoff(i, time.Millisecond, 512*time.Millisecond)
+		Expect(backoff >= 0).To(BeTrue())
+		Expect(backoff <= 512*time.Millisecond).To(BeTrue())
+	}
+}
diff --git a/internal/log.go b/internal/log.go
new file mode 100644
index 00000000..fd14222e
--- /dev/null
+++ b/internal/log.go
@@ -0,0 +1,15 @@
+package internal
+
+import (
+	"fmt"
+	"log"
+)
+
+var Logger *log.Logger
+
+func Logf(s string, args ...interface{}) {
+	if Logger == nil {
+		return
+	}
+	Logger.Output(2, fmt.Sprintf(s, args...))
+}
diff --git a/internal/once.go b/internal/once.go
new file mode 100644
index 00000000..64f46272
--- /dev/null
+++ b/internal/once.go
@@ -0,0 +1,60 @@
+/*
+Copyright 2014 The Camlistore Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package internal
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// A Once will perform a successful action exactly once.
+//
+// Unlike a sync.Once, this Once's func returns an error
+// and is re-armed on failure.
+type Once struct {
+	m    sync.Mutex
+	done uint32
+}
+
+// Do calls the function f if and only if Do has not been invoked
+// without error for this instance of Once.  In other words, given
+// 	var once Once
+// if once.Do(f) is called multiple times, only the first call will
+// invoke f, even if f has a different value in each invocation unless
+// f returns an error.  A new instance of Once is required for each
+// function to execute.
+//
+// Do is intended for initialization that must be run exactly once.  Since f
+// is niladic, it may be necessary to use a function literal to capture the
+// arguments to a function to be invoked by Do:
+// 	err := config.once.Do(func() error { return config.init(filename) })
+func (o *Once) Do(f func() error) error {
+	if atomic.LoadUint32(&o.done) == 1 {
+		return nil
+	}
+	// Slow-path.
+	o.m.Lock()
+	defer o.m.Unlock()
+	var err error
+	if o.done == 0 {
+		err = f()
+		if err == nil {
+			atomic.StoreUint32(&o.done, 1)
+		}
+	}
+	return err
+}
diff --git a/internal/pool/bench_test.go b/internal/pool/bench_test.go
new file mode 100644
index 00000000..e0bb5244
--- /dev/null
+++ b/internal/pool/bench_test.go
@@ -0,0 +1,80 @@
+package pool_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis/internal/pool"
+)
+
+func benchmarkPoolGetPut(b *testing.B, poolSize int) {
+	connPool := pool.NewConnPool(&pool.Options{
+		Dialer:             dummyDialer,
+		PoolSize:           poolSize,
+		PoolTimeout:        time.Second,
+		IdleTimeout:        time.Hour,
+		IdleCheckFrequency: time.Hour,
+	})
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			cn, _, err := connPool.Get()
+			if err != nil {
+				b.Fatal(err)
+			}
+			if err = connPool.Put(cn); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkPoolGetPut10Conns(b *testing.B) {
+	benchmarkPoolGetPut(b, 10)
+}
+
+func BenchmarkPoolGetPut100Conns(b *testing.B) {
+	benchmarkPoolGetPut(b, 100)
+}
+
+func BenchmarkPoolGetPut1000Conns(b *testing.B) {
+	benchmarkPoolGetPut(b, 1000)
+}
+
+func benchmarkPoolGetRemove(b *testing.B, poolSize int) {
+	connPool := pool.NewConnPool(&pool.Options{
+		Dialer:             dummyDialer,
+		PoolSize:           poolSize,
+		PoolTimeout:        time.Second,
+		IdleTimeout:        time.Hour,
+		IdleCheckFrequency: time.Hour,
+	})
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			cn, _, err := connPool.Get()
+			if err != nil {
+				b.Fatal(err)
+			}
+			if err := connPool.Remove(cn); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkPoolGetRemove10Conns(b *testing.B) {
+	benchmarkPoolGetRemove(b, 10)
+}
+
+func BenchmarkPoolGetRemove100Conns(b *testing.B) {
+	benchmarkPoolGetRemove(b, 100)
+}
+
+func BenchmarkPoolGetRemove1000Conns(b *testing.B) {
+	benchmarkPoolGetRemove(b, 1000)
+}
diff --git a/internal/pool/conn.go b/internal/pool/conn.go
new file mode 100644
index 00000000..8af51d9d
--- /dev/null
+++ b/internal/pool/conn.go
@@ -0,0 +1,78 @@
+package pool
+
+import (
+	"net"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-redis/redis/internal/proto"
+)
+
+var noDeadline = time.Time{}
+
+type Conn struct {
+	netConn net.Conn
+
+	Rd *proto.Reader
+	Wb *proto.WriteBuffer
+
+	Inited bool
+	usedAt atomic.Value
+}
+
+func NewConn(netConn net.Conn) *Conn {
+	cn := &Conn{
+		netConn: netConn,
+		Wb:      proto.NewWriteBuffer(),
+	}
+	cn.Rd = proto.NewReader(cn.netConn)
+	cn.SetUsedAt(time.Now())
+	return cn
+}
+
+func (cn *Conn) UsedAt() time.Time {
+	return cn.usedAt.Load().(time.Time)
+}
+
+func (cn *Conn) SetUsedAt(tm time.Time) {
+	cn.usedAt.Store(tm)
+}
+
+func (cn *Conn) SetNetConn(netConn net.Conn) {
+	cn.netConn = netConn
+	cn.Rd.Reset(netConn)
+}
+
+func (cn *Conn) IsStale(timeout time.Duration) bool {
+	return timeout > 0 && time.Since(cn.UsedAt()) > timeout
+}
+
+func (cn *Conn) SetReadTimeout(timeout time.Duration) error {
+	now := time.Now()
+	cn.SetUsedAt(now)
+	if timeout > 0 {
+		return cn.netConn.SetReadDeadline(now.Add(timeout))
+	}
+	return cn.netConn.SetReadDeadline(noDeadline)
+}
+
+func (cn *Conn) SetWriteTimeout(timeout time.Duration) error {
+	now := time.Now()
+	cn.SetUsedAt(now)
+	if timeout > 0 {
+		return cn.netConn.SetWriteDeadline(now.Add(timeout))
+	}
+	return cn.netConn.SetWriteDeadline(noDeadline)
+}
+
+func (cn *Conn) Write(b []byte) (int, error) {
+	return cn.netConn.Write(b)
+}
+
+func (cn *Conn) RemoteAddr() net.Addr {
+	return cn.netConn.RemoteAddr()
+}
+
+func (cn *Conn) Close() error {
+	return cn.netConn.Close()
+}
diff --git a/internal/pool/main_test.go b/internal/pool/main_test.go
new file mode 100644
index 00000000..43afe3fa
--- /dev/null
+++ b/internal/pool/main_test.go
@@ -0,0 +1,35 @@
+package pool_test
+
+import (
+	"net"
+	"sync"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestGinkgoSuite(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "pool")
+}
+
+func perform(n int, cbs ...func(int)) {
+	var wg sync.WaitGroup
+	for _, cb := range cbs {
+		for i := 0; i < n; i++ {
+			wg.Add(1)
+			go func(cb func(int), i int) {
+				defer GinkgoRecover()
+				defer wg.Done()
+
+				cb(i)
+			}(cb, i)
+		}
+	}
+	wg.Wait()
+}
+
+func dummyDialer() (net.Conn, error) {
+	return &net.TCPConn{}, nil
+}
diff --git a/internal/pool/pool.go b/internal/pool/pool.go
new file mode 100644
index 00000000..25e78aa3
--- /dev/null
+++ b/internal/pool/pool.go
@@ -0,0 +1,371 @@
+package pool
+
+import (
+	"errors"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+)
+
+var ErrClosed = errors.New("redis: client is closed")
+var ErrPoolTimeout = errors.New("redis: connection pool timeout")
+
+var timers = sync.Pool{
+	New: func() interface{} {
+		t := time.NewTimer(time.Hour)
+		t.Stop()
+		return t
+	},
+}
+
+// Stats contains pool state information and accumulated stats.
+type Stats struct {
+	Requests uint32 // number of times a connection was requested by the pool
+	Hits     uint32 // number of times free connection was found in the pool
+	Timeouts uint32 // number of times a wait timeout occurred
+
+	TotalConns uint32 // the number of total connections in the pool
+	FreeConns  uint32 // the number of free connections in the pool
+}
+
+type Pooler interface {
+	NewConn() (*Conn, error)
+	CloseConn(*Conn) error
+
+	Get() (*Conn, bool, error)
+	Put(*Conn) error
+	Remove(*Conn) error
+
+	Len() int
+	FreeLen() int
+	Stats() *Stats
+
+	Close() error
+}
+
+type Options struct {
+	Dialer  func() (net.Conn, error)
+	OnClose func(*Conn) error
+
+	PoolSize           int
+	PoolTimeout        time.Duration
+	IdleTimeout        time.Duration
+	IdleCheckFrequency time.Duration
+}
+
+type ConnPool struct {
+	opt *Options
+
+	dialErrorsNum  uint32 // atomic
+	_lastDialError atomic.Value
+
+	queue chan struct{}
+
+	connsMu sync.Mutex
+	conns   []*Conn
+
+	freeConnsMu sync.Mutex
+	freeConns   []*Conn
+
+	stats Stats
+
+	_closed uint32 // atomic
+}
+
+var _ Pooler = (*ConnPool)(nil)
+
+func NewConnPool(opt *Options) *ConnPool {
+	p := &ConnPool{
+		opt: opt,
+
+		queue:     make(chan struct{}, opt.PoolSize),
+		conns:     make([]*Conn, 0, opt.PoolSize),
+		freeConns: make([]*Conn, 0, opt.PoolSize),
+	}
+	if opt.IdleTimeout > 0 && opt.IdleCheckFrequency > 0 {
+		go p.reaper(opt.IdleCheckFrequency)
+	}
+	return p
+}
+
+func (p *ConnPool) NewConn() (*Conn, error) {
+	if p.closed() {
+		return nil, ErrClosed
+	}
+
+	if atomic.LoadUint32(&p.dialErrorsNum) >= uint32(p.opt.PoolSize) {
+		return nil, p.lastDialError()
+	}
+
+	netConn, err := p.opt.Dialer()
+	if err != nil {
+		p.setLastDialError(err)
+		if atomic.AddUint32(&p.dialErrorsNum, 1) == uint32(p.opt.PoolSize) {
+			go p.tryDial()
+		}
+		return nil, err
+	}
+
+	cn := NewConn(netConn)
+	p.connsMu.Lock()
+	p.conns = append(p.conns, cn)
+	p.connsMu.Unlock()
+
+	return cn, nil
+}
+
+func (p *ConnPool) tryDial() {
+	for {
+		if p.closed() {
+			return
+		}
+
+		conn, err := p.opt.Dialer()
+		if err != nil {
+			p.setLastDialError(err)
+			time.Sleep(time.Second)
+			continue
+		}
+
+		atomic.StoreUint32(&p.dialErrorsNum, 0)
+		_ = conn.Close()
+		return
+	}
+}
+
+func (p *ConnPool) setLastDialError(err error) {
+	p._lastDialError.Store(err)
+}
+
+func (p *ConnPool) lastDialError() error {
+	return p._lastDialError.Load().(error)
+}
+
+// Get returns existed connection from the pool or creates a new one.
+func (p *ConnPool) Get() (*Conn, bool, error) {
+	if p.closed() {
+		return nil, false, ErrClosed
+	}
+
+	atomic.AddUint32(&p.stats.Requests, 1)
+
+	select {
+	case p.queue <- struct{}{}:
+	default:
+		timer := timers.Get().(*time.Timer)
+		timer.Reset(p.opt.PoolTimeout)
+
+		select {
+		case p.queue <- struct{}{}:
+			if !timer.Stop() {
+				<-timer.C
+			}
+			timers.Put(timer)
+		case <-timer.C:
+			timers.Put(timer)
+			atomic.AddUint32(&p.stats.Timeouts, 1)
+			return nil, false, ErrPoolTimeout
+		}
+	}
+
+	for {
+		p.freeConnsMu.Lock()
+		cn := p.popFree()
+		p.freeConnsMu.Unlock()
+
+		if cn == nil {
+			break
+		}
+
+		if cn.IsStale(p.opt.IdleTimeout) {
+			p.CloseConn(cn)
+			continue
+		}
+
+		atomic.AddUint32(&p.stats.Hits, 1)
+		return cn, false, nil
+	}
+
+	newcn, err := p.NewConn()
+	if err != nil {
+		<-p.queue
+		return nil, false, err
+	}
+
+	return newcn, true, nil
+}
+
+func (p *ConnPool) popFree() *Conn {
+	if len(p.freeConns) == 0 {
+		return nil
+	}
+
+	idx := len(p.freeConns) - 1
+	cn := p.freeConns[idx]
+	p.freeConns = p.freeConns[:idx]
+	return cn
+}
+
+func (p *ConnPool) Put(cn *Conn) error {
+	if data := cn.Rd.PeekBuffered(); data != nil {
+		internal.Logf("connection has unread data: %q", data)
+		return p.Remove(cn)
+	}
+	p.freeConnsMu.Lock()
+	p.freeConns = append(p.freeConns, cn)
+	p.freeConnsMu.Unlock()
+	<-p.queue
+	return nil
+}
+
+func (p *ConnPool) Remove(cn *Conn) error {
+	_ = p.CloseConn(cn)
+	<-p.queue
+	return nil
+}
+
+func (p *ConnPool) CloseConn(cn *Conn) error {
+	p.connsMu.Lock()
+	for i, c := range p.conns {
+		if c == cn {
+			p.conns = append(p.conns[:i], p.conns[i+1:]...)
+			break
+		}
+	}
+	p.connsMu.Unlock()
+
+	return p.closeConn(cn)
+}
+
+func (p *ConnPool) closeConn(cn *Conn) error {
+	if p.opt.OnClose != nil {
+		_ = p.opt.OnClose(cn)
+	}
+	return cn.Close()
+}
+
+// Len returns total number of connections.
+func (p *ConnPool) Len() int {
+	p.connsMu.Lock()
+	l := len(p.conns)
+	p.connsMu.Unlock()
+	return l
+}
+
+// FreeLen returns number of free connections.
+func (p *ConnPool) FreeLen() int {
+	p.freeConnsMu.Lock()
+	l := len(p.freeConns)
+	p.freeConnsMu.Unlock()
+	return l
+}
+
+func (p *ConnPool) Stats() *Stats {
+	return &Stats{
+		Requests:   atomic.LoadUint32(&p.stats.Requests),
+		Hits:       atomic.LoadUint32(&p.stats.Hits),
+		Timeouts:   atomic.LoadUint32(&p.stats.Timeouts),
+		TotalConns: uint32(p.Len()),
+		FreeConns:  uint32(p.FreeLen()),
+	}
+}
+
+func (p *ConnPool) closed() bool {
+	return atomic.LoadUint32(&p._closed) == 1
+}
+
+func (p *ConnPool) Filter(fn func(*Conn) bool) error {
+	var firstErr error
+	p.connsMu.Lock()
+	for _, cn := range p.conns {
+		if fn(cn) {
+			if err := p.closeConn(cn); err != nil && firstErr == nil {
+				firstErr = err
+			}
+		}
+	}
+	p.connsMu.Unlock()
+	return firstErr
+}
+
+func (p *ConnPool) Close() error {
+	if !atomic.CompareAndSwapUint32(&p._closed, 0, 1) {
+		return ErrClosed
+	}
+
+	var firstErr error
+	p.connsMu.Lock()
+	for _, cn := range p.conns {
+		if err := p.closeConn(cn); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	p.conns = nil
+	p.connsMu.Unlock()
+
+	p.freeConnsMu.Lock()
+	p.freeConns = nil
+	p.freeConnsMu.Unlock()
+
+	return firstErr
+}
+
+func (p *ConnPool) reapStaleConn() bool {
+	if len(p.freeConns) == 0 {
+		return false
+	}
+
+	cn := p.freeConns[0]
+	if !cn.IsStale(p.opt.IdleTimeout) {
+		return false
+	}
+
+	p.CloseConn(cn)
+	p.freeConns = append(p.freeConns[:0], p.freeConns[1:]...)
+
+	return true
+}
+
+func (p *ConnPool) ReapStaleConns() (int, error) {
+	var n int
+	for {
+		p.queue <- struct{}{}
+		p.freeConnsMu.Lock()
+
+		reaped := p.reapStaleConn()
+
+		p.freeConnsMu.Unlock()
+		<-p.queue
+
+		if reaped {
+			n++
+		} else {
+			break
+		}
+	}
+	return n, nil
+}
+
+func (p *ConnPool) reaper(frequency time.Duration) {
+	ticker := time.NewTicker(frequency)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		if p.closed() {
+			break
+		}
+		n, err := p.ReapStaleConns()
+		if err != nil {
+			internal.Logf("ReapStaleConns failed: %s", err)
+			continue
+		}
+		s := p.Stats()
+		internal.Logf(
+			"reaper: removed %d stale conns (TotalConns=%d FreeConns=%d Requests=%d Hits=%d Timeouts=%d)",
+			n, s.TotalConns, s.FreeConns, s.Requests, s.Hits, s.Timeouts,
+		)
+	}
+}
diff --git a/internal/pool/pool_single.go b/internal/pool/pool_single.go
new file mode 100644
index 00000000..ff91279b
--- /dev/null
+++ b/internal/pool/pool_single.go
@@ -0,0 +1,55 @@
+package pool
+
+type SingleConnPool struct {
+	cn *Conn
+}
+
+var _ Pooler = (*SingleConnPool)(nil)
+
+func NewSingleConnPool(cn *Conn) *SingleConnPool {
+	return &SingleConnPool{
+		cn: cn,
+	}
+}
+
+func (p *SingleConnPool) NewConn() (*Conn, error) {
+	panic("not implemented")
+}
+
+func (p *SingleConnPool) CloseConn(*Conn) error {
+	panic("not implemented")
+}
+
+func (p *SingleConnPool) Get() (*Conn, bool, error) {
+	return p.cn, false, nil
+}
+
+func (p *SingleConnPool) Put(cn *Conn) error {
+	if p.cn != cn {
+		panic("p.cn != cn")
+	}
+	return nil
+}
+
+func (p *SingleConnPool) Remove(cn *Conn) error {
+	if p.cn != cn {
+		panic("p.cn != cn")
+	}
+	return nil
+}
+
+func (p *SingleConnPool) Len() int {
+	return 1
+}
+
+func (p *SingleConnPool) FreeLen() int {
+	return 0
+}
+
+func (p *SingleConnPool) Stats() *Stats {
+	return nil
+}
+
+func (p *SingleConnPool) Close() error {
+	return nil
+}
diff --git a/internal/pool/pool_sticky.go b/internal/pool/pool_sticky.go
new file mode 100644
index 00000000..17f16385
--- /dev/null
+++ b/internal/pool/pool_sticky.go
@@ -0,0 +1,123 @@
+package pool
+
+import "sync"
+
+type StickyConnPool struct {
+	pool     *ConnPool
+	reusable bool
+
+	cn     *Conn
+	closed bool
+	mu     sync.Mutex
+}
+
+var _ Pooler = (*StickyConnPool)(nil)
+
+func NewStickyConnPool(pool *ConnPool, reusable bool) *StickyConnPool {
+	return &StickyConnPool{
+		pool:     pool,
+		reusable: reusable,
+	}
+}
+
+func (p *StickyConnPool) NewConn() (*Conn, error) {
+	panic("not implemented")
+}
+
+func (p *StickyConnPool) CloseConn(*Conn) error {
+	panic("not implemented")
+}
+
+func (p *StickyConnPool) Get() (*Conn, bool, error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed {
+		return nil, false, ErrClosed
+	}
+	if p.cn != nil {
+		return p.cn, false, nil
+	}
+
+	cn, _, err := p.pool.Get()
+	if err != nil {
+		return nil, false, err
+	}
+	p.cn = cn
+	return cn, true, nil
+}
+
+func (p *StickyConnPool) putUpstream() (err error) {
+	err = p.pool.Put(p.cn)
+	p.cn = nil
+	return err
+}
+
+func (p *StickyConnPool) Put(cn *Conn) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed {
+		return ErrClosed
+	}
+	return nil
+}
+
+func (p *StickyConnPool) removeUpstream() error {
+	err := p.pool.Remove(p.cn)
+	p.cn = nil
+	return err
+}
+
+func (p *StickyConnPool) Remove(cn *Conn) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed {
+		return nil
+	}
+	return p.removeUpstream()
+}
+
+func (p *StickyConnPool) Len() int {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.cn == nil {
+		return 0
+	}
+	return 1
+}
+
+func (p *StickyConnPool) FreeLen() int {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.cn == nil {
+		return 1
+	}
+	return 0
+}
+
+func (p *StickyConnPool) Stats() *Stats {
+	return nil
+}
+
+func (p *StickyConnPool) Close() error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed {
+		return ErrClosed
+	}
+	p.closed = true
+	var err error
+	if p.cn != nil {
+		if p.reusable {
+			err = p.putUpstream()
+		} else {
+			err = p.removeUpstream()
+		}
+	}
+	return err
+}
diff --git a/internal/pool/pool_test.go b/internal/pool/pool_test.go
new file mode 100644
index 00000000..68c9a1be
--- /dev/null
+++ b/internal/pool/pool_test.go
@@ -0,0 +1,241 @@
+package pool_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis/internal/pool"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ConnPool", func() {
+	var connPool *pool.ConnPool
+
+	BeforeEach(func() {
+		connPool = pool.NewConnPool(&pool.Options{
+			Dialer:             dummyDialer,
+			PoolSize:           10,
+			PoolTimeout:        time.Hour,
+			IdleTimeout:        time.Millisecond,
+			IdleCheckFrequency: time.Millisecond,
+		})
+	})
+
+	AfterEach(func() {
+		connPool.Close()
+	})
+
+	It("should unblock client when conn is removed", func() {
+		// Reserve one connection.
+		cn, _, err := connPool.Get()
+		Expect(err).NotTo(HaveOccurred())
+
+		// Reserve all other connections.
+		var cns []*pool.Conn
+		for i := 0; i < 9; i++ {
+			cn, _, err := connPool.Get()
+			Expect(err).NotTo(HaveOccurred())
+			cns = append(cns, cn)
+		}
+
+		started := make(chan bool, 1)
+		done := make(chan bool, 1)
+		go func() {
+			defer GinkgoRecover()
+
+			started <- true
+			_, _, err := connPool.Get()
+			Expect(err).NotTo(HaveOccurred())
+			done <- true
+
+			err = connPool.Put(cn)
+			Expect(err).NotTo(HaveOccurred())
+		}()
+		<-started
+
+		// Check that Get is blocked.
+		select {
+		case <-done:
+			Fail("Get is not blocked")
+		default:
+			// ok
+		}
+
+		err = connPool.Remove(cn)
+		Expect(err).NotTo(HaveOccurred())
+
+		// Check that Ping is unblocked.
+		select {
+		case <-done:
+			// ok
+		case <-time.After(time.Second):
+			Fail("Get is not unblocked")
+		}
+
+		for _, cn := range cns {
+			err = connPool.Put(cn)
+			Expect(err).NotTo(HaveOccurred())
+		}
+	})
+})
+
+var _ = Describe("conns reaper", func() {
+	const idleTimeout = time.Minute
+
+	var connPool *pool.ConnPool
+	var conns, idleConns, closedConns []*pool.Conn
+
+	BeforeEach(func() {
+		conns = nil
+		closedConns = nil
+
+		connPool = pool.NewConnPool(&pool.Options{
+			Dialer:             dummyDialer,
+			PoolSize:           10,
+			PoolTimeout:        time.Second,
+			IdleTimeout:        idleTimeout,
+			IdleCheckFrequency: time.Hour,
+
+			OnClose: func(cn *pool.Conn) error {
+				closedConns = append(closedConns, cn)
+				return nil
+			},
+		})
+
+		// add stale connections
+		idleConns = nil
+		for i := 0; i < 3; i++ {
+			cn, _, err := connPool.Get()
+			Expect(err).NotTo(HaveOccurred())
+			cn.SetUsedAt(time.Now().Add(-2 * idleTimeout))
+			conns = append(conns, cn)
+			idleConns = append(idleConns, cn)
+		}
+
+		// add fresh connections
+		for i := 0; i < 3; i++ {
+			cn, _, err := connPool.Get()
+			Expect(err).NotTo(HaveOccurred())
+			conns = append(conns, cn)
+		}
+
+		for _, cn := range conns {
+			Expect(connPool.Put(cn)).NotTo(HaveOccurred())
+		}
+
+		Expect(connPool.Len()).To(Equal(6))
+		Expect(connPool.FreeLen()).To(Equal(6))
+
+		n, err := connPool.ReapStaleConns()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(3))
+	})
+
+	AfterEach(func() {
+		_ = connPool.Close()
+		Expect(connPool.Len()).To(Equal(0))
+		Expect(connPool.FreeLen()).To(Equal(0))
+		Expect(len(closedConns)).To(Equal(len(conns)))
+		Expect(closedConns).To(ConsistOf(conns))
+	})
+
+	It("reaps stale connections", func() {
+		Expect(connPool.Len()).To(Equal(3))
+		Expect(connPool.FreeLen()).To(Equal(3))
+	})
+
+	It("does not reap fresh connections", func() {
+		n, err := connPool.ReapStaleConns()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(0))
+	})
+
+	It("stale connections are closed", func() {
+		Expect(len(closedConns)).To(Equal(len(idleConns)))
+		Expect(closedConns).To(ConsistOf(idleConns))
+	})
+
+	It("pool is functional", func() {
+		for j := 0; j < 3; j++ {
+			var freeCns []*pool.Conn
+			for i := 0; i < 3; i++ {
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(cn).NotTo(BeNil())
+				freeCns = append(freeCns, cn)
+			}
+
+			Expect(connPool.Len()).To(Equal(3))
+			Expect(connPool.FreeLen()).To(Equal(0))
+
+			cn, _, err := connPool.Get()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cn).NotTo(BeNil())
+			conns = append(conns, cn)
+
+			Expect(connPool.Len()).To(Equal(4))
+			Expect(connPool.FreeLen()).To(Equal(0))
+
+			err = connPool.Remove(cn)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(connPool.Len()).To(Equal(3))
+			Expect(connPool.FreeLen()).To(Equal(0))
+
+			for _, cn := range freeCns {
+				err := connPool.Put(cn)
+				Expect(err).NotTo(HaveOccurred())
+			}
+
+			Expect(connPool.Len()).To(Equal(3))
+			Expect(connPool.FreeLen()).To(Equal(3))
+		}
+	})
+})
+
+var _ = Describe("race", func() {
+	var connPool *pool.ConnPool
+	var C, N int
+
+	BeforeEach(func() {
+		C, N = 10, 1000
+		if testing.Short() {
+			C = 4
+			N = 100
+		}
+	})
+
+	AfterEach(func() {
+		connPool.Close()
+	})
+
+	It("does not happen on Get, Put, and Remove", func() {
+		connPool = pool.NewConnPool(&pool.Options{
+			Dialer:             dummyDialer,
+			PoolSize:           10,
+			PoolTimeout:        time.Minute,
+			IdleTimeout:        time.Millisecond,
+			IdleCheckFrequency: time.Millisecond,
+		})
+
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				if err == nil {
+					Expect(connPool.Put(cn)).NotTo(HaveOccurred())
+				}
+			}
+		}, func(id int) {
+			for i := 0; i < N; i++ {
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				if err == nil {
+					Expect(connPool.Remove(cn)).NotTo(HaveOccurred())
+				}
+			}
+		})
+	})
+})
diff --git a/internal/proto/proto_test.go b/internal/proto/proto_test.go
new file mode 100644
index 00000000..c9a820eb
--- /dev/null
+++ b/internal/proto/proto_test.go
@@ -0,0 +1,13 @@
+package proto_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestGinkgoSuite(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "proto")
+}
diff --git a/internal/proto/reader.go b/internal/proto/reader.go
new file mode 100644
index 00000000..2159cf63
--- /dev/null
+++ b/internal/proto/reader.go
@@ -0,0 +1,334 @@
+package proto
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strconv"
+
+	"github.com/go-redis/redis/internal"
+)
+
+const bytesAllocLimit = 1024 * 1024 // 1mb
+
+const (
+	ErrorReply  = '-'
+	StatusReply = '+'
+	IntReply    = ':'
+	StringReply = '$'
+	ArrayReply  = '*'
+)
+
+type MultiBulkParse func(*Reader, int64) (interface{}, error)
+
+type Reader struct {
+	src *bufio.Reader
+	buf []byte
+}
+
+func NewReader(rd io.Reader) *Reader {
+	return &Reader{
+		src: bufio.NewReader(rd),
+		buf: make([]byte, 4096),
+	}
+}
+
+func (r *Reader) Reset(rd io.Reader) {
+	r.src.Reset(rd)
+}
+
+func (p *Reader) PeekBuffered() []byte {
+	if n := p.src.Buffered(); n != 0 {
+		b, _ := p.src.Peek(n)
+		return b
+	}
+	return nil
+}
+
+func (p *Reader) ReadN(n int) ([]byte, error) {
+	b, err := readN(p.src, p.buf, n)
+	if err != nil {
+		return nil, err
+	}
+	p.buf = b
+	return b, nil
+}
+
+func (p *Reader) ReadLine() ([]byte, error) {
+	line, isPrefix, err := p.src.ReadLine()
+	if err != nil {
+		return nil, err
+	}
+	if isPrefix {
+		return nil, bufio.ErrBufferFull
+	}
+	if len(line) == 0 {
+		return nil, internal.RedisError("redis: reply is empty")
+	}
+	if isNilReply(line) {
+		return nil, internal.Nil
+	}
+	return line, nil
+}
+
+func (p *Reader) ReadReply(m MultiBulkParse) (interface{}, error) {
+	line, err := p.ReadLine()
+	if err != nil {
+		return nil, err
+	}
+
+	switch line[0] {
+	case ErrorReply:
+		return nil, ParseErrorReply(line)
+	case StatusReply:
+		return parseStatusValue(line), nil
+	case IntReply:
+		return parseInt(line[1:], 10, 64)
+	case StringReply:
+		return p.readTmpBytesValue(line)
+	case ArrayReply:
+		n, err := parseArrayLen(line)
+		if err != nil {
+			return nil, err
+		}
+		return m(p, n)
+	}
+	return nil, fmt.Errorf("redis: can't parse %.100q", line)
+}
+
+func (p *Reader) ReadIntReply() (int64, error) {
+	line, err := p.ReadLine()
+	if err != nil {
+		return 0, err
+	}
+	switch line[0] {
+	case ErrorReply:
+		return 0, ParseErrorReply(line)
+	case IntReply:
+		return parseInt(line[1:], 10, 64)
+	default:
+		return 0, fmt.Errorf("redis: can't parse int reply: %.100q", line)
+	}
+}
+
+func (p *Reader) ReadTmpBytesReply() ([]byte, error) {
+	line, err := p.ReadLine()
+	if err != nil {
+		return nil, err
+	}
+	switch line[0] {
+	case ErrorReply:
+		return nil, ParseErrorReply(line)
+	case StringReply:
+		return p.readTmpBytesValue(line)
+	case StatusReply:
+		return parseStatusValue(line), nil
+	default:
+		return nil, fmt.Errorf("redis: can't parse string reply: %.100q", line)
+	}
+}
+
+func (r *Reader) ReadBytesReply() ([]byte, error) {
+	b, err := r.ReadTmpBytesReply()
+	if err != nil {
+		return nil, err
+	}
+	cp := make([]byte, len(b))
+	copy(cp, b)
+	return cp, nil
+}
+
+func (p *Reader) ReadStringReply() (string, error) {
+	b, err := p.ReadTmpBytesReply()
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+func (p *Reader) ReadFloatReply() (float64, error) {
+	b, err := p.ReadTmpBytesReply()
+	if err != nil {
+		return 0, err
+	}
+	return parseFloat(b, 64)
+}
+
+func (p *Reader) ReadArrayReply(m MultiBulkParse) (interface{}, error) {
+	line, err := p.ReadLine()
+	if err != nil {
+		return nil, err
+	}
+	switch line[0] {
+	case ErrorReply:
+		return nil, ParseErrorReply(line)
+	case ArrayReply:
+		n, err := parseArrayLen(line)
+		if err != nil {
+			return nil, err
+		}
+		return m(p, n)
+	default:
+		return nil, fmt.Errorf("redis: can't parse array reply: %.100q", line)
+	}
+}
+
+func (p *Reader) ReadArrayLen() (int64, error) {
+	line, err := p.ReadLine()
+	if err != nil {
+		return 0, err
+	}
+	switch line[0] {
+	case ErrorReply:
+		return 0, ParseErrorReply(line)
+	case ArrayReply:
+		return parseArrayLen(line)
+	default:
+		return 0, fmt.Errorf("redis: can't parse array reply: %.100q", line)
+	}
+}
+
+func (p *Reader) ReadScanReply() ([]string, uint64, error) {
+	n, err := p.ReadArrayLen()
+	if err != nil {
+		return nil, 0, err
+	}
+	if n != 2 {
+		return nil, 0, fmt.Errorf("redis: got %d elements in scan reply, expected 2", n)
+	}
+
+	cursor, err := p.ReadUint()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	n, err = p.ReadArrayLen()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	keys := make([]string, n)
+	for i := int64(0); i < n; i++ {
+		key, err := p.ReadStringReply()
+		if err != nil {
+			return nil, 0, err
+		}
+		keys[i] = key
+	}
+
+	return keys, cursor, err
+}
+
+func (p *Reader) readTmpBytesValue(line []byte) ([]byte, error) {
+	if isNilReply(line) {
+		return nil, internal.Nil
+	}
+
+	replyLen, err := strconv.Atoi(string(line[1:]))
+	if err != nil {
+		return nil, err
+	}
+
+	b, err := p.ReadN(replyLen + 2)
+	if err != nil {
+		return nil, err
+	}
+	return b[:replyLen], nil
+}
+
+func (r *Reader) ReadInt() (int64, error) {
+	b, err := r.ReadTmpBytesReply()
+	if err != nil {
+		return 0, err
+	}
+	return parseInt(b, 10, 64)
+}
+
+func (r *Reader) ReadUint() (uint64, error) {
+	b, err := r.ReadTmpBytesReply()
+	if err != nil {
+		return 0, err
+	}
+	return parseUint(b, 10, 64)
+}
+
+// --------------------------------------------------------------------
+
+func readN(r io.Reader, b []byte, n int) ([]byte, error) {
+	if n == 0 && b == nil {
+		return make([]byte, 0), nil
+	}
+
+	if cap(b) >= n {
+		b = b[:n]
+		_, err := io.ReadFull(r, b)
+		return b, err
+	}
+	b = b[:cap(b)]
+
+	pos := 0
+	for pos < n {
+		diff := n - len(b)
+		if diff > bytesAllocLimit {
+			diff = bytesAllocLimit
+		}
+		b = append(b, make([]byte, diff)...)
+
+		nn, err := io.ReadFull(r, b[pos:])
+		if err != nil {
+			return nil, err
+		}
+		pos += nn
+	}
+
+	return b, nil
+}
+
+func formatInt(n int64) string {
+	return strconv.FormatInt(n, 10)
+}
+
+func formatUint(u uint64) string {
+	return strconv.FormatUint(u, 10)
+}
+
+func formatFloat(f float64) string {
+	return strconv.FormatFloat(f, 'f', -1, 64)
+}
+
+func isNilReply(b []byte) bool {
+	return len(b) == 3 &&
+		(b[0] == StringReply || b[0] == ArrayReply) &&
+		b[1] == '-' && b[2] == '1'
+}
+
+func ParseErrorReply(line []byte) error {
+	return internal.RedisError(string(line[1:]))
+}
+
+func parseStatusValue(line []byte) []byte {
+	return line[1:]
+}
+
+func parseArrayLen(line []byte) (int64, error) {
+	if isNilReply(line) {
+		return 0, internal.Nil
+	}
+	return parseInt(line[1:], 10, 64)
+}
+
+func atoi(b []byte) (int, error) {
+	return strconv.Atoi(internal.BytesToString(b))
+}
+
+func parseInt(b []byte, base int, bitSize int) (int64, error) {
+	return strconv.ParseInt(internal.BytesToString(b), base, bitSize)
+}
+
+func parseUint(b []byte, base int, bitSize int) (uint64, error) {
+	return strconv.ParseUint(internal.BytesToString(b), base, bitSize)
+}
+
+func parseFloat(b []byte, bitSize int) (float64, error) {
+	return strconv.ParseFloat(internal.BytesToString(b), bitSize)
+}
diff --git a/internal/proto/reader_test.go b/internal/proto/reader_test.go
new file mode 100644
index 00000000..8d2d71be
--- /dev/null
+++ b/internal/proto/reader_test.go
@@ -0,0 +1,87 @@
+package proto_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/go-redis/redis/internal/proto"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Reader", func() {
+
+	It("should read n bytes", func() {
+		data, err := proto.NewReader(strings.NewReader("ABCDEFGHIJKLMNO")).ReadN(10)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(data)).To(Equal(10))
+		Expect(string(data)).To(Equal("ABCDEFGHIJ"))
+
+		data, err = proto.NewReader(strings.NewReader(strings.Repeat("x", 8192))).ReadN(6000)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(data)).To(Equal(6000))
+	})
+
+	It("should read lines", func() {
+		p := proto.NewReader(strings.NewReader("$5\r\nhello\r\n"))
+
+		data, err := p.ReadLine()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(string(data)).To(Equal("$5"))
+
+		data, err = p.ReadLine()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(string(data)).To(Equal("hello"))
+	})
+
+})
+
+func BenchmarkReader_ParseReply_Status(b *testing.B) {
+	benchmarkParseReply(b, "+OK\r\n", nil, false)
+}
+
+func BenchmarkReader_ParseReply_Int(b *testing.B) {
+	benchmarkParseReply(b, ":1\r\n", nil, false)
+}
+
+func BenchmarkReader_ParseReply_Error(b *testing.B) {
+	benchmarkParseReply(b, "-Error message\r\n", nil, true)
+}
+
+func BenchmarkReader_ParseReply_String(b *testing.B) {
+	benchmarkParseReply(b, "$5\r\nhello\r\n", nil, false)
+}
+
+func BenchmarkReader_ParseReply_Slice(b *testing.B) {
+	benchmarkParseReply(b, "*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n", multiBulkParse, false)
+}
+
+func benchmarkParseReply(b *testing.B, reply string, m proto.MultiBulkParse, wanterr bool) {
+	buf := new(bytes.Buffer)
+	for i := 0; i < b.N; i++ {
+		buf.WriteString(reply)
+	}
+	p := proto.NewReader(buf)
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_, err := p.ReadReply(m)
+		if !wanterr && err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func multiBulkParse(p *proto.Reader, n int64) (interface{}, error) {
+	vv := make([]interface{}, 0, n)
+	for i := int64(0); i < n; i++ {
+		v, err := p.ReadReply(multiBulkParse)
+		if err != nil {
+			return nil, err
+		}
+		vv = append(vv, v)
+	}
+	return vv, nil
+}
diff --git a/internal/proto/scan.go b/internal/proto/scan.go
new file mode 100644
index 00000000..3ab40b94
--- /dev/null
+++ b/internal/proto/scan.go
@@ -0,0 +1,131 @@
+package proto
+
+import (
+	"encoding"
+	"fmt"
+	"reflect"
+
+	"github.com/go-redis/redis/internal"
+)
+
+func Scan(b []byte, v interface{}) error {
+	switch v := v.(type) {
+	case nil:
+		return internal.RedisError("redis: Scan(nil)")
+	case *string:
+		*v = internal.BytesToString(b)
+		return nil
+	case *[]byte:
+		*v = b
+		return nil
+	case *int:
+		var err error
+		*v, err = atoi(b)
+		return err
+	case *int8:
+		n, err := parseInt(b, 10, 8)
+		if err != nil {
+			return err
+		}
+		*v = int8(n)
+		return nil
+	case *int16:
+		n, err := parseInt(b, 10, 16)
+		if err != nil {
+			return err
+		}
+		*v = int16(n)
+		return nil
+	case *int32:
+		n, err := parseInt(b, 10, 32)
+		if err != nil {
+			return err
+		}
+		*v = int32(n)
+		return nil
+	case *int64:
+		n, err := parseInt(b, 10, 64)
+		if err != nil {
+			return err
+		}
+		*v = n
+		return nil
+	case *uint:
+		n, err := parseUint(b, 10, 64)
+		if err != nil {
+			return err
+		}
+		*v = uint(n)
+		return nil
+	case *uint8:
+		n, err := parseUint(b, 10, 8)
+		if err != nil {
+			return err
+		}
+		*v = uint8(n)
+		return nil
+	case *uint16:
+		n, err := parseUint(b, 10, 16)
+		if err != nil {
+			return err
+		}
+		*v = uint16(n)
+		return nil
+	case *uint32:
+		n, err := parseUint(b, 10, 32)
+		if err != nil {
+			return err
+		}
+		*v = uint32(n)
+		return nil
+	case *uint64:
+		n, err := parseUint(b, 10, 64)
+		if err != nil {
+			return err
+		}
+		*v = n
+		return nil
+	case *float32:
+		n, err := parseFloat(b, 32)
+		if err != nil {
+			return err
+		}
+		*v = float32(n)
+		return err
+	case *float64:
+		var err error
+		*v, err = parseFloat(b, 64)
+		return err
+	case *bool:
+		*v = len(b) == 1 && b[0] == '1'
+		return nil
+	case encoding.BinaryUnmarshaler:
+		return v.UnmarshalBinary(b)
+	default:
+		return fmt.Errorf(
+			"redis: can't unmarshal %T (consider implementing BinaryUnmarshaler)", v)
+	}
+}
+
+func ScanSlice(data []string, slice interface{}) error {
+	v := reflect.ValueOf(slice)
+	if !v.IsValid() {
+		return fmt.Errorf("redis: ScanSlice(nil)")
+	}
+	if v.Kind() != reflect.Ptr {
+		return fmt.Errorf("redis: ScanSlice(non-pointer %T)", slice)
+	}
+	v = v.Elem()
+	if v.Kind() != reflect.Slice {
+		return fmt.Errorf("redis: ScanSlice(non-slice %T)", slice)
+	}
+
+	for i, s := range data {
+		elem := internal.SliceNextElem(v)
+		if err := Scan(internal.StringToBytes(s), elem.Addr().Interface()); err != nil {
+			return fmt.Errorf("redis: ScanSlice(index=%d value=%q) failed: %s", i, s, err)
+		}
+	}
+
+	return nil
+}
diff --git a/internal/proto/scan_test.go b/internal/proto/scan_test.go
new file mode 100644
index 00000000..fadcd056
--- /dev/null
+++ b/internal/proto/scan_test.go
@@ -0,0 +1,48 @@
+package proto
+
+import (
+	"encoding/json"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+type testScanSliceStruct struct {
+	ID   int
+	Name string
+}
+
+func (s *testScanSliceStruct) MarshalBinary() ([]byte, error) {
+	return json.Marshal(s)
+}
+
+func (s *testScanSliceStruct) UnmarshalBinary(b []byte) error {
+	return json.Unmarshal(b, s)
+}
+
+var _ = Describe("ScanSlice", func() {
+	data := []string{
+		`{"ID":-1,"Name":"Back Yu"}`,
+		`{"ID":1,"Name":"szyhf"}`,
+	}
+
+	It("[]testScanSliceStruct", func() {
+		var slice []testScanSliceStruct
+		err := ScanSlice(data, &slice)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(slice).To(Equal([]testScanSliceStruct{
+			{-1, "Back Yu"},
+			{1, "szyhf"},
+		}))
+	})
+
+	It("var testContainer []*testScanSliceStruct", func() {
+		var slice []*testScanSliceStruct
+		err := ScanSlice(data, &slice)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(slice).To(Equal([]*testScanSliceStruct{
+			{-1, "Back Yu"},
+			{1, "szyhf"},
+		}))
+	})
+})
diff --git a/internal/proto/write_buffer.go b/internal/proto/write_buffer.go
new file mode 100644
index 00000000..096b6d76
--- /dev/null
+++ b/internal/proto/write_buffer.go
@@ -0,0 +1,103 @@
+package proto
+
+import (
+	"encoding"
+	"fmt"
+	"strconv"
+)
+
+type WriteBuffer struct {
+	b []byte
+}
+
+func NewWriteBuffer() *WriteBuffer {
+	return &WriteBuffer{
+		b: make([]byte, 0, 4096),
+	}
+}
+
+func (w *WriteBuffer) Len() int      { return len(w.b) }
+func (w *WriteBuffer) Bytes() []byte { return w.b }
+func (w *WriteBuffer) Reset()        { w.b = w.b[:0] }
+
+func (w *WriteBuffer) Append(args []interface{}) error {
+	w.b = append(w.b, ArrayReply)
+	w.b = strconv.AppendUint(w.b, uint64(len(args)), 10)
+	w.b = append(w.b, '\r', '\n')
+
+	for _, arg := range args {
+		if err := w.append(arg); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (w *WriteBuffer) append(val interface{}) error {
+	switch v := val.(type) {
+	case nil:
+		w.AppendString("")
+	case string:
+		w.AppendString(v)
+	case []byte:
+		w.AppendBytes(v)
+	case int:
+		w.AppendString(formatInt(int64(v)))
+	case int8:
+		w.AppendString(formatInt(int64(v)))
+	case int16:
+		w.AppendString(formatInt(int64(v)))
+	case int32:
+		w.AppendString(formatInt(int64(v)))
+	case int64:
+		w.AppendString(formatInt(v))
+	case uint:
+		w.AppendString(formatUint(uint64(v)))
+	case uint8:
+		w.AppendString(formatUint(uint64(v)))
+	case uint16:
+		w.AppendString(formatUint(uint64(v)))
+	case uint32:
+		w.AppendString(formatUint(uint64(v)))
+	case uint64:
+		w.AppendString(formatUint(v))
+	case float32:
+		w.AppendString(formatFloat(float64(v)))
+	case float64:
+		w.AppendString(formatFloat(v))
+	case bool:
+		if v {
+			w.AppendString("1")
+		} else {
+			w.AppendString("0")
+		}
+	default:
+		if bm, ok := val.(encoding.BinaryMarshaler); ok {
+			bb, err := bm.MarshalBinary()
+			if err != nil {
+				return err
+			}
+			w.AppendBytes(bb)
+		} else {
+			return fmt.Errorf(
+				"redis: can't marshal %T (consider implementing encoding.BinaryMarshaler)", val)
+		}
+	}
+	return nil
+}
+
+func (w *WriteBuffer) AppendString(s string) {
+	w.b = append(w.b, StringReply)
+	w.b = strconv.AppendUint(w.b, uint64(len(s)), 10)
+	w.b = append(w.b, '\r', '\n')
+	w.b = append(w.b, s...)
+	w.b = append(w.b, '\r', '\n')
+}
+
+func (w *WriteBuffer) AppendBytes(p []byte) {
+	w.b = append(w.b, StringReply)
+	w.b = strconv.AppendUint(w.b, uint64(len(p)), 10)
+	w.b = append(w.b, '\r', '\n')
+	w.b = append(w.b, p...)
+	w.b = append(w.b, '\r', '\n')
+}
diff --git a/internal/proto/write_buffer_test.go b/internal/proto/write_buffer_test.go
new file mode 100644
index 00000000..84799ff3
--- /dev/null
+++ b/internal/proto/write_buffer_test.go
@@ -0,0 +1,63 @@
+package proto_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis/internal/proto"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("WriteBuffer", func() {
+	var buf *proto.WriteBuffer
+
+	BeforeEach(func() {
+		buf = proto.NewWriteBuffer()
+	})
+
+	It("should reset", func() {
+		buf.AppendString("string")
+		Expect(buf.Len()).To(Equal(12))
+		buf.Reset()
+		Expect(buf.Len()).To(Equal(0))
+	})
+
+	It("should append args", func() {
+		err := buf.Append([]interface{}{
+			"string",
+			12,
+			34.56,
+			[]byte{'b', 'y', 't', 'e', 's'},
+			true,
+			nil,
+		})
+		Expect(err).NotTo(HaveOccurred())
+		Expect(buf.Bytes()).To(Equal([]byte("*6\r\n" +
+			"$6\r\nstring\r\n" +
+			"$2\r\n12\r\n" +
+			"$5\r\n34.56\r\n" +
+			"$5\r\nbytes\r\n" +
+			"$1\r\n1\r\n" +
+			"$0\r\n" +
+			"\r\n")))
+	})
+
+	It("should append marshalable args", func() {
+		err := buf.Append([]interface{}{time.Unix(1414141414, 0)})
+		Expect(err).NotTo(HaveOccurred())
+		Expect(buf.Len()).To(Equal(26))
+	})
+
+})
+
+func BenchmarkWriteBuffer_Append(b *testing.B) {
+	buf := proto.NewWriteBuffer()
+	args := []interface{}{"hello", "world", "foo", "bar"}
+
+	for i := 0; i < b.N; i++ {
+		buf.Append(args)
+		buf.Reset()
+	}
+}
diff --git a/internal/safe.go b/internal/safe.go
new file mode 100644
index 00000000..870fe541
--- /dev/null
+++ b/internal/safe.go
@@ -0,0 +1,11 @@
+// +build appengine
+
+package internal
+
+func BytesToString(b []byte) string {
+	return string(b)
+}
+
+func StringToBytes(s string) []byte {
+	return []byte(s)
+}
diff --git a/internal/unsafe.go b/internal/unsafe.go
new file mode 100644
index 00000000..c18b25c1
--- /dev/null
+++ b/internal/unsafe.go
@@ -0,0 +1,27 @@
+// +build !appengine
+
+package internal
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+func BytesToString(b []byte) string {
+	bytesHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	strHeader := reflect.StringHeader{
+		Data: bytesHeader.Data,
+		Len:  bytesHeader.Len,
+	}
+	return *(*string)(unsafe.Pointer(&strHeader))
+}
+
+func StringToBytes(s string) []byte {
+	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
+	bh := reflect.SliceHeader{
+		Data: sh.Data,
+		Len:  sh.Len,
+		Cap:  sh.Len,
+	}
+	return *(*[]byte)(unsafe.Pointer(&bh))
+}
diff --git a/internal/util.go b/internal/util.go
new file mode 100644
index 00000000..520596fd
--- /dev/null
+++ b/internal/util.go
@@ -0,0 +1,47 @@
+package internal
+
+import "reflect"
+
+func ToLower(s string) string {
+	if isLower(s) {
+		return s
+	}
+
+	b := make([]byte, len(s))
+	for i := range b {
+		c := s[i]
+		if c >= 'A' && c <= 'Z' {
+			c += 'a' - 'A'
+		}
+		b[i] = c
+	}
+	return BytesToString(b)
+}
+
+func isLower(s string) bool {
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c >= 'A' && c <= 'Z' {
+			return false
+		}
+	}
+	return true
+}
+
+func SliceNextElem(v reflect.Value) reflect.Value {
+	if v.Len() < v.Cap() {
+		v.Set(v.Slice(0, v.Len()+1))
+		return v.Index(v.Len() - 1)
+	}
+
+	elemType := v.Type().Elem()
+
+	if elemType.Kind() == reflect.Ptr {
+		elem := reflect.New(elemType.Elem())
+		v.Set(reflect.Append(v, elem))
+		return elem.Elem()
+	}
+
+	v.Set(reflect.Append(v, reflect.Zero(elemType)))
+	return v.Index(v.Len() - 1)
+}
diff --git a/iterator.go b/iterator.go
new file mode 100644
index 00000000..5d4bedfe
--- /dev/null
+++ b/iterator.go
@@ -0,0 +1,73 @@
+package redis
+
+import "sync"
+
+// ScanIterator is used to incrementally iterate over a collection of elements.
+// It's safe for concurrent use by multiple goroutines.
+type ScanIterator struct {
+	mu  sync.Mutex // protects Scanner and pos
+	cmd *ScanCmd
+	pos int
+}
+
+// Err returns the last iterator error, if any.
+func (it *ScanIterator) Err() error {
+	it.mu.Lock()
+	err := it.cmd.Err()
+	it.mu.Unlock()
+	return err
+}
+
+// Next advances the cursor and returns true if more values can be read.
+func (it *ScanIterator) Next() bool {
+	it.mu.Lock()
+	defer it.mu.Unlock()
+
+	// Instantly return on errors.
+	if it.cmd.Err() != nil {
+		return false
+	}
+
+	// Advance cursor, check if we are still within range.
+	if it.pos < len(it.cmd.page) {
+		it.pos++
+		return true
+	}
+
+	for {
+		// Return if there is no more data to fetch.
+		if it.cmd.cursor == 0 {
+			return false
+		}
+
+		// Fetch next page.
+		if it.cmd._args[0] == "scan" {
+			it.cmd._args[1] = it.cmd.cursor
+		} else {
+			it.cmd._args[2] = it.cmd.cursor
+		}
+
+		err := it.cmd.process(it.cmd)
+		if err != nil {
+			return false
+		}
+
+		it.pos = 1
+
+		// Redis can occasionally return empty page.
+		if len(it.cmd.page) > 0 {
+			return true
+		}
+	}
+}
+
+// Val returns the key/field at the current cursor position.
+func (it *ScanIterator) Val() string {
+	var v string
+	it.mu.Lock()
+	if it.cmd.Err() == nil && it.pos > 0 && it.pos <= len(it.cmd.page) {
+		v = it.cmd.page[it.pos-1]
+	}
+	it.mu.Unlock()
+	return v
+}
diff --git a/iterator_test.go b/iterator_test.go
new file mode 100644
index 00000000..a2e62381
--- /dev/null
+++ b/iterator_test.go
@@ -0,0 +1,136 @@
+package redis_test
+
+import (
+	"fmt"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ScanIterator", func() {
+	var client *redis.Client
+
+	var seed = func(n int) error {
+		pipe := client.Pipeline()
+		for i := 1; i <= n; i++ {
+			pipe.Set(fmt.Sprintf("K%02d", i), "x", 0).Err()
+		}
+		_, err := pipe.Exec()
+		return err
+	}
+
+	var extraSeed = func(n int, m int) error {
+		pipe := client.Pipeline()
+		for i := 1; i <= m; i++ {
+			pipe.Set(fmt.Sprintf("A%02d", i), "x", 0).Err()
+		}
+		for i := 1; i <= n; i++ {
+			pipe.Set(fmt.Sprintf("K%02d", i), "x", 0).Err()
+		}
+		_, err := pipe.Exec()
+		return err
+	}
+
+	var hashKey = "K_HASHTEST"
+	var hashSeed = func(n int) error {
+		pipe := client.Pipeline()
+		for i := 1; i <= n; i++ {
+			pipe.HSet(hashKey, fmt.Sprintf("K%02d", i), "x").Err()
+		}
+		_, err := pipe.Exec()
+		return err
+	}
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should scan across empty DBs", func() {
+		iter := client.Scan(0, "", 10).Iterator()
+		Expect(iter.Next()).To(BeFalse())
+		Expect(iter.Err()).NotTo(HaveOccurred())
+	})
+
+	It("should scan across one page", func() {
+		Expect(seed(7)).NotTo(HaveOccurred())
+
+		var vals []string
+		iter := client.Scan(0, "", 0).Iterator()
+		for iter.Next() {
+			vals = append(vals, iter.Val())
+		}
+		Expect(iter.Err()).NotTo(HaveOccurred())
+		Expect(vals).To(ConsistOf([]string{"K01", "K02", "K03", "K04", "K05", "K06", "K07"}))
+	})
+
+	It("should scan across multiple pages", func() {
+		Expect(seed(71)).NotTo(HaveOccurred())
+
+		var vals []string
+		iter := client.Scan(0, "", 10).Iterator()
+		for iter.Next() {
+			vals = append(vals, iter.Val())
+		}
+		Expect(iter.Err()).NotTo(HaveOccurred())
+		Expect(vals).To(HaveLen(71))
+		Expect(vals).To(ContainElement("K01"))
+		Expect(vals).To(ContainElement("K71"))
+	})
+
+	It("should hscan across multiple pages", func() {
+		Expect(hashSeed(71)).NotTo(HaveOccurred())
+
+		var vals []string
+		iter := client.HScan(hashKey, 0, "", 10).Iterator()
+		for iter.Next() {
+			vals = append(vals, iter.Val())
+		}
+		Expect(iter.Err()).NotTo(HaveOccurred())
+		Expect(vals).To(HaveLen(71 * 2))
+		Expect(vals).To(ContainElement("K01"))
+		Expect(vals).To(ContainElement("K71"))
+	})
+
+	It("should scan to page borders", func() {
+		Expect(seed(20)).NotTo(HaveOccurred())
+
+		var vals []string
+		iter := client.Scan(0, "", 10).Iterator()
+		for iter.Next() {
+			vals = append(vals, iter.Val())
+		}
+		Expect(iter.Err()).NotTo(HaveOccurred())
+		Expect(vals).To(HaveLen(20))
+	})
+
+	It("should scan with match", func() {
+		Expect(seed(33)).NotTo(HaveOccurred())
+
+		var vals []string
+		iter := client.Scan(0, "K*2*", 10).Iterator()
+		for iter.Next() {
+			vals = append(vals, iter.Val())
+		}
+		Expect(iter.Err()).NotTo(HaveOccurred())
+		Expect(vals).To(HaveLen(13))
+	})
+
+	It("should scan with match across empty pages", func() {
+		Expect(extraSeed(2, 10)).NotTo(HaveOccurred())
+
+		var vals []string
+		iter := client.Scan(0, "K*", 1).Iterator()
+		for iter.Next() {
+			vals = append(vals, iter.Val())
+		}
+		Expect(iter.Err()).NotTo(HaveOccurred())
+		Expect(vals).To(HaveLen(2))
+	})
+})
diff --git a/main_test.go b/main_test.go
new file mode 100644
index 00000000..30f09c61
--- /dev/null
+++ b/main_test.go
@@ -0,0 +1,355 @@
+package redis_test
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+const (
+	redisPort          = "6380"
+	redisAddr          = ":" + redisPort
+	redisSecondaryPort = "6381"
+)
+
+const (
+	ringShard1Port = "6390"
+	ringShard2Port = "6391"
+)
+
+const (
+	sentinelName       = "mymaster"
+	sentinelMasterPort = "8123"
+	sentinelSlave1Port = "8124"
+	sentinelSlave2Port = "8125"
+	sentinelPort       = "8126"
+)
+
+var (
+	redisMain                                                *redisProcess
+	ringShard1, ringShard2                                   *redisProcess
+	sentinelMaster, sentinelSlave1, sentinelSlave2, sentinel *redisProcess
+)
+
+var cluster = &clusterScenario{
+	ports:     []string{"8220", "8221", "8222", "8223", "8224", "8225"},
+	nodeIds:   make([]string, 6),
+	processes: make(map[string]*redisProcess, 6),
+	clients:   make(map[string]*redis.Client, 6),
+}
+
+func init() {
+	//redis.SetLogger(log.New(os.Stderr, "redis: ", log.LstdFlags|log.Lshortfile))
+}
+
+var _ = BeforeSuite(func() {
+	var err error
+
+	redisMain, err = startRedis(redisPort)
+	Expect(err).NotTo(HaveOccurred())
+
+	ringShard1, err = startRedis(ringShard1Port)
+	Expect(err).NotTo(HaveOccurred())
+
+	ringShard2, err = startRedis(ringShard2Port)
+	Expect(err).NotTo(HaveOccurred())
+
+	sentinelMaster, err = startRedis(sentinelMasterPort)
+	Expect(err).NotTo(HaveOccurred())
+
+	sentinel, err = startSentinel(sentinelPort, sentinelName, sentinelMasterPort)
+	Expect(err).NotTo(HaveOccurred())
+
+	sentinelSlave1, err = startRedis(
+		sentinelSlave1Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
+	Expect(err).NotTo(HaveOccurred())
+
+	sentinelSlave2, err = startRedis(
+		sentinelSlave2Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(startCluster(cluster)).NotTo(HaveOccurred())
+})
+
+var _ = AfterSuite(func() {
+	Expect(redisMain.Close()).NotTo(HaveOccurred())
+
+	Expect(ringShard1.Close()).NotTo(HaveOccurred())
+	Expect(ringShard2.Close()).NotTo(HaveOccurred())
+
+	Expect(sentinel.Close()).NotTo(HaveOccurred())
+	Expect(sentinelSlave1.Close()).NotTo(HaveOccurred())
+	Expect(sentinelSlave2.Close()).NotTo(HaveOccurred())
+	Expect(sentinelMaster.Close()).NotTo(HaveOccurred())
+
+	Expect(stopCluster(cluster)).NotTo(HaveOccurred())
+})
+
+func TestGinkgoSuite(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "go-redis")
+}
+
+//------------------------------------------------------------------------------
+
+func redisOptions() *redis.Options {
+	return &redis.Options{
+		Addr:               redisAddr,
+		DB:                 15,
+		DialTimeout:        10 * time.Second,
+		ReadTimeout:        30 * time.Second,
+		WriteTimeout:       30 * time.Second,
+		PoolSize:           10,
+		PoolTimeout:        30 * time.Second,
+		IdleTimeout:        500 * time.Millisecond,
+		IdleCheckFrequency: 500 * time.Millisecond,
+	}
+}
+
+func redisClusterOptions() *redis.ClusterOptions {
+	return &redis.ClusterOptions{
+		DialTimeout:        10 * time.Second,
+		ReadTimeout:        30 * time.Second,
+		WriteTimeout:       30 * time.Second,
+		PoolSize:           10,
+		PoolTimeout:        30 * time.Second,
+		IdleTimeout:        500 * time.Millisecond,
+		IdleCheckFrequency: 500 * time.Millisecond,
+	}
+}
+
+func redisRingOptions() *redis.RingOptions {
+	return &redis.RingOptions{
+		Addrs: map[string]string{
+			"ringShardOne": ":" + ringShard1Port,
+			"ringShardTwo": ":" + ringShard2Port,
+		},
+		DialTimeout:        10 * time.Second,
+		ReadTimeout:        30 * time.Second,
+		WriteTimeout:       30 * time.Second,
+		PoolSize:           10,
+		PoolTimeout:        30 * time.Second,
+		IdleTimeout:        500 * time.Millisecond,
+		IdleCheckFrequency: 500 * time.Millisecond,
+	}
+}
+
+func perform(n int, cbs ...func(int)) {
+	var wg sync.WaitGroup
+	for _, cb := range cbs {
+		for i := 0; i < n; i++ {
+			wg.Add(1)
+			go func(cb func(int), i int) {
+				defer GinkgoRecover()
+				defer wg.Done()
+
+				cb(i)
+			}(cb, i)
+		}
+	}
+	wg.Wait()
+}
+
+func eventually(fn func() error, timeout time.Duration) error {
+	var exit int32
+	errCh := make(chan error)
+	done := make(chan struct{})
+
+	go func() {
+		defer GinkgoRecover()
+
+		for atomic.LoadInt32(&exit) == 0 {
+			err := fn()
+			if err == nil {
+				close(done)
+				return
+			}
+			select {
+			case errCh <- err:
+			default:
+			}
+			time.Sleep(timeout / 100)
+		}
+	}()
+
+	select {
+	case <-done:
+		return nil
+	case <-time.After(timeout):
+		atomic.StoreInt32(&exit, 1)
+		select {
+		case err := <-errCh:
+			return err
+		default:
+			return fmt.Errorf("timeout after %s", timeout)
+		}
+	}
+}
+
+func execCmd(name string, args ...string) (*os.Process, error) {
+	cmd := exec.Command(name, args...)
+	if testing.Verbose() {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+	}
+	return cmd.Process, cmd.Start()
+}
+
+func connectTo(port string) (*redis.Client, error) {
+	client := redis.NewClient(&redis.Options{
+		Addr: ":" + port,
+	})
+
+	err := eventually(func() error {
+		return client.Ping().Err()
+	}, 30*time.Second)
+	if err != nil {
+		return nil, err
+	}
+
+	return client, nil
+}
+
+type redisProcess struct {
+	*os.Process
+	*redis.Client
+}
+
+func (p *redisProcess) Close() error {
+	if err := p.Kill(); err != nil {
+		return err
+	}
+
+	err := eventually(func() error {
+		if err := p.Client.Ping().Err(); err != nil {
+			return nil
+		}
+		return errors.New("client is not shutdown")
+	}, 10*time.Second)
+	if err != nil {
+		return err
+	}
+
+	p.Client.Close()
+	return nil
+}
+
+var (
+	redisServerBin, _  = filepath.Abs(filepath.Join("testdata", "redis", "src", "redis-server"))
+	redisServerConf, _ = filepath.Abs(filepath.Join("testdata", "redis.conf"))
+)
+
+func redisDir(port string) (string, error) {
+	dir, err := filepath.Abs(filepath.Join("testdata", "instances", port))
+	if err != nil {
+		return "", err
+	}
+	if err := os.RemoveAll(dir); err != nil {
+		return "", err
+	}
+	if err := os.MkdirAll(dir, 0775); err != nil {
+		return "", err
+	}
+	return dir, nil
+}
+
+func startRedis(port string, args ...string) (*redisProcess, error) {
+	dir, err := redisDir(port)
+	if err != nil {
+		return nil, err
+	}
+	if err = exec.Command("cp", "-f", redisServerConf, dir).Run(); err != nil {
+		return nil, err
+	}
+
+	baseArgs := []string{filepath.Join(dir, "redis.conf"), "--port", port, "--dir", dir}
+	process, err := execCmd(redisServerBin, append(baseArgs, args...)...)
+	if err != nil {
+		return nil, err
+	}
+
+	client, err := connectTo(port)
+	if err != nil {
+		process.Kill()
+		return nil, err
+	}
+	return &redisProcess{process, client}, err
+}
+
+func startSentinel(port, masterName, masterPort string) (*redisProcess, error) {
+	dir, err := redisDir(port)
+	if err != nil {
+		return nil, err
+	}
+	process, err := execCmd(redisServerBin, os.DevNull, "--sentinel", "--port", port, "--dir", dir)
+	if err != nil {
+		return nil, err
+	}
+	client, err := connectTo(port)
+	if err != nil {
+		process.Kill()
+		return nil, err
+	}
+	for _, cmd := range []*redis.StatusCmd{
+		redis.NewStatusCmd("SENTINEL", "MONITOR", masterName, "127.0.0.1", masterPort, "1"),
+		redis.NewStatusCmd("SENTINEL", "SET", masterName, "down-after-milliseconds", "500"),
+		redis.NewStatusCmd("SENTINEL", "SET", masterName, "failover-timeout", "1000"),
+		redis.NewStatusCmd("SENTINEL", "SET", masterName, "parallel-syncs", "1"),
+	} {
+		client.Process(cmd)
+		if err := cmd.Err(); err != nil {
+			process.Kill()
+			return nil, err
+		}
+	}
+	return &redisProcess{process, client}, nil
+}
+
+//------------------------------------------------------------------------------
+
+type badConnError string
+
+func (e badConnError) Error() string   { return string(e) }
+func (e badConnError) Timeout() bool   { return false }
+func (e badConnError) Temporary() bool { return false }
+
+type badConn struct {
+	net.TCPConn
+
+	readDelay, writeDelay time.Duration
+	readErr, writeErr     error
+}
+
+var _ net.Conn = &badConn{}
+
+func (cn *badConn) Read([]byte) (int, error) {
+	if cn.readDelay != 0 {
+		time.Sleep(cn.readDelay)
+	}
+	if cn.readErr != nil {
+		return 0, cn.readErr
+	}
+	return 0, badConnError("bad connection")
+}
+
+func (cn *badConn) Write([]byte) (int, error) {
+	if cn.writeDelay != 0 {
+		time.Sleep(cn.writeDelay)
+	}
+	if cn.writeErr != nil {
+		return 0, cn.writeErr
+	}
+	return 0, badConnError("bad connection")
+}
diff --git a/options.go b/options.go
new file mode 100644
index 00000000..dea04545
--- /dev/null
+++ b/options.go
@@ -0,0 +1,210 @@
+package redis
+
+import (
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"net/url"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/internal/pool"
+)
+
+type Options struct {
+	// The network type, either tcp or unix.
+	// Default is tcp.
+	Network string
+	// host:port address.
+	Addr string
+
+	// Dialer creates new network connection and has priority over
+	// Network and Addr options.
+	Dialer func() (net.Conn, error)
+
+	// Hook that is called when new connection is established.
+	OnConnect func(*Conn) error
+
+	// Optional password. Must match the password specified in the
+	// requirepass server configuration option.
+	Password string
+	// Database to be selected after connecting to the server.
+	DB int
+
+	// Maximum number of retries before giving up.
+	// Default is to not retry failed commands.
+	MaxRetries int
+	// Minimum backoff between each retry.
+	// Default is 8 milliseconds; -1 disables backoff.
+	MinRetryBackoff time.Duration
+	// Maximum backoff between each retry.
+	// Default is 512 milliseconds; -1 disables backoff.
+	MaxRetryBackoff time.Duration
+
+	// Dial timeout for establishing new connections.
+	// Default is 5 seconds.
+	DialTimeout time.Duration
+	// Timeout for socket reads. If reached, commands will fail
+	// with a timeout instead of blocking.
+	// Default is 3 seconds.
+	ReadTimeout time.Duration
+	// Timeout for socket writes. If reached, commands will fail
+	// with a timeout instead of blocking.
+	// Default is ReadTimeout.
+	WriteTimeout time.Duration
+
+	// Maximum number of socket connections.
+	// Default is 10 connections per every CPU as reported by runtime.NumCPU.
+	PoolSize int
+	// Amount of time client waits for connection if all connections
+	// are busy before returning an error.
+	// Default is ReadTimeout + 1 second.
+	PoolTimeout time.Duration
+	// Amount of time after which client closes idle connections.
+	// Should be less than server's timeout.
+	// Default is 5 minutes.
+	IdleTimeout time.Duration
+	// Frequency of idle checks.
+	// Default is 1 minute.
+	// When minus value is set, then idle check is disabled.
+	IdleCheckFrequency time.Duration
+
+	// Enables read only queries on slave nodes.
+	readOnly bool
+
+	// TLS Config to use. When set TLS will be negotiated.
+	TLSConfig *tls.Config
+}
+
+func (opt *Options) init() {
+	if opt.Network == "" {
+		opt.Network = "tcp"
+	}
+	if opt.Dialer == nil {
+		opt.Dialer = func() (net.Conn, error) {
+			conn, err := net.DialTimeout(opt.Network, opt.Addr, opt.DialTimeout)
+			if opt.TLSConfig == nil || err != nil {
+				return conn, err
+			}
+			t := tls.Client(conn, opt.TLSConfig)
+			return t, t.Handshake()
+		}
+	}
+	if opt.PoolSize == 0 {
+		opt.PoolSize = 10 * runtime.NumCPU()
+	}
+	if opt.DialTimeout == 0 {
+		opt.DialTimeout = 5 * time.Second
+	}
+	switch opt.ReadTimeout {
+	case -1:
+		opt.ReadTimeout = 0
+	case 0:
+		opt.ReadTimeout = 3 * time.Second
+	}
+	switch opt.WriteTimeout {
+	case -1:
+		opt.WriteTimeout = 0
+	case 0:
+		opt.WriteTimeout = opt.ReadTimeout
+	}
+	if opt.PoolTimeout == 0 {
+		opt.PoolTimeout = opt.ReadTimeout + time.Second
+	}
+	if opt.IdleTimeout == 0 {
+		opt.IdleTimeout = 5 * time.Minute
+	}
+	if opt.IdleCheckFrequency == 0 {
+		opt.IdleCheckFrequency = time.Minute
+	}
+
+	switch opt.MinRetryBackoff {
+	case -1:
+		opt.MinRetryBackoff = 0
+	case 0:
+		opt.MinRetryBackoff = 8 * time.Millisecond
+	}
+	switch opt.MaxRetryBackoff {
+	case -1:
+		opt.MaxRetryBackoff = 0
+	case 0:
+		opt.MaxRetryBackoff = 512 * time.Millisecond
+	}
+}
+
+// ParseURL parses an URL into Options that can be used to connect to Redis.
+func ParseURL(redisURL string) (*Options, error) {
+	o := &Options{Network: "tcp"}
+	u, err := url.Parse(redisURL)
+	if err != nil {
+		return nil, err
+	}
+
+	if u.Scheme != "redis" && u.Scheme != "rediss" {
+		return nil, errors.New("invalid redis URL scheme: " + u.Scheme)
+	}
+
+	if u.User != nil {
+		if p, ok := u.User.Password(); ok {
+			o.Password = p
+		}
+	}
+
+	if len(u.Query()) > 0 {
+		return nil, errors.New("no options supported")
+	}
+
+	h, p, err := net.SplitHostPort(u.Host)
+	if err != nil {
+		h = u.Host
+	}
+	if h == "" {
+		h = "localhost"
+	}
+	if p == "" {
+		p = "6379"
+	}
+	o.Addr = net.JoinHostPort(h, p)
+
+	f := strings.FieldsFunc(u.Path, func(r rune) bool {
+		return r == '/'
+	})
+	switch len(f) {
+	case 0:
+		o.DB = 0
+	case 1:
+		if o.DB, err = strconv.Atoi(f[0]); err != nil {
+			return nil, fmt.Errorf("invalid redis database number: %q", f[0])
+		}
+	default:
+		return nil, errors.New("invalid redis URL path: " + u.Path)
+	}
+
+	if u.Scheme == "rediss" {
+		o.TLSConfig = &tls.Config{ServerName: h}
+	}
+	return o, nil
+}
+
+func newConnPool(opt *Options) *pool.ConnPool {
+	return pool.NewConnPool(&pool.Options{
+		Dialer:             opt.Dialer,
+		PoolSize:           opt.PoolSize,
+		PoolTimeout:        opt.PoolTimeout,
+		IdleTimeout:        opt.IdleTimeout,
+		IdleCheckFrequency: opt.IdleCheckFrequency,
+	})
+}
+
+// PoolStats contains pool state information and accumulated stats.
+type PoolStats struct {
+	Requests uint32 // number of times a connection was requested by the pool
+	Hits     uint32 // number of times free connection was found in the pool
+	Timeouts uint32 // number of times a wait timeout occurred
+
+	TotalConns uint32 // the number of total connections in the pool
+	FreeConns  uint32 // the number of free connections in the pool
+}
diff --git a/options_test.go b/options_test.go
new file mode 100644
index 00000000..6a4af716
--- /dev/null
+++ b/options_test.go
@@ -0,0 +1,94 @@
+// +build go1.7
+
+package redis
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestParseURL(t *testing.T) {
+	cases := []struct {
+		u    string
+		addr string
+		db   int
+		tls  bool
+		err  error
+	}{
+		{
+			"redis://localhost:123/1",
+			"localhost:123",
+			1, false, nil,
+		},
+		{
+			"redis://localhost:123",
+			"localhost:123",
+			0, false, nil,
+		},
+		{
+			"redis://localhost/1",
+			"localhost:6379",
+			1, false, nil,
+		},
+		{
+			"redis://12345",
+			"12345:6379",
+			0, false, nil,
+		},
+		{
+			"rediss://localhost:123",
+			"localhost:123",
+			0, true, nil,
+		},
+		{
+			"redis://localhost/?abc=123",
+			"",
+			0, false, errors.New("no options supported"),
+		},
+		{
+			"http://google.com",
+			"",
+			0, false, errors.New("invalid redis URL scheme: http"),
+		},
+		{
+			"redis://localhost/1/2/3/4",
+			"",
+			0, false, errors.New("invalid redis URL path: /1/2/3/4"),
+		},
+		{
+			"12345",
+			"",
+			0, false, errors.New("invalid redis URL scheme: "),
+		},
+		{
+			"redis://localhost/iamadatabase",
+			"",
+			0, false, errors.New(`invalid redis database number: "iamadatabase"`),
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.u, func(t *testing.T) {
+			o, err := ParseURL(c.u)
+			if c.err == nil && err != nil {
+				t.Fatalf("unexpected error: '%q'", err)
+				return
+			}
+			if c.err != nil && err != nil {
+				if c.err.Error() != err.Error() {
+					t.Fatalf("got %q, expected %q", err, c.err)
+				}
+				return
+			}
+			if o.Addr != c.addr {
+				t.Errorf("got %q, want %q", o.Addr, c.addr)
+			}
+			if o.DB != c.db {
+				t.Errorf("got %q, expected %q", o.DB, c.db)
+			}
+			if c.tls && o.TLSConfig == nil {
+				t.Errorf("got nil TLSConfig, expected a TLSConfig")
+			}
+		})
+	}
+}
diff --git a/parser.go b/parser.go
new file mode 100644
index 00000000..1d7ec630
--- /dev/null
+++ b/parser.go
@@ -0,0 +1,374 @@
+package redis
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"time"
+
+	"github.com/go-redis/redis/internal/proto"
+)
+
+// Implements proto.MultiBulkParse
+func sliceParser(rd *proto.Reader, n int64) (interface{}, error) {
+	vals := make([]interface{}, 0, n)
+	for i := int64(0); i < n; i++ {
+		v, err := rd.ReadReply(sliceParser)
+		if err == Nil {
+			vals = append(vals, nil)
+		} else if err != nil {
+			return nil, err
+		} else {
+			switch vv := v.(type) {
+			case []byte:
+				vals = append(vals, string(vv))
+			default:
+				vals = append(vals, v)
+			}
+		}
+	}
+	return vals, nil
+}
+
+// Implements proto.MultiBulkParse
+func boolSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
+	bools := make([]bool, 0, n)
+	for i := int64(0); i < n; i++ {
+		n, err := rd.ReadIntReply()
+		if err != nil {
+			return nil, err
+		}
+		bools = append(bools, n == 1)
+	}
+	return bools, nil
+}
+
+// Implements proto.MultiBulkParse
+func stringSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
+	ss := make([]string, 0, n)
+	for i := int64(0); i < n; i++ {
+		s, err := rd.ReadStringReply()
+		if err == Nil {
+			ss = append(ss, "")
+		} else if err != nil {
+			return nil, err
+		} else {
+			ss = append(ss, s)
+		}
+	}
+	return ss, nil
+}
+
+// Implements proto.MultiBulkParse
+func stringStringMapParser(rd *proto.Reader, n int64) (interface{}, error) {
+	m := make(map[string]string, n/2)
+	for i := int64(0); i < n; i += 2 {
+		key, err := rd.ReadStringReply()
+		if err != nil {
+			return nil, err
+		}
+
+		value, err := rd.ReadStringReply()
+		if err != nil {
+			return nil, err
+		}
+
+		m[key] = value
+	}
+	return m, nil
+}
+
+// Implements proto.MultiBulkParse
+func stringIntMapParser(rd *proto.Reader, n int64) (interface{}, error) {
+	m := make(map[string]int64, n/2)
+	for i := int64(0); i < n; i += 2 {
+		key, err := rd.ReadStringReply()
+		if err != nil {
+			return nil, err
+		}
+
+		n, err := rd.ReadIntReply()
+		if err != nil {
+			return nil, err
+		}
+
+		m[key] = n
+	}
+	return m, nil
+}
+
+// Implements proto.MultiBulkParse
+func zSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
+	zz := make([]Z, n/2)
+	for i := int64(0); i < n; i += 2 {
+		var err error
+
+		z := &zz[i/2]
+
+		z.Member, err = rd.ReadStringReply()
+		if err != nil {
+			return nil, err
+		}
+
+		z.Score, err = rd.ReadFloatReply()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return zz, nil
+}
+
+// Implements proto.MultiBulkParse
+func clusterSlotsParser(rd *proto.Reader, n int64) (interface{}, error) {
+	slots := make([]ClusterSlot, n)
+	for i := 0; i < len(slots); i++ {
+		n, err := rd.ReadArrayLen()
+		if err != nil {
+			return nil, err
+		}
+		if n < 2 {
+			err := fmt.Errorf("redis: got %d elements in cluster info, expected at least 2", n)
+			return nil, err
+		}
+
+		start, err := rd.ReadIntReply()
+		if err != nil {
+			return nil, err
+		}
+
+		end, err := rd.ReadIntReply()
+		if err != nil {
+			return nil, err
+		}
+
+		nodes := make([]ClusterNode, n-2)
+		for j := 0; j < len(nodes); j++ {
+			n, err := rd.ReadArrayLen()
+			if err != nil {
+				return nil, err
+			}
+			if n != 2 && n != 3 {
+				err := fmt.Errorf("got %d elements in cluster info address, expected 2 or 3", n)
+				return nil, err
+			}
+
+			ip, err := rd.ReadStringReply()
+			if err != nil {
+				return nil, err
+			}
+
+			port, err := rd.ReadIntReply()
+			if err != nil {
+				return nil, err
+			}
+			nodes[j].Addr = net.JoinHostPort(ip, strconv.FormatInt(port, 10))
+
+			if n == 3 {
+				id, err := rd.ReadStringReply()
+				if err != nil {
+					return nil, err
+				}
+				nodes[j].Id = id
+			}
+		}
+
+		slots[i] = ClusterSlot{
+			Start: int(start),
+			End:   int(end),
+			Nodes: nodes,
+		}
+	}
+	return slots, nil
+}
+
+func newGeoLocationParser(q *GeoRadiusQuery) proto.MultiBulkParse {
+	return func(rd *proto.Reader, n int64) (interface{}, error) {
+		var loc GeoLocation
+		var err error
+
+		loc.Name, err = rd.ReadStringReply()
+		if err != nil {
+			return nil, err
+		}
+		if q.WithDist {
+			loc.Dist, err = rd.ReadFloatReply()
+			if err != nil {
+				return nil, err
+			}
+		}
+		if q.WithGeoHash {
+			loc.GeoHash, err = rd.ReadIntReply()
+			if err != nil {
+				return nil, err
+			}
+		}
+		if q.WithCoord {
+			n, err := rd.ReadArrayLen()
+			if err != nil {
+				return nil, err
+			}
+			if n != 2 {
+				return nil, fmt.Errorf("got %d coordinates, expected 2", n)
+			}
+
+			loc.Longitude, err = rd.ReadFloatReply()
+			if err != nil {
+				return nil, err
+			}
+			loc.Latitude, err = rd.ReadFloatReply()
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return &loc, nil
+	}
+}
+
+func newGeoLocationSliceParser(q *GeoRadiusQuery) proto.MultiBulkParse {
+	return func(rd *proto.Reader, n int64) (interface{}, error) {
+		locs := make([]GeoLocation, 0, n)
+		for i := int64(0); i < n; i++ {
+			v, err := rd.ReadReply(newGeoLocationParser(q))
+			if err != nil {
+				return nil, err
+			}
+			switch vv := v.(type) {
+			case []byte:
+				locs = append(locs, GeoLocation{
+					Name: string(vv),
+				})
+			case *GeoLocation:
+				locs = append(locs, *vv)
+			default:
+				return nil, fmt.Errorf("got %T, expected string or *GeoLocation", v)
+			}
+		}
+		return locs, nil
+	}
+}
+
+func geoPosParser(rd *proto.Reader, n int64) (interface{}, error) {
+	var pos GeoPos
+	var err error
+
+	pos.Longitude, err = rd.ReadFloatReply()
+	if err != nil {
+		return nil, err
+	}
+
+	pos.Latitude, err = rd.ReadFloatReply()
+	if err != nil {
+		return nil, err
+	}
+
+	return &pos, nil
+}
+
+func geoPosSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
+	positions := make([]*GeoPos, 0, n)
+	for i := int64(0); i < n; i++ {
+		v, err := rd.ReadReply(geoPosParser)
+		if err != nil {
+			if err == Nil {
+				positions = append(positions, nil)
+				continue
+			}
+			return nil, err
+		}
+		switch v := v.(type) {
+		case *GeoPos:
+			positions = append(positions, v)
+		default:
+			return nil, fmt.Errorf("got %T, expected *GeoPos", v)
+		}
+	}
+	return positions, nil
+}
+
+func commandInfoParser(rd *proto.Reader, n int64) (interface{}, error) {
+	var cmd CommandInfo
+	var err error
+
+	if n != 6 {
+		return nil, fmt.Errorf("redis: got %d elements in COMMAND reply, wanted 6", n)
+	}
+
+	cmd.Name, err = rd.ReadStringReply()
+	if err != nil {
+		return nil, err
+	}
+
+	arity, err := rd.ReadIntReply()
+	if err != nil {
+		return nil, err
+	}
+	cmd.Arity = int8(arity)
+
+	flags, err := rd.ReadReply(stringSliceParser)
+	if err != nil {
+		return nil, err
+	}
+	cmd.Flags = flags.([]string)
+
+	firstKeyPos, err := rd.ReadIntReply()
+	if err != nil {
+		return nil, err
+	}
+	cmd.FirstKeyPos = int8(firstKeyPos)
+
+	lastKeyPos, err := rd.ReadIntReply()
+	if err != nil {
+		return nil, err
+	}
+	cmd.LastKeyPos = int8(lastKeyPos)
+
+	stepCount, err := rd.ReadIntReply()
+	if err != nil {
+		return nil, err
+	}
+	cmd.StepCount = int8(stepCount)
+
+	for _, flag := range cmd.Flags {
+		if flag == "readonly" {
+			cmd.ReadOnly = true
+			break
+		}
+	}
+
+	return &cmd, nil
+}
+
+// Implements proto.MultiBulkParse
+func commandInfoSliceParser(rd *proto.Reader, n int64) (interface{}, error) {
+	m := make(map[string]*CommandInfo, n)
+	for i := int64(0); i < n; i++ {
+		v, err := rd.ReadReply(commandInfoParser)
+		if err != nil {
+			return nil, err
+		}
+		vv := v.(*CommandInfo)
+		m[vv.Name] = vv
+
+	}
+	return m, nil
+}
+
+// Implements proto.MultiBulkParse
+func timeParser(rd *proto.Reader, n int64) (interface{}, error) {
+	if n != 2 {
+		return nil, fmt.Errorf("got %d elements, expected 2", n)
+	}
+
+	sec, err := rd.ReadInt()
+	if err != nil {
+		return nil, err
+	}
+
+	microsec, err := rd.ReadInt()
+	if err != nil {
+		return nil, err
+	}
+
+	return time.Unix(sec, microsec*1000), nil
+}
diff --git a/pipeline.go b/pipeline.go
new file mode 100644
index 00000000..b66c0597
--- /dev/null
+++ b/pipeline.go
@@ -0,0 +1,106 @@
+package redis
+
+import (
+	"sync"
+
+	"github.com/go-redis/redis/internal/pool"
+)
+
+type pipelineExecer func([]Cmder) error
+
+type Pipeliner interface {
+	StatefulCmdable
+	Process(cmd Cmder) error
+	Close() error
+	Discard() error
+	discard() error
+	Exec() ([]Cmder, error)
+	pipelined(fn func(Pipeliner) error) ([]Cmder, error)
+}
+
+var _ Pipeliner = (*Pipeline)(nil)
+
+// Pipeline implements pipelining as described in
+// http://redis.io/topics/pipelining. It's safe for concurrent use
+// by multiple goroutines.
+type Pipeline struct {
+	statefulCmdable
+
+	exec pipelineExecer
+
+	mu     sync.Mutex
+	cmds   []Cmder
+	closed bool
+}
+
+func (c *Pipeline) Process(cmd Cmder) error {
+	c.mu.Lock()
+	c.cmds = append(c.cmds, cmd)
+	c.mu.Unlock()
+	return nil
+}
+
+// Close closes the pipeline, releasing any open resources.
+func (c *Pipeline) Close() error {
+	c.mu.Lock()
+	c.discard()
+	c.closed = true
+	c.mu.Unlock()
+	return nil
+}
+
+// Discard resets the pipeline and discards queued commands.
+func (c *Pipeline) Discard() error {
+	c.mu.Lock()
+	err := c.discard()
+	c.mu.Unlock()
+	return err
+}
+
+func (c *Pipeline) discard() error {
+	if c.closed {
+		return pool.ErrClosed
+	}
+	c.cmds = c.cmds[:0]
+	return nil
+}
+
+// Exec executes all previously queued commands using one
+// client-server roundtrip.
+//
+// Exec always returns list of commands and error of the first failed
+// command if any.
+func (c *Pipeline) Exec() ([]Cmder, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.closed {
+		return nil, pool.ErrClosed
+	}
+
+	if len(c.cmds) == 0 {
+		return nil, nil
+	}
+
+	cmds := c.cmds
+	c.cmds = nil
+
+	return cmds, c.exec(cmds)
+}
+
+func (c *Pipeline) pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	if err := fn(c); err != nil {
+		return nil, err
+	}
+	cmds, err := c.Exec()
+	_ = c.Close()
+	return cmds, err
+}
+
+func (c *Pipeline) Pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.pipelined(fn)
+}
+
+func (c *Pipeline) Pipeline() Pipeliner {
+	return c
+}
diff --git a/pipeline_test.go b/pipeline_test.go
new file mode 100644
index 00000000..11896c6b
--- /dev/null
+++ b/pipeline_test.go
@@ -0,0 +1,80 @@
+package redis_test
+
+import (
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("pipelining", func() {
+	var client *redis.Client
+	var pipe *redis.Pipeline
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("supports block style", func() {
+		var get *redis.StringCmd
+		cmds, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+			get = pipe.Get("foo")
+			return nil
+		})
+		Expect(err).To(Equal(redis.Nil))
+		Expect(cmds).To(HaveLen(1))
+		Expect(cmds[0]).To(Equal(get))
+		Expect(get.Err()).To(Equal(redis.Nil))
+		Expect(get.Val()).To(Equal(""))
+	})
+
+	assertPipeline := func() {
+		It("returns no errors when there are no commands", func() {
+			_, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It("discards queued commands", func() {
+			pipe.Get("key")
+			pipe.Discard()
+			cmds, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmds).To(BeNil())
+		})
+
+		It("handles val/err", func() {
+			err := client.Set("key", "value", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			get := pipe.Get("key")
+			cmds, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmds).To(HaveLen(1))
+
+			val, err := get.Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("value"))
+		})
+	}
+
+	Describe("Pipeline", func() {
+		BeforeEach(func() {
+			pipe = client.Pipeline().(*redis.Pipeline)
+		})
+
+		assertPipeline()
+	})
+
+	Describe("TxPipeline", func() {
+		BeforeEach(func() {
+			pipe = client.TxPipeline().(*redis.Pipeline)
+		})
+
+		assertPipeline()
+	})
+})
diff --git a/pool_test.go b/pool_test.go
new file mode 100644
index 00000000..34a548a6
--- /dev/null
+++ b/pool_test.go
@@ -0,0 +1,141 @@
+package redis_test
+
+import (
+	"time"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("pool", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("respects max size", func() {
+		perform(1000, func(id int) {
+			val, err := client.Ping().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("PONG"))
+		})
+
+		pool := client.Pool()
+		Expect(pool.Len()).To(BeNumerically("<=", 10))
+		Expect(pool.FreeLen()).To(BeNumerically("<=", 10))
+		Expect(pool.Len()).To(Equal(pool.FreeLen()))
+	})
+
+	It("respects max size on multi", func() {
+		perform(1000, func(id int) {
+			var ping *redis.StatusCmd
+
+			err := client.Watch(func(tx *redis.Tx) error {
+				cmds, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+					ping = pipe.Ping()
+					return nil
+				})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(cmds).To(HaveLen(1))
+				return err
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(ping.Err()).NotTo(HaveOccurred())
+			Expect(ping.Val()).To(Equal("PONG"))
+		})
+
+		pool := client.Pool()
+		Expect(pool.Len()).To(BeNumerically("<=", 10))
+		Expect(pool.FreeLen()).To(BeNumerically("<=", 10))
+		Expect(pool.Len()).To(Equal(pool.FreeLen()))
+	})
+
+	It("respects max size on pipelines", func() {
+		perform(1000, func(id int) {
+			pipe := client.Pipeline()
+			ping := pipe.Ping()
+			cmds, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmds).To(HaveLen(1))
+			Expect(ping.Err()).NotTo(HaveOccurred())
+			Expect(ping.Val()).To(Equal("PONG"))
+			Expect(pipe.Close()).NotTo(HaveOccurred())
+		})
+
+		pool := client.Pool()
+		Expect(pool.Len()).To(BeNumerically("<=", 10))
+		Expect(pool.FreeLen()).To(BeNumerically("<=", 10))
+		Expect(pool.Len()).To(Equal(pool.FreeLen()))
+	})
+
+	It("removes broken connections", func() {
+		cn, _, err := client.Pool().Get()
+		Expect(err).NotTo(HaveOccurred())
+		cn.SetNetConn(&badConn{})
+		Expect(client.Pool().Put(cn)).NotTo(HaveOccurred())
+
+		err = client.Ping().Err()
+		Expect(err).To(MatchError("bad connection"))
+
+		val, err := client.Ping().Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).To(Equal("PONG"))
+
+		pool := client.Pool()
+		Expect(pool.Len()).To(Equal(1))
+		Expect(pool.FreeLen()).To(Equal(1))
+
+		stats := pool.Stats()
+		Expect(stats.Requests).To(Equal(uint32(4)))
+		Expect(stats.Hits).To(Equal(uint32(2)))
+		Expect(stats.Timeouts).To(Equal(uint32(0)))
+	})
+
+	It("reuses connections", func() {
+		for i := 0; i < 100; i++ {
+			val, err := client.Ping().Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).To(Equal("PONG"))
+		}
+
+		pool := client.Pool()
+		Expect(pool.Len()).To(Equal(1))
+		Expect(pool.FreeLen()).To(Equal(1))
+
+		stats := pool.Stats()
+		Expect(stats.Requests).To(Equal(uint32(101)))
+		Expect(stats.Hits).To(Equal(uint32(100)))
+		Expect(stats.Timeouts).To(Equal(uint32(0)))
+	})
+
+	It("removes idle connections", func() {
+		stats := client.PoolStats()
+		Expect(stats).To(Equal(&redis.PoolStats{
+			Requests:   1,
+			Hits:       0,
+			Timeouts:   0,
+			TotalConns: 1,
+			FreeConns:  1,
+		}))
+
+		time.Sleep(2 * time.Second)
+
+		stats = client.PoolStats()
+		Expect(stats).To(Equal(&redis.PoolStats{
+			Requests:   1,
+			Hits:       0,
+			Timeouts:   0,
+			TotalConns: 0,
+			FreeConns:  0,
+		}))
+	})
+})
diff --git a/pubsub.go b/pubsub.go
new file mode 100644
index 00000000..4a5c65f5
--- /dev/null
+++ b/pubsub.go
@@ -0,0 +1,392 @@
+package redis
+
+import (
+	"fmt"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+	"github.com/go-redis/redis/internal/pool"
+)
+
+// PubSub implements Pub/Sub commands as described in
+// http://redis.io/topics/pubsub. It's NOT safe for concurrent use by
+// multiple goroutines.
+//
+// PubSub automatically resubscribes to the channels and patterns
+// when Redis becomes unavailable.
+type PubSub struct {
+	opt *Options
+
+	newConn   func([]string) (*pool.Conn, error)
+	closeConn func(*pool.Conn) error
+
+	mu       sync.Mutex
+	cn       *pool.Conn
+	channels []string
+	patterns []string
+	closed   bool
+
+	cmd *Cmd
+}
+
+func (c *PubSub) conn() (*pool.Conn, error) {
+	c.mu.Lock()
+	cn, err := c._conn(nil)
+	c.mu.Unlock()
+	return cn, err
+}
+
+func (c *PubSub) _conn(channels []string) (*pool.Conn, error) {
+	if c.closed {
+		return nil, pool.ErrClosed
+	}
+
+	if c.cn != nil {
+		return c.cn, nil
+	}
+
+	cn, err := c.newConn(channels)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := c.resubscribe(cn); err != nil {
+		_ = c.closeConn(cn)
+		return nil, err
+	}
+
+	c.cn = cn
+	return cn, nil
+}
+
+func (c *PubSub) resubscribe(cn *pool.Conn) error {
+	var firstErr error
+	if len(c.channels) > 0 {
+		if err := c._subscribe(cn, "subscribe", c.channels...); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	if len(c.patterns) > 0 {
+		if err := c._subscribe(cn, "psubscribe", c.patterns...); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
+func (c *PubSub) _subscribe(cn *pool.Conn, redisCmd string, channels ...string) error {
+	args := make([]interface{}, 1+len(channels))
+	args[0] = redisCmd
+	for i, channel := range channels {
+		args[1+i] = channel
+	}
+	cmd := NewSliceCmd(args...)
+
+	cn.SetWriteTimeout(c.opt.WriteTimeout)
+	return writeCmd(cn, cmd)
+}
+
+func (c *PubSub) releaseConn(cn *pool.Conn, err error) {
+	c.mu.Lock()
+	c._releaseConn(cn, err)
+	c.mu.Unlock()
+}
+
+func (c *PubSub) _releaseConn(cn *pool.Conn, err error) {
+	if internal.IsBadConn(err, true) && c.cn == cn {
+		_ = c.closeTheCn()
+	}
+}
+
+func (c *PubSub) closeTheCn() error {
+	err := c.closeConn(c.cn)
+	c.cn = nil
+	return err
+}
+
+func (c *PubSub) Close() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.closed {
+		return pool.ErrClosed
+	}
+	c.closed = true
+
+	if c.cn != nil {
+		return c.closeTheCn()
+	}
+	return nil
+}
+
+// Subscribes the client to the specified channels. It returns
+// empty subscription if there are no channels.
+func (c *PubSub) Subscribe(channels ...string) error {
+	c.mu.Lock()
+	err := c.subscribe("subscribe", channels...)
+	c.channels = appendIfNotExists(c.channels, channels...)
+	c.mu.Unlock()
+	return err
+}
+
+// Subscribes the client to the given patterns. It returns
+// empty subscription if there are no patterns.
+func (c *PubSub) PSubscribe(patterns ...string) error {
+	c.mu.Lock()
+	err := c.subscribe("psubscribe", patterns...)
+	c.patterns = appendIfNotExists(c.patterns, patterns...)
+	c.mu.Unlock()
+	return err
+}
+
+// Unsubscribes the client from the given channels, or from all of
+// them if none is given.
+func (c *PubSub) Unsubscribe(channels ...string) error {
+	c.mu.Lock()
+	err := c.subscribe("unsubscribe", channels...)
+	c.channels = remove(c.channels, channels...)
+	c.mu.Unlock()
+	return err
+}
+
+// Unsubscribes the client from the given patterns, or from all of
+// them if none is given.
+func (c *PubSub) PUnsubscribe(patterns ...string) error {
+	c.mu.Lock()
+	err := c.subscribe("punsubscribe", patterns...)
+	c.patterns = remove(c.patterns, patterns...)
+	c.mu.Unlock()
+	return err
+}
+
+func (c *PubSub) subscribe(redisCmd string, channels ...string) error {
+	cn, err := c._conn(channels)
+	if err != nil {
+		return err
+	}
+
+	err = c._subscribe(cn, redisCmd, channels...)
+	c._releaseConn(cn, err)
+	return err
+}
+
+func (c *PubSub) Ping(payload ...string) error {
+	args := []interface{}{"ping"}
+	if len(payload) == 1 {
+		args = append(args, payload[0])
+	}
+	cmd := NewCmd(args...)
+
+	cn, err := c.conn()
+	if err != nil {
+		return err
+	}
+
+	cn.SetWriteTimeout(c.opt.WriteTimeout)
+	err = writeCmd(cn, cmd)
+	c.releaseConn(cn, err)
+	return err
+}
+
+// Message received after a successful subscription to channel.
+type Subscription struct {
+	// Can be "subscribe", "unsubscribe", "psubscribe" or "punsubscribe".
+	Kind string
+	// Channel name we have subscribed to.
+	Channel string
+	// Number of channels we are currently subscribed to.
+	Count int
+}
+
+func (m *Subscription) String() string {
+	return fmt.Sprintf("%s: %s", m.Kind, m.Channel)
+}
+
+// Message received as result of a PUBLISH command issued by another client.
+type Message struct {
+	Channel string
+	Pattern string
+	Payload string
+}
+
+func (m *Message) String() string {
+	return fmt.Sprintf("Message<%s: %s>", m.Channel, m.Payload)
+}
+
+// Pong received as result of a PING command issued by another client.
+type Pong struct {
+	Payload string
+}
+
+func (p *Pong) String() string {
+	if p.Payload != "" {
+		return fmt.Sprintf("Pong<%s>", p.Payload)
+	}
+	return "Pong"
+}
+
+func (c *PubSub) newMessage(reply interface{}) (interface{}, error) {
+	switch reply := reply.(type) {
+	case string:
+		return &Pong{
+			Payload: reply,
+		}, nil
+	case []interface{}:
+		switch kind := reply[0].(string); kind {
+		case "subscribe", "unsubscribe", "psubscribe", "punsubscribe":
+			return &Subscription{
+				Kind:    kind,
+				Channel: reply[1].(string),
+				Count:   int(reply[2].(int64)),
+			}, nil
+		case "message":
+			return &Message{
+				Channel: reply[1].(string),
+				Payload: reply[2].(string),
+			}, nil
+		case "pmessage":
+			return &Message{
+				Pattern: reply[1].(string),
+				Channel: reply[2].(string),
+				Payload: reply[3].(string),
+			}, nil
+		case "pong":
+			return &Pong{
+				Payload: reply[1].(string),
+			}, nil
+		default:
+			return nil, fmt.Errorf("redis: unsupported pubsub message: %q", kind)
+		}
+	default:
+		return nil, fmt.Errorf("redis: unsupported pubsub message: %#v", reply)
+	}
+}
+
+// ReceiveTimeout acts like Receive but returns an error if message
+// is not received in time. This is low-level API and most clients
+// should use ReceiveMessage.
+func (c *PubSub) ReceiveTimeout(timeout time.Duration) (interface{}, error) {
+	if c.cmd == nil {
+		c.cmd = NewCmd()
+	}
+
+	cn, err := c.conn()
+	if err != nil {
+		return nil, err
+	}
+
+	cn.SetReadTimeout(timeout)
+	err = c.cmd.readReply(cn)
+	c.releaseConn(cn, err)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.newMessage(c.cmd.Val())
+}
+
+// Receive returns a message as a Subscription, Message, Pong or error.
+// See PubSub example for details. This is low-level API and most clients
+// should use ReceiveMessage.
+func (c *PubSub) Receive() (interface{}, error) {
+	return c.ReceiveTimeout(0)
+}
+
+// ReceiveMessage returns a Message or error ignoring Subscription or Pong
+// messages. It automatically reconnects to Redis Server and resubscribes
+// to channels in case of network errors.
+func (c *PubSub) ReceiveMessage() (*Message, error) {
+	return c.receiveMessage(5 * time.Second)
+}
+
+func (c *PubSub) receiveMessage(timeout time.Duration) (*Message, error) {
+	var errNum uint
+	for {
+		msgi, err := c.ReceiveTimeout(timeout)
+		if err != nil {
+			if !internal.IsNetworkError(err) {
+				return nil, err
+			}
+
+			errNum++
+			if errNum < 3 {
+				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+					err := c.Ping()
+					if err != nil {
+						internal.Logf("PubSub.Ping failed: %s", err)
+					}
+				}
+			} else {
+				// 3 consequent errors - connection is broken or
+				// Redis Server is down.
+				// Sleep to not exceed max number of open connections.
+				time.Sleep(time.Second)
+			}
+			continue
+		}
+
+		// Reset error number, because we received a message.
+		errNum = 0
+
+		switch msg := msgi.(type) {
+		case *Subscription:
+			// Ignore.
+		case *Pong:
+			// Ignore.
+		case *Message:
+			return msg, nil
+		default:
+			return nil, fmt.Errorf("redis: unknown message: %T", msgi)
+		}
+	}
+}
+
+// Channel returns a channel for concurrently receiving messages.
+// The channel is closed with PubSub.
+func (c *PubSub) Channel() <-chan *Message {
+	ch := make(chan *Message, 100)
+	go func() {
+		for {
+			msg, err := c.ReceiveMessage()
+			if err != nil {
+				if err == pool.ErrClosed {
+					break
+				}
+				continue
+			}
+			ch <- msg
+		}
+		close(ch)
+	}()
+	return ch
+}
+
+func appendIfNotExists(ss []string, es ...string) []string {
+loop:
+	for _, e := range es {
+		for _, s := range ss {
+			if s == e {
+				continue loop
+			}
+		}
+		ss = append(ss, e)
+	}
+	return ss
+}
+
+func remove(ss []string, es ...string) []string {
+	if len(es) == 0 {
+		return ss[:0]
+	}
+	for _, e := range es {
+		for i, s := range ss {
+			if s == e {
+				ss = append(ss[:i], ss[i+1:]...)
+				break
+			}
+		}
+	}
+	return ss
+}
diff --git a/pubsub_test.go b/pubsub_test.go
new file mode 100644
index 00000000..1d9dfcb9
--- /dev/null
+++ b/pubsub_test.go
@@ -0,0 +1,427 @@
+package redis_test
+
+import (
+	"io"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("PubSub", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should support pattern matching", func() {
+		pubsub := client.PSubscribe("mychannel*")
+		defer pubsub.Close()
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			subscr := msgi.(*redis.Subscription)
+			Expect(subscr.Kind).To(Equal("psubscribe"))
+			Expect(subscr.Channel).To(Equal("mychannel*"))
+			Expect(subscr.Count).To(Equal(1))
+		}
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err.(net.Error).Timeout()).To(Equal(true))
+			Expect(msgi).To(BeNil())
+		}
+
+		n, err := client.Publish("mychannel1", "hello").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(1)))
+
+		Expect(pubsub.PUnsubscribe("mychannel*")).NotTo(HaveOccurred())
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			subscr := msgi.(*redis.Message)
+			Expect(subscr.Channel).To(Equal("mychannel1"))
+			Expect(subscr.Pattern).To(Equal("mychannel*"))
+			Expect(subscr.Payload).To(Equal("hello"))
+		}
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			subscr := msgi.(*redis.Subscription)
+			Expect(subscr.Kind).To(Equal("punsubscribe"))
+			Expect(subscr.Channel).To(Equal("mychannel*"))
+			Expect(subscr.Count).To(Equal(0))
+		}
+
+		stats := client.PoolStats()
+		Expect(stats.Requests - stats.Hits).To(Equal(uint32(2)))
+	})
+
+	It("should pub/sub channels", func() {
+		channels, err := client.PubSubChannels("mychannel*").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(channels).To(BeEmpty())
+
+		pubsub := client.Subscribe("mychannel", "mychannel2")
+		defer pubsub.Close()
+
+		channels, err = client.PubSubChannels("mychannel*").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(channels).To(ConsistOf([]string{"mychannel", "mychannel2"}))
+
+		channels, err = client.PubSubChannels("").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(channels).To(BeEmpty())
+
+		channels, err = client.PubSubChannels("*").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(channels)).To(BeNumerically(">=", 2))
+	})
+
+	It("should return the numbers of subscribers", func() {
+		pubsub := client.Subscribe("mychannel", "mychannel2")
+		defer pubsub.Close()
+
+		channels, err := client.PubSubNumSub("mychannel", "mychannel2", "mychannel3").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(channels).To(Equal(map[string]int64{
+			"mychannel":  1,
+			"mychannel2": 1,
+			"mychannel3": 0,
+		}))
+	})
+
+	It("should return the numbers of subscribers by pattern", func() {
+		num, err := client.PubSubNumPat().Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(num).To(Equal(int64(0)))
+
+		pubsub := client.PSubscribe("*")
+		defer pubsub.Close()
+
+		num, err = client.PubSubNumPat().Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(num).To(Equal(int64(1)))
+	})
+
+	It("should pub/sub", func() {
+		pubsub := client.Subscribe("mychannel", "mychannel2")
+		defer pubsub.Close()
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			subscr := msgi.(*redis.Subscription)
+			Expect(subscr.Kind).To(Equal("subscribe"))
+			Expect(subscr.Channel).To(Equal("mychannel"))
+			Expect(subscr.Count).To(Equal(1))
+		}
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			subscr := msgi.(*redis.Subscription)
+			Expect(subscr.Kind).To(Equal("subscribe"))
+			Expect(subscr.Channel).To(Equal("mychannel2"))
+			Expect(subscr.Count).To(Equal(2))
+		}
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err.(net.Error).Timeout()).To(Equal(true))
+			Expect(msgi).NotTo(HaveOccurred())
+		}
+
+		n, err := client.Publish("mychannel", "hello").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(1)))
+
+		n, err = client.Publish("mychannel2", "hello2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(1)))
+
+		Expect(pubsub.Unsubscribe("mychannel", "mychannel2")).NotTo(HaveOccurred())
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			msg := msgi.(*redis.Message)
+			Expect(msg.Channel).To(Equal("mychannel"))
+			Expect(msg.Payload).To(Equal("hello"))
+		}
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			msg := msgi.(*redis.Message)
+			Expect(msg.Channel).To(Equal("mychannel2"))
+			Expect(msg.Payload).To(Equal("hello2"))
+		}
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			subscr := msgi.(*redis.Subscription)
+			Expect(subscr.Kind).To(Equal("unsubscribe"))
+			Expect(subscr.Channel).To(Equal("mychannel"))
+			Expect(subscr.Count).To(Equal(1))
+		}
+
+		{
+			msgi, err := pubsub.ReceiveTimeout(time.Second)
+			Expect(err).NotTo(HaveOccurred())
+			subscr := msgi.(*redis.Subscription)
+			Expect(subscr.Kind).To(Equal("unsubscribe"))
+			Expect(subscr.Channel).To(Equal("mychannel2"))
+			Expect(subscr.Count).To(Equal(0))
+		}
+
+		stats := client.PoolStats()
+		Expect(stats.Requests - stats.Hits).To(Equal(uint32(2)))
+	})
+
+	It("should ping/pong", func() {
+		pubsub := client.Subscribe("mychannel")
+		defer pubsub.Close()
+
+		_, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = pubsub.Ping("")
+		Expect(err).NotTo(HaveOccurred())
+
+		msgi, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+		pong := msgi.(*redis.Pong)
+		Expect(pong.Payload).To(Equal(""))
+	})
+
+	It("should ping/pong with payload", func() {
+		pubsub := client.Subscribe("mychannel")
+		defer pubsub.Close()
+
+		_, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = pubsub.Ping("hello")
+		Expect(err).NotTo(HaveOccurred())
+
+		msgi, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+		pong := msgi.(*redis.Pong)
+		Expect(pong.Payload).To(Equal("hello"))
+	})
+
+	It("should multi-ReceiveMessage", func() {
+		pubsub := client.Subscribe("mychannel")
+		defer pubsub.Close()
+
+		subscr, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(subscr).To(Equal(&redis.Subscription{
+			Kind:    "subscribe",
+			Channel: "mychannel",
+			Count:   1,
+		}))
+
+		err = client.Publish("mychannel", "hello").Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		err = client.Publish("mychannel", "world").Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		msg, err := pubsub.ReceiveMessage()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(msg.Channel).To(Equal("mychannel"))
+		Expect(msg.Payload).To(Equal("hello"))
+
+		msg, err = pubsub.ReceiveMessage()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(msg.Channel).To(Equal("mychannel"))
+		Expect(msg.Payload).To(Equal("world"))
+	})
+
+	It("should ReceiveMessage after timeout", func() {
+		timeout := 100 * time.Millisecond
+
+		pubsub := client.Subscribe("mychannel")
+		defer pubsub.Close()
+
+		subscr, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(subscr).To(Equal(&redis.Subscription{
+			Kind:    "subscribe",
+			Channel: "mychannel",
+			Count:   1,
+		}))
+
+		done := make(chan bool, 1)
+		go func() {
+			defer GinkgoRecover()
+			defer func() {
+				done <- true
+			}()
+
+			time.Sleep(timeout + 100*time.Millisecond)
+			n, err := client.Publish("mychannel", "hello").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(int64(1)))
+		}()
+
+		msg, err := pubsub.ReceiveMessageTimeout(timeout)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(msg.Channel).To(Equal("mychannel"))
+		Expect(msg.Payload).To(Equal("hello"))
+
+		Eventually(done).Should(Receive())
+
+		stats := client.PoolStats()
+		Expect(stats.Requests).To(Equal(uint32(2)))
+		Expect(stats.Hits).To(Equal(uint32(1)))
+	})
+
+	It("returns an error when subscribe fails", func() {
+		pubsub := client.Subscribe()
+		defer pubsub.Close()
+
+		pubsub.SetNetConn(&badConn{
+			readErr:  io.EOF,
+			writeErr: io.EOF,
+		})
+
+		err := pubsub.Subscribe("mychannel")
+		Expect(err).To(MatchError("EOF"))
+
+		err = pubsub.Subscribe("mychannel")
+		Expect(err).NotTo(HaveOccurred())
+	})
+
+	expectReceiveMessageOnError := func(pubsub *redis.PubSub) {
+		pubsub.SetNetConn(&badConn{
+			readErr:  io.EOF,
+			writeErr: io.EOF,
+		})
+
+		done := make(chan bool, 1)
+		go func() {
+			defer GinkgoRecover()
+			defer func() {
+				done <- true
+			}()
+
+			time.Sleep(100 * time.Millisecond)
+			err := client.Publish("mychannel", "hello").Err()
+			Expect(err).NotTo(HaveOccurred())
+		}()
+
+		msg, err := pubsub.ReceiveMessage()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(msg.Channel).To(Equal("mychannel"))
+		Expect(msg.Payload).To(Equal("hello"))
+
+		Eventually(done).Should(Receive())
+	}
+
+	It("Subscribe should reconnect on ReceiveMessage error", func() {
+		pubsub := client.Subscribe("mychannel")
+		defer pubsub.Close()
+
+		subscr, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(subscr).To(Equal(&redis.Subscription{
+			Kind:    "subscribe",
+			Channel: "mychannel",
+			Count:   1,
+		}))
+
+		expectReceiveMessageOnError(pubsub)
+	})
+
+	It("PSubscribe should reconnect on ReceiveMessage error", func() {
+		pubsub := client.PSubscribe("mychannel")
+		defer pubsub.Close()
+
+		subscr, err := pubsub.ReceiveTimeout(time.Second)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(subscr).To(Equal(&redis.Subscription{
+			Kind:    "psubscribe",
+			Channel: "mychannel",
+			Count:   1,
+		}))
+
+		expectReceiveMessageOnError(pubsub)
+	})
+
+	It("should return on Close", func() {
+		pubsub := client.Subscribe("mychannel")
+		defer pubsub.Close()
+
+		var wg sync.WaitGroup
+		wg.Add(1)
+		go func() {
+			defer GinkgoRecover()
+
+			wg.Done()
+			defer wg.Done()
+
+			_, err := pubsub.ReceiveMessage()
+			Expect(err).To(HaveOccurred())
+			Expect(err).To(SatisfyAny(
+				MatchError("redis: client is closed"),
+				MatchError("use of closed network connection"), // Go 1.4
+			))
+		}()
+
+		wg.Wait()
+		wg.Add(1)
+
+		Expect(pubsub.Close()).NotTo(HaveOccurred())
+
+		wg.Wait()
+	})
+
+	It("should ReceiveMessage without a subscription", func() {
+		timeout := 100 * time.Millisecond
+
+		pubsub := client.Subscribe()
+		defer pubsub.Close()
+
+		var wg sync.WaitGroup
+		wg.Add(1)
+		go func() {
+			defer GinkgoRecover()
+			defer wg.Done()
+
+			time.Sleep(2 * timeout)
+
+			err := pubsub.Subscribe("mychannel")
+			Expect(err).NotTo(HaveOccurred())
+
+			time.Sleep(timeout)
+
+			err = client.Publish("mychannel", "hello").Err()
+			Expect(err).NotTo(HaveOccurred())
+		}()
+
+		msg, err := pubsub.ReceiveMessageTimeout(timeout)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(msg.Channel).To(Equal("mychannel"))
+		Expect(msg.Payload).To(Equal("hello"))
+
+		wg.Wait()
+	})
+})
diff --git a/race_test.go b/race_test.go
new file mode 100644
index 00000000..5bcb0768
--- /dev/null
+++ b/race_test.go
@@ -0,0 +1,247 @@
+package redis_test
+
+import (
+	"bytes"
+	"fmt"
+	"net"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("races", func() {
+	var client *redis.Client
+	var C, N int
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).To(BeNil())
+
+		C, N = 10, 1000
+		if testing.Short() {
+			C = 4
+			N = 100
+		}
+	})
+
+	AfterEach(func() {
+		err := client.Close()
+		Expect(err).NotTo(HaveOccurred())
+	})
+
+	It("should echo", func() {
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				msg := fmt.Sprintf("echo %d %d", id, i)
+				echo, err := client.Echo(msg).Result()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(echo).To(Equal(msg))
+			}
+		})
+	})
+
+	It("should incr", func() {
+		key := "TestIncrFromGoroutines"
+
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				err := client.Incr(key).Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+		})
+
+		val, err := client.Get(key).Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).To(Equal(int64(C * N)))
+	})
+
+	It("should handle many keys", func() {
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				err := client.Set(
+					fmt.Sprintf("keys.key-%d-%d", id, i),
+					fmt.Sprintf("hello-%d-%d", id, i),
+					0,
+				).Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+		})
+
+		keys := client.Keys("keys.*")
+		Expect(keys.Err()).NotTo(HaveOccurred())
+		Expect(len(keys.Val())).To(Equal(C * N))
+	})
+
+	It("should handle many keys 2", func() {
+		perform(C, func(id int) {
+			keys := []string{"non-existent-key"}
+			for i := 0; i < N; i++ {
+				key := fmt.Sprintf("keys.key-%d", i)
+				keys = append(keys, key)
+
+				err := client.Set(key, fmt.Sprintf("hello-%d", i), 0).Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+			keys = append(keys, "non-existent-key")
+
+			vals, err := client.MGet(keys...).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(vals)).To(Equal(N + 2))
+
+			for i := 0; i < N; i++ {
+				Expect(vals[i+1]).To(Equal(fmt.Sprintf("hello-%d", i)))
+			}
+
+			Expect(vals[0]).To(BeNil())
+			Expect(vals[N+1]).To(BeNil())
+		})
+	})
+
+	It("should handle big vals in Get", func() {
+		C, N = 4, 100
+
+		bigVal := bytes.Repeat([]byte{'*'}, 1<<17) // 128kb
+
+		err := client.Set("key", bigVal, 0).Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		// Reconnect to get new connection.
+		Expect(client.Close()).To(BeNil())
+		client = redis.NewClient(redisOptions())
+
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				got, err := client.Get("key").Bytes()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(got).To(Equal(bigVal))
+			}
+		})
+	})
+
+	It("should handle big vals in Set", func() {
+		C, N = 4, 100
+
+		bigVal := bytes.Repeat([]byte{'*'}, 1<<17) // 128kb
+
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				err := client.Set("key", bigVal, 0).Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+		})
+	})
+
+	It("should select db", func() {
+		err := client.Set("db", 1, 0).Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		perform(C, func(id int) {
+			opt := redisOptions()
+			opt.DB = id
+			client := redis.NewClient(opt)
+			for i := 0; i < N; i++ {
+				err := client.Set("db", id, 0).Err()
+				Expect(err).NotTo(HaveOccurred())
+
+				n, err := client.Get("db").Int64()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(n).To(Equal(int64(id)))
+			}
+			err := client.Close()
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		n, err := client.Get("db").Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(1)))
+	})
+
+	It("should select DB with read timeout", func() {
+		perform(C, func(id int) {
+			opt := redisOptions()
+			opt.DB = id
+			opt.ReadTimeout = time.Nanosecond
+			client := redis.NewClient(opt)
+
+			perform(C, func(id int) {
+				err := client.Ping().Err()
+				Expect(err).To(HaveOccurred())
+				Expect(err.(net.Error).Timeout()).To(BeTrue())
+			})
+
+			err := client.Close()
+			Expect(err).NotTo(HaveOccurred())
+		})
+	})
+
+	It("should Watch/Unwatch", func() {
+		err := client.Set("key", "0", 0).Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				err := client.Watch(func(tx *redis.Tx) error {
+					val, err := tx.Get("key").Result()
+					Expect(err).NotTo(HaveOccurred())
+					Expect(val).NotTo(Equal(redis.Nil))
+
+					num, err := strconv.ParseInt(val, 10, 64)
+					Expect(err).NotTo(HaveOccurred())
+
+					cmds, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+						pipe.Set("key", strconv.FormatInt(num+1, 10), 0)
+						return nil
+					})
+					Expect(cmds).To(HaveLen(1))
+					return err
+				}, "key")
+				if err == redis.TxFailedErr {
+					i--
+					continue
+				}
+				Expect(err).NotTo(HaveOccurred())
+			}
+		})
+
+		val, err := client.Get("key").Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).To(Equal(int64(C * N)))
+	})
+
+	It("should Pipeline", func() {
+		perform(C, func(id int) {
+			pipe := client.Pipeline()
+			for i := 0; i < N; i++ {
+				pipe.Echo(fmt.Sprint(i))
+			}
+
+			cmds, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmds).To(HaveLen(N))
+
+			for i := 0; i < N; i++ {
+				Expect(cmds[i].(*redis.StringCmd).Val()).To(Equal(fmt.Sprint(i)))
+			}
+		})
+	})
+
+	It("should Pipeline", func() {
+		pipe := client.Pipeline()
+		perform(N, func(id int) {
+			pipe.Incr("key")
+		})
+
+		cmds, err := pipe.Exec()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(cmds).To(HaveLen(N))
+
+		n, err := client.Get("key").Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(N)))
+	})
+})
diff --git a/redis.go b/redis.go
new file mode 100644
index 00000000..b18973cd
--- /dev/null
+++ b/redis.go
@@ -0,0 +1,458 @@
+package redis
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+	"github.com/go-redis/redis/internal/pool"
+	"github.com/go-redis/redis/internal/proto"
+)
+
+// Redis nil reply, .e.g. when key does not exist.
+const Nil = internal.Nil
+
+func SetLogger(logger *log.Logger) {
+	internal.Logger = logger
+}
+
+func (c *baseClient) String() string {
+	return fmt.Sprintf("Redis<%s db:%d>", c.getAddr(), c.opt.DB)
+}
+
+func (c *baseClient) newConn() (*pool.Conn, error) {
+	cn, err := c.connPool.NewConn()
+	if err != nil {
+		return nil, err
+	}
+
+	if !cn.Inited {
+		if err := c.initConn(cn); err != nil {
+			_ = c.connPool.CloseConn(cn)
+			return nil, err
+		}
+	}
+
+	return cn, nil
+}
+
+func (c *baseClient) getConn() (*pool.Conn, bool, error) {
+	cn, isNew, err := c.connPool.Get()
+	if err != nil {
+		return nil, false, err
+	}
+
+	if !cn.Inited {
+		if err := c.initConn(cn); err != nil {
+			_ = c.connPool.Remove(cn)
+			return nil, false, err
+		}
+	}
+
+	return cn, isNew, nil
+}
+
+func (c *baseClient) releaseConn(cn *pool.Conn, err error) bool {
+	if internal.IsBadConn(err, false) {
+		_ = c.connPool.Remove(cn)
+		return false
+	}
+
+	_ = c.connPool.Put(cn)
+	return true
+}
+
+func (c *baseClient) initConn(cn *pool.Conn) error {
+	cn.Inited = true
+
+	if c.opt.Password == "" &&
+		c.opt.DB == 0 &&
+		!c.opt.readOnly &&
+		c.opt.OnConnect == nil {
+		return nil
+	}
+
+	// Temp client to initialize connection.
+	conn := &Conn{
+		baseClient: baseClient{
+			opt:      c.opt,
+			connPool: pool.NewSingleConnPool(cn),
+		},
+	}
+	conn.setProcessor(conn.Process)
+
+	_, err := conn.Pipelined(func(pipe Pipeliner) error {
+		if c.opt.Password != "" {
+			pipe.Auth(c.opt.Password)
+		}
+
+		if c.opt.DB > 0 {
+			pipe.Select(c.opt.DB)
+		}
+
+		if c.opt.readOnly {
+			pipe.ReadOnly()
+		}
+
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	if c.opt.OnConnect != nil {
+		return c.opt.OnConnect(conn)
+	}
+	return nil
+}
+
+// WrapProcess replaces the process func. It takes a function createWrapper
+// which is supplied by the user. createWrapper takes the old process func as
+// an input and returns the new wrapper process func. createWrapper should
+// use call the old process func within the new process func.
+func (c *baseClient) WrapProcess(fn func(oldProcess func(cmd Cmder) error) func(cmd Cmder) error) {
+	c.process = fn(c.defaultProcess)
+}
+
+func (c *baseClient) Process(cmd Cmder) error {
+	if c.process != nil {
+		return c.process(cmd)
+	}
+	return c.defaultProcess(cmd)
+}
+
+func (c *baseClient) defaultProcess(cmd Cmder) error {
+	for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
+		if attempt > 0 {
+			time.Sleep(c.retryBackoff(attempt))
+		}
+
+		cn, _, err := c.getConn()
+		if err != nil {
+			cmd.setErr(err)
+			if internal.IsRetryableError(err) {
+				continue
+			}
+			return err
+		}
+
+		cn.SetWriteTimeout(c.opt.WriteTimeout)
+		if err := writeCmd(cn, cmd); err != nil {
+			c.releaseConn(cn, err)
+			cmd.setErr(err)
+			if internal.IsRetryableError(err) {
+				continue
+			}
+			return err
+		}
+
+		cn.SetReadTimeout(c.cmdTimeout(cmd))
+		err = cmd.readReply(cn)
+		c.releaseConn(cn, err)
+		if err != nil && internal.IsRetryableError(err) {
+			continue
+		}
+
+		return err
+	}
+
+	return cmd.Err()
+}
+
+func (c *baseClient) retryBackoff(attempt int) time.Duration {
+	return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
+}
+
+func (c *baseClient) cmdTimeout(cmd Cmder) time.Duration {
+	if timeout := cmd.readTimeout(); timeout != nil {
+		return *timeout
+	} else {
+		return c.opt.ReadTimeout
+	}
+}
+
+// Close closes the client, releasing any open resources.
+//
+// It is rare to Close a Client, as the Client is meant to be
+// long-lived and shared between many goroutines.
+func (c *baseClient) Close() error {
+	var firstErr error
+	if c.onClose != nil {
+		if err := c.onClose(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	if err := c.connPool.Close(); err != nil && firstErr == nil {
+		firstErr = err
+	}
+	return firstErr
+}
+
+func (c *baseClient) getAddr() string {
+	return c.opt.Addr
+}
+
+type pipelineProcessor func(*pool.Conn, []Cmder) (bool, error)
+
+func (c *baseClient) pipelineExecer(p pipelineProcessor) pipelineExecer {
+	return func(cmds []Cmder) error {
+		var firstErr error
+		for i := 0; i <= c.opt.MaxRetries; i++ {
+			cn, _, err := c.getConn()
+			if err != nil {
+				setCmdsErr(cmds, err)
+				return err
+			}
+
+			canRetry, err := p(cn, cmds)
+			c.releaseConn(cn, err)
+			if err == nil {
+				return nil
+			}
+			if firstErr == nil {
+				firstErr = err
+			}
+			if !canRetry || !internal.IsRetryableError(err) {
+				break
+			}
+		}
+		return firstErr
+	}
+}
+
+func (c *baseClient) pipelineProcessCmds(cn *pool.Conn, cmds []Cmder) (bool, error) {
+	cn.SetWriteTimeout(c.opt.WriteTimeout)
+	if err := writeCmd(cn, cmds...); err != nil {
+		setCmdsErr(cmds, err)
+		return true, err
+	}
+
+	// Set read timeout for all commands.
+	cn.SetReadTimeout(c.opt.ReadTimeout)
+	return pipelineReadCmds(cn, cmds)
+}
+
+func pipelineReadCmds(cn *pool.Conn, cmds []Cmder) (retry bool, firstErr error) {
+	for i, cmd := range cmds {
+		err := cmd.readReply(cn)
+		if err == nil {
+			continue
+		}
+		if i == 0 {
+			retry = true
+		}
+		if firstErr == nil {
+			firstErr = err
+		}
+	}
+	return
+}
+
+func (c *baseClient) txPipelineProcessCmds(cn *pool.Conn, cmds []Cmder) (bool, error) {
+	cn.SetWriteTimeout(c.opt.WriteTimeout)
+	if err := txPipelineWriteMulti(cn, cmds); err != nil {
+		setCmdsErr(cmds, err)
+		return true, err
+	}
+
+	// Set read timeout for all commands.
+	cn.SetReadTimeout(c.opt.ReadTimeout)
+
+	if err := c.txPipelineReadQueued(cn, cmds); err != nil {
+		return false, err
+	}
+
+	_, err := pipelineReadCmds(cn, cmds)
+	return false, err
+}
+
+func txPipelineWriteMulti(cn *pool.Conn, cmds []Cmder) error {
+	multiExec := make([]Cmder, 0, len(cmds)+2)
+	multiExec = append(multiExec, NewStatusCmd("MULTI"))
+	multiExec = append(multiExec, cmds...)
+	multiExec = append(multiExec, NewSliceCmd("EXEC"))
+	return writeCmd(cn, multiExec...)
+}
+
+func (c *baseClient) txPipelineReadQueued(cn *pool.Conn, cmds []Cmder) error {
+	var firstErr error
+
+	// Parse queued replies.
+	var statusCmd StatusCmd
+	if err := statusCmd.readReply(cn); err != nil && firstErr == nil {
+		firstErr = err
+	}
+
+	for _, cmd := range cmds {
+		err := statusCmd.readReply(cn)
+		if err != nil {
+			cmd.setErr(err)
+			if firstErr == nil {
+				firstErr = err
+			}
+		}
+	}
+
+	// Parse number of replies.
+	line, err := cn.Rd.ReadLine()
+	if err != nil {
+		if err == Nil {
+			err = TxFailedErr
+		}
+		return err
+	}
+
+	switch line[0] {
+	case proto.ErrorReply:
+		return proto.ParseErrorReply(line)
+	case proto.ArrayReply:
+		// ok
+	default:
+		err := fmt.Errorf("redis: expected '*', but got line %q", line)
+		return err
+	}
+
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+// Client is a Redis client representing a pool of zero or more
+// underlying connections. It's safe for concurrent use by multiple
+// goroutines.
+type Client struct {
+	baseClient
+	cmdable
+}
+
+func newClient(opt *Options, pool pool.Pooler) *Client {
+	client := Client{
+		baseClient: baseClient{
+			opt:      opt,
+			connPool: pool,
+		},
+	}
+	client.setProcessor(client.Process)
+	return &client
+}
+
+// NewClient returns a client to the Redis Server specified by Options.
+func NewClient(opt *Options) *Client {
+	opt.init()
+	return newClient(opt, newConnPool(opt))
+}
+
+func (c *Client) copy() *Client {
+	c2 := new(Client)
+	*c2 = *c
+	c2.setProcessor(c2.Process)
+	return c2
+}
+
+// Options returns read-only Options that were used to create the client.
+func (c *Client) Options() *Options {
+	return c.opt
+}
+
+// PoolStats returns connection pool stats.
+func (c *Client) PoolStats() *PoolStats {
+	s := c.connPool.Stats()
+	return &PoolStats{
+		Requests: s.Requests,
+		Hits:     s.Hits,
+		Timeouts: s.Timeouts,
+
+		TotalConns: s.TotalConns,
+		FreeConns:  s.FreeConns,
+	}
+}
+
+func (c *Client) Pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.Pipeline().pipelined(fn)
+}
+
+func (c *Client) Pipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.pipelineExecer(c.pipelineProcessCmds),
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
+
+func (c *Client) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.TxPipeline().pipelined(fn)
+}
+
+// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
+func (c *Client) TxPipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.pipelineExecer(c.txPipelineProcessCmds),
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
+
+func (c *Client) pubSub() *PubSub {
+	return &PubSub{
+		opt: c.opt,
+
+		newConn: func(channels []string) (*pool.Conn, error) {
+			return c.newConn()
+		},
+		closeConn: c.connPool.CloseConn,
+	}
+}
+
+// Subscribe subscribes the client to the specified channels.
+// Channels can be omitted to create empty subscription.
+func (c *Client) Subscribe(channels ...string) *PubSub {
+	pubsub := c.pubSub()
+	if len(channels) > 0 {
+		_ = pubsub.Subscribe(channels...)
+	}
+	return pubsub
+}
+
+// PSubscribe subscribes the client to the given patterns.
+// Patterns can be omitted to create empty subscription.
+func (c *Client) PSubscribe(channels ...string) *PubSub {
+	pubsub := c.pubSub()
+	if len(channels) > 0 {
+		_ = pubsub.PSubscribe(channels...)
+	}
+	return pubsub
+}
+
+//------------------------------------------------------------------------------
+
+// Conn is like Client, but its pool contains single connection.
+type Conn struct {
+	baseClient
+	statefulCmdable
+}
+
+func (c *Conn) Pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.Pipeline().pipelined(fn)
+}
+
+func (c *Conn) Pipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.pipelineExecer(c.pipelineProcessCmds),
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
+
+func (c *Conn) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.TxPipeline().pipelined(fn)
+}
+
+// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
+func (c *Conn) TxPipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.pipelineExecer(c.txPipelineProcessCmds),
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
diff --git a/redis_context.go b/redis_context.go
new file mode 100644
index 00000000..6ec811ca
--- /dev/null
+++ b/redis_context.go
@@ -0,0 +1,35 @@
+// +build go1.7
+
+package redis
+
+import (
+	"context"
+
+	"github.com/go-redis/redis/internal/pool"
+)
+
+type baseClient struct {
+	connPool pool.Pooler
+	opt      *Options
+
+	process func(Cmder) error
+	onClose func() error // hook called when client is closed
+
+	ctx context.Context
+}
+
+func (c *Client) Context() context.Context {
+	if c.ctx != nil {
+		return c.ctx
+	}
+	return context.Background()
+}
+
+func (c *Client) WithContext(ctx context.Context) *Client {
+	if ctx == nil {
+		panic("nil context")
+	}
+	c2 := c.copy()
+	c2.ctx = ctx
+	return c2
+}
diff --git a/redis_no_context.go b/redis_no_context.go
new file mode 100644
index 00000000..0752192f
--- /dev/null
+++ b/redis_no_context.go
@@ -0,0 +1,15 @@
+// +build !go1.7
+
+package redis
+
+import (
+	"github.com/go-redis/redis/internal/pool"
+)
+
+type baseClient struct {
+	connPool pool.Pooler
+	opt      *Options
+
+	process func(Cmder) error
+	onClose func() error // hook called when client is closed
+}
diff --git a/redis_test.go b/redis_test.go
new file mode 100644
index 00000000..49d3fb32
--- /dev/null
+++ b/redis_test.go
@@ -0,0 +1,364 @@
+package redis_test
+
+import (
+	"bytes"
+	"net"
+	"time"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Client", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		client.Close()
+	})
+
+	It("should Stringer", func() {
+		Expect(client.String()).To(Equal("Redis<:6380 db:15>"))
+	})
+
+	It("should ping", func() {
+		val, err := client.Ping().Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).To(Equal("PONG"))
+	})
+
+	It("should return pool stats", func() {
+		Expect(client.PoolStats()).To(BeAssignableToTypeOf(&redis.PoolStats{}))
+	})
+
+	It("should support custom dialers", func() {
+		custom := redis.NewClient(&redis.Options{
+			Addr: ":1234",
+			Dialer: func() (net.Conn, error) {
+				return net.Dial("tcp", redisAddr)
+			},
+		})
+
+		val, err := custom.Ping().Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).To(Equal("PONG"))
+		Expect(custom.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should close", func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+		err := client.Ping().Err()
+		Expect(err).To(MatchError("redis: client is closed"))
+	})
+
+	It("should close pubsub without closing the client", func() {
+		pubsub := client.Subscribe()
+		Expect(pubsub.Close()).NotTo(HaveOccurred())
+
+		_, err := pubsub.Receive()
+		Expect(err).To(MatchError("redis: client is closed"))
+		Expect(client.Ping().Err()).NotTo(HaveOccurred())
+	})
+
+	It("should close Tx without closing the client", func() {
+		err := client.Watch(func(tx *redis.Tx) error {
+			_, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+				pipe.Ping()
+				return nil
+			})
+			return err
+		})
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(client.Ping().Err()).NotTo(HaveOccurred())
+	})
+
+	It("should close pipeline without closing the client", func() {
+		pipeline := client.Pipeline()
+		Expect(pipeline.Close()).NotTo(HaveOccurred())
+
+		pipeline.Ping()
+		_, err := pipeline.Exec()
+		Expect(err).To(MatchError("redis: client is closed"))
+
+		Expect(client.Ping().Err()).NotTo(HaveOccurred())
+	})
+
+	It("should close pubsub when client is closed", func() {
+		pubsub := client.Subscribe()
+		Expect(client.Close()).NotTo(HaveOccurred())
+
+		_, err := pubsub.Receive()
+		Expect(err).To(MatchError("redis: client is closed"))
+
+		Expect(pubsub.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should close pipeline when client is closed", func() {
+		pipeline := client.Pipeline()
+		Expect(client.Close()).NotTo(HaveOccurred())
+		Expect(pipeline.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should select DB", func() {
+		db2 := redis.NewClient(&redis.Options{
+			Addr: redisAddr,
+			DB:   2,
+		})
+		Expect(db2.FlushDB().Err()).NotTo(HaveOccurred())
+		Expect(db2.Get("db").Err()).To(Equal(redis.Nil))
+		Expect(db2.Set("db", 2, 0).Err()).NotTo(HaveOccurred())
+
+		n, err := db2.Get("db").Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(2)))
+
+		Expect(client.Get("db").Err()).To(Equal(redis.Nil))
+
+		Expect(db2.FlushDB().Err()).NotTo(HaveOccurred())
+		Expect(db2.Close()).NotTo(HaveOccurred())
+	})
+
+	It("processes custom commands", func() {
+		cmd := redis.NewCmd("PING")
+		client.Process(cmd)
+
+		// Flush buffers.
+		Expect(client.Echo("hello").Err()).NotTo(HaveOccurred())
+
+		Expect(cmd.Err()).NotTo(HaveOccurred())
+		Expect(cmd.Val()).To(Equal("PONG"))
+	})
+
+	It("should retry command on network error", func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+
+		client = redis.NewClient(&redis.Options{
+			Addr:       redisAddr,
+			MaxRetries: 1,
+		})
+
+		// Put bad connection in the pool.
+		cn, _, err := client.Pool().Get()
+		Expect(err).NotTo(HaveOccurred())
+
+		cn.SetNetConn(&badConn{})
+		err = client.Pool().Put(cn)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = client.Ping().Err()
+		Expect(err).NotTo(HaveOccurred())
+	})
+
+	It("should retry with backoff", func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+
+		// use up all the available connections to force a fail
+		connectionHogClient := redis.NewClient(&redis.Options{
+			Addr:       redisAddr,
+			MaxRetries: 1,
+		})
+		defer connectionHogClient.Close()
+
+		for i := 0; i <= 1002; i++ {
+			connectionHogClient.Pool().NewConn()
+		}
+
+		clientNoRetry := redis.NewClient(&redis.Options{
+			Addr:            redisAddr,
+			PoolSize:        1,
+			MaxRetryBackoff: -1,
+		})
+		defer clientNoRetry.Close()
+
+		clientRetry := redis.NewClient(&redis.Options{
+			Addr:            redisAddr,
+			MaxRetries:      5,
+			PoolSize:        1,
+			MaxRetryBackoff: 128 * time.Millisecond,
+		})
+		defer clientRetry.Close()
+
+		startNoRetry := time.Now()
+		err := clientNoRetry.Ping().Err()
+		Expect(err).To(HaveOccurred())
+		elapseNoRetry := time.Since(startNoRetry)
+
+		startRetry := time.Now()
+		err = clientRetry.Ping().Err()
+		Expect(err).To(HaveOccurred())
+		elapseRetry := time.Since(startRetry)
+
+		Expect(elapseRetry > elapseNoRetry).To(BeTrue())
+	})
+
+	It("should update conn.UsedAt on read/write", func() {
+		cn, _, err := client.Pool().Get()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(cn.UsedAt).NotTo(BeZero())
+		createdAt := cn.UsedAt()
+
+		err = client.Pool().Put(cn)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(cn.UsedAt().Equal(createdAt)).To(BeTrue())
+
+		err = client.Ping().Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		cn, _, err = client.Pool().Get()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(cn).NotTo(BeNil())
+		Expect(cn.UsedAt().After(createdAt)).To(BeTrue())
+	})
+
+	It("should process command with special chars", func() {
+		set := client.Set("key", "hello1\r\nhello2\r\n", 0)
+		Expect(set.Err()).NotTo(HaveOccurred())
+		Expect(set.Val()).To(Equal("OK"))
+
+		get := client.Get("key")
+		Expect(get.Err()).NotTo(HaveOccurred())
+		Expect(get.Val()).To(Equal("hello1\r\nhello2\r\n"))
+	})
+
+	It("should handle big vals", func() {
+		bigVal := bytes.Repeat([]byte{'*'}, 2e6)
+
+		err := client.Set("key", bigVal, 0).Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		// Reconnect to get new connection.
+		Expect(client.Close()).NotTo(HaveOccurred())
+		client = redis.NewClient(redisOptions())
+
+		got, err := client.Get("key").Bytes()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(got).To(Equal(bigVal))
+	})
+
+	It("should call WrapProcess", func() {
+		var wrapperFnCalled bool
+
+		client.WrapProcess(func(oldProcess func(redis.Cmder) error) func(redis.Cmder) error {
+			return func(cmd redis.Cmder) error {
+				wrapperFnCalled = true
+				return oldProcess(cmd)
+			}
+		})
+
+		Expect(client.Ping().Err()).NotTo(HaveOccurred())
+
+		Expect(wrapperFnCalled).To(BeTrue())
+	})
+})
+
+var _ = Describe("Client timeout", func() {
+	var opt *redis.Options
+	var client *redis.Client
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	testTimeout := func() {
+		It("Ping timeouts", func() {
+			err := client.Ping().Err()
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+
+		It("Pipeline timeouts", func() {
+			_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
+				pipe.Ping()
+				return nil
+			})
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+
+		It("Subscribe timeouts", func() {
+			if opt.WriteTimeout == 0 {
+				return
+			}
+
+			pubsub := client.Subscribe()
+			defer pubsub.Close()
+
+			err := pubsub.Subscribe("_")
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+
+		It("Tx timeouts", func() {
+			err := client.Watch(func(tx *redis.Tx) error {
+				return tx.Ping().Err()
+			})
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+
+		It("Tx Pipeline timeouts", func() {
+			err := client.Watch(func(tx *redis.Tx) error {
+				_, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+					pipe.Ping()
+					return nil
+				})
+				return err
+			})
+			Expect(err).To(HaveOccurred())
+			Expect(err.(net.Error).Timeout()).To(BeTrue())
+		})
+	}
+
+	Context("read timeout", func() {
+		BeforeEach(func() {
+			opt = redisOptions()
+			opt.ReadTimeout = time.Nanosecond
+			opt.WriteTimeout = -1
+			client = redis.NewClient(opt)
+		})
+
+		testTimeout()
+	})
+
+	Context("write timeout", func() {
+		BeforeEach(func() {
+			opt = redisOptions()
+			opt.ReadTimeout = -1
+			opt.WriteTimeout = time.Nanosecond
+			client = redis.NewClient(opt)
+		})
+
+		testTimeout()
+	})
+})
+
+var _ = Describe("Client OnConnect", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		opt := redisOptions()
+		opt.DB = 0
+		opt.OnConnect = func(cn *redis.Conn) error {
+			return cn.ClientSetName("on_connect").Err()
+		}
+
+		client = redis.NewClient(opt)
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("calls OnConnect", func() {
+		name, err := client.ClientGetName().Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(name).To(Equal("on_connect"))
+	})
+})
diff --git a/result.go b/result.go
new file mode 100644
index 00000000..28cea5ca
--- /dev/null
+++ b/result.go
@@ -0,0 +1,140 @@
+package redis
+
+import "time"
+
+// NewCmdResult returns a Cmd initalised with val and err for testing
+func NewCmdResult(val interface{}, err error) *Cmd {
+	var cmd Cmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewSliceResult returns a SliceCmd initalised with val and err for testing
+func NewSliceResult(val []interface{}, err error) *SliceCmd {
+	var cmd SliceCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewStatusResult returns a StatusCmd initalised with val and err for testing
+func NewStatusResult(val string, err error) *StatusCmd {
+	var cmd StatusCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewIntResult returns an IntCmd initalised with val and err for testing
+func NewIntResult(val int64, err error) *IntCmd {
+	var cmd IntCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewDurationResult returns a DurationCmd initalised with val and err for testing
+func NewDurationResult(val time.Duration, err error) *DurationCmd {
+	var cmd DurationCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewBoolResult returns a BoolCmd initalised with val and err for testing
+func NewBoolResult(val bool, err error) *BoolCmd {
+	var cmd BoolCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewStringResult returns a StringCmd initalised with val and err for testing
+func NewStringResult(val string, err error) *StringCmd {
+	var cmd StringCmd
+	cmd.val = []byte(val)
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewFloatResult returns a FloatCmd initalised with val and err for testing
+func NewFloatResult(val float64, err error) *FloatCmd {
+	var cmd FloatCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewStringSliceResult returns a StringSliceCmd initalised with val and err for testing
+func NewStringSliceResult(val []string, err error) *StringSliceCmd {
+	var cmd StringSliceCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewBoolSliceResult returns a BoolSliceCmd initalised with val and err for testing
+func NewBoolSliceResult(val []bool, err error) *BoolSliceCmd {
+	var cmd BoolSliceCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewStringStringMapResult returns a StringStringMapCmd initalised with val and err for testing
+func NewStringStringMapResult(val map[string]string, err error) *StringStringMapCmd {
+	var cmd StringStringMapCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewStringIntMapCmdResult returns a StringIntMapCmd initalised with val and err for testing
+func NewStringIntMapCmdResult(val map[string]int64, err error) *StringIntMapCmd {
+	var cmd StringIntMapCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewZSliceCmdResult returns a ZSliceCmd initalised with val and err for testing
+func NewZSliceCmdResult(val []Z, err error) *ZSliceCmd {
+	var cmd ZSliceCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewScanCmdResult returns a ScanCmd initalised with val and err for testing
+func NewScanCmdResult(keys []string, cursor uint64, err error) *ScanCmd {
+	var cmd ScanCmd
+	cmd.page = keys
+	cmd.cursor = cursor
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewClusterSlotsCmdResult returns a ClusterSlotsCmd initalised with val and err for testing
+func NewClusterSlotsCmdResult(val []ClusterSlot, err error) *ClusterSlotsCmd {
+	var cmd ClusterSlotsCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewGeoLocationCmdResult returns a GeoLocationCmd initalised with val and err for testing
+func NewGeoLocationCmdResult(val []GeoLocation, err error) *GeoLocationCmd {
+	var cmd GeoLocationCmd
+	cmd.locations = val
+	cmd.setErr(err)
+	return &cmd
+}
+
+// NewCommandsInfoCmdResult returns a CommandsInfoCmd initalised with val and err for testing
+func NewCommandsInfoCmdResult(val map[string]*CommandInfo, err error) *CommandsInfoCmd {
+	var cmd CommandsInfoCmd
+	cmd.val = val
+	cmd.setErr(err)
+	return &cmd
+}
diff --git a/ring.go b/ring.go
new file mode 100644
index 00000000..72d52bf7
--- /dev/null
+++ b/ring.go
@@ -0,0 +1,458 @@
+package redis
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+	"github.com/go-redis/redis/internal/consistenthash"
+	"github.com/go-redis/redis/internal/hashtag"
+	"github.com/go-redis/redis/internal/pool"
+)
+
+var errRingShardsDown = errors.New("redis: all ring shards are down")
+
+// RingOptions are used to configure a ring client and should be
+// passed to NewRing.
+type RingOptions struct {
+	// Map of name => host:port addresses of ring shards.
+	Addrs map[string]string
+
+	// Frequency of PING commands sent to check shards availability.
+	// Shard is considered down after 3 subsequent failed checks.
+	HeartbeatFrequency time.Duration
+
+	// Following options are copied from Options struct.
+
+	OnConnect func(*Conn) error
+
+	DB       int
+	Password string
+
+	MaxRetries int
+
+	DialTimeout  time.Duration
+	ReadTimeout  time.Duration
+	WriteTimeout time.Duration
+
+	PoolSize           int
+	PoolTimeout        time.Duration
+	IdleTimeout        time.Duration
+	IdleCheckFrequency time.Duration
+}
+
+func (opt *RingOptions) init() {
+	if opt.HeartbeatFrequency == 0 {
+		opt.HeartbeatFrequency = 500 * time.Millisecond
+	}
+}
+
+func (opt *RingOptions) clientOptions() *Options {
+	return &Options{
+		OnConnect: opt.OnConnect,
+
+		DB:       opt.DB,
+		Password: opt.Password,
+
+		DialTimeout:  opt.DialTimeout,
+		ReadTimeout:  opt.ReadTimeout,
+		WriteTimeout: opt.WriteTimeout,
+
+		PoolSize:           opt.PoolSize,
+		PoolTimeout:        opt.PoolTimeout,
+		IdleTimeout:        opt.IdleTimeout,
+		IdleCheckFrequency: opt.IdleCheckFrequency,
+	}
+}
+
+type ringShard struct {
+	Client *Client
+	down   int32
+}
+
+func (shard *ringShard) String() string {
+	var state string
+	if shard.IsUp() {
+		state = "up"
+	} else {
+		state = "down"
+	}
+	return fmt.Sprintf("%s is %s", shard.Client, state)
+}
+
+func (shard *ringShard) IsDown() bool {
+	const threshold = 3
+	return atomic.LoadInt32(&shard.down) >= threshold
+}
+
+func (shard *ringShard) IsUp() bool {
+	return !shard.IsDown()
+}
+
+// Vote votes to set shard state and returns true if state was changed.
+func (shard *ringShard) Vote(up bool) bool {
+	if up {
+		changed := shard.IsDown()
+		atomic.StoreInt32(&shard.down, 0)
+		return changed
+	}
+
+	if shard.IsDown() {
+		return false
+	}
+
+	atomic.AddInt32(&shard.down, 1)
+	return shard.IsDown()
+}
+
+// Ring is a Redis client that uses constistent hashing to distribute
+// keys across multiple Redis servers (shards). It's safe for
+// concurrent use by multiple goroutines.
+//
+// Ring monitors the state of each shard and removes dead shards from
+// the ring. When shard comes online it is added back to the ring. This
+// gives you maximum availability and partition tolerance, but no
+// consistency between different shards or even clients. Each client
+// uses shards that are available to the client and does not do any
+// coordination when shard state is changed.
+//
+// Ring should be used when you need multiple Redis servers for caching
+// and can tolerate losing data when one of the servers dies.
+// Otherwise you should use Redis Cluster.
+type Ring struct {
+	cmdable
+
+	opt       *RingOptions
+	nreplicas int
+
+	mu     sync.RWMutex
+	hash   *consistenthash.Map
+	shards map[string]*ringShard
+
+	cmdsInfoOnce internal.Once
+	cmdsInfo     map[string]*CommandInfo
+
+	closed bool
+}
+
+func NewRing(opt *RingOptions) *Ring {
+	const nreplicas = 100
+	opt.init()
+	ring := &Ring{
+		opt:       opt,
+		nreplicas: nreplicas,
+
+		hash:   consistenthash.New(nreplicas, nil),
+		shards: make(map[string]*ringShard),
+	}
+	ring.setProcessor(ring.Process)
+	for name, addr := range opt.Addrs {
+		clopt := opt.clientOptions()
+		clopt.Addr = addr
+		ring.addClient(name, NewClient(clopt))
+	}
+	go ring.heartbeat()
+	return ring
+}
+
+// Options returns read-only Options that were used to create the client.
+func (c *Ring) Options() *RingOptions {
+	return c.opt
+}
+
+// PoolStats returns accumulated connection pool stats.
+func (c *Ring) PoolStats() *PoolStats {
+	var acc PoolStats
+	for _, shard := range c.shards {
+		s := shard.Client.connPool.Stats()
+		acc.Requests += s.Requests
+		acc.Hits += s.Hits
+		acc.Timeouts += s.Timeouts
+		acc.TotalConns += s.TotalConns
+		acc.FreeConns += s.FreeConns
+	}
+	return &acc
+}
+
+// Subscribe subscribes the client to the specified channels.
+func (c *Ring) Subscribe(channels ...string) *PubSub {
+	if len(channels) == 0 {
+		panic("at least one channel is required")
+	}
+
+	shard, err := c.shardByKey(channels[0])
+	if err != nil {
+		// TODO: return PubSub with sticky error
+		panic(err)
+	}
+	return shard.Client.Subscribe(channels...)
+}
+
+// PSubscribe subscribes the client to the given patterns.
+func (c *Ring) PSubscribe(channels ...string) *PubSub {
+	if len(channels) == 0 {
+		panic("at least one channel is required")
+	}
+
+	shard, err := c.shardByKey(channels[0])
+	if err != nil {
+		// TODO: return PubSub with sticky error
+		panic(err)
+	}
+	return shard.Client.PSubscribe(channels...)
+}
+
+// ForEachShard concurrently calls the fn on each live shard in the ring.
+// It returns the first error if any.
+func (c *Ring) ForEachShard(fn func(client *Client) error) error {
+	var wg sync.WaitGroup
+	errCh := make(chan error, 1)
+	for _, shard := range c.shards {
+		if shard.IsDown() {
+			continue
+		}
+
+		wg.Add(1)
+		go func(shard *ringShard) {
+			defer wg.Done()
+			err := fn(shard.Client)
+			if err != nil {
+				select {
+				case errCh <- err:
+				default:
+				}
+			}
+		}(shard)
+	}
+	wg.Wait()
+
+	select {
+	case err := <-errCh:
+		return err
+	default:
+		return nil
+	}
+}
+
+func (c *Ring) cmdInfo(name string) *CommandInfo {
+	err := c.cmdsInfoOnce.Do(func() error {
+		var firstErr error
+		for _, shard := range c.shards {
+			cmdsInfo, err := shard.Client.Command().Result()
+			if err == nil {
+				c.cmdsInfo = cmdsInfo
+				return nil
+			}
+			if firstErr == nil {
+				firstErr = err
+			}
+		}
+		return firstErr
+	})
+	if err != nil {
+		return nil
+	}
+	return c.cmdsInfo[name]
+}
+
+func (c *Ring) addClient(name string, cl *Client) {
+	c.mu.Lock()
+	c.hash.Add(name)
+	c.shards[name] = &ringShard{Client: cl}
+	c.mu.Unlock()
+}
+
+func (c *Ring) shardByKey(key string) (*ringShard, error) {
+	key = hashtag.Key(key)
+
+	c.mu.RLock()
+
+	if c.closed {
+		c.mu.RUnlock()
+		return nil, pool.ErrClosed
+	}
+
+	name := c.hash.Get(key)
+	if name == "" {
+		c.mu.RUnlock()
+		return nil, errRingShardsDown
+	}
+
+	shard := c.shards[name]
+	c.mu.RUnlock()
+	return shard, nil
+}
+
+func (c *Ring) randomShard() (*ringShard, error) {
+	return c.shardByKey(strconv.Itoa(rand.Int()))
+}
+
+func (c *Ring) shardByName(name string) (*ringShard, error) {
+	if name == "" {
+		return c.randomShard()
+	}
+
+	c.mu.RLock()
+	shard := c.shards[name]
+	c.mu.RUnlock()
+	return shard, nil
+}
+
+func (c *Ring) cmdShard(cmd Cmder) (*ringShard, error) {
+	cmdInfo := c.cmdInfo(cmd.Name())
+	firstKey := cmd.arg(cmdFirstKeyPos(cmd, cmdInfo))
+	return c.shardByKey(firstKey)
+}
+
+func (c *Ring) Process(cmd Cmder) error {
+	shard, err := c.cmdShard(cmd)
+	if err != nil {
+		cmd.setErr(err)
+		return err
+	}
+	return shard.Client.Process(cmd)
+}
+
+// rebalance removes dead shards from the Ring.
+func (c *Ring) rebalance() {
+	hash := consistenthash.New(c.nreplicas, nil)
+	for name, shard := range c.shards {
+		if shard.IsUp() {
+			hash.Add(name)
+		}
+	}
+
+	c.mu.Lock()
+	c.hash = hash
+	c.mu.Unlock()
+}
+
+// heartbeat monitors state of each shard in the ring.
+func (c *Ring) heartbeat() {
+	ticker := time.NewTicker(c.opt.HeartbeatFrequency)
+	defer ticker.Stop()
+	for range ticker.C {
+		var rebalance bool
+
+		c.mu.RLock()
+
+		if c.closed {
+			c.mu.RUnlock()
+			break
+		}
+
+		for _, shard := range c.shards {
+			err := shard.Client.Ping().Err()
+			if shard.Vote(err == nil || err == pool.ErrPoolTimeout) {
+				internal.Logf("ring shard state changed: %s", shard)
+				rebalance = true
+			}
+		}
+
+		c.mu.RUnlock()
+
+		if rebalance {
+			c.rebalance()
+		}
+	}
+}
+
+// Close closes the ring client, releasing any open resources.
+//
+// It is rare to Close a Ring, as the Ring is meant to be long-lived
+// and shared between many goroutines.
+func (c *Ring) Close() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.closed {
+		return nil
+	}
+	c.closed = true
+
+	var firstErr error
+	for _, shard := range c.shards {
+		if err := shard.Client.Close(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	c.hash = nil
+	c.shards = nil
+
+	return firstErr
+}
+
+func (c *Ring) Pipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.pipelineExec,
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
+
+func (c *Ring) Pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.Pipeline().pipelined(fn)
+}
+
+func (c *Ring) pipelineExec(cmds []Cmder) (firstErr error) {
+	cmdsMap := make(map[string][]Cmder)
+	for _, cmd := range cmds {
+		cmdInfo := c.cmdInfo(cmd.Name())
+		name := cmd.arg(cmdFirstKeyPos(cmd, cmdInfo))
+		if name != "" {
+			name = c.hash.Get(hashtag.Key(name))
+		}
+		cmdsMap[name] = append(cmdsMap[name], cmd)
+	}
+
+	for i := 0; i <= c.opt.MaxRetries; i++ {
+		var failedCmdsMap map[string][]Cmder
+
+		for name, cmds := range cmdsMap {
+			shard, err := c.shardByName(name)
+			if err != nil {
+				setCmdsErr(cmds, err)
+				if firstErr == nil {
+					firstErr = err
+				}
+				continue
+			}
+
+			cn, _, err := shard.Client.getConn()
+			if err != nil {
+				setCmdsErr(cmds, err)
+				if firstErr == nil {
+					firstErr = err
+				}
+				continue
+			}
+
+			canRetry, err := shard.Client.pipelineProcessCmds(cn, cmds)
+			shard.Client.releaseConn(cn, err)
+			if err == nil {
+				continue
+			}
+			if firstErr == nil {
+				firstErr = err
+			}
+			if canRetry && internal.IsRetryableError(err) {
+				if failedCmdsMap == nil {
+					failedCmdsMap = make(map[string][]Cmder)
+				}
+				failedCmdsMap[name] = cmds
+			}
+		}
+
+		if len(failedCmdsMap) == 0 {
+			break
+		}
+		cmdsMap = failedCmdsMap
+	}
+
+	return firstErr
+}
diff --git a/ring_test.go b/ring_test.go
new file mode 100644
index 00000000..0cad4298
--- /dev/null
+++ b/ring_test.go
@@ -0,0 +1,193 @@
+package redis_test
+
+import (
+	"crypto/rand"
+	"fmt"
+	"time"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Redis Ring", func() {
+	const heartbeat = 100 * time.Millisecond
+
+	var ring *redis.Ring
+
+	setRingKeys := func() {
+		for i := 0; i < 100; i++ {
+			err := ring.Set(fmt.Sprintf("key%d", i), "value", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+		}
+	}
+
+	BeforeEach(func() {
+		opt := redisRingOptions()
+		opt.HeartbeatFrequency = heartbeat
+		ring = redis.NewRing(opt)
+
+		err := ring.ForEachShard(func(cl *redis.Client) error {
+			return cl.FlushDB().Err()
+		})
+		Expect(err).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(ring.Close()).NotTo(HaveOccurred())
+	})
+
+	It("distributes keys", func() {
+		setRingKeys()
+
+		// Both shards should have some keys now.
+		Expect(ringShard1.Info().Val()).To(ContainSubstring("keys=57"))
+		Expect(ringShard2.Info().Val()).To(ContainSubstring("keys=43"))
+	})
+
+	It("distributes keys when using EVAL", func() {
+		script := redis.NewScript(`
+			local r = redis.call('SET', KEYS[1], ARGV[1])
+			return r
+		`)
+
+		var key string
+		for i := 0; i < 100; i++ {
+			key = fmt.Sprintf("key%d", i)
+			err := script.Run(ring, []string{key}, "value").Err()
+			Expect(err).NotTo(HaveOccurred())
+		}
+
+		Expect(ringShard1.Info().Val()).To(ContainSubstring("keys=57"))
+		Expect(ringShard2.Info().Val()).To(ContainSubstring("keys=43"))
+	})
+
+	It("uses single shard when one of the shards is down", func() {
+		// Stop ringShard2.
+		Expect(ringShard2.Close()).NotTo(HaveOccurred())
+
+		// Ring needs 3 * heartbeat time to detect that node is down.
+		// Give it more to be sure.
+		time.Sleep(2 * 3 * heartbeat)
+
+		setRingKeys()
+
+		// RingShard1 should have all keys.
+		Expect(ringShard1.Info().Val()).To(ContainSubstring("keys=100"))
+
+		// Start ringShard2.
+		var err error
+		ringShard2, err = startRedis(ringShard2Port)
+		Expect(err).NotTo(HaveOccurred())
+
+		// Wait for ringShard2 to come up.
+		Eventually(func() error {
+			return ringShard2.Ping().Err()
+		}, "1s").ShouldNot(HaveOccurred())
+
+		// Ring needs heartbeat time to detect that node is up.
+		// Give it more to be sure.
+		time.Sleep(heartbeat + heartbeat)
+
+		setRingKeys()
+
+		// RingShard2 should have its keys.
+		Expect(ringShard2.Info().Val()).To(ContainSubstring("keys=43"))
+	})
+
+	It("supports hash tags", func() {
+		for i := 0; i < 100; i++ {
+			err := ring.Set(fmt.Sprintf("key%d{tag}", i), "value", 0).Err()
+			Expect(err).NotTo(HaveOccurred())
+		}
+
+		Expect(ringShard1.Info().Val()).ToNot(ContainSubstring("keys="))
+		Expect(ringShard2.Info().Val()).To(ContainSubstring("keys=100"))
+	})
+
+	Describe("pipeline", func() {
+		It("distributes keys", func() {
+			pipe := ring.Pipeline()
+			for i := 0; i < 100; i++ {
+				err := pipe.Set(fmt.Sprintf("key%d", i), "value", 0).Err()
+				Expect(err).NotTo(HaveOccurred())
+			}
+			cmds, err := pipe.Exec()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmds).To(HaveLen(100))
+			Expect(pipe.Close()).NotTo(HaveOccurred())
+
+			for _, cmd := range cmds {
+				Expect(cmd.Err()).NotTo(HaveOccurred())
+				Expect(cmd.(*redis.StatusCmd).Val()).To(Equal("OK"))
+			}
+
+			// Both shards should have some keys now.
+			Expect(ringShard1.Info().Val()).To(ContainSubstring("keys=57"))
+			Expect(ringShard2.Info().Val()).To(ContainSubstring("keys=43"))
+		})
+
+		It("is consistent with ring", func() {
+			var keys []string
+			for i := 0; i < 100; i++ {
+				key := make([]byte, 64)
+				_, err := rand.Read(key)
+				Expect(err).NotTo(HaveOccurred())
+				keys = append(keys, string(key))
+			}
+
+			_, err := ring.Pipelined(func(pipe redis.Pipeliner) error {
+				for _, key := range keys {
+					pipe.Set(key, "value", 0).Err()
+				}
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			for _, key := range keys {
+				val, err := ring.Get(key).Result()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(val).To(Equal("value"))
+			}
+		})
+
+		It("supports hash tags", func() {
+			_, err := ring.Pipelined(func(pipe redis.Pipeliner) error {
+				for i := 0; i < 100; i++ {
+					pipe.Set(fmt.Sprintf("key%d{tag}", i), "value", 0).Err()
+				}
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(ringShard1.Info().Val()).ToNot(ContainSubstring("keys="))
+			Expect(ringShard2.Info().Val()).To(ContainSubstring("keys=100"))
+		})
+	})
+})
+
+var _ = Describe("empty Redis Ring", func() {
+	var ring *redis.Ring
+
+	BeforeEach(func() {
+		ring = redis.NewRing(&redis.RingOptions{})
+	})
+
+	AfterEach(func() {
+		Expect(ring.Close()).NotTo(HaveOccurred())
+	})
+
+	It("returns an error", func() {
+		err := ring.Ping().Err()
+		Expect(err).To(MatchError("redis: all ring shards are down"))
+	})
+
+	It("pipeline returns an error", func() {
+		_, err := ring.Pipelined(func(pipe redis.Pipeliner) error {
+			pipe.Ping()
+			return nil
+		})
+		Expect(err).To(MatchError("redis: all ring shards are down"))
+	})
+})
diff --git a/script.go b/script.go
new file mode 100644
index 00000000..74135f5a
--- /dev/null
+++ b/script.go
@@ -0,0 +1,62 @@
+package redis
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+	"io"
+	"strings"
+)
+
+type scripter interface {
+	Eval(script string, keys []string, args ...interface{}) *Cmd
+	EvalSha(sha1 string, keys []string, args ...interface{}) *Cmd
+	ScriptExists(scripts ...string) *BoolSliceCmd
+	ScriptLoad(script string) *StringCmd
+}
+
+var _ scripter = (*Client)(nil)
+var _ scripter = (*Ring)(nil)
+var _ scripter = (*ClusterClient)(nil)
+
+type Script struct {
+	src, hash string
+}
+
+func NewScript(src string) *Script {
+	h := sha1.New()
+	io.WriteString(h, src)
+	return &Script{
+		src:  src,
+		hash: hex.EncodeToString(h.Sum(nil)),
+	}
+}
+
+func (s *Script) Hash() string {
+	return s.hash
+}
+
+func (s *Script) Load(c scripter) *StringCmd {
+	return c.ScriptLoad(s.src)
+}
+
+func (s *Script) Exists(c scripter) *BoolSliceCmd {
+	return c.ScriptExists(s.src)
+}
+
+func (s *Script) Eval(c scripter, keys []string, args ...interface{}) *Cmd {
+	return c.Eval(s.src, keys, args...)
+}
+
+func (s *Script) EvalSha(c scripter, keys []string, args ...interface{}) *Cmd {
+	return c.EvalSha(s.hash, keys, args...)
+}
+
+// Run optimistically uses EVALSHA to run the script. If script does not exist
+// it is retried using EVAL.
+func (s *Script) Run(c scripter, keys []string, args ...interface{}) *Cmd {
+	r := s.EvalSha(c, keys, args...)
+	if err := r.Err(); err != nil && strings.HasPrefix(err.Error(), "NOSCRIPT ") {
+		return s.Eval(c, keys, args...)
+	}
+	return r
+}
diff --git a/sentinel.go b/sentinel.go
new file mode 100644
index 00000000..3bfdb4a3
--- /dev/null
+++ b/sentinel.go
@@ -0,0 +1,335 @@
+package redis
+
+import (
+	"errors"
+	"net"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/go-redis/redis/internal"
+	"github.com/go-redis/redis/internal/pool"
+)
+
+//------------------------------------------------------------------------------
+
+// FailoverOptions are used to configure a failover client and should
+// be passed to NewFailoverClient.
+type FailoverOptions struct {
+	// The master name.
+	MasterName string
+	// A seed list of host:port addresses of sentinel nodes.
+	SentinelAddrs []string
+
+	// Following options are copied from Options struct.
+
+	OnConnect func(*Conn) error
+
+	Password string
+	DB       int
+
+	MaxRetries int
+
+	DialTimeout  time.Duration
+	ReadTimeout  time.Duration
+	WriteTimeout time.Duration
+
+	PoolSize           int
+	PoolTimeout        time.Duration
+	IdleTimeout        time.Duration
+	IdleCheckFrequency time.Duration
+}
+
+func (opt *FailoverOptions) options() *Options {
+	return &Options{
+		Addr: "FailoverClient",
+
+		OnConnect: opt.OnConnect,
+
+		DB:       opt.DB,
+		Password: opt.Password,
+
+		MaxRetries: opt.MaxRetries,
+
+		DialTimeout:  opt.DialTimeout,
+		ReadTimeout:  opt.ReadTimeout,
+		WriteTimeout: opt.WriteTimeout,
+
+		PoolSize:           opt.PoolSize,
+		PoolTimeout:        opt.PoolTimeout,
+		IdleTimeout:        opt.IdleTimeout,
+		IdleCheckFrequency: opt.IdleCheckFrequency,
+	}
+}
+
+// NewFailoverClient returns a Redis client that uses Redis Sentinel
+// for automatic failover. It's safe for concurrent use by multiple
+// goroutines.
+func NewFailoverClient(failoverOpt *FailoverOptions) *Client {
+	opt := failoverOpt.options()
+	opt.init()
+
+	failover := &sentinelFailover{
+		masterName:    failoverOpt.MasterName,
+		sentinelAddrs: failoverOpt.SentinelAddrs,
+
+		opt: opt,
+	}
+
+	client := Client{
+		baseClient: baseClient{
+			opt:      opt,
+			connPool: failover.Pool(),
+
+			onClose: func() error {
+				return failover.Close()
+			},
+		},
+	}
+	client.setProcessor(client.Process)
+
+	return &client
+}
+
+//------------------------------------------------------------------------------
+
+type sentinelClient struct {
+	cmdable
+	baseClient
+}
+
+func newSentinel(opt *Options) *sentinelClient {
+	opt.init()
+	client := sentinelClient{
+		baseClient: baseClient{
+			opt:      opt,
+			connPool: newConnPool(opt),
+		},
+	}
+	client.cmdable = cmdable{client.Process}
+	return &client
+}
+
+func (c *sentinelClient) PubSub() *PubSub {
+	return &PubSub{
+		opt: c.opt,
+
+		newConn: func(channels []string) (*pool.Conn, error) {
+			return c.newConn()
+		},
+		closeConn: c.connPool.CloseConn,
+	}
+}
+
+func (c *sentinelClient) GetMasterAddrByName(name string) *StringSliceCmd {
+	cmd := NewStringSliceCmd("SENTINEL", "get-master-addr-by-name", name)
+	c.Process(cmd)
+	return cmd
+}
+
+func (c *sentinelClient) Sentinels(name string) *SliceCmd {
+	cmd := NewSliceCmd("SENTINEL", "sentinels", name)
+	c.Process(cmd)
+	return cmd
+}
+
+type sentinelFailover struct {
+	sentinelAddrs []string
+
+	opt *Options
+
+	pool     *pool.ConnPool
+	poolOnce sync.Once
+
+	mu          sync.RWMutex
+	masterName  string
+	_masterAddr string
+	sentinel    *sentinelClient
+}
+
+func (d *sentinelFailover) Close() error {
+	return d.resetSentinel()
+}
+
+func (d *sentinelFailover) Pool() *pool.ConnPool {
+	d.poolOnce.Do(func() {
+		d.opt.Dialer = d.dial
+		d.pool = newConnPool(d.opt)
+	})
+	return d.pool
+}
+
+func (d *sentinelFailover) dial() (net.Conn, error) {
+	addr, err := d.MasterAddr()
+	if err != nil {
+		return nil, err
+	}
+	return net.DialTimeout("tcp", addr, d.opt.DialTimeout)
+}
+
+func (d *sentinelFailover) MasterAddr() (string, error) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	addr, err := d.masterAddr()
+	if err != nil {
+		return "", err
+	}
+
+	if d._masterAddr != addr {
+		d.switchMaster(addr)
+	}
+
+	return addr, nil
+}
+
+func (d *sentinelFailover) masterAddr() (string, error) {
+	// Try last working sentinel.
+	if d.sentinel != nil {
+		addr, err := d.sentinel.GetMasterAddrByName(d.masterName).Result()
+		if err == nil {
+			addr := net.JoinHostPort(addr[0], addr[1])
+			internal.Logf("sentinel: master=%q addr=%q", d.masterName, addr)
+			return addr, nil
+		}
+
+		internal.Logf("sentinel: GetMasterAddrByName name=%q failed: %s", d.masterName, err)
+		d._resetSentinel()
+	}
+
+	for i, sentinelAddr := range d.sentinelAddrs {
+		sentinel := newSentinel(&Options{
+			Addr: sentinelAddr,
+
+			DialTimeout:  d.opt.DialTimeout,
+			ReadTimeout:  d.opt.ReadTimeout,
+			WriteTimeout: d.opt.WriteTimeout,
+
+			PoolSize:    d.opt.PoolSize,
+			PoolTimeout: d.opt.PoolTimeout,
+			IdleTimeout: d.opt.IdleTimeout,
+		})
+
+		masterAddr, err := sentinel.GetMasterAddrByName(d.masterName).Result()
+		if err != nil {
+			internal.Logf("sentinel: GetMasterAddrByName master=%q failed: %s", d.masterName, err)
+			sentinel.Close()
+			continue
+		}
+
+		// Push working sentinel to the top.
+		d.sentinelAddrs[0], d.sentinelAddrs[i] = d.sentinelAddrs[i], d.sentinelAddrs[0]
+		d.setSentinel(sentinel)
+
+		addr := net.JoinHostPort(masterAddr[0], masterAddr[1])
+		return addr, nil
+	}
+
+	return "", errors.New("redis: all sentinels are unreachable")
+}
+
+func (d *sentinelFailover) switchMaster(masterAddr string) {
+	internal.Logf(
+		"sentinel: new master=%q addr=%q",
+		d.masterName, masterAddr,
+	)
+	_ = d.Pool().Filter(func(cn *pool.Conn) bool {
+		return cn.RemoteAddr().String() != masterAddr
+	})
+	d._masterAddr = masterAddr
+}
+
+func (d *sentinelFailover) setSentinel(sentinel *sentinelClient) {
+	d.discoverSentinels(sentinel)
+	d.sentinel = sentinel
+	go d.listen(sentinel)
+}
+
+func (d *sentinelFailover) resetSentinel() error {
+	var err error
+	d.mu.Lock()
+	if d.sentinel != nil {
+		err = d._resetSentinel()
+	}
+	d.mu.Unlock()
+	return err
+}
+
+func (d *sentinelFailover) _resetSentinel() error {
+	err := d.sentinel.Close()
+	d.sentinel = nil
+	return err
+}
+
+func (d *sentinelFailover) discoverSentinels(sentinel *sentinelClient) {
+	sentinels, err := sentinel.Sentinels(d.masterName).Result()
+	if err != nil {
+		internal.Logf("sentinel: Sentinels master=%q failed: %s", d.masterName, err)
+		return
+	}
+	for _, sentinel := range sentinels {
+		vals := sentinel.([]interface{})
+		for i := 0; i < len(vals); i += 2 {
+			key := vals[i].(string)
+			if key == "name" {
+				sentinelAddr := vals[i+1].(string)
+				if !contains(d.sentinelAddrs, sentinelAddr) {
+					internal.Logf(
+						"sentinel: discovered new sentinel=%q for master=%q",
+						sentinelAddr, d.masterName,
+					)
+					d.sentinelAddrs = append(d.sentinelAddrs, sentinelAddr)
+				}
+			}
+		}
+	}
+}
+
+func (d *sentinelFailover) listen(sentinel *sentinelClient) {
+	var pubsub *PubSub
+	for {
+		if pubsub == nil {
+			pubsub = sentinel.PubSub()
+
+			if err := pubsub.Subscribe("+switch-master"); err != nil {
+				internal.Logf("sentinel: Subscribe failed: %s", err)
+				pubsub.Close()
+				d.resetSentinel()
+				return
+			}
+		}
+
+		msg, err := pubsub.ReceiveMessage()
+		if err != nil {
+			internal.Logf("sentinel: ReceiveMessage failed: %s", err)
+			pubsub.Close()
+			d.resetSentinel()
+			return
+		}
+
+		switch msg.Channel {
+		case "+switch-master":
+			parts := strings.Split(msg.Payload, " ")
+			if parts[0] != d.masterName {
+				internal.Logf("sentinel: ignore addr for master=%q", parts[0])
+				continue
+			}
+			addr := net.JoinHostPort(parts[3], parts[4])
+
+			d.mu.Lock()
+			if d._masterAddr != addr {
+				d.switchMaster(addr)
+			}
+			d.mu.Unlock()
+		}
+	}
+}
+
+func contains(slice []string, str string) bool {
+	for _, s := range slice {
+		if s == str {
+			return true
+		}
+	}
+	return false
+}
diff --git a/sentinel_test.go b/sentinel_test.go
new file mode 100644
index 00000000..c67713cd
--- /dev/null
+++ b/sentinel_test.go
@@ -0,0 +1,88 @@
+package redis_test
+
+import (
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Sentinel", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewFailoverClient(&redis.FailoverOptions{
+			MasterName:    sentinelName,
+			SentinelAddrs: []string{":" + sentinelPort},
+		})
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should facilitate failover", func() {
+		// Set value on master.
+		err := client.Set("foo", "master", 0).Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		// Verify.
+		val, err := sentinelMaster.Get("foo").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(val).To(Equal("master"))
+
+		// Create subscription.
+		ch := client.Subscribe("foo").Channel()
+
+		// Wait until replicated.
+		Eventually(func() string {
+			return sentinelSlave1.Get("foo").Val()
+		}, "1s", "100ms").Should(Equal("master"))
+		Eventually(func() string {
+			return sentinelSlave2.Get("foo").Val()
+		}, "1s", "100ms").Should(Equal("master"))
+
+		// Wait until slaves are picked up by sentinel.
+		Eventually(func() string {
+			return sentinel.Info().Val()
+		}, "10s", "100ms").Should(ContainSubstring("slaves=2"))
+
+		// Kill master.
+		sentinelMaster.Shutdown()
+		Eventually(func() error {
+			return sentinelMaster.Ping().Err()
+		}, "5s", "100ms").Should(HaveOccurred())
+
+		// Wait for Redis sentinel to elect new master.
+		Eventually(func() string {
+			return sentinelSlave1.Info().Val() + sentinelSlave2.Info().Val()
+		}, "30s", "1s").Should(ContainSubstring("role:master"))
+
+		// Check that client picked up new master.
+		Eventually(func() error {
+			return client.Get("foo").Err()
+		}, "5s", "100ms").ShouldNot(HaveOccurred())
+
+		// Publish message to check if subscription is renewed.
+		err = client.Publish("foo", "hello").Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		var msg *redis.Message
+		Eventually(ch).Should(Receive(&msg))
+		Expect(msg.Channel).To(Equal("foo"))
+		Expect(msg.Payload).To(Equal("hello"))
+	})
+
+	It("supports DB selection", func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+
+		client = redis.NewFailoverClient(&redis.FailoverOptions{
+			MasterName:    sentinelName,
+			SentinelAddrs: []string{":" + sentinelPort},
+			DB:            1,
+		})
+		err := client.Ping().Err()
+		Expect(err).NotTo(HaveOccurred())
+	})
+})
diff --git a/src/all.h b/src/all.h
deleted file mode 100644
index fcd5186f..00000000
--- a/src/all.h
+++ /dev/null
@@ -1,349 +0,0 @@
-#ifndef __ALL_
-#define __ALL_
-
-#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#include <unistd.h>
-#include <sys/epoll.h>
-#include <list>
-#include <map>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <assert.h>
-#include <signal.h>
-#include <string.h>
-#include <errno.h>
-#include <sys/eventfd.h>
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-#include <deque>
-#include <functional>
-#include <algorithm>
-#include <memory>
-#include <condition_variable>
-#include <thread>
-#include <unistd.h>
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <signal.h>
-#include <string>
-#include <linux/tcp.h>
-#include <string.h>
-#include <iosfwd>    // for ostream forward-declaration
-#include <string>
-#include <sys/socket.h>
-#include <unistd.h>
-#include <set>
-#include <arpa/inet.h>
-#include <errno.h>
-#include <sys/uio.h>
-#include <array>
-#include <utility>
-#include <unistd.h>
-#include <limits.h>
-#include <stdint.h>
-#include <sys/stat.h>
-#include <sys/timerfd.h>
-#include<sys/socket.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <atomic>
-#include <stdarg.h>
-#include <sys/resource.h>
-#include <limits.h>
-
-
-#define REDIS_ENCODING_EMBSTR_SIZE_LIMIT 39
-/* Client request types */
-#define REDIS_REQ_INLINE 1
-#define REDIS_REQ_MULTIBULK 2
-/* Error codes */
-#define REDIS_OK                1
-#define REDIS_ERR               0
-#define REDIS_INLINE_MAX_SIZE   (4096*64 *10 * 10) /* Max size of inline reads */
-#define REDIS_LRU_BITS 24
-#define REDIS_MBULK_BIG_ARG     (4096*11 * 10 * 10)
-#define REDIS_STRING 0
-#define REDIS_LIST 1
-#define REDIS_SET 2
-#define REDIS_ZSET 3
-#define REDIS_HASH 4
-
-/* Object types */
-#define OBJ_STRING 0
-#define OBJ_LIST 1
-#define OBJ_SET 2
-#define OBJ_ZSET 3
-#define OBJ_HASH 4
-
-#define OBJ_SET_NO_FLAGS 0
-#define OBJ_SET_NX (1<<0)     /* Set if key not exists. */
-#define OBJ_SET_XX (1<<1)     /* Set if key exists. */
-#define OBJ_SET_EX (1<<2)     /* Set if time in seconds is given */
-#define OBJ_SET_PX (1<<3)     /* Set if time in ms in given */
-
-
-/* Units */
-#define UNIT_SECONDS 0
-#define UNIT_MILLISECONDS 1
-
-
-#define OBJ_ENCODING_RAW 0     /* Raw representation */
-#define OBJ_ENCODING_INT 1     /* Encoded as integer */
-#define OBJ_ENCODING_HT 2      /* Encoded as hash table */
-#define OBJ_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
-#define OBJ_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
-#define OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
-#define OBJ_ENCODING_INTSET 6  /* Encoded as intset */
-#define OBJ_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
-#define OBJ_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
-#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
-
-
-
-/* Static server configuration */
-#define REDIS_DEFAULT_HZ        10      /* Time interrupt calls/sec. */
-#define REDIS_MIN_HZ            1
-#define REDIS_MAX_HZ            500
-#define REDIS_SERVERPORT        6379    /* TCP port */
-#define REDIS_TCP_BACKLOG       511     /* TCP listen backlog */
-#define REDIS_MAXIDLETIME       0       /* default client timeout: infinite */
-#define REDIS_DEFAULT_DBNUM     16
-#define REDIS_CONFIGLINE_MAX    1024
-#define REDIS_DBCRON_DBS_PER_CALL 16
-#define REDIS_MAX_WRITE_PER_EVENT (1024*64)
-#define REDIS_SHARED_SELECT_CMDS 10
-#define REDIS_SHARED_INTEGERS 10000
-#define REDIS_SHARED_BULKHDR_LEN 32
-#define REDIS_MAX_LOGMSG_LEN    1024 /* Default maximum length of syslog messages */
-#define REDIS_AOF_REWRITE_PERC  100
-#define REDIS_AOF_REWRITE_MIN_SIZE (64*1024*1024)
-#define REDIS_AOF_REWRITE_ITEMS_PER_CMD 64
-#define REDIS_SLOWLOG_LOG_SLOWER_THAN 10000
-#define REDIS_SLOWLOG_MAX_LEN 128
-#define REDIS_MAX_CLIENTS 10000
-#define REDIS_AUTHPASS_MAX_LEN 512
-#define REDIS_DEFAULT_SLAVE_PRIORITY 100
-#define REDIS_REPL_TIMEOUT 60
-#define REDIS_REPL_PING_SLAVE_PERIOD 10
-#define REDIS_RUN_ID_SIZE 40
-#define REDIS_OPS_SEC_SAMPLES 16
-#define REDIS_DEFAULT_REPL_BACKLOG_SIZE (1024*1024)    /* 1mb */
-#define REDIS_DEFAULT_REPL_BACKLOG_TIME_LIMIT (60*60)  /* 1 hour */
-#define REDIS_REPL_BACKLOG_MIN_SIZE (1024*16)          /* 16k */
-#define REDIS_BGSAVE_RETRY_DELAY 5 /* Wait a few secs before trying again. */
-#define REDIS_DEFAULT_PID_FILE "/var/run/redis.pid"
-#define REDIS_DEFAULT_SYSLOG_IDENT "redis"
-#define REDIS_DEFAULT_CLUSTER_CONFIG_FILE "nodes.conf"
-#define REDIS_DEFAULT_DAEMONIZE 0
-#define REDIS_DEFAULT_UNIX_SOCKET_PERM 0
-#define REDIS_DEFAULT_TCP_KEEPALIVE 0
-#define REDIS_DEFAULT_LOGFILE ""
-#define REDIS_DEFAULT_SYSLOG_ENABLED 0
-#define REDIS_DEFAULT_STOP_WRITES_ON_BGSAVE_ERROR 1
-#define REDIS_DEFAULT_RDB_COMPRESSION 1
-#define REDIS_DEFAULT_RDB_CHECKSUM 1
-#define REDIS_DEFAULT_RDB_FILENAME "dump.rdb"
-#define REDIS_DEFAULT_SLAVE_SERVE_STALE_DATA 1
-#define REDIS_DEFAULT_SLAVE_READ_ONLY 1
-#define REDIS_DEFAULT_REPL_DISABLE_TCP_NODELAY 0
-#define REDIS_DEFAULT_MAXMEMORY 0
-#define REDIS_DEFAULT_MAXMEMORY_SAMPLES 5
-#define REDIS_DEFAULT_AOF_FILENAME "appendonly.aof"
-#define REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE 0
-#define REDIS_DEFAULT_ACTIVE_REHASHING 1
-#define REDIS_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC 1
-#define REDIS_DEFAULT_MIN_SLAVES_TO_WRITE 0
-#define REDIS_DEFAULT_MIN_SLAVES_MAX_LAG 10
-#define REDIS_IP_STR_LEN INET6_ADDRSTRLEN
-#define REDIS_PEER_ID_LEN (REDIS_IP_STR_LEN+32) /* Must be enough for ip:port */
-#define REDIS_BINDADDR_MAX 16
-#define REDIS_MIN_RESERVED_FDS 32
-#define REDIS_ENCODING_RAW 0     /* Raw representation */
-#define REDIS_ENCODING_INT 1     /* Encoded as integer */
-#define REDIS_ENCODING_HT 2      /* Encoded as hash table */
-#define REDIS_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
-#define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
-#define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
-#define REDIS_ENCODING_INTSET 6  /* Encoded as intset */
-#define REDIS_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
-#define REDIS_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
-
-/* The current RDB version. When the format changes in a way that is no longer
- * backward compatible this number gets incremented. */
-#define REDIS_RDB_VERSION 6
-
-/* Defines related to the dump file format. To store 32 bits lengths for short
- * keys requires a lot of space, so we check the most significant 2 bits of
- * the first byte to interpreter the length:
- *
- * 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte
- * 01|000000 00000000 =>  01, the len is 14 byes, 6 bits + 8 bits of next byte
- * 10|000000 [32 bit integer] => if it's 01, a full 32 bit len will follow
- * 11|000000 this means: specially encoded object will follow. The six bits
- *           number specify the kind of object that follows.
- *           See the REDIS_RDB_ENC_* defines.
- *
- * Lengths up to 63 are stored using a single byte, most DB keys, and may
- * values, will fit inside. */
-#define REDIS_RDB_6BITLEN 0
-#define REDIS_RDB_14BITLEN 1
-#define REDIS_RDB_32BITLEN 2
-#define REDIS_RDB_ENCVAL 3
-#define REDIS_RDB_LENERR UINT_MAX
-
-/* When a length of a string object stored on disk has the first two bits
- * set, the remaining two bits specify a special encoding for the object
- * accordingly to the following defines: */
-#define REDIS_RDB_ENC_INT8 0        /* 8 bit signed integer */
-#define REDIS_RDB_ENC_INT16 1       /* 16 bit signed integer */
-#define REDIS_RDB_ENC_INT32 2       /* 32 bit signed integer */
-#define REDIS_RDB_ENC_LZF 3         /* string compressed with FASTLZ */
-
-/* Dup object types to RDB object types. Only reason is readability (are we
- * dealing with RDB types or with in-memory object types?). */
-#define REDIS_RDB_TYPE_STRING 0
-#define REDIS_RDB_TYPE_LIST   1
-#define REDIS_RDB_TYPE_SET    2
-#define REDIS_RDB_TYPE_ZSET   3
-#define REDIS_RDB_TYPE_HASH   4
-
-/* Object types for encoded objects. */
-#define REDIS_RDB_TYPE_HASH_ZIPMAP    9
-#define REDIS_RDB_TYPE_LIST_ZIPLIST  10
-#define REDIS_RDB_TYPE_SET_INTSET    11
-#define REDIS_RDB_TYPE_ZSET_ZIPLIST  12
-#define REDIS_RDB_TYPE_HASH_ZIPLIST  13
-
-/* Test if a type is an object type. */
-#define rdbIsObjectType(t) ((t >= 0 && t <= 4) || (t >= 9 && t <= 13))
-
-/* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */
-#define REDIS_RDB_OPCODE_SET        250
-#define REDIS_RDB_OPCODE_HSET       251
-
-#define REDIS_RDB_OPCODE_EXPIRETIME_MS 252
-#define REDIS_RDB_OPCODE_EXPIRETIME 253
-#define REDIS_RDB_OPCODE_SELECTDB   254
-#define REDIS_RDB_OPCODE_EOF        255
-
-#define REDIS_RDB_SET 100
-#define REDIS_RDB_HSET 101
-#define REDIS_RDB_SSET 102
-#define REDIS_RDB_SORT_SET 103
-
-/* Protocol and I/O related defines */
-#define PROTO_MAX_QUERYBUF_LEN  (1024*1024*1024) /* 1GB max query buffer. */
-#define PROTO_IOBUF_LEN         (1024*16)  /* Generic I/O buffer size */
-#define PROTO_REPLY_CHUNK_BYTES (16*1024) /* 16k output buffer */
-#define PROTO_INLINE_MAX_SIZE   (1024*64) /* Max size of inline reads */
-#define PROTO_MBULK_BIG_ARG     (1024*32)
-#define LONG_STR_SIZE      21          /* Bytes needed for long -> str + '\0' */
-#define AOF_AUTOSYNC_BYTES (1024*1024*32) /* fdatasync every 32MB */
-
-#define REDIS_REPLY_STRING 1
-#define REDIS_REPLY_ARRAY 2
-#define REDIS_REPLY_INTEGER 3
-#define REDIS_REPLY_NIL 4
-#define REDIS_REPLY_STATUS 5
-#define REDIS_REPLY_ERROR 6
-
-#define REPLI_TIME_OUT	60
-
-/* Connection type can be blocking or non-blocking and is set in the
- * least significant bit of the flags field in redisContext. */
-#define REDIS_BLOCK 0x1
-
-/* Connection may be disconnected before being free'd. The second bit
- * in the flags field is set when the context is connected. */
-#define REDIS_CONNECTED 0x2
-
-/* The async API might try to disconnect cleanly and flush the output
- * buffer and read all subsequent replies before disconnecting.
- * This flag means no new commands can come in and the connection
- * should be terminated once all replies have been read. */
-#define REDIS_DISCONNECTING 0x4
-
-/* Flag specific to the async API which means that the context should be clean
- * up as soon as possible. */
-#define REDIS_FREEING 0x8
-
-/* Flag that is set when an async callback is executed. */
-#define REDIS_IN_CALLBACK 0x10
-
-/* Flag that is set when the async context has one or more subscriptions. */
-#define REDIS_SUBSCRIBED 0x20
-
-/* Flag that is set when monitor mode is active */
-#define REDIS_MONITORING 0x40
-
-
-/* When an error occurs, the err flag in a context is set to hold the type of
- * error that occured. REDIS_ERR_IO means there was an I/O error and you
- * should use the "errno" variable to find out what is wrong.
- * For other values, the "errstr" field will hold a description. */
-#define REDIS_ERR_IO 1 /* Error in read or write */
-#define REDIS_ERR_EOF 3 /* End of file */
-#define REDIS_ERR_PROTOCOL 4 /* Protocol error */
-#define REDIS_ERR_OOM 5 /* Out of memory */
-#define REDIS_ERR_OTHER 2 /* Everything else... */
-
-
-#define REDIS_SLAVE_SYNC_SIZE  65536 
-#define REDIS_RECONNECT_COUNT 10
-
-#define CLUSTER_SLOTS 16384
-#define CLUSTER_OK 0          /* Everything looks ok */
-#define CLUSTER_FAIL 1        /* The cluster can't work */
-#define CLUSTER_NAMELEN 40    /* sha1 hex length */
-#define CLUSTER_PORT_INCR 10000 /* Cluster port = baseport + PORT_INCR */
-
-
- /* Redirection errors returned by getNodeByQuery(). */
-#define CLUSTER_REDIR_NONE 0          /* Node can serve the request. */
-#define CLUSTER_REDIR_CROSS_SLOT 1    /* -CROSSSLOT request. */
-#define CLUSTER_REDIR_UNSTABLE 2      /* -TRYAGAIN redirection required */
-#define CLUSTER_REDIR_ASK 3           /* -ASK redirection required. */
-#define CLUSTER_REDIR_MOVED 4         /* -MOVED redirection required. */
-#define CLUSTER_REDIR_DOWN_STATE 5    /* -CLUSTERDOWN, global state. */
-#define CLUSTER_REDIR_DOWN_UNBOUND 6  /* -CLUSTERDOWN, unbound slot. */
-
-
-#define CLUSTER_SYNC 0
-#define CLUSTER_SYNCING  1
-#define CLUSTER_SYNCED 2
-
-class noncopyable
-{
- protected:
-  noncopyable(){}
- private:
-  noncopyable(const noncopyable&);
-  noncopyable& operator =(const noncopyable&);
-};
-
-
-
-class stringPiepe
-{
- public:
-	stringPiepe(const char* str)
-	: str(str), len(static_cast<int>(strlen(str))) { }
-	stringPiepe(const std::string& str)
-	:str(str.data()), len(static_cast<int>(str.size())) { }
-	stringPiepe(const char* str, size_t len)
-	:str(str),len(len) {}
-	std::string as_string() const { return std::string(str,len);}
-	const char* str;
-	const size_t len;
-};
-
-
-#endif
diff --git a/src/makefile b/src/makefile
deleted file mode 100755
index 923d8d34..00000000
--- a/src/makefile
+++ /dev/null
@@ -1,47 +0,0 @@
-TARGET= ./redis-server
-
-CFLAGS := -Wall -w  -O3  -Wno-unused -Wno-sign-compare -Wno-deprecated-declarations -Wno-deprecated -Wl,--no-as-needed -std=c++11  #-DUSE_JEMALLOC
-cppfiles := $(shell ls *.cpp)
-cfiles := $(-shell ls *.c)
-OBJS := $(patsubst %.cpp,../obj/%.o, $(cppfiles) $(cfiles))
-COBJS=${patsubst %.c,../obj/%.o,$(cfiles)}
-CXXOBJS=${patsubst %.cpp,../obj/%.o,$(cppfiles)}
-
-DEPS=$(patsubst %.o,%.d,$(OBJS))
-
-LIB= # ../libjemalloc.a  #/usr/lib64/libprofiler.so
-
-
-
-SO_LIB= 
-
-
-.PHONY: all clean
-
-all: ${TARGET}
-
-${TARGET}: ${OBJS} ${LIB} 
-	${CXX} -lrt -o $@ $^ ${LDFLAGS}${LIB} ${LIB64}  -lpthread
-
-${CXXOBJS}:../obj/%.o:../src/%.cpp
-	${CXX} -MMD -c -o $@ $< ${CFLAGS} 
-
-${COBJS}:../obj/%.o:../src/%.c
-	${CC} -MMD -c -o $@ $< ${CFLAGS} 
-
--include $(DEPS)
-
-clean:
-	rm -f  *.log *.temp ${OBJS} ${TARGET} ${DEPS}
-
-show:
-	@echo GPROF=$(GPROF)
-	@echo CFLAGS=$(CFLAGS)
-	@echo LDFLAGS=$(LDFLAGS)
-	@echo objs=$(OBJS)
-	@echo cppfiels=$(cppfiles)
-	@echo cfiels=$(cfiles)
-	@echo DEPS=$(DEPS)
-	@echo CXXOBJS=$(CXXOBJS)
-	@echo COBJS=$(COBJS)
-
diff --git a/src/xAcceptor.cpp b/src/xAcceptor.cpp
deleted file mode 100644
index ecaaea1d..00000000
--- a/src/xAcceptor.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "xAcceptor.h"
-
- xAcceptor::xAcceptor(xEventLoop* loop,std::string ip, int16_t port)
- :loop(loop),
-  socket(loop,ip,port),
-  channel(loop,socket.getListenFd()),
-  listenfd(socket.getListenFd()),
-  listenning(false)
- {
-	 channel.setReadCallback(std::bind(&xAcceptor::handleRead,this));
- }
-
- xAcceptor::~xAcceptor()
- {
-	 channel.disableAll();
-	 channel.remove();
-	::close(listenfd);
- }
-
-
-
- void xAcceptor::handleRead()
- {
-	loop->assertInLoopThread();
-
-	struct sockaddr_in client_address;
-	socklen_t client_addrlength = sizeof( client_address );
-
-	int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
-	if (connfd >= 0)
-	{
-		if (newConnectionCallback)
-		{
-			socket.setSocketNonBlock(connfd);
-			newConnectionCallback(connfd);
-		}
-		else
-		{
-		  ::close(connfd);
-		  //TRACE("xAcceptor::handleRead");
-		}
-	}
-	else
-	{
-		int savedErrno = errno;
-		//TRACE("errno %d",errno);
-	}
- }
-
-
-
- void xAcceptor::listen()
- {
-	loop->assertInLoopThread();
-	listenning = true;
-	channel.enableReading();
- }
diff --git a/src/xAcceptor.h b/src/xAcceptor.h
deleted file mode 100644
index bc0d2df1..00000000
--- a/src/xAcceptor.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xChannel.h"
-#include "xEventLoop.h"
-#include "xSocket.h"
-
-class xAcceptor : noncopyable
-{
-public:
-
-	 typedef std::function<void (int sockfd)> NewConnectionCallback;
-
-	 xAcceptor(xEventLoop* loop,std::string ip, int16_t port);
-	 ~xAcceptor();
-
-
-	void setNewConnectionCallback(const NewConnectionCallback& cb){ newConnectionCallback = cb; }
-
-	bool getlistenning() const { return listenning; }
-	void listen();
-
-private:
-	void handleRead();
-
-private:
-	xEventLoop *loop;
-	xSocket    socket;
-	xChannel   channel;
-	int        listenfd;
-
-	NewConnectionCallback newConnectionCallback;
-	bool listenning;
-	bool protocol;
-	void *data;
-
-};
diff --git a/src/xBuffer.cpp b/src/xBuffer.cpp
deleted file mode 100644
index 8b83eb5b..00000000
--- a/src/xBuffer.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-
-#include "xBuffer.h"
-
-
-const char xBuffer::kCRLF[] = "\r\n";
-const char xBuffer::kCRLFCRLF[] = "\r\n\r\n";
-const char xBuffer::CONTENT[] = "Content-Length";
-const size_t xBuffer::kCheapPrepend;
-const size_t xBuffer::kInitialSize;
-
-ssize_t xBuffer::readFd(int fd, int* savedErrno)
-{
-  char extrabuf[65536];
-  struct iovec vec[2];
-  const size_t writable = writableBytes();
-  vec[0].iov_base = begin()+writerIndex;
-  vec[0].iov_len = writable;
-  vec[1].iov_base = extrabuf;
-  vec[1].iov_len = sizeof extrabuf;
-  const int iovcnt = (writable < sizeof extrabuf) ? 2 : 1;
-  const ssize_t n = ::readv(fd, vec, iovcnt);
-  if (n < 0)
-  {
-    *savedErrno = errno;
-  }
-  else if (size_t(n) <= writable)
-  {
-    writerIndex += n;
-  }
-  else
-  {
-    writerIndex = buffer.size();
-    append(extrabuf, n - writable);
-  }
-
-  return n;
-}
-
diff --git a/src/xBuffer.h b/src/xBuffer.h
deleted file mode 100644
index 5ca51396..00000000
--- a/src/xBuffer.h
+++ /dev/null
@@ -1,351 +0,0 @@
-#pragma once
-
-
-#include "all.h"
-using namespace std;
-
-class xBuffer
-{
- public:
-  static const size_t kCheapPrepend = 8;
-  static const size_t kInitialSize = 1024 * 16;
-
-  explicit xBuffer(size_t initialSize = kInitialSize)
-    : buffer(kCheapPrepend + initialSize),
-      readerIndex(kCheapPrepend),
-      writerIndex(kCheapPrepend)
-  {
-    assert(readableBytes() == 0);
-    assert(writableBytes() == initialSize);
-    assert(prependableBytes() == kCheapPrepend);
-  }
-
-  void swap(xBuffer& rhs)
-  {
-    buffer.swap(rhs.buffer);
-    std::swap(readerIndex, rhs.readerIndex);
-    std::swap(writerIndex, rhs.writerIndex);
-  }
-
-  size_t readableBytes() const
-  { return writerIndex - readerIndex; }
-
-  size_t writableBytes() const
-  { return buffer.size() - writerIndex; }
-
-  size_t prependableBytes() const
-  { return readerIndex; }
-
-  const char* peek() const
-  { return begin() + readerIndex; }
-
-  const char* findCRLF() const
-  {
-    const char* crlf = std::search(peek(), beginWrite(), kCRLF, kCRLF+2);
-    return crlf == beginWrite() ? NULL : crlf;
-  }
-
-  const char* findCRLF(const char* start) const
-  {
-    assert(peek() <= start);
-    assert(start <= beginWrite());
-    const char* crlf = std::search(start, beginWrite(), kCRLF, kCRLF+2);
-    return crlf == beginWrite() ? NULL : crlf;
-  }
-
-  const char* findCRLFCRLF() const
-   {
- 	  const char* crlfcrlf = std::search(peek(), beginWrite(), kCRLFCRLF, kCRLFCRLF+4);
- 	  return crlfcrlf == beginWrite() ? NULL : crlfcrlf;
-   }
-
-  const char* findEOL() const
-  {
-    const void* eol = memchr(peek(), '\n', readableBytes());
-    return static_cast<const char*>(eol);
-  }
-
-  const char* findCONTENT()const
-   {
- 	  const char* content = std::search(peek(), beginWrite(), CONTENT, CONTENT+14);
- 	  return content == beginWrite() ? NULL : content;
-   }
-
-
-  const char* findEOL(const char* start) const
-  {
-    assert(peek() <= start);
-    assert(start <= beginWrite());
-    const void* eol = memchr(start, '\n', beginWrite() - start);
-    return static_cast<const char*>(eol);
-  }
-
-  void retrieve(size_t len)
-  {
-    assert(len <= readableBytes());
-    if (len < readableBytes())
-    {
-      readerIndex += len;
-    }
-    else
-    {
-      retrieveAll();
-    }
-  }
-
-  void retrieveUntil(const char* end)
-  {
-    assert(peek() <= end);
-    assert(end <= beginWrite());
-    retrieve(end - peek());
-  }
-
-  void retrieveInt64()
-  {
-    retrieve(sizeof(int64_t));
-  }
-
-  void retrieveInt32()
-  {
-    retrieve(sizeof(int32_t));
-  }
-
-  void retrieveInt16()
-  {
-    retrieve(sizeof(int16_t));
-  }
-
-  void retrieveInt8()
-  {
-    retrieve(sizeof(int8_t));
-  }
-
-  void retrieveAll()
-  {
-    readerIndex = kCheapPrepend;
-    writerIndex = kCheapPrepend;
-  }
-
-  void resize()
-  {
-
-  }
-
-  string retrieveAllAsString()
-  {
-    return retrieveAsString(readableBytes());;
-  }
-
-  string retrieveAsString(size_t len)
-  {
-    assert(len <= readableBytes());
-    string result(peek(), len);
-    retrieve(len);
-    return result;
-  }
-
-
-  void append(const char* /*restrict*/ data, size_t len)
-  {
-    ensureWritableBytes(len);
-    std::copy(data, data+len, beginWrite());
-    hasWritten(len);
-  }
-
-  void append(const stringPiepe & str)
-  {
-	 append(str.str, str.len);
-  }
-
-  void append(const void* /*restrict*/ data, size_t len)
-  {
-    append(static_cast<const char*>(data), len);
-  }
-
-  void ensureWritableBytes(size_t len)
-  {
-    if (writableBytes() < len)
-    {
-      makeSpace(len);
-    }
-    assert(writableBytes() >= len);
-  }
-
-  char* beginWrite()
-  { return begin() + writerIndex; }
-
-  const char* beginWrite() const
-  { return begin() + writerIndex; }
-
-  void hasWritten(size_t len)
-  {
-    assert(len <= writableBytes());
-    writerIndex += len;
-  }
-
-  void unwrite(size_t len)
-  {
-    assert(len <= readableBytes());
-    writerIndex -= len;
-  }
-
-  void appendInt64(int64_t x)
-  {
-    int64_t be64 = htobe64(x);
-    append(&be64, sizeof be64);
-  }
-
-  void appendInt32(int32_t x)
-  {
-    int32_t be32 = htobe32(x);
-    append(&be32, sizeof be32);
-  }
-
-  void appendInt16(int16_t x)
-  {
-    int16_t be16 = htobe16(x);
-    append(&be16, sizeof be16);
-  }
-
-  void appendInt8(int8_t x)
-  {
-    append(&x, sizeof x);
-  }
-
-
-  int64_t readInt64()
-  {
-    int64_t result = peekInt64();
-    retrieveInt64();
-    return result;
-  }
-
-  int32_t readInt32()
-  {
-    int32_t result = peekInt32();
-    retrieveInt32();
-    return result;
-  }
-
-  int16_t readInt16()
-  {
-    int16_t result = peekInt16();
-    retrieveInt16();
-    return result;
-  }
-
-  int8_t readInt8()
-  {
-    int8_t result = peekInt8();
-    retrieveInt8();
-    return result;
-  }
-
-  int64_t peekInt64() const
-  {
-    assert(readableBytes() >= sizeof(int64_t));
-    int64_t be64 = 0;
-    ::memcpy(&be64, peek(), sizeof be64);
-    return be64;
-  }
-
-  int32_t peekInt32() const
-  {
-    assert(readableBytes() >= sizeof(int32_t));
-    int32_t be32 = 0;
-    ::memcpy(&be32, peek(), sizeof be32);
-    return be32;
-  }
-
-  int16_t peekInt16() const
-  {
-    assert(readableBytes() >= sizeof(int16_t));
-    int16_t be16 = 0;
-    ::memcpy(&be16, peek(), sizeof be16);
-    return be16;
-  }
-
-  int8_t peekInt8() const
-  {
-    assert(readableBytes() >= sizeof(int8_t));
-    int8_t x = *peek();
-    return x;
-  }
-
-  void prependInt64(int64_t x)
-  {
-    int64_t be64 = htobe64(x);
-    prepend(&be64, sizeof be64);
-  }
-
-  void prependInt32(int32_t x)
-  {
-    int32_t be32 = htobe32(x);
-    prepend(&be32, sizeof be32);
-  }
-
-  void prependInt16(int16_t x)
-  {
-    int16_t be16 = htobe16(x);
-    prepend(&be16, sizeof be16);
-  }
-
-  void prependInt8(int8_t x)
-  {
-    prepend(&x, sizeof x);
-  }
-
-  void prepend(const void* /*restrict*/ data, size_t len)
-  {
-    assert(len <= prependableBytes());
-    readerIndex -= len;
-    const char* d = static_cast<const char*>(data);
-    std::copy(d, d+len, begin()+readerIndex);
-  }
-
-
-  size_t internalCapacity() const
-  {
-    return buffer.capacity();
-  }
-  ssize_t readFd(int fd, int* savedErrno);
-
- private:
-
-  char* begin()
-  { return &*buffer.begin(); }
-
-  const char* begin() const
-  { return &*buffer.begin(); }
-
-  void makeSpace(size_t len)
-  {
-    if (writableBytes() + prependableBytes() < len + kCheapPrepend)
-    {
-      buffer.resize(writerIndex+len);
-    }
-    else
-    {
-      assert(kCheapPrepend < readerIndex);
-      size_t readable = readableBytes();
-      std::copy(begin()+readerIndex,
-                begin()+writerIndex,
-                begin()+kCheapPrepend);
-      readerIndex = kCheapPrepend;
-      writerIndex = readerIndex + readable;
-      assert(readable == readableBytes());
-    }
-  }
- private:
-	std::vector<char> buffer;
-	size_t readerIndex;
-	size_t writerIndex;
-
-	static const char kCRLF[];
-	static const char kCRLFCRLF[];
-	static const char CONTENT[];
-};
-
-
-
-
diff --git a/src/xCallback.h b/src/xCallback.h
deleted file mode 100644
index e02aeb87..00000000
--- a/src/xCallback.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-#include "all.h"
-
-class xBuffer;
-class xTcpconnection;
-class xConnector;
-class xRedisAsyncContext;
-class xRedisContext;
-class xRedisReader;
-
-typedef std::shared_ptr<xRedisReader> xRedisReaderPtr;
-typedef std::shared_ptr<xRedisContext> xRedisContextPtr;
-typedef std::shared_ptr<xRedisAsyncContext> xRedisAsyncContextPtr;
-
-typedef std::shared_ptr<xTcpconnection> xTcpconnectionPtr;
-typedef std::shared_ptr<xConnector> xConnectorPtr;
-typedef std::function<void(void *)> xTimerCallback;
-typedef std::function<int(void *,void *)> xCmpCallback;
-
-typedef std::function<void (const xTcpconnectionPtr&,void *)> ConnectionCallback;
-typedef std::function<void (void *)> ConnectionErrorCallback;
-typedef std::function<void (const xTcpconnectionPtr&)> CloseCallback;
-typedef std::function<void (const xTcpconnectionPtr&)> WriteCompleteCallback;
-typedef std::function<void (const xTcpconnectionPtr&, size_t)> HighWaterMarkCallback;
-typedef std::function<void (const xTcpconnectionPtr&,xBuffer*,void *)> MessageCallback;
-
-
-
-
-
-
-
-
diff --git a/src/xChannel.cpp b/src/xChannel.cpp
deleted file mode 100644
index 8fe4e74b..00000000
--- a/src/xChannel.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "xChannel.h"
-#include "xEventLoop.h"
-
-const int xChannel::kNoneEvent = 0;
-const int xChannel::kReadEvent = EPOLLIN | EPOLLPRI;
-const int xChannel::kWriteEvent = EPOLLOUT;
-
-
-
-xChannel::xChannel(xEventLoop *loop,int fd)
-:loop(loop),
- fd(fd),
- events(0),
- revents(0),
- index(-1),
- tied(false),
- eventHandling(false),
- addedToLoop(false)
-{
-
-}
-
-xChannel::~xChannel()
-{
-	assert(!eventHandling);
-	assert(!addedToLoop);
-	if (loop->isInLoopThread())
-	{
-		assert(!loop->hasChannel(this));
-	}
-}
-
-
-
-void xChannel::remove()
-{
-	assert(isNoneEvent());
-	addedToLoop = false;
-	loop->removeChannel(this);
-}
-
-
-void xChannel::update()
-{
-	addedToLoop = true;
-	loop->updateChannel(this);
-}
-
-
-
-void xChannel::handleEventWithGuard()
-{
-	eventHandling = true;
-
-	if ((revents & EPOLLHUP) && !(revents & EPOLLIN))
-	{
-		if (closeCallback) closeCallback();
-	}
-
-	if (revents & EPOLLERR)
-	{
-		if (errorCallback) errorCallback();
-	}
-
-	if (revents & (EPOLLIN | EPOLLPRI | EPOLLRDHUP))
-	{
-		if (readCallback) readCallback();
-	}
-
-	if (revents & EPOLLOUT)
-	{
-		if (writeCallback) writeCallback();
-	}
-
-	eventHandling = false;
-}
-
-void xChannel::handleEvent()
-{
-	std::shared_ptr<void> guard;
-	if (tied)
-	{
-		guard = tie.lock();
-		if (guard)
-		{
-		  handleEventWithGuard();
-		}
-	}
-	else
-	{
-		handleEventWithGuard();
-	}
-
-}
-
-void xChannel::setTie(const std::shared_ptr<void>& obj)
-{
-	 tie = obj;
-	 tied = true;
-}
diff --git a/src/xChannel.h b/src/xChannel.h
deleted file mode 100755
index 97ad7947..00000000
--- a/src/xChannel.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include "all.h"
-
-
-class xEventLoop;
-
-class xChannel: noncopyable
-{
-public:
-	typedef std::function<void()> EventCallback;
-	xChannel(xEventLoop *loop,int fd);
-	~xChannel();
-
-	void handleEvent();
-	void setTie(const std::shared_ptr<void>&);
-	void setRevents(int revt) { revents = revt; }
-	void setIndex(int idx) { index = idx; }
-	void setReadCallback(EventCallback&& cb) { readCallback  = std::move(cb); }
-	void setWriteCallback(EventCallback&& cb){ writeCallback = std::move(cb); }
-	void setCloseCallback(EventCallback&& cb){ closeCallback = std::move(cb); }
-	void setErrorCallback(EventCallback&& cb){ errorCallback = std::move(cb); }
-
-	bool isNoneEvent() const { return events == kNoneEvent; }
-	void enableReading() { events |= kReadEvent; update(); }
-	void disableReading() { events &= ~kReadEvent; update(); }
-	void enableWriting() { events |= kWriteEvent; update(); }
-	void disableWriting() { events &= ~kWriteEvent; update(); }
-	void disableAll() { events = kNoneEvent; update(); }
-	bool isWriting() const { return events & kWriteEvent; }
-	bool isReading() const { return events & kReadEvent; }
-
-	int  getEvents() { return events; }
-	int  getfd(){ return fd;}
-	void remove();
-	int  getIndex(){ return index; }
-	xEventLoop *ownerLoop() { return loop; }
-private:
-	void update();
-	void handleEventWithGuard();
-	EventCallback  readCallback;
-	EventCallback  writeCallback;
-	EventCallback  closeCallback;
-	EventCallback  errorCallback;
-
-	static const int kNoneEvent;
-	static const int kReadEvent;
-	static const int kWriteEvent;
-
-	xEventLoop *loop;
-	int fd;
-	int events;
-	int revents;
-	int index;
-	bool tied;
-	bool eventHandling;
-	bool addedToLoop;
-	std::weak_ptr<void> tie;
-
-};
diff --git a/src/xCluster.cpp b/src/xCluster.cpp
deleted file mode 100755
index c4f0a1c0..00000000
--- a/src/xCluster.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-#include "xCluster.h"
-#include "xRedis.h"
-#include "xLog.h"
-#include "xCrc16.h"
-
-xCluster::xCluster()
-{
-
-}
-
-
-xCluster::~xCluster()
-{
-
-}
-
-void xCluster::readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf, void *data)
-{
-	while (recvBuf->readableBytes() > 0)
-	{
-		if (memcmp(recvBuf->peek(), shared.ok->ptr, 3) == 0)
-		{
-			recvBuf->retrieve(5);
-			if (recvBuf->readableBytes() == 0)
-			{
-				std::shared_ptr<xSession> session(new xSession(redis, conn));
-				{
-					MutexLockGuard lk(redis->mutex);
-					redis->sessions[conn->getSockfd()] = session;
-				}
-
-				break;
-			}
-		}
-		else
-		{
-			conn->forceClose();
-			LOG_WARN << "connect cluster read msg error";
-			break;
-		}
-
-	}
-}
-
-
-void xCluster::clusterRedirectClient(xSession * session, xClusterNode * n, int hashSlot, int errCode)
-{
-	if (errCode == CLUSTER_REDIR_CROSS_SLOT) {
-		addReplySds(session->sendBuf, sdsnew("-CROSSSLOT Keys in request don't hash to the same slot\r\n"));
-	}
-	else if (errCode == CLUSTER_REDIR_UNSTABLE) {
-		/* The request spawns mutliple keys in the same slot,
-		* but the slot is not "stable" currently as there is
-		* a migration or import in progress. */
-		addReplySds(session->sendBuf,  sdsnew("-TRYAGAIN Multiple keys request during rehashing of slot\r\n"));
-	}
-	else if (errCode == CLUSTER_REDIR_DOWN_STATE) {
-		addReplySds(session->sendBuf,  sdsnew("-CLUSTERDOWN The cluster is down\r\n"));
-	}
-	else if (errCode == CLUSTER_REDIR_DOWN_UNBOUND) {
-		addReplySds(session->sendBuf, sdsnew("-CLUSTERDOWN Hash slot not served\r\n"));
-	}
-	else if (errCode == CLUSTER_REDIR_MOVED ||
-		errCode == CLUSTER_REDIR_ASK)
-	{
-		addReplySds(session->sendBuf,  sdscatprintf(sdsempty(),
-			"-%s %d %s:%d\r\n",
-			(errCode == CLUSTER_REDIR_ASK) ? "ASK" : "MOVED",
-			hashSlot, n->ip.c_str(), n->port));
-	}
-	else {
-		LOG_WARN << "getNodeByQuery() unknown error.";
-	}
-} 
-
-
-void xCluster::syncClusterSlot(std::deque<rObj*> &robj)
-{
-	for (auto it = redis->clustertcpconnMaps.begin(); it != redis->clustertcpconnMaps.end(); it++)
-	{
-		xBuffer sendBuf;
-		redis->structureRedisProtocol(sendBuf, robj);
-		it->second->send(&sendBuf);
-	}
-
-	for (auto it = robj.begin(); it != robj.end(); it++)
-	{
-		zfree(*it);
-	}
-
-}
-
-unsigned int xCluster::keyHashSlot(char *key, int keylen)
-{
-	int s, e; /* start-end indexes of { and } */
-
-	for (s = 0; s < keylen; s++)
-		if (key[s] == '{') break;
-
-	/* No '{' ? Hash the whole key. This is the base case. */
-	if (s == keylen) return crc16(key, keylen) & 0x3FFF;
-
-	/* '{' found? Check if we have the corresponding '}'. */
-	for (e = s + 1; e < keylen; e++)
-		if (key[e] == '}') break;
-
-	/* No '}' or nothing betweeen {} ? Hash the whole key. */
-	if (e == keylen || e == s + 1) return crc16(key, keylen) & 0x3FFF;
-
-	/* If we are here there is both a { and a } on its right. Hash
-	* what is in the middle between { and }. */
-	return crc16(key + s + 1, e - s - 1) & 0x3FFF;
-}
-
-int xCluster::getSlotOrReply(xSession  * session,rObj * o)
-{
-	long long slot;
-
-	if (getLongLongFromObject(o, &slot) != REDIS_OK ||
-		slot < 0 || slot >= CLUSTER_SLOTS)
-	{
-		addReplyError(session->sendBuf, "Invalid or out of range slot");
-		return  REDIS_ERR;
-	}
-	return (int)slot;
-}
-
-void xCluster::structureProtocolSetCluster(std::string host, int32_t port, xBuffer &sendBuf, std::deque<rObj*> &robj,const xTcpconnectionPtr & conn)
-{
-	rObj * ip = createStringObject(host.c_str(), host.length());
-	char buf[32];
-	int32_t len = ll2string(buf, sizeof(buf), port);
-	rObj * p = createStringObject((const char*)buf, len);
-	robj.push_back(ip);
-	robj.push_back(p);
-	redis->structureRedisProtocol(sendBuf, robj);
-	robj.pop_back();
-	robj.pop_back();
-	zfree(ip);
-	zfree(p);
-	conn->send(&sendBuf);
-	sendBuf.retrieveAll();
-}
-
-
-void xCluster::delClusterImport(std::deque<rObj*> &robj)
-{
-	for (auto it = redis->clustertcpconnMaps.begin(); it != redis->clustertcpconnMaps.end(); it++)
-	{
-		xBuffer sendBuf;
-		redis->structureRedisProtocol(sendBuf, robj);
-		it->second->send(&sendBuf);
-	}
-
-	for (auto it = robj.begin(); it != robj.end(); it++)
-	{
-		zfree(*it);
-	}
-}
-
-
-void xCluster::asyncReplicationToNode(std::string ip,int32_t port)
-{
-	std::unordered_set<int32_t>  uset;
-	int32_t fd = 0;
-	std::string ipPort = ip + "::" + std::to_string(port);
-	{
-		MutexLockGuard lk(redis->clusterMutex);
-		auto it = migratingSlosTos.find(ipPort);
-		if(it == migratingSlosTos.end())
-		{
-			LOG_WARN<<"async slot error";
-			return ;
-		}
-			
-		if(it->second.size() == 0)
-		{
-			LOG_WARN<<"async slot size  error";
-			return ;
-		}
-
-		 uset = it->second;
-
-		 for(auto iter = redis->clustertcpconnMaps.begin(); iter != redis->clustertcpconnMaps.end(); iter++)
-		 {
-		 	if(iter->second->host == ip && iter->second->port == port)
-		 	{
-		 		fd = iter->first;
-				break;
-		 	}
-		 }
-	}
-
-	xBuffer sendBuf;
-	
-	if(fd == 0)
-	{
-		LOG_WARN<<"clustertcpconnMaps error";
-		return ;
-	}
-
-	
-	redis->clusterRepliMigratEnabled = true;
-
-	std::deque<rObj*> deques;
-	for(auto it = redis->setMapShards.begin(); it != redis->setMapShards.end();it++)
-	{
-		{
-			rObj * o = createStringObject("set", 3);
-			MutexLockGuard lock((*it).mutex);
-			for(auto iter = (*it).setMap.begin(); iter !=  (*it).setMap.end(); )
-			{
-				unsigned int slot = keyHashSlot((char*)iter->first->ptr,sdsllen(iter->first->ptr));
-				auto iterr = uset.find(slot);
-				if(iterr != uset.end())
-				{
-					deques.push_back(o);
-					deques.push_back(iter->first);
-					deques.push_back(iter->second);
-					redis->structureRedisProtocol(sendBuf,deques);
-					zfree(iter->first);
-					zfree(iter->second);
-					(*it).setMap.erase(iter++);
-					continue;
-				}
-				
-				iter ++;
-			}
-			zfree(o);
-		}
-
-		{
-			MutexLockGuard lock(redis->clusterMutex);
-			auto iter = redis->clustertcpconnMaps.find(fd);
-			if(iter == redis->clustertcpconnMaps.end())
-			{
-				LOG_WARN<<"cluster disconnect error";
-				return ;
-			}
-			
-			if(sendBuf.readableBytes() > 0)
-			{
-				iter->second->send(&sendBuf);
-				sendBuf.retrieveAll();
-				
-			}
-		
-		}
-	}
-	
-	
-	redis->clusterRepliMigratEnabled = false;
-	
-	{
-
-		MutexLockGuard lock(redis->clusterMutex);	
-		if(redis->clusterMigratCached.readableBytes()> 0 )
-		{
-			
-			auto iter = redis->clustertcpconnMaps.find(fd);
-			if(iter == redis->clustertcpconnMaps.end())
-			{
-				LOG_WARN<<"cluster disconnect error";
-				return ;
-			}
-			
-			iter->second->send(&redis->clusterMigratCached);
-			xBuffer buff;
-			buff.swap(redis->clusterMigratCached);
-		}
-
-		migratingSlosTos.clear();
-
-		for(auto it = uset.begin(); it != uset.end(); it ++)
-		{
-			auto iter = clusterSlotNodes.find(*it);
-			if(iter !=  clusterSlotNodes.end())
-			{
-				iter->second.ip = ip;
-				iter->second.port = port;
-			}
-			std::deque<rObj*> robj;
-			rObj * c = createStringObject("cluster", 7);
-			rObj * s = createStringObject("setslot", 7);
-			robj.push_back(c);
-			robj.push_back(s);
-			char buf[32];
-			int32_t len = ll2string(buf, sizeof(buf), *it);
-			rObj * o = createStringObject((const char*)buf, len);
-			robj.push_back(o);
-			rObj * n = createStringObject("node", 4);
-			robj.push_back(n);
-			rObj * t = createStringObject(ipPort.c_str(),ipPort.length());
-			robj.push_back(t);
-			std::string hp = redis->host +"::" +  std::to_string(redis->port);
-			rObj * h =  createStringObject(hp.c_str(),hp.length());
-			robj.push_back(h);
-			syncClusterSlot(robj);	
-
-		}
-			
-
-	}
-
-	
-
-	LOG_INFO<<"cluster send  success";
-	
-}
-
-
-void xCluster::connCallBack(const xTcpconnectionPtr& conn, void *data)
-{
-	if (conn->connected())
-	{
-		socket.getpeerName(conn->getSockfd(), &(conn->host), conn->port);
-		{
-			xBuffer sendBuf;
-			std::deque<rObj*> robj;
-			rObj * c = createStringObject("cluster", 7);
-			rObj * m = createStringObject("connect", 7);
-			robj.push_back(c);
-			robj.push_back(m);
-
-			MutexLockGuard lk(redis->clusterMutex);
-			for (auto it = redis->clustertcpconnMaps.begin(); it != redis->clustertcpconnMaps.end(); it++)
-			{
-				structureProtocolSetCluster(it->second->host, it->second->port, sendBuf, robj,conn);
-			}
-
-			structureProtocolSetCluster(redis->host, redis->port, sendBuf, robj,conn);
-			for (auto it = robj.begin(); it != robj.end(); it++)
-			{
-				zfree(*it);
-			}
-
-			redis->clustertcpconnMaps.insert(std::make_pair(conn->getSockfd(), conn));
-		}
-
-		std::shared_ptr<xSession> session(new xSession(redis, conn));
-		{
-			MutexLockGuard lk(redis->mutex);
-			redis->sessions[conn->getSockfd()] = session;
-		}
-
-		LOG_INFO << "connect cluster success ";
-
-	}
-	else
-	{
-		{
-			MutexLockGuard lc(redis->clusterMutex);
-			redis->clustertcpconnMaps.erase(conn->getSockfd());
-			for (auto it = tcpvectors.begin(); it != tcpvectors.end(); it++)
-			{
-				if ((*it)->connection->host == conn->host && (*it)->connection->port == conn->port)
-				{
-					tcpvectors.erase(it);
-					break;
-				}
-			}
-			eraseClusterNode(conn->host,conn->port);
-			migratingSlosTos.erase(conn->host + std::to_string(conn->port));
-			importingSlotsFrom.erase(conn->host + std::to_string(conn->port));
-
-		}
-
-		LOG_INFO << "disconnect cluster ";
-	}
-}
-
-
-
-void xCluster::eraseImportSlot(int slot)
-{
-
-}
-
-void xCluster::eraseClusterNode(std::string host,int32_t port)
-{
-	for(auto it = clusterSlotNodes.begin(); it != clusterSlotNodes.end(); )
-	{
-		if(host == it->second.ip && port == it->second.port)
-		{
-			clusterSlotNodes.erase(it++);
-			continue;
-		}
-
-		it ++;
-	}
-
-}
-
-
-void xCluster::connSetCluster(std::string ip, int32_t port,xRedis * redis)
-{
-	this->redis = redis;
-	std::shared_ptr<xTcpClient> client(new xTcpClient(loop, this));
-	client->setConnectionCallback(std::bind(&xCluster::connCallBack, this, std::placeholders::_1, std::placeholders::_2));
-	client->setMessageCallback(std::bind(&xCluster::readCallBack, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
-	client->setConnectionErrorCallBack(std::bind(&xCluster::connErrorCallBack, this));
-	client->connect(ip.c_str(), port);
-	tcpvectors.push_back(client);
-}
-
-void xCluster::connectCluster()
-{
-	xEventLoop loop;
-	this->loop = &loop;
-	loop.run();
-}
-
-void xCluster::reconnectTimer(void * data)
-{
-	LOG_INFO << "Reconnect..........";
-
-}
-
-
-
-void xCluster::connErrorCallBack()
-{
-	return;
-}
-
-void xCluster::init()
-{
-
-}
-
-
-
-
diff --git a/src/xCluster.h b/src/xCluster.h
deleted file mode 100755
index 5b3e1964..00000000
--- a/src/xCluster.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xObject.h"
-#include "xTcpClient.h"
-#include "xSocket.h"
-#include "xSession.h"
-
-
-
-struct xClusterNode
-{
-	std::string ip;
-	int32_t  port;
-};
-
-
-class xRedis;
-class xCluster : noncopyable
-{
-public:
-	xCluster();
-	~xCluster();
-	void init();
-	void connSetCluster(std::string ip, int32_t port, xRedis * redis);
-	void connectCluster();
-	void connErrorCallBack();
-	void readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf, void *data);
-	void connCallBack(const xTcpconnectionPtr& conn, void *data);
-	void reconnectTimer(void * data);
-	void structureProtocolSetCluster(std::string host, int32_t port, xBuffer &sendBuf, std::deque<rObj*> &robjs, const xTcpconnectionPtr & conn);
-	int getSlotOrReply(xSession  * session,rObj * o );
-	unsigned int keyHashSlot(char *key, int keylen);
-	void syncClusterSlot(std::deque<rObj*> &robj);
-	void clusterRedirectClient(xSession * session, xClusterNode * node,int hashSlot,int errCode);
-	void asyncReplicationToNode(std::string ip,int32_t port);
-	void delClusterImport(std::deque<rObj*> &robj);
-	void eraseClusterNode(std::string host,int32_t port);
-	void eraseImportSlot(int slot);
-
-public:
-	xEventLoop *loop;
-	xRedis *redis;
-	xSocket socket;
-	std::vector<std::shared_ptr<xTcpClient>> tcpvectors;	
-	std::map<int32_t, xClusterNode> clusterSlotNodes;
-	std::unordered_map<std::string, std::unordered_set<int32_t>> migratingSlosTos;
-	std::unordered_map<std::string, std::unordered_set<int32_t>> importingSlotsFrom;
-
-};
diff --git a/src/xConnector.cpp b/src/xConnector.cpp
deleted file mode 100644
index b922d612..00000000
--- a/src/xConnector.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "xConnector.h"
-
-xConnector::xConnector(xEventLoop *loop)
- :loop(loop),
-  state(kDisconnected),
-  isconnect(false)
-{
-
-}
-
-
-xConnector::~xConnector()
-{
-
-}
-
-
-void xConnector::start(const char *ip, int16_t port)
-{
-	isconnect = true;
-	loop->runInLoop(std::bind(&xConnector::startInLoop, this,ip,port));
-}
-
-
-
-void xConnector::startInLoop(const char *ip, int16_t port)
-{
-	loop->assertInLoopThread();
-	if (isconnect)
-	{
-		connect(ip,port);
-	}
-	else
-	{
-		LOG_WARN<<"do not connect";
-	}
-}
-
-void xConnector::stop()
-{
-  isconnect= false;
-  loop->queueInLoop(std::bind(&xConnector::stopInLoop, this));
-}
-
-void xConnector::stopInLoop()
-{
-	loop->assertInLoopThread();
-	if (state == kConnecting)
-	{
-		setState(kDisconnected);
-		int sockfd = removeAndResetChannel();
-
-	}
-}
-
-int  xConnector::removeAndResetChannel()
-{
-	return -1;
-}
-
-void xConnector::connecting(int sockfd)
-{
-	if(state == kConnecting)
-	{
-		newConnectionCallback(sockfd);
-	}
-	else
-	{
-		//TRACE("connect error\n");
-	}
-}
-
-
-void xConnector::connect(const char *ip, int16_t port)
-{
-  int sockfd = socket.createNonBloackSocket();
-  int ret = socket.connect(sockfd, ip,port);
-  int savedErrno = (ret == 0) ? 0 : errno;
-  switch (savedErrno)
-  {
-    case 0:
-    case EINPROGRESS:
-    case EINTR:
-    case EISCONN:
-      setState(kConnecting);
-      connecting(sockfd);
-      socket.setSocketNonBlock(sockfd);
-	  socket.setkeepAlive(sockfd,3);
-      break;
-    default:
-//
-//    case EAGAIN:
-//    case EADDRINUSE:
-//    case EADDRNOTAVAIL:
-//    case ECONNREFUSED:
-//    case ENETUNREACH:
-//    case EACCES:
-//    case EPERM:
-//    case EAFNOSUPPORT:
-//    case EALREADY:
-//    case EBADF:
-//    case EFAULT:
-//    case ENOTSOCK:
-      LOG_WARN<<"Connect savedErrno "<<savedErrno;
-      ::close(sockfd);
-      setState(kDisconnected);
-      errorConnectionCallback();
-      break;
-  }
-}
diff --git a/src/xConnector.h b/src/xConnector.h
deleted file mode 100644
index 54e9a269..00000000
--- a/src/xConnector.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xEventLoop.h"
-#include "xChannel.h"
-#include "xSocket.h"
-#include "xLog.h"
-
-class xConnector
-{
-public:
-  typedef std::function<void (int sockfd)> NewConnectionCallback;
-  typedef std::function<void()> ErrorConnectionCallback;
-
-  xConnector(xEventLoop* loop);
-  ~xConnector();
-
-  void setNewConnectionCallback(const NewConnectionCallback& cb)
-  {
-	  newConnectionCallback = cb;
-  }
-
-  void setConnectionErrorCallBack(const ErrorConnectionCallback & cb)
-  {
-	  errorConnectionCallback = cb;
-  }
-
-  void start(const char *ip, int16_t port);
-  void restart();
-  void stop();
-
-  void startInLoop(const char *ip, int16_t port);
-  void stopInLoop();
-  void connect(const char *ip, int16_t port);
-  void connecting(int sockfd);
-  void resetChannel();
-  int  removeAndResetChannel();
-
-
-
-private:
- enum States { kDisconnected, kConnecting, kConnected };
-public:
-  void setState(States  s) { state = s; }
-  xEventLoop* loop;
-  std::string ip;
-  int port;
-
-  States state;
-  std::unique_ptr<xChannel> channel;
-  bool isconnect;
-  ErrorConnectionCallback	errorConnectionCallback;
-  NewConnectionCallback newConnectionCallback;
-  xSocket    socket;
-};
diff --git a/src/xCrc16.h b/src/xCrc16.h
deleted file mode 100644
index df957ae4..00000000
--- a/src/xCrc16.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#pragma once
-#include "all.h"
-
-/*
- * Copyright 2001-2010 Georges Menie (www.menie.org)
- * Copyright 2010-2012 Salvatore Sanfilippo (adapted to Redis coding style)
- * All rights reserved.
- *
- * 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.
- *     * Neither the name of the University of California, Berkeley nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS AND 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.
- */
-
-/* CRC16 implementation according to CCITT standards.
- *
- * Note by @antirez: this is actually the XMODEM CRC 16 algorithm, using the
- * following parameters:
- *
- * Name                       : "XMODEM", also known as "ZMODEM", "CRC-16/ACORN"
- * Width                      : 16 bit
- * Poly                       : 1021 (That is actually x^16 + x^12 + x^5 + 1)
- * Initialization             : 0000
- * Reflect Input byte         : False
- * Reflect Output CRC         : False
- * Xor constant to output CRC : 0000
- * Output for "123456789"     : 31C3
- */
-
-static const uint16_t crc16tab[256]= {
-    0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
-    0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
-    0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
-    0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
-    0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
-    0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
-    0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
-    0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
-    0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
-    0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
-    0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
-    0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
-    0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
-    0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
-    0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
-    0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
-    0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
-    0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
-    0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
-    0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
-    0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
-    0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
-    0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
-    0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
-    0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
-    0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
-    0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
-    0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
-    0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
-    0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
-    0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
-    0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
-};
-
-uint16_t crc16(const char *buf, int len) {
-    int counter;
-    uint16_t crc = 0;
-    for (counter = 0; counter < len; counter++)
-            crc = (crc<<8) ^ crc16tab[((crc>>8) ^ *buf++)&0x00FF];
-    return crc;
-}
diff --git a/src/xCrc64.cpp b/src/xCrc64.cpp
deleted file mode 100644
index 72f3c8a8..00000000
--- a/src/xCrc64.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-/* Redis uses the CRC64 variant with "Jones" coefficients and init value of 0.
- *
- * Specification of this CRC64 variant follows:
- * Name: crc-64-jones
- * Width: 64 bites
- * Poly: 0xad93d23594c935a9
- * Reflected In: True
- * Xor_In: 0xffffffffffffffff
- * Reflected_Out: True
- * Xor_Out: 0x0
- * Check("123456789"): 0xe9c6d914c4b8d9ca
- *
- * Copyright (c) 2012, Salvatore Sanfilippo <antirez at gmail dot com>
- * All rights reserved.
- *
- * 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.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * 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 OWNER 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. */
-#include "xCrc64.h"
-static const uint64_t crc64_tab[256] = {
-    UINT64_C(0x0000000000000000), UINT64_C(0x7ad870c830358979),
-    UINT64_C(0xf5b0e190606b12f2), UINT64_C(0x8f689158505e9b8b),
-    UINT64_C(0xc038e5739841b68f), UINT64_C(0xbae095bba8743ff6),
-    UINT64_C(0x358804e3f82aa47d), UINT64_C(0x4f50742bc81f2d04),
-    UINT64_C(0xab28ecb46814fe75), UINT64_C(0xd1f09c7c5821770c),
-    UINT64_C(0x5e980d24087fec87), UINT64_C(0x24407dec384a65fe),
-    UINT64_C(0x6b1009c7f05548fa), UINT64_C(0x11c8790fc060c183),
-    UINT64_C(0x9ea0e857903e5a08), UINT64_C(0xe478989fa00bd371),
-    UINT64_C(0x7d08ff3b88be6f81), UINT64_C(0x07d08ff3b88be6f8),
-    UINT64_C(0x88b81eabe8d57d73), UINT64_C(0xf2606e63d8e0f40a),
-    UINT64_C(0xbd301a4810ffd90e), UINT64_C(0xc7e86a8020ca5077),
-    UINT64_C(0x4880fbd87094cbfc), UINT64_C(0x32588b1040a14285),
-    UINT64_C(0xd620138fe0aa91f4), UINT64_C(0xacf86347d09f188d),
-    UINT64_C(0x2390f21f80c18306), UINT64_C(0x594882d7b0f40a7f),
-    UINT64_C(0x1618f6fc78eb277b), UINT64_C(0x6cc0863448deae02),
-    UINT64_C(0xe3a8176c18803589), UINT64_C(0x997067a428b5bcf0),
-    UINT64_C(0xfa11fe77117cdf02), UINT64_C(0x80c98ebf2149567b),
-    UINT64_C(0x0fa11fe77117cdf0), UINT64_C(0x75796f2f41224489),
-    UINT64_C(0x3a291b04893d698d), UINT64_C(0x40f16bccb908e0f4),
-    UINT64_C(0xcf99fa94e9567b7f), UINT64_C(0xb5418a5cd963f206),
-    UINT64_C(0x513912c379682177), UINT64_C(0x2be1620b495da80e),
-    UINT64_C(0xa489f35319033385), UINT64_C(0xde51839b2936bafc),
-    UINT64_C(0x9101f7b0e12997f8), UINT64_C(0xebd98778d11c1e81),
-    UINT64_C(0x64b116208142850a), UINT64_C(0x1e6966e8b1770c73),
-    UINT64_C(0x8719014c99c2b083), UINT64_C(0xfdc17184a9f739fa),
-    UINT64_C(0x72a9e0dcf9a9a271), UINT64_C(0x08719014c99c2b08),
-    UINT64_C(0x4721e43f0183060c), UINT64_C(0x3df994f731b68f75),
-    UINT64_C(0xb29105af61e814fe), UINT64_C(0xc849756751dd9d87),
-    UINT64_C(0x2c31edf8f1d64ef6), UINT64_C(0x56e99d30c1e3c78f),
-    UINT64_C(0xd9810c6891bd5c04), UINT64_C(0xa3597ca0a188d57d),
-    UINT64_C(0xec09088b6997f879), UINT64_C(0x96d1784359a27100),
-    UINT64_C(0x19b9e91b09fcea8b), UINT64_C(0x636199d339c963f2),
-    UINT64_C(0xdf7adabd7a6e2d6f), UINT64_C(0xa5a2aa754a5ba416),
-    UINT64_C(0x2aca3b2d1a053f9d), UINT64_C(0x50124be52a30b6e4),
-    UINT64_C(0x1f423fcee22f9be0), UINT64_C(0x659a4f06d21a1299),
-    UINT64_C(0xeaf2de5e82448912), UINT64_C(0x902aae96b271006b),
-    UINT64_C(0x74523609127ad31a), UINT64_C(0x0e8a46c1224f5a63),
-    UINT64_C(0x81e2d7997211c1e8), UINT64_C(0xfb3aa75142244891),
-    UINT64_C(0xb46ad37a8a3b6595), UINT64_C(0xceb2a3b2ba0eecec),
-    UINT64_C(0x41da32eaea507767), UINT64_C(0x3b024222da65fe1e),
-    UINT64_C(0xa2722586f2d042ee), UINT64_C(0xd8aa554ec2e5cb97),
-    UINT64_C(0x57c2c41692bb501c), UINT64_C(0x2d1ab4dea28ed965),
-    UINT64_C(0x624ac0f56a91f461), UINT64_C(0x1892b03d5aa47d18),
-    UINT64_C(0x97fa21650afae693), UINT64_C(0xed2251ad3acf6fea),
-    UINT64_C(0x095ac9329ac4bc9b), UINT64_C(0x7382b9faaaf135e2),
-    UINT64_C(0xfcea28a2faafae69), UINT64_C(0x8632586aca9a2710),
-    UINT64_C(0xc9622c4102850a14), UINT64_C(0xb3ba5c8932b0836d),
-    UINT64_C(0x3cd2cdd162ee18e6), UINT64_C(0x460abd1952db919f),
-    UINT64_C(0x256b24ca6b12f26d), UINT64_C(0x5fb354025b277b14),
-    UINT64_C(0xd0dbc55a0b79e09f), UINT64_C(0xaa03b5923b4c69e6),
-    UINT64_C(0xe553c1b9f35344e2), UINT64_C(0x9f8bb171c366cd9b),
-    UINT64_C(0x10e3202993385610), UINT64_C(0x6a3b50e1a30ddf69),
-    UINT64_C(0x8e43c87e03060c18), UINT64_C(0xf49bb8b633338561),
-    UINT64_C(0x7bf329ee636d1eea), UINT64_C(0x012b592653589793),
-    UINT64_C(0x4e7b2d0d9b47ba97), UINT64_C(0x34a35dc5ab7233ee),
-    UINT64_C(0xbbcbcc9dfb2ca865), UINT64_C(0xc113bc55cb19211c),
-    UINT64_C(0x5863dbf1e3ac9dec), UINT64_C(0x22bbab39d3991495),
-    UINT64_C(0xadd33a6183c78f1e), UINT64_C(0xd70b4aa9b3f20667),
-    UINT64_C(0x985b3e827bed2b63), UINT64_C(0xe2834e4a4bd8a21a),
-    UINT64_C(0x6debdf121b863991), UINT64_C(0x1733afda2bb3b0e8),
-    UINT64_C(0xf34b37458bb86399), UINT64_C(0x8993478dbb8deae0),
-    UINT64_C(0x06fbd6d5ebd3716b), UINT64_C(0x7c23a61ddbe6f812),
-    UINT64_C(0x3373d23613f9d516), UINT64_C(0x49aba2fe23cc5c6f),
-    UINT64_C(0xc6c333a67392c7e4), UINT64_C(0xbc1b436e43a74e9d),
-    UINT64_C(0x95ac9329ac4bc9b5), UINT64_C(0xef74e3e19c7e40cc),
-    UINT64_C(0x601c72b9cc20db47), UINT64_C(0x1ac40271fc15523e),
-    UINT64_C(0x5594765a340a7f3a), UINT64_C(0x2f4c0692043ff643),
-    UINT64_C(0xa02497ca54616dc8), UINT64_C(0xdafce7026454e4b1),
-    UINT64_C(0x3e847f9dc45f37c0), UINT64_C(0x445c0f55f46abeb9),
-    UINT64_C(0xcb349e0da4342532), UINT64_C(0xb1eceec59401ac4b),
-    UINT64_C(0xfebc9aee5c1e814f), UINT64_C(0x8464ea266c2b0836),
-    UINT64_C(0x0b0c7b7e3c7593bd), UINT64_C(0x71d40bb60c401ac4),
-    UINT64_C(0xe8a46c1224f5a634), UINT64_C(0x927c1cda14c02f4d),
-    UINT64_C(0x1d148d82449eb4c6), UINT64_C(0x67ccfd4a74ab3dbf),
-    UINT64_C(0x289c8961bcb410bb), UINT64_C(0x5244f9a98c8199c2),
-    UINT64_C(0xdd2c68f1dcdf0249), UINT64_C(0xa7f41839ecea8b30),
-    UINT64_C(0x438c80a64ce15841), UINT64_C(0x3954f06e7cd4d138),
-    UINT64_C(0xb63c61362c8a4ab3), UINT64_C(0xcce411fe1cbfc3ca),
-    UINT64_C(0x83b465d5d4a0eece), UINT64_C(0xf96c151de49567b7),
-    UINT64_C(0x76048445b4cbfc3c), UINT64_C(0x0cdcf48d84fe7545),
-    UINT64_C(0x6fbd6d5ebd3716b7), UINT64_C(0x15651d968d029fce),
-    UINT64_C(0x9a0d8ccedd5c0445), UINT64_C(0xe0d5fc06ed698d3c),
-    UINT64_C(0xaf85882d2576a038), UINT64_C(0xd55df8e515432941),
-    UINT64_C(0x5a3569bd451db2ca), UINT64_C(0x20ed197575283bb3),
-    UINT64_C(0xc49581ead523e8c2), UINT64_C(0xbe4df122e51661bb),
-    UINT64_C(0x3125607ab548fa30), UINT64_C(0x4bfd10b2857d7349),
-    UINT64_C(0x04ad64994d625e4d), UINT64_C(0x7e7514517d57d734),
-    UINT64_C(0xf11d85092d094cbf), UINT64_C(0x8bc5f5c11d3cc5c6),
-    UINT64_C(0x12b5926535897936), UINT64_C(0x686de2ad05bcf04f),
-    UINT64_C(0xe70573f555e26bc4), UINT64_C(0x9ddd033d65d7e2bd),
-    UINT64_C(0xd28d7716adc8cfb9), UINT64_C(0xa85507de9dfd46c0),
-    UINT64_C(0x273d9686cda3dd4b), UINT64_C(0x5de5e64efd965432),
-    UINT64_C(0xb99d7ed15d9d8743), UINT64_C(0xc3450e196da80e3a),
-    UINT64_C(0x4c2d9f413df695b1), UINT64_C(0x36f5ef890dc31cc8),
-    UINT64_C(0x79a59ba2c5dc31cc), UINT64_C(0x037deb6af5e9b8b5),
-    UINT64_C(0x8c157a32a5b7233e), UINT64_C(0xf6cd0afa9582aa47),
-    UINT64_C(0x4ad64994d625e4da), UINT64_C(0x300e395ce6106da3),
-    UINT64_C(0xbf66a804b64ef628), UINT64_C(0xc5bed8cc867b7f51),
-    UINT64_C(0x8aeeace74e645255), UINT64_C(0xf036dc2f7e51db2c),
-    UINT64_C(0x7f5e4d772e0f40a7), UINT64_C(0x05863dbf1e3ac9de),
-    UINT64_C(0xe1fea520be311aaf), UINT64_C(0x9b26d5e88e0493d6),
-    UINT64_C(0x144e44b0de5a085d), UINT64_C(0x6e963478ee6f8124),
-    UINT64_C(0x21c640532670ac20), UINT64_C(0x5b1e309b16452559),
-    UINT64_C(0xd476a1c3461bbed2), UINT64_C(0xaeaed10b762e37ab),
-    UINT64_C(0x37deb6af5e9b8b5b), UINT64_C(0x4d06c6676eae0222),
-    UINT64_C(0xc26e573f3ef099a9), UINT64_C(0xb8b627f70ec510d0),
-    UINT64_C(0xf7e653dcc6da3dd4), UINT64_C(0x8d3e2314f6efb4ad),
-    UINT64_C(0x0256b24ca6b12f26), UINT64_C(0x788ec2849684a65f),
-    UINT64_C(0x9cf65a1b368f752e), UINT64_C(0xe62e2ad306bafc57),
-    UINT64_C(0x6946bb8b56e467dc), UINT64_C(0x139ecb4366d1eea5),
-    UINT64_C(0x5ccebf68aecec3a1), UINT64_C(0x2616cfa09efb4ad8),
-    UINT64_C(0xa97e5ef8cea5d153), UINT64_C(0xd3a62e30fe90582a),
-    UINT64_C(0xb0c7b7e3c7593bd8), UINT64_C(0xca1fc72bf76cb2a1),
-    UINT64_C(0x45775673a732292a), UINT64_C(0x3faf26bb9707a053),
-    UINT64_C(0x70ff52905f188d57), UINT64_C(0x0a2722586f2d042e),
-    UINT64_C(0x854fb3003f739fa5), UINT64_C(0xff97c3c80f4616dc),
-    UINT64_C(0x1bef5b57af4dc5ad), UINT64_C(0x61372b9f9f784cd4),
-    UINT64_C(0xee5fbac7cf26d75f), UINT64_C(0x9487ca0fff135e26),
-    UINT64_C(0xdbd7be24370c7322), UINT64_C(0xa10fceec0739fa5b),
-    UINT64_C(0x2e675fb4576761d0), UINT64_C(0x54bf2f7c6752e8a9),
-    UINT64_C(0xcdcf48d84fe75459), UINT64_C(0xb71738107fd2dd20),
-    UINT64_C(0x387fa9482f8c46ab), UINT64_C(0x42a7d9801fb9cfd2),
-    UINT64_C(0x0df7adabd7a6e2d6), UINT64_C(0x772fdd63e7936baf),
-    UINT64_C(0xf8474c3bb7cdf024), UINT64_C(0x829f3cf387f8795d),
-    UINT64_C(0x66e7a46c27f3aa2c), UINT64_C(0x1c3fd4a417c62355),
-    UINT64_C(0x935745fc4798b8de), UINT64_C(0xe98f353477ad31a7),
-    UINT64_C(0xa6df411fbfb21ca3), UINT64_C(0xdc0731d78f8795da),
-    UINT64_C(0x536fa08fdfd90e51), UINT64_C(0x29b7d047efec8728),
-};
-
-uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l) {
-    uint64_t j;
-
-    for (j = 0; j < l; j++) {
-        uint8_t byte = s[j];
-        crc = crc64_tab[(uint8_t)crc ^ byte] ^ (crc >> 8);
-    }
-    return crc;
-}
-
-/* Test main */
-#ifdef TEST_MAIN
-#include <stdio.h>
-int main(void) {
-    printf("e9c6d914c4b8d9ca == %016llx\n",
-        (unsigned long long) crc64(0,(unsigned char*)"123456789",9));
-    return 0;
-}
-#endif
diff --git a/src/xCrc64.h b/src/xCrc64.h
deleted file mode 100644
index 4d686132..00000000
--- a/src/xCrc64.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-#include "all.h"
-uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l);
-
diff --git a/src/xCurrentThread.h b/src/xCurrentThread.h
deleted file mode 100644
index f231c672..00000000
--- a/src/xCurrentThread.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "all.h"
-
-
-namespace   xCurrentThread
-{
-	extern __thread int t_cachedTid;
-
-	void cacheTid();
-
-	inline int tid()
-	{
-		if (__builtin_expect(t_cachedTid == 0, 0))
-		{
-		  cacheTid();
-		}
-		return t_cachedTid;
-	}
-}
diff --git a/src/xEpoll.cpp b/src/xEpoll.cpp
deleted file mode 100644
index 3144bc29..00000000
--- a/src/xEpoll.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-#include "xEpoll.h"
-#include "xChannel.h"
-
-#include "xEventLoop.h"
-
-const int kNew = -1;
-const int kAdded = 1;
-const int kDeleted = 2;
-
-
-xEpoll::xEpoll(xEventLoop * loop)
-:events(50000),
-loop(loop),
-maxFd(0),
-epollFd(-1)
-{
-	init(-1);
-}
-
-xEpoll::~xEpoll()
-{
-	 ::close(epollFd);
-}
-
-bool xEpoll::init(int fdCount)
-{
-    maxFd = fdCount;
-    epollFd = epoll_create(100000);
-
-    if (epollFd < 0)
-    {
-        //TRACE("create epollFd Failed! <epollFd:%d>! error:%s", epollFd, strerror(errno));
-        return false;
-    }
-
-    return true;
-}
-
-void  xEpoll::epollWait(ChannelList* activeChannels,int msTime)
-{
-	int numEvents = epoll_wait(epollFd, &*events.begin(), static_cast<int>(events.size()), msTime);
-	int savedErrno = errno;
-
-	if (numEvents > 0)
-	{
-		fillActiveChannels(numEvents, activeChannels);
-		if (numEvents == events.size())
-		{
-		  events.resize(events.size()*2);
-		}
-	}
-	else if (numEvents == 0)
-	{
-
-	}
-	else
-	{
-		// error happens, log uncommon ones
-		if (savedErrno != EINTR)
-		{
-		  errno = savedErrno;
-		  //TRACE("wait error %d",errno);
-		}
-	}
-
-}
-
-
-bool xEpoll::hasChannel(xChannel* channel)
-{
-	loop->assertInLoopThread();
-	ChannelMap::const_iterator it = channels.find(channel->getfd());
-	return it != channels.end() && it->second == channel;
-}
-
-
-
-void xEpoll::updateChannel(xChannel* channel)
-{
-  loop->assertInLoopThread();
-  const int index = channel->getIndex();
-  if (index == kNew || index == kDeleted)
-  {
-    // a new one, add with EPOLL_CTL_ADD
-    int fd = channel->getfd();
-    if (index == kNew)
-    {
-      assert(channels.find(fd) == channels.end());
-      channels[fd] = channel;
-    }
-    else // index == kDeleted
-    {
-      assert(channels.find(fd) != channels.end());
-      assert(channels[fd] == channel);
-    }
-
-    channel->setIndex(kAdded);
-    update(EPOLL_CTL_ADD, channel);
-  }
-  else
-  {
-    // update existing one with EPOLL_CTL_MOD/DEL
-    int fd = channel->getfd();
-    (void)fd;
-    assert(channels.find(fd) != channels.end());
-    assert(channels[fd] == channel);
-    assert(index == kAdded);
-    if (channel->isNoneEvent())
-    {
-      update(EPOLL_CTL_DEL, channel);
-      channel->setIndex(kDeleted);
-    }
-    else
-    {
-      update(EPOLL_CTL_MOD, channel);
-    }
-  }
-}
-
-
-
-
-void xEpoll::removeChannel(xChannel* channel)
-{
-  loop->assertInLoopThread();
-  int fd = channel->getfd();
-  assert(channels.find(fd) != channels.end());
-  assert(channels[fd] == channel);
-  assert(channel->isNoneEvent());
-  int index = channel->getIndex();
-  assert(index == kAdded || index == kDeleted);
-  size_t n = channels.erase(fd);
-  (void)n;
-  assert(n == 1);
-
-  if (index == kAdded)
-  {
-    update(EPOLL_CTL_DEL, channel);
-  }
-  channel->setIndex(kNew);
-}
-
-void xEpoll::update(int operation, xChannel* channel)
-{
-  struct epoll_event event;
-  bzero(&event, sizeof event);
-  event.events = channel->getEvents();
-  event.data.ptr = channel;
-  int fd = channel->getfd();
-  if (::epoll_ctl(epollFd, operation, fd, &event) < 0)
-  {
-	  //TRACE("epoll_ctl op %d\n",fd );
-  }
-}
-
-
-
-
-void xEpoll::fillActiveChannels(int numEvents, ChannelList* activeChannels) const
-{
-	 for (int i = 0; i < numEvents; ++i)
-	  {
-	    xChannel* channel = static_cast<xChannel*>(events[i].data.ptr);
-	    int fd = channel->getfd();
-	    ChannelMap::const_iterator it = channels.find(fd);
-	    assert(it != channels.end());
-	    assert(it->second == channel);
-	    channel->setRevents(events[i].events);
-	    activeChannels->push_back(channel);
-	  }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/xEpoll.h b/src/xEpoll.h
deleted file mode 100644
index 11bf940e..00000000
--- a/src/xEpoll.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "all.h"
-
-class xChannel;
-class xEventLoop;
-
-class xEpoll
-{
-public:
-	typedef std::vector<struct epoll_event> EventList;
-	typedef std::vector<xChannel*>          ChannelList;
-	typedef std::unordered_map<int, xChannel*> 		ChannelMap;
-	
-	xEpoll(xEventLoop * loop);
-	~xEpoll();
-
-	bool	init(int fdCount);
-	void  epollWait(ChannelList* activeChannels,int msTime = 10);
-	bool	hasChannel(xChannel* channel);
-	void  updateChannel(xChannel* channel);
-	void  removeChannel(xChannel* channel);
-	void  update(int operation, xChannel* channel);
-    void 	fillActiveChannels(int numEvents, ChannelList* activeChannels) const;
- private:
-	ChannelMap 				channels;
-	EventList 			    events;
-	xEventLoop 				*loop;
-	int                    		maxFd;;
-	int                     		epollFd;
-};
-
diff --git a/src/xEventLoop.cpp b/src/xEventLoop.cpp
deleted file mode 100644
index d979b300..00000000
--- a/src/xEventLoop.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-#include "all.h"
-
-#include "xEventLoop.h"
-
-
-const int maxCount = 65535;
-
-int createEventfd()
-{
-  int evtfd = ::eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
-  if (evtfd < 0)
-  {
-    assert(false);
-  }
-  return evtfd;
-}
-
-
-xEventLoop::xEventLoop()
-:wakeupFd(createEventfd()),
- threadId(xCurrentThread::tid()),
- epoller(new xEpoll(this)),
- timerQueue(new xTimerQueue(this)),
- wakeupChannel(new xChannel(this,wakeupFd)),
- currentActiveChannel(nullptr),
- running(false),
- eventHandling(false),
- callingPendingFunctors(false)
-{
-	signal(SIGPIPE, SIG_IGN);
-	signal(SIGHUP, SIG_IGN);
-	wakeupChannel->setReadCallback(std::bind(&xEventLoop::handleRead, this));
-	wakeupChannel->enableReading();
-}
-
-
-void xEventLoop::abortNotInLoopThread()
-{
-	assert(false);
-}
-
-xEventLoop::~xEventLoop()
-{
-	wakeupChannel->disableAll();
-	wakeupChannel->remove();
-	::close(wakeupFd);
-}
-
-
-
-void xEventLoop::updateChannel(xChannel* channel)
-{
-	assert(channel->ownerLoop() == this);
-	assertInLoopThread();
-	epoller->updateChannel(channel);
-}
-
-
-void xEventLoop::removeChannel(xChannel* channel)
-{
-	assert(channel->ownerLoop() == this);
-	assertInLoopThread();
-	if (eventHandling)
-	{
-		assert(currentActiveChannel == channel ||
-		std::find(activeChannels.begin(), activeChannels.end(), channel) == activeChannels.end());
-	}
-	epoller->removeChannel(channel);
-}
-
-
-
-
-void xEventLoop::cancelAfter(xTimer * timer)
-{
-	timerQueue->cancelTimer(timer);
-}
-
-xTimer * xEventLoop::runAfter(double  when, void * data,bool repeat,xTimerCallback&& cb)
-{
-	return timerQueue->addTimer(when,data,repeat,std::move(cb));
-}
-
-
-
-bool xEventLoop::hasChannel(xChannel* channel)
-{
-	assert(channel->ownerLoop() == this);
-	assertInLoopThread();
-	return epoller->hasChannel(channel);
-}
-
-void  xEventLoop::handleRead()
-{
-	uint64_t one = 1;
-	ssize_t n = ::read(wakeupFd, &one, sizeof one);
-	if (n != sizeof one)
-	{
-		//TRACE("xEventLoop::handleRead() reads error");
-	}
-}
-
-
-void xEventLoop::quit()
-{
-	running = false;
-	if (!isInLoopThread())
-	{
-		wakeup();
-	}
-}
-
-
-
-void xEventLoop::wakeup()
-{
-  uint64_t one = 1;
-  ssize_t n = ::write(wakeupFd, &one, sizeof one);
-  if (n != sizeof one)
-  {
-    //TRACE("EventLoop::wakeup() wrties error");
-  }
-}
-
-
-void xEventLoop::runInLoop(Functor&& cb)
-{
-	if (isInLoopThread())
-	{
-		cb();
-	}
-	else
-	{
-		queueInLoop(std::move(cb));
-	}
-
-}
-void xEventLoop::queueInLoop(Functor&& cb)
-{
-	{
-	 std::unique_lock<std::mutex> lk(mutex);
-	 pendingFunctors.push_back(std::move(cb));
-
-	}
-
-	if (!isInLoopThread() || callingPendingFunctors)
-	{
-		wakeup();
-	}
-}
-
-
-
-
-void xEventLoop::doPendingFunctors()
-{
-	std::vector<Functor> functors;
-	callingPendingFunctors = true;
-
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		functors.swap(pendingFunctors);
-		//functors = std::move(pendingFunctors);
-	}
-
-	for (size_t i = 0; i < functors.size(); ++i)
-	{
-		functors[i]();
-	}
-	callingPendingFunctors = false;
-}
-
-
-void xEventLoop::run()
-{
-	running = true;
-	while (running)
-	{
-		activeChannels.clear();
-		epoller->epollWait(&activeChannels);
-
-		// TODO sort channel by priority
-		eventHandling = true;
-		for (ChannelList::iterator it = activeChannels.begin();
-			it != activeChannels.end(); ++it)
-		{
-		  currentActiveChannel = *it;
-		  currentActiveChannel->handleEvent();
-		}
-		currentActiveChannel = nullptr;
-		eventHandling = false;
-		doPendingFunctors();
-	}
-}
-
-
diff --git a/src/xEventLoop.h b/src/xEventLoop.h
deleted file mode 100644
index ab5f10e0..00000000
--- a/src/xEventLoop.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#pragma once
-#include "all.h"
-
-#include "xChannel.h"
-#include "xEpoll.h"
-#include "xCurrentThread.h"
-#include "xTimerQueue.h"
-#include "xCallback.h"
-
-class xEventLoop
-{
-public:
-    typedef std::function<void()> Functor;
-
-	xEventLoop();
-	~xEventLoop();
-
-    void quit();
-    void run();
-    void handleRead();
-    void runInLoop(Functor&& cb);
-    void queueInLoop(Functor&& cb);
-    void wakeup();
-    void updateChannel(xChannel* channel);
-    void removeChannel(xChannel* channel);
-    bool hasChannel(xChannel* channel);
-    void cancelAfter(xTimer * timer);
-    xTimer  *runAfter(double  when,void * data,bool repeat,xTimerCallback&& cb);
-    void assertInLoopThread()
-    {
-      if (!isInLoopThread())
-      {
-          abortNotInLoopThread();
-      }
-    }
-    bool isInLoopThread() const { return threadId == xCurrentThread::tid(); }
-    bool geteventHandling() const { return eventHandling; }
-
-    int32_t getThreadId() const { return threadId;}
-private:
-
-    void abortNotInLoopThread();
-    void doPendingFunctors();
-
-    int wakeupFd;
-    const int32_t threadId;
-    mutable std::mutex mutex;
-
-    std::unique_ptr<xEpoll>   epoller;
-    std::unique_ptr<xTimerQueue> timerQueue;
-    std::unique_ptr<xChannel> wakeupChannel;
-    typedef std::vector<xChannel*> ChannelList;
-    ChannelList activeChannels;
-    xChannel* currentActiveChannel;
-	
-    bool running;
-    bool eventHandling;
-    bool callingPendingFunctors;
-    std::vector<Functor> pendingFunctors;
-
-};
-
diff --git a/src/xHiredis.cpp b/src/xHiredis.cpp
deleted file mode 100644
index b79c2c81..00000000
--- a/src/xHiredis.cpp
+++ /dev/null
@@ -1,1489 +0,0 @@
-#include "xHiredis.h"
-
-static redisReply * createReplyObject(int type);
-static void * createStringObject(const redisReadTask * task, const char * str, size_t len);
-static void * createArrayObject(const redisReadTask * task, int elements);
-static void * createIntegerObject(const redisReadTask * task, long long value);
-static void * createNilObject(const redisReadTask * task);
-void freeReplyObject(void *reply);
-
-
-static redisReplyObjectFunctions defaultFunctions =
-{
-	createStringObject,
-	createArrayObject,
-	createIntegerObject,
-	createNilObject,
-	freeReplyObject
-};
-
-static int intlen(int i)
-{
-	int 			len = 0;
-	if (i < 0)
-	{
-		len++;
-		i = -i;
-	}
-
-	do
-	{
-		len++;
-		i /= 10;
-	}while(i);
-
-	return len;
-}
-
-
-/* Create a reply object */
-static redisReply * createReplyObject(int type)
-{
-	redisReply *	r	= (redisReply*)zcalloc( sizeof(*r));
-
-	if (r == NULL)
-		return NULL;
-
-	r->type 			= type;
-	return r;
-}
-
-static long long readLongLong(const char * s)
-{
-	long long		v	= 0;
-	int 			dec, mult = 1;
-	char			c;
-
-	if (*s == '-')
-	{
-		mult				= -1;
-		s++;
-	}
-	else if (*s == '+')
-	{
-		mult				= 1;
-		s++;
-	}
-
-	while ((c = * (s++)) != '\r')
-	{
-		dec 				= c - '0';
-
-		if (dec >= 0 && dec < 10)
-		{
-			v					*= 10;
-			v					+= dec;
-		}
-		else
-		{
-			/* Should not happen... */
-			return - 1;
-		}
-	}
-
-	return mult * v;
-}
-
-
-/* Find pointer to \r\n. */
-static const char * seekNewline(const char * s, size_t len)
-{
-	int 			pos = 0;
-	int 			_len = len - 1;
-
-	/* Position should be < len-1 because the character at "pos" should be
-	 * followed by a \n. Note that strchr cannot be used because it doesn't
-	 * allow to search a limited length and the buffer that is being searched
-	 * might not have a trailing NULL character. */
-	while (pos < _len)
-	{
-		while (pos < _len && s[pos] != '\r')
-			pos++;
-
-		if (s[pos] != '\r')
-		{
-			/* Not found. */
-			return NULL;
-		}
-		else
-		{
-			if (s[pos + 1] == '\n')
-			{
-				/* Found. */
-				return s + pos;
-			}
-			else
-			{
-				/* Continue searching. */
-				pos++;
-			}
-		}
-	}
-
-	return NULL;
-}
-
-
-static const char * readLine(const xRedisReaderPtr & r,  int * _len)
-{
-	const char *			p;
-	const char *s;
-	int 			len;
-
-	p					= r->buf->peek() + r->pos;
-	s					= seekNewline(p, (r->buf->readableBytes() - r->pos));
-
-	if (s != NULL)
-	{
-		len 				= s - (r->buf->peek() + r->pos);
-		r->pos				+= len + 2; 			/* skip \r\n */
-
-		if (_len)
-			*_len = len;
-
-		return p;
-	}
-
-	return NULL;
-}
-
-static  const char * readBytes(const xRedisReaderPtr & r, unsigned int bytes)
-{
-	const char *			p;
-
-	if (r->buf->readableBytes() - r->pos >= bytes)
-	{
-		p					= r->buf->peek() + r->pos;
-		r->pos				+= bytes;
-		return p;
-	}
-
-	return NULL;
-}
-
-
-/* Free a reply object */
-void freeReplyObject(void * reply)
-{
-	redisReply *	r	= (redisReply*)reply;
-	size_t			j;
-
-	switch (r->type)
-	{
-	case REDIS_REPLY_INTEGER:
-		break; /* Nothing to free */
-
-	case REDIS_REPLY_ARRAY:
-		if (r->element != NULL)
-		{
-			for (j = 0; j < r->elements; j++)
-				if (r->element[j] != NULL)
-					freeReplyObject(r->element[j]);
-
-			zfree(r->element);
-		}
-
-		break;
-
-	case REDIS_REPLY_ERROR:
-	case REDIS_REPLY_STATUS:
-	case REDIS_REPLY_STRING:
-		if (r->str != NULL)
-			zfree(r->str);
-
-		break;
-	}
-
-	zfree(r);
-}
-
-void * createStringObject(const redisReadTask * task, const char * str, size_t len)
-{
-	redisReply *	r, *parent;
-	char *			buf;
-
-	r					= createReplyObject(task->type);
-
-	if (r == NULL)
-		return NULL;
-
-	buf 	= (char *)zmalloc(len + 1);
-
-	if (buf == NULL)
-	{
-		freeReplyObject(r);
-		return NULL;
-	}
-
-	assert(task->type == REDIS_REPLY_ERROR || task->type == REDIS_REPLY_STATUS || task->type == REDIS_REPLY_STRING);
-
-	/* Copy string value */
-	memcpy(buf, str, len);
-	buf[len]			= '\0';
-	r->str				= buf;
-	r->len				= len;
-
-	if (task->parent)
-	{
-		parent				=(redisReply*) task->parent->obj;
-		assert(parent->type == REDIS_REPLY_ARRAY);
-		parent->element[task->idx] = r;
-	}
-
-	return r;
-}
-
-
-void * createArrayObject(const redisReadTask * task, int elements)
-{
-	redisReply *	r, *parent;
-
-	r					= createReplyObject(REDIS_REPLY_ARRAY);
-
-	if (r == NULL)
-		return NULL;
-
-	if (elements > 0)
-	{
-		r->element			= (redisReply**)zmalloc(elements * sizeof(redisReply *));
-
-		if (r->element == NULL)
-		{
-			freeReplyObject(r);
-			return NULL;
-		}
-	}
-
-	r->elements 		= elements;
-
-	if (task->parent)
-	{
-		parent				= (redisReply*)task->parent->obj;
-		assert(parent->type == REDIS_REPLY_ARRAY);
-		parent->element[task->idx] = r;
-	}
-
-	return r;
-}
-
-
-void * createIntegerObject(const redisReadTask * task, long long value)
-{
-	redisReply *	r, *parent;
-
-	r					= createReplyObject(REDIS_REPLY_INTEGER);
-
-	if (r == NULL)
-		return NULL;
-
-	r->integer			= value;
-
-	if (task->parent)
-	{
-		parent				= (redisReply*)task->parent->obj;
-		assert(parent->type == REDIS_REPLY_ARRAY);
-		parent->element[task->idx] = r;
-	}
-
-	return r;
-}
-
-
-void * createNilObject(const redisReadTask * task)
-{
-	redisReply *	r, *parent;
-
-	r					= createReplyObject(REDIS_REPLY_NIL);
-
-	if (r == NULL)
-		return NULL;
-
-	if (task->parent)
-	{
-		parent				= (redisReply*)task->parent->obj;
-		assert(parent->type == REDIS_REPLY_ARRAY);
-		parent->element[task->idx] = r;
-	}
-
-	return r;
-}
-
-
-static size_t bulklen(size_t len)
-{
-	return 1 + intlen(len) + 2 + len + 2;
-}
-
-
-static char *nextArgument(char *start, char **str, size_t *len) {
-    char *p = start;
-    if (p[0] != '$') {
-        p = strchr(p,'$');
-        if (p == NULL) return NULL;
-    }
-
-    *len = (int)strtol(p+1,NULL,10);
-    p = strchr(p,'\r');
-    assert(p);
-    *str = p+2;
-    return p+2+(*len)+2;
-}
-
-
-
-void __redisSetError(const xRedisContextPtr  & c, int type, const char * str)
-{
-	size_t			len;
-
-	c->err				= type;
-
-	if (str != NULL)
-	{
-		len 				= strlen(str);
-		len 				= len < (sizeof(c->errstr) - 1) ? len: (sizeof(c->errstr) - 1);
-		memcpy(c->errstr, str, len);
-		c->errstr[len]		= '\0';
-	}
-	else
-	{
-		/* Only REDIS_ERR_IO may lack a description! */
-		assert(type == REDIS_ERR_IO);
-		strerror_r(errno, c->errstr, sizeof(c->errstr));
-	}
-}
-
-static void moveToNextTask(const xRedisReaderPtr & r)
-{
-	redisReadTask * cur, *prv;
-	while (r->ridx >= 0)
-	{
-		/* Return a.s.a.p. when the stack is now empty. */
-		if (r->ridx == 0)
-		{
-			r->ridx--;
-			return;
-		}
-
-		cur 				= & (r->rstack[r->ridx]);
-		prv 				= & (r->rstack[r->ridx - 1]);
-		assert(prv->type == REDIS_REPLY_ARRAY);
-
-		if (cur->idx == prv->elements - 1)
-		{
-			r->ridx--;
-		}
-		else
-		{
-			/* Reset the type because the next item can be anything */
-			assert(cur->idx < prv->elements);
-			cur->type			= -1;
-			cur->elements		= -1;
-			cur->idx++;
-			return;
-		}
-	}
-}
-
-
-static int processLineItem(const xRedisReaderPtr  &r)
-{
-	redisReadTask * cur = & (r->rstack[r->ridx]);
-	void *			obj;
-	const char *			p;
-	int 			len;
-
-	if ((p = readLine(r, &len)) != NULL)
-	{
-		if (cur->type == REDIS_REPLY_INTEGER)
-		{
-			if (r->fn && r->fn->createInteger)
-				obj = r->fn->createInteger(cur, readLongLong(p));
-			else
-				obj = (void *)
-				REDIS_REPLY_INTEGER;
-			}
-			else
-			{
-				/* Type will be error or status. */
-				if (r->fn && r->fn->createString)
-					obj = r->fn->createString(cur, p, len);
-				else
-					obj = (void *) (size_t) (cur->type);
-			}
-
-			if (obj == NULL)
-			{
-				//__redisReaderSetErrorOOM(r);
-				return REDIS_ERR;
-			}
-
-			/* Set reply if this is the root object. */
-			if (r->ridx == 0)
-				r->reply = obj;
-
-			moveToNextTask(r);
-			return REDIS_OK;
-	}
-
-	return REDIS_ERR;
-}
-
-
-static int processBulkItem(const xRedisReaderPtr  & r)
-{
-	redisReadTask * cur = & (r->rstack[r->ridx]);
-	void *			obj = NULL;
-	const char *			p;
-	const char *s;
-	long			len;
-	unsigned long	bytelen;
-	int 			success = 0;
-
-	p					= r->buf->peek() + r->pos;
-	s					= seekNewline(p, r->buf->readableBytes() - r->pos);
-
-	if (s != NULL)
-		{
-		p					= r->buf->peek() + r->pos;
-		bytelen 			= s - (r->buf->peek() + r->pos) + 2; /* include \r\n */
-		len 				= readLongLong(p);
-
-		if (len < 0)
-			{
-			/* The nil object can always be created. */
-			if (r->fn && r->fn->createNil)
-				obj = r->fn->createNil(cur);
-			else
-				obj = (void *)
-				REDIS_REPLY_NIL;
-
-			success 			= 1;
-			}
-		else
-			{
-			/* Only continue when the buffer contains the entire bulk item. */
-			bytelen 			+= len + 2; 		/* include \r\n */
-
-			if (r->pos + bytelen <= r->buf->readableBytes())
-				{
-				if (r->fn && r->fn->createString)
-					obj = r->fn->createString(cur, s + 2, len);
-				else
-					obj = (void *)
-					REDIS_REPLY_STRING;
-
-				success 			= 1;
-				}
-			}
-
-		/* Proceed when obj was created. */
-		if (success)
-			{
-			if (obj == NULL)
-				{
-				//__redisReaderSetErrorOOM(r);
-				return REDIS_ERR;
-				}
-
-			r->pos				+= bytelen;
-
-			/* Set reply if this is the root object. */
-			if (r->ridx == 0)
-				r->reply = obj;
-
-			moveToNextTask(r);
-			return REDIS_OK;
-			}
-		}
-
-	return REDIS_ERR;
-}
-
-
-static int processMultiBulkItem(const xRedisReaderPtr  & r)
-{
-	redisReadTask * cur = & (r->rstack[r->ridx]);
-	void *			obj;
-	const char *			p;
-	long			elements;
-	int 			root = 0;
-
-	/* Set error for nested multi bulks with depth > 7 */
-	if (r->ridx == 8)
-	{
-	//__redisReaderSetError(r, REDIS_ERR_PROTOCOL,
-		//"No support for nested multi bulk replies with depth > 7");
-	return REDIS_ERR;
-	}
-
-	if ((p = readLine(r, NULL)) != NULL)
-	{
-	elements			= readLongLong(p);
-	root				= (r->ridx == 0);
-
-	if (elements == -1)
-	{
-	if (r->fn && r->fn->createNil)
-		obj = r->fn->createNil(cur);
-	else
-		obj = (void *)
-		REDIS_REPLY_NIL;
-
-	if (obj == NULL)
-		{
-		//__redisReaderSetErrorOOM(r);
-		return REDIS_ERR;
-		}
-
-	moveToNextTask(r);
-	}
-	else
-	{
-		if (r->fn && r->fn->createArray)
-			obj = r->fn->createArray(cur, elements);
-		else
-			obj = (void *)
-			REDIS_REPLY_ARRAY;
-
-		if (obj == NULL)
-			{
-			//__redisReaderSetErrorOOM(r);
-			return REDIS_ERR;
-			}
-
-		/* Modify task stack when there are more than 0 elements. */
-		if (elements > 0)
-		{
-			cur->elements		= elements;
-			cur->obj			= obj;
-			r->ridx++;
-			r->rstack[r->ridx].type = -1;
-			r->rstack[r->ridx].elements = -1;
-			r->rstack[r->ridx].idx = 0;
-			r->rstack[r->ridx].obj = NULL;
-			r->rstack[r->ridx].parent = cur;
-			r->rstack[r->ridx].privdata = r->privdata;
-		}
-		else
-		{
-			moveToNextTask(r);
-		}
-	}
-
-	/* Set reply if this is the root object. */
-	if (root)
-		r->reply = obj;
-
-	return REDIS_OK;
-	}
-
-	return REDIS_ERR;
-}
-
-static int processItem(const xRedisReaderPtr & r)
-{
-	redisReadTask * cur = & (r->rstack[r->ridx]);
-	const char *			p;
-
-/* check if we need to read type */
-	if (cur->type < 0)
-	{
-		if ((p = readBytes(r, 1)) != NULL)
-			{
-			switch (p[0])
-				{
-				case '-':
-					cur->type = REDIS_REPLY_ERROR;
-					break;
-
-				case '+':
-					cur->type = REDIS_REPLY_STATUS;
-					break;
-
-				case ':':
-					cur->type = REDIS_REPLY_INTEGER;
-					break;
-
-				case '$':
-					cur->type = REDIS_REPLY_STRING;
-					break;
-
-				case '*':
-					cur->type = REDIS_REPLY_ARRAY;
-					break;
-
-				default:
-					//__redisReaderSetErrorProtocolByte(r, *p);
-					return REDIS_ERR;
-				}
-			}
-		else
-			{
-			/* could not consume 1 byte */
-			return REDIS_ERR;
-			}
-	}
-
-/* process typed item */
-	switch (cur->type)
-	{
-	case REDIS_REPLY_ERROR:
-	case REDIS_REPLY_STATUS:
-	case REDIS_REPLY_INTEGER:
-		return processLineItem(r);
-
-	case REDIS_REPLY_STRING:
-		return processBulkItem(r);
-
-	case REDIS_REPLY_ARRAY:
-		return processMultiBulkItem(r);
-
-	default:
-		assert(NULL);
-		return REDIS_ERR; /* Avoid warning. */
-	}
-}
-
-int redisReaderGetReply(const xRedisReaderPtr &r,void * *reply)
-{
-	/* Default target pointer to NULL. */
-		if (reply != NULL)
-			*reply = NULL;
-
-		/* Return early when this reader is in an erroneous state. */
-		if (r->err)
-			return REDIS_ERR;
-
-		/* When the buffer is empty, there will never be a reply. */
-		if (r->buf->readableBytes() == 0)
-			return REDIS_OK;
-		/* Set first item to process when the stack is empty. */
-			if (r->ridx == -1)
-			{
-				r->rstack[0].type	= -1;
-				r->rstack[0].elements = -1;
-				r->rstack[0].idx	= -1;
-				r->rstack[0].obj	= NULL;
-				r->rstack[0].parent = NULL;
-				r->rstack[0].privdata = r->privdata;
-				r->ridx 			= 0;
-			}
-
-		/* Process items in reply. */
-			while (r->ridx >= 0)
-				if (processItem(r) != REDIS_OK)
-					break;
-
-		/* Return ASAP when an error occurred. */
-			if (r->err)
-				return REDIS_ERR;
-
-			/* Discard part of the buffer when we've consumed at least 1k, to avoid
-			 * doing unnecessary calls to memmove() in sds.c. */
-			if (r->pos >= 1024)
-			{
-				r->buf->retrieve(r->pos);
-				r->pos				= 0;
-			}
-
-			/* Emit a reply when there is one. */
-			if (r->ridx == -1)
-			{
-				if (reply != NULL)
-					*reply = r->reply;
-
-				r->reply			= NULL;
-			}
-
-			return REDIS_OK;
-
-}
-
-
-int redisGetReplyFromReader(const xRedisContextPtr & c, void * *reply)
-{
-	if (redisReaderGetReply(c->reader, reply) == REDIS_ERR)
-	{
-		__redisSetError(c, c->reader->err, c->reader->errstr);
-		return REDIS_ERR;
-	}
-
-	return REDIS_OK;
-}
-
-
-
-int redisBufferWrite(const xRedisContextPtr & c, int * done)
-{
-	int nwritten;
-
-	/* Return early when the context has seen an error. */
-	if (c->err)
-		return REDIS_ERR;
-
-	if (c->sender.readableBytes() > 0)
-	{
-		nwritten			=  ::write(c->fd, c->sender.peek(), c->sender.readableBytes());
-
-		if (nwritten == -1)
-		{
-			if ((errno == EAGAIN && ! (c->flags & REDIS_BLOCK)) || (errno == EINTR))
-			{
-			/* Try again later */
-			}
-			else
-			{
-				__redisSetError(c, REDIS_ERR_IO, NULL);
-				return REDIS_ERR;
-			}
-		}
-		else if (nwritten > 0)
-		{
-			if (nwritten == (signed)
-					c->sender.readableBytes())
-			{
-				c->sender.retrieveAll();
-			}
-			else
-			{
-				c->sender.retrieve(nwritten);
-			}
-		}
-	}
-
-	if (done != NULL)
-		*done =( c->sender.readableBytes() == 0);
-
-	return REDIS_OK;
-}
-
-int redisBufferRead(const xRedisContextPtr & c)
-{
-	int savedErrno = 0;
-	ssize_t n = c->reader->buf->readFd(c->fd, &savedErrno);
-	if (n > 0)
-	{
-		//messageCallback(shared_from_this(), &recvBuff,data);
-	}
-	else if (n == 0)
-	{
-		LOG_WARN<<"Server closed the connection";
-		return REDIS_ERR;
-	}
-	else
-	{
-		if ((errno == EAGAIN && ! (c->flags & REDIS_BLOCK)) || (errno == EINTR))
-		{
-			/* Try again later */
-		}
-		else
-		{
-			LOG_WARN<<"Server closed the connection";
-			return REDIS_ERR;
-		}
-	}
-
-	return REDIS_OK;
-}
-int redisGetReply(const xRedisContextPtr & c, void * *reply)
-{
-	int wdone			= 0;
-	void * aux			= NULL;
-
-	/* Try to read pending replies */
-	if (redisGetReplyFromReader(c, &aux) == REDIS_ERR)
-		return REDIS_ERR;
-
-	/* For the blocking context, flush output buffer and read reply */
-		if (aux == NULL && c->flags & REDIS_BLOCK)
-		{
-
-			do
-			{
-				if (redisBufferWrite(c, &wdone) == REDIS_ERR)
-				return REDIS_ERR;
-			}
-			while(!wdone);
-
-
-			do
-			{
-				if (redisBufferRead(c) == REDIS_ERR)
-					return REDIS_ERR;
-
-				if (redisGetReplyFromReader(c, &aux) == REDIS_ERR)
-					return REDIS_ERR;
-			}
-			while(aux == NULL);
-		}
-
-		/* Set reply object */
-		if (reply != NULL)
-			*reply = aux;
-
-	return REDIS_OK;
-}
-
-
-
-int __redisAsyncCommand(const xRedisAsyncContextPtr &ac,redisCallbackFn *fn, void *privdata, char *cmd, size_t len)
-{
-	redisCallback cb;
-	int pvariant, hasnext;
-	char *cstr, *astr;
-	size_t clen, alen;
-	char *p;
-	sds sname;
-	cb.fn = fn;
-	cb.privdata = privdata;
-	p = nextArgument(cmd,&cstr,&clen);
-	assert(p != NULL);
-	hasnext = (p[0] == '$');
-	pvariant = (tolower(cstr[0]) == 'p') ? 1 : 0;
-	cstr += pvariant;
-	clen -= pvariant;
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		ac->replies.push_back(std::move(cb));
-	}
-	ac->conn->send(stringPiepe(cmd,len));
-
-    return REDIS_OK;
-}
-
-
-int redisvFormatCommand(char * *target, const char * format, va_list ap)
-{
-	const char *	c	= format;
-	char *			cmd = NULL; 					/* final command */
-	int 			pos;							/* position in final command */
-	sds 			curarg, newarg; 				/* current argument */
-	int 			touched = 0;					/* was the current argument touched? */
-	char * *		curargv = NULL, * *newargv = NULL;
-	int 			argc = 0;
-	int 			totlen = 0;
-	int 			j;
-
-	/* Abort if there is not target to set */
-	if (target == NULL)
-		return - 1;
-	/* Build the command string accordingly to protocol */
-	curarg				= sdsempty();
-	if (curarg == NULL)
-		return - 1;
-
-	while (*c != '\0')
-	{
-		if (*c != '%' || c[1] == '\0')
-		{
-			if (*c == ' ')
-			{
-				if (touched)
-				{
-					newargv = (char**) zrealloc(curargv, sizeof(char *) * (argc + 1));
-					if (newargv == NULL)
-						goto err;
-					curargv 			= newargv;
-					curargv[argc++] 	= curarg;
-					totlen				+= bulklen(sdslen(curarg));
-					/* curarg is put in argv so it can be overwritten. */
-					curarg				= sdsempty();
-					if (curarg == NULL)
-						goto err;
-					touched 			= 0;
-				}
-			}
-			else
-			{
-				newarg				= sdscatlen(curarg, c, 1);
-				if (newarg == NULL)
-					goto err;
-				curarg				= newarg;
-				touched 			= 1;
-			}
-		}
-		else
-		{
-			char *			arg;
-			size_t			size;
-			/* Set newarg so it can be checked even if it is not touched. */
-			newarg				= curarg;
-			switch (c[1])
-			{
-			case 's':
-				arg = va_arg(ap, char *);
-				size = strlen(arg);
-
-				if (size > 0)
-					newarg = sdscatlen(curarg, arg, size);
-				break;
-			case 'b':
-				arg = va_arg(ap, char *);
-				size = va_arg(ap, size_t);
-				if (size > 0)
-					newarg = sdscatlen(curarg, arg, size);
-				break;
-			case '%':
-				newarg = sdscat(curarg, "%");
-				break;
-			default:
-				/* Try to detect printf format */
-					{
-					static const char intfmts[] = "diouxX";
-					char			_format[16];
-					const char *	_p	= c + 1;
-					size_t			_l	= 0;
-					va_list 		_cpy;
-
-					/* Flags */
-					if (*_p != '\0' && *_p == '#')
-						_p ++;
-
-					if (*_p != '\0' && *_p == '0')
-						_p ++;
-
-					if (*_p != '\0' && *_p == '-')
-						_p ++;
-
-					if (*_p != '\0' && *_p == ' ')
-						_p ++;
-
-					if (*_p != '\0' && *_p == '+')
-						_p ++;
-
-					/* Field width */
-					while (*_p != '\0' && isdigit(*_p))
-						_p ++;
-
-					/* Precision */
-					if (*_p == '.')
-					{
-						_p ++;
-						while (*_p != '\0' && isdigit(*_p))
-							_p ++;
-					}
-					/* Copy va_list before consuming with va_arg */
-					va_copy(_cpy, ap);
-					/* Integer conversion (without modifiers) */
-					if (strchr(intfmts, *_p) != NULL)
-						{
-						va_arg(ap, int);
-						goto fmt_valid;
-						}
-					/* Double conversion (without modifiers) */
-					if (strchr("eEfFgGaA", *_p) != NULL)
-						{
-						va_arg(ap, double);
-						goto fmt_valid;
-						}
-					/* Size: char */
-					if (_p[0] == 'h' && _p[1] == 'h')
-						{
-						_p					+= 2;
-						if (*_p != '\0' && strchr(intfmts, *_p) != NULL)
-							{
-							va_arg(ap, int);	/* char gets promoted to int */
-							goto fmt_valid;
-							}
-						goto fmt_invalid;
-						}
-					/* Size: short */
-					if (_p[0] == 'h')
-						{
-						_p					+= 1;
-						if (*_p != '\0' && strchr(intfmts, *_p) != NULL)
-							{
-							va_arg(ap, int);	/* short gets promoted to int */
-							goto fmt_valid;
-							}
-						goto fmt_invalid;
-						}
-					/* Size: long long */
-					if (_p[0] == 'l' && _p[1] == 'l')
-						{
-						_p					+= 2;
-
-						if (*_p != '\0' && strchr(intfmts, *_p) != NULL)
-							{
-							va_arg(ap, long long);
-							goto fmt_valid;
-							}
-
-						goto fmt_invalid;
-						}
-					/* Size: long */
-					if (_p[0] == 'l')
-						{
-						_p					+= 1;
-						if (*_p != '\0' && strchr(intfmts, *_p) != NULL)
-							{
-							va_arg(ap, long);
-							goto fmt_valid;
-							}
-						goto fmt_invalid;
-						}
-fmt_invalid:
-					va_end(_cpy);
-					goto err;
-fmt_valid:
-					_l					= (_p +1) -c;
-					if (_l < sizeof(_format) - 2)
-						{
-						memcpy(_format, c, _l);
-						_format[_l] 		= '\0';
-						newarg				= sdscatvprintf(curarg, _format, _cpy);
-
-						/* Update current position (note: outer blocks
-						 * increment c twice so compensate here) */
-						c					= _p -1;
-						}
-					va_end(_cpy);
-					break;
-					}
-			}
-		if (newarg == NULL)
-			goto err;
-		curarg				= newarg;
-		touched 			= 1;
-		c++;
-		}
-	c++;
-	}
-	/* Add the last argument if needed */
-	if (touched)
-	{
-		newargv = (char **)zrealloc(curargv, sizeof(char *) * (argc + 1));
-
-		if (newargv == NULL)
-			goto err;
-
-		curargv 			= newargv;
-		curargv[argc++] 	= curarg;
-		totlen				+= bulklen(sdslen(curarg));
-	}
-	else
-	{
-		sdsfree(curarg);
-	}
-	/* Clear curarg because it was put in curargv or was free'd. */
-	curarg				= NULL;
-	/* Add bytes needed to hold multi bulk count */
-	totlen				+= 1 + intlen(argc) + 2;
-	/* Build the command at protocol level */
-	cmd 				= (char *)zmalloc(totlen + 1);
-	if (cmd == NULL)
-		goto err;
-	pos 				= sprintf(cmd, "*%d\r\n", argc);
-	for (j = 0; j < argc; j++)
-	{
-		pos 				+= sprintf(cmd + pos, "$%zu\r\n", sdslen(curargv[j]));
-		memcpy(cmd + pos, curargv[j], sdslen(curargv[j]));
-		pos 				+= sdslen(curargv[j]);
-		sdsfree(curargv[j]);
-		cmd[pos++]			= '\r';
-		cmd[pos++]			= '\n';
-	}
-	assert(pos == totlen);
-	cmd[pos]			= '\0';
-	zfree(curargv);
-	*target 			= cmd;
-	return totlen;
-err:
-	while (argc--)
-		sdsfree(curargv[argc]);
-	free(curargv);
-	if (curarg != NULL)
-		sdsfree(curarg);
-	/* No need to check cmd since it is the last statement that can fail,
-	 * but do it anyway to be as defensive as possible. */
-	if (cmd != NULL)
-		zfree(cmd);
-	return - 1;
-
-}
-
-xRedisReader::xRedisReader()
-{
-	pos 				= 0;
-	err				= 0;
-	errstr[0]		= '\0';
-	fn				= &defaultFunctions;
-	ridx 			= -1;
-
-}
-
-
-xHiredis::xHiredis(xClient * owner)
-:owner(owner),
-client(&sloop,this)
-{
-	client.setConnectionCallback(std::bind(&xHiredis::connSyncCallBack, this, std::placeholders::_1,std::placeholders::_2));
-	//client.setMessageCallback( std::bind(&xHiredis::readCallBack, this, std::placeholders::_1,std::placeholders::_2,std::placeholders::_3));
-	client.setConnectionErrorCallBack(std::bind(&xHiredis::connErrorCallBack, this));
-}
-
-
-xHiredis::xHiredis(xEventLoop *loop,xClient * owner)
-:loop(loop),
- owner(owner),
- client(loop,this)
-{
-	client.setConnectionCallback(std::bind(&xHiredis::connCallBack, this, std::placeholders::_1,std::placeholders::_2));
-	client.setMessageCallback( std::bind(&xHiredis::readCallBack, this, std::placeholders::_1,std::placeholders::_2,std::placeholders::_3));
-	client.setConnectionErrorCallBack(std::bind(&xHiredis::connErrorCallBack, this));
-}
-
-
-void xHiredis::connSyncCallBack(const xTcpconnectionPtr& conn,void *data)
-{
-	if(conn->connected())
-	{
-		xBuffer buffer;
-		xRedisContextPtr c (new (xRedisContext));
-
-		c->fd = conn->getSockfd();
-		c->flags			|= REDIS_BLOCK;
-		c->reader->buf = & buffer;
-		redisSyncs.insert(std::make_pair(conn->getSockfd(),c));
-
-		 redisReply *reply;
-
-		/* PING server */
-		reply = ( redisReply *)redisCommand(c,"PING");
-		printf("PING: %s\n", reply->str);
-		freeReplyObject(reply);
-
-		/* Set a key */
-		reply =  ( redisReply *)redisCommand(c,"SET %s %s", "foo", "hello world");
-		printf("SET: %s\n", reply->str);
-		freeReplyObject(reply);
-
-		/* Set a key using binary safe API */
-		reply =  ( redisReply *)redisCommand(c,"SET %b %b", "bar", (size_t) 3, "hello", (size_t) 5);
-		printf("SET (binary API): %s\n", reply->str);
-		freeReplyObject(reply);
-
-		/* Try a GET and two INCR */
-		reply =  ( redisReply *)redisCommand(c,"GET foo");
-		printf("GET foo: %s\n", reply->str);
-		freeReplyObject(reply);
-
-		reply =  ( redisReply *)redisCommand(c,"INCR counter");
-		printf("INCR counter: %lld\n", reply->integer);
-		freeReplyObject(reply);
-		/* again ... */
-		reply = ( redisReply *) redisCommand(c,"INCR counter");
-		printf("INCR counter: %lld\n", reply->integer);
-		freeReplyObject(reply);
-
-		/* Create a list of numbers, from 0 to 9 */
-		reply = ( redisReply *) redisCommand(c,"DEL mylist");
-		freeReplyObject(reply);
-		for (int j = 0; j < 10; j++) {
-			char buf[64];
-
-			snprintf(buf,64,"%d",j);
-			reply =  ( redisReply *)redisCommand(c,"LPUSH mylist element-%s", buf);
-			freeReplyObject(reply);
-		}
-
-		/* Let's check what we have inside the list */
-		reply =  ( redisReply *)redisCommand(c,"LRANGE mylist 0 -1");
-		if (reply->type == REDIS_REPLY_ARRAY) {
-			for (int j = 0; j < reply->elements; j++) {
-				printf("%u) %s\n", j, reply->element[j]->str);
-			}
-		}
-
-		freeReplyObject(reply);
-
-	}
-	else
-	{
-		redisSyncs.erase(conn->getSockfd());
-	}
-}
-
-
-void xHiredis::readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data)
-{
-
-	xRedisAsyncContextPtr redis;
-
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		auto it = redisAsyncs.find(conn->getSockfd());
-		if(it == redisAsyncs.end())
-		{
-			assert(false);
-		}
-
-		redis = it->second;
-	}
-
-	 redisCallback cb;
-
-	if(recvBuf->readableBytes() > 0 )
-	{
-		 xRedisContextPtr  c = (redis->c);
-		 void  *reply = NULL;
-		 int status;
-		 while((status = redisGetReply(c,&reply)) == REDIS_OK)
-		 {
-			 if(reply == nullptr)
-			 {
-				 break;
-			 }
-
-			 {
-				 std::unique_lock<std::mutex> lk(mutex);
-				 cb = std::move(redis->replies.front());
-			 }
-
-			 c->flags |= REDIS_IN_CALLBACK;
-			 if(cb.fn != nullptr)
-			 {
-				 cb.fn(redis,reply,cb.privdata);
-			 }
-
-		     c->reader->fn->freeObject(reply);
-
-			 c->flags &= ~REDIS_IN_CALLBACK;
-
-			 {
-				 std::unique_lock<std::mutex> lk(mutex);
-				 redis->replies.pop_front();
-			 }
-
-		 }
-	}
-}
-
-
-void xHiredis::start()
-{
-	client.connect(owner->ip,owner->port);
-}
-
-
-void xHiredis::connErrorCallBack()
-{
-	LOG_WARN<<"connect server failure";
-}
-
-
- static void getCallback(const xRedisAsyncContextPtr &c, void *r, void *privdata)
- {
-    redisReply *reply = (redisReply*)r;
-    if (reply == NULL)
-	{
-		assert(false);
-	}
-
-    if(reply->type == REDIS_REPLY_NIL || reply->type == REDIS_REPLY_ERROR)
-	{
-		assert(false);
-	}
-
-}
-
-
-void xHiredis::connCallBack(const xTcpconnectionPtr& conn,void *data)
-{
-	if(conn->connected())
-	{
-		xRedisAsyncContextPtr ac (new xRedisAsyncContext());
-		ac->conn = conn;
-		ac->c->reader->buf = &conn->recvBuff;
-		ac->c->fd = conn->getSockfd();
-		{
-			std::unique_lock<std::mutex> lk(mutex);
-			redisAsyncs.insert(std::make_pair(conn->getSockfd(),ac));
-		}
-
-//		for(int i = 0 ; i < 200;i++)
-//		{
-//			std::string str = "set test" + std::to_string(i) + " "  + " %b";
-//			redisAsyncCommand(ac, nullptr, nullptr, str.c_str(), owner->message.c_str(), owner->message.length());
-//			std::string str1 = "get test" + std::to_string(i);
-//			redisAsyncCommand(ac, getCallback, nullptr,str1.c_str());
-//		}
-
-
-	}
-	else
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		redisAsyncs.erase(conn->getSockfd());
-	}
-
-}
-
-
-int redisvAsyncCommand(const xRedisAsyncContextPtr &ac,redisCallbackFn *fn, void *privdata, const char *format, va_list ap)
-{
-	char *cmd;
-	int len;
-	int status;
-	len = redisvFormatCommand(&cmd,format,ap);
-	status = __redisAsyncCommand(ac,fn,privdata,cmd,len);
-	zfree(cmd);
-	return status;
-}
-
-
-
-int redisAsyncCommand(const xRedisAsyncContextPtr &ac,redisCallbackFn *fn, void *privdata, const char *format, ...)
-{
-	va_list ap;
-	int status;
-	va_start(ap,format);
-	status = redisvAsyncCommand(ac,fn,privdata,format,ap);
-	va_end(ap);
-	return status;
-}
-
-
-
-
-static void * __redisBlockForReply(const xRedisContextPtr & c)
-{
-	void * reply;
-
-	if (c->flags & REDIS_BLOCK)
-	{
-		if (redisGetReply(c, &reply) != REDIS_OK)
-			return NULL;
-
-		return reply;
-	}
-
-	return NULL;
-}
-
-
-int __redisAppendCommand(const xRedisContextPtr & c, const char * cmd, size_t len)
-{
-	c->sender.append(cmd,len);
-	return REDIS_OK;
-}
-
-int redisvAppendCommand(const xRedisContextPtr  & c, const char * format, va_list ap)
-{
-	char * cmd;
-	int len;
-
-	len 				= redisvFormatCommand(&cmd, format, ap);
-
-	if (len == -1)
-	{
-		__redisSetError(c, REDIS_ERR_OOM, "Out of memory");
-		return REDIS_ERR;
-	}
-
-	if (__redisAppendCommand(c, cmd, len) != REDIS_OK)
-	{
-		zfree(cmd);
-		return REDIS_ERR;
-	}
-
-	zfree(cmd);
-	return REDIS_OK;
-}
-
-
-void * redisCommand(const xRedisContextPtr & c, const char * format, ...)
-{
-
-		va_list ap;
-		void * reply		= NULL;
-		va_start(ap, format);
-		reply				= redisvCommand(c, format, ap);
-		va_end(ap);
-		return reply;
-}
-
-void * redisvCommand(const xRedisContextPtr & c, const char * format, va_list ap)
-{
-
-	if (redisvAppendCommand(c, format, ap) != REDIS_OK)
-			return NULL;
-
-    return __redisBlockForReply(c);
-}
-
-
-
-int redisFormatCommandArgv(char * *target, int argc, const char * *argv, const size_t * argvlen)
-{
-	char *			cmd = NULL; 					/* final command */
-	int 			pos;							/* position in final command */
-	size_t			len;
-	int 			totlen, j;
-
-	/* Calculate number of bytes needed for the command */
-	totlen				= 1 + intlen(argc) + 2;
-
-	for (j = 0; j < argc; j++)
-		{
-		len 				= argvlen ? argvlen[j]: strlen(argv[j]);
-		totlen				+= bulklen(len);
-		}
-
-	/* Build the command at protocol level */
-	cmd 				= (char*)zmalloc(totlen + 1);
-
-	if (cmd == NULL)
-		return - 1;
-
-	pos 				= sprintf(cmd, "*%d\r\n", argc);
-
-	for (j = 0; j < argc; j++)
-		{
-		len 				= argvlen ? argvlen[j]: strlen(argv[j]);
-		pos 				+= sprintf(cmd + pos, "$%zu\r\n", len);
-		memcpy(cmd + pos, argv[j], len);
-		pos 				+= len;
-		cmd[pos++]			= '\r';
-		cmd[pos++]			= '\n';
-		}
-
-	assert(pos == totlen);
-	cmd[pos]			= '\0';
-
-	*target 			= cmd;
-	return totlen;
-}
-
-
-int redisAppendCommandArgv(const xRedisContextPtr  & c, int argc, const char * *argv, const size_t * argvlen)
-{
-	char * cmd;
-	int len;
-
-	len 				= redisFormatCommandArgv(&cmd, argc, argv, argvlen);
-
-	if (len == -1)
-	{
-		__redisSetError(c, REDIS_ERR_OOM, "Out of memory");
-		return REDIS_ERR;
-	}
-
-	if (__redisAppendCommand(c, cmd, len) != REDIS_OK)
-	{
-		zfree(cmd);
-		return REDIS_ERR;
-	}
-
-	zfree(cmd);
-	return REDIS_OK;
-}
-
-
-void * redisCommandArgv(const xRedisContextPtr & c, int argc, const char * *argv, const size_t * argvlen)
-{
-	if (redisAppendCommandArgv(c, argc, argv, argvlen) != REDIS_OK)
-			return NULL;
-
-	return __redisBlockForReply(c);
-}
diff --git a/src/xHiredis.h b/src/xHiredis.h
deleted file mode 100644
index 5a173f25..00000000
--- a/src/xHiredis.h
+++ /dev/null
@@ -1,218 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xSds.h"
-#include "xTcpconnection.h"
-#include "xObject.h"
-#include "xTcpClient.h"
-#include "xSocket.h"
-#include "xLog.h"
-#include "xThreadPool.h"
-
-class xRedisAsyncContext;
-typedef void (redisCallbackFn)(const xRedisAsyncContextPtr &ac, void*, void*);
-
-
-typedef struct redisReply 
-{
-    int type;
-    long long integer;
-    int len;
-    char *str;
-    size_t elements;
-    struct redisReply **element;
-} redisReply;
-
-
-typedef struct redisReadTask {
-    int type;
-    int elements;
-    int idx;
-    void *obj;
-    struct redisReadTask *parent;
-    void *privdata;
-} redisReadTask;
-
-
-
-typedef struct redisReplyObjectFunctions
-{
-	void *(*createString)(const redisReadTask*, const char*, size_t);
-	void *(*createArray)(const redisReadTask*, int);
-	void *(*createInteger)(const redisReadTask*, long long);
-	void *(*createNil)(const redisReadTask*);
-	void (*freeObject)(void*);
-} redisReplyObjectFunctions;
-
-
-
-class xRedisReader
-{
-public:
-	xRedisReader();
-    int err;
-    char errstr[128];
-    size_t pos;
-	xBuffer *buf;
-    redisReadTask rstack[9];
-    int ridx;
-    void *reply;
-    redisReplyObjectFunctions *fn;
-    void *privdata;
-};
-
-
-typedef struct redisCallback
-{
-    redisCallbackFn *fn;
-    void *privdata;
-} redisCallback;
-
-typedef std::list<redisCallback> RedisCallbackList;
-
-class xRedisContext: noncopyable
-{
-public:
-	xRedisContext():reader(new xRedisReader())
-	{
-		flags			&= ~REDIS_BLOCK;
-		err				= 0;
-		errstr[0]		= '\0';
-	}
-	int err;
-	char errstr[128];
-	int fd;
-	int flags;
-	xBuffer sender;
-	xRedisReaderPtr reader;
-};
-
-class xRedisAsyncContext: noncopyable
-{
-public:
-	xRedisAsyncContext():c(new (xRedisContext))
-	{
-		err = 0;
-		errstr = nullptr;
-		data = nullptr;
-	}
-	int err;
-	char *errstr;
-	void *data;
-	xRedisContextPtr c;
-	xTcpconnectionPtr conn;
-	RedisCallbackList replies;
-};
-
-class xClient;
-
-class xHiredis:noncopyable
-{
-public:
-	xHiredis(xEventLoop *loop,xClient * owner);
-	xHiredis(xClient * owner);
-	~xHiredis(){}
-	void start();
-
-	void readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data);
-	void connSyncCallBack(const xTcpconnectionPtr& conn,void *data);
-	void connCallBack(const xTcpconnectionPtr& conn,void *data);
-	void connErrorCallBack();
-
-private:
-	xEventLoop *loop;
-	xEventLoop sloop;
-	std::map<int32_t,xRedisAsyncContextPtr> redisAsyncs;
-	std::map<int32_t,xRedisContextPtr> redisSyncs;
-	xClient * owner;
-	xTcpClient client;
-	mutable std::mutex mutex;
-};
-
-
-class xClient:noncopyable
-{
-public:
-	xClient(xEventLoop *loop,const char *ip,uint16_t port,int blockSize,int sessionCount,int threadCount)
-	:loop(loop),
-	ip(ip),
-	port(port),
-	sessionCount(sessionCount),
-	threadPool(loop)
-{
-
-	if (threadCount > 1)
-	{
-	  threadPool.setThreadNum(threadCount);
-	}
-
-	threadPool.start();
-	for (int i = 0; i < blockSize; ++i)
-	{
-		message.push_back(static_cast<char>(i % 128));
-	}
-
-	for(int i = 0; i < sessionCount ; i ++)
-	{
-		std::shared_ptr<xHiredis>   redis = std::shared_ptr<xHiredis>(new xHiredis(threadPool.getNextLoop(),this));
-		redis->start();
-		redisVectors.push_back(redis);
-	}
-}
-
-	xClient(const char *ip,uint16_t port)
-	:ip(ip),
-	port(port),
-	threadPool(loop)
-{
-	std::shared_ptr<xHiredis>   redis = std::shared_ptr<xHiredis>(new xHiredis(this));
-	redis->start();
-	redisVectors.push_back(redis);
-}
-
-
-
-~xClient()
-{
-	redisVectors.clear();
-}
-
-public:
-	xEventLoop *loop;
-	const char *ip;
-	uint16_t port;
-	int sessionCount;
-	xThreadPool threadPool;
-	std::string message;
-	std::vector<std::shared_ptr<xHiredis>>   redisVectors;
-};
-
-
-int __redisAsyncCommand(const xRedisAsyncContextPtr &ac,redisCallbackFn *fn, void *privdata, char *cmd, size_t len);
-int redisvFormatCommand(char * *target, const char * format, va_list ap);
-int redisvAsyncCommand(const xRedisAsyncContextPtr &ac, redisCallbackFn *fn, void *privdata, const char *format, va_list ap);
-int redisAsyncCommand(const xRedisAsyncContextPtr &ac, redisCallbackFn *fn, void *privdata, const char *format, ...);
-
-
-int redisFormatCommandArgv(char * *target, int argc, const char * *argv, const size_t * argvlen);
-int redisAppendCommandArgv(const xRedisContextPtr  & c, int argc, const char * *argv, const size_t * argvlen);
-
-int redisvAppendCommand(const xRedisContextPtr  & c, const char * format, va_list ap);
-int __redisAppendCommand(const xRedisContextPtr & c, const char * cmd, size_t len);
-
-
-void * redisCommand(const xRedisContextPtr  & c, const char * format, ...);
-void * redisvCommand(const xRedisContextPtr  & c, const char * format, va_list ap);
-void * redisCommandArgv(const xRedisContextPtr  & c, int argc, const char * *argv, const size_t * argvlen);
-
-int redisBufferRead(const xRedisContextPtr & c);
-int redisBufferWrite(const xRedisContextPtr & c, int * done);
-int redisGetReply(const xRedisContextPtr & c, void * *reply);
-int redisGetReplyFromReader(const xRedisContextPtr & c, void * *reply);
-int redisReaderGetReply(const xRedisReaderPtr & r,void * *reply);
-void __redisSetError(const xRedisContextPtr & c, int type, const char * str);
-
-
-
-
-
-
diff --git a/src/xHttpContext.cpp b/src/xHttpContext.cpp
deleted file mode 100644
index f7e89d65..00000000
--- a/src/xHttpContext.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-#include "xHttpContext.h"
-#include "xBuffer.h"
-
-bool xHttpContext::processRequestLine(const char *begin,const char *end)
-{
-	bool succeed = false;
-	const char *start = begin;
-	const  char *space = std::find(start,end,' ');
-	if(space != end && request.setMethod(start,space))
-	{
-		start = space+1;
-		space = std::find(start, end, ' ');
-		if (space != end)
-		{
-			const char *question = std::find(start,space ,'?');
-			if(question != space)
-			{
-				request.setPath(start,question);
-				request.setQuery(question + 1,space);
-			}
-			else
-			{
-				request.setPath(start,space);
-			}
-
-			start = space + 1;
-			succeed = end - start == 8 && std::equal(start,end - 1,"HTTP/1.");
-			if(succeed)
-			{
-				if (*(end-1) == '1')
-				{
-					request.setVersion(xHttpRequest::kHttp11);
-				}
-				else if (*(end-1) == '0')
-				{
-					request.setVersion(xHttpRequest::kHttp10);
-				}
-				else
-				{
-					succeed = false;
-				}
-			}
-		}
-	}
-	return succeed;
-}
-
-
-bool xHttpContext::parseServerRequest(xBuffer *buf)
-{
-	const char * crlfcrlf = buf->findCRLFCRLF();
-	if(crlfcrlf == nullptr)
-	{
-		return false;
-	}
-
-	const char * content = buf->findCONTENT();
-	if(content != nullptr)
-	{
-		buf->retrieveUntil(content);
-		const char *crlf = buf->findCRLF();
-		if(crlf)
-		{
-			const char * colon = std::find(buf->peek(),crlf,':');
-			if(colon != crlf)
-			{
-				request.setMethod();
-				request.addContent(buf->peek(),colon,crlf);
-				buf->retrieveUntil(crlfcrlf + 4);
-			}
-			else
-			{
-				return false;
-			}
-		}
-		else
-		{
-			return false;
-		}
-
-	}
-
-	return true;
-}
-
-
-bool xHttpContext::parseClientRequest(xBuffer *buf)
-{
-	bool ok = true;
-	bool hasMore = true;
-	while(hasMore)
-	{
-		if(state == kExpectRequestLine)
-		{
-			const char * crlf = buf->findCRLF();
-			if(crlf)
-			{
-				ok = processRequestLine(buf->peek(),crlf);
-				if(ok)
-				{
-					request.setReceiveTime(time(0));
-					buf->retrieveUntil(crlf + 2);
-					state = kExpectHeaders;
-				}
-				else
-				{
-					hasMore = false;
-				}
-			}
-			else
-			{
-				hasMore = false;
-			}
-		}
-		else if(state == kExpectHeaders)
-		{
-			const char * crlf = buf->findCRLF();
-			if(crlf)
-			{
-				const char *colon = std::find(buf->peek(), crlf, ':');
-				if(colon != crlf)
-				{
-					request.addHeader(buf->peek(),colon,crlf);
-				}
-				else
-				{
-					state = kGotAll;
-					hasMore = false;
-				}
-				buf->retrieveUntil(crlf + 2);
-			}
-			else
-			{
-				hasMore = false;
-			}
-		}
-		else if(state == kExpectBody)
-		{
-
-		}
-	}
-	return ok;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/xHttpContext.h b/src/xHttpContext.h
deleted file mode 100644
index c590e7f0..00000000
--- a/src/xHttpContext.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-#include "xHttpRequest.h"
-class xBuffer;
-class xHttpContext
-{
-public:
-	enum HttpRequestParseState
-	{
-		kExpectRequestLine,
-		kExpectHeaders,
-		kExpectBody,
-		kGotAll,
-	};
-	xHttpContext()
-	:state(kExpectRequestLine)
-	{
-
-	}
-
-	bool parseServerRequest(xBuffer *buf);
-	bool parseClientRequest(xBuffer *buf);
-
-	bool gotAll() const
-	{;
-		return state == kGotAll;
-	}
-
-	void reset()
-	{
-		state = kExpectRequestLine;
-		xHttpRequest dummy;
-		request.swap(dummy);
-	}
-
-	xHttpRequest & getRequest()
-	{
-		return request;
-	}
-
-	bool processRequestLine(const char *begin,const char *end);
-private:
-
-	HttpRequestParseState state;
-	xHttpRequest request;
-};
diff --git a/src/xHttpRequest.h b/src/xHttpRequest.h
deleted file mode 100644
index 09764f74..00000000
--- a/src/xHttpRequest.h
+++ /dev/null
@@ -1,202 +0,0 @@
-#pragma once
-#include "all.h"
-
-class xHttpRequest
-{
-public:
-
-xHttpRequest()
-    : method(kInvalid),
-      version(kUnknown)
-  {
-  }
-
- enum Method
-{
-	 kInvalid, kGet, kPost, kHead, kPut, kDelete,kContent
-};
-enum Version
-{
-	kUnknown, kHttp10, kHttp11
-};
-
-void setVersion(Version v)
-{
-	version = v;
-}
-Version getVersion()const
-{
-	return version;
-}
-
-void setMethod()
-{
-	method = kContent;
-}
-
-bool setMethod(const char * start,const char * end)
-{
-	assert(method == kInvalid);
-	std::string m(start,end);
-	if (m == "GET")
-	{
-	  method = kGet;
-	}
-	else if (m == "POST")
-	{
-	  method = kPost;
-	}
-	else if (m == "HEAD")
-	{
-	  method = kHead;
-	}
-	else if (m == "PUT")
-	{
-	  method = kPut;
-	}
-	else if (m == "DELETE")
-	{
-	  method = kDelete;
-	}
-	else
-	{
-	  method = kInvalid;
-	}
-	
-
-	return method != kInvalid;
-
-}
-
-Method getMethod()const
-{
-	return method;
-}
-
-const char * methodString()const
-{
-	const char * result = "UNKNOWN";
-	switch(method)
-	{
-		case kGet:
-		{
-			result = "GET";
-			break;
-		}
-		case kPost:
-		{
-			result = "POST";
-			break;
-		}
-		case kHead:
-		{
-			result = "HEAD";
-			break;
-		}
-		case kPut:
-		{
-			result = "PUT";
-			break;
-		}
-		case kDelete:
-		{
-			result = "DELETE";
-			break;
-		}
-		default:
-			break;
-			
-	}
-	return result;
-}
-
-std::string &getPath()
-{
-	return path;
-}
-
-void setPath(const char *start,const char *end)
-{
-	path.assign(start,end);
-}
-
-void setQuery(const char *start,const char * end)
-{
-	query.assign(start,end);
-}
-
-const std::string &getQuery()const
-{
-	return query;
-}
-
-void setReceiveTime(int64_t t)
-{
-	receiveTime = t;
-}
-
-void addContent(const char *start,const char *colon,const char *end)
-{
-	std::string field(start,colon);
-	++colon;
-	while(colon < end && isspace(*colon))
-	{
-		++colon;
-	}
-	std::string value(colon,end);
-	while (!value.empty() && isspace(value[value.size()-1]))
-	{
-		value.resize(value.size()-1);
-	}
-	contentLength = atoi(value.c_str());
-}
-void addHeader(const char *start,const char *colon,const char *end)
-{
-	std::string field(start,colon);
-	++colon;
-	while(colon < end && isspace(*colon))
-	{
-		++colon;
-	}
-	std::string value(colon,end);
-	while (!value.empty() && isspace(value[value.size()-1]))
-	{
-		value.resize(value.size()-1);
-	}
-	headers[field] = value;
-}
-
-std::string getHeader(const std::string& field) const
-{
-	std::string result;
-	std::map<std::string, std::string>::const_iterator it = headers.find(field);
-	if (it != headers.end())
-	{
-	  result = it->second;
-	}
-	return result;
-}
-
-const std::map<std::string, std::string>& getHeaders() const
-{
-	return headers;
-}
-
-void swap(xHttpRequest& that)
-{
-	std::swap(method, that.method);
-	path.swap(that.path);
-	query.swap(that.query);
-	headers.swap(that.headers);
-}
-  
-private:
-	Method method;
-	Version version;
-	std::string path;
-	std::string query;
-	int32_t queryLength = -1;
-	std::map<std::string,std::string> headers;
-	int64_t receiveTime = -1;
-	int32_t contentLength = -1;
-};
diff --git a/src/xHttpResponse.cpp b/src/xHttpResponse.cpp
deleted file mode 100644
index edeee4de..00000000
--- a/src/xHttpResponse.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "xHttpResponse.h"
-#include "xBuffer.h"
-void xHttpResponse::appendToBuffer(xBuffer* output) const
-{
-  char buf[32];
-  snprintf(buf, sizeof buf, "HTTP/1.1 %d ", statusCode);
-  output->append(buf);
-  output->append(statusMessage);
-  output->append("\r\n");
-
-  if (closeConnection)
-  {
-    output->append("Connection: close\r\n");
-  }
-  else
-  {
-    snprintf(buf, sizeof buf, "Content-Length: %zd\r\n", body.size());
-    output->append(buf);
-    output->append("Connection: Keep-Alive\r\n");
-  }
-
-  for (std::map<std::string, std::string>::const_iterator it = headers.begin();
-       it != headers.end(); ++it)
-  {
-    output->append(it->first);
-    output->append(": ");
-    output->append(it->second);
-    output->append("\r\n");
-  }
-
-  output->append("\r\n");
-  output->append(body);
-}
diff --git a/src/xHttpResponse.h b/src/xHttpResponse.h
deleted file mode 100644
index 064307af..00000000
--- a/src/xHttpResponse.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#pragma once
-
-#include "all.h"
-
-class xBuffer;
-class xHttpResponse
-{
-public:
-	enum HttpStatusCode
-	{
-		kUnknown,
-		k2000k = 200,
-		k301MovedPermanently = 301,
-	};
-	explicit xHttpResponse(bool close)
-	:statusCode(kUnknown),
-	 closeConnection(close)
-	{
-
-	}
-
-	void setStatusCode(HttpStatusCode code)
-	{
-		statusCode = code;
-	}
-
-	void setStatusMessage(const std::string & message)
-	{
-		statusMessage = message;
-	}
-
-	void setCloseConnection(bool on)
-	{
-		closeConnection = on;
-	}
-
-	bool getCloseConnection()
-	{
-		return closeConnection;
-	}
-
-	void setContentTyoe(const std::string & contentType)
-	{
-		addHeader("Content-Type", contentType);
-	}
-
-	void addHeader(const std::string &key,const std::string &value)
-	{
-		headers[key] = value;
-	}
-
-	void setBody(const std::string &body )
-	{
-		this->body = body;
-	}
-
-	void appendToBuffer(xBuffer* output) const;
-
-
-private:
-	std::map<std::string,std::string> headers;
-	HttpStatusCode statusCode;
-	std::string statusMessage;
-	bool closeConnection;
-	std::string body;
-};
diff --git a/src/xHttpServer.cpp b/src/xHttpServer.cpp
deleted file mode 100644
index 789c5438..00000000
--- a/src/xHttpServer.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "xHttpServer.h"
-#include "xHttpContext.h"
-#include "xHttpResponse.h"
-#include "xHttpRequest.h"
-#include "xBuffer.h"
-#include "xTcpconnection.h"
-xHttpServer::xHttpServer(xEventLoop *loop,const std::string &ip,const int32_t port)
-{
-
-}
-
-
-void xHttpServer::disPlayer(const char *begin)
-{
-
-}
-
-
-xHttpServer::~xHttpServer()
-{
-
-}
-
-
-void xHttpServer::start()
-{
-	server.start();
-}
-
-void xHttpServer::onConnection(const xTcpconnectionPtr & conn)
-{
-	if(conn->connected())
-	{
-		xHttpContext context;
-		conn->setContext((void*)&context);
-	}
-}
-
-
-void xHttpServer::onMessage(const xTcpconnectionPtr &conn,xBuffer *recvBuf)
-{
-	xHttpContext * context = (xHttpContext*)(conn->getContext());
-	if(!context->parseClientRequest(recvBuf))
-	{
-		conn->send("HTTP/1.1 400 Bad Request\r\n\r\n");
-		conn->shutdown();
-	}
-
-	if(context->gotAll())
-	{
-		onRequest(conn,context->getRequest());
-		context->reset();
-	}
-
-
-}
-
-
-void xHttpServer::onRequest(const xTcpconnectionPtr & conn ,const xHttpRequest & req)
-{
-	const std::string &connection =req.getHeader("Connection");
-	bool close = connection == "close" ||
-	    (req.getVersion() == xHttpRequest::kHttp10 && connection != "Keep-Alive");
-	 xHttpResponse response(close);
-	 httpCallback(req,&response);
-	 xBuffer sendBuf;
-	 response.appendToBuffer(&sendBuf);
-	 conn->send(&sendBuf);
-	 if(response.getCloseConnection())
-	 {
-		 conn->shutdown();
-	 }
-}
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/xHttpServer.h b/src/xHttpServer.h
deleted file mode 100644
index 24656eb7..00000000
--- a/src/xHttpServer.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xTcpServer.h"
-
-class xEventLoop;
-class xHttpRequest;
-class xHttpResponse;
-
-class xHttpServer:noncopyable
-{
-public:
-	typedef std::function<void(const xHttpRequest &,xHttpResponse*)> HttpCallBack;
-
-	xHttpServer(xEventLoop *loop,const std::string &ip,const int32_t port);
-	~xHttpServer();
-	//xEventLoop *getLoop() const { server.getLoop(); }
-	void disPlayer(const char *begin);
-	void setThreadNum(int numThreads)
-	{
-		server.setThreadNum(numThreads);
-	}
-	void start();
-
-	void onConnection(const xTcpconnectionPtr & conn);
-	void onMessage(const xTcpconnectionPtr &conn,xBuffer *recvBuf);
-	void onRequest(const xTcpconnectionPtr &conn,const xHttpRequest &req);
-private:
-	xTcpServer server;
-	HttpCallBack httpCallback;
-};
diff --git a/src/xLog.cpp b/src/xLog.cpp
deleted file mode 100755
index cf7a8d6e..00000000
--- a/src/xLog.cpp
+++ /dev/null
@@ -1,537 +0,0 @@
-#include "xLog.h"
-
-const char digits[] = "9876543210123456789";
-const char digitsHex[] = "0123456789ABCDEF";
-const char* zero = digits + 9;
-template<typename T>
-size_t convert(char buf[], T value)
-{
-  T i = value;
-  char* p = buf;
-
-  do
-  {
-    int lsd = static_cast<int>(i % 10);
-    i /= 10;
-    *p++ = zero[lsd];
-  } while (i != 0);
-
-  if (value < 0)
-  {
-    *p++ = '-';
-  }
-  *p = '\0';
-  std::reverse(buf, p);
-
-  return p - buf;
-}
-
-
-size_t convertHex(char buf[], uintptr_t value)
-{
-  uintptr_t i = value;
-  char* p = buf;
-
-  do
-  {
-    int lsd = static_cast<int>(i % 16);
-    i /= 16;
-    *p++ = digitsHex[lsd];
-  } while (i != 0);
-
-  *p = '\0';
-  std::reverse(buf, p);
-
-  return p - buf;
-}
-
-AppendFile::AppendFile(std::string  &filename)
-  : fp(::fopen(filename.c_str(), "ae")),  // 'e' for O_CLOEXEC
-    writtenBytes(0)
-{
-  assert(fp);
-  ::setbuffer(fp, buffer, sizeof buffer);
-}
-
-AppendFile::~AppendFile()
-{
-  ::fclose(fp);
-}
-
-void AppendFile::append(const char* logline, const size_t len)
-{
-  size_t n = write(logline, len);
-  size_t remain = len - n;
-  while (remain > 0)
-  {
-    size_t x = write(logline + n, remain);
-    if (x == 0)
-    {
-      int err = ferror(fp);
-      if (err)
-      {
-        //fprintf(stderr, "AppendFile::append() failed %s\n", strerror_tl(err));
-      }
-      break;
-    }
-    n += x;
-    remain = len - n; // remain -= x
-  }
-
-  writtenBytes += len;
-}
-
-void AppendFile::flush()
-{
-  ::fflush(fp);
-}
-
-size_t AppendFile::write(const char* logline, size_t len)
-{
-  // #undef fwrite_unlocked
-  return ::fwrite_unlocked(logline, 1, len, fp);
-}
-
-
-
-xLogFile::xLogFile(const std::string& basename,
-                 size_t rollSize,
-                 bool threadSafe,
-                 int flushInterval,
-                 int checkEveryN)
-  : basename(basename),
-    rollSize(rollSize),
-    flushInterval(flushInterval),
-    checkEveryN(checkEveryN),
-    count(0),
-    startOfPeriod(0),
-    lastRoll(0),
-    lastFlush(0)
-{
-  assert(basename.find('/') == std::string::npos);
-  rollFile();
-}
-
-xLogFile::~xLogFile()
-{
-}
-
-void xLogFile::append(const char* logline, int len)
-{
-	std::unique_lock<std::mutex> lk(mutex);
-	append_unlocked(logline, len);
-}
-
-void xLogFile::flush()
-{
-	std::unique_lock<std::mutex> lk(mutex);
-	file->flush();
-
-}
-
-void xLogFile::append_unlocked(const char* logline, int len)
-{
-  file->append(logline, len);
-
-  if (file->getWrittenBytes() > rollSize)
-  {
-    rollFile();
-  }
-  else
-  {
-    ++count;
-    if (count >= checkEveryN)
-    {
-      count = 0;
-      time_t now = ::time(NULL);
-      time_t thisPeriod = now / kRollPerSeconds * kRollPerSeconds;
-      if (thisPeriod != startOfPeriod)
-      {
-        rollFile();
-      }
-      else if (now - lastFlush > flushInterval)
-      {
-        lastFlush = now;
-        file->flush();
-      }
-    }
-  }
-}
-
-bool xLogFile::rollFile()
-{
-  time_t now = 0;
-  std::string filename = getLogFileName(basename, &now);
-  time_t start = now / kRollPerSeconds* kRollPerSeconds;
-
-  if (now > lastRoll)
-  {
-    lastRoll = now;
-    lastFlush = now;
-    startOfPeriod = start;
-    file.reset(new AppendFile(filename));
-    return true;
-  }
-  return false;
-}
-
-std::string xLogFile::getLogFileName(const std::string& basename, time_t* now)
-{
-  std::string filename;
-  filename.reserve(basename.size() + 64);
-  filename = basename;
-
-  char timebuf[32];
-  struct tm tm;
-  *now = time(NULL);
-  gmtime_r(now, &tm); // FIXME: localtime_r ?
-  strftime(timebuf, sizeof timebuf, ".%Y%m%d-%H%M%S", &tm);
-  filename += timebuf;
-  filename += ".log";
-  return filename;
-}
-
-
-
-
-xAsyncLogging::xAsyncLogging(std::string baseName,size_t rollSize,int flushInterval)
-:baseName(baseName),
-flushInterval(flushInterval),
-running(false),
-rollSize(rollSize),
-thread(nullptr),
-currentBuffer(new Buffer),
-nextBuffer(new Buffer),
-buffers()
-{
-	currentBuffer->bzero();
-	nextBuffer->bzero();
-	buffers.reserve(16);
-}
-
-void xAsyncLogging::append(const char * logline,int len)
-{
-	std::unique_lock<std::mutex> lk(mutex);
-	if(currentBuffer->avail() > len)
-	{
-		currentBuffer->append(logline,len);
-	}
-	else
-	{
-		buffers.push_back(std::unique_ptr<Buffer>(currentBuffer.release()));
-		if(nextBuffer)
-		{
-			currentBuffer = std::move(nextBuffer);
-		}
-		else
-		{
-			currentBuffer.reset(new Buffer);
-		}
-
-		currentBuffer->append(logline,len);
-		condition.notify_one();
-
-
-	}
-
-
-}
-
-void xAsyncLogging::threadFunc()
-{
-
-	xLogFile output(baseName,rollSize,false);
-	BufferPtr newBuffer1(new Buffer);
-	BufferPtr newBuffer2(new Buffer);
-	newBuffer1->bzero();
-	newBuffer2->bzero();
-
-	BufferVector buffersToWrite;
-	buffersToWrite.reserve(16);
-
-	running = true;
-	condition.notify_one();
-
-	while(running)
-	{
-		assert(newBuffer1 && newBuffer1->length() == 0);
-		assert(newBuffer2 && newBuffer2->length() == 0);
-		assert(buffersToWrite.empty());
-		{
-			std::unique_lock<std::mutex> lk(mutex);
-			if(buffers.empty())
-			{
-				condition.wait_for(lk,std::chrono::seconds(3));
-			}
-
-			buffers.push_back(std::unique_ptr<Buffer>(currentBuffer.release()));
-			currentBuffer  = std::move(newBuffer1);
-			buffersToWrite.swap(buffers);
-
-			if(!nextBuffer)
-			{
-				nextBuffer = std::move(newBuffer2);
-			}
-		}
-
-		assert(!buffersToWrite.empty());
-
-		if(buffersToWrite.size() > 25)
-		{
-
-		}
-
-		for (size_t i = 0; i < buffersToWrite.size(); ++i)
-		{
-			// FIXME: use unbuffered stdio FILE ? or use ::writev ?
-			output.append(buffersToWrite[i]->getData(), buffersToWrite[i]->length());
-		}
-
-		if (buffersToWrite.size() > 2)
-		{
-			// drop non-bzero-ed buffers, avoid trashing
-			buffersToWrite.resize(2);
-		}
-
-		if (!newBuffer1)
-		{
-			assert(!buffersToWrite.empty());
-			newBuffer1 = std::move(buffersToWrite.back());
-			buffersToWrite.pop_back();
-			newBuffer1->reset();
-		}
-
-		if (!newBuffer2)
-		{
-			assert(!buffersToWrite.empty());
-			newBuffer2 = std::move(buffersToWrite.back());
-			buffersToWrite.pop_back();
-			newBuffer2->reset();
-		}
-
-		buffersToWrite.clear();
-		output.flush();
-
-
-	}
-	output.flush();
-
-}
-
-
-template<typename T>
-void xLogStream::formatInteger(T v)
-{
-  if (buffer.avail() >= kMaxNumericSize)
-  {
-    size_t len = convert(buffer.current(), v);
-    buffer.add(len);
-  }
-}
-
-
-
-xLogStream& xLogStream::operator<<(short v)
-{
-  *this << static_cast<int>(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(unsigned short v)
-{
-  *this << static_cast<unsigned int>(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(int v)
-{
-  formatInteger(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(unsigned int v)
-{
-  formatInteger(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(long v)
-{
-  formatInteger(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(unsigned long v)
-{
-  formatInteger(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(long long v)
-{
-  formatInteger(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(unsigned long long v)
-{
-  formatInteger(v);
-  return *this;
-}
-
-xLogStream& xLogStream::operator<<(const void* p)
-{
-  uintptr_t v = reinterpret_cast<uintptr_t>(p);
-  if (buffer.avail() >= kMaxNumericSize)
-  {
-    char* buf = buffer.current();
-    buf[0] = '0';
-    buf[1] = 'x';
-    size_t len = convertHex(buf+2, v);
-    buffer.add(len+2);
-  }
-  return *this;
-}
-
-// FIXME: replace this with Grisu3 by Florian Loitsch.
-xLogStream& xLogStream::operator<<(double v)
-{
-  if (buffer.avail() >= kMaxNumericSize)
-  {
-    int len = snprintf(buffer.current(), kMaxNumericSize, "%.12g", v);
-    buffer.add(len);
-  }
-  return *this;
-}
-
-
-
-xLogger::LogLevel initLogLevel()
-{
-  if (::getenv("TRACE"))
-    return xLogger::TRACE;
-  else if (::getenv("DEBUG"))
-    return xLogger::DEBUG;
-  else
-    return xLogger::INFO;
-}
-
-xLogger::LogLevel g_logLevel = initLogLevel();
-
-
-const char* LogLevelName[xLogger::NUM_LOG_LEVELS] =
-{
-  "TRACE ",
-  "DEBUG ",
-  "INFO  ",
-  "WARN  ",
-  "ERROR ",
-  "FATAL ",
-};
-
-
-
-void defaultOutput(const char* msg, int len)
-{
-  size_t n = fwrite(msg, 1, len, stdout);
-  //FIXME check n
-  (void)n;
-  printf("%s\n",msg);
-}
-
-void defaultFlush()
-{
-  fflush(stdout);
-}
-
-
-
-
-xLogger::OutputFunc g_output = defaultOutput;
-xLogger::FlushFunc g_flush = defaultFlush;
-
-
-xLogger::xImpl::xImpl(LogLevel level, int savedErrno, const xSourceFile& file, int line)
-  : stream(),
-    level(level),
-    line(line),
-    baseName(file)
-{
-	formatTime();
-}
-
-void xLogger::xImpl::formatTime()
-{
-	char t_time[32];
-	char timebuf[32];
-	struct tm tm_time;
-	time_t now = time(0);
-	gmtime_r(&now, &tm_time);
-	 int len = snprintf(t_time, sizeof(t_time), "%4d%02d%02d %02d:%02d:%02d",
-	tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday,
-	tm_time.tm_hour + 8, tm_time.tm_min, tm_time.tm_sec);
-	assert(len == 17); (void)len;
-	stream<<T(t_time,17);
-	stream<<"  ";
-
-}
-
-
-void xLogger::xImpl::finish()
-{
-	stream << "  " << T(baseName.data,baseName.size)<< ':' << line<<"\r";
-}
-
-xLogger::xLogger(xSourceFile file, int line)
- :impl(INFO, 0, file, line)
-{
-}
-
-xLogger::xLogger(xSourceFile file, int line, LogLevel level, const char* func)
-  : impl(level, 0, file, line)
-{
-  impl.stream << func << ' ';
-}
-
-xLogger::xLogger(xSourceFile file, int line, LogLevel level)
-  : impl(level, 0, file, line)
-{
-}
-
-xLogger::xLogger(xSourceFile file, int line, bool toAbort)
-  : impl(toAbort?FATAL:ERROR, errno, file, line)
-{
-}
-
-
-
-xLogger::~xLogger()
-{
-	impl.finish();
-
-	const xLogStream::Buffer& buf(stream().getBuffer());
-	g_output(buf.getData(), buf.length());
-	if (impl.level == FATAL)
-	{
-		g_flush();
-		abort();
-	}
-
-
-}
-
-
-void xLogger::setLogLevel(xLogger::LogLevel level)
-{
-  g_logLevel = level;
-}
-
-void xLogger::setOutput(OutputFunc out)
-{
-  g_output = out;
-}
-
-void xLogger::setFlush(FlushFunc flush)
-{
-  g_flush = flush;
-}
diff --git a/src/xLog.h b/src/xLog.h
deleted file mode 100644
index eda2ab49..00000000
--- a/src/xLog.h
+++ /dev/null
@@ -1,336 +0,0 @@
-#pragma once
-#include "all.h"
-const int kSmallBuffer = 4000;
-const int kLargeBuffer = 4000*10;
-
-template<int SIZE>
-class xFixedBuffer:noncopyable
-{
-public:
-	xFixedBuffer():cur(data){}
-	~xFixedBuffer(){}
-
-	void append(const char *buf,size_t len)
-	{
-		if(avail() > len)
-		{
-			memcpy(cur,buf,len);
-			cur+=len;
-		}
-	}
-
-	const char * getData()const { return data; }
-	int length() const { return static_cast<int>(cur - data); }
-	char *current() { return cur; }
-	void add(size_t len) { cur +=len; }
-
-	void reset(){ cur = data;}
-	void bzero(){ ::bzero(data,sizeof data); }
-
-	std::string toString() const { return std::string(data, length()); }
-	int  avail() const { return static_cast<int>(end() - cur); }
-	const char* end() const { return data + sizeof data; }
-private:
-	char data[SIZE];
-	char *cur;
-};
-
-
-class AppendFile : noncopyable
-{
- public:
-  explicit AppendFile(std::string  &filename);
-
-  ~AppendFile();
-
-  void append(const char* logline, const size_t len);
-
-  void flush();
-
-  size_t getWrittenBytes() const { return writtenBytes; }
-
- private:
-
-  size_t write(const char* logline, size_t len);
-
-  FILE* fp;
-  char buffer[64*1024];
-  size_t writtenBytes;
-};
-
-
-class xLogFile :noncopyable
-{
- public:
-	xLogFile(const std::string& basename,
-          size_t rollSize,
-          bool threadSafe = true,
-          int flushInterval = 3,
-          int checkEveryN = 1024);
-  ~xLogFile();
-
-  void append(const char* logline, int len);
-  void flush();
-  bool rollFile();
-
- private:
-  void append_unlocked(const char* logline, int len);
-
-  static std::string getLogFileName(const std::string& basename, time_t* now);
-
-  const std::string basename;
-  const size_t rollSize;
-  const int flushInterval;
-  const int checkEveryN;
-
-  int count;
-
-  mutable std::mutex mutex;
-  time_t startOfPeriod;
-  time_t lastRoll;
-  time_t lastFlush;
-  std::unique_ptr<AppendFile> file;
-
-  const static int kRollPerSeconds = 60*60*24;
-};
-
-
-
-class xAsyncLogging:noncopyable
-{
-public:
-	xAsyncLogging(std::string baseName,size_t rollSize,int flushInterval = 3);
-	~xAsyncLogging()
-	{
-		if(running)
-		{
-			stop();
-		}
-	
-	}
-
-	void stop()
-	{
-		running = false;
-		condition.notify_one();
-		thread->join();
-	}
-
-	void start()
-	{
-		thread = new std::thread(std::bind(&xAsyncLogging::threadFunc,this));
-		std::unique_lock<std::mutex> lock(mutex);
-		while(!running)
-		{
-			condition.wait(lock);
-		}
-	}
-
-	void append(const char * loline,int len);
-private:
-	void threadFunc();
-
-	typedef xFixedBuffer<kLargeBuffer> Buffer;
-	typedef std::vector<std::unique_ptr<Buffer>> BufferVector;
-	typedef std::unique_ptr<Buffer> BufferPtr;
-	std::string baseName;
-	const int flushInterval;
-	bool running;
-	size_t rollSize;
-	std::thread * thread;
-	mutable std::mutex mutex;
-	std::condition_variable condition;
-	BufferPtr currentBuffer;
-	BufferPtr nextBuffer;
-	BufferVector buffers;
-};
-
-
-
-class T
-{
- public:
-	T(const char* str)
-	: str(str), len(static_cast<int>(strlen(str))) { }
-	T(const std::string& str)
-	:str(str.data()), len(static_cast<int>(str.size())) { }
-	T(const char* str, unsigned len)
-	:str(str),len(len) {}
-	const char* str;
-	const unsigned len;
-};
-
-
-
-class xLogStream : noncopyable
-{
-public:
-	typedef xLogStream self;
-	typedef xFixedBuffer<kSmallBuffer>  Buffer;
-
-	self& operator<<(bool v)
-	{
-		buffer.append(v ? "1" : "0", 1);
-		return *this;
-	}
-
-	self& operator<<(short);
-	self& operator<<(unsigned short);
-	self& operator<<(int);
-	self& operator<<(unsigned int);
-	self& operator<<(long);
-	self& operator<<(unsigned long);
-	self& operator<<(long long);
-	self& operator<<(unsigned long long);
-	self& operator<<(const void*);
-	self& operator<<(float v)
-	{
-		*this << static_cast<double>(v);
-		return *this;
-	}
-	self& operator<<(double);
-
-	self& operator<<(char v)
-	{
-		buffer.append(&v, 1);
-		return *this;
-	}
-
-	self& operator<<(const char* str)
-	{
-		if (str)
-		{
-		  buffer.append(str, strlen(str));
-		}
-		else
-		{
-		  buffer.append("(null)", 6);
-		}
-		return *this;
-	}
-
-	self& operator<<(const unsigned char* str)
-	{
-		return operator<<(reinterpret_cast<const char*>(str));
-	}
-
-	self& operator<<(const std::string& v)
-	{
-		buffer.append(v.c_str(), v.size());
-		return *this;
-	}
-
-	self& operator<<(const T & v)
-	{
-		buffer.append(v.str, v.len);
-		return *this;
-	}
-
-	void append(const char* data, int len) { buffer.append(data, len); }
-	const Buffer& getBuffer() const { return buffer; }
-	void resetBuffer() { buffer.reset(); }
-public:
-	template<typename T>
-	void formatInteger(T);
-
-	Buffer buffer;
-	static const int kMaxNumericSize = 32;
-};
-
-class xLogger
-{
-public:
-	enum LogLevel
-	  {
-		TRACE,
-		DEBUG,
-		INFO,
-		WARN,
-		ERROR,
-		FATAL,
-		NUM_LOG_LEVELS,
-	  };
-
-	class xSourceFile
-	{
-	public:
-		template<int N>
-		inline xSourceFile(const char (&arr)[N])
-		:data(arr),
-		 size(N-1)
-		{
-			const  char * slash = strrchr(data,'/');
-			if(slash)
-			{
-				data = slash + 1;
-				size -= static_cast<int>(data - arr);
-			}
-		}
-
-		explicit xSourceFile(const  char * fileName)
-		:data(fileName)
-		{
-			const char * slash = strrchr(fileName,'/');
-			if(slash)
-			{
-				data = slash + 1;
-			}
-			size = static_cast<int> (strlen(data));
-		}
-		const char * data;
-		int size;
-	};
-
-	xLogger(xSourceFile file, int line);
-	xLogger(xSourceFile file, int line, LogLevel level);
-	xLogger(xSourceFile file, int line, LogLevel level, const char* func);
-	xLogger(xSourceFile file, int line, bool toAbort);
-	~xLogger();
-
-	xLogStream& stream() { return impl.stream; }
-
-	static LogLevel logLevel();
-	static void setLogLevel(LogLevel level);
-
-	typedef void (*OutputFunc)(const char* msg, int len);
-	typedef void (*FlushFunc)();
-
-	static void setOutput(OutputFunc);
-	static void setFlush(FlushFunc);
-
-private:
-	class xImpl
-	{
-	public:
-		 typedef xLogger::LogLevel LogLevel;
-		 xImpl(LogLevel level,int oldErrno,const xSourceFile &file, int line);
-		 void formatTime();
-		 void finish();
-
-		 xLogStream stream;
-		 LogLevel level;
-		 int line;
-		 xSourceFile baseName;
-	};
-	xImpl impl;
-};
-
-extern xLogger::LogLevel g_logLevel;
-inline xLogger::LogLevel xLogger::logLevel()
-{
-  return g_logLevel;
-}
-
-#define LOG_TRACE if (xLogger::logLevel() <= xLogger::TRACE) \
-  xLogger(__FILE__, __LINE__, xLogger::TRACE, __func__).stream()
-#define LOG_DEBUG if (xLogger::logLevel() <= xLogger::DEBUG) \
-  xLogger(__FILE__, __LINE__, xLogger::DEBUG, __func__).stream()
-#define LOG_INFO xLogger(__FILE__, __LINE__).stream()
-#define LOG_WARN xLogger(__FILE__, __LINE__, xLogger::WARN).stream()
-#define LOG_ERROR xLogger(__FILE__, __LINE__, xLogger::ERROR).stream()
-#define LOG_FATAL xLogger(__FILE__, __LINE__, xLogger::FATAL).stream()
-#define LOG_SYSERR xLogger(__FILE__, __LINE__, false).stream()
-#define LOG_SYSFATAL xLogger(__FILE__, __LINE__, true).stream()
-
-
-
diff --git a/src/xLzf.cpp b/src/xLzf.cpp
deleted file mode 100644
index 8c9ef90a..00000000
--- a/src/xLzf.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
- * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp@schmorp.de>
- *
- * Redistribution and use in source and binary forms, with or without modifica-
- * tion, are permitted provided that the following conditions are met:
- *
- *   1.  Redistributions of source code must retain the above copyright notice,
- *       this list of conditions and the following disclaimer.
- *
- *   2.  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 AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
- * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
- * CIAL, 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 OTH-
- * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Alternatively, the contents of this file may be used under the terms of
- * the GNU General Public License ("GPL") version 2 or any later version,
- * in which case the provisions of the GPL are applicable instead of
- * the above. If you wish to allow the use of your version of this file
- * only under the terms of the GPL and not to allow others to use your
- * version of this file under the BSD license, indicate your decision
- * by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL. If you do not delete the
- * provisions above, a recipient may use your version of this file under
- * either the BSD or the GPL.
- */
-
-#include "xLzfp.h"
-
-#define HSIZE (1 << (HLOG))
-
-/*
- * don't play with this unless you benchmark!
- * the data format is not dependent on the hash function.
- * the hash function might seem strange, just believe me,
- * it works ;)
- */
-#ifndef FRST
-# define FRST(p) (((p[0]) << 8) | p[1])
-# define NEXT(v,p) (((v) << 8) | p[2])
-# if ULTRA_FAST
-#  define IDX(h) ((( h             >> (3*8 - HLOG)) - h  ) & (HSIZE - 1))
-# elif VERY_FAST
-#  define IDX(h) ((( h             >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
-# else
-#  define IDX(h) ((((h ^ (h << 5)) >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
-# endif
-#endif
-/*
- * IDX works because it is very similar to a multiplicative hash, e.g.
- * ((h * 57321 >> (3*8 - HLOG)) & (HSIZE - 1))
- * the latter is also quite fast on newer CPUs, and compresses similarly.
- *
- * the next one is also quite good, albeit slow ;)
- * (int)(cos(h & 0xffffff) * 1e6)
- */
-
-#if 0
-/* original lzv-like hash function, much worse and thus slower */
-# define FRST(p) (p[0] << 5) ^ p[1]
-# define NEXT(v,p) ((v) << 5) ^ p[2]
-# define IDX(h) ((h) & (HSIZE - 1))
-#endif
-
-#define        MAX_LIT        (1 <<  5)
-#define        MAX_OFF        (1 << 13)
-#define        MAX_REF        ((1 << 8) + (1 << 3))
-
-#if __GNUC__ >= 3
-# define expect(expr,value)         __builtin_expect ((expr),(value))
-# define inline                     inline
-#else
-# define expect(expr,value)         (expr)
-# define inline                     static
-#endif
-
-#define expect_false(expr) expect ((expr) != 0, 0)
-#define expect_true(expr)  expect ((expr) != 0, 1)
-
-/*
- * compressed format
- *
- * 000LLLLL <L+1>    ; literal, L+1=1..33 octets
- * LLLooooo oooooooo ; backref L+1=1..7 octets, o+1=1..4096 offset
- * 111ooooo LLLLLLLL oooooooo ; backref L+8 octets, o+1=1..4096 offset
- *
- */
-
-unsigned int
-lzf_compress (const void *const in_data, unsigned int in_len,
-	      void *out_data, unsigned int out_len
-#if LZF_STATE_ARG
-              , LZF_STATE htab
-#endif
-              )
-{
-#if !LZF_STATE_ARG
-  LZF_STATE htab;
-#endif
-  const u8 *ip = (const u8 *)in_data;
-        u8 *op = (u8 *)out_data;
-  const u8 *in_end  = ip + in_len;
-        u8 *out_end = op + out_len;
-  const u8 *ref;
-
-  /* off requires a type wide enough to hold a general pointer difference.
-   * ISO C doesn't have that (size_t might not be enough and ptrdiff_t only
-   * works for differences within a single object). We also assume that no
-   * no bit pattern traps. Since the only platform that is both non-POSIX
-   * and fails to support both assumptions is windows 64 bit, we make a
-   * special workaround for it.
-   */
-#if defined (WIN32) && defined (_M_X64)
-  unsigned _int64 off; /* workaround for missing POSIX compliance */
-#else
-  unsigned long off;
-#endif
-  unsigned int hval;
-  int lit;
-
-  if (!in_len || !out_len)
-    return 0;
-
-#if INIT_HTAB
-  memset (htab, 0, sizeof (htab));
-#endif
-
-  lit = 0; op++; /* start run */
-
-  hval = FRST (ip);
-  while (ip < in_end - 2)
-    {
-      LZF_HSLOT *hslot;
-
-      hval = NEXT (hval, ip);
-      hslot = htab + IDX (hval);
-      ref = *hslot + LZF_HSLOT_BIAS; *hslot = ip - LZF_HSLOT_BIAS;
-
-      if (1
-#if INIT_HTAB
-          && ref < ip /* the next test will actually take care of this, but this is faster */
-#endif
-          && (off = ip - ref - 1) < MAX_OFF
-          && ref > (u8 *)in_data
-          && ref[2] == ip[2]
-#if STRICT_ALIGN
-          && ((ref[1] << 8) | ref[0]) == ((ip[1] << 8) | ip[0])
-#else
-          && *(u16 *)ref == *(u16 *)ip
-#endif
-        )
-        {
-          /* match found at *ref++ */
-          unsigned int len = 2;
-          unsigned int maxlen = in_end - ip - len;
-          maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
-
-          if (expect_false (op + 3 + 1 >= out_end)) /* first a faster conservative test */
-            if (op - !lit + 3 + 1 >= out_end) /* second the exact but rare test */
-              return 0;
-
-          op [- lit - 1] = lit - 1; /* stop run */
-          op -= !lit; /* undo run if length is zero */
-
-          for (;;)
-            {
-              if (expect_true (maxlen > 16))
-                {
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                  len++; if (ref [len] != ip [len]) break;
-                }
-
-              do
-                len++;
-              while (len < maxlen && ref[len] == ip[len]);
-
-              break;
-            }
-
-          len -= 2; /* len is now #octets - 1 */
-          ip++;
-
-          if (len < 7)
-            {
-              *op++ = (off >> 8) + (len << 5);
-            }
-          else
-            {
-              *op++ = (off >> 8) + (  7 << 5);
-              *op++ = len - 7;
-            }
-
-          *op++ = off;
-
-          lit = 0; op++; /* start run */
-
-          ip += len + 1;
-
-          if (expect_false (ip >= in_end - 2))
-            break;
-
-#if ULTRA_FAST || VERY_FAST
-          --ip;
-# if VERY_FAST && !ULTRA_FAST
-          --ip;
-# endif
-          hval = FRST (ip);
-
-          hval = NEXT (hval, ip);
-          htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
-          ip++;
-
-# if VERY_FAST && !ULTRA_FAST
-          hval = NEXT (hval, ip);
-          htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
-          ip++;
-# endif
-#else
-          ip -= len + 1;
-
-          do
-            {
-              hval = NEXT (hval, ip);
-              htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
-              ip++;
-            }
-          while (len--);
-#endif
-        }
-      else
-        {
-          /* one more literal byte we must copy */
-          if (expect_false (op >= out_end))
-            return 0;
-
-          lit++; *op++ = *ip++;
-
-          if (expect_false (lit == MAX_LIT))
-            {
-              op [- lit - 1] = lit - 1; /* stop run */
-              lit = 0; op++; /* start run */
-            }
-        }
-    }
-
-  if (op + 3 > out_end) /* at most 3 bytes can be missing here */
-    return 0;
-
-  while (ip < in_end)
-    {
-      lit++; *op++ = *ip++;
-
-      if (expect_false (lit == MAX_LIT))
-        {
-          op [- lit - 1] = lit - 1; /* stop run */
-          lit = 0; op++; /* start run */
-        }
-    }
-
-  op [- lit - 1] = lit - 1; /* end run */
-  op -= !lit; /* undo run if length is zero */
-
-  return op - (u8 *)out_data;
-}
-
diff --git a/src/xLzf.h b/src/xLzf.h
deleted file mode 100644
index 87259f4b..00000000
--- a/src/xLzf.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#define LZF_VERSION 0x0105 /* 1.5, API version */
-unsigned int
-lzf_compress (const void *const in_data,  unsigned int in_len,
-              void             *out_data, unsigned int out_len);
-
-unsigned int
-lzf_decompress (const void *const in_data,  unsigned int in_len,
-                void             *out_data, unsigned int out_len);
-
-
diff --git a/src/xLzfd.cpp b/src/xLzfd.cpp
deleted file mode 100644
index 01c615dd..00000000
--- a/src/xLzfd.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp@schmorp.de>
- *
- * Redistribution and use in source and binary forms, with or without modifica-
- * tion, are permitted provided that the following conditions are met:
- *
- *   1.  Redistributions of source code must retain the above copyright notice,
- *       this list of conditions and the following disclaimer.
- *
- *   2.  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 AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
- * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
- * CIAL, 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 OTH-
- * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Alternatively, the contents of this file may be used under the terms of
- * the GNU General Public License ("GPL") version 2 or any later version,
- * in which case the provisions of the GPL are applicable instead of
- * the above. If you wish to allow the use of your version of this file
- * only under the terms of the GPL and not to allow others to use your
- * version of this file under the BSD license, indicate your decision
- * by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL. If you do not delete the
- * provisions above, a recipient may use your version of this file under
- * either the BSD or the GPL.
- */
-
-#include "xLzfp.h"
-
-#if AVOID_ERRNO
-# define SET_ERRNO(n)
-#else
-# include <errno.h>
-# define SET_ERRNO(n) errno = (n)
-#endif
-
-#if USE_REP_MOVSB /* small win on amd, big loss on intel */
-#if (__i386 || __amd64) && __GNUC__ >= 3
-# define lzf_movsb(dst, src, len)                \
-   asm ("rep movsb"                              \
-        : "=D" (dst), "=S" (src), "=c" (len)     \
-        :  "0" (dst),  "1" (src),  "2" (len));
-#endif
-#endif
-
-unsigned int
-lzf_decompress (const void *const in_data,  unsigned int in_len,
-                void             *out_data, unsigned int out_len)
-{
-  u8 const *ip = (const u8 *)in_data;
-  u8       *op = (u8 *)out_data;
-  u8 const *const in_end  = ip + in_len;
-  u8       *const out_end = op + out_len;
-
-  do
-    {
-      unsigned int ctrl = *ip++;
-
-      if (ctrl < (1 << 5)) /* literal run */
-        {
-          ctrl++;
-
-          if (op + ctrl > out_end)
-            {
-              SET_ERRNO (E2BIG);
-              return 0;
-            }
-
-#if CHECK_INPUT
-          if (ip + ctrl > in_end)
-            {
-              SET_ERRNO (EINVAL);
-              return 0;
-            }
-#endif
-
-#ifdef lzf_movsb
-          lzf_movsb (op, ip, ctrl);
-#else
-          switch (ctrl)
-            {
-              case 32: *op++ = *ip++; case 31: *op++ = *ip++; case 30: *op++ = *ip++; case 29: *op++ = *ip++;
-              case 28: *op++ = *ip++; case 27: *op++ = *ip++; case 26: *op++ = *ip++; case 25: *op++ = *ip++;
-              case 24: *op++ = *ip++; case 23: *op++ = *ip++; case 22: *op++ = *ip++; case 21: *op++ = *ip++;
-              case 20: *op++ = *ip++; case 19: *op++ = *ip++; case 18: *op++ = *ip++; case 17: *op++ = *ip++;
-              case 16: *op++ = *ip++; case 15: *op++ = *ip++; case 14: *op++ = *ip++; case 13: *op++ = *ip++;
-              case 12: *op++ = *ip++; case 11: *op++ = *ip++; case 10: *op++ = *ip++; case  9: *op++ = *ip++;
-              case  8: *op++ = *ip++; case  7: *op++ = *ip++; case  6: *op++ = *ip++; case  5: *op++ = *ip++;
-              case  4: *op++ = *ip++; case  3: *op++ = *ip++; case  2: *op++ = *ip++; case  1: *op++ = *ip++;
-            }
-#endif
-        }
-      else /* back reference */
-        {
-          unsigned int len = ctrl >> 5;
-
-          u8 *ref = op - ((ctrl & 0x1f) << 8) - 1;
-
-#if CHECK_INPUT
-          if (ip >= in_end)
-            {
-              SET_ERRNO (EINVAL);
-              return 0;
-            }
-#endif
-          if (len == 7)
-            {
-              len += *ip++;
-#if CHECK_INPUT
-              if (ip >= in_end)
-                {
-                  SET_ERRNO (EINVAL);
-                  return 0;
-                }
-#endif
-            }
-
-          ref -= *ip++;
-
-          if (op + len + 2 > out_end)
-            {
-              SET_ERRNO (E2BIG);
-              return 0;
-            }
-
-          if (ref < (u8 *)out_data)
-            {
-              SET_ERRNO (EINVAL);
-              return 0;
-            }
-
-#ifdef lzf_movsb
-          len += 2;
-          lzf_movsb (op, ref, len);
-#else
-          switch (len)
-            {
-              default:
-                len += 2;
-
-                if (op >= ref + len)
-                  {
-                    /* disjunct areas */
-                    memcpy (op, ref, len);
-                    op += len;
-                  }
-                else
-                  {
-                    /* overlapping, use octte by octte copying */
-                    do
-                      *op++ = *ref++;
-                    while (--len);
-                  }
-
-                break;
-
-              case 9: *op++ = *ref++;
-              case 8: *op++ = *ref++;
-              case 7: *op++ = *ref++;
-              case 6: *op++ = *ref++;
-              case 5: *op++ = *ref++;
-              case 4: *op++ = *ref++;
-              case 3: *op++ = *ref++;
-              case 2: *op++ = *ref++;
-              case 1: *op++ = *ref++;
-              case 0: *op++ = *ref++; /* two octets more */
-                      *op++ = *ref++;
-            }
-#endif
-        }
-    }
-  while (ip < in_end);
-
-  return op - (u8 *)out_data;
-}
-
diff --git a/src/xLzfp.h b/src/xLzfp.h
deleted file mode 100644
index cfd139e6..00000000
--- a/src/xLzfp.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp@schmorp.de>
- *
- * Redistribution and use in source and binary forms, with or without modifica-
- * tion, are permitted provided that the following conditions are met:
- *
- *   1.  Redistributions of source code must retain the above copyright notice,
- *       this list of conditions and the following disclaimer.
- *
- *   2.  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 AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
- * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
- * CIAL, 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 OTH-
- * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Alternatively, the contents of this file may be used under the terms of
- * the GNU General Public License ("GPL") version 2 or any later version,
- * in which case the provisions of the GPL are applicable instead of
- * the above. If you wish to allow the use of your version of this file
- * only under the terms of the GPL and not to allow others to use your
- * version of this file under the BSD license, indicate your decision
- * by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL. If you do not delete the
- * provisions above, a recipient may use your version of this file under
- * either the BSD or the GPL.
- */
-
-
-#pragma once
-
-#define STANDALONE 1 /* at the moment, this is ok. */
-
-#ifndef STANDALONE
-# include "xLzf.h"
-#endif
-
-/*
- * Size of hashtable is (1 << HLOG) * sizeof (char *)
- * decompression is independent of the hash table size
- * the difference between 15 and 14 is very small
- * for small blocks (and 14 is usually a bit faster).
- * For a low-memory/faster configuration, use HLOG == 13;
- * For best compression, use 15 or 16 (or more, up to 22).
- */
-#ifndef HLOG
-# define HLOG 16
-#endif
-
-/*
- * Sacrifice very little compression quality in favour of compression speed.
- * This gives almost the same compression as the default code, and is
- * (very roughly) 15% faster. This is the preferred mode of operation.
- */
-#ifndef VERY_FAST
-# define VERY_FAST 1
-#endif
-
-/*
- * Sacrifice some more compression quality in favour of compression speed.
- * (roughly 1-2% worse compression for large blocks and
- * 9-10% for small, redundant, blocks and >>20% better speed in both cases)
- * In short: when in need for speed, enable this for binary data,
- * possibly disable this for text data.
- */
-#ifndef ULTRA_FAST
-# define ULTRA_FAST 0
-#endif
-
-/*
- * Unconditionally aligning does not cost very much, so do it if unsure
- */
-#ifndef STRICT_ALIGN
-# define STRICT_ALIGN !(defined(__i386) || defined (__amd64))
-#endif
-
-/*
- * You may choose to pre-set the hash table (might be faster on some
- * modern cpus and large (>>64k) blocks, and also makes compression
- * deterministic/repeatable when the configuration otherwise is the same).
- */
-#ifndef INIT_HTAB
-# define INIT_HTAB 0
-#endif
-
-/*
- * Avoid assigning values to errno variable? for some embedding purposes
- * (linux kernel for example), this is necessary. NOTE: this breaks
- * the documentation in lzf.h. Avoiding errno has no speed impact.
- */
-#ifndef AVOID_ERRNO
-# define AVOID_ERRNO 0
-#endif
-
-/*
- * Whether to pass the LZF_STATE variable as argument, or allocate it
- * on the stack. For small-stack environments, define this to 1.
- * NOTE: this breaks the prototype in lzf.h.
- */
-#ifndef LZF_STATE_ARG
-# define LZF_STATE_ARG 0
-#endif
-
-/*
- * Whether to add extra checks for input validity in lzf_decompress
- * and return EINVAL if the input stream has been corrupted. This
- * only shields against overflowing the input buffer and will not
- * detect most corrupted streams.
- * This check is not normally noticeable on modern hardware
- * (<1% slowdown), but might slow down older cpus considerably.
- */
-#ifndef CHECK_INPUT
-# define CHECK_INPUT 1
-#endif
-
-/*
- * Whether to store pointers or offsets inside the hash table. On
- * 64 bit architetcures, pointers take up twice as much space,
- * and might also be slower. Default is to autodetect.
- */
-/*#define LZF_USER_OFFSETS autodetect */
-
-/*****************************************************************************/
-/* nothing should be changed below */
-
-#ifdef __cplusplus
-# include <cstring>
-# include <climits>
-using namespace std;
-#else
-# include <string.h>
-# include <limits.h>
-#endif
-
-#ifndef LZF_USE_OFFSETS
-# if defined (WIN32)
-#  define LZF_USE_OFFSETS defined(_M_X64)
-# else
-#  if __cplusplus > 199711L
-#   include <cstdint>
-#  else
-#   include <stdint.h>
-#  endif
-#  define LZF_USE_OFFSETS (UINTPTR_MAX > 0xffffffffU)
-# endif
-#endif
-
-typedef unsigned char u8;
-
-#if LZF_USE_OFFSETS
-# define LZF_HSLOT_BIAS ((const u8 *)in_data)
-  typedef unsigned int LZF_HSLOT;
-#else
-# define LZF_HSLOT_BIAS 0
-  typedef const u8 *LZF_HSLOT;
-#endif
-
-typedef LZF_HSLOT LZF_STATE[1 << (HLOG)];
-
-#if !STRICT_ALIGN
-/* for unaligned accesses we need a 16 bit datatype. */
-# if USHRT_MAX == 65535
-    typedef unsigned short u16;
-# elif UINT_MAX == 65535
-    typedef unsigned int u16;
-# else
-#  undef STRICT_ALIGN
-#  define STRICT_ALIGN 1
-# endif
-#endif
-
-#if ULTRA_FAST
-# undef VERY_FAST
-#endif
-
-
diff --git a/src/xMain.cpp b/src/xMain.cpp
deleted file mode 100755
index a916ea05..00000000
--- a/src/xMain.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-
-//redis srever
-#include "xRedis.h"
-#include "xCurrentThread.h"
-#include "xLog.h"
-#include <stdio.h>
-//#include <gperftools/profiler.h>
-
-xAsyncLogging *g_asyncLog = nullptr;
-void asyncOutput(const char* msg, int len)
-{
-	printf("%s\n",msg);
-	g_asyncLog->append(msg, len);
-}
-
-char *ascii_logo =
-"                _._                                                  \n"
-"           _.-``__ ''-._                                             \n"
-"      _.-``    `.  `_.  ''-._           redis 1.0 					  \n"
-"  .-`` .-```.  ```\\/    _.,_ ''-._                                   \n"
-" (    '      ,       .-`  | `,    )									  \n"
-" |`-._`-...-` __...-.``-._|'` _.-'|									  \n"
-" |    `-._   `._    /     _.-'    |  								  \n"
-"  `-._    `-._  `-./  _.-'    _.-'                                   \n"
-" |`-._`-._    `-.__.-'    _.-'_.-'|                                  \n"
-" |    `-._`-._        _.-'_.-'    |                   				  \n"
-"  `-._    `-._`-.__.-'_.-'    _.-'                                   \n"
-" |`-._`-._    `-.__.-'    _.-'_.-'|                                  \n"
-" |    `-._`-._        _.-'_.-'    |                                  \n"
-"  `-._    `-._`-.__.-'_.-'    _.-'                                   \n"
-"      `-._    `-.__.-'    _.-'                                       \n"
-"          `-._        _.-'                                           \n"
-"              `-.__.-'                                               \n";
-
-
-int main(int argc, char* argv[])
-{
-	if (argc < 6)
-	{
-		fprintf(stderr, "Usage: server <address> <port> <threads> <cluster> <sentinel>\n");
-	}
-	else
-	{
-		//ProfilerStart("out.prof");
-		printf("%s\n",ascii_logo);
-		const char* ip = argv[1];
-		uint16_t port = static_cast<uint16_t>(atoi(argv[2]));
-		int16_t threadCount =  atoi(argv[3]);
-		uint16_t clusterEnbaled =  atoi(argv[4]);
-		uint16_t sentinelEnabled =  atoi(argv[3]);
-		xLogger::setOutput(asyncOutput);
-
-		xAsyncLogging log("xredis", 20000);
-		log.start();
-		g_asyncLog = &log;
-		xRedis redis(ip,port,threadCount,clusterEnbaled,sentinelEnabled);
-		redis.run();
-		//ProfilerStop();
-
-	}
-
-	return 0;
-}
-
-
-
-
-
-
diff --git a/src/xObject.cpp b/src/xObject.cpp
deleted file mode 100644
index 19808159..00000000
--- a/src/xObject.cpp
+++ /dev/null
@@ -1,719 +0,0 @@
-
-#include "xObject.h"
-sharedObjectsStruct shared;
-
-
-
-int string2ll(const char * s,size_t slen, long long * value)
-{
-	const char *p = s;
-    size_t plen = 0;
-    int negative = 0;
-    unsigned long long v;
-
-    if (plen == slen)
-        return 0;
-
-    if (slen == 1 && p[0] == '0') {
-        if (value != NULL) *value = 0;
-        return 1;
-    }
-
-    if (p[0] == '-') {
-        negative = 1;
-        p++; plen++;
-
-        if (plen == slen)
-            return 0;
-    }
-
-    if (p[0] >= '1' && p[0] <= '9') {
-        v = p[0]-'0';
-        p++; plen++;
-    } else if (p[0] == '0' && slen == 1) {
-        *value = 0;
-        return 1;
-    } else {
-        return 0;
-    }
-
-    while (plen < slen && p[0] >= '0' && p[0] <= '9') {
-        if (v > (ULLONG_MAX / 10))
-            return 0;
-        v *= 10;
-
-        if (v > (ULLONG_MAX - (p[0]-'0')))
-            return 0;
-        v += p[0]-'0';
-
-        p++; plen++;
-    }
-
-    if (plen < slen)
-        return 0;
-
-    if (negative) {
-        if (v > ((unsigned long long)(-(LLONG_MIN+1))+1))
-            return 0;
-        if (value != NULL) *value = -v;
-    } else {
-        if (v > LLONG_MAX) /* Overflow. */
-            return 0;
-        if (value != NULL) *value = v;
-    }
-    return 1;
-
-}
-
-
-int ll2string(char *s, size_t len, long long value)
-{
-    char buf[32], *p;
-    unsigned long long v;
-    size_t l;
-
-    if (len == 0) return 0;
-    v = (value < 0) ? -value : value;
-    p = buf+31; /* point to the last character */
-    do {
-        *p-- = '0'+(v%10);
-        v /= 10;
-    } while(v);
-    if (value < 0) *p-- = '-';
-    p++;
-    l = 32-(p-buf);
-    if (l+1 > len) l = len-1; /* Make sure it fits, including the nul term */
-    memcpy(s,p,l);
-    s[l] = '\0';
-    return l;
-}
-
-
-
-
-rObj * createObject(int type, const void *ptr)
-{
-	rObj * o = (rObj*)zmalloc(sizeof(rObj));
-	o->type = REDIS_ENCODING_RAW;
-	o->ptr  = (const char*)ptr;
-	return o;
-}
-
-
-int getLongLongFromObject(rObj *o, long long   *target) {
-	long long   value;
-
-	if (o == nullptr) {
-		value = 0;
-	}
-	else {
-
-		if (sdsEncodedObject(o)) {
-			if (string2ll(o->ptr, sdsllen(o->ptr), &value) == 0) return REDIS_ERR;
-		}
-		else {
-			LOG_ERROR << "Unknown string encoding";
-		}
-	}
-	if (target) *target = value;
-	return REDIS_OK;
-
-}
-
-
-
-int getLongLongFromObjectOrReply(xBuffer &sendBuf,rObj *o, long long *target, const char *msg) 
-{
-    long long value;
-    if (getLongLongFromObject(o, &value) != REDIS_OK) {
-        if (msg != NULL) {
-            addReplyError(sendBuf,(char*)msg);
-        } else {
-            addReplyError(sendBuf,"value is not an integer or out of range");
-        }
-        return REDIS_ERR;
-    }
-    *target = value;
-    return REDIS_OK;
-}
-
-
-int getLongFromObjectOrReply(xBuffer &sendBuf, rObj *o, long  *target, const char *msg)
-{
-	long  long value;
-	if (getLongLongFromObject(o, &value) != REDIS_OK)
-	{
-		if (msg != nullptr) 
-		{
-			addReplyError(sendBuf, (char*)msg);
-		}
-		else 
-		{
-			addReplyError(sendBuf, "value is not an integer or out of range");
-		}
-		return REDIS_ERR;
-	}
-	*target = value;
-	
-	return REDIS_OK;
-}
-
-rObj *createStringObjectFromLongLong(long long value)
-{
-	rObj *o;
-	if(value <=0 && value < REDIS_SHARED_INTEGERS)
-	{
-		o = shared.integers[value];
-	}
-	else
-	{
-		if(value >= LONG_MIN && value <= LONG_MAX)
-		{
-			o = createObject(REDIS_STRING, NULL);
-            o->encoding = REDIS_ENCODING_INT;
-            o->ptr = (const char *)(value);
-		}
-		else
-		{
-			o = createObject(REDIS_STRING,sdsfromlonglong(value));
-		}
-	}
-	return o;
-}
-
-
-void freeStringObject(rObj *o) 
-{
-    if (o->encoding == OBJ_ENCODING_RAW)
-    {
-        sdsfree((sds)o->ptr);
-    }
-}
-
-
-void decrRefCount(rObj *o) 
-{
-	switch(o->type)
-	{
-		case OBJ_STRING: freeStringObject(o); break;
-		default: LOG_WARN<<"Unknown object type"; break;
-	}
-	zfree(o);
-}
-
-
-void destorySharedObjects()
-{
-	freeStringObject(shared.crlf);
-	freeStringObject(shared.ok);
-	freeStringObject(shared.err);
-	freeStringObject(shared.emptybulk);
-	freeStringObject(shared.czero);
-	freeStringObject(shared.cone);
-	freeStringObject(shared.cnegone);
-	freeStringObject(shared.nullbulk);
-	freeStringObject(shared.nullmultibulk);
-	freeStringObject(shared.emptymultibulk);
-	freeStringObject(shared.pping);
-	freeStringObject(shared.ping);
-	freeStringObject(shared.pong);
-	freeStringObject(shared.ppong);
-	freeStringObject(shared.queued);
-	freeStringObject(shared.emptyscan);
-	freeStringObject(shared.wrongtypeerr);
-	freeStringObject(shared.nokeyerr);
-	freeStringObject(shared.syntaxerr);
-	freeStringObject(shared.sameobjecterr);
-	freeStringObject(shared.outofrangeerr);
-	freeStringObject(shared.noscripterr);
-	freeStringObject(shared.loadingerr);
-	freeStringObject(shared.slowscripterr);
-	freeStringObject(shared.masterdownerr);
-	freeStringObject(shared.bgsaveerr);
-	freeStringObject(shared.roslaveerr);
-	freeStringObject(shared.noautherr);
-	freeStringObject(shared.oomerr);
-	freeStringObject(shared.execaborterr);
-	freeStringObject(shared.noreplicaserr);
-	freeStringObject(shared.busykeyerr);
-	freeStringObject(shared.space);
-	freeStringObject(shared.colon);
-	freeStringObject(shared.plus);
-	freeStringObject(shared.messagebulk);
-	freeStringObject(shared.pmessagebulk);
-	freeStringObject(shared.subscribebulk);
-	freeStringObject(shared.unsubscribebulk);
-	freeStringObject(shared.psubscribebulk);
-	freeStringObject(shared.punsubscribebulk);
-
-	
-	for (int j = 0; j < REDIS_SHARED_BULKHDR_LEN; j++)
-	{
-		freeStringObject(shared.mbulkhdr[j]);
-		freeStringObject(shared.bulkhdr[j]);
-	}
-
-	freeStringObject(shared.sync);
-
-}
-
-
-void createSharedObjects()
-{
-	 int j;
-
-    shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
-    shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
-    shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
-    shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
-    shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
-    shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
-    shared.cnegone = createObject(REDIS_STRING,sdsnew(":-1\r\n"));
-    shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
-    shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
-    shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
-    shared.pping = createObject(REDIS_STRING, sdsnew("PPING\r\n"));
-    shared.ping = createObject(REDIS_STRING,sdsnew("PING\r\n"));
-    shared.pong = createObject(REDIS_STRING, sdsnew("+PONG\r\n"));
-    shared.ppong = createObject(REDIS_STRING,sdsnew("PPONG"));
-    shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n"));
-    shared.emptyscan = createObject(REDIS_STRING,sdsnew("*2\r\n$1\r\n0\r\n*0\r\n"));
-  
-    shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
-        "-WRONGTYPE Operation against a key holding the wrong kind of value\r\n"));
-    shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
-        "-ERR no such key\r\n"));
-    shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
-        "-ERR syntax error\r\n"));
-    shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
-        "-ERR source and destination objects are the same\r\n"));
-    shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
-        "-ERR index out of range\r\n"));
-    shared.noscripterr = createObject(REDIS_STRING,sdsnew(
-        "-NOSCRIPT No matching script. Please use EVAL.\r\n"));
-    shared.loadingerr = createObject(REDIS_STRING,sdsnew(
-        "-LOADING Redis is loading the dataset in memory\r\n"));
-    shared.slowscripterr = createObject(REDIS_STRING,sdsnew(
-        "-BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.\r\n"));
-    shared.masterdownerr = createObject(REDIS_STRING,sdsnew(
-        "-MASTERDOWN Link with MASTER is down and slave-serve-stale-data is set to 'no'.\r\n"));
-    shared.bgsaveerr = createObject(REDIS_STRING,sdsnew(
-        "-MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk. Commands that may modify the data set are disabled. Please check Redis logs for details about the error.\r\n"));
-    shared.roslaveerr = createObject(REDIS_STRING,sdsnew(
-        "-READONLY You can't write against a read only slave.\r\n"));
-    shared.noautherr = createObject(REDIS_STRING,sdsnew(
-        "-NOAUTH Authentication required.\r\n"));
-    shared.oomerr = createObject(REDIS_STRING,sdsnew(
-        "-OOM command not allowed when used memory > 'maxmemory'.\r\n"));
-    shared.execaborterr = createObject(REDIS_STRING,sdsnew(
-        "-EXECABORT Transaction discarded because of previous errors.\r\n"));
-    shared.noreplicaserr = createObject(REDIS_STRING,sdsnew(
-        "-NOREPLICAS Not enough good slaves to write.\r\n"));
-    shared.busykeyerr = createObject(REDIS_STRING,sdsnew(
-        "-BUSYKEY Target key name already exists.\r\n"));
-
-    shared.space = createObject(REDIS_STRING,sdsnew(" "));
-    shared.colon = createObject(REDIS_STRING,sdsnew(":"));
-    shared.plus = createObject(REDIS_STRING,sdsnew("+"));
-
-
-    /*for (j = 0; j < REDIS_SHARED_SELECT_CMDS; j++) {
-        char dictid_str[64];
-        int dictid_len;
-
-        dictid_len = ll2string(dictid_str,sizeof(dictid_str),j);
-        shared.select[j] = createObject(REDIS_STRING,
-            sdscatprintf(sdsempty(),
-                "*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n",
-                dictid_len, dictid_str));
-    }
-
-    */
-
-    shared.messagebulk = createStringObject("$7\r\nmessage\r\n",13);
-    shared.pmessagebulk = createStringObject("$8\r\npmessage\r\n",14);
-    shared.subscribebulk = createStringObject("$9\r\nsubscribe\r\n",15);
-    shared.unsubscribebulk = createStringObject("$11\r\nunsubscribe\r\n",18);
-    shared.psubscribebulk = createStringObject("$10\r\npsubscribe\r\n",17);
-    shared.punsubscribebulk = createStringObject("$12\r\npunsubscribe\r\n",19);
-
-
-  /*  shared.del = createStringObject("DEL",3);
-    shared.rpop = createStringObject("RPOP",4);
-    shared.lpop = createStringObject("LPOP",4);
-    shared.lpush = createStringObject("LPUSH",5);
-    */
-
-  /*  for (j = 0; j < REDIS_SHARED_INTEGERS; j++) {
-        shared.integers[j] = createObject(REDIS_STRING,(void*)(long)j);
-        shared.integers[j]->encoding = REDIS_ENCODING_INT;
-    }
-    */
-
-
-
-    for (j = 0; j < REDIS_SHARED_BULKHDR_LEN; j++) {
-        shared.mbulkhdr[j] = createObject(REDIS_STRING,
-            sdscatprintf(sdsempty(),"*%d\r\n",j));
-        shared.bulkhdr[j] = createObject(REDIS_STRING,
-            sdscatprintf(sdsempty(),"$%d\r\n",j));
-    }
-
-	//shared.minstring = createStringObject("minstring",9);
-    //shared.maxstring = createStringObject("maxstring",9);
-    shared.sync = createObject(REDIS_STRING,sdsnew("sync\r\n"));
-
-
-}
-
-
-
-rObj * createStringObject(const char *ptr, size_t len)
-{
-   	return createEmbeddedStringObject(ptr,len);
-}
-
-
-
-rObj *createRawStringObject(const char *ptr, size_t len)
-{
-    return createObject(REDIS_STRING,sdsnewlen(ptr,len));
-}
-
-rObj * createEmbeddedStringObject(const char *ptr, size_t len)
-{
-    rObj *o = (rObj*)zmalloc(sizeof(rObj)+sizeof(struct sdshdr)+len+1);
-    struct sdshdr *sh = (sdshdr*)(o+1);
-
-    o->type = REDIS_STRING;
-    o->encoding = REDIS_ENCODING_EMBSTR;
-    o->ptr = (const char*)(sh+1);
-    o->hash = 0;
-    sh->len = len;
-    sh->free = 0;
-    if (ptr)
-    {
-        memcpy(sh->buf,ptr,len);
-        sh->buf[len] = '\0';
-    }
-    else
-    {
-        memset(sh->buf,0,len+1);
-    }
-    return o;
-}
-
-
-
-void addReplyBulkLen(xBuffer & sendBuf,rObj *obj)
-{
-	size_t len;
-
-	if (sdsEncodedObject(obj)) {
-	    len = sdslen((const sds)obj->ptr);
-	} else {
-	    long n = (long)obj->ptr;
-
-	    /* Compute how many bytes will take this integer as a radix 10 string */
-	    len = 1;
-	    if (n < 0) {
-	        len++;
-	        n = -n;
-	    }
-	    while((n = n/10) != 0) {
-	        len++;
-	    }
-	}
-
-	if (len < REDIS_SHARED_BULKHDR_LEN)
-	    addReply(sendBuf,shared.bulkhdr[len]);
-	else
-	    addReplyLongLongWithPrefix(sendBuf,len,'$');
-
-}
-
-
-void addReplyBulk(xBuffer &sendBuf,rObj *obj)
-{
-    addReplyBulkLen(sendBuf,obj);
-    addReply(sendBuf,obj);
-    addReply(sendBuf,shared.crlf);
-}
-
-
-void addReplyLongLongWithPrefix(xBuffer &sendBuf,long long ll, char prefix)
-{
-	char buf[128];
-    int len;
-
-    /* Things like $3\r\n or *2\r\n are emitted very often by the protocol
-     * so we have a few shared objects to use if the integer is small
-     * like it is most of the times. */
-    if (prefix == '*' && ll < REDIS_SHARED_BULKHDR_LEN) {
-        // ???????????
-        addReply(sendBuf,shared.mbulkhdr[ll]);
-        return;
-    } else if (prefix == '$' && ll < REDIS_SHARED_BULKHDR_LEN) {
-        // ???????
-        addReply(sendBuf,shared.bulkhdr[ll]);
-        return;
-    }
-
-    buf[0] = prefix;
-    len = ll2string(buf+1,sizeof(buf)-1,ll);
-    buf[len+1] = '\r';
-    buf[len+2] = '\n';
-    sendBuf.append(buf,len +3);
-
-}
-
-
-void addReplyLongLong(xBuffer &sendBuf,size_t len)
-{
-	if (len == 0)
-		addReply(sendBuf,shared.czero);
-	else if (len == 1)
-		addReply(sendBuf,shared.cone);
-	else
-		addReplyLongLongWithPrefix(sendBuf,len,':');
-}
-void addReplyError(xBuffer &sendBuf,const char *str)
-{
-	addReplyErrorLength(sendBuf,str,strlen(str));
-}
-
-void addReply(xBuffer &sendBuf,rObj *obj)
-{
-	sendBuf.append(obj->ptr,sdslen((const sds)obj->ptr));
-}
-
-/* Add sds to reply (takes ownership of sds and frees it) */
-void addReplyBulkSds(xBuffer &sendBuf, sds s)  {
-    addReplySds(sendBuf,sdscatfmt(sdsempty(),"$%u\r\n",
-        (unsigned long)sdslen(s)));
-    addReplySds(sendBuf,s);
-    addReply(sendBuf,shared.crlf);
-}
-
-
-
-void addReplyMultiBulkLen(xBuffer & sendBuf,long length)
-{
-	if (length < REDIS_SHARED_BULKHDR_LEN)
-        addReply(sendBuf,shared.mbulkhdr[length]);
-    else
-        addReplyLongLongWithPrefix(sendBuf,length,'*');
-}
-
-
-
-void addReplyBulkCBuffer(xBuffer & sendBuf,const char *p, size_t len)
-{
-	addReplyLongLongWithPrefix(sendBuf,len,'$');
-	addReplyString(sendBuf,p,len);
-	addReply(sendBuf,shared.crlf);
-}
-
-void addReplyErrorFormat(xBuffer & sendBuf,const char *fmt, ...)
-{
-    size_t l, j;
-    va_list ap;
-    va_start(ap,fmt);
-    sds s = sdscatvprintf(sdsempty(),fmt,ap);
-    va_end(ap);
-    l = sdslen(s);
-    for (j = 0; j < l; j++) {
-        if (s[j] == '\r' || s[j] == '\n') s[j] = ' ';
-    }
-    addReplyErrorLength(sendBuf,s,sdslen(s));
-    sdsfree(s);
-}
-
-
-
-void addReplyString(xBuffer & sendBuf,const char *s, size_t len)
-{
-	sendBuf.append(s,len);
-}
-
-
-
-void addReplySds(xBuffer &sendBuf, sds s)
-{
-	sendBuf.append(s, sdslen(s));
-	sdsfree(s);
-}
-
-
-void addReplyErrorLength(xBuffer & sendBuf,const char *s,size_t len)
-{
-    addReplyString(sendBuf,"-ERR ",5);
-    addReplyString(sendBuf,s,len);
-    addReplyString(sendBuf,"\r\n",2);
-}
-
-
-long long ustime(void)
-{
-    struct timeval tv;
-    long long ust;
-
-    gettimeofday(&tv, NULL);
-    ust = ((long long)tv.tv_sec)*1000000;
-    ust += tv.tv_usec;
-    return ust;
-}
-
-/* Return the UNIX time in milliseconds */
-long long mstime(void) {
-    return ustime()/1000;
-}
-
-
-/* Return the UNIX time in seconds */
-long long setime(void) 
-{
-    return ustime()/1000/1000;
-}
-
-
-
-/* Toggle the 16 bit unsigned integer pointed by *p from little endian to
- * big endian */
-void memrev16(void *p) {
-    unsigned char *x = (unsigned char *)p, t;
-
-    t = x[0];
-    x[0] = x[1];
-    x[1] = t;
-}
-
-/* Toggle the 32 bit unsigned integer pointed by *p from little endian to
- * big endian */
-void memrev32(void *p) {
-    unsigned char *x = (unsigned char *)p, t;
-
-    t = x[0];
-    x[0] = x[3];
-    x[3] = t;
-    t = x[1];
-    x[1] = x[2];
-    x[2] = t;
-}
-
-/* Toggle the 64 bit unsigned integer pointed by *p from little endian to
- * big endian */
-void memrev64(void *p) {
-    unsigned char *x = (unsigned char *)p, t;
-
-    t = x[0];
-    x[0] = x[7];
-    x[7] = t;
-    t = x[1];
-    x[1] = x[6];
-    x[6] = t;
-    t = x[2];
-    x[2] = x[5];
-    x[5] = t;
-    t = x[3];
-    x[3] = x[4];
-    x[4] = t;
-}
-
-
-
-const uint32_t dict_hash_function_seed = 5381;
-
-
-/* And a case insensitive hash function (based on djb hash) */
-unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len) {
-    unsigned int hash = (unsigned int)dict_hash_function_seed;
-
-    while (len--)
-        hash = ((hash << 5) + hash) + (tolower(*buf++)); /* hash * 33 + c */
-    return hash;
-}
-
-
-
-unsigned int dictGenHashFunction(const void *key, int len) {
-	/* 'm' and 'r' are mixing constants generated offline.
-	 They're not really 'magic', they just happen to work well.  */
-	uint32_t seed = dict_hash_function_seed;
-	const uint32_t m = 0x5bd1e995;
-	const int r = 24;
-
-	/* Initialize the hash to a 'random' value */
-	uint32_t h = seed ^ len;
-
-	/* Mix 4 bytes at a time into the hash */
-	const unsigned char *data = (const unsigned char *)key;
-
-	while(len >= 4) {
-		uint32_t k = *(uint32_t*)data;
-
-		k *= m;
-		k ^= k >> r;
-		k *= m;
-
-		h *= m;
-		h ^= k;
-
-		data += 4;
-		len -= 4;
-	}
-
-	/* Handle the last few bytes of the input array  */
-	switch(len) {
-	case 3: h ^= data[2] << 16;
-	case 2: h ^= data[1] << 8;
-	case 1: h ^= data[0]; h *= m;
-	};
-
-	/* Do a few final mixes of the hash to ensure the last few
-	 * bytes are well-incorporated. */
-	h ^= h >> 13;
-	h *= m;
-	h ^= h >> 15;
-
-	return (unsigned int)h;
-}
-
-
-
-
-/* Convert an amount of bytes into a human readable string in the form
- * of 100B, 2G, 100M, 4K, and so forth. */
-void bytesToHuman(char *s, unsigned long long n) {
-    double d;
-
-    if (n < 1024) {
-        /* Bytes */
-        sprintf(s,"%lluB",n);
-        return;
-    } else if (n < (1024*1024)) {
-        d = (double)n/(1024);
-        sprintf(s,"%.2fK",d);
-    } else if (n < (1024LL*1024*1024)) {
-        d = (double)n/(1024*1024);
-        sprintf(s,"%.2fM",d);
-    } else if (n < (1024LL*1024*1024*1024)) {
-        d = (double)n/(1024LL*1024*1024);
-        sprintf(s,"%.2fG",d);
-    } else if (n < (1024LL*1024*1024*1024*1024)) {
-        d = (double)n/(1024LL*1024*1024*1024);
-        sprintf(s,"%.2fT",d);
-    } else if (n < (1024LL*1024*1024*1024*1024*1024)) {
-        d = (double)n/(1024LL*1024*1024*1024*1024);
-        sprintf(s,"%.2fP",d);
-    } else {
-        /* Let's hope we never need this */
-        sprintf(s,"%lluB",n);
-    }
-}
-
-
-
-
-
-
diff --git a/src/xObject.h b/src/xObject.h
deleted file mode 100644
index 3f8ab0a3..00000000
--- a/src/xObject.h
+++ /dev/null
@@ -1,136 +0,0 @@
-#pragma once
-
-#include "all.h"
-#include "xZmalloc.h"
-#include "xSds.h"
-#include "xBuffer.h"
-#include "xLog.h"
-
-unsigned int dictGenHashFunction(const void *key, int len) ;
-unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len);
-#define sdsEncodedObject(objptr) (objptr->encoding == REDIS_ENCODING_RAW || objptr->encoding == REDIS_ENCODING_EMBSTR)
-typedef struct redisObject 
-{		
-	void calHash()
-	{
-		hash = dictGenHashFunction(ptr,sdsllen(ptr));
-	}
-
-	unsigned type:4;
-	unsigned encoding:4;
-	size_t hash;
-	const char *ptr;
-} rObj;
-
-typedef struct redisSortObject
-{
-	bool operator <(const redisSortObject & r) const
-	{	
-		int cmp = memcmp(key->ptr,r.key->ptr,sdsllen(key->ptr));
-		if( cmp < 0)
-		{
-			return true;
-		}
-		else if(cmp == 0)
-		{
-			return memcmp(value->ptr,r.value->ptr,sdsllen(value->ptr)) < 0;
-		}
-		else
-		{
-			return false;
-		}
-	}
-
-	rObj * key;
-	rObj * value;
-}rSObj;
-
-
-struct Hash
-{
-	size_t operator()(const rObj * x) const
-	{
-			return x->hash;
-	}
-};
-
-
-struct Equal
-{
-	bool operator()(const rObj * x, const rObj * y) const
-	{
-		 return ((sdsllen(x->ptr) == sdsllen(y->ptr)) &&
-            (memcmp(x->ptr, y->ptr, sdsllen(y->ptr))== 0));
-	}
-
-};
-
-
-struct EEqual
-{
-	bool operator()(const rObj * x, const rObj * y) const
-	{
-		 return  (strcasecmp(x->ptr, y->ptr) == 0);
-	}
-
-};
-
-struct sharedObjectsStruct
-{
-    rObj *crlf, *ok, *err, *emptybulk, *czero, *cone, *cnegone, *pping,*ping,*pong,*ppong, *space,
-    *colon, *nullbulk, *nullmultibulk, *queued,
-    *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
-    *outofrangeerr, *noscripterr, *loadingerr, *slowscripterr, *bgsaveerr,
-    *masterdownerr, *roslaveerr, *execaborterr, *noautherr, *noreplicaserr,
-    *busykeyerr, *oomerr, *plus, *messagebulk, *pmessagebulk, *subscribebulk,
-    *unsubscribebulk, *psubscribebulk, *punsubscribebulk, *del, *rpop, *lpop,
-    *lpush, *emptyscan, *minstring, *maxstring,*sync,
-    *select[REDIS_SHARED_SELECT_CMDS],
-    *integers[REDIS_SHARED_INTEGERS],
-    *mbulkhdr[REDIS_SHARED_BULKHDR_LEN], /* "*<value>\r\n" */
-    *bulkhdr[REDIS_SHARED_BULKHDR_LEN];  /* "$<value>\r\n" */
-};
-
-extern sharedObjectsStruct shared;
-
-int ll2string(char *s, size_t len, long long value);
-int string2ll(const char * s,size_t slen, long long * value);
-rObj *createRawStringObject(const char *ptr, size_t len);
-rObj *createObject(int type, const void *ptr);
-rObj *createStringObject(const char *ptr, size_t len);
-rObj *createEmbeddedStringObject(const char *ptr, size_t len);
-void createSharedObjects();
-void destorySharedObjects();
-void freeStringObject(rObj *o) ;
-void decrRefCount(rObj *o) ;
-
-rObj *createStringObjectFromLongLong(long long value);
-int getLongLongFromObject(rObj *o, long long   *target);
-int getLongFromObjectOrReply(xBuffer &sendBuf, rObj *o, long  *target, const char *msg);
-int getLongLongFromObjectOrReply(xBuffer &sendBuf,rObj *o, long long *target, const char *msg) ;
-
-
-void addReplyBulkSds(xBuffer &sendBuf, sds s);
-void addReplyMultiBulkLen(xBuffer &sendBuf,long length);
-void addReply(xBuffer &sendBuf,rObj *obj);
-void addReplyString(xBuffer & sendBuf,const char *s, size_t len);
-void addReplyError(xBuffer &sendBuf,const char *str);
-void addReplyErrorLength(xBuffer &sendBuf,const char *s,size_t len);
-void addReplyLongLongWithPrefix(xBuffer &sendBuf, long long ll, char prefix);
-void addReplyBulkLen(xBuffer &sendBuf,rObj *obj);
-void addReplyBulk(xBuffer &sendBuf,rObj *obj);
-void addReplyErrorFormat(xBuffer &sendBuf,const char *fmt, ...);
-void addReplyBulkCBuffer(xBuffer &sendBuf,const char *p, size_t len);
-void addReplyLongLong(xBuffer &sendBuf,size_t len);
-void addReplySds(xBuffer &sendBuf,sds s);
-
-long long ustime(void);
-long long mstime(void);
-long long setime(void) ;
-
-#define memrev16ifbe(p) memrev16(p)
-#define memrev32ifbe(p) memrev32(p)
-#define memrev64ifbe(p) memrev64(p)
-
-void bytesToHuman(char *s, unsigned long long n);
-
diff --git a/src/xPosix.h b/src/xPosix.h
deleted file mode 100644
index 5f485fb5..00000000
--- a/src/xPosix.h
+++ /dev/null
@@ -1,104 +0,0 @@
-
-#pragma once
-#include "all.h"
-
-
-class MutexLock : noncopyable
-{
- public:
-  MutexLock()
-  {
-    pthread_mutex_init(&mutex,nullptr);
-  }
-
-  ~MutexLock()
-  {
-    pthread_mutex_destroy(&mutex);
-  }
-
- 
-  void lock()
-  {
-    pthread_mutex_lock(&mutex);
-   
-  }
-
-  void unlock()
-  {
-    pthread_mutex_unlock(&mutex);
-  }
-
-  pthread_mutex_t* getPthreadMutex() /* non-const */
-  {
-    return &mutex;
-  }
-
-public:
-  pthread_mutex_t mutex;
- 
-};
-
-
-
-class MutexLockGuard : noncopyable
-{
- public:
-  explicit MutexLockGuard(MutexLock& mutex)
-    : mutex(mutex)
-  {
-    mutex.lock();
-  }
-
-  ~MutexLockGuard()
-  {
-    mutex.unlock();
-  }
-
- 
- void lock()
- {
-   mutex.lock();
-  
- }
- 
- void unlock()
- {
-   mutex.unlock();
- }
- 
-
-private:
-
-  MutexLock& mutex;
-};
-
-
-class CondVar
-{
-public:
-	explicit CondVar(MutexLock *mu): mu(mu)
-	{
-		pthread_cond_init(&cv, nullptr);
-	}
-	~CondVar()
-	{
-		pthread_cond_destroy(&cv); 
-	}
-	void Wait()
-	{
-		pthread_cond_wait(&cv, &mu->mutex);
-	}
-	void Signal()
-	{
-		pthread_cond_signal(&cv);
-	}
-	void SignalAll()
-	{
-		pthread_cond_broadcast(&cv);
-	}
-	
-private:
-	pthread_cond_t cv;
-	MutexLock *mu;	
-};
-
diff --git a/src/xRdb.cpp b/src/xRdb.cpp
deleted file mode 100644
index 7ffc6d6f..00000000
--- a/src/xRdb.cpp
+++ /dev/null
@@ -1,1326 +0,0 @@
-#include "xRdb.h"
-
-xRio::xRio()
-{
-
-}
-
-xRio::~xRio()
-{
-
-}
-
-
-off_t rioTell(xRio *r)
-{
-	return r->tellFuc(r);
-}
-
-off_t rioFlush(xRio *r)
-{
-	return r->flushFuc(r);
-}
-
-size_t rioWrite(xRio *r,const void *buf,size_t len)
-{
-	while(len)
-	{
-		size_t bytesToWrite = (r->maxProcessingChunk && r->maxProcessingChunk < len)?r->maxProcessingChunk:len;
-		if(r->updateFuc)
-		{
-			r->updateFuc(r,buf,bytesToWrite);
-		}
-
-		if(r->writeFuc(r,buf,bytesToWrite) == 0)
-		{
-			return 0;
-		}
-
-		buf = (char*)buf + bytesToWrite;
-		len -= bytesToWrite;
-		r->processedBytes += bytesToWrite;
-	}
-
-	return 1;
-}
-
-
-size_t rioRepliRead(xRio * r,void * buf,size_t len)
-{
-	fseek(r->io.file.fp,r->processedBytes ,SEEK_SET);
-	size_t readBytes = ::fread(buf,1,len,r->io.file.fp);
-	if(readBytes == 0)
-	{
-		return 0;
-	}
-
-	if(r->updateFuc)
-	{
-		r->updateFuc(r,buf,readBytes);
-	}
-
-	r->processedBytes += readBytes;
-	return readBytes;
-}
-
-size_t rioRead(xRio *r,void  *buf,size_t len)
-{
-	while(len)
-	{
-		size_t bytesToRead = (r->maxProcessingChunk && r->maxProcessingChunk <len)? r->maxProcessingChunk:len;
-		if(r->readFuc(r,buf,bytesToRead) == 0)
-		{
-			return 0;
-		}
-
-		if(r->updateFuc)
-		{
-			r->updateFuc(r,buf,bytesToRead);
-		}
-
-		buf = (char*)buf + bytesToRead;
-		len -= bytesToRead;
-		r->processedBytes += bytesToRead;
-	}
-
-	return 1;
-}
-
-size_t rioFileRead(xRio*r, void *buf, size_t len)
-{
-	return fread(buf,len,1,r->io.file.fp);
-}
-
-size_t rioFileWrite(xRio *r, const void *buf, size_t len)
-{
-	 size_t retval;
-	 retval = fwrite(buf,len,1,r->io.file.fp);
-	 r->io.file.buffered += len;
-
-	 if(r->io.file.autosync && r->io.file.buffered >= r->io.file.autosync)
-	 {
-	 	fflush(r->io.file.fp);
-	 }
-
-	 return retval;
-}
-
-off_t rioFileTell(xRio *r)
-{
-	return ftello(r->io.file.fp);
-}
-
-int rioFileFlush(xRio *r)
-{
-	return (fflush(r->io.file.fp) == 0) ? 1:0;
-}
-
-
-void rioGenericUpdateChecksum(xRio *r, const void *buf, size_t len)
-{
-	r->cksum = crc64(r->cksum,(const unsigned char*)buf,len);
-}
-
-void rioInitWithFile(xRio *r, FILE *fp)
-{
-	r->readFuc = rioFileRead;
-	r->writeFuc = rioFileWrite;
-	r->tellFuc = rioFileTell;
-	r->flushFuc =rioFileFlush;
-	r->updateFuc = rioGenericUpdateChecksum;
-	r->cksum = 0;
-	r->processedBytes = 0;
-	r->maxProcessingChunk = 65536;
-	r->io.file.fp = fp;
-	r->io.file.buffered = 0;
-	r->io.file.autosync = 0;
-}
-
-void rioInitWithBuffer(xRio *r, sds s)
-{
-
-}
-
-
-int rdbEncodeInteger(long long value, unsigned char *enc)
-{
-	if (value >= -(1<<7) && value <= (1<<7)-1) {
-        enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT8;
-        enc[1] = value&0xFF;
-        return 2;
-    } else if (value >= -(1<<15) && value <= (1<<15)-1) {
-        enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT16;
-        enc[1] = value&0xFF;
-        enc[2] = (value>>8)&0xFF;
-        return 3;
-    } else if (value >= -((long long)1<<31) && value <= ((long long)1<<31)-1) {
-        enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT32;
-        enc[1] = value&0xFF;
-        enc[2] = (value>>8)&0xFF;
-        enc[3] = (value>>16)&0xFF;
-        enc[4] = (value>>24)&0xFF;
-        return 5;
-    } else {
-        return 0;
-    }
-}
-
-int rdbTryIntegerEncoding(char *s, size_t len, unsigned char *enc)
-{
-	long long value;
-	char *endptr,buf[32];
-
-	value = strtoll(s,&endptr,10);
-	if(endptr[0] != '\0')
-	{
-		return 0;
-	}
-	
-	ll2string(buf,32,value);
-	if (strlen(buf) != len || memcmp(buf,s,len)) 
-	{
-		return 0;	
-	}
-
-    return rdbEncodeInteger(value,enc);
-	
-}
-
-
-uint32_t rdbLoadLen(xRio *rdb, int *isencoded)
-{
-	unsigned char buf[2];
-	uint32_t len;
-	int type;
-	if(isencoded)
-	{
-		*isencoded = 0;
-	}
-
-	if(rioRead(rdb,buf,1) == 0)
-	{
-		return REDIS_RDB_LENERR;
-	}
-
-	type = (buf[0]&0xC0)>>6;
-
-	if(type == REDIS_RDB_ENCVAL)
-	{
-		if(isencoded)
-		{
-			*isencoded = 1;
-		}
-		return buf[0]&0x3F;
-	}
-	else if(type == REDIS_RDB_6BITLEN)
-	{
-		return buf[0]&0x3F;
-	}
-	else if(type == REDIS_RDB_14BITLEN)
-	{
-		if (rioRead(rdb,buf+1,1) == 0)
-		{
-			return REDIS_RDB_LENERR;	
-		}
-        return ((buf[0]&0x3F)<<8)|buf[1];
-	}
-	else
-	{
-		if (rioRead(rdb,&len,4) == 0)
-		{
-			return REDIS_RDB_LENERR;
-		}
-        return ntohl(len);
-	}
-	
-}
-
-rObj *rdbLoadIntegerObject(xRio *rdb, int enctype, int encode)
-{
-	unsigned char enc[4];
-	long long val;
-
-	if(enctype == REDIS_RDB_ENC_INT8)
-	{
-		if(rioRead(rdb,enc,1) == 0)
-		{
-			return nullptr;
-		}
-		val = (signed char)enc[0];
-	}
-	else if(enctype == REDIS_RDB_ENC_INT16)
-	{
-		uint16_t v;
-        if (rioRead(rdb,enc,2) == 0) return NULL;
-        v = enc[0]|(enc[1]<<8);
-        val = (int16_t)v;
-	}
-	else if (enctype == REDIS_RDB_ENC_INT32)
-	{
-        uint32_t v;
-        if (rioRead(rdb,enc,4) == 0) return NULL;
-        v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24);
-        val = (int32_t)v;
-    } 
-	else 
-	{
-        val = 0; /* anti-warning */
-        //TRACE("Unknown RDB integer encoding type");
-    }
-
-	if (encode)
-        return createStringObjectFromLongLong(val);
-    else
-        return createObject(REDIS_STRING,sdsfromlonglong(val));
-	
-	
-}
-
-
-rObj *rdbLoadEncodedStringObject(xRio *rdb)
-{
-	return rdbGenericLoadStringObject(rdb,1);
-}
-
-
-rObj *rdbLoadLzfStringObject(xRio *rdb)
-{
-	rObj * obj = nullptr;
-    unsigned int len, clen;
-    unsigned char *c = NULL;
-    sds val = NULL;
-
-    if ((clen = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
-    if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
-    if ((c = (unsigned char *)zmalloc(clen)) == NULL) goto err;
-    if ((val = sdsnewlen(NULL,len)) == NULL) goto err;
-    if (rioRead(rdb,c,clen) == 0) goto err;
-    if (lzf_decompress(c,clen,val,len) == 0) goto err;
-
-    obj =  createStringObject(val,len);
-    sdsfree(val);
-    zfree(c);
-    return obj;
-err:
-    zfree(c);
-    sdsfree(val);
-    return NULL;
-}
-
-
-rObj *rdbGenericLoadStringObject(xRio *rdb, int encode)
-{
-    int isencoded;
-    uint32_t len;
-    rObj *o;
-
-    len = rdbLoadLen(rdb,&isencoded);
-    if (isencoded)
-    {
-        switch(len)
-        {
-        case REDIS_RDB_ENC_INT8:
-        case REDIS_RDB_ENC_INT16:
-        case REDIS_RDB_ENC_INT32:
-            return rdbLoadIntegerObject(rdb,len,encode);
-        case REDIS_RDB_ENC_LZF:
-           	return rdbLoadLzfStringObject(rdb);
-        default:
-            LOG_WARN<<"Unknown RDB encoding type";
-            break;
-        }
-    }
-
-    if (len == REDIS_RDB_LENERR)
-	{
-		return nullptr;
-    }
-
-    o = createStringObject(NULL,len);
-    if (len && rioRead(rdb,(void*)o->ptr,len) == 0) 
-	{
-        return nullptr;
-    }
-    
-    return o;
-}
-
-
-
-
-rObj *rdbLoadStringObject(xRio *rdb)
-{
-	 return rdbGenericLoadStringObject(rdb,0);
-}
-
-
-int rdbSaveSSet(xRio *rdb,xRedis * redis)
-{
-	for(auto it = redis->setShards.begin(); it != redis->setShards.end(); it++)
-	{
-		auto &map = (*it).set;
-		MutexLock & mu = (*it).mutex;
-		MutexLockGuard lock(mu);
-		for(auto iter = map.begin(); iter != map.end(); iter++)
-		{
-			if (rdbSaveKey(rdb,iter->first,0) == -1)
-			{
-				return REDIS_ERR;
-			}
-
-			if((rdbSaveLen(rdb,iter->second.size()) == -1))
-			{
-				return REDIS_ERR;
-			}
-
-			for(auto iterr = iter->second.begin(); iterr != iter->second.end(); iterr++)
-			{
-				 if (rdbSaveValue(rdb,*iterr,0) == -1)
-				 {
-					return REDIS_ERR;
-				 }
-			}
-		}
-	}
-
-	if (rdbSaveType(rdb,REDIS_RDB_SSET) == -1) return REDIS_ERR;
-
-	return REDIS_OK;
-}
-
-int rdbSaveSortSet(xRio *rdb,xRedis * redis)
-{
-	for(auto it = redis->sortSetShards.begin(); it != redis->sortSetShards.end(); it++)
-	{
-		auto &map = (*it).set;
-		MutexLock & mu = (*it).mutex;
-		MutexLockGuard lock(mu);
-		for(auto iter = map.begin(); iter != map.end(); iter++)
-		{
-			if (rdbSaveKey(rdb,iter->first,0) == -1)
-			{
-				return REDIS_ERR;
-			}
-
-			if((rdbSaveLen(rdb,iter->second.size()) == -1))
-			{
-				return REDIS_ERR;
-			}
-
-			for(auto iterr = iter->second.begin(); iterr != iter->second.end(); iterr++)
-			{
-				 if (rdbSaveKeyValuePair(rdb,iterr->first,iterr->second,0) == -1)
-				 {
-					return REDIS_ERR;
-				 }
-			}
-		}
-
-	}
-
-	if (rdbSaveType(rdb,REDIS_RDB_SORT_SET) == -1) return REDIS_ERR;
-
-	return REDIS_OK;
-}
-
-
-int rdbSaveSet(xRio *rdb,xRedis * redis)
-{
-	for(auto it = redis->setMapShards.begin(); it != redis->setMapShards.end(); it++)
-	{
-		auto &map = (*it).setMap;
-		MutexLock & mu = (*it).mutex;
-		MutexLockGuard lock(mu);
-		for(auto iter = map.begin(); iter != map.end(); iter++)
-		{
-			 if (rdbSaveKeyValuePair(rdb,iter->first,iter->second,0) == -1)
-			 {
-			 	return REDIS_ERR;
-			 }
-		}
-	}
-	
-	if (rdbSaveType(rdb,REDIS_RDB_SET) == -1) return REDIS_ERR;
-
-	return REDIS_OK;
-}
-
-int rdbSaveHset(xRio *rdb,xRedis * redis)
-{
-	for(auto it = redis->hsetMapShards.begin(); it != redis->hsetMapShards.end(); it++)
-	{
-		auto &map = (*it).hsetMap;
-		MutexLock & mu = (*it).mutex;
-		MutexLockGuard lock(mu);
-		for(auto iter = map.begin(); iter != map.end(); iter++)
-		{
-			if (rdbSaveKey(rdb,iter->first,0) == -1)
-			{
-			 	return REDIS_ERR;
-			}
-
-			if((rdbSaveLen(rdb,iter->second.size()) == -1))
-			{
-				return REDIS_ERR;
-			}
-
-			for(auto iterr = iter->second.begin(); iterr != iter->second.end(); iterr++)
-			{	
-				 if (rdbSaveKeyValuePair(rdb,iterr->first,iterr->second,0) == -1)
-				 {
-				 	return REDIS_ERR;
-				 }
-			}
-			
-			
-		}
-	}
-	
-	if (rdbSaveType(rdb,REDIS_RDB_HSET) == -1) return REDIS_ERR;
-
-	return REDIS_OK;
-}
-
-
-int rdbLoadSet(xRio *rdb,xRedis * redis)
-{
-	int type;
-	while(1)
-	{
-		rObj *key,*val;
-
-		if ((type = rdbLoadType(rdb)) == -1)
-		{
-			return  REDIS_ERR;
-		}
-
-		if (type == REDIS_RDB_SET)
-		{
-			return REDIS_OK;
-		}
-		  
-		if ((key = rdbLoadStringObject(rdb)) == nullptr)
-		{
-			return  REDIS_ERR;
-		}
-
-		if ((val = rdbLoadObject(type,rdb)) == nullptr)
-		{
-			return REDIS_ERR;
-		}
-
-		key->calHash();
-		size_t hash = key->hash;
-		MutexLock &mu = redis->setMapShards[hash% redis->kShards].mutex;
-		auto & setMap = redis->setMapShards[hash % redis->kShards].setMap;
-		{
-			MutexLockGuard lock(mu);
-			auto it = setMap.find(key);
-			if(it == setMap.end())
-			{
-				setMap.insert(std::make_pair(key,val));
-			}
-			else
-			{
-				zfree(it->first);
-				zfree(it->second);
-				setMap.erase(it);
-				setMap.insert(std::make_pair(key,val));
-			}
-		}
-	}
-	
-	return REDIS_OK;
-}
-
-int rdbLoadHset(xRio *rdb,xRedis * redis)
-{
-	int type,rdbver;
-	int len;
-	while(1)
-	{
-		rObj *key,*kkey,*val;
-		std::unordered_map<rObj*,rObj*,Hash,Equal> umap;
-		if ((type = rdbLoadType(rdb)) == -1)
-			return	REDIS_ERR;
-		
-		if (type == REDIS_RDB_HSET)
-			return REDIS_OK;
-		
-		if ((key = rdbLoadStringObject(rdb)) == nullptr)
-			return	REDIS_ERR;
-
-		if ((len = rdbLoadLen(rdb,nullptr)) == -1)
-			return	REDIS_ERR;
-		
-		
-		for(int i = 0 ; i < len; i ++)
-		{
-			if ((rdbver = rdbLoadType(rdb)) == -1)
-				return	REDIS_ERR;
-			
-			if(rdbver != REDIS_RDB_TYPE_STRING)
-				return REDIS_ERR;
-				
-			if ((kkey = rdbLoadStringObject(rdb)) == nullptr)
-				return	REDIS_ERR;
-	  
-			if ((val = rdbLoadObject(rdbver,rdb)) == nullptr)
-				return	REDIS_ERR;
-
-			kkey->calHash();
-			umap.insert(std::make_pair(kkey,val));
-		}
-
-		key->calHash();
-		size_t hash = key->hash;
-		MutexLock &mu = redis->hsetMapShards[hash% redis->kShards].mutex;
-		auto & hsetMap = redis->hsetMapShards[hash % redis->kShards].hsetMap;
-		MutexLockGuard lock(mu);
-		auto it = hsetMap.find(key);
-		if(it == hsetMap.end())
-		{
-			hsetMap.insert(std::make_pair(key,std::move(umap)));
-		}
-		else
-		{
-			zfree(it->first);
-			for(auto iter = it->second.begin(); iter != it->second.end(); iter++)
-			{
-				zfree(iter->first);
-				zfree(iter->second);
-			}
-			it->second.clear();
-			hsetMap.erase(it);
-			hsetMap.insert(std::make_pair(key,std::move(umap)));
-		}
-		
-	}
-
-	return REDIS_OK;
-}
-
-
-int rdbLoadSSet(xRio * rdb,xRedis * redis)
-{
-	int type,rdbver;
-	int len;
-
-	while(1)
-	{
-		rObj *key,*val;
-
-		std::unordered_set<rObj*,Hash,Equal> umap;
-		if ((type = rdbLoadType(rdb)) == -1)
-		{
-			return  REDIS_ERR;
-		}
-
-		if (type == REDIS_RDB_SSET)
-		{
-			return REDIS_OK;
-		}
-
-		if ((key = rdbLoadStringObject(rdb)) == nullptr)
-			return	REDIS_ERR;
-
-		if ((len = rdbLoadLen(rdb,nullptr)) == -1)
-			return	REDIS_ERR;
-
-		for(int i = 0 ; i < len; i ++)
-		{
-			if ((rdbver = rdbLoadType(rdb)) == -1)
-				return	REDIS_ERR;
-
-			if(rdbver != REDIS_RDB_TYPE_STRING)
-				return REDIS_ERR;
-
-			if ((val = rdbLoadObject(rdbver,rdb)) == nullptr)
-				return	REDIS_ERR;
-
-			val->calHash();
-			umap.insert(val);
-
-		}
-
-		key->calHash();
-		size_t hash = key->hash;
-		MutexLock &mu = redis->setShards[hash% redis->kShards].mutex;
-		auto & set = redis->setShards[hash % redis->kShards].set;
-		MutexLockGuard lock(mu);
-		auto it = set.find(key);
-		if(it == set.end())
-		{
-			set.insert(std::make_pair(key,std::move(umap)));
-		}
-		else
-		{
-
-			for(auto iter = it->second.begin(); iter != it->second.end(); iter++)
-			{
-				zfree(*iter);
-			}
-
-			set.erase(it);
-			zfree(it->first);
-			set.insert(std::make_pair(key,std::move(umap)));
-		}
-
-
-	}
-
-}
-
-
-int rdbLoadSortSet(xRio * rdb,xRedis * redis)
-{
-	int type,rdbver;
-	int len;
-	while(1)
-	{
-		rObj *key,*kkey,*val;
-		std::unordered_map<rObj*,rObj*,Hash,Equal> umap;
-		std::set<rSObj> smap;
-		if ((type = rdbLoadType(rdb)) == -1)
-			return	REDIS_ERR;
-
-		if (type == REDIS_RDB_SORT_SET)
-			return REDIS_OK;
-
-		if ((key = rdbLoadStringObject(rdb)) == nullptr)
-			return	REDIS_ERR;
-
-		if ((len = rdbLoadLen(rdb,nullptr)) == -1)
-			return	REDIS_ERR;
-
-		key->calHash();
-		size_t hash = key->hash;
-		MutexLock &mu = redis->sortSetShards[hash% redis->kShards].mutex;
-		auto & set = redis->sortSetShards[hash % redis->kShards].set;
-		auto &sset =  redis->sortSetShards[hash % redis->kShards].sset;
-		{
-			MutexLockGuard lock(mu);	
-			auto it = set.find(key);
-			if(it == set.end())
-			{
-				for(int i = 0 ; i < len; i ++)
-				{
-					if ((rdbver = rdbLoadType(rdb)) == -1)
-						return	REDIS_ERR;
-				
-					if(rdbver != REDIS_RDB_TYPE_STRING)
-						return REDIS_ERR;
-				
-					if ((kkey = rdbLoadStringObject(rdb)) == nullptr)
-						return	REDIS_ERR;
-				
-					if ((val = rdbLoadObject(rdbver,rdb)) == nullptr)
-						return	REDIS_ERR;
-				
-					kkey->calHash();
-					umap.insert(std::make_pair(kkey,val));
-				
-					rSObj obj;
-					obj.key = val;
-					obj.value = kkey;
-					smap.insert(std::move(obj));
-				}
-				sset.insert(std::make_pair(key,std::move(smap)));
-				set.insert(std::make_pair(key,std::move(umap)));
-			}
-			else
-			{
-				auto itt = sset.find(key);
-				if(itt == sset.end())
-				{
-					assert(false);
-				}
-				zfree(key);
-				
-				for(int i = 0 ; i < len; i ++)
-				{
-					if ((rdbver = rdbLoadType(rdb)) == -1)
-						return	REDIS_ERR;
-				
-					if(rdbver != REDIS_RDB_TYPE_STRING)
-						return REDIS_ERR;
-				
-					if ((kkey = rdbLoadStringObject(rdb)) == nullptr)
-						return	REDIS_ERR;
-				
-					if ((val = rdbLoadObject(rdbver,rdb)) == nullptr)
-						return	REDIS_ERR;
-				
-					kkey->calHash();
-					auto iter = it->second.find(kkey);
-					if(iter == it->second.end())
-					{
-						rSObj obj;
-						obj.key = val;
-						obj.value = kkey;
-						itt->second.insert(std::move(obj));
-						it->second.insert(std::make_pair(kkey,val));	
-					}
-					else
-					{
-						zfree(kkey);
-						{
-							rSObj  robj;
-							robj.key = iter->second;
-							robj.value = iter->first;
-							itt->second.erase(std::move(robj));
-						}
-						
-						zfree(iter->second);
-						iter->second = val;
-						{
-						
-							rSObj  robj;
-							robj.key = iter->second;
-							robj.value = iter->first;
-							itt->second.insert(std::move(robj));
-						}
-					
-					}
-				
-					
-				}
-			}
-		}
-	}
-	
-	return REDIS_OK;
-}
-
-
-bool   rdbReplication(char *filename,xSession *session)
-{
-	xRio rdb;
-	FILE *fp ;
-	if((fp = fopen(filename,"r")) == nullptr)
-	{
-		return false;
-	}
-	
-	rioInitWithFile(&rdb,fp);
-	struct stat sb;
-	if(fstat(fileno(fp),&sb) == -1)
-	{
-		return false;
-	}
-	else
-	{
-		LOG_INFO<<"load dump.rdb size :"<<sb.st_size;
-	}
-
-	size_t len = REDIS_SLAVE_SYNC_SIZE;
-	
-	char str[4];
-	int32_t * sendLen = (int32_t*)str;
-	*sendLen = sb.st_size;
-	int32_t sendBytes  = * sendLen ;
-	session->sendBuf.append((const char*)str,4);
-	session->conn->send(&session->sendBuf);
-	session->sendBuf.retrieveAll();
-	
-	while(sendBytes)
-	{
-		if(sendBytes <  len)
-		{
-			len = sendBytes;
-		}
-	
-		char buf[len ];
-		size_t readBytes = rioRepliRead(&rdb,(void*)buf,len);
-		if(readBytes == 0)
-		{
-			fclose(fp);
-			return false;
-		}
-		session->sendBuf.append((const char *)buf,readBytes);
-		session->conn->send(&session->sendBuf);
-		session->sendBuf.retrieveAll();
-
-		sendBytes -=readBytes;
-	}
-
-	fclose(fp);
-	return true;
-}
-
-
-
-
-int  closeFile(FILE * fp)
-{
-	if (fclose(fp) == EOF) return REDIS_ERR;
-}
-
-
-FILE *createFile()
-{
-	FILE *fp ;
-	char tmpfile[256];
-	snprintf(tmpfile,256,"temp-%d.rdb",(int)getpid());
-	fp = fopen(tmpfile,"w");
-	if(!fp)
-	{
-		 LOG_TRACE<<"Failed opening .rdb for saving:"<<strerror(errno);
-		 return nullptr;
-	}
-	
-	return fp;	
-}
-
-
-int rdbSyncWrite(const char *buf,FILE * fp,size_t len)
-{
-	xRio rdb;
-	rioInitWithFile(&rdb,fp);
-	if(rioWrite(&rdb,buf,len) == 0)
-	{
-		return REDIS_ERR;
-	}
-}
-
-
-int  rdbSyncClose(char * fileName,FILE * fp)
-{
-	if (fflush(fp) == EOF) return REDIS_ERR;
-	if (fsync(fileno(fp)) == -1) return REDIS_ERR;
-	if (fclose(fp) == EOF) return REDIS_ERR;
-
-
-	char tmpfile[256];
-	snprintf(tmpfile,256,"temp-%d.rdb",(int)getpid());
-	
-	if(rename(tmpfile,fileName) == -1)
-	{
-		return REDIS_ERR;
-	}
-}
-
-int  rdbWrite(char *filename,const char *buf, size_t len)
-{
-	FILE *fp ;
-	xRio rdb;
-	char tmpfile[256];
-	snprintf(tmpfile,256,"temp-%d.rdb",(int)getpid());
-	fp = fopen(tmpfile,"w");
-	if(!fp)
-	{
-		 LOG_TRACE<<"Failed opening .rdb for saving:"<<strerror(errno);
-		 return REDIS_ERR;
-	}
-
-	rioInitWithFile(&rdb,fp);
-	if(rioWrite(&rdb,buf,len) == 0)
-	{
-		return REDIS_ERR;
-	}
-
-	if (fflush(fp) == EOF) return REDIS_ERR;
-	if (fsync(fileno(fp)) == -1) return REDIS_ERR;
-	if (fclose(fp) == EOF) return REDIS_ERR;
-
-	if(rename(tmpfile,filename) == -1)
-	{
-		return REDIS_ERR;
-	}
-	
-	return REDIS_OK;
-}
-
-
-int rdbLoad(char *filename,xRedis * redis)
-{
-	uint32_t dbid;
-	int type,rdbver;
-	char buf[1024];
-	FILE *fp ;
-	xRio rdb;
-
-	if((fp = fopen(filename,"r")) == nullptr)
-	{
-		return REDIS_ERR;
-	}
-	rioInitWithFile(&rdb,fp);
-	if(rioRead(&rdb,buf,9) == 0)
-	{
-		return REDIS_ERR;
-	}
-	buf[9] = '\0';
-
-	if(memcmp(buf,"REDIS",5) !=0)
-	{
-		fclose(fp);
-		LOG_ERROR<<"Wrong signature trying to load DB from file";
-		return REDIS_ERR;
-	}
-
-	struct stat sb;
-	if(fstat(fileno(fp),&sb) == -1)
-	{	
-		return REDIS_ERR;
-	}
-	else
-	{
-		LOG_INFO<<"load dump.rdb "<<sb.st_size;
-	}
-
-	if(rdbLoadSet(&rdb,redis) != REDIS_OK )
-	{
-		return REDIS_ERR;
-	}
-	
-	if(rdbLoadHset(&rdb,redis) != REDIS_OK)
-	{
-		return REDIS_ERR;
-	}
-	
-	if(rdbLoadSSet(&rdb,redis) != REDIS_OK)
-	{
-		return REDIS_ERR;
-	}
-
-	if(rdbLoadSortSet(&rdb,redis) != REDIS_OK)
-	{
-		return REDIS_ERR;
-	}
-
-
-	uint64_t cksum,expected = rdb.cksum;
-	if(rioRead(&rdb,&cksum,8) == 0)
-	{
-		return REDIS_ERR;
-	}
-	
-	if (cksum == 0)
-	{
-		LOG_WARN<<"RDB file was saved with checksum disabled: no check performed";
-		return REDIS_ERR;
-	}
-	else if(cksum != expected)
-	{
-		LOG_WARN<<"Wrong RDB checksum. Aborting now";
-		return REDIS_ERR;
-	}
-
-	fclose(fp);
-	return REDIS_OK;
-}
-
-
-int rdbLoadType(xRio *rdb) 
-{
-    unsigned char type;
-    if (rioRead(rdb,&type,1) == 0) return -1;
-    return type;
-}
-
-
-uint32_t rdbLoadUType(xRio *rdb) 
-{
-    uint32_t  type;
-    if (rioRead(rdb,&type,1) == 0) return -1;
-    return type;
-}
-
-
-
-
-int rdbSaveLen(xRio *rdb, uint32_t len)
-{
-    unsigned char buf[2];
-    size_t nwritten;
-
-    if (len < (1<<6)) {
-        /* Save a 6 bit len */
-        buf[0] = (len&0xFF)|(REDIS_RDB_6BITLEN<<6);
-        if (rdbWriteRaw(rdb,buf,1) == -1) return -1;
-        nwritten = 1;
-    } else if (len < (1<<14)) {
-        /* Save a 14 bit len */
-        buf[0] = ((len>>8)&0xFF)|(REDIS_RDB_14BITLEN<<6);
-        buf[1] = len&0xFF;
-        if (rdbWriteRaw(rdb,buf,2) == -1) return -1;
-        nwritten = 2;
-    } else {
-        /* Save a 32 bit len */
-        buf[0] = (REDIS_RDB_32BITLEN<<6);
-        if (rdbWriteRaw(rdb,buf,1) == -1) return -1;
-        len = htonl(len);
-        if (rdbWriteRaw(rdb,&len,4) == -1) return -1;
-        nwritten = 1+4;
-    }
-    return nwritten;
-}
-
-
-int rdbSaveLzfStringObject(xRio *rdb, unsigned char *s, size_t len)
-{
-	size_t comprlen,outlen;
-	unsigned char byte;
-	int n,nwritten = 0;
-	void *out;
-
-	if(len <=4 ) return 0;
-	outlen = len- 4;
-	if((out = zmalloc(outlen + 1)) == nullptr) return 0;
-	comprlen = lzf_compress(s,len,out,outlen);
-	if(comprlen == 0)
-	{
-		zfree(out);
-		return 0;
-	}
-	
-	/* Data compressed! Let's save it on disk */
-    byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF;
-    if ((n = rdbWriteRaw(rdb,&byte,1)) == -1) return REDIS_ERR;
-    nwritten += n;
-
-    if ((n = rdbSaveLen(rdb,comprlen)) == -1) return REDIS_ERR;
-    nwritten += n;
-
-    if ((n = rdbSaveLen(rdb,len)) == -1) return REDIS_ERR;
-    nwritten += n;
-
-    if ((n = rdbWriteRaw(rdb,out,comprlen)) == -1) return REDIS_ERR;
-    nwritten += n;
-
-    zfree(out);
-    return nwritten;
-	
-}
-
-size_t rdbSaveRawString(xRio *rdb, const  char *s, size_t len)
-{
-	int enclen;
-	int n,nwritten = 0;
-
-	if( len > 20)
-	{
-		n = rdbSaveLzfStringObject(rdb, (unsigned char*)s,len);
-		if (n == -1) return -1;
-      	if (n > 0) return n;
-	}
-	
-	if((n = rdbSaveLen(rdb,len) == -1))
-	{
-		return -1;
-	}
-	nwritten += n;
-	if(len > 0)
-	{
-		if (rdbWriteRaw(rdb,(void*)s,len) == -1) 
-		{
-			return -1;	
-		}
-		
-        nwritten += len;
-	}
-	
-	return nwritten;
-	
-}
-
-
-
-rObj *rdbLoadObject(int rdbtype, xRio *rdb) 
-{
-	rObj *o = nullptr;
-	size_t len;
-	unsigned int i;
-	if(rdbtype == REDIS_RDB_TYPE_STRING)
-	{
-		if ((o = rdbLoadEncodedStringObject(rdb)) == nullptr)
-		{
-			return nullptr;	
-		}
-	}
-	else
-	{
-		LOG_WARN<<"rdbLoadObject type error";
-	}
-	return o;
-}
-
-int rdbSaveStringObject(xRio *rdb, rObj *obj)
-{
-	return rdbSaveRawString(rdb,obj->ptr,sdsllen(obj->ptr));
-}
-
-
-int rdbSaveType(xRio *rdb, unsigned char type)
-{
-    return rdbWriteRaw(rdb,&type,1);
-}
-
-
-
-int rdbSaveObjectType(xRio *rdb, rObj *o)
-{
-	switch(o->type)
-	{
-		case REDIS_STRING:
-		{
-			return rdbSaveType(rdb,REDIS_RDB_TYPE_STRING);
-		}
-		case REDIS_LIST:
-		{
-			return rdbSaveType(rdb,REDIS_RDB_TYPE_LIST);
-		}
-		
-		case REDIS_SET:
-		{
-			return rdbSaveType(rdb,REDIS_RDB_TYPE_SET);
-		}
-		
-		case REDIS_ZSET:
-		{
-			return rdbSaveType(rdb,REDIS_RDB_TYPE_ZSET);
-		}
-		
-		case REDIS_HASH:
-		{
-			return rdbSaveType(rdb,REDIS_RDB_TYPE_HASH);
-		}
-		default:
-        	{
-			LOG_WARN<<"Unknown object type";
-		}
-		
-	}
-	
-	return  -1;
-}	
-
-
-int rdbSaveObject(xRio *rdb, rObj *o)
-{
-	int n, nwritten = 0;
-
-	if (o->type == OBJ_STRING)
-	{
-		if ((n = rdbSaveStringObject(rdb,o)) == -1)
-		{
-			return -1;
-		}
-		nwritten += n;
-    } 
-    else if (o->type == OBJ_LIST)
-    {
-    	
-    }
-    
-    return nwritten;
-}
-
-	
-
-int rdbSaveKeyValuePair(xRio *rdb, rObj *key, rObj *val, long long now)
-{
-    if (rdbSaveObjectType(rdb,val) == -1) return -1;
-    if (rdbSaveStringObject(rdb,key) == -1) return -1;
-    if (rdbSaveObject(rdb,val) == -1) return -1;
-	return 1;
-}
-
-
-int rdbSaveValue(xRio *rdb, rObj *value,long long now)
-{
-    if (rdbSaveObjectType(rdb,value) == -1) return -1;
-    if (rdbSaveStringObject(rdb,value) == -1) return -1;
-
-	return 1;
-}
-
-
-
-int rdbSaveKey(xRio *rdb, rObj *key,long long now)
-{
-    if (rdbSaveObjectType(rdb,key) == -1) return -1;
-    if (rdbSaveStringObject(rdb,key) == -1) return -1;
-	return 1;
-}
-
-
-
-int rdbWriteRaw(xRio *rdb, void *p, size_t len)
-{
-   if (rdb && rioWrite(rdb,p,len) == 0)
-   { 
-   	 return -1;
-   }
-	
-   return len;
-}
-
-
-int rdbSaveRio(xRio *rdb,int *error,xRedis * redis)
-{
-	char magic[10];
-	int j;
-	long long now = time(0);
-	uint64_t cksum;
-	snprintf(magic,sizeof(magic),"REDIS%04d",REDIS_RDB_VERSION);
-	if (rdbWriteRaw(rdb,magic,9) == -1)
-	{
-		*error = errno;
-		return REDIS_ERR;
-	}
-
-	rdbSaveSet(rdb,redis);
-	rdbSaveHset(rdb,redis);
-	rdbSaveSSet(rdb,redis);
-	rdbSaveSortSet(rdb,redis);
-
-	cksum = rdb->cksum;
-	if(rioWrite(rdb,&cksum,8) == 0)
-	{
-		*error = errno;
-		return REDIS_ERR;
-	}
-	
-	return REDIS_OK;
-}
-int rdbSave(char *filename,xRedis * redis)
-{
-	char tmpfile[256];
-	FILE *fp;
-	xRio rdb;
-	int error;
-
-	snprintf(tmpfile,256,"temp-%d.rdb",(int)getpid());
-	fp = fopen(tmpfile,"w");
-	if(!fp)
-	{
-		 LOG_TRACE<<"Failed opening .rdb for saving:"<<strerror(errno);
-		 return REDIS_ERR;
-	}
-
-	rioInitWithFile(&rdb,fp);
-	if(rdbSaveRio(&rdb,&error,redis) == REDIS_ERR)
-	{
-		errno = error;
-		goto werr;
-	}
-
-	if (fflush(fp) == EOF) goto werr;
-	if (fsync(fileno(fp)) == -1) goto werr;
-	if (fclose(fp) == EOF) goto werr;
-
-	if(rename(tmpfile,filename) == -1)
-	{
-		LOG_TRACE<<"Error moving temp DB file  on the final:"<<strerror(errno);
-		unlink(tmpfile);
-		return REDIS_ERR;
-	}
-
-	return REDIS_OK;
-werr:
-	 LOG_WARN<<"Write error saving DB on disk:" <<strerror(errno);
-	 fclose(fp);
-	 unlink(tmpfile);
-	 return REDIS_ERR;
-}
diff --git a/src/xRdb.h b/src/xRdb.h
deleted file mode 100644
index dd688956..00000000
--- a/src/xRdb.h
+++ /dev/null
@@ -1,115 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xSds.h"
-#include "xCrc64.h"
-#include "xObject.h"
-#include "xLzf.h"
-#include "xPosix.h"
-#include "xRedis.h"
-
-
-class xRio
-{
-public:
-	xRio();
-	~xRio();
-	union
-	{
-		struct
-		{
-			sds ptr;
-			off_t pos;
-		}buffer;
-
-		struct
-		{
-			FILE *fp;
-			off_t buffered;
-			off_t autosync;
-		}file;
-
-		struct
-		{
-			int *fds;
-			int *state;
-			int numfds;
-			off_t pos;
-			sds buf;
-		}fdset;
-	}io;
-
-public:
-	uint64_t cksum;
-	size_t processedBytes;
-	size_t maxProcessingChunk;
-
-	std::function<size_t (xRio *,void * buf,size_t len) > readFuc;
-	std::function<size_t (xRio *,const void *buf,size_t len) > writeFuc;
-	std::function<off_t (xRio *) > tellFuc;
-	std::function<int (xRio *) > flushFuc;
-	std::function<void (xRio *,const void *buf,size_t len) > updateFuc;
-};
-
-
-
-off_t  rioTell(xRio *r);
-size_t rioWrite(xRio *r,const void *buf,size_t len);
-size_t rioRead(xRio *r,void *buf,size_t len);
-size_t rioRepliRead(xRio * r,void *buf,size_t len);
-off_t  rioFlush(xRio *r);
-
-
-size_t rioFileRead(xRio*r, void *buf, size_t len);
-size_t rioFileWrite(xRio *r, const void *buf, size_t len);
-
-inline off_t rioFileTell(xRio *r);
-int rioFileFlush(xRio *r);
-
-void rioInitWithFile(xRio *r, FILE *fp);
-void rioInitWithBuffer(xRio *r, sds s);
-
-FILE * createFile();
-int  closeFile(FILE * fp);
-
-
-int rdbSaveType(xRio *rdb, unsigned char type);
-int rdbSaveLen(xRio *rdb, uint32_t len);
-int rdbSave(char *filename,xRedis * redis);
-int rdbSaveRio(xRio *rdb, int *error,xRedis * redis);
-int rdbSaveObject(xRio *rdb, rObj *o);
-int rdbSaveStringObject(xRio *rdb, rObj *obj);
-int rdbSaveKeyValuePair(xRio *rdb, rObj *key, rObj *val, long long now);
-size_t rdbSaveRawString(xRio *rdb, const char *s, size_t len);
-int rdbSaveLzfStringObject(xRio *rdb, unsigned char *s, size_t len);
-int rdbSaveValue(xRio *rdb, rObj *value,long long now);
-int rdbSaveKey(xRio *rdb, rObj *value,long long now);
-int rdbSaveSet(xRio *rdb,xRedis * redis);
-int rdbSaveHset(xRio *rdb,xRedis * redis);
-int rdbSaveSSet(xRio *rdb,xRedis * redis);
-int rdbSaveSortSet(xRio *rdb,xRedis * redis);
-int rdbSaveObjectType(xRio *rdb, rObj *o);
-
-int rdbLoadType(xRio *rdb);
-uint32_t rdbLoadUType(xRio *rdb);
-rObj *rdbLoadIntegerObject(xRio *rdb, int enctype, int encode);
-rObj *rdbLoadEncodedStringObject(xRio *rdb);
-rObj *rdbLoadLzfStringObject(xRio *rdb);
-int rdbLoadSet(xRio *rdb,xRedis * redis);
-int rdbLoadHset(xRio *rdb,xRedis * redis);
-int rdbLoadSSet(xRio * rdb,xRedis * redis);
-int rdbLoadSortSet(xRio * rdb,xRedis * redis);
-uint32_t rdbLoadLen(xRio *rdb, int *isencoded);
-int rdbLoad(char *filename,xRedis * redis);
-bool  rdbReplication(char *filename,xSession *session);
-rObj *rdbLoadObject(int type, xRio *rdb);
-rObj *rdbLoadStringObject(xRio *rdb);
-
-void rioGenericUpdateChecksum(xRio *r, const void *buf, size_t len);
-int rdbWriteRaw(xRio *rdb, void *p, size_t len);
-int rdbTryIntegerEncoding(char *s, size_t len, unsigned char *enc);
-int rdbEncodeInteger(long long value, unsigned char *enc);
-rObj *rdbGenericLoadStringObject(xRio *rdb, int encode);
-int  rdbWrite(char *filename,const char *buf, size_t len);
-int rdbSyncWrite(const char *buf,FILE * fp,size_t len);
-int rdbSyncClose(char * fileName,FILE * fp);
-
diff --git a/src/xRedis.cpp b/src/xRedis.cpp
deleted file mode 100755
index b56ed8a2..00000000
--- a/src/xRedis.cpp
+++ /dev/null
@@ -1,2474 +0,0 @@
-#include "xRedis.h"
-
-xRedis::xRedis(const char * ip, int16_t port, int16_t threadCount,bool enbaledCluster,bool enabledSentinel)
-:host(ip),
-port(port),
-threadCount(threadCount),
-masterPort(0),
-clusterEnabled(enbaledCluster),
-slaveEnabled(false),
-authEnabled(false),
-repliEnabled(false),
-salveCount(0),
-clusterSlotEnabled(false),
-clusterRepliMigratEnabled(false),
-clusterRepliImportEnabeld(false),
-count(0),
-pingPong(false)
-{
-	initConifg();
-	createSharedObjects();
-	loadDataFromDisk();
-	server.init(&loop, host, port,this);
-	server.setConnectionCallback(std::bind(&xRedis::connCallBack, this, std::placeholders::_1,std::placeholders::_2));
-	server.setThreadNum(threadCount);
-	server.start();
-	zmalloc_enable_thread_safeness();
-}
-
-xRedis::~xRedis()
-{
-	destorySharedObjects();
-	clearCommond();
-}
-
-
-
-
-bool xRedis::clearClusterMigradeCommond(void * data)
-{
-
-}
-
-void xRedis::replyCheck()
-{
-
-}
-
-void xRedis::test(void * data)
-{
-	count++;
-	LOG_INFO << count;
-}
-
-void xRedis::handleTimeOut(void * data)
-{
-	loop.quit();
-}
-
-void xRedis::handleSetExpire(void * data)
-{
-	rObj * obj = (rObj*) data;
-	int count = 0 ;
-	removeCommond(obj,count);
-}
-
-
-void xRedis::handleSalveRepliTimeOut(void * data)
-{
-	int32_t *sockfd = (int32_t *)data;
-	MutexLockGuard mu(slaveMutex);
-	auto it = salvetcpconnMaps.find(*sockfd);
-	if(it != salvetcpconnMaps.end())
-	{
-		it->second->forceClose();
-	}
-	LOG_INFO<<"sync connect repli  timeout ";
-}
-
-
-void xRedis::clearRepliState(int32_t sockfd)
-{
-	{
-		MutexLockGuard mu(slaveMutex);
-		auto it = salvetcpconnMaps.find(sockfd);
-		if(it != salvetcpconnMaps.end())
-		{
-			salveCount--;
-			salvetcpconnMaps.erase(sockfd);
-			if(salvetcpconnMaps.size() == 0)
-			{
-				repliEnabled = false;
-				xBuffer buffer;
-				slaveCached.swap(buffer);
-			}
-		}
-
-		auto iter = repliTimers.find(sockfd);
-		if(iter != repliTimers.end())
-		{
-			loop.cancelAfter(iter->second);
-			repliTimers.erase(iter);
-		}
-
-	}
-
-
-}
-void xRedis::connCallBack(const xTcpconnectionPtr& conn,void *data)
-{
-	if(conn->connected())
-	{
-		socket.getpeerName(conn->getSockfd(),&(conn->host),conn->port);
-		std::shared_ptr<xSession> session (new xSession(this,conn));
-		MutexLockGuard mu(mutex);
-		sessions[conn->getSockfd()] = session;
-		//LOG_INFO<<"Client connect success";
-	}
-	else
-	{
-		{
-			clearRepliState(conn->getSockfd());
-		}
-	
-		{
-			MutexLockGuard mu(mutex);
-			sessions.erase(conn->getSockfd());
-		}
-
-		
-		//LOG_INFO<<"Client disconnect";
-	}
-}
-
-
-bool xRedis::deCodePacket(const xTcpconnectionPtr& conn,xBuffer *recvBuf,void  *data)
-{
- 	return true;
-}
-
-
-void xRedis::run()
-{
-	loop.run();
-}
-
-
-void xRedis::loadDataFromDisk()
-{
-	char rdb_filename[] = "dump.rdb";
-	  
-	if(rdbLoad(rdb_filename,this) == REDIS_OK)
-	{
-		LOG_INFO<<"load rdb success";
-	}
-	else if (errno != ENOENT)
-	{
-        LOG_WARN<<"Fatal error loading the DB:  Exiting."<<strerror(errno);
-    }
-
-}
-
-
-bool xRedis::zrevrangeCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size()  < 3  || obj.size() > 4)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown zrevrange  error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash = obj[0]->hash;
-	long long  begin = 0;
-	string2ll(obj[1]->ptr,sdsllen(obj[1]->ptr),&begin);
-	long long  end = 0;
-	string2ll(obj[2]->ptr,sdsllen(obj[2]->ptr),&end);
-
-	MutexLock &mu = sortSetShards[hash% kShards].mutex;
-	auto &sset = sortSetShards[hash% kShards].sset;
-	{
-		MutexLockGuard lock(mu);
-		auto it = sset.find(obj[0]);
-		if(it != sset.end())
-		{
-			addReplyMultiBulkLen(session->sendBuf,sset.size() * 2);
-			int i  = 0 ;
-			for(auto iter = it->second.rbegin(); iter != it->second.rend(); iter ++)
-			{
-				addReplyBulkCBuffer(session->sendBuf,(*iter).value->ptr,sdsllen((*iter).value->ptr));
-				addReplyBulkCBuffer(session->sendBuf,(*iter).key->ptr,sdsllen((*iter).key->ptr));
-			}
-		}
-		else
-		{
-			addReplyMultiBulkLen(session->sendBuf,0);
-		}
-	}
-
-	for(auto it  = obj.begin(); it != obj.end(); it ++)
-	{
-		zfree(*it);
-	}
-
-	return true;
-}
-
-
-bool xRedis::zaddCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() < 3  ||   (obj.size() - 1 ) % 2  != 0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown zadd  error");
-		return false;
-	}
-
-	int count = 0;
-	obj[0]->calHash();
-	size_t hash = obj[0]->hash;
-	MutexLock &mu = sortSetShards[hash% kShards].mutex;
-	auto &set = sortSetShards[hash% kShards].set;
-	auto &sset = sortSetShards[hash% kShards].sset;
-	{
-		MutexLockGuard lock(mu);
-		auto it = set.find(obj[0]);
-		if(it == set.end())
-		{
-			SetMap setMap;
-			std::set<rSObj> sObj;
-		
-			for(int i = 1; i < obj.size(); i +=2)
-			{
-				obj[i]->calHash();
-				obj[i + 1]->calHash();
-				auto iter = setMap.find(obj[i + 1]);
-				if(iter == setMap.end())
-				{
-					rSObj robj;
-					robj.key = obj[i];
-					robj.value = obj[i + 1];
-					sObj.insert(robj);
-					setMap.insert(std::make_pair(obj[i + 1],obj[i]));
-					count++;
-				}
-				else
-				{
-					{
-						rSObj  robj;
-						robj.key = iter->second;
-						robj.value = iter->first;
-						sObj.erase(robj);
-					}
-
-					zfree(obj [i + 1]);
-					zfree(iter->second);
-					iter->second = obj[i];
-					
-					{
-						rSObj  robj;
-						robj.key = iter->second;
-						robj.value = iter->first;
-						sObj.insert(robj);
-					}
-					
-				}
-			}
-			
-			set.insert(std::make_pair(obj[0],setMap));
-			sset.insert(std::make_pair(obj[0],sObj));
-			
-		}
-		else
-		{
-			auto itt = sset.find(obj[0]);
-			if(itt == sset.end())
-			{
-				assert(false);
-			}
-			
-			zfree(obj[0]);
-			for(int i = 1; i < obj.size(); i +=2)
-			{
-				obj[i]->calHash();
-				obj[i + 1]->calHash();
-				auto iter = it->second.find(obj[i + 1]);
-				if(iter == it->second.end())
-				{
-					rSObj robj;
-					robj.key = obj[i];
-					robj.value = obj[i + 1];
-					itt->second.insert(robj);
-					it->second.insert(std::make_pair(obj[i + 1],obj[i]));
-					count++;
-				}
-				else
-				{
-					{
-						rSObj  robj;
-						robj.key = iter->second;
-						robj.value = iter->first;
-						itt->second.erase(robj);
-					}
-				
-					zfree(obj [i + 1]);	
-					zfree(iter->second);
-					iter->second = obj[i];
-					{
-					
-						rSObj  robj;
-						robj.key = iter->second;
-						robj.value = iter->first;
-						itt->second.insert(robj);
-					}
-				
-				}
-			}
-				
-		}
-	}
-
-	addReplyLongLong(session->sendBuf,count);
-	return true;
-}
-
-bool xRedis::zcardCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	return false;
-}
-
-bool xRedis::zcountCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	return false;
-}
-
-
-bool xRedis::keysCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1 )
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown keys  error");
-		return false;
-	}
-
-	std::string des  = "*";
-	std::string src = obj[0]->ptr;
-
-
-	addReplyMultiBulkLen(session->sendBuf,getDbsize());
-
-	{
-		for(auto it = setMapShards.begin(); it != setMapShards.end(); it++)
-		{
-			auto &map = (*it).setMap;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter != map.end(); iter++)
-			{
-				addReplyBulkCBuffer(session->sendBuf,iter->first->ptr,sdsllen(iter->first->ptr));
-			}
-
-		}
-
-	}
-
-	{
-		for(auto it = hsetMapShards.begin(); it != hsetMapShards.end(); it++)
-		{
-			auto &map = (*it).hsetMap;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter!=map.end(); iter++)
-			{
-				addReplyBulkCBuffer(session->sendBuf,iter->first->ptr,sdsllen(iter->first->ptr));
-			}
-
-		}
-
-	}
-
-	{
-		for(auto it = setShards.begin(); it != setShards.end(); it++)
-		{
-			auto &map = (*it).set;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter != map.end(); iter ++)
-			{
-				addReplyBulkCBuffer(session->sendBuf,iter->first->ptr,sdsllen(iter->first->ptr));
-			}
-
-		}
-	}
-
-
-
-	{
-		for(auto it = sortSetShards.begin(); it != sortSetShards.end(); it++)
-		{
-			auto &map = (*it).set;
-			auto &mmap = (*it).sset;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter != map.end(); iter ++)
-			{
-				addReplyBulkCBuffer(session->sendBuf,iter->first->ptr,sdsllen(iter->first->ptr));
-			}
-
-		}
-	}
-
-
-	{
-		for(auto it = pubSubShards.begin(); it != pubSubShards.end(); it++)
-		{
-			auto &map = (*it).pubSub;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter != map.end(); iter ++)
-			{
-				addReplyBulkCBuffer(session->sendBuf,iter->first->ptr,sdsllen(iter->first->ptr));
-			}
-
-		}
-	}
-
-
-
-
-	return false;
-}
-
-bool xRedis::zrangeCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size()  < 3  || obj.size() > 4)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown zrange  error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash = obj[0]->hash;
-	long long  begin = 0;
-	string2ll(obj[1]->ptr,sdsllen(obj[1]->ptr),&begin);
-	long long  end = 0;
-	string2ll(obj[2]->ptr,sdsllen(obj[2]->ptr),&end);
-	MutexLock &mu =  sortSetShards[hash% kShards].mutex;
-	auto &sset = sortSetShards[hash% kShards].sset; 
-	{
-		MutexLockGuard lock(mu);
-		auto it = sset.find(obj[0]);
-		if(it != sset.end())
-		{
-			addReplyMultiBulkLen(session->sendBuf,it->second.size() * 2);
-			for(auto iter = it->second.begin(); iter != it->second.end(); iter ++)
-			{
-				addReplyBulkCBuffer(session->sendBuf,(*iter).value->ptr,sdsllen((*iter).value->ptr));
-				addReplyBulkCBuffer(session->sendBuf,(*iter).key->ptr,sdsllen((*iter).key->ptr));
-			}
-		}
-		else
-		{
-			addReplyMultiBulkLen(session->sendBuf,0);
-		}
-	
-	}
-
-	return false;
-}
-
-bool xRedis::zrankCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	return false;
-}
-
-
-bool xRedis::unsubscribeCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown unsubscribe  error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash = obj[0]->hash;
-	MutexLock &mu = pubSubShards[hash% kShards].mutex;
-	auto &pubSub = pubSubShards[hash% kShards].pubSub;
-	{
-		MutexLockGuard lock(mu);
-		auto iter = pubSub.find(obj[0]);
-		if(iter == pubSub.end())
-		{
-			addReply(session->sendBuf,shared.czero);
-		}
-		else
-		{
-			pubSub.erase(iter);
-			zfree(iter->first);
-			addReply(session->sendBuf,shared.ok);
-		}
-	}
-
-	for(auto it = obj.begin(); it != obj.end(); it ++)
-	{
-		zfree(*it);
-	}
-
-	return true;
-}
-
-
-bool xRedis::sentinelCommond(const std::deque<rObj*> & obj, xSession * session)
-{
-	return false;
-}
-
-bool xRedis::memoryCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size()  > 2)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown memory  error");
-		return false;
-		}
-#ifdef USE_JEMALLOC
-
-		char tmp[32];
-		unsigned narenas = 0;
-		size_t sz = sizeof(unsigned);
-		if (!je_mallctl("arenas.narenas", &narenas, &sz, NULL, 0))
-		{
-		sprintf(tmp, "arena.%d.purge", narenas);
-		if (!je_mallctl(tmp, NULL, 0, NULL, 0))
-		{
-			addReply(session->sendBuf, shared.ok);
-			return false;
-		}
-	}
-
-#endif
-
-	addReply(session->sendBuf,shared.ok);
-
-
-	return false;
-}
-
-bool xRedis::infoCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size()  < 0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown info  error");
-		return false;
-	}
-
-	struct rusage self_ru, c_ru;
-	getrusage(RUSAGE_SELF, &self_ru);
-	getrusage(RUSAGE_CHILDREN, &c_ru);
-	sds info = sdsempty();
-
-	char hmem[64];
-	char peak_hmem[64];
-	char total_system_hmem[64];
-	char used_memory_rss_hmem[64];
-	char maxmemory_hmem[64];
-	size_t zmalloc_used = zmalloc_used_memory();
-	size_t total_system_mem =  zmalloc_get_memory_size();
-	bytesToHuman(hmem,zmalloc_used);
-	bytesToHuman(peak_hmem,zmalloc_used);
-	bytesToHuman(total_system_hmem,total_system_mem);
-	bytesToHuman(used_memory_rss_hmem,zmalloc_get_rss());
-	bytesToHuman(maxmemory_hmem, 8);
-
-	info = sdscatprintf(info,
-	"# Memory\r\n"
-	"used_memory:%zu\r\n"
-	"used_memory_human:%s\r\n"
-	"used_memory_rss:%zu\r\n"
-	"used_memory_rss_human:%s\r\n"
-	"used_memory_peak:%zu\r\n"
-	"used_memory_peak_human:%s\r\n"
-	"total_system_memory:%lu\r\n"
-	"total_system_memory_human:%s\r\n"
-	"maxmemory_human:%s\r\n"
-	"mem_fragmentation_ratio:%.2f\r\n"
-	"mem_allocator:%s\r\n",
-	zmalloc_used,
-	hmem,
-	zmalloc_get_rss(),
-	used_memory_rss_hmem,
-	zmalloc_used,
-	peak_hmem,
-	(unsigned long)total_system_mem,
-	total_system_hmem,
-	maxmemory_hmem,
-	zmalloc_get_fragmentation_ratio(zmalloc_get_rss()),
-	ZMALLOC_LIB
-	);
-
-	info = sdscat(info,"\r\n");
-	info = sdscatprintf(info,
-	"# CPU\r\n"
-	"used_cpu_sys:%.2f\r\n"
-	"used_cpu_user:%.2f\r\n"
-	"used_cpu_sys_children:%.2f\r\n"
-	"used_cpu_user_children:%.2f\r\n",
-	(float)self_ru.ru_stime.tv_sec+(float)self_ru.ru_stime.tv_usec/1000000,
-	(float)self_ru.ru_utime.tv_sec+(float)self_ru.ru_utime.tv_usec/1000000,
-	(float)c_ru.ru_stime.tv_sec+(float)c_ru.ru_stime.tv_usec/1000000,
-	(float)c_ru.ru_utime.tv_sec+(float)c_ru.ru_utime.tv_usec/1000000);
-
-	info = sdscat(info,"\r\n");
-	info = sdscatprintf(info,
-	"# Server\r\n"
-	"tcp_connect_count:%d\r\n"
-	"local_ip:%s\r\n"
-	"local_port:%d\r\n"
-	"local_thread_count:%d\n",
-	sessions.size(),
-	host.c_str(),
-	port,
-	threadCount);
-
-	{
-		MutexLockGuard lock(slaveMutex);
-		for(auto it = salvetcpconnMaps.begin(); it != salvetcpconnMaps.end(); it ++)
-		{
-			info = sdscat(info,"\r\n");
-			info = sdscatprintf(info,
-			"# SlaveInfo \r\n"
-			"slave_ip:%s\r\n"
-			"slave_port:%d\r\n",
-			it->second->host.c_str(),
-			it->second->port);
-
-		}
-
-	}
-	
-	addReplyBulkSds(session->sendBuf, info);
-	
-	return false ;
-}
-
-
-bool xRedis::clientCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() > 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown client  error");
-		return false;
-	}
-
-	addReply(session->sendBuf,shared.ok);
-
-	return false;
-}
-
-
-bool xRedis::echoCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() > 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown echo  error");
-		return false;
-	}
-
-	addReplyBulk(session->sendBuf,obj[0]);
-	return false;
-}
-
-bool xRedis::publishCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size()  != 2)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown publish  error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash = obj[0]->hash;
-	MutexLock &mu = pubSubShards[hash% kShards].mutex;
-	auto &pubSub = pubSubShards[hash% kShards].pubSub;
-	{
-		MutexLockGuard lock(mu);
-		auto iter = pubSub.find(obj[0]);
-		if(iter != pubSub.end())
-		{
-			for(auto list = iter->second.begin(); list != iter->second.end(); list ++)
-			{
-				session->pubSubTcpconn.push_back(*list);
-			}
-
-			addReply(session->sendPubSub,shared.mbulkhdr[3]);
-			addReply(session->sendPubSub,shared.messagebulk);
-			addReplyBulk(session->sendPubSub,obj[0]);
-			addReplyBulk(session->sendPubSub,obj[1]);
-			addReplyLongLong(session->sendPubSub,iter->second.size());
-			addReply(session->sendBuf,shared.ok);
-		}
-		else
-		{
-			addReply(session->sendBuf,shared.czero);
-		}
-	}
-
-	return false;
-}
-
-bool xRedis::subscribeCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size()  < 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown subscribe  error");
-		return false;
-	}
-	int count = 0;
-
-	for(auto it = obj.begin(); it != obj.end(); it++)
-	{
-	     (*it)->calHash();
-	     size_t hash = (*it)->hash;
-
-	     MutexLock &mu = pubSubShards[hash% kShards].mutex;
-		auto &pubSub = pubSubShards[hash% kShards].pubSub;
-		{
-			MutexLockGuard lock(mu);
-			auto iter = pubSub.find(*it);
-			if(iter != pubSub.end())
-			{
-				zfree(*it);
-				iter->second.push_back(session->conn);
-			}
-			else
-			{
-				std::list<xTcpconnectionPtr> list;
-				list.push_back(session->conn);
-				pubSub.insert(std::make_pair(*it, std::move(list)));
-			}
-
-		}
-
-		addReply(session->sendBuf, shared.mbulkhdr[3]);
-		addReply(session->sendBuf, shared.subscribebulk);
-		addReplyBulk(session->sendBuf, *it);
-		addReplyLongLong(session->sendBuf, ++count);
-
-	}
-
-	return true;
-}
-
-bool xRedis::authCommond(const std::deque <rObj*> & obj, xSession * session)
-{
-	if (obj.size() > 1)
-	{
-		addReplyErrorFormat(session->sendBuf, "unknown auth  error");
-		return false;
-	}
-
-	if (password.c_str() == nullptr)
-	{
-		addReplyError(session->sendBuf, "Client sent AUTH, but no password is set");
-		return false;
-	}
-
-	if (!strcasecmp(obj[0]->ptr, password.c_str()))
-	{
-		session->authEnabled = true;
-		addReply(session->sendBuf, shared.ok);
-	}
-	else
-	{
-		addReplyError(session->sendBuf, "invalid password");
-	}
-
-
-	return false;
-}
-
-bool xRedis::configCommond(const std::deque <rObj*> & obj, xSession * session)
-{
-
-	if (obj.size() > 3)
-	{
-		addReplyErrorFormat(session->sendBuf, "unknown config  error");
-		return false;
-	}
-
-	if (!strcasecmp(obj[0]->ptr, "set"))
-	{
-		if (obj.size() != 3)
-		{
-			addReplyErrorFormat(session->sendBuf, "Wrong number of arguments for CONFIG %s",
-				(char*)obj[0]->ptr);
-			return false;
-		}
-
-		if (!strcasecmp(obj[1]->ptr, "requirepass"))
-		{
-			password = obj[2]->ptr;
-			authEnabled = true;
-			session->authEnabled = false;
-			addReply(session->sendBuf, shared.ok);
-		}
-		else
-		{
-			addReplyErrorFormat(session->sendBuf, "Invalid argument  for CONFIG SET '%s'",
-				(char*)obj[1]->ptr);
-		}
-
-	}
-	else
-	{
-		addReplyError(session->sendBuf, "CONFIG subcommand must be one of GET, SET, RESETSTAT, REWRITE");
-	}
-
-	return false;
-
-}
-
-bool xRedis::migrateCommond(const std::deque<rObj*> & obj, xSession * session)
-{
-	if (obj.size() < 2)
-	{
-		addReplyErrorFormat(session->sendBuf, "unknown migrate  error");
-	}
-
-	if (!clusterEnabled)
-	{
-		addReplyError(session->sendBuf, "This instance has cluster support disabled");
-		return false;
-	}
-
-	long long port;
-
-	if (getLongLongFromObject(obj[1], &port) != REDIS_OK)
-	{
-		addReplyErrorFormat(session->sendBuf, "Invalid TCP port specified: %s",
-			(char*)obj[2]->ptr);
-		return false;
-	}
-
-
-	std::string ip = obj[0]->ptr;
-	if (ip == host  &&  this->port == port)
-	{
-		addReplyErrorFormat(session->sendBuf, "migrate  self server error ");
-		return false;
-	}
-
-	clus.asyncReplicationToNode( ip , port);
-
-	addReply(session->sendBuf, shared.ok);
-	return false;
-}
-
-bool xRedis::clusterCommond(const std::deque <rObj*> & obj, xSession * session)
-{
-	if (!clusterEnabled)
-	{
-		addReplyError(session->sendBuf, "This instance has cluster support disabled");
-		return false;
-	}
-
-	if (!strcasecmp(obj[0]->ptr, "meet"))
-	{
-		if (obj.size() != 3)
-		{
-			addReplyErrorFormat(session->sendBuf, "unknown cluster  error");
-			return false;
-		}
-
-		long long port;
-
-		if (getLongLongFromObject(obj[2], &port) != REDIS_OK)
-		{
-			addReplyErrorFormat(session->sendBuf, "Invalid TCP port specified: %s",
-				(char*)obj[2]->ptr);
-			return false;
-		}
-
-		if (host.c_str() && !memcmp(host.c_str(), obj[1]->ptr, sdsllen(obj[1]->ptr))
-			&& this->port == port)
-		{
-			LOG_WARN << "cluster  meet  connect self error .";
-			addReplyErrorFormat(session->sendBuf, "Don't connect self ");
-			return false;
-		}
-
-		{
-			MutexLockGuard lk(clusterMutex);
-			for (auto it = clustertcpconnMaps.begin(); it != clustertcpconnMaps.end(); it++)
-			{
-				if (port == it->second->port && !memcmp(it->second->host.c_str(), obj[1]->ptr, sdsllen(obj[1]->ptr)))
-				{
-					LOG_WARN << "cluster  meet  already exists .";
-					addReplyErrorFormat(session->sendBuf, "cluster  meet  already exists ");
-					return false;
-				}
-			}
-		}
-		clus.connSetCluster(obj[1]->ptr, port, this);
-	}
-	else if (!strcasecmp(obj[0]->ptr, "connect") && obj.size() == 3)
-	{
-		long long  port;
-	
-		if (getLongLongFromObject(obj[2], &port) != REDIS_OK)
-		{
-			addReplyError(session->sendBuf, "Invalid or out of range port");
-			return  false;
-		}
-
-		{
-			MutexLockGuard lk(clusterMutex);
-			for (auto it = clustertcpconnMaps.begin(); it != clustertcpconnMaps.end(); it++)
-			{
-				if (port == it->second->port && !memcmp(it->second->host.c_str(), obj[1]->ptr, sdsllen(obj[1]->ptr)))
-				{
-					return false;
-				}
-			}
-		}
-	
-		clus.connSetCluster(obj[1]->ptr, (int32_t)port, this);
-		return false;
-	}
-	else if (!strcasecmp(obj[0]->ptr, "info") && obj.size() == 1)
-	{
-		rObj *o;
-		MutexLockGuard lk(clusterMutex);
-		sds ci = sdsempty(), ni = sdsempty();
-
-		ci = sdscatprintf(sdsempty(), "%s %s:%d ------connetc slot:",
-			(host + "::" + std::to_string(port)).c_str(),
-			host.c_str(),
-			port);
-
-		for (auto it = clus.clusterSlotNodes.begin(); it != clus.clusterSlotNodes.end(); it++)
-		{
-			if (it->second.ip == host && it->second.port == port)
-			{
-				ni = sdscatprintf(sdsempty(), "%d ",
-					it->first);
-				ci = sdscatsds(ci, ni);
-				sdsfree(ni);
-			}
-		}
-		ci = sdscatlen(ci, "\n", 1);
-
-		for (auto it = clustertcpconnMaps.begin(); it != clustertcpconnMaps.end(); it++)
-		{
-			ni = sdscatprintf(sdsempty(), "%s %s:%d ------connetc slot:",
-				(it->second->host +  "::" + std::to_string(it->second->port)).c_str(),
-				it->second->host.c_str(),
-				it->second->port);
-
-			ci = sdscatsds(ci, ni);
-			sdsfree(ni);
-		
-			for (auto iter = clus.clusterSlotNodes.begin(); iter != clus.clusterSlotNodes.end(); iter++)
-			{
-				if (iter->second.ip == it->second->host && iter->second.port == it->second->port)
-				{
-					ni = sdscatprintf(sdsempty(), "%d ",
-						iter->first);
-					ci = sdscatsds(ci, ni);
-					sdsfree(ni);
-				}
-				
-			}
-			ci = sdscatlen(ci, "\n", 1);
-
-		}
-
-		o = createObject(OBJ_STRING, ci);
-		addReplyBulk(session->sendBuf, o);
-		decrRefCount(o);
-		return false;
-	}
-	else if (!strcasecmp(obj[0]->ptr, "slots") && obj.size() == 1)
-	{
-
-	}
-	else if (!strcasecmp(obj[0]->ptr, "keyslot") && obj.size() == 2)
-	{
-		const char * key = obj[1]->ptr;
-		addReplyLongLong(session->sendBuf, clus.keyHashSlot((char*)key, sdsllen(key)));
-		return false;
-	}
-	else if (!strcasecmp(obj[0]->ptr, "setslot") && obj.size() >= 4)
-	{
-		int slot;
-		if ((slot = clus.getSlotOrReply(session, obj[1])) == -1)
-		{
-			addReplyErrorFormat(session->sendBuf, "Invalid slot %d",
-				(char*)obj[1]->ptr);
-			return false;
-		}
-
-		
-		if( !strcasecmp(obj[2]->ptr, "node") )
-		{
-			MutexLockGuard lk(clusterMutex);
-			std::string ipPort = obj[3]->ptr;
-			std::string imipPort = obj[4]->ptr;
-			const char *start = obj[3]->ptr;
-			const char *end = obj[3]->ptr + sdsllen(obj[3]->ptr );
-			const  char *space = std::find(start,end,':');
-			if(space != end)
-			{
-				std::string ip(start,space);
-				std::string port(space + 2,end);
-				long long value;
-				string2ll(port.c_str(), port.length(), &value);
-				auto it = clus.clusterSlotNodes.find(slot);
-				if(it != clus.clusterSlotNodes.end())
-				{
-					it->second.ip = ip;
-					it->second.port = value;
-				}
-
-				
-				clus.importingSlotsFrom.erase(imipPort);
-
-				if(clus.importingSlotsFrom.size() == 0)
-				{
-					clusterRepliImportEnabeld = false;
-				}
-		
-			}
-		
-			LOG_INFO<<"importingSlotsFrom  erase ";
-			//addReply(session->sendBuf, shared.ok);
-			return false;
-		}
-
-
-		std::string nodeName = obj[3]->ptr;
-		if (nodeName == host + "::" + std::to_string(port))
-		{
-			addReplyErrorFormat(session->sendBuf, "setslot self server error ");
-			return false;
-		}
-
-
-		if( !strcasecmp(obj[2]->ptr, "importing") && obj.size() == 4)
-		{
-			bool mark = false;
-			{
-				MutexLockGuard lk(clusterMutex);
-				for (auto it = clus.clusterSlotNodes.begin(); it != clus.clusterSlotNodes.end(); it++)
-				{
-					std::string node = it->second.ip + "::" + std::to_string(it->second.port);
-					if (node == nodeName && slot == it->first)
-					{
-						mark = true;
-						break;
-						
-					}
-				}
-			}
-
-			if (!mark)
-			{
-				addReplyErrorFormat(session->sendBuf, "setslot slot node no found error ");
-				return false;
-			}
-		
-			MutexLockGuard lk(clusterMutex);
-			auto it = clus.importingSlotsFrom.find(nodeName);
-			if (it == clus.importingSlotsFrom.end())
-			{
-				std::unordered_set<int32_t> uset;
-				uset.insert(slot);
-				clus.importingSlotsFrom.insert(std::make_pair(std::move(nodeName), std::move(uset)));
-			}
-			else
-			{
-				auto iter = it->second.find(slot);
-				if (iter == it->second.end())
-				{
-					it->second.insert(slot);
-				}
-				else
-				{
-					addReplyErrorFormat(session->sendBuf, "repeat importing slot :%d", slot);
-					return false;
-				}
-
-			}
-
-			clusterRepliImportEnabeld = true;
-		}
-		else if (!strcasecmp(obj[2]->ptr, "migrating") && obj.size() == 4)
-		{
-			MutexLockGuard lk(clusterMutex);
-			auto it = clus.migratingSlosTos.find(nodeName);
-			if (it == clus.migratingSlosTos.end())
-			{
-				std::unordered_set<int32_t> uset;
-				uset.insert(slot);
-				clus.migratingSlosTos.insert(std::make_pair(std::move(nodeName), std::move(uset)));
-			}
-			else
-			{
-				auto iter = it->second.find(slot);
-				if (iter == it->second.end())
-				{
-					it->second.insert(slot);
-				}
-				else
-				{
-					addReplyErrorFormat(session->sendBuf, "repeat migrating slot :%d", slot);
-					return false;
-				}
-			}
-		}
-		else
-		{
-			addReplyErrorFormat(session->sendBuf, "Invalid  param ");
-			return false;
-		}
-
-		
-	}
-	else if(!strcasecmp(obj[0]->ptr, "delimport"))
-	{
-		MutexLockGuard lk(clusterMutex);
-		clus.importingSlotsFrom.clear();
-		clusterRepliImportEnabeld = false;
-		LOG_INFO << "delimport success:";
-		return false;
-	}
-	else if (!strcasecmp(obj[0]->ptr, "delsync"))
-	{
-		int slot;
-		if ((slot = clus.getSlotOrReply(session, obj[1])) == 0)
-		{
-			LOG_INFO << "getSlotOrReply error ";
-			return false;
-		}
-
-		MutexLockGuard lk(clusterMutex);
-		clus.clusterSlotNodes.erase(slot);
-		LOG_INFO << "delsync success:" << slot;
-		return false;
-
-	}
-	else if (!strcasecmp(obj[0]->ptr, "addsync"))
-	{
-		int slot;
-		long long  p;
-		if ((slot = clus.getSlotOrReply(session, obj[1])) == 0)
-		{
-			LOG_INFO << "getSlotOrReply error ";
-			return false;
-		}
-
-		if (getLongLongFromObject(obj[3], &p) != REDIS_OK)
-		{
-			addReplyError(session->sendBuf, "Invalid or out of range port");
-			return  REDIS_ERR;
-		}
-
-		MutexLockGuard lk(clusterMutex);
-		auto it = clus.clusterSlotNodes.find(slot);
-		if (it == clus.clusterSlotNodes.end())
-		{
-			clusterSlotEnabled = true;
-			LOG_INFO << "addsync success:" << slot;
-			xClusterNode node;
-			node.ip = obj[2]->ptr;
-			node.port = (int32_t)p;
-			clus.clusterSlotNodes.insert(std::make_pair(slot, std::move(node)));
-
-		}
-		else
-		{
-			LOG_INFO << "clusterSlotNodes insert error ";
-		}
-
-		return false;
-		
-	}
-	else if (!strcasecmp(obj[0]->ptr, "delslots") &&  obj.size() == 2)
-	{		
-		MutexLockGuard lk(clusterMutex);
-		if (clustertcpconnMaps.size() == 0)
-		{
-			addReplyErrorFormat(session->sendBuf, "execute cluster meet ip:port");
-			return false;
-		}
-
-		int slot;
-		int j;
-		for (j = 1; j < obj.size(); j++)
-		{
-			if ((slot = clus.getSlotOrReply(session, obj[j])) == 0)
-			{
-				return false;
-			}
-
-			if(slot < 0 || slot > 16384 )
-			{
-				addReplyErrorFormat(session->sendBuf, "cluster delslots range error %d:",slot);
-				return false;
-			}
-
-			auto it = clus.clusterSlotNodes.find(slot);
-			if (it != clus.clusterSlotNodes.end())
-			{
-				std::deque<rObj*> robj;
-				rObj * c = createStringObject("cluster", 7);
-				rObj * d = createStringObject("delsync", 7);
-				robj.push_back(c);
-				robj.push_back(d);
-				rObj * o = createStringObject(obj[j]->ptr, sdsllen(obj[j]->ptr));
-				robj.push_back(o);
-				clus.syncClusterSlot(robj);
-				clus.clusterSlotNodes.erase(slot);
-				LOG_INFO << "deslots success " << slot;
-			}
-		}
-
-		if (clus.clusterSlotNodes.size() == 0)
-		{
-			clusterSlotEnabled = false;
-		}
-
-	}
-	else if (!strcasecmp(obj[0]->ptr, "addslots") && obj.size() == 2)
-	{
-		int32_t  j, slot;
-		for (j = 1; j < obj.size(); j++)
-		{
-			if(slot < 0 || slot > 16384 )
-			{
-				addReplyErrorFormat(session->sendBuf, "cluster delslots range error %d:",slot);
-				return false;
-			}
-
-			if ((slot = clus.getSlotOrReply(session, obj[j])) == 0)
-			{
-				return false;
-			}
-
-			MutexLockGuard lk(clusterMutex);
-			if (clustertcpconnMaps.size() == 0)
-			{
-				addReplyErrorFormat(session->sendBuf, "execute cluster meet ip:port");
-				return false;
-			}
-
-			auto it = clus.clusterSlotNodes.find(slot);
-			if (it == clus.clusterSlotNodes.end())
-			{
-				xClusterNode  node;
-				node.ip = host;
-				node.port = this->port;
-				rObj * i = createStringObject(host.c_str(), host.length());
-				char buf[32];
-				int32_t len = ll2string(buf, sizeof(buf), this->port);
-				rObj * p = createStringObject((const char*)buf, len);
-
-				std::deque<rObj*> robj;
-				rObj * c = createStringObject("cluster", 7);
-				rObj * a = createStringObject("addsync", 7);
-			
-				robj.push_back(c);
-				robj.push_back(a);
-				rObj * o = createStringObject(obj[j]->ptr, sdsllen(obj[j]->ptr));
-				robj.push_back(o);
-				robj.push_back(i);
-				robj.push_back(p);
-
-				clus.syncClusterSlot(robj);
-				clus.clusterSlotNodes.insert(std::make_pair(slot, std::move(node)));
-				LOG_INFO << "addslots success " << slot;
-			}
-			else
-			{
-				addReplyErrorFormat(session->sendBuf, "Slot %d specified multiple times", slot);
-				return false;
-			}
-		}
-		clusterSlotEnabled = true;
-
-	}
-	else
-	{
-		addReplyErrorFormat(session->sendBuf, "unknown param error");
-		return false;
-	}
-	
-	addReply(session->sendBuf, shared.ok);
-	return false;
-	
-}
-
-void xRedis::structureRedisProtocol(xBuffer &  sendBuf, std::deque<rObj*> &robjs)
-{
-	int len, j;
-	char buf[32];
-	buf[0] = '*';
-	len = 1 + ll2string(buf + 1, sizeof(buf) - 1, robjs.size());
-	buf[len++] = '\r';
-	buf[len++] = '\n';
-	sendBuf.append(buf, len);
-
-	for (int i = 0; i < robjs.size(); i++)
-	{
-		buf[0] = '$';
-		len = 1 + ll2string(buf + 1, sizeof(buf) - 1, sdsllen(robjs[i]->ptr));
-		buf[len++] = '\r';
-		buf[len++] = '\n';
-		sendBuf.append(buf, len);
-		sendBuf.append(robjs[i]->ptr, sdsllen(robjs[i]->ptr));
-		sendBuf.append("\r\n", 2);
-	}
-}
-
-
-bool  xRedis::save(xSession * session)
-{
-	int64_t start =  mstime();
-	{
-		MutexLockGuard lk(mutex);
-		char filename[] = "dump.rdb";
-		if(rdbSave(filename,this) == REDIS_OK)
-		{
-			LOG_INFO<<"Save rdb success";
-		}
-		else
-		{
-			LOG_INFO<<"Save rdb failure";
-
-			return false;
-		}
-	}
-
-	return true;
-}
-
-
-bool xRedis::bgsaveCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	
-	if(obj.size() > 0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown bgsave error");
-		return false;
-	}
-	
-	if(save(session))
-	{
-		addReply(session->sendBuf,shared.ok);
-			
-	}
-	else
-	{
-		addReply(session->sendBuf,shared.err);
-	}
-
-	return true;
-	
-}
-
-bool xRedis::saveCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() > 0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown save error");
-		return false;
-	}
-
-	if(save(session))
-	{
-		addReply(session->sendBuf,shared.ok);
-	}
-	else
-	{
-		addReply(session->sendBuf,shared.err);
-	}
-
-	return true;
-}
-
-
-bool xRedis::slaveofCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() !=  2)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown slaveof error");
-		return false;
-	}
-
-	
-	if (!strcasecmp(obj[0]->ptr,"no") &&!strcasecmp(obj[1]->ptr,"one")) 
-	{
-		if (masterHost.c_str() && masterPort) 
-		{
-			LOG_WARN<<"MASTER MODE enabled (user request from "<<masterHost.c_str()<<":"<<masterPort;
-			repli.client->disconnect();
-			repli.isreconnect = false;
-		}
-
-	}
-	else
-	{
-		long   port;
-		if ((getLongFromObjectOrReply(session->sendBuf, obj[1], &port, nullptr) != REDIS_OK))
-			return false;
-
-		if (host.c_str() && !memcmp(host.c_str(), obj[0]->ptr,sdsllen(obj[0]->ptr))
-		&& this->port == port)
-		{
-			LOG_WARN<<"SLAVE OF connect self error .";
-			addReplySds(session->sendBuf,sdsnew("Don't connect master self \r\n"));
-			return false;
-		}
-
-		if (masterPort > 0)
-		{
-			LOG_WARN<<"SLAVE OF would result into synchronization with the master we are already connected with. No operation performed.";
-			addReplySds(session->sendBuf,sdsnew("+OK Already connected to specified master\r\n"));
-			return false;
-		}	
-
-		repli.replicationSetMaster(this,obj[0],port);
-		LOG_INFO<<"SLAVE OF "<<obj[0]->ptr<<":"<<port<<" enabled (user request from client";
-	}
-	
-
-
-	addReply(session->sendBuf,shared.ok);
-	return false;
-}
-
-
-
-bool xRedis::commandCommond(const std::deque <rObj*> & obj,xSession * session)
-{	
-	addReply(session->sendBuf,shared.ok);
-	return false;
-}
-
-
-bool xRedis::syncCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() >  0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown sync  error");
-		return false;
-	}
-
-	xTimer * timer = nullptr;
-	{
-		MutexLockGuard lk(slaveMutex);
-		auto it = repliTimers.find(session->conn->getSockfd());
-		if(it != repliTimers.end())
-		{
-			LOG_WARN<<"Client repeat send sync ";
-			session->conn->forceClose();
-			return false;
-		}
-
-		int32_t sockfd = session->conn->getSockfd();
-		timer = session->conn->getLoop()->runAfter(REPLI_TIME_OUT,(void *)&sockfd,
-				false,std::bind(&xRedis::handleSalveRepliTimeOut,this,std::placeholders::_1));
-		repliTimers.insert(std::make_pair(session->conn->getSockfd(),timer));
-		salvetcpconnMaps.insert(std::make_pair(session->conn->getSockfd(),session->conn));
-		repliEnabled = true;
-	}
-
-	if(!save(session))
-	{
-		repli.isreconnect =false;
-		session->conn->forceClose();
-		return false;
-	}
-
-
-	bool mark  = true;
-	char rdbFileName[] = "dump.rdb";
-	{
-		{
-			MutexLockGuard lk(mutex);
-			mark = rdbReplication(rdbFileName,session);
-		}
-
-		if(!mark)
-		{
-			MutexLockGuard lk(slaveMutex);
-			if(timer)
-			{
-				session->conn->getLoop()->cancelAfter(timer);
-			}
-			session->conn->forceClose();
-			LOG_INFO<<"master sync send failure";
-			return false;
-		}
-	}
-
-	LOG_INFO<<"master sync send success ";
-	return true;
-}
-
-
-bool xRedis::psyncCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() >  0)
-	{
-		LOG_WARN<<"unknown psync  error";
-		addReplyErrorFormat(session->sendBuf,"unknown psync  error");
-		return false;
-	}
-
-	return true;
-}
-
-
-size_t xRedis::getDbsize()
-{
-	size_t size = 0;
-	{
-
-		for(auto it = setMapShards.begin(); it != setMapShards.end(); it++)
-		{
-			MutexLock &mu = (*it).mutex;
-			MutexLockGuard lk(mu);
-			size+=(*it).setMap.size();
-		}
-	}
-
-	{
-		for(auto it = hsetMapShards.begin(); it != hsetMapShards.end(); it++)
-		{
-			MutexLock &mu = (*it).mutex;
-			MutexLockGuard lk(mu);
-			size+=(*it).hsetMap.size();
-		}
-	}
-
-
-	{
-		for(auto it = setShards.begin(); it != setShards.end(); it++)
-		{
-			MutexLock &mu = (*it).mutex;
-			MutexLockGuard lk(mu);
-			size+=(*it).set.size();
-		}
-	}
-
-
-
-	{
-		for(auto it = sortSetShards.begin(); it != sortSetShards.end(); it++)
-		{
-			MutexLock &mu = (*it).mutex;
-			MutexLockGuard lk(mu);
-			size+=(*it).set.size();
-		}
-	}
-
-
-	{
-		for(auto it = pubSubShards.begin(); it != pubSubShards.end(); it++)
-		{
-			MutexLock &mu = (*it).mutex;
-			MutexLockGuard lk(mu);
-			size+=(*it).pubSub.size();
-		}
-	}
-
-	return size;
-}
-
-bool xRedis::dbsizeCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() > 0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown dbsize error");
-		return false;
-	}
-
-	addReplyLongLong(session->sendBuf,getDbsize());
-
-	return true;
-}
-
-
-
-int  xRedis::removeCommond(rObj * obj,int &count)
-{
-	
-	{
-		MutexLock &mu = setMapShards[obj->hash% kShards].mutex;
-		auto &setMap = setMapShards[obj->hash% kShards].setMap;
-		{
-			MutexLockGuard lock(mu);
-			auto it = setMap.find(obj);
-			if(it != setMap.end())
-			{
-				auto iter = expireTimers.find(obj);
-				if(iter != expireTimers.end())
-				{
-					expireTimers.erase(iter);
-					loop.cancelAfter(iter->second);
-				}
-
-				count ++;
-				setMap.erase(it);
-				zfree(it->first);
-				zfree(it->second);
-			}
-
-		}
-	}
-
-	{
-		MutexLock &mu = hsetMapShards[obj->hash% kShards].mutex;
-		auto &hsetMap = hsetMapShards[obj->hash% kShards].hsetMap;
-		{
-			MutexLockGuard lock(mu);
-			auto hmap = hsetMap.find(obj);
-			if(hmap != hsetMap.end())
-			{
-				count ++;
-				for(auto iter = hmap->second.begin(); iter != hmap->second.end(); iter++)
-				{
-					zfree(iter->first);
-					zfree(iter->second);
-				}
-
-				hsetMap.erase(hmap);
-				zfree(hmap->first);
-			}
-
-
-		}
-	}
-
-	{
-		MutexLock &mu = setShards[obj->hash% kShards].mutex;
-		auto &set = setShards[obj->hash% kShards].set;
-		{
-			MutexLockGuard lock(mu);
-			auto it = set.find(obj);
-			if(it != set.end())
-			{
-				count ++;
-				for(auto iter = it->second.begin(); iter != it->second.end(); iter++)
-				{
-					zfree(*iter);
-				}
-
-				set.erase(it);
-				zfree(it->first);
-			}
-		}
-	}
-
-
-
-	{
-		MutexLock &mu = sortSetShards[obj->hash% kShards].mutex;
-		auto &set = sortSetShards[obj->hash% kShards].set;
-		auto &sset = sortSetShards[obj->hash% kShards].sset;
-		{
-			MutexLockGuard lock(mu);
-			auto it = set.find(obj);
-			if(it != set.end())
-			{
-				auto itt = sset.find(obj);
-				if(itt == sset.end())
-				{
-					assert(false);
-				}
-				
-				count  ++;
-				for(auto iter = it->second.begin(); iter != it->second.end(); iter++)
-				{
-					zfree(iter->first);
-					zfree(iter->second);
-				}
-
-				set.erase(it);
-				zfree(it->first);
-				sset.erase(itt);
-
-			}
-		}
-	}
-
-
-	{
-		MutexLock &mu = pubSubShards[obj->hash% kShards].mutex;
-		auto &pubSub = pubSubShards[obj->hash% kShards].pubSub;
-		{
-			MutexLockGuard lock(mu);
-			auto it = pubSub.find(obj);
-			if(it != pubSub.end())
-			{
-				count  ++;
-				pubSub.erase(it);
-				zfree(it->first);
-			}
-		}
-	}
-
-	return  count;
-}
-
-
-bool xRedis::delCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  del error");
-	}
-
-	int count = 0;
-	for(int i = 0 ; i < obj.size(); i ++)
-	{
-		obj[i]->calHash();		
-		removeCommond(obj[i],count);
-		zfree(obj[i]);
-	}
-
-	addReplyLongLong(session->sendBuf,count);
-	
-	return true;
-}
-
-
-bool setnxCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	return true;
-}
-
-
-bool xRedis::scardCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1 )
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  scard error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash= obj[0]->hash;
-	int count = 0;
-	MutexLock &mu = setShards[hash% kShards].mutex;
-	auto &set = setShards[hash% kShards].set;
-	{
-		MutexLockGuard lock(mu);
-		auto it = set.find(obj[0]);
-		if(it != set.end())
-		{
-			count = it->second.size();
-		}
-	}
-
-	 addReplyLongLong(session->sendBuf,count);
-
-	for(auto it = obj.begin(); it != obj.end(); it ++)
-	{
-		zfree(*it);
-	}
-	return true;
-}
-
-bool xRedis::saddCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() < 2)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  sadd error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash= obj[0]->hash;
-
-	int count = 0;
-	MutexLock &mu = setShards[hash% kShards].mutex;
-	auto &set = setShards[hash% kShards].set;
-	{
-		MutexLockGuard lock(mu);
-		auto it = set.find(obj[0]);
-		if(it == set.end())
-		{
-			std::unordered_set<rObj*,Hash,Equal> uset;
-			for(int i = 1; i < obj.size(); i ++)
-			{
-				obj[i]->calHash();
-				auto iter = uset.find(obj[i]);
-				if(iter == uset.end())
-				{
-					count++;
-					uset.insert(obj[i]);
-				}
-				else
-				{
-					zfree(obj[i]);
-				}
-				set.insert(std::make_pair(obj[0],std::move(uset)));
-			}
-		}
-		else
-		{
-			zfree(obj[0]);
-			for(int i = 1; i < obj.size(); i ++)
-			{
-				obj[i]->calHash();
-				auto iter = it->second.find(obj[i]);
-				if(iter == it->second.end())
-				{
-					count++;
-					it->second.insert(obj[i]);
-				}
-				else
-				{
-					zfree(obj[i]);
-				}
-			}
-		}
-	}
-
-	addReplyLongLong(session->sendBuf,count);
-
-	return true;
-}
-
-bool xRedis::selectCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  select error");
-		return false;
-	}
-
-	for(auto it = obj.begin(); it != obj.end(); it ++)
-	{
-		zfree(*it);
-	}
-
-
-	addReply(session->sendBuf,shared.ok);
-	return true;
-}
-
-bool xRedis::hkeysCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  hkeys error");
-		return false;
-	}
-
-	obj[0]->calHash();
-    size_t hash= obj[0]->hash;
-
-
-    MutexLock &mu = hsetMapShards[hash% kShards].mutex;
-	auto &hsetMap = hsetMapShards[hash% kShards].hsetMap;
-	{
-		MutexLockGuard lock(mu);
-
-		auto it = hsetMap.find(obj[0]);
-		if(it == hsetMap.end())
-		{
-			addReply(session->sendBuf,shared.emptymultibulk);
-			return false;
-		}
-
-		addReplyMultiBulkLen(session->sendBuf,it->second.size());
-
-		for(auto iter = it->second.begin(); iter != it->second.end(); iter++)
-		{
-			addReplyBulkCBuffer(session->sendBuf,iter->first->ptr,sdsllen(iter->first->ptr));
-		}
-	}
-
-	return false;
-
-}
-
-
-bool xRedis::ppingCommond(const std::deque <rObj*> & obj, xSession * session)
-{
-	std::deque<rObj*>  robjs;
-	robjs.push_back(shared.ppong);
-	structureRedisProtocol(session->sendBuf,robjs);
-	return true;
-}
-
-bool xRedis::ppongCommond(const std::deque <rObj*> & obj, xSession * session)
-{
-	pingPong = true;
-	return true;
-}
-
-
-bool xRedis::pongCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	return false;
-}
-
-bool xRedis::pingCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() > 0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown ping error");
-		return false;
-	}
-	
-	addReply(session->sendBuf,shared.pong);
-	return true;
-}
-
-
-bool xRedis::hgetallCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  hgetall error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash= obj[0]->hash;
-	
-	MutexLock &mu = hsetMapShards[hash% kShards].mutex;
-	auto &hsetMap = hsetMapShards[hash% kShards].hsetMap;
-	{
-		MutexLockGuard lock(mu);
-		
-		auto it = hsetMap.find(obj[0]);
-		if(it == hsetMap.end())
-		{
-			addReply(session->sendBuf,shared.emptymultibulk);
-			return false;
-		}
-
-		addReplyMultiBulkLen(session->sendBuf,it->second.size() * 2);
-
-		for(auto iter = it->second.begin(); iter != it->second.end(); iter++)
-		{
-			addReplyBulkCBuffer(session->sendBuf,iter->first->ptr,sdsllen(iter->first->ptr));
-			addReplyBulkCBuffer(session->sendBuf,iter->second->ptr,sdsllen(iter->second->ptr));
-		}
-	}
-
-	zfree(obj[0]);
-
-	return true;
-}
-
-bool xRedis::hlenCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  hlen error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	size_t hash= obj[0]->hash;
-	bool update = false;
-
-	int count = 0;
-	MutexLock &mu = hsetMapShards[hash% kShards].mutex;
-	auto &hsetMap = hsetMapShards[hash% kShards].hsetMap;
-	{
-		MutexLockGuard lock(mu);
-		auto it = hsetMap.find(obj[0]);
-		if(it != hsetMap.end())
-		{
-			count = it->second.size();
-		}
-	}
-
-	zfree(obj[0]);
-
-	addReplyLongLong(session->sendBuf,count);
-	return  true;
-}
-
-bool xRedis::hsetCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 3)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  hset error");
-		return false;
-	}
-
-	obj[0]->calHash();
-	obj[1]->calHash();
-	size_t hash= obj[0]->hash;
-	bool update = false;
-	
-	MutexLock &mu = hsetMapShards[hash% kShards].mutex;
-	auto &hsetMap = hsetMapShards[hash% kShards].hsetMap;
-	{
-		MutexLockGuard lock(mu);
-		auto it = hsetMap.find(obj[0]);
-		if(it == hsetMap.end())
-		{
-			std::unordered_map<rObj*,rObj*,Hash,Equal> hset;
-			hset.insert(std::make_pair(obj[1],obj[2]));
-			hsetMap.insert(std::make_pair(obj[0],std::move(hset)));
-		}
-		else
-		{
-			zfree(obj[0]);
-			auto iter = it->second.find(obj[1]);
-			if(iter ==  it->second.end())
-			{
-				it->second.insert(std::make_pair(obj[1],obj[2]));
-			}
-			else
-			{
-				zfree(obj[1]);
-				zfree(iter->second);
-				iter->second = obj[2];
-				update = true;
-			}
-		}
-	}
-	
-	addReply(session->sendBuf,update ? shared.czero : shared.cone);
-
-	return true;
-}
-
-bool xRedis::hgetCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 2)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  hget  param error");
-		return false;
-	}
-	
-	obj[0]->calHash();
-	obj[1]->calHash();
-	size_t hash= obj[0]->hash;
-	MutexLock &mu = hsetMapShards[hash% kShards].mutex;
-	auto &hsetMap = hsetMapShards[hash% kShards].hsetMap;
-	{
-		MutexLockGuard lock(mu);
-		auto it = hsetMap.find(obj[0]);
-		if(it == hsetMap.end())
-		{
-			addReply(session->sendBuf,shared.nullbulk);
-			return false;
-		}
-
-		auto iter = it->second.find(obj[1]);
-		if(iter == it->second.end())
-		{
-			addReply(session->sendBuf,shared.nullbulk);
-			return false;
-		}
-		addReplyBulk(session->sendBuf,iter->second);
-	}
-
-	zfree(obj[0]);
-	zfree(obj[1]);
-	return true;
-}
-
-
-
-void xRedis::clearCommond()
-{
-	{
-		for(auto it = setMapShards.begin(); it != setMapShards.end(); it++)
-		{
-			auto &map = (*it).setMap;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter !=map.end(); iter++)
-			{
-				auto iterr = expireTimers.find(iter->first);
-				if(iterr != expireTimers.end())
-				{
-					expireTimers.erase(iterr);
-					loop.cancelAfter(iterr->second);
-				}
-			
-				zfree(iter->first);
-				zfree(iter->second);
-			}
-			map.clear();
-		}
-
-	}
-
-	{
-		for(auto it = hsetMapShards.begin(); it != hsetMapShards.end(); it++)
-		{
-			auto &map = (*it).hsetMap;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter!=map.end(); iter++)
-			{
-				auto  &mmap = iter->second;
-				for(auto iterr = mmap.begin(); iterr!=mmap.end(); iterr++)
-				{
-					zfree(iterr->first);
-					zfree(iterr->second);
-				}
-				zfree(iter->first);
-			}
-			map.clear();
-
-		}
-
-	}
-
-	{
-		for(auto it = setShards.begin(); it != setShards.end(); it++)
-		{
-			auto &map = (*it).set;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter != map.end(); iter ++)
-			{
-				for(auto iterr = iter->second.begin(); iterr != iter->second.end() ;iterr ++)
-				{
-					zfree(*iterr);
-				}
-				zfree(iter->first);
-			}
-			map.clear();
-
-		}
-	}
-	
-
-
-	{
-		for(auto it = sortSetShards.begin(); it != sortSetShards.end(); it++)
-		{
-			auto &map = (*it).set;
-			auto &mmap = (*it).sset;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter != map.end(); iter ++)
-			{
-				for(auto iterr = iter->second.begin(); iterr != iter->second.end() ;iterr ++)
-				{
-						zfree(iterr->first);
-						zfree(iterr->second);
-				}
-
-				zfree(iter->first);
-			}
-
-			mmap.clear();
-			map.clear();
-
-		}
-	}
-
-
-	{
-		for(auto it = pubSubShards.begin(); it != pubSubShards.end(); it++)
-		{
-			auto &map = (*it).pubSub;
-			MutexLock &mu =  (*it).mutex;
-			MutexLockGuard lock(mu);
-			for(auto iter = map.begin(); iter != map.end(); iter ++)
-			{
-				zfree(iter->first);
-			}
-			map.clear();
-
-		}
-	}
-
-}
-
-
-bool xRedis::flushdbCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() > 0)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  flushdb  param error");
-		return false;
-	}
-
-	clearCommond();
-
-	addReply(session->sendBuf,shared.ok);	
-	return true;
-}
-
-bool xRedis::quitCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	session->conn->forceClose();
-	return true;
-}
-
-
-bool xRedis::setCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() <  2 || obj.size() > 8 )
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  set param error");
-		return false;
-	}
-
-    int j;
-    rObj *expire = NULL;
-    int unit = UNIT_SECONDS;	
-    int flags = OBJ_SET_NO_FLAGS;
-
-	for (j = 2; j < obj.size();j++)
-	{
-		const char *a = obj[j]->ptr;
-		rObj *next = (j == obj.size() - 2) ? NULL : obj[j + 1];
-
-		if ((a[0] == 'n' || a[0] == 'N') &&
-		(a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
-		!(flags & OBJ_SET_XX))
-		{
-			flags |= OBJ_SET_NX;
-		}
-		else if ((a[0] == 'x' || a[0] == 'X') &&
-		       (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
-		       !(flags & OBJ_SET_NX))
-		{
-			flags |= OBJ_SET_XX;
-		}
-		else if ((a[0] == 'e' || a[0] == 'E') &&
-		       (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
-		       !(flags & OBJ_SET_PX) && next)
-		{
-			flags |= OBJ_SET_EX;
-			unit = UNIT_SECONDS;
-			expire = next;
-			j++;
-		}
-		else if ((a[0] == 'p' || a[0] == 'P') &&
-		       (a[1] == 'x' || a[1] == 'X') && a[2] == '\0' &&
-		       !(flags & OBJ_SET_EX) && next)
-		{
-			flags |= OBJ_SET_PX;
-			unit = UNIT_MILLISECONDS;
-			expire = next;
-			j++;
-		}
-		else
-		{
-			addReply(session->sendBuf,shared.syntaxerr);
-			return false;
-		}
-	}
-	
-
-	long long milliseconds = 0; /* initialized to avoid any harmness warning */
-
-	if (expire)
-	{
-		if (getLongLongFromObjectOrReply(session->sendBuf, expire, &milliseconds, NULL) != REDIS_OK)
-		   return false;
-		if (milliseconds <= 0)
-		{
-		    addReplyErrorFormat(session->sendBuf,"invalid expire time in");
-		    return false;
-		}
-		if (unit == UNIT_SECONDS) milliseconds *= 1000;
-	}
-    
-	obj[0]->calHash();
-	size_t hash= obj[0]->hash;
-	int index = hash  % kShards;
-	MutexLock &mu = setMapShards[index].mutex;
-	auto & setMap = setMapShards[index].setMap;
-
-	{
-		MutexLockGuard lock(mu);
-
-		auto it = setMap.find(obj[0]);
-		if(it == setMap.end())
-		{
-			if(flags & OBJ_SET_XX)
-			{
-				addReply(session->sendBuf,shared.nullbulk);
-				return false;
-			}
-			setMap.insert(std::make_pair(obj[0],obj[1]));
-		}
-		else
-		{
-			if(flags & OBJ_SET_NX)
-			{
-				addReply(session->sendBuf,shared.nullbulk);
-				return false;
-			}
-
-			zfree(obj[0]);
-			zfree(it->second);
-			it->second = obj[1];
-		}
-	}
-
-	if (expire)
-	{
-		MutexLockGuard lock(expireMutex);
-		auto iter = expireTimers.find(obj[0]);
-		if(iter != expireTimers.end())
-		{
-			expireTimers.erase(iter);
-			loop.cancelAfter(iter->second);
-		}
-
-		xTimer * timer = loop.runAfter(milliseconds / 1000,(void *)(obj[0]),false,std::bind(&xRedis::handleSetExpire,this,std::placeholders::_1));
-		expireTimers.insert(std::make_pair(obj[0],timer));
-
-		for(int i = 2; i < obj.size(); i++)
-		{
-			zfree(obj[i]);
-		}
-	}
-
-	addReply(session->sendBuf,shared.ok);
-	return true;
-}
-
-bool xRedis::getCommond(const std::deque <rObj*> & obj,xSession * session)
-{
-	if(obj.size() != 1)
-	{
-		addReplyErrorFormat(session->sendBuf,"unknown  get param error");
-		return false;
-	}
-	
-	obj[0]->calHash();
-	size_t hash = obj[0]->hash;
-	int index = hash  % kShards;
-	MutexLock &mu = setMapShards[index].mutex;
-	SetMap & setMap = setMapShards[index].setMap;
-	{
-		MutexLockGuard lock(mu);
-		
-		auto it = setMap.find(obj[0]);
-		if(it == setMap.end())
-		{
-			addReply(session->sendBuf,shared.nullbulk);
-			return false;
-		}
-		
-		addReplyBulk(session->sendBuf,it->second);
-	}
-
-	zfree(obj[0]);
-	
-	return true;
-}
-
-
-void xRedis::flush()
-{
-
-}
-
-
-
-void xRedis::initConifg()
-{
-	rObj * obj = createStringObject("set",3);
-	handlerCommondMap[obj] =std::bind(&xRedis::setCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("get",3);
-	handlerCommondMap[obj] =std::bind(&xRedis::getCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("flushdb",7);
-	handlerCommondMap[obj] =std::bind(&xRedis::flushdbCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("dbsize",6);
-	handlerCommondMap[obj] =std::bind(&xRedis::dbsizeCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("hset",4);
-	handlerCommondMap[obj] =std::bind(&xRedis::hsetCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("hget",4);
-	handlerCommondMap[obj] =std::bind(&xRedis::hgetCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("hgetall",7);
-	handlerCommondMap[obj] =std::bind(&xRedis::hgetallCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("ping",4);
-	handlerCommondMap[obj] =std::bind(&xRedis::pingCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("save",4);
-	handlerCommondMap[obj] =std::bind(&xRedis::saveCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("slaveof",7);
-	handlerCommondMap[obj] =std::bind(&xRedis::slaveofCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("sync",4);
-	handlerCommondMap[obj] =std::bind(&xRedis::syncCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("command",7);
-	handlerCommondMap[obj] =std::bind(&xRedis::commandCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("config",6);
-	handlerCommondMap[obj] = std::bind(&xRedis::configCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("auth",4);
-	handlerCommondMap[obj] = std::bind(&xRedis::authCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("info",4);
-	handlerCommondMap[obj] = std::bind(&xRedis::infoCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("echo",4);
-	handlerCommondMap[obj] = std::bind(&xRedis::echoCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("client",5);
-	handlerCommondMap[obj] = std::bind(&xRedis::clientCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("subscribe",9);
-	handlerCommondMap[obj] = std::bind(&xRedis::subscribeCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("hkeys",5);
-	handlerCommondMap[obj] = std::bind(&xRedis::hkeysCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("select",6);
-	handlerCommondMap[obj] = std::bind(&xRedis::selectCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("sadd",4);
-	handlerCommondMap[obj] = std::bind(&xRedis::saddCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("scard",6);
-	handlerCommondMap[obj] = std::bind(&xRedis::scardCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("publish",7);
-	handlerCommondMap[obj] = std::bind(&xRedis::publishCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("del",3);
-	handlerCommondMap[obj] = std::bind(&xRedis::delCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("unsubscribe",11);
-	handlerCommondMap[obj] = std::bind(&xRedis::unsubscribeCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("hlen",4);
-	handlerCommondMap[obj] = std::bind(&xRedis::hlenCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("zadd",4);
-	handlerCommondMap[obj] = std::bind(&xRedis::zaddCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("zcard",5);
-	handlerCommondMap[obj] = std::bind(&xRedis::zcardCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("zrange",6);
-	handlerCommondMap[obj] = std::bind(&xRedis::zrangeCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("zrank",5);
-	handlerCommondMap[obj] = std::bind(&xRedis::zrankCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("zrevrange",9);
-	handlerCommondMap[obj] = std::bind(&xRedis::zrevrangeCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("keys",4);
-	handlerCommondMap[obj] = std::bind(&xRedis::keysCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("bgsave",6);
-	handlerCommondMap[obj] = std::bind(&xRedis::bgsaveCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("memory",6);
-	handlerCommondMap[obj] = std::bind(&xRedis::memoryCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("ppong",6);
-	handlerCommondMap[obj] = std::bind(&xRedis::ppongCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("pping", 6);
-	handlerCommondMap[obj] = std::bind(&xRedis::ppingCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("sentinel", 8);
-	handlerCommondMap[obj] = std::bind(&xRedis::ppingCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("cluster", 7);
-	handlerCommondMap[obj] = std::bind(&xRedis::clusterCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("migrate", 7);
-	handlerCommondMap[obj] = std::bind(&xRedis::migrateCommond, this, std::placeholders::_1, std::placeholders::_2);
-	obj = createStringObject("set",3);
-	unorderedmapCommonds.insert(obj);
-	obj = createStringObject("hset",4);
-	unorderedmapCommonds.insert(obj);
-	obj = createStringObject("zadd",4);
-	unorderedmapCommonds.insert(obj);
-	obj = createStringObject("sadd",4);
-	unorderedmapCommonds.insert(obj);
-	obj = createStringObject("del",3);
-	unorderedmapCommonds.insert(obj);
-	obj = createStringObject("flushdb",7);
-	unorderedmapCommonds.insert(obj);
-
-	sentiThreads =  std::shared_ptr<std::thread>(new std::thread(std::bind(&xSentinel::connectSentinel,&senti)));
-	sentiThreads->detach();
-	repliThreads = std::shared_ptr<std::thread>(new std::thread(std::bind(&xReplication::connectMaster,&repli)));
-	repliThreads->detach();
-	clusterThreads = std::shared_ptr<std::thread>(new std::thread(std::bind(&xCluster::connectCluster, &clus)));
-	clusterThreads->detach();
-
-	
-}
-
-
diff --git a/src/xRedis.h b/src/xRedis.h
deleted file mode 100755
index 13b7070e..00000000
--- a/src/xRedis.h
+++ /dev/null
@@ -1,190 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xEventLoop.h"
-#include "xTcpconnection.h"
-#include "xBuffer.h"
-#include "xTcpServer.h"
-#include "xSds.h"
-#include "xSession.h"
-#include "xObject.h"
-#include "xRdb.h"
-#include "xPosix.h"
-#include "xLog.h"
-#include "xSocket.h"
-#include "xReplication.h"
-#include "xSentinel.h"
-#include "xCluster.h"
-
-class xRedis : noncopyable
-{
-public:
-	
-	xRedis(const char * ip, int16_t port,int16_t threadCount,bool enbaledCluster = false,bool enabledSentinel = false);
-	~xRedis();
-	void initConifg();
-	void test(void * data);
-	void handleTimeOut(void * data);
-	void handleSalveRepliTimeOut(void * data);
-	void handleSetExpire(void * data);
-	
-	void run();
-	void connCallBack(const xTcpconnectionPtr& conn,void *data);
-	bool deCodePacket(const xTcpconnectionPtr& conn,xBuffer *recvBuf,void  *data);
-	void replyCheck();
-	void loadDataFromDisk();
-	void flush();
-
-	bool saveCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool pingCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool pongCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool ppingCommond(const std::deque <rObj*> & obj, xSession * session);
-	bool ppongCommond(const std::deque <rObj*> & obj, xSession * session);
-
-	bool flushdbCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool dbsizeCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool quitCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool delCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool setCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool getCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool hsetCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool hgetCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool hgetallCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool hlenCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool slaveofCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool syncCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool psyncCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool commandCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool clusterCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool authCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool configCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool infoCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool clientCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool echoCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool subscribeCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool publishCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool selectCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool hkeysCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool scardCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool saddCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool unsubscribeCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool zaddCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool zcardCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool zcountCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool zrangeCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool zrankCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool zrevrangeCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool keysCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool bgsaveCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool memoryCommond(const std::deque <rObj*> & obj,xSession * session);
-	bool sentinelCommond(const std::deque<rObj*> & obj, xSession * session);
-	bool migrateCommond(const std::deque<rObj*> & obj, xSession * session);
-
-	bool clearClusterMigradeCommond(void * data);
-	bool save(xSession * session);
-	int removeCommond(rObj * obj,int &count);
-	void clearCommond();
-	void clearRepliState(int32_t sockfd);
-	size_t getDbsize();
-	void structureRedisProtocol(xBuffer &  sendBuf, std::deque<rObj*> &robjs);
-public:
-	
-	std::unordered_set<rObj*,Hash,EEqual>  unorderedmapCommonds;
-	typedef std::function<bool (const std::deque<rObj*> &,xSession *)> commondFunction;
-	std::unordered_map<rObj*,commondFunction,Hash,EEqual> handlerCommondMap;
-	std::unordered_map<int32_t , std::shared_ptr<xSession>> sessions;
-
-
-	typedef std::unordered_map<rObj*,rObj*,Hash,Equal> SetMap;
-	typedef std::unordered_map<rObj*,std::unordered_map<rObj*,rObj*,Hash,Equal> ,Hash,Equal> HsetMap;
-	typedef std::unordered_map<rObj*,std::unordered_set<rObj*,Hash,Equal>,Hash,Equal> Set;
-	typedef std::unordered_map<rObj*,std::unordered_map<rObj *,rObj *,Hash,Equal>,Hash,Equal> SortSet;
-	typedef std::unordered_map<rObj*,std::set<rSObj>,Hash,Equal> SSet;
-	typedef std::unordered_map<rObj*,std::list<xTcpconnectionPtr>,Hash,Equal> PubSub;
-
-	struct SetMapLock
-	{		
-		SetMap setMap;
-		mutable MutexLock mutex;
-	};
-
-	struct HsetMapLock
-	{
-		HsetMap hsetMap;
-		mutable MutexLock mutex;
-	};
-
-	struct SetLock
-	{
-		Set set;
-		mutable MutexLock mutex;
-	};
-
-	struct SortSetLock
-	{
-		SortSet set;
-		SSet sset;
-		mutable MutexLock mutex;
-	};
-
-	struct PubSubLock
-	{
-		PubSub pubSub;
-		mutable MutexLock mutex;
-	};
-
-	const static int kShards = 4096;
-	std::array<SetMapLock, kShards> setMapShards;
-	std::array<HsetMapLock, kShards> hsetMapShards;
-	std::array<SetLock, kShards> setShards;
-	std::array<SortSetLock,kShards> sortSetShards;
-	std::array<PubSubLock, kShards> pubSubShards;
-
-	xEventLoop loop;
-	xTcpServer server;
-	mutable MutexLock mutex;
-	mutable MutexLock slaveMutex;
-	mutable MutexLock expireMutex;
-	mutable MutexLock sentinelMutex;
-	mutable MutexLock clusterMutex;
-
-
-	std::atomic<int>	  salveCount;
-	std::atomic<bool>  clusterEnabled;
-	std::atomic<bool>  slaveEnabled;
-	std::atomic<bool>  authEnabled;
-	std::atomic<bool>  repliEnabled;
-	std::atomic<bool>  sentinelEnabled;
-	std::atomic<bool>  clusterSlotEnabled;
-	std::atomic<bool>  clusterRepliMigratEnabled;
-	std::atomic<bool>  clusterRepliImportEnabeld;
-
-	xBuffer	slaveCached;
-	xBuffer	clusterMigratCached;
-	xBuffer	clusterImportCached;
-	
-	xReplication  repli;
-	xSentinel	   senti;
-	xCluster	   clus;
-
-	std::shared_ptr<std::thread > repliThreads;
-	std::shared_ptr<std::thread > sentiThreads;
-	std::shared_ptr<std::thread>  clusterThreads;
-
-	std::unordered_map<int32_t,xTcpconnectionPtr> salvetcpconnMaps;
-	std::unordered_map<int32_t, xTcpconnectionPtr> clustertcpconnMaps;
-	std::unordered_map<int32_t,xTimer*> repliTimers;
-	std::unordered_map<rObj*,xTimer*,Hash,Equal> expireTimers;
-	
-	xSocket socket;
-	std::string password;
-	std::atomic<int64_t >  count;
-	std::atomic<bool>	pingPong;
-	std::string host;
-	int16_t port;
-	int16_t threadCount;
-	std::string masterHost;
-	std::atomic<int>	masterPort ;
-	
-};
-
-
diff --git a/src/xReplication.cpp b/src/xReplication.cpp
deleted file mode 100644
index 472d51f3..00000000
--- a/src/xReplication.cpp
+++ /dev/null
@@ -1,243 +0,0 @@
-#include "xReplication.h"
-#include "xRedis.h"
-#include "xLog.h"
-
-xReplication::xReplication()
-:start(false),
- isreconnect(true),
- port(0),
- salveLen(0),
- salveReadLen(0),
- slaveSyncEnabled(false),
- timer(nullptr)
- {
-
- }
-
-xReplication::~xReplication()
-{
-	client->disconnect();
-	loop->quit();
-
-}
-
-void xReplication::connectMaster()
-{
-	start = true;
-	xEventLoop loop;
-	xTcpClient client(&loop,this);
-	client.setConnectionCallback(std::bind(&xReplication::connCallBack, this, std::placeholders::_1,std::placeholders::_2));
-	client.setMessageCallback( std::bind(&xReplication::readCallBack, this, std::placeholders::_1,std::placeholders::_2,std::placeholders::_3));
-	client.setConnectionErrorCallBack(std::bind(&xReplication::connErrorCallBack, this));
-	this->client = & client;
-	this->loop = &loop;
-	loop.run();
-}
-
-
-void xReplication::replicationCron()
-{
-
-}
-
-
-
-void xReplication::handleTimer(void * data)
-{
-	if(conn)
-	{
-		if(!redis->pingPong)
-		{
-			LOG_WARN<<"ping pong handleTimer timeout";
-		}
-		else
-		{
-			LOG_INFO<<"ping ping ";	
-		}
-		
-		conn->send(stringPiepe(shared.pping->ptr,sdsllen(shared.pping->ptr)));
-	}
-}
-
-void xReplication::syncWrite(const xTcpconnectionPtr& conn)
-{
-	conn->send(stringPiepe(shared.sync->ptr,sdsllen(shared.sync->ptr)));
-	fp = createFile();
-	if(fp == nullptr)
-	{
-		conn->forceClose();
-	}
-}
-
-void xReplication::syncWithMaster(const xTcpconnectionPtr& conn)
-{
-	int sockerr = 0;
-   	socklen_t errlen = sizeof(sockerr);
-	/* Check for errors in the socket. */
-	if (getsockopt(conn->getSockfd(), SOL_SOCKET, SO_ERROR, &sockerr, &errlen) == -1)
-	   sockerr = errno;
-	if (sockerr) 
-	{
-	   LOG_WARN<<"Error condition on socket for SYNC"<< strerror(sockerr);
-	   return ;
-	}
-	
-	syncWrite(conn);	
-	
-}
-
-void xReplication::readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data)
-{
-	while(recvBuf->readableBytes() >= 4)
-	{
-		if(!slaveSyncEnabled)
-		{
-			salveLen = *(int32_t*)(recvBuf->peek());
-			if(salveLen >= INT_MAX || salveLen<=0)
-			{
-				isreconnect = false;
-				LOG_WARN<<"Length is too large";
-				closeFile(fp);
-				conn->forceClose();
-				break;
-			}
-			slaveSyncEnabled = true;
-			recvBuf->retrieveInt32();
-			if(recvBuf->readableBytes() == 0)
-			{
-				break;
-			}
-		}
-
-		
-		char fileName[] = "dump.rdb";
-		rdbSyncWrite(recvBuf->peek(),fp,recvBuf->readableBytes());
-		salveReadLen += recvBuf->readableBytes();
-		recvBuf->retrieveAll();
-
-		if(salveReadLen > salveLen)
-		{
-			LOG_WARN<<"slave read data failure";
-			closeFile(fp);
-			conn->forceClose();
-			
-		}
-
-		if(salveLen == salveReadLen)
-		{
-			LOG_INFO<<"slave read data sucess";
-			rdbSyncClose(fileName,fp);
-			redis->clearCommond();
-
-			if(rdbLoad(fileName,redis) == REDIS_OK)
-			{
-				LOG_INFO<<"Replication load rdb success";
-			}
-			else
-			{
-				closeFile(fp);
-				conn->forceClose();
-				LOG_INFO<<"Replication load rdb failure";
-				return ;
-			}
-
-			conn->send(stringPiepe(shared.ok->ptr,sdsllen(shared.ok->ptr)));
-			std::shared_ptr<xSession> session (new xSession(redis,conn));
-			MutexLockGuard mu(redis->mutex);
-			redis->sessions[conn->getSockfd()] = session;
-			conn->send(stringPiepe(shared.pping->ptr,sdsllen(shared.pping->ptr)));
-			timer = loop->runAfter(1,nullptr,true,std::bind(&xReplication::handleTimer,this,std::placeholders::_1));
-	
-		}
-		
-
-	}
-	
-}
-
-
-void xReplication::connCallBack(const xTcpconnectionPtr& conn,void *data)
-{
-	if(conn->connected())
-	{
-		this->conn = conn;
-		socket.getpeerName(conn->getSockfd(),&(conn->host),conn->port);
-		redis->masterHost = conn->host.c_str();
-		redis->masterPort = conn->port ;
-		redis->slaveEnabled =  true;
-		redis->repliEnabled = true;
-		isreconnect = true;
-		LOG_INFO<<"Connect master success";
-		syncWithMaster(conn);
-	}
-	else
-	{
-		this->conn = nullptr;
-		slaveSyncEnabled = false;
-		salveReadLen = 0;
-		salveLen = 0;
-		redis->masterHost.clear();
-		redis->masterPort = 0;
-		redis->slaveEnabled =  false;
-		redis->repliEnabled = false;
-		MutexLockGuard mu(redis->mutex);
-		redis->sessions.erase(conn->getSockfd());
-		
-		if(timer)
-		{
-			loop->cancelAfter(timer);
-		}
-		
-		LOG_INFO<<"Connect  master disconnect";
-	}
-}
-
-void xReplication::reconnectTimer(void * data)
-{
-	LOG_INFO<<"Reconnect..........";
-	client->connect(ip.c_str(),port);
-}
-
-void xReplication::connErrorCallBack()
-{
-	return;
-
-	/*
-	if(!isreconnect)
-	{
-		return ;
-	}
-	
-	if(connectCount >= REDIS_RECONNECT_COUNT)
-	{
-		LOG_WARN<<"Reconnect failure";
-		ip.clear();
-		port = 0;
-		isreconnect = true;
-		return ;
-	}
-	
-	++connectCount;
-	loop->runAfter(5,nullptr,false,std::bind(&xReplication::reconnectTimer,this,std::placeholders::_1));
-	*/
-	
-}
-
-void xReplication::replicationSetMaster(xRedis * redis,rObj * obj,int32_t port)
-{
-	this->ip = obj->ptr;
-	this->port = port;
-	this->redis = redis;
-
-	if(redis->repliEnabled)
-	{
-		MutexLockGuard mu(redis->slaveMutex);
-		for(auto it = redis->salvetcpconnMaps.begin(); it != redis->salvetcpconnMaps.end(); it ++)
-		{
-			it->second->forceClose();
-		}
-	}
-
-	client->connect(this->ip.c_str(),this->port);
-}
-
diff --git a/src/xReplication.h b/src/xReplication.h
deleted file mode 100644
index f17fc669..00000000
--- a/src/xReplication.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "all.h"
-#include "xObject.h"
-#include "xTcpClient.h"
-#include "xSocket.h"
-
-class xRedis;
-class xReplication: noncopyable
-{
-public:
-	xReplication();
-	~xReplication();
-
-	void handleTimer(void * data);
-	void connectMaster();
-	void replicationSetMaster(xRedis * redis,rObj * obj,int32_t port);
-
-	void connErrorCallBack();
-	void readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data);
-	void connCallBack(const xTcpconnectionPtr& conn,void *data);
-
-	void reconnectTimer(void * data);
-	void syncWithMaster(const xTcpconnectionPtr& conn);
-	void replicationCron();
-	void syncWrite(const xTcpconnectionPtr& conn);
-
-public:
-
-	bool start;
-	bool isreconnect;
-	xEventLoop *loop;
-	xTcpClient *client;
-	xRedis *redis;
-	std::string ip;
-	int32_t port;
-	int replLen;
-	int replState;
-	xBuffer sendBuf;
-	int connectCount;
-	xSocket socket;
-	FILE * fp ;
-	int32_t salveLen;
-	int32_t salveReadLen;
-	std::atomic<bool>  slaveSyncEnabled;
-	xTcpconnectionPtr conn;
-	xTimer *timer;
-};
-
diff --git a/src/xSds.cpp b/src/xSds.cpp
deleted file mode 100644
index 4581f6de..00000000
--- a/src/xSds.cpp
+++ /dev/null
@@ -1,1031 +0,0 @@
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <assert.h>
-#include "xSds.h"
-
-sds sdsnewlen(const void *init, size_t initlen) {
-    struct sdshdr *sh;
-    // T = O(N)
-    if (init) {
-
-        sh = (sdshdr*)zmalloc(sizeof(struct sdshdr)+initlen+1);
-    } else {
-
-        sh = (sdshdr*)zcalloc(sizeof(struct sdshdr)+initlen+1);
-    }
-
-
-    if (sh == NULL) return NULL;
-    sh->len = initlen;
-    sh->free = 0;
-    // T = O(N)
-    if (initlen && init)
-        memcpy(sh->buf, init, initlen);
-    sh->buf[initlen] = '\0';
-    return (char*)sh->buf;
-}
-
-/* Create an empty (zero length) sds string. Even in this case the string
- * always has an implicit null term. */
-sds sdsempty(void) {
-    return sdsnewlen("",0);
-}
-
-/* Create a new sds string starting from a null termined C string. */
-sds sdsnew(const char *init) {
-    size_t initlen = (init == NULL) ? 0 : strlen(init);
-    return sdsnewlen(init, initlen);
-}
-
-sds sdsdup(const sds s) {
-    return sdsnewlen(s, sdslen(s));
-}
-
-void sdsfree(sds s) {
-    if (s == NULL) return;
-    zfree(s-sizeof(struct sdshdr));
-}
-
-
-void sdsupdatelen(sds s) {
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    int reallen = strlen(s);
-    sh->free += (sh->len-reallen);
-    sh->len = reallen;
-}
-
-void sdsclear(sds s) {
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    sh->free += sh->len;
-    sh->len = 0;
-    sh->buf[0] = '\0';
-}
-
-sds sdsMakeRoomFor(sds s, size_t addlen) {
-    struct sdshdr *sh, *newsh;
-    size_t free = sdsavail(s);
-    size_t len, newlen;
-    if (free >= addlen) return s;
-    len = sdslen(s);
-    sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    newlen = (len+addlen);
-    if (newlen < SDS_MAX_PREALLOC)
-        newlen *= 2;
-    else
-        newlen += SDS_MAX_PREALLOC;
-    // T = O(N)
-    newsh = (sdshdr*)zrealloc(sh, sizeof(struct sdshdr)+newlen+1);
-    if (newsh == NULL) return NULL;
-    newsh->free = newlen - len;
-    return newsh->buf;
-}
-
-/* Reallocate the sds string so that it has no free space at the end. The
- * contained string remains not altered, but next concatenation operations
- * will require a reallocation.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdsRemoveFreeSpace(sds s) {
-    struct sdshdr *sh;
-
-    sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-
-    // T = O(N)
-    sh = (sdshdr*)zrealloc(sh, sizeof(struct sdshdr)+sh->len+1);
-
-    sh->free = 0;
-
-    return sh->buf;
-}
-/* Return the total size of the allocation of the specifed sds string,
- * including:
- * 1) The sds header before the pointer.
- * 2) The string.
- * 3) The free buffer at the end if any.
- * 4) The implicit null term.
- */
-size_t sdsAllocSize(sds s) {
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-
-    return sizeof(*sh)+sh->len+sh->free+1;
-}
-
-void sdsIncrLen(sds s, int incr) {
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    assert(sh->free >= incr);
-    sh->len += incr;
-    sh->free -= incr;
-    assert(sh->free >= 0);
-    s[sh->len] = '\0';
-}
-
-/* Grow the sds to have the specified length. Bytes that were not part of
- * the original length of the sds will be set to zero.
- *
- * if the specified length is smaller than the current length, no operation
-*/
-sds sdsgrowzero(sds s, size_t len) {
-    struct sdshdr *sh = (sdshdr*)(s-(sizeof(struct sdshdr)));
-    size_t totlen, curlen = sh->len;
-
-    if (len <= curlen) return s;
-
-    // T = O(N)
-    s = sdsMakeRoomFor(s,len-curlen);
-    if (s == NULL) return NULL;
-
-  
-    sh = (sdshdr*)(s-(sizeof(struct sdshdr)));
-    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
-
-    totlen = sh->len+sh->free;
-    sh->len = len;
-    sh->free = totlen-sh->len;
-
-    return s;
-}
-
-/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the
- * end of the specified sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatlen(sds s, const void *t, size_t len) {
-    
-    struct sdshdr *sh;
-    size_t curlen = sdslen(s);
-
-    // T = O(N)
-    s = sdsMakeRoomFor(s,len);
-
-    if (s == NULL) return NULL;
-
-    // T = O(N)
-    sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    memcpy(s+curlen, t, len);
-    sh->len = curlen+len;
-    sh->free = sh->free-len;
-
-    s[curlen+len] = '\0';
-
-    return s;
-}
-
-/* Append the specified null termianted C string to the sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscat(sds s, const char *t) {
-    return sdscatlen(s, t, strlen(t));
-}
-
-/* Append the specified sds 't' to the existing sds 's'.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatsds(sds s, const sds t) {
-    return sdscatlen(s, t, sdslen(t));
-}
-
-/* Destructively modify the sds string 's' to hold the specified binary
- * safe string pointed by 't' of length 'len' bytes. */
-sds sdscpylen(sds s, const char *t, size_t len) {
-
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-
-    size_t totlen = sh->free+sh->len;
-   
-    if (totlen < len) {
-        // T = O(N)
-        s = sdsMakeRoomFor(s,len-sh->len);
-        if (s == NULL) return NULL;
-        sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-        totlen = sh->free+sh->len;
-    }
-    memcpy(s, t, len);
-
-    s[len] = '\0';
-
-    sh->len = len;
-    sh->free = totlen-len;
-
-    return s;
-}
-
-/* Like sdscpylen() but 't' must be a null-termined string so that the length
- * of the string is obtained with strlen(). */
-sds sdscpy(sds s, const char *t) {
-    return sdscpylen(s, t, strlen(t));
-}
-
-/* Helper for sdscatlonglong() doing the actual number -> string
- * conversion. 's' must point to a string with room for at least
- * SDS_LLSTR_SIZE bytes.
- *
- * The function returns the lenght of the null-terminated string
- * representation stored at 's'. */
-#define SDS_LLSTR_SIZE 21
-int sdsll2str(char *s, long long value) {
-    char *p, aux;
-    unsigned long long v;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    v = (value < 0) ? -value : value;
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-    if (value < 0) *p++ = '-';
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Identical sdsll2str(), but for unsigned long long type. */
-int sdsull2str(char *s, unsigned long long v) {
-    char *p, aux;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Create an sds string from a long long value. It is much faster than:
- *
- * sdscatprintf(sdsempty(),"%lld\n", value);
- */
-sds sdsfromlonglong(long long value) {
-    char buf[SDS_LLSTR_SIZE];
-    int len = sdsll2str(buf,value);
-
-    return sdsnewlen(buf,len);
-}
-
-
-/* Like sdscatpritf() but gets va_list instead of being variadic. */
-sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
-    va_list cpy;
-    char staticbuf[1024], *buf = staticbuf, *t;
-    size_t buflen = strlen(fmt)*2;
-
-    /* We try to start using a static buffer for speed.
-     * If not possible we revert to heap allocation. */
-    if (buflen > sizeof(staticbuf)) {
-        buf = (char*)zmalloc(buflen);
-        if (buf == NULL) return NULL;
-    } else {
-        buflen = sizeof(staticbuf);
-    }
-
-    /* Try with buffers two times bigger every time we fail to
-     * fit the string in the current buffer size. */
-    while(1) {
-        buf[buflen-2] = '\0';
-        va_copy(cpy,ap);
-        // T = O(N)
-        vsnprintf(buf, buflen, fmt, cpy);
-        if (buf[buflen-2] != '\0') {
-            if (buf != staticbuf) zfree(buf);
-            buflen *= 2;
-            buf = (char*)zmalloc(buflen);
-            if (buf == NULL) return NULL;
-            continue;
-        }
-        break;
-    }
-
-    /* Finally concat the obtained string to the SDS string and return it. */
-    t = sdscat(s, buf);
-    if (buf != staticbuf) zfree(buf);
-    return t;
-}
-
-/* Append to the sds string 's' a string obtained using printf-alike format
- * specifier.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsempty("Sum is: ");
- * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b).
- *
- * Often you need to create a string from scratch with the printf-alike
- * format. When this is the need, just use sdsempty() as the target string:
- *
- * s = sdscatprintf(sdsempty(), "... your format ...", args);
- */
-sds sdscatprintf(sds s, const char *fmt, ...) {
-    va_list ap;
-    char *t;
-    va_start(ap, fmt);
-    // T = O(N^2)
-    t = sdscatvprintf(s,fmt,ap);
-    va_end(ap);
-    return t;
-}
-
-/* This function is similar to sdscatprintf, but much faster as it does
- * not rely on sprintf() family functions implemented by the libc that
- * are often very slow. Moreover directly handling the sds string as
- * new data is concatenated provides a performance improvement.
- *
- * However this function only handles an incompatible subset of printf-alike
- * format specifiers:
- *
- * %s - C String
- * %S - SDS string
- * %i - signed int
- * %I - 64 bit signed integer (long long, int64_t)
- * %u - unsigned int
- * %U - 64 bit unsigned integer (unsigned long long, uint64_t)
- * %% - Verbatim "%" character.
- */
-sds sdscatfmt(sds s, char const *fmt, ...) {
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    size_t initlen = sdslen(s);
-    const char *f = fmt;
-    int i;
-    va_list ap;
-
-    va_start(ap,fmt);
-    f = fmt;    /* Next format specifier byte to process. */
-    i = initlen; /* Position of the next byte to write to dest str. */
-    while(*f) {
-        char next, *str;
-        size_t l;
-        long long num;
-        unsigned long long unum;
-
-        /* Make sure there is always space for at least 1 char. */
-        if (sh->free == 0) {
-            s = sdsMakeRoomFor(s,1);
-            sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-        }
-
-        switch(*f) {
-        case '%':
-            next = *(f+1);
-            f++;
-            switch(next) {
-            case 's':
-            case 'S':
-                str = va_arg(ap,char*);
-                l = (next == 's') ? strlen(str) : sdslen(str);
-                if (sh->free < l) {
-                    s = sdsMakeRoomFor(s,l);
-                    sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-                }
-                memcpy(s+i,str,l);
-                sh->len += l;
-                sh->free -= l;
-                i += l;
-                break;
-            case 'i':
-            case 'I':
-                if (next == 'i')
-                    num = va_arg(ap,int);
-                else
-                    num = va_arg(ap,long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsll2str(buf,num);
-                    if (sh->free < l) {
-                        s = sdsMakeRoomFor(s,l);
-                        sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-                    }
-                    memcpy(s+i,buf,l);
-                    sh->len += l;
-                    sh->free -= l;
-                    i += l;
-                }
-                break;
-            case 'u':
-            case 'U':
-                if (next == 'u')
-                    unum = va_arg(ap,unsigned int);
-                else
-                    unum = va_arg(ap,unsigned long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsull2str(buf,unum);
-                    if (sh->free < l) {
-                        s = sdsMakeRoomFor(s,l);
-                        sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-                    }
-                    memcpy(s+i,buf,l);
-                    sh->len += l;
-                    sh->free -= l;
-                    i += l;
-                }
-                break;
-            default: /* Handle %% and generally %<unknown>. */
-                s[i++] = next;
-                sh->len += 1;
-                sh->free -= 1;
-                break;
-            }
-            break;
-        default:
-            s[i++] = *f;
-            sh->len += 1;
-            sh->free -= 1;
-            break;
-        }
-        f++;
-    }
-    va_end(ap);
-
-    /* Add null-term */
-    s[i] = '\0';
-    return s;
-}
-
-/* Remove the part of the string from left and from right composed just of
- * contiguous characters found in 'cset', that is a null terminted C string.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsnew("AA...AA.a.aa.aHelloWorld     :::");
- * s = sdstrim(s,"A. :");
- * printf("%s\n", s);
- *
- * Output will be just "Hello World".
- */
-sds sdstrim(sds s, const char *cset) {
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    char *start, *end, *sp, *ep;
-    size_t len;
-    sp = start = s;
-    ep = end = s+sdslen(s)-1;
-
-
-    while(sp <= end && strchr(cset, *sp)) sp++;
-    while(ep > start && strchr(cset, *ep)) ep--;
-
- 
-    len = (sp > ep) ? 0 : ((ep-sp)+1);
-    
-    // T = O(N)
-    if (sh->buf != sp) memmove(sh->buf, sp, len);
-
-   
-    sh->buf[len] = '\0';
-
- 
-    sh->free = sh->free+(sh->len-len);
-    sh->len = len;
-
-   
-    return s;
-}
-
-/* Turn the string into a smaller (or equal) string containing only the
- * substring specified by the 'start' and 'end' indexes.
- *
- * start and end can be negative, where -1 means the last character of the
- * string, -2 the penultimate character, and so forth.
- *
- * The interval is inclusive, so the start and end characters will be part
- * of the resulting string.
- *
- * The string is modified in-place.
- *
- * Example:
- *
- * s = sdsnew("Hello World");
- * sdsrange(s,1,-1); => "ello World"
- */
-void sdsrange(sds s, int start, int end) {
-    struct sdshdr *sh = (sdshdr*) (s-(sizeof(struct sdshdr)));
-    size_t newlen, len = sdslen(s);
-
-    if (len == 0) return;
-    if (start < 0) {
-        start = len+start;
-        if (start < 0) start = 0;
-    }
-    if (end < 0) {
-        end = len+end;
-        if (end < 0) end = 0;
-    }
-    newlen = (start > end) ? 0 : (end-start)+1;
-    if (newlen != 0) {
-        if (start >= (signed)len) {
-            newlen = 0;
-        } else if (end >= (signed)len) {
-            end = len-1;
-            newlen = (start > end) ? 0 : (end-start)+1;
-        }
-    } else {
-        start = 0;
-    }
-
-   
-    if (start && newlen) memmove(sh->buf, sh->buf+start, newlen);
-
- 
-    sh->buf[newlen] = 0;
-
-    sh->free = sh->free+(sh->len-newlen);
-    sh->len = newlen;
-}
-
-/* Apply tolower() to every character of the sds string 's'. */
-void sdstolower(sds s) {
-    int len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = tolower(s[j]);
-}
-
-
-/* Apply toupper() to every character of the sds string 's'. */
-void sdstoupper(sds s) {
-    int len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = toupper(s[j]);
-}
-
-/* Compare two sds strings s1 and s2 with memcmp().
- *
- * Return value:
- *
- *     1 if s1 > s2.
- *    -1 if s1 < s2.
- *     0 if s1 and s2 are exactly the same binary string.
- *
- * If two strings share exactly the same prefix, but one of the two has
- * additional characters, the longer string is considered to be greater than
- * the smaller one. */
-int sdscmp(const sds s1, const sds s2) {
-    size_t l1, l2, minlen;
-    int cmp;
-
-    l1 = sdslen(s1);
-    l2 = sdslen(s2);
-    minlen = (l1 < l2) ? l1 : l2;
-    cmp = memcmp(s1,s2,minlen);
-
-    if (cmp == 0) return l1-l2;
-
-    return cmp;
-}
-
-sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count) {
-    int elements = 0, slots = 5, start = 0, j;
-    sds *tokens;
-
-    if (seplen < 1 || len < 0) return NULL;
-
-    tokens = (sds*)zmalloc(sizeof(sds)*slots);
-    if (tokens == NULL) return NULL;
-
-    if (len == 0) {
-        *count = 0;
-        return tokens;
-    }
-    
-    // T = O(N^2)
-    for (j = 0; j < (len-(seplen-1)); j++) {
-        /* make sure there is room for the next element and the final one */
-        if (slots < elements+2) {
-            sds *newtokens;
-
-            slots *= 2;
-            newtokens = (sds*)zrealloc(tokens,sizeof(sds)*slots);
-            if (newtokens == NULL) goto cleanup;
-            tokens = newtokens;
-        }
-        /* search the separator */
-        // T = O(N)
-        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
-            tokens[elements] = sdsnewlen(s+start,j-start);
-            if (tokens[elements] == NULL) goto cleanup;
-            elements++;
-            start = j+seplen;
-            j = j+seplen-1; /* skip the separator */
-        }
-    }
-    /* Add the final element. We are sure there is room in the tokens array. */
-    tokens[elements] = sdsnewlen(s+start,len-start);
-    if (tokens[elements] == NULL) goto cleanup;
-    elements++;
-    *count = elements;
-    return tokens;
-
-cleanup:
-    {
-        int i;
-        for (i = 0; i < elements; i++) sdsfree(tokens[i]);
-        zfree(tokens);
-        *count = 0;
-        return NULL;
-    }
-}
-
-
-/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
-void sdsfreesplitres(sds *tokens, int count) {
-    if (!tokens) return;
-    while(count--)
-        sdsfree(tokens[count]);
-    zfree(tokens);
-}
-
-
-/* Append to the sds string "s" an escaped string representation where
- * all the non-printable characters (tested with isprint()) are turned into
- * escapes in the form "\n\r\a...." or "\x<hex-number>".
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatrepr(sds s, const char *p, size_t len) {
-
-    s = sdscatlen(s,"\"",1);
-
-    while(len--) {
-        switch(*p) {
-        case '\\':
-        case '"':
-            s = sdscatprintf(s,"\\%c",*p);
-            break;
-        case '\n': s = sdscatlen(s,"\\n",2); break;
-        case '\r': s = sdscatlen(s,"\\r",2); break;
-        case '\t': s = sdscatlen(s,"\\t",2); break;
-        case '\a': s = sdscatlen(s,"\\a",2); break;
-        case '\b': s = sdscatlen(s,"\\b",2); break;
-        default:
-            if (isprint(*p))
-                s = sdscatprintf(s,"%c",*p);
-            else
-                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
-            break;
-        }
-        p++;
-    }
-
-    return sdscatlen(s,"\"",1);
-}
-
-/* Helper function for sdssplitargs() that returns non zero if 'c'
- * is a valid hex digit. */
-
-int is_hex_digit(char c) {
-    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
-           (c >= 'A' && c <= 'F');
-}
-
-/* Helper function for sdssplitargs() that converts a hex digit into an
- * integer from 0 to 15 */
-
-int hex_digit_to_int(char c) {
-    switch(c) {
-    case '0': return 0;
-    case '1': return 1;
-    case '2': return 2;
-    case '3': return 3;
-    case '4': return 4;
-    case '5': return 5;
-    case '6': return 6;
-    case '7': return 7;
-    case '8': return 8;
-    case '9': return 9;
-    case 'a': case 'A': return 10;
-    case 'b': case 'B': return 11;
-    case 'c': case 'C': return 12;
-    case 'd': case 'D': return 13;
-    case 'e': case 'E': return 14;
-    case 'f': case 'F': return 15;
-    default: return 0;
-    }
-}
-
-
-sds *sdssplitargs(const char *line, int *argc) {
-    const char *p = line;
-    char *current = NULL;
-    char **vector = NULL;
-
-    *argc = 0;
-    while(1) {
-
-       
-        // T = O(N)
-        while(*p && isspace(*p)) p++;
-
-        if (*p) {
-            /* get a token */
-            int inq=0;  /* set to 1 if we are in "quotes" */
-            int insq=0; /* set to 1 if we are in 'single quotes' */
-            int done=0;
-
-            if (current == NULL) current = sdsempty();
-
-            // T = O(N)
-            while(!done) {
-                if (inq) {
-                    if (*p == '\\' && *(p+1) == 'x' &&
-                                             is_hex_digit(*(p+2)) &&
-                                             is_hex_digit(*(p+3)))
-                    {
-                        unsigned char byte;
-
-                        byte = (hex_digit_to_int(*(p+2))*16)+
-                                hex_digit_to_int(*(p+3));
-                        current = sdscatlen(current,(char*)&byte,1);
-                        p += 3;
-                    } else if (*p == '\\' && *(p+1)) {
-                        char c;
-
-                        p++;
-                        switch(*p) {
-                        case 'n': c = '\n'; break;
-                        case 'r': c = '\r'; break;
-                        case 't': c = '\t'; break;
-                        case 'b': c = '\b'; break;
-                        case 'a': c = '\a'; break;
-                        default: c = *p; break;
-                        }
-                        current = sdscatlen(current,&c,1);
-                    } else if (*p == '"') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else if (insq) {
-                    if (*p == '\\' && *(p+1) == '\'') {
-                        p++;
-                        current = sdscatlen(current,"'",1);
-                    } else if (*p == '\'') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else {
-                    switch(*p) {
-                    case ' ':
-                    case '\n':
-                    case '\r':
-                    case '\t':
-                    case '\0':
-                        done=1;
-                        break;
-                    case '"':
-                        inq=1;
-                        break;
-                    case '\'':
-                        insq=1;
-                        break;
-                    default:
-                        current = sdscatlen(current,p,1);
-                        break;
-                    }
-                }
-                if (*p) p++;
-            }
-            /* add the token to the vector */
-            // T = O(N)
-            vector = (char **)zrealloc(vector,((*argc)+1)*sizeof(char*));
-            vector[*argc] = current;
-            (*argc)++;
-            current = NULL;
-        } else {
-            /* Even on empty input string return something not NULL. */
-            if (vector == NULL) vector = (char **)zmalloc(sizeof(void*));
-            return vector;
-        }
-    }
-
-err:
-    while((*argc)--)
-        sdsfree(vector[*argc]);
-    zfree(vector);
-    if (current) sdsfree(current);
-    *argc = 0;
-    return NULL;
-}
-
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
-    size_t j, i, l = sdslen(s);
-
-    // ���������ַ���
-    for (j = 0; j < l; j++) {
-        // ����ӳ��
-        for (i = 0; i < setlen; i++) {
-            // �滻�ַ���
-            if (s[j] == from[i]) {
-                s[j] = to[i];
-                break;
-            }
-        }
-    }
-    return s;
-}
-
-/* Join an array of C strings using the specified separator (also a C string).
- * Returns the result as an sds string. */
-sds sdsjoin(char **argv, int argc, char *sep) {
-    sds join = sdsempty();
-    int j;
-
-    for (j = 0; j < argc; j++) {
-        join = sdscat(join, argv[j]);
-        if (j != argc-1) join = sdscat(join,sep);
-    }
-    return join;
-}
-
-#ifdef SDS_TEST_MAIN
-#include <stdio.h>
-#include "testhelp.h"
-#include "limits.h"
-
-int main(void) {
-    {
-        struct sdshdr *sh;
-        sds x = sdsnew("foo"), y;
-
-        test_cond("Create a string and obtain the length",
-            sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0)
-
-        sdsfree(x);
-        x = sdsnewlen("foo",2);
-        test_cond("Create a string with specified length",
-            sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0)
-
-        x = sdscat(x,"bar");
-        test_cond("Strings concatenation",
-            sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0);
-
-        x = sdscpy(x,"a");
-        test_cond("sdscpy() against an originally longer string",
-            sdslen(x) == 1 && memcmp(x,"a\0",2) == 0)
-
-        x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk");
-        test_cond("sdscpy() against an originally shorter string",
-            sdslen(x) == 33 &&
-            memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0)
-
-        sdsfree(x);
-        x = sdscatprintf(sdsempty(),"%d",123);
-        test_cond("sdscatprintf() seems working in the base case",
-            sdslen(x) == 3 && memcmp(x,"123\0",4) == 0)
-
-        sdsfree(x);
-        x = sdsnew("--");
-        x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX);
-        test_cond("sdscatfmt() seems working in the base case",
-            sdslen(x) == 60 &&
-            memcmp(x,"--Hello Hi! World -9223372036854775808,"
-                     "9223372036854775807--",60) == 0)
-
-        sdsfree(x);
-        x = sdsnew("--");
-        x = sdscatfmt(x, "%u,%U--", UINT_MAX, ULLONG_MAX);
-        test_cond("sdscatfmt() seems working with unsigned numbers",
-            sdslen(x) == 35 &&
-            memcmp(x,"--4294967295,18446744073709551615--",35) == 0)
-
-        sdsfree(x);
-        x = sdsnew("xxciaoyyy");
-        sdstrim(x,"xy");
-        test_cond("sdstrim() correctly trims characters",
-            sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0)
-
-        y = sdsdup(x);
-        sdsrange(y,1,1);
-        test_cond("sdsrange(...,1,1)",
-            sdslen(y) == 1 && memcmp(y,"i\0",2) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,1,-1);
-        test_cond("sdsrange(...,1,-1)",
-            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,-2,-1);
-        test_cond("sdsrange(...,-2,-1)",
-            sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,2,1);
-        test_cond("sdsrange(...,2,1)",
-            sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,1,100);
-        test_cond("sdsrange(...,1,100)",
-            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,100,100);
-        test_cond("sdsrange(...,100,100)",
-            sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnew("foo");
-        y = sdsnew("foa");
-        test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnew("bar");
-        y = sdsnew("bar");
-        test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnew("aar");
-        y = sdsnew("bar");
-        test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnewlen("\a\n\0foo\r",7);
-        y = sdscatrepr(sdsempty(),x,sdslen(x));
-        test_cond("sdscatrepr(...data...)",
-            memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0)
-
-        {
-            int oldfree;
-
-            sdsfree(x);
-            x = sdsnew("0");
-            sh = (void*) (x-(sizeof(struct sdshdr)));
-            test_cond("sdsnew() free/len buffers", sh->len == 1 && sh->free == 0);
-            x = sdsMakeRoomFor(x,1);
-            sh = (void*) (x-(sizeof(struct sdshdr)));
-            test_cond("sdsMakeRoomFor()", sh->len == 1 && sh->free > 0);
-            oldfree = sh->free;
-            x[1] = '1';
-            sdsIncrLen(x,1);
-            test_cond("sdsIncrLen() -- content", x[0] == '0' && x[1] == '1');
-            test_cond("sdsIncrLen() -- len", sh->len == 2);
-            test_cond("sdsIncrLen() -- free", sh->free == oldfree-1);
-        }
-    }
-    test_report()
-    return 0;
-}
-#endif
diff --git a/src/xSds.h b/src/xSds.h
deleted file mode 100644
index 89ed26ff..00000000
--- a/src/xSds.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-#define SDS_MAX_PREALLOC (1024*1024)
-#include <sys/types.h>
-#include <stdarg.h>
-#include "xZmalloc.h"
-typedef char *sds;
-
-
-struct sdshdr
-{
-    int len;
-    int free;
-    char buf[];
-};
-
-
-static inline size_t sdsllen(const char *s) {
-    struct sdshdr *sh = (sdshdr*)(s-(sizeof(struct sdshdr)));
-    return sh->len;
-}
-
-
-static inline size_t sdslen(const sds s) {
-    struct sdshdr *sh = (sdshdr*)(s-(sizeof(struct sdshdr)));
-    return sh->len;
-}
-
-static inline size_t sdsavail(const sds s) {
-    struct sdshdr *sh = (sdshdr*)(s-(sizeof(struct sdshdr)));
-    return sh->free;
-}
-
-sds sdsnewlen(const void *init, size_t initlen);
-sds sdsnew(const char *init);
-sds sdsempty(void);
-size_t sdslen(const sds s);
-sds sdsdup(const sds s);
-void sdsfree(sds s);
-size_t sdsavail(const sds s);
-sds sdsgrowzero(sds s, size_t len);
-sds sdscatlen(sds s, const void *t, size_t len);
-sds sdscat(sds s, const char *t);
-sds sdscatsds(sds s, const sds t);
-sds sdscpylen(sds s, const char *t, size_t len);
-sds sdscpy(sds s, const char *t);
-
-sds sdscatvprintf(sds s, const char *fmt, va_list ap);
-#ifdef __GNUC__
-sds sdscatprintf(sds s, const char *fmt, ...)
-    __attribute__((format(printf, 2, 3)));
-#else
-sds sdscatprintf(sds s, const char *fmt, ...);
-#endif
-
-sds sdscatfmt(sds s, char const *fmt, ...);
-sds sdstrim(sds s, const char *cset);
-void sdsrange(sds s, int start, int end);
-void sdsupdatelen(sds s);
-void sdsclear(sds s);
-int sdscmp(const sds s1, const sds s2);
-sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
-void sdsfreesplitres(sds *tokens, int count);
-void sdstolower(sds s);
-void sdstoupper(sds s);
-sds sdsfromlonglong(long long value);
-sds sdscatrepr(sds s, const char *p, size_t len);
-sds *sdssplitargs(const char *line, int *argc);
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
-sds sdsjoin(char **argv, int argc, char *sep);
-
-/* Low level functions exposed to the user API */
-sds sdsMakeRoomFor(sds s, size_t addlen);
-void sdsIncrLen(sds s, int incr);
-sds sdsRemoveFreeSpace(sds s);
-size_t sdsAllocSize(sds s);
-
-
diff --git a/src/xSentinel.cpp b/src/xSentinel.cpp
deleted file mode 100644
index 222d1571..00000000
--- a/src/xSentinel.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "xSentinel.h"
-#include "xRedis.h"
-#include "xLog.h"
-
-xSentinel::xSentinel()
-:start(false),
- isreconnect(true),
- port(0)
-{
-
-}
-
-
-xSentinel::~xSentinel()
-{
-	
-}
-
-void xSentinel::readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data)
-{
-	
-}
-
-
-void xSentinel::connCallBack(const xTcpconnectionPtr& conn,void *data)
-{
-	if(conn->connected())
-	{
-		this->conn = conn;
-		socket.getpeerName(conn->getSockfd(),&(conn->host),conn->port);
-		{
-			MutexLockGuard lk(redis->sentinelMutex);
-			redis->salvetcpconnMaps.insert(std::make_pair(conn->getSockfd(), conn));
-		}
-		LOG_INFO<<"connect Sentinel suucess ";
-		
-	}
-	else
-	{
-		{
-			MutexLockGuard lk(redis->sentinelMutex);
-			redis->salvetcpconnMaps.erase(conn->getSockfd());
-		}
-		LOG_INFO<<"disconnect sentinel ";
-	}
-}
-
-
-void xSentinel::connectSentinel()
-{
-	start = true;
-	xEventLoop loop;
-	xTcpClient client(&loop,this);
-	client.setConnectionCallback(std::bind(&xSentinel::connCallBack, this, std::placeholders::_1,std::placeholders::_2));
-	client.setMessageCallback( std::bind(&xSentinel::readCallBack, this, std::placeholders::_1,std::placeholders::_2,std::placeholders::_3));
-	client.setConnectionErrorCallBack(std::bind(&xSentinel::connErrorCallBack, this));
-	this->loop = &loop;
-	this->client = & client;
-	this->loop = &loop;
-	loop.run();
-}
-
-void xSentinel::reconnectTimer(void * data)
-{
-	LOG_INFO<<"Reconnect..........";
-	client->connect(ip.c_str(),port);
-}
-
-
-
-void xSentinel::connErrorCallBack()
-{
-
-	if(!isreconnect)
-	{
-		return ;
-	}
-	
-	if(connectCount >= REDIS_RECONNECT_COUNT)
-	{
-		LOG_WARN<<"Reconnect failure";
-		ip.clear();
-		port = 0;
-		isreconnect = true;
-		return ;
-	}
-	
-	++connectCount;
-	loop->runAfter(5,nullptr,false,std::bind(&xSentinel::reconnectTimer,this,std::placeholders::_1));
-}
-
-void xSentinel::init()
-{
-	
-}
-
-
-
diff --git a/src/xSentinel.h b/src/xSentinel.h
deleted file mode 100644
index 327812c2..00000000
--- a/src/xSentinel.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xObject.h"
-#include "xTcpClient.h"
-#include "xSocket.h"
-
-class xRedis;
-class xSentinel: noncopyable
-{
-public:
-	xSentinel();
-	~xSentinel();
-	void init();
-	void connectSentinel();
-	void connErrorCallBack();
-	void readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data);
-	void connCallBack(const xTcpconnectionPtr& conn,void *data);
-	void reconnectTimer(void * data);
-private:
-	bool start;
-	bool isreconnect;
-	xEventLoop *loop;
-	xTcpClient *client;
-	xRedis *redis;
-	std::string ip;
-	int32_t port;
-	xBuffer sendBuf;
-	int connectCount;
-	xSocket socket;
-	xTcpconnectionPtr conn;
-};
diff --git a/src/xSession.cpp b/src/xSession.cpp
deleted file mode 100755
index 317bfd60..00000000
--- a/src/xSession.cpp
+++ /dev/null
@@ -1,527 +0,0 @@
-#include "xSession.h"
-#include "xRedis.h"
-
-xSession::xSession(xRedis *redis,const xTcpconnectionPtr & conn)
-:reqtype(0),
- multibulklen(0),
- bulklen(-1),
- argc(0),
- conn(conn),
- redis(redis),
- authEnabled(false),
- retrieveBuffer(false)
-{
-	 conn->setMessageCallback(
-	        std::bind(&xSession::readCallBack, this, std::placeholders::_1,std::placeholders::_2,std::placeholders::_3));
-}
-
-xSession::~xSession()
-{
-
-}
-
-void xSession::readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data)
-{
-	while(recvBuf->readableBytes() > 0 )
-	{
-		if(!reqtype)
-		{
-			if((recvBuf->peek()[0])== '*')
-			{
-				reqtype = REDIS_REQ_MULTIBULK;
-			}
-			else
-			{
-				reqtype = REDIS_REQ_INLINE;
-			}
-		}
-
-		if(reqtype == REDIS_REQ_MULTIBULK)
-		{
-			if(processMultibulkBuffer(recvBuf)!= REDIS_OK)
-			{
-				break;
-			}
-		}
-		else if(reqtype == REDIS_REQ_INLINE)
-		{
-			if(processInlineBuffer(recvBuf)!= REDIS_OK)
-			{
-				break;
-			}
-		}
-		else
-		{
-			LOG_WARN<<"Unknown request type";
-		}
-
-		processCommand();
-		reset();
-	}
-
-
-	if( (conn->host == redis->masterHost) && (conn->port == redis->masterPort) )
-	{
-		sendBuf.retrieveAll();
-		sendSlaveBuf.retrieveAll();
-		sendPubSub.retrieveAll();
-	}
-	else
-	{
-
-		if(retrieveBuffer)
-		{
-			sendBuf.retrieveAll();
-			retrieveBuffer = false;
-		}
-		
-		if(sendBuf.readableBytes() > 0 )
-		{
-			conn->send(&sendBuf);
-			sendBuf.retrieveAll();
-		}
-
-		if(sendPubSub.readableBytes() > 0 )
-		{
-			for(auto iter = pubSubTcpconn.begin(); iter != pubSubTcpconn.end(); iter ++)
-			{
-				(*iter)->send(&sendPubSub);
-			}
-
-			pubSubTcpconn.clear();
-			sendPubSub.retrieveAll();
-		}
-
-		
-
-		if(redis->repliEnabled)
-		{
-			MutexLockGuard mu(redis->slaveMutex);
-			for(auto it = redis->salvetcpconnMaps.begin(); it != redis->salvetcpconnMaps.end(); it++)
-			{
-				if(sendSlaveBuf.readableBytes() > 0 )
-				{
-					it->second->send(&sendSlaveBuf);
-				}
-			}
-			sendSlaveBuf.retrieveAll();
-		}
-	}
-}
-
-
-
-bool xSession::checkCommond(rObj*  robjs)
-{
-	auto it = redis->unorderedmapCommonds.find(robjs);
-	if(it == redis->unorderedmapCommonds.end())
-	{
-		return true;
-	}
-		
-	return false;
-}
-
-
-int xSession::processCommand()
-{
-	assert(robjs.size());
-	
-	if(redis->authEnabled)
-	{
-		if(!authEnabled)
-		{
-			if (strcasecmp(robjs[0]->ptr,"auth") != 0)
-			{
-				clearObj();
-				addReplyErrorFormat(sendBuf,"NOAUTH Authentication required");
-				return REDIS_ERR;
-			}
-		}
-	}
-
-	if (redis->clusterEnabled && redis->clusterSlotEnabled)
-	{
-		
-		if (!(strcasecmp(robjs[0]->ptr, "cluster")) || !(strcasecmp(robjs[0]->ptr, "migrate")))
-		{
-			
-		}
-		else
-		{
-		
-			if (robjs.size() >= 2)
-			{
-				const char * key = robjs[1]->ptr;
-				int hashslot = redis->clus.keyHashSlot((char*)key, sdsllen(key));
-				
-				MutexLockGuard mu(redis->clusterMutex);
-				if(redis->clusterRepliMigratEnabled)
-				{
-					for(auto it = redis->clus.migratingSlosTos.begin(); it != redis->clus.migratingSlosTos.end(); it ++)
-					{
-						auto iter = it->second.find(hashslot);
-						if(iter != it->second.end())
-						{
-							redis->structureRedisProtocol(redis->clusterMigratCached,robjs);
-							goto jump;
-						}
-					}
-				}
-
-				
-
-				if(redis->clusterRepliImportEnabeld)
-				{
-					for(auto it = redis->clus.importingSlotsFrom.begin(); it != redis->clus.importingSlotsFrom.end(); it ++)
-					{
-						auto iter = it->second.find(hashslot);
-						if(iter !=  it->second.end())
-						{
-							retrieveBuffer = true;
-							goto jump;
-						}
-					}	
-				}
-				
-				
-				if (redis->clus.clusterSlotNodes.size() == 0)
-				{
-					redis->clus.clusterRedirectClient(this, nullptr, hashslot, CLUSTER_REDIR_DOWN_UNBOUND);
-					clearObj();
-					return REDIS_ERR;
-				}
-
-				auto it = redis->clus.clusterSlotNodes.find(hashslot);
-				if (it == redis->clus.clusterSlotNodes.end())
-				{
-					redis->clus.clusterRedirectClient(this, nullptr, hashslot, CLUSTER_REDIR_DOWN_UNBOUND);
-					clearObj();
-					return REDIS_ERR;
-				}
-				else
-				{
-					if (redis->host == it->second.ip && redis->port == it->second.port)
-					{
-
-					}
-					else
-					{
-						redis->clus.clusterRedirectClient(this, &(it->second), hashslot, CLUSTER_REDIR_MOVED);
-						clearObj();
-						return REDIS_ERR;
-					}
-				}
-			}
-
-		}
-	}
-	
-
-jump:
-		
-	bool fromSalve = false;
-	
-	if(redis->repliEnabled)
-	{
-		{
-			MutexLockGuard mu(redis->slaveMutex);
-			auto it = redis->salvetcpconnMaps.find(conn->getSockfd());
-			if(it !=  redis->salvetcpconnMaps.end())
-			{
-				fromSalve = true;
-				if(memcmp(robjs[0]->ptr,shared.ok->ptr,3) == 0)
-				{
-					if(++redis->salveCount >= redis->salvetcpconnMaps.size())
-					{
-						LOG_INFO<<"slaveof sync success";
-						if(redis->slaveCached.readableBytes() > 0)
-						{
-							conn->send(&redis->slaveCached);
-							redis->slaveCached.retrieveAll();
-							xBuffer buffer;
-							redis->slaveCached.swap(buffer);
-						}
-					}
-
-					auto iter = redis->repliTimers.find(conn->getSockfd());
-					if(iter == redis->repliTimers.end())
-					{
-						assert(false);
-					}
-
-					if(iter->second)
-					{
-						conn->getLoop()->cancelAfter(iter->second);
-					}
-
-					redis->repliTimers.erase(conn->getSockfd());
-					clearObj();
-					return REDIS_OK;
-				}
-			}
-			
-		}
-
-		if( (conn->host == redis->masterHost) && (conn->port == redis->masterPort) )
-		{
-
-		}
-		else
-		{
-			if( redis->masterPort == 0 )
-			{
-				if(!fromSalve)
-				{
-					MutexLockGuard mu(redis->slaveMutex);
-					if(redis->salveCount <  redis->salvetcpconnMaps.size())
-					{
-						redis->structureRedisProtocol(redis->slaveCached,robjs);
-					}
-					else
-					{
-						redis->structureRedisProtocol(sendSlaveBuf,robjs);
-					}
-				}
-				
-
-			}
-			else
-			{
-				if(!checkCommond(robjs[0]))
-				{
-					if(redis->slaveEnabled)
-					{
-						clearObj();
-						addReplyErrorFormat(sendBuf,"slaveof mode commond unknown ");
-						return REDIS_ERR;
-					}
-				}
-			}
-		}
-				
-	}
-	
-	
-
-	auto iter = redis->handlerCommondMap.find(robjs[0]);
-	if(iter == redis->handlerCommondMap.end() )
-	{
-		clearObj();
-		addReplyErrorFormat(sendBuf,"command unknown eror");
-		return REDIS_ERR;
-	}
-
-	rObj * obj = robjs.front();
-	robjs.pop_front();
-	zfree(obj);
-
-	if(!iter->second(robjs,this))
-	{
-		clearObj();
-		return REDIS_ERR;
-	}
-	
-	return REDIS_OK;
-}
-
-void xSession::resetVlaue()
-{
-	
-}
-
-void xSession::clearObj()
-{
-	for(auto it = robjs.begin(); it != robjs.end(); it++)
-	{
-		zfree(*it);
-	}	
-}
-
-void xSession::reset()
-{
-	 argc = 0;
-	 multibulklen = 0;
-	 bulklen = -1;
-	 robjs.clear();
-}
-
-int xSession::processInlineBuffer(xBuffer *recvBuf)
-{
-    const char *newline;
-    const char *queryBuf = recvBuf->peek();
-    int  j;
-    size_t queryLen;
-    sds *argv, aux;
-	  
-    /* Search for end of line */
-    newline = strchr(queryBuf,'\n');
-    if(newline == nullptr)
-    {
-    	 if(recvBuf->readableBytes() > PROTO_INLINE_MAX_SIZE)
-    	 {
-    	 	  addReplyError(sendBuf,"Protocol error: too big inline request");
-	        return REDIS_ERR;
-    	 }
-		 
-    }
-
-	if (newline && newline != queryBuf && *(newline-1) == '\r')
-	newline--;
-	  
-	queryLen = newline-(queryBuf);
-	aux = sdsnewlen(queryBuf,queryLen);
-	argv = sdssplitargs(aux,&argc);
-	sdsfree(aux);
-
-
-	recvBuf->retrieve(queryLen + 2);
-	  
-	if (argv == nullptr) 
-	{
-		addReplyError(sendBuf,"Protocol error: unbalanced quotes in request");
-		return REDIS_ERR;
-       }
-
-	for (j = 0; j  < argc; j++)
-	{
-		rObj * obj = (rObj*)createStringObject(argv[j],sdslen(argv[j]));
-		robjs.push_back(obj);
-		sdsfree(argv[j]);
-	}
-
-	zfree(argv);
-	return REDIS_OK;
-   
-}
-
-int xSession::processMultibulkBuffer(xBuffer *recvBuf)
-{
-	const char * newline = nullptr;
-	int pos = 0,ok;
-	long long ll = 0 ;
-	const char * queryBuf = recvBuf->peek();
-	if(multibulklen == 0)
-	{
-		newline = strchr(queryBuf,'\r');
-		if(newline == nullptr)
-		{
-			if(recvBuf->readableBytes() > REDIS_INLINE_MAX_SIZE)
-			{
-				addReplyError(sendBuf,"Protocol error: too big mbulk count string");
-				LOG_INFO<<"Protocol error: too big mbulk count string";
-			}
-			return REDIS_ERR;
-		}
-
-
-		  if (newline-(queryBuf) > ((signed)recvBuf->readableBytes()-2))
-		  {
-		  	 return REDIS_ERR;
-		  }
-     
-
-		if(queryBuf[0] != '*')
-		{
-			LOG_WARN<<"Protocol error: *";
-			return REDIS_ERR;
-		}
-
-		ok = string2ll(queryBuf + 1,newline - ( queryBuf + 1),&ll);
-		if(!ok || ll > 1024 * 1024)
-		{
-			addReplyError(sendBuf,"Protocol error: invalid multibulk length");
-			LOG_INFO<<"Protocol error: invalid multibulk length";
-			return REDIS_ERR;
-		}
-
-		pos = (newline - queryBuf) + 2;
-		if(ll <= 0)
-		{
-			recvBuf->retrieve(pos);
-			return REDIS_OK;
-		}
-
-		multibulklen = ll;
-
-	}
-	
-	while(multibulklen)
-	{
-		if(bulklen == -1)
-		{
-			newline = strchr(queryBuf + pos, '\r');
-			if(newline == nullptr)
-			{
-				if(recvBuf->readableBytes() > REDIS_INLINE_MAX_SIZE)
-				{
-
-					addReplyError(sendBuf,"Protocol error: too big bulk count string");
-					LOG_INFO<<"Protocol error: too big bulk count string";
-					return REDIS_ERR;
-				}
-			
-				break;
-			}
-
-			if( (newline - queryBuf) > ((signed)recvBuf->readableBytes() - 2))
-			{
-				break;
-			}
-
-			if(queryBuf[pos] != '$')
-			{
-
-				addReplyErrorFormat(sendBuf,"Protocol error: expected '$', got '%c'",queryBuf[pos]);
-				LOG_INFO<<"Protocol error: &";
-				return REDIS_ERR;
-			}
-
-
-			ok = string2ll(queryBuf + pos +  1,newline - (queryBuf + pos + 1),&ll);
-			if(!ok || ll < 0 || ll > 512 * 1024 * 1024)
-			{
-
-				addReplyError(sendBuf,"Protocol error: invalid bulk length");
-				LOG_INFO<<"Protocol error: invalid bulk length";
-				return REDIS_ERR;
-			}
-
-			pos += newline - (queryBuf + pos) + 2;
-			if(ll >= REDIS_MBULK_BIG_ARG)
-			{	
-				return REDIS_ERR;
-			}
-			bulklen = ll;
-		}
-
-		if(recvBuf->readableBytes() - pos < (bulklen + 2))
-		{
-			break;
-		}
-		else
-		{
-			rObj * obj = (rObj*)createStringObject(queryBuf + pos,bulklen);
-			robjs.push_back(obj);
-			pos += bulklen+2;
-			bulklen = -1;
-			multibulklen --;
-		}
-	}
-
-	
-	if(pos)
-	{
-		recvBuf->retrieve(pos);
-	}	
-	
-	if(multibulklen == 0)
-	{
-		return REDIS_OK;
-	}
-
-	return REDIS_ERR;
-}
-
-
-
diff --git a/src/xSession.h b/src/xSession.h
deleted file mode 100755
index 25667574..00000000
--- a/src/xSession.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xTcpconnection.h"
-#include "xObject.h"
-#include "xSds.h"
-
-
-class xSentinel;
-class xRedis;
-class xSession: noncopyable, public std::enable_shared_from_this<xSession>
-{
-public:
-	xSession(xRedis *redis,const xTcpconnectionPtr & conn);
-	~xSession();
-public:
-	 void resetVlaue();
-	 void clearObj();
-	 void reset();
-	 void readCallBack(const xTcpconnectionPtr& conn, xBuffer* recvBuf,void *data);
-	 int processMultibulkBuffer(xBuffer *recvBuf);
-	 int processInlineBuffer(xBuffer *recvBuf);
-	 int processCommand();
-	 bool checkCommond(rObj*  robjs);
-
-public:
-	int32_t 			reqtype;
-	int32_t 			multibulklen;
-	int64_t 			bulklen;
-	int32_t 		        argc;
-	xBuffer 			sendBuf;
-	xBuffer 			sendSlaveBuf;
-	xBuffer 			sendPubSub;
-	xTcpconnectionPtr 	conn;
-	std::vector<xTcpconnectionPtr> pubSubTcpconn;
-	std::deque<rObj*>  robjs;
-	std::string commond;
-	xRedis *redis;
-	bool authEnabled;
-	bool  retrieveBuffer;
-};
-
diff --git a/src/xSocket.cpp b/src/xSocket.cpp
deleted file mode 100644
index c9618fb4..00000000
--- a/src/xSocket.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#include "all.h"
-#include "xSocket.h"
-#include "xLog.h"
-
-
-xSocket::xSocket(xEventLoop *loop,std::string ip, int16_t port)
-:loop(loop),
- ip(ip),
- port(port)
-{
-	   listenSocketFd          = -1;
-	   onlineNumber            = 0;
-	   createTcpListenSocket();
-
-}
-
-xSocket::xSocket()
-{
-    listenSocketFd          = -1;
-    onlineNumber            = 0;
-}
-
-xSocket::~xSocket()
-{
-	 ::close(listenSocketFd);
-}
-
-
-int  xSocket::getListenFd()
-{
-	return listenSocketFd;
-
-}
-
-
-bool xSocket::getpeerName(int32_t fd,std::string *ip, int32_t &port)
-{
-	struct sockaddr_in sa;
-	socklen_t len = sizeof(sa);
-	if(!getpeername(fd, (struct sockaddr *)&sa, &len))
-	{
-		char * inIp = inet_ntoa(sa.sin_addr);
-		*ip = inIp;
-		port = ntohs(sa.sin_port);
-		return true;
-	}
-	else
-	{
-		return false;
-	}
-
-}
-
-
-int  xSocket::createNonBloackSocket()
-{
-	return socket(AF_INET, SOCK_STREAM, 0);
-}
-
-int xSocket::connect(int sockfd,std::string ip, int16_t port)
-{
-	struct sockaddr_in sin;
-	memset(&sin, 0, sizeof(sin));
-	sin.sin_family = AF_INET;
-	sin.sin_port = htons(port);
-	sin.sin_addr.s_addr = inet_addr(ip.c_str());
-
-	int ret = ::connect(sockfd, (struct sockaddr *)&sin, sizeof(sin));
-	return ret;
-}
-
-
-void  xSocket::setkeepAlive(int fd,int idle)
-{
-	int keepalive = 1;
-	int keepidle = idle;
-	int keepintvl = 2;
-	int keepcnt = 3;
-	int err = 0;
-
-	if(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&keepalive, sizeof(keepalive)) < 0)
-	{
-		LOG_DEBUG<<"SOL_SOCKET";
-	}
-
-	if(setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, (char *)&keepidle, sizeof(keepidle)) < 0)
-	{
-		LOG_DEBUG<<"TCP_KEEPIDLE";
-	}
-
-	if(setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL,(char *)&keepintvl, sizeof(keepintvl)) < 0)
-	{
-		LOG_DEBUG<<"TCP_KEEPINTVL";
-	}
-
-	if(setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT,(char *)&keepcnt, sizeof(keepcnt)) < 0)
-	{
-		LOG_DEBUG<<"TCP_KEEPCNT";
-	}
-}
-
-bool xSocket::createTcpListenSocket()
-{
-    struct sockaddr_in serverAdress;
-    serverAdress.sin_family = AF_INET;
-    serverAdress.sin_port   = htons(port);
-
-    if (ip.length() > 0 )
-    {
-        serverAdress.sin_addr.s_addr = inet_addr(ip.c_str());
-    }
-    else
-    {
-        serverAdress.sin_addr.s_addr = htonl(INADDR_ANY);
-    }
-
-    listenSocketFd = socket(AF_INET, SOCK_STREAM, 0);
-
-    if (listenSocketFd < 0)
-    {
-        LOG_WARN<<"Create Tcp Socket Failed! "<< strerror(errno);
-        return false;
-    }
-
-    if (!setSocketNonBlock(listenSocketFd))
-    {
-    	LOG_WARN<<"Set listen socket <%d> to non-block failed!";
-        return false;
-    }
-
-    int optval = 1;
-    if (setsockopt(listenSocketFd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0)
-    {
-    	LOG_WARN<<"Set listen socket<%d> failed! error "<<strerror(errno);
-        close(listenSocketFd);
-        return false;
-    }
-
-    if (bind(listenSocketFd, (struct sockaddr*)&serverAdress, sizeof(serverAdress)) < 0 )
-    {
-        LOG_WARN<<"Bind listen socket<%d> failed! error "<<strerror(errno);
-        close(listenSocketFd);
-        return false;
-    }
-
-    if (listen(listenSocketFd, SOMAXCONN))
-    {
-        LOG_WARN<<"Listen listen socket<%d> failed! error "<<strerror(errno);
-        close(listenSocketFd);
-        return false;
-    }
-
-    setsockopt(listenSocketFd, IPPROTO_TCP, TCP_NODELAY,&optval, static_cast<socklen_t>(sizeof optval));
-
-    int len = 65536;
-    setsockopt(listenSocketFd, SOL_SOCKET, SO_RCVBUF, (void*)&len, sizeof(len));
-    setsockopt(listenSocketFd, SOL_SOCKET, SO_SNDBUF, (void*)&len, sizeof(len));
-
-    return true;
-}
-
-bool xSocket::setSocketNonBlock(int socketFd)
-{
-    int opt = fcntl(socketFd, F_GETFL);
-    if (opt < 0)
-    {
-        LOG_WARN<<"fcntl F_GETFL) failed! error"<<strerror(errno);
-        return false;
-    }
-
-    opt = opt | O_NONBLOCK | O_NDELAY;
-    if (fcntl(socketFd, F_SETFL, opt) < 0)
-    {
-    	 LOG_WARN<<"fcntl F_GETFL) failed! error"<<strerror(errno);
-        return false;
-    }
-
-    return true;
-}
-
-
-
diff --git a/src/xSocket.h b/src/xSocket.h
deleted file mode 100644
index 0e181265..00000000
--- a/src/xSocket.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-#include "all.h"
-
-class xEventLoop;
-class xSocket: noncopyable
-{
-private:
-
-	xEventLoop		    *loop;
-	std::string				ip;
-	int16_t 				port;
-
-    int                     listenSocketFd;
-    int                     maxSocketFd;
-    int                     onlineNumber;
-    bool					 protocol;
-public:
-    typedef std::function<void (int sockfd,const std::string &ip, int16_t port)> NewConnectionCallback;
-	xSocket();
-	xSocket(xEventLoop *loop,std::string ip, int16_t port);
-	~xSocket();
-
-	bool getpeerName(int32_t fd,std::string *ip, int32_t &port);
-	int  createNonBloackSocket();
-	int  connect(int sockfd,std::string ip, int16_t port);
-
-    bool  initialize();
-    int   getListenFd();
-    void  setkeepAlive(int fd,int idle);
-    bool  createTcpListenSocket();
-    bool  setSocketNonBlock(int socketFd);
-
-};
-
diff --git a/src/xTcpClient.cpp b/src/xTcpClient.cpp
deleted file mode 100644
index 760d7fb6..00000000
--- a/src/xTcpClient.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include "xTcpClient.h"
-#include "xConnector.h"
-#include "xTcpconnection.h"
-
-xTcpClient::xTcpClient()
-{
-
-}
-
-xTcpClient::xTcpClient(xEventLoop *loop,void *data)
-: connector(new xConnector(loop)),
-loop(loop),
- isconnect(false),
- nextConnId(0),
- data(data)
-{
-	  connector->setNewConnectionCallback(std::bind(&xTcpClient::newConnection, this, std::placeholders::_1));
-	  connector->setConnectionErrorCallBack(std::bind(&xTcpClient::errorConnection,this));
-}
-
-
-namespace detail
-{
-
-	void removeConnection(xEventLoop* loop, const xTcpconnectionPtr& conn)
-	{
-	  loop->queueInLoop(std::bind(&xTcpconnection::connectDestroyed, conn));
-	}
-
-}
-xTcpClient::~xTcpClient()
-{
-	  xTcpconnectionPtr conn;
-	  bool unique = false;
-	  {
-		std::unique_lock<std::mutex> lk(mutex);
-		unique = connection.unique();
-		conn = connection;
-	  }
-
-	  if (conn)
-	  {
-	    assert(loop == conn->getLoop());
-	    CloseCallback cb = std::bind(&detail::removeConnection, loop, conn);
-	    loop->runInLoop(std::bind(&xTcpconnection::setCloseCallback, conn, cb));
-	    if (unique)
-	    {
-	      conn->forceClose();
-	    }
-	  }
-	  else
-	  {
-	    connector->stop();
-	  }
-}
-
-
-void xTcpClient::connect(const char *ip,int32_t port)
-{
-	 isconnect = true;
-	 connector->start(ip,port);
-}
-
-
-
-void xTcpClient::disconnect()
-{
-	isconnect = false;
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		if (connection)
-		{
-		  	connection->shutdown();
-		}
-	}
-}
-
-
-
-void xTcpClient::stop()
-{
-	isconnect = false;
-	connector->stop();
-}
-
-
-
-void xTcpClient::errorConnection()
-{
-	connectionErrorCallBack(data);
-}
-
-
-void xTcpClient::newConnection(int sockfd)
-{
-	  xTcpconnectionPtr conn(new xTcpconnection(loop,sockfd,data));
-	  conn->setConnectionCallback(connectionCallback);
-	  conn->setMessageCallback(messageCallback);
-	  conn->setWriteCompleteCallback(writeCompleteCallback);
-	  conn->setCloseCallback(std::bind(&xTcpClient::removeConnection, this,std::placeholders::_1));
-	  {
-		std::unique_lock<std::mutex> lk(mutex);
-	      connection = conn;
-	  }
-	  conn->connectEstablished();
-}
-
-
-void xTcpClient::removeConnection(const xTcpconnectionPtr& conn)
-{
-	loop->assertInLoopThread();
-	assert(loop == conn->getLoop());
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		assert(connection == conn);
-		connection.reset();
-	}
-
-	loop->queueInLoop(std::bind(&xTcpconnection::connectDestroyed, conn));
-	connectionErrorCallBack(data);
-}
diff --git a/src/xTcpClient.h b/src/xTcpClient.h
deleted file mode 100644
index 853047ad..00000000
--- a/src/xTcpClient.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include "all.h"
-#include "xEventLoop.h"
-#include "xCallback.h"
-
-
-class xTcpClient
-{
-public:
-	xTcpClient();
-	xTcpClient(xEventLoop *loop,void *data);
-	~xTcpClient();
-
-
-	void connect(const char * ip,int32_t port);
-	void disconnect();
-	void stop();
-
-	void setConnectionErrorCallBack(ConnectionErrorCallback &&cb) { connectionErrorCallBack = std::move(cb);}
-	void setConnectionCallback(ConnectionCallback&& cb) { connectionCallback = std::move(cb); }
-	void setMessageCallback(MessageCallback&&  cb){ messageCallback = std::move(cb); }
-	void setWriteCompleteCallback(WriteCompleteCallback&& cb) { writeCompleteCallback = std::move(cb); }
-
-
-public:
-
-	void errorConnection();
-	void newConnection(int sockfd);
-	void removeConnection(const xTcpconnectionPtr& conn);
-
-	xConnectorPtr connector;
-	xEventLoop *loop;
-
-
-	bool isconnect;
-	int nextConnId;
-	mutable std::mutex mutex;
-	ConnectionErrorCallback connectionErrorCallBack;
-	ConnectionCallback connectionCallback;
-	MessageCallback messageCallback;
-	WriteCompleteCallback writeCompleteCallback;
-
-	xTcpconnectionPtr connection;
-	void *data;
-
-
-};
diff --git a/src/xTcpServer.cpp b/src/xTcpServer.cpp
deleted file mode 100644
index f0115c46..00000000
--- a/src/xTcpServer.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "xTcpServer.h"
-#include "xTcpconnection.h"
-
-xTcpServer::xTcpServer()
-{
-
-}
-
-
-void xTcpServer::init(xEventLoop *loop,std::string ip,int16_t port,void *data)
-{
-	this->loop = loop;
-	this->data = data;
-	acceptor =  std::unique_ptr<xAcceptor>(new xAcceptor(loop,ip,port));
-	threadPool = std::shared_ptr<xThreadPool>(new xThreadPool(loop));
-	acceptor->setNewConnectionCallback(std::bind(&xTcpServer::newConnection,this,std::placeholders::_1));
-
-}
-
-xTcpServer::~xTcpServer()
-{
-	loop->assertInLoopThread();
-
-	for (ConnectionMap::iterator it(connections.begin());
-	  it != connections.end(); ++it)
-	{
-		xTcpconnectionPtr conn = it->second;
-		it->second.reset();
-		conn->getLoop()->runInLoop(
-		  std::bind(&xTcpconnection::connectDestroyed, conn));
-		conn.reset();
-	}
-}
-
-
-void xTcpServer::newConnection(int sockfd)
-{
-	loop->assertInLoopThread();
-	xEventLoop* loop = threadPool->getNextLoop();
-	//TRACE("newConnection is thread: %d",loop->getThreadId());
-	xTcpconnectionPtr conn(new xTcpconnection(loop,sockfd,data));
-	connections[sockfd] = conn;
-	conn->setConnectionCallback(connectionCallback);
-	conn->setMessageCallback(messageCallback);
-	conn->setWriteCompleteCallback(writeCompleteCallback);
-	conn->setCloseCallback(std::bind(&xTcpServer::removeConnection, this, std::placeholders::_1)); // FIXME: unsafe
-	loop->runInLoop(std::bind(&xTcpconnection::connectEstablished, conn));
-}
-
-
-void xTcpServer::setData(void *data)
-{
-	this->data = data;
-}
-
-void xTcpServer::setThreadNum(int numThreads)
-{
-	threadPool->setThreadNum(numThreads);
-}
-
-void xTcpServer::start()
-{
-	threadPool->start(threadInitCallback);
-	acceptor->listen();
-
-
-}
-
-void xTcpServer::removeConnection(const xTcpconnectionPtr& conn)
-{
-	loop->runInLoop(std::bind(&xTcpServer::removeConnectionInLoop, this, conn));
-}
-	  /// Not thread safe, but in loop
-void xTcpServer::removeConnectionInLoop(const xTcpconnectionPtr& conn)
-{
-	loop->assertInLoopThread();
-	size_t n = connections.erase(conn->getSockfd());
-	(void)n;
-	assert(n == 1);
-	xEventLoop* ioLoop = conn->getLoop();
-	ioLoop->queueInLoop(
-	std::bind(&xTcpconnection::connectDestroyed, conn));
-
-
-}
diff --git a/src/xTcpServer.h b/src/xTcpServer.h
deleted file mode 100644
index 50c419a1..00000000
--- a/src/xTcpServer.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include "xAcceptor.h"
-#include "xThreadPool.h"
-#include "xCallback.h"
-
-class xEventLoop;
-
-class xTcpServer
-{
-public:
-	typedef std::function<void(xEventLoop*)> ThreadInitCallback;
-	xTcpServer();
-	~xTcpServer();
-
-
-	void init(xEventLoop *loop,std::string ip,int16_t port,void *data);
-	void newConnection(int sockfd);
-	void start();
-
-	void removeConnection(const xTcpconnectionPtr& conn);
-	void removeConnectionInLoop(const xTcpconnectionPtr& conn);
-	void setThreadInitCallback(const ThreadInitCallback& cb){ threadInitCallback= cb; }
-	void setConnectionCallback(const ConnectionCallback& cb){ connectionCallback = cb; }
-	void setMessageCallback(const MessageCallback& cb){ messageCallback = cb; }
-	void setWriteCompleteCallback(const WriteCompleteCallback& cb){ writeCompleteCallback = cb; }
-	void setThreadNum(int numThreads);
-	void setData(void *data);
-	xEventLoop *getLoop() const { return loop; }
-
-private:
-	xEventLoop* loop;
-	std::unique_ptr<xAcceptor> 		acceptor;
-	std::shared_ptr<xThreadPool> 	threadPool;
-
-
-	ConnectionCallback connectionCallback;
-	MessageCallback messageCallback;
-	WriteCompleteCallback writeCompleteCallback;
-	ThreadInitCallback threadInitCallback;
-
-
-	typedef std::unordered_map<int, xTcpconnectionPtr> ConnectionMap;
-	ConnectionMap connections;
-	void *data;
-
-};
diff --git a/src/xTcpconnection.cpp b/src/xTcpconnection.cpp
deleted file mode 100644
index 4e202417..00000000
--- a/src/xTcpconnection.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-#include "all.h"
-#include "xEventLoop.h"
-#include "xTcpconnection.h"
-
-xTcpconnection::xTcpconnection(xEventLoop *loop,int sockfd,void *data)
-:loop(loop),
- sockfd(sockfd),
- state(kConnecting),
- channel(new xChannel(loop,sockfd)),
- data(data)
-{
-	channel->setReadCallback(
-	  std::bind(&xTcpconnection::handleRead, this));
-	channel->setWriteCallback(
-	  std::bind(&xTcpconnection::handleWrite, this));
-	channel->setCloseCallback(
-	  std::bind(&xTcpconnection::handleClose, this));
-	channel->setErrorCallback(
-	  std::bind(&xTcpconnection::handleError, this));
-}
-
-xTcpconnection::~xTcpconnection()
-{
-	assert(state == kDisconnected);
-	::close(sockfd);
-}
-
-
-void xTcpconnection::setData(void *data)
-{
-	this->data = data;
-}
-void xTcpconnection::shutdown()
-{
-  if (state == kConnected)
-  {
-    setState(kDisconnecting);
-    loop->runInLoop(std::bind(&xTcpconnection::shutdownInLoop, this));
-  }
-}
-
-
-void xTcpconnection::forceClose()
-{
-	  if (state == kConnected || state == kDisconnecting)
-	  {
-	    setState(kDisconnecting);
-	    loop->queueInLoop(std::bind(&xTcpconnection::forceCloseInLoop, shared_from_this()));
-	  }
-}
-
-
-void xTcpconnection::forceCloseInLoop()
-{
-  loop->assertInLoopThread();
-  if (state== kConnected   ||  state == kDisconnecting)
-  {
-    // as if we received 0 byte in handleRead();
-    handleClose();
-  }
-}
-
-void xTcpconnection::shutdownInLoop()
-{
-  loop->assertInLoopThread();
-  if (!channel->isWriting())
-  {
-	if (::shutdown(sockfd, SHUT_WR) < 0)
-	{
-		//TRACE_ERR("sockets::shutdownWrite");
-	}
-  }
-}
-
-void xTcpconnection::handleRead()
-{
-	loop->assertInLoopThread();
-	int savedErrno = 0;
-	ssize_t n = recvBuff.readFd(channel->getfd(), &savedErrno);
-	if (n > 0)
-	{
-		messageCallback(shared_from_this(), &recvBuff,data);
-	}
-	else if (n == 0)
-	{
-		handleClose();
-	}
-	else
-	{
-		errno = savedErrno;
-		if(errno != ECONNRESET || errno !=  ETIMEDOUT)
-		{
-			//TRACE("TcpConnection::handleRead %d\n",errno);
-		}
-		//handleError();
-	}
-}
-
-void xTcpconnection::handleWrite()
-{
-	loop->assertInLoopThread();
-	if (channel->isWriting())
-	{
-		ssize_t n = ::write(channel->getfd(),sendBuff.peek(),sendBuff.readableBytes());
-		if (n > 0)
-		{
-			sendBuff.retrieve(n);
-			if (sendBuff.readableBytes() == 0)
-			{
-				channel->disableWriting();
-				if (writeCompleteCallback)
-				{
-				  loop->queueInLoop(std::bind(writeCompleteCallback, shared_from_this()));
-				}
-				if (state == kDisconnecting)
-				{
-				  shutdownInLoop();
-				}
-			}
-		}
-		else
-		{
-		  //TRACE_ERR("TcpConnection::handleWrite");
-
-		}
-
-	}
-	else
-	{
-		//TRACE("Connection fd = %d  is down, no more writing ",channel->getfd());
-	}
-}
-void xTcpconnection::handleClose()
-{
-	loop->assertInLoopThread();
-	//TRACE("handle close fd: %d",channel->getfd());
-	assert(state == kConnected || state == kDisconnecting);
-	setState(kDisconnected);
-	channel->disableAll();
-	xTcpconnectionPtr guardThis(shared_from_this());
-	connectionCallback(guardThis,data);
-	closeCallback(guardThis);
-}
-void xTcpconnection::handleError()
-{
-	//TRACE("handleError");
-}
-
-
-bool xTcpconnection::connected()
-{
-	return state == kConnected;
-}
-
-xEventLoop *xTcpconnection::getLoop()
-{
-	return loop;
-}
-
-int xTcpconnection::getSockfd()
-{
-	return sockfd;
-}
-
-
-//void xTcpconnection::send(std::string&& message)
-//{
-//	 if (state == kConnected)
-//	  {
-//	    if (loop->isInLoopThread())
-//	    {
-//	      sendInLoop(message);
-//	    }
-//	    else
-//	    {
-//	      loop->runInLoop(
-//	          boost::bind(&xTcpconnection::sendInLoop,
-//	                      this,
-//						  std::move(message)));
-//	    }
-//	  }
-//}
-
-
-
-void xTcpconnection::send(const stringPiepe & message)
-{
-	if (state == kConnected)
-	{
-		if (loop->isInLoopThread())
-		{
-		  sendInLoop(message.str,message.len);
-		}
-		else
-		{
-		  loop->runInLoop(
-				  std::bind(&bindSendInLoop,
-						  this, message.as_string()));
-		}
-	}
-}
-
-
-void xTcpconnection::bindSendInLoop(xTcpconnection* conn, const stringPiepe& message)
-{
-	 conn->sendInLoop(message.str, message.len);
-}
-
-void xTcpconnection::send(xBuffer* buf)
-{
-  if (state == kConnected)
-  {
-    if (loop->isInLoopThread())
-    {
-      sendInLoop(buf->peek(), buf->readableBytes());
-    }
-    else
-    {
-      loop->runInLoop(
-          std::bind(&bindSendInLoop,
-                      this, buf->retrieveAllAsString()));
-    }
-  }
-}
-
-void xTcpconnection::sendInLoop(const stringPiepe & message)
-{
-	sendInLoop(message.str,message.len);
-}
-
-//void xTcpconnection::sendInLoop(std::string & message)
-//{
-//	sendInLoop(message.data(),message.size());
-//}
-
-void xTcpconnection::sendInLoop(const void* data, size_t len)
-{
-  loop->assertInLoopThread();
-  ssize_t nwrote = 0;
-  size_t remaining = len;
-  bool faultError = false;
-  if (state == kDisconnected)
-  {
-    //TRACE("disconnected, give up writing");
-    return;
-  }
-  // if no thing in output queue, try writing directly
-  if (!channel->isWriting() && sendBuff.readableBytes() == 0)
-  {
-    nwrote = ::write(channel->getfd(), data, len);
-    if (nwrote >= 0)
-    {
-      remaining = len - nwrote;
-      if (remaining == 0 && writeCompleteCallback)
-      {
-        loop->queueInLoop(std::bind(writeCompleteCallback, shared_from_this()));
-      }
-    }
-    else // nwrote < 0
-    {
-      nwrote = 0;
-      if (errno != EWOULDBLOCK)
-      {
-        //TRACE_ERR("TcpConnection::sendInLoop");
-        if (errno == EPIPE || errno == ECONNRESET) // FIXME: any others?
-        {
-          faultError = true;
-        }
-      }
-    }
-  }
-
-  assert(remaining <= len);
-  if (!faultError && remaining > 0)
-  {
-    size_t oldLen = sendBuff.readableBytes();
-    if (oldLen + remaining >= highWaterMark
-        && oldLen < highWaterMark
-        && highWaterMarkCallback)
-    {
-      loop->queueInLoop(std::bind(highWaterMarkCallback, shared_from_this(), oldLen + remaining));
-    }
-    sendBuff.append(static_cast<const char*>(data)+nwrote, remaining);
-    if (!channel->isWriting())
-    {
-      channel->enableWriting();
-    }
-  }
-}
-
-void xTcpconnection::connectEstablished()
-{
-	loop->assertInLoopThread();
-	assert(state == kConnecting);
-	setState(kConnected);
-	channel->setTie(shared_from_this());
-	channel->enableReading();
-	connectionCallback(shared_from_this(),data);
-}
-
-
-void xTcpconnection::connectDestroyed()
-{
-	loop->assertInLoopThread();
-	if (state == kConnected)
-	{
-		setState(kDisconnected);
-		channel->disableAll();
-
-		connectionCallback(shared_from_this(),data);
-	}
-	channel->remove();
-}
-
-
diff --git a/src/xTcpconnection.h b/src/xTcpconnection.h
deleted file mode 100644
index eeaf0dc1..00000000
--- a/src/xTcpconnection.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#pragma once
-
-#include "all.h"
-#include "xBuffer.h"
-#include "xCallback.h"
-#include "xChannel.h"
-
-class xEventLoop;
-class xTcpconnection:noncopyable,public std::enable_shared_from_this<xTcpconnection>
-{
-public:
-	enum StateE { kDisconnected, kConnecting, kConnected, kDisconnecting };
-	xTcpconnection(xEventLoop *loop,int sockfd,void *data);
-	~xTcpconnection();
-
-	xEventLoop			*getLoop();
-	int 				getSockfd();
-
-
-	void setState(StateE s) { state  = s; }
-
-	void setConnectionCallback(const ConnectionCallback& cb)
-	{ connectionCallback = cb; }
-
-	void setMessageCallback(const MessageCallback& cb)
-	{ messageCallback = cb; }
-
-	void setWriteCompleteCallback(const WriteCompleteCallback& cb)
-	{ writeCompleteCallback = cb; }
-
-	void setHighWaterMarkCallback(const HighWaterMarkCallback& cb, size_t highWaterMark)
-	{ highWaterMarkCallback = cb; this->highWaterMark  = highWaterMark; }
-
-	void setCloseCallback(const CloseCallback& cb)
-	{ closeCallback = cb; }
-
-	void handleRead();
-	void handleWrite();
-	void handleClose();
-	void handleError();
-
-	void sendInLoop(const void* message, size_t len);
-	void sendInLoop(const stringPiepe & message);
-
-	static void bindSendInLoop(xTcpconnection* conn, const stringPiepe& message);
-
-    //void sendInLoop(std::string & message);
-	void send(xBuffer* message);
-	//void send(std::string && message);
-	void send(const stringPiepe  &message);
-
-	bool disconnected() const { return state == kDisconnected; }
-	bool connected();
-	void forceCloseInLoop();
-	void connectEstablished();
-	const void *getContext()const{ return context;}
-	void setContext(void * context) { this->context = context;}
-	void connectDestroyed();
-	void setData(void *data);
-	void * getData() {return data;}
-	void shutdown();
-	void shutdownInLoop();
-	void forceClose();
-	xBuffer * getSendBuff(){ return &sendBuff; }
-	
-public:
-	xEventLoop 			  *loop;
-	int 				  sockfd;
-	xBuffer               recvBuff;
-	xBuffer               sendBuff;
-	ConnectionCallback    connectionCallback;
-	MessageCallback 	  messageCallback;
-	WriteCompleteCallback writeCompleteCallback;
-	HighWaterMarkCallback highWaterMarkCallback;
-	CloseCallback 		  closeCallback;
-
-	size_t 				      highWaterMark;
-	StateE 				  state;
-	std::shared_ptr<xChannel> channel;
-	void 				*data;
-	void 				*context;
-	std::string			host;
-	int32_t 			port;
-
-};
diff --git a/src/xThread.cpp b/src/xThread.cpp
deleted file mode 100644
index 461defb5..00000000
--- a/src/xThread.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "xThread.h"
-#include "xCurrentThread.h"
-#include "xEventLoop.h"
-
-namespace xCurrentThread
-{
-
-	__thread int t_cachedTid = 0;
-	void cacheTid()
-	{
-		if (t_cachedTid == 0)
-		{
-			t_cachedTid =  static_cast<pid_t>(::syscall(SYS_gettid));
-		}
-	}
-}
-
-
-
-xThread::xThread(const ThreadInitCallback& cb)
-:loop(nullptr),
- exiting(false),
- callback(cb)
-{
-
-}
-
-
-xThread::~xThread()
-{
-	delete xthread;
-}
-
-
-xEventLoop *xThread::startLoop()
-{
-	xthread = new std::thread(std::bind(&xThread::threadFunc,this));
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		while (loop == nullptr)
-		{
-			condition.wait(lk);
-		}
-
-	}
-	return loop;
-
-}
-
-void xThread::threadFunc()
-{
-	xEventLoop xloop;
-
-	if (callback)
-	{
-		callback(&xloop);
-	}
-
-	{
-		std::unique_lock<std::mutex> lk(mutex);
-		loop = &xloop;
-		condition.notify_one();
-	}
-
-	xloop.run();
-	loop = nullptr;
-}
diff --git a/src/xThread.h b/src/xThread.h
deleted file mode 100644
index a3c7f492..00000000
--- a/src/xThread.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "all.h"
-
-class xEventLoop;
-
-class xThread: noncopyable
-{
-public:
-	typedef std::function<void(xEventLoop*)> ThreadInitCallback;
-
-	xThread(const ThreadInitCallback& cb = ThreadInitCallback());
-	~xThread();
-
-	xEventLoop *startLoop();
-
-private:
-	void threadFunc();
-	xEventLoop *loop;
-	bool exiting;
-	std::thread * xthread;
-	mutable std::mutex mutex;
-	std::condition_variable condition;
-	ThreadInitCallback callback;
-};
diff --git a/src/xThreadPool.cpp b/src/xThreadPool.cpp
deleted file mode 100644
index 53f320f5..00000000
--- a/src/xThreadPool.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "xThreadPool.h"
-#include "xEventLoop.h"
-#include "xThread.h"
-
-xThreadPool::xThreadPool(xEventLoop *baseLoop)
-:baseLoop(baseLoop),
- started(false),
- numThreads(0),
- next(0)
-{
-
-}
-xThreadPool::~xThreadPool()
-{
-	threads.clear();
-}
-
-void xThreadPool::start(const ThreadInitCallback& cb)
-{
-	assert(!started);
-	baseLoop->assertInLoopThread();
-
-	started = true;
-
-	for(int i = 0 ; i < numThreads; i++)
-	{
-		std::shared_ptr<xThread>  t( new xThread(cb));
-		threads.push_back(t);
-		loops.push_back(t->startLoop());
-	}
-
-	if(numThreads == 0 && cb)
-	{
-		cb(baseLoop);
-	}
-
-
-}
-
-
-xEventLoop* xThreadPool::getNextLoop()
-{
-	baseLoop->assertInLoopThread();
-	assert(started);
-	xEventLoop* loop = baseLoop;
-
-	if (!loops.empty())
-	{
-		// round-robin
-		loop = loops[next];
-		++next;
-		if (next >= loops.size())
-		{
-		  next = 0;
-		}
-	}
-	return loop;
-
-}
-
-xEventLoop* xThreadPool::getLoopForHash(size_t hashCode)
-{
-	baseLoop->assertInLoopThread();
-	xEventLoop* loop = baseLoop;
-
-	if (!loops.empty())
-	{
-		loop = loops[hashCode % loops.size()];
-	}
-	return loop;
-}
-
-std::vector<xEventLoop*> xThreadPool::getAllLoops()
-{
-	baseLoop->assertInLoopThread();
-	assert(started);
-	if (loops.empty())
-	{
-		return std::vector<xEventLoop*>(1, baseLoop);
-	}
-	else
-	{
-		return loops;
-	}
-}
-
diff --git a/src/xThreadPool.h b/src/xThreadPool.h
deleted file mode 100644
index 4843c181..00000000
--- a/src/xThreadPool.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-#include "all.h"
-
-class xThread;
-class xEventLoop;
-
-class xThreadPool :noncopyable
-{
-public:
-	typedef std::function<void(xEventLoop*)> ThreadInitCallback;
-	xThreadPool(xEventLoop *baseLoop);
-	~xThreadPool();
-
-	void setThreadNum(int numThreads) { this->numThreads = numThreads; }
-	void start(const ThreadInitCallback& cb = ThreadInitCallback());
-
-	xEventLoop* getNextLoop();
-	xEventLoop* getLoopForHash(size_t hashCode);
-	std::vector<xEventLoop*> getAllLoops();
-	bool getStarted() const { return started; }
-
-
-private:
-	xEventLoop * baseLoop;
-	bool  		 started;
-	int 		 numThreads;
-	int			 next;
-
-	std::vector<std::shared_ptr<xThread>>    threads;
-	std::vector<xEventLoop*> loops;
-
-
-};
diff --git a/src/xTimer.cpp b/src/xTimer.cpp
deleted file mode 100644
index 92b063c9..00000000
--- a/src/xTimer.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "xTimer.h"
-
-xTimer::xTimer(xTimerCallback && cb, xTimestamp && expiration,bool	repeat,double interval,void * data)
-:index(-1),
- repeat(repeat),
- interval(interval),
- expiration(std::move(expiration)),
-callback(std::move(cb)),
-data(data)
-{
-	
-}
-
-
-xTimer::~xTimer()
-{
-
-}
-
-
-void xTimer::run()
-{
-	if(callback)
-	{
-		callback(data);
-	}
-	
-	
-}
-
-
-void xTimer::restart(xTimestamp now)
-{
-  if (repeat)
-  {
-    expiration = addTime(now, interval);
-  }
-  else
-  {
-    expiration = xTimestamp::invalid();
-  }
-}
-
-
-
diff --git a/src/xTimer.h b/src/xTimer.h
deleted file mode 100644
index 3f4f20bc..00000000
--- a/src/xTimer.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-#include "all.h"
-#include "xZmalloc.h"
-#include "xCallback.h"
-
-class xTimestamp
-{
-public:
-	xTimestamp()
-	: microSecondsSinceEpoch(0)
-	{
-	}
-
-	explicit xTimestamp(int64_t microSecondsSinceEpochArg)
-	: microSecondsSinceEpoch(microSecondsSinceEpochArg)
-	{
-	}
-
-	int64_t getMicroSecondsSinceEpoch() const { return microSecondsSinceEpoch; }
-	time_t secondsSinceEpoch() const
-	{ return static_cast<time_t>(microSecondsSinceEpoch / kMicroSecondsPerSecond); }
-
-	static xTimestamp now()
-	{
-		struct timeval tv;
-		gettimeofday(&tv, NULL);
-		int64_t seconds = tv.tv_sec;
-		return xTimestamp(seconds * kMicroSecondsPerSecond + tv.tv_usec);
-	}
-
-	  static xTimestamp invalid()
-	  {
-	    return xTimestamp();
-	  }
-
-	static const int kMicroSecondsPerSecond = 1000 * 1000;
-private:
-	int64_t microSecondsSinceEpoch;
-};
-
-inline xTimestamp addTime(xTimestamp timestamp, double seconds)
-{
-  int64_t delta = static_cast<int64_t>(seconds * xTimestamp::kMicroSecondsPerSecond);
-  return xTimestamp(timestamp.getMicroSecondsSinceEpoch() + delta);
-}
-
-class xTimer
-{
-public:
-	xTimer() {}
-	xTimer(xTimerCallback && cb, xTimestamp && expiration,bool	repeat,double interval,void * data);
-	xTimestamp getExpiration() const  { return expiration;}
-	int64_t getWhen() { return expiration.getMicroSecondsSinceEpoch(); };
-	void restart(xTimestamp now);
-	~xTimer();
-	void run();
-public:	
-	int32_t index;
-	bool	repeat;
-	double interval;
-	xTimestamp expiration;
-	xTimerCallback callback;
-	void * data = nullptr;
-};
-
-
-
diff --git a/src/xTimerQueue.cpp b/src/xTimerQueue.cpp
deleted file mode 100644
index 06ed895b..00000000
--- a/src/xTimerQueue.cpp
+++ /dev/null
@@ -1,316 +0,0 @@
-#include "xTimerQueue.h"
-#include "xEventLoop.h"
-#include "xTimer.h"
-
-xPriorityQueue::xPriorityQueue()
-{
-	p = nullptr;
-	n = 0;
-	a = 0;
-}
-
-
-void xPriorityQueue::dtor()
-{
-	if(p)
-	{
-		for(int i = 0 ; i < a; i ++)
-		{
-			if(p[i] == nullptr)
-			{
-				continue;
-			}
-			zfree(p[i]);
-		}
-		zfree(p);
-	}
-}
-xPriorityQueue::~xPriorityQueue()
-{
-	dtor();
-}
-
-
-bool xPriorityQueue::push(xTimer *e)
-{
-	if(a < n + 1)
-	{
-		reserve();
-	}
-
-	shiftUp(n++, e);
-	return true;
-}
-xTimer *xPriorityQueue::pop()
-{
-	if (n)
-	{
-		xTimer *e = *p;
-		shiftDown(0, p[--n]);
-		*(int *)e = -1;
-		return e;
-	}
-	return nullptr;
-}
-
-
-int  xPriorityQueue::size()
-{
-	return n;
-}
-
-bool   xPriorityQueue::erase(xTimer *e)
-{
-	if (-1 != *(int *)e)
-	{
-		xTimer *last = p[--n];
-		int parent = (*(int *)e - 1) / 2;
-		if (*(int *)e > 0 && (p[parent]->getWhen()  >  last->getWhen()) > 0)
-			shiftUp(*(int *)e, last);
-		else
-			shiftDown(*(int *)e, last);
-		*(int *)e = -1;
-		return 0;
-	}
-	return -1;
-}
-xTimer *xPriorityQueue::head()
-{
-	return p[0];
-}
-
-void xPriorityQueue::clear()
-{
-	p = 0;
-	n = 0;
-	a = 0;
-}
-
-xTimer *xPriorityQueue::top()
-{
-	return n?*p:nullptr;
-}
-
-void  xPriorityQueue::reserve()
-{
-	int aa = a ? a * 2:8;
-	xTimer **pp = (xTimer**)zrealloc(p,aa * sizeof * pp);
-
-	a = aa;
-	p = pp;
-
-}
-
-
-void xPriorityQueue::shiftUp(int hole_index, xTimer *e)
-{
-	int parent = (hole_index - 1) / 2;
-	while (hole_index && ((p[parent])->getWhen() >  e->getWhen()) > 0)
-	{
-		*(int *)(p[hole_index] = p[parent]) = hole_index;
-		hole_index = parent;
-		parent = (hole_index - 1) / 2;
-	}
-	*(int *)(p[hole_index] = e) = hole_index;
-}
-
-
-void xPriorityQueue::shiftDown(int hole_index, xTimer *e)
-{
-	int min_child = 2 * (hole_index + 1);
-	while (min_child <= n)
-	{
-		min_child -= min_child == n || (p[min_child]->getWhen()  >  p[min_child - 1]->getWhen()) > 0;
-		if (!((e->getWhen() >  p[min_child]->getWhen() ) > 0))
-			break;
-		*(int *)(p[hole_index] = p[min_child]) = hole_index;
-		hole_index = min_child;
-		min_child = 2 * (hole_index + 1);
-	}
-	*(int *)(p[hole_index] = e) = hole_index;
-}
-
-
-
-int createTimerfd()
-{
-  int timerfd = ::timerfd_create(CLOCK_MONOTONIC,
-                                 TFD_NONBLOCK | TFD_CLOEXEC);
-  if (timerfd < 0)
-  {	
-  	assert(false);
-  }
-  return timerfd;
-}
-
-struct timespec howMuchTimeFromNow(xTimestamp when)
-{
-	int64_t  microseconds = when.getMicroSecondsSinceEpoch()
-						 - xTimestamp::now().getMicroSecondsSinceEpoch();
-	if (microseconds < 100)
-	{
-		microseconds = 100;
-	}
-
-	struct timespec ts;
-	ts.tv_sec = static_cast<time_t>(
-	  microseconds / xTimestamp::kMicroSecondsPerSecond);
-	ts.tv_nsec = static_cast<long>(
-	  (microseconds % xTimestamp::kMicroSecondsPerSecond) * 1000);
-	return ts;
-}
-
-
-
-
-
-void resetTimerfd(int timerfd, xTimestamp expiration)
-{
-	struct itimerspec newValue;
-	struct itimerspec oldValue;
-	bzero(&newValue, sizeof newValue);
-	bzero(&oldValue, sizeof oldValue);
-	newValue.it_value = howMuchTimeFromNow(expiration);
-	int net = ::timerfd_settime(timerfd, 0, &newValue, &oldValue);
-	if(net < 0 )
-	{
-		assert(false);
-	}
-  
-}
-
-
-
-
-void readTimerfd(int timerfd,xTimestamp now)
-{
-  uint64_t howmany;
-  ssize_t n = ::read(timerfd, &howmany, sizeof howmany);
-  if (n != sizeof howmany)
-  {
-    assert(false);
-  }
-}
-
-
-xTimerQueue::xTimerQueue(xEventLoop *loop)
-:loop(loop),
-timerfd(createTimerfd()),
-timerfdChannel(loop,timerfd)
-{
-	timerfdChannel.setReadCallback(std::bind(&xTimerQueue::handleRead, this));
-	timerfdChannel.enableReading();
-}
-
-
-xTimerQueue::~xTimerQueue()
-{
-	timerfdChannel.disableAll();
-	timerfdChannel.remove();
-	::close(timerfd);
-}
-
-xTimer  * xTimerQueue::addTimer(double when, void * data,bool repeat,xTimerCallback&& cb)
-{
-	xTimestamp time(addTime(xTimestamp::now(), when));
-	xTimer * timer = (xTimer*)zmalloc(sizeof(xTimer));
-	new(timer)xTimer(std::move(cb), std::move(time), repeat, when, data);
-	//xTimer * timer = new xTimer(std::move(cb),std::move(time),repeat,when,data);
-	loop->runInLoop(std::bind(&xTimerQueue::addTimerInLoop,this,timer));
-	return timer;
-}
-
-void xTimerQueue::cancelTimer(xTimer *timer)
-{
-	loop->runInLoop(std::bind(&xTimerQueue::cancelInloop,this,timer));
-}
-
-void xTimerQueue::cancelInloop(xTimer *timer)
-{
-	if(pqueue.size() == 0 )
-	{
-		return ;
-	}
-
-	pqueue.erase(timer);
-	timer->~xTimer();
-	zfree(timer);
-	if (pqueue.size() > 1)
-	{
-		resetTimerfd(timerfd, pqueue.head()->getExpiration());
-	}
-	
-}
-
-
-void   xTimerQueue::addTimerInLoop(xTimer* timer)
-{
-	bool earliestChanged = false;
-	loop->assertInLoopThread();
-	if(pqueue.size() == 0 )
-	{
-		 earliestChanged = true;
-	}
-	else
-	{
-		if(timer->getWhen() < pqueue.head()->getWhen())
-		{
-			earliestChanged = true;
-		}
-	}
-
-	pqueue.push(timer);
-
-	if(earliestChanged)
-	{
-		resetTimerfd(timerfd,timer->getExpiration());
-	}
-
-}
-
-void  xTimerQueue::handleRead()
-{
-	loop->assertInLoopThread();
-	xTimestamp now(xTimestamp::now());
-	readTimerfd(timerfd,now);
-	std::vector<xTimer *> vectors;
-	while(pqueue.size() > 0 )
-	{
-		if(now.getMicroSecondsSinceEpoch() >= pqueue.head()->getWhen())
-		{
-			xTimer *timer = pqueue.pop();
-			if(timer == nullptr)
-			{
-				assert(false);
-			}
-
-			timer->run();
-			vectors.push_back(timer);
-		}
-		else
-		{
-			resetTimerfd(timerfd,pqueue.head()->getExpiration());
-			break;
-		}
-	}
-	
-
-	for(auto it = vectors.begin(); it != vectors.end(); it ++)
-	{
-		if( (*it)->repeat)
-		{
-			(*it)->restart(now);
-			resetTimerfd(timerfd, now);
-			pqueue.push(*it);
-		}
-		else
-		{
-			(*it)->~xTimer();
-			zfree(*it);
-			*it = nullptr;
-		}
-	}
-
-
-}
-
diff --git a/src/xTimerQueue.h b/src/xTimerQueue.h
deleted file mode 100644
index a78562ed..00000000
--- a/src/xTimerQueue.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "all.h"
-#include "xChannel.h"
-#include "xCallback.h"
-#include "xTimer.h"
-class xEventLoop;
-class xTimerId;
-
-class xPriorityQueue
-{
-public:
-	xPriorityQueue();
-	~xPriorityQueue();
-	void dtor();
-	bool push(xTimer *e);
-	xTimer *pop();
-	bool  erase(xTimer *e);
-	int   size();
-	xTimer *head();
-	void clear();
-	xTimer *top();
-	void reserve();
-	void shiftUp(int hole_index, xTimer *e);
-	void shiftDown(int hole_index, xTimer *e);
-
-	xTimer **p;
-	int n,a;
-};
-
-class xTimerQueue
-{
-public:
-	xTimerQueue(xEventLoop *loop);
-	~xTimerQueue();
-	void handleRead();
-	void cancelTimer(xTimer *timer);
-	void cancelInloop(xTimer *timer);
-	void addTimerInLoop(xTimer* timer);
-  	xTimer  *addTimer(double  when,void * data,bool repeat,xTimerCallback&& cb);
-
-  	static const int kMicroSecondsPerSecond = 1000 * 1000;
-private:
-	xEventLoop *loop;
-	xPriorityQueue pqueue;
-	const int timerfd;
-	xChannel timerfdChannel;
-
-};
diff --git a/src/xZmalloc.cpp b/src/xZmalloc.cpp
deleted file mode 100644
index 76eca7d7..00000000
--- a/src/xZmalloc.cpp
+++ /dev/null
@@ -1,389 +0,0 @@
-#include "xZmalloc.h"
-/* This function provide us access to the original libc free(). This is useful
- * for instance to free results obtained by backtrace_symbols(). We need
- * to define this function before including zmalloc.h that may shadow the
- * free implementation if we use jemalloc or another non standard allocator. */
-void zlibc_free(void *ptr) {
-    free(ptr);
-}
-
-
-
-#ifdef HAVE_MALLOC_SIZE
-#define PREFIX_SIZE (0)
-#else
-#if defined(__sun) || defined(__sparc) || defined(__sparc__)
-#define PREFIX_SIZE (sizeof(long long))
-#else
-#define PREFIX_SIZE (sizeof(size_t))
-#endif
-#endif
-
-/* Explicitly override malloc/free etc when using tcmalloc. */
-#if defined(USE_TCMALLOC)
-#define malloc(size) tc_malloc(size)
-#define calloc(count,size) tc_calloc(count,size)
-#define realloc(ptr,size) tc_realloc(ptr,size)
-#define free(ptr) tc_free(ptr)
-#elif defined(USE_JEMALLOC)
-#define malloc(size) je_malloc(size)
-#define calloc(count,size) je_calloc(count,size)
-#define realloc(ptr,size) je_realloc(ptr,size)
-#define free(ptr) je_free(ptr)
-#endif
-
-#if defined(__ATOMIC_RELAXED)
-#define update_zmalloc_stat_add(__n) __atomic_add_fetch(&used_memory, (__n), __ATOMIC_RELAXED)
-#define update_zmalloc_stat_sub(__n) __atomic_sub_fetch(&used_memory, (__n), __ATOMIC_RELAXED)
-#elif defined(HAVE_ATOMIC)
-#define update_zmalloc_stat_add(__n) __sync_add_and_fetch(&used_memory, (__n))
-#define update_zmalloc_stat_sub(__n) __sync_sub_and_fetch(&used_memory, (__n))
-#else
-#define update_zmalloc_stat_add(__n) do { \
-    pthread_mutex_lock(&used_memory_mutex); \
-    used_memory += (__n); \
-    pthread_mutex_unlock(&used_memory_mutex); \
-} while(0)
-
-#define update_zmalloc_stat_sub(__n) do { \
-    pthread_mutex_lock(&used_memory_mutex); \
-    used_memory -= (__n); \
-    pthread_mutex_unlock(&used_memory_mutex); \
-} while(0)
-
-#endif
-
-#define update_zmalloc_stat_alloc(__n) do { \
-    size_t _n = (__n); \
-    if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \
-    if (zmalloc_thread_safe) { \
-        update_zmalloc_stat_add(_n); \
-    } else { \
-        used_memory += _n; \
-    } \
-} while(0)
-
-#define update_zmalloc_stat_free(__n) do { \
-    size_t _n = (__n); \
-    if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \
-    if (zmalloc_thread_safe) { \
-        update_zmalloc_stat_sub(_n); \
-    } else { \
-        used_memory -= _n; \
-    } \
-} while(0)
-
-static size_t used_memory = 0;
-static int zmalloc_thread_safe = 0;
-pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static void zmalloc_default_oom(size_t size) {
-    fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n",
-        size);
-    fflush(stderr);
-    abort();
-}
-
-static void (*zmalloc_oom_handler)(size_t) = zmalloc_default_oom;
-
-void *zmalloc(size_t size) {
-    void *ptr = malloc(size+PREFIX_SIZE);
-
-    if (!ptr) zmalloc_oom_handler(size);
-#ifdef HAVE_MALLOC_SIZE
-    update_zmalloc_stat_alloc(zmalloc_size(ptr));
-    return ptr;
-#else
-    *((size_t*)ptr) = size;
-    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
-    return (char*)ptr+PREFIX_SIZE;
-#endif
-}
-
-void *zcalloc(size_t size) {
-    void *ptr = calloc(1, size+PREFIX_SIZE);
-
-    if (!ptr) zmalloc_oom_handler(size);
-#ifdef HAVE_MALLOC_SIZE
-    update_zmalloc_stat_alloc(zmalloc_size(ptr));
-    return ptr;
-#else
-    *((size_t*)ptr) = size;
-    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
-    return (char*)ptr+PREFIX_SIZE;
-#endif
-}
-
-void *zrealloc(void *ptr, size_t size) {
-#ifndef HAVE_MALLOC_SIZE
-    void *realptr;
-#endif
-    size_t oldsize;
-    void *newptr;
-
-    if (ptr == NULL) return zmalloc(size);
-#ifdef HAVE_MALLOC_SIZE
-    oldsize = zmalloc_size(ptr);
-    newptr = realloc(ptr,size);
-    if (!newptr) zmalloc_oom_handler(size);
-
-    update_zmalloc_stat_free(oldsize);
-    update_zmalloc_stat_alloc(zmalloc_size(newptr));
-    return newptr;
-#else
-    realptr = (char*)ptr-PREFIX_SIZE;
-    oldsize = *((size_t*)realptr);
-    newptr = realloc(realptr,size+PREFIX_SIZE);
-    if (!newptr) zmalloc_oom_handler(size);
-
-    *((size_t*)newptr) = size;
-    update_zmalloc_stat_free(oldsize);
-    update_zmalloc_stat_alloc(size);
-    return (char*)newptr+PREFIX_SIZE;
-#endif
-}
-
-/* Provide zmalloc_size() for systems where this function is not provided by
- * malloc itself, given that in that case we store a header with this
- * information as the first bytes of every allocation. */
-#ifndef HAVE_MALLOC_SIZE
-size_t zmalloc_size(void *ptr) {
-    void *realptr = (char*)ptr-PREFIX_SIZE;
-    size_t size = *((size_t*)realptr);
-    /* Assume at least that all the allocations are padded at sizeof(long) by
-     * the underlying allocator. */
-    if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1));
-    return size+PREFIX_SIZE;
-}
-#endif
-
-void zfree(void *ptr) {
-#ifndef HAVE_MALLOC_SIZE
-    void *realptr;
-    size_t oldsize;
-#endif
-
-    if (ptr == NULL) return;
-#ifdef HAVE_MALLOC_SIZE
-    update_zmalloc_stat_free(zmalloc_size(ptr));
-    free(ptr);
-#else
-    realptr = (char*)ptr-PREFIX_SIZE;
-    oldsize = *((size_t*)realptr);
-    update_zmalloc_stat_free(oldsize+PREFIX_SIZE);
-    free(realptr);
-#endif
-}
-
-char *zstrdup(const char *s) {
-    size_t l = strlen(s)+1;
-    char *p = (char*)zmalloc(l);
-
-    memcpy(p,s,l);
-    return p;
-}
-
-size_t zmalloc_used_memory(void) {
-    size_t um;
-
-    if (zmalloc_thread_safe) {
-#if defined(__ATOMIC_RELAXED) || defined(HAVE_ATOMIC)
-        um = update_zmalloc_stat_add(0);
-#else
-        pthread_mutex_lock(&used_memory_mutex);
-        um = used_memory;
-        pthread_mutex_unlock(&used_memory_mutex);
-#endif
-    }
-    else {
-        um = used_memory;
-    }
-
-    return um;
-}
-
-void zmalloc_enable_thread_safeness(void) {
-    zmalloc_thread_safe = 1;
-}
-
-void zmalloc_set_oom_handler(void (*oom_handler)(size_t)) {
-    zmalloc_oom_handler = oom_handler;
-}
-
-/* Get the RSS information in an OS-specific way.
- *
- * WARNING: the function zmalloc_get_rss() is not designed to be fast
- * and may not be called in the busy loops where Redis tries to release
- * memory expiring or swapping out objects.
- *
- * For this kind of "fast RSS reporting" usages use instead the
- * function RedisEstimateRSS() that is a much faster (and less precise)
- * version of the function. */
-
-#if defined(HAVE_PROC_STAT)
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-size_t zmalloc_get_rss(void) {
-    int page = sysconf(_SC_PAGESIZE);
-    size_t rss;
-    char buf[4096];
-    char filename[256];
-    int fd, count;
-    char *p, *x;
-
-    snprintf(filename,256,"/proc/%d/stat",getpid());
-    if ((fd = open(filename,O_RDONLY)) == -1) return 0;
-    if (read(fd,buf,4096) <= 0) {
-        close(fd);
-        return 0;
-    }
-    close(fd);
-
-    p = buf;
-    count = 23; /* RSS is the 24th field in /proc/<pid>/stat */
-    while(p && count--) {
-        p = strchr(p,' ');
-        if (p) p++;
-    }
-    if (!p) return 0;
-    x = strchr(p,' ');
-    if (!x) return 0;
-    *x = '\0';
-
-    rss = strtoll(p,NULL,10);
-    rss *= page;
-    return rss;
-}
-#elif defined(HAVE_TASKINFO)
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <mach/task.h>
-#include <mach/mach_init.h>
-
-size_t zmalloc_get_rss(void) {
-    task_t task = MACH_PORT_NULL;
-    struct task_basic_info t_info;
-    mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
-
-    if (task_for_pid(current_task(), getpid(), &task) != KERN_SUCCESS)
-        return 0;
-    task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count);
-
-    return t_info.resident_size;
-}
-#else
-size_t zmalloc_get_rss(void) {
-    /* If we can't get the RSS in an OS-specific way for this system just
-     * return the memory usage we estimated in zmalloc()..
-     *
-     * Fragmentation will appear to be always 1 (no fragmentation)
-     * of course... */
-    return zmalloc_used_memory();
-}
-#endif
-
-/* Fragmentation = RSS / allocated-bytes */
-float zmalloc_get_fragmentation_ratio(size_t rss) {
-    return (float)rss/zmalloc_used_memory();
-}
-
-/* Get the sum of the specified field (converted form kb to bytes) in
- * /proc/self/smaps. The field must be specified with trailing ":" as it
- * apperas in the smaps output.
- *
- * Example: zmalloc_get_smap_bytes_by_field("Rss:");
- */
-#if defined(HAVE_PROC_SMAPS)
-size_t zmalloc_get_smap_bytes_by_field(char *field) {
-    char line[1024];
-    size_t bytes = 0;
-    FILE *fp = fopen("/proc/self/smaps","r");
-    int flen = strlen(field);
-
-    if (!fp) return 0;
-    while(fgets(line,sizeof(line),fp) != NULL) {
-        if (strncmp(line,field,flen) == 0) {
-            char *p = strchr(line,'k');
-            if (p) {
-                *p = '\0';
-                bytes += strtol(line+flen,NULL,10) * 1024;
-            }
-        }
-    }
-    fclose(fp);
-    return bytes;
-}
-#else
-size_t zmalloc_get_smap_bytes_by_field(char *field) {
-    ((void) field);
-    return 0;
-}
-#endif
-
-size_t zmalloc_get_private_dirty(void) {
-    return zmalloc_get_smap_bytes_by_field("Private_Dirty:");
-}
-
-/* Returns the size of physical memory (RAM) in bytes.
- * It looks ugly, but this is the cleanest way to achive cross platform results.
- * Cleaned up from:
- *
- * http://nadeausoftware.com/articles/2012/09/c_c_tip_how_get_physical_memory_size_system
- *
- * Note that this function:
- * 1) Was released under the following CC attribution license:
- *    http://creativecommons.org/licenses/by/3.0/deed.en_US.
- * 2) Was originally implemented by David Robert Nadeau.
- * 3) Was modified for Redis by Matt Stancliff.
- * 4) This note exists in order to comply with the original license.
- */
-size_t zmalloc_get_memory_size(void) {
-#if defined(__unix__) || defined(__unix) || defined(unix) || \
-    (defined(__APPLE__) && defined(__MACH__))
-#if defined(CTL_HW) && (defined(HW_MEMSIZE) || defined(HW_PHYSMEM64))
-    int mib[2];
-    mib[0] = CTL_HW;
-#if defined(HW_MEMSIZE)
-    mib[1] = HW_MEMSIZE;            /* OSX. --------------------- */
-#elif defined(HW_PHYSMEM64)
-    mib[1] = HW_PHYSMEM64;          /* NetBSD, OpenBSD. --------- */
-#endif
-    int64_t size = 0;               /* 64-bit */
-    size_t len = sizeof(size);
-    if (sysctl( mib, 2, &size, &len, NULL, 0) == 0)
-        return (size_t)size;
-    return 0L;          /* Failed? */
-
-#elif defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
-    /* FreeBSD, Linux, OpenBSD, and Solaris. -------------------- */
-    return (size_t)sysconf(_SC_PHYS_PAGES) * (size_t)sysconf(_SC_PAGESIZE);
-
-#elif defined(CTL_HW) && (defined(HW_PHYSMEM) || defined(HW_REALMEM))
-    /* DragonFly BSD, FreeBSD, NetBSD, OpenBSD, and OSX. -------- */
-    int mib[2];
-    mib[0] = CTL_HW;
-#if defined(HW_REALMEM)
-    mib[1] = HW_REALMEM;        /* FreeBSD. ----------------- */
-#elif defined(HW_PYSMEM)
-    mib[1] = HW_PHYSMEM;        /* Others. ------------------ */
-#endif
-    unsigned int size = 0;      /* 32-bit */
-    size_t len = sizeof(size);
-    if (sysctl(mib, 2, &size, &len, NULL, 0) == 0)
-        return (size_t)size;
-    return 0L;          /* Failed? */
-#else
-    return 0L;          /* Unknown method to get the data. */
-#endif
-#else
-    return 0L;          /* Unknown OS. */
-#endif
-}
-
-
diff --git a/src/xZmalloc.h b/src/xZmalloc.h
deleted file mode 100644
index 91f31210..00000000
--- a/src/xZmalloc.h
+++ /dev/null
@@ -1,236 +0,0 @@
-#pragma once
-#include "all.h"
-
-
-#ifdef __APPLE__
-#include <AvailabilityMacros.h>
-#endif
-
-#ifdef __linux__
-#include <linux/version.h>
-#include <features.h>
-#endif
-
-/* Define redis_fstat to fstat or fstat64() */
-#if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
-#define redis_fstat fstat64
-#define redis_stat stat64
-#else
-#define redis_fstat fstat
-#define redis_stat stat
-#endif
-
-/* Test for proc filesystem */
-#ifdef __linux__
-#define HAVE_PROC_STAT 1
-#define HAVE_PROC_MAPS 1
-#define HAVE_PROC_SMAPS 1
-#define HAVE_PROC_SOMAXCONN 1
-#endif
-
-/* Test for task_info() */
-#if defined(__APPLE__)
-#define HAVE_TASKINFO 1
-#endif
-
-/* Test for backtrace() */
-#if defined(__APPLE__) || (defined(__linux__) && defined(__GLIBC__))
-#define HAVE_BACKTRACE 1
-#endif
-
-/* MSG_NOSIGNAL. */
-#ifdef __linux__
-#define HAVE_MSG_NOSIGNAL 1
-#endif
-
-/* Test for polling API */
-#ifdef __linux__
-#define HAVE_EPOLL 1
-#endif
-
-#if (defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined (__NetBSD__)
-#define HAVE_KQUEUE 1
-#endif
-
-#ifdef __sun
-#include <sys/feature_tests.h>
-#ifdef _DTRACE_VERSION
-#define HAVE_EVPORT 1
-#endif
-#endif
-
-/* Define aof_fsync to fdatasync() in Linux and fsync() for all the rest */
-#ifdef __linux__
-#define aof_fsync fdatasync
-#else
-#define aof_fsync fsync
-#endif
-
-/* Define rdb_fsync_range to sync_file_range() on Linux, otherwise we use
- * the plain fsync() call. */
-#ifdef __linux__
-#if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
-#if (LINUX_VERSION_CODE >= 0x020611 && __GLIBC_PREREQ(2, 6))
-#define HAVE_SYNC_FILE_RANGE 1
-#endif
-#else
-#if (LINUX_VERSION_CODE >= 0x020611)
-#define HAVE_SYNC_FILE_RANGE 1
-#endif
-#endif
-#endif
-
-#ifdef HAVE_SYNC_FILE_RANGE
-#define rdb_fsync_range(fd,off,size) sync_file_range(fd,off,size,SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE)
-#else
-#define rdb_fsync_range(fd,off,size) fsync(fd)
-#endif
-
-/* Check if we can use setproctitle().
- * BSD systems have support for it, we provide an implementation for
- * Linux and osx. */
-#if (defined __NetBSD__ || defined __FreeBSD__ || defined __OpenBSD__)
-#define USE_SETPROCTITLE
-#endif
-
-#if ((defined __linux && defined(__GLIBC__)) || defined __APPLE__)
-#define USE_SETPROCTITLE
-#define INIT_SETPROCTITLE_REPLACEMENT
-void spt_init(int argc, char *argv[]);
-void setproctitle(const char *fmt, ...);
-#endif
-
-/* Byte ordering detection */
-#include <sys/types.h> /* This will likely define BYTE_ORDER */
-
-#ifndef BYTE_ORDER
-#if (BSD >= 199103)
-# include <machine/endian.h>
-#else
-#if defined(linux) || defined(__linux__)
-# include <endian.h>
-#else
-#define	LITTLE_ENDIAN	1234	/* least-significant byte first (vax, pc) */
-#define	BIG_ENDIAN	4321	/* most-significant byte first (IBM, net) */
-#define	PDP_ENDIAN	3412	/* LSB first in word, MSW first in long (pdp)*/
-
-#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || \
-   defined(vax) || defined(ns32000) || defined(sun386) || \
-   defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
-   defined(__alpha__) || defined(__alpha)
-#define BYTE_ORDER    LITTLE_ENDIAN
-#endif
-
-#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
-    defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
-    defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
-    defined(apollo) || defined(__convex__) || defined(_CRAY) || \
-    defined(__hppa) || defined(__hp9000) || \
-    defined(__hp9000s300) || defined(__hp9000s700) || \
-    defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc)
-#define BYTE_ORDER	BIG_ENDIAN
-#endif
-#endif /* linux */
-#endif /* BSD */
-#endif /* BYTE_ORDER */
-
-/* Sometimes after including an OS-specific header that defines the
- * endianess we end with __BYTE_ORDER but not with BYTE_ORDER that is what
- * the Redis code uses. In this case let's define everything without the
- * underscores. */
-#ifndef BYTE_ORDER
-#ifdef __BYTE_ORDER
-#if defined(__LITTLE_ENDIAN) && defined(__BIG_ENDIAN)
-#ifndef LITTLE_ENDIAN
-#define LITTLE_ENDIAN __LITTLE_ENDIAN
-#endif
-#ifndef BIG_ENDIAN
-#define BIG_ENDIAN __BIG_ENDIAN
-#endif
-#if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#define BYTE_ORDER LITTLE_ENDIAN
-#else
-#define BYTE_ORDER BIG_ENDIAN
-#endif
-#endif
-#endif
-#endif
-
-#if !defined(BYTE_ORDER) || \
-    (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN)
-	/* you must determine what the correct bit order is for
-	 * your compiler - the next line is an intentional error
-	 * which will force your compiles to bomb until you fix
-	 * the above macros.
-	 */
-#error "Undefined or invalid BYTE_ORDER"
-#endif
-
-#if (__i386 || __amd64 || __powerpc__) && __GNUC__
-#define GNUC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-#if defined(__clang__)
-#define HAVE_ATOMIC
-#endif
-#if (defined(__GLIBC__) && defined(__GLIBC_PREREQ))
-#if (GNUC_VERSION >= 40100 && __GLIBC_PREREQ(2, 6))
-#define HAVE_ATOMIC
-#endif
-#endif
-#endif
-
-
-/* Double expansion needed for stringification of macro values. */
-#define __xstr(s) __str(s)
-#define __str(s) #s
-
-#if defined(USE_TCMALLOC)
-#define ZMALLOC_LIB ("tcmalloc-" __xstr(TC_VERSION_MAJOR) "." __xstr(TC_VERSION_MINOR))
-#include <google/tcmalloc.h>
-#if (TC_VERSION_MAJOR == 1 && TC_VERSION_MINOR >= 6) || (TC_VERSION_MAJOR > 1)
-#define HAVE_MALLOC_SIZE 1
-#define zmalloc_size(p) tc_malloc_size(p)
-#else
-#error "Newer version of tcmalloc required"
-#endif
-
-#elif defined(USE_JEMALLOC)
-#define ZMALLOC_LIB ("jemalloc-" __xstr(JEMALLOC_VERSION_MAJOR) "." __xstr(JEMALLOC_VERSION_MINOR) "." __xstr(JEMALLOC_VERSION_BUGFIX))
-#include <jemalloc/jemalloc.h>
-#if (JEMALLOC_VERSION_MAJOR == 2 && JEMALLOC_VERSION_MINOR >= 1) || (JEMALLOC_VERSION_MAJOR > 2)
-#define HAVE_MALLOC_SIZE 1
-#define zmalloc_size(p) je_malloc_usable_size(p)
-#else
-#error "Newer version of jemalloc required"
-#endif
-
-#elif defined(__APPLE__)
-#include <malloc/malloc.h>
-#define HAVE_MALLOC_SIZE 1
-#define zmalloc_size(p) malloc_size(p)
-#endif
-
-#ifndef ZMALLOC_LIB
-#define ZMALLOC_LIB "libc"
-#endif
-
-
-void *zmalloc(size_t size);
-void *zcalloc(size_t size);
-void *zrealloc(void *ptr, size_t size);
-void zfree(void *ptr);
-char *zstrdup(const char *s);
-size_t zmalloc_used_memory(void);
-void zmalloc_enable_thread_safeness(void);
-void zmalloc_set_oom_handler(void (*oom_handler)(size_t));
-float zmalloc_get_fragmentation_ratio(size_t rss);
-size_t zmalloc_get_rss(void);
-size_t zmalloc_get_private_dirty(void);
-size_t zmalloc_get_smap_bytes_by_field(char *field);
-size_t zmalloc_get_memory_size(void);
-void zlibc_free(void *ptr);
-
-#ifndef HAVE_MALLOC_SIZE
-size_t zmalloc_size(void *ptr);
-#endif
-
-
diff --git a/testdata/redis.conf b/testdata/redis.conf
new file mode 100644
index 00000000..235b2954
--- /dev/null
+++ b/testdata/redis.conf
@@ -0,0 +1,10 @@
+# Minimal redis.conf
+
+port 6379
+daemonize no
+dir .
+save ""
+appendonly yes
+cluster-config-file nodes.conf
+cluster-node-timeout 30000
+maxclients 1001
\ No newline at end of file
diff --git a/tx.go b/tx.go
new file mode 100644
index 00000000..5ef89619
--- /dev/null
+++ b/tx.go
@@ -0,0 +1,96 @@
+package redis
+
+import (
+	"github.com/go-redis/redis/internal"
+	"github.com/go-redis/redis/internal/pool"
+)
+
+// Redis transaction failed.
+const TxFailedErr = internal.RedisError("redis: transaction failed")
+
+// Tx implements Redis transactions as described in
+// http://redis.io/topics/transactions. It's NOT safe for concurrent use
+// by multiple goroutines, because Exec resets list of watched keys.
+// If you don't need WATCH it is better to use Pipeline.
+type Tx struct {
+	statefulCmdable
+	baseClient
+}
+
+func (c *Client) newTx() *Tx {
+	tx := Tx{
+		baseClient: baseClient{
+			opt:      c.opt,
+			connPool: pool.NewStickyConnPool(c.connPool.(*pool.ConnPool), true),
+		},
+	}
+	tx.setProcessor(tx.Process)
+	return &tx
+}
+
+func (c *Client) Watch(fn func(*Tx) error, keys ...string) error {
+	tx := c.newTx()
+	if len(keys) > 0 {
+		if err := tx.Watch(keys...).Err(); err != nil {
+			_ = tx.Close()
+			return err
+		}
+	}
+	firstErr := fn(tx)
+	if err := tx.Close(); err != nil && firstErr == nil {
+		firstErr = err
+	}
+	return firstErr
+}
+
+// close closes the transaction, releasing any open resources.
+func (c *Tx) Close() error {
+	_ = c.Unwatch().Err()
+	return c.baseClient.Close()
+}
+
+// Watch marks the keys to be watched for conditional execution
+// of a transaction.
+func (c *Tx) Watch(keys ...string) *StatusCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "WATCH"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStatusCmd(args...)
+	c.Process(cmd)
+	return cmd
+}
+
+// Unwatch flushes all the previously watched keys for a transaction.
+func (c *Tx) Unwatch(keys ...string) *StatusCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "UNWATCH"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStatusCmd(args...)
+	c.Process(cmd)
+	return cmd
+}
+
+func (c *Tx) Pipeline() Pipeliner {
+	pipe := Pipeline{
+		exec: c.pipelineExecer(c.txPipelineProcessCmds),
+	}
+	pipe.setProcessor(pipe.Process)
+	return &pipe
+}
+
+// Pipelined executes commands queued in the fn in a transaction
+// and restores the connection state to normal.
+//
+// When using WATCH, EXEC will execute commands only if the watched keys
+// were not modified, allowing for a check-and-set mechanism.
+//
+// Exec always returns list of commands. If transaction fails
+// TxFailedErr is returned. Otherwise Exec returns error of the first
+// failed command or nil.
+func (c *Tx) Pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
+	return c.Pipeline().pipelined(fn)
+}
diff --git a/tx_test.go b/tx_test.go
new file mode 100644
index 00000000..de597ff0
--- /dev/null
+++ b/tx_test.go
@@ -0,0 +1,151 @@
+package redis_test
+
+import (
+	"strconv"
+	"sync"
+
+	"github.com/go-redis/redis"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Tx", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should Watch", func() {
+		var incr func(string) error
+
+		// Transactionally increments key using GET and SET commands.
+		incr = func(key string) error {
+			err := client.Watch(func(tx *redis.Tx) error {
+				n, err := tx.Get(key).Int64()
+				if err != nil && err != redis.Nil {
+					return err
+				}
+
+				_, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
+					pipe.Set(key, strconv.FormatInt(n+1, 10), 0)
+					return nil
+				})
+				return err
+			}, key)
+			if err == redis.TxFailedErr {
+				return incr(key)
+			}
+			return err
+		}
+
+		var wg sync.WaitGroup
+		for i := 0; i < 100; i++ {
+			wg.Add(1)
+			go func() {
+				defer GinkgoRecover()
+				defer wg.Done()
+
+				err := incr("key")
+				Expect(err).NotTo(HaveOccurred())
+			}()
+		}
+		wg.Wait()
+
+		n, err := client.Get("key").Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(n).To(Equal(int64(100)))
+	})
+
+	It("should discard", func() {
+		err := client.Watch(func(tx *redis.Tx) error {
+			cmds, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+				pipe.Set("key1", "hello1", 0)
+				pipe.Discard()
+				pipe.Set("key2", "hello2", 0)
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmds).To(HaveLen(1))
+			return err
+		}, "key1", "key2")
+		Expect(err).NotTo(HaveOccurred())
+
+		get := client.Get("key1")
+		Expect(get.Err()).To(Equal(redis.Nil))
+		Expect(get.Val()).To(Equal(""))
+
+		get = client.Get("key2")
+		Expect(get.Err()).NotTo(HaveOccurred())
+		Expect(get.Val()).To(Equal("hello2"))
+	})
+
+	It("returns no error when there are no commands", func() {
+		err := client.Watch(func(tx *redis.Tx) error {
+			_, err := tx.Pipelined(func(redis.Pipeliner) error { return nil })
+			return err
+		})
+		Expect(err).NotTo(HaveOccurred())
+
+		v, err := client.Ping().Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(v).To(Equal("PONG"))
+	})
+
+	It("should exec bulks", func() {
+		const N = 20000
+
+		err := client.Watch(func(tx *redis.Tx) error {
+			cmds, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+				for i := 0; i < N; i++ {
+					pipe.Incr("key")
+				}
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(cmds)).To(Equal(N))
+			for _, cmd := range cmds {
+				Expect(cmd.Err()).NotTo(HaveOccurred())
+			}
+			return err
+		})
+		Expect(err).NotTo(HaveOccurred())
+
+		num, err := client.Get("key").Int64()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(num).To(Equal(int64(N)))
+	})
+
+	It("should recover from bad connection", func() {
+		// Put bad connection in the pool.
+		cn, _, err := client.Pool().Get()
+		Expect(err).NotTo(HaveOccurred())
+
+		cn.SetNetConn(&badConn{})
+		err = client.Pool().Put(cn)
+		Expect(err).NotTo(HaveOccurred())
+
+		do := func() error {
+			err := client.Watch(func(tx *redis.Tx) error {
+				_, err := tx.Pipelined(func(pipe redis.Pipeliner) error {
+					pipe.Ping()
+					return nil
+				})
+				return err
+			})
+			return err
+		}
+
+		err = do()
+		Expect(err).To(MatchError("bad connection"))
+
+		err = do()
+		Expect(err).NotTo(HaveOccurred())
+	})
+})
diff --git a/universal.go b/universal.go
new file mode 100644
index 00000000..4aa579fa
--- /dev/null
+++ b/universal.go
@@ -0,0 +1,133 @@
+package redis
+
+import "time"
+
+// UniversalOptions information is required by UniversalClient to establish
+// connections.
+type UniversalOptions struct {
+	// Either a single address or a seed list of host:port addresses
+	// of cluster/sentinel nodes.
+	Addrs []string
+
+	// The sentinel master name.
+	// Only failover clients.
+	MasterName string
+
+	// Database to be selected after connecting to the server.
+	// Only single-node and failover clients.
+	DB int
+
+	// Only cluster clients.
+
+	// Enables read only queries on slave nodes.
+	ReadOnly bool
+
+	MaxRedirects   int
+	RouteByLatency bool
+
+	// Common options
+
+	MaxRetries         int
+	Password           string
+	DialTimeout        time.Duration
+	ReadTimeout        time.Duration
+	WriteTimeout       time.Duration
+	PoolSize           int
+	PoolTimeout        time.Duration
+	IdleTimeout        time.Duration
+	IdleCheckFrequency time.Duration
+}
+
+func (o *UniversalOptions) cluster() *ClusterOptions {
+	if len(o.Addrs) == 0 {
+		o.Addrs = []string{"127.0.0.1:6379"}
+	}
+
+	return &ClusterOptions{
+		Addrs:          o.Addrs,
+		MaxRedirects:   o.MaxRedirects,
+		RouteByLatency: o.RouteByLatency,
+		ReadOnly:       o.ReadOnly,
+
+		MaxRetries:         o.MaxRetries,
+		Password:           o.Password,
+		DialTimeout:        o.DialTimeout,
+		ReadTimeout:        o.ReadTimeout,
+		WriteTimeout:       o.WriteTimeout,
+		PoolSize:           o.PoolSize,
+		PoolTimeout:        o.PoolTimeout,
+		IdleTimeout:        o.IdleTimeout,
+		IdleCheckFrequency: o.IdleCheckFrequency,
+	}
+}
+
+func (o *UniversalOptions) failover() *FailoverOptions {
+	if len(o.Addrs) == 0 {
+		o.Addrs = []string{"127.0.0.1:26379"}
+	}
+
+	return &FailoverOptions{
+		SentinelAddrs: o.Addrs,
+		MasterName:    o.MasterName,
+		DB:            o.DB,
+
+		MaxRetries:         o.MaxRetries,
+		Password:           o.Password,
+		DialTimeout:        o.DialTimeout,
+		ReadTimeout:        o.ReadTimeout,
+		WriteTimeout:       o.WriteTimeout,
+		PoolSize:           o.PoolSize,
+		PoolTimeout:        o.PoolTimeout,
+		IdleTimeout:        o.IdleTimeout,
+		IdleCheckFrequency: o.IdleCheckFrequency,
+	}
+}
+
+func (o *UniversalOptions) simple() *Options {
+	addr := "127.0.0.1:6379"
+	if len(o.Addrs) > 0 {
+		addr = o.Addrs[0]
+	}
+
+	return &Options{
+		Addr:     addr,
+		DB:       o.DB,
+
+		MaxRetries:         o.MaxRetries,
+		Password:           o.Password,
+		DialTimeout:        o.DialTimeout,
+		ReadTimeout:        o.ReadTimeout,
+		WriteTimeout:       o.WriteTimeout,
+		PoolSize:           o.PoolSize,
+		PoolTimeout:        o.PoolTimeout,
+		IdleTimeout:        o.IdleTimeout,
+		IdleCheckFrequency: o.IdleCheckFrequency,
+	}
+}
+
+// --------------------------------------------------------------------
+
+// UniversalClient is an abstract client which - based on the provided options -
+// can connect to either clusters, or sentinel-backed failover instances or simple
+// single-instance servers. This can be useful for testing cluster-specific
+// applications locally.
+type UniversalClient interface {
+	Cmdable
+	Process(cmd Cmder) error
+	Close() error
+}
+
+// NewUniversalClient returns a new multi client. The type of client returned depends
+// on the following three conditions:
+//
+// 1. if a MasterName is passed a sentinel-backed FailoverClient will be returned
+// 2. if the number of Addrs is two or more, a ClusterClient will be returned
+// 3. otherwise, a single-node redis Client will be returned.
+func NewUniversalClient(opts *UniversalOptions) UniversalClient {
+	if opts.MasterName != "" {
+		return NewFailoverClient(opts.failover())
+	} else if len(opts.Addrs) > 1 {
+		return NewClusterClient(opts.cluster())
+	}
+	return NewClient(opts.simple())
+}
diff --git a/universal_test.go b/universal_test.go
new file mode 100644
index 00000000..2a0850de
--- /dev/null
+++ b/universal_test.go
@@ -0,0 +1,41 @@
+package redis_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/go-redis/redis"
+)
+
+var _ = Describe("UniversalClient", func() {
+	var client redis.UniversalClient
+
+	AfterEach(func() {
+		if client != nil {
+			Expect(client.Close()).To(Succeed())
+		}
+	})
+
+	It("should connect to failover servers", func() {
+		client = redis.NewUniversalClient(&redis.UniversalOptions{
+			MasterName: sentinelName,
+			Addrs:      []string{":" + sentinelPort},
+		})
+		Expect(client.Ping().Err()).NotTo(HaveOccurred())
+	})
+
+	It("should connect to simple servers", func() {
+		client = redis.NewUniversalClient(&redis.UniversalOptions{
+			Addrs: []string{redisAddr},
+		})
+		Expect(client.Ping().Err()).NotTo(HaveOccurred())
+	})
+
+	It("should connect to clusters", func() {
+		client = redis.NewUniversalClient(&redis.UniversalOptions{
+			Addrs: cluster.addrs(),
+		})
+		Expect(client.Ping().Err()).NotTo(HaveOccurred())
+	})
+
+})