PubSubManager.java

  1. /**
  2.  *
  3.  * Copyright the original author or authors
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.pubsub;

  19. import java.util.Collections;
  20. import java.util.List;
  21. import java.util.Map;
  22. import java.util.concurrent.ConcurrentHashMap;

  24. import org.jivesoftware.smack.SmackException.NoResponseException;
  25. import org.jivesoftware.smack.SmackException.NotConnectedException;
  26. import org.jivesoftware.smack.XMPPConnection;
  27. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  28. import org.jivesoftware.smack.packet.EmptyResultIQ;
  29. import org.jivesoftware.smack.packet.IQ;
  30. import org.jivesoftware.smack.packet.IQ.Type;
  31. import org.jivesoftware.smack.packet.Stanza;
  32. import org.jivesoftware.smack.packet.ExtensionElement;
  33. import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
  34. import org.jivesoftware.smackx.disco.packet.DiscoverInfo;
  35. import org.jivesoftware.smackx.disco.packet.DiscoverItems;
  36. import org.jivesoftware.smackx.pubsub.packet.PubSub;
  37. import org.jivesoftware.smackx.pubsub.packet.PubSubNamespace;
  38. import org.jivesoftware.smackx.pubsub.util.NodeUtils;
  39. import org.jivesoftware.smackx.xdata.Form;
  40. import org.jivesoftware.smackx.xdata.FormField;
  41. import org.jxmpp.jid.DomainBareJid;
  42. import org.jxmpp.jid.Jid;
  43. import org.jxmpp.jid.impl.JidCreate;
  44. import org.jxmpp.stringprep.XmppStringprepException;

  46. /**
  47.  * This is the starting point for access to the pubsub service.  It
  48.  * will provide access to general information about the service, as
  49.  * well as create or retrieve pubsub {@link LeafNode} instances.  These 
  50.  * instances provide the bulk of the functionality as defined in the 
  51.  * pubsub specification <a href="http://xmpp.org/extensions/xep-0060.html">XEP-0060</a>.
  52.  * 
  53.  * @author Robin Collier
  54.  */
  55. final public class PubSubManager
  56. {
  57.     private XMPPConnection con;
  58.     private DomainBareJid to;
  59.     private Map<String, Node> nodeMap = new ConcurrentHashMap<String, Node>();
  60.     
  61.     /**
  62.      * Create a pubsub manager associated to the specified connection.  Defaults the service
  63.      * name to <i>pubsub</i>
  64.      * 
  65.      * @param connection The XMPP connection
  66.      * @throws XmppStringprepException 
  67.      */
  68.     public PubSubManager(XMPPConnection connection) throws XmppStringprepException
  69.     {
  70.         con = connection;
  71.         to = JidCreate.domainBareFrom("pubsub." + connection.getServiceName());
  72.     }
  73.     
  74.     /**
  75.      * Create a pubsub manager associated to the specified connection where
  76.      * the pubsub requests require a specific to address for packets.
  77.      * 
  78.      * @param connection The XMPP connection
  79.      * @param toAddress The pubsub specific to address (required for some servers)
  80.      */
  81.     public PubSubManager(XMPPConnection connection, DomainBareJid toAddress)
  82.     {
  83.         con = connection;
  84.         to = toAddress;
  85.     }
  86.     
  87.     /**
  88.      * Creates an instant node, if supported.
  89.      * 
  90.      * @return The node that was created
  91.      * @throws XMPPErrorException 
  92.      * @throws NoResponseException 
  93.      * @throws NotConnectedException 
  94.      * @throws InterruptedException 
  95.      */
  96.     public LeafNode createNode() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  97.     {
  98.         PubSub reply = sendPubsubPacket(Type.set, new NodeExtension(PubSubElementType.CREATE), null);
  99.         NodeExtension elem = reply.getExtension("create", PubSubNamespace.BASIC.getXmlns());
  100.         
  101.         LeafNode newNode = new LeafNode(con, elem.getNode());
  102.         newNode.setTo(to);
  103.         nodeMap.put(newNode.getId(), newNode);
  104.         
  105.         return newNode;
  106.     }
  107.     
  108.     /**
  109.      * Creates a node with default configuration.
  110.      * 
  111.      * @param id The id of the node, which must be unique within the 
  112.      * pubsub service
  113.      * @return The node that was created
  114.      * @throws XMPPErrorException 
  115.      * @throws NoResponseException 
  116.      * @throws NotConnectedException 
  117.      * @throws InterruptedException 
  118.      */
  119.     public LeafNode createNode(String id) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  120.     {
  121.         return (LeafNode)createNode(id, null);
  122.     }
  123.     
  124.     /**
  125.      * Creates a node with specified configuration.
  126.      * 
  127.      * Note: This is the only way to create a collection node.
  128.      * 
  129.      * @param name The name of the node, which must be unique within the 
  130.      * pubsub service
  131.      * @param config The configuration for the node
  132.      * @return The node that was created
  133.      * @throws XMPPErrorException 
  134.      * @throws NoResponseException 
  135.      * @throws NotConnectedException 
  136.      * @throws InterruptedException 
  137.      */
  138.     public Node createNode(String name, Form config) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  139.     {
  140.         PubSub request = PubSub.createPubsubPacket(to, Type.set, new NodeExtension(PubSubElementType.CREATE, name), null);
  141.         boolean isLeafNode = true;
  142.         
  143.         if (config != null)
  144.         {
  145.             request.addExtension(new FormNode(FormNodeType.CONFIGURE, config));
  146.             FormField nodeTypeField = config.getField(ConfigureNodeFields.node_type.getFieldName());
  147.             
  148.             if (nodeTypeField != null)
  149.                 isLeafNode = nodeTypeField.getValues().get(0).equals(NodeType.leaf.toString());
  150.         }

  152.         // Errors will cause exceptions in getReply, so it only returns
  153.         // on success.
  154.         sendPubsubPacket(con, request);
  155.         Node newNode = isLeafNode ? new LeafNode(con, name) : new CollectionNode(con, name);
  156.         newNode.setTo(to);
  157.         nodeMap.put(newNode.getId(), newNode);
  158.         
  159.         return newNode;
  160.     }

  162.     /**
  163.      * Retrieves the requested node, if it exists.  It will throw an 
  164.      * exception if it does not.
  165.      * 
  166.      * @param id - The unique id of the node
  167.      * @return the node
  168.      * @throws XMPPErrorException The node does not exist
  169.      * @throws NoResponseException if there was no response from the server.
  170.      * @throws NotConnectedException 
  171.      * @throws InterruptedException 
  172.      */
  173.     @SuppressWarnings("unchecked")
  174.     public <T extends Node> T getNode(String id) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  175.     {
  176.         Node node = nodeMap.get(id);
  177.         
  178.         if (node == null)
  179.         {
  180.             DiscoverInfo info = new DiscoverInfo();
  181.             info.setTo(to);
  182.             info.setNode(id);
  183.             
  184.             DiscoverInfo infoReply = (DiscoverInfo) con.createPacketCollectorAndSend(info).nextResultOrThrow();

  186.             if (infoReply.hasIdentity(PubSub.ELEMENT, "leaf")) {
  187.                 node = new LeafNode(con, id);
  188.             }
  189.             else if (infoReply.hasIdentity(PubSub.ELEMENT, "collection")) {
  190.                 node = new CollectionNode(con, id);
  191.             }
  192.             else {
  193.                 // XEP-60 5.3 states that
  194.                 // "The 'disco#info' result MUST include an identity with a category of 'pubsub' and a type of either 'leaf' or 'collection'."
  195.                 // If this is not the case, then we are dealing with an PubSub implementation that doesn't follow the specification.
  196.                 throw new AssertionError(
  197.                                 "PubSub service '"
  198.                                                 + to
  199.                                                 + "' returned disco info result for node '"
  200.                                                 + id
  201.                                                 + "', but it did not contain an Identity of type 'leaf' or 'collection' (and category 'pubsub'), which is not allowed according to XEP-60 5.3.");
  202.             }
  203.             node.setTo(to);
  204.             nodeMap.put(id, node);
  205.         }
  206.         return (T) node;
  207.     }
  208.     
  209.     /**
  210.      * Get all the nodes that currently exist as a child of the specified
  211.      * collection node.  If the service does not support collection nodes
  212.      * then all nodes will be returned.
  213.      * 
  214.      * To retrieve contents of the root collection node (if it exists), 
  215.      * or there is no root collection node, pass null as the nodeId.
  216.      * 
  217.      * @param nodeId - The id of the collection node for which the child 
  218.      * nodes will be returned.  
  219.      * @return {@link DiscoverItems} representing the existing nodes
  220.      * @throws XMPPErrorException 
  221.      * @throws NoResponseException if there was no response from the server.
  222.      * @throws NotConnectedException 
  223.      * @throws InterruptedException 
  224.      */
  225.     public DiscoverItems discoverNodes(String nodeId) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  226.     {
  227.         DiscoverItems items = new DiscoverItems();
  228.         
  229.         if (nodeId != null)
  230.             items.setNode(nodeId);
  231.         items.setTo(to);
  232.         DiscoverItems nodeItems = (DiscoverItems) con.createPacketCollectorAndSend(items).nextResultOrThrow();
  233.         return nodeItems;
  234.     }
  235.     
  236.     /**
  237.      * Gets the subscriptions on the root node.
  238.      * 
  239.      * @return List of exceptions
  240.      * @throws XMPPErrorException 
  241.      * @throws NoResponseException 
  242.      * @throws NotConnectedException 
  243.      * @throws InterruptedException 
  244.      */
  245.     public List<Subscription> getSubscriptions() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  246.     {
  247.         Stanza reply = sendPubsubPacket(Type.get, new NodeExtension(PubSubElementType.SUBSCRIPTIONS), null);
  248.         SubscriptionsExtension subElem = reply.getExtension(PubSubElementType.SUBSCRIPTIONS.getElementName(), PubSubElementType.SUBSCRIPTIONS.getNamespace().getXmlns());
  249.         return subElem.getSubscriptions();
  250.     }
  251.     
  252.     /**
  253.      * Gets the affiliations on the root node.
  254.      * 
  255.      * @return List of affiliations
  256.      * @throws XMPPErrorException 
  257.      * @throws NoResponseException 
  258.      * @throws NotConnectedException 
  259.      * @throws InterruptedException 
  260.      * 
  261.      */
  262.     public List<Affiliation> getAffiliations() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  263.     {
  264.         PubSub reply = sendPubsubPacket(Type.get, new NodeExtension(PubSubElementType.AFFILIATIONS), null);
  265.         AffiliationsExtension listElem = reply.getExtension(PubSubElementType.AFFILIATIONS);
  266.         return listElem.getAffiliations();
  267.     }

  269.     /**
  270.      * Delete the specified node
  271.      * 
  272.      * @param nodeId
  273.      * @throws XMPPErrorException 
  274.      * @throws NoResponseException 
  275.      * @throws NotConnectedException 
  276.      * @throws InterruptedException 
  277.      */
  278.     public void deleteNode(String nodeId) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  279.     {
  280.         sendPubsubPacket(Type.set, new NodeExtension(PubSubElementType.DELETE, nodeId), PubSubElementType.DELETE.getNamespace());
  281.         nodeMap.remove(nodeId);
  282.     }
  283.     
  284.     /**
  285.      * Returns the default settings for Node configuration.
  286.      * 
  287.      * @return configuration form containing the default settings.
  288.      * @throws XMPPErrorException 
  289.      * @throws NoResponseException 
  290.      * @throws NotConnectedException 
  291.      * @throws InterruptedException 
  292.      */
  293.     public ConfigureForm getDefaultConfiguration() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  294.     {
  295.         // Errors will cause exceptions in getReply, so it only returns
  296.         // on success.
  297.         PubSub reply = sendPubsubPacket(Type.get, new NodeExtension(PubSubElementType.DEFAULT), PubSubElementType.DEFAULT.getNamespace());
  298.         return NodeUtils.getFormFromPacket(reply, PubSubElementType.DEFAULT);
  299.     }
  300.     
  301.     /**
  302.      * Gets the supported features of the servers pubsub implementation
  303.      * as a standard {@link DiscoverInfo} instance.
  304.      * 
  305.      * @return The supported features
  306.      * @throws XMPPErrorException 
  307.      * @throws NoResponseException 
  308.      * @throws NotConnectedException 
  309.      * @throws InterruptedException 
  310.      */
  311.     public DiscoverInfo getSupportedFeatures() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  312.     {
  313.         ServiceDiscoveryManager mgr = ServiceDiscoveryManager.getInstanceFor(con);
  314.         return mgr.discoverInfo(to);
  315.     }

  317.     private PubSub sendPubsubPacket(Type type, ExtensionElement ext, PubSubNamespace ns)
  318.                     throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  319.         return sendPubsubPacket(con, to, type, Collections.singletonList(ext), ns);
  320.     }

  322.     static PubSub sendPubsubPacket(XMPPConnection con, Jid to, Type type, List<ExtensionElement> extList, PubSubNamespace ns) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  323.     {
  324.         PubSub pubSub = new PubSub(to, type, ns);
  325.         for (ExtensionElement pe : extList) {
  326.             pubSub.addExtension(pe);
  327.         }
  328.         return sendPubsubPacket(con ,pubSub);
  329.     }

  331.     static PubSub sendPubsubPacket(XMPPConnection con, PubSub packet) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
  332.     {
  333.         IQ resultIQ = con.createPacketCollectorAndSend(packet).nextResultOrThrow();
  334.         if (resultIQ instanceof EmptyResultIQ) {
  335.             return null;
  336.         }
  337.         return (PubSub) resultIQ;
  338.     }

  340. }
Created with JaCoCo 0.7.4.201502262128