jelly-tags/threads/src/java/org/apache/commons/jelly/tags/threads/ThreadTag.java

/*
 * Copyright 2002,2004 The Apache Software Foundation.
 *
 * Licensed 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.commons.jelly.tags.threads;

import org.apache.commons.jelly.JellyContext;
import org.apache.commons.jelly.JellyTagException;
import org.apache.commons.jelly.TagSupport;
import org.apache.commons.jelly.XMLOutput;
import org.apache.commons.jelly.util.NestedRuntimeException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

/**
 * A tag that spawns the contained script in a separate thread.  A thread
 * can wait on another thread or another thread group to finish before starting.
 *
 * @author <a href="mailto:vinayc@apache.org">Vinay Chandran</a>
 * @author <a href="mailto:jason@jhorman.org">Jason Horman</a>
 */
public class ThreadTag extends TagSupport {
    /** The Log to which logging calls will be made. */
    private static final Log log = LogFactory.getLog(ThreadTag.class);

    /** The current thread number. Used for default thread naming */
    private static int threadNumber = 0;

    /** Variable to place the thread into */
    private String var = null;
    /** Thread Name */
    private String name = null;
    /** Thread priority, defaults to Thread.NORM_PRIORITY */
    private int priority = Thread.NORM_PRIORITY;
    /** Set if the thread should be a daemon or not */
    private boolean daemon = false;
    /** the destination of output */
    private XMLOutput xmlOutput;
    /** Should we close the underlying output */
    private boolean closeOutput;
    /** Should a new context be created */
    private boolean newContext = false;
    /** Keep a reference to the thread */
    private JellyThread thread = new JellyThread();

    public ThreadTag() {
        super();
    }

    public ThreadTag(boolean shouldTrim) {
        super(shouldTrim);
    }

    // Tag interface
    //-------------------------------------------------------------------------
    public void doTag(final XMLOutput output) throws JellyTagException {
        if (xmlOutput == null) {
            // lets default to system.out
            try {
                xmlOutput = XMLOutput.createXMLOutput(System.out);
            }
            catch (UnsupportedEncodingException e) {
                throw new JellyTagException(e);
            }
        }

        // lets create a child context
        final JellyContext useThisContext = newContext ? context.newJellyContext() : context;

        // set the target to run
        thread.setTarget(new Runnable() {
            public void run() {
                try {
                    getBody().run(useThisContext, xmlOutput);
                    if (closeOutput) {
                        xmlOutput.close();
                    }
                    else {
                        xmlOutput.flush();
                    }
                }
                catch (JellyTagException e) {
                    // jelly wraps the exceptions thrown
                    Throwable subException = e.getCause();
                    if (subException != null) {
                        if (subException instanceof TimeoutException) {
                            throw (TimeoutException)subException;
                        } else if (subException instanceof RequirementException) {
                            throw (RequirementException)subException;
                        }
                    }

                    log.error(e);

                    // wrap the exception with a RuntimeException
                    throw new NestedRuntimeException(e);
                }
                catch (Exception e) {
                    log.error(e);

                    // wrap the exception with a RuntimeException
                    if (e instanceof RuntimeException) {
                        throw (RuntimeException) e;
                    }
                    else {
                        throw new NestedRuntimeException(e);
                    }
                }
            }
        });

        // set the threads priority
        thread.setPriority(priority);

        // set the threads name
        if (name != null) {
            thread.setName(name);
        } else {
            thread.setName("Jelly Thread #" + (threadNumber++));
        }

        // set whether this thread is a daemon thread
        thread.setDaemon(daemon);

        // save the thread in a context variable
        if (var != null) {
            context.setVariable(var, thread);
        }

        // check if this tag is nested inside a group tag. if so
        // add this thread to the thread group but do not start it.
        // all threads in a thread group should start together.
        GroupTag gt = (GroupTag) findAncestorWithClass(GroupTag.class);
        if (gt != null) {
            gt.addThread(thread);
        } else {
            // start the thread
            thread.start();
        }
    }

    /**
     * Sets the variable name to export, optional
     * @param var The variable name
     */
    public void setVar(String var) {
        this.var = var;
        if (name == null) {
            name = var;
        }
    }

    /**
     * Sets the name of the thread.
     * @param name The name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Set the threads priority. Defaults to Thread.NORM_PRIORITY
     */
    public void setPriority(int priority) {
        this.priority = priority;
    }

    /**
     * Sets the thread to be a daemon thread if true
     */
    public void setDaemon(boolean daemon) {
        this.daemon = daemon;
    }

    /**
     * Sets the destination of output
     */
    public void setXmlOutput(XMLOutput xmlOutput) {
        this.closeOutput = false;
        this.xmlOutput = xmlOutput;
    }

    /**
     * Set the file which is generated from the output
     * @param name The output file name
     */
    public void setFile(String name) throws IOException {
        this.closeOutput = true;
        setXmlOutput(XMLOutput.createXMLOutput(new FileOutputStream(name)));
    }

    /**
     * Should a new context be created for this thread?
     */
    public void setNewContext(boolean newContext) {
        this.newContext = newContext;
    }

    /**
     * Get the thread instance
     * @return The thread
     */
    public Thread getThread() {
        return thread;
    }
}