Java tutorial
/** * Copyright 2005-2014 Red Hat, Inc. * * Red Hat 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. */ package io.fabric8.agent.mvn; import java.io.File; import java.net.MalformedURLException; import java.net.URL; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import io.fabric8.common.util.XmlUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; /** * Default implementation of Settings. * * @see MavenSettings * @since August 10, 2007 */ public class MavenSettingsImpl implements MavenSettings { /** * Logger. */ private static final Log LOGGER = LogFactory.getLog(MavenSettingsImpl.class); /** * Path of local repository tag. */ private static final String LOCAL_REPOSITORY_TAG = "localRepository"; /** * Path to server tag. */ private static final String SERVER_TAG = "servers/server"; /** * Path to profiles tag. */ private static final String PROFILE_TAG = "profiles/profile"; /** * Path to repository tag. */ private static final String REPOSITORY_TAG = "repositories/repository"; /** * Path to activeProfiles tag. */ private static final String ACTIVE_PROFILES_TAG = "activeProfiles/activeProfile"; /** * Path to proxy tag. */ private static final String PROXY_TAG = "proxies/proxy"; /** * Fallback Maven repositories. */ private static final String FALLBACK_REPOSITORIES = "http://osgi.sonatype.org/content/groups/pax-runner," + "http://repo1.maven.org/maven2," + "http://repository.ops4j.org/maven2," + "http://repository.springsource.com/maven/bundles/release," + "http://repository.springsource.com/maven/bundles/external"; /** * The settings.xml DOM Document. Null if there is no settings.xml. */ private Document m_document; /** * The settings.xml file url. Can be null if no settings.xml was resolved. */ private URL m_settingsURL; /** * Forces uses of fallback repositories instead of default repositories. */ private final boolean m_useFallbackRepositories; /** * The local repository spec. */ private String m_localRepository; /** * Comma separated list of repositories. Null if there is no settings xml or settings.xml does not contain * repositories. */ private String m_repositories; /** * Map of known proxies for various protocols */ private Map<String, Map<String, String>> m_proxySettings; /** * Creates new settings with the following resolution:<br/> * 1. looks for the specified url * 2. if not found looks for ${user.home}/.m2/settings.xml * 3. if not found looks for ${maven.home}/conf/settings.xml * 4. if not found looks for ${M2_HOME}/conf/settings.xml * * @param settingsURL prefered settings.xml file * @param useFallbackRepositories if fallback repositories should be used instead of default repositories */ public MavenSettingsImpl(final URL settingsURL, final boolean useFallbackRepositories) { m_settingsURL = settingsURL; m_useFallbackRepositories = useFallbackRepositories; if (m_settingsURL == null) { m_settingsURL = safeGetFile(System.getProperty("user.home") + "/.m2/settings.xml"); if (m_settingsURL == null) { m_settingsURL = safeGetFile(System.getProperty("maven.home") + "/conf/settings.xml"); if (m_settingsURL == null) { try { m_settingsURL = safeGetFile(System.getenv("M2_HOME") + "/conf/settings.xml"); } catch (Error e) { // ignore error - probably running on Java 1.4.x } } } } } /** * See {@link #MavenSettingsImpl(java.net.URL, boolean)}. * Forces use of default repositories. * * @param settingsURL prefered settings.xml file */ public MavenSettingsImpl(final URL settingsURL) { this(settingsURL, false); } /** * Returns the local repository directory from settings.xml. If there is no settings.xml file, or the settings.xml * does not caontain an <localRepository> tag or the value of that tag is empty it will return the hardcoded * standard location: ${user.home}/.m2/repository * * @return the local repository directory */ public String getLocalRepository() { if (m_localRepository == null) { /* readSettings(); if( m_document != null ) { Element settingsElement = XmlUtils.getElement( m_document, LOCAL_REPOSITORY_TAG ); if( settingsElement != null ) { m_localRepository = XmlUtils.getTextContent( settingsElement ); } } */ if (m_localRepository == null || m_localRepository.trim().length() == 0) { m_localRepository = System.getProperty("user.home") + "/.m2/repository"; } } return m_localRepository; } /** * Gets the list of repositories from settings.xml. * If there is no settings.xml file or there are no repositories in settings.xml the list returned will be null. * <p/> * If there are repositories in settings.xml and those repositories have user and password the user and password * will be included in the repository url as for example http://user:password@repository.ops4j.org/maven2. * <p/> * Repositories are organized in profiles. * Active profiles are selected by looking at activeProfiles tag (just under <settings>) * * @return a comma separated list of repositories from settings.xml */ public String getRepositories() { if (m_repositories == null) { /* readSettings(); if( m_document != null ) { Set<String> activeProfiles = getActiveProfiles(); Map<String, String> repositories = null; List<String> order = null; List<Element> profiles = XmlUtils.getElements( m_document, PROFILE_TAG ); // first look for profiles if( profiles != null ) { for( Element profile : profiles ) { Element profileIdElement = XmlUtils.getElement( profile, "id" ); if( profileIdElement != null ) { String profileId = XmlUtils.getTextContent( profileIdElement ); if( profileId != null ) { if( activeProfiles.contains( profileId ) ) { List<Element> repos = XmlUtils.getElements( profile, REPOSITORY_TAG ); if( repos != null ) { for( Element repo : repos ) { Element element = XmlUtils.getElement( repo, "id" ); if( element != null ) { String id = XmlUtils.getTextContent( element ); element = XmlUtils.getElement( repo, "layout" ); String layout = null; if( element != null ) { layout = XmlUtils.getTextContent( element ); } // take only repositories with a default layout (skip legacy ones) if( layout == null || "default".equals( layout ) ) { String snapshots = XmlUtils.getTextContentOfElement( repo, "snapshots/enabled" ); String releases = XmlUtils.getTextContentOfElement( repo, "releases/enabled" ); element = XmlUtils.getElement( repo, "url" ); if( element != null ) { String url = XmlUtils.getTextContent( element ); if( url != null ) { if( repositories == null ) { repositories = new HashMap<String, String>(); order = new ArrayList<String>(); } if( snapshots != null && Boolean.valueOf( snapshots ) ) { url += MavenConstants.SEPARATOR_OPTIONS + MavenConstants.OPTION_ALLOW_SNAPSHOTS; } if( releases != null && !Boolean.valueOf( releases ) ) { url += MavenConstants.SEPARATOR_OPTIONS + MavenConstants.OPTION_DISALLOW_RELEASES; } repositories.put( id, url ); order.add( id ); } } } } } } } else { LOGGER.debug( "Profile " + "[" + profileId + "] is inactive (ignored)." ); } } } } // then look for user / passwords but only if we have repositories if( repositories != null ) { List<Element> servers = XmlUtils.getElements( m_document, SERVER_TAG ); if( servers != null ) { for( Element server : servers ) { Element element = XmlUtils.getElement( server, "id" ); if( element != null ) { String id = XmlUtils.getTextContent( element ); // if we do not find a corresponding repository don't go furter String repository = repositories.get( id ); if( repository != null && repository.contains( "://" ) ) { element = XmlUtils.getElement( server, "username" ); if( element != null ) { String username = XmlUtils.getTextContent( element ); // if there is no username stop the search if( username != null ) { element = XmlUtils.getElement( server, "password" ); if( element != null ) { String password = XmlUtils.getTextContent( element ); if( password != null ) { username = username + ":" + password; } } // PAXURL-86: treat string as // literal String repo = "://" + username + "@"; repo = Matcher.quoteReplacement(repo); repositories.put(id, repository.replaceFirst("://", repo)); } } } } } } } // build the list of repositories final StringBuilder builder = new StringBuilder(); if( order != null ) { for( String repositoryId : order ) { if( builder.length() > 0 ) { builder.append( "," ); } builder.append( repositories.get( repositoryId ) ); } } m_repositories = builder.toString(); } } */ // PAXURL-92 Have the ability to only use a local repository, by // not requiring the use of a DEFAULT_REPOSITORY. Helps with // users who have proxies and want to lockdown their repos. if (m_useFallbackRepositories) { if (m_repositories == null || m_repositories.length() == 0) { m_repositories = FALLBACK_REPOSITORIES; } else { m_repositories = m_repositories + "," + FALLBACK_REPOSITORIES; } } } return m_repositories; } /* private Set<String> getActiveProfiles() { Set<String> ret = new HashSet<String>(); List<Element> activeProfiles = XmlUtils.getElements( m_document, ACTIVE_PROFILES_TAG ); if( activeProfiles != null ) { for( Element active : activeProfiles ) { ret.add( XmlUtils.getTextContent( active ) ); } } return ret; } */ private void readSettings() { if (m_document == null && m_settingsURL != null) { try { m_document = XmlUtils.parseDoc(m_settingsURL.openStream()); } catch (Exception e) { throw new RuntimeException("Could not parse settings [" + m_settingsURL + "]", e); } } } private static URL safeGetFile(final String filePath) { if (filePath != null) { File file = new File(filePath); if (file.exists() && file.canRead() && file.isFile()) { try { return file.toURI().toURL(); } catch (MalformedURLException e) { // do nothing } } } return null; } private String getSetting(Element element, String settingName, String defaultSetting) { final String setting = XmlUtils.getTextContentOfElement(element, settingName); if (setting == null) { return defaultSetting; } return setting; } /** * Returns the active proxy settings from settings.xml * * @return the active proxy settings */ public Map<String, Map<String, String>> getProxySettings() { if (m_proxySettings == null) { m_proxySettings = new HashMap<String, Map<String, String>>(); try { readSettings(); if (m_document != null) { List<Element> proxies = XmlUtils.getElements(m_document, PROXY_TAG); if (proxies != null) { for (Element proxy : proxies) { String active = getSetting(proxy, "active", "false"); String protocol = getSetting(proxy, "protocol", "http"); if (!m_proxySettings.containsKey(protocol) || "true".equalsIgnoreCase(active)) { Map<String, String> proxyDetails = new HashMap<String, String>(); proxyDetails.put("user", getSetting(proxy, "username", "")); proxyDetails.put("pass", getSetting(proxy, "password", "")); proxyDetails.put("host", getSetting(proxy, "host", "127.0.0.1")); proxyDetails.put("port", getSetting(proxy, "port", "8080")); proxyDetails.put("nonProxyHosts", getSetting(proxy, "nonProxyHosts", "")); m_proxySettings.put(protocol, proxyDetails); } } } } } catch (Exception e) { LOGGER.warn("Could not read maven proxy settings: " + e, e); } } return Collections.unmodifiableMap(m_proxySettings); } }