restopeerservice.java

这个事关于jxta编程的入门级代码

import java.io.*;
import java.util.*;
import java.net.URL;

import net.jxta.service.Service;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.exception.PeerGroupException;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.Advertisement;
import net.jxta.document.Element;
import net.jxta.document.TextElement;
import net.jxta.document.MimeMediaType;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredTextDocument;
import net.jxta.discovery.DiscoveryService;
import net.jxta.pipe.PipeService;
import net.jxta.pipe.InputPipe;
import net.jxta.pipe.OutputPipe;
import net.jxta.pipe.PipeID;
import net.jxta.protocol.PipeAdvertisement;
import net.jxta.protocol.PeerGroupAdvertisement;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.endpoint.Message;
import net.jxta.id.IDFactory;
import net.jxta.id.ID;

// The class RestoPeerService is an example of a PeerGroup Service.
// This service is registered as a RestoNet Peergroup service.
// This service implements the RestoPeer service for Chez JXTA.
public class RestoPeerService implements Service {


    // Service Module Spec Index ID
    public static String Module_Spec_ID =
        "jxta:uuid-737D1ED776B043E7A8718B102B62055A05";

    private String brand = "Chez JXTA";         // Brand of this restaurant
    private String specials = "large ($3.00)";  // Current restaurant Special

    private PeerGroup restoNet = null;   // The RestoNet Peergroup
    private PipeService pipes = null;    // Pipe service in the RestoNet

    private ModuleImplAdvertisement srvImpl = null;
    private PipeAdvertisement myAdv = null;  // My pipe advertisement
    private InputPipe pipeIn = null;         // Input pipe that we listening
                                             // to for requests
    private int rtimeout = 8000;             // Resolver pipe timeout

    // Service objects are not manipulated directly to protect usage
    //of the service. A Service interface is returned to access the service
    public Service getInterface() {
        return this;
    }

    // Returns the module impl advertisement for this service.
    public Advertisement getImplAdvertisement() {
        return srvImpl;
    }

    // Called when the peergroup initializes the service
    public void init(PeerGroup group, ID assignedID, Advertisement impl) {
        // Save the RestoNet pointer, the pipe and the RestoPeer Service
        restoNet = group;
        srvImpl = (ModuleImplAdvertisement) impl;
        System.out.println("Initialization RestoPeer Special Service: " +
                           srvImpl.getModuleSpecID());

        // Extract the service pipe advertisement from the service
        // module impl Advertisement. The client MUST use the same pipe
        // advertisement to talk to the service. When the client
        // discovers the peergroup advertisement, it will extract the
        // pipe advertisement to create the connecting pipe by getting
        // the module impl advertisement associated with the RestoPeer
        // service.
        System.out.println("Extract the pipe advertisement from the Service");
        PipeAdvertisement pipeadv = null;

        try {
            // Extract the pipe adv from the Module impl param section
            myAdv = (PipeAdvertisement)
                AdvertisementFactory.newAdvertisement((TextElement)
                      srvImpl.getParam().getChildren().nextElement());
        } catch (Exception e) {
            System.out.println("failed to read/parse pipe advertisement");
            e.printStackTrace();
            System.exit(-1);
        }

        // Start the RestoPeer service loop thread to respond to Hungry peers
        // fries requests. Start a new thread for processing all the
        // requests
        HandleFriesRequest peerRequest = new HandleFriesRequest();
        peerRequest.start();
    }

    // Called when the service is started
    public int startApp (String args[]) {
        // nothing to do here
        return 0;
    }

    // Called just before the service is stopped
    public void stopApp() {
    }

    // Thread to handle fries auction requests from HungryPeers.
    // The method waits for HungryPeer requests pipe messages to arrive.
    // Incoming requests contain a pipe advertisement to respond to the
    // HungryPeers requester and a fries size.
    // The method generates a bid offer for the request, opens an output
    // pipe to the HungryPeer requester and send the response.
    private class HandleFriesRequest extends Thread {

        InputStream ip = null;               // Input Stream of message
        PipeAdvertisement hungryPipe = null; // HungryPeer Requester pipe
        StructuredDocument request = null;   // Request document
        StructuredDocument bid = null;       // Bid response
        MimeMediaType mimeType = new MimeMediaType("text", "xml");
        Element el = null;                   // Element in document
        String name = null;                  // Name of the sender
        String size = null;                  // Fries size Requested
        OutputPipe pipeOut = null;           // Output pipe to respond to
                                             // HungryPeer requester

        public void run() {
            // Need to check that the Pipe peergroup service of
            // RestoNet is initialized. Peergroup services are loaded
            // dynamically. Here we just wait until the pipe service
            // is initialized so we can create a new pipe.
            try {
                while (pipes == null) {
                    Thread.sleep(2000);
                    pipes = restoNet.getPipeService();
                }

                // Create the input pipe to receive incoming request
                if (!createRestoPipe()) {
                    System.out.println(
                        "Aborting due to failure to create RestoPeer pipe");
                    return;
                }
            } catch (Exception ex) {
                    System.out.println(
                           "Exception while creating RestoPeer pipe");
                    return;
            }

            System.out.println("RestoNet Restaurant (" + brand +
                           ") waiting for HungryPeer requests");

            // Loop waiting for HungryPeer Requests
            while (true) {
                Message msg = null;          // incoming pipe message
                try {
                    // Block until a message arrive on the RestoPeer pipe
                    msg = pipeIn.waitForMessage();

                    // If message is null, discard message
                    if (msg == null) {
                        if (Thread.interrupted()) {
                            // We have been asked to stop
                            System.out.println("Abort: RestoPeer interrupted");
                            return;
                        }
                    }

                    // We received a message; extract the request
                    try {
                        // Extract the HungryPipe pipe information
                        // to reply to the sender
                        ip = msg.getElement("HungryPeerPipe").getStream();

                        // Construct the associated pipe advertisement
                        // via the AdvertisementFactory
                        hungryPipe = (PipeAdvertisement)
                        AdvertisementFactory.newAdvertisement(mimeType, ip);

                        // Extract the sender name and fries size requested
                        // building a StructuredDocument
                        ip = msg.getElement("Request").getStream();
                        request = StructuredDocumentFactory.
                                    newStructuredDocument(mimeType, ip);

                        // Extract the fields from the structured Document
                        Enumeration enum = request.getChildren();

                        // Loop over all the elements of the document
                        while (enum.hasMoreElements()) {
                            el = (Element) enum.nextElement();
                            String attr = (String) el.getKey();
                            String value = (String) el.getValue();

                            // Extract the HungryPeer Requester Name
                            if (attr.equals("Name")) {
                                name = value;
                                continue;
                            }

                            // Extract the Fries  size requested
                            if (attr.equals("Fries")) {
                                size = value;
                                continue;
                            }
                        }
                    } catch (Exception e) {
                        // Broken Content
                        continue;
                    }

                    System.out.println("Received Request from HungryPeer "
                               + name + " for " + size + " Fries.");

                    // The auction request is valid. We can
                    // 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
                        // requester
                        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 {
                        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();

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

                        pipeOut.send(msg);
                        pipeOut.close();

                    } catch (Exception ex) {
                        System.out.println(
                            "Error sending bid offer to HungryPeer " + name);
                    }

                    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 input endpoint
    private boolean createRestoPipe() {
        try {
            // 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" + e.getMessage());
            return false;
        }
        return true;
    }
}