src/pconn.h

   1 /*
   2  * Copyright (C) 1996-2014 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 #ifndef SQUID_PCONN_H
  10 #define SQUID_PCONN_H
  11
  12 #include "base/CbcPointer.h"
  13 #include <set>
  14
  15 /**
  16  \defgroup PConnAPI Persistent Connection API
  17  \ingroup Component
  18  *
  19  \todo CLEANUP: Break multiple classes out of the generic pconn.h header
  20  */
  21
  22 class PconnPool;
  23 class PeerPoolMgr;
  24
  25 /* for CBDATA_CLASS2() macros */
  26 #include "cbdata.h"
  27 /* for hash_link */
  28 #include "hash.h"
  29 /* for IOCB */
  30 #include "comm.h"
  31
  32 /// \ingroup PConnAPI
  33 #define PCONN_HIST_SZ (1<<16)
  34
  35 /** \ingroup PConnAPI
  36  * A list of connections currently open to a particular destination end-point.
  37  */
  38 class IdleConnList
  39 {
  40 public:
  41     IdleConnList(const char *key, PconnPool *parent);
  42     ~IdleConnList();
  43
  44     /// Pass control of the connection to the idle list.
  45     void push(const Comm::ConnectionPointer &conn);
  46
  47     /// get first conn which is not pending read fd.
  48     Comm::ConnectionPointer pop();
  49
  50     /** Search the list for a connection which matches the 'key' details
  51      * and pop it off the list.
  52      * The list is created based on remote IP:port hash. This further filters
  53      * the choices based on specific local-end details requested.
  54      * If nothing usable is found the a nil pointer is returned.
  55      */
  56     Comm::ConnectionPointer findUseable(const Comm::ConnectionPointer &key);
  57
  58     void clearHandlers(const Comm::ConnectionPointer &conn);
  59
  60     int count() const { return size_; }
  61     void closeN(size_t count);
  62
  63 private:
  64     bool isAvailable(int i) const;
  65     bool removeAt(int index);
  66     int findIndexOf(const Comm::ConnectionPointer &conn) const;
  67     void findAndClose(const Comm::ConnectionPointer &conn);
  68     static IOCB Read;
  69     static CTCB Timeout;
  70
  71 public:
  72     hash_link hash;             /** must be first */
  73
  74 private:
  75     /** List of connections we are holding.
  76      * Sorted as FIFO list for most efficient speeds on pop() and findUsable()
  77      * The worst-case pop() and scans occur on timeout and link closure events
  78      * where timing is less critical. Occasional slow additions are okay.
  79      */
  80     Comm::ConnectionPointer *theList_;
  81
  82     /// Number of entries theList can currently hold without re-allocating (capacity).
  83     int capacity_;
  84     ///< Number of in-use entries in theList
  85     int size_;
  86
  87     /** The pool containing this sub-list.
  88      * The parent performs all stats accounting, and
  89      * will delete us when it dies. It persists for the
  90      * full duration of our existence.
  91      */
  92     PconnPool *parent_;
  93
  94     char fakeReadBuf_[4096]; // TODO: kill magic number.
  95
  96     CBDATA_CLASS2(IdleConnList);
  97 };
  98
  99 #include "ip/forward.h"
 100
 101 class StoreEntry;
 102 class IdleConnLimit;
 103
 104 /* for hash_table */
 105 #include "hash.h"
 106
 107 /** \ingroup PConnAPI
 108  * Manages idle persistent connections to a caller-defined set of
 109  * servers (e.g., all HTTP servers). Uses a collection of IdleConnLists
 110  * internally to list the individual open connections to each server.
 111  * Controls lists existence and limits the total number of
 112  * idle connections across the collection.
 113  */
 114 class PconnPool
 115 {
 116
 117 public:
 118     PconnPool(const char *aDescription, const CbcPointer<PeerPoolMgr> &aMgr);
 119     ~PconnPool();
 120
 121     void moduleInit();
 122     void push(const Comm::ConnectionPointer &serverConn, const char *domain);
 123
 124     /**
 125      * Returns either a pointer to a popped connection to dest or nil.
 126      * Closes the connection before returning its pointer unless keepOpen.
 127      *
 128      * A caller with a non-retriable transaction should set keepOpen to false
 129      * and call pop() anyway, even though the caller does not want a pconn.
 130      * This forces us to close an available persistent connection, avoiding
 131      * creating a growing number of open connections when many transactions
 132      * create (and push) persistent connections but are not retriable and,
 133      * hence, do not need to pop a connection.
 134      */
 135     Comm::ConnectionPointer pop(const Comm::ConnectionPointer &dest, const char *domain, bool keepOpen);
 136     void count(int uses);
 137     void dumpHist(StoreEntry *e) const;
 138     void dumpHash(StoreEntry *e) const;
 139     void unlinkList(IdleConnList *list);
 140     void noteUses(int uses);
 141     /// closes any n connections, regardless of their destination
 142     void closeN(int n);
 143     int count() const { return theCount; }
 144     void noteConnectionAdded() { ++theCount; }
 145     void noteConnectionRemoved() { assert(theCount > 0); --theCount; }
 146
 147     // sends an async message to the pool manager, if any
 148     void notifyManager(const char *reason);
 149
 150 private:
 151
 152     static const char *key(const Comm::ConnectionPointer &destLink, const char *domain);
 153
 154     int hist[PCONN_HIST_SZ];
 155     hash_table *table;
 156     const char *descr;
 157     CbcPointer<PeerPoolMgr> mgr; ///< optional pool manager (for notifications)
 158     int theCount; ///< the number of pooled connections
 159 };
 160
 161 class StoreEntry;
 162 class PconnPool;
 163
 164 /** \ingroup PConnAPI
 165  * The global registry of persistent connection pools.
 166  */
 167 class PconnModule
 168 {
 169
 170 public:
 171     /** the module is a singleton until we have instance based cachemanager
 172      * management
 173      */
 174     static PconnModule * GetInstance();
 175     /** A thunk to the still C like CacheManager callback api. */
 176     static void DumpWrapper(StoreEntry *e);
 177
 178     PconnModule();
 179     void registerWithCacheManager(void);
 180
 181     void add(PconnPool *);
 182     void remove(PconnPool *); ///< unregister and forget about this pool object
 183
 184     OBJH dump;
 185
 186 private:
 187     typedef std::set<PconnPool*> Pools; ///< unordered PconnPool collection
 188     Pools pools; ///< all live pools
 189
 190     static PconnModule * instance;
 191 };
 192
 193 #endif /* SQUID_PCONN_H */