PeerSelectState.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_PEERSELECTSTATE_H
#define SQUID_SRC_PEERSELECTSTATE_H
 
#include "AccessLogEntry.h"
#include "acl/Checklist.h"
#include "base/CbcPointer.h"
#include "comm/forward.h"
#include "hier_code.h"
#include "ip/Address.h"
#include "ipcache.h"
#include "mem/forward.h"
#include "PingData.h"
#include "typedefs.h" /* for IRCB */
 
class ErrorState;
class HtcpReplyData;
class HttpRequest;
class icp_common_t;
class StoreEntry;
 
void peerSelectInit(void);
 
class PeerSelectionInitiator: public CbdataParent
{
public:
    ~PeerSelectionInitiator() override = default;
 
    virtual void noteDestination(Comm::ConnectionPointer path) = 0;
 
    virtual void noteDestinationsEnd(ErrorState *error) = 0;
 
    bool subscribed = false;
 
    /* protected: */
    void startSelectingDestinations(HttpRequest *request, const AccessLogEntry::Pointer &ale, StoreEntry *entry);
};
 
class FwdServer;
 
class PeerSelector: public Dns::IpReceiver
{
    CBDATA_CHILD(PeerSelector);
 
public:
    explicit PeerSelector(PeerSelectionInitiator*);
    ~PeerSelector() override;
 
    /* Dns::IpReceiver API */
    void noteIp(const Ip::Address &ip) override;
    void noteIps(const Dns::CachedIps *ips, const Dns::LookupDetails &details) override;
    void noteLookup(const Dns::LookupDetails &details) override;
 
    // Produce a URL for display identifying the transaction we are
    // trying to locate a peer for.
    const SBuf url() const;
 
    PeerSelectionInitiator *interestedInitiator();
 
    bool wantsMoreDestinations() const;
 
    void handlePath(const Comm::ConnectionPointer &path, FwdServer &fs);
 
    void selectMore();
 
    void startPingWaiting();
 
    void cancelPingTimeoutMonitoring();
 
    static void HandlePingTimeout(PeerSelector *);
 
    HttpRequest *request;
    AccessLogEntry::Pointer al; 
    StoreEntry *entry;
 
    void *peerCountMcastPeerXXX = nullptr; 
 
    ping_data ping;
 
protected:
    bool selectionAborted();
 
    void handlePingTimeout();
    void handleIcpReply(CachePeer*, const peer_t, icp_common_t *header);
    void handleIcpParentMiss(CachePeer*, icp_common_t*);
#if USE_HTCP
    void handleHtcpParentMiss(CachePeer*, HtcpReplyData*);
    void handleHtcpReply(CachePeer*, const peer_t, HtcpReplyData*);
#endif
 
    int checkNetdbDirect();
    void checkAlwaysDirectDone(const Acl::Answer answer);
    void checkNeverDirectDone(const Acl::Answer answer);
 
    void selectSomeNeighbor();
    void selectSomeNeighborReplies();
    void selectSomeDirect();
    void selectSomeParent();
    void selectAllParents();
    void selectPinned();
 
    void addSelection(CachePeer*, const hier_code);
 
    void resolveSelected();
 
    static IRCB HandlePingReply;
    static ACLCB CheckAlwaysDirectDone;
    static ACLCB CheckNeverDirectDone;
 
private:
    Acl::Answer always_direct;
    Acl::Answer never_direct;
    int direct;   // TODO: fold always_direct/never_direct/prefer_direct into this now that ACL can do a multi-state result.
    size_t foundPaths = 0; 
    ErrorState *lastError;
 
    FwdServer *servers; 
 
    /*
     * Why are these Ip::Address instead of CachePeer *?  Because a
     * CachePeer structure can become invalid during the CachePeer selection
     * phase, specifically after a reconfigure.  Thus we need to lookup
     * the CachePeer * based on the address when we are finally ready to
     * reference the CachePeer structure.
     */
 
    Ip::Address first_parent_miss;
 
    Ip::Address closest_parent_miss;
    /*
     * ->hit can be CachePeer* because it should only be
     * accessed during the thread when it is set
     */
    CachePeer *hit;
    peer_t hit_type;
 
    typedef CbcPointer<PeerSelectionInitiator> Initiator;
    Initiator initiator_; 
 
    const InstanceId<PeerSelector> id; 
};
 
#endif /* SQUID_SRC_PEERSELECTSTATE_H */