Profile Support for the Atom Syndication FormatEMC6801 Koll Center ParkwayPleasanton, CA 94566U.S.A.+1-925-6006244erik.wilde@emc.comhttp://dret.net/netdret/The Atom syndication format is a generic XML format for representing collections. Profiles are one way how Atom feeds can indicate that they support specific extensions. To make this support visible on the media type level, this specification adds an optional "profile" media type parameter to the Atom media type. This allows profiles to become visible at the media type level, so that servers as well as clients can indicate support for specific Atom profiles in conversations, for example when communicating via HTTP. This specification updates RFC 4287 by adding the "profile" media type parameter to the application/atom+xml media type registration.This draft should be discussed on the atom-syntax mailing list.Online access to all versions and files is available on github.The Atom Syndication Format "is an XML-based document format that describes lists of related information known as 'feeds'. Feeds are composed of a number of items, known as 'entries', each with an extensible set of attached metadata. For example, each entry has a title." Profiles "can be described as additional semantics that can be used to process a resource representation, such as constraints, conventions, extensions, or any other aspects that do not alter the basic media type semantics. A profile MUST NOT change the semantics of the resource representation when processed without profile knowledge, so that clients both with and without knowledge of a profiled resource can safely use the same representation." Profiles are identified by URI, and their use can be indicated for a representation by adding a link with the registered "profile" link relation type, linking to the profile URI. While this is sufficient to represent the fact that a certain representation is using a profile, it does not make that fact visible outside of this representation. Ideally, peers communicating their media type, for example when communicating via Hypertext Transfer Protocol (HTTP) , should be able to indicate the support of certain profiles through the media type identifier itself, without changing the base media type.Because Atom supports generic links through its <link/> element, "profile" links can be easily added to a feed, indicating that this feed does adhere to a certain profile. However, on the media type level, this feed would still be labeled as application/atom+xml, making the profile invisible on that level and thus not allowing it to be used in interactions such as content negotiation in HTTP.This specification adds a "profile" media type parameter to the application/atom+xml media type, thereby making it possible for profiles to be exposed at the media type level. Apart from adding that one media type parameter, this specification does not change anything about the Atom format itself, or its media type registration.Adding a "profile" parameter to the Atom media type adds visibility of profiles at the media type level, for example when alternative profiles are supported by a service. It might also help to further "specialize" a media type in environments where such a "specialization" is useful. Two examples are intended to illustrate these two scenarios.For example, when linking to feeds of media-oriented services, it would be possible to expose two feeds, one using MediaRSS, and the other one using Podcasts. Both formats roughly cover the same functionality as media-oriented feed-based extensions, but by having the ability to expose their capabilities at the media type level, HTTP mechanisms and conversations can be used to distinguish between these formats.In some cases it may be possible to support more than one profile, and then it is up for the service to decide whether these should be exposed in one representation (which can be exposed by linking to multiple profiles from the resource representation and/or in the media type parameter), or whether there should be two representations, one for each profile. This decision will probably depend on implementation complexity, the trade-off between navigation complexity (two representations with one profile each) and processing complexity, and also the size of the profile data, because in particular in the case of overlapping profiles, there might be many redundancies.Thus, which way to go for multiple profiles is not a question that has one correct answer; it depends on the profiles, and on the services that are built around them.Feed-based services may provide additional features in feeds that are represented using Atom's extension mechanisms. These additional features might be useful only for those clients that support them, and otherwise might add volume to a feed that is of no value to general consumers. In such a scenario, specialized clients might also request their specialized features via profile media type parameters, and will then get the feed being "enriched" with the additional features. If clients do not request such a profile or request one that is not known to the server, the server responds with a generic feed, still allowing them to treat the feed as a generic feed (with no additional features being represented).Whether services respond with profiles by default or only for specific requests about a profile is a matter of policy, and will be influenced by factors such as the added volume when adding profile data, and the question whether profiles should only be exposed to those that specifically ask for them. Since profiles are not allowed to change the semantics of the media type itself, such a decision can depend on the trade-off being a matter of expressivity, and not whether it will break clients under some circumstances.The Atom Publishing Protocol (AtomPub) builds on Atom and defines additional interactions with feeds, such as the ability to POST an entry to a collection URI as a request to create a new entry in that collection. AtomPub uses Atom's media type for representing feeds and entries (and introduces its own media type for representing category and service documents, but these are not relevant for this discussion).When requesting a collection URI from an AtomPub server, clients will GET a feed document with no indication that the server supports AtomPub. Clients are supposed to have knowledge about AtomPub support, so that they know whether POST requests to the collection URI might succeed. It is possible that clients send an OPTIONS request to the collection URI to find out about the allowed methods, but this requires an additional roundtrip, and since the AtomPub spec does not explicitly mention OPTIONS, it may be the case that implementations do not generally support this discovery mechanism.To make AtomPub support of a collection explicit in a feed document, the profile URI urn:ietf:rfc:5023 is suggested. When including this profile URI in a feed, a server indicates AtomPub support:
]]>When used with the profile parameter of the Atom media type, this profile URI MAY be used to indicate that the resource is advertising AtomPub support. It should be noted that AtomPub servers are not required to use the AtomPub profile URI in any way (because it is not a part of the AtomPub specification), but that supporting it may make it easier for clients to discover the AtomPub capabilities of available resources.The profile parameter for the application/atom+xml media type allows one or more profile URIs to be specified. These profile URIs have the identifier semantics defined in , and when appearing as media type parameter, they have the same semantics as if they had been associated with the resource URI through other means, such as using one or more <link profile="" href=""/> elements as children of the <feed> element.As a general rule, media type parameters must be quoted unless they are tokens. For the "profile" media type parameter defined here, this means that is must be quoted. It contains a non-empty list of space-separated URIs (the profile URIs).profile-param = "profile=" profile-value
profile-value = <"> profile-URI 0*( 1*SP profile-URI ) <">
profile-URI = URIThe "URI" in the above grammar refers to the "URI" as defined in Section 3 of This specification updates an existing media type according to the registry mechanism described in .The Internet media type for Atom (application/atom+xml) should be updated by adding the following optional media type parameter:profile: This parameter indicates that one or more profiles are used in the feed, according to the definition of profiles in . The parameter syntax is specified in of RFC XXXXNote 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"....There are no known security considerations for adding this optional media type parameter to the application/atom+xml media type.Note to RFC Editor: Please remove this section before publication.Monitor how the proposal for a "Profile URI Registry" is coming along. If it is successful, then the proposed AtomPub Profile URI should be included in the IANA Considerations .Note to RFC Editor: Please remove this section before publication.Added "Implementation Status" section ()."Added example and suggested URI for an AtomPub Profile ()Changed IANA section to only request adding a "profile" media type parameter (instead of providing a complete media type registration template).Added "Open Issues" section () and reminder to check the progress of the "Profile URI Registry" draft.Updating "Implementation Status" section to refer to RFC 6982 .Adding "Security Considerations" section ()Fixed typos.Removed the requirement to percent-encode URIs in the profile parameter.Added example for media type specialization.XML Media TypesThis document standardizes five new media types -- text/xml, application/xml, text/xml-external-parsed-entity, application/xml- external-parsed-entity, and application/xml-dtd -- for use in exchanging network entities that are related to the Extensible Markup Language (XML). This document also standardizes a convention (using the suffix '+xml') for naming media types outside of these five types when those media types represent XML MIME (Multipurpose Internet Mail Extensions) entities. [STANDARDS-TRACK]Uniform Resource Identifier (URI): Generic SyntaxWorld Wide Web ConsortiumMassachusetts Institute of Technology77 Massachusetts AvenueCambridgeMA02139USA+1-617-253-5702+1-617-258-5999timbl@w3.orghttp://www.w3.org/People/Berners-Lee/Day Software5251 California Ave., Suite 110IrvineCA92617USA+1-949-679-2960+1-949-679-2972fielding@gbiv.comhttp://roy.gbiv.com/Adobe Systems Incorporated345 Park AveSan JoseCA95110USA+1-408-536-3024LMM@acm.orghttp://larry.masinter.net/
Applications
uniform resource identifierURIURLURNWWWresourceA Uniform Resource Identifier (URI) is a compact sequence of characters that identifies an abstract or physical resource. This specification defines the generic URI syntax and a process for resolving URI references that might be in relative form, along with guidelines and security considerations for the use of URIs on the Internet. The URI syntax defines a grammar that is a superset of all valid URIs, allowing an implementation to parse the common components of a URI reference without knowing the scheme-specific requirements of every possible identifier. This specification does not define a generative grammar for URIs; that task is performed by the individual specifications of each URI scheme.The Atom Syndication Formatmnot@pobox.comhttp://www.mnot.net/rfsayre@boswijck.comhttp://boswijck.comThis document specifies Atom, an XML-based Web content and metadata syndication format.The 'profile' Link Relation TypeThis specification defines the 'profile' link relation type that allows resource representations to indicate that they are following one or more profiles. A profile is defined not to alter the semantics of the resource representation itself, but to allow clients to learn about additional semantics (constraints, conventions, extensions) that are associated with the resource representation, in addition to those defined by the media type and possibly other mechanisms.Hypertext Transfer Protocol -- HTTP/1.1Department of Information and Computer ScienceUniversity of California, IrvineIrvineCA92697-3425+1(949)824-1715fielding@ics.uci.eduWorld Wide Web ConsortiumMIT Laboratory for Computer Science, NE43-356545 Technology SquareCambridgeMA02139+1(617)258-8682jg@w3.orgCompaq Computer CorporationWestern Research Laboratory250 University AvenuePalo AltoCA94305mogul@wrl.dec.comWorld Wide Web ConsortiumMIT Laboratory for Computer Science, NE43-356545 Technology SquareCambridgeMA02139+1(617)258-8682frystyk@w3.orgXerox CorporationMIT Laboratory for Computer Science, NE43-3563333 Coyote Hill RoadPalo AltoCA94034masinter@parc.xerox.comMicrosoft Corporation1 Microsoft WayRedmondWA98052paulle@microsoft.comWorld Wide Web ConsortiumMIT Laboratory for Computer Science, NE43-356545 Technology SquareCambridgeMA02139+1(617)258-8682timbl@w3.orgThe Hypertext Transfer Protocol (HTTP) is an application-level protocol for distributed, collaborative, hypermedia information systems. It is a generic, stateless, protocol which can be used for many tasks beyond its use for hypertext, such as name servers and distributed object management systems, through extension of its request methods, error codes and headers . A feature of HTTP is the typing and negotiation of data representation, allowing systems to be built independently of the data being transferred.HTTP has been in use by the World-Wide Web global information initiative since 1990. This specification defines the protocol referred to as "HTTP/1.1", and is an update to RFC 2068.The Atom Publishing ProtocolThe 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]Media Type Specifications and Registration ProceduresThis document defines procedures for the specification and registration of media types for use in HTTP, MIME, and other Internet protocols. This memo documents an Internet Best Current Practice.The IETF Profile URI RegistryThis document defines a registry for profile URIs to be used in specifications standardizing profiles.Improving Awareness of Running Code: The Implementation Status SectionThis 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.Thanks for comments and suggestions provided by Markus Lanthaler and Peter Rushforth.