rdvconfigadv.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

        
        String typedoctype = "";
        Attribute itsType = doc.getAttribute("type");
        
        if (null != itsType) {
            typedoctype = itsType.getValue();
        }
        
        if (!doctype.equals(getAdvertisementType()) && !getAdvertisementType().equals(typedoctype)) {
            throw new IllegalArgumentException("Could not construct : " + getClass().getName() + "from doc containing a " + doc.getName());
        }
        
        Enumeration eachAttr = doc.getAttributes();
        
        while (eachAttr.hasMoreElements()) {
            Attribute aRdvAttr = (Attribute) eachAttr.nextElement();
            
            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()).booleanValue();
            } 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 ("type".equals(aRdvAttr.getName())) {
                ;
            } else if ("xmlns:jxta".equals(aRdvAttr.getName())) {
                ;
            } else {
                if (LOG.isEnabledFor(Level.WARN)) {
                    LOG.warn("Unhandled Attribute: " + aRdvAttr.getName());
                }
            }
        }
        
        Enumeration elements = doc.getChildren();
        
        while (elements.hasMoreElements()) {
            XMLElement elem = (XMLElement) elements.nextElement();
            
            if (!handleElement(elem)) {
                if (LOG.isEnabledFor(Level.WARN)) {
                    LOG.warn("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}
     **/
    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 (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()).booleanValue() ) {
                            seedingURIs.add(endpAddr);
                        } else {
                            seedRendezvous.add(endpAddr);
                        }
                    }
                } else {
                    if (LOG.isEnabledFor(Level.WARN)) {
                        LOG.warn("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()).booleanValue();
                } else if (CONNECT_DELAY_ATTR.equals(aSeedAttr.getName())) {
                    seedRendezvousConnectDelay = Long.parseLong(aSeedAttr.getValue().trim());
                } else {
                    if (LOG.isEnabledFor(Level.WARN)) {
                        LOG.warn("Unhandled Attribute: " + aSeedAttr.getName());
                    }
                }
            }
            
            return true;
        }
        
        ///////////// DEPRECATED PARSING //////////
        
        else if( "Addr".equals(elem.getName())) {
            String addrElement = elem.getTextValue();
            
            if( null != addrElement ) {
                URI endpAddr = URI.create(addrElement.trim());
                
                seedRendezvous.add(endpAddr);
            }
            
            return true;
        } else if( "Rdv".equals(elem.getName())) {
            String bool = elem.getTextValue();
            
            if( null != bool ) {
                bool = bool.trim();
                
                configuration = Boolean.valueOf(bool).booleanValue() ? RendezVousConfiguration.RENDEZVOUS : RendezVousConfiguration.EDGE;
            }
            
            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.");
        }
        
        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));
            }
            
            Iterator eachSeed = seedRendezvous.iterator();
            
            while (eachSeed.hasNext()) {
                Element aSeed = adv.createElement(SEED_RDV_ADDR_ELEMENT, eachSeed.next().toString());
                
                seedsElem.appendChild(aSeed);
            }
            
            eachSeed = seedingURIs.iterator();
            
            while (eachSeed.hasNext()) {
                Element aSeed = adv.createElement(SEED_RDV_ADDR_ELEMENT, eachSeed.next().toString());
                
                seedsElem.appendChild(aSeed);
                
                Attributable seedAttr = (Attributable) aSeed;
                
                seedAttr.addAttribute( SEED_RDV_ADDR_SEEDING_ATTR, Boolean.TRUE.toString() );
            }
        }
        
        return adv;
    }