relaytransport.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.warning("Stalled until there is an endpoint service");
            }

            return START_AGAIN_STALLED;
        }

        // XXX bondolo 20041025 Server depends upon discovery and its non-optional.
        DiscoveryService discovery = group.getDiscoveryService();

        if (null == discovery) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.warning("Stalled until there is a discovery service");
            }

            return START_AGAIN_STALLED;
        }

        // XXX bondolo 20041025 Server depends upon pipes and its non-optional.
        PipeService pipeService = group.getPipeService();

        if (null == pipeService) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.warning("Stalled until there is a pipe service");
            }

            return START_AGAIN_STALLED;
        }

        endpoint.addIncomingMessageListener(this, serviceName, null);

        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
            LOG.fine("Message Listener added " + serviceName);
        }

        if (relayServer != null) {
            if (!relayServer.startServer()) {
                return -1; // cannot start
            }
        }

        if (relayClient != null) {
            if (!relayClient.startClient()) {
                return -1; // cannot start
            }
        }

        if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
            LOG.info("Relay Message Transport started");
        }

        return 0;
    }

    /**
     * {@inheritDoc}
     */
    public void stopApp() {
        // remove listener
        EndpointService endpoint = group.getEndpointService();

        if (endpoint == null) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.warning("could not get EndpointService");
            }
        } else {
            endpoint.removeIncomingMessageListener(serviceName, null);

            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("Message Listener removed " + serviceName);
            }
        }

        if (relayServer != null) {
            relayServer.stopServer();
        }

        if (relayClient != null) {
            relayClient.stopClient();
        }

        if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
            LOG.info("Relay Message Transport stopped");
        }
    }

    /**
     * {@inheritDoc}
     */
    public void processIncomingMessage(Message message, EndpointAddress srcAddr, EndpointAddress dstAddr) {
        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
            LOG.fine("Started for " + message + "\tsrc=" + srcAddr);
        }

        MessageElement element;

        // check if it is a request
        element = message.getMessageElement(RelayTransport.RELAY_NS, REQUEST_ELEMENT);

        if (element != null) {
            // this is a request, pass it to the relayServer
            if (relayServer != null) {
                relayServer.handleRequest(message, dstAddr);
            }
        } else {
            // check if it is a response
            element = message.getMessageElement(RelayTransport.RELAY_NS, RESPONSE_ELEMENT);

            if (element != null) {
                // this is a response, pass it to the relayClient
                if (relayClient != null) {
                    relayClient.handleResponse(message, dstAddr);
                }
            }
        }
    }

    protected PeerGroup getGroup() {
        return group;
    }

    protected String getServiceName() {
        return serviceName;
    }

    // This is for reference only, the Desktop client implementation does not
    // use that server feature
    static Message createPIDRequestMessage() {
        Message message = new Message();
        message.addMessageElement(RELAY_NS, PID_REQUEST_ELEMENT);
        return message;
    }

    static Message createPIDResponseMessage(String pidStr) {
        Message message = new Message();
        message.addMessageElement(RELAY_NS, PID_RESPONSE_ELEMENT);
        setString(message, PEERID_ELEMENT, pidStr);

        return message;
    }

    static Message createConnectMessage(long lease, boolean doReturnAdv, boolean doFlushQueue) {
        Message message = new Message();
        String request = createConnectString(lease, doReturnAdv, doFlushQueue);
        setString(message, REQUEST_ELEMENT, request);
        return message;
    }

    static String createConnectString(long lease, boolean doReturnAdv, boolean doFlushQueue) {

        String request = CONNECT_REQUEST;

        if (lease > 0) {
            request += "," + Long.toString(lease);
        } else {
            request += ",";
        }

        if (doFlushQueue) {
            request += ",flush";
        } else {
            request += ",keep";
        }

        if (doReturnAdv) {
            request += ",true";
        } else {
            request += ",other";
        }

        return request;
    }

    static Message createConnectedMessage(long lease) {
        Message message = new Message();

        message.addMessageElement(RELAY_NS, CONNECTED_RESPONSE_ELEMENT);

        if (lease > 0) {
            setString(message, LEASE_ELEMENT, Long.toString(lease));
        }

        return message;
    }

    static Message createDisconnectMessage() {
        Message message = new Message();
        message.addMessageElement(RELAY_NS, DISCONNECT_REQUEST_ELEMENT);
        return message;
    }

    static Message createDisconnectedMessage() {
        Message message = new Message();
        message.addMessageElement(RELAY_NS, DISCONNECTED_RESPONSE_ELEMENT);
        return message;
    }

    /**
     * Convinence function for setting a string element with the relay namespace
     *
     * @param message the message
     * @param elementName message element name
     * @param value the value of the string
     */
    static void setString(Message message, String elementName, String value) {
        // create a new String Element with the given value
        StringMessageElement sme = new StringMessageElement(elementName, value, null);

        // add the new element to the message
        message.addMessageElement(RELAY_NS, sme);
    }

    /**
     * Convinence function for getting a String from the element with the given
     * tag and relay namespace
     *
     * @param message the message
     * @param elementName the value of the string
     * @return the string value, null if the element does not exist
     */
    static String getString(Message message, String elementName) {
        // get the requested element
        MessageElement element = message.getMessageElement(RelayTransport.RELAY_NS, elementName);

        // if the element is not present, return null
        if (element == null) {
            return null;
        }
        return element.toString();
    }
}