HappyConnOpener.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 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_SRC_HAPPYCONNOPENER_H
#define SQUID_SRC_HAPPYCONNOPENER_H
#include "base/AsyncCallbacks.h"
#include "base/JobWait.h"
#include "base/RefCount.h"
#include "comm.h"
#include "comm/Connection.h"
#include "comm/ConnOpener.h"
#include "errorpage.h"
#include "http/forward.h"
#include "log/forward.h"
#include "ResolvedPeers.h"
 
#include <iosfwd>
 
class HappyConnOpener;
class HappyOrderEnforcer;
class JobGapEnforcer;
typedef RefCount<ResolvedPeers> ResolvedPeersPointer;
 
typedef std::list< CbcPointer<HappyConnOpener> > HappySpareWaitList;
 
typedef double HappyAbsoluteTime;
 
class HappySpareWait {
public:
    explicit operator bool() const { return toGivePrimeItsChance || forSpareAllowance || forPrimesToFail || forNewPeer; }
 
    void clear() { *this = HappySpareWait(); }
 
    CodeContext::Pointer codeContext; 
 
    AsyncCall::Pointer callback;
 
    HappySpareWaitList::iterator position;
 
    /* The following four fields represent mutually exclusive wait reasons. */
 
    bool toGivePrimeItsChance = false;
 
    bool forSpareAllowance = false;
 
    bool forPrimesToFail = false;
 
    bool forNewPeer = false;
};
 
class HappyConnOpenerAnswer
{
public:
    ~HappyConnOpenerAnswer();
 
    bool success() const { return !error; }
 
    PeerConnectionPointer conn;
 
    // answer recipients must clear the error member in order to keep its info
    // XXX: We should refcount ErrorState instead of cbdata-protecting it.
    CbcPointer<ErrorState> error; 
 
    int n_tries = 0;
 
    bool reused = false;
};
 
std::ostream &operator <<(std::ostream &, const HappyConnOpenerAnswer &);
 
class HappyConnOpener: public AsyncJob
{
    CBDATA_CHILD(HappyConnOpener);
public:
    typedef HappyConnOpenerAnswer Answer;
 
public:
    HappyConnOpener(const ResolvedPeersPointer &, const AsyncCallback<Answer> &, const HttpRequestPointer &, time_t aFwdStart, int tries, const AccessLogEntryPointer &);
    ~HappyConnOpener() override;
 
    void allowPersistent(bool permitted) { allowPconn_ = permitted; }
 
    void setRetriable(bool retriable) { retriable_ = retriable; }
 
    void setHost(const char *);
 
    void noteCandidatesChange();
 
    void noteGavePrimeItsChance();
 
    void noteSpareAllowance();
 
    HappyAbsoluteTime primeStart = 0;
 
private:
    class Attempt {
    public:
        using CallbackMethod = void (HappyConnOpener::*)(const CommConnectCbParams &);
 
        Attempt(const CallbackMethod method, const char *methodName);
 
        explicit operator bool() const { return static_cast<bool>(path); }
 
        void finish();
 
        void cancel(const char *reason);
 
        PeerConnectionPointer path; 
 
        JobWait<Comm::ConnOpener> connWait;
 
        const CallbackMethod callbackMethod; 
        const char * const callbackMethodName; 
    };
    friend std::ostream &operator <<(std::ostream &, const Attempt &);
 
    /* AsyncJob API */
    void start() override;
    bool doneAll() const override;
    void swanSong() override;
    const char *status() const override;
 
    void maybeOpenPrimeConnection();
    void maybeOpenSpareConnection();
 
    void maybeGivePrimeItsChance();
    void stopGivingPrimeItsChance();
    void stopWaitingForSpareAllowance();
 
    void startConnecting(Attempt &, PeerConnectionPointer &);
    void openFreshConnection(Attempt &, PeerConnectionPointer &);
    bool reuseOldConnection(PeerConnectionPointer &);
 
    void notePrimeConnectDone(const CommConnectCbParams &);
    void noteSpareConnectDone(const CommConnectCbParams &);
    void handleConnOpenerAnswer(Attempt &, const CommConnectCbParams &, const char *connDescription);
 
    void checkForNewConnection();
 
    void updateSpareWaitAfterPrimeFailure();
 
    void cancelSpareWait(const char *reason);
 
    bool ranOutOfTimeOrAttempts() const;
 
    ErrorState *makeError(const err_type type) const;
    Answer *futureAnswer(const PeerConnectionPointer &);
    void sendSuccess(const PeerConnectionPointer &conn, bool reused, const char *connKind);
    void sendFailure();
    void cancelAttempt(Attempt &, const char *reason);
 
    const time_t fwdStart; 
 
    AsyncCallback<Answer> callback_;
 
    ResolvedPeersPointer destinations;
 
    Attempt prime;
 
    Attempt spare;
 
    Comm::ConnectionPointer currentPeer;
 
    HappySpareWait spareWaiting;
    friend class HappyOrderEnforcer;
 
    AccessLogEntryPointer ale; 
 
    ErrorState *lastError = nullptr; 
    PeerConnectionPointer lastFailedConnection; 
 
    bool ignoreSpareRestrictions = false;
 
    bool gotSpareAllowance = false;
 
    bool allowPconn_ = true;
 
    bool retriable_ = true;
 
    const char *host_ = nullptr;
 
    HttpRequestPointer cause;
 
    int n_tries;
 
    mutable const char *ranOutOfTimeOrAttemptsEarlier_ = nullptr;
};
 
#endif /* SQUID_SRC_HAPPYCONNOPENER_H */