This project has retired. For details please refer to its
Attic page.
1 package org.apache.archiva.rest.services;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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.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.lang3.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
58
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#default")
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
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 ArchivaRestServiceExceptionestServiceException.html#ArchivaRestServiceException">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
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 ArchivaRestServiceExceptionestServiceException.html#ArchivaRestServiceException">ArchivaRestServiceException newEx = new ArchivaRestServiceException(e.getMessage(), e);
218 newEx.setErrorKey("error.ldap.userMapper.init.failed");
219 throw newEx;
220 }
221 }
222
223
224
225
226 return Boolean.TRUE;
227 }
228 catch (ArchivaRestServiceException e) {
229 log.error(e.getMessage(), e);
230 throw e;
231 } catch ( Exception e )
232 {
233 log.error( e.getMessage(), e );
234 throw new ArchivaRestServiceException(e.getMessage(), e);
235 }
236 }
237
238 @Override
239 public List<UserManagerImplementationInformation> getUserManagerImplementationInformations()
240 throws ArchivaRestServiceException
241 {
242
243 Map<String, UserManager> beans = applicationContext.getBeansOfType( UserManager.class );
244
245 if ( beans.isEmpty() )
246 {
247 return Collections.emptyList();
248 }
249
250 List<UserManagerImplementationInformation> informations = new ArrayList<>( beans.size() );
251
252 for ( Map.Entry<String, UserManager> entry : beans.entrySet() )
253 {
254 UserManager userManager = applicationContext.getBean( entry.getKey(), UserManager.class );
255 if ( userManager.isFinalImplementation() )
256 {
257 UserManagerImplementationInformationnformation.html#UserManagerImplementationInformation">UserManagerImplementationInformation information = new UserManagerImplementationInformation();
258 information.setBeanId( StringUtils.substringAfter( entry.getKey(), "#" ) );
259 information.setDescriptionKey( userManager.getDescriptionKey() );
260 information.setReadOnly( userManager.isReadOnly() );
261 informations.add( information );
262 }
263 }
264
265 return informations;
266 }
267
268 @Override
269 public List<RBACManagerImplementationInformation> getRbacManagerImplementationInformations()
270 throws ArchivaRestServiceException
271 {
272 Map<String, RBACManager> beans = applicationContext.getBeansOfType( RBACManager.class );
273
274 if ( beans.isEmpty() )
275 {
276 return Collections.emptyList();
277 }
278
279 List<RBACManagerImplementationInformation> informations = new ArrayList<>( beans.size() );
280
281 for ( Map.Entry<String, RBACManager> entry : beans.entrySet() )
282 {
283 RBACManager rbacManager = applicationContext.getBean( entry.getKey(), RBACManager.class );
284 if ( rbacManager.isFinalImplementation() )
285 {
286 RBACManagerImplementationInformationnformation.html#RBACManagerImplementationInformation">RBACManagerImplementationInformation information = new RBACManagerImplementationInformation();
287 information.setBeanId( StringUtils.substringAfter( entry.getKey(), "#" ) );
288 information.setDescriptionKey( rbacManager.getDescriptionKey() );
289 information.setReadOnly( rbacManager.isReadOnly() );
290 informations.add( information );
291 }
292 }
293
294 return informations;
295 }
296
297 @Override
298 public RedbackImplementationsInformations getRedbackImplementationsInformations()
299 throws ArchivaRestServiceException
300 {
301 return new RedbackImplementationsInformations( getUserManagerImplementationInformations(),
302 getRbacManagerImplementationInformations() );
303 }
304
305 @Override
306 public Boolean checkLdapConnection()
307 throws ArchivaRestServiceException
308 {
309 LdapConnection ldapConnection = null;
310 try
311 {
312 ldapConnection = ldapConnectionFactory.getConnection();
313 }
314 catch ( LdapException e )
315 {
316 log.warn( "fail to get ldapConnection: {}", e.getMessage(), e );
317 throw new ArchivaRestServiceException( e.getMessage(), e );
318 }
319 finally
320 {
321
322 if ( ldapConnection != null )
323 {
324 ldapConnection.close();
325 }
326 }
327
328 return Boolean.TRUE;
329 }
330
331 @Override
332 public Boolean checkLdapConnection( LdapConfiguration ldapConfiguration )
333 throws ArchivaRestServiceException
334 {
335 LdapConnection ldapConnection = null;
336 try
337 {
338 LdapConnectionConfiguration ldapConnectionConfiguration =
339 new LdapConnectionConfiguration( ldapConfiguration.getHostName(), ldapConfiguration.getPort(),
340 ldapConfiguration.getBaseDn(), ldapConfiguration.getContextFactory(),
341 ldapConfiguration.getBindDn(), ldapConfiguration.getPassword(),
342 ldapConfiguration.getAuthenticationMethod(),
343 toProperties( ldapConfiguration.getExtraProperties() ) );
344 ldapConnectionConfiguration.setSsl( ldapConfiguration.isSsl() );
345
346 ldapConnection = ldapConnectionFactory.getConnection( ldapConnectionConfiguration );
347
348 ldapConnection.close();
349
350
351
352 ldapConnectionConfiguration =
353 new LdapConnectionConfiguration( ldapConfiguration.getHostName(), ldapConfiguration.getPort(),
354 ldapConfiguration.getBaseGroupsDn(),
355 ldapConfiguration.getContextFactory(), ldapConfiguration.getBindDn(),
356 ldapConfiguration.getPassword(),
357 ldapConfiguration.getAuthenticationMethod(),
358 toProperties( ldapConfiguration.getExtraProperties() ) );
359
360 ldapConnectionConfiguration.setSsl( ldapConfiguration.isSsl() );
361
362 ldapConnection = ldapConnectionFactory.getConnection( ldapConnectionConfiguration );
363 }
364 catch ( InvalidNameException e )
365 {
366 log.warn( "fail to get ldapConnection: {}", e.getMessage(), e );
367 throw new ArchivaRestServiceException( e.getMessage(), e );
368 }
369 catch ( LdapException e )
370 {
371 log.warn( "fail to get ldapConnection: {}", e.getMessage(), e );
372 throw new ArchivaRestServiceException( e.getMessage(), e );
373 }
374 finally
375 {
376
377 if ( ldapConnection != null )
378 {
379 ldapConnection.close();
380 }
381 }
382
383 return Boolean.TRUE;
384 }
385
386 private Properties toProperties( Map<String, String> map )
387 {
388 Properties properties = new Properties();
389 if ( map == null || map.isEmpty() )
390 {
391 return properties;
392 }
393 for ( Map.Entry<String, String> entry : map.entrySet() )
394 {
395 properties.put( entry.getKey(), entry.getValue() );
396 }
397 return properties;
398 }
399
400 }
401
402