Java tutorial
package org.apache.archiva.admin.repository.runtime; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import org.apache.archiva.admin.model.RepositoryAdminException; import org.apache.archiva.admin.model.beans.CacheConfiguration; import org.apache.archiva.admin.model.beans.LdapConfiguration; import org.apache.archiva.admin.model.beans.LdapGroupMapping; import org.apache.archiva.admin.model.beans.RedbackRuntimeConfiguration; import org.apache.archiva.admin.model.runtime.RedbackRuntimeConfigurationAdmin; import org.apache.archiva.admin.repository.AbstractRepositoryAdmin; import org.apache.archiva.configuration.ArchivaConfiguration; import org.apache.archiva.configuration.Configuration; import org.apache.archiva.configuration.IndeterminateConfigurationException; import org.apache.archiva.redback.components.cache.Cache; import org.apache.archiva.redback.components.registry.RegistryException; import org.apache.archiva.redback.configuration.UserConfiguration; import org.apache.archiva.redback.configuration.UserConfigurationException; import org.apache.archiva.redback.configuration.UserConfigurationKeys; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Service; import javax.annotation.PostConstruct; import javax.inject.Inject; import javax.inject.Named; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; /** * @author Olivier Lamy * @since 1.4-M4 */ @Service("redbackRuntimeConfigurationAdmin#default") public class DefaultRedbackRuntimeConfigurationAdmin extends AbstractRepositoryAdmin implements RedbackRuntimeConfigurationAdmin, UserConfiguration { protected Logger log = LoggerFactory.getLogger(getClass()); private ArchivaConfiguration archivaConfiguration; private UserConfiguration userConfiguration; private Cache usersCache; @Inject public DefaultRedbackRuntimeConfigurationAdmin(ArchivaConfiguration archivaConfiguration, // @Named(value = "userConfiguration#redback") // UserConfiguration userConfiguration, @Named(value = "cache#users") Cache usersCache) { this.archivaConfiguration = archivaConfiguration; this.userConfiguration = userConfiguration; this.usersCache = usersCache; } @PostConstruct @Override public void initialize() throws UserConfigurationException { try { RedbackRuntimeConfiguration redbackRuntimeConfiguration = getRedbackRuntimeConfiguration(); // migrate or not data from redback if (!redbackRuntimeConfiguration.isMigratedFromRedbackConfiguration()) { // not migrated so build a new fresh one redbackRuntimeConfiguration = new RedbackRuntimeConfiguration(); // so migrate if available String userManagerImpl = userConfiguration.getConcatenatedList( UserConfigurationKeys.USER_MANAGER_IMPL, // DEFAULT_USER_MANAGER_IMPL); if (StringUtils.isNotEmpty(userManagerImpl)) { String[] impls = StringUtils.split(userManagerImpl, ','); for (String impl : impls) { redbackRuntimeConfiguration.getUserManagerImpls().add(impl); } } else { redbackRuntimeConfiguration.getUserManagerImpls().add(DEFAULT_USER_MANAGER_IMPL); } String rbacManagerImpls = userConfiguration.getConcatenatedList( UserConfigurationKeys.RBAC_MANAGER_IMPL, // DEFAULT_RBAC_MANAGER_IMPL); if (StringUtils.isNotEmpty(rbacManagerImpls)) { String[] impls = StringUtils.split(rbacManagerImpls, ','); for (String impl : impls) { redbackRuntimeConfiguration.getRbacManagerImpls().add(impl); } } else { redbackRuntimeConfiguration.getRbacManagerImpls().add(DEFAULT_RBAC_MANAGER_IMPL); } // now ldap LdapConfiguration ldapConfiguration = redbackRuntimeConfiguration.getLdapConfiguration(); if (ldapConfiguration == null) { ldapConfiguration = new LdapConfiguration(); redbackRuntimeConfiguration.setLdapConfiguration(ldapConfiguration); } ldapConfiguration .setHostName(userConfiguration.getString(UserConfigurationKeys.LDAP_HOSTNAME, null)); ldapConfiguration.setPort(userConfiguration.getInt(UserConfigurationKeys.LDAP_PORT, -1)); ldapConfiguration.setSsl(userConfiguration.getBoolean(UserConfigurationKeys.LDAP_SSL, false)); ldapConfiguration .setBaseDn(userConfiguration.getConcatenatedList(UserConfigurationKeys.LDAP_BASEDN, null)); ldapConfiguration.setBaseGroupsDn(userConfiguration.getConcatenatedList( UserConfigurationKeys.LDAP_GROUPS_BASEDN, ldapConfiguration.getBaseDn())); ldapConfiguration .setContextFactory(userConfiguration.getString(UserConfigurationKeys.LDAP_CONTEX_FACTORY, isSunContextFactoryAvailable() ? "com.sun.jndi.ldap.LdapCtxFactory" : "")); ldapConfiguration .setBindDn(userConfiguration.getConcatenatedList(UserConfigurationKeys.LDAP_BINDDN, null)); ldapConfiguration .setPassword(userConfiguration.getString(UserConfigurationKeys.LDAP_PASSWORD, null)); ldapConfiguration.setAuthenticationMethod( userConfiguration.getString(UserConfigurationKeys.LDAP_AUTHENTICATION_METHOD, null)); ldapConfiguration .setWritable(userConfiguration.getBoolean(UserConfigurationKeys.LDAP_WRITABLE, false)); ldapConfiguration.setUseRoleNameAsGroup( userConfiguration.getBoolean(UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME, false)); boolean ldapBindAuthenticatorEnabled = userConfiguration .getBoolean(UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED, false); ldapConfiguration.setBindAuthenticatorEnabled(ldapBindAuthenticatorEnabled); // LDAP groups mapping reading !! // UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY // userConfiguration.getKeys() Collection<String> keys = userConfiguration.getKeys(); List<LdapGroupMapping> ldapGroupMappings = new ArrayList<>(); for (String key : keys) { if (key.startsWith(UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY)) { String group = StringUtils.substringAfter(key, UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY); String val = userConfiguration.getConcatenatedList(key, ""); if (!StringUtils.isEmpty(val)) { String[] roles = StringUtils.split(val, ','); ldapGroupMappings.add(new LdapGroupMapping(group, roles)); } } } redbackRuntimeConfiguration.setLdapGroupMappings(ldapGroupMappings); redbackRuntimeConfiguration.setMigratedFromRedbackConfiguration(true); updateRedbackRuntimeConfiguration(redbackRuntimeConfiguration); } // we must ensure userManagerImpls list is not empty if so put at least jdo one ! if (redbackRuntimeConfiguration.getUserManagerImpls().isEmpty()) { log.info( "redbackRuntimeConfiguration with empty userManagerImpls so force at least jdo implementation !"); redbackRuntimeConfiguration.getUserManagerImpls().add("jdo"); updateRedbackRuntimeConfiguration(redbackRuntimeConfiguration); } else { log.info("using userManagerImpls: {}", redbackRuntimeConfiguration.getUserManagerImpls()); } // we ensure rbacManagerImpls is not empty if so put at least cached if (redbackRuntimeConfiguration.getRbacManagerImpls().isEmpty()) { log.info( "redbackRuntimeConfiguration with empty rbacManagerImpls so force at least cached implementation !"); redbackRuntimeConfiguration.getRbacManagerImpls().add("cached"); updateRedbackRuntimeConfiguration(redbackRuntimeConfiguration); } else { log.info("using rbacManagerImpls: {}", redbackRuntimeConfiguration.getRbacManagerImpls()); } boolean save = false; // NPE free if (redbackRuntimeConfiguration.getUsersCacheConfiguration() == null) { redbackRuntimeConfiguration.setUsersCacheConfiguration(new CacheConfiguration()); } // if -1 it means non initialized to take values from the spring bean if (redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToIdleSeconds() < 0) { redbackRuntimeConfiguration.getUsersCacheConfiguration() .setTimeToIdleSeconds(usersCache.getTimeToIdleSeconds()); save = true; } usersCache.setTimeToIdleSeconds( redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToIdleSeconds()); if (redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToLiveSeconds() < 0) { redbackRuntimeConfiguration.getUsersCacheConfiguration() .setTimeToLiveSeconds(usersCache.getTimeToLiveSeconds()); save = true; } usersCache.setTimeToLiveSeconds( redbackRuntimeConfiguration.getUsersCacheConfiguration().getTimeToLiveSeconds()); if (redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsInMemory() < 0) { redbackRuntimeConfiguration.getUsersCacheConfiguration() .setMaxElementsInMemory(usersCache.getMaxElementsInMemory()); save = true; } usersCache.setMaxElementsInMemory( redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsInMemory()); if (redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsOnDisk() < 0) { redbackRuntimeConfiguration.getUsersCacheConfiguration() .setMaxElementsOnDisk(usersCache.getMaxElementsOnDisk()); save = true; } usersCache.setMaxElementsOnDisk( redbackRuntimeConfiguration.getUsersCacheConfiguration().getMaxElementsOnDisk()); if (save) { updateRedbackRuntimeConfiguration(redbackRuntimeConfiguration); } } catch (RepositoryAdminException e) { throw new UserConfigurationException(e.getMessage(), e); } } private boolean isSunContextFactoryAvailable() { try { return Thread.currentThread().getContextClassLoader() .loadClass("com.sun.jndi.ldap.LdapCtxFactory") != null; } catch (ClassNotFoundException e) { return false; } } @Override public RedbackRuntimeConfiguration getRedbackRuntimeConfiguration() { return build(archivaConfiguration.getConfiguration().getRedbackRuntimeConfiguration()); } @Override public void updateRedbackRuntimeConfiguration(RedbackRuntimeConfiguration redbackRuntimeConfiguration) throws RepositoryAdminException { org.apache.archiva.configuration.RedbackRuntimeConfiguration runtimeConfiguration = build( redbackRuntimeConfiguration); Configuration configuration = archivaConfiguration.getConfiguration(); configuration.setRedbackRuntimeConfiguration(runtimeConfiguration); try { archivaConfiguration.save(configuration); } catch (RegistryException e) { throw new RepositoryAdminException(e.getMessage(), e); } catch (IndeterminateConfigurationException e) { throw new RepositoryAdminException(e.getMessage(), e); } } private RedbackRuntimeConfiguration build( org.apache.archiva.configuration.RedbackRuntimeConfiguration runtimeConfiguration) { RedbackRuntimeConfiguration redbackRuntimeConfiguration = getModelMapper().map(runtimeConfiguration, RedbackRuntimeConfiguration.class); if (runtimeConfiguration.getLdapConfiguration() != null) { redbackRuntimeConfiguration.setLdapConfiguration( getModelMapper().map(runtimeConfiguration.getLdapConfiguration(), LdapConfiguration.class)); } if (runtimeConfiguration.getUsersCacheConfiguration() != null) { redbackRuntimeConfiguration.setUsersCacheConfiguration(getModelMapper() .map(runtimeConfiguration.getUsersCacheConfiguration(), CacheConfiguration.class)); } if (redbackRuntimeConfiguration.getLdapConfiguration() == null) { // prevent NPE redbackRuntimeConfiguration.setLdapConfiguration(new LdapConfiguration()); } if (redbackRuntimeConfiguration.getUsersCacheConfiguration() == null) { redbackRuntimeConfiguration.setUsersCacheConfiguration(new CacheConfiguration()); } List<org.apache.archiva.configuration.LdapGroupMapping> mappings = runtimeConfiguration .getLdapGroupMappings(); if (mappings != null && mappings.size() > 0) { List<LdapGroupMapping> ldapGroupMappings = new ArrayList<>(mappings.size()); for (org.apache.archiva.configuration.LdapGroupMapping mapping : mappings) { ldapGroupMappings.add(new LdapGroupMapping(mapping.getGroup(), mapping.getRoleNames())); } redbackRuntimeConfiguration.setLdapGroupMappings(ldapGroupMappings); } cleanupProperties(redbackRuntimeConfiguration); return redbackRuntimeConfiguration; } /** * cleaning from map properties used directly in archiva configuration fields * * @param redbackRuntimeConfiguration */ private void cleanupProperties(RedbackRuntimeConfiguration redbackRuntimeConfiguration) { Map<String, String> properties = redbackRuntimeConfiguration.getConfigurationProperties(); properties.remove(UserConfigurationKeys.LDAP_HOSTNAME); properties.remove(UserConfigurationKeys.LDAP_PORT); properties.remove(UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED); properties.remove(UserConfigurationKeys.LDAP_SSL); properties.remove(UserConfigurationKeys.LDAP_BASEDN); properties.remove(UserConfigurationKeys.LDAP_GROUPS_BASEDN); properties.remove(UserConfigurationKeys.LDAP_CONTEX_FACTORY); properties.remove(UserConfigurationKeys.LDAP_BINDDN); properties.remove(UserConfigurationKeys.LDAP_PASSWORD); properties.remove(UserConfigurationKeys.LDAP_AUTHENTICATION_METHOD); properties.remove(UserConfigurationKeys.LDAP_WRITABLE); properties.remove(UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME); // cleanup groups <-> role mapping /**for ( Map.Entry<String, String> entry : new HashMap<String, String>( properties ).entrySet() ) { if ( entry.getKey().startsWith( UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY ) ) { properties.remove( entry.getKey() ); } }*/ } private org.apache.archiva.configuration.RedbackRuntimeConfiguration build( RedbackRuntimeConfiguration redbackRuntimeConfiguration) { org.apache.archiva.configuration.RedbackRuntimeConfiguration res = getModelMapper().map( redbackRuntimeConfiguration, org.apache.archiva.configuration.RedbackRuntimeConfiguration.class); if (redbackRuntimeConfiguration.getLdapConfiguration() == null) { redbackRuntimeConfiguration.setLdapConfiguration(new LdapConfiguration()); } res.setLdapConfiguration(getModelMapper().map(redbackRuntimeConfiguration.getLdapConfiguration(), org.apache.archiva.configuration.LdapConfiguration.class)); if (redbackRuntimeConfiguration.getUsersCacheConfiguration() == null) { redbackRuntimeConfiguration.setUsersCacheConfiguration(new CacheConfiguration()); } res.setUsersCacheConfiguration( getModelMapper().map(redbackRuntimeConfiguration.getUsersCacheConfiguration(), org.apache.archiva.configuration.CacheConfiguration.class)); List<LdapGroupMapping> ldapGroupMappings = redbackRuntimeConfiguration.getLdapGroupMappings(); if (ldapGroupMappings != null && ldapGroupMappings.size() > 0) { List<org.apache.archiva.configuration.LdapGroupMapping> mappings = new ArrayList<>( ldapGroupMappings.size()); for (LdapGroupMapping ldapGroupMapping : ldapGroupMappings) { org.apache.archiva.configuration.LdapGroupMapping mapping = new org.apache.archiva.configuration.LdapGroupMapping(); mapping.setGroup(ldapGroupMapping.getGroup()); mapping.setRoleNames(new ArrayList<>(ldapGroupMapping.getRoleNames())); mappings.add(mapping); } res.setLdapGroupMappings(mappings); } return res; } // wrapper for UserConfiguration to intercept values (and store it not yet migrated) @Override public String getString(String key) { if (UserConfigurationKeys.USER_MANAGER_IMPL.equals(key)) { // possible false for others than archiva user manager return getRedbackRuntimeConfiguration().getUserManagerImpls().get(0); } if (StringUtils.startsWith(key, UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY)) { RedbackRuntimeConfiguration redbackRuntimeConfiguration = getRedbackRuntimeConfiguration(); int index = redbackRuntimeConfiguration.getLdapGroupMappings().indexOf(new LdapGroupMapping( StringUtils.substringAfter(key, UserConfigurationKeys.LDAP_GROUPS_ROLE_START_KEY))); if (index > -1) { return StringUtils .join(redbackRuntimeConfiguration.getLdapGroupMappings().get(index).getRoleNames(), ','); } } RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration(); if (conf.getConfigurationProperties().containsKey(key)) { return conf.getConfigurationProperties().get(key); } String value = userConfiguration.getString(key); if (value == null) { return null; } conf.getConfigurationProperties().put(key, value); try { updateRedbackRuntimeConfiguration(conf); } catch (RepositoryAdminException e) { log.error("fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e); throw new RuntimeException(e.getMessage(), e); } return value; } @Override public String getString(String key, String defaultValue) { if (UserConfigurationKeys.LDAP_HOSTNAME.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getHostName(); } if (UserConfigurationKeys.LDAP_CONTEX_FACTORY.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getContextFactory(); } if (UserConfigurationKeys.LDAP_PASSWORD.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getPassword(); } if (UserConfigurationKeys.LDAP_AUTHENTICATION_METHOD.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getAuthenticationMethod(); } RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration(); if (conf.getConfigurationProperties().containsKey(key)) { return conf.getConfigurationProperties().get(key); } String value = userConfiguration.getString(key, defaultValue); if (value == null) { return null; } conf.getConfigurationProperties().put(key, value); try { updateRedbackRuntimeConfiguration(conf); } catch (RepositoryAdminException e) { log.error("fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e); throw new RuntimeException(e.getMessage(), e); } return value; } @Override public int getInt(String key) { RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration(); if (conf.getConfigurationProperties().containsKey(key)) { return Integer.valueOf(conf.getConfigurationProperties().get(key)); } int value = userConfiguration.getInt(key); conf.getConfigurationProperties().put(key, Integer.toString(value)); try { updateRedbackRuntimeConfiguration(conf); } catch (RepositoryAdminException e) { log.error("fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e); throw new RuntimeException(e.getMessage(), e); } return value; } @Override public int getInt(String key, int defaultValue) { if (UserConfigurationKeys.LDAP_PORT.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getPort(); } RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration(); if (conf.getConfigurationProperties().containsKey(key)) { return Integer.valueOf(conf.getConfigurationProperties().get(key)); } int value = userConfiguration.getInt(key, defaultValue); conf.getConfigurationProperties().put(key, Integer.toString(value)); try { updateRedbackRuntimeConfiguration(conf); } catch (RepositoryAdminException e) { log.error("fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e); throw new RuntimeException(e.getMessage(), e); } return value; } @Override public boolean getBoolean(String key) { RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration(); if (UserConfigurationKeys.LDAP_WRITABLE.equals(key)) { return conf.getLdapConfiguration().isWritable(); } if (UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME.equals(key)) { return conf.getLdapConfiguration().isUseRoleNameAsGroup(); } if (UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED.equals(key)) { return conf.getLdapConfiguration().isBindAuthenticatorEnabled(); } if (conf.getConfigurationProperties().containsKey(key)) { return Boolean.valueOf(conf.getConfigurationProperties().get(key)); } boolean value = userConfiguration.getBoolean(key); conf.getConfigurationProperties().put(key, Boolean.toString(value)); try { updateRedbackRuntimeConfiguration(conf); } catch (RepositoryAdminException e) { log.error("fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e); throw new RuntimeException(e.getMessage(), e); } return value; } @Override public boolean getBoolean(String key, boolean defaultValue) { if (UserConfigurationKeys.LDAP_SSL.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().isSsl(); } if (UserConfigurationKeys.LDAP_WRITABLE.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().isWritable(); } if (UserConfigurationKeys.LDAP_GROUPS_USE_ROLENAME.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().isUseRoleNameAsGroup(); } if (UserConfigurationKeys.LDAP_BIND_AUTHENTICATOR_ENABLED.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().isBindAuthenticatorEnabled(); } RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration(); if (conf.getConfigurationProperties().containsKey(key)) { return Boolean.valueOf(conf.getConfigurationProperties().get(key)); } boolean value = userConfiguration.getBoolean(key, defaultValue); conf.getConfigurationProperties().put(key, Boolean.toString(value)); try { updateRedbackRuntimeConfiguration(conf); } catch (RepositoryAdminException e) { log.error("fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e); throw new RuntimeException(e.getMessage(), e); } return value; } @Override public List<String> getList(String key) { List<String> value = userConfiguration.getList(key); RedbackRuntimeConfiguration conf = getRedbackRuntimeConfiguration(); // TODO concat values conf.getConfigurationProperties().put(key, ""); try { updateRedbackRuntimeConfiguration(conf); } catch (RepositoryAdminException e) { log.error("fail to save RedbackRuntimeConfiguration: {}", e.getMessage(), e); throw new RuntimeException(e.getMessage(), e); } return value; } @Override public String getConcatenatedList(String key, String defaultValue) { if (UserConfigurationKeys.LDAP_BASEDN.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getBaseDn(); } if (UserConfigurationKeys.LDAP_BINDDN.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getBindDn(); } if (UserConfigurationKeys.LDAP_GROUPS_BASEDN.equals(key)) { return getRedbackRuntimeConfiguration().getLdapConfiguration().getBaseGroupsDn(); } return userConfiguration.getConcatenatedList(key, defaultValue); } @Override public Collection<String> getKeys() { Collection<String> keys = userConfiguration.getKeys(); Set<String> keysSet = new HashSet<>(keys); keysSet.addAll(getRedbackRuntimeConfiguration().getConfigurationProperties().keySet()); return keysSet; } }