Pipelining was added to HTTP/1.1 as a means of improving the performance of persistent connections in common cases. While it is deployed in some limited circumstances, it is not widely used by clients on the open Internet. This memo suggests some measures designed to make it more possible for clients to reliably and safely use HTTP pipelining in these situations.
This memo should be discussed on the email@example.com mailing list, although it is not a work item of the HTTPbis WG.
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at http://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as “work in progress.”
This Internet-Draft will expire on February 11, 2011.
Copyright (c) 2010 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.
3. HTTP Pipelining Issues
4. Discovering Faulty Proxies
5. Identifying Responses
6. Signing Content for Integrity
7. Hinting Pipelinable Content
8. Origin Server Considerations for Pipelining
9. User Agent Considerations for Pipelining
10. Security Considerations
11. IANA Considerations
12.1. Normative References
12.2. Informative References
Appendix A. Acknowledgements
Appendix B. Frequently Asked Questions
§ Author's Address
HTTP/1.1 [RFC2616] (Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., and T. Berners-Lee, “Hypertext Transfer Protocol -- HTTP/1.1,” June 1999.) added pipelining -- that is, the ability to have more than one outstanding request on a connection at a particular time -- to improve performance when many requests need to be made (e.g., when an HTML page references several images).
Although not usable in all circumstances (e.g., POST, PUT and other non-idempotent requests cannot be pipelined), for the common case of Web browsing, pipelining seems at first like a broadly useful improvement -- especially since the number of TCP connections browsers and servers can use for a given interaction is limited, and especially where there is noticeable latency present.
Indeed, in constrained applications of HTTP such as Subversion, pipelining has been shown to improve end-user perceived latency considerably.
However, pipelining is not broadly used on the Web today; while most (but not all) servers and intermediaries support pipelining (to varying degrees), only one major Web browser uses it in its default configuration, and that implementation is reported to use a number of proprietary heuristics to determine when it is safe to pipeline.
This memo characterises issues currently encountered in the use of HTTP pipelining, and suggests the use of mechanisms that, when used in concert, are designed to make its use more reliable and safe for browsers. It does not propose large protocol changes (e.g., out-of-order messages), but rather incremental improvements that can be deployed within the confines of existing infrastructure.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119] (Bradner, S., “Key words for use in RFCs to Indicate Requirement Levels,” March 1997.).
Anecdotal evidence suggests there are a number of reasons why clients don't use HTTP pipelining by default. Briefly, they are:
Note that here, "servers" can also include proxies and other intermediaries.
The remainder of this memo proposes mechanisms that, together, can be used to mitigate these issues.
Issues specific to proxies are limited to the network infrastructure currently used by the client, and it is reasonable to assume that testing the infrastructure at the beginning of a session will indicate how safe it is to pipeline while that infrastructure is in use.
Such issues can be detected by sending pipelined requests to a known server, and examining the responses for errors.
For example, if the ExampleBrowser implementation wishes to probe for faulty proxies, it can send a series of requests to "http://browser.example.com/pipeline-test/" and subresources. If the bodies of the resulting responses deviate from those it expects in any way, it is reasonable to assume that a faulty proxy is present, and pipelining SHOULD NOT be used through it.
Typically, user agents will do this upon startup and changes in the network, although they might periodically test to assure that a new proxy hasn't been interposed.
Note that proxies aren't always configured explicitly.
HTTP relies on the context of the connection to associate a given request with its intended response. In HTTP/1.0, this was a reasonable assumption, since only one request could be outstanding at a given time, and each request had exactly one response.
HTTP/1.1 made associating requests and responses in a given connection more complex (and therefore fault-prone). Not only does pipelining mean that multiple requests can be outstanding, but also the 1xx series of response status codes introduce the possibility of multiple response messages (syntactically) being associated with a single request.
To improve the client's ability to correlate responses with their requests and identify responses that are out of order (as well as serve other potential use cases), this memo introduces the "Assoc-Req" response header field.
Assoc-Req = "Assoc-Req" ":" OWS Assoc-Req-v Assoc-Req-v = Method SP absolute-URI
The field-value of the Assoc-Req header field is the method and effective request URI of the request associated with the response that it appears in. The URI used MUST be generated using the algorithm for finding the Effective Request URI in [I‑D.ietf‑httpbis‑p1‑messaging] (Fielding, R., Gettys, J., Mogul, J., Nielsen, H., Masinter, L., Leach, P., Berners-Lee, T., Lafon, Y., and J. Reschke, “HTTP/1.1, part 1: URIs, Connections, and Message Parsing,” August 2010.). The header field MUST NOT be generated by proxies.
For example, given the following request over port 80:
GET /foo?it HTTP/1.1 Host: www.example.com
the appropriate Assoc-Req header field would be:
Assoc-Req: GET http://www.example.com/foo?it
Note that the Assoc-Req header field is not a perfectly reliable identifier for the request associated with a response; for example, it does not incorporate the selecting headers for content negotiation [I‑D.ietf‑httpbis‑p6‑cache] (Fielding, R., Gettys, J., Mogul, J., Nielsen, H., Masinter, L., Leach, P., Berners-Lee, T., Lafon, Y., Nottingham, M., and J. Reschke, “HTTP/1.1, part 6: Caching,” August 2010.), nor does it differentiate request bodies, when present. However, for the purposes of making pipelining more reliable, it is sufficient.
Clients who wish to use the Assoc-Req response header field to aid in identifying problems in pipelining can compare its values to those of the request that they believe it to be associated with (based upon HTTP's message parsing rules, defined in [I‑D.ietf‑httpbis‑p1‑messaging] (Fielding, R., Gettys, J., Mogul, J., Nielsen, H., Masinter, L., Leach, P., Berners-Lee, T., Lafon, Y., and J. Reschke, “HTTP/1.1, part 1: URIs, Connections, and Message Parsing,” August 2010.)). If either the method or the URI differ, it indicates that there may be a pipelining-related issue.
Another means of protecting against server issues (whether proxy or origin server) is to sign the response content for integrity, so that any corruption becomes apparent.
One existing way to do this is to use the Content-MD5 header field [I‑D.ietf‑httpbis‑p3‑payload] (Fielding, R., Gettys, J., Mogul, J., Nielsen, H., Masinter, L., Leach, P., Berners-Lee, T., Lafon, Y., and J. Reschke, “HTTP/1.1, part 3: Message Payload and Content Negotiation,” August 2010.).
Clients who wish to use the Content-MD5 response header field to aid in identifying corrupted content due to pipelining issues can compare the hash to a calculated hash of the content.
In some circumstances, it may be impractical for the server to buffer the response content in order to calculate a hash before sending it. In these cases, the Content-MD5 response header can be send in an HTTP trailer, provided that the connection is HTTP/1.1 from end to end, and the client is able to process trailers.
Additional means of verifying HTTP response integrity may become available in time.
Finally, to assist clients in determining what requests are suitable for pipelining, we define extensions to allow hinting by origin servers.
Each of these hints indicates URLs that, when dereferenced, will likely not incur significant latency on the server in generating the response, nor significant latency on the network in transferring the response.
What is "significant" is determined by the server. Clients will use these hints to determine what request(s) it is safe to pipeline something else after.
For example, if "http://example.com/a" is hinted, a client can be more confident pipelining another request (e.g., to "http://example.com/b") on the same request afterwards.
To allow flexibility and ease of administration, different kinds of hints are defined:
To maximise the potential for request pipelining from clients that support this specification, origin servers:
To take advantage of the server-side mechanisms defined in this specification, user agents:
Upon encountering an indication of pipelining problems with a particular response (e.g., an incorrect Assoc-Req field-value, an incorrect Content-MD5 field-value), user agents SHOULD discard the response in question, all subsequent responses on the same connection, close the connection. Unsatisfied requests can be resubmitted, without pipelining, and the implementation can choose not to use pipelining to the same server in the future.
|[I-D.ietf-httpbis-p1-messaging]||Fielding, R., Gettys, J., Mogul, J., Nielsen, H., Masinter, L., Leach, P., Berners-Lee, T., Lafon, Y., and J. Reschke, “HTTP/1.1, part 1: URIs, Connections, and Message Parsing,” draft-ietf-httpbis-p1-messaging-11 (work in progress), August 2010 (TXT).|
|[I-D.ietf-httpbis-p3-payload]||Fielding, R., Gettys, J., Mogul, J., Nielsen, H., Masinter, L., Leach, P., Berners-Lee, T., Lafon, Y., and J. Reschke, “HTTP/1.1, part 3: Message Payload and Content Negotiation,” draft-ietf-httpbis-p3-payload-11 (work in progress), August 2010 (TXT).|
|[RFC2119]||Bradner, S., “Key words for use in RFCs to Indicate Requirement Levels,” BCP 14, RFC 2119, March 1997 (TXT, HTML, XML).|
|[I-D.ietf-httpbis-p6-cache]||Fielding, R., Gettys, J., Mogul, J., Nielsen, H., Masinter, L., Leach, P., Berners-Lee, T., Lafon, Y., Nottingham, M., and J. Reschke, “HTTP/1.1, part 6: Caching,” draft-ietf-httpbis-p6-cache-11 (work in progress), August 2010 (TXT).|
|[RFC2616]||Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., and T. Berners-Lee, “Hypertext Transfer Protocol -- HTTP/1.1,” RFC 2616, June 1999 (TXT, PS, PDF, HTML, XML).|
Thanks to Julian Reschke for help in defining the Assoc-Req field-value. The author takes all responsibility for errors and omissions.
Isn't full multiplexing better?
While "full" multiplexing is theoretically better, pipelining -- once usable -- is adequate for almost all common Web browsing cases. Since the browser needs to download HTML first, it has an opportunity to receive hints about subsequent requests and pipeline them appropriately. Likewise, by far the most common case for multiplexing on the Web is when a large number of images and other page assets need to be fetched with GET; a perfect use of pipelining, provided that the client has enough information to avoid head-of-line blocking.
Why not have the client generate a unique request identifier?
While in some ways this would be easier than the approach that the Assoc-Req header takes, it would be more difficult to deploy, because existing caching proxies wouldn't be able to serve the correct identifier when using a cached response.