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