import java.rmi.*;import java.rmi.server.*;import java.io.*;import net.jxta.peergroup.PeerGroup;import net.jxta.peergroup.PeerGroupFactory;import net.jxta.exception.PeerGroupException;import net.jxta.document.Advertisement;import net.jxta.document.AdvertisementFactory;import net.jxta.document.StructuredTextDocument;import net.jxta.document.StructuredDocumentFactory;import net.jxta.document.Element;import net.jxta.document.MimeMediaType;import net.jxta.discovery.DiscoveryService;import net.jxta.protocol.ModuleImplAdvertisement;import net.jxta.protocol.ModuleClassAdvertisement;import net.jxta.protocol.ModuleSpecAdvertisement;import net.jxta.platform.ModuleClassID;import net.jxta.id.IDFactory;import jxta.security.util.URLBase64;public class RMIServiceImpl implements RMIService {    PeerGroup netpg;    String stub;    public RMIServiceImpl() throws RemoteException { }    public void init() throws Exception {        try {            //Discover and join (or start) the default peergroup            netpg = PeerGroupFactory.newNetPeerGroup();        } catch (PeerGroupException e) {            //Couldn't initialize; can't continue            System.out.println("Fatal error : creating the NetPeerGroup");            System.exit(1);        }        makeStub();        publishAdv();    }    // The stub is how RMI clients call RMI servers. RMI clients normally    // get the stub from the lookup service via object serialization; in    // this example, they'll get the stub from the module service    // advertisement. Note that the serialized object is encoded as an    // ASCII string so that it can be transmitted through a variety    // of networks.    private void makeStub() throws IOException {        ByteArrayOutputStream baos = new ByteArrayOutputStream();        ObjectOutputStream oos = new ObjectOutputStream(baos);        oos.writeObject(UnicastRemoteObject.exportObject(this));        oos.close();        stub = new String(URLBase64.encode(baos.toByteArray()));    }    public String sayHello() {        return "Hello";    }    // Publish the advertisement. There's no point in caching this    // advertisement because the RMI stub is invalid between runs. So we    // always have to publish a new advertisement.    public boolean publishAdv() {        try {            DiscoveryService disco = netpg.getDiscoveryService();            ModuleClassAdvertisement mca = (ModuleClassAdvertisement)                AdvertisementFactory.newAdvertisement(                ModuleClassAdvertisement.getAdvertisementType());            mca.setName("JXTAMOD:RMIService:HelloService");            mca.setDescription("Sample RMI-as-JXTA Service");            ModuleClassID mcID = IDFactory.newModuleClassID();            mca.setModuleClassID(mcID);            disco.publish(mca, DiscoveryService.ADV);            disco.remotePublish(mca, DiscoveryService.ADV);            ModuleSpecAdvertisement msa = (ModuleSpecAdvertisement)                AdvertisementFactory.newAdvertisement(                ModuleSpecAdvertisement.getAdvertisementType());            msa.setName("JXTASPEC:RMIService:HelloService");            msa.setVersion("Version 1.0");            msa.setCreator("sun.com");            msa.setSpecURI("http://www.jxta.org/tutorial/RMIService.jar");            msa.setModuleSpecID(IDFactory.newModuleSpecID(mcID));            StructuredTextDocument doc = (StructuredTextDocument)                StructuredDocumentFactory.newStructuredDocument(                new MimeMediaType("text/xml"), "Parm");            Element e = doc.createElement("Stub", stub);            doc.appendChild(e);            msa.setParam(doc);            disco.publish(msa, DiscoveryService.ADV);            disco.remotePublish(msa, DiscoveryService.ADV);            System.out.println("Created the RMI advertisement");        } catch (Exception e) {            System.out.println(e);            e.printStackTrace();            return false;        }        return true;    }    public static void main(String[] args) throws Exception {        RMIServiceImpl rsi = new RMIServiceImpl();        rsi.init();        System.out.println("RMIService waiting for requests...");        // If we exit, rsi becomes eligible for GC, which means        // it could no longer handle requests        synchronized(rsi) {            rsi.wait();        }    }}