/*******************************************************************************
* Copyright (c) 2004, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.core.tests.session;
import java.io.File;
import java.io.IOException;
import java.util.*;
import javax.xml.parsers.*;
import org.eclipse.core.runtime.Platform;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
public class SetupManager {
public class SetupException extends Exception {
/**
* All serializable objects should have a stable serialVersionUID
*/
private static final long serialVersionUID = 1L;
public SetupException(String message, Throwable cause) {
super(message, cause);
}
public SetupException(String message) {
super(message);
}
}
private static SetupManager instance;
private static final String SETUP_DEBUG = "setup.debug";
private static final String SETUP_FILES = "setup.files";
private static final String SETUP_OPTIONS = "setup.options";
private static final String SETUP_OVERRIDE_ECLIPSEARGS = "setup.override.eclipseArgs";
private static final String SETUP_OVERRIDE_SYSTEMPROPERTIES = "setup.override.systemProperties";
private static final String SETUP_OVERRIDE_VMARGS = "setup.override.vmArgs";
private String defaultOptionSetIds = "";
private Map setupById;
private Collection setups;
private static boolean contains(Object[] set, Object element) {
for (int i = 0; i < set.length; i++)
if (element.equals(set[i]))
return true;
return false;
}
public synchronized static SetupManager getInstance() throws SetupException {
if (instance != null)
return instance;
instance = new SetupManager();
return instance;
}
public static boolean inDebugMode() {
return Boolean.getBoolean(SETUP_DEBUG);
}
public static void main(String[] args) throws Exception {
SetupManager manager = SetupManager.getInstance();
System.out.println(manager.getDefaultSetup());
}
static String[] parseItems(String string) {
if (string == null)
return new String[0];
StringTokenizer tokenizer = new StringTokenizer(string, ","); //$NON-NLS-1$
if (!tokenizer.hasMoreTokens())
return new String[0];
String first = tokenizer.nextToken().trim();
if (!tokenizer.hasMoreTokens())
return new String[] {first};
ArrayList items = new ArrayList();
items.add(first);
do {
items.add(tokenizer.nextToken().trim());
} while (tokenizer.hasMoreTokens());
return (String[]) items.toArray(new String[items.size()]);
}
protected SetupManager() throws SetupException {
setups = new ArrayList();
setupById = new HashMap();
try {
loadSetups();
} catch (SetupException e) {
throw e;
} catch (Exception e) {
throw new SetupException("Problems initializing SetupManager", e);
}
}
public Setup buildSetup(String[] optionSets) {
Setup defaultSetup = Setup.getDefaultSetup(this);
for (Iterator i = setups.iterator(); i.hasNext();) {
Setup customSetup = (Setup) i.next();
if ((customSetup.getId() == null || contains(optionSets, customSetup.getId())) && customSetup.isSatisfied(optionSets))
defaultSetup.merge(customSetup);
}
defaultSetup.setEclipseArguments(parseOptions(System.getProperty(SETUP_OVERRIDE_ECLIPSEARGS)));
defaultSetup.setVMArguments(parseOptions(System.getProperty(SETUP_OVERRIDE_VMARGS)));
defaultSetup.setSystemProperties(parseOptions(System.getProperty(SETUP_OVERRIDE_SYSTEMPROPERTIES)));
return defaultSetup;
}
private String getAttribute(NamedNodeMap attributes, String name) {
Node selected = attributes.getNamedItem(name);
return selected == null ? null : selected.getNodeValue();
}
private String[] getDefaultOptionSets() {
return parseItems(System.getProperty(SETUP_OPTIONS, defaultOptionSetIds));
}
/**
* Returns a brand new setup object configured according to the current
* default setup settings.
*
* @return a new setup object
*/
public Setup getDefaultSetup() {
return buildSetup(getDefaultOptionSets());
}
public Setup getSetup(String id) {
return (Setup) setupById.get(id);
}
private void loadEclipseArgument(Setup newSetup, Element toParse) {
newSetup.setEclipseArgument(toParse.getAttribute("option"), toParse.getAttribute("value"));
}
private void loadProperty(Setup newSetup, Element toParse) {
newSetup.setSystemProperty(toParse.getAttribute("key"), toParse.getAttribute("value"));
}
private void loadSetup(Element markup) {
NamedNodeMap attributes = markup.getAttributes();
if (attributes == null)
return;
Setup newSetup = new Setup(this);
newSetup.setId(getAttribute(attributes, "id"));
newSetup.setName(getAttribute(attributes, "name"));
String timeout = getAttribute(attributes, "timeout");
newSetup.setBaseSetups(parseItems(getAttribute(attributes, "base")));
newSetup.setRequiredSets(parseItems(getAttribute(attributes, "with")));
if (timeout != null)
newSetup.setTimeout(Integer.parseInt(timeout));
NodeList children = markup.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node next = children.item(i);
if (!(next instanceof Element))
continue;
Element toParse = (Element) next;
if (toParse.getTagName().equals("eclipseArg"))
loadEclipseArgument(newSetup, toParse);
else if (toParse.getTagName().equals("vmArg"))
loadVMArgument(newSetup, toParse);
else if (toParse.getTagName().equals("systemProperty"))
loadProperty(newSetup, toParse);
}
setups.add(newSetup);
if (newSetup.getId() != null)
setupById.put(newSetup.getId(), newSetup);
}
private void loadSetups() throws ParserConfigurationException, FactoryConfigurationError, SAXException, IOException, SetupException {
String setupFilesProperty = System.getProperty(SETUP_FILES);
boolean defaultLocation = false;
if (setupFilesProperty == null) {
setupFilesProperty = "default-setup.xml";
defaultLocation = true;
}
String[] setupFileNames = parseItems(setupFilesProperty);
File[] setupFiles = new File[setupFileNames.length];
int found = 0;
for (int i = 0; i < setupFiles.length; i++) {
setupFiles[found] = new File(setupFileNames[i]);
if (!setupFiles[found].isFile()) {
if (!defaultLocation)
// warn if user-provided location does not exist
System.out.println("No setup files found at '" + setupFiles[i].getAbsolutePath() + "'. ");
continue;
}
found++;
}
if (found == 0) {
if (Platform.isRunning()) {
// No setup descriptions found, only the default setup will be available
return;
}
// no setup files found, and we are not running in Eclipse...
throw new SetupException("No setup descriptions found. Ensure you are specifying the path for an existing setup file (e.g. -Dsetup.files=<setup-file-location1>[...,<setup-file-locationN>])");
}
DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
for (int fileIndex = 0; fileIndex < found; fileIndex++) {
Document doc = docBuilder.parse(setupFiles[fileIndex]);
Element root = doc.getDocumentElement();
String setupDefaultOptionSets = root.getAttribute("default");
if (setupDefaultOptionSets != null)
defaultOptionSetIds = defaultOptionSetIds == null ? setupDefaultOptionSets : (defaultOptionSetIds + ',' + setupDefaultOptionSets);
NodeList optionSets = root.getChildNodes();
for (int i = 0; i < optionSets.getLength(); i++) {
Node next = optionSets.item(i);
if (!(next instanceof Element))
continue;
Element toParse = (Element) next;
if (!toParse.getTagName().equals("optionSet"))
continue;
loadSetup(toParse);
}
}
}
private void loadVMArgument(Setup newSetup, Element toParse) {
newSetup.setVMArgument(toParse.getAttribute("option"), toParse.getAttribute("value"));
}
private Map parseOptions(String options) {
if (options == null)
return Collections.EMPTY_MAP;
Map result = new HashMap();
StringTokenizer tokenizer = new StringTokenizer(options.trim(), ";");
while (tokenizer.hasMoreTokens()) {
String option = tokenizer.nextToken();
int separatorIndex = option.indexOf('=');
if (separatorIndex == -1 || separatorIndex == option.length() - 1)
// property with no value defined
result.put(option, "");
else {
String key = option.substring(0, separatorIndex);
String value = option.substring(separatorIndex + 1);
result.put(key, value);
}
}
return result;
}
}