This project has retired. For details please refer to its
Attic page.
1 package org.apache.archiva.admin.repository.runtime;
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.CacheConfiguration;
23 import org.apache.archiva.admin.model.beans.LdapConfiguration;
24 import org.apache.archiva.admin.model.beans.LdapGroupMapping;
25 import org.apache.archiva.admin.model.beans.RedbackRuntimeConfiguration;
26 import org.apache.archiva.admin.model.runtime.RedbackRuntimeConfigurationAdmin;
27 import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
28 import org.apache.archiva.configuration.ArchivaConfiguration;
29 import org.apache.archiva.configuration.Configuration;
30 import org.apache.archiva.configuration.IndeterminateConfigurationException;
31 import org.apache.archiva.redback.components.cache.Cache;
32 import org.apache.archiva.redback.components.registry.RegistryException;
33 import org.apache.archiva.redback.configuration.UserConfiguration;
34 import org.apache.archiva.redback.configuration.UserConfigurationException;
35 import org.apache.archiva.redback.configuration.UserConfigurationKeys;
36 import org.apache.commons.lang.StringUtils;
37 import org.slf4j.Logger;
38 import org.slf4j.LoggerFactory;
39 import org.springframework.stereotype.Service;
40
41 import javax.annotation.PostConstruct;
42 import javax.inject.Inject;
43 import javax.inject.Named;
44 import java.util.ArrayList;
45 import java.util.Arrays;
46 import java.util.Collection;
47 import java.util.HashSet;
48 import java.util.List;
49 import java.util.Map;
50 import java.util.Set;
51
52
53
54
55
56 @Service( "redbackRuntimeConfigurationAdmin#default" )
57 public class DefaultRedbackRuntimeConfigurationAdmin
58 extends AbstractRepositoryAdmin
59 implements RedbackRuntimeConfigurationAdmin, UserConfiguration
60 {
61
62 protected Logger log = LoggerFactory.getLogger( getClass() );
63
64 private ArchivaConfiguration archivaConfiguration;
65
66 private UserConfiguration userConfiguration;
67
68 private Cache usersCache;
69
70 @Inject
71 public DefaultRedbackRuntimeConfigurationAdmin( ArchivaConfiguration archivaConfiguration,
72 @Named( value = "userConfiguration#redback" )
73 UserConfiguration userConfiguration,
74 @Named( value = "cache#users" ) Cache usersCache )
75 {
76 this.archivaConfiguration = archivaConfiguration;
77 this.userConfiguration = userConfiguration;
78 this.usersCache = usersCache;
79 }
80
81 @PostConstruct
82 @Override
83 public void initialize()
84 throws UserConfigurationException
85 {
86 try
87 {
88 RedbackRuntimeConfiguration redbackRuntimeConfiguration = getRedbackRuntimeConfiguration();
89
90 if ( !redbackRuntimeConfiguration.isMigratedFromRedbackConfiguration() )
91 {
92
93 redbackRuntimeConfiguration = new RedbackRuntimeConfiguration();
94
95 String userManagerImpl =
96 userConfiguration.getConcatenatedList( UserConfigurationKeys.USER_MANAGER_IMPL,
97 DEFAULT_USER_MANAGER_IMPL );
98 if ( StringUtils.isNotEmpty( userManagerImpl ) )
99 {
100 String[] impls = StringUtils.split( userManagerImpl, ',' );
101 for ( String impl : impls )
102 {
103 redbackRuntimeConfiguration.getUserManagerImpls().add( impl );
104 }
105 }
106 else
107 {
108 redbackRuntimeConfiguration.getUserManagerImpls().add( DEFAULT_USER_MANAGER_IMPL );
109 }
110
111 String rbacManagerImpls =
112 userConfiguration.getConcatenatedList( UserConfigurationKeys.RBAC_MANAGER_IMPL,
113 DEFAULT_RBAC_MANAGER_IMPL );
114
115 if ( StringUtils.isNotEmpty( rbacManagerImpls ) )
116 {
117 String[] impls = StringUtils.split( rbacManagerImpls, ',' );
118 for ( String impl : impls )
119 {
120 redbackRuntimeConfiguration.getRbacManagerImpls().add( impl );
121 }
122 }
123 else
124 {
125 redbackRuntimeConfiguration.getRbacManagerImpls().add( DEFAULT_RBAC_MANAGER_IMPL );
126 }
127
128
129
130 LdapConfiguration ldapConfiguration = redbackRuntimeConfiguration.getLdapConfiguration();
131 if ( ldapConfiguration == null )
132 {
133 ldapConfiguration = new LdapConfiguration();
134 redbackRuntimeConfiguration.setLdapConfiguration( ldapConfiguration );
135 }
136
137 ldapConfiguration.setHostName(
138 userConfiguration.getString( UserConfigurationKeys.LDAP_HOSTNAME, null ) );
139 ldapConfiguration.setPort( userConfiguration.getInt( UserConfigurationKeys.LDAP_PORT, -1 ) );
140 ldapConfiguration.setSsl( userConfiguration.getBoolean( UserConfigurationKeys.LDAP_SSL, false ) );
141 ldapConfiguration.setBaseDn(
142 userConfiguration.getConcatenatedList( UserConfigurationKeys.LDAP_BASEDN, null ) );
143
144 ldapConfiguration.setBaseGroupsDn(
145 userConfiguration.getConcatenatedList( UserConfigurationKeys.LDAP_GROUPS_BASEDN,
146 ldapConfiguration.getBaseDn() ) );
147
148 ldapConfiguration.setContextFactory(
149 userConfiguration.getString( UserConfigurationKeys.LDAP_CONTEX_FACTORY,
150 isSunContextFactoryAvailable()
151 ? "com.sun.jndi.ldap.LdapCtxFactory"
152 : "" ) );
153 ldapConfiguration.setBindDn(
154 userConfiguration.getConcatenatedList( UserConfigurationKeys.LDAP_BINDDN, null ) );
155 ldapConfiguration.setPassword(
156 userConfiguration.getString( UserConfigurationKeys.LDAP_PASSWORD, null ) );
157 ldapConfiguration.setAuthenticationMethod(
158 userConfiguration.getString( UserConfigurationKeys.LDAP_AUTHENTICATION_METHOD, null ) );
159
160 ldapConfiguration.setWritable(
161 userConfiguration.getBoolean( UserConfigurationKeys.LDAP_WRITABLE, false ) );
162
163 ldapConfiguration.setUseRoleNameAsGroup(
164 userConfiguration.getBoolean( UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME, false ) );
165
166 boolean ldapBindAuthenticatorEnabled =
167 userConfiguration.getBoolean( UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED, false );
168 ldapConfiguration.setBindAuthenticatorEnabled( ldapBindAuthenticatorEnabled );
169
170
171
172
173
174 Collection<String> keys = userConfiguration.getKeys();
175
176 List<LdapGroupMapping> ldapGroupMappings = new ArrayList<>();
177
178 for ( String key : keys )
179 {
180 if ( key.startsWith( UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY ) )
181 {
182 String group =
183 StringUtils.substringAfter( key, UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY );
184 String val = userConfiguration.getConcatenatedList( key, "" );
185 if ( !StringUtils.isEmpty( val ) )
186 {
187 String[] roles = StringUtils.split( val, ',' );
188 ldapGroupMappings.add( new LdapGroupMapping( group, roles ) );
189 }
190 }
191 }
192
193 redbackRuntimeConfiguration.setLdapGroupMappings( ldapGroupMappings );
194
195 redbackRuntimeConfiguration.setMigratedFromRedbackConfiguration( true );
196
197 updateRedbackRuntimeConfiguration( redbackRuntimeConfiguration );
198
199 }
200
201 if ( redbackRuntimeConfiguration.getUserManagerImpls().isEmpty() )
202 {
203 log.info(
204 "redbackRuntimeConfiguration with empty userManagerImpls so force at least jdo implementation !" );
205 redbackRuntimeConfiguration.getUserManagerImpls().add( "jdo" );
206 updateRedbackRuntimeConfiguration( redbackRuntimeConfiguration );
207 }
208 else
209 {
210 log.info( "using userManagerImpls: {}", redbackRuntimeConfiguration.getUserManagerImpls() );
211 }
212
213
214 if ( redbackRuntimeConfiguration.getRbacManagerImpls().isEmpty() )
215 {
216 log.info(
217 "redbackRuntimeConfiguration with empty rbacManagerImpls so force at least cached implementation !" );
218 redbackRuntimeConfiguration.getRbacManagerImpls().add( "cached" );
219 updateRedbackRuntimeConfiguration( redbackRuntimeConfiguration );
220 }
221 else
222 {
223 log.info( "using rbacManagerImpls: {}", redbackRuntimeConfiguration.getRbacManagerImpls() );
224 }
225
226 boolean save = false;
227
228
229 if ( redbackRuntimeConfiguration.getUsersCacheConfiguration() == null )
230 {
231 redbackRuntimeConfiguration.setUsersCacheConfiguration( new CacheConfiguration() );
232 }
233
234 if ( redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToIdleSeconds() < 0 )
235 {
236 redbackRuntimeConfiguration.getUsersCacheConfiguration().setTimeToIdleSeconds(
237 usersCache.getTimeToIdleSeconds() );
238 save = true;
239
240 }
241 usersCache.setTimeToIdleSeconds(
242 redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToIdleSeconds() );
243
244 if ( redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToLiveSeconds() < 0 )
245 {
246 redbackRuntimeConfiguration.getUsersCacheConfiguration().setTimeToLiveSeconds(
247 usersCache.getTimeToLiveSeconds() );
248 save = true;
249
250 }
251 usersCache.setTimeToLiveSeconds(
252 redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToLiveSeconds() );
253
254 if ( redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsInMemory() < 0 )
255 {
256 redbackRuntimeConfiguration.getUsersCacheConfiguration().setMaxElementsInMemory(
257 usersCache.getMaxElementsInMemory() );
258 save = true;
259 }
260 usersCache.setMaxElementsInMemory(
261 redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsInMemory() );
262
263 if ( redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsOnDisk() < 0 )
264 {
265 redbackRuntimeConfiguration.getUsersCacheConfiguration().setMaxElementsOnDisk(
266 usersCache.getMaxElementsOnDisk() );
267 save = true;
268 }
269 usersCache.setMaxElementsOnDisk(
270 redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsOnDisk() );
271
272 if ( save )
273 {
274 updateRedbackRuntimeConfiguration( redbackRuntimeConfiguration );
275 }
276
277 }
278 catch ( RepositoryAdminException e )
279 {
280 throw new UserConfigurationException( e.getMessage(), e );
281 }
282 }
283
284 private boolean isSunContextFactoryAvailable()
285 {
286 try
287 {
288 return Thread.currentThread().getContextClassLoader().loadClass( "com.sun.jndi.ldap.LdapCtxFactory" )
289 != null;
290 }
291 catch ( ClassNotFoundException e )
292 {
293 return false;
294 }
295 }
296
297 @Override
298 public RedbackRuntimeConfiguration getRedbackRuntimeConfiguration()
299 {
300 return build( archivaConfiguration.getConfiguration().getRedbackRuntimeConfiguration() );
301 }
302
303 @Override
304 public void updateRedbackRuntimeConfiguration( RedbackRuntimeConfiguration redbackRuntimeConfiguration )
305 throws RepositoryAdminException
306 {
307 org.apache.archiva.configuration.RedbackRuntimeConfiguration runtimeConfiguration =
308 build( redbackRuntimeConfiguration );
309 Configuration configuration = archivaConfiguration.getConfiguration();
310 configuration.setRedbackRuntimeConfiguration( runtimeConfiguration );
311 try
312 {
313 archivaConfiguration.save( configuration );
314 }
315 catch ( RegistryException e )
316 {
317 throw new RepositoryAdminException( e.getMessage(), e );
318 }
319 catch ( IndeterminateConfigurationException e )
320 {
321 throw new RepositoryAdminException( e.getMessage(), e );
322 }
323 }
324
325 private RedbackRuntimeConfiguration build(
326 org.apache.archiva.configuration.RedbackRuntimeConfiguration runtimeConfiguration )
327 {
328 RedbackRuntimeConfiguration redbackRuntimeConfiguration =
329 getModelMapper().map( runtimeConfiguration, RedbackRuntimeConfiguration.class );
330
331 if ( runtimeConfiguration.getLdapConfiguration() != null )
332 {
333 redbackRuntimeConfiguration.setLdapConfiguration(
334 getModelMapper().map( runtimeConfiguration.getLdapConfiguration(), LdapConfiguration.class ) );
335 }
336
337 if ( runtimeConfiguration.getUsersCacheConfiguration() != null )
338 {
339 redbackRuntimeConfiguration.setUsersCacheConfiguration(
340 getModelMapper().map( runtimeConfiguration.getUsersCacheConfiguration(), CacheConfiguration.class ) );
341 }
342
343 if ( redbackRuntimeConfiguration.getLdapConfiguration() == null )
344 {
345
346 redbackRuntimeConfiguration.setLdapConfiguration( new LdapConfiguration() );
347 }
348
349 if ( redbackRuntimeConfiguration.getUsersCacheConfiguration() == null )
350 {
351 redbackRuntimeConfiguration.setUsersCacheConfiguration( new CacheConfiguration() );
352 }
353
354 List<org.apache.archiva.configuration.LdapGroupMapping> mappings = runtimeConfiguration.getLdapGroupMappings();
355
356 if ( mappings != null && mappings.size() > 0 )
357 {
358 List<LdapGroupMapping> ldapGroupMappings = new ArrayList<>( mappings.size() );
359
360 for ( org.apache.archiva.configuration.LdapGroupMapping mapping : mappings )
361 {
362 ldapGroupMappings.add( new LdapGroupMapping( mapping.getGroup(), mapping.getRoleNames() ) );
363 }
364
365 redbackRuntimeConfiguration.setLdapGroupMappings( ldapGroupMappings );
366 }
367
368 cleanupProperties( redbackRuntimeConfiguration );
369
370 return redbackRuntimeConfiguration;
371 }
372
373
374
375
376
377
378 private void cleanupProperties( RedbackRuntimeConfiguration redbackRuntimeConfiguration )
379 {
380 Map<String, String> properties = redbackRuntimeConfiguration.getConfigurationProperties();
381 properties.remove( UserConfigurationKeys.LDAP_HOSTNAME );
382 properties.remove( UserConfigurationKeys.LDAP_PORT );
383 properties.remove( UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED );
384 properties.remove( UserConfigurationKeys.LDAP_SSL );
385 properties.remove( UserConfigurationKeys.LDAP_BASEDN );
386 properties.remove( UserConfigurationKeys.LDAP_GROUPS_BASEDN );
387 properties.remove( UserConfigurationKeys.LDAP_CONTEX_FACTORY );
388 properties.remove( UserConfigurationKeys.LDAP_BINDDN );
389 properties.remove( UserConfigurationKeys.LDAP_PASSWORD );
390 properties.remove( UserConfigurationKeys.LDAP_AUTHENTICATION_METHOD );
391 properties.remove( UserConfigurationKeys.LDAP_WRITABLE );
392 properties.remove( UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME );
393
394
395
396
397
398
399
400
401
402 }
403
404 private org.apache.archiva.configuration.RedbackRuntimeConfiguration build(
405 RedbackRuntimeConfiguration redbackRuntimeConfiguration )
406 {
407 org.apache.archiva.configuration.RedbackRuntimeConfiguration res =
408 getModelMapper().map( redbackRuntimeConfiguration,
409 org.apache.archiva.configuration.RedbackRuntimeConfiguration.class );
410
411 if ( redbackRuntimeConfiguration.getLdapConfiguration() == null )
412 {
413 redbackRuntimeConfiguration.setLdapConfiguration( new LdapConfiguration() );
414 }
415 res.setLdapConfiguration( getModelMapper().map( redbackRuntimeConfiguration.getLdapConfiguration(),
416 org.apache.archiva.configuration.LdapConfiguration.class ) );
417
418 if ( redbackRuntimeConfiguration.getUsersCacheConfiguration() == null )
419 {
420 redbackRuntimeConfiguration.setUsersCacheConfiguration( new CacheConfiguration() );
421 }
422
423 res.setUsersCacheConfiguration( getModelMapper().map( redbackRuntimeConfiguration.getUsersCacheConfiguration(),
424 org.apache.archiva.configuration.CacheConfiguration.class ) );
425
426 List<LdapGroupMapping> ldapGroupMappings = redbackRuntimeConfiguration.getLdapGroupMappings();
427
428 if ( ldapGroupMappings != null && ldapGroupMappings.size() > 0 )
429 {
430
431 List<org.apache.archiva.configuration.LdapGroupMapping> mappings =
432 new ArrayList<>( ldapGroupMappings.size() );
433
434 for ( LdapGroupMapping ldapGroupMapping : ldapGroupMappings )
435 {
436
437 org.apache.archiva.configuration.LdapGroupMapping mapping =
438 new org.apache.archiva.configuration.LdapGroupMapping();
439 mapping.setGroup( ldapGroupMapping.getGroup() );
440 mapping.setRoleNames( new ArrayList<>( ldapGroupMapping.getRoleNames() ) );
441 mappings.add( mapping );
442
443 }
444 res.setLdapGroupMappings( mappings );
445 }
446 return res;
447 }
448
449
450
451
452 @Override
453 public String getString( String key )
454 {
455 if ( UserConfigurationKeys.USER_MANAGER_IMPL.equals( key ) )
456 {
457
458 return getRedbackRuntimeConfiguration().getUserManagerImpls().get( 0 );
459 }
460
461 if ( StringUtils.startsWith( key, UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY ) )
462 {
463 RedbackRuntimeConfiguration redbackRuntimeConfiguration = getRedbackRuntimeConfiguration();
464 int index = redbackRuntimeConfiguration.getLdapGroupMappings().indexOf( new LdapGroupMapping(
465 StringUtils.substringAfter( key, UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY ) ) );
466 if ( index > -1 )
467 {
468 return StringUtils.join( redbackRuntimeConfiguration.getLdapGroupMappings().get( index ).getRoleNames(),
469 ',' );
470 }
471 }
472
473 RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration();
474
475 if ( conf.getConfigurationProperties().containsKey( key ) )
476 {
477 return conf.getConfigurationProperties().get( key );
478 }
479
480 String value = userConfiguration.getString( key );
481 if ( value == null )
482 {
483 return null;
484 }
485 conf.getConfigurationProperties().put( key, value );
486
487 try
488 {
489 updateRedbackRuntimeConfiguration( conf );
490 }
491 catch ( RepositoryAdminException e )
492 {
493 log.error( "fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e );
494 throw new RuntimeException( e.getMessage(), e );
495 }
496
497 return value;
498 }
499
500 @Override
501 public String getString( String key, String defaultValue )
502 {
503 if ( UserConfigurationKeys.LDAP_HOSTNAME.equals( key ) )
504 {
505 return getRedbackRuntimeConfiguration().getLdapConfiguration().getHostName();
506 }
507 if ( UserConfigurationKeys.LDAP_CONTEX_FACTORY.equals( key ) )
508 {
509 return getRedbackRuntimeConfiguration().getLdapConfiguration().getContextFactory();
510 }
511 if ( UserConfigurationKeys.LDAP_PASSWORD.equals( key ) )
512 {
513 return getRedbackRuntimeConfiguration().getLdapConfiguration().getPassword();
514 }
515 if ( UserConfigurationKeys.LDAP_AUTHENTICATION_METHOD.equals( key ) )
516 {
517 return getRedbackRuntimeConfiguration().getLdapConfiguration().getAuthenticationMethod();
518 }
519
520 RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration();
521
522 if ( conf.getConfigurationProperties().containsKey( key ) )
523 {
524 return conf.getConfigurationProperties().get( key );
525 }
526
527 String value = userConfiguration.getString( key, defaultValue );
528
529 if ( value == null )
530 {
531 return null;
532 }
533
534 conf.getConfigurationProperties().put( key, value );
535 try
536 {
537 updateRedbackRuntimeConfiguration( conf );
538 }
539 catch ( RepositoryAdminException e )
540 {
541 log.error( "fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e );
542 throw new RuntimeException( e.getMessage(), e );
543 }
544
545 return value;
546 }
547
548 @Override
549 public int getInt( String key )
550 {
551 RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration();
552
553 if ( conf.getConfigurationProperties().containsKey( key ) )
554 {
555 return Integer.valueOf( conf.getConfigurationProperties().get( key ) );
556 }
557
558 int value = userConfiguration.getInt( key );
559
560 conf.getConfigurationProperties().put( key, Integer.toString( value ) );
561 try
562 {
563 updateRedbackRuntimeConfiguration( conf );
564 }
565 catch ( RepositoryAdminException e )
566 {
567 log.error( "fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e );
568 throw new RuntimeException( e.getMessage(), e );
569 }
570
571 return value;
572 }
573
574 @Override
575 public int getInt( String key, int defaultValue )
576 {
577 if ( UserConfigurationKeys.LDAP_PORT.equals( key ) )
578 {
579 return getRedbackRuntimeConfiguration().getLdapConfiguration().getPort();
580 }
581
582 RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration();
583
584 if ( conf.getConfigurationProperties().containsKey( key ) )
585 {
586 return Integer.valueOf( conf.getConfigurationProperties().get( key ) );
587 }
588
589 int value = userConfiguration.getInt( key, defaultValue );
590
591 conf.getConfigurationProperties().put( key, Integer.toString( value ) );
592 try
593 {
594 updateRedbackRuntimeConfiguration( conf );
595 }
596 catch ( RepositoryAdminException e )
597 {
598 log.error( "fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e );
599 throw new RuntimeException( e.getMessage(), e );
600 }
601
602 return value;
603 }
604
605 @Override
606 public boolean getBoolean( String key )
607 {
608 RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration();
609
610 if ( UserConfigurationKeys.LDAP_WRITABLE.equals( key ) )
611 {
612 return conf.getLdapConfiguration().isWritable();
613 }
614
615 if ( UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME.equals( key ) )
616 {
617 return conf.getLdapConfiguration().isUseRoleNameAsGroup();
618 }
619
620 if ( UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED.equals( key ) )
621 {
622 return conf.getLdapConfiguration().isBindAuthenticatorEnabled();
623 }
624
625 if ( conf.getConfigurationProperties().containsKey( key ) )
626 {
627 return Boolean.valueOf( conf.getConfigurationProperties().get( key ) );
628 }
629
630 boolean value = userConfiguration.getBoolean( key );
631
632 conf.getConfigurationProperties().put( key, Boolean.toString( value ) );
633 try
634 {
635 updateRedbackRuntimeConfiguration( conf );
636 }
637 catch ( RepositoryAdminException e )
638 {
639 log.error( "fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e );
640 throw new RuntimeException( e.getMessage(), e );
641 }
642
643 return value;
644 }
645
646 @Override
647 public boolean getBoolean( String key, boolean defaultValue )
648 {
649 if ( UserConfigurationKeys.LDAP_SSL.equals( key ) )
650 {
651 return getRedbackRuntimeConfiguration().getLdapConfiguration().isSsl();
652 }
653
654 if ( UserConfigurationKeys.LDAP_WRITABLE.equals( key ) )
655 {
656 return getRedbackRuntimeConfiguration().getLdapConfiguration().isWritable();
657 }
658
659 if ( UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME.equals( key ) )
660 {
661 return getRedbackRuntimeConfiguration().getLdapConfiguration().isUseRoleNameAsGroup();
662 }
663
664 if ( UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED.equals( key ) )
665 {
666 return getRedbackRuntimeConfiguration().getLdapConfiguration().isBindAuthenticatorEnabled();
667 }
668
669 RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration();
670
671 if ( conf.getConfigurationProperties().containsKey( key ) )
672 {
673 return Boolean.valueOf( conf.getConfigurationProperties().get( key ) );
674 }
675
676 boolean value = userConfiguration.getBoolean( key, defaultValue );
677
678 conf.getConfigurationProperties().put( key, Boolean.toString( value ) );
679 try
680 {
681 updateRedbackRuntimeConfiguration( conf );
682 }
683 catch ( RepositoryAdminException e )
684 {
685 log.error( "fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e );
686 throw new RuntimeException( e.getMessage(), e );
687 }
688
689 return value;
690 }
691
692 @Override
693 public List<String> getList( String key )
694 {
695 RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration();
696 if (conf.getConfigurationProperties().containsKey(key)) {
697 return Arrays.asList(conf.getConfigurationProperties().get(key).split(","));
698 }
699
700 List<String> value = userConfiguration.getList( key );
701
702 conf.getConfigurationProperties().put( key, "" );
703 try
704 {
705 updateRedbackRuntimeConfiguration( conf );
706 }
707 catch ( RepositoryAdminException e )
708 {
709 log.error( "fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e );
710 throw new RuntimeException( e.getMessage(), e );
711 }
712
713 return value;
714 }
715
716 @Override
717 public String getConcatenatedList( String key, String defaultValue )
718 {
719 if ( UserConfigurationKeys.LDAP_BASEDN.equals( key ) )
720 {
721 return getRedbackRuntimeConfiguration().getLdapConfiguration().getBaseDn();
722 }
723 if ( UserConfigurationKeys.LDAP_BINDDN.equals( key ) )
724 {
725 return getRedbackRuntimeConfiguration().getLdapConfiguration().getBindDn();
726 }
727 if ( UserConfigurationKeys.LDAP_GROUPS_BASEDN.equals( key ) )
728 {
729 return getRedbackRuntimeConfiguration().getLdapConfiguration().getBaseGroupsDn();
730 }
731 return userConfiguration.getConcatenatedList( key, defaultValue );
732 }
733
734 @Override
735 public Collection<String> getKeys()
736 {
737 Collection<String> keys = userConfiguration.getKeys();
738
739 Set<String> keysSet = new HashSet<>( keys );
740
741 keysSet.addAll( getRedbackRuntimeConfiguration().getConfigurationProperties().keySet() );
742
743 return keysSet;
744 }
745
746
747 }