relayconfigadv.java

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

        if ((-1 != stallTimeout) && (stallTimeout <= 0)) {
            throw new IllegalArgumentException("Client stall timeout duration must not be negative or zero.");
        }

        if ((-1 != announceInterval) && (announceInterval <= 0)) {
            throw new IllegalArgumentException("Announce interval must not be negative or zero.");
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public RelayConfigAdv clone() {

        RelayConfigAdv result;
        
        try {
            result = (RelayConfigAdv) super.clone();
        } catch (CloneNotSupportedException impossible) {
            throw new Error("Object.clone() threw CloneNotSupportedException", impossible);
        }  

        result.setAnnounceInterval(getAnnounceInterval());
        result.setClientEnabled(isClientEnabled());
        result.setClientLeaseDuration(getClientLeaseDuration());
        result.setClientMessageQueueSize(getClientMessageQueueSize());
        result.setMaxClients(getMaxClients());
        result.setMaxRelays(getMaxRelays());
        result.setMessengerPollInterval(getMessengerPollInterval());
        result.setServerEnabled(isServerEnabled());
        result.setServerLeaseDuration(getServerLeaseDuration());
        result.setStallTimeout(getStallTimeout());
        result.setUseOnlySeeds(getUseOnlySeeds());
        
        return result;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getAdvType() {
        return getAdvertisementType();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public final String getBaseAdvType() {
        return getAdvertisementType();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public ID getID() {
        return ID.nullID;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected boolean handleElement(Element raw) {

        if (super.handleElement(raw)) {
            return true;
        }

        XMLElement elem = (XMLElement) raw;

        if (RELAY_CLIENT_ELEMENT.equals(elem.getName())) {
            Enumeration eachAttr = elem.getAttributes();

            while (eachAttr.hasMoreElements()) {
                Attribute aRelayAttr = (Attribute) eachAttr.nextElement();

                if (RELAY_CLIENT_SERVERS_ATTR.equals(aRelayAttr.getName())) {
                    maxRelays = Integer.parseInt(aRelayAttr.getValue().trim());
                } else if (RELAY_CLIENT_LEASE_ATTR.equals(aRelayAttr.getName())) {
                    maxClientLeaseDuration = Long.parseLong(aRelayAttr.getValue().trim());
                } else if (RELAY_CLIENT_POLL_ATTR.equals(aRelayAttr.getName())) {
                    messengerPollInterval = Long.parseLong(aRelayAttr.getValue().trim());
                } else {
                    if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                        LOG.warning("Unhandled Attribute: " + aRelayAttr.getName());
                    }
                }
            }

            Enumeration elements = elem.getChildren();

            while (elements.hasMoreElements()) {
                XMLElement seedsElem = (XMLElement) elements.nextElement();

                if (RELAY_CLIENT_SEEDS_ELEMENT.equals(seedsElem.getName())) {
                    Enumeration eachSeedsAttr = seedsElem.getAttributes();

                    while (eachSeedsAttr.hasMoreElements()) {
                        Attribute aRelayAttr = (Attribute) eachSeedsAttr.nextElement();

                        if (USE_ONLY_SEEDS_ATTR.equals(aRelayAttr.getName())) {
                            useOnlySeeds = Boolean.valueOf(aRelayAttr.getValue().trim());
                        } else {
                            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                                LOG.warning("Unhandled Attribute: " + aRelayAttr.getName());
                            }
                        }
                    }

                    Enumeration addrElements = seedsElem.getChildren();

                    while (addrElements.hasMoreElements()) {
                        XMLElement addrElem = (XMLElement) addrElements.nextElement();

                        if (SEED_RELAY_ADDR_ELEMENT.equals(addrElem.getName())) {
                            String endpAddrString = addrElem.getTextValue();

                            if (null != endpAddrString) {
                                URI endpURI = URI.create(endpAddrString.trim());

                                Attribute seedingAttr = addrElem.getAttribute(SEED_RELAY_ADDR_SEEDING_ATTR);

                                if ((null != seedingAttr) && Boolean.valueOf(seedingAttr.getValue().trim())) {
                                    seedingURIs.add(endpURI);
                                } else {
                                    seedRelays.add(new EndpointAddress(endpURI));
                                }
                            }
                        } else {
                            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                                LOG.warning("Unhandled Element: " + elem.toString());
                            }
                        }
                    }
                } else {
                    if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                        LOG.warning("Unhandled Element: " + elem.toString());
                    }
                }
            }

            return true;
        } else if (RELAY_SERVER_ELEMENT.equals(elem.getName())) {
            Enumeration eachAttr = elem.getAttributes();

            while (eachAttr.hasMoreElements()) {
                Attribute aRelayAttr = (Attribute) eachAttr.nextElement();

                if (RELAY_SERVER_CLIENTS_ATTR.equals(aRelayAttr.getName())) {
                    maxClients = Integer.parseInt(aRelayAttr.getValue().trim());
                } else if (RELAY_SERVER_QUEUE_ATTR.equals(aRelayAttr.getName())) {
                    maxClientMessageQueue = Integer.parseInt(aRelayAttr.getValue().trim());
                } else if (RELAY_SERVER_LEASE_ATTR.equals(aRelayAttr.getName())) {
                    maxServerLeaseDuration = Long.parseLong(aRelayAttr.getValue().trim());
                } else if (RELAY_SERVER_STALL_ATTR.equals(aRelayAttr.getName())) {
                    stallTimeout = Long.parseLong(aRelayAttr.getValue().trim());
                } else if (RELAY_SERVER_ANNOUNCE_ATTR.equals(aRelayAttr.getName())) {
                    announceInterval = Long.parseLong(aRelayAttr.getValue().trim());
                } else {
                    if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                        LOG.warning("Unhandled Attribute: " + aRelayAttr.getName());
                    }
                }
            }

            return true;
        } else if (ACL_URI.equals(elem.getName())) {
            String addrElement = elem.getTextValue();

            if (null != addrElement) {
                aclURI = URI.create(addrElement.trim());
            }

            return true;
        }

        return false;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Document getDocument(MimeMediaType encodeAs) {
        StructuredDocument adv = (StructuredDocument) super.getDocument(encodeAs);

        if (!(adv instanceof Attributable)) {
            throw new IllegalStateException("Only Attributable documents are supported.");
        }

        if ((-1 != maxRelays) && (maxRelays <= 0)) {
            throw new IllegalStateException("Max relays must not be negative or zero.");
        }

        if ((-1 != maxClientLeaseDuration) && (maxClientLeaseDuration <= 0)) {
            throw new IllegalStateException("Max lease duration must not be negative or zero.");
        }

        if ((-1 != messengerPollInterval) && (messengerPollInterval <= 0)) {
            throw new IllegalStateException("Messenger poll interval must not be negative or zero.");
        }

        if (useOnlySeeds && clientEnabled && seedRelays.isEmpty() && seedingURIs.isEmpty()) {
            throw new IllegalStateException("Cannot specify 'useOnlySeeds' and no seed relays");
        }

        if ((-1 != maxClients) && (maxClients <= 0)) {
            throw new IllegalStateException("Max clients must not be negative or zero.");
        }

        if ((-1 != maxClientMessageQueue) && (maxClientMessageQueue <= 0)) {
            throw new IllegalStateException("Max client queue must not be negative or zero.");
        }

        if ((-1 != maxServerLeaseDuration) && (maxServerLeaseDuration <= 0)) {
            throw new IllegalStateException("Max lease duration must not be negative or zero.");
        }

        if ((-1 != stallTimeout) && (stallTimeout <= 0)) {
            throw new IllegalStateException("Client stall timeout duration must not be negative or zero.");
        }

        if ((-1 != announceInterval) && (announceInterval <= 0)) {
            throw new IllegalStateException("Announce interval must not be negative or zero.");
        }

        Attributable attrDoc = (Attributable) adv;

        if (clientEnabled) {
            attrDoc.addAttribute(RELAY_CLIENT_ATTR, Boolean.TRUE.toString());
        }

        if (serverEnabled) {
            attrDoc.addAttribute(RELAY_SERVER_ATTR, Boolean.TRUE.toString());
        }

        Element clientElem = adv.createElement(RELAY_CLIENT_ELEMENT);

        adv.appendChild(clientElem);

        Attributable attrElem = (Attributable) clientElem;

        if (-1 != maxRelays) {
            attrElem.addAttribute(RELAY_CLIENT_SERVERS_ATTR, Integer.toString(maxRelays));
        }

        if (-1 != maxClientLeaseDuration) {
            attrElem.addAttribute(RELAY_CLIENT_LEASE_ATTR, Long.toString(maxClientLeaseDuration));
        }

        if (-1 != messengerPollInterval) {
            attrElem.addAttribute(RELAY_CLIENT_POLL_ATTR, Long.toString(messengerPollInterval));
        }

        if (!seedRelays.isEmpty() || !seedingURIs.isEmpty()) {
            Element seedsElem = adv.createElement(RELAY_CLIENT_SEEDS_ELEMENT);

            clientElem.appendChild(seedsElem);

            attrElem = (Attributable) seedsElem;

            if (useOnlySeeds) {
                attrElem.addAttribute(USE_ONLY_SEEDS_ATTR, Boolean.TRUE.toString());
            }

            for (EndpointAddress seedRelay : seedRelays) {
                Element addrElement = adv.createElement(SEED_RELAY_ADDR_ELEMENT, seedRelay.toString());

                seedsElem.appendChild(addrElement);
            }

            for (URI seedingURI : seedingURIs) {
                Element addrElement = adv.createElement(SEED_RELAY_ADDR_ELEMENT, seedingURI.toString());

                seedsElem.appendChild(addrElement);

                ((Attributable) addrElement).addAttribute(SEED_RELAY_ADDR_SEEDING_ATTR, Boolean.TRUE.toString());
            }
        }

        Element serverElem = adv.createElement(RELAY_SERVER_ELEMENT);

        adv.appendChild(serverElem);

        attrElem = (Attributable) serverElem;

        if (-1 != maxClients) {
            attrElem.addAttribute(RELAY_SERVER_CLIENTS_ATTR, Integer.toString(maxClients));
        }

        if (-1 != maxClientMessageQueue) {
            attrElem.addAttribute(RELAY_SERVER_QUEUE_ATTR, Integer.toString(maxClientMessageQueue));
        }

        if (-1 != maxServerLeaseDuration) {
            attrElem.addAttribute(RELAY_SERVER_LEASE_ATTR, Long.toString(maxServerLeaseDuration));
        }

        if (-1 != stallTimeout) {
            attrElem.addAttribute(RELAY_SERVER_STALL_ATTR, Long.toString(stallTimeout));
        }

        if (-1 != announceInterval) {
            attrElem.addAttribute(RELAY_SERVER_ANNOUNCE_ATTR, Long.toString(announceInterval));
        }
        if (aclURI != null) {
            Element acl = adv.createElement(ACL_URI, aclURI.toString());

            adv.appendChild(acl);
        }
        return adv;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String[] getIndexFields() {
        return fields;
    }

    /**
     * If true then this peer will act as a relay client.
     *
     * @return If true then this peer will act as a relay client.
     */
    public boolean isClientEnabled() {
        return clientEnabled;