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;
        }
    }