configdialog.java

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

    /**
     * Manages relay service parameters
     */
    final static class RelayPanel extends BorderPanelGBL implements ItemListener {

        private final Checkbox useRelay;
        private final Checkbox useOnlySeeds;
        private final HostListPanel seeding;
        private final HostListPanel seeds;

        public RelayPanel(boolean useARelay, boolean onlySeeds) {

            super("Relay Settings");

            useRelay = new Checkbox("Use a relay", null, useARelay);
            useOnlySeeds = new Checkbox("Use only configured seeds", null, onlySeeds);
            useOnlySeeds.setEnabled(useARelay);
            seeds = new HostListPanel("Seeds", "Relay seed peers", useARelay, false);
            seeding = new HostListPanel("Seeding", "Relay seeding URIs", useARelay, false);

            GridBagConstraints c1 = new GridBagConstraints();

            c1.gridx = 0;
            c1.gridy = 0;
            c1.anchor = GridBagConstraints.LINE_START;
            add(useRelay, c1);
            useRelay.addItemListener(this);

            c1.gridx++;
            c1.anchor = GridBagConstraints.LINE_END;
            add(useOnlySeeds, c1);

            c1.gridx = 0;
            c1.gridy++;
            c1.gridwidth = 2;
            c1.weightx = 1.0;
            c1.fill = GridBagConstraints.HORIZONTAL;
            c1.anchor = GridBagConstraints.LINE_START;
            add(seeding, c1);

            c1.gridy++;
            add(seeds, c1);
        }

        /**
         * {@inheritDoc}
         */
        public void itemStateChanged(ItemEvent e) {
            seeds.setEnabled(useRelay.getState());
            seeding.setEnabled(useRelay.getState());
            useOnlySeeds.setEnabled(useRelay.getState());
        }
    }

    private final PlatformConfig configAdv;

    private final Label helpLabel;
    private final IdPanel idPanel;
    private final EnablingPanel enablingPanel;
    private final IPTptPanel tcpPanel;
    private final IPTptPanel httpPanel;
    private final RdvPanel rdvPanel;
    private final RelayPanel relayPanel;

    private final Button ok;
    private final Button cancel;
    private final PagesPanel pages = new PagesPanel();

    boolean done = false;
    boolean canceled = false;

    String tcpMulticastAddr;
    int tcpMulticastPort;
    int tcpMulticastLength;

    public ConfigDialog(PlatformConfig configAdv) throws ConfiguratorException {
        super("JXTA Configurator");

        this.configAdv = configAdv;

        // Identity settings
        String peerName = configAdv.getName();

        if ((null == peerName) || (0 == peerName.trim().length())) {
            peerName = "";
        }

        // Security settings
        boolean needSecurityConfig = true;

        // If security is already in place, then the security info is not shown.
        XMLElement param = (XMLElement) configAdv.getServiceParam(PeerGroup.membershipClassID);

        if (param != null) {
            Advertisement adv = null;

            try {
                adv = AdvertisementFactory.newAdvertisement(param);
            } catch (NoSuchElementException notAnAdv) {
                ; // that's ok.
            } catch (IllegalArgumentException badAdv) {
                ; // that's ok.
            }

            if (adv instanceof PSEConfigAdv) {
                PSEConfigAdv pseConfig = (PSEConfigAdv) adv;

                // no certificate? That means we need to make one.
                needSecurityConfig = (null == pseConfig.getCertificate());
            }
        }

        // JXME Proxy Settings
        boolean isJxmeProxy = false;

        try {
            param = (XMLElement) configAdv.getServiceParam(PeerGroup.proxyClassID);

            if (param != null && configAdv.isSvcEnabled(PeerGroup.proxyClassID)) {
                isJxmeProxy = true;
            }
        } catch (Exception nobigdeal) {
            nobigdeal.printStackTrace();
        }

        int index;

        // TCP Settings
        boolean tcpEnabled;
        boolean clientDefaultT;
        boolean serverDefaultT;
        String defaultInterfaceAddressT;
        String defaultPortT;
        String defaultServerNameT;
        String defaultServerPortT;
        boolean multicastEnabledT;
        boolean noPublicAddressesT;

        try {
            param = (XMLElement) configAdv.getServiceParam(PeerGroup.tcpProtoClassID);

            tcpEnabled = configAdv.isSvcEnabled(PeerGroup.tcpProtoClassID);

            Enumeration<XMLElement> tcpChilds = param.getChildren(TransportAdvertisement.getAdvertisementType());

            // get the TransportAdv from either TransportAdv or tcpAdv
            if (tcpChilds.hasMoreElements()) {
                param = tcpChilds.nextElement();
            } else {
                throw new IllegalStateException("Missing TCP Advertisment");
            }

            TCPAdv tcpAdv = (TCPAdv) AdvertisementFactory.newAdvertisement(param);

            clientDefaultT = tcpAdv.isClientEnabled();
            serverDefaultT = tcpAdv.isServerEnabled();

            defaultInterfaceAddressT = tcpAdv.getInterfaceAddress();

            if ((null == defaultInterfaceAddressT) || (0 == defaultInterfaceAddressT.trim().length())) {
                defaultInterfaceAddressT = null;
            }

            defaultPortT = Integer.toString(tcpAdv.getPort());
            if ((defaultPortT == null) || (0 == defaultPortT.trim().length())) {
                defaultPortT = "9701";
            }

            defaultServerNameT = tcpAdv.getServer();

            if ((null == defaultServerNameT) || (0 == defaultServerNameT.trim().length())) {
                defaultServerNameT = "";
            }

            if (defaultServerNameT != null && (index = defaultServerNameT.lastIndexOf(":")) != -1) {
                if ((0 == index) || (index == defaultServerNameT.length())) {
                    throw new IllegalArgumentException("Bad TCP server name . Cannot proceed.");
                }
                defaultServerPortT = defaultServerNameT.substring(index + 1);
                defaultServerNameT = defaultServerNameT.substring(0, index);
            } else {
                defaultServerNameT = "";
                defaultServerPortT = "9701";
            }

            noPublicAddressesT = tcpAdv.getPublicAddressOnly();
            multicastEnabledT = tcpAdv.getMulticastState();

            // we will just pass these to save.
            tcpMulticastAddr = tcpAdv.getMulticastAddr();
            tcpMulticastPort = tcpAdv.getMulticastPort();
            tcpMulticastLength = tcpAdv.getMulticastSize();
        } catch (Exception failure) {
            throw new ConfiguratorException("Broken Platform Config. Cannot proceed.", failure);
        }

        // HTTP Settings
        boolean httpEnabled;
        boolean clientDefaultH;
        boolean serverDefaultH;
        String defaultInterfaceAddressH;
        String defaultPortH;
        String defaultServerNameH;
        String defaultServerPortH;
        boolean noPublicAddressesH;

        try {
            param = (XMLElement) configAdv.getServiceParam(PeerGroup.httpProtoClassID);

            httpEnabled = configAdv.isSvcEnabled(PeerGroup.httpProtoClassID);

            Enumeration<XMLElement> httpChilds = param.getChildren(TransportAdvertisement.getAdvertisementType());

            // get the TransportAdv from either TransportAdv
            if (httpChilds.hasMoreElements()) {
                param = httpChilds.nextElement();
            } else {
                throw new IllegalStateException("Missing HTTP Advertisment");
            }

            // Read-in the adv as it is now.
            HTTPAdv httpAdv = (HTTPAdv) AdvertisementFactory.newAdvertisement(param);

            clientDefaultH = httpAdv.isClientEnabled();
            serverDefaultH = httpAdv.isServerEnabled();

            defaultInterfaceAddressH = httpAdv.getInterfaceAddress();

            if ((null == defaultInterfaceAddressH) || (0 == defaultInterfaceAddressH.trim().length())) {
                defaultInterfaceAddressH = null;
            }

            defaultPortH = Integer.toString(httpAdv.getPort());

            if ((defaultPortH == null) || (0 == defaultPortH.trim().length())) {
                defaultPortH = "9700";
            }

            defaultServerNameH = httpAdv.getServer();

            if ((null != defaultServerNameH) && (0 == defaultServerNameH.trim().length())) {
                defaultServerNameH = "";
            }

            defaultServerPortH = "9700";

            if (defaultServerNameH != null && (index = defaultServerNameH.lastIndexOf(":")) != -1) {
                if ((0 == index) || (index == defaultServerNameH.length())) {
                    throw new IllegalArgumentException("Bad HTTP server name. Cannot proceed.");
                }
                defaultServerPortH = defaultServerNameH.substring(index + 1);
                defaultServerNameH = defaultServerNameH.substring(0, index);
            } else {
                defaultServerNameH = "";
                defaultServerPortH = "9700";
            }

            noPublicAddressesH = httpAdv.getPublicAddressOnly();
        } catch (Exception failure) {
            throw new ConfiguratorException("Broken Platform Config. Cannot proceed.", failure);
        }

        // Rendezvous Settings
        boolean isRendezvous;
        boolean isAdhoc;
        boolean onlySeeds;
        List<String> seedRdvs = new ArrayList<String>();
        List<String> seedingRdvs = new ArrayList<String>();

        try {
            RdvConfigAdv rdvConfigAdv;

            param = (XMLElement) configAdv.getServiceParam(PeerGroup.rendezvousClassID);

            rdvConfigAdv = (RdvConfigAdv) AdvertisementFactory.newAdvertisement(param);

            isRendezvous = (RendezVousConfiguration.RENDEZVOUS == rdvConfigAdv.getConfiguration());

            isAdhoc = (RendezVousConfiguration.AD_HOC == rdvConfigAdv.getConfiguration());

            onlySeeds = rdvConfigAdv.getUseOnlySeeds();

            for (URI uri : Arrays.asList(rdvConfigAdv.getSeedRendezvous())) {
                seedRdvs.add(uri.toString());
            }

            for (URI uri1 : Arrays.asList(rdvConfigAdv.getSeedingURIs())) {
                seedingRdvs.add(uri1.toString());
            }
        } catch (Exception failure) {
            throw new ConfiguratorException("Broken Platform Config. Cannot proceed.", failure);
        }

        // Relay Settings
        boolean isRelay;
        boolean useRelay;
        boolean useOnlySeedRelays;
        List<String> seedRelays = new ArrayList<String>();
        List<String> seedingRelays = new ArrayList<String>();

        try {
            param = (XMLElement) configAdv.getServiceParam(PeerGroup.relayProtoClassID);

            RelayConfigAdv relayConfig = (RelayConfigAdv) AdvertisementFactory.newAdvertisement(param);

            isRelay = relayConfig.isServerEnabled();

            useRelay = relayConfig.isClientEnabled();

            useOnlySeedRelays = relayConfig.getUseOnlySeeds();

            for (EndpointAddress endpointAddress : Arrays.asList(relayConfig.getSeedRelays())) {
                seedRelays.add(endpointAddress.toString());
            }

            for (URI uri : Arrays.asList(relayConfig.getSeedingURIs())) {
                seedingRelays.add(uri.toString());
            }
        } catch (Exception failure) {
            throw new ConfiguratorException("Broken Platform Config. Cannot proceed.", failure);
        }

        // BEGIN BUILDING UI

        GridBagLayout layout = new GridBagLayout();

        setLayout(layout);

        addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(WindowEvent e) {
                beCanceled();
            }
        });

        helpLabel = new Label("See \"http://jxta-jxse.dev.java.net/confighelp.html\" for config help", Label.CENTER);
        helpLabel.setBackground(new Color(220, 220, 220));
        helpLabel.setForeground(Color.black);

        helpLabel.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                helpLabel.setForeground(Color.black);
                helpLabel.setText("See \"http://jxta-jxse.dev.java.net/confighelp.html\" for config help");
            }
        });

        idPanel = new IdPanel(peerName, needSecurityConfig);

        enablingPanel = new EnablingPanel(isRelay, isRendezvous, isJxmeProxy);

        tcpPanel = new IPTptPanel(IPTptPanel.TransportType.TYPE_TCP, tcpEnabled, "TCP Settings", defaultInterfaceAddressT,
                defaultPortT, clientDefaultT, serverDefaultT, defaultServerNameT, defaultServerPortT, noPublicAddressesT,
                multicastEnabledT);

        httpPanel = new IPTptPanel(IPTptPanel.TransportType.TYPE_HTTP, httpEnabled, "HTTP Settings", defaultInterfaceAddressH,
                defaultPortH, clientDefaultH, serverDefaultH, defaultServerNameH, defaultServerPortH, noPublicAddressesH);

        rdvPanel = new RdvPanel(!isAdhoc, onlySeeds);

        // add the relays

        for (Object seedRdv : seedRdvs) {
            rdvPanel.seeds.addItem((String) seedRdv);
        }

        for (Object seedingRdv : seedingRdvs) {
            rdvPanel.seeding.addItem((String) seedingRdv);
        }

        relayPanel = new RelayPanel(useRelay, useOnlySeedRelays);

        // add the relays
        for (Object seedRelay : seedRelays) {
            relayPanel.seeds.addItem((String) seedRelay);
        }

        for (Object seedingRelay : seedingRelays) {
            relayPanel.seeding.addItem((String) seedingRelay);
        }

        ok = new Button("  OK  ");

        ok.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if (verifyInput()) {
                    if (saveValues()) {
                        beDone();
                    } else {
                        beCanceled();
                    }