InternalComponentManager.java 10.3 KB
Newer Older
Matt Tucker's avatar
Matt Tucker committed
1 2 3 4 5 6 7 8 9 10 11
/**
 * $RCSfile$
 * $Revision$
 * $Date$
 *
 * Copyright (C) 2004 Jive Software. All rights reserved.
 *
 * This software is published under the terms of the GNU Public License (GPL),
 * a copy of which is included in this distribution.
 */

Derek DeMoro's avatar
Derek DeMoro committed
12 13
package org.jivesoftware.messenger;

14
import org.dom4j.Element;
15
import org.jivesoftware.messenger.auth.UnauthorizedException;
16 17 18 19
import org.xmpp.component.Component;
import org.xmpp.component.ComponentManager;
import org.xmpp.component.ComponentManagerFactory;
import org.xmpp.packet.IQ;
20
import org.xmpp.packet.JID;
21
import org.xmpp.packet.Packet;
22
import org.xmpp.packet.Presence;
23
import org.jivesoftware.util.Log;
Derek DeMoro's avatar
Derek DeMoro committed
24

25 26 27
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

28
/**
29
 * Manages the registration and delegation of Components. The ComponentManager
Matt Tucker's avatar
Matt Tucker committed
30
 * is responsible for managing registration and delegation of {@link Component Components},
31
 * as well as offering a facade around basic server functionallity such as sending and
32 33 34 35 36
 * receiving of packets.<p>
 *
 * This component manager will be an internal service whose JID will be component.[domain]. So the
 * component manager will be able to send packets to other internal or external components and also
 * receive packets from other components or even from trusted clients (e.g. ad-hoc commands).
37 38 39
 *
 * @author Derek DeMoro
 */
40
public class InternalComponentManager implements ComponentManager, RoutableChannelHandler {
41

42
    private Map<String, Component> components = new ConcurrentHashMap<String, Component>();
43
    private Map<JID, JID> presenceMap = new ConcurrentHashMap<JID, JID>();
Derek DeMoro's avatar
Derek DeMoro committed
44

45
    private static InternalComponentManager instance = new InternalComponentManager();
46 47 48 49 50 51 52 53 54
    /**
     * XMPP address of this internal service. The address is of the form: component.[domain]
     */
    private JID serviceAddress;
    /**
     * Holds the domain of the server. We are using an iv since we use this value many times
     * in many methods.
     */
    private String serverDomain;
Derek DeMoro's avatar
Derek DeMoro committed
55

56
    public static InternalComponentManager getInstance() {
57
        return instance;
Derek DeMoro's avatar
Derek DeMoro committed
58 59
    }

60 61 62 63
    public void start() {
        // Set this ComponentManager as the current component manager
        ComponentManagerFactory.setComponentManager(instance);

64 65 66 67
        XMPPServer server = XMPPServer.getInstance();
        serverDomain = server.getServerInfo().getName();
        // Set the address of this internal service. component.[domain]
        serviceAddress = new JID(null, "component." + serverDomain, null);
68 69 70 71
        if (!server.isSetupMode()) {
            // Add a route to this service
            server.getRoutingTable().addRoute(getAddress(), this);
        }
Derek DeMoro's avatar
Derek DeMoro committed
72 73
    }

74 75 76
    public void addComponent(String subdomain, Component component) {
        components.put(subdomain, component);

77
        JID componentJID = new JID(subdomain + "." + serverDomain);
78

79
        // Add the route to the new service provided by the component
80 81
        XMPPServer.getInstance().getRoutingTable().addRoute(componentJID,
                new RoutableComponent(componentJID, component));
82

83 84
        // Check for potential interested users.
        checkPresences();
85 86 87
        // Send a disco#info request to the new component. If the component provides information
        // then it will be added to the list of discoverable server items.
        checkDiscoSupport(component, componentJID);
Derek DeMoro's avatar
Derek DeMoro committed
88 89
    }

90 91 92
    public void removeComponent(String subdomain) {
        components.remove(subdomain);

93
        JID componentJID = new JID(subdomain + "." + serverDomain);
94 95 96 97 98

        // Remove the route for the service provided by the component
        if (XMPPServer.getInstance().getRoutingTable() != null) {
            XMPPServer.getInstance().getRoutingTable().removeRoute(componentJID);
        }
99 100

        // Remove the disco item from the server for the component that is being removed
101 102 103
        if (XMPPServer.getInstance().getIQDiscoItemsHandler() != null) {
            XMPPServer.getInstance().getIQDiscoItemsHandler().removeComponentItem(componentJID.toBareJID());
        }
Derek DeMoro's avatar
Derek DeMoro committed
104 105
    }

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
    public void sendPacket(Component component, Packet packet) {
        PacketRouter router;
        router = XMPPServer.getInstance().getPacketRouter();
        if (router != null) {
            router.route(packet);
        }
    }

    public String getProperty(String name) {
        return JiveGlobals.getProperty(name);
    }

    public void setProperty(String name, String value) {
        //To change body of implemented methods use File | Settings | File Templates.
    }

    public boolean isExternalMode() {
        return false;  //To change body of implemented methods use File | Settings | File Templates.
    }

126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
    public org.xmpp.component.Log getLog() {
        return new  org.xmpp.component.Log() {
            public void error(String msg) {
                Log.error(msg);
            }

            public void error(String msg, Throwable throwable) {
                Log.error(msg, throwable);
            }

            public void error(Throwable throwable) {
                Log.error(throwable);
            }

            public void warn(String msg) {
                Log.warn(msg);
            }

            public void warn(String msg, Throwable throwable) {
                Log.warn(msg, throwable);
            }

            public void warn(Throwable throwable) {
                Log.warn(throwable);
            }

            public void info(String msg) {
                Log.info(msg);
            }

            public void info(String msg, Throwable throwable) {
                Log.info(msg, throwable);
            }

            public void info(Throwable throwable) {
                Log.info(throwable);
            }

            public void debug(String msg) {
                Log.debug(msg);
            }

            public void debug(String msg, Throwable throwable) {
                Log.debug(msg, throwable);
            }

            public void debug(Throwable throwable) {
                Log.debug(throwable);
            }
        };
176 177
    }

178 179 180 181 182
    /**
     * Retrieves the <code>Component</code> which is mapped
     * to the specified JID.
     *
     * @param jid the jid mapped to the component.
Matt Tucker's avatar
Matt Tucker committed
183
     * @return the component with the specified id.
184 185
     */
    public Component getComponent(String jid) {
Matt Tucker's avatar
Matt Tucker committed
186 187 188
        jid = new JID(jid).toBareJID();
        if (components.containsKey(jid)) {
            return components.get(jid);
Derek DeMoro's avatar
Derek DeMoro committed
189 190
        }
        else {
Matt Tucker's avatar
Matt Tucker committed
191
            String serverName = new JID(jid).getDomain();
Derek DeMoro's avatar
Derek DeMoro committed
192
            int index = serverName.indexOf(".");
193
            if (index != -1) {
Derek DeMoro's avatar
Derek DeMoro committed
194 195 196 197
                String serviceName = serverName.substring(0, index);
                jid = serviceName;
            }
        }
Matt Tucker's avatar
Matt Tucker committed
198
        return components.get(jid);
Derek DeMoro's avatar
Derek DeMoro committed
199 200
    }

201 202
    /**
     * Registers Probeers who have not yet been serviced.
203
     *
204 205 206
     * @param prober the jid probing.
     * @param probee the presence being probed.
     */
207
    public void addPresenceRequest(JID prober, JID probee) {
208 209 210 211
        presenceMap.put(prober, probee);
    }

    private void checkPresences() {
212 213
        for (JID prober : presenceMap.keySet()) {
            JID probee = presenceMap.get(prober);
214

215
            Component component = getComponent(probee.toBareJID());
216
            if (component != null) {
217 218 219
                Presence presence = new Presence();
                presence.setFrom(prober);
                presence.setTo(probee);
220
                component.processPacket(presence);
221

222 223
                // No reason to hold onto prober reference.
                presenceMap.remove(prober);
224 225 226
            }
        }
    }
227

228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
    /**
     *  Send a disco#info request to the new component. If the component provides information
     *  then it will be added to the list of discoverable server items.
     *
     * @param component the new component that was added to this manager.
     * @param componentJID the XMPP address of the new component.
     */
    private void checkDiscoSupport(Component component, JID componentJID) {
        // Build a disco#info request that will be sent to the component
        IQ iq = new IQ(IQ.Type.get);
        iq.setFrom(getAddress());
        iq.setTo(componentJID);
        iq.setChildElement("query", "http://jabber.org/protocol/disco#info");
        // Send the disco#info request to the component. The reply (if any) will be processed in
        // #process(Packet)
        sendPacket(component, iq);
    }

    public JID getAddress() {
        return serviceAddress;
    }

    /**
     * Processes packets that were sent to this service. Currently only packets that were sent from
     * registered components are being processed. In the future, we may also process packet of
     * trusted clients. Trusted clients may be able to execute ad-hoc commands such as adding or
     * removing components.
     *
     * @param packet the packet to process.
     */
    public void process(Packet packet) throws UnauthorizedException, PacketException {
        Component component = getComponent(packet.getFrom().getDomain());
        // Only process packets that were sent by registered components
        if (component != null) {
            if (packet instanceof IQ && IQ.Type.result == ((IQ) packet).getType()) {
                IQ iq = (IQ) packet;
                Element childElement = iq.getChildElement();
                String namespace = null;
                if (childElement != null) {
                    namespace = childElement.getNamespaceURI();
                }
                if ("http://jabber.org/protocol/disco#info".equals(namespace)) {
                    // Add a disco item to the server for the component that supports disco
                    XMPPServer.getInstance().getIQDiscoItemsHandler().addComponentItem(packet.getFrom()
                            .toBareJID(),
                            childElement.element("identity").attributeValue("name"));
                }
            }
        }
    }

279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
    /**
     * Exposes a Component as a RoutableChannelHandler.
     */
    public static class RoutableComponent implements RoutableChannelHandler {

        private JID jid;
        private Component component;

        public RoutableComponent(JID jid, Component component) {
            this.jid = jid;
            this.component = component;
        }

        public JID getAddress() {
            return jid;
        }

        public void process(Packet packet) throws UnauthorizedException, PacketException {
            component.processPacket(packet);
        }
    }
300
}