groupdiscovery.java

JXTA中对等节点成员身份协议和检索协议的实例

import java.io.InputStream;
import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.lang.String;
import java.util.Enumeration;
import javax.swing.JList;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.MimeMediaType;
import net.jxta.discovery.DiscoveryService;
import net.jxta.discovery.DiscoveryListener;
import net.jxta.discovery.DiscoveryEvent;
import net.jxta.exception.PeerGroupException;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.protocol.DiscoveryResponseMsg;
import net.jxta.protocol.PeerAdvertisement;
import net.jxta.protocol.PeerGroupAdvertisement;


/*
*GroupDiscovery
*Responsible for local and remote discovery of groups.
*Also responsible for updating the group information
*in the GUI.
*/
public class GroupDiscovery implements Runnable, DiscoveryListener {
    //necessary links to important group information
    private PeerGroup netPeerGroup;
    private DiscoveryService discovery;
    private PeerAdvertisement peerAdv;

    //link to group tree GUI
    private JList groupList;
    private String defaultGroupName;

    //link to GUI discovery selection type (local or remote)
    private boolean local;

    /*
    *Update group GUI for adding/removing groups and
    *respective peers under groups.
    */
    private void updateGUI(boolean stringCast, Enumeration enum) {
        String str = null;
        PeerGroupAdvertisement newAdv = null;
        MimeMediaType mmt = new MimeMediaType("text/xml");
        SortedListModel groups = (SortedListModel) groupList.getModel();

        while (enum.hasMoreElements()) {
            //Processing String objects
            if (stringCast) {
                str = (String) enum.nextElement();

                try {
                    //create an advertisement from each element
                    newAdv = (PeerGroupAdvertisement) AdvertisementFactory.newAdvertisement(
                                     mmt, 
                                     new ByteArrayInputStream(str.getBytes()));
                } catch (IOException ioe) {
                    System.out.println("Error parsing response element!");
                    ioe.printStackTrace();

                    continue;
                }
            }
            //Processing PeerGroupAdvertisement objects
            else {
                newAdv = (PeerGroupAdvertisement) enum.nextElement();
            }

            System.out.println("Discovered group = " + newAdv.getName());

            //found a new group,add them to the groupList
            if (groups.contains(newAdv.getName()) == false) {
                groups.addElement(newAdv.getName());
                System.out.println("Discovered group = " + newAdv.getName() + 
                                   " added ");
            }
        }


        //update the GUI
        groupList.setModel(groups);
        groupList.setSelectedValue(defaultGroupName, true);
    }

    /*
    *Start JXTA method.
    */
    public void startJxta() {
        //flush local group cache
        flushGroupInfo();
    }

    /*
    *Flush local group cache information.
    */
    public void flushGroupInfo() {
        try {
            discovery.flushAdvertisements(null, DiscoveryService.GROUP);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
    *On demand,discover groups locally or remotely
    *via a thread.
    */
    public void run() {
        Enumeration enum = null;
        PeerGroupAdvertisement pga = null;
        SortedListModel groups = (SortedListModel) groupList.getModel();

        try {
            //Add ourselves as a discoverylistener for
            //discovery response events.
            discovery.addDiscoveryListener(this);

            //check local cache for peer
            if (local) {
                enum = discovery.getLocalAdvertisements(DiscoveryService.GROUP, 
                                                        null, null);

                if ((enum == null) || (enum.hasMoreElements() == false)) {
                    System.out.println("No local advertisements found");

                    return;
                }

                System.out.println("update GUI group discovery now");


                //update group list in GUI
                updateGUI(false, enum);
            }
            //wait 10 seconds per remote discovery
            else {
                discovery.getRemoteAdvertisements(null, DiscoveryService.GROUP, 
                                                  null, null, 10, this);

                try {
                    Thread.sleep(10 * 1000);
                } catch (Exception e) {
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
    *Handle remote discovery messages.
    */
    public void discoveryEvent(DiscoveryEvent e) {
        DiscoveryResponseMsg drm = e.getResponse();
        String response = drm.getPeerAdv();
        InputStream is = null;
        MimeMediaType mmt = new MimeMediaType("text/xml");

        try {
            //Create a group advertisement.
            is = new ByteArrayInputStream(response.getBytes());
            peerAdv = (PeerAdvertisement) AdvertisementFactory.newAdvertisement(
                              mmt, is);
            System.out.println("[ Received discovery response[" + 
                               drm.getResponseCount() + 
                               " elements ] from group:" + peerAdv.getName() + 
                               " ]");
        } catch (IOException ioe) {
            System.out.println("Error parsing remote peer抯 advertisement!");
            ioe.printStackTrace();

            return;
        }


        //update groups in GUI
        updateGUI(true, drm.getResponses());
    }

    /*
    *Set discovery type
    *local =true