/*
* 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.
*
*/
package org.apache.ivy.ant;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;
import java.util.Properties;
import org.apache.ivy.Ivy;
import org.apache.ivy.core.settings.IvySettings;
import org.apache.ivy.core.settings.IvyVariableContainer;
import org.apache.ivy.util.Message;
import org.apache.ivy.util.url.CredentialsStore;
import org.apache.ivy.util.url.URLHandler;
import org.apache.ivy.util.url.URLHandlerDispatcher;
import org.apache.ivy.util.url.URLHandlerRegistry;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectComponent;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.taskdefs.Property;
import org.apache.tools.ant.types.DataType;
public class IvyAntSettings extends DataType {
public static class Credentials {
private String realm;
private String host;
private String username;
private String passwd;
public String getPasswd() {
return this.passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
public String getRealm() {
return this.realm;
}
public void setRealm(String realm) {
this.realm = format(realm);
}
public String getHost() {
return this.host;
}
public void setHost(String host) {
this.host = format(host);
}
public String getUsername() {
return this.username;
}
public void setUsername(String userName) {
this.username = format(userName);
}
}
private Ivy ivyEngine = null;
private File file = null;
private URL url = null;
private String realm = null;
private String host = null;
private String userName = null;
private String passwd = null;
private String id = "ivy.instance";
private boolean autoRegistered = false;
/**
* Returns the default ivy settings of this classloader. If it doesn't exist yet, a new one is
* created using the given project to back the VariableContainer.
*
* @param project
* TODO add text.
* @return An IvySetting instance.
*/
public static IvyAntSettings getDefaultInstance(ProjectComponent task) {
Project project = task.getProject();
Object defaultInstanceObj = project.getReference("ivy.instance");
if (defaultInstanceObj != null
&& defaultInstanceObj.getClass().getClassLoader() != IvyAntSettings.class
.getClassLoader()) {
task.log("ivy.instance reference an ivy:settings defined in an other classloader. "
+ "An new default one will be used in this project.", Project.MSG_WARN);
defaultInstanceObj = null;
}
if (defaultInstanceObj != null && !(defaultInstanceObj instanceof IvyAntSettings)) {
throw new BuildException("ivy.instance reference a "
+ defaultInstanceObj.getClass().getName()
+ " an not an IvyAntSettings. Please don't use this reference id ()");
}
if (defaultInstanceObj == null) {
task.log("No ivy:settings found for the default reference 'ivy.instance'. "
+ "A default instance will be used", Project.MSG_VERBOSE);
IvyAntSettings settings = new IvyAntSettings();
settings.setProject(project);
project.addReference("ivy.instance", settings);
settings.createIvyEngine(task);
return settings;
} else {
return (IvyAntSettings) defaultInstanceObj;
}
}
/*
* Keep this for backwards compatibility!
*/
public static IvyAntSettings getDefaultInstance(Task task) {
return getDefaultInstance((ProjectComponent) task);
}
public File getFile() {
return file;
}
public URL getUrl() {
return url;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String aPasswd) {
passwd = aPasswd;
}
public String getRealm() {
return realm;
}
public void setRealm(String aRealm) {
realm = format(aRealm);
}
public String getHost() {
return host;
}
public void setHost(String aHost) {
host = format(aHost);
}
public String getUsername() {
return userName;
}
public void setUsername(String aUserName) {
userName = format(aUserName);
}
public void setProject(Project p) {
super.setProject(p);
if ("ivy.instance".equals(id) && !getProject().getReferences().containsKey(id)) {
// register ourselfs as default settings, just in case the id attribute is not set
getProject().addReference("ivy.instance", this);
autoRegistered = true;
}
}
private static String format(String str) {
return str == null ? str : (str.trim().length() == 0 ? null : str.trim());
}
public void addConfiguredCredentials(Credentials c) {
CredentialsStore.INSTANCE.addCredentials(c.getRealm(), c.getHost(), c.getUsername(),
c.getPasswd());
}
public void setFile(File file) {
this.file = file;
}
public void setUrl(String confUrl) throws MalformedURLException {
this.url = new URL(confUrl);
}
public void setUrl(URL url) {
this.url = url;
}
/*
* This is usually not necessary to define a reference in Ant, but it's the only way to know the
* id of the settings, which we use to set ant properties.
*/
public void setId(String id) {
if (autoRegistered && getProject().getReference(this.id) == this) {
getProject().getReferences().remove(this.id);
autoRegistered = false;
}
this.id = id;
if (getProject() != null) {
getProject().addReference(this.id, this);
}
}
public String getId() {
return id;
}
/**
* Return the configured Ivy instance.
*
* @return Returns the configured Ivy instance.
*/
public Ivy getConfiguredIvyInstance(ProjectComponent task) {
if (ivyEngine == null) {
createIvyEngine(task);
}
return ivyEngine;
}
/*
* Keep this for backwards compatibility!
*/
public Ivy getConfiguredIvyInstance(Task task) {
return getConfiguredIvyInstance((ProjectComponent) task);
}
void createIvyEngine(final ProjectComponent task) {
Project project = task.getProject();
Property prop = new Property() {
public void execute() throws BuildException {
addProperties(getDefaultProperties(task));
}
};
prop.setProject(project);
prop.init();
prop.execute();
IvyAntVariableContainer ivyAntVariableContainer = new IvyAntVariableContainer(project);
IvySettings settings = new IvySettings(ivyAntVariableContainer);
settings.setBaseDir(project.getBaseDir());
if (file == null && url == null) {
defineDefaultSettingFile(ivyAntVariableContainer, task);
}
Ivy ivy = Ivy.newInstance(settings);
try {
ivy.pushContext();
AntMessageLogger.register(task, ivy);
Message.showInfo();
configureURLHandler();
if (file != null) {
if (!file.exists()) {
throw new BuildException("settings file does not exist: " + file);
}
ivy.configure(file);
} else {
if (url == null) {
throw new AssertionError(
"ivy setting should have either a file, either an url,"
+ " and if not defineDefaultSettingFile must set it.");
}
ivy.configure(url);
}
ivyAntVariableContainer.updateProject(id);
ivyEngine = ivy;
} catch (ParseException e) {
throw new BuildException("impossible to configure ivy:settings with given "
+ (file != null ? "file: " + file : "url: " + url) + " : " + e, e);
} catch (IOException e) {
throw new BuildException("impossible to configure ivy:settings with given "
+ (file != null ? "file: " + file : "url: " + url) + " : " + e, e);
} finally {
ivy.popContext();
}
}
protected Properties getDefaultProperties(ProjectComponent task) {
URL url = IvySettings.getDefaultPropertiesURL();
// this is copy of loadURL code from ant Property task (not available in 1.5.1)
Properties props = new Properties();
task.log("Loading " + url, Project.MSG_VERBOSE);
try {
InputStream is = url.openStream();
try {
props.load(is);
} finally {
if (is != null) {
is.close();
}
}
} catch (IOException ex) {
throw new BuildException(ex);
}
return props;
}
/**
* Set file or url to its default value
*
* @param variableContainer
*/
private void defineDefaultSettingFile(IvyVariableContainer variableContainer,
ProjectComponent task) {
String settingsFileName = variableContainer.getVariable("ivy.conf.file");
if (settingsFileName != null
&& !settingsFileName.equals(variableContainer.getVariable("ivy.settings.file"))) {
task.log("DEPRECATED: 'ivy.conf.file' is deprecated, use 'ivy.settings.file' instead",
Project.MSG_INFO);
} else {
settingsFileName = variableContainer.getVariable("ivy.settings.file");
}
File[] settingsLocations = new File[] {
new File(getProject().getBaseDir(), settingsFileName),
new File(getProject().getBaseDir(), "ivyconf.xml"), new File(settingsFileName),
new File("ivyconf.xml")};
for (int i = 0; i < settingsLocations.length; i++) {
file = settingsLocations[i];
task.log("searching settings file: trying " + file, Project.MSG_VERBOSE);
if (file.exists()) {
break;
}
}
if (!file.exists()) {
file = null;
if (Boolean.valueOf(getProject().getProperty("ivy.14.compatible")).booleanValue()) {
task.log("no settings file found, using Ivy 1.4 default...", Project.MSG_VERBOSE);
url = IvySettings.getDefault14SettingsURL();
} else {
String settingsFileUrl = variableContainer.getVariable("ivy.settings.url");
if (settingsFileUrl != null) {
try {
url = new URL(settingsFileUrl);
} catch (MalformedURLException e) {
throw new BuildException(
"Impossible to configure ivy:settings with given url: "
+ settingsFileUrl + ": " + e.getMessage(), e);
}
} else {
task.log("no settings file found, using default...", Project.MSG_VERBOSE);
url = IvySettings.getDefaultSettingsURL();
}
}
}
}
private void configureURLHandler() {
// TODO : the credentialStore should also be scoped
CredentialsStore.INSTANCE.addCredentials(getRealm(), getHost(), getUsername(), getPasswd());
URLHandlerDispatcher dispatcher = new URLHandlerDispatcher();
URLHandler httpHandler = URLHandlerRegistry.getHttp();
dispatcher.setDownloader("http", httpHandler);
dispatcher.setDownloader("https", httpHandler);
URLHandlerRegistry.setDefault(dispatcher);
}
}