pconn.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2020 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 SQUID_PCONN_H
#define SQUID_PCONN_H
 
#include "base/CbcPointer.h"
#include "base/RunnersRegistry.h"
#include "mgr/forward.h"
 
#include <set>
 
class PconnPool;
class PeerPoolMgr;
 
#include "cbdata.h"
#include "hash.h"
/* for IOCB */
#include "comm.h"
 
#define PCONN_HIST_SZ (1<<16)
 
class IdleConnList: public hash_link, private IndependentRunner
{
    CBDATA_CLASS(IdleConnList);
 
public:
    IdleConnList(const char *key, PconnPool *parent);
    ~IdleConnList();
 
    void push(const Comm::ConnectionPointer &conn);
 
    Comm::ConnectionPointer pop();
 
    Comm::ConnectionPointer findUseable(const Comm::ConnectionPointer &key);
 
    void clearHandlers(const Comm::ConnectionPointer &conn);
 
    int count() const { return size_; }
    void closeN(size_t count);
 
    // IndependentRunner API
    virtual void endingShutdown();
private:
    bool isAvailable(int i) const;
    bool removeAt(int index);
    int findIndexOf(const Comm::ConnectionPointer &conn) const;
    void findAndClose(const Comm::ConnectionPointer &conn);
    static IOCB Read;
    static CTCB Timeout;
 
private:
    Comm::ConnectionPointer *theList_;
 
    int capacity_;
    int size_;
 
    PconnPool *parent_;
 
    char fakeReadBuf_[4096]; // TODO: kill magic number.
};
 
#include "ip/forward.h"
 
class StoreEntry;
class IdleConnLimit;
 
/* for hash_table */
#include "hash.h"
 
class PconnPool
{
 
public:
    PconnPool(const char *aDescription, const CbcPointer<PeerPoolMgr> &aMgr);
    ~PconnPool();
 
    void moduleInit();
    void push(const Comm::ConnectionPointer &serverConn, const char *domain);
 
    Comm::ConnectionPointer pop(const Comm::ConnectionPointer &dest, const char *domain, bool keepOpen);
    void count(int uses);
    void dumpHist(StoreEntry *e) const;
    void dumpHash(StoreEntry *e) const;
    void unlinkList(IdleConnList *list);
    void noteUses(int uses);
    void closeN(int n);
    int count() const { return theCount; }
    void noteConnectionAdded() { ++theCount; }
    void noteConnectionRemoved() { assert(theCount > 0); --theCount; }
 
    // sends an async message to the pool manager, if any
    void notifyManager(const char *reason);
 
private:
 
    static const char *key(const Comm::ConnectionPointer &destLink, const char *domain);
 
    Comm::ConnectionPointer popStored(const Comm::ConnectionPointer &dest, const char *domain, const bool keepOpen);
 
    int hist[PCONN_HIST_SZ];
    hash_table *table;
    const char *descr;
    CbcPointer<PeerPoolMgr> mgr; 
    int theCount; 
};
 
class StoreEntry;
class PconnPool;
 
class PconnModule
{
 
public:
    static PconnModule * GetInstance();
    static void DumpWrapper(StoreEntry *e);
 
    PconnModule();
    void registerWithCacheManager(void);
 
    void add(PconnPool *);
    void remove(PconnPool *); 
 
    OBJH dump;
 
private:
    typedef std::set<PconnPool*> Pools; 
    Pools pools; 
 
    static PconnModule * instance;
};
 
#endif /* SQUID_PCONN_H */