MessageDelayPools.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2022 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 *);
    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 *, MessageDelayConfig &cfg)
{
    cfg.dumpResponseDelayPoolParameters(entry);
}
 
inline void
parse_response_delay_pool_parameters(MessageDelayConfig * cfg)
{
    cfg->parseResponseDelayPool();
}
 
inline void
parse_response_delay_pool_access(MessageDelayConfig * cfg)
{
    cfg->parseResponseDelayPoolAccess();
}
 
#endif
#endif