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 group

    protected PeerGroup parent;

    // Net peer for creating advertisements.

    protected PeerGroup netPeerGroup;

    // The current peer group

    protected 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 example

    public static final String DOCUMENT_MIME_TYPE="text";

    // The base type of all documents

    public static final String DOCUMENT_BASE_TYPE="xml";

    // This is the root element documents created

    public 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 binding

    private 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 platform

                StructuredDocument paramDoc = advertisement.getParam();

                System.out.println("StructuredDocument paramDoc:"+paramDoc);

                // The Param document used to make the StandradPeerGroup Advertisement

                StdPeerGroupParamAdv paramAdv = new StdPeerGroupParamAdv(paramDoc);

                // List of all the available standard services

                Map services = paramAdv.getServices();

                // Make a ModuleImplAdvertisemnet for the membership service

                ModuleImplAdvertisement 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 command

        LOG.debug("Creating the Peer Group");

        PeerGroup peerGroup = null;

        try {

            // create a PeerGroup ID

            PeerGroupID peerGroupID = null;

            if(oldPeerGroupID != null){

                peerGroupID = oldPeerGroupID;

            }else{

                peerGroupID = IDFactory.newPeerGroupID();

            }

            // create the PeerGroup

            peerGroup = parent.newGroup(peerGroupID, advertisement, groupName, groupDescription);////

            // initialize the peergroup

            peerGroup.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 advertisement

        LOG.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();

        else

            return 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 dialog

        LOG.debug("Apply process successful");

        authenticate(authenticator);

        // third , try to join the service

        Credential authenticatedCredential =joinMembershipService(authenticator,newGroup);

        // All is fine ! We can switch to the new group

        activeGroup = 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 authentic

        if( !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 Department

        if(!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 successful

        if(!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 Service

    private 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;

     else

      return 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 Platform

        myNetPeerGroup = 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 Group

        String login = "PrivatePeerGroups";

        String passwd = "RULE";

        String groupName = "SatellaGroup";

        // create The Passwd Authenticated Peer Group

        satellaPeerGroup = this.createPeerGroup(myNetPeerGroup, groupName,

                login, passwd);

        // join the satellaPeerGroup

        if (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 object

        PeerGroup satellaPeerGroup = null;

        PeerGroupAdvertisement satellaPeerGroupAdvertisement;

        // Create the PeerGroup Module Implementation Adv

        ModuleImplAdvertisement passwdMembershipModuleImplAdv;

        passwdMembershipModuleImplAdv = this

                .createPasswdMembershipPeerGroupModuleImplAdv(rootPeerGroup);

        // Publish it in the parent peer group

        DiscoveryService 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 Advertisement

        satellaPeerGroupAdvertisement = this.createPeerGroupAdvertisement(

                passwdMembershipModuleImplAdv, groupName, login, passwd);

        // Publish it in the parent peer group

        try {

            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 Group

        if (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 group

        PeerGroupAdvertisement 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 Group

        if (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 section

        ModuleImplAdvertisement 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 adv

                ModuleImplAdvertisement allPurposePeerGroupMemershipServiceModuleImplAdv = (ModuleImplAdvertisement) allPurposePeerGroupServicesHashtable

                        .get(allPurposePeerGroupServiceID);

                // Create the passwdMembershipServiceModuleImplAdv

                passwdMembershipServiceModuleImplAdv = 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 Else

                membershipServiceFound = true;

            } // end if (allPurposePeerGroupServiceID.

            // equals(PeerGroup.membershipClassID))

        }// end While

        return passwdMembershipPeerGroupModuleImplAdv;

    }

    private ModuleImplAdvertisement createPasswdMembershipServiceModuleImplAdv(

            ModuleImplAdvertisement allPurposePeerGroupMemershipServiceModuleImplAdv) {

        // Create a new ModuleImplAdvertisement for the

        // Membership Service

        ModuleImplAdvertisement 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 provided

        StructuredDocument creds = null;

        try {

            // Create the resume to apply for the Job

            // Alias generate the credentials for the Peer Group

            AuthenticationCredential authCred = new AuthenticationCredential(

                    satellaPeerGroup, null, creds);

            // Create the resume to apply for the Job

            // Alias generate the credentials for the Peer Group

            MembershipService membershipService = satellaPeerGroup

                    .getMembershipService();

            // Send the resume and get the Job application form

            // Alias get the Authenticator from the Authentication creds

            Authenticator 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 else

                        if (-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" Title

        String 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 exit

            System.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);

    }

}