Passa al contenuto principale

4.2.3. Calculating Age (计算年龄)

🇬🇧 English​

The Age header field is used to convey an estimated age of the response message when obtained from a cache. The Age field value is the cache's estimate of the number of seconds since the response was generated or validated by the origin server. In essence, the Age value is the sum of the time that the response has been resident in each of the caches along the path from the origin server, plus the amount of time it has been in transit along network paths.

The following data is used for the age calculation:

age_value: The term "age_value" denotes the value of the Age header field (Section 5.1), in a form appropriate for arithmetic operation; or 0, if not available.

date_value: The term "date_value" denotes the value of the Date header field, in a form appropriate for arithmetic operations. See Section 7.1.1.2 of [RFC7231] for the definition of the Date header field, and for requirements regarding responses without it.

now: The term "now" means "the current value of the clock at the host performing the calculation". A host ought to use NTP ([RFC5905]) or some similar protocol to synchronize its clocks to Coordinated Universal Time.

request_time: The current value of the clock at the host at the time the request resulting in the stored response was made.

response_time: The current value of the clock at the host at the time the response was received.

A response's age can be calculated in two entirely independent ways:

  1. the "apparent_age": response_time minus date_value, if the local clock is reasonably well synchronized to the origin server's clock. If the result is negative, the result is replaced by zero.

  2. the "corrected_age_value", if all of the caches along the response path implement HTTP/1.1. A cache MUST interpret this value relative to the time the request was initiated, not the time that the response was received.

apparent_age = max(0, response_time - date_value);

response_delay = response_time - request_time;
corrected_age_value = age_value + response_delay;

These are combined as

corrected_initial_age = max(apparent_age, corrected_age_value);

unless the cache is confident in the value of the Age header field (e.g., because there are no HTTP/1.0 hops in the Via header field), in which case the corrected_age_value MAY be used as the corrected_initial_age.

The current_age of a stored response can then be calculated by adding the amount of time (in seconds) since the stored response was last validated by the origin server to the corrected_initial_age.

resident_time = now - response_time;
current_age = corrected_initial_age + resident_time;

🇨🇳 中文​

Age头字段用于传达从缓存获取响应消息时的估计年龄。Age字段值是缓存对自响应由源服务器生成或验证以来的秒数的估计。本质上，Age值是响应在从源服务器到达路径上的每个缓存中驻留的时间总和，加上它在网络路径上传输所花费的时间。

以下数据用于年龄计算:

age_value: 术语"age_value"表示Age头字段（第5.1节）的值，采用适合算术运算的形式; 如果不可用，则为0。

date_value: 术语"date_value"表示Date头字段的值，采用适合算术运算的形式。有关Date头字段的定义以及没有它的响应的要求，请参见 [RFC7231] 的第7.1.1.2节。

now: 术语"now"表示"执行计算的主机上时钟的当前值"。主机应使用NTP（[RFC5905]）或类似协议将其时钟同步到协调世界时。

request_time: 发出导致存储响应的请求时主机上时钟的当前值。

response_time: 接收响应时主机上时钟的当前值。

响应的年龄可以通过两种完全独立的方式计算:

  1. "apparent_age"（表观年龄）: response_time减去date_value，前提是本地时钟与源服务器的时钟合理同步。如果结果为负，则结果替换为零。

  2. "corrected_age_value"（校正年龄值），前提是响应路径上的所有缓存都实现HTTP/1.1。缓存必须 (MUST) 相对于发起请求的时间（而非接收响应的时间）解释此值。

apparent_age = max(0, response_time - date_value);

response_delay = response_time - request_time;
corrected_age_value = age_value + response_delay;

这些组合为

corrected_initial_age = max(apparent_age, corrected_age_value);

除非缓存对Age头字段的值有信心（例如，因为Via头字段中没有HTTP/1.0跃点），在这种情况下，corrected_age_value可以 (MAY) 用作corrected_initial_age。

然后可以通过将自存储响应上次由源服务器验证以来的时间量（以秒为单位）添加到corrected_initial_age来计算存储响应的current_age。

resident_time = now - response_time;
current_age = corrected_initial_age + resident_time;

🇯🇵 日本語​

Ageヘッダーフィールドは、キャッシュから取得した場合のレスポンスメッセージの推定経過時間を伝えるために使用される。Ageフィールド値は、レスポンスがオリジンサーバーによって生成または検証されてからの秒数に関するキャッシュの推定値である。本質的に、Age値は、レスポンスがオリジンサーバーからのパスに沿った各キャッシュに常駐していた時間の合計と、ネットワークパスに沿って転送中であった時間の量である。

次のデータが経過時間の計算に使用される:

age_value: 用語"age_value"は、算術演算に適した形式のAgeヘッダーフィールド（セクション5.1）の値を示す; 利用できない場合は0。

date_value: 用語"date_value"は、算術演算に適した形式のDateヘッダーフィールドの値を示す。Dateヘッダーフィールドの定義、およびそれを持たないレスポンスに関する要件については、[RFC7231] のセクション7.1.1.2を参照。

now: 用語"now"は「計算を実行しているホストでの時計の現在の値」を意味する。ホストは、NTP（[RFC5905]）または類似のプロトコルを使用して、時計を協定世界時に同期すべきである (ought to)。

request_time: 保存されたレスポンスをもたらしたリクエストが行われた時点でのホストでの時計の現在値。

response_time: レスポンスが受信された時点でのホストでの時計の現在値。

レスポンスの経過時間は、2つの完全に独立した方法で計算できる:

  1. "apparent_age"（見かけの経過時間）: ローカル時計がオリジンサーバーの時計と合理的に同期している場合、response_timeからdate_valueを引いたもの。結果が負の場合、結果はゼロに置き換えられる。

  2. "corrected_age_value"（修正された経過時間値）、レスポンスパスに沿ったすべてのキャッシュがHTTP/1.1を実装している場合。キャッシュは、この値をレスポンスが受信された時刻ではなく、リクエストが開始された時刻を基準として解釈しなければならない (MUST)。

apparent_age = max(0, response_time - date_value);

response_delay = response_time - request_time;
corrected_age_value = age_value + response_delay;

これらは次のように結合される

corrected_initial_age = max(apparent_age, corrected_age_value);

キャッシュがAgeヘッダーフィールドの値に信頼を持っている場合（例えば、ViaヘッダーフィールドにHTTP/1.0ホップがないため）を除き、その場合、corrected_age_valueをcorrected_initial_ageとして使用してもよい (MAY)。

次に、保存されたレスポンスがオリジンサーバーによって最後に検証されてからの時間量（秒単位）をcorrected_initial_ageに追加することによって、保存されたレスポンスのcurrent_ageを計算できる。

resident_time = now - response_time;
current_age = corrected_initial_age + resident_time;

🇫🇷 Français​

Le champ d'en-tête Age est utilisé pour transmettre un âge estimé du message de réponse lorsqu'il est obtenu à partir d'un cache. La valeur du champ Age est l'estimation du cache du nombre de secondes depuis que la réponse a été générée ou validée par le serveur d'origine. En essence, la valeur Age est la somme du temps pendant lequel la réponse a résidé dans chacun des caches le long du chemin depuis le serveur d'origine, plus le temps qu'elle a passé en transit le long des chemins réseau.

Les données suivantes sont utilisées pour le calcul de l'âge :

age_value : Le terme "age_value" désigne la valeur du champ d'en-tête Age (Section 5.1), sous une forme appropriée pour une opération arithmétique ; ou 0, s'il n'est pas disponible.

date_value : Le terme "date_value" désigne la valeur du champ d'en-tête Date, sous une forme appropriée pour des opérations arithmétiques. Voir Section 7.1.1.2 de [RFC7231] pour la définition du champ d'en-tête Date, et pour les exigences concernant les réponses sans celui-ci.

now : Le terme "now" signifie "la valeur actuelle de l'horloge sur l'hôte effectuant le calcul". Un hôte devrait (ought to) utiliser NTP ([RFC5905]) ou un protocole similaire pour synchroniser ses horloges avec le Temps universel coordonné.

request_time : La valeur actuelle de l'horloge sur l'hôte au moment où la requête résultant en la réponse stockée a été effectuée.

response_time : La valeur actuelle de l'horloge sur l'hôte au moment où la réponse a été reçue.

L'âge d'une réponse peut être calculé de deux manières entièrement indépendantes :

  1. l'"apparent_age" (âge apparent) : response_time moins date_value, si l'horloge locale est raisonnablement bien synchronisée avec l'horloge du serveur d'origine. Si le résultat est négatif, le résultat est remplacé par zéro.

  2. le "corrected_age_value" (valeur d'âge corrigée), si tous les caches le long du chemin de réponse implémentent HTTP/1.1. Un cache DOIT (MUST) interpréter cette valeur par rapport au moment où la requête a été initiée, et non au moment où la réponse a été reçue.

apparent_age = max(0, response_time - date_value);

response_delay = response_time - request_time;
corrected_age_value = age_value + response_delay;

Ceux-ci sont combinés comme

corrected_initial_age = max(apparent_age, corrected_age_value);

à moins que le cache ne soit confiant dans la valeur du champ d'en-tête Age (par exemple, parce qu'il n'y a pas de sauts HTTP/1.0 dans le champ d'en-tête Via), auquel cas le corrected_age_value PEUT (MAY) être utilisé comme corrected_initial_age.

Le current_age d'une réponse stockée peut alors être calculé en ajoutant le temps (en secondes) depuis que la réponse stockée a été validée pour la dernière fois par le serveur d'origine au corrected_initial_age.

resident_time = now - response_time;
current_age = corrected_initial_age + resident_time;

🇩🇪 Deutsch​

Das Age-Header-Feld wird verwendet, um ein geschätztes Alter der Antwortnachricht zu übermitteln, wenn sie aus einem Cache bezogen wird. Der Age-Feldwert ist die Schätzung des Caches für die Anzahl der Sekunden seit der Erzeugung oder Validierung der Antwort durch den Ursprungsserver. Im Wesentlichen ist der Age-Wert die Summe der Zeit, die die Antwort in jedem der Caches entlang des Pfads vom Ursprungsserver verweilte, plus der Zeit, die sie auf Netzwerkpfaden unterwegs war.

Die folgenden Daten werden für die Altersberechnung verwendet:

age_value: Der Begriff "age_value" bezeichnet den Wert des Age-Header-Felds (Abschnitt 5.1) in einer für arithmetische Operationen geeigneten Form; oder 0, falls nicht verfügbar.

date_value: Der Begriff "date_value" bezeichnet den Wert des Date-Header-Felds in einer für arithmetische Operationen geeigneten Form. Siehe Abschnitt 7.1.1.2 von [RFC7231] für die Definition des Date-Header-Felds und für Anforderungen bezüglich Antworten ohne dieses.

now: Der Begriff "now" bedeutet "der aktuelle Wert der Uhr auf dem Host, der die Berechnung durchführt". Ein Host sollte (ought to) NTP ([RFC5905]) oder ein ähnliches Protokoll verwenden, um seine Uhren mit der koordinierten Weltzeit zu synchronisieren.

request_time: Der aktuelle Wert der Uhr auf dem Host zum Zeitpunkt, als die Anfrage gestellt wurde, die zur gespeicherten Antwort führte.

response_time: Der aktuelle Wert der Uhr auf dem Host zum Zeitpunkt, als die Antwort empfangen wurde.

Das Alter einer Antwort kann auf zwei völlig unabhängige Arten berechnet werden:

  1. das "apparent_age" (scheinbare Alter): response_time minus date_value, wenn die lokale Uhr vernünftig gut mit der Uhr des Ursprungsservers synchronisiert ist. Wenn das Ergebnis negativ ist, wird das Ergebnis durch Null ersetzt.

  2. der "corrected_age_value" (korrigierte Alterswert), wenn alle Caches entlang des Antwortpfads HTTP/1.1 implementieren. Ein Cache MUSS (MUST) diesen Wert relativ zur Zeit interpretieren, zu der die Anfrage initiiert wurde, nicht zur Zeit, zu der die Antwort empfangen wurde.

apparent_age = max(0, response_time - date_value);

response_delay = response_time - request_time;
corrected_age_value = age_value + response_delay;

Diese werden kombiniert als

corrected_initial_age = max(apparent_age, corrected_age_value);

es sei denn, der Cache ist sicher im Wert des Age-Header-Felds (z. B., weil es keine HTTP/1.0-Hops im Via-Header-Feld gibt), in diesem Fall DARF (MAY) der corrected_age_value als corrected_initial_age verwendet werden.

Das current_age einer gespeicherten Antwort kann dann berechnet werden, indem die Zeit (in Sekunden) seit der letzten Validierung der gespeicherten Antwort durch den Ursprungsserver zum corrected_initial_age addiert wird.

resident_time = now - response_time;
current_age = corrected_initial_age + resident_time;

🇮🇹 Italiano​

Il campo di intestazione Age viene utilizzato per trasmettere un'età stimata del messaggio di risposta quando ottenuto da una cache. Il valore del campo Age è la stima della cache del numero di secondi trascorsi da quando la risposta è stata generata o validata dal server di origine. In sostanza, il valore Age è la somma del tempo in cui la risposta è rimasta in ciascuna delle cache lungo il percorso dal server di origine, più il tempo in cui è stata in transito lungo i percorsi di rete.

I seguenti dati vengono utilizzati per il calcolo dell'età:

age_value: Il termine "age_value" indica il valore del campo di intestazione Age (Sezione 5.1), in una forma appropriata per operazioni aritmetiche; o 0, se non disponibile.

date_value: Il termine "date_value" indica il valore del campo di intestazione Date, in una forma appropriata per operazioni aritmetiche. Vedere Sezione 7.1.1.2 di [RFC7231] per la definizione del campo di intestazione Date e per i requisiti riguardanti le risposte senza di esso.

now: Il termine "now" significa "il valore corrente dell'orologio sull'host che esegue il calcolo". Un host dovrebbe (ought to) utilizzare NTP ([RFC5905]) o un protocollo simile per sincronizzare i suoi orologi con il Tempo universale coordinato.

request_time: Il valore corrente dell'orologio sull'host al momento in cui è stata effettuata la richiesta che ha portato alla risposta memorizzata.

response_time: Il valore corrente dell'orologio sull'host al momento in cui la risposta è stata ricevuta.

L'età di una risposta può essere calcolata in due modi completamente indipendenti:

  1. l'"apparent_age" (età apparente): response_time meno date_value, se l'orologio locale è ragionevolmente ben sincronizzato con l'orologio del server di origine. Se il risultato è negativo, il risultato viene sostituito con zero.

  2. il "corrected_age_value" (valore dell'età corretto), se tutte le cache lungo il percorso della risposta implementano HTTP/1.1. Una cache DEVE (MUST) interpretare questo valore relativamente al momento in cui la richiesta è stata avviata, non al momento in cui la risposta è stata ricevuta.

apparent_age = max(0, response_time - date_value);

response_delay = response_time - request_time;
corrected_age_value = age_value + response_delay;

Questi sono combinati come

corrected_initial_age = max(apparent_age, corrected_age_value);

a meno che la cache non sia sicura del valore del campo di intestazione Age (ad esempio, perché non ci sono hop HTTP/1.0 nel campo di intestazione Via), nel qual caso il corrected_age_value PUÒ (MAY) essere utilizzato come corrected_initial_age.

Il current_age di una risposta memorizzata può quindi essere calcolato aggiungendo il tempo (in secondi) trascorso dall'ultima validazione della risposta memorizzata da parte del server di origine al corrected_initial_age.

resident_time = now - response_time;
current_age = corrected_initial_age + resident_time;

4.2.4. Serving Stale Responses (提供过期响应)

🇬🇧 English​

A "stale" response is one that either has explicit expiry information or is allowed to have heuristic expiry calculated, but is not fresh according to the calculations in Section 4.2.

A cache MUST NOT generate a stale response if it is prohibited by an explicit in-protocol directive (e.g., by a "no-store" or "no-cache" cache directive, a "must-revalidate" cache-response-directive, or an applicable "s-maxage" or "proxy-revalidate" cache-response-directive; see Section 5.2.2).

A cache MUST NOT send stale responses unless it is disconnected (i.e., it cannot contact the origin server or otherwise find a forward path) or doing so is explicitly allowed (e.g., by the max-stale request directive; see Section 5.2.1).

A cache SHOULD generate a Warning header field with the 110 warn-code (see Section 5.5.1) in stale responses. Likewise, a cache SHOULD generate a 112 warn-code (see Section 5.5.3) in stale responses if the cache is disconnected.

A cache SHOULD NOT generate a new Warning header field when forwarding a response that does not have an Age header field, even if the response is already stale. A cache need not validate a response that merely became stale in transit.

🇨🇳 中文​

"过期"(Stale) 响应是具有显式过期信息或允许计算启发式过期但根据第4.2节的计算不新鲜的响应。

如果被显式的协议内指令禁止（例如，通过"no-store"或"no-cache"缓存指令、"must-revalidate"缓存响应指令，或适用的"s-maxage"或"proxy-revalidate"缓存响应指令; 见第5.2.2节），则缓存不得 (MUST NOT) 生成过期响应。

除非缓存已断开连接（即，无法联系源服务器或以其他方式找到转发路径），或者明确允许这样做（例如，通过max-stale请求指令; 见第5.2.1节），否则缓存不得 (MUST NOT) 发送过期响应。

缓存应该 (SHOULD) 在过期响应中生成带有110 warn-code的Warning头字段（见第5.5.1节）。同样，如果缓存已断开连接，则缓存应该 (SHOULD) 在过期响应中生成112 warn-code（见第5.5.3节）。

当转发没有Age头字段的响应时，即使响应已经过期，缓存也不应该 (SHOULD NOT) 生成新的Warning头字段。缓存不需要验证仅在传输过程中变得过期的响应。

🇯🇵 日本語​

"古い"(Stale) レスポンスとは、明示的な有効期限情報を持つか、ヒューリスティック有効期限の計算が許可されているが、セクション4.2の計算によると新鮮ではないレスポンスである。

明示的なプロトコル内ディレクティブ（例えば、"no-store"または"no-cache"キャッシュディレクティブ、"must-revalidate"キャッシュレスポンスディレクティブ、または該当する"s-maxage"または"proxy-revalidate"キャッシュレスポンスディレクティブ; セクション5.2.2参照）によって禁止されている場合、キャッシュは古いレスポンスを生成してはならない (MUST NOT)。

キャッシュが切断されている（つまり、オリジンサーバーに接触できないか、他の方法でフォワードパスを見つけることができない）場合、または明示的に許可されている場合（例えば、max-staleリクエストディレクティブによって; セクション5.2.1参照）を除き、キャッシュは古いレスポンスを送信してはならない (MUST NOT)。

キャッシュは、古いレスポンスに110 warn-code（セクション5.5.1参照）を含むWarningヘッダーフィールドを生成すべきである (SHOULD)。同様に、キャッシュが切断されている場合、キャッシュは古いレスポンスに112 warn-code（セクション5.5.3参照）を生成すべきである (SHOULD)。

キャッシュは、レスポンスがすでに古い場合でも、Ageヘッダーフィールドを持たないレスポンスを転送するときに新しいWarningヘッダーフィールドを生成すべきではない (SHOULD NOT)。キャッシュは、単に転送中に古くなったレスポンスを検証する必要はない。

🇫🇷 Français​

Une réponse "périmée" (Stale) est une réponse qui possède des informations d'expiration explicites ou est autorisée à avoir une expiration heuristique calculée, mais n'est pas fraîche selon les calculs de la Section 4.2.

Un cache NE DOIT PAS (MUST NOT) générer une réponse périmée si cela est interdit par une directive explicite du protocole (par exemple, par une directive de cache "no-store" ou "no-cache", une directive de cache-réponse "must-revalidate", ou une directive de cache-réponse applicable "s-maxage" ou "proxy-revalidate" ; voir Section 5.2.2).

Un cache NE DOIT PAS (MUST NOT) envoyer de réponses périmées à moins qu'il ne soit déconnecté (c'est-à-dire qu'il ne peut pas contacter le serveur d'origine ou trouver autrement un chemin de transmission) ou que cela soit explicitement autorisé (par exemple, par la directive de requête max-stale ; voir Section 5.2.1).

Un cache DEVRAIT (SHOULD) générer un champ d'en-tête Warning avec le warn-code 110 (voir Section 5.5.1) dans les réponses périmées. De même, un cache DEVRAIT (SHOULD) générer un warn-code 112 (voir Section 5.5.3) dans les réponses périmées si le cache est déconnecté.

Un cache NE DEVRAIT PAS (SHOULD NOT) générer un nouveau champ d'en-tête Warning lors de la transmission d'une réponse qui n'a pas de champ d'en-tête Age, même si la réponse est déjà périmée. Un cache n'a pas besoin de valider une réponse qui est simplement devenue périmée pendant le transit.

🇩🇪 Deutsch​

Eine "veraltete" (Stale) Antwort ist eine Antwort, die entweder explizite Ablaufinformationen hat oder eine heuristische Ablaufberechnung zulässt, aber gemäß den Berechnungen in Abschnitt 4.2 nicht frisch ist.

Ein Cache DARF NICHT (MUST NOT) eine veraltete Antwort generieren, wenn dies durch eine explizite Protokolldirektive verboten ist (z. B. durch eine "no-store"- oder "no-cache"-Cache-Direktive, eine "must-revalidate"-Cache-Response-Direktive oder eine anwendbare "s-maxage"- oder "proxy-revalidate"-Cache-Response-Direktive; siehe Abschnitt 5.2.2).

Ein Cache DARF NICHT (MUST NOT) veraltete Antworten senden, es sei denn, er ist getrennt (d. h., er kann den Ursprungsserver nicht kontaktieren oder anderweitig einen Weiterleitungspfad finden) oder dies ist ausdrücklich erlaubt (z. B. durch die max-stale-Anfragedirektive; siehe Abschnitt 5.2.1).

Ein Cache SOLLTE (SHOULD) ein Warning-Header-Feld mit dem 110-Warn-Code (siehe Abschnitt 5.5.1) in veralteten Antworten generieren. Ebenso SOLLTE (SHOULD) ein Cache einen 112-Warn-Code (siehe Abschnitt 5.5.3) in veralteten Antworten generieren, wenn der Cache getrennt ist.

Ein Cache SOLLTE NICHT (SHOULD NOT) ein neues Warning-Header-Feld generieren, wenn er eine Antwort weiterleitet, die kein Age-Header-Feld hat, selbst wenn die Antwort bereits veraltet ist. Ein Cache muss eine Antwort nicht validieren, die lediglich während der Übertragung veraltet ist.

🇮🇹 Italiano​

Una risposta "obsoleta" (Stale) è una risposta che ha informazioni di scadenza esplicite o è autorizzata ad avere una scadenza euristica calcolata, ma non è fresca secondo i calcoli nella Sezione 4.2.

Una cache NON DEVE (MUST NOT) generare una risposta obsoleta se è proibito da una direttiva esplicita del protocollo (ad esempio, da una direttiva di cache "no-store" o "no-cache", una direttiva di cache-risposta "must-revalidate", o una direttiva di cache-risposta applicabile "s-maxage" o "proxy-revalidate"; vedere Sezione 5.2.2).

Una cache NON DEVE (MUST NOT) inviare risposte obsolete a meno che non sia disconnessa (cioè, non possa contattare il server di origine o altrimenti trovare un percorso di inoltro) o ciò sia esplicitamente consentito (ad esempio, dalla direttiva di richiesta max-stale; vedere Sezione 5.2.1).

Una cache DOVREBBE (SHOULD) generare un campo di intestazione Warning con il warn-code 110 (vedere Sezione 5.5.1) nelle risposte obsolete. Allo stesso modo, una cache DOVREBBE (SHOULD) generare un warn-code 112 (vedere Sezione 5.5.3) nelle risposte obsolete se la cache è disconnessa.

Una cache NON DOVREBBE (SHOULD NOT) generare un nuovo campo di intestazione Warning quando inoltra una risposta che non ha un campo di intestazione Age, anche se la risposta è già obsoleta. Una cache non ha bisogno di validare una risposta che è semplicemente diventata obsoleta durante il transito.

📝 翻译说明 (Translation Notes)

  • 4.2.3 核心算法: Age计算是HTTP缓存最复杂的算法之一，涉及多个时间变量和公式，所有语言版本都精确保留了算法公式和变量名
  • 数学公式: max(), apparent_age, corrected_age_value等在所有语言中保持英文，确保技术实现的一致性
  • 4.2.4 关键指令: must-revalidate, no-cache, no-store等指令的法律级严谨性在所有语言版本中得到保持
  • Warning机制: 110和112 warn-code的精确用法在所有语言中都得到了准确传达
Ultimo aggiornamento il