From: Mathieu Baudier Date: Sat, 22 Nov 2008 12:07:45 +0000 (+0000) Subject: Introduce org.argeo.slc.lib.detached X-Git-Tag: argeo-slc-2.1.7~2403 X-Git-Url: http://git.argeo.org/?a=commitdiff_plain;h=8235a54f85d7ff7ba23873c7612d50097ecdd809;p=gpl%2Fargeo-slc.git Introduce org.argeo.slc.lib.detached git-svn-id: https://svn.argeo.org/slc/trunk@1850 4cfe0d0a-d680-48aa-b62c-e0a02a3f76cc --- diff --git a/runtime/org.argeo.slc.lib.detached/.classpath b/runtime/org.argeo.slc.lib.detached/.classpath new file mode 100644 index 000000000..9653ef0ac --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/runtime/org.argeo.slc.lib.detached/.project b/runtime/org.argeo.slc.lib.detached/.project new file mode 100644 index 000000000..f874c09a1 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/.project @@ -0,0 +1,23 @@ + + + org.argeo.slc.agent + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.maven.ide.eclipse.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.maven.ide.eclipse.maven2Nature + + diff --git a/runtime/org.argeo.slc.lib.detached/.settings/org.eclipse.jdt.core.prefs b/runtime/org.argeo.slc.lib.detached/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..964778b0e --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +#Fri Aug 29 11:31:46 CEST 2008 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.5 diff --git a/runtime/org.argeo.slc.lib.detached/build.xml b/runtime/org.argeo.slc.lib.detached/build.xml new file mode 100644 index 000000000..4213f1de9 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/build.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/runtime/org.argeo.slc.lib.detached/pom.xml b/runtime/org.argeo.slc.lib.detached/pom.xml new file mode 100644 index 000000000..396598180 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/pom.xml @@ -0,0 +1,135 @@ + + 4.0.0 + + org.argeo.slc + argeo-slc + 0.11.2-SNAPSHOT + ../org.argeo.slc + + org.argeo.slc.agent + jar + Argeo SLC Agent + + + scm:svn:https://www.argeo.org/svn/slc/trunk/org.argeo.slc.agent + + + https://www.argeo.org/svn/slc/trunk/org.argeo.slc.agent + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + org.apache.maven.plugins + maven-jar-plugin + + + org.apache.maven.plugins + maven-source-plugin + + + org.apache.maven.plugins + maven-surefire-plugin + + + org.apache.maven.plugins + maven-assembly-plugin + + + src/assembly/base.xml + + + + + assembly-base + package + + single + + + + + + org.apache.felix + maven-bundle-plugin + + + + org.argeo.slc.* + + *,org.argeo.slc.core.test.spring,org.apache.commons.cli;resolution:=optional + + + + + + + + org.argeo.slc + org.argeo.slc.core + ${project.version} + + + org.argeo.slc + org.argeo.slc.detached + ${project.version} + + + + org.springframework.ws + org.springframework.ws + + + + javax.xml.soap + com.springsource.javax.xml.soap + + + com.sun.xml + + com.springsource.com.sun.xml.messaging.saaj + + + + + org.argeo.dep.osgi + org.argeo.dep.osgi.ant + + + + org.apache.commons + com.springsource.org.apache.commons.net + + + org.apache.oro + com.springsource.org.apache.oro + + + + org.apache.bsf + com.springsource.org.apache.bsf + + + org.beanshell + com.springsource.bsh + + + + + org.argeo.dep.osgi + org.argeo.dep.osgi.commons.cli + + + + \ No newline at end of file diff --git a/runtime/org.argeo.slc.lib.detached/src/assembly/base.xml b/runtime/org.argeo.slc.lib.detached/src/assembly/base.xml new file mode 100644 index 000000000..aef97a5cd --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/assembly/base.xml @@ -0,0 +1,16 @@ + + base + false + + tar.gz + + + + src/base + + 0755 + + + \ No newline at end of file diff --git a/runtime/org.argeo.slc.lib.detached/src/base/bin/slc b/runtime/org.argeo.slc.lib.detached/src/base/bin/slc new file mode 100755 index 000000000..ca8ef49d9 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/base/bin/slc @@ -0,0 +1,35 @@ +#!/bin/sh + +# Find home +if [ -z "$ARGEO_SLC_HOME" -o ! -d "$ARGEO_SLC_HOME" ] ; then + ## resolve links - $0 may be a link to home + PRG="$0" + progname=`basename "$0"` + + # need this for relative symlinks + while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> $.*$$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi + done + + ARGEO_SLC_HOME=`dirname "$PRG"`/.. + + # make it fully qualified + ARGEO_SLC_HOME=`cd "$ARGEO_SLC_HOME" && pwd` +fi + +echo ARGEO_SLC_HOME=$ARGEO_SLC_HOME + +for i in "${ARGEO_SLC_HOME}"/lib/*.jar + do + CLASSPATH="$CLASSPATH:$i" + done + +#echo CLASSPATH=$CLASSPATH + +java -cp $CLASSPATH org.argeo.slc.cli.SlcMain "$@" diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntConstants.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntConstants.java new file mode 100644 index 000000000..f89742d61 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntConstants.java @@ -0,0 +1,47 @@ +package org.argeo.slc.ant; + +public interface AntConstants { + // ANT + /** The Ant reference to the Spring application context used. */ + public static final String REF_ROOT_CONTEXT = "slcApplicationContext"; + /** The Ant reference to the SLC structure registry used. */ + public static final String REF_STRUCTURE_REGISTRY = "slcStructureRegistry"; + /** The Ant reference to the TreePath of the current project */ + public static final String REF_PROJECT_PATH = "slcProjectPath"; + /** + * Resource path to the property file listing the SLC specific Ant tasks: + * /org/argeo/slc/ant/taskdefs.properties + */ + public static final String SLC_TASKDEFS_RESOURCE_PATH = "/org/argeo/slc/ant/taskdefs.properties"; + /** + * Resource path to the property file listing the SLC specific Ant types: + * /org/argeo/slc/ant/typedefs.properties + */ + public static final String SLC_TYPEDEFS_RESOURCE_PATH = "/org/argeo/slc/ant/typedefs.properties"; + public static final String REF_SLC_EXECUTION = "slcExecution"; + + // SLC EXECUTION + public static final String EXECTYPE_ANT = "org.apache.tools.ant"; + public static final String EXECTYPE_SLC_ANT = "org.argeo.slc.ant"; + + public final static String EXECATTR_RUNTIME = "slc.runtime"; + public final static String EXECATTR_ANT_FILE = "ant.file"; + public final static String EXECATTR_ANT_TARGETS = "ant.targets"; + + // PROPERTIES + /** Property for the root dir (SLC root property file). */ + public final static String ROOT_DIR_PROPERTY = "slc.rootDir"; + /** Property for the conf dir (SLC root property file). */ + public final static String CONF_DIR_PROPERTY = "slc.confDir"; + /** Property for the work dir (SLC root property file). */ + public final static String WORK_DIR_PROPERTY = "slc.workDir"; + /** Name of the Spring bean used by default */ + public final static String DEFAULT_TEST_RUN_PROPERTY = "slc.defaultTestRun"; + + /** Property for the runtime to use. */ + public final static String RUNTIME_PROPERTY = "slc.runtime"; + + // LOG4J + public final static String MDC_ANT_PROJECT = "slc.ant.project"; + +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntExecutionContext.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntExecutionContext.java new file mode 100644 index 000000000..75bfd340e --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntExecutionContext.java @@ -0,0 +1,33 @@ +package org.argeo.slc.ant; + +import org.apache.tools.ant.Project; +import org.argeo.slc.core.process.SlcExecution; +import org.argeo.slc.runtime.SlcExecutionContext; +import org.springframework.context.ApplicationContext; + +public class AntExecutionContext implements SlcExecutionContext { + private final Project project; + + public AntExecutionContext(Project project) { + this.project = project; + } + + public T getBean(String name) { + ApplicationContext context = (ApplicationContext) project + .getReference(AntConstants.REF_ROOT_CONTEXT); + return (T) context.getBean(name); + } + + public T getAntRef(String antId) { + return (T) project.getReference(antId); + } + + public SlcExecution getSlcExecution() { + return (SlcExecution) project + .getReference(AntConstants.REF_SLC_EXECUTION); + } + + public Project getProject() { + return project; + } +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntRunner.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntRunner.java new file mode 100644 index 000000000..1adb21058 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntRunner.java @@ -0,0 +1,91 @@ +package org.argeo.slc.ant; + +import java.io.File; +import java.net.URL; +import java.util.Arrays; +import java.util.Map; +import java.util.Properties; +import java.util.Vector; + +import org.apache.tools.ant.Project; +import org.apache.tools.ant.ProjectHelper; +import org.apache.tools.ant.helper.ProjectHelper2; +import org.argeo.slc.core.SlcException; + +/** Run regular Ant script (that is, not SLC instrumented) */ +public class AntRunner { + private URL buildFile; + private String[] targets; + private Properties properties; + + public AntRunner() { + + } + + public AntRunner(URL buildFile, String target, Properties properties) { + this(buildFile, new String[] { target }, properties); + } + + public AntRunner(URL buildFile, String[] targets, Properties properties) { + this.buildFile = buildFile; + this.targets = targets; + this.properties = properties; + } + + public void run() { + Project p = new Project(); + + String path = buildFile.getFile(); + p.setUserProperty("ant.file", path); + p.setBaseDir(extractBaseDir(path)); + + p.init(); + ProjectHelper projectHelper = new ProjectHelper2(); + p.addReference(ProjectHelper.PROJECTHELPER_REFERENCE, projectHelper); + projectHelper.parse(p, buildFile); + + if (properties != null) { + for (Map.Entry entry : properties.entrySet()) { + p.setUserProperty(entry.getKey().toString(), entry.getValue() + .toString()); + } + } + + p.fireBuildStarted(); + Throwable exception = null; + try { + if (targets == null) { + p.executeTarget(p.getDefaultTarget()); + } else { + p.executeTargets(new Vector(Arrays.asList(targets))); + } + } catch (Throwable e) { + exception = e; + throw new SlcException("Could not run Ant script " + buildFile, e); + } finally { + p.fireBuildFinished(exception); + } + + } + + private File extractBaseDir(String path) { + String baseDir = null; + if (path.length() > 1) { + int indx = path.lastIndexOf('/', path.length() - 1); + if (indx == -1 || indx == 0) { + baseDir = "/"; + } else { + baseDir = path.substring(0, indx) + "/"; + } + } else { + baseDir = "/"; + } + File file = new File(baseDir); + if (file.exists()) { + return file; + } else { + return new File(System.getProperty("user.dir")); + } + } + +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntSlcApplication.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntSlcApplication.java new file mode 100644 index 000000000..410098d21 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/AntSlcApplication.java @@ -0,0 +1,424 @@ +package org.argeo.slc.ant; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.StringTokenizer; +import java.util.Vector; + +import org.apache.commons.io.IOUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.log4j.Appender; +import org.apache.log4j.LogManager; +import org.apache.log4j.MDC; +import org.apache.tools.ant.BuildListener; +import org.apache.tools.ant.Project; +import org.apache.tools.ant.ProjectHelper; +import org.apache.tools.ant.helper.ProjectHelper2; +import org.argeo.slc.core.SlcException; +import org.argeo.slc.core.process.SlcExecution; +import org.argeo.slc.core.structure.SimpleSElement; +import org.argeo.slc.core.structure.StructureRegistry; +import org.argeo.slc.core.structure.tree.TreeSPath; +import org.argeo.slc.core.structure.tree.TreeSRegistry; +import org.argeo.slc.logging.Log4jUtils; +import org.argeo.slc.runtime.SlcExecutionOutput; +import org.springframework.beans.factory.BeanFactoryUtils; +import org.springframework.beans.factory.ListableBeanFactory; +import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer; +import org.springframework.beans.factory.xml.XmlBeanDefinitionReader; +import org.springframework.context.ConfigurableApplicationContext; +import org.springframework.context.support.GenericApplicationContext; +import org.springframework.core.io.DefaultResourceLoader; +import org.springframework.core.io.Resource; +import org.springframework.core.io.ResourceLoader; +import org.springframework.util.SystemPropertyUtils; + +public class AntSlcApplication { + private final static String DEFAULT_APP_LOG4J_PROPERTIES = "org/argeo/slc/ant/defaultAppLog4j.properties"; + + private final static Log log = LogFactory.getLog(AntSlcApplication.class); + + private Resource contextLocation; + private ConfigurableApplicationContext parentContext; + + private Resource rootDir; + private Resource confDir; + private File workDir; + + public void execute(SlcExecution slcExecution, Properties properties, + Map references, + SlcExecutionOutput executionOutput) { + + // Properties and application logging initialization + initSystemProperties(properties); + Log4jUtils.initLog4j("classpath:" + DEFAULT_APP_LOG4J_PROPERTIES); + + log.info("\n###\n### Start SLC execution " + slcExecution.getUuid() + + "\n###\n"); + if (log.isDebugEnabled()) { + log.debug("rootDir=" + rootDir); + log.debug("confDir=" + confDir); + log.debug("workDir=" + workDir); + } + + // Ant coordinates + String scriptRelativePath = findAntScript(slcExecution); + List targets = findAntTargets(slcExecution); + + // Spring initialization + ConfigurableApplicationContext ctx = createExecutionContext(slcExecution); + + // Ant project initialization + Project project = new Project(); + AntExecutionContext executionContext = new AntExecutionContext(project); + project.addReference(AntConstants.REF_ROOT_CONTEXT, ctx); + project.addReference(AntConstants.REF_SLC_EXECUTION, slcExecution); + + try { + initProject(project, properties, references); + parseProject(project, scriptRelativePath); + + // Execute project + initStructure(project, scriptRelativePath); + runProject(project, targets); + + if (executionOutput != null) + executionOutput.postExecution(executionContext); + } finally { + ctx.close(); + } + } + + protected void initSystemProperties(Properties userProperties) { + // Set user properties as system properties so that Spring can access + // them + if (userProperties != null) { + for (Object key : userProperties.keySet()) { + System.setProperty(key.toString(), userProperties + .getProperty(key.toString())); + } + } + + if (System.getProperty(AntConstants.DEFAULT_TEST_RUN_PROPERTY) == null) { + System.setProperty(AntConstants.DEFAULT_TEST_RUN_PROPERTY, + "defaultTestRun"); + } + + try { + if (rootDir != null) + setSystemPropertyForRes(AntConstants.ROOT_DIR_PROPERTY, rootDir); + if (confDir != null) + setSystemPropertyForRes(AntConstants.CONF_DIR_PROPERTY, confDir); + if (workDir != null) + System.setProperty(AntConstants.WORK_DIR_PROPERTY, workDir + .getCanonicalPath()); + + // Additional properties in slc.properties file. Already set sytem + // properties (such as the various directories) can be resolved in + // placeholders. + if (confDir != null) { + Resource slcPropertiesRes = confDir + .createRelative("slc.properties"); + if (slcPropertiesRes.exists()) { + Properties slcProperties = new Properties(); + InputStream in = slcPropertiesRes.getInputStream(); + try { + slcProperties.load(in); + } finally { + IOUtils.closeQuietly(in); + } + + for (Object obj : slcProperties.keySet()) { + String key = obj.toString(); + if (!System.getProperties().containsKey(key)) { + String value = SystemPropertyUtils + .resolvePlaceholders(slcProperties + .getProperty(key)); + System.setProperty(key, value); + } + } + } + } + } catch (Exception e) { + throw new SlcException("Cannot init system properties.", e); + } + } + + /** + * Set property as an absolute file path if the resource can be located on + * the file system, or as an url. + */ + private void setSystemPropertyForRes(String key, Resource res) + throws IOException { + String value = null; + try { + value = res.getFile().getCanonicalPath(); + } catch (IOException e) { + value = res.getURL().toString(); + } + System.setProperty(key, value); + } + + protected ConfigurableApplicationContext createExecutionContext( + SlcExecution slcExecution) { + try { + + // Find runtime definition + Resource runtimeRes = null; + String runtimeStr = slcExecution.getAttributes().get( + AntConstants.EXECATTR_RUNTIME); + if (runtimeStr == null) + runtimeStr = System.getProperty(AntConstants.RUNTIME_PROPERTY, + "default"); + + ResourceLoader rl = new DefaultResourceLoader(getClass() + .getClassLoader()); + try {// tries absolute reference + runtimeRes = rl.getResource(runtimeStr); + } catch (Exception e) { + // silent + } + if (runtimeRes == null || !runtimeRes.exists()) { + if (confDir != null) + runtimeRes = confDir.createRelative("runtime/" + runtimeStr + + ".xml"); + } + + // Find runtime independent application context definition + if (confDir != null && contextLocation == null) { + contextLocation = confDir + .createRelative("applicationContext.xml"); + } + + GenericApplicationContext ctx = new GenericApplicationContext( + parentContext); + ctx.setDisplayName("SLC Execution #" + slcExecution.getUuid()); + + XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(ctx); + if (runtimeRes != null && runtimeRes.exists()) + xmlReader.loadBeanDefinitions(runtimeRes); + else + log.warn("No runtime context defined"); + + if (contextLocation != null && contextLocation.exists()) + xmlReader.loadBeanDefinitions(contextLocation); + else + log.warn("No runtime independent application context defined"); + + // Add property place holder + PropertyPlaceholderConfigurer ppc = new PropertyPlaceholderConfigurer(); + ppc.setIgnoreUnresolvablePlaceholders(true); + ctx.addBeanFactoryPostProcessor(ppc); + + ctx.refresh(); + return ctx; + } catch (Exception e) { + throw new SlcException( + "Cannot create SLC execution application context.", e); + } + } + + protected String findAntScript(SlcExecution slcExecution) { + String scriptStr = slcExecution.getAttributes().get( + AntConstants.EXECATTR_ANT_FILE); + if (scriptStr == null) + throw new SlcException("No Ant script provided"); + + return scriptStr; + } + + protected List findAntTargets(SlcExecution slcExecution) { + String targetList = slcExecution.getAttributes().get( + AntConstants.EXECATTR_ANT_TARGETS); + List targets = new Vector(); + if (targetList != null) { + StringTokenizer stTargets = new StringTokenizer(targetList, ","); + while (stTargets.hasMoreTokens()) { + targets.add(stTargets.nextToken()); + } + } + return targets; + } + + protected void initProject(Project project, Properties properties, + Map references) { + if (properties != null) { + for (Map.Entry entry : properties.entrySet()) { + project.setUserProperty(entry.getKey().toString(), entry + .getValue().toString()); + } + } + + if (references != null) { + for (Map.Entry entry : references.entrySet()) { + project.addReference(entry.getKey(), entry.getValue()); + } + } + + //project.addBuildListener(new CommonsLoggingListener()); + + ListableBeanFactory context = (ListableBeanFactory) project + .getReference(AntConstants.REF_ROOT_CONTEXT); + // Register build listeners + Map listeners = BeanFactoryUtils + .beansOfTypeIncludingAncestors(context, BuildListener.class, + false, false); + for (BuildListener listener : listeners.values()) { + project.addBuildListener(listener); + } + + // Register log4j appenders from context + MDC.put(AntConstants.MDC_ANT_PROJECT, project); + Map appenders = context.getBeansOfType( + Appender.class, false, true); + for (Appender appender : appenders.values()) { + LogManager.getRootLogger().addAppender(appender); + } + + project.init(); + addCustomTaskAndTypes(project); + } + + /** Loads the SLC specific Ant tasks. */ + protected void addCustomTaskAndTypes(Project project) { + Properties taskdefs = getDefs(project, + AntConstants.SLC_TASKDEFS_RESOURCE_PATH); + for (Object o : taskdefs.keySet()) { + String name = o.toString(); + try { + project.addTaskDefinition(name, Class.forName(taskdefs + .getProperty(name))); + } catch (ClassNotFoundException e) { + log.error("Unknown class for task " + name, e); + } + } + Properties typedefs = getDefs(project, + AntConstants.SLC_TYPEDEFS_RESOURCE_PATH); + for (Object o : typedefs.keySet()) { + String name = o.toString(); + try { + project.addDataTypeDefinition(name, Class.forName(typedefs + .getProperty(name))); + } catch (ClassNotFoundException e) { + log.error("Unknown class for type " + name, e); + } + } + } + + private Properties getDefs(Project project, String path) { + Properties defs = new Properties(); + try { + InputStream in = project.getClass().getResourceAsStream(path); + defs.load(in); + in.close(); + } catch (IOException e) { + throw new SlcException("Cannot load task definitions", e); + } + return defs; + } + + protected void initStructure(Project project, String scriptRelativePath) { + // Init structure registry + StructureRegistry registry = new TreeSRegistry(); + project.addReference(AntConstants.REF_STRUCTURE_REGISTRY, registry); + + // Lowest levels + StringTokenizer st = new StringTokenizer(scriptRelativePath, "/"); + TreeSPath currPath = null; + while (st.hasMoreTokens()) { + String name = st.nextToken(); + if (currPath == null) { + currPath = TreeSPath.createRootPath(name); + } else { + if (st.hasMoreTokens())// don't register project file + currPath = currPath.createChild(name); + } + registry.register(currPath, new SimpleSElement(name)); + } + + // Project level + String projectName = project.getName() != null + && !project.getName().equals("") ? project.getName() + : "project"; + TreeSPath projectPath = currPath.createChild(projectName); + + String projectDesc = project.getDescription() != null + && !project.getDescription().equals("") ? project + .getDescription() : projectPath.getName(); + + registry.register(projectPath, new SimpleSElement(projectDesc)); + project.addReference(AntConstants.REF_PROJECT_PATH, projectPath); + + if (log.isDebugEnabled()) + log.debug("Project path: " + projectPath); + } + + protected void parseProject(Project project, String scriptRelativePath) { + try { + Resource script = rootDir.createRelative(scriptRelativePath); + File baseDir = null; + try { + File scriptFile = script.getFile(); + baseDir = scriptFile.getParentFile(); + } catch (IOException e) {// resource is not a file + baseDir = new File(System.getProperty("user.dir")); + } + project.setBaseDir(baseDir); + // Reset basedir property, in order to avoid base dir override when + // running in Maven + project.setProperty("basedir", baseDir.getAbsolutePath()); + + ProjectHelper2 projectHelper = new ProjectHelper2(); + project.addReference(ProjectHelper.PROJECTHELPER_REFERENCE, + projectHelper); + projectHelper.parse(project, script.getURL()); + } catch (Exception e) { + throw new SlcException("Could not parse project for script " + + scriptRelativePath, e); + } + + } + + protected void runProject(Project p, List targets) { + p.fireBuildStarted(); + Throwable exception = null; + try { + if (targets.size() == 0) {// no target defined + p.executeTarget(p.getDefaultTarget()); + } else { + p.executeTargets(new Vector(targets)); + } + } catch (Throwable e) { + exception = e; + throw new SlcException("SLC Ant execution failed", exception); + } finally { + p.fireBuildFinished(exception); + } + } + + public void setContextLocation(Resource contextLocation) { + this.contextLocation = contextLocation; + } + + public void setRootDir(Resource rootDir) { + this.rootDir = rootDir; + } + + public void setConfDir(Resource confDir) { + this.confDir = confDir; + } + + public void setWorkDir(File workDir) { + this.workDir = workDir; + } + + public void setParentContext(ConfigurableApplicationContext runtimeContext) { + this.parentContext = runtimeContext; + } + +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/RemoveRootDirMapper.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/RemoveRootDirMapper.java new file mode 100644 index 000000000..43b247c2b --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/RemoveRootDirMapper.java @@ -0,0 +1,40 @@ +package org.argeo.slc.ant; + +import java.util.StringTokenizer; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.tools.ant.util.FileNameMapper; + +public class RemoveRootDirMapper implements FileNameMapper { + private Log log = LogFactory.getLog(RemoveRootDirMapper.class); + private String to = "enabled"; + + public String[] mapFileName(String sourceFileName) { + StringTokenizer st = new StringTokenizer(sourceFileName, "/"); + boolean first = true; + boolean skipRoot = !to.equals("disabled"); + StringBuffer buf = new StringBuffer(""); + while (st.hasMoreTokens()) { + if (first && skipRoot) { // skip + st.nextToken(); + first = false; + } else { + buf.append(st.nextToken()).append('/'); + } + } + + if (log.isTraceEnabled()) { + log.trace("Source: " + sourceFileName + " - out: " + buf); + } + return new String[] { buf.toString() }; + } + + public void setFrom(String from) { + } + + public void setTo(String to) { + this.to = to; + } + +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/SlcExecutionBuildListener.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/SlcExecutionBuildListener.java new file mode 100644 index 000000000..7447583ab --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/SlcExecutionBuildListener.java @@ -0,0 +1,202 @@ +package org.argeo.slc.ant; + +import java.util.List; +import java.util.Vector; + +import org.apache.log4j.AppenderSkeleton; +import org.apache.log4j.Level; +import org.apache.log4j.MDC; +import org.apache.log4j.spi.LoggingEvent; +import org.apache.tools.ant.BuildEvent; +import org.apache.tools.ant.BuildListener; +import org.apache.tools.ant.Project; +import org.argeo.slc.core.SlcException; +import org.argeo.slc.core.process.SlcExecution; +import org.argeo.slc.core.process.SlcExecutionNotifier; +import org.argeo.slc.core.process.SlcExecutionStep; + +public class SlcExecutionBuildListener extends AppenderSkeleton implements + BuildListener { + private List notifiers = new Vector(); + + private boolean currentStepNotified = true; + + // CUSTOMIZATIONS + /** + * Whether to log Ant initialization stuff before the first target has been + * called. + */ + private boolean logBeforeFirstTarget = false; + /** Whether the first target has been called. */ + private boolean firstTargetStarted = false; + + private boolean logTaskStartFinish = true; + + public SlcExecutionBuildListener() { + // Default log level + setThreshold(Level.INFO); + } + + public void buildStarted(BuildEvent event) { + SlcExecution slcExecution = getSlcExecution(event); + for (SlcExecutionNotifier notifier : notifiers) { + notifier.newExecution(slcExecution); + } + } + + public void buildFinished(BuildEvent event) { + SlcExecution slcExecution = getSlcExecution(event); + String oldStatus = slcExecution.getStatus(); + slcExecution.setStatus(SlcExecution.STATUS_FINISHED); + + for (SlcExecutionNotifier notifier : notifiers) { + notifier.updateStatus(slcExecution, oldStatus, slcExecution + .getStatus()); + } + } + + public void messageLogged(BuildEvent event) { + if (!shouldLog()) + return; + + SlcExecution slcExecution = getSlcExecution(event); + if (slcExecution != null) { + if (currentStepNotified) { + slcExecution.getSteps().add( + new SlcExecutionStep(event.getMessage())); + notifyStep(slcExecution, slcExecution.currentStep()); + currentStepNotified = true; + } else { + slcExecution.currentStep().addLog(event.getMessage()); + } + } else { + // TODO: log before initialization? + } + } + + public void targetStarted(BuildEvent event) { + if (!firstTargetStarted) + firstTargetStarted = true; + + addLogStep(event, "Target " + event.getTarget().getName() + " started"); + } + + public void targetFinished(BuildEvent event) { + addLogStep(event, "Target " + event.getTarget().getName() + " finished"); + } + + public void taskStarted(BuildEvent event) { + if (!shouldLog()) + return; + + SlcExecution slcExecution = getSlcExecution(event); + if (!currentStepNotified) { + notifyStep(slcExecution, slcExecution.currentStep()); + currentStepNotified = true; + } + + String msg = null; + if (logTaskStartFinish) + msg = "Task " + event.getTask().getTaskName() + " started"; + + slcExecution.getSteps().add(new SlcExecutionStep(msg)); + + currentStepNotified = false; + } + + public void taskFinished(BuildEvent event) { + if (!shouldLog()) + return; + + SlcExecution slcExecution = getSlcExecution(event); + if (!currentStepNotified) { + + if (logTaskStartFinish) + slcExecution.currentStep().addLog( + "Task " + event.getTask().getTaskName() + " finished"); + + notifyStep(slcExecution, slcExecution.currentStep()); + currentStepNotified = true; + } + } + + public void setNotifiers(List notifiers) { + this.notifiers = notifiers; + } + + protected SlcExecution getSlcExecution(BuildEvent event) { + return getSlcExecution(event.getProject()); + } + + protected SlcExecution getSlcExecution(Project project) { + SlcExecution slcExecution = (SlcExecution) project + .getReference(AntConstants.REF_SLC_EXECUTION); + + if (slcExecution == null) + throw new SlcException("No SLC Execution registered."); + return slcExecution; + } + + protected void addLogStep(BuildEvent event, String msg) { + SlcExecution slcExecution = getSlcExecution(event); + slcExecution.getSteps().add(new SlcExecutionStep(msg)); + + notifyStep(slcExecution, slcExecution.currentStep()); + currentStepNotified = true; + } + + protected void notifyStep(SlcExecution slcExecution, SlcExecutionStep step) { + Vector additionalSteps = new Vector(); + additionalSteps.add(step); + notifySteps(slcExecution, additionalSteps); + } + + protected void notifySteps(SlcExecution slcExecution, + List additionalSteps) { + for (SlcExecutionNotifier notifier : notifiers) { + notifier.addSteps(slcExecution, additionalSteps); + } + } + + /* Log4j methods */ + + @Override + protected void append(LoggingEvent event) { + Project project = (Project) MDC.get(AntConstants.MDC_ANT_PROJECT); + if (project == null) + throw new SlcException("No Ant project registered in Log4j MDC."); + + SlcExecution slcExecution = getSlcExecution(project); + if (currentStepNotified) { + slcExecution.getSteps().add( + new SlcExecutionStep(event.getMessage().toString())); + currentStepNotified = false; + } else { + slcExecution.currentStep().addLog(event.getMessage().toString()); + } + } + + protected boolean shouldLog() { + return logBeforeFirstTarget || firstTargetStarted; + } + + public void close() { + } + + public boolean requiresLayout() { + return false; + } + + public void setLogBeforeFirstTarget(boolean logBeforeFirstTarget) { + this.logBeforeFirstTarget = logBeforeFirstTarget; + } + + public void setLogTaskStartFinish(boolean logTaskStartFinish) { + this.logTaskStartFinish = logTaskStartFinish; + } + + public void setLogLevel(String logLevel) { + setThreshold(Level.toLevel(logLevel)); + } + +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/SlcDeployTask.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/SlcDeployTask.java new file mode 100644 index 000000000..2055e3b66 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/SlcDeployTask.java @@ -0,0 +1,72 @@ +package org.argeo.slc.ant.deploy; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.tools.ant.BuildException; +import org.argeo.slc.ant.spring.SpringArg; +import org.argeo.slc.ant.structure.SAwareTask; +import org.argeo.slc.core.build.Distribution; +import org.argeo.slc.core.deploy.Deployment; +import org.argeo.slc.core.deploy.DeploymentData; +import org.argeo.slc.core.deploy.TargetData; + +/** Ant task wrapping a deployment. */ +public class SlcDeployTask extends SAwareTask { + private Log log = LogFactory.getLog(SlcDeployTask.class); + + private String deploymentBean = null; + + private SpringArg deploymentDataArg; + private SpringArg targetDataArg; + private SpringArg distributionArg; + + @Override + public void executeActions(String mode) throws BuildException { + Deployment deployment = (Deployment) getContext().getBean( + deploymentBean); + + // set overridden references + if (distributionArg != null) { + deployment.setDistribution(distributionArg.getInstance()); + log.trace("Overrides distribution"); + } + + if (deploymentDataArg != null) { + deployment.setDeploymentData(deploymentDataArg.getInstance()); + log.trace("Overrides deployment data"); + } + + if (targetDataArg != null) { + deployment.setTargetData(targetDataArg.getInstance()); + log.trace("Overrides target data"); + } + + deployment.execute(); + } + + /** + * The bean name of the test run to use. If not set the default is used. + * + * @see SlcAntConfig + */ + public void setDeployment(String deploymentBean) { + this.deploymentBean = deploymentBean; + } + + /** Creates deployment data sub tag. */ + public SpringArg createDeploymentData() { + deploymentDataArg = new SpringArg(); + return deploymentDataArg; + } + + /** Creates target data sub tag. */ + public SpringArg createTargetData() { + targetDataArg = new SpringArg(); + return targetDataArg; + } + + public SpringArg createDistribution() { + distributionArg = new SpringArg(); + return distributionArg; + } +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/SlcManagerTask.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/SlcManagerTask.java new file mode 100644 index 000000000..c4cc74bb1 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/SlcManagerTask.java @@ -0,0 +1,35 @@ +package org.argeo.slc.ant.deploy; + +import java.lang.reflect.Method; + +import org.argeo.slc.ant.structure.SAwareTask; +import org.argeo.slc.core.SlcException; +import org.argeo.slc.core.deploy.DeployedSystem; +import org.argeo.slc.core.deploy.DeployedSystemManager; + +public class SlcManagerTask extends SAwareTask { + private String action; + private String manager; + + @Override + protected void executeActions(String mode) { + DeployedSystemManager systemManager = getBean(manager); + + try { + Method method = systemManager.getClass().getMethod(action, null); + method.invoke(systemManager, null); + } catch (Exception e) { + throw new SlcException("Cannot execute action " + action + + " for manager " + manager, e); + } + } + + public void setAction(String action) { + this.action = action; + } + + public void setManager(String manager) { + this.manager = manager; + } + +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/package.html b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/package.html new file mode 100644 index 000000000..76582d159 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/deploy/package.html @@ -0,0 +1,6 @@ + + + +Integration of SLC Deploy in Ant. + + \ No newline at end of file diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/detached/SlcDetachedTask.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/detached/SlcDetachedTask.java new file mode 100644 index 000000000..d973d3815 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/detached/SlcDetachedTask.java @@ -0,0 +1,76 @@ +package org.argeo.slc.ant.detached; + +import java.util.Properties; +import java.util.UUID; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.argeo.slc.ant.spring.MapArg; +import org.argeo.slc.ant.structure.SAwareTask; +import org.argeo.slc.core.SlcException; +import org.argeo.slc.detached.DetachedAnswer; +import org.argeo.slc.detached.DetachedClient; +import org.argeo.slc.detached.DetachedRequest; +import org.argeo.slc.spring.SpringUtils; + +public class SlcDetachedTask extends SAwareTask { + private final static Log log = LogFactory.getLog(SlcDetachedTask.class); + + private String client; + private String action; + + private MapArg properties; + + @Override + protected void executeActions(String mode) { + // Find detached client + DetachedClient detachedClient = null; + if (client != null) + detachedClient = getBean(client); + else + detachedClient = SpringUtils.loadSingleFromContext(getContext(), + DetachedClient.class); + + if (detachedClient == null) + throw new SlcException("Could not find any detached client."); + + // Prepare and send request + DetachedRequest request = new DetachedRequest(UUID.randomUUID() + .toString()); + request.setRef(action); + + if (properties != null) { + Properties props = new Properties(); + props.putAll(properties.getMap()); + request.setProperties(props); + } + + try { + detachedClient.sendRequest(request); + DetachedAnswer answer = detachedClient.receiveAnswer(); + if (answer.getStatus() == DetachedAnswer.ERROR) + throw new SlcException("Error when executing request " + + answer.getUuid() + ": " + answer.getLog()); + else + log.info("Admin answer: " + answer.getLog()); + } catch (Exception e) { + throw new SlcException("Could not send request.", e); + } + } + + public void setClient(String driverBean) { + this.client = driverBean; + } + + public void setAction(String action) { + this.action = action; + } + + public MapArg createProperties() { + if (properties == null) + properties = new MapArg(); + else + throw new SlcException("Properties already declared."); + return properties; + } +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/package.html b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/package.html new file mode 100644 index 000000000..9f36fb1bf --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/package.html @@ -0,0 +1,38 @@ + + + +Bases classes for SLC Ant extensions. +

Introduction

+SLC Ant allows to integrate Ant and Spring in order to run an +application based on top of SLC. Sequence of actions are defined in Ant +files with specific Ant tasks referencing Spring beans implementing the +SLC interfaces. The properties of these beans can be overridden at +runtime in the Ant scripts. +
+SLC Ant also provides a tree-based implementation of the SLC structure +which allows to uniquely identify and reference the various actions. + +

Installation

+The structure will be first defined by the directory tree where the Ant +files are stored. In order to define the root of this tree, you need to +place in the root directory an +SLC Ant root file +(default name: slcRoot.properties). +
+In this root file you can define a configuration directory and a work +directory (default values are provided if they are not explicitly set). +
+Additional properties can then be defined in files stored under the +configuration directory. +
+For details about the configuration and the various properties, please +refer to {@link org.argeo.slc.ant.SlcAntConfig}. + +

Running SLC Ant

+SLC Ant can be run either via pure Ant scripts or programmatically using +{@link org.argeo.slc.ant.AntRegistryUtil}. In both cases, make sure that +SLC and its dependencies are in the classpath (Spring (always), logging +system such as log4j, Hibernate, etc.). + + + \ No newline at end of file diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/spring/AbstractSpringTask.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/spring/AbstractSpringTask.java new file mode 100644 index 000000000..f0eae3fd0 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/spring/AbstractSpringTask.java @@ -0,0 +1,24 @@ +package org.argeo.slc.ant.spring; + +import org.springframework.context.ApplicationContext; + +import org.apache.tools.ant.Task; + +import org.argeo.slc.ant.AntConstants; +import org.argeo.slc.core.process.SlcExecution; + +/** Abstract Ant task providing access to a Spring context. */ +public abstract class AbstractSpringTask extends Task { + + /** Gets the related Spring context. */ + protected ApplicationContext getContext() { + return (ApplicationContext) getProject().getReference( + AntConstants.REF_ROOT_CONTEXT); + } + + /** Gets the related slc execution or null if not is registered. */ + protected SlcExecution getSlcExecution() { + return (SlcExecution) getProject().getReference( + AntConstants.REF_SLC_EXECUTION); + } +} diff --git a/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/spring/ListArg.java b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/spring/ListArg.java new file mode 100644 index 000000000..7c270eef4 --- /dev/null +++ b/runtime/org.argeo.slc.lib.detached/src/main/java/org/argeo/slc/ant/spring/ListArg.java @@ -0,0 +1,37 @@ +package org.argeo.slc.ant.spring; + +import java.util.List; +import java.util.Vector; + +import org.argeo.slc.core.SlcException; + +/** List of overrides */ +public class ListArg { + private List list = new Vector(); + + /** Creates override sub tag. */ + public OverrideArg createOverride() { + OverrideArg overrideArg = new OverrideArg(); + list.add(overrideArg); + return overrideArg; + } + + /** Gets as list of objects. */ + public List