Exemplo n.º 1
0
  /** Initializes the script, loading any required dependencies and running the script. */
  private void init() {
    int repos = 0;
    for (String repo : script.getHeaders("m2repo")) {
      Map<String, Object> args = Maps.newHashMap();
      args.put("name", "repo_" + repos++);
      args.put("root", repo);
      args.put("m2compatible", true);
      Grape.addResolver(args);
    }

    for (String dependency : script.getHeaders("dependency")) {
      String[] parts = dependency.split(":");
      if (parts.length >= 3) classLoader.loadDependency(parts[0], parts[1], parts[2]);
    }

    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    try {
      Thread.currentThread().setContextClassLoader(classLoader);

      Script groovyScript = shell.parse(script.getBody(), scriptName);
      binding.setProperty("log", log);
      groovyScript.setMetaClass(new ScriptMetaClass(groovyScript.getMetaClass()));

      groovyScript.setBinding(binding);
      groovyScript.run();
    } catch (CompilationFailedException e) {
      log.error("Compilation of Groovy script failed: ", e);
      throw new RuntimeException("Compilation of Groovy script failed", e);
    } finally {
      Thread.currentThread().setContextClassLoader(cl);
    }
  }
 public Object build(Script script) {
   // this used to be synchronized, but we also used to remove the
   // metaclass.  Since adding the metaclass is now a side effect, we
   // don't need to ensure the meta-class won't be observed and don't
   // need to hide the side effect.
   MetaClass scriptMetaClass = script.getMetaClass();
   script.setMetaClass(new FactoryInterceptorMetaClass(scriptMetaClass, this));
   script.setBinding(this);
   Object oldScriptName = getProxyBuilder().getVariables().get(SCRIPT_CLASS_NAME);
   try {
     getProxyBuilder().setVariable(SCRIPT_CLASS_NAME, script.getClass().getName());
     return script.run();
   } finally {
     if (oldScriptName != null) {
       getProxyBuilder().setVariable(SCRIPT_CLASS_NAME, oldScriptName);
     } else {
       getProxyBuilder().getVariables().remove(SCRIPT_CLASS_NAME);
     }
   }
 }
Exemplo n.º 3
0
  public Object eval(final Context context, final Bindings request, final Bindings... scopes)
      throws ScriptException {

    final Map<String, Object> bindings = mergeBindings(context, request, scopes);

    // Bindings so script has access to this environment.
    // Only initialize once.
    if (null == bindings.get("context")) {
      // add context to bindings
      // ctx.setAttribute("context", ctx);

      // direct output to ctx.getWriter
      // If we're wrapping with a PrintWriter here,
      // enable autoFlush because otherwise it might not get done!
      final Writer writer = engine.getWriter();
      bindings.put("out", (writer instanceof PrintWriter) ? writer : new PrintWriter(writer, true));

      // Not going to do this after all (at least for now).
      // Scripts can use context.{reader, writer, errorWriter}.
      // That is a modern version of System.{in, out, err} or
      // Console.{reader, writer}().
      //
      // // New I/O names consistent with ScriptContext and
      // java.io.Console.
      //
      // ctx.setAttribute("writer", writer, ScriptContext.ENGINE_SCOPE);
      //
      // // Direct errors to ctx.getErrorWriter
      // final Writer errorWriter = ctx.getErrorWriter();
      // ctx.setAttribute("errorWriter", (errorWriter instanceof
      // PrintWriter) ?
      // errorWriter :
      // new PrintWriter(errorWriter),
      // ScriptContext.ENGINE_SCOPE);
      //
      // // Get input from ctx.getReader
      // // We don't wrap with BufferedReader here because we expect that
      // if
      // // the host wants that they do it. Either way Groovy scripts will
      // // always have readLine because the GDK supplies it for Reader.
      // ctx.setAttribute("reader", ctx.getReader(),
      // ScriptContext.ENGINE_SCOPE);
    }

    // Fix for GROOVY-3669: Can't use several times the same JSR-223
    // ScriptContext for differents groovy script
    // if (ctx.getWriter() != null) {
    // ctx.setAttribute("out", new PrintWriter(ctx.getWriter(), true),
    // DefaultScriptContext.REQUEST_SCOPE);
    // }

    try {
      Script scriptObject = engine.createScript(scriptName, new Binding(bindings));

      // create a Map of MethodClosures from this new script object
      Method[] methods = scriptObject.getClass().getMethods();
      final Map<String, Closure> closures = new HashMap<String, Closure>();
      for (Method m : methods) {
        String name = m.getName();
        closures.put(name, new MethodClosure(scriptObject, name));
      }

      MetaClass oldMetaClass = scriptObject.getMetaClass();

      /*
       * We override the MetaClass of this script object so that we can
       * forward calls to global closures (of previous or future "eval"
       * calls) This gives the illusion of working on the same "global"
       * scope.
       */
      scriptObject.setMetaClass(
          new DelegatingMetaClass(oldMetaClass) {
            @Override
            public Object invokeMethod(Object object, String name, Object args) {
              if (args == null) {
                return invokeMethod(object, name, MetaClassHelper.EMPTY_ARRAY);
              }
              if (args instanceof Tuple) {
                return invokeMethod(object, name, ((Tuple) args).toArray());
              }
              if (args instanceof Object[]) {
                return invokeMethod(object, name, (Object[]) args);
              } else {
                return invokeMethod(object, name, new Object[] {args});
              }
            }

            @Override
            public Object invokeMethod(Object object, String name, Object[] args) {
              try {
                return super.invokeMethod(object, name, args);
              } catch (MissingMethodException mme) {
                return callGlobal(name, args, bindings);
              }
            }

            @Override
            public Object invokeStaticMethod(Object object, String name, Object[] args) {
              try {
                return super.invokeStaticMethod(object, name, args);
              } catch (MissingMethodException mme) {
                return callGlobal(name, args, bindings);
              }
            }

            private Object callGlobal(String name, Object[] args, Map<String, Object> ctx) {
              Closure closure = closures.get(name);
              if (closure != null) {
                return closure.call(args);
              } else {
                // Look for closure valued variable in the
                // given ScriptContext. If available, call it.
                Object value = ctx.get(name);
                if (value instanceof Closure) {
                  return ((Closure) value).call(args);
                } // else fall thru..
              }
              throw new MissingMethodException(name, getClass(), args);
            }
          });

      try {
        return scriptObject.run();
      } catch (Exception e) {
        throw new ScriptThrownException(e.getMessage(), e);
      }
    } catch (ScriptException e) {
      throw e;
    } catch (CompilationFailedException e) {
      throw new ScriptCompilationException(e);
    } catch (Exception e) {
      throw new ScriptException(e);
    } finally {
      // Fix for GROOVY-3669: Can't use several times the same JSR-223
      // ScriptContext for different groovy script
      // Groovy's scripting engine implementation adds those two variables
      // in the binding
      // but should clean up afterwards
      // ctx.removeAttribute("context",
      // DefaultScriptContext.REQUEST_SCOPE);
      // ctx.removeAttribute("out", DefaultScriptContext.REQUEST_SCOPE);
    }
  }