16 August 95, 18:11 Mitra <mitra@mitra.biz>
This document is part of a collection of VRML2.0 history at http://www.mitra.biz/vrml/vrml2/mw_history.html
Revision: 18 Sept 95 - changed file ref to be a URL.
This is a straw-person document, I'd love to hear concerns and proposed changes It is a response to queries from a number of people at Siggraph who were trying to figure out solutions to a number of problems and thought URN's might be the answer


The goal of this proposal is to allow us to:

URNs and Generic objects

Firstly, URNs are NOT the same thing as generic objects.


URN's are a concept that's been around almost as long as URLs. Currently there is a consensus that they should look something like:
Says this is a URN and not a Http or other kind of URL
Says the issuing authority is foo.com - there is plenty of controversy about who how these should be assigned, but DNS names look like the best contenders.
Is an opaque string assigned by foo.com, it can be any printable ascii - and may or may not be case dependant - for now I recommend we require all URNs to be lower case, just so we win whichever the IETF decides.
The IETF could talk about this for ever, a proposal merging 3 or 4 competing ideas and meeting the formal "requirements document" was presented last October, but the IETF doesn't set timelines, so other proposals keep appearing faster than they can be debunked. Personally I wouldn't bet on IETF ever agreeing, although recent reorganisation of the working group to seperate URN's to its own group ups the odds a bit!

URN's now, and later

For this proposal to succeed we need to address three timelines:
  1. In the short term, we cannot assume any server infrastructure, everything must be happening at the client.
  2. In the medium term, we can assume a server infrastructure created specifically for handling some URNs in relationship to VRML.
  3. In the long term, we can assume a global URN infrastructure, however how long this will take is anyone's guess.

Short term - client only

In the short term, we are relying on the client only, to do this, in brief, the client receives a URN as part of a WWWInline, or WWWAnchor, and then looks up in a hierarchy of tables to determine if/where it has a copy of the file.

This requires four steps:

  1. Make WWWInline a MFString rather than SFString.
    This allows a client to see a list of potential locations for an object, and use the first one available. This is generally usefull for clients that don't implement URN's since it allows multiple alternate locations for the same file - increasing reliability.

    Its also usefull for the generic objects scenario, where a client can display a URL it does have cached, while waiting for the correct one to be downloaded e.g.

    WWWInline { 
        name [ "urn:foo.com:abc126,                  # A URN for the fancy phone 
               "http://www.foo.com/fancyphone.wrl",  # Where we know there is a copy
               "http://vrml.org/generic/phone.wrl ]  # A generic version to use now
  2. Define a file format for resolving URNs. This format should allow easy future extension to support networked URN resolution. A typical top level URN file might look like.
        # We have the object library from foo.com here
        urn:foo.com:* @file:c:/objectlib/foo/index.urn
        # Maybe we have the URN cached from earlier
        *             @file:e:/objectcache/index.urn
        # Try looking in d: (the CDROM) maybe its there
        *             @file:d:/index.urn
    Note the "@" to denote to look in that file, rather than return the file.

    Lower level URN files would look something like

        urn:foo.com:abc123 file:c:/objectlib/foo/table.wrl
        urn:foo.com:abc124 file:c:/objectlib/foo/chair.wrl

    Of course, a clever browser might implement its own, more efficient, binary format, but we need a common shared format.

  3. Browsers would need to know where to go to find the top level file, e.g. by looking in the .ini file
  4. CDRom makers would need a standard location to put a URN index of objects on their disk - I suggest index.urn in the top directory.

Medium Term - some server support

In the medium term, when we can assume some server support for this, then the client wants to be able to go across the network to resolve a URN. Retrieving a URN should be no different from retrieving a URL.

This is implemented by:

  1. Add a network format to the URN file e.g.
        urn:bar.com:* @http://bar.com
        urn:*         @http://vrml.org
  2. The client sends queries to the http server specified.
  3. The server can return the document specified, (typically this will be where it holds the doc, or is a caching server)
  4. Alternatively, the server sends back a HTTP Redirect message - typically where the server is just providing resolution services.
  5. The client interprets the redirect message to retrieve the file from the real server.
  6. We can add a Form-based registration processes, so that sites like vrml.org can know where certain collections of objects are available.

Long term - global infrastructure

This gives us a number of migration directions, if and when URNs become widely deployed and supported.
  1. Implement URN resolution and/or retrieval in common caching http servers
  2. Have caching servers, and resolution servers that implement the official URN resolution method (whatever that is).
  3. Use the real URN standard resolution method directly from the clients


This document outlines a simple way to add URN support to existing clients, while retaining our options towards a really usefull URN resolution system in the future.