package com.sams.jxta.groups;import net.jxta.credential.AuthenticationCredential;
import net.jxta.credential.Credential;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredTextDocument;
import net.jxta.exception.PeerGroupException;
import net.jxta.exception.ProtocolNotSupportedException;
import net.jxta.id.IDFactory;
import net.jxta.impl.id.UUID.UUIDFactory;
import net.jxta.impl.protocol.PeerGroupAdv;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.impl.peergroup.StdPeerGroup;
import net.jxta.impl.peergroup.StdPeerGroupParamAdv;
import net.jxta.membership.Authenticator;
import net.jxta.membership.MembershipService;
import net.jxta.peergroup.PeerGroup;
import net.jxta.platform.ModuleClassID;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.protocol.PeerGroupAdvertisement;import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Map;/*** This class can be used to create a new group with a pluggable * Membership service.It provides simple APIs for Apply,Join and Resign* functionalities.*/public class GroupManager {private static final org.apache.log4j.Category LOG = org.apache.log4j.Category.getInstance(GroupManager.class.getName());protected DiscoveryService disco;// The parent group of the current peer groupprotected PeerGroup parent;// Net peer for creating advertisements.protected PeerGroup netPeerGroup;// The current peer groupprotected PeerGroup activeGroup;// Any module(like a peer group) that is loaded by the parent group,must // be compatible with the parent.Compatibility is checked by comparision // with the stdCompactStatement public StructuredTextDocument stdCompatStatement = // ??? Taken from StdPeerGroup
                mkCS();// An identifier to the implementation used // ??? Is it so ?public String stdUri = "http://www.jxta.org/download/jxta.jar";// ??? Taken from StdPeerGroup// The provider of the implementation // ??? Is it so ?public String stdProvider = "sun.com";// ??? Taken from StdPeerGroup// The mime type of all documents used in this examplepublic static final String DOCUMENT_MIME_TYPE="text";// The base type of all documentspublic static final String DOCUMENT_BASE_TYPE="xml";// This is the root element documents createdpublic static final String DOCUMENT_ROOT_ELEMENT="Comp";    // Key ??? What is this used for ?private static final String KEY="Efmt";    // Value ??? What is this used for ?private static final String VALUE="JDK1.4";// Key used to represent the bindingprivate static final String BINDING_KEY="Bind";// Value of the binding key.It represents the binding // of JXTA that we use.private static final String BINDING_VALUE="V1.0 Ref Impl";/** * The constructor of the Group Manger.Initially * the parent group is the also the active group.*/public GroupManager(PeerGroup netPeerGroup, PeerGroup parent) {this.disco  = parent.getDiscoveryService();this.parent = parent;this.activeGroup = parent;this.netPeerGroup = netPeerGroup;if (netPeerGroup ==  null){System.out.println("netPeerGroup :"+netPeerGroup+" - aborting");throw new NullPointerException("netPeerGroup :"+netPeerGroup+" - aborting");}}/* *   Method to add a new peer group and publish it.The *   groupMemebershipClassName is the fully qualified class *   name of the mermbership service class.**/public PeerGroup addGroup(String groupName,String groupMembershipClassName,String groupDescription,ModuleImplAdvertisement advertisement,boolean conditional){
System.out.println("GroupManager.addGroup Successfully created SecurityDemoGroup");// The first thing we do is to see if a group already exists by this name.// If so we get the Group ID of the group. Then depending on the unconditional// flag we proceed.// If it is an conditional add ,we create a new group only if no other group// with the same name already exists otherwise we throw an exception.// If it is an unconditional add , we always create  a group.If the user had previously// created the group , we use the Old group ID . PeerGroupID oldPeerGroupID = alreadyExists(groupName);if(oldPeerGroupID != null && conditional==true)throw new GroupManagerException("A Group by this name already exists with id :"+oldPeerGroupID);// If no Advertisement is provided, we create a fresh advertisement.if (advertisement == null){LOG.debug("Creating a new Advertisement");// We use the existing advertisement of the standard peer group// and add our service along with the other standard services try{// This is used as a base to create the new advertisement upon    System.out.println("netPeerGroup :"+netPeerGroup);advertisement = netPeerGroup.getAllPurposePeerGroupImplAdvertisement();//advertisement = parent.getAllPurposePeerGroupImplAdvertisement();//<< Did not work in current platformStructuredDocument paramDoc = advertisement.getParam();System.out.println("StructuredDocument paramDoc:"+paramDoc);// The Param document used to make the StandradPeerGroup AdvertisementStdPeerGroupParamAdv paramAdv = new StdPeerGroupParamAdv(paramDoc);// List of all the available standard servicesMap services = paramAdv.getServices();// Make a ModuleImplAdvertisemnet for the membership serviceModuleImplAdvertisement moduleAdv = mkImplAdvBuiltin(PeerGroup.refMembershipSpecID,groupMembershipClassName,groupDescription);// Add this service along the other standard services
                services.put(PeerGroup.membershipClassID, moduleAdv);paramAdv.setServices(services);advertisement.setParam((net.jxta.document.TextElement)paramAdv.getDocument(new net.jxta.document.MimeMediaType(DOCUMENT_MIME_TYPE,DOCUMENT_BASE_TYPE)));System.out.println("compat " + advertisement.getCompat());System.out.println("compat " + StdPeerGroup.STD_COMPAT);}catch(PeerGroupException peerGroupException){peerGroupException.printStackTrace();System.exit(-1);LOG.error("Error in creating Advertisement",peerGroupException);throw new GroupManagerException(peerGroupException.getMessage());}catch(Exception genericException){genericException.printStackTrace();LOG.error("Error in creating Advertisement",genericException);System.exit(-1);throw new GroupManagerException(genericException.getMessage());}}LOG.debug("Successfullt created ADVERTISEMENT");  // initialize but to no start the application// this is done by the join commandLOG.debug("Creating the Peer Group");        PeerGroup peerGroup = null;try {// create a PeerGroup IDPeerGroupID peerGroupID = null;if(oldPeerGroupID != null){peerGroupID = oldPeerGroupID;}else{peerGroupID = IDFactory.newPeerGroupID();}// create the PeerGrouppeerGroup = parent.newGroup(peerGroupID, advertisement, groupName, groupDescription);// initialize the peergrouppeerGroup.init(this.parent,peerGroupID, advertisement);} catch (PeerGroupException peerGroupException) {peerGroupException.printStackTrace();LOG.error("Unable to create a peer group !",peerGroupException);throw new GroupManagerException(peerGroupException.getMessage());}// For debug purposes, print advertisement to console//com.sams.jxta.Util.printAdvertismentDoc(advertisement);// Try to publish the advertisementLOG.debug("Trying to publish the advertisement");publish(peerGroup, advertisement/*original advertisement???*/);LOG.debug("Peer Group Advertisement successfully published");return peerGroup;}/** * Will check if a peer group with the same name exists on this peer*/public PeerGroupID alreadyExists(String name){DiscoveryService discovery = parent.getDiscoveryService();Enumeration enumeration =null;try{enumeration =discovery.getLocalAdvertisements(discovery.GROUP, "Name",name);} catch(java.io.IOException ioException) {LOG.debug("Error in getting local advertisements ");return null;}// If the group already exists either the  enumeration is null// or it does not contain any data if(enumeration != null && enumeration.hasMoreElements())return ((PeerGroupAdv)enumeration.nextElement()).getPeerGroupID();elsereturn null; }// Tries to publish the newly created peer group  // ??? Why do we need the original Advertisement ?private void publish(PeerGroup child,Advertisement pgAdv//PeerGroupAdvertisement origAdv
                               ) {System.out.println("Publishing group");//get the Discovery for this group//Publish the New Peer in its group discovery
      DiscoveryService discovery;try {discovery = parent.getDiscoveryService();discovery.publish(pgAdv);// let's publish the peer adv//if (origAdv != null){//?????? Not sure what this does// we could check if it is indeed ours// but it does not hurt to publish it any way//   discovery = child.getDiscoveryService();//   discovery.publish(origAdv, DiscoveryService.GROUP);//}} catch (java.io.IOException ioException) {LOG.error("Could not publish the service !",ioException);throw new GroupManagerException(ioException.getMessage());}LOG.debug("Published the group successfully");}/***  This is the code that will create a credential to join the group.*  Each group that we are joining has a specific membership requirement.*  Many groups will just be the NullMembership, which is the default.**/public Credential joinGroup(PeerGroup newGroup,StructuredDocument credentials,String authenticationMethod) throws GroupManagerAuthenticationException,ProtocolNotSupportedException{MembershipService membership = (MembershipService) newGroup.getMembershipService();// The first step is to apply to the membership service
        Authenticator authenticator;authenticator = applyToMembershipService(newGroup,credentials,authenticationMethod);// Next step is to allow the user to "fill up" the authenticator// by creating a dialogLOG.debug("Apply process successful");authenticate(authenticator);// third , try to join the serviceCredential authenticatedCredential =joinMembershipService(authenticator,newGroup);// All is fine ! We can switch to the new groupactiveGroup = newGroup;           LOG.debug("JOIN SUCCESSFUL !");return authenticatedCredential;}/*** This code demonstrates how to apply to a membership service.*/private Authenticator applyToMembershipService(PeerGroup peerGroup,StructuredDocument credentials,String authenticationMethod)throws GroupManagerAuthenticationException,ProtocolNotSupportedException{Authenticator authenticator = null;// Here we create an authentication credential and // try to apply for a Authenticator.An exception is thrown in case// this step fails.try {AuthenticationCredential authenticationCredential =new AuthenticationCredential(peerGroup,authenticationMethod,credentials );MembershipService membership = (MembershipService) peerGroup.getMembershipService();authenticator = (Authenticator)membership.apply( authenticationCredential );} catch( PeerGroupException peerGroupException ) {// This denotes a failure in the Apply process.We// consider this as an Authentication exception.LOG.error("Apply process failed !! ",peerGroupException);throw new GroupManagerAuthenticationException(peerGroupException.getMessage());} catch (ProtocolNotSupportedException protocolNotSupportedException){LOG.error(protocolNotSupportedException);throw protocolNotSupportedException;  }return authenticator;                                        }/** * This method will help the user to actually "fill up" the authenticator* details. It will display a dialog and enable the user to visually * provide details to each parameter of the Authenticator.The parameters* of the Authenticator are found by Introspection.*/private void authenticate( Authenticator authenticator ){// The following bean looks for standard bean parameters to create the// contents to set the authenticator. There is no real spec so this// will have to do.AuthenticatorBean viewBean = new AuthenticatorBean(null,true,authenticator,"Please Enter Required Group Info");viewBean.setVisible(true);}/*** This code demonstrates how to join a membership service.*/private Credential joinMembershipService(Authenticator authenticator,PeerGroup peerGroup)throws GroupManagerAuthenticationException {Credential authenticatedCredential = null;                                    // We check if the user is authenticif( !authenticator.isReadyForJoin() ) {LOG.error( "Authenticator is not ready to join");throw new GroupManagerAuthenticationException("Authenticator is not ready to join !");}// Since the user is authentic , we allow the // user to join the service.But the service may reject the// user as well.try{MembershipService membership = (MembershipService) peerGroup.getMembershipService();authenticatedCredential= membership.join(authenticator);} catch(PeerGroupException peerGroupException) {LOG.error( "Error in the Join Process",peerGroupException);throw new GroupManagerAuthenticationException("Error in the Join Process");}return authenticatedCredential;                                                     }/*** Method used to quit the current active group.*/public void leaveGroup(){MembershipService memberShipService = activeGroup.getMembershipService();try{memberShipService.resign();    } catch(PeerGroupException peerGroupException){LOG.error("Exception in resign",peerGroupException);throw new GroupManagerException(peerGroupException.getMessage());}activeGroup = parent;purgeGroups();}/** The method to renew the membership to the currently active group. */public void renew(Credential credential){// ??? Seems that the implementation does not have a concept of renewal
    }/*** Purge all groups from the cache. This help prevent us from creating* a copy of a group with the same ID.**/public void purgeGroups(){DiscoveryService discovery = parent.getDiscoveryService();try{discovery.flushAdvertisements(null,DiscoveryService.GROUP);} catch (java.io.IOException ioException) {LOG.error("Error in purging Groups",ioException);throw new GroupManagerException(ioException.getMessage());}}/*** Creates an ModuleImplAdvertisement which in this context is a * MembershipService.* */private ModuleImplAdvertisement mkImplAdvBuiltin(net.jxta.platform.ModuleSpecID specID,String code,String descr) {String moduleImplAdvType = ModuleImplAdvertisement.getAdvertisementType();ModuleImplAdvertisement implAdvertisement = (ModuleImplAdvertisement)AdvertisementFactory.newAdvertisement(moduleImplAdvType);implAdvertisement.setModuleSpecID(specID);implAdvertisement.setCompat(stdCompatStatement);implAdvertisement.setCode(code);implAdvertisement.setUri(stdUri);implAdvertisement.setProvider(stdProvider);implAdvertisement.setDescription(descr);return implAdvertisement;}/*** Creates a compatibility segment for a ModuleImplAdvertisement.* This is needed so that our parent group can load modules of the * reference implementation also.*///??? Taken from StdPeerGroup because it was private. This should have //* been in a utility class.protected StructuredTextDocument mkCS() {StructuredTextDocument doc = (StructuredTextDocument)net.jxta.document.StructuredDocumentFactory.newStructuredDocument(new net.jxta.document.MimeMediaType(DOCUMENT_MIME_TYPE,DOCUMENT_BASE_TYPE),DOCUMENT_ROOT_ELEMENT);net.jxta.document.Element e = doc.createElement(KEY, VALUE);doc.appendChild(e);e = doc.createElement(BINDING_KEY, BINDING_VALUE);doc.appendChild(e);return doc;}/*** This method is used for refreshing the peer with remotely published advertisements.* //???Makes little sense without a listener.Moreover the method is deprecated*/public void refreshGroups(){//disco.getRemoteAdvertisements(null, DiscoveryService.GROUP, null, null,100);
    }/** Method used to get the currently active group.*/public PeerGroup getActiveGroup(){return activeGroup;           }
}

package com.sams.jxta.groups.student;import net.jxta.membership.MembershipService;
import net.jxta.membership.Authenticator;
import net.jxta.credential.Credential;
import net.jxta.credential.AuthenticationCredential;
import net.jxta.exception.PeerGroupException;
import net.jxta.exception.ProtocolNotSupportedException;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Element;
import net.jxta.document.Advertisement;
import net.jxta.id.ID;
import net.jxta.impl.membership.passwd.PasswdMembershipService;
import net.jxta.peergroup.PeerGroup;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.service.Service;
import net.jxta.document.StructuredDocument;import java.util.Vector;import java.util.Enumeration;/** A Membership Service designed to represent the Admission Process in a Univeristy.*/public class UniversityAdmissionsService extends PasswdMembershipService{public UniversityAdmissionsService() throws PeerGroupException {super();}private static final org.apache.log4j.Category LOG = org.apache.log4j.Category.getInstance(UniversityAdmissionsService.class.getName());private PeerGroup peerGroup;private ModuleImplAdvertisement implAdv;private ID assignedID;private Vector    invitationLetters          = new Vector();private Vector    authenticationCredentials = new Vector();/** This method is called during an apply process.*/public Authenticator apply( AuthenticationCredential unsubscribedCredential )throws PeerGroupException, ProtocolNotSupportedException{String method = unsubscribedCredential.getMethod();if( (null != method) && !"PreApplication".equals( method ) )throw new ProtocolNotSupportedException("Authentication method not recognized : Required /"PreApplication/" ");StructuredDocument preApForm = (StructuredDocument)unsubscribedCredential.getIdentityInfo();Enumeration enums = preApForm.getChildren();Element element = (Element) enums.nextElement();String departmentAppliedFor =(String) element.getValue();// Vacancies exist only in the Computer Science Departmentif(!departmentAppliedFor.equals(PreApplicationForm.DEPARTMENT_COMPUTER_SCIENCE))throw new PeerGroupException("No Admissions to this Department(code:"+departmentAppliedFor+")");ApplicationForm applicationForm = new ApplicationForm(this,unsubscribedCredential);        return applicationForm;}         /** This method is called when the peer is interested in joining the peer group.*/public Credential join(Authenticator authenticated )throws PeerGroupException{ApplicationForm applicationForm   = (ApplicationForm)authenticated;// We double check that the Authentiction is indeed successfulif(!applicationForm.isReadyForJoin())throw new PeerGroupException("Application Form rejected !!");            // this means that the person can be taken in InvitationLetter invitationLetter = new InvitationLetter(this);invitationLetters.addElement(invitationLetter);authenticationCredentials.addElement(authenticated.getAuthenticationCredential());return invitationLetter;}/** This method is called when the peer leaves the group.* Here we destroy all previous records of Authentication* Credentials and Credentials*/public void resign(){//Destory all records invitationLetters          = new Vector();authenticationCredentials = new Vector();}/** Returns all the Credentials for this peer */public Enumeration getCurrentCredentials(){return invitationLetters.elements();}/** Returns all the Authentication Credentials for this peer */public Enumeration getAuthCredentials(){return authenticationCredentials.elements();}/** Returns the ModuleImplAdvertisement*/public Advertisement getImplAdvertisement(){return implAdv;}/** This method is called when the module is initialized.*/public void init(PeerGroup peerGroup,ID assignedID,Advertisement implAdv)throws PeerGroupException{this.peerGroup = peerGroup;this.assignedID=assignedID;this.implAdv=(ModuleImplAdvertisement)implAdv;}/** Getter method for the peer group*/public PeerGroup getPeerGroup(){return peerGroup;}/** Getter for the Interface.For the sake of simplicity ,* this object acts as it's own interface.*/public Service getInterface() {return this;}/** Methods to be implemented by virtue of being a module.* Not used in this example */public int startApp(String[] args){return 0;}public void stopApp(){}/** This method is currently not supported .//??? Is this OK ?*/public Credential makeCredential( Element element )throws PeerGroupException, Exception{return null;}}

package com.sams.jxta.groups.student;import net.jxta.document.Element;
import net.jxta.document.MimeMediaType;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredDocumentFactory;/** A Pre Application Form is used as an identity info in the * Authentication Credential.* */public abstract class PreApplicationForm {public static final String DEPARTMENT_COMPUTER_SCIENCE = "CS";public static final String DEPARTMENT_MANAGEMENT       = "MT";public static final String DEPARTMENT_ARCHITECTURE     = "AT";/** This methods creates a Structured Document representing the PreApp form.* This serves as an IdentityInfo in the authentication credential.*/public static final StructuredDocument createPreAppForm(String department){MimeMediaType type = new MimeMediaType("text","xml");StructuredDocument doc =StructuredDocumentFactory.newStructuredDocument( type,"PreAppForm" );Element e = doc.createElement( "Department",department); doc.appendChild( e );return doc;}
}

package com.sams.jxta.groups.student;import net.jxta.credential.Credential;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.peer.PeerID;
import net.jxta.service.Service;
import net.jxta.id.ID;
import net.jxta.membership.MembershipService;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.MimeMediaType;
import net.jxta.document.Element;/** This class represents a Credential that is supplied to a* peer after a successful apply process.*/
public class InvitationLetter implements Credential {// Reference to the Membership Serviceprivate UniversityAdmissionsService admissionsService;/** Constructor which takes a Membership Service Object*/public InvitationLetter(UniversityAdmissionsService admissionsService){this.admissionsService = admissionsService;}/** Getter for the Membership Service*/public Service  getSourceService(){return admissionsService;}/** This method returns the PeerGroup ID*/public ID getPeerGroupID(){return admissionsService.getPeerGroup().getPeerGroupID();}/** This method returns the Peer ID*/public ID getPeerID(){return admissionsService.getPeerGroup().getPeerID();}/** This method returns a Structured Document representing the Credential*/public StructuredDocument getDocument(MimeMediaType as) throws Exception {StructuredDocument doc =StructuredDocumentFactory.newStructuredDocument( as,"InivtationLetter" );Element e = doc.createElement( "PeerGroupID", admissionsService.getPeerGroup().getPeerGroupID() );doc.appendChild( e );e = doc.createElement("TimeOfRequest",""+System.currentTimeMillis());doc.appendChild( e );return doc;}public Object getSubject() {return null;}public boolean isExpired() {return false;}public boolean isValid() {return false;}
}

package com.sams.jxta.groups.student;import net.jxta.membership.Authenticator;
import net.jxta.membership.MembershipService;
import net.jxta.credential.AuthenticationCredential;/** An Application Form represents an Authenticator.* */
public class ApplicationForm implements Authenticator{private String studentName;private float GPA;private UniversityAdmissionsService admissionsService;private AuthenticationCredential unsubscribedCredential;    /** Constructor*/public ApplicationForm(UniversityAdmissionsService admissionsService,AuthenticationCredential unsubscribedCredential){this.admissionsService      = admissionsService;this.unsubscribedCredential = unsubscribedCredential;}/** Returns a String representing the method Name*/public String getMethodName(){return "ApplicationForm";}/** Returns the Authentication Credential*/public AuthenticationCredential getAuthenticationCredential(){return unsubscribedCredential;}/** Returns the Source Membership Service*/public MembershipService  getSourceService(){return admissionsService;}/** This method checks if the Application Form is authenticated properly* Only if the form is "filled" properly , can the peer join the Membership* Service. Here we consider an Application Form as ready to join if * the GPA is greater than 3.0 and a "non blank" name has been provided.* */public boolean  isReadyForJoin(){if(studentName == null || studentName.trim().equals(""))return false;                    if(GPA >3.0f)return true;elsereturn false;}/** Setter for the GPA*/public void setGPA(float GPA){this.GPA = GPA;}/** Setter for the Student Name*/public void setStudentName(String studentName){this.studentName=studentName;}
}

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URI;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import net.jxta.credential.AuthenticationCredential;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.Element;
import net.jxta.document.MimeMediaType;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.StructuredTextDocument;
import net.jxta.document.TextElement;
import net.jxta.exception.PeerGroupException;
import net.jxta.id.ID;
import net.jxta.id.IDFactory;
import net.jxta.impl.membership.PasswdMembershipService;
import net.jxta.membership.Authenticator;
import net.jxta.membership.MembershipService;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.platform.ModuleSpecID;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.protocol.PeerGroupAdvertisement;
import net.jxta.impl.peergroup.StdPeerGroupParamAdv;public class PrivatePeerGroup {private PeerGroup myNetPeerGroup = null, satellaPeerGroup = null,discoveredSatellaPeerGroup = null;private final static PeerGroupID satellaPeerGroupID = PeerGroupID.create(URI.create("jxta:uuid-4d6172676572696e204272756e6f202002"));/** Creates new RootWS */public PrivatePeerGroup() {// Starts the JXTA PlatformmyNetPeerGroup = this.startJxta();if (myNetPeerGroup != null) {System.out.println("JXTA platform Started ...");} else {System.err.println("Failed to start JXTA : myNetPeerGroup is null");System.exit(1);}// Generate the parameters:// login, passwd, peer group name and peer group id// for creating the Peer GroupString login = "PrivatePeerGroups";String passwd = "RULE";String groupName = "SatellaGroup";// create The Passwd Authenticated Peer GroupsatellaPeerGroup = this.createPeerGroup(myNetPeerGroup, groupName,login, passwd);// join the satellaPeerGroupif (satellaPeerGroup != null) {System.out.println(" Peer Group Created ...");discoveredSatellaPeerGroup = this.discoverPeerGroup(myNetPeerGroup,satellaPeerGroupID);if (discoveredSatellaPeerGroup != null) {System.out.println(" Peer Group Found ...");this.joinPeerGroup(discoveredSatellaPeerGroup, login, passwd);}}System.out.println(" Peer Group Joined ...");// Print the Peer Group Adverstisement on sdt out.this.printXmlAdvertisement("XML Advertisement forPeer Group Advertisement",satellaPeerGroup.getPeerGroupAdvertisement());}private PeerGroup createPeerGroup(PeerGroup rootPeerGroup,String groupName, String login, String passwd) {// create the Peer Group by doing the following:// - Create a Peer Group Module Implementation Advertisement and publish// it// - Create a Peer Group Adv and publish it// - Create a Peer Group from the Peer Group Adv and return this objectPeerGroup satellaPeerGroup = null;PeerGroupAdvertisement satellaPeerGroupAdvertisement;// Create the PeerGroup Module Implementation Adv
        ModuleImplAdvertisement passwdMembershipModuleImplAdv;passwdMembershipModuleImplAdv = this.createPasswdMembershipPeerGroupModuleImplAdv(rootPeerGroup);// Publish it in the parent peer groupDiscoveryService rootPeerGroupDiscoveryService = rootPeerGroup.getDiscoveryService();try {rootPeerGroupDiscoveryService.publish(passwdMembershipModuleImplAdv, PeerGroup.DEFAULT_LIFETIME,PeerGroup.DEFAULT_EXPIRATION);rootPeerGroupDiscoveryService.remotePublish(passwdMembershipModuleImplAdv,PeerGroup.DEFAULT_EXPIRATION);} catch (java.io.IOException e) {System.err.println("Can't Publish passwdMembershipModuleImplAdv");System.exit(1);}// Now, Create the Peer Group AdvertisementsatellaPeerGroupAdvertisement = this.createPeerGroupAdvertisement(passwdMembershipModuleImplAdv, groupName, login, passwd);// Publish it in the parent peer grouptry {rootPeerGroupDiscoveryService.publish(satellaPeerGroupAdvertisement, PeerGroup.DEFAULT_LIFETIME,PeerGroup.DEFAULT_EXPIRATION);rootPeerGroupDiscoveryService.remotePublish(satellaPeerGroupAdvertisement,PeerGroup.DEFAULT_EXPIRATION);} catch (java.io.IOException e) {System.err.println("Can't Publish satellaPeerGroupAdvertisement");System.exit(1);}// Finally Create the Peer Groupif (satellaPeerGroupAdvertisement == null) {System.err.println("satellaPeerGroupAdvertisement is null");}try {satellaPeerGroup = rootPeerGroup.newGroup(satellaPeerGroupAdvertisement);} catch (net.jxta.exception.PeerGroupException e) {System.err.println("Can't create Satella Peer Group from Advertisement");e.printStackTrace();return null;}return satellaPeerGroup;}private PeerGroupAdvertisement createPeerGroupAdvertisement(ModuleImplAdvertisement passwdMembershipModuleImplAdv,String groupName, String login, String passwd) {// Create a PeerGroupAdvertisement for the peer groupPeerGroupAdvertisement satellaPeerGroupAdvertisement = (PeerGroupAdvertisement) AdvertisementFactory.newAdvertisement(PeerGroupAdvertisement.getAdvertisementType());// Instead of creating a new group ID each time, by using the// line below// satellaPeerGroupAdvertisement.setPeerGroupID// (IDFactory.newPeerGroupID());// I use a fixed ID so that each time I start PrivatePeerGroup,// it creates the same Group
        satellaPeerGroupAdvertisement.setPeerGroupID(satellaPeerGroupID);satellaPeerGroupAdvertisement.setModuleSpecID(passwdMembershipModuleImplAdv.getModuleSpecID());satellaPeerGroupAdvertisement.setName(groupName);satellaPeerGroupAdvertisement.setDescription("Peer Group using Password Authentication");// Now create the Structured Document Containing the login and// passwd informations. Login and passwd are put into the Param// section of the peer Groupif (login != null) {StructuredTextDocument loginAndPasswd = (StructuredTextDocument) StructuredDocumentFactory.newStructuredDocument(new MimeMediaType("text/xml"),"Parm");String loginAndPasswdString = login + ":"+ PasswdMembershipService.makePsswd(passwd) + ":";TextElement loginElement = loginAndPasswd.createElement("login",loginAndPasswdString);loginAndPasswd.appendChild(loginElement);// All Right, now that loginAndPasswdElement// (The strucuted document// that is the Param Element for The PeerGroup Adv// is done, include it in the Peer Group Advertisement
            satellaPeerGroupAdvertisement.putServiceParam(PeerGroup.membershipClassID, loginAndPasswd);}return satellaPeerGroupAdvertisement;}private ModuleImplAdvertisement createPasswdMembershipPeerGroupModuleImplAdv(PeerGroup rootPeerGroup) {// Create a ModuleImpl Advertisement for the Passwd// Membership Service Take a allPurposePeerGroupImplAdv// ModuleImplAdvertisement parameter to// Clone some of its fields. It is easier than to recreate// everything from scratch// Try to locate where the PasswdMembership is within this// ModuleImplAdvertisement.// For a PeerGroup Module Impl, the list of the services// (including Membership) are located in the Param sectionModuleImplAdvertisement allPurposePeerGroupImplAdv = null;try {allPurposePeerGroupImplAdv = rootPeerGroup.getAllPurposePeerGroupImplAdvertisement();} catch (java.lang.Exception e) {System.err.println("Can't Execute: getAllPurposePeerGroupImplAdvertisement();");System.exit(1);}ModuleImplAdvertisement passwdMembershipPeerGroupModuleImplAdv = allPurposePeerGroupImplAdv;ModuleImplAdvertisement passwdMembershipServiceModuleImplAdv = null;StdPeerGroupParamAdv passwdMembershipPeerGroupParamAdv = null;passwdMembershipPeerGroupParamAdv = new StdPeerGroupParamAdv(allPurposePeerGroupImplAdv.getParam());Hashtable allPurposePeerGroupServicesHashtable = (Hashtable) passwdMembershipPeerGroupParamAdv.getServices();Enumeration allPurposePeerGroupServicesEnumeration = allPurposePeerGroupServicesHashtable.keys();boolean membershipServiceFound = false;while ((!membershipServiceFound)&& (allPurposePeerGroupServicesEnumeration.hasMoreElements())) {Object allPurposePeerGroupServiceID = allPurposePeerGroupServicesEnumeration.nextElement();if (allPurposePeerGroupServiceID.equals(PeerGroup.membershipClassID)) {// allPurposePeerGroupMemershipServiceModuleImplAdv is// the all Purpose Mermbership Service for the all// purpose Peer Group Module Impl advModuleImplAdvertisement allPurposePeerGroupMemershipServiceModuleImplAdv = (ModuleImplAdvertisement) allPurposePeerGroupServicesHashtable.get(allPurposePeerGroupServiceID);// Create the passwdMembershipServiceModuleImplAdvpasswdMembershipServiceModuleImplAdv = this.createPasswdMembershipServiceModuleImplAdv(allPurposePeerGroupMemershipServiceModuleImplAdv);// Remove the All purpose Membership Service implementation
                allPurposePeerGroupServicesHashtable.remove(allPurposePeerGroupServiceID);// And Replace it by the Passwd Membership Service// Implementation
                allPurposePeerGroupServicesHashtable.put(PeerGroup.membershipClassID,passwdMembershipServiceModuleImplAdv);membershipServiceFound = true;// Now the Service Advertisements are complete. Let's// update the passwdMembershipPeerGroupModuleImplAdv by// Updating its param
                passwdMembershipPeerGroupModuleImplAdv.setParam((Element) passwdMembershipPeerGroupParamAdv.getDocument(MimeMediaType.XMLUTF8));// Update its Spec ID This comes from the// Instant P2P PeerGroupManager Code (Thanks !!!!)if (!passwdMembershipPeerGroupModuleImplAdv.getModuleSpecID().equals(PeerGroup.allPurposePeerGroupSpecID)) {passwdMembershipPeerGroupModuleImplAdv.setModuleSpecID(IDFactory.newModuleSpecID(passwdMembershipPeerGroupModuleImplAdv.getModuleSpecID().getBaseClass()));} else {ID passwdGrpModSpecID = ID.create(URI.create("urn"+ "jxta:uuid-" + "DeadBeefDeafBabaFeedBabe00000001"+ "04" + "06"));passwdMembershipPeerGroupModuleImplAdv.setModuleSpecID((ModuleSpecID) passwdGrpModSpecID);} // End ElsemembershipServiceFound = true;} // end if (allPurposePeerGroupServiceID.// equals(PeerGroup.membershipClassID))}// end Whilereturn passwdMembershipPeerGroupModuleImplAdv;}private ModuleImplAdvertisement createPasswdMembershipServiceModuleImplAdv(ModuleImplAdvertisement allPurposePeerGroupMemershipServiceModuleImplAdv) {// Create a new ModuleImplAdvertisement for the// Membership ServiceModuleImplAdvertisement passwdMembershipServiceModuleImplAdv = (ModuleImplAdvertisement) AdvertisementFactory.newAdvertisement(ModuleImplAdvertisement.getAdvertisementType());passwdMembershipServiceModuleImplAdv.setModuleSpecID(PasswdMembershipService.passwordMembershipSpecID);passwdMembershipServiceModuleImplAdv.setCode(PasswdMembershipService.class.getName());passwdMembershipServiceModuleImplAdv.setDescription(" Module Impl Advertisement for the PasswdMembership Service");passwdMembershipServiceModuleImplAdv.setCompat(allPurposePeerGroupMemershipServiceModuleImplAdv.getCompat());passwdMembershipServiceModuleImplAdv.setUri(allPurposePeerGroupMemershipServiceModuleImplAdv.getUri());passwdMembershipServiceModuleImplAdv.setProvider(allPurposePeerGroupMemershipServiceModuleImplAdv.getProvider());return passwdMembershipServiceModuleImplAdv;}private PeerGroup discoverPeerGroup(PeerGroup myNetPeerGroup,PeerGroupID satellaPeerGroupID) {// First discover the peer group// In most cases we should use discovery listeners so that// we can do the discovery asynchroneously.// Here I won't, for increased simplicity and because// The Peer Group Advertisement is in the local cache for// sure
        PeerGroup satellaPeerGroup;DiscoveryService myNetPeerGroupDiscoveryService = null;if (myNetPeerGroup != null) {myNetPeerGroupDiscoveryService = myNetPeerGroup.getDiscoveryService();} else {System.err.println("Can't join Peer Group since it's parent is null");System.exit(1);}boolean isGroupFound = false;Enumeration localPeerGroupAdvertisementEnumeration = null;PeerGroupAdvertisement satellaPeerGroupAdvertisement = null;while (!isGroupFound) {try {localPeerGroupAdvertisementEnumeration = myNetPeerGroupDiscoveryService.getLocalAdvertisements(DiscoveryService.GROUP, "GID",satellaPeerGroupID.toString());} catch (java.io.IOException e) {System.out.println("Can't Discover Local Adv");}if (localPeerGroupAdvertisementEnumeration != null) {while (localPeerGroupAdvertisementEnumeration.hasMoreElements()) {PeerGroupAdvertisement pgAdv = null;pgAdv = (PeerGroupAdvertisement) localPeerGroupAdvertisementEnumeration.nextElement();if (pgAdv.getPeerGroupID().equals(satellaPeerGroupID)) {satellaPeerGroupAdvertisement = pgAdv;isGroupFound = true;break;}}}try {Thread.sleep(5 * 1000);} catch (Exception e) {}}try {satellaPeerGroup = myNetPeerGroup.newGroup(satellaPeerGroupAdvertisement);} catch (net.jxta.exception.PeerGroupException e) {System.err.println("Can't create Peer Group from Advertisement");e.printStackTrace();return null;}return satellaPeerGroup;}private void joinPeerGroup(PeerGroup satellaPeerGroup, String login,String passwd) {// Get the Heavy Weight Paper for the resume// Alias define the type of credential to be providedStructuredDocument creds = null;try {// Create the resume to apply for the Job// Alias generate the credentials for the Peer GroupAuthenticationCredential authCred = new AuthenticationCredential(satellaPeerGroup, null, creds);// Create the resume to apply for the Job// Alias generate the credentials for the Peer GroupMembershipService membershipService = satellaPeerGroup.getMembershipService();// Send the resume and get the Job application form// Alias get the Authenticator from the Authentication credsAuthenticator auth = membershipService.apply(authCred);// Fill in the Job Application Form// Alias complete the authentication
            completeAuth(auth, login, passwd);// Check if I got the Job// Alias Check if the authentication that was submitted was// accepted.if (!auth.isReadyForJoin()) {System.out.println("Failure in authentication.");System.out.println("Group was not joined. Does not know how to complete authenticator");}// I got the Job, Join the company// Alias I the authentication I completed was accepted,// therefore join the Peer Group accepted.
            membershipService.join(auth);} catch (Exception e) {System.out.println("Failure in authentication.");System.out.println("Group was not joined. Login was incorrect.");e.printStackTrace();}}private void completeAuth(Authenticator auth, String login, String passwd)throws Exception {Method[] methods = auth.getClass().getMethods();Vector authMethods = new Vector();// Find out with fields of the application needs to be// filled// Alias Go through the methods of the Authenticator// class and// copy them sorted by name into a vector.for (int eachMethod = 0; eachMethod < methods.length; eachMethod++) {if (methods[eachMethod].getName().startsWith("setAuth")) {if (Modifier.isPublic(methods[eachMethod].getModifiers())) {// sorted insertion.for (int doInsert = 0; doInsert <= authMethods.size(); doInsert++) {int insertHere = -1;if (doInsert == authMethods.size())insertHere = doInsert;else {if (methods[eachMethod].getName().compareTo(((Method) authMethods.elementAt(doInsert)).getName()) <= 0)insertHere = doInsert;} // end elseif (-1 != insertHere) {authMethods.insertElementAt(methods[eachMethod],insertHere);break;} // end if ( -1 != insertHere)} // end for (int doInsert=0} // end if (modifier.isPublic} // end if (methods[eachMethod]} // end for (int eachMethod)Object[] AuthId = { login };Object[] AuthPasswd = { passwd };for (int eachAuthMethod = 0; eachAuthMethod < authMethods.size(); eachAuthMethod++) {Method doingMethod = (Method) authMethods.elementAt(eachAuthMethod);String authStepName = doingMethod.getName().substring(7);if (doingMethod.getName().equals("setAuth1Identity")) {// Found identity Method, providing identity
                doingMethod.invoke(auth, AuthId);} else if (doingMethod.getName().equals("setAuth2_Password")) {// Found Passwd Method, providing passwd
                doingMethod.invoke(auth, AuthPasswd);}}}private void printXmlAdvertisement(String title, Advertisement adv) {// First, Let's print a "nice" TitleString separator = "";for (int i = 0; i < title.length() + 4; i++) {separator = separator + "-";}System.out.println(separator);System.out.println("| " + title + " |");System.out.println(separator);// Now let's print the Advertisement
        System.out.println(adv.toString());// Let's end up with a line
        System.out.println(separator);}/** Starts the jxta platform */private PeerGroup startJxta() {PeerGroup myNetPeerGroup = null;try {myNetPeerGroup = PeerGroupFactory.newNetPeerGroup();} catch (PeerGroupException e) {// could not instantiate the group, print the stack// and exitSystem.out.println("fatal error : group creation failure");e.printStackTrace();System.exit(1);}return myNetPeerGroup;}public static void main(String args[]) {PrivatePeerGroup satellaRoot = new PrivatePeerGroup();System.exit(0);}
}