[thirdparty/squid.git] / src / PeerDigest.h

/*
 * Copyright (C) 1996-2025 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_PEERDIGEST_H
#define SQUID_SRC_PEERDIGEST_H

#if USE_CACHE_DIGESTS

#include "cbdata.h"
#include "StatCounters.h"

class Version
{
public:
    short int current;      /* current version */
    short int required;     /* minimal version that can safely handle current version */
};

/* digest control block; used for transmission and storage */

class StoreDigestCBlock
{
public:
    Version ver;
    int capacity;
    int count;
    int del_count;
    int mask_size;
    unsigned char bits_per_entry;
    unsigned char hash_func_count;
    short int reserved_short;
    int reserved[32 - 6];
};

class HttpRequest;
class PeerDigest;
class store_client;

class DigestFetchState
{
    CBDATA_CLASS(DigestFetchState);

public:
    DigestFetchState(PeerDigest *,HttpRequest *);
    ~DigestFetchState();

    CbcPointer<PeerDigest> pd;
    StoreEntry *entry;
    StoreEntry *old_entry;
    store_client *sc;
    store_client *old_sc;
    HttpRequest *request;
    int offset;
    uint32_t mask_offset;
    time_t start_time;
    time_t resp_time;
    time_t expires;

    struct {
        int msg;
        int bytes;
    } sent, recv;

    char buf[SM_PAGE_SIZE];
    ssize_t bufofs;
    digest_read_state_t state;
};

class PeerDigest
{
    CBDATA_CLASS(PeerDigest);

public:
    PeerDigest(CachePeer *);
    ~PeerDigest();

    /// reacts to digest transfer completion
    /// \prec DigestFetchState stats were finalized (by calling peerDigestFetchSetStats())
    void noteFetchFinished(const DigestFetchState &, const char *outcomeDescription, bool sawError);

    CbcPointer<CachePeer> peer; ///< pointer back to peer structure, argh
    CacheDigest *cd = nullptr;            /**< actual digest structure */
    const SBuf host; ///< copy of peer->host
    const char *req_result = nullptr;     /**< text status of the last request */

    struct {
        bool needed = false;          /**< there were requests for this digest */
        bool usable = false;          /**< can be used for lookups */
        bool requested = false;       /**< in process of receiving [fresh] digest */
    } flags;

    struct {
        /* all times are absolute unless augmented with _delay */
        time_t initialized = 0; /* creation */
        time_t needed = 0;      /* first lookup/use by a peer */
        time_t next_check = 0;  /* next scheduled check/refresh event */
        time_t retry_delay = 0; /* delay before re-checking _invalid_ digest */
        time_t requested = 0;   /* requested a fresh copy of a digest */
        time_t req_delay = 0;   /* last request response time */
        time_t received = 0;    /* received the current copy of a digest */
        time_t disabled = 0;    /* disabled for good */
    } times;

    struct {
        CacheDigestGuessStats guess;
        int used_count = 0;

        struct {
            int msgs = 0;
            ByteCounter kbytes;
        } sent, recv;
    } stats;
};

extern const Version CacheDigestVer;

void peerDigestNeeded(PeerDigest * pd);
void peerDigestNotePeerGone(PeerDigest * pd);
void peerDigestStatsReport(const PeerDigest * pd, StoreEntry * e);

#endif /* USE_CACHE_DIGESTS */

#endif /* SQUID_SRC_PEERDIGEST_H */
Commit	Line	Data
	1	/*
	2	* Copyright (C) 1996-2025 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_SRC_PEERDIGEST_H
	10	#define SQUID_SRC_PEERDIGEST_H
	11
	12	#if USE_CACHE_DIGESTS
	13
	14	#include "cbdata.h"
	15	#include "StatCounters.h"
	16
	17	class Version
	18	{
	19	public:
	20	short int current; /* current version */
	21	short int required; /* minimal version that can safely handle current version */
	22	};
	23
	24	/* digest control block; used for transmission and storage */
	25
	26	class StoreDigestCBlock
	27	{
	28	public:
	29	Version ver;
	30	int capacity;
	31	int count;
	32	int del_count;
	33	int mask_size;
	34	unsigned char bits_per_entry;
	35	unsigned char hash_func_count;
	36	short int reserved_short;
	37	int reserved[32 - 6];
	38	};
	39
	40	class HttpRequest;
	41	class PeerDigest;
	42	class store_client;
	43
	44	class DigestFetchState
	45	{
	46	CBDATA_CLASS(DigestFetchState);
	47
	48	public:
	49	DigestFetchState(PeerDigest ,HttpRequest );
	50	~DigestFetchState();
	51
	52	CbcPointer<PeerDigest> pd;
	53	StoreEntry *entry;
	54	StoreEntry *old_entry;
	55	store_client *sc;
	56	store_client *old_sc;
	57	HttpRequest *request;
	58	int offset;
	59	uint32_t mask_offset;
	60	time_t start_time;
	61	time_t resp_time;
	62	time_t expires;
	63
	64	struct {
	65	int msg;
	66	int bytes;
	67	} sent, recv;
	68
	69	char buf[SM_PAGE_SIZE];
	70	ssize_t bufofs;
	71	digest_read_state_t state;
	72	};
	73
	74	class PeerDigest
	75	{
	76	CBDATA_CLASS(PeerDigest);
	77
	78	public:
	79	PeerDigest(CachePeer *);
	80	~PeerDigest();
	81
	82	/// reacts to digest transfer completion
	83	/// \prec DigestFetchState stats were finalized (by calling peerDigestFetchSetStats())
	84	void noteFetchFinished(const DigestFetchState &, const char *outcomeDescription, bool sawError);
	85
	86	CbcPointer<CachePeer> peer; ///< pointer back to peer structure, argh
	87	CacheDigest cd = nullptr; /< actual digest structure /
	88	const SBuf host; ///< copy of peer->host
	89	const char req_result = nullptr; /< text status of the last request /
	90
	91	struct {
	92	bool needed = false; /*< there were requests for this digest /
	93	bool usable = false; /*< can be used for lookups /
	94	bool requested = false; /*< in process of receiving [fresh] digest /
	95	} flags;
	96
	97	struct {
	98	/* all times are absolute unless augmented with _delay */
	99	time_t initialized = 0; /* creation */
	100	time_t needed = 0; /* first lookup/use by a peer */
	101	time_t next_check = 0; /* next scheduled check/refresh event */
	102	time_t retry_delay = 0; /* delay before re-checking _invalid_ digest */
	103	time_t requested = 0; /* requested a fresh copy of a digest */
	104	time_t req_delay = 0; /* last request response time */
	105	time_t received = 0; /* received the current copy of a digest */
	106	time_t disabled = 0; /* disabled for good */
	107	} times;
	108
	109	struct {
	110	CacheDigestGuessStats guess;
	111	int used_count = 0;
	112
	113	struct {
	114	int msgs = 0;
	115	ByteCounter kbytes;
	116	} sent, recv;
	117	} stats;
	118	};
	119
	120	extern const Version CacheDigestVer;
	121
	122	void peerDigestNeeded(PeerDigest * pd);
	123	void peerDigestNotePeerGone(PeerDigest * pd);
	124	void peerDigestStatsReport(const PeerDigest * pd, StoreEntry * e);
	125
	126	#endif /* USE_CACHE_DIGESTS */
	127
	128	#endif /* SQUID_SRC_PEERDIGEST_H */
	129