rdvconfigadv.java

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

        }

        Enumeration eachAttr = doc.getAttributes();

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

            if (super.handleAttribute(aRdvAttr)) {// nothing to do
            } else if (RDV_CONFIG_ATTR.equals(aRdvAttr.getName())) {
                String config = aRdvAttr.getValue().trim();

                if ("adhoc".equals(config)) {
                    configuration = RendezVousConfiguration.AD_HOC;
                } else if ("client".equals(config)) {
                    configuration = RendezVousConfiguration.EDGE;
                } else if ("rendezvous".equals(config)) {
                    configuration = RendezVousConfiguration.RENDEZVOUS;
                } else {
                    throw new IllegalArgumentException("Unrecognized Rendezvous configuration :" + config);
                }
            } else if (MAX_TTL_ATTR.equals(aRdvAttr.getName())) {
                maximumTTL = Integer.parseInt(aRdvAttr.getValue().trim());
            } else if (AUTO_RDV_INTERVAL_ATTR.equals(aRdvAttr.getName())) {
                autoRendezvousCheckInterval = Long.parseLong(aRdvAttr.getValue().trim());
            } else if (PROBE_RELAYS_ATTR.equals(aRdvAttr.getName())) {
                probeRelays = Boolean.valueOf(aRdvAttr.getValue().trim());
            } else if (MAX_CLIENTS_ATTR.equals(aRdvAttr.getName())) {
                maxClients = Integer.parseInt(aRdvAttr.getValue().trim());
            } else if (LEASE_DURATION_ATTR.equals(aRdvAttr.getName())) {
                leaseDuration = Long.parseLong(aRdvAttr.getValue().trim());
            } else if (LEASE_MARGIN_ATTR.equals(aRdvAttr.getName())) {
                leaseMargin = Long.parseLong(aRdvAttr.getValue().trim());
            } else if (MIN_HAPPY_PEERVIEW_ATTR.equals(aRdvAttr.getName())) {
                minHappyPeerView = Integer.parseInt(aRdvAttr.getValue().trim());
            } else if (PROPAGATE_RESPOND_ATTR.equals(aRdvAttr.getName())) {// Ignored; deprecated.
            } else if ("Flags".equals(aRdvAttr.getName())) { // deprecated
                boolean onlySeeds = (aRdvAttr.getValue().indexOf("UseOnlySeeds") != -1);

                setUseOnlySeeds(onlySeeds);
            } else {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.warning("Unhandled Attribute: " + aRdvAttr.getName());
                }
            }
        }

        Enumeration elements = doc.getChildren();

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

            if (!handleElement(elem)) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.warning("Unhandled Element: " + elem.toString());
                }
            }
        }

        // Sanity Check!!!

        if ((maximumTTL != -1) && (maximumTTL < 0)) {
            throw new IllegalArgumentException("Maximum TTL must be >= 0");
        }

        if (autoRendezvousCheckInterval < 0) {
            throw new IllegalArgumentException("Auto Rendezvous Check Interval must be >= 0");
        }

        if (seedRendezvousConnectDelay < 0) {
            throw new IllegalArgumentException("Seed Rendezvous Connect Delay must be >= 0");
        }

        if ((-1 != minHappyPeerView) && (minHappyPeerView <= 0)) {
            throw new IllegalArgumentException("Min Happy Peer View must be > 0");
        }

        if ((seedingURIs.isEmpty() && seedRendezvous.isEmpty() && useOnlySeeds) && (configuration == RendezVousConfiguration.EDGE)) {
            throw new IllegalArgumentException("Must specify rendezvous if 'useOnlySeeds' is enabled and configured as client");
        }
    }

    /**
     * {@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 (SEEDS_RDV_ELEMENT.equals(elem.getName())) {

            Enumeration eachSeedElem = elem.getChildren();

            while (eachSeedElem.hasMoreElements()) {
                XMLElement aSeedElem = (XMLElement) eachSeedElem.nextElement();

                if (SEED_RDV_ADDR_ELEMENT.equals(aSeedElem.getName())) {
                    String endpAddrString = aSeedElem.getTextValue();

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

                        Attribute seedingAttr = aSeedElem.getAttribute(SEED_RDV_ADDR_SEEDING_ATTR);

                        if ((null != seedingAttr) && Boolean.valueOf(seedingAttr.getValue().trim())) {
                            seedingURIs.add(endpAddr);
                        } else {
                            seedRendezvous.add(endpAddr);
                        }
                    }
                } else {
                    if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                        LOG.warning("Unhandled Element: " + aSeedElem.getName());
                    }
                }
            }

            Enumeration eachAttr = elem.getAttributes();

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

                if (USE_ONLY_SEEDS_ATTR.equals(aSeedAttr.getName())) {
                    useOnlySeeds = Boolean.valueOf(aSeedAttr.getValue().trim());
                } else if (CONNECT_DELAY_ATTR.equals(aSeedAttr.getName())) {
                    seedRendezvousConnectDelay = Long.parseLong(aSeedAttr.getValue().trim());
                } else {
                    if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                        LOG.warning("Unhandled Attribute: " + aSeedAttr.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.");
        }

        Attributable attrDoc = (Attributable) adv;

        if (RendezVousConfiguration.AD_HOC == configuration) {
            attrDoc.addAttribute(RDV_CONFIG_ATTR, "adhoc");
        } else if (RendezVousConfiguration.EDGE == configuration) {
            attrDoc.addAttribute(RDV_CONFIG_ATTR, "client");
        } else if (RendezVousConfiguration.RENDEZVOUS == configuration) {
            attrDoc.addAttribute(RDV_CONFIG_ATTR, "rendezvous");
        }

        if (maximumTTL != -1) {
            if (maximumTTL < 0) {
                throw new IllegalStateException("Maximum TTL must be >= 0");
            }

            attrDoc.addAttribute(MAX_TTL_ATTR, Integer.toString(maximumTTL));
        }

        if ((seedingURIs.isEmpty() && seedRendezvous.isEmpty() && useOnlySeeds) && (configuration == RendezVousConfiguration.EDGE)) {
            throw new IllegalStateException("Must specify rendezvous if 'useOnlySeeds' is enabled and configured as client");
        }

        if (0 != autoRendezvousCheckInterval) {
            if (autoRendezvousCheckInterval < 0) {
                throw new IllegalStateException("Auto Rendezvous Check Interval must be >= 0");
            }

            attrDoc.addAttribute(AUTO_RDV_INTERVAL_ATTR, Long.toString(autoRendezvousCheckInterval));
        }

        if (!probeRelays) {
            attrDoc.addAttribute(PROBE_RELAYS_ATTR, Boolean.toString(probeRelays));
        }

        if (-1 != maxClients) {
            if (maxClients < 0) {
                throw new IllegalStateException("Max Clients must be >= 0");
            }

            attrDoc.addAttribute(MAX_CLIENTS_ATTR, Integer.toString(maxClients));
        }

        if (0 != leaseDuration) {
            if (leaseDuration < 0) {
                throw new IllegalStateException("Lease Duration must be >= 0");
            }

            attrDoc.addAttribute(LEASE_DURATION_ATTR, Long.toString(leaseDuration));
        }

        if (0 != leaseMargin) {
            if (leaseMargin < 0) {
                throw new IllegalStateException("Lease Margin must be >= 0");
            }

            attrDoc.addAttribute(LEASE_MARGIN_ATTR, Long.toString(leaseMargin));
        }

        if (-1 != minHappyPeerView) {
            if (minHappyPeerView < 0) {
                throw new IllegalStateException("Min Happy Peer View must be > 0");
            }

            attrDoc.addAttribute(MIN_HAPPY_PEERVIEW_ATTR, Integer.toString(minHappyPeerView));
        }

        if (!seedRendezvous.isEmpty() || !seedingURIs.isEmpty()) {
            Element seedsElem = adv.createElement(SEEDS_RDV_ELEMENT);

            adv.appendChild(seedsElem);

            Attributable attrSeeds = (Attributable) seedsElem;

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

            if (0 != seedRendezvousConnectDelay) {
                if (seedRendezvousConnectDelay < 0) {
                    throw new IllegalStateException("Seed Rendezvous Connect Delay must be >= 0");
                }

                attrSeeds.addAttribute(CONNECT_DELAY_ATTR, Long.toString(seedRendezvousConnectDelay));
            }

            for (URI seedRendezvou : seedRendezvous) {
                Element aSeed = adv.createElement(SEED_RDV_ADDR_ELEMENT, seedRendezvou.toString());

                seedsElem.appendChild(aSeed);
            }

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

                seedsElem.appendChild(aSeed);

                Attributable seedAttr = (Attributable) aSeed;

                seedAttr.addAttribute(SEED_RDV_ADDR_SEEDING_ATTR, Boolean.TRUE.toString());
            }
            if (aclURI != null) {
                Element acl = adv.createElement(ACL_URI, aclURI.toString());

                adv.appendChild(acl);
            }
        }

        return adv;
    }

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

    /**
     * True if this peer is to default to act as a rendezvous.
     *
     * @return True if this peer is to be a rendezvous
     */
    public RendezVousConfiguration getConfiguration() {
        return configuration;
    }

    /**
     * Set the default rendezvous state of this peer.
     *
     * @param newstate if true then this peer should default to acting as a