Paolo Mazzetti wrote:
I am trying to summarize our respective positions and find a common
point of view useful to finalize a discussion paper. These are mine
opinions and temptative conclusion. Since I think that these issues
concern too much technical details for the mailing-list, I send my
thoughts directly to you (and Stefano in cc).
I hope you don't mind, I'm CCing the list because I think a number of
others would be interested in these details. Also, the other reason for
the list is to archive the discussions and I'd really like to keep all
of this conversation in one place.
(Sorry to make any uninterested parties hit the "delete" key more than
necessary. If anyone really wants this conversation taken off-list, let
a) On resources and representation. I agree with your interpretation
of what resources and representations are in the WCS domain in the
sense that different subsets, interpolation, etc. identify different
resources and not simply different representations. This means that
the query string parameters are not the set of input parameters for a
single processing service resource, but actually parts of different
resources identifiers. (Indeed only the parameter FORMAT should be
considered affecting the representation and not identifying the
resource. In a perfect REST world its content should be provided in
the Accept header field.). Our (Stefano's and mine) previous note
speaking of 'representation' storage was misleading.
In my opinion, what is provided by the possible redirection is not a
new resource but a (temporary) URI which is an alias of the original
URI for the same resource (a resource can have more than an URI). For
example the resource http://someserver.net/coverages/foo?bbox=... is
assigned a temporary identifier
http://someserver.net/coverages/temp/xyz. Anyway the resource is still
retrievable at the original (and authoritative URI). This alias is
useful because, for example, in the time range of its validity the
retrieving of the resource representation could be faster than the
retrieving from the original (canonical) URI.
b) On creation and redirection. Taking into account also the previous
interpretation I still prefer the redirection response (302 code). In
particular, I think that a GET should not create any resource. RFC
1945 (HTTP/1.0) explicitely stated that "/Of the methods defined by
this specification, only POST can create a resource/.". In HTTP/1.1
this statement was suppressed, I suppose, for the introduction of
methods other than GET, HEAD and POST but I think that its original
meaning (GET and HEAD methods cannot create resources) should remain
valid. Moreover I think that 302 responses could be cached and the URI
provided used more than one time. The RFC says that "/Since the
redirection might be altered on occasion, the client SHOULD continue
to use the Request-URI for future requests. This response is only
cacheable if indicated by a Cache-Control or Expires header field./"
(Upper case as in the original). I interpret it on a weak sense such
as "If you are not sure about the validity of the redirection then use
the original uri" but if the server knows the redirection validity it
can provide it in the header and the client can refer to it.
I think dealing with asynchronous responses requires a flexible view of
GET vs POST, creation, and "resource". An asynchronously created
resource is, in general, only temporarily available and so doesn't
affect the long-term state of the system. Even if the response is stored
more permanently it still does not change the state of the system as the
stored resource could be requested again with the original URI.
The key point in my thinking then is the intent of the request. The
intent is to retrieve a resource and not change the underlying data (or
cause any other "side-effects"). So, I think the intent of the request
is both "safe" and "idempotent" in which case GET seems appropriate.
Of course, that is for a server determined asynchronous response. When a
client makes a "store=true" request, the intent of the request is to
create a new (though possibly temporary) resource. [Idempotent but not
safe?] So, maybe a POST is more appropriate in this case.
Concerning the other two points that you touched in your last email,
these are my opinions:
1) delayed/non-stored/pull case
What happens if two users make the same request around the same time?
Does the server have to do the same processing twice?
Yes I think that if two users make the same request than the server
has to do the same processing twice. (Obviously a smart server could
recognize that the requests are the same and make use of a sort of
internal cache, but this is an implementation problem. By the way, it
is not easy to recognize that two requests are the same, in particular
due to the query string which is made of non-hierarchical parameters.
E.g. two requests could only differ for the parameters order.)
And even worse, a small difference in a BBOX value might result in the
Why would anyone prefer the delayed/non-stored/pull case over
By the client point of view the non-stored use case has the only
(really small) advantage of avoiding the redirection. But the server
has other advantages (especially in terms of simplicity) and could
decide to not support the stored use-case for all or some of its
Ah ha. Upon re-reading the "202 Accept" section of the HTTP spec, I
realize that there is nothing in the spec that says anything about
the results of the accepted processing. The 202 response seems to
have been targeted only at requests for processing where knowing it
has been completed is all that is important. Not, as I have
interpreted it, that processing is done and may have resulted in a
new resource (all encoded in the body of the response or the results
of a status monitor). I think our interpretation of the 202 response
is the root of the difference in some of our responses. Though I
still find the 202 response the cleanest mapping to an asynchronous
response. Whether the accepted processing results in an externally
accessible artifact or not, the 202 response seems to capture what is
going on. It is up to the body of the 202 response and any response
to the "status monitor" to communicate information about any
artifacts of the accepted processing.
Yes the 202 specification is very plain. Sending 202 the server
informs that the request has been accepted but gives no other
information about the processing. It simply avoids to mantain the
connection open for long-running processes. It seems to be designed as
the minimal basis for allowing asynchronous interaction over HTTP. It
can be used as is for a polling approach. A more meaningful semantics
is demanded to the body content. This is the reason we should define a
(XML?) schema for providing information about processing status/result.
I definitely agree that we need to define some XML schema to provide
Taking into account all the previous points we could consider the
following approach for asynchronous operations:
a) the Client performs a GET on URI Ures
b) If the availability is delayed the server sends a 202 providing a
link to a status monitor resource (identified by the URI Ustatus)
c) the client observes the status monitor (by polling or with a push
approach in the future)
d) When the resource is available the status monitor responds:
d1) 200 and content if storage is not required
d2) 302 with redirection to alias URI U2 and expiration information
(if storage is required)
I think that this approach could be considered really close to what
RFC says. Let me know what you think.
That sounds good. Though I think of the status monitor as an extension
of the body of the 202 response (which is the XML document mentioned
above that we need to define). Perhaps this is part of why I had not
thought of using redirects. I see this status monitor XML document as
removing the asynchronous response from the realm of the HTTP
specification (sort of) and instead moving it into the xlink:href world.
So, rather than the status monitor response code redirecting us to the
new resource, the body of the status monitor response would indicate the
new resource was available and provide a link to the new resource. So,
here's my take:
a) client GETs the Ures URI
b) if delayed, response 202 code with
b1) Location header providing status monitor URI (Ustatus)
b2) Body containing XML document with status, estimate of completion,
and link to status monitor URI (Ustatus)
c) client GETs the Ustatus URI:
c1) if still not available, response code 200 with XML document same as
response b2 (maybe without Ustatus link).
c2) if available, response code 200 with XML document (similar to
response b2?) that indicates the resource is ready and provides a link
to the resulting resource.
Some very simple XML possibilities ...
<asynchResponse status="processing" completionEstimate="2007-10-24T02:34">
<statusMonitor xlink:href="some URI" />
<asynchResponse status="processing" completionEstimate="2007-10-24T02:34" />
<generatedResource xlink:href="some URI" />
Thanks. This is a great discussion.
Ethan R. Davis Telephone: (303) 497-8155
Software Engineer Fax: (303) 497-8690
UCAR Unidata Program Center E-mail: edavis@xxxxxxxx
P.O. Box 3000
Boulder, CO 80307-3000 http://www.unidata.ucar.edu/