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