Memcached Enyim.Caching 解决无法遍历获取Key的问题

亦凉 2022-09-02 01:16 6阅读 0赞

**STATS命令**

出于性能考虑，memcached没有提供遍历功能，不过我们可以通过以下两个stats命令得到所有的缓存对象。

1、stats items

显示各个slab中item的数目。

2、stats cachedump slab\_id limit\_num  
显示某个slab中的前limit\_num个key列表，显示格式：ITEM key\_name \[ value\_length b; expire\_time|access\_time s\]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlc3NoZWk_size_16_color_FFFFFF_t_70][]

![20210729161717908.png][]

基于此 我们就可以通过 扩展类的方式来实现其业务逻辑

public class MemcachedClient : Enyim.Caching.MemcachedClient
        {
            public MemcachedClient(string sectionName) : base(sectionName)
            {
    
            }
    
            public IDictionary<IPEndPoint, List<string>> GetKeys()
            {
                var data = new Dictionary<IPEndPoint, List<string>>();
                var result = StatsItems("items");
                var itemsData = new Dictionary<IPEndPoint, Dictionary<string, string>>();
                foreach (var item in result)
                {
                    var ip = item.Key;
                    var items = new Dictionary<string, string>();
                    foreach (var info in item.Value)
                    {
                        var key = info.Key;
                        var strArry = key.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
                        if (strArry.Length == 3 && strArry[2] == "number")
                        {
                            key = strArry[1].Trim();
                            var value = info.Value;
                            items.Add(key, value);
                        }
                    }
                    if (items.Any())
                    {
                        itemsData.Add(ip, items);
                    }
                }
                if (itemsData.Any())
                {
                    foreach (var item in itemsData)
                    {
                        var ip = item.Key;
                        var list = new List<string>();
                        foreach (var info in item.Value)
                        {
                            var dump = StatsItems($"cachedump {info.Key} {info.Value}");
                            if (dump.TryGetValue(ip, out Dictionary<string, string> dics))
                            {
                                foreach (var dic in dics)
                                {
                                    list.Add(dic.Key);
                                }
                            }
                        }
                        if (list.Any())
                        {
                            data.Add(ip, list);
                        }
                    }
                }
                return data;
            }
            private Dictionary<IPEndPoint, Dictionary<string, string>> StatsItems(string type)
            {
                var results = new Dictionary<IPEndPoint, Dictionary<string, string>>();
    
                foreach (var node in this.Pool.GetWorkingNodes())
                {
                    IStatsOperation cmd = new StatsItemsOperation(type);
                    node.Execute(cmd);
                    results[node.EndPoint] = cmd.Result;
                }
                return results;
            }
        } 
        public class StatsItemsOperation : Operation, IStatsOperation
        {
            private static Enyim.Caching.ILog log = Enyim.Caching.LogManager.GetLogger(typeof(StatsOperation));
    
            private string type;
            private Dictionary<string, string> result;
    
            public StatsItemsOperation(string type)
            {
                this.type = type;
            }
    
            protected override IList<ArraySegment<byte>> GetBuffer()
            {
                var command = String.IsNullOrEmpty(this.type)
                                ? "stats" + TextSocketHelper.CommandTerminator
                                : "stats " + this.type + TextSocketHelper.CommandTerminator;
    
                return TextSocketHelper.GetCommandBuffer(command);
            }
    
            protected override IOperationResult ReadResponse(PooledSocket socket)
            {
                var serverData = new Dictionary<string, string>();
    
                while (true)
                {
                    string line = TextSocketHelper.ReadResponse(socket);
    
                    // stat values are terminated by END
                    if (String.Compare(line, "END", StringComparison.Ordinal) == 0)
                        break;
    
                     expected response is STAT item_name item_value
                    //if (line.Length < 6 || String.Compare(line, 0, "STAT ", 0, 5, StringComparison.Ordinal) != 0)
                    //{
                    //	if (log.IsWarnEnabled)
                    //		log.Warn("Unknow response: " + line);
    
                    //	continue;
                    //}
    
                    // get the key&value
                    string[] parts = line.Remove(0, 5).Split(' ');
                    //if (parts.Length != 2)
                    //{
                    //	if (log.IsWarnEnabled)
                    //		log.Warn("Unknow response: " + line);
    
                    //	continue;
                    //}
    
                    // store the stat item
                    serverData[parts[0]] = parts[1];
                }
    
                this.result = serverData;
    
                return new TextOperationResult().Pass();
            }
    
            Dictionary<string, string> IStatsOperation.Result
            {
                get { return result; }
            }
    
            protected override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
            {
                throw new System.NotSupportedException();
            }
        }
        internal static class TextSocketHelper
        {
            private const string GenericErrorResponse = "ERROR";
            private const string ClientErrorResponse = "CLIENT_ERROR ";
            private const string ServerErrorResponse = "SERVER_ERROR ";
            private const int ErrorResponseLength = 13;
    
            public const string CommandTerminator = "\r\n";
    
            private static readonly Enyim.Caching.ILog log = Enyim.Caching.LogManager.GetLogger(typeof(TextSocketHelper));
    
            /// <summary>
            /// Reads the response of the server.
            /// </summary>
            /// <returns>The data sent by the memcached server.</returns>
            /// <exception cref="T:System.InvalidOperationException">The server did not sent a response or an empty line was returned.</exception>
            /// <exception cref="T:Enyim.Caching.Memcached.MemcachedException">The server did not specified any reason just returned the string ERROR. - or - The server returned a SERVER_ERROR, in this case the Message of the exception is the message returned by the server.</exception>
            /// <exception cref="T:Enyim.Caching.Memcached.MemcachedClientException">The server did not recognize the request sent by the client. The Message of the exception is the message returned by the server.</exception>
            public static string ReadResponse(PooledSocket socket)
            {
                string response = TextSocketHelper.ReadLine(socket);
    
                if (log.IsDebugEnabled)
                    log.Debug("Received response: " + response);
    
                if (String.IsNullOrEmpty(response))
                    throw new MemcachedClientException("Empty response received.");
    
                if (String.Compare(response, GenericErrorResponse, StringComparison.Ordinal) == 0)
                    throw new NotSupportedException("Operation is not supported by the server or the request was malformed. If the latter please report the bug to the developers.");
    
                if (response.Length >= ErrorResponseLength)
                {
                    if (String.Compare(response, 0, ClientErrorResponse, 0, ErrorResponseLength, StringComparison.Ordinal) == 0)
                    {
                        throw new MemcachedClientException(response.Remove(0, ErrorResponseLength));
                    }
                    else if (String.Compare(response, 0, ServerErrorResponse, 0, ErrorResponseLength, StringComparison.Ordinal) == 0)
                    {
                        throw new MemcachedException(response.Remove(0, ErrorResponseLength));
                    }
                }
    
                return response;
            }
    
    
            /// <summary>
            /// Reads a line from the socket. A line is terninated by \r\n.
            /// </summary>
            /// <returns></returns>
            private static string ReadLine(PooledSocket socket)
            {
                MemoryStream ms = new MemoryStream(50);
    
                bool gotR = false;
                //byte[] buffer = new byte[1];
    
                int data;
    
                while (true)
                {
                    data = socket.ReadByte();
    
                    if (data == 13)
                    {
                        gotR = true;
                        continue;
                    }
    
                    if (gotR)
                    {
                        if (data == 10)
                            break;
    
                        ms.WriteByte(13);
    
                        gotR = false;
                    }
    
                    ms.WriteByte((byte)data);
                }
    
                string retval = Encoding.ASCII.GetString(ms.GetBuffer(), 0, (int)ms.Length);
    
                if (log.IsDebugEnabled)
                    log.Debug("ReadLine: " + retval);
    
                return retval;
            }
    
            /// <summary>
            /// Gets the bytes representing the specified command. returned buffer can be used to streamline multiple writes into one Write on the Socket
            /// using the <see cref="M:Enyim.Caching.Memcached.PooledSocket.Write(IList<ArraySegment<byte>>)"/>
            /// </summary>
            /// <param name="value">The command to be converted.</param>
            /// <returns>The buffer containing the bytes representing the command. The command must be terminated by \r\n.</returns>
            /// <remarks>The Nagle algorithm is disabled on the socket to speed things up, so it's recommended to convert a command into a buffer
            /// and use the <see cref="M:Enyim.Caching.Memcached.PooledSocket.Write(IList<ArraySegment<byte>>)"/> to send the command and the additional buffers in one transaction.</remarks>
            public  static IList<ArraySegment<byte>> GetCommandBuffer(string value)
            {
                var data = new ArraySegment<byte>(Encoding.ASCII.GetBytes(value));
    
                return new ArraySegment<byte>[] { data };
            }
        }

使用方式;

![20210729161937737.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlc3NoZWk_size_16_color_FFFFFF_t_70]: /images/20220829/f869e49f9f1e4c3ab8926e3fd431574f.png
[20210729161717908.png]: /images/20220829/cc2937b3e5504956b73155e1f70bc3dc.png
[20210729161937737.png]: /images/20220829/b1426e2cac574d9cb87daf79ef85de50.png