MessageDelayPools.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2019 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */

#ifndef MESSAGEDELAYPOOLS_H
#define MESSAGEDELAYPOOLS_H

#if USE_DELAY_POOLS

#include "acl/Acl.h"
#include "base/RefCount.h"
#include "DelayBucket.h"
#include "DelayPools.h"
#include "sbuf/SBuf.h"

class MessageBucket;
typedef RefCount<MessageBucket> MessageBucketPointer;

class MessageDelayPool : public RefCountable
{
public:
    typedef RefCount<MessageDelayPool> Pointer;

    MessageDelayPool(const SBuf &name, int64_t bucketSpeed, int64_t bucketSize,
                     int64_t aggregateSpeed, int64_t aggregateSize, uint16_t initialBucketPercent);
    ~MessageDelayPool();
    MessageDelayPool(const MessageDelayPool &) = delete;
    MessageDelayPool &operator=(const MessageDelayPool &) = delete;

    void refillBucket();
    void bytesIn(int qty) { if (!noLimit()) theBucket.bytesIn(qty); }
    int level() { return theBucket.level(); }
    MessageBucketPointer createBucket();
    bool noLimit () const { return aggregateRestore < 0; }

    void dump (StoreEntry * entry) const;

    acl_access *access;
    SBuf poolName;
    int64_t individualRestore;
    int64_t individualMaximum;
    int64_t aggregateRestore;
    int64_t aggregateMaximum;
    uint16_t initialBucketLevel;
    DelayBucket theBucket;

private:
    time_t lastUpdate;
};

class MessageDelayPools
{
public:
    MessageDelayPools(const MessageDelayPools &) = delete;
    MessageDelayPools &operator=(const MessageDelayPools &) = delete;

    static MessageDelayPools *Instance();

    MessageDelayPool::Pointer pool(const SBuf &name);
    void add(MessageDelayPool *pool);
    void freePools();

    std::vector<MessageDelayPool::Pointer> pools;

private:
    MessageDelayPools() {}
    ~MessageDelayPools();
    void Stats() { } // TODO
};

class MessageDelayConfig
{
public:
    void parseResponseDelayPool();
    void dumpResponseDelayPoolParameters(StoreEntry *e, const char *name);
    void parseResponseDelayPoolAccess();
    void freePools();
};

#define free_response_delay_pool_access(X)
#define dump_response_delay_pool_access(X, Y, Z)

inline void
free_response_delay_pool_parameters(MessageDelayConfig * cfg)
{
    cfg->freePools();
}

inline void
dump_response_delay_pool_parameters(StoreEntry *entry, const char *name, MessageDelayConfig &cfg)
{
    cfg.dumpResponseDelayPoolParameters(entry, name);
}

inline void
parse_response_delay_pool_parameters(MessageDelayConfig * cfg)
{
    cfg->parseResponseDelayPool();
}

inline void
parse_response_delay_pool_access(MessageDelayConfig * cfg)
{
    cfg->parseResponseDelayPoolAccess();
}

#endif
#endif