Source code

001package org.apache.archiva.admin.repository.runtime;
002/*
003 * Licensed to the Apache Software Foundation (ASF) under one
004 * or more contributor license agreements.  See the NOTICE file
005 * distributed with this work for additional information
006 * regarding copyright ownership.  The ASF licenses this file
007 * to you under the Apache License, Version 2.0 (the
008 * "License"); you may not use this file except in compliance
009 * with the License.  You may obtain a copy of the License at
010 *
011 *   http://www.apache.org/licenses/LICENSE-2.0
012 *
013 * Unless required by applicable law or agreed to in writing,
014 * software distributed under the License is distributed on an
015 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
016 * KIND, either express or implied.  See the License for the
017 * specific language governing permissions and limitations
018 * under the License.
019 */
020
021import org.apache.archiva.admin.model.RepositoryAdminException;
022import org.apache.archiva.admin.model.beans.CacheConfiguration;
023import org.apache.archiva.admin.model.beans.LdapConfiguration;
024import org.apache.archiva.admin.model.beans.LdapGroupMapping;
025import org.apache.archiva.admin.model.beans.RedbackRuntimeConfiguration;
026import org.apache.archiva.admin.model.runtime.RedbackRuntimeConfigurationAdmin;
027import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
028import org.apache.archiva.configuration.ArchivaConfiguration;
029import org.apache.archiva.configuration.Configuration;
030import org.apache.archiva.configuration.IndeterminateConfigurationException;
031import org.apache.archiva.redback.components.cache.Cache;
032import org.apache.archiva.redback.components.registry.RegistryException;
033import org.apache.archiva.redback.configuration.UserConfiguration;
034import org.apache.archiva.redback.configuration.UserConfigurationException;
035import org.apache.archiva.redback.configuration.UserConfigurationKeys;
036import org.apache.commons.lang.StringUtils;
037import org.slf4j.Logger;
038import org.slf4j.LoggerFactory;
039import org.springframework.stereotype.Service;
040
041import javax.annotation.PostConstruct;
042import javax.inject.Inject;
043import javax.inject.Named;
044import java.util.ArrayList;
045import java.util.Arrays;
046import java.util.Collection;
047import java.util.HashSet;
048import java.util.List;
049import java.util.Map;
050import java.util.Set;
051
052/**
053 * @author Olivier Lamy
054 * @since 1.4-M4
055 */
056@Service( "redbackRuntimeConfigurationAdmin#default" )
057public class DefaultRedbackRuntimeConfigurationAdmin
058    extends AbstractRepositoryAdmin
059    implements RedbackRuntimeConfigurationAdmin, UserConfiguration
060{
061
062    protected Logger log = LoggerFactory.getLogger( getClass() );
063
064    private ArchivaConfiguration archivaConfiguration;
065
066    private UserConfiguration userConfiguration;
067
068    private Cache usersCache;
069
070    @Inject
071    public DefaultRedbackRuntimeConfigurationAdmin( ArchivaConfiguration archivaConfiguration,//
072                                                    @Named( value = "userConfiguration#redback" ) //
073                                                        UserConfiguration userConfiguration,
074                                                    @Named( value = "cache#users" ) Cache usersCache )
075    {
076        this.archivaConfiguration = archivaConfiguration;
077        this.userConfiguration = userConfiguration;
078        this.usersCache = usersCache;
079    }
080
081    @PostConstruct
082    @Override
083    public void initialize()
084        throws UserConfigurationException
085    {
086        try
087        {
088            RedbackRuntimeConfiguration redbackRuntimeConfiguration = getRedbackRuntimeConfiguration();
089            // migrate or not data from redback
090            if ( !redbackRuntimeConfiguration.isMigratedFromRedbackConfiguration() )
091            {
092                // not migrated so build a new fresh one
093                redbackRuntimeConfiguration = new RedbackRuntimeConfiguration();
094                // so migrate if available
095                String userManagerImpl =
096                    userConfiguration.getConcatenatedList( UserConfigurationKeys.USER_MANAGER_IMPL, //
097                                                           DEFAULT_USER_MANAGER_IMPL );
098                if ( StringUtils.isNotEmpty( userManagerImpl ) )
099                {
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                // now ldap
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                // LDAP groups mapping reading !!
171                // UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY
172                // userConfiguration.getKeys()
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            // we must ensure userManagerImpls list is not empty if so put at least jdo one !
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            // we ensure rbacManagerImpls is not empty if so put at least cached
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            // NPE free
229            if ( redbackRuntimeConfiguration.getUsersCacheConfiguration() == null )
230            {
231                redbackRuntimeConfiguration.setUsersCacheConfiguration( new CacheConfiguration() );
232            }
233            // if -1 it means non initialized to take values from the spring bean
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            // prevent NPE
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     * cleaning from map properties used directly in archiva configuration fields
375     *
376     * @param redbackRuntimeConfiguration
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        // cleanup groups <-> role mapping
395        /**for ( Map.Entry<String, String> entry : new HashMap<String, String>( properties ).entrySet() )
396         {
397         if ( entry.getKey().startsWith( UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY ) )
398         {
399         properties.remove( entry.getKey() );
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    // wrapper for UserConfiguration to intercept values (and store it not yet migrated)
450
451
452    @Override
453    public String getString( String key )
454    {
455        if ( UserConfigurationKeys.USER_MANAGER_IMPL.equals( key ) )
456        {
457            // possible false for others than archiva user manager
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}