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                 throw new UserManagerException( lastException.getMessage(), lastException );
 235             }
 236         }
 237
 238         return user;
 239     }
 240
 241
 242     @Override
 243     public User getGuestUser()
 244         throws UserNotFoundException, UserManagerException
 245     {
 246         return findUser( GUEST_USERNAME );
 247     }
 248
 249     public List<User> findUsersByEmailKey( String emailKey, boolean orderAscending )
 250         throws UserManagerException
 251     {
 252         List<User> users = new ArrayList<User>();
 253
 254         for ( UserManager userManager : userManagerPerId.values() )
 255         {
 256             List<User> found = userManager.findUsersByEmailKey( emailKey, orderAscending );
 257             if ( found != null )
 258             {
 259                 users.addAll( found );
 260             }
 261         }
 262         return users;
 263     }
 264
 265     public List<User> findUsersByFullNameKey( String fullNameKey, boolean orderAscending )
 266         throws UserManagerException
 267     {
 268         List<User> users = new ArrayList<User>();
 269
 270         for ( UserManager userManager : userManagerPerId.values() )
 271         {
 272             List<User> found = userManager.findUsersByFullNameKey( fullNameKey, orderAscending );
 273             if ( found != null )
 274             {
 275                 users.addAll( found );
 276             }
 277         }
 278         return users;
 279     }
 280
 281     public List<User> findUsersByQuery( UserQuery query )
 282         throws UserManagerException
 283     {
 284         List<User> users = new ArrayList<User>();
 285
 286         for ( UserManager userManager : userManagerPerId.values() )
 287         {
 288             List<User> found = userManager.findUsersByQuery( query );
 289             if ( found != null )
 290             {
 291                 users.addAll( found );
 292             }
 293         }
 294         return users;
 295     }
 296
 297     public List<User> findUsersByUsernameKey( String usernameKey, boolean orderAscending )
 298         throws UserManagerException
 299     {
 300         List<User> users = new ArrayList<User>();
 301
 302         for ( UserManager userManager : userManagerPerId.values() )
 303         {
 304             List<User> found = userManager.findUsersByUsernameKey( usernameKey, orderAscending );
 305             if ( found != null )
 306             {
 307                 users.addAll( found );
 308             }
 309         }
 310         return users;
 311     }
 312
 313     public String getId()
 314     {
 315         return null;
 316     }
 317
 318     public List<User> getUsers()
 319         throws UserManagerException
 320     {
 321         List<User> users = new ArrayList<User>();
 322
 323         for ( UserManager userManager : userManagerPerId.values() )
 324         {
 325             List<User> found = userManager.getUsers();
 326             if ( found != null )
 327             {
 328                 users.addAll( found );
 329             }
 330         }
 331         return users;
 332     }
 333
 334     public List<User> getUsers( boolean orderAscending )
 335         throws UserManagerException
 336     {
 337         List<User> users = new ArrayList<User>();
 338
 339         for ( UserManager userManager : userManagerPerId.values() )
 340         {
 341             List<User> found = userManager.getUsers( orderAscending );
 342             if ( found != null )
 343             {
 344                 users.addAll( found );
 345             }
 346         }
 347         return users;
 348     }
 349
 350     public boolean isReadOnly()
 351     {
 352         boolean readOnly = false;
 353
 354         for ( UserManager userManager : userManagerPerId.values() )
 355         {
 356             readOnly = readOnly || userManager.isReadOnly();
 357         }
 358         return readOnly;
 359     }
 360
 361     public User updateUser( User user )
 362         throws UserNotFoundException, UserManagerException
 363     {
 364         user = userManagerPerId.get( user.getUserManagerId() ).updateUser( user );
 365
 366         if ( useUsersCache() )
 367         {
 368             usersCache.put( user.getUsername(), user );
 369         }
 370
 371         return user;
 372     }
 373
 374     public User updateUser( User user, boolean passwordChangeRequired )
 375         throws UserNotFoundException, UserManagerException
 376     {
 377         user = userManagerPerId.get( user.getUserManagerId() ).updateUser( user, passwordChangeRequired );
 378
 379         if ( useUsersCache() )
 380         {
 381             usersCache.put( user.getUsername(), user );
 382         }
 383
 384         return user;
 385     }
 386
 387     public void setUserManagerImpl( UserManager userManagerImpl )
 388     {
 389         // not possible here but we know so no need of log.error
 390         log.debug( "setUserManagerImpl cannot be used in this implementation" );
 391     }
 392
 393     @Override
 394     public User createGuestUser()
 395         throws UserManagerException
 396     {
 397         Exception lastException = null;
 398         boolean allFailed = true;
 399         User user = null;
 400         for ( UserManager userManager : userManagerPerId.values() )
 401         {
 402             try
 403             {
 404                 if ( !userManager.isReadOnly() )
 405                 {
 406                     user = userManager.createGuestUser();
 407                     allFailed = false;
 408                 }
 409             }
 410             catch ( Exception e )
 411             {
 412                 lastException = e;
 413             }
 414         }
 415         if ( lastException != null && allFailed )
 416         {
 417             throw new UserManagerException( lastException.getMessage(), lastException );
 418         }
 419         return user;
 420     }
 421
 422
 423     public boolean userExists( String userName )
 424         throws UserManagerException
 425     {
 426         Exception lastException = null;
 427         boolean allFailed = true;
 428         boolean exists = false;
 429         for ( UserManager userManager : userManagerPerId.values() )
 430         {
 431             try
 432             {
 433
 434                 if ( userManager.userExists( userName ) )
 435                 {
 436                     exists = true;
 437                 }
 438                 allFailed = false;
 439
 440             }
 441             catch ( Exception e )
 442             {
 443                 lastException = e;
 444             }
 445         }
 446         if ( lastException != null && allFailed )
 447         {
 448             throw new UserManagerException( lastException.getMessage(), lastException );
 449         }
 450         return exists;
 451     }
 452
 453
 454
 455     @Override
 456     public boolean isFinalImplementation()
 457     {
 458         return false;
 459     }
 460
 461     public String getDescriptionKey()
 462     {
 463         return "archiva.redback.usermanager.configurable.archiva";
 464     }
 465
 466
 467 }