1 package org.apache.archiva.web.security;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 import org.apache.archiva.admin.model.RepositoryAdminException;
22 import org.apache.archiva.admin.model.runtime.RedbackRuntimeConfigurationAdmin;
23 import org.apache.archiva.redback.components.cache.Cache;
24 import org.apache.archiva.redback.users.AbstractUserManager;
25 import org.apache.archiva.redback.users.User;
26 import org.apache.archiva.redback.users.UserManager;
27 import org.apache.archiva.redback.users.UserManagerException;
28 import org.apache.archiva.redback.users.UserManagerListener;
29 import org.apache.archiva.redback.users.UserNotFoundException;
30 import org.apache.archiva.redback.users.UserQuery;
31 import org.apache.archiva.redback.users.configurable.ConfigurableUserManager;
32 import org.springframework.context.ApplicationContext;
33 import org.springframework.stereotype.Service;
34
35 import javax.annotation.PostConstruct;
36 import javax.inject.Inject;
37 import javax.inject.Named;
38 import java.util.ArrayList;
39 import java.util.LinkedHashMap;
40 import java.util.List;
41 import java.util.Map;
42
43
44
45
46
47 @Service("userManager#archiva")
48 public class ArchivaConfigurableUsersManager
49 extends AbstractUserManager
50 {
51
52 @Inject
53 private RedbackRuntimeConfigurationAdmin redbackRuntimeConfigurationAdmin;
54
55 @Inject
56 private ApplicationContext applicationContext;
57
58 private Map<String, UserManager> userManagerPerId;
59
60 @Inject
61 @Named(value = "cache#users")
62 private Cache<String, User> usersCache;
63
64 private boolean useUsersCache;
65
66 @PostConstruct
67 public void initialize()
68 {
69 try
70 {
71 List<String> userManagerImpls =
72 redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration().getUserManagerImpls();
73 log.info( "use userManagerImpls: '{}'", userManagerImpls );
74
75 userManagerPerId = new LinkedHashMap<String, UserManager>( userManagerImpls.size() );
76 for ( String id : userManagerImpls )
77 {
78 UserManager userManagerImpl = applicationContext.getBean( "userManager#" + id, UserManager.class );
79 setUserManagerImpl( userManagerImpl );
80 userManagerPerId.put( id, userManagerImpl );
81 }
82
83 this.useUsersCache = redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration().isUseUsersCache();
84 }
85 catch ( RepositoryAdminException e )
86 {
87
88 log.error( e.getMessage(), e );
89 throw new RuntimeException( e.getMessage(), e );
90 }
91 }
92
93 protected boolean useUsersCache()
94 {
95 return this.useUsersCache;
96 }
97
98 public User addUser( User user )
99 throws UserManagerException
100 {
101 user = userManagerPerId.get( user.getUserManagerId() ).addUser( user );
102
103 if ( useUsersCache() )
104 {
105 usersCache.put( user.getUsername(), user );
106 }
107
108 return user;
109 }
110
111 public void addUserUnchecked( User user )
112 throws UserManagerException
113 {
114 userManagerPerId.get( user.getUserManagerId() ).addUserUnchecked( user );
115
116 if ( useUsersCache() )
117 {
118 usersCache.put( user.getUsername(), user );
119 }
120 }
121
122 public User createUser( String username, String fullName, String emailAddress )
123 throws UserManagerException
124 {
125 Exception lastException = null;
126 boolean allFailed = true;
127 User user = null;
128 for ( UserManager userManager : userManagerPerId.values() )
129 {
130 try
131 {
132 if ( !userManager.isReadOnly() )
133 {
134 user = userManager.createUser( username, fullName, emailAddress );
135 allFailed = false;
136 }
137 }
138 catch ( Exception e )
139 {
140 lastException = e;
141 }
142 }
143 if ( lastException != null && allFailed )
144 {
145 throw new UserManagerException( lastException.getMessage(), lastException );
146 }
147 return user;
148 }
149
150 public UserQuery createUserQuery()
151 {
152 return userManagerPerId.values().iterator().next().createUserQuery();
153 }
154
155
156 public void deleteUser( String username )
157 throws UserNotFoundException, UserManagerException
158 {
159 Exception lastException = null;
160 boolean allFailed = true;
161 User user = null;
162 for ( UserManager userManager : userManagerPerId.values() )
163 {
164 try
165 {
166 if ( !userManager.isReadOnly() )
167 {
168 userManager.deleteUser( username );
169 allFailed = false;
170 }
171 }
172 catch ( Exception e )
173 {
174 lastException = e;
175 }
176 }
177 if ( lastException != null && allFailed )
178 {
179 throw new UserManagerException( lastException.getMessage(), lastException );
180 }
181 }
182
183 public void eraseDatabase()
184 {
185 for ( UserManager userManager : userManagerPerId.values() )
186 {
187 userManager.eraseDatabase();
188 }
189 }
190
191 public User findUser( String username )
192 throws UserManagerException
193 {
194
195 User user = null;
196 if ( useUsersCache() )
197 {
198 user = usersCache.get( username );
199 if ( user != null )
200 {
201 return user;
202 }
203
204 }
205 Exception lastException = null;
206 for ( UserManager userManager : userManagerPerId.values() )
207 {
208 try
209 {
210 user = userManager.findUser( username );
211 if ( user != null )
212 {
213 if ( useUsersCache() )
214 {
215 usersCache.put( username, user );
216 }
217 return user;
218 }
219 }
220 catch ( UserNotFoundException e )
221 {
222 lastException = e;
223 }
224 catch ( Exception e )
225 {
226 lastException = e;
227 }
228 }
229
230 if ( user == null )
231 {
232 if ( lastException != null )
233 {
234 if ( lastException instanceof UserNotFoundException )
235 {
236 throw (UserNotFoundException) lastException;
237 }
238 throw new UserManagerException( lastException.getMessage(), lastException );
239 }
240 }
241
242 return user;
243 }
244
245
246 @Override
247 public User getGuestUser()
248 throws UserNotFoundException, UserManagerException
249 {
250 return findUser( GUEST_USERNAME );
251 }
252
253 public List<User> findUsersByEmailKey( String emailKey, boolean orderAscending )
254 throws UserManagerException
255 {
256 List<User> users = new ArrayList<User>();
257
258 for ( UserManager userManager : userManagerPerId.values() )
259 {
260 List<User> found = userManager.findUsersByEmailKey( emailKey, orderAscending );
261 if ( found != null )
262 {
263 users.addAll( found );
264 }
265 }
266 return users;
267 }
268
269 public List<User> findUsersByFullNameKey( String fullNameKey, boolean orderAscending )
270 throws UserManagerException
271 {
272 List<User> users = new ArrayList<User>();
273
274 for ( UserManager userManager : userManagerPerId.values() )
275 {
276 List<User> found = userManager.findUsersByFullNameKey( fullNameKey, orderAscending );
277 if ( found != null )
278 {
279 users.addAll( found );
280 }
281 }
282 return users;
283 }
284
285 public List<User> findUsersByQuery( UserQuery query )
286 throws UserManagerException
287 {
288 List<User> users = new ArrayList<User>();
289
290 for ( UserManager userManager : userManagerPerId.values() )
291 {
292 List<User> found = userManager.findUsersByQuery( query );
293 if ( found != null )
294 {
295 users.addAll( found );
296 }
297 }
298 return users;
299 }
300
301 public List<User> findUsersByUsernameKey( String usernameKey, boolean orderAscending )
302 throws UserManagerException
303 {
304 List<User> users = new ArrayList<User>();
305
306 for ( UserManager userManager : userManagerPerId.values() )
307 {
308 List<User> found = userManager.findUsersByUsernameKey( usernameKey, orderAscending );
309 if ( found != null )
310 {
311 users.addAll( found );
312 }
313 }
314 return users;
315 }
316
317 public String getId()
318 {
319 return null;
320 }
321
322 public List<User> getUsers()
323 throws UserManagerException
324 {
325 List<User> users = new ArrayList<User>();
326
327 for ( UserManager userManager : userManagerPerId.values() )
328 {
329 List<User> found = userManager.getUsers();
330 if ( found != null )
331 {
332 users.addAll( found );
333 }
334 }
335 return users;
336 }
337
338 public List<User> getUsers( boolean orderAscending )
339 throws UserManagerException
340 {
341 List<User> users = new ArrayList<User>();
342
343 for ( UserManager userManager : userManagerPerId.values() )
344 {
345 List<User> found = userManager.getUsers( orderAscending );
346 if ( found != null )
347 {
348 users.addAll( found );
349 }
350 }
351 return users;
352 }
353
354 public boolean isReadOnly()
355 {
356 boolean readOnly = false;
357
358 for ( UserManager userManager : userManagerPerId.values() )
359 {
360 readOnly = readOnly || userManager.isReadOnly();
361 }
362 return readOnly;
363 }
364
365 public User updateUser( User user )
366 throws UserNotFoundException, UserManagerException
367 {
368 user = userManagerPerId.get( user.getUserManagerId() ).updateUser( user );
369
370 if ( useUsersCache() )
371 {
372 usersCache.put( user.getUsername(), user );
373 }
374
375 return user;
376 }
377
378 public User updateUser( User user, boolean passwordChangeRequired )
379 throws UserNotFoundException, UserManagerException
380 {
381 user = userManagerPerId.get( user.getUserManagerId() ).updateUser( user, passwordChangeRequired );
382
383 if ( useUsersCache() )
384 {
385 usersCache.put( user.getUsername(), user );
386 }
387
388 return user;
389 }
390
391 public void setUserManagerImpl( UserManager userManagerImpl )
392 {
393
394 log.debug( "setUserManagerImpl cannot be used in this implementation" );
395 }
396
397 @Override
398 public User createGuestUser()
399 throws UserManagerException
400 {
401 Exception lastException = null;
402 boolean allFailed = true;
403 User user = null;
404 for ( UserManager userManager : userManagerPerId.values() )
405 {
406 try
407 {
408 if ( !userManager.isReadOnly() )
409 {
410 user = userManager.createGuestUser();
411 allFailed = false;
412 }
413 }
414 catch ( Exception e )
415 {
416 lastException = e;
417 }
418 }
419 if ( lastException != null && allFailed )
420 {
421 throw new UserManagerException( lastException.getMessage(), lastException );
422 }
423 return user;
424 }
425
426
427 public boolean userExists( String userName )
428 throws UserManagerException
429 {
430 Exception lastException = null;
431 boolean allFailed = true;
432 boolean exists = false;
433 for ( UserManager userManager : userManagerPerId.values() )
434 {
435 try
436 {
437
438 if ( userManager.userExists( userName ) )
439 {
440 exists = true;
441 }
442 allFailed = false;
443
444 }
445 catch ( Exception e )
446 {
447 lastException = e;
448 }
449 }
450 if ( lastException != null && allFailed )
451 {
452 throw new UserManagerException( lastException.getMessage(), lastException );
453 }
454 return exists;
455 }
456
457
458 @Override
459 public boolean isFinalImplementation()
460 {
461 return false;
462 }
463
464 public String getDescriptionKey()
465 {
466 return "archiva.redback.usermanager.configurable.archiva";
467 }
468
469
470 }