Subversion Repositories XServices

/*
 *   Copyright 2011 Brian Rosenberger (Brutex Network)
 *
 *   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 net.brutex.xservices.util;

import java.io.Serializable;
import java.util.Date;

import org.mozilla.javascript.Context;
import org.mozilla.javascript.Scriptable;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * Wrapper for jobs that can be executed through quartz scheduler.
 * 
 * @author Brian Rosenberger, bru@brutex.de
 * @since 0.5.0
 * 
 */
public class JobWrapper implements Job, Serializable {

        public void execute(JobExecutionContext jcontext)
                
        throws JobExecutionException {
                try {

                        System.out.println("Executing scheduled job '"+jcontext.getJobDetail().getKey().getName()+"' at " + new Date());

                        JobDataMap jdMap = jcontext.getJobDetail().getJobDataMap();
                        String script = jdMap.getString("script");

                        // Create and enter a Context. A Context stores information about
                        // the execution environment of a script.
                        Context cx = Context.enter();
                        cx.setOptimizationLevel(0);
                        cx.setLanguageVersion(Context.VERSION_1_7);
                        // cx is the Context instance you're using to run scripts
                        /*
                         * cx.setClassShutter(new ClassShutter() { public boolean
                         * visibleToScripts(String className) {
                         * if(className.startsWith("adapter")) return true;
                         * if(className.startsWith("java.lang.System") ||
                         * className.startsWith
                         * ("org.apache.tomcat.util.log.SystemLogHandler")) return true;
                         * System.out.println(className + " is blocked."); return false; }
                         * });
                         */

                        // Initialise the standard objects (Object, Function, etc.). This
                        // must be done before scripts can be
                        // executed. The null parameter tells initStandardObjects
                        // to create and return a scope object that we use
                        // in later calls.
                        Scriptable scope = cx.initStandardObjects();
                        //Object wrappedOut = Context.javaToJS(System.out, scope);
                        //Object wrappedOut2 = Context.javaToJS(this, scope);
                        //scope.put("out", scope, wrappedOut);
                        //scope.put("exe", scope, wrappedOut2);

                        // Execute the script
                        // cx.evaluateString(scope, "importClass('java.lang.System');\n",
                        // "head", 1, null);
                        // cx.evaluateString(scope, "importPackage('java.util');\n", "head",
                        // 2, null);
                        Object obj = cx
                                        .evaluateString(scope, script, "TestScript", 1, null);
                        

                } catch (Exception e) {
                        System.out.println(e.getMessage());
                } finally {
                        // Exit the Context. This removes the association between the
                        // Context and the current thread and is an
                        // essential cleanup action. There should be a call to exit for
                        // every call to enter.
                        Context.exit();
                }

        }
}