NET_Cache.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_Cache.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __NET_CACHE_H__
#define __NET_CACHE_H__

#include "NET_API.h"

#include <UT/UT_ErrorCode.h>
#include <UT/UT_Function.h>
#include <UT/UT_Map.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_SQLORM.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_WorkBuffer.h>

#include <SYS/SYS_Types.h>

class NET_API NET_ICache
{
public:
    using int_def_clb_t = UT_Function<int(UT_ErrorCode& ec)>;
    using str_def_clb_t = UT_Function<UT_StringHolder(UT_ErrorCode& ec)>;

    virtual ~NET_ICache() = default;
    UT_NON_COPYABLE(NET_ICache);

    virtual int64 getBackendTimeout(int64 timeout = -1)
    {
        if (timeout == -1)
            timeout = myDefaultTimeout;
        else if (timeout == 0)
            timeout = -1;
        return time(nullptr) + timeout;
    }
    UT_StringHolder makeKey(
            const UT_StringHolder& key,
            int version = -1)
    {
        if (version == -1)
            version = myDefaultVersion;

        return generateKey(myKeyPrefix, key, version);
    }
    virtual bool add(
            const UT_StringHolder& key,
            int value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1)
    {
        UT_StringHolder vstr;
        vstr.format("{}", value);
        return add(key, vstr, ec, timeout, version);
    }
    virtual bool add(
            const UT_StringHolder& key,
            const UT_StringHolder& value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1)
            = 0;
    virtual bool get(
            const UT_StringRef& key,
            int& value,
            int def = -1,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        UT_StringHolder v;
        if (get(key, v, v, ec, version))
        {
            value = v.toInt();
            return true;
        }
        else
        {
            value = def;
            return false;
        }
    }
    virtual bool get(
            const UT_StringRef& key,
            UT_StringHolder& value,
            const UT_StringHolder& def = UT_StringHolder::theEmptyString,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
            = 0;
    virtual bool set(
            const UT_StringHolder& key,
            int value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1)
    {
        UT_StringHolder vstr;
        vstr.format("{}", value);
        return set(key, vstr, ec, timeout, version);
    }
    virtual bool set(
            const UT_StringHolder& key,
            const UT_StringHolder& value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1) = 0;
    virtual bool touch(
            const UT_StringRef& key,
            UT_ErrorCode* ec = nullptr,
            int timeout = -1,
            int version = -1)
            = 0;
    virtual bool remove(
            const UT_StringRef& key,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
            = 0;
    virtual void getMany(
            const UT_StringArray& keys,
            UT_Map<UT_StringHolder, UT_StringHolder>& results,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        results.clear();
        for (auto&& key : keys)
        {
            UT_StringHolder value;
            if (get(key, value, /*def=*/UT_StringHolder::theEmptyString,
                    nullptr, version))
            {
                results[key] = value;
            }
        }
    }
    virtual void getMany(
            const UT_StringArray& keys,
            UT_Map<UT_StringHolder, int>& results,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        results.clear();
        for (auto&& key : keys)
        {
            int value = 0;
            if (get(key, value, /*def=*/-1, nullptr, version))
            {
                results[key] = value;
            }
        }
    }
    virtual int getOrSet(
            const UT_StringRef& key,
            int_def_clb_t&& clb,
            UT_ErrorCode& ec,
            int64 timeout = -1,
            int version=-1)
    {
        int value = -1;
        UT_ErrorCode* tec = &ec;
        if (!get(key, value, value, tec, version))
        {
            int def = clb(ec);
            if (ec)
                return def;

            add(key, def, tec, timeout, version);

            get(key, def, /*def=*/-1, tec, version);
            return def;
        }
        return value;
    }
    virtual int getOrSet(
            const UT_StringRef& key,
            int def,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1)
    {
        int value = -1;
        if (!get(key, value, def, ec, version))
        {
            add(key, def, ec, timeout, version);

            get(key, def, /*def=*/-1, ec, version);
            return def;
        }
        return value;
    }
    virtual UT_StringHolder getOrSet(
            const UT_StringRef& key,
            str_def_clb_t&& clb,
            UT_ErrorCode& ec,
            int64 timeout = -1,
            int version=-1)
    {
        UT_StringHolder value;
        UT_ErrorCode* tec = &ec;
        if (!get(key, value, UT_StringHolder::theEmptyString, tec, version))
        {
            UT_StringHolder def = clb(ec);
            if (ec)
                return def;

            add(key, def, tec, timeout, version);

            get(key, def, /*def=*/UT_StringHolder::theEmptyString, tec, version);
            return def;
        }
        return value;
    }
    virtual UT_StringHolder getOrSet(
            const UT_StringRef& key,
            const UT_StringHolder& def,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1)
    {
        UT_StringHolder value;
        if (!get(key, value, def, ec, version))
        {
            add(key, def, ec, timeout, version);

            // Retrieve the value from the cache to prevent race conditions
            get(key, value, /*def=*/UT_StringHolder::theEmptyString, ec,
                version);
            return value;
        }
        return value;
    }

    virtual bool hasKey(
            const UT_StringRef& key,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        int v = 0;
        return get(key, /*value=*/v, /*def=*/v, ec, version);
    }

    virtual bool incr(
            const UT_StringRef& key,
            int &value,
            int delta = 1,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        if (get(key, value, value, ec, version))
        {
            value = value + delta;
            return set(key, value, ec, /*timeout=*/-1, version);
        }
        return false;
    }
    virtual bool decr(
            const UT_StringRef& key,
            int &value,
            int delta = 1,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        return incr(key, value, -delta, ec, version);
    }

    virtual UT_StringArray setMany(
            const UT_Map<UT_StringHolder, UT_StringHolder>& data,
            int64 timeout = -1,
            int version = -1)
    {
        for (auto&& [key, value] : data)
            set(key, value, nullptr, timeout, version);
        // NB: Some backends support returning which keys failed to be
        // inserted.
        return UT_StringArray{};
    }
    virtual UT_StringArray setMany(
            const UT_Map<UT_StringHolder, int>& data,
            int64 timeout = -1,
            int version = -1)
    {
        for (auto&& [key, value] : data)
            set(key, value, nullptr, timeout, version);
        // NB: Some backends support returning which keys failed to be
        // inserted.
        return UT_StringArray{};
    }
    virtual void removeMany(
            const UT_StringArray& keys,
            UT_ErrorCode* ec,
            int version = -1)
    {
        for (auto&& key : keys)
            remove(key, ec, version);
    }
    virtual void clear(UT_ErrorCode* ec = nullptr) = 0;
    virtual int incrVersion(
            const UT_StringRef& key,
            int delta = 1,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        if (version == -1)
            version = myDefaultVersion;

        int value = 0;
        if (get(key, value, value, ec, version))
        {
            if (!set(key, value, ec, /*timeout=*/-1, version + delta))
                return value;
            remove(key, ec, version);
        }
        else
        {
            return version;
        }
        return version + delta;
    }
    virtual int decrVersion(
            const UT_StringRef& key,
            int delta = 1,
            UT_ErrorCode* ec = nullptr,
            int version = -1)
    {
        return incrVersion(key, -delta, ec, version);
    }

    virtual void close(UT_ErrorCode* ec = nullptr) {}

protected:
    NET_ICache() = default;

    virtual UT_StringHolder generateKey(
            const UT_StringHolder& key_prefix,
            const UT_StringHolder& key,
            int version)
    {
        UT_WorkBuffer wbuf;
        wbuf.append(key_prefix);
        wbuf.append(':');
        wbuf.append(key);
        wbuf.append(':');
        wbuf.appendFormat("{}", version);
        return wbuf;
    }

    int myDefaultTimeout = 300;
    int myMaxEntries = 300;
    int myCullFequency = 3;

    UT_StringHolder myKeyPrefix;
    int myDefaultVersion = 1;
};


class NET_API NET_DatabaseCache final : public NET_ICache
{
public:
    NET_DatabaseCache(const UT_StringHolder& table_name);
    ~NET_DatabaseCache() override;

    UT_NON_COPYABLE(NET_DatabaseCache);

    bool open(UT_SqlOrm& orm, UT_ErrorCode& ec);

    bool add(
            const UT_StringHolder& key,
            int value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1) override
    {
        UT_StringHolder vstr;
        vstr.format("{}", value);
        return add(key, vstr, ec, timeout, version);
    }
    bool add(
            const UT_StringHolder& key,
            const UT_StringHolder& value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1) override; 
    bool get(
            const UT_StringRef& key,
            int& value,
            int def = -1,
            UT_ErrorCode* ec = nullptr,
            int version = -1) override;
    bool get(
            const UT_StringRef& key,
            UT_StringHolder& value,
            const UT_StringHolder& def = UT_StringHolder::theEmptyString,
            UT_ErrorCode* ec = nullptr,
            int version = -1) override;
    void getMany(
            const UT_StringArray& keys,
            UT_Map<UT_StringHolder, UT_StringHolder>& results,
            UT_ErrorCode* ec = nullptr,
            int version = -1) override;
    void getMany(
            const UT_StringArray& keys,
            UT_Map<UT_StringHolder, int>& results,
            UT_ErrorCode* ec = nullptr,
            int version = -1) override;
    bool set(
            const UT_StringHolder& key,
            const UT_StringHolder& value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1) override;
    bool set(
            const UT_StringHolder& key,
            int value,
            UT_ErrorCode* ec = nullptr,
            int64 timeout = -1,
            int version = -1) override
    {
        UT_StringHolder vstr;
        vstr.format("{}", value);
        return set(key, vstr, ec, timeout, version);
    }
    bool touch(
            const UT_StringRef& key,
            UT_ErrorCode* ec = nullptr,
            int timeout = -1,
            int version = -1) override;
    bool remove(
            const UT_StringRef& key,
            UT_ErrorCode* ec = nullptr,
            int version = -1) override;
    void removeMany(
            const UT_StringArray& keys,
            UT_ErrorCode* ec = nullptr,
            int version = -1) override
    {
        UT_StringArray ks(keys);
        for (auto&& key : ks)
            key = makeKey(key, version);
        UT_ErrorCode oec;
        doRemoveMany_(keys, oec);
        if (ec)
            *ec = oec;
    }
    void clear(UT_ErrorCode* ec = nullptr) override;
    void close(UT_ErrorCode* ec = nullptr) override;

    bool incr(
            const UT_StringRef& key,
            int& value,
            int delta = 1,
            UT_ErrorCode* ec = nullptr,
            int version = -1) override;

private:
    enum DatabaseOp
    {
        DB_OP_SET,
        DB_OP_TOUCH,
        DB_OP_ADD
    };

    bool doSet_(
            DatabaseOp op,
            const UT_StringHolder& key,
            const UT_StringHolder& value,
            UT_ErrorCode& ec,
            int64 timeout);
    void doCull_(UT_SqlStatement& db, time_t now, int count);
    bool doRemoveMany_(const UT_StringArray& key, UT_ErrorCode& ec);
    void doGetMany_(
            const UT_StringArray& keys,
            UT_Function<void(const UT_StringHolder&, const UT_StringHolder&)>&&
                    result_func,
            UT_ErrorCode* ec,
            int version);
    bool doIncrement_(
            const UT_StringHolder& key,
            UT_StringHolder& value,
            int delta,
            UT_ErrorCode& ec);

    UT_StringHolder myTableName;
    UT_SqlOrm* myORM = nullptr;
};

#endif // __NET_CACHE_H__