HappyConnOpener.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2021 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_HAPPYCONNOPENER_H
#define SQUID_HAPPYCONNOPENER_H
#include "base/RefCount.h"
#include "comm.h"
#include "comm/Connection.h"
#include "comm/ConnOpener.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;
 
    template <class Initiator>
    class CbDialer: public CallDialer, public Answer {
    public:
        // initiator method to receive our answer
        typedef void (Initiator::*Method)(Answer &);
 
        CbDialer(Method method, Initiator *initiator): initiator_(initiator), method_(method) {}
        virtual ~CbDialer() = default;
 
        /* CallDialer API */
        bool canDial(AsyncCall &) { return initiator_.valid(); }
        void dial(AsyncCall &) {((*initiator_).*method_)(*this); }
        virtual void print(std::ostream &os) const override {
            os << '(' << static_cast<const Answer&>(*this) << ')';
        }
 
    private:
        CbcPointer<Initiator> initiator_; 
        Method method_; 
    };
 
public:
    HappyConnOpener(const ResolvedPeersPointer &, const AsyncCall::Pointer &,  HttpRequestPointer &, const time_t aFwdStart, int tries, const AccessLogEntryPointer &al);
    virtual ~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 */
    virtual void start() override;
    virtual bool doneAll() const override;
    virtual void swanSong() override;
    virtual 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; 
 
    AsyncCall::Pointer 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