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

   1 package org.apache.archiva.redback.authentication;
   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.policy.AccountLockedException;
  23 import org.apache.archiva.redback.policy.MustChangePasswordException;
  24 import org.springframework.context.ApplicationContext;
  25 import org.springframework.stereotype.Service;
  26
  27 import javax.annotation.PostConstruct;
  28 import javax.inject.Inject;
  29 import java.util.ArrayList;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33
  34
  35 /**
  36  * DefaultAuthenticationManager: the goal of the authentication manager is to act as a conduit for
  37  * authentication requests into different authentication schemes
  38  * <p/>
  39  * For example, the default implementation can be configured with any number of authenticators and will
  40  * sequentially try them for an authenticated result.  This allows you to have the standard user/pass
  41  * auth procedure followed by authentication based on a known key for 'remember me' type functionality.
  42  *
  43  * @author: Jesse McConnell <jesse@codehaus.org>
  44  */
  45 @Service("authenticationManager")
  46 public class DefaultAuthenticationManager
  47     implements AuthenticationManager
  48 {
  49
  50     private List<Authenticator> authenticators;
  51
  52     @Inject
  53     private ApplicationContext applicationContext;
  54
  55     @SuppressWarnings("unchecked")
  56     @PostConstruct
  57     public void initialize()
  58     {
  59         this.authenticators =
  60             new ArrayList<Authenticator>( applicationContext.getBeansOfType( Authenticator.class ).values() );
  61     }
  62
  63
  64     public String getId()
  65     {
  66         return "Default Authentication Manager - " + this.getClass().getName() + " : managed authenticators - " +
  67             knownAuthenticators();
  68     }
  69
  70     public AuthenticationResult authenticate( AuthenticationDataSource source )
  71         throws AccountLockedException, AuthenticationException, MustChangePasswordException
  72     {
  73         if ( authenticators == null || authenticators.size() == 0 )
  74         {
  75             return ( new AuthenticationResult( false, null, new AuthenticationException(
  76                 "no valid authenticators, can't authenticate" ) ) );
  77         }
  78
  79         // put AuthenticationResult exceptions in a map
  80         List<AuthenticationFailureCause> authnResultErrors = new ArrayList<AuthenticationFailureCause>();
  81         for ( Authenticator authenticator : authenticators )
  82         {
  83             if ( authenticator.supportsDataSource( source ) )
  84             {
  85                 AuthenticationResult authResult = authenticator.authenticate( source );
  86                 List<AuthenticationFailureCause> authenticationFailureCauses =
  87                     authResult.getAuthenticationFailureCauses();
  88
  89                 if ( authResult.isAuthenticated() )
  90                 {
  91                     return authResult;
  92                 }
  93
  94                 if ( authenticationFailureCauses != null )
  95                 {
  96                     authnResultErrors.addAll( authenticationFailureCauses );
  97                 }
  98                 else
  99                 {
 100                     if ( authResult.getException() != null )
 101                     {
 102                         authnResultErrors.add(
 103                             new AuthenticationFailureCause( AuthenticationConstants.AUTHN_RUNTIME_EXCEPTION,
 104                                                             authResult.getException().getMessage() ) );
 105                     }
 106                 }
 107
 108
 109             }
 110         }
 111
 112         return ( new AuthenticationResult( false, null, new AuthenticationException(
 113             "authentication failed on authenticators: " + knownAuthenticators() ), authnResultErrors ) );
 114     }
 115
 116     public List<Authenticator> getAuthenticators()
 117     {
 118         return authenticators;
 119     }
 120
 121     private String knownAuthenticators()
 122     {
 123         StringBuilder strbuf = new StringBuilder();
 124
 125         for ( Authenticator authenticator : authenticators )
 126         {
 127             strbuf.append( '(' ).append( authenticator.getId() ).append( ") " );
 128         }
 129
 130         return strbuf.toString();
 131     }
 132 }