src/CachePeer.h

   1 /*
   2  * Copyright (C) 1996-2022 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_CACHEPEER_H_
  10 #define SQUID_CACHEPEER_H_
  11
  12 #include "acl/forward.h"
  13 #include "base/CbcPointer.h"
  14 #include "enums.h"
  15 #include "http/StatusCode.h"
  16 #include "icp_opcode.h"
  17 #include "ip/Address.h"
  18 #include "security/PeerOptions.h"
  19
  20 #include <iosfwd>
  21
  22 //TODO: remove, it is unconditionally defined and always used.
  23 #define PEER_MULTICAST_SIBLINGS 1
  24
  25 class NeighborTypeDomainList;
  26 class PconnPool;
  27 class PeerDigest;
  28 class PeerPoolMgr;
  29
  30 class CachePeer
  31 {
  32     CBDATA_CLASS(CachePeer);
  33
  34 public:
  35     explicit CachePeer(const char *hostname);
  36     ~CachePeer();
  37
  38     /// reacts to a successful establishment of a connection to this cache_peer
  39     void noteSuccess();
  40
  41     /// reacts to a failure on a connection to this cache_peer
  42     /// \param code a received response status code, if any
  43     void noteFailure(Http::StatusCode code);
  44
  45     /// (re)configure cache_peer name=value
  46     void rename(const char *);
  47
  48     /// \returns the effective connect timeout for the given peer
  49     time_t connectTimeout() const;
  50
  51     u_int index = 0;
  52
  53     /// cache_peer name (if explicitly configured) or hostname (otherwise).
  54     /// Unique across already configured cache_peers in the current configuration.
  55     /// Not necessarily unique across discovered non-peers (see mgr:non_peers).
  56     /// The value may change during CachePeer configuration.
  57     /// The value affects various peer selection hashes (e.g., carp.hash).
  58     /// Preserves configured spelling (i.e. does not lower letters case).
  59     /// Never nil.
  60     char *name = nullptr;
  61
  62     /// The lowercase version of the configured cache_peer hostname or
  63     /// the IP address of a non-peer (see mgr:non_peers).
  64     /// May not be unique among cache_peers and non-peers.
  65     /// Never nil.
  66     char *host = nullptr;
  67
  68     peer_t type = PEER_NONE;
  69
  70     Ip::Address in_addr;
  71
  72     struct {
  73         int pings_sent = 0;
  74         int pings_acked = 0;
  75         int fetches = 0;
  76         int rtt = 0;
  77         int ignored_replies = 0;
  78         int n_keepalives_sent = 0;
  79         int n_keepalives_recv = 0;
  80         time_t probe_start = 0;
  81         time_t last_query = 0;
  82         time_t last_reply = 0;
  83         time_t last_connect_failure = 0;
  84         time_t last_connect_probe = 0;
  85         int logged_state = PEER_ALIVE;   ///< so we can print dead/revived msgs
  86         int conn_open = 0;               ///< current opened connections
  87     } stats;
  88
  89     struct icp_ {
  90         icp_() { memset(&counts, 0, sizeof(counts)); }
  91         int version = ICP_VERSION_CURRENT;
  92         int counts[ICP_END+1];
  93         unsigned short port = CACHE_ICP_PORT;
  94     } icp;
  95
  96 #if USE_HTCP
  97     struct {
  98         double version = 0.0;
  99         int counts[2] = {0, 0};
 100         unsigned short port = 0;
 101     } htcp;
 102 #endif
 103
 104     unsigned short http_port = CACHE_HTTP_PORT;
 105     NeighborTypeDomainList *typelist = nullptr;
 106     acl_access *access = nullptr;
 107
 108     struct {
 109         bool proxy_only = false;
 110         bool no_query = false;
 111         bool background_ping = false;
 112         bool no_digest = false;
 113         bool default_parent = false;
 114         bool roundrobin = false;
 115         bool weighted_roundrobin = false;
 116         bool mcast_responder = false;
 117         bool closest_only = false;
 118 #if USE_HTCP
 119         bool htcp = false;
 120         bool htcp_oldsquid = false;
 121         bool htcp_no_clr = false;
 122         bool htcp_no_purge_clr = false;
 123         bool htcp_only_clr = false;
 124         bool htcp_forward_clr = false;
 125 #endif
 126         bool no_netdb_exchange = false;
 127 #if USE_DELAY_POOLS
 128         bool no_delay = false;
 129 #endif
 130         bool allow_miss = false;
 131         bool carp = false;
 132         struct {
 133             bool set = false; //If false, whole url is to be used. Overrides others
 134             bool scheme = false;
 135             bool host = false;
 136             bool port = false;
 137             bool path = false;
 138             bool params = false;
 139         } carp_key;
 140 #if USE_AUTH
 141         bool userhash = false;
 142 #endif
 143         bool sourcehash = false;
 144         bool originserver = false;
 145         bool no_tproxy = false;
 146 #if PEER_MULTICAST_SIBLINGS
 147         bool mcast_siblings = false;
 148 #endif
 149         bool auth_no_keytab = false;
 150     } options;
 151
 152     int weight = 1;
 153     int basetime = 0;
 154
 155     struct {
 156         double avg_n_members = 0.0;
 157         int n_times_counted = 0;
 158         int n_replies_expected = 0;
 159         int ttl = 0;
 160         int id = 0;
 161
 162         struct {
 163             bool count_event_pending = false;
 164             bool counting = false;
 165         } flags;
 166     } mcast;
 167
 168 #if USE_CACHE_DIGESTS
 169     PeerDigest *digest = nullptr;
 170     char *digest_url = nullptr;
 171 #endif
 172
 173     /// The number of failures sufficient to stop selecting this cache_peer. All
 174     /// cache_peer selection algorithms skip cache_peers with 0 tcp_up values.
 175     /// The initial 0 value prevents unprobed cache_peers from being selected.
 176     int tcp_up = 0;
 177
 178     /// whether to do another TCP probe after current TCP probes
 179     bool reprobe = false;
 180
 181     Ip::Address addresses[10];
 182     int n_addresses = 0;
 183     int rr_count = 0;
 184     CachePeer *next = nullptr;
 185     int testing_now = 0;
 186
 187     struct {
 188         unsigned int hash = 0;
 189         double load_multiplier = 0.0;
 190         double load_factor = 0.0;     ///< normalized weight value
 191     } carp;
 192 #if USE_AUTH
 193     struct {
 194         unsigned int hash = 0;
 195         double load_multiplier = 0.0;
 196         double load_factor = 0.0;     ///< normalized weight value
 197     } userhash;
 198 #endif
 199     struct {
 200         unsigned int hash = 0;
 201         double load_multiplier = 0.0;
 202         double load_factor = 0.0;     ///< normalized weight value
 203     } sourcehash;
 204
 205     char *login = nullptr;        /* Proxy authorization */
 206     time_t connect_timeout_raw = 0; ///< connect_timeout; use connectTimeout() instead!
 207     int connect_fail_limit = 0;
 208     int max_conn = 0;
 209
 210     /// optional "cache_peer standby=limit" feature
 211     struct {
 212         PconnPool *pool = nullptr;    ///< idle connection pool for this peer
 213         CbcPointer<PeerPoolMgr> mgr;  ///< pool manager
 214         int limit = 0;                ///< the limit itself
 215         bool waitingForClose = false; ///< a conn must close before we open a standby conn
 216     } standby;
 217
 218     char *domain = nullptr; ///< Forced domain
 219
 220     /// security settings for peer connection
 221     Security::PeerOptions secure;
 222     Security::ContextPointer sslContext;
 223     Security::SessionStatePointer sslSession;
 224
 225     int front_end_https = 0; ///< 0 - off, 1 - on, 2 - auto
 226     int connection_auth = 2; ///< 0 - off, 1 - on, 2 - auto
 227
 228 private:
 229     void countFailure();
 230 };
 231
 232 /// reacts to a successful establishment of a connection to an origin server or cache_peer
 233 /// \param peer nil if Squid established a connection to an origin server
 234 inline void
 235 NoteOutgoingConnectionSuccess(CachePeer * const peer)
 236 {
 237     if (peer)
 238         peer->noteSuccess();
 239 }
 240
 241 /// reacts to a failure on a connection to an origin server or cache_peer
 242 /// \param peer nil if the connection is to an origin server
 243 /// \param code a received response status code, if any
 244 inline void
 245 NoteOutgoingConnectionFailure(CachePeer * const peer, const Http::StatusCode code)
 246 {
 247     if (peer)
 248         peer->noteFailure(code);
 249 }
 250
 251 /// identify the given cache peer in cache.log messages and such
 252 std::ostream &operator <<(std::ostream &, const CachePeer &);
 253
 254 #endif /* SQUID_CACHEPEER_H_ */
 255