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

   1 package org.apache.archiva.redback.users.ldap.ctl;
   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 java.util.Collection;
  23 import java.util.LinkedHashSet;
  24 import java.util.LinkedList;
  25 import java.util.List;
  26 import java.util.Set;
  27
  28 import javax.inject.Inject;
  29 import javax.inject.Named;
  30 import javax.naming.NamingEnumeration;
  31 import javax.naming.NamingException;
  32 import javax.naming.directory.DirContext;
  33 import javax.naming.directory.SearchControls;
  34 import javax.naming.directory.SearchResult;
  35
  36 import org.apache.archiva.redback.common.ldap.LdapUser;
  37 import org.apache.archiva.redback.common.ldap.LdapUserMapper;
  38 import org.apache.archiva.redback.common.ldap.UserMapper;
  39 import org.apache.archiva.redback.users.User;
  40 import org.apache.archiva.redback.users.UserManager;
  41 import org.apache.archiva.redback.common.ldap.MappingException;
  42 import org.apache.archiva.redback.users.ldap.LdapUserQuery;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45 import org.springframework.stereotype.Service;
  46
  47 /**
  48  * @author <a href="jesse@codehaus.org"> jesse
  49  * @version "$Id$"
  50  */
  51 @Service
  52 public class DefaultLdapController
  53     implements LdapController
  54 {
  55
  56     private Logger log = LoggerFactory.getLogger( getClass() );
  57
  58     @Inject
  59     @Named(value = "userMapper#ldap")
  60     private UserMapper mapper;
  61
  62     /**
  63          * @see org.codehaus.plexus.redback.users.ldap.ctl.LdapControllerI#removeUser(java.lang.Object, javax.naming.directory.DirContext)
  64          */
  65     public void removeUser( Object principal, DirContext context )
  66         throws LdapControllerException
  67     {
  68
  69     }
  70
  71     /**
  72          * @see org.codehaus.plexus.redback.users.ldap.ctl.LdapControllerI#updateUser(org.apache.archiva.redback.users.User, javax.naming.directory.DirContext)
  73          */
  74     public void updateUser( User user, DirContext context )
  75         throws LdapControllerException, MappingException
  76     {
  77
  78     }
  79
  80     /**
  81          * @see org.codehaus.plexus.redback.users.ldap.ctl.LdapControllerI#userExists(java.lang.Object, javax.naming.directory.DirContext)
  82          */
  83     public boolean userExists( Object key, DirContext context )
  84         throws LdapControllerException
  85     {
  86         NamingEnumeration<SearchResult> results = null;
  87         try
  88         {
  89             results = searchUsers( key, context );
  90             return results.hasMoreElements();
  91         }
  92         catch ( NamingException e )
  93         {
  94             throw new LdapControllerException( "Error searching for the existence of user: " + key, e );
  95         }
  96         finally
  97         {
  98             if ( results != null )
  99                 try
 100                 {
 101                     results.close();
 102                 }
 103                 catch ( NamingException e )
 104                 {
 105                     log.warn( "Error closing search results", e );
 106                 }
 107         }
 108     }
 109
 110     protected NamingEnumeration<SearchResult> searchUsers( Object key, DirContext context )
 111         throws NamingException
 112     {
 113         LdapUserQuery query = new LdapUserQuery();
 114         query.setUsername( "" + key );
 115         return searchUsers( context, null, query );
 116     }
 117
 118     protected NamingEnumeration<SearchResult> searchUsers( DirContext context )
 119         throws NamingException
 120     {
 121         return searchUsers( context, null, null );
 122     }
 123
 124     protected NamingEnumeration<SearchResult> searchUsers( DirContext context, String[] returnAttributes )
 125         throws NamingException
 126     {
 127         return searchUsers( context, returnAttributes, null );
 128     }
 129
 130     protected NamingEnumeration<SearchResult> searchUsers( DirContext context, String[] returnAttributes, LdapUserQuery query )
 131         throws NamingException
 132     {
 133         if ( query == null )
 134         {
 135             query = new LdapUserQuery();
 136         }
 137         SearchControls ctls = new SearchControls();
 138
 139         ctls.setDerefLinkFlag( true );
 140         ctls.setSearchScope( SearchControls.SUBTREE_SCOPE );
 141         ctls.setReturningAttributes( mapper.getReturningAttributes() );
 142         ctls.setCountLimit( ( (LdapUserMapper) mapper ).getMaxResultCount() );
 143
 144         String finalFilter = "(&(objectClass=" + mapper.getUserObjectClass() + ")" +
 145             ( mapper.getUserFilter() != null ? mapper.getUserFilter() : "" ) + query.getLdapFilter(mapper) + ")";
 146
 147         log.info( "Searching for users with filter: \'{}\'" + " from base dn: {}",finalFilter, mapper.getUserBaseDn() );
 148
 149         return context.search( mapper.getUserBaseDn(), finalFilter, ctls );
 150     }
 151
 152     /**
 153          * @see org.codehaus.plexus.redback.users.ldap.ctl.LdapControllerI#getUsers(javax.naming.directory.DirContext)
 154          */
 155     public Collection<User> getUsers( DirContext context )
 156         throws LdapControllerException, MappingException
 157     {
 158         NamingEnumeration<SearchResult> results = null;
 159         try
 160         {
 161             results = searchUsers( context, null, null );
 162             Set<User> users = new LinkedHashSet<User>();
 163
 164             while ( results.hasMoreElements() )
 165             {
 166                 SearchResult result = results.nextElement();
 167
 168                 users.add( mapper.getUser( result.getAttributes() ) );
 169             }
 170
 171             return users;
 172         }
 173         catch ( NamingException e )
 174         {
 175             String message = "Failed to retrieve ldap information for users.";
 176
 177             throw new LdapControllerException( message, e );
 178         }
 179         finally
 180         {
 181             if ( results != null )
 182                 try
 183                 {
 184                     results.close();
 185                 }
 186                 catch ( NamingException e )
 187                 {
 188                     log.warn( "failed to close search results", e );
 189                 }
 190         }
 191     }
 192
 193    /**
 194     * @see org.codehaus.plexus.redback.users.ldap.ctl.LdapControllerI#getUsersByQuery(org.apache.archiva.redback.users.ldap.LdapUserQuery, javax.naming.directory.DirContext)
 195     */
 196    public List<User> getUsersByQuery( LdapUserQuery query, DirContext context )
 197        throws LdapControllerException, MappingException
 198    {
 199        NamingEnumeration<SearchResult> results = null;
 200        try
 201        {
 202            results = searchUsers( context, null, query );
 203            List<User> users = new LinkedList<User>();
 204
 205            while ( results.hasMoreElements() )
 206            {
 207                SearchResult result = results.nextElement();
 208
 209                users.add( mapper.getUser( result.getAttributes() ) );
 210            }
 211
 212            return users;
 213        }
 214        catch ( NamingException e )
 215        {
 216            String message = "Failed to retrieve ldap information for users.";
 217
 218            throw new LdapControllerException( message, e );
 219        }
 220        finally
 221         {
 222             if ( results != null )
 223                 try
 224                 {
 225                     results.close();
 226                 }
 227                 catch ( NamingException e )
 228                 {
 229                     log.warn( "failed to close search results", e );
 230                 }
 231         }
 232    }
 233
 234     /**
 235          * @see org.codehaus.plexus.redback.users.ldap.ctl.LdapControllerI#createUser(org.apache.archiva.redback.users.User, javax.naming.directory.DirContext, boolean)
 236          */
 237     public void createUser( User user, DirContext context, boolean encodePasswordIfChanged )
 238         throws LdapControllerException, MappingException
 239     {
 240         if ( user == null )
 241         {
 242             return;
 243         }
 244         if ( user.getUsername().equals( UserManager.GUEST_USERNAME ) )
 245         {
 246             //We don't store guest
 247             return;
 248         }
 249
 250     }
 251
 252     /**
 253          * @see org.codehaus.plexus.redback.users.ldap.ctl.LdapControllerI#getUser(java.lang.Object, javax.naming.directory.DirContext)
 254          */
 255     public LdapUser getUser( Object key, DirContext context )
 256         throws LdapControllerException, MappingException
 257     {
 258         String username = key.toString();
 259
 260         log.info( "Searching for user: {}", username );
 261         LdapUserQuery query = new LdapUserQuery();
 262         query.setUsername( username );
 263
 264         NamingEnumeration<SearchResult> result = null;
 265         try
 266         {
 267             result = searchUsers( context, null, query );
 268
 269             if ( result.hasMoreElements() )
 270             {
 271                 SearchResult next = result.nextElement();
 272
 273                 return mapper.getUser( next.getAttributes() );
 274             }
 275             else
 276             {
 277                 return null;
 278             }
 279         }
 280         catch ( NamingException e )
 281         {
 282             String message = "Failed to retrieve information for user: " + username;
 283
 284             throw new LdapControllerException( message, e );
 285         }
 286         finally
 287         {
 288             if ( result != null )
 289                 try
 290                 {
 291                     result.close();
 292                 }
 293                 catch ( NamingException e )
 294                 {
 295                     log.warn( "failed to close search results", e );
 296                 }
 297         }
 298     }
 299
 300 }