HappyConnOpener.h
Go to the documentation of this file.
1/*
2 * Copyright (C) 1996-2023 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_HAPPYCONNOPENER_H
10#define SQUID_HAPPYCONNOPENER_H
11#include "base/AsyncCallbacks.h"
12#include "base/JobWait.h"
13#include "base/RefCount.h"
14#include "comm.h"
15#include "comm/Connection.h"
16#include "comm/ConnOpener.h"
17#include "errorpage.h"
18#include "http/forward.h"
19#include "log/forward.h"
20#include "ResolvedPeers.h"
21
22#include <iosfwd>
23
24class HappyConnOpener;
26class JobGapEnforcer;
28
30typedef std::list< CbcPointer<HappyConnOpener> > HappySpareWaitList;
31
33typedef double HappyAbsoluteTime;
34
37public:
38 explicit operator bool() const { return toGivePrimeItsChance || forSpareAllowance || forPrimesToFail || forNewPeer; }
39
42 void clear() { *this = HappySpareWait(); }
43
45
48
51 HappySpareWaitList::iterator position;
52
53 /* The following four fields represent mutually exclusive wait reasons. */
54
58
63 bool forSpareAllowance = false;
64
67 bool forPrimesToFail = false;
68
71 bool forNewPeer = false;
72};
73
76{
77public:
79
81 bool success() const { return !error; }
82
86
87 // answer recipients must clear the error member in order to keep its info
88 // XXX: We should refcount ErrorState instead of cbdata-protecting it.
90
93 int n_tries = 0;
94
96 bool reused = false;
97};
98
100std::ostream &operator <<(std::ostream &, const HappyConnOpenerAnswer &);
101
106{
108public:
110
111public:
112 HappyConnOpener(const ResolvedPeersPointer &, const AsyncCallback<Answer> &, const HttpRequestPointer &, time_t aFwdStart, int tries, const AccessLogEntryPointer &);
113 ~HappyConnOpener() override;
114
116 void allowPersistent(bool permitted) { allowPconn_ = permitted; }
117
119 void setRetriable(bool retriable) { retriable_ = retriable; }
120
122 void setHost(const char *);
123
126
129
131 void noteSpareAllowance();
132
135
136private:
138 class Attempt {
139 public:
142
143 Attempt(const CallbackMethod method, const char *methodName);
144
145 explicit operator bool() const { return static_cast<bool>(path); }
146
148 void finish();
149
151 void cancel(const char *reason);
152
154
157
159 const char * const callbackMethodName;
160 };
161 friend std::ostream &operator <<(std::ostream &, const Attempt &);
162
163 /* AsyncJob API */
164 void start() override;
165 bool doneAll() const override;
166 void swanSong() override;
167 const char *status() const override;
168
171
175
179
182 void handleConnOpenerAnswer(Attempt &, const CommConnectCbParams &, const char *connDescription);
183
185
187
188 void cancelSpareWait(const char *reason);
189
190 bool ranOutOfTimeOrAttempts() const;
191
192 ErrorState *makeError(const err_type type) const;
194 void sendSuccess(const PeerConnectionPointer &conn, bool reused, const char *connKind);
195 void sendFailure();
196 void cancelAttempt(Attempt &, const char *reason);
197
198 const time_t fwdStart;
199
202
205
208
211
215
218 friend class HappyOrderEnforcer;
219
221
224
227
229 bool gotSpareAllowance = false;
230
232 bool allowPconn_ = true;
233
235 bool retriable_ = true;
236
238 const char *host_ = nullptr;
239
242
246
248 mutable const char *ranOutOfTimeOrAttemptsEarlier_ = nullptr;
249};
250
251#endif
252
RefCount< ResolvedPeers > ResolvedPeersPointer
std::list< CbcPointer< HappyConnOpener > > HappySpareWaitList
A FIFO queue of HappyConnOpener jobs waiting to open a spare connection.
double HappyAbsoluteTime
absolute time in fractional seconds; compatible with current_timed
std::ostream & operator<<(std::ostream &, const HappyConnOpenerAnswer &)
reports Answer details (for AsyncCall parameter debugging)
int conn
the current server connection FD
Definition: Transport.cc:26
a smart AsyncCall pointer for delivery of future results
Final result (an open connection or an error) sent to the job initiator.
bool success() const
whether HappyConnOpener succeeded, returning a usable connection
bool reused
whether conn was open earlier, by/for somebody else
PeerConnectionPointer conn
CbcPointer< ErrorState > error
problem details (nil on success)
a connection opening attempt in progress (or falsy)
void finish()
reacts to a natural attempt completion (successful or otherwise)
const char *const callbackMethodName
for callbackMethod debugging
void(HappyConnOpener::*)(const CommConnectCbParams &) CallbackMethod
HappyConnOpener method implementing a ConnOpener callback.
JobWait< Comm::ConnOpener > connWait
waits for a connection to the peer to be established/opened
void cancel(const char *reason)
aborts an in-progress attempt
const CallbackMethod callbackMethod
ConnOpener calls this method.
PeerConnectionPointer path
the destination we are connecting to
Attempt(const CallbackMethod method, const char *methodName)
bool doneAll() const override
whether positive goal has been reached
void noteSpareConnectDone(const CommConnectCbParams &)
Comm::ConnOpener callback for the spare connection attempt.
bool ignoreSpareRestrictions
whether spare connection attempts disregard happy_eyeballs_* settings
bool gotSpareAllowance
whether we have received a permission to open a spare while spares are limited
PeerConnectionPointer lastFailedConnection
nil if none has failed
void start() override
called by AsyncStart; do not call directly
void noteGavePrimeItsChance()
reacts to expired happy_eyeballs_connect_timeout
bool retriable_
whether we are opening connections for a request that may be resent
const char * status() const override
internal cleanup; do not call directly
void cancelAttempt(Attempt &, const char *reason)
cancels the in-progress attempt, making its path a future candidate
Comm::ConnectionPointer currentPeer
void maybeGivePrimeItsChance()
void setHost(const char *)
configures the origin server domain name
const char * ranOutOfTimeOrAttemptsEarlier_
Reason to ran out of time or attempts.
void sendSuccess(const PeerConnectionPointer &conn, bool reused, const char *connKind)
send a successful result to the initiator (if it still needs an answer)
HappyConnOpener(const ResolvedPeersPointer &, const AsyncCallback< Answer > &, const HttpRequestPointer &, time_t aFwdStart, int tries, const AccessLogEntryPointer &)
void updateSpareWaitAfterPrimeFailure()
reacts to a prime attempt failure
~HappyConnOpener() override
CBDATA_CHILD(HappyConnOpener)
HttpRequestPointer cause
the request that needs a to-server connection
void stopGivingPrimeItsChance()
called when the prime attempt has used up its chance for a solo victory
friend std::ostream & operator<<(std::ostream &, const Attempt &)
HappyConnOpener::Attempt printer for debugging.
AccessLogEntryPointer ale
transaction details
void maybeOpenSpareConnection()
if possible, starts a spare connection attempt
Answer * futureAnswer(const PeerConnectionPointer &)
const time_t fwdStart
requestor start time
void checkForNewConnection()
void allowPersistent(bool permitted)
configures reuse of old connections
void handleConnOpenerAnswer(Attempt &, const CommConnectCbParams &, const char *connDescription)
prime/spare-agnostic processing of a Comm::ConnOpener result
bool ranOutOfTimeOrAttempts() const
Check for maximum connection tries and forwarding time restrictions.
void stopWaitingForSpareAllowance()
called when the spare attempt should no longer obey spare connection limits
HappyConnOpenerAnswer Answer
ErrorState * makeError(const err_type type) const
void noteSpareAllowance()
reacts to satisfying happy_eyeballs_connect_gap and happy_eyeballs_connect_limit
HappySpareWait spareWaiting
preconditions for an attempt to open a spare connection
void sendFailure()
inform the initiator about our failure to connect (if needed)
void swanSong() override
void setRetriable(bool retriable)
configures whether the request may be retried later if things go wrong
ErrorState * lastError
last problem details (or nil)
bool reuseOldConnection(PeerConnectionPointer &)
void startConnecting(Attempt &, PeerConnectionPointer &)
starts opening (or reusing) a connection to the given destination
bool allowPconn_
whether persistent connections are allowed
const char * host_
origin server domain name (or equivalent)
Attempt spare
current connection opening attempt on the spare track (if any)
ResolvedPeersPointer destinations
Candidate paths. Shared with the initiator. May not be finalized yet.
HappyAbsoluteTime primeStart
the start of the first connection attempt for the currentPeer
void maybeOpenPrimeConnection()
starts a prime connection attempt if possible or does nothing otherwise
void openFreshConnection(Attempt &, PeerConnectionPointer &)
AsyncCallback< Answer > callback_
answer destination
void notePrimeConnectDone(const CommConnectCbParams &)
Comm::ConnOpener callback for the prime connection attempt.
void cancelSpareWait(const char *reason)
stops waiting for the right conditions to open a spare connection
void noteCandidatesChange()
reacts to changes in the destinations list
Attempt prime
current connection opening attempt on the prime track (if any)
keeps track of HappyConnOpener spare track waiting state
HappySpareWaitList::iterator position
CodeContext::Pointer codeContext
requestor's context
AsyncCall::Pointer callback
a pending noteGavePrimeItsChance() or noteSpareAllowance() call
err_type
Definition: forward.h:14

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors