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  import org.apache.fulcrum.security.acl.AccessControlList;
    28  import org.apache.fulcrum.security.util.DataBackendException;
    29  import org.apache.fulcrum.security.util.EntityExistsException;
    30  import org.apache.fulcrum.security.util.PasswordMismatchException;
    31  import org.apache.fulcrum.security.util.UnknownEntityException;
    32  import org.apache.turbine.om.security.User;
    33  import org.apache.turbine.services.security.UserManager;
    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 1706239 2015-10-01 13:18:35Z tv $
    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      @Override
    54      public void init(Configuration conf)
    55      {
    56          // GNDN
    57      }
    58
    59      /**
    60       * Check whether a specified user's account exists.
    61       *
    62       * The login name is used for looking up the account.
    63       *
    64       * @param user The user to be checked.
    65       * @return true if the specified account exists
    66       * @throws DataBackendException if there was an error accessing the data backend.
    67       */
    68      @Override
    69      public boolean accountExists(User user)
    70              throws DataBackendException
    71      {
    72          throw new DataBackendException("PassiveUserManager knows no users");
    73      }
    74
    75      /**
    76       * Check whether a specified user's account exists.
    77       *
    78       * The login name is used for looking up the account.
    79       *
    80       * @param userName The name of the user to be checked.
    81       * @return true if the specified account exists
    82       * @throws DataBackendException if there was an error accessing the data backend.
    83       */
    84      @Override
    85      public boolean accountExists(String userName)
    86              throws DataBackendException
    87      {
    88          throw new DataBackendException("PassiveUserManager knows no users");
    89      }
    90
    91      /**
    92       * Retrieve a user from persistent storage using username as the
    93       * key.
    94       *
    95       * @param username the name of the user.
    96       * @return an User object.
    97       * @exception UnknownEntityException if the user's record does not
    98       *            exist in the database.
    99       * @exception DataBackendException if there is a problem accessing the
    100      *            storage.
    101      */
    102     @Override
    103     public <U extends User> U retrieve(String username)
    104             throws UnknownEntityException, DataBackendException
    105     {
    106         throw new DataBackendException("PassiveUserManager knows no users");
    107     }
    108
    109     /**
    110      * Retrieve a set of users that meet the specified criteria.
    111      *
    112      * As the keys for the criteria, you should use the constants that
    113      * are defined in {@link User} interface, plus the names
    114      * of the custom attributes you added to your user representation
    115      * in the data storage. Use verbatim names of the attributes -
    116      * without table name prefix in case of DB implementation.
    117      *
    118      * @param criteria The criteria of selection.
    119      * @return a List of users meeting the criteria.
    120      * @throws DataBackendException if there is a problem accessing the
    121      *         storage.
    122      */
    123     @Override
    124     public List<? extends User> retrieveList(Object criteria)
    125             throws DataBackendException
    126     {
    127         throw new DataBackendException("PassiveUserManager knows no users");
    128     }
    129
    130     /**
    131      * Retrieve a user from persistent storage using username as the
    132      * key, and authenticate the user. The implementation may chose
    133      * to authenticate to the server as the user whose data is being
    134      * retrieved.
    135      *
    136      * @param username the name of the user.
    137      * @param password the user supplied password.
    138      * @return an User object.
    139      * @exception PasswordMismatchException if the supplied password was
    140      *            incorrect.
    141      * @exception UnknownEntityException if the user's record does not
    142      *            exist in the database.
    143      * @exception DataBackendException if there is a problem accessing the
    144      *            storage.
    145      */
    146     @Override
    147     public <U extends User> U retrieve(String username, String password)
    148             throws PasswordMismatchException, UnknownEntityException,
    149             DataBackendException
    150     {
    151         throw new DataBackendException("PassiveUserManager knows no users");
    152     }
    153
    154     /**
    155      * Save an User object to persistent storage. User's record is
    156      * required to exist in the storage.
    157      *
    158      * @param user an User object to store.
    159      * @exception UnknownEntityException if the user's record does not
    160      *            exist in the database.
    161      * @exception DataBackendException if there is a problem accessing the
    162      *            storage.
    163      */
    164     @Override
    165     public void store(User user)
    166             throws UnknownEntityException, DataBackendException
    167     {
    168         throw new DataBackendException("PassiveUserManager does not support saving user data");
    169     }
    170
    171     /**
    172      * Saves User data when the session is unbound. The user account is required
    173      * to exist in the storage.
    174      *
    175      * LastLogin, AccessCounter, persistent pull tools, and any data stored
    176      * in the permData hashtable that is not mapped to a column will be saved.
    177      *
    178      * @exception UnknownEntityException if the user's account does not
    179      *            exist in the database.
    180      * @exception DataBackendException if there is a problem accessing the
    181      *            storage.
    182      */
    183     @Override
    184     public void saveOnSessionUnbind(User user)
    185             throws UnknownEntityException, DataBackendException
    186     {
    187         throw new DataBackendException("PassiveUserManager does not support saving user data");
    188     }
    189
    190     /**
    191      * Authenticate an User with the specified password. If authentication
    192      * is successful the method returns nothing. If there are any problems,
    193      * exception was thrown.
    194      *
    195      * @param user an User object to authenticate.
    196      * @param password the user supplied password.
    197      * @exception PasswordMismatchException if the supplied password was
    198      *            incorrect.
    199      * @exception UnknownEntityException if the user's record does not
    200      *            exist in the database.
    201      * @exception DataBackendException if there is a problem accessing the
    202      *            storage.
    203      */
    204     @Override
    205     public void authenticate(User user, String password)
    206             throws PasswordMismatchException, UnknownEntityException,
    207             DataBackendException
    208     {
    209         throw new DataBackendException("PassiveUserManager knows no users");
    210     }
    211
    212     /**
    213      * Creates new user account with specified attributes.
    214      *
    215      * @param user the object describing account to be created.
    216      * @param initialPassword The password to use for the object creation
    217      *
    218      * @throws DataBackendException if there was an error accessing the data backend.
    219      * @throws EntityExistsException if the user account already exists.
    220      */
    221     @Override
    222     public void createAccount(User user, String initialPassword)
    223             throws EntityExistsException, DataBackendException
    224     {
    225         throw new DataBackendException("PassiveUserManager does not support"
    226                 + " creating accounts");
    227     }
    228
    229     /**
    230      * Removes an user account from the system.
    231      *
    232      * @param user the object describing the account to be removed.
    233      * @throws DataBackendException if there was an error accessing the data backend.
    234      * @throws UnknownEntityException if the user account is not present.
    235      */
    236     @Override
    237     public void removeAccount(User user)
    238             throws UnknownEntityException, DataBackendException
    239     {
    240         throw new DataBackendException("PassiveUserManager does not support removing accounts");
    241     }
    242
    243     /**
    244      * Change the password for an User.
    245      *
    246      * @param user an User to change password for.
    247      * @param oldPassword the current password supplied by the user.
    248      * @param newPassword the current password requested by the user.
    249      * @exception PasswordMismatchException if the supplied password was
    250      *            incorrect.
    251      * @exception UnknownEntityException if the user's record does not
    252      *            exist in the database.
    253      * @exception DataBackendException if there is a problem accessing the
    254      *            storage.
    255      */
    256     @Override
    257     public void changePassword(User user, String oldPassword,
    258                                String newPassword)
    259             throws PasswordMismatchException, UnknownEntityException,
    260             DataBackendException
    261     {
    262         throw new DataBackendException("PassiveUserManager does not support setting passwords");
    263     }
    264
    265     /**
    266      * Forcibly sets new password for an User.
    267      *
    268      * This is supposed by the administrator to change the forgotten or
    269      * compromised passwords. Certain implementations of this feature
    270      * would require administrative level access to the authenticating
    271      * server / program.
    272      *
    273      * @param user an User to change password for.
    274      * @param password the new password.
    275      * @exception UnknownEntityException if the user's record does not
    276      *            exist in the database.
    277      * @exception DataBackendException if there is a problem accessing the
    278      *            storage.
    279      */
    280     @Override
    281     public void forcePassword(User user, String password)
    282             throws UnknownEntityException, DataBackendException
    283     {
    284         throw new DataBackendException("PassiveUserManager does not support setting passwords");
    285     }
    286
    287     /**
    288      * Constructs an User object to represent an anonymous user of the
    289      * application.
    290      *
    291      * @return An anonymous Turbine User.
    292      * @throws UnknownEntityException
    293      *             if the anonymous User object couldn't be constructed.
    294      */
    295     @Override
    296     public <T extends User> T getAnonymousUser() throws UnknownEntityException
    297     {
    298         throw new UnknownEntityException("PassiveUserManager knows no users");
    299     }
    300
    301     /**
    302      * Checks whether a passed user object matches the anonymous user pattern
    303      * according to the configured user manager
    304      *
    305      * @param u a user object
    306      *
    307      * @return true if this is an anonymous user
    308      *
    309      */
    310     @Override
    311     public boolean isAnonymousUser(User u)
    312     {
    313         return true;
    314     }
    315
    316     /**
    317      * Construct a blank User object.
    318      *
    319      * This method calls getUserClass, and then creates a new object using the
    320      * default constructor.
    321      *
    322      * @return an object implementing User interface.
    323      * @throws DataBackendException
    324      *             if the object could not be instantiated.
    325      */
    326     @Override
    327     public <T extends User> T getUserInstance() throws DataBackendException
    328     {
    329         throw new DataBackendException("PassiveUserManager knows no users");
    330     }
    331
    332     /**
    333      * Construct a blank User object.
    334      *
    335      * This method calls getUserClass, and then creates a new object using the
    336      * default constructor.
    337      *
    338      * @param userName
    339      *            The name of the user.
    340      *
    341      * @return an object implementing User interface.
    342      * @throws DataBackendException
    343      *             if the object could not be instantiated.
    344      */
    345     @Override
    346     public <T extends User> T getUserInstance(String userName) throws DataBackendException
    347     {
    348         throw new DataBackendException("PassiveUserManager knows no users");
    349     }
    350
    351     /**
    352      * Return a Class object representing the system's chosen implementation of
    353      * of ACL interface.
    354      *
    355      * @return systems's chosen implementation of ACL interface.
    356      * @throws UnknownEntityException
    357      *             if the implementation of ACL interface could not be
    358      *             determined, or does not exist.
    359      */
    360     @Override
    361     public <T extends AccessControlList> T getACL(User user) throws UnknownEntityException
    362     {
    363         throw new UnknownEntityException("PassiveUserManager knows no users");
    364     }
    365 }