<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE xep SYSTEM 'xep.dtd' [
  <!ENTITY % ents SYSTEM "xep.ent">
%ents;
]>
<?xml-stylesheet type='text/xsl' href='xep.xsl'?>
<xep>
<header>
  <title>Publish/Subscribe</title>
  <abstract>A publish-subscribe protocol for Jabber.</abstract> 
  <legal>This document has been placed in the public domain.</legal>
  <number>0024</number>
  <status>Retracted</status>
  <type>Standards Track</type>
  <sig>Standards</sig>
  <supersedes>None</supersedes>
  <supersededby>XEP-0060</supersededby>
  <shortname>None</shortname>
  <author>
    <firstname>DJ</firstname>
    <surname>Adams</surname>
    <email>dj.adams@pobox.com</email>
    <jid>dj@gnu.mine.nu</jid>
  </author>
  <author>
    <firstname>Piers</firstname>
    <surname>Harding</surname>
    <email>piers@ompa.net</email>
    <jid>piers@gnu.mine.nu</jid>
  </author>
  <revision>
    <version>0.2</version>
    <date>2003-04-22</date>
    <initials>psa</initials>
    <remark>At the request of the authors, the status of this document has been changed to Retracted since it has been superseded by XEP-0060.</remark>
  </revision>
  <revision>
    <version>0.1</version>
    <date>2002-03-05</date>
    <initials>dja</initials>
    <remark>Initial draft.</remark>
  </revision>
</header>

<section1 topic='Abstract'>
<p>
Pubsub ("publish/subscribe") is a technique for coordinating the efficient
delivery of information from publisher to consumer. This specification
describes the use of pubsub within a Jabber context and is a result of
two separate but related goals:
</p>

<ul>
<li>to be able to exchange information _within_ a Jabber environment
(for example continuously changing personal information between users)</li>
<li>to be able to exchange information _using_ Jabber as a mechanism for
<ul>
<li>organising that exchange</li>
<li>providing transport for the information</li>
</ul>
</li>
</ul>

<p>
The specification details the use of the Jabber protocol elements and
introduces a new namespace, jabber:iq:pubsub. 
It also includes notes on actual implementation of such a
mechanism in Jabber.
</p>

</section1>


<section1 topic='Introduction'>
<p>
It's clear that as Jabber is deployed over a wider spectrum of platforms
and circumstances, more and more information will be exchanged. Whether
that information is specific to Jabber (JSM) users, or components, we need
an mechanism to be able to manage the exchange of this information in an
efficient way. 
</p>

<p>
For example, it is currently the trend to embed information about a
particular client's circumstance inside presence packets, either in the
&lt;status/&gt; tag or in an &lt;x/&gt; extension. One example that comes
to mind is "song currently playing on my MP3 player" (to which I have to
admit some responsibility for the meme in the first place). While embedding
information inside presence packets and having that information diffused to
the users who are subscribed to that user's presence has the desired effect,
it has a couple of non-trivial drawbacks:
</p>

<ul>
<li>the diffusion is inefficient, sending potentially huge amounts of data
to recipients who aren't interested</li>
<li>the distribution is tied to closely to presence subscription; any entity
that wants to receive information must be subscribed to the source's presence,
and there is no mechanism for specifying _what_ information they wish to
receive. It is also arguably too closely tied to the JSM to be useful for
_component_-based information exchange.</li>
</ul>

<p>
This is above and beyond the simple fact that this overloading of presence
packets and the presence subscription and diffusion mechanism can only end
in tears.
</p>

<p>
It would be far better to have a separate (sub-)protocol that enabled
entities to take part in publish/subscribe relationships, and have a service
that facilitated the efficient exchange of information. Not only would it
relax the undue pressure on the presence mechanism, but it would also allow
people to use Jabber, which is, after all, about exchanging structured content
between endpoints, as a publish/subscribe _mechanism_ in its own right.
</p>

<p>
This specification describes a publish/subscribe protocol in terms
of IQ packets with payload data in a new namespace, jabber:iq:pubsub. The
choice for this namespace is slightly arbitrary - it was the same namespace
used in temas's original document, seems to fit well, and we need a namespace
to focus on.<note>It may well be that we will move to a URI-based namespace
in the form of a URL pointing to this specification.</note>
</p>

<p>
The aim of the specification is to provide for a facility where Jabber
entities can subscribe to (consume) and publish (emit) information in an
efficient and organised way. These entities could be JSM users or components.
</p>

<p>
Push technology is back with a vengeance. Jabber can play a fundamental
part.
</p>

</section1>

<section1 topic='The Specification'>

<p>
The pubsub services will be typically provided by a component. In what
follows, there are generally three parties involved:
</p>

<ul>
<li>the subscriber</li>
<li>the pubsub service</li>
<li>the publisher</li>
</ul>

<p>
Bear in mind that it is perfectly possible for a subscriber to be a
publisher, and a publisher to be a subscriber, too.
</p>

<p>
The pubsub traffic will be carried in info/query (IQ) packets. All of the
data in these packets will be qualified by the jabber:iq:pubsub namespace.
</p>

<p>
Pubsub scenarios can be seen in a subscribe (or unsubscribe) context or a
publish context. In light of this, we will examine the IQ packets
used in these contexts.
</p>

<section2 topic='Subscribe/Unsubscribe Context'>

<p>
A potential consumer, or recipient, of published information, needs to
request that he be sent that published information. Requesting to receive,
or be pushed, information is known as subscribing.
</p>

<p>
A subscription request generally takes this form:
</p>

<example caption='General form of a subscription'>
SEND: &lt;iq type='set' from='subscriber' to='pubsub' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
             &lt;ns&gt;namespace:2&lt;/ns&gt;
             ...
             &lt;ns&gt;namespace:N&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' to='subscriber' from='pubsub' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
             &lt;ns&gt;namespace:2&lt;/ns&gt;
             ...
             &lt;ns&gt;namespace:N&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<section3 option='Publisher-Specific Subscriptions and Unsubscriptions'>

<p>
Subscriptions can be specific to a publisher, in which case a to attribute
is specified in the &lt;subscribe/&gt; tag:
</p>

<example caption='Publisher-specific subscription'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
In this case, the namespaces specified will be added to any existing list
of namespaces already recorded for that subscriber:publisher relationship.
In other words, it's a relative, not an absolute, subscription request.
</p>

<p>
It is also possible in a publisher-specific subscription to omit specific
namespaces, if you want to be sent everything that particular publisher
might publish:
</p>

<example caption='Publisher-specific subscription without namespace specification'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
This type of subscription should have the effect of absolutely replacing any
previous namespace-specific subscription to the publisher specified.
</p>

<p>
If a subscriber wishes to cancel a subscription from a particular publisher,
he can send an unsubscribe like this:
</p>

<example caption='Publisher-specific unsubscription'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe to='publisher'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/unsubscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe to='publisher'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/unsubscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
This should have the effect of removing the subscription from that publisher
for the namespaces specified.
</p>

<p>
You can also send an unsubscribe without specifying any namespaces:
</p>

<example caption='Publisher-specific general unsubscription'>
SEND: &lt;iq type='set' to='pubsub.localhost' 
             from='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe to='publisher'/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe to='publisher'/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
This should have the effect of removing any subscription relationship with
the publisher specified. Note, however, that this won't stop the subscriber
being pushed information from that publisher if he's specified a
"publisher-generic" subscription (see next section).
</p>

</section3>

<section3 option='Non-Publisher-Specific Subscriptions and Unsubscriptions'>

<p>
As well as being able to subscribe to specific publishers, it is also
possible to subscribe to receive data, according to namespace, regardless
of publisher:
</p>

<example caption='General namespace specific subscription'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
This means that the subscriber wishes to be pushed information in the
namespaces specified, regardless of who publishes it. Like the
publisher-specific subscribe that specifies namespaces, this request is
relative, in the namespaces are added to any existing namespaces already
recorded for this generic subscription.
</p>

<p>
Subscribing to everything from everyone is probably not a good idea and
we should not allow this. (The format of the request is actually used in
an IQ-get context - see later).
</p>

<example caption='This is not allowed'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='error' from='pubsub.localhost'
             to='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe/&gt;
        &lt;/query&gt;
        &lt;error code='405'&gt;Not Allowed&lt;/error&gt;
      &lt;/iq&gt;
</example>


<p>
Likewise, you can unsubscribe from certain namespaces in this non-publisher-specific context like this:
</p>

<example caption='General unsubscription to specific namespaces'>
SEND: &lt;iq type='set' to='pubsub.localhost' 
             from='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/unsubscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost' 
             to='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/unsubscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
If there are any subscriptions to specific publishers for the namespaces
specified here, they should be removed (for those namespaces) in addition
to the removal from the 'all publishers' list.
</p>

<p>
Finally, a subscriber can wipe the slate clean like this:
</p>

<example caption='Wiping the slate'>
SEND: &lt;iq type='set' to='pubsub.localhost' 
             from='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost' 
             to='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;unsubscribe/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
which should have the effect of removing all namespace subscriptions
from everywhere.
</p>

</section3>

<section3 option='Further Notes'>

<p>
All the examples so far have shown actions on the subscriber's part, and
have consisted of IQ-sets. In an IQ-set, within the jabber:iq:pubsub
namespace, multiple children can exist in the query payload, but those
children must be of the same type. In other words, you can send multiple
&lt;subscribe/&gt;s, or multiple &lt;unsubscribe/&gt;s, but not a combination
of the two.
</p>

<p>
This is allowed:
</p>

<example caption='Subscribing to more than one publisher at once'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisherA'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
          &lt;subscribe to='publisherB'&gt;
            &lt;ns&gt;namespace:3&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisherA'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
          &lt;subscribe to='publisherB'&gt;
            &lt;ns&gt;namespace:3&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
But this is not allowed:
</p>

<example caption='Subscribes and unsubscribes in same IQ-set is not allowed'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisherA'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
          &lt;unsubscribe to='publisherB'&gt;
            &lt;ns&gt;namespace:3&lt;/ns&gt;
          &lt;/unsubscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisherA'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
          &lt;unsubscribe to='publisherB'&gt;
            &lt;ns&gt;namespace:3&lt;/ns&gt;
          &lt;/unsubscribe&gt;
        &lt;/query&gt;
        &lt;error code='400'&gt;
          Bad Request: only subscribes or unsubscribes
        &lt;/error&gt;
      &lt;/iq&gt;
</example>

<p>
In the case where multiple &lt;subscribe/&gt;s or &lt;unsubscribe/&gt;s
appear in an action, each element will be processed in turn, as they appear
in the payload.
</p>

<p>
As well as actions, the subscriber can query his subscription using an
IQ-get in the jabber:iq:pubsub namespace. This should return a list of
the subscribers current subscriptions, like this:
</p>

<example caption='Querying current subscription'>
SEND: &lt;iq type='get' to='pubsub.localhost'
             from='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe/&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
          &lt;subscribe to='publisherA'&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
            &lt;ns&gt;namespace:4&lt;/ns&gt;
          &lt;/subscribe&gt;
          &lt;subscribe to='publisherB'&gt;
            &lt;ns&gt;namespace:5&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
Note the two references to namespace:2 - one inside the non-publisher-specific
subscription list and one inside the subscription list specific to publisherA.
This example implies that the non-publisher-specific and publisher-specific
subscription information should be kept separately. This is designed to make
it easier on the subscriber to manage his specific subscriptions over time.
</p>

</section3>

</section2>

<section2 topic='Publish Context'>

<p>
In contrast to the subscribe and unsubscribe context, the publishing
context is a lot simpler to explain.
</p>

<p>
A publisher can publish information within a certain namespace, like this:
</p>

<example caption='Publishing information'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='publisher@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='foo'&gt;
            &lt;foo xmlns='foo'&gt;bar&lt;/foo&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='publisher@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='foo'&gt;
            &lt;foo xmlns='foo'&gt;bar&lt;/foo&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
It's also possible for a publisher to publish more than one item at once,
like this:
</p>

<example caption='Publishing information in different namespaces'>
SEND: &lt;iq type='set' to='pubsub.localhost'
             from='publisher.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='foo'&gt;
            &lt;foo xmlns='foo'&gt;bar&lt;/foo&gt;
          &lt;/publish&gt;
          &lt;publish ns='jabber:x:oob'&gt;
            &lt;x xmlns='jabber:x:oob'&gt;
              &lt;url&gt;http://www.pipetree.com/jabber/&lt;/url&gt;
              &lt;desc&gt;Some stuff about Jabber&lt;/desc&gt;
            &lt;/x&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;

RECV: &lt;iq type='result' from='pubsub.localhost'
             to='publisher.localhost' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='foo'&gt;
            &lt;foo xmlns='foo'&gt;bar&lt;/foo&gt;
          &lt;/publish&gt;
          &lt;publish ns='jabber:x:oob'&gt;
            &lt;x xmlns='jabber:x:oob'&gt;
              &lt;url&gt;http://www.pipetree.com/jabber/&lt;/url&gt;
              &lt;desc&gt;Some stuff about Jabber&lt;/desc&gt;
            &lt;/x&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<!--
<p>
Optionally, a pubsub component may respond with an empty IQ-result, to 
reduce traffic:
</p>

<example>
RECV: &lt;iq type='result' from='pubsub.localhost'
             to='publisher.localhost' id='s1'&gt;
      &lt;/iq&gt;
</example>
-->

<p>
Each published item is wrapped in a &lt;publish/&gt; tag. This tag
must contain the namespace of the item being publishes, in an ns 
attribute, as shown. This is distinct from the xmlns attribute of
the fragment of XML actually being published. It is theoretically
none of the pubsub component's business to go poking around in the
real published data, nor should it have to. It needs to know what
namespace is qualifying the published information that has been 
received, so that the list of appropriate recipients can be 
determined.
</p>

</section2>


<section2 topic='Distributing Published Information'>
<p>
While it's the responsibility of the publishing entities to publish
information, it's the responsibility of the pubsub
component to push out that published data to the subscribers. The 
list of recipient subscribers must be determined by the information
stored by the pubsub component as a result of receiving subscription
requests (which are described earlier).
</p>
<p>
On receipt of an IQ-set containing published information, the pubsub
entity must determine the list of subscribers to which that information
should be pushed. If the IQ-set contains multiple &lt;publish/&gt;
fragments, this process must be carried out for each one in turn.
<note>Whether a pubsub component implementation should be allowed to
batch up individual published information fragments for one recipient
as a result of a large, multi-part incoming publishing IQ-set, is not
specified here, the choice is down to the implementer. Receiving entities
should be able to cope with being pushed an IQ-set with multiple
fragments of published data.</note>
</p>
<p>
Taking the earlier example of the publishing of data in the 'foo'
namespace, the following example shows what the pubsub component
must send to push this foo data out to a subscriber. 
</p>
<example caption='Pushing out published information to a subscriber'>
SEND: &lt;iq type='set' to='subscriber@localhost/foosink'
             from='pubsub.localhost' id='push1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='foo' from='publisher@localhost'&gt;
            &lt;foo xmlns='foo'&gt;bar&lt;/foo&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>
<p>
The recipient is _not_ required to send an 'acknowledgement' in the 
form of an IQ-result; the idea that this _push_ of information is
akin to how information is pushed in a live browsing context (see
jabber:iq:browse documentation for more details).
</p>

</section2>

<section2 topic='Delivery Sensitivity'>

<p>
When a pubsub service receives a publish packet like the ones above, it
needs to deliver (push) the information out according to the subscriptions
that have been made. 
</p>

<p>
However, we can introduce a modicum of sensitivity by using a presence
subscription between the pubsub service and the subscriber(s). If the
subscriber wishes only to receive information when he's online (this is
a JSM-specific issue), then he needs to set up a presence subscription
relationship with the pubsub service. The pubsub service should respond
to presence subscriptions and unsubscriptions by 
</p>

<ul>
<li>accepting the (un)subscription request</li>
<li>reciprocating the (un)subscription request</li>
</ul>

<p>
If the pubsub service deems that a published piece of information should
be pushed to a subscriber, and there is a presence subscription relationship
with that subscriber, the service should only push that information to the 
subscriber if he is available. If he is not available, the information is not
to be sent. 
</p>

<p>
Thus the subscriber can control the sensitivity by initiating (or not) a
presence relationship with the service. If the subscriber wishes to receive
information regardless of availability, he should not initiate a (or cancel
any previous) presence relationship with the service. 
</p>

<p>
This loose coupling of presence relationships for sensitivity allows this
specification to be used in the wider context of component-to-component
publish/subscribe where presence is not a given.
</p>

</section2>

<section2 topic='Use of Resources'>
<p>
When in receipt of a pubsub subscription request from an entity 
where a resource is specified in the JID, the pubsub component must
honour the resource specified in the from attribute of the request.
For example, here's a typical subscription request from a JSM user:
</p>
<example caption='Incoming subscription request from a JSM user'>
RECV: &lt;iq type='set' to='pubsub.localhost'
             from='subscriber@localhost/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
            &lt;ns&gt;namespace:2&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>
<p>
When storing the subscriber/publisher/namespace relationship matrix for
eventual querying when a publisher publishes some information, the 
pubsub component must use the full JID, not just the username@host part.
</p>
<p>
Similarly, in this example:
</p>
<example caption='Incoming subscription request from a component'>
RECV: &lt;iq type='set' to='pubsub.localhost'
             from='news.server/politics-listener' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher'&gt;
            &lt;ns&gt;news:politics:home&lt;/ns&gt;
            &lt;ns&gt;news:politics:foreign:usa&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>
<p>
the full JID of the component subscriber - news.server/politics-listener,
should be used to qualify the matrix.
</p>
<p>
This is because it allows the subscribing entities to arrange the 
receipt of pushed items by resource. In the case of a JSM user, it
allows him to organise his clients, which may have different capabilities
(some being able to handle the jabber:iq:pubsub data, others not) to
receive the 'right' data. In the case of a component, it allows the
component to associate component-specific data with incoming published
namespace-qualified information.
</p>

</section2>

</section1>


<section1 topic='Implementation Notes'>

<p>
While the specification describes the fundamental building blocks of the
pubsub protocol, there are ideas that are not discussed above but nonetheless
may be incorporated into an implementation. There are other considerations
that have to be made in the wider context of publish and subscribe. Some of
the main ones are discussed briefly here too.
</p>

<section2 topic='Publisher Discovery'>
<p>
There is no part of this pubsub specification that determines how a 
potential subscriber might discover publishers. After all, there are
no rules governing which pubsub component a publisher could or should
publish to. And since pubsub subscriptions are specific to a pubsub
component, there is an information gap - "how do I find out what 
publishers there are, and through which pubsub components they're publishing
information?"
</p>
<p>
This problem domain should be solved using other methods, not with the
actual jabber:iq:pubsub specific namespace. A combination of jabber:iq:browse
usage (the magic ointment that heals all things) and perhaps a DNS style
(or at least root-node-based) knowledge hierarchy might be the right
direction.
</p>
<p>
In the case where a server administrator wishes to facilitate pubsub
flow between JSM users on a server, a pubsub component can be plugged
into the jabberd backbone, and there is potentially no real issue with
knowing which pubsub component to use, and where it is.
But what about if the JSM users on one server wish to build pubsub
relationships with JSM users on another server? (Note that this general
question is not specific to JSM users, although that example will be used
here). The next two sections look at how these things might pan out.
</p>
</section2>

<section2 topic='Cross-Server Relationships'>
<p>
When JSM users on server1 wish to subscribe to information published 
by JSM users on server2 (let's say it's the mp3 player info, or avatars)
then there are some issues that come immediately to mind:
</p>
<ul>
<li>Does a JSM user on server1 (userA@server1) send his IQ-set subscription
to the pubsub component on server2 (pubsub.server2), or server1
(pubsub.server1)?</li>
<li>If he sends it to pubsub.server2, can we expect 
pubsub.server2 to always accept that subscription request, i.e. to 
be willing to serve userA@server1 (if pubsub.server2 knows that 
pubsub.server1 exists)?</li>
<li>Will there be performance (or at least server-to-server traffic)
implications if many subscription relationships exist between subscribers on
server1 and publishers on server2?</li>
</ul>

<section3 topic='Proxy Subscriptions'>
<p>
To reduce the amount of server-to-server traffic, we can employ the 
concept of "proxy subscriptions". This is simply getting a pubsub component
to act on behalf of a (server-local) subscriber. Benefit comes when a pubsub
component acts on behalf of multiple (server-local) subscribers.
</p>
<p>
Here's how such proxy subscriptions can work, to reduce the amount of
server-to-server traffic:
</p>
<p>
Step 1: Subscriber sends original subscription
</p>
<p>
JSM users on server1 wish to subscribe to information published by an 
entity on server2. Each of them sends a subscription request to the
_local_ pubsub component:
</p>
<example>
SEND: &lt;iq type='set' to='pubsub.server1'
             from='subscriber@server1/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher.server2'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
Step2: Pubsub component subscribes on subscriber's behalf
</p>
<p>
The pubsub component knows about the publisher, and where (to which
pubsub component) that publisher publishes information. It formulates
a subscription request and sends it to the remote pubsub component:
</p>
<example>
SEND: &lt;iq type='set' to='pubsub.server2'
             from='pubsub.server1' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher.server2'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
The remote pubsub component receives and acknowledges the subscription
request, and the local pubsub component relays the response back to 
the original requester:
</p>
<example>
SEND: &lt;iq type='result' from='pubsub.server1'
             to='subscriber@server1/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher.server2'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
If the remote pubsub server was unable or unwilling to accept the 
subscription request, this should be reflected in the response:
</p>
<example>
SEND: &lt;iq type='error' from='pubsub.server1'
             to='subscriber@server1/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher.server2'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
        &lt;error code='406'&gt;Not Acceptable&lt;/error&gt;
      &lt;/iq&gt;
</example>

<p>
Step3: Publisher publishes information
</p>
<p>
The publisher, publisher.server2, publishes information in the 
namespace:1 namespace, to the remote pubsub component pubsub.server2:
</p>
<example>
SEND: &lt;iq type='set' from='publisher.server2'
             to='pubsub.server2' id='p1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='namespace;1'&gt;
            &lt;stuff xmlns='namespace:1'&gt;nonsense&lt;/stuff&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>


<p>
Step4: Pubsub component receives published information
</p>
<p>
The pubsub component pushes the published information to pubsub.server1,
who has been determined to be a valid recipient:
</p>
<example>
RECV: &lt;iq type='set' from='pubsub.server2'
             to='pubsub.server1' id='p1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='namespace;1' from='publisher.server2'&gt;
            &lt;stuff xmlns='namespace:1'&gt;nonsense&lt;/stuff&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
Step5: Pubsub component forwards published information to original subscriber
</p>
<p>
The local pubsub component then diffuses the information received to the
original subscriber:
</p>
<example>
SEND: &lt;iq type='set' from='pubsub.server1'
             to='subscriber@server1/resource' id='p1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;publish ns='namespace;1' from='publisher.server2'&gt;
            &lt;stuff xmlns='namespace:1'&gt;nonsense&lt;/stuff&gt;
          &lt;/publish&gt;
        &lt;/query&gt;
      &lt;/iq&gt;
</example>

<p>
This way, only a single published element must travel between servers
to satisfy a multiplex of subscribed entities at the delivery end.
</p>

<p>
Of course, this mechanism will rely upon knowledge about pubsub components
and where they're available; furthermore, it will require knowledge about
where publisher entities publish their information.
This knowledge, and the mechanisms to discover this sort of information,
is not to be covered in this spec, which purely deals with the subscription
and publishing of information. As SOAP is to UDDI (to use a slightly
controversial pair of technologies), so is jabber:iq:pubsub to this 
discovery mechanism as yet undefined. To include the definition of such
a discovery mechanism in this specification is wrong on two counts:
</p>
<ul>
<li>Discovery mechanisms by nature should not be tied to specific areas</li>
<li>Trying to load too much onto jabber:iq:pubsub will only produce a 
complex and hard-to-implement specification</li>
</ul>
<p>
After all, the jabber:iq:pubsub spec as defined here is usable out of the
box for the simple scenarios, and scenarios where discovery is not 
necessary or the information can be exchanged in other ways.
</p>

</section3>

<section3 topic='Willingness to Serve'>
<p>
There are some situations where it might be appropriate for a pubsub
component to refuse particular subscription requests. Here are two 
examples:
</p>
<ul>
<li>Where a pubsub component that's been designed, implemented, or
configured to handle local-only pubsub traffic, and a subscription request
is received, specifying a publisher that the local pubsub component knows
to be one that publishes to a remote pubsub component <note>under other
circumstances, this would trigger a 'Proxy Subscription', as described earlier, if supported</note>. In this case, the local pubsub component would be
unwilling to provoke a server-to-server connection and therefore unwilling to 
honour the request.</li>
<li>Where a pubsub component receives a subscription request from a 
remote subscriber, and that pubsub component knows that there's a 
pubsub component local to the subscriber. In this case, the (administrator 
of the) remote pubsub component might want to encourage proxy subscriptions.
</li>
</ul>
<p>
A refusal could take one of a number of guises:
</p>
<example caption='A flat refusal'>
SEND: &lt;iq type='error' from='pubsub.server2'
             to='subscriber@server1/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher.server2'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
        &lt;error code='406'&gt;Local pubsub only&lt;/error&gt;
      &lt;/iq&gt;
</example>
<example caption='A refusal with redirection'>
SEND: &lt;iq type='error' from='pubsub.server2'
             to='subscriber@server1/resource' id='s1'&gt;
        &lt;query xmlns='jabber:iq:pubsub'&gt;
          &lt;subscribe to='publisher.server2'&gt;
            &lt;ns&gt;namespace:1&lt;/ns&gt;
          &lt;/subscribe&gt;
        &lt;/query&gt;
        &lt;error code='302' jid='pubsub.server1'/&gt;
      &lt;/iq&gt;
</example>
<note>This 302 redirect is not covered in the general protocol specification,
but it's an interesting concept :-)</note>
</section3>

</section2>


<section2 topic='Subscriber Anonymity and Acceptance?'>
<p>
The jabber:iq:pubsub specification makes no provision for 
publishers to query a pubsub component to ask for a list of those entities
that are subscribed to (namespaces) it (publishes). This is deliberate. 
Do we wish to add to the specification to allow the publisher to discover
this information? If so, it must be as an optional 'opt-in' (or 'opt-out')
tag for the subscriber, to determine whether his JID will show up on the
list. 
<note>Even if there is no provision for querying the subscribers, perhaps
we should make a provision for the publisher to ask the pubsub component
for a list of namespaces that have been subscribed to (for that publisher).
</note>
</p>
<p>
Associated with this is the semi-reciprocal issue of acceptance? The 
specification deliberately makes no provision for a subscription acceptance
mechanism (where the publisher must first accept a subscriber's request,
via the pubsub component). If we're to prevent the publishers knowing
who is subscribing, ought we to give them the power of veto, to 'balance
things out'?
</p>
<p>
Note that if we do, the acceptance issue is not necessarily one for the
pubsub specification to resolve; there are other ways of introducing 
access control, at least in a component environment; use of a mechanism
that the Jabber::Component::Proxy Perl module represents is one example:
wedge a proxy component in front of a real (pubsub) component and have
the ability to use ACLs (access control lists) to control who gets to 
connect to the real component.
</p>

</section2>

</section1>

</xep>
