source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.web.security;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  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  * @author Olivier Lamy
  45  * @since 1.4-M4
  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             // revert to a default one ?
  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         // not possible here but we know so no need of log.error
 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 }