org.coos.messaging.routing.RouterChannel Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of messaging-lib
The newest version!
/**
 * COOS - Connected Objects Operating System (www.connectedobjects.org).
 *
 * Copyright (C) 2009 Telenor ASA and Tellu AS. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see .
 *
 * You may also contact one of the following for additional information:
 * Telenor ASA, Snaroyveien 30, N-1331 Fornebu, Norway (www.telenor.no)
 * Tellu AS, Hagalokkveien 13, N-1383 Asker, Norway (www.tellu.no)
 */
package org.coos.messaging.routing;

import org.coos.messaging.Connectable;
import org.coos.messaging.ConnectingException;
import org.coos.messaging.Message;
import org.coos.messaging.impl.DefaultChannel;
import org.coos.messaging.impl.DefaultMessage;
import org.coos.messaging.impl.DefaultProcessor;
import org.coos.messaging.util.Log;
import org.coos.messaging.util.LogFactory;


/**
 * @author Knut Eilif Husa, Tellu AS
 *
 * Router Channel class. Contains one inlink
 * and one outlink and a transport This Channel type connects COOS
 * instances
 */
public class RouterChannel extends DefaultChannel {

    private final Log logger = LogFactory.getLog(this.getClass(), true);
    private String routingAlgorithm;

    @SuppressWarnings("unchecked")
    public RouterChannel() {
        protocols.addElement("coos");
    }

    public String getRoutingAlgorithm() {
        return routingAlgorithm;
    }

    public void setRoutingAlgorithmName(String routingAlgorithm) {
        this.routingAlgorithm = routingAlgorithm;
    }

    public String getConnectingPartyUuid() {
        return connectingPartyUuid;
    }

    public void setConnectingPartyUuid(String connectingPartyUuid) {
        this.connectingPartyUuid = connectingPartyUuid;
    }

    /**
     * Method that connects the channel if the Channel is init property set to
     * true
     */
    public void connect(Connectable linkManager) throws ConnectingException {
        this.connectable = linkManager;

        final Connectable linkManager1 = linkManager;

        if (!isInit()) {
            return;
        }

        try {

            transport.setChainedProcessor(new DefaultProcessor() {
                    public void processMessage(Message msg) {

                        if (msg.getHeader(Message.MESSAGE_NAME).equals(CONNECT_ACK)) {
                            String conUuid = msg.getHeader(CONNECT_UUID);

                            if (conUuid != null) {
                                outLink.setDestinationUuid(conUuid);
                                outLink.setChainedProcessor(transport);

                                inLink.setChainedProcessor(linkManager1.getDefaultProcessor());
                                inLink.setDestinationUuid(connectingPartyUuid);
                                transport.setChainedProcessor(inLink);
                                connected = true;

                                try {
                                    linkManager1.addLink(conUuid, outLink);
                                } catch (Exception e) {
                                    disconnect();
                                    logger.warn("Connection failed.", e);
                                }

                            } else {
                                logger.warn("Can not process msg: " + msg);
                                disconnect();
                            }
                        } else {
                            logger.warn("Connection failed: " + msg);
                            disconnect();
                        }
                    }
                });

            Message msg = new DefaultMessage(CONNECT);
            msg.setHeader(CONNECT_UUID, connectingPartyUuid);
            msg.setHeader(ROUTING_ALGORITHM, routingAlgorithm);
            transport.start();
            outLink.start();
            inLink.start();
            transport.processMessage(msg);

        } catch (Exception e) {
            logger.error("Exception ignored.", e);
        }
    }

    /**
     * Method that disconnects the Channel
     */
    public void disconnect() {

        // todo disconnect protocol is missing towards the peer. Will only
        // disconnect on this channel side
        connected = false;

        try {

            if (connectable != null) {
                connectable.removeLinkById(outLink.getLinkId());
            }

            outLink.stop();
            inLink.stop();

            if (transport != null) {
                transport.stop();
            }
        } catch (Exception e) {
            logger.error("Exception ignored.", e);
        }
    }

    /**
     * Makes a copy of the channel. Based on the shared property of the
     * processors the Channel will be populated with unique or shared instances
     *
     * @return - the copied channel
     */
    public DefaultChannel copy() {
        RouterChannel ch = (RouterChannel) super.copy();
        ch.setConnectingPartyUuid(connectingPartyUuid);

        return ch;
    }


}