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

   1 package org.apache.archiva.redback.users.cached;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.redback.components.cache.Cache;
  23 import org.apache.archiva.redback.users.User;
  24 import org.apache.archiva.redback.users.UserManagerListener;
  25 import org.apache.archiva.redback.users.UserNotFoundException;
  26 import org.apache.archiva.redback.users.UserQuery;
  27 import org.apache.archiva.redback.users.UserManager;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30 import org.springframework.stereotype.Service;
  31
  32 import javax.inject.Inject;
  33 import javax.inject.Named;
  34 import java.util.List;
  35
  36 /**
  37  * CachedUserManager
  38  *
  39  * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
  40  * @version $Id$
  41  */
  42 @Service( "userManager#cached" )
  43 public class CachedUserManager
  44     implements UserManager, UserManagerListener
  45 {
  46
  47     private Logger log = LoggerFactory.getLogger( getClass() );
  48
  49     @Inject
  50     @Named( value = "userManager#jdo" )
  51     private UserManager userImpl;
  52
  53     @Inject
  54     @Named( value = "cache#users" )
  55     private Cache usersCache;
  56
  57     public boolean isReadOnly()
  58     {
  59         return userImpl.isReadOnly();
  60     }
  61
  62     public User createGuestUser()
  63     {
  64         return userImpl.createGuestUser();
  65     }
  66
  67     public User addUser( User user )
  68     {
  69         if ( user != null )
  70         {
  71             usersCache.remove( user.getPrincipal() );
  72         }
  73         return this.userImpl.addUser( user );
  74     }
  75
  76     public void addUserManagerListener( UserManagerListener listener )
  77     {
  78         this.userImpl.addUserManagerListener( listener );
  79     }
  80
  81     public void addUserUnchecked( User user )
  82     {
  83         if ( user != null )
  84         {
  85             usersCache.remove( user.getPrincipal() );
  86         }
  87         this.userImpl.addUserUnchecked( user );
  88     }
  89
  90     public User createUser( String username, String fullName, String emailAddress )
  91     {
  92         usersCache.remove( username );
  93         return this.userImpl.createUser( username, fullName, emailAddress );
  94     }
  95
  96     public void deleteUser( Object principal )
  97         throws UserNotFoundException
  98     {
  99         usersCache.remove( principal );
 100         this.userImpl.deleteUser( principal );
 101     }
 102
 103     public void deleteUser( String username )
 104         throws UserNotFoundException
 105     {
 106         usersCache.remove( username );
 107         this.userImpl.deleteUser( username );
 108     }
 109
 110     public void eraseDatabase()
 111     {
 112         try
 113         {
 114             this.userImpl.eraseDatabase();
 115         }
 116         finally
 117         {
 118             usersCache.clear();
 119         }
 120     }
 121
 122     public User findUser( String username )
 123         throws UserNotFoundException
 124     {
 125         if ( GUEST_USERNAME.equals( username ) )
 126         {
 127             return getGuestUser();
 128         }
 129
 130         Object el = usersCache.get( username );
 131         if ( el != null )
 132         {
 133             return (User) el;
 134         }
 135         else
 136         {
 137             User user = this.userImpl.findUser( username );
 138             usersCache.put( username, user );
 139             return user;
 140         }
 141     }
 142
 143     public User getGuestUser()
 144         throws UserNotFoundException
 145     {
 146         Object el = usersCache.get( GUEST_USERNAME );
 147         if ( el != null )
 148         {
 149             return (User) el;
 150         }
 151         else
 152         {
 153             User user = this.userImpl.getGuestUser();
 154             usersCache.put( GUEST_USERNAME, user );
 155             return user;
 156         }
 157     }
 158
 159     public User findUser( Object principal )
 160         throws UserNotFoundException
 161     {
 162         Object el = usersCache.get( principal );
 163         if ( el != null )
 164         {
 165             return (User) el;
 166         }
 167         else
 168         {
 169             User user = this.userImpl.findUser( principal );
 170             usersCache.put( principal, user );
 171             return user;
 172         }
 173     }
 174
 175     public UserQuery createUserQuery()
 176     {
 177         return userImpl.createUserQuery();
 178     }
 179
 180
 181     public List<User> findUsersByQuery( UserQuery query )
 182     {
 183         log.debug( "NOT CACHED - .findUsersByQuery(UserQuery)" );
 184         return this.userImpl.findUsersByQuery( query );
 185     }
 186
 187     public List<User> findUsersByEmailKey( String emailKey, boolean orderAscending )
 188     {
 189         log.debug( "NOT CACHED - .findUsersByEmailKey(String, boolean)" );
 190         return this.userImpl.findUsersByEmailKey( emailKey, orderAscending );
 191     }
 192
 193     public List<User> findUsersByFullNameKey( String fullNameKey, boolean orderAscending )
 194     {
 195         log.debug( "NOT CACHED - .findUsersByFullNameKey(String, boolean)" );
 196         return this.userImpl.findUsersByFullNameKey( fullNameKey, orderAscending );
 197     }
 198
 199     public List<User> findUsersByUsernameKey( String usernameKey, boolean orderAscending )
 200     {
 201         log.debug( "NOT CACHED - .findUsersByUsernameKey(String, boolean)" );
 202         return this.userImpl.findUsersByUsernameKey( usernameKey, orderAscending );
 203     }
 204
 205     public String getId()
 206     {
 207         return "Cached User Manager [" + this.userImpl.getId() + "]";
 208     }
 209
 210     public List<User> getUsers()
 211     {
 212         log.debug( "NOT CACHED - .getUsers()" );
 213         return this.userImpl.getUsers();
 214     }
 215
 216     public List<User> getUsers( boolean orderAscending )
 217     {
 218         log.debug( "NOT CACHED - .getUsers(boolean)" );
 219         return this.userImpl.getUsers( orderAscending );
 220     }
 221
 222     public void removeUserManagerListener( UserManagerListener listener )
 223     {
 224         this.userImpl.removeUserManagerListener( listener );
 225     }
 226
 227     public User updateUser( User user )
 228         throws UserNotFoundException
 229     {
 230         return updateUser( user, false );
 231     }
 232
 233     public User updateUser( User user, boolean passwordChangeRequired )
 234         throws UserNotFoundException
 235     {
 236         if ( user != null )
 237         {
 238             usersCache.remove( user.getPrincipal() );
 239         }
 240         return this.userImpl.updateUser( user, passwordChangeRequired );
 241     }
 242
 243     public boolean userExists( Object principal )
 244     {
 245         if ( usersCache.hasKey( principal ) )
 246         {
 247             return true;
 248         }
 249
 250         return this.userImpl.userExists( principal );
 251     }
 252
 253     public void userManagerInit( boolean freshDatabase )
 254     {
 255         if ( userImpl instanceof UserManager )
 256         {
 257             ( (UserManagerListener) this.userImpl ).userManagerInit( freshDatabase );
 258         }
 259
 260         usersCache.clear();
 261     }
 262
 263     public void userManagerUserAdded( User user )
 264     {
 265         if ( userImpl instanceof UserManager )
 266         {
 267             ( (UserManagerListener) this.userImpl ).userManagerUserAdded( user );
 268         }
 269
 270         if ( user != null )
 271         {
 272             usersCache.remove( user.getPrincipal() );
 273         }
 274     }
 275
 276     public void userManagerUserRemoved( User user )
 277     {
 278         if ( userImpl instanceof UserManager )
 279         {
 280             ( (UserManagerListener) this.userImpl ).userManagerUserRemoved( user );
 281         }
 282
 283         if ( user != null )
 284         {
 285             usersCache.remove( user.getPrincipal() );
 286         }
 287     }
 288
 289     public void userManagerUserUpdated( User user )
 290     {
 291         if ( userImpl instanceof UserManager )
 292         {
 293             ( (UserManagerListener) this.userImpl ).userManagerUserUpdated( user );
 294         }
 295
 296         if ( user != null )
 297         {
 298             usersCache.remove( user.getPrincipal() );
 299         }
 300     }
 301
 302     public UserManager getUserImpl()
 303     {
 304         return userImpl;
 305     }
 306
 307     public void setUserImpl( UserManager userImpl )
 308     {
 309         this.userImpl = userImpl;
 310     }
 311
 312     public Cache getUsersCache()
 313     {
 314         return usersCache;
 315     }
 316
 317     public void setUsersCache( Cache usersCache )
 318     {
 319         this.usersCache = usersCache;
 320     }
 321 }