hungrypeer.java

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

        try {
            // extract the RestoPeer service from the RestoNet peergroup
            // advertisement since it is now part of the RestoNet Peergroup
            ID  msrvID = null;
            PipeAdvertisement restoPipe = null;

            // get the Spec ID for the RestoPeerService to lookup the service
            // in the Peergroug handle
            try {
                msrvID = IDFactory.fromURL(new URL("urn", "",
                         RestoPeerService.Module_Spec_ID));

            } catch (java.net.MalformedURLException e) {
            } catch (java.net.UnknownServiceException e) {
                System.err.println(" Can't create restoPeer PipeID: UnknownServiceException ") ;
                System.exit(1);
            }

            // lookup for the RestoPeer peergroup service
            // we have to wait to make sure the service was completly initialized
            // before we can lookup the service
            while (restoSrv == null) {
                try {
                    Thread.sleep(2000);
                    restoSrv = (RestoPeerService) restoNet.lookupService(msrvID);

                } catch (Exception ex) { // This is ok
                }
            }

            // Extract the pipe advertisement from the RestoPeer service module
            // implementation advertisement. Get the ModuleImpl advertisement
            // associated with the service
            ModuleImplAdvertisement restoImpl = (ModuleImplAdvertisement)
                restoSrv.getImplAdvertisement();

            // extract the pipe from the param section of the Module Implementation
            restoPipe = (PipeAdvertisement)
                AdvertisementFactory.newAdvertisement((TextElement)
                      restoImpl.getParam().getChildren().nextElement());

            // save the pipe
            restoPeerAdvs.addElement(restoPipe);
            ++found;

        } catch (Exception ex) {
            System.out.println("Failure to connect to RestoPeer service pipe");
            ex.printStackTrace();
        }
        // Completed RestoPeer Discovery
        System.out.println("Found " + found + " RestoPeers Service");
    }

    // Method to connect and open output pipes to all the
    // RestoPeers that we have discovered. Each RestoPeer is
    // identified by its unique RestoPeer pipe advertisement.
    private void connectToRestoPeers() {

        // Enumerate all the RestoPeer pipe advertisments we have discovered
        // and attempt to connect a pipe which each of them
        for (Enumeration en = restoPeerAdvs.elements(); en.hasMoreElements();) {

            PipeAdvertisement padv = (PipeAdvertisement) en.nextElement();

            try {

                System.out.println("Attempt to connect to discovered RestoPeer");

                // Create an output Pipe connection to the RestoPeer
                OutputPipe pipeOut = pipes.createOutputPipe(padv, rtimeout);

                // Check if we have a connected Pipe
                if (pipeOut == null) { // Failed go to next RestoPeer
                    System.out.println("Failure to connect to RestoPeer Pipe:" +
                                       padv.getName());
                    continue;
                }

                // Save the output Pipe in RestoPeers connected structure
                restoPeerPipes.addElement(pipeOut);

                System.out.println("Connected pipe to " + padv.getName());

            } catch (Exception e) { // Error during connection go to next RestoPeer
                 System.out.println("RestoPeer may not be there anymore:" +
                                    padv.getName());
                 continue;
            }
        }
    }

    // Send an auction request for French Fries to all the RestoPeer
    // pipes we have successfully connected
    private void sendFriesAuctionRequests() {

        // Enumerate all the RestoPeer pipe connections we have successfully
        // connected with
        for (Enumeration en = restoPeerPipes.elements(); en.hasMoreElements();) {
            OutputPipe op = (OutputPipe) en.nextElement();
            try {

                // Construct the Request document
                StructuredDocument request  =
                    StructuredDocumentFactory.newStructuredDocument(mimeType,
                    "RestoNet:Request");

                // Fill up the Fries auction request argument
                Element re;
                re = request.createElement("Name", myIdentity);
                request.appendChild(re);
                re = request.createElement("Fries", friesRequest);
                request.appendChild(re);

                // create the pipe message to send
                Message msg = pipes.createMessage();

                // fill the first message element which is the HungryPeer
                // pipe advertisement return address. We need this
                // so RestoPeers can respond to us
                msg.addElement(msg.newMessageElement("HungryPeerPipe", mimeType,
                    myAdv.getDocument(mimeType).getStream()));

                // fill the second message element
                // the fries request. Insert the document
                //in the message
                msg.addElement(msg.newMessageElement("Request", mimeType,
                     request.getStream()));

                // send the auction message to the RestoPeer connected
                // pipe
                op.send(msg);

                System.out.println("Sent Fries Auction Request (" + friesRequest +
                                   ") to connected peers");

            } catch (Exception ex) { // Error sending auction request
                System.out.println("Failed to send auction request to RestoPeer");
            }
        }
    }

    // Receive bid requests from RestoPeers on the
    // HungryPeer listening pipe
    private void receiveFriesBids() {

        // Continue until we got all answers
        while (true) {

            Message msg = null;      // pipe message received
            String price = null;     // Fries price bid
            String brand = null;     // RestoPeer name which offers the bid
            String specials = null;  // specials offer bid
            InputStream ip = null;   // input stream to read message element
            StructuredDocument bid = null; //Bid document received

            try {

                // Wait for a bid message to arrive from a RestoPeer
                // Will block until a message arrive
                msg = myPipe.waitForMessage();

                // Check if the message is valid
                if (msg == null) {
                    if (Thread.interrupted()) {// interupted
                        // We have been asked to stop
                        System.out.println("Abort Receiving bid loop interrupted");
                        myPipe.close(); // Close the Pipe
                        return;
                    }
                }

            } catch (Exception ex) { // error in receiving message
                myPipe.close();
                System.out.println("Abort Receiving Error receiving bids");
                return;
            }

            // We got a message from a RestoPeer. Let's
            // extract and display infomation about the bid received
            try {

                // Extract the Bid document from the message
                ip = msg.getElement("Bid").getStream();
                bid = StructuredDocumentFactory.newStructuredDocument(mimeType,
                                                                        ip);

                // Parse the document to extract bid information
                Enumeration enum = bid.getChildren();
                while (enum.hasMoreElements()) {
                    Element element = (Element) enum.nextElement();
                    String attr = (String) element.getKey();
                    String value = (String) element.getValue();
                    if (attr.equals("Price")) {
                        price = value;
                        continue;
                    }
                    if (attr.equals("Brand")) {
                        brand = value;
                        continue;
                    }
                    if (attr.equals("Specials")) {
                        specials = value;
                        continue;
                    }
                }

                // We got a valid bid. Let's print it
                System.out.println("Received Fries Bid from RestoPeers (" +
                                   brand + ") at a Price ($" + price +
                                   ") \nRestoPeers Special (" + specials + ")");

            } catch (Exception e) { // Error extracting bid from the message
                System.out.println("Error extracting bid from the message");
                continue; // broken content;
            }
        }
    }
}