relayconfigadv.java

jxta平台的开发包

        }

        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}
     */
    public String getAdvType() {
        return getAdvertisementType();
    }

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

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

    /**
     *  {@inheritDoc}
     */
    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 (LOG.isEnabledFor(Level.WARN)) {
                        LOG.warn("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()).booleanValue();
                        } else {
                            if (LOG.isEnabledFor(Level.WARN)) {
                                LOG.warn("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()).booleanValue()) {
                                    seedingURIs.add(endpURI);
                                } else {
                                    seedRelays.add(new EndpointAddress(endpURI));
                                }
                            }
                        } else {
                            if (LOG.isEnabledFor(Level.WARN)) {
                                LOG.warn("Unhandled Element: " + elem.toString());
                            }
                        }
                    }
                } else {
                    if (LOG.isEnabledFor(Level.WARN)) {
                        LOG.warn("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 (LOG.isEnabledFor(Level.WARN)) {
                        LOG.warn("Unhandled Attribute: " + aRelayAttr.getName());
                    }
                }
            }

            return true;
        }

        // ////////////// DEPRECATED PARSING ////////////////

        String value = elem.getTextValue();

        if((null == value) || (0 == value.trim().length())) {
            return false;
        }

        value = value.trim();

        if ("isServer".equals(elem.getName())) {
            serverEnabled = Boolean.valueOf(value).booleanValue();

            return true;
        } else if ("isClient".equals(elem.getName())) {
            clientEnabled = Boolean.valueOf(value).booleanValue();

            return true;
        } else if ("ServerMaximumClients".equals(elem.getName())) {
            maxClients = Integer.parseInt(value);

            return true;
        } else if ("ClientMaximumServers".equals(elem.getName())) {
            maxRelays = Integer.parseInt(value);

            return true;
        } else if ("ServerLeaseInSeconds".equals(elem.getName())) {
            maxServerLeaseDuration = Long.parseLong(value) * TimeUtils.ASECOND;

            return true;
        } else if ("ClientLeaseInSeconds".equals(elem.getName())) {
            maxClientLeaseDuration = Long.parseLong(value) * TimeUtils.ASECOND;

            return true;
        } else if ("StallTimeoutInSeconds".equals(elem.getName())) {
            stallTimeout = Long.parseLong(value) * TimeUtils.ASECOND;

            return true;
        } else if ("ClientQueueSize".equals(elem.getName())) {
            maxClientMessageQueue = Integer.parseInt(value);

            return true;
        } else if ("BroadcastIntervalInSeconds".equals(elem.getName())) {
            announceInterval = Long.parseLong(value) * TimeUtils.ASECOND;

            return true;
        } else if ("PollIntervalInSeconds".equals(elem.getName())) {
            messengerPollInterval = Long.parseLong(value) * TimeUtils.ASECOND;

            return true;
        } else if ("tcpaddr".equals(elem.getName())) {
            seedRelays.add(new EndpointAddress("tcp", value, null, null));

            return true;
        } else if ("httpaddr".equals(elem.getName())) {
            seedRelays.add(new EndpointAddress("http", value, null, null));

            return true;
        }

        return false;
    }

    /**
     *  {@inheritDoc}
     */
    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());
            }

            Iterator eachSeed = seedRelays.iterator();

            while (eachSeed.hasNext()) {
                Element addrElement = adv.createElement(SEED_RELAY_ADDR_ELEMENT, eachSeed.next().toString());

                seedsElem.appendChild(addrElement);
            }

            eachSeed = seedingURIs.iterator();

            while (eachSeed.hasNext()) {
                Element addrElement = adv.createElement(SEED_RELAY_ADDR_ELEMENT, eachSeed.next().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));
        }