restopeer.java

JXTA技术手册 书上3.4.5章的源代码

                // create the output pipe to send the response bid to
                // the HungryPeer requester
                try {
                    System.out.println(
                        "Attempting to create Output Pipe to HungryPeer " +
                        name);

                    // Create an output pipe connection to the HungryPeer
                    pipeOut = pipes.createOutputPipe(hungryPipe,
                                                     rtimeout);
                    // Check if we have a pipe
                    if (pipeOut == null) {
                        // Cannot conect the pipe
                        System.out.println("Could not find HungryPeer pipe");
                        continue;
                    }
                } catch (Exception e) {
                    // Pipe creation exception
                    System.out.println("HungryPeer may not be listening anymore");
                    continue;
                }

                // We have a pipe connection to the HungryPeer.
                // Now create the Bid Response document
                try {
                    // Construct the Response document
                    bid = StructuredDocumentFactory.newStructuredDocument(
                                     mimeType,
                                     "RestoNet:Bid");

                    // Set the Bid values (Brand, price, special)
                    // in the response document
                    el = bid.createElement("Brand", brand);
                    bid.appendChild(el);
                    el = bid.createElement("Price", friesPrice(size));
                    bid.appendChild(el);
                    el = bid.createElement("Specials", specials);
                    bid.appendChild(el);

                    // Create a new pipe message
                    msg = pipes.createMessage();

                    // Push the Bid offer in the message
                    msg.addElement(msg.newMessageElement(
                                   "Bid",mimeType, bid.getStream()));

                    // Send the message
                    pipeOut.send(msg);

                    // Close the output pipe connection
                    pipeOut.close();
                } catch (Exception ex) {
                    System.out.println(
                        "Error sending bid offer to HungryPeer " + name);
                    continue;
                }

                System.out.println("Sent Bid Offer to HungryPeer (" + name +
                       ") Fries price = "  + friesPrice(size) +
                       ", special = " + specials);
            } catch (Exception e) {
               System.out.println("Abort RestoPeer interrupted");
               return;
            }
        }
    }

    // Determine the price of the French fries depending on the size
    private String friesPrice(String size) {
        if (size.equals("small"))
              return "$1.50";
        if (size.equals("medium"))
              return "2.50";
        if (size.equals("large"))
              return "3.00";
        return "error";
    }

    // Create the resto pipe associated with this RestoPeer.
    // Discover first if a pipe advertisement exists, if
    // not create and publish it.
    private boolean createRestoPipe() {

        int count = 3;           // Discovery retry count
        Enumeration ae = null;   // Discovery response enumeration

        try {
            System.out.println(
                "Attempting to Discover the Restaurant RestoPipe");

            // Check if I have already published myself
            while (count-- > 0) {
                try {
                    // Check first locally if we have the advertisement cached
                    ae = disco.getLocalAdvertisements(DiscoveryService.ADV,
                                      "name", "RestoNet:RestoPipe:" + brand);

                    // If we found our pipe advertisement we are done
                    if (ae != null && ae.hasMoreElements())
                        break;

                    // We did not find the advertisement locally;
                    // send a remote request
                    disco.getRemoteAdvertisements(null,
                          DiscoveryService.ADV, "name",
                          "RestoNet:RestoPipe:" + brand, 1, null);

                    // Sleep to allow time for peers to respond to the
                    // discovery request
                    try {
                        Thread.sleep(timeout);
                    } catch (InterruptedException e) {}
                } catch (IOException e) {
                    // Found nothing! Move on
                }
            }

            if (ae == null || !ae.hasMoreElements()) {
                // We did not find the pipe advertisement, so create one
                System.out.println(
                    "Could not find the Restaurant Pipe Advertisement");

                // Create a pipe advertisement for our RestoPeer
                myAdv = (PipeAdvertisement)
                    AdvertisementFactory.newAdvertisement(
                        PipeAdvertisement.getAdvertisementType());

                // Assign a unique ID to the pipe
                myAdv.setPipeID(
                        IDFactory.newPipeID(restoNet.getPeerGroupID() ));

                // The symbolic name of the pipe is built from
                // the brand name of RestoPeer;  each RestoPeer
                // must therefore have a unique name.
                myAdv.setName("RestoNet:RestoPipe:" + brand);

                // Set the type of the pipe to be unidirectional
                myAdv.setType(PipeService.UnicastType);

                // We have the advertisement; publish it
                // into our local cache and to the RestoNet PeerGroup.
                // We use the default lifetime and the default
                // expiration time for remote publishing
                disco.publish(myAdv, DiscoveryService.ADV,
                              PeerGroup.DEFAULT_LIFETIME,
                              PeerGroup.DEFAULT_EXPIRATION);
                disco.remotePublish(myAdv, DiscoveryService.ADV,
                              PeerGroup.DEFAULT_EXPIRATION);

                System.out.println(
                    "Created the Restaurant Pipe Advertisement");
            } else {
                // We found an existing pipe advertisement
                myAdv = (PipeAdvertisement) ae.nextElement();
                System.out.println("Found Restaurant Pipe Advertisement");
            }

            // Create my input pipe to listen for hungry peers
            // requests
            pipeIn = pipes.createInputPipe(myAdv);
        } catch (Exception e) {
            System.out.println("Could not initialize the Restaurant pipe");
            return false;
        }
        return true;
    }

    // Create a Module Impl Advertisement that represents a peergroup
    // which is a clone of the NetPeerGroup but with a different
    // membership service.
    private ModuleImplAdvertisement createAuthPeerGroupModuleImplAdv(
                PeerGroup parent) {

        ModuleImplAdvertisement allPurposePeerGroupImplAdv = null;
        StdPeerGroupParamAdv PeerGroupParamAdv = null;

        try {
            // Clone the parent (NetPeerGroup) implementation to get
            // a module implementation
            allPurposePeerGroupImplAdv =
                parent.getAllPurposePeerGroupImplAdvertisement();
        }
        catch (Exception e) {
            System.err.println("Cannot get allPurposePeerGroupImplAdv " + e);
            return null;
        }

        // Get the param field that conatins all the peergroup services
        // associated with the peergroup
        try {
            PeerGroupParamAdv = new StdPeerGroupParamAdv(
                                allPurposePeerGroupImplAdv.getParam());
        }
        catch (PeerGroupException e) {
            System.err.println("Cannot get StdPeerGroupParamAdv " + e);
             return null;
        }

        // Get the hashtable containaing the list of all the peergroup
        // services from the param advertisements.
        Hashtable allPurposePeerGroupServicesHashtable =
            PeerGroupParamAdv.getServices();

        // Replace the membership service in the hashtable
        // This entails enumerating the known services to find the
        // membership service, and then replacing its advertisement.
        Enumeration services = allPurposePeerGroupServicesHashtable.keys();
        while (services.hasMoreElements()) {
            Object key = services.nextElement();
            ModuleClassID mcid;
            try {
                mcid = (ModuleClassID) key;
            } catch (ClassCastException cce) {
                System.out.println("Not a service; ignoring");
                continue;
            }
            if (mcid.isOfSameBaseClass(PeerGroup.refMembershipSpecID)) {
                // Got the membership service. Save its class id for
                // later and then make an advertisement for our new
                // membership service.
                membershipClassID = mcid;
                ModuleImplAdvertisement mia = (ModuleImplAdvertisement)
                    AdvertisementFactory.newAdvertisement(
                    ModuleImplAdvertisement.getAdvertisementType());
                mia.setModuleSpecID(
                    PasswdMembershipService.passwordMembershipSpecID);
                mia.setCode(
                    "net.jxta.impl.membership.PasswdMembershipService");
                mia.setDescription("Authenticated Membership Service");
                StructuredTextDocument doc = (StructuredTextDocument)
                    StructuredDocumentFactory.newStructuredDocument(
                    new MimeMediaType("text/xml"), "Comp");
                Element e = doc.createElement("Efmt", "JDK1.4");
                doc.appendChild(e);
                e = doc.createElement("Bind", "V1.0 Ref Impl");
                doc.appendChild(e);
                mia.setCompat(doc);
                mia.setUri("http://www.jxta.org/download/jxta.jar");
                mia.setProvider("sun.com");
                allPurposePeerGroupServicesHashtable.remove(key);
                allPurposePeerGroupServicesHashtable.put(key, mia);
                break;
            }
        }

        // Update the PeerGroupModuleImplAdv with our new list
        // of peergroup services
        allPurposePeerGroupImplAdv.setParam((Element)
                PeerGroupParamAdv.getDocument(new MimeMediaType("text/xml")));

        // Set the new unique Spec ID that identifies this new peergroup
        // implementation
        allPurposePeerGroupImplAdv.setModuleSpecID(
            PasswdMembershipService.passwordMembershipSpecID);

        // We are done creating our new peergroup implementation
        return allPurposePeerGroupImplAdv;
    }

    // This utility method is used to create a PeerGroup advertisement
    // associated with a module peergroup implementation
    private PeerGroupAdvertisement createPeerGroupAdvertisement(
         ModuleImplAdvertisement implAdv, String groupName) {

        // Create a new peergroup advertisement
        PeerGroupAdvertisement myadv = (PeerGroupAdvertisement)
            AdvertisementFactory.newAdvertisement(
                PeerGroupAdvertisement.getAdvertisementType());

        // Instead of creating a new group ID we use the
        // RestoPeer pre-defined peergroup id, so we create the same
        // peergroupId each time the group
        // is created
        myadv.setPeerGroupID(restoPeerGroupID);

        // Assign the pre-defined module spec id that corresponds
        // to our peergroup module implementation
        myadv.setModuleSpecID(implAdv.getModuleSpecID());

        // Assign peergroup name
        myadv.setName(groupName);

        // Set the peergroup description
        myadv.setDescription("This is the authenticated RestoNet Peergroup");

        return myadv;
    }

    // Create an authentication document and use it to join the given
    // peergroup.
    private void authenticateAndJoin(PeerGroup pg) {
        try {
            StructuredDocument creds = null;
            // Get the application document from the peergroup
            AuthenticationCredential authCred =
                new AuthenticationCredential(pg, null, creds);
            MembershipService m = (MembershipService)
                pg.getMembershipService();
            // Get the entity used to check the application document.
            Authenticator auth = m.apply(authCred);
            PasswdMembershipService.PasswdAuthenticator pwAuth =
                     (PasswdMembershipService.PasswdAuthenticator) auth;
            // Fill out the application document.
            pwAuth.setAuth1Identity("hungrypeer");
            pwAuth.setAuth2_Password("password");
            if (!auth.isReadyForJoin()) {
                System.err.println("Authentication failed: not ready");
                throw new IllegalArgumentException("Can't authenticate");
            }
            // Send the application document and join the peergroup.
            m.join(auth);
        } catch (Exception e) {
            System.err.println("Authentication failed: " + e);
            throw new IllegalArgumentException(e.toString());
        }
    }
}