Subject: Direct References in the Advanced Collections Requirements

From: "Slein, Judith A" <[email-masked]>
Date: Tue, 15 Sep 1998 15:23:36 -0400

I would like to propose the following changes to the Advanced
Collections Requirements.

1. The requirements will use the following terminology and definitions
instead of the current indirect / direct references terminology:

Client-Side Reference:  A reference that must be resolved by the client.
Any method applied to a Client-Side Reference affects the reference
only, not its target.  To affect the target of a Client-Side reference,
the client must resolve the reference and operate directly on its
target.

Server-Side Reference:  A reference whose existence is, in general,
hidden from the client.  For the most part, methods applied to a
Server-Side Reference affect its target, not the reference itself.  The
server resolves the reference and applies the method to its target.

Rationale:  Roy Fielding has been requesting for some time that we
change the terminology.  This is in part an attempt to satisfy his
request.  In addition, the current requirements document defines a
Server-Side Reference as one for which all operations are passed through
to its target.  It is clear from the discussion at IETF 42 that this
definition is too strong.  It was proposed there that DELETE, COPY, and
MOVE are not passed through to the target.  I would like *not* to make a
commitment in the requirements about exactly which operations get passed
through and which do not, but still express the general intent of
Server-Side References.  For most operations, they give a client the
impression that it is operating directly on the target, hiding the
existence of the reference from the client.

2. The requirements will give the following rationale for supporting
both sorts of reference.

Client-Side References provide the basic benefits desired from
referencing:  They allow multiple collections, on the same or different
servers, to share a single resource, in such a way that any change to
the resource will automatically be reflected in the collections that
contain it by reference.  They provide this benefit at very low cost to
the server, and with no security implications.

Server-Side References hide the existence of the reference from the
client, thus simplifying for the client operations through the
reference, and making them more efficient.  Fewer round trips are
required to accomplish the same task than with Client-Side References.
Servers already support server-side references, generally through
configuration files; exposing this capability through the protocol seems
desirable.

Judith A. Slein
Xerox Corporation
[email-masked]
(716)422-5169
800 Phillips Road 105/50C
Webster, NY 14580