Ellipse Tutorial

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
 48 
 49 
 50 
 51 
 52 
 53 
 54 
 55 
 56 
 57 
 58 
 59 
 60 
 61 

package corelib.security;

/**
 * <p>
 *     This interface defines methods for access to a security service. A security
 *     service must provide two mechanisms: authentication and permissions management.
 *     Authentication consist to identify a user and enable him (or not) connecting
 *     to the considered system. The management of permissions allows, once the user
 *     authenticated, him to have an access (or not) to resources.
 * </p>
 * 
 * <p>
 *     In the current version of the Ellipse framework, only authentication is supported.
 *     But a future version of the framework will add the concepts of permissions. The
 *     Ellipse framework provides the JdbcSecurityManager class : this is, of course,
 *     an implementation of this interface that use a relational database to store
 *     the security informations.
 * </p>
 * 
 * @see corelib.security.JdbcSecurityManager
 * @see corelib.security.RoleManager
 * @see corelib.security.UserManager
 * 
 * @author Dominique Liard
 * @since 0.3.6
 */
public interface SecurityManager {

    /**
     * Open a session to the considered security service.
     * 
     * @throws SecurityManagerException    Thrown when connection to the security
     *            service cannot be established.
     */
    public void openSession() throws SecurityManagerException;
    
    /**
     * Close the session with the considered security service.
     * 
     * @throws SecurityManagerException    Thrown when connection to the security
     *         service cannot be closed.
     */
    public void closeSession() throws SecurityManagerException;
    
    /**
     * Returns the role manager associated to this security manager. 
     * A role manager provided methods to manage roles.
     * 
     * @return The role manager associated to this security manager. 
     */
    public RoleManager getRoleManager();
    
    /**
     * Returns the user manager associated to this security manager.
     * A user manager provided methods to manage users.
     * 
     * @return The user manager associated to this security manager. 
     */
    public UserManager getUserManager();    
    
}

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
 48 
 49 
 50 
 51 
 52 
 53 
 54 
 55 
 56 
 57 
 58 
 59 
 60 
 61 
 62 
 63 
 64 
 65 
 66 
 67 
 68 
 69 
 70 
 71 
 72 
 73 
 74 
 75 
 76 
 77 

package corelib.security;

/**
 * This interface defines the methods used to manage User instances.
 * To can get a UserManager instance by asking it at your SecurityManager.
 * 
 * @see corelib.security.SecurityManager
 * @see corelib.security.JdbcSecurityManager
 * @see corelib.security.User
 * 
 * @author Dominique Liard
 * @since 0.3.6
 */
public interface UserManager {

    /**
     * Check if the pair login/password represents an autorized user for the considered
     * application. If the identity is rejected, an exception will thrown. If the
     * identity is accepted, the connection number of the considered user is increased.
     * 
     * @param userLogin     The login for the considered user.
     * @param userPassword  The password for the considered user.
     * @return              The considered user instance.
     * 
     * @throws BadCredientialsException   Thrown if the identity is rejected.
     */
    public User checkCredentials( String userLogin, String userPassword ) throws BadCredientialsException;
    
    /**
     * Insert a new user in the security system. The new used has the specified
     * login and the specified password.
     * 
     * @param login         The login for the considered user.
     * @param password      The password for the considered user. The specified password
     *                      is automaticly encoded by this method.
     * @return              The new user instance.
     * 
     * @exception SecurityManagerException
     *            Thrown if the new user cannot be inserted in the security system. 
     * @exception UserAlreadyRegisteredException
     *            Thrown if the specified login is already registered in the security system.
     */
    public User insertUser( String login, String password ) throws SecurityManagerException ;
    
    /**
     * Update informations, in the security system, for the specified user.
     * 
     * @param user  The user instance to update.
     * 
     * @throws SecurityManagerException
     *         Thrown if this manager cannot update the user informations.
     */
    public void updateUser( User user ) throws SecurityManagerException ;
    
    /**
     * Delete the specified user from the security system.
     * 
     * @param user    The user to delete.
     * 
     * @throws SecurityManagerException
     *         Thrown if this manager cannot remove the user.
     */
    public void deleteUser( User user ) throws SecurityManagerException ;
    
    /** 
     * Defines the algorithm used for encode password. User password is stored in 
     * encoded format.
     * 
     * @param clearPassword       A password (in clear).
     * @return                    The encoded password.
     * 
     * @throws SecurityManagerException
     *         Thrown if password encription failed.
     */
    public String encryptPassword( String clearPassword ) throws SecurityManagerException;
    
}

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
 48 
 49 
 50 
 51 
 52 
 53 
 54 
 55 
 56 
 57 
 58 
 59 
 60 
 61 
 62 
 63 
 64 
 65 
 66 
 67 
 68 
 69 
 70 

package corelib.security;

/**
 * This interface defines the methods used to manage Role instances.
 * To can get a RoleManager instance by asking it at your SecurityManager.
 * 
 * @see corelib.security.SecurityManager
 * @see corelib.security.JdbcSecurityManager
 * @see corelib.security.Role
 * 
 * @author Dominique Liard
 * @since 0.3.6
 */
public interface RoleManager {

    /**
     * Select the role with the identifier specified in parameter.
     * 
     * @param roleIdentifier    The identifier of the role to returns. 
     * @return                    The selected role.
     * 
     * @exception SecurityManagerException
     *         Thrown if the searched role don't exists.
     */
    public Role selectRoleById( int roleIdentifier ) throws SecurityManagerException ;
    
    /**
     * Select the role with the name specified in parameter.
     * 
     * @param roleName        The name of the role to returns.
     * @return                 The selected role.
     * 
     * @exception SecurityManagerException
     *         Thrown if the searched role don't exists.
     */
    public Role selectRoleByName( String roleName ) throws SecurityManagerException ;
    
    /**
     * Insert a new role into the used security system.
     * 
     * @param roleName        The name of the new role.
     * @return                The new role.
     * 
     * @exception SecurityManagerException
     *         Thrown if the role cannot be inserted into the security system. 
     * @exception RoleAlreadyRegisteredException
     *         Thrown if the specified role name already exists in the security system.
     */
    public Role insertRole( String roleName ) throws SecurityManagerException ;
    
    /**
     * Update the informations for this role (actually, only the role name).
     * 
     * @param role    The role to update.
     * 
     * @exception SecurityManagerException
     *         Thrown if the role cannot be updated into the security system.
     */
    public void updateRole( Role role ) throws SecurityManagerException ;
    
    /**
     * Delete, on the security system, the specified role.
     * 
     * @param role    The role to delete.
     * @exception SecurityManagerException
     *         Thrown if the specified role cannot be deleted from the seciry system.
     */
    public void deleteRole( Role role ) throws SecurityManagerException ;

}

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
 48 
 49 
 50 
 51 
 52 
 53 
 54 
 55 
 56 
 57 
 58 
 59 
 60 
 61 
 62 
 63 
 64 
 65 
 66 
 67 
 68 
 69 
 70 
 71 
 72 
 73 
 74 
 75 
 76 
 77 
 78 
 79 
 80 
 81 
 82 
 83 
 84 
 85 
 86 
 87 
 88 
 89 
 90 
 91 
 92 
 93 
 94 
 95 
 96 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import corelib.security.JdbcSecurityManager;
import corelib.security.Role;
import corelib.security.RoleManager;
import corelib.security.SecurityManagerException;
import corelib.security.User;
import corelib.security.UserManager;
import corelib.utilities.jdbc.DataSource;


public class SecurityManagerSample {

    private static BufferedReader keyboard = new BufferedReader(
        new InputStreamReader( System.in )
    );
    
    private DataSource dataSource = null;
    private JdbcSecurityManager securityManager = null;
    private UserManager userManager = null;
    private RoleManager roleManager = null;

    
    public SecurityManagerSample() throws SecurityManagerException {
        this.dataSource = new DataSource() {
            @Override public String getUrl() { return "jdbc:mysql://localhost/TheBase"; }
            @Override public String getPassword() { return ""; }
            @Override public String getLogin() { return "root"; }
            @Override public String getDriver() { return "com.mysql.jdbc.Driver"; }
        };
        this.securityManager = new JdbcSecurityManager( this.dataSource );
        this.userManager = this.securityManager.getUserManager();
        this.roleManager = this.securityManager.getRoleManager();
    }
    
    public void init() throws SecurityManagerException {
        Role adminRole = this.roleManager.insertRole( "Administrator" );
        Role userRole = this.roleManager.insertRole( "Simple User" );
        
        User root = this.userManager.insertUser( "root", "azerty" );
        root.addRole( adminRole );
        root.addRole( userRole );
        this.userManager.updateUser( root );
        
        User toto = this.userManager.insertUser( "toto", "qwerty" );
        toto.addRole( userRole );
        this.userManager.updateUser( toto );
    }    
    
    public void run() throws SecurityManagerException, IOException {
        System.out.println( "Secure system: logon is required." );
        
        while( true ) {
            System.out.print( "Login: " );
            String strLogin = keyboard.readLine();
            
            System.out.print( "Password: " );
            String strPassword = keyboard.readLine();
            
            try {
                User user = this.userManager.checkCredentials( strLogin, strPassword );
                System.out.println( "Welcome " + user.getLogin() );
                break;
            } catch( Exception exception ) {
                System.out.println( "Login failed, please retry" );
            }
        }

        System.out.println( "Bye" );
    }
    
    public void destroy() throws SecurityManagerException {
        this.userManager.deleteUser(
            this.userManager.checkCredentials( "root", "azerty" ) );
        this.userManager.deleteUser(
            this.userManager.checkCredentials( "toto", "qwerty" ) );
        
        this.roleManager.deleteRole( 
            this.roleManager.selectRoleByName( "Administrator" ) );
        this.roleManager.deleteRole( 
                this.roleManager.selectRoleByName( "Simple User" ) );
    }
    
    public static void main( String[] args ) throws Exception {
        SecurityManagerSample sample = new SecurityManagerSample();
        try {
            sample.init();
            sample.run();
        } finally {
            sample.destroy();
        }
    }
    
}