View Javadoc

    1   package org.apache.turbine.services.security.passive;
    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.List;
    25
    26  import org.apache.commons.configuration.Configuration;
    27
    28  import org.apache.turbine.om.security.User;
    29  import org.apache.turbine.services.security.UserManager;
    30  import org.apache.turbine.util.security.DataBackendException;
    31  import org.apache.turbine.util.security.EntityExistsException;
    32  import org.apache.turbine.util.security.PasswordMismatchException;
    33  import org.apache.turbine.util.security.UnknownEntityException;
    34
    35  /**
    36   * Void user manager can be used where no data storage is needed
    37   * by the application.
    38   * It's methods don't provide any useful functionality  except throwing
    39   * DataBackendExceptions. Security service will be still able to create
    40   * anonymous User objects when this UserManager is used.
    41   *
    42   * @author <a href="mailto:Rafal.Krzewski@e-point.pl">Rafal Krzewski</a>
    43   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
    44   * @version $Id: PassiveUserManager.java 1096130 2011-04-23 10:37:19Z ludwig $
    45   */
    46  public class PassiveUserManager implements UserManager
    47  {
    48      /**
    49       * Initializes the UserManager
    50       *
    51       * @param conf A Configuration object to init this Manager
    52       */
    53      public void init(Configuration conf)
    54      {
    55          // GNDN
    56      }
    57
    58      /**
    59       * Check whether a specified user's account exists.
    60       *
    61       * The login name is used for looking up the account.
    62       *
    63       * @param user The user to be checked.
    64       * @return true if the specified account exists
    65       * @throws DataBackendException if there was an error accessing the data backend.
    66       */
    67      public boolean accountExists(User user)
    68              throws DataBackendException
    69      {
    70          throw new DataBackendException("PassiveUserManager knows no users");
    71      }
    72
    73      /**
    74       * Check whether a specified user's account exists.
    75       *
    76       * The login name is used for looking up the account.
    77       *
    78       * @param userName The name of the user to be checked.
    79       * @return true if the specified account exists
    80       * @throws DataBackendException if there was an error accessing the data backend.
    81       */
    82      public boolean accountExists(String userName)
    83              throws DataBackendException
    84      {
    85          throw new DataBackendException("PassiveUserManager knows no users");
    86      }
    87
    88      /**
    89       * Retrieve a user from persistent storage using username as the
    90       * key.
    91       *
    92       * @param username the name of the user.
    93       * @return an User object.
    94       * @exception UnknownEntityException if the user's record does not
    95       *            exist in the database.
    96       * @exception DataBackendException if there is a problem accessing the
    97       *            storage.
    98       */
    99      public User retrieve(String username)
    100             throws UnknownEntityException, DataBackendException
    101     {
    102         throw new DataBackendException("PassiveUserManager knows no users");
    103     }
    104
    105     /**
    106      * Retrieve a set of users that meet the specified criteria.
    107      *
    108      * As the keys for the criteria, you should use the constants that
    109      * are defined in {@link User} interface, plus the names
    110      * of the custom attributes you added to your user representation
    111      * in the data storage. Use verbatim names of the attributes -
    112      * without table name prefix in case of DB implementation.
    113      *
    114      * @param criteria The criteria of selection.
    115      * @return a List of users meeting the criteria.
    116      * @throws DataBackendException if there is a problem accessing the
    117      *         storage.
    118      * @deprecated Use <a href="#retrieveList">retrieveList</a> instead.
    119      */
    120     public User[] retrieve(Object criteria)
    121             throws DataBackendException
    122     {
    123         throw new DataBackendException("PassiveUserManager knows no users");
    124     }
    125
    126     /**
    127      * Retrieve a set of users that meet the specified criteria.
    128      *
    129      * As the keys for the criteria, you should use the constants that
    130      * are defined in {@link User} interface, plus the names
    131      * of the custom attributes you added to your user representation
    132      * in the data storage. Use verbatim names of the attributes -
    133      * without table name prefix in case of DB implementation.
    134      *
    135      * @param criteria The criteria of selection.
    136      * @return a List of users meeting the criteria.
    137      * @throws DataBackendException if there is a problem accessing the
    138      *         storage.
    139      */
    140     public List retrieveList(Object criteria)
    141             throws DataBackendException
    142     {
    143         throw new DataBackendException("PassiveUserManager knows no users");
    144     }
    145
    146     /**
    147      * Retrieve a user from persistent storage using username as the
    148      * key, and authenticate the user. The implementation may chose
    149      * to authenticate to the server as the user whose data is being
    150      * retrieved.
    151      *
    152      * @param username the name of the user.
    153      * @param password the user supplied password.
    154      * @return an User object.
    155      * @exception PasswordMismatchException if the supplied password was
    156      *            incorrect.
    157      * @exception UnknownEntityException if the user's record does not
    158      *            exist in the database.
    159      * @exception DataBackendException if there is a problem accessing the
    160      *            storage.
    161      */
    162     public User retrieve(String username, String password)
    163             throws PasswordMismatchException, UnknownEntityException,
    164             DataBackendException
    165     {
    166         throw new DataBackendException("PassiveUserManager knows no users");
    167     }
    168
    169     /**
    170      * Save an User object to persistent storage. User's record is
    171      * required to exist in the storage.
    172      *
    173      * @param user an User object to store.
    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     public void store(User user)
    180             throws UnknownEntityException, DataBackendException
    181     {
    182         throw new DataBackendException("PassiveUserManager does not support saving user data");
    183     }
    184
    185     /**
    186      * Saves User data when the session is unbound. The user account is required
    187      * to exist in the storage.
    188      *
    189      * LastLogin, AccessCounter, persistent pull tools, and any data stored
    190      * in the permData hashtable that is not mapped to a column will be saved.
    191      *
    192      * @exception UnknownEntityException if the user's account does not
    193      *            exist in the database.
    194      * @exception DataBackendException if there is a problem accessing the
    195      *            storage.
    196      */
    197     public void saveOnSessionUnbind(User user)
    198             throws UnknownEntityException, DataBackendException
    199     {
    200         throw new DataBackendException("PassiveUserManager does not support saving user data");
    201     }
    202
    203     /**
    204      * Authenticate an User with the specified password. If authentication
    205      * is successful the method returns nothing. If there are any problems,
    206      * exception was thrown.
    207      *
    208      * @param user an User object to authenticate.
    209      * @param password the user supplied password.
    210      * @exception PasswordMismatchException if the supplied password was
    211      *            incorrect.
    212      * @exception UnknownEntityException if the user's record does not
    213      *            exist in the database.
    214      * @exception DataBackendException if there is a problem accessing the
    215      *            storage.
    216      */
    217     public void authenticate(User user, String password)
    218             throws PasswordMismatchException, UnknownEntityException,
    219             DataBackendException
    220     {
    221         throw new DataBackendException("PassiveUserManager knows no users");
    222     }
    223
    224     /**
    225      * Creates new user account with specified attributes.
    226      *
    227      * @param user the object describing account to be created.
    228      * @param initialPassword The password to use for the object creation
    229      *
    230      * @throws DataBackendException if there was an error accessing the data backend.
    231      * @throws EntityExistsException if the user account already exists.
    232      */
    233     public void createAccount(User user, String initialPassword)
    234             throws EntityExistsException, DataBackendException
    235     {
    236         throw new DataBackendException("PassiveUserManager does not support"
    237                 + " creating accounts");
    238     }
    239
    240     /**
    241      * Removes an user account from the system.
    242      *
    243      * @param user the object describing the account to be removed.
    244      * @throws DataBackendException if there was an error accessing the data backend.
    245      * @throws UnknownEntityException if the user account is not present.
    246      */
    247     public void removeAccount(User user)
    248             throws UnknownEntityException, DataBackendException
    249     {
    250         throw new DataBackendException("PassiveUserManager does not support removing accounts");
    251     }
    252
    253     /**
    254      * Change the password for an User.
    255      *
    256      * @param user an User to change password for.
    257      * @param oldPassword the current password supplied by the user.
    258      * @param newPassword the current password requested by the user.
    259      * @exception PasswordMismatchException if the supplied password was
    260      *            incorrect.
    261      * @exception UnknownEntityException if the user's record does not
    262      *            exist in the database.
    263      * @exception DataBackendException if there is a problem accessing the
    264      *            storage.
    265      */
    266     public void changePassword(User user, String oldPassword,
    267                                String newPassword)
    268             throws PasswordMismatchException, UnknownEntityException,
    269             DataBackendException
    270     {
    271         throw new DataBackendException("PassiveUserManager does not support setting passwords");
    272     }
    273
    274     /**
    275      * Forcibly sets new password for an User.
    276      *
    277      * This is supposed by the administrator to change the forgotten or
    278      * compromised passwords. Certain implementatations of this feature
    279      * would require administrative level access to the authenticating
    280      * server / program.
    281      *
    282      * @param user an User to change password for.
    283      * @param password the new password.
    284      * @exception UnknownEntityException if the user's record does not
    285      *            exist in the database.
    286      * @exception DataBackendException if there is a problem accessing the
    287      *            storage.
    288      */
    289     public void forcePassword(User user, String password)
    290             throws UnknownEntityException, DataBackendException
    291     {
    292         throw new DataBackendException("PassiveUserManager does not support setting passwords");
    293     }
    294 }