redis 一致性hash

使用zookeeper 实现一致性hash。

redis服务启动时，将自己的路由信息通过临时节点方式写入zk，客户端通过zk client读取可用的路由信息。

服务端

使用python 脚本写的守护进程：https://github.com/LittlePeng/redis-manager

脚本部署在redis-server本机，定时ping redis-server

节点失效的情况：

1.服务器与ZK服务器失去连接 Session Expired ，环境网络波动造成，需要根据网络情况设置适当zookeeper的Timeout时间，避免此情况发生

2. 服务器宕机，Zookeeper server 发现zkclient ping超时，就会通知节点下线

3. redis-server 挂了，redis-manager ping 超时主动断开与zookeeper server的连接

客户端

需要zkclient监控 节点变化，及时更新路由策略

下面是C# 版本一致性hash算法：

class KetamaNodeLocator
    {
        private Dictionary<long, RedisCluster> ketamaNodes;
        private HashAlgorithm hashAlg;
        private int numReps = 160;
        private long[] keys;

        public KetamaNodeLocator(List<RedisCluster> nodes)
        {
            ketamaNodes = new Dictionary<long, RedisCluster>();

            //对所有节点，生成nCopies个虚拟结点
            for (int j = 0; j < nodes.Count; j++) {
                RedisCluster node = nodes[j];
                int numReps = node.Weight;

                //每四个虚拟结点为一组
                for (int i = 0; i < numReps / 4; i++) {
                    byte[] digest = ComputeMd5(
                        String.Format("{0}_{1}_{2}", node.RoleName, node.RouteValue, i));

                    /** Md5是一个16字节长度的数组，将16字节的数组每四个字节一组，
                     * 分别对应一个虚拟结点，这就是为什么上面把虚拟结点四个划分一组的原因*/
                    for (int h = 0; h < 4; h++) {

                        long rv = ((long)(digest[3 + h * 4] & 0xFF) << 24)
                                   | ((long)(digest[2 + h * 4] & 0xFF) << 16)
                                   | ((long)(digest[1 + h * 4] & 0xFF) << 8)
                                   | ((long)digest[0 + h * 4] & 0xFF);

                        rv = rv & 0xffffffffL; /* Truncate to 32-bits */
                        ketamaNodes[rv] = node;
                    }
                }
            }

            keys = ketamaNodes.Keys.OrderBy(p => p).ToArray();
        }
        public RedisCluster GetWorkerNode(string k)
        {
            byte[] digest = ComputeMd5(k);
            return GetNodeInner(Hash(digest, 0));
        }

        RedisCluster GetNodeInner(long hash)
        {
            if (ketamaNodes.Count == 0)
                return null;
            long key = hash;
            int near = 0;
            int index = Array.BinarySearch(keys, hash);
            if (index < 0) {
                near = (~index);
                if (near == keys.Length)
                    near = 0;
            }
            else {
                near = index;
            }

            return ketamaNodes[keys[near]];
        }

        public static long Hash(byte[] digest, int nTime)
        {
            long rv = ((long)(digest[3 + nTime * 4] & 0xFF) << 24)
                    | ((long)(digest[2 + nTime * 4] & 0xFF) << 16)
                    | ((long)(digest[1 + nTime * 4] & 0xFF) << 8)
                    | ((long)digest[0 + nTime * 4] & 0xFF);

            return rv & 0xffffffffL; /* Truncate to 32-bits */
        }

        public static byte[] ComputeMd5(string k)
        {
            MD5 md5 = new MD5CryptoServiceProvider();

            byte[] keyBytes = md5.ComputeHash(Encoding.UTF8.GetBytes(k));
            md5.Clear();
            return keyBytes;
        }
    }