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.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
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#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
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
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
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
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