configurator.java

JXTA源文件

    /**
     * Clears and resets the RendezVous addresses.
     *
     * @param      rendezVous               RendezVous addresses 
     * @throws     ConfiguratorException    {@link net.jxta.exception.ConfigurationException}
     *                                      chained list of configuration errors
     */
    
    public void setRendezVous(List rendezVous)
    throws ConfiguratorException {
        this.rdvConfig.clearSeedRendezvous();
        addRendezVous(rendezVous);
    }
    
    /**
     * Add a RendezVous address.
     *
     * @param       rendezVous              RendezVous address
     * @throws      ConfiguratorException   {@link net.jxta.exception.ConfiguratorException}
     *                                      chained list of configuration errors
     */
    
    public void addRendezVous(URI rendezVous)
    throws ConfiguratorException {
        addRendezVous(Collections.singletonList(rendezVous));
    }
    
    /**
     * Adds a {@link java.util.List} of RendezVous addresses.
     *
     * @param       rendezVous              RendezVousService addresses
     * @throws      ConfiguratorException   {@link net.jxta.exception.ConfiguratorException}
     *                                      chained list of configuration errors
     */
    
    public void addRendezVous(List rendezVous)
    throws ConfiguratorException {
        for (Iterator r = rendezVous.iterator(); r.hasNext();) {
            URI u = (URI)r.next();
            
            if (Util.validateAddress(u, false).trim().length() == 0) {
                this.rdvConfig.addSeedRendezvous(u);
            } else {
                throw new ConfiguratorException("invalid address: " + u);
            }
        }
    }
    
    /**
     * Remove a RendezVous address.
     *
     * @param   rendezVous  RendezVousService address
     * @return              removed RendezVous address
     */
    
    public URI removeRendezVous(URI rendezVous) {
        URI u = null;
        
        if (this.rdvConfig != null) {
            this.rdvConfig.removeSeedRendezvous(rendezVous);
            
            u = rendezVous;
        }
        
        return u;
    }
    
    /**
     * Remove all RendezVous addresses.
     */
    
    public void clearRendezVous() {
        if (this.rdvConfig != null) {
            this.rdvConfig.clearSeedRendezvous();
        }
    }
    
    /**
     * Accessor to the RendezVous AutoStart enabler.
     *
     * <p>The AutoStart feature allows the JXTA Peer to opt to variably provision
     * the {@link net.jxta.rendezvous.RendezVousService} in the event no other,
     * or not enough, RendezVous are found within the specified time interval.
     *
     * @deprecated  use {@link net.jxta.ext.config.Configurator#getRendezVousAutoStart()}
     * @return      the RendezVous AutoStart value
     */
    
    public boolean isRendezVousAutoStart() {
        return (this.rdvConfig.getAutoRendezvousCheckInterval() != 0);
    }
    
    /**
     * Accessor to the RendezVous AutoStart value measured in milliseconds.
     *
     * <p>The RendezVous AutoStart feature allows the JXTA instance to opt to
     * variably provision the {@link net.jxta.rendezvous.RendezVousService}
     * in the event no other, or not enough, RendezVous are found within the
     * specified time interval.
     *
     * @return      RendezVous AutoStart value in milliseconds
     */
    
    public long getRendezVousAutoStart() {
        return this.rdvConfig.getAutoRendezvousCheckInterval();
    }
    
    /**
     * Specifies the RendezVous AutoStart value in milliseconds.
     *
     * @param   autoStart   RendezVous AutoStart value
     */
    
    public void setRendezVousAutoStart(long autoStart) {
        this.rdvConfig.setAutoRendezvousCheckInterval(autoStart);
    }
    
    /**
     * Accessor to the Relay Service enabler which indicates as to whether
     * or not the to be configured instance is to provision the Relay Service.
     *
     * @return      Relay enabler
     */
    
    public boolean isRelay() {
        return this.relayConfig.isClientEnabled() ||
	    this.relayConfig.isServerEnabled();
    }
    
    /**
     * Specify the Relay enabler.
     *
     * @param   isEnabled    Relay enabler
     */
    
    public void setRelay(boolean isEnabled) {
//         throw new UnsupportedOperationException("this doesn't work");
    }
    
    /**
     * Accessor to the configured Relay addresses in the form of {@link java.net.URI}.
     *
     * @return      Relays as a {@link java.util.List} of {@link java.net.URI}
     */
    
    public List getRelays() {
        List allSeeds = Arrays.asList( this.relayConfig.getSeedRelays() );
        List result = new ArrayList(allSeeds.size());
        
        for (Iterator si = allSeeds.iterator(); si.hasNext(); ) {
            try {
                result.add(new URI(si.next().toString()));
            } catch(URISyntaxException ignored) {
            }
        }
        
        return result;
    }
    
    /**
     * Clears and resets the Relay address.
     *
     * @param       relay                   Relay address
     * @throws      ConfiguratorException   {@link net.jxta.exception.ConfiguratorException}
     *                                      chained list of configuration errors
     */
    
    public void setRelay(URI relay)
    throws ConfiguratorException {
        this.relayConfig.clearSeedRelays();
        this.relayConfig.addSeedRelay(relay.toString());
    }
    
    /**
     * Clears and resets the Relay addresses.
     *
     * @param      relays                   Relay addresses 
     * @throws     ConfiguratorException    {@link net.jxta.exception.ConfigurationException}
     *                                      chained list of configuration errors
     */
    
    public void setRelays(List relays)
    throws ConfiguratorException {
        this.relayConfig.clearSeedRelays();
        
        addRelays(relays);
    }
    
    /**
     * Add a Relay address.
     *
     * @param       relay                   Relay address
     * @throws      ConfiguratorException   {@link net.jxta.exception.ConfiguratorException}
     *                                      chained list of configuration errors
     */
    
    public void addRelay(URI relay)
    throws ConfiguratorException {
        try {
            this.relayConfig.addSeedRelay(relay.toString());
        } catch (Exception all) {
            throw new ConfiguratorException("Bad relay", all);
        }
    }
    
    /**
     * Adds a {@link java.util.List} of Relay addresses.
     *
     * @param       relays                  Relay addresses
     * @throws      ConfiguratorException   {@link net.jxta.exception.ConfiguratorException}
     *                                      chained list of configuration errors
     */
    
    public void addRelays(List relays)
    throws ConfiguratorException {
        for (Iterator ri = relays.iterator(); ri.hasNext(); ) {
            addRelay((URI)ri.next());
        }
    }
    
    // xxx: ?we can't remove a relay?
    /**
     * Remove a Relay address.
     *
     * @param   relay       Relay address
     * @return              removed Relay address
     */
    
    public URI removeRelay(URI relay) {
        throw new UnsupportedOperationException("this doesn't work");
    }
    
    /**
     * Remove all Relay addresses.
     */
     
    public void clearRelays() {
        if (this.relayConfig != null) {
        this.relayConfig.clearSeedRelays();
    }
    }
    
    /**
     * Accessor to Relay incoming attribute.
     *
     * <p>An incoming attribute indicates the associated service accepts inbound
     * communications.
     *
     * @return      the Relay incoming attribute
     */
    
    public boolean isRelayIncoming() {
        return this.relayConfig.isServerEnabled();
    }
    
    /**
     * Specify the Relay incoming attribute.
     *
     * @param   isEnabled   Relay incoming attribute
     */
    
    public void setRelayIncoming(boolean isEnabled) {
        this.relayConfig.setServerEnabled( isEnabled );
    }
    
    /**
     * Accessor to the Relay incoming maximum connection attribute.
     *
     * <p>A incoming maximum specifies the amount of maximum incoming connections
     * are allowed.
     *
     * @return      the Relay maximum incoming connection attribute
     */
    
    public int getRelayIncomingMaximum() {
        return this.relayConfig.getMaxClients( );
    }
    
    /**
     * Specify the Relay maximum incoming connection attribute.
     *
     * @param   maximumIncoming     Relay maximum incoming attribute
     */
    
    public void setRelayIncomingMaximum(int maximumIncoming) {
        this.relayConfig.setMaxClients( maximumIncoming );
    }
    
    /**
     * Accessor to the Relay incoming lease attribute in milliseconds.
     *
     * <p>A incoming lease specifies the time, in milliseconds, with which Relay
     * leases are held.
     *
     * @return      the Relay incoming lease attribute in milliseconds.
     */
    
    public long getRelayIncomingLease() {
        return this.relayConfig.getServerLeaseDuration();
    }
    
    /**
     * Specify the Relay incoming lease attribute in milliseconds.
     *
     * @param   incomingLease   the Relay incoming lease attribute in milliseconds.
     */
    
    public void setRelayIncomingLease(long incomingLease) {
        this.relayConfig.setServerLeaseDuration( incomingLease );
    }
    
    /**
     * Accessor to the Relay outgoing attribute.
     *
     * <p>An outgoing attribute indicates the associated service initiates outbound
     * communications.
     *
     * @return      Relay outgoing attribute
     */
    
    public boolean isRelayOutgoing() {
        return this.relayConfig.isClientEnabled();
    }
    
    /**
     * Specify the Relay outgoing attribute.
     *
     * @param   isEnabled   Relay outgoing attribute
     */
    
    public void setRelayOutgoing(boolean isEnabled) {
        this.relayConfig.setClientEnabled( isEnabled );
    }
    
    /**
     * Accessor to the Relay outgoing maximum connection attribute.
     *
     * <p>A outgoing maximum specifies the amount of maximum outgoing connections
     * are allowed.
     *
     * @return      the Relay maximum outgoing connection attribute
     */
    
    public int getRelayOutgoingMaximum() {
        return this.relayConfig.getMaxRelays();
    }
    
    /**
     * Specify the Relay maximum outgoing connection attribute.
     *
     * @param   maximumOutgoing     Relay maximum outgoing attribute
     */
    
    public void setRelayOutgoingMaximum(int maximumOutgoing) {
        this.relayConfig.setMaxRelays( maximumOutgoing );
    }
    
    /**
     * Accessor to the Relay outgoing lease attribute in milliseconds.
     *
     * <p>A outgoing lease specifies the time, in milliseconds, with which Relay
     * leases are held.
     *
     * @return      the Relay outgoing lease attribute in milliseconds.
     */
    
    public long getRelayOutgoingLease() {
        return this.relayConfig.getClientLeaseDuration();
    }
    
    /**
     * Specify the Relay outgoing lease attribute in milliseconds.
     *
     * @param   outgoingLease   the Relay outgoing lease attribute in milliseconds.
     */
    
    public void setRelayOutgoingLease(long outgoingLease) {
        this.relayConfig.setClientLeaseDuration( outgoingLease );
    }
    
    /**
     * Accessor to the Relay queue size.
     *
     * <p>A queue size specifies the overall message buffer size when exceeded
     * messages are dropped.
     *
     * @return      Relay queue size
     */
    
    public int getRelayQueueSize() {
        return this.relayConfig.getClientMessageQueueSize();
    } 
    
    /**
     * Specify the Relay queue size.
     *
     * @param   queueSize   the Relay queue size
     */
    
    public void setRelayQueueSize(int queueSize) {
        this.relayConfig.setClientMessageQueueSize( queueSize );
    }
    
    /**
     * Accessor to the {@link net.jxta.ext.config.Transport}.
     *