MemCacheClient.h

Go to the documentation of this file.

#ifndef INCLUDED_MemCacheClient
#define INCLUDED_MemCacheClient

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

#ifndef WIN32
# include <stdint.h>
#endif

#include <string>
#include <vector>

#ifdef CROSSBASE_API
#include <Core/ReadWriteBuffer.h>
START_CL_NAMESPACE
#else
# include "ReadWriteBuffer.h"
# include "Matilda.h"
#endif

// ----------------------------------------------------------------------------
enum MCResult { 
    // success: n >= 0
    MCERR_OK        = 0,    
    MCERR_NOREPLY   = 1,    
    MCERR_NOTSTORED = 2,    
    MCERR_NOTFOUND  = 3,    

    // failure: n < 0
    MCERR_NOSERVER  = -1    
};

// ----------------------------------------------------------------------------
class CROSSBASE_CLASS_API MemCacheClient 
{
    class Server;                           

public:
    typedef std::string         string_t;   
#ifdef WIN32
    typedef unsigned __int64    uint64_t;   
#else
    typedef unsigned long long  uint64_t;   
#endif

    struct MemRequest 
    {
        struct Sort;        
        Server * mServer;   

    public:
        MemRequest() { Clear(); }

        void Clear() { 
            mServer  = NULL;
            mService = 0;
            mKey     = "";
            mFlags   = 0;
            mExpiry  = 0; 
            mCas     = 0;
            mResult  = MCERR_OK;
            mData.SetEmpty();
            mContext  = NULL;
        }

    public:
        unsigned mService;

        string_t mKey;

        unsigned int mFlags;

        time_t mExpiry; 

        uint64_t mCas;

        MCResult mResult; 

        ReadWriteBuffer mData;

        void * mContext;
    };

public:
    const static int MAX_REQUESTS = 50;

    MemCacheClient();

    ~MemCacheClient();

    void SetTimeout(size_t aTimeoutMs);

    void SetRetryPeriod(size_t aRetryMs);

    static const char * ConvertResult(MCResult aResult);

    void DumpTables();

    /*-----------------------------------------------------------------------*/
    bool AddServer(
        const char *    aServerAddress,
        const char *    aServerName = NULL,
        unsigned        aServices = (unsigned)-1);

    bool DelServer(const char * aServerAddress);

    void GetServers(std::vector<string_t> & aServers);

    void ClearServers();

    /*-----------------------------------------------------------------------*/
    inline int Add(MemRequest & aItem) { return Store("add", &aItem, 1); }

    inline int Set(MemRequest & aItem) { return Store("set", &aItem, 1); }

    inline int Replace(MemRequest & aItem) { return Store("replace", &aItem, 1); }

    inline int Append(MemRequest & aItem) { return Store("append", &aItem, 1); }

    inline int Prepend(MemRequest & aItem) { return Store("prepend", &aItem, 1); }

    inline int CheckSet(MemRequest & aItem) { return Store("cas", &aItem, 1); }

    inline int Get(MemRequest & aItem) { return Combine("get", &aItem, 1); }

    inline int Gets(MemRequest & aItem) { return Combine("gets", &aItem, 1); }

    inline int Del(MemRequest & aItem) { return Combine("del", &aItem, 1); }


    inline MCResult Increment(const char * aKey, uint64_t * aNewValue = NULL, uint64_t aDiff = 1, bool aWantReply = true, unsigned aService = 0) { 
        return IncDec("incr", aService, aKey, aNewValue, aDiff, aWantReply);
    }

    inline MCResult Decrement(const char * aKey, uint64_t * aNewValue = NULL, uint64_t aDiff = 1, bool aWantReply = true, unsigned aService = 0) { 
        return IncDec("decr", aService, aKey, aNewValue, aDiff, aWantReply); 
    }

    /*-----------------------------------------------------------------------*/
    inline int Add(MemRequest * aItem, int aCount) { return Store("add", aItem, aCount); }

    inline int Set(MemRequest * aItem, int aCount) { return Store("set", aItem, aCount); }

    inline int Replace(MemRequest * aItem, int aCount) { return Store("replace", aItem, aCount); }

    inline int Append(MemRequest * aItem, int aCount) { return Store("append", aItem, aCount); }

    inline int Prepend(MemRequest * aItem, int aCount) { return Store("prepend", aItem, aCount); }

    inline int CheckSet(MemRequest * aItem, int aCount) { return Store("cas", aItem, aCount); }

    inline int Get(MemRequest * aItem, int aCount) { return Combine("get", aItem, aCount); }

    inline int Gets(MemRequest * aItem, int aCount) { return Combine("gets", aItem, aCount); }

    inline int Del(MemRequest * aItem, int aCount) { return Combine("del", aItem, aCount); }

    int FlushAll(const char * aServer = NULL, int aExpiry = 0);

private:
    // disabled
    MemCacheClient(const MemCacheClient &); 
    MemCacheClient & operator=(const MemCacheClient &); 

    /*-----------------------------------------------------------------------*/
    ClTrace mTrace;

    std::vector<Server*> mServer; 

    size_t mTimeoutMs; 

    size_t mRetryMs; 

    struct ConsistentHash { 
        unsigned long   mHash;      
        Server *        mServer;    
        unsigned        mServices;  
        int             mEntry;     

        ConsistentHash(unsigned long aHash, Server * aServer, unsigned aServices, int aEntry) 
            : mHash(aHash), mServer(aServer), mServices(aServices), mEntry(aEntry) { }
        ConsistentHash(const ConsistentHash & rhs) { operator=(rhs); }
        ConsistentHash & operator=(const ConsistentHash & rhs) {
            mHash = rhs.mHash; mServer = rhs.mServer; mServices = rhs.mServices; mEntry = rhs.mEntry; 
            return *this; 
        }
        inline bool services(unsigned aService) { return (mServices & aService) == aService; }
        bool operator<(const ConsistentHash & rhs) const;
        struct MatchServer;
    private:
        bool operator==(const ConsistentHash & rhs) const;
    };

    std::vector<ConsistentHash> mServerHash;

    unsigned long CreateKeyHash(const char * aKey);

    Server * FindServer(const string_t & aKey, unsigned aService);

    int Store(const char * aType, MemRequest * aItem, int aCount);

    void HandleStoreResponse(Server * aServer, MemRequest & aItem);
    
    int Combine(const char * aType, MemRequest * aItem, int aCount);

    int HandleGetResponse(Server * aServer, MemRequest ** aBegin, MemRequest ** aEnd);

    int HandleDelResponse(Server * aServer, MemRequest ** aBegin, MemRequest ** aEnd);

    MCResult IncDec(const char * aType, unsigned aService, const char * aKey, uint64_t * aNewValue, uint64_t aDiff, bool aWantReply);

};

#ifdef CROSSBASE_API
END_CL_NAMESPACE
#endif

#endif // INCLUDED_MemCacheClient