This project has retired. For details please refer to its Attic page.
DefaultRedbackRuntimeConfigurationService xref
View Javadoc
1   package org.apache.archiva.rest.services;
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.beans.LdapConfiguration;
23  import org.apache.archiva.admin.model.beans.RedbackRuntimeConfiguration;
24  import org.apache.archiva.admin.model.runtime.RedbackRuntimeConfigurationAdmin;
25  import org.apache.archiva.redback.authentication.Authenticator;
26  import org.apache.archiva.redback.common.ldap.connection.LdapConnection;
27  import org.apache.archiva.redback.common.ldap.connection.LdapConnectionConfiguration;
28  import org.apache.archiva.redback.common.ldap.connection.LdapConnectionFactory;
29  import org.apache.archiva.redback.common.ldap.connection.LdapException;
30  import org.apache.archiva.redback.common.ldap.user.LdapUserMapper;
31  import org.apache.archiva.redback.components.cache.Cache;
32  import org.apache.archiva.redback.policy.CookieSettings;
33  import org.apache.archiva.redback.policy.PasswordRule;
34  import org.apache.archiva.redback.rbac.RBACManager;
35  import org.apache.archiva.redback.role.RoleManager;
36  import org.apache.archiva.redback.users.UserManager;
37  import org.apache.archiva.rest.api.model.RBACManagerImplementationInformation;
38  import org.apache.archiva.rest.api.model.RedbackImplementationsInformations;
39  import org.apache.archiva.rest.api.model.UserManagerImplementationInformation;
40  import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
41  import org.apache.archiva.rest.api.services.RedbackRuntimeConfigurationService;
42  import org.apache.commons.lang.StringUtils;
43  import org.springframework.context.ApplicationContext;
44  import org.springframework.stereotype.Service;
45  
46  import javax.inject.Inject;
47  import javax.inject.Named;
48  import javax.naming.InvalidNameException;
49  import java.util.ArrayList;
50  import java.util.Collection;
51  import java.util.Collections;
52  import java.util.List;
53  import java.util.Map;
54  import java.util.Properties;
55  
56  /**
57   * @author Olivier Lamy
58   * @since 1.4-M4
59   */
60  @Service("redbackRuntimeConfigurationService#rest")
61  public class DefaultRedbackRuntimeConfigurationService
62      extends AbstractRestService
63      implements RedbackRuntimeConfigurationService
64  {
65  
66      @Inject
67      private RedbackRuntimeConfigurationAdmin redbackRuntimeConfigurationAdmin;
68  
69      @Inject
70      @Named(value = "userManager#configurable")
71      private UserManager userManager;
72  
73      @Inject
74      @Named(value = "rbacManager#default")
75      private RBACManager rbacManager;
76  
77      @Inject
78      private RoleManager roleManager;
79  
80      @Inject
81      private ApplicationContext applicationContext;
82  
83      @Inject
84      @Named(value = "ldapConnectionFactory#configurable")
85      private LdapConnectionFactory ldapConnectionFactory;
86  
87      @Inject
88      @Named(value = "cache#users")
89      private Cache usersCache;
90  
91      @Inject
92      private LdapUserMapper ldapUserMapper;
93  
94  
95      @Override
96      public RedbackRuntimeConfiguration getRedbackRuntimeConfiguration()
97          throws ArchivaRestServiceException
98      {
99          try
100         {
101             RedbackRuntimeConfiguration redbackRuntimeConfiguration =
102                 redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration();
103 
104             log.debug( "getRedbackRuntimeConfiguration -> {}", redbackRuntimeConfiguration );
105 
106             return redbackRuntimeConfiguration;
107         }
108         catch ( RepositoryAdminException e )
109         {
110             throw new ArchivaRestServiceException( e.getMessage(), e );
111         }
112     }
113 
114     @Override
115     public Boolean updateRedbackRuntimeConfiguration( RedbackRuntimeConfiguration redbackRuntimeConfiguration )
116         throws ArchivaRestServiceException
117     {
118         try
119         {
120             // has user manager impl changed ?
121             boolean userManagerChanged = redbackRuntimeConfiguration.getUserManagerImpls().size()
122                 != redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration().getUserManagerImpls().size();
123 
124             userManagerChanged =
125                 userManagerChanged || ( redbackRuntimeConfiguration.getUserManagerImpls().toString().hashCode()
126                     != redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration().getUserManagerImpls().toString().hashCode() );
127 
128             boolean rbacManagerChanged = redbackRuntimeConfiguration.getRbacManagerImpls().size()
129                 != redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration().getRbacManagerImpls().size();
130 
131             rbacManagerChanged =
132                 rbacManagerChanged || ( redbackRuntimeConfiguration.getRbacManagerImpls().toString().hashCode()
133                     != redbackRuntimeConfigurationAdmin.getRedbackRuntimeConfiguration().getRbacManagerImpls().toString().hashCode() );
134 
135             boolean ldapConfigured = false;
136             for (String um : redbackRuntimeConfiguration.getUserManagerImpls()) {
137                 if (um.contains("ldap")) {
138                     ldapConfigured=true;
139                 }
140             }
141             if (!ldapConfigured) {
142                 for (String rbm : redbackRuntimeConfiguration.getRbacManagerImpls()) {
143                     if (rbm.contains("ldap")) {
144                         ldapConfigured = true;
145                     }
146                 }
147             }
148 
149             redbackRuntimeConfigurationAdmin.updateRedbackRuntimeConfiguration( redbackRuntimeConfiguration );
150 
151             if ( userManagerChanged )
152             {
153                 log.info( "user managerImpls changed to {} so reload it",
154                           redbackRuntimeConfiguration.getUserManagerImpls() );
155                 userManager.initialize();
156             }
157 
158             if ( rbacManagerChanged )
159             {
160                 log.info( "rbac manager changed to {} so reload it",
161                           redbackRuntimeConfiguration.getRbacManagerImpls() );
162                 rbacManager.initialize();
163                 roleManager.initialize();
164             }
165 
166             if (ldapConfigured) {
167                 try {
168                     ldapConnectionFactory.initialize();
169                 } catch (Exception e) {
170                     ArchivaRestServiceException newEx = new ArchivaRestServiceException(e.getMessage(), e);
171                     newEx.setErrorKey("error.ldap.connectionFactory.init.failed");
172                     throw newEx;
173                 }
174             }
175             Collection<PasswordRule> passwordRules = applicationContext.getBeansOfType( PasswordRule.class ).values();
176 
177             for ( PasswordRule passwordRule : passwordRules )
178             {
179                 passwordRule.initialize();
180             }
181 
182             Collection<CookieSettings> cookieSettingsList =
183                 applicationContext.getBeansOfType( CookieSettings.class ).values();
184 
185             for ( CookieSettings cookieSettings : cookieSettingsList )
186             {
187                 cookieSettings.initialize();
188             }
189 
190             Collection<Authenticator> authenticators =
191                 applicationContext.getBeansOfType( Authenticator.class ).values();
192 
193             for ( Authenticator authenticator : authenticators )
194             {
195                 try {
196                     log.debug("Initializing authenticatior "+authenticator.getId());
197                     authenticator.initialize();
198                 } catch (Exception e) {
199                     log.error("Initialization of authenticator failed "+authenticator.getId(),e);
200                 }
201             }
202 
203             // users cache
204             usersCache.setTimeToIdleSeconds(
205                 redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToIdleSeconds() );
206             usersCache.setTimeToLiveSeconds(
207                 redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToLiveSeconds() );
208             usersCache.setMaxElementsInMemory(
209                 redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsInMemory() );
210             usersCache.setMaxElementsOnDisk(
211                 redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsOnDisk() );
212 
213             if (ldapConfigured) {
214                 try {
215                     ldapUserMapper.initialize();
216                 } catch (Exception e) {
217                     ArchivaRestServiceException newEx = new ArchivaRestServiceException(e.getMessage(), e);
218                     newEx.setErrorKey("error.ldap.userMapper.init.failed");
219                     throw newEx;
220                 }
221             }
222 
223             //check repositories roles are here !!!
224 
225             return Boolean.TRUE;
226         }
227         catch (ArchivaRestServiceException e) {
228             log.error(e.getMessage(), e);
229             throw e;
230         } catch ( Exception e )
231         {
232             log.error( e.getMessage(), e );
233             throw new ArchivaRestServiceException(e.getMessage(), e);
234         }
235     }
236 
237     @Override
238     public List<UserManagerImplementationInformation> getUserManagerImplementationInformations()
239         throws ArchivaRestServiceException
240     {
241 
242         Map<String, UserManager> beans = applicationContext.getBeansOfType( UserManager.class );
243 
244         if ( beans.isEmpty() )
245         {
246             return Collections.emptyList();
247         }
248 
249         List<UserManagerImplementationInformation> informations = new ArrayList<>( beans.size() );
250 
251         for ( Map.Entry<String, UserManager> entry : beans.entrySet() )
252         {
253             UserManager userManager = applicationContext.getBean( entry.getKey(), UserManager.class );
254             if ( userManager.isFinalImplementation() )
255             {
256                 UserManagerImplementationInformation information = new UserManagerImplementationInformation();
257                 information.setBeanId( StringUtils.substringAfter( entry.getKey(), "#" ) );
258                 information.setDescriptionKey( userManager.getDescriptionKey() );
259                 information.setReadOnly( userManager.isReadOnly() );
260                 informations.add( information );
261             }
262         }
263 
264         return informations;
265     }
266 
267     @Override
268     public List<RBACManagerImplementationInformation> getRbacManagerImplementationInformations()
269         throws ArchivaRestServiceException
270     {
271         Map<String, RBACManager> beans = applicationContext.getBeansOfType( RBACManager.class );
272 
273         if ( beans.isEmpty() )
274         {
275             return Collections.emptyList();
276         }
277 
278         List<RBACManagerImplementationInformation> informations = new ArrayList<>( beans.size() );
279 
280         for ( Map.Entry<String, RBACManager> entry : beans.entrySet() )
281         {
282             RBACManager rbacManager = applicationContext.getBean( entry.getKey(), RBACManager.class );
283             if ( rbacManager.isFinalImplementation() )
284             {
285                 RBACManagerImplementationInformation information = new RBACManagerImplementationInformation();
286                 information.setBeanId( StringUtils.substringAfter( entry.getKey(), "#" ) );
287                 information.setDescriptionKey( rbacManager.getDescriptionKey() );
288                 information.setReadOnly( rbacManager.isReadOnly() );
289                 informations.add( information );
290             }
291         }
292 
293         return informations;
294     }
295 
296     @Override
297     public RedbackImplementationsInformations getRedbackImplementationsInformations()
298         throws ArchivaRestServiceException
299     {
300         return new RedbackImplementationsInformations( getUserManagerImplementationInformations(),
301                                                        getRbacManagerImplementationInformations() );
302     }
303 
304     @Override
305     public Boolean checkLdapConnection()
306         throws ArchivaRestServiceException
307     {
308         LdapConnection ldapConnection = null;
309         try
310         {
311             ldapConnection = ldapConnectionFactory.getConnection();
312         }
313         catch ( LdapException e )
314         {
315             log.warn( "fail to get ldapConnection: {}", e.getMessage(), e );
316             throw new ArchivaRestServiceException( e.getMessage(), e );
317         }
318         finally
319         {
320 
321             if ( ldapConnection != null )
322             {
323                 ldapConnection.close();
324             }
325         }
326 
327         return Boolean.TRUE;
328     }
329 
330     @Override
331     public Boolean checkLdapConnection( LdapConfiguration ldapConfiguration )
332         throws ArchivaRestServiceException
333     {
334         LdapConnection ldapConnection = null;
335         try
336         {
337             LdapConnectionConfiguration ldapConnectionConfiguration =
338                 new LdapConnectionConfiguration( ldapConfiguration.getHostName(), ldapConfiguration.getPort(),
339                                                  ldapConfiguration.getBaseDn(), ldapConfiguration.getContextFactory(),
340                                                  ldapConfiguration.getBindDn(), ldapConfiguration.getPassword(),
341                                                  ldapConfiguration.getAuthenticationMethod(),
342                                                  toProperties( ldapConfiguration.getExtraProperties() ) );
343             ldapConnectionConfiguration.setSsl( ldapConfiguration.isSsl() );
344 
345             ldapConnection = ldapConnectionFactory.getConnection( ldapConnectionConfiguration );
346 
347             ldapConnection.close();
348 
349             // verify groups dn value too
350 
351             ldapConnectionConfiguration =
352                 new LdapConnectionConfiguration( ldapConfiguration.getHostName(), ldapConfiguration.getPort(),
353                                                  ldapConfiguration.getBaseGroupsDn(),
354                                                  ldapConfiguration.getContextFactory(), ldapConfiguration.getBindDn(),
355                                                  ldapConfiguration.getPassword(),
356                                                  ldapConfiguration.getAuthenticationMethod(),
357                                                  toProperties( ldapConfiguration.getExtraProperties() ) );
358 
359             ldapConnectionConfiguration.setSsl( ldapConfiguration.isSsl() );
360 
361             ldapConnection = ldapConnectionFactory.getConnection( ldapConnectionConfiguration );
362         }
363         catch ( InvalidNameException e )
364         {
365             log.warn( "fail to get ldapConnection: {}", e.getMessage(), e );
366             throw new ArchivaRestServiceException( e.getMessage(), e );
367         }
368         catch ( LdapException e )
369         {
370             log.warn( "fail to get ldapConnection: {}", e.getMessage(), e );
371             throw new ArchivaRestServiceException( e.getMessage(), e );
372         }
373         finally
374         {
375 
376             if ( ldapConnection != null )
377             {
378                 ldapConnection.close();
379             }
380         }
381 
382         return Boolean.TRUE;
383     }
384 
385     private Properties toProperties( Map<String, String> map )
386     {
387         Properties properties = new Properties();
388         if ( map == null || map.isEmpty() )
389         {
390             return properties;
391         }
392         for ( Map.Entry<String, String> entry : map.entrySet() )
393         {
394             properties.put( entry.getKey(), entry.getValue() );
395         }
396         return properties;
397     }
398 
399 }
400 
401