Update 2006-03-17: On March 15, 2006, W3C acknowledged receipt of three Member Submissions from leading industry partners including BEA Systems, Computer Associates, IBM, Intel, Microsoft, Sonic Software, Systinet, and TIBCO Software for WS-* specifications relating to resources, events, and management. Also on March 15, 2006 a Joint White Paper Toward Converging Web Service Standards for Resources, Events, and Management was published by Hewlett Packard Corporation, IBM Corporation, Intel Corporation, and Microsoft Corporation. The Joint White Paper outlines a plan to "develop a common set of specifications for resources, events, and management that can be broadly supported across multiple platforms." The roadmap outlines planned development and support for WS-Transfer Addendum, WS-ResourceTransfer, WS-EventNotification, a new common Web services management specification, and updating of WS-MetadataExchange. See WS-Transfer, WS-Eventing, and WS-Enumeration Specifications Submitted to W3C.

Note 2004-10-08: In October 2004, a Web Services for Management (WS-Management) specification was released, superseding Microsoft's Web Services Management eXtensions (WMX) document discussed at WinHEC 2004. The WS-Management specification was edited by Microsoft and co-developed by AMD, Dell, Intel, and Sun. It makes normative reference to WS-Transfer and WS-Enumeration. See details in "AMD, Dell, Intel, Microsoft, and Sun Release Web Services for Management (WS-Management)."

[September 17, 2004] Two new Web Services messaging specifications have been published under terms of co-development and joint authorship by BEA Systems, Computer Associates, Microsoft, Sonic Software, and Systinet. The documents have been released as-is, for review and evaluation only, with no further warrantees or representations.

Web Service Enumeration (WS-Enumeration) "describes a general SOAP-based protocol for enumerating a sequence of XML elements that is suitable for traversing logs, message queues, or other linear information models. It brings enumeration capabilities to the WS-* suite of specifications, enabling an application to ask for items from a list of data that is held by a Web service. In this way, WS-Enumeration is useful for reading event logs, message queues, or other data collections."

WS-Enumeration recognizes that "there are numerous applications for which a simple single-request/single-reply metaphor is insufficient for transferring large data sets over SOAP. Applications that do not fit into this simple paradigm include streaming, traversal, query, and enumeration. In its simplest form, WS-Enumeration defines a single operation, Pull, which allows a data source, in the context of a specific enumeration, to produce a sequence of XML elements in the body of a SOAP message. Each subsequent Pull operation returns the next N elements in the aggregate sequence."

The Web Service Transfer (WS-Transfer) specification "describes a general SOAP-based protocol for accessing XML representations of Web service-based resources. It enables state transfer over SOAP by defining how to invoke a simple set of familiar verbs (Get, Post, Put, and Delete) using SOAP. An application protocol may be constructed to perform these operations over resources."

WS-Transfer "defines two types of entities: (1) Resources, which are entities addressable by an endpoint reference that provide an XML representation; (2) Resource factories, which are Web services that can create a new resource from an XML representation. Specifically, it defines two operations for sending and receiving the representation of a given resource and two operations for creating and deleting a resource and its corresponding representation."

The joint authors (co-developers) are said to each "agree to grant you a license, under royalty-free and otherwise reasonable, non-discriminatory terms and conditions, to their respective essential patent claims that they deem necessary to implement" the two specifications.

Bibliographic Information

• Web Service Enumeration (WS-Enumeration). September 2004. 27 pages. Authors: Jan Alexander (Systinet), Don Box (Microsoft), Luis Felipe Cabrera (Microsoft), Dave Chappell (Sonic Software), Glen Daniels (Sonic Software), Alan Geller (Microsoft, editor), Chris Kaler (Microsoft), David Orchard (BEA), Igor Sedukhin (Computer Associates), Miroslav Simek (Systinet), and Marvin Theimer (Microsoft). Copyright (c) 2004 BEA Systems Inc., Computer Associates, Microsoft Corporation, Inc., Sonic Software, and Systinet Corporation.

  Acknowledgements: "This specification has been developed as a result of joint work with many individuals and teams, including: Suwat Chitphakdibodin (Microsoft Corporation), Omri Gazitt (Microsoft), Gopal Kakivaya (Microsoft), Brad Lovering (Microsoft), Ray McCollum (Microsoft), Jeffrey Schlimmer (Microsoft), and John Shewchuk (Microsoft).

• Web Service Transfer (WS-Transfer). September 2004. 17 pages. Authors: Jan Alexander (Systinet), Don Box (Microsoft), Luis Felipe Cabrera (Microsoft), Dave Chappell (Sonic Software), Glen Daniels (Sonic Software), Alan Geller (Microsoft, editor), Radovan Janecek (Systinet), Chris Kaler (Microsoft), Brad Lovering (Microsoft), David Orchard (BEA), Jeffrey Schlimmer (Microsoft), Igor Sedukhin (Computer Associates), and John Shewchuk (Microsoft). Copyright (c) 2004 BEA Systems Inc., Computer Associates, Microsoft Corporation, Inc., Sonic Software, and Systinet Corporation.

  Acknowledgements: "This specification has been developed as a result of joint work with many individuals and teams, including: Erik Christensen (Microsoft), Henrik Frystyk Nielsen (Microsoft), Omri Gazitt (Microsoft), Martin Gudgin (Microsoft), Andrew Layman (Microsoft), Steve Millet (Microsoft), and Marvin Theimer (Microsoft).

About WS-Enumeration

"The Web Service Enumeration (WS-Enumeration) specification is intended to support enumeration of data sources that cannot practically fit into a single SOAP message. It supports both server-side and client-side enumeration state maintenance and minimizes additional mechanism beyond the current web service architecture.

WS-Enumeration defines a simple SOAP-based protocol for enumeration that allows the data source to provide a session abstraction, called an enumeration context, to a consumer that represents a logical cursor through a sequence of data items. The consumer can then request XML element information items using this enumeration context over the span of one or more SOAP messages.

Somewhere, state must be maintained regarding the progress of the iteration. This state may be maintained between requests by the data source being enumerated or by the data consumer. WS-Enumeration allows the data source to decide, on a request-by-request basis, which party will be responsible for maintaining this state for the next request...

In the context of a specific enumeration, a data source may provide a custom mechanism for starting a new enumeration. For instance, a data source that provides access to a SQL database may support a SELECT operation that performs a database query and uses an explicit database cursor to iterate through the returned rows. In general, however, it is simpler if all data sources support a single, standard operation to start an enumeration. This specification defines such an operation, Enumerate, that data sources may implement for starting a new enumeration of a data source. The Enumerate operation is used to create new enumeration contexts for subsequent traversal/retrieval. Each Enumerate operation results in a distinct enumeration context, each with its own logical cursor/position.

It should be emphasized that different enumerations of the same data source may produce different results; this may happen even for two enumeration contexts created concurrently by a single consumer using identical Enumerate requests. In general, the consumer of an enumeration should not make any assumptions about the ordering or completeness of the enumeration; the returned data items represent a selection by the data source of items it wishes to present to that consumer at that time in that order, with no guarantee that every available item is returned or that the order in which items is returned has any semantic meaning whatsoever (of course, any specific data source may provide strong guarantees, if so desired). In particular, it should be noted that the very act of enumerating the contents of a data source may modify the contents of the data source; for instance, a queue might be represented as a data source such that items that are returned in a Pull response are removed from the queue..." [from the Introduction]

Microsoft's white paper "An Introduction to the Web Services Architecture and Its Specifications Version 1.0" (September 2004) summarizes WS-Enumeration in a section "Enumeration, Transfer, and Eventing," which presents specifications "that provide enumeration of service resources, their state management, and event notification in the Web services architecture; they are based on WS-Enumeration, WS-Transfer, and WS-Eventing...

Many scenarios require data exchange using more than just a single request/response message pair. Types of applications that require these longer data exchanges include database queries, data streaming, the traversal of information such as namespaces, and enumerating lists. Enumeration, in particular, is achieved though establishing a session between the data source and the requestor. Successive messages within the session transport the collection of elements being retrieved. No assumptions are made on the approach used by the service to organize the items that will be produced. What is expected is that under normal processing circumstances the enumeration will produce all the underlying data before the end of the session.

WS-Enumeration specifies protocols to establish an enumeration session and to retrieve sequences of data. The enumeration protocols allow the data source to provide a session abstraction, called an enumeration context, to the consuming service. This enumeration context represents a logical cursor through a sequence of data items. The requestor then uses this enumeration context over a span of one or more SOAP messages to request the data. The enumerated data is represented as XML Infosets. The specification also allows a data source to provide a custom mechanism for starting a new enumeration. Since an enumeration session may require several message exchanges, the session state must be retained.

State information regarding the progress of the iteration may be maintained between requests by either the data source or the consuming service. WS-Enumeration allows the data source to decide, on a request-by-request basis, which party will be responsible for maintaining state for the next request. This flexibility enables several kinds of optimizations. One optimization example is allowing a server to avoid saving any cursor state between invocations. As message latencies can be large for a service supporting several simultaneous enumerations, not preserving state may yield substantial savings in the total amount of information that must be maintained. Service implementations on resource-constrained devices, such as cell phones, may not be able to maintain any state information at all..."

About WS-Transfer

"The Web Service Transfer (WS-Transfer) specification defines a mechanism for acquiring XML-based representations of entities using the Web service infrastructure. It intends to provide a SOAP-based protocol for managing resources and their representations, and to minimize additional mechanism beyond the current web service architecture.

(WS-Transfer) defines two types of entities: (1) Resources, which are entities addressable by an endpoint reference that provide an XML representation; (2) Resource factories, which are Web services that can create a new resource from an XML representation. Specifically, it defines two operations for sending and receiving the representation of a given resource and two operations for creating and deleting a resource and its corresponding representation.

It should be noted that the state maintenance of a resource is at most subject to the 'best efforts' of the hosting server. When a client receives the server's acceptance of a request to create or update a resource, it can reasonably expect that the resource now exists at the confirmed location and with the confirmed representation, but this is not a guarantee, even in the absence of any third parties. The server may change the representation of a resource, may remove a resource entirely, or may bring back a resource that was deleted. For instance, the server may store resource state information on a disk drive. If that drive crashes and the server recovers state information from a backup tape, changes that occurred after the backup was made will be lost.

A server may have other operational processes that change resource state information. A server may run a background process that examines resources for objectionable content and deletes any such resources it finds. A server may purge resources that have not been accessed for some period of time. A server may apply storage quotas that cause it to occasionally purge resources.

In essence, the confirmation by a service of having processed a request to create, modify, or delete a resource implies a commitment only at the instant that the confirmation was generated. While the usual case should be that resources are long-lived and stable, there are no guarantees, and clients should code defensively..." [from the Introduction]

The Microsoft white paper on Web Services Architecture says of 'Transfer': "A factory is a Web service that can create a resource from its XML representation. WS-Transfer introduces operations that create, update, retrieve and delete resources. These operations extend the abilities of the read-only operations found in WS-MetadataExchange. The Create request is sent to a factory. The factory then creates the requested resource and determines its initial representation. The factory is assumed to be distinct from the resource being created. The new resource is assigned a service-determined endpoint reference that is returned in the response message. The Put operation updates a resource by providing a replacement representation. A one-time snapshot of the representation of a resource, identical to the Get operation in WS-MetadataExchange, can be retrieved by using the Get operation in WS-Transfer. After a successful Delete operation the resource is no longer available through the endpoint reference. These four metadata management operations form the basis needed to build state management in Web services..."

Reblog of Omri Gazitt's Weblog

The most illuminating blog on WS-Transfer and WS-Enumeration [as of 2004-09-17] seemed to be that published by Omri Gazitt in WS-Transfer and WS-Enumeration, here excerpted/adapted without the hyperlinks:

"Like WS-Eventing (just republished) and WS-MetadataExchange (republishing very soon), the WS-Transfer and WS-Enumeration specifications are applications on top of WS-Addressing that specify some common patterns in distributed systems that can be built on top of the WS architecture.

WS-Transfer is a spec that Don Box has wanted to publish for a year now. It codifies the simple CRUD pattern for Web services; the operations are named after their HTTP equivalents — GET, PUT, DELETE, and there is also a CREATE pattern. The pattern of manipulating resources using these simple verbs is quite prevalent (Roy Fielding's REST is the most common moniker for it), and of course it underlies the HTTP protocol.

Of course, you could implement this pattern before WS-Transfer, but it does help to write this down so people can do this over SOAP in a consistent way. One interesting existing application of this pattern is Atom, a publishing/blogging protocol built on top of SOAP. Looking at the Atom WSDL, it looks very much like WS-Transfer — a GET, PUT, DELETE, and POST (which is the CREATE verb specific to this application). So Atom could easily be built on top of WS-Transfer. What would be the advantage of that? The same advantage that comes with any kind of consistent application of a technology: the more the consistent pattern is applied, the more value it accrues. Just the value of baking that pattern into various toolsets (e.g., VS.NET) makes it attractive to use the pattern.

WS-Enumeration is another such application of WS-Addressing: it goes after another common pattern — namely 'chunking' through a large data set. Anyone who's ever implemented a website that returns more than a page-full of results, and has to offer UI to navigate through the pages of data, can appreciate this pattern — and wishes HTTP had support for it :-). The WS-Enumeration specification has two main verbs: Enumerate (which returns an enumeration context) and Pull (which gets the next chunk). Basically a 'firehose cursor' through a data set.

Both of these specifications are useful for many applications, among them systems management. WS-Transfer helps me get and set resource state (e.g., the fan speed of a CPU) and WS-Enumeration lets me go through large sets of data (e.g., the catalog of resources on a system) in a straightforward way..."