IBM

johnarwe@us.ibm.com

IBM

sspeiche@us.ibm.com

UC Berkeley

dret@berkeley.edu http://dret.net/netdret/

This specification defines a new HTTP response header field Accept-Post, which indicates server support for specific media types for entity bodies in HTTP POST requests. This draft should be discussed on the apps-discuss mailing list. Online access to all versions and files is available on github.

This specification defines a new HTTP response header field Accept-Post, which indicates server support for specific media types for entity bodies in HTTP POST requests. This header field is comparable to the Accept-Patch response header field specified together with the HTTP PATCH method (notice, however, that while Accept-Patch is defined to only list specific media types, Accept-Post reuses the "media range" concept of HTTP's Accept header and thus allows media type wildcards as well).

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 RFC 2119 .

This specification introduces a new response header field Accept-Post used to specify the document formats accepted by the server in HTTP POST requests. Accept-Post SHOULD appear in the OPTIONS response for any resource that supports the use of the POST method. The presence of the Accept-Post header in response to any method is an implicit indication that POST is allowed on the resource identified by the Request-URI. The presence of a specific document format in this header indicates that this specific format is allowed on the resource identified by the Request-URI. The syntax for Accept-Post headers, using the ABNF syntax defined in Section 5.3.2 of HTTP/1.1 , is given by the following definition:

Accept-Post = #( media-range [ accept-params ] )

(Please note that this ABNF differs from the one given in Section 5.3.2 of RFC 7231 , which includes the header field name.) The Accept-Post header specifies a media range as defined by HTTP . The media range specifies a type of representation that can be POSTed to the Request-URI. The app:accept element is similar to the HTTP Accept request header field . Media type parameters are allowed within Accept-Post, but Accept-Post has no notion of preference - "accept-params" or "q" arguments, as specified in Section 5.3.2 of , are not significant.

This specification defines a response header field for the Hypertext Transfer Protocol (HTTP) that has been registered with the Internet Assigned Numbers Authority (IANA) following the "Registration Procedures for Message Header Fields" .

The Accept-Post response header should be added to the permanent registry of message header fields (see ), taking into account the guidelines given by HTTP/1.1 . Header Field Name: Accept-Post Applicable Protocol: Hypertext Transfer Protocol (HTTP) Status: Standard Author/Change controller: IETF Specification document(s): RFC XXXX

Accept-Post extends the way in which interaction information can be exposed in HTTP itself. The following sections contain some examples how this can be used in concrete HTTP-based services. Based on the first example of AtomPub , when sending a GET request to the URI of a collection, the following response could be sent, if the server decided to support Accept-Post headers:

HTTP/1.1 201 OK Date: Fri, 23 Feb 2007 21:17:11 GMT Content-Length: nnn Content-Type: application/atom+xml;type=feed Accept-Post: image/gif, image/jpeg, image/png

In this response to the GET request of a collection URI, the server indicates that this particular collection accepts new entries in the form of GIF, JPEG, or PNG images. No parameters are used, which means that there is no server-specified preference among those media types.

The Atom Publishing Protocol (AtomPub) defines a model of interacting with collections and members, based on representations using the Atom syntax. AtomPub allows clients to create new collection members by using HTTP POST, with the request being sent to the collection URI. AtomPub servers can limit the media types they accept in these POST requests, and the accepted media types are listed in an "AtomPub service document". The Accept-Post header field does allow an AtomPub server to advertise its support for specific media types in interactions with the collection resource, without the need for a client to locate the service document and interact with it. This increases the visibility of the "POST to Create" model of AtomPub, and makes it easier for clients to find out about the capabilities of a specific collection. While the AtomPub protocol cannot be changed retroactively, this additional way of exposing interaction guidance could make it easier for clients to interact with AtomPub services that do support the Accept-Post header field. For those that do not support Accept-Post, clients would still have to rely on using the information contained in the service document (including the sometimes tricky issue of how to locate the service document for a given collection).

The Linked Data Platform (LDP) describes a set of best practices and simple approach for a read-write Linked Data architecture, based on HTTP access to Web resources that describe their state using the RDF data model. LDP defines LDP Containers (LDPC) and LDP Resources (LDPR). Adding new LDPRs to an LDPC is done by sending an HTTP POST request to the LDPC. An LDPC can constrain the media types it is accepting for these POST requests, and should expose its support for accepted media types via Accept-Post. In fact, the Accept-Post header was initially developed within the W3C's LDP Working Group (LDPWG), see for acknowledgements. It was then decided that the header itself might be useful in other contexts as well, and thus should be specified in a standalone document.

If a client POSTs an unsupported POST document, it is possible for the server to use Accept-Post to indicate the supported media types. These can be specified using a 415 (Unsupported Media Type) response when the client sends a POST document format that the server does not support for the resource identified by the Request-URI. Such a response then MAY include an Accept-Post response header notify the client what POST document media types are supported. This example applies to all resources supporting a limited set of media types for POST requests, such as the ones listed in the previous to sections. In both AtomPub and LDP, it would be possible for a server to include an Accept-Post header in a 415 response to a failed POST request, and indicate the media types that are accepted for POST requests.

Note to RFC Editor: Please remove this section before publication. This section records the status of known implementations of the protocol defined by this specification at the time of posting of this Internet-Draft, and is based on a proposal described in RFC 6982 . The description of implementations in this section is intended to assist the IETF in its decision processes in progressing drafts to RFCs. Please note that the listing of any individual implementation here does not imply endorsement by the IETF. Furthermore, no effort has been spent to verify the information presented here that was supplied by IETF contributors. This is not intended as, and must not be construed to be, a catalog of available implementations or their features. Readers are advised to note that other implementations may exist. According to RFC 6982, "this will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature. It is up to the individual working groups to use this information as they see fit".

Organization: IBM developed and contributed to the Eclipse Lyo project. Name: Eclipse Lyo "LDP reference implementation" Description: A very simple reference implementation for W3C Linked Data Platform (LDP) using some base Java technologies such as JAX-RS 2.0 and Apache Jena. The goals of this reference implementation is to experiment with validating the concepts in the specification and understanding what a SDK might look like to build LDP-compliant servers. Additional goal is to validate the approach for usage in OSLC4J SDK for building OSLC clients and servers. Maturity: Early prototype/alpha. Coverage: All parts of the specification were covered for server requirements. Licensing: Freely distributable (Eclipse Public License (EPL) and Eclipse Distribution License (EDL)). Implementation Experience: Experience is only from the server perspective of generating the HTTP response header. It was trivial using JAX-RS 2.0 mechanism using a ContainerResponseFilter on all responses. More details about this approach are described in this blog post. Contact: Steve Speicher <sspeiche@gmail.com>

Organization: No particular organization. The work done is part of project RWW.I/O. Name: RWW.I/O - personal linked data storage. Description: A minimal support for LDP is now included in RWW.I/O, which is a personal linked data storage space, following the structure of a Unix file system. Currently, only LDPCs are supported, since the LDPRs are always files or directories that are being managed through RESTful operations. RWW.I/O encourages the use of .meta files to semantically describe non-LD resources (e.g. images, html, js, css, etc.), and the use of .acl files for access control rules using the WAC vocabulary. Both .meta and .acl should be used per file (i.e. photo.jpg will have a .meta.photo.jpg and a .acl.photo.jpg). Maturity: Beta until more features from LDP spec are included (if necessary). Coverage: LDPCs on the server side, pagination and Accept-Post header. You can test LDPC support like this: curl -H "Accept: text/turtle" https://deiu.rww.io/public/?p=1 ; You can test Accept-Post header like this: curl -v -X OPTIONS -H "Accept: text/turtle" https://deiu.rww.io/public/ Licensing: MIT license. Source code is available on GitHub. Implementation Experience: Implementing current LDP features in RWW.I/O was trivial. I've also decided to add the Accept-Post header to HEAD replies, as it helps to reduce the number of requests for a client trying to discover more information about the server. Contact: Andrei Sambra <andrei.sambra@gmail.com>

Organization: IBM Name: Tivoli Workload Automation Description: An existing scheduling product that already implements the OSLC Automation specification (both client and server roles), including creation factories for Automation Requests that accept HTTP POST requests. Since OSLC Automation offers no programmatic way for clients to know which media types are supported by the server, clients are limited in practice to those required by OSLC Automation (RDF/XML), or to making optimistic requests using other RDF media types. Maturity: Early prototype/alpha Coverage: All parts of the specification were covered for server and client requirements. Licensing: proprietary Implementation Experience: Experience from the server perspective of generating the HTTP response header is that it was trivial using JAX-RS annotations to add another response header. Client parsing of the header presented no new problems, since the syntax is almost identical to the server-side processing of an Accept header. Contact: John Arwe <johnarwe@us.ibm.com>

Organization: IBM Name: Jazz for Service Management Registry Services Description: An existing component bundled with multiple existing Cloud and Smarter Infrastructure (formerly branded as Tivoli) products. It already supports multiple resource collections that use HTTP POST requests to create new member resources, e.g. "registration records". Given that clients have no existing means by which they can know which media types the server supports, and given that Registry Services has been adding new media types over the past few months as part of its continuous delivery process, Accept-Post is a natural fit to enable looser client coupling. Maturity: Early prototype/alpha Coverage: All parts of the specification were covered for server requirements. Licensing: proprietary Implementation Experience: Experience is only from the server perspective of generating the HTTP response header. It was easy to add a new header using JAX-RS annotations. Contact: John Arwe <johnarwe@us.ibm.com>

The Accept-Post header may expose information that a server would prefer to not publish. In such a case, a server can simply stop exposing the header, in which case HTTP interactions would be back to the level of standard HTTP (i.e., with no indication what kind of media types a resource accepts in POST requests).

Note to RFC Editor: Please remove this section before publication. Accept-Post currently uses the "media range" concept of HTTP's Accept header field. An alternative would be only support fully specified media types, which is what the Accept-Patch header field is doing. This latter solution is more constrained, and fails to address some uses cases, such as AtomPub's way of exposing collection support for POST requests. While "accept-post" is currently defined in the "HTTP Link Hints" draft , it would be good to align the way in which they work. Currently, the "accept-post" of link hints allows a list of specific media types, whereas the Accept-Post header field may contain "media ranges".

Note to RFC Editor: Please remove this section before publication.

Updating references (removing RFC 2616, adding new HTTP/1.1 RFCs).

Adding reference to RFC 5234 (ABNF). Updating references. Adding proper registration template.

Added header field example. Updated author address. Adding more entries to the "Implementation Status" section.

Changed ABNF for header field from RFC 2616 to HTTPbis convention (only specify the header field value grammar). Added implementations (all from the LDP community for now). Added open issue for aligning accept-post as defined by the "HTTP Link Hints" draft.

Harvard University

1350 Mass. Ave. Cambridge MA 02138 - +1 617 495 3864

This specification defines registration procedures for the message header fields used by Internet mail, HTTP, Netnews and other applications. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements.

mnot@pobox.com http://www.mnot.net/

rfsayre@boswijck.com http://boswijck.com

This document specifies Atom, an XML-based Web content and metadata syndication format. The Atom Publishing Protocol (AtomPub) is an application-level protocol for publishing and editing Web resources. The protocol is based on HTTP transfer of Atom-formatted representations. The Atom format is documented in the Atom Syndication Format. [STANDARDS TRACK] Internet technical specifications often need to define a formal syntax. Over the years, a modified version of Backus-Naur Form (BNF), called Augmented BNF (ABNF), has been popular among many Internet specifications. The current specification documents ABNF. It balances compactness and simplicity with reasonable representational power. The differences between standard BNF and ABNF involve naming rules, repetition, alternatives, order-independence, and value ranges. This specification also supplies additional rule definitions and encoding for a core lexical analyzer of the type common to several Internet specifications. [STANDARDS-TRACK] Several applications extending the Hypertext Transfer Protocol (HTTP) require a feature to do partial resource modification. The existing HTTP PUT method only allows a complete replacement of a document. This proposal adds a new HTTP method, PATCH, to modify an existing HTTP resource. This document describes a simple process that allows authors of Internet-Drafts to record the status of known implementations by including an Implementation Status section. This will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature.</t><t> The process in this document is offered as an experiment. Authors of Internet-Drafts are encouraged to consider using the process for their documents, and working groups are invited to think about applying the process to all of their protocol specifications. The authors of this document intend to collate experiences with this experiment and to report them to the community. The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document defines the semantics of HTTP/1.1 messages, as expressed by request methods, request header fields, response status codes, and response header fields, along with the payload of messages (metadata and body content) and mechanisms for content negotiation. This memo specifies "HTTP Link Hints", a mechanism for annotating Web links to HTTP(S) resources with information that otherwise might be discovered by interacting with them. Note to Readers This draft should be discussed on the apps-discuss mailing list; see [apps-discuss].

Thanks for comments and suggestions provided by Martin Duerst, Barry Leiba, Mark Nottingham, and Julian Reschke. This work has been done in the context of the W3C Linked Data Platform Working Group (LDPWG) ; thanks for comments and suggestions provided by the working group as a whole.