/*

 * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/**

 *  <p>The <code>javax.management.namespace</code> package makes it possible

 *  to federate MBeanServers into a hierarchical name space.</p>

 *

 *  <h3 id="WhatIs">What Is a Name Space?</h3>

 *  <p>

 *      A name space is like an {@link javax.management.MBeanServer} within

 *      an {@code MBeanServer}. Just as a file system folder can contain

 *      another file system folder, an {@code MBeanServer} can contain another

 *      {@code MBeanServer}. Similarly, just as a remote folder on a remote

 *      disk can be mounted on a parent folder on a local disk, a remote name

 *      space in a remote {@code MBeanServer} can be mounted on a name

 *      space in a local parent {@code MBeanServer}.

 *  </p>

 *  <p>

 *      The <code>javax.management.namespace</code> API thus makes it possible to

 *      create a hierarchy of MBean servers federated in a hierarchical name

 *      space inside a single {@code MBeanServer}.

 *  </p>

 *  <h3 id="HowToCreate">How To Create a Name Space?</h3>

 *  <p>

 *      To create a name space, you only need to register a

 *      {@link javax.management.namespace.JMXNamespace} MBean in

 *      an MBean server. We have seen that a namespace is like

 *      an {@code MBeanServer} within an {@code MBeanServer}, and

 *      therefore, it is possible to create a namespace that shows the

 *      content of another {@code MBeanServer}. The simplest case is

 *      when that {@code MBeanServer} is another {@code MBeanServer}

 *      created by the {@link javax.management.MBeanServerFactory} as

 *      shown in the extract below:

 *  </p>

 *  <pre>

 *  final MBeanServer server = ....;

 *  final String namespace = "foo";

 *  final ObjectName namespaceName = {@link javax.management.namespace.JMXNamespaces#getNamespaceObjectName

 *        JMXNamespaces.getNamespaceObjectName(namespace)};

 *  server.registerMBean(new JMXNamespace(MBeanServerFactory.newMBeanServer()),

 *                      namespaceName);

 *  </pre>

 *  <p id="NamespaceView">

 *     To navigate in namespaces and view their content, the easiest way is

 *     to use an instance of {@link javax.management.namespace.JMXNamespaceView}. For instance, given

 *     the {@code server} above, in which we created a namespace {@code "foo"},

 *     it is possible to create a {@code JMXNamespaceView} that will make it

 *     possible to navigate easily in the namespaces and sub-namespaces of that

 *     server:

 *  </p>

 *  <pre>

 *  // create a namespace view for 'server'

 *  final JMXNamespaceView view = new JMXNamespaceView(server);

 *

 *  // list all top level namespaces in 'server'

 *  System.out.println("List of namespaces: " + Arrays.toString({@link javax.management.namespace.JMXNamespaceView#list() view.list()}));

 *

 *  // go down into namespace 'foo': provides a namespace view of 'foo' and its

 *  // sub namespaces...

 *  final JMXNamespaceView foo = {@link javax.management.namespace.JMXNamespaceView#down view.down("foo")};

 *

 *  // list all MBeans contained in namespace 'foo'

 *  System.out.println({@link javax.management.namespace.JMXNamespaceView#where() foo.where()} + " contains: " +

 *         {@link javax.management.namespace.JMXNamespaceView#getMBeanServerConnection foo.getMBeanServerConnection()}.queryNames(null,null));

 *  </pre>

 * <p>

 *   It is also possible to create more complex namespaces, such as namespaces

 *   that point to MBean servers located in remote JVMs.

 * </p>

 * <p>

 *      For instance, to mount the MBeanServer accessible

 *      at <code>service:jmx:rmi:///jndi/rmi://localhost:9000/jmxrmi</code>

 *      in a name space {@code "foo"} inside the {@linkplain

 *      java.lang.management.ManagementFactory#getPlatformMBeanServer platform

 *      MBeanServer} you would write the following piece of code:

 *  </p>

 *  <pre>

 *      final JMXServiceURL sourceURL =

 *         new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9000/jmxrmi");

 *      final MBeanServer platform = ManagementFactory.getPlatformMBeanServer();

 *      final Map<String,Object> options = Collections.emptyMap();

 *      final JMXRemoteNamespace mbean = {@link

 *            javax.management.namespace.JMXRemoteNamespace JMXRemoteNamespace}.

 *         {@link javax.management.namespace.JMXRemoteNamespace#newJMXRemoteNamespace newJMXRemoteNamespace(sourceURL, options)};

 *      final ObjectName name = {@link javax.management.namespace.JMXNamespaces JMXNamespaces}.{@link javax.management.namespace.JMXNamespaces#getNamespaceObjectName(String) getNamespaceObjectName("foo")};

 *      final ObjectInstance ref = platform.registerMBean(mbean,name);

 *      platform.invoke(ref.getObjectName(),"connect",null,null);

 *  </pre>

 *

 *  <h3 id="WhatLike">What Does a Name Space Look Like?</h3>

 *

 *  <p>

 *   We have seen that {@link javax.management.namespace.JMXNamespaceView} class

 *   provides an easy way to navigate within namespaces. It is however also

 *   possible to interact with namespaces directly from the top level

 *   {@code MBeanServer} in which they have been created.

 *      From the outside, a name space only appears as a special MBean in

 *      the MBean server. There's nothing much you can do with this MBean

 *      directly.

 *  </p>

 *  <p>

 *      For instance, let's assume you have registered a {@link

 *      javax.management.namespace.JMXRemoteNamespaceMBean

 *      JMXRemoteNamespaceMBean} to manage the name space {@code "foo"}.

 *      <br>If you query for

 *      <code>platform.queryNames("&#42;//:*",null)</code>, then you will see

 *      one MBean named {@code "foo//:type=JMXNamespace"}.

 *      <br>This is the {@link javax.management.namespace.JMXNamespace}

 *      MBean which is in charge of handling the namespace {@code "foo"}.

 *  </p>

 *  <p>

 *      In fact, name space handler MBeans are instances of

 *      the class {@link javax.management.namespace.JMXNamespace} - or

 *      instances of a subclass of that class.

 *      They have a special {@link javax.management.ObjectName} defined by

 *      {@link javax.management.namespace.JMXNamespaces#getNamespaceObjectName

 *      JMXNamespaces.getNamespaceObjectName}.<br>

 *      {@link javax.management.namespace.JMXNamespace} instances are able

 *      to return an {@link

 *      javax.management.namespace.JMXNamespace#getSourceServer MBeanServer}

 *      which corresponds to the MBeanServer within (= the name space itself).

 *  </p>

 *  <p>

 *      So how does it work? How can you see the MBeans contained in the new

 *      name space?

 *  </p>

 *  <p>In order to address scalability issues, MBeans registered in

 *     namespaces (such as our namespace {@code "foo"} above) can not be

 *     seen with {@code mbeanServer.queryNames("*:*",null)}. To see the MBeans

 *     contained in a namespace, you can use one of these methods:

 *  </p>

 *  <ol>

 *      <li>

 *          You can use the {@link javax.management.namespace.JMXNamespaceView}

 *          class <a href="#NamespaceView">shown above</a>,

 *      </li>

 *      <li>

 *          or you can <a href="#NamespacePrefix">directly look</a> for MBeans

 *          whose names match

 *         {@code "foo//*:*"},

 *      </li>

 *      <li>

 *          or you can <a href="#ChangeTo">narrow down</a> to the namespace

 *          and obtain an MBeanServer

 *          proxy that corresponds to an MBeanServer view of that namespace.

 *          The JMXNamespaces class provides a static method that

 *          allows you to narrow down to a name space, by calling

 *          {@link javax.management.namespace.JMXNamespaces#narrowToNamespace(MBeanServer,String)

 *                 JMXNamespaces.narrowToNamespace}.

 *      </li>

 *  </ol>

 *

 *  <h3 id="NamespacePrefix">Using Name Space Prefixes</h3>

 *  <p>

 *      As we have explained above, MBeans contained in name

 *      spaces are not returned by {@code server.queryNames(null,null)} - or

 *      <code>server.queryNames({@link javax.management.ObjectName#WILDCARD ObjectName.WILDCARD},null)</code>.

 *      <br>

 *      However, these MBeans can still be accessed from the top level

 *      {@code MBeanServer} interface, without using any API specific to the

 *      version 2.0 of the JMX API, simply by using object names with

 *      name space prefixes:

 *      <br>To list MBeans contained in a namespace {@code "foo"} you can

 *      query for MBeans whose names match {@code "foo//*:*"}, as shown

 *      earlier in this document:

 *      <pre>

 *         server.queryNames(new ObjectName("foo//*:*", null);

 *         // or equivalently:

 *         server.queryNames(JMXNamespaces.getWildcardFor("foo"), null);

 *      </pre>

 *      This will return a list of MBean names whose domain name starts

 *      with {@code foo//}.

 *  </p><p>

 *      Using these names, you can invoke any operation on the corresponding

 *      MBeans. For instance, to get the {@link javax.management.MBeanInfo

 *      MBeanInfo} of an MBean

 *      contained in name space {@code "foo"} (assuming

 *      the name of the MBean within its name space is <i>domain:type=Thing</i>,

 *      then simply call:

 *      <pre>

 *         server.getMBeanInfo(new ObjectName("foo//domain:type=Thing"));

 *      </pre>

 *      An easier way to access MBeans contained in a name space is to

 *      <i>cd</i> inside the name space, as shown in the following paragraph.

 *  </p>

 *

 *  <h3 id="ChangeTo">Narrowing Down Into a Name Spaces</h3>

 *  <p>

 *      As we have seen, name spaces are like MBean servers within MBean servers.

 *      Therefore, it is possible to view a name space just as if it were

 *      an other MBean server. This is similar to opening a sub

 *      folder from a parent folder.<br>

 *      This operation is illustrated in the code extract below:

 *      <pre>

 *          final MBeanServer foo =

 *                JMXNamespaces.narrowToNamespace(platform, "foo");

 *          final MBeanInfo info =

 *                foo.getMBeanInfo(new ObjectName("domain:type=Thing"));

 *      </pre>

 *      The {@code MBeanServer} returned by {@link

 *      javax.management.namespace.JMXNamespaces#narrowToNamespace(MBeanServer,String)

 *      JMXNamespaces.narrowToNamespace} is an {@code MBeanServer} view that

 *      narrows down into a given namespace. The MBeans contained inside that

 *      namespace can now be accessed by their regular local name. <br>

 *      The MBean server obtained by narrowing down

 *      to name space {@code "foo"} behaves just like a regular MBean server.

 *      However, it may sometimes throw an {@link

 *      java.lang.UnsupportedOperationException UnsupportedOperationException}

 *      wrapped in a JMX exception if you try to call an operation which is not

 *      supported by the underlying name space handler.

 *      <br>For instance, {@link javax.management.MBeanServer#registerMBean

 *      registerMBean} is not supported for name spaces mounted from remote

 *      MBean servers.

 *  </p>

 *  <p>

 *      <u>Note:</u> If you have a deep hierarchy of namespaces, and if you

 *      are switching from one namespace to another in the course of your

 *      application, it might be more convenient to use a

 *      {@link javax.management.namespace.JMXNamespaceView}

 *      in order to navigate in your namespaces.

 *  </p>

 *

 *  <h3 id="NamespaceTypes">Different Types of Name Spaces</h3>

 *      <p>

 *          This API lets you create several types of name spaces:

 *          <ul>

 *              <li id="RemoteNS">

 *                  You can use the {@link

 *                  javax.management.namespace.JMXRemoteNamespace

 *                  JMXRemoteNamespace} to create

 *                  <b>remote</b> name spaces, mounted from

 *                  a remote sub {@code MBeanServer} source, as shown

 *                  <a href="#HowToCreate">earlier</a> in this document.

 *              </li>

 *              <li id="LocalNS">

 *                  You can also use {@link

 *                  javax.management.namespace.JMXNamespace

 *                  JMXNamespace} to create

 *                  <b>local</b> name spaces,

 *                  by providing a direct reference to another {@code MBeanServer}

 *                  instance living in the same JVM.

 *              </li>

 *              <li id="VirtualNS">

 *                  Finally, you can create

 *                  name spaces containing <b>virtual</b> MBeans,

 *                  by subclassing the {@link

 *                  javax.management.namespace.MBeanServerSupport

 *                  MBeanServerSupport}, and passing an instance of

 *                  your own subclass to a {@link

 *                  javax.management.namespace.JMXNamespace JMXNamespace}.

 *              </li>

 *              <li id="CustomNS">

 *                  If none of these classes suit your needs, you can also provide

 *                  <b>your own</b> subclass of {@link

 *                  javax.management.namespace.JMXNamespace

 *                  JMXNamespace}. This is however discouraged.

 *              </li>

 *          </ul>

 *      </p>

 *

 *      <h3 id="SpecialOp">Name Spaces And Special Operations</h3>

 *      <p>

 *          MBean Naming considerations aside, Name Spaces are transparent for

 *          most {@code MBeanServer} operations. There are however a few

 *          exceptions:

 *      </p>

 *      <ul>

 *          <li>

 *              <p>MBeanServer only operations - these are the operations which are

 *              supported by {@link javax.management.MBeanServer MBeanServer} but

 *              are not present in {@link

 *              javax.management.MBeanServerConnection

 *              MBeanServerConnection}. Since a name space can be a local view of

 *              a remote {@code MBeanServer}, accessible only through an

 *              {@code MBeanServerConnection}, these

 *              kinds of operations are not always supported.</p>

 *              <ul>

 *                  <li id="registerMBean">

 *                      <p>registerMBean:</p>

 *                      <p> The {@link javax.management.MBeanServer#registerMBean

 *                          registerMBean}

 *                          operation is not supported by most name spaces. A call

 *                          to

 *                          <pre>

 *   MBeanServer server = ....;

 *   ThingMBean mbean = new Thing(...);

 *   ObjectName name = new ObjectName("foo//domain:type=Thing");

 *   server.registerMBean(mbean, name);

 *                          </pre>

 *                          will usually fail, unless the name space

 *                          {@code "foo"} is a <a href="#LocalNS">local</a> name

 *                          space. In the case where you attempt to cross

 *                          multiple name spaces, then all name spaces in the

 *                          path must support the {@code registerMBean} operation

 *                          in order for it to succeed.<br>

 *                          To create an MBean inside a name space, it is

 *                          usually safer to use {@code createMBean} -

 *                          although some <a href="#MBeanCreation">special

 *                          considerations</a> can also apply.

 *                      </p>

 *         <p></p>

 *                  </li>

 *                  <li id="getClassLoader">

 *                      <p>getClassLoader:</p>

 *                      <p> Similarly to <a href="#registerMBean">registerMBean</a>,

 *                          and for the same reasons, {@link

 *                          javax.management.MBeanServer#getClassLoader

 *                          getClassLoader} will usually fail, unless the

 *                          class loader is an MBean registered in a

 *                          <a href="#LocalNS">local</a> name space.<br>

 *                      </p>

 *                  </li>

 *                  <li id="getClassLoaderFor">

 *                      <p>getClassLoaderFor:</p>

 *                      <p> The implementation of {@link

 *                          javax.management.MBeanServer#getClassLoaderFor

 *                          getClassLoaderFor} also depends on which

 *                          <a href="#NamespaceTypes">type of name space</a>

 *                          handler is used across the namespace path.

 *                      </p>

 *                      <p>

 *                          A <a href="#LocalNS">local</a> name space will usually

 *                          be able to implement this method just as a real

 *                          {@code MBeanServer} would. A

 *                          <a href="#RemoteNS">remote</a> name space will usually

 *                          return the default class loader configured on the

 *                          internal {@link javax.management.remote.JMXConnector

 *                          JMXConnector} used to connect to the remote server.

 *                          When a {@link

 *                          javax.management.namespace.JMXRemoteNamespace

 *                          JMXRemoteNamespace} is used to connect to a

 *                          remote server that contains MBeans which export

 *                          custom types, the {@link

 *                          javax.management.namespace.JMXRemoteNamespace

 *                          JMXRemoteNamespace} must thus be configured with

 *                          an options map such that the underlying connector

 *                          can obtain a default class loader able

 *                          to handle those types.

 *                      </p>

 *                      <p>

 *                          Other <a href="#NamespaceTypes">types of name spaces</a>

 *                          may implement this method

 *                          as best as they can.

 *                      </p>

 *                  </li>

 *              </ul>

 *          </li>

 *          <li id="MBeanCreation">

 *              <p>MBean creation</p>

 *              <p> MBean creation through {@link

 *                  javax.management.MBeanServerConnection#createMBean

 *                  createMBean} might not be supported by all

 *                  name spaces: <a href="#LocalNS">local</a> name spaces and

 *                  <a href="#LocalNS">remote</a> name spaces will usually

 *                  support it, but <a href="#VirtualNS">virtual</a> name

 *                  spaces and <a href="#CustomNS">custom</a> name

 *                  spaces might not.

 *              </p>

 *              <p>

 *                  In that case, they will throw an {@link

 *                  java.lang.UnsupportedOperationException

 *                  UnsupportedOperationException} usually wrapped into an {@link

 *                  javax.management.MBeanRegistrationException}.

 *              </p>

 *          </li>

 *          <li id="Notifications">

 *              <p>Notifications</p>

 *              <p> Some namespaces might not support JMX Notifications. In that

 *                  case, a call to add or remove notification listener for an

 *                  MBean contained in that name space will raise a

 *                  {@link javax.management.RuntimeOperationsException

 *                  RuntimeOperationsException} wrapping an {@link

 *                  java.lang.UnsupportedOperationException

 *                  UnsupportedOperationException} exception.

 *              </p>

 *          </li>

 *      </ul>

 *

 *      <h3 id="CrossingNamespace">Crossing Several Name Spaces</h3>

 *      <p>

 *          Just as folders can contain other folders, name spaces can contain

 *          other name spaces. For instance, if an {@code MBeanServer} <i>S1</i>

 *          containing a name space {@code "bar"} is mounted in another

 *          {@code MBeanServer} <i>S2</i> with name space {@code "foo"}, then

 *          an MBean <i>M1</i> named {@code "domain:type=Thing"} in namespace

 *          {@code "bar"} will appear as {@code "foo//bar//domain:type=Thing"} in

 *          {@code MBeanServer} <i>S2</i>.

 *      </p>

 *      <p>

 *          When accessing the MBean <i>M1</i> from server <i>S2</i>, the

 *          method call will traverse in a cascade {@code MBeanServer} <i>S2</i>,

 *          then the name space handler for name space {@code "foo"}, then

 *          {@code MBeanServer} <i>S1</i>, before coming to the name space

 *          handler for name space {@code "bar"}.  Any operation invoked

 *          on the MBean from a "top-level" name space will therefore need to

 *          traverse all the name spaces along the name space path until

 *          it eventually reaches the named MBean. This means that an operation

 *          like <a href="#registerMBean">registerMBean</a> for instance,

 *          can only succeed if all the name spaces along the path support it.

 *      </p>

 *      <p>

 *          Narrowing to a nested name space works just the same as narrowing

 *          to a top level name space:

 *      <pre>

 *          final MBeanServer S2 = .... ;

 *          final MBeanServer bar =

 *                JMXNamespaces.narrowToNamespace(S2, "foo//bar");

 *          final MBeanInfo info =

 *                foo.getMBeanInfo(new ObjectName("domain:type=Thing"));

 *      </pre>

 *      </p>

 *

 *      <h3 id="OperationResult">Name Spaces And Operation Results</h3>

 *      <p>

 *          Operation results, as well as attribute values returned by an MBean

 *          contained in a name space must be interpreted in the context of that

 *          name space.<br>

 *          In other words, if an MBean in name space "foo" has an attribute of

 *          type {@code ObjectName}, then it must be assumed that the

 *          {@code ObjectName} returned by that MBean is relative to

 *          name space "foo".<br>

 *          The same rule aplies for MBean names that can be returned by

 *          operations invoked on such an MBean. If one of the MBean operations

 *          return, say, a {@code Set<ObjectName>} then those MBean names must

 *          also be assumed to be relative to name space "foo".<br>

 *      </p>

 *      <p>

 *          In the usual case, a JMX client will first

 *          <a href="#ChangeTo">narrow to a name space</a> before invoking

 *          any operation on the MBeans it contains. In that case the names

 *          returned by the MBean invoked can be directly fed back to the

 *          narrowed connection.

 *          <br>

 *          If however, the JMX client directly invoked the MBean from a higher

 *          name space, without having narrowed to that name space first, then

 *          the names that might be returned by that MBean will not be directly

 *          usable - the JMX client will need to either

 *          <a href="#ChangeTo">narrow to the name space</a> before using the

 *          returned names, or convert the names to the higher level name space

 *          context.

 *          <br>

 *          The {@link javax.management.namespace.JMXNamespaces JMXNamespaces}

 *          class provides methods that can be used to perform that conversion.

 *      </p>

 *

 *      <h3 id="NamespacesAndNotifications">Name Spaces And Notifications</h3>

 *      <p>

 *          As <a href="#WhatIs">already explained</a>, name spaces are very

 *          similar to {@code MBeanServer}s. It is thus possible to get

 *          {@link javax.management.MBeanServerNotification MBeanServerNotifications}

 *          when MBeans are added or removed within a name space, by registering

 *          with the {@link javax.management.MBeanServerDelegate

 *          MBeanServerDelegate} MBean of the corresponding name space.<br>

 *          However, it must be noted that the notifications emitted by a

 *          name space must be interpreted in the context of that name space.

 *          For instance, if an MBean {@code "domain:type=Thing"} contained in

 *          namespace "foo//bar" emits a notification, the source of the

 *          notification will be {@code "domain:type=Thing"}, not

 *          {@code "foo//bar//domain:type=Thing"}. <br>

 *          It is therefore recommended to keep track of the name space

 *          information when registering a listener with an MBean contained in

 *          a name space, especially if the same listener is used to receive

 *          notifications from different name spaces. An easy solution is to

 *          use the handback, as illustrated in the code below.

 *          <pre>

 *            final MBeanServer server = ...;

 *            final NotificationListener listener = new NotificationListener() {

 *                public void handleNotification(Notification n, Object handback) {

 *                    if (!(n instanceof MBeanServerNotification)) {

 *                        System.err.println("Error: expected MBeanServerNotification");

 *                        return;

 *                    }

 *                    final MBeanServerNotification mbsn =

 *                            (MBeanServerNotification) n;

 *

 *                    // We will pass the namespace path in the handback.

 *                    //

 *                    // The received notification must be interpreted in

 *                    // the context of its source - therefore

 *                    // mbsn.getMBeanName() does not include the name space

 *                    // path...

 *                    //

 *                    final String namespace = (String) handback;

 *                    System.out.println("Received " + mbsn.getType() +

 *                            " for MBean " + mbsn.getMBeanName() +

 *                            " from name space " + namespace);

 *                }

 *            };

 *            server.addNotificationListener(JMXNamespaces.insertPath("foo//bar",

 *                    MBeanServerDelegate.DELEGATE_NAME),listener,null,"foo//bar");

 *            server.addNotificationListener(JMXNamespaces.insertPath("foo//joe",

 *                    MBeanServerDelegate.DELEGATE_NAME),listener,null,"foo//joe");

 *          </pre>

 *      </p>

 *      <p>

 *          JMX Connectors may require some configuration in order to be able

 *          to forward notifications from MBeans located in name spaces.

 *          The RMI JMX Connector Server

 *          in the Java SE 7 platform is configured by default to internally

 *          use the new {@linkplain javax.management.event event service} on

 *          the server side.

 *          When the connector server is configured in this way, JMX clients

 *          which use the old JMX Notifications mechanism (such as clients

 *          running on prior versions of the JDK) will be able to

 *          to receive notifications from MBeans located in sub name spaces.

 *          This is because the connector server will transparently delegate

 *          their subscriptions to the underlying {@linkplain