groupmanager.java~

Java p2p程序设计2002年版

         //}
      } 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;           
    }
}