View Javadoc

    1   package org.apache.turbine.services.security;
    2
    3
    4   /*
    5    * Licensed to the Apache Software Foundation (ASF) under one
    6    * or more contributor license agreements.  See the NOTICE file
    7    * distributed with this work for additional information
    8    * regarding copyright ownership.  The ASF licenses this file
    9    * to you under the Apache License, Version 2.0 (the
    10   * "License"); you may not use this file except in compliance
    11   * with the License.  You may obtain a copy of the License at
    12   *
    13   *   http://www.apache.org/licenses/LICENSE-2.0
    14   *
    15   * Unless required by applicable law or agreed to in writing,
    16   * software distributed under the License is distributed on an
    17   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    18   * KIND, either express or implied.  See the License for the
    19   * specific language governing permissions and limitations
    20   * under the License.
    21   */
    22
    23
    24  import java.util.ArrayList;
    25  import java.util.List;
    26
    27  import org.apache.commons.configuration.Configuration;
    28  import org.apache.fulcrum.security.acl.AccessControlList;
    29  import org.apache.fulcrum.security.model.turbine.TurbineUserManager;
    30  import org.apache.fulcrum.security.model.turbine.entity.TurbineUser;
    31  import org.apache.fulcrum.security.util.DataBackendException;
    32  import org.apache.fulcrum.security.util.EntityExistsException;
    33  import org.apache.fulcrum.security.util.PasswordMismatchException;
    34  import org.apache.fulcrum.security.util.UnknownEntityException;
    35  import org.apache.fulcrum.security.util.UserSet;
    36  import org.apache.turbine.om.security.DefaultUserImpl;
    37  import org.apache.turbine.om.security.User;
    38  import org.apache.turbine.services.ServiceManager;
    39  import org.apache.turbine.services.TurbineServices;
    40  import org.apache.turbine.util.ObjectUtils;
    41
    42  /**
    43   * Default user manager.
    44   *
    45   * The user manager wraps Fulcrum security user objects into
    46   * Turbine-specific ones.
    47   *
    48   * @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
    49   * @version $Id: PassiveUserManager.java 1096130 2011-04-23 10:37:19Z ludwig $
    50   */
    51  public class DefaultUserManager implements UserManager
    52  {
    53      /** Fulcrum user manager instance to delegate to */
    54      private TurbineUserManager umDelegate = null;
    55
    56      /**
    57       * Wrap a Fulcrum user object into a Turbine user object
    58       *
    59       * @param user the user object to delegate to
    60       *
    61       * @return the wrapped object
    62       */
    63      protected <U extends User> U wrap(TurbineUser user)
    64      {
    65          @SuppressWarnings("unchecked")
    66          U u = (U)new DefaultUserImpl(user);
    67          return u;
    68      }
    69
    70      /**
    71       * Initializes the UserManager
    72       *
    73       * @param conf A Configuration object to init this Manager
    74       */
    75      @Override
    76      public void init(Configuration conf)
    77      {
    78          ServiceManager manager = TurbineServices.getInstance();
    79          this.umDelegate = (TurbineUserManager)manager.getService(TurbineUserManager.ROLE);
    80      }
    81
    82      /**
    83       * Check whether a specified user's account exists.
    84       *
    85       * The login name is used for looking up the account.
    86       *
    87       * @param user The user to be checked.
    88       * @return true if the specified account exists
    89       * @throws DataBackendException if there was an error accessing the data backend.
    90       */
    91      @Override
    92      public boolean accountExists(User user)
    93              throws DataBackendException
    94      {
    95          return umDelegate.checkExists(user);
    96      }
    97
    98      /**
    99       * Check whether a specified user's account exists.
    100      *
    101      * The login name is used for looking up the account.
    102      *
    103      * @param userName The name of the user to be checked.
    104      * @return true if the specified account exists
    105      * @throws DataBackendException if there was an error accessing the data backend.
    106      */
    107     @Override
    108     public boolean accountExists(String userName)
    109             throws DataBackendException
    110     {
    111         return umDelegate.checkExists(userName);
    112     }
    113
    114     /**
    115      * Retrieve a user from persistent storage using username as the
    116      * key.
    117      *
    118      * @param username the name of the user.
    119      * @return an User object.
    120      * @exception UnknownEntityException if the user's record does not
    121      *            exist in the database.
    122      * @exception DataBackendException if there is a problem accessing the
    123      *            storage.
    124      */
    125     @Override
    126     public <U extends User> U retrieve(String username)
    127             throws UnknownEntityException, DataBackendException
    128     {
    129         TurbineUser u = umDelegate.getUser(username);
    130         return wrap(u);
    131     }
    132
    133     /**
    134      * Retrieve a set of users that meet the specified criteria.
    135      *
    136      * As the keys for the criteria, you should use the constants that
    137      * are defined in {@link User} interface, plus the names
    138      * of the custom attributes you added to your user representation
    139      * in the data storage. Use verbatim names of the attributes -
    140      * without table name prefix in case of DB implementation.
    141      *
    142      * @param criteria The criteria of selection.
    143      * @return a List of users meeting the criteria.
    144      * @throws DataBackendException if there is a problem accessing the
    145      *         storage.
    146      */
    147     @Override
    148     public List<? extends User> retrieveList(Object criteria)
    149             throws DataBackendException
    150     {
    151         UserSet uset = umDelegate.getAllUsers();
    152         List<User> userList = new ArrayList<User>();
    153
    154         for (org.apache.fulcrum.security.entity.User u : uset)
    155         {
    156             TurbineUser tu = (TurbineUser)u;
    157             userList.add(wrap(tu));
    158         }
    159
    160         return userList;
    161     }
    162
    163     /**
    164      * Retrieve a user from persistent storage using username as the
    165      * key, and authenticate the user. The implementation may chose
    166      * to authenticate to the server as the user whose data is being
    167      * retrieved.
    168      *
    169      * @param username the name of the user.
    170      * @param password the user supplied password.
    171      * @return an User object.
    172      * @exception PasswordMismatchException if the supplied password was
    173      *            incorrect.
    174      * @exception UnknownEntityException if the user's record does not
    175      *            exist in the database.
    176      * @exception DataBackendException if there is a problem accessing the
    177      *            storage.
    178      */
    179     @Override
    180     public <U extends User> U retrieve(String username, String password)
    181             throws PasswordMismatchException, UnknownEntityException,
    182             DataBackendException
    183     {
    184         TurbineUser u = umDelegate.getUser(username, password);
    185         return wrap(u);
    186     }
    187
    188     /**
    189      * Save an User object to persistent storage. User's record is
    190      * required to exist in the storage.
    191      *
    192      * @param user an User object to store.
    193      * @exception UnknownEntityException if the user's record does not
    194      *            exist in the database.
    195      * @exception DataBackendException if there is a problem accessing the
    196      *            storage.
    197      */
    198     @Override
    199     public void store(User user)
    200             throws UnknownEntityException, DataBackendException
    201     {
    202         try
    203         {
    204             user.setObjectdata(ObjectUtils.serializeMap(user.getPermStorage()));
    205         }
    206         catch (Exception e)
    207         {
    208             throw new DataBackendException("Could not serialize permanent storage", e);
    209         }
    210
    211         umDelegate.saveUser(((DefaultUserImpl)user).getUserDelegate());
    212     }
    213
    214     /**
    215      * Saves User data when the session is unbound. The user account is required
    216      * to exist in the storage.
    217      *
    218      * LastLogin, AccessCounter, persistent pull tools, and any data stored
    219      * in the permData hashtable that is not mapped to a column will be saved.
    220      *
    221      * @exception UnknownEntityException if the user's account does not
    222      *            exist in the database.
    223      * @exception DataBackendException if there is a problem accessing the
    224      *            storage.
    225      */
    226     @Override
    227     public void saveOnSessionUnbind(User user)
    228             throws UnknownEntityException, DataBackendException
    229     {
    230         store(user);
    231     }
    232
    233     /**
    234      * Authenticate an User with the specified password. If authentication
    235      * is successful the method returns nothing. If there are any problems,
    236      * exception was thrown.
    237      *
    238      * @param user an User object to authenticate.
    239      * @param password the user supplied password.
    240      * @exception PasswordMismatchException if the supplied password was
    241      *            incorrect.
    242      * @exception UnknownEntityException if the user's record does not
    243      *            exist in the database.
    244      * @exception DataBackendException if there is a problem accessing the
    245      *            storage.
    246      */
    247     @Override
    248     public void authenticate(User user, String password)
    249             throws PasswordMismatchException, UnknownEntityException,
    250             DataBackendException
    251     {
    252         umDelegate.authenticate(user, password);
    253     }
    254
    255     /**
    256      * Creates new user account with specified attributes.
    257      *
    258      * @param user the object describing account to be created.
    259      * @param initialPassword The password to use for the object creation
    260      *
    261      * @throws DataBackendException if there was an error accessing the data backend.
    262      * @throws EntityExistsException if the user account already exists.
    263      */
    264     @Override
    265     public void createAccount(User user, String initialPassword)
    266             throws EntityExistsException, DataBackendException
    267     {
    268         umDelegate.addUser(user, initialPassword);
    269     }
    270
    271     /**
    272      * Removes an user account from the system.
    273      *
    274      * @param user the object describing the account to be removed.
    275      * @throws DataBackendException if there was an error accessing the data backend.
    276      * @throws UnknownEntityException if the user account is not present.
    277      */
    278     @Override
    279     public void removeAccount(User user)
    280             throws UnknownEntityException, DataBackendException
    281     {
    282         umDelegate.removeUser(user);
    283     }
    284
    285     /**
    286      * Change the password for an User.
    287      *
    288      * @param user an User to change password for.
    289      * @param oldPassword the current password supplied by the user.
    290      * @param newPassword the current password requested by the user.
    291      * @exception PasswordMismatchException if the supplied password was
    292      *            incorrect.
    293      * @exception UnknownEntityException if the user's record does not
    294      *            exist in the database.
    295      * @exception DataBackendException if there is a problem accessing the
    296      *            storage.
    297      */
    298     @Override
    299     public void changePassword(User user, String oldPassword,
    300                                String newPassword)
    301             throws PasswordMismatchException, UnknownEntityException,
    302             DataBackendException
    303     {
    304         umDelegate.changePassword(
    305                 ((DefaultUserImpl)user).getUserDelegate(),
    306                 oldPassword, newPassword);
    307     }
    308
    309     /**
    310      * Forcibly sets new password for an User.
    311      *
    312      * This is supposed by the administrator to change the forgotten or
    313      * compromised passwords. Certain implementations of this feature
    314      * would require administrative level access to the authenticating
    315      * server / program.
    316      *
    317      * @param user an User to change password for.
    318      * @param password the new password.
    319      * @exception UnknownEntityException if the user's record does not
    320      *            exist in the database.
    321      * @exception DataBackendException if there is a problem accessing the
    322      *            storage.
    323      */
    324     @Override
    325     public void forcePassword(User user, String password)
    326             throws UnknownEntityException, DataBackendException
    327     {
    328         umDelegate.forcePassword(user, password);
    329     }
    330
    331     /**
    332      * Constructs an User object to represent an anonymous user of the
    333      * application.
    334      *
    335      * @return An anonymous Turbine User.
    336      * @throws UnknownEntityException
    337      *             if the anonymous User object couldn't be constructed.
    338      */
    339     @Override
    340     public <T extends User> T getAnonymousUser() throws UnknownEntityException
    341     {
    342         TurbineUser u = umDelegate.getAnonymousUser();
    343         return wrap(u);
    344     }
    345
    346     /**
    347      * Checks whether a passed user object matches the anonymous user pattern
    348      * according to the configured user manager
    349      *
    350      * @param u a user object
    351      *
    352      * @return True if this is an anonymous user
    353      *
    354      */
    355     @Override
    356     public boolean isAnonymousUser(User u)
    357     {
    358         return umDelegate.isAnonymousUser(u);
    359     }
    360
    361     /**
    362      * Construct a blank User object.
    363      *
    364      * This method calls getUserClass, and then creates a new object using the
    365      * default constructor.
    366      *
    367      * @return an object implementing User interface.
    368      * @throws DataBackendException
    369      *             if the object could not be instantiated.
    370      */
    371     @Override
    372     public <T extends User> T getUserInstance() throws DataBackendException
    373     {
    374         TurbineUser u = umDelegate.getUserInstance();
    375         return wrap(u);
    376     }
    377
    378     /**
    379      * Construct a blank User object.
    380      *
    381      * This method calls getUserClass, and then creates a new object using the
    382      * default constructor.
    383      *
    384      * @param userName
    385      *            The name of the user.
    386      *
    387      * @return an object implementing User interface.
    388      * @throws DataBackendException
    389      *             if the object could not be instantiated.
    390      */
    391     @Override
    392     public <T extends User> T getUserInstance(String userName) throws DataBackendException
    393     {
    394         TurbineUser u = umDelegate.getUserInstance(userName);
    395         return wrap(u);
    396     }
    397
    398     /**
    399      * Return a Class object representing the system's chosen implementation of
    400      * of ACL interface.
    401      *
    402      * @return systems's chosen implementation of ACL interface.
    403      * @throws UnknownEntityException
    404      *             if the implementation of ACL interface could not be
    405      *             determined, or does not exist.
    406      */
    407     @Override
    408     public <T extends AccessControlList> T getACL(User user) throws UnknownEntityException
    409     {
    410         return umDelegate.getACL(user);
    411     }
    412 }