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 }