private GroovyShell createEngine(AbstractBuild<?, ?> build, TaskListener listener) {

    ClassLoader cl = Jenkins.getInstance().getPluginManager().uberClassLoader;
    ScriptSandbox sandbox = null;
    CompilerConfiguration cc = new CompilerConfiguration();
    cc.addCompilationCustomizers(
        new ImportCustomizer()
            .addStarImports("jenkins", "jenkins.model", "hudson", "hudson.model"));

    ExtendedEmailPublisher publisher =
        build.getProject().getPublishersList().get(ExtendedEmailPublisher.class);
    if (publisher.getDescriptor().isSecurityEnabled()) {
      cc.addCompilationCustomizers(new SandboxTransformer());
      sandbox = new ScriptSandbox();
    }

    Binding binding = new Binding();
    binding.setVariable("build", build);
    binding.setVariable("project", build.getParent());
    binding.setVariable("rooturl", publisher.getDescriptor().getHudsonUrl());
    binding.setVariable("out", listener.getLogger());

    GroovyShell shell = new GroovyShell(cl, binding, cc);

    if (sandbox != null) {
      sandbox.register();
    }

    return shell;
  }
  @Override
  public void compileToDir(
      ScriptSource source,
      ClassLoader classLoader,
      File classesDir,
      File metadataDir,
      CompileOperation<?> extractingTransformer,
      Class<? extends Script> scriptBaseClass,
      Action<? super ClassNode> verifier) {
    Clock clock = new Clock();
    GFileUtils.deleteDirectory(classesDir);
    GFileUtils.mkdirs(classesDir);
    CompilerConfiguration configuration = createBaseCompilerConfiguration(scriptBaseClass);
    configuration.setTargetDirectory(classesDir);
    try {
      compileScript(
          source,
          classLoader,
          configuration,
          classesDir,
          metadataDir,
          extractingTransformer,
          verifier);
    } catch (GradleException e) {
      GFileUtils.deleteDirectory(classesDir);
      GFileUtils.deleteDirectory(metadataDir);
      throw e;
    }

    logger.debug(
        "Timing: Writing script to cache at {} took: {}",
        classesDir.getAbsolutePath(),
        clock.getTime());
  }
  private boolean executePresendScript(
      AbstractBuild<?, ?> build,
      BuildListener listener,
      MimeMessage msg,
      EmailTrigger trigger,
      Map<String, EmailTrigger> triggered)
      throws RuntimeException {
    boolean cancel = false;
    presendScript = new ContentBuilder().transformText(presendScript, this, build, listener);
    if (StringUtils.isNotBlank(presendScript)) {
      listener.getLogger().println("Executing pre-send script");
      ClassLoader cl = Jenkins.getInstance().getPluginManager().uberClassLoader;
      ScriptSandbox sandbox = null;
      CompilerConfiguration cc = new CompilerConfiguration();
      cc.addCompilationCustomizers(
          new ImportCustomizer()
              .addStarImports("jenkins", "jenkins.model", "hudson", "hudson.model"));

      if (ExtendedEmailPublisher.DESCRIPTOR.isSecurityEnabled()) {
        debug(listener.getLogger(), "Setting up sandbox for pre-send script");
        cc.addCompilationCustomizers(new SandboxTransformer());
        sandbox = new ScriptSandbox();
      }

      Binding binding = new Binding();
      binding.setVariable("build", build);
      binding.setVariable("msg", msg);
      binding.setVariable("logger", listener.getLogger());
      binding.setVariable("cancel", cancel);
      binding.setVariable("trigger", trigger);
      binding.setVariable("triggered", Collections.unmodifiableMap(triggered));

      GroovyShell shell = new GroovyShell(cl, binding, cc);
      StringWriter out = new StringWriter();
      PrintWriter pw = new PrintWriter(out);

      if (sandbox != null) {
        sandbox.register();
      }

      try {
        Object output = shell.evaluate(presendScript);
        if (output != null) {
          pw.println("Result: " + output);
          cancel = ((Boolean) shell.getVariable("cancel")).booleanValue();
          debug(listener.getLogger(), "Pre-send script set cancel to %b", cancel);
        }
      } catch (SecurityException e) {
        listener
            .getLogger()
            .println("Pre-send script tried to access secured objects: " + e.getMessage());
      } catch (Throwable t) {
        t.printStackTrace(pw);
        listener.getLogger().println(out.toString());
        // should we cancel the sending of the email???
      }
      debug(listener.getLogger(), out.toString());
    }
    return !cancel;
  }
Пример #4
0
  public static CompilerConfiguration generateCompilerConfigurationFromOptions(CommandLine cli)
      throws IOException {
    //
    // Setup the configuration data

    CompilerConfiguration configuration = new CompilerConfiguration();

    if (cli.hasOption("classpath")) {
      configuration.setClasspath(cli.getOptionValue("classpath"));
    }

    if (cli.hasOption('d')) {
      configuration.setTargetDirectory(cli.getOptionValue('d'));
    }

    if (cli.hasOption("encoding")) {
      configuration.setSourceEncoding(cli.getOptionValue("encoding"));
    }

    if (cli.hasOption("basescript")) {
      configuration.setScriptBaseClass(cli.getOptionValue("basescript"));
    }

    // joint compilation parameters
    if (cli.hasOption('j')) {
      Map<String, Object> compilerOptions = new HashMap<String, Object>();

      String[] opts = cli.getOptionValues("J");
      compilerOptions.put("namedValues", opts);

      opts = cli.getOptionValues("F");
      compilerOptions.put("flags", opts);

      configuration.setJointCompilationOptions(compilerOptions);
    }

    if (cli.hasOption("indy")) {
      configuration.getOptimizationOptions().put("int", false);
      configuration.getOptimizationOptions().put("indy", true);
    }

    if (cli.hasOption("configscript")) {
      String path = cli.getOptionValue("configscript");
      File groovyConfigurator = new File(path);
      Binding binding = new Binding();
      binding.setVariable("configuration", configuration);

      CompilerConfiguration configuratorConfig = new CompilerConfiguration();
      ImportCustomizer customizer = new ImportCustomizer();
      customizer.addStaticStars(
          "org.codehaus.groovy.control.customizers.builder.CompilerCustomizationBuilder");
      configuratorConfig.addCompilationCustomizers(customizer);

      GroovyShell shell = new GroovyShell(binding, configuratorConfig);
      shell.evaluate(groovyConfigurator);
    }

    return configuration;
  }
Пример #5
0
 private static GroovyClassLoader getGroovyClassLoader() {
   GroovySystem.getMetaClassRegistry()
       .setMetaClassCreationHandle(new ExpandoMetaClassCreationHandle());
   CompilerConfiguration config = new CompilerConfiguration();
   config.setDebug(true);
   config.setVerbose(true);
   ClassLoader parent = ClassLoader.getSystemClassLoader();
   GroovyClassLoader loader = new GroovyClassLoader(parent);
   loader.setShouldRecompile(true);
   return loader;
 }
Пример #6
0
  private void runCompiler(String[] commandLine) {
    // hand crank it so we can add our own compiler configuration
    try {
      Options options = FileSystemCompiler.createCompilationOptions();

      CommandLineParser cliParser = new DefaultParser();

      CommandLine cli;
      cli = cliParser.parse(options, commandLine);

      configuration = FileSystemCompiler.generateCompilerConfigurationFromOptions(cli);
      configuration.setScriptExtensions(getScriptExtensions());
      String tmpExtension = getScriptExtension();
      if (tmpExtension.startsWith("*.")) tmpExtension = tmpExtension.substring(1);
      configuration.setDefaultScriptExtension(tmpExtension);

      // Load the file name list
      String[] filenames = FileSystemCompiler.generateFileNamesFromOptions(cli);
      boolean fileNameErrors = filenames == null;

      fileNameErrors = fileNameErrors || !FileSystemCompiler.validateFiles(filenames);

      if (targetBytecode != null) {
        configuration.setTargetBytecode(targetBytecode);
      }

      if (!fileNameErrors) {
        FileSystemCompiler.doCompilation(
            configuration, makeCompileUnit(), filenames, forceLookupUnnamedFiles);
      }

    } catch (Exception re) {
      Throwable t = re;
      if ((re.getClass() == RuntimeException.class) && (re.getCause() != null)) {
        // unwrap to the real exception
        t = re.getCause();
      }
      StringWriter writer = new StringWriter();
      new ErrorReporter(t, false).write(new PrintWriter(writer));
      String message = writer.toString();

      taskSuccess = false;
      if (errorProperty != null) {
        getProject().setNewProperty(errorProperty, "true");
      }

      if (failOnError) {
        log.error(message);
        throw new BuildException("Compilation Failed", t, getLocation());
      } else {
        log.error(message);
      }
    }
  }
Пример #7
0
 public GroovyEngine(ServiceDispatcher dispatcher) {
   super(dispatcher);
   try {
     String scriptBaseClass = ServiceConfigUtil.getEngineParameter("groovy", "scriptBaseClass");
     if (scriptBaseClass != null) {
       CompilerConfiguration conf = new CompilerConfiguration();
       conf.setScriptBaseClass(scriptBaseClass);
       groovyClassLoader = new GroovyClassLoader(getClass().getClassLoader(), conf);
     }
   } catch (GenericConfigException gce) {
     Debug.logWarning(
         gce, "Error retrieving the configuration for the groovy service engine: ", module);
   }
 }
 @Inject
 public GroovyScriptEngineService(Settings settings) {
   super(settings);
   ImportCustomizer imports = new ImportCustomizer();
   imports.addStarImports("org.joda.time");
   imports.addStaticStars("java.lang.Math");
   CompilerConfiguration config = new CompilerConfiguration();
   config.addCompilationCustomizers(imports);
   this.sandboxed = settings.getAsBoolean(GROOVY_SCRIPT_SANDBOX_ENABLED, true);
   if (this.sandboxed) {
     config.addCompilationCustomizers(
         GroovySandboxExpressionChecker.getSecureASTCustomizer(settings));
   }
   this.loader = new GroovyClassLoader(settings.getClassLoader(), config);
 }
Пример #9
0
  protected boolean isSourceNewer(ScriptCacheEntry entry) throws ResourceException {
    if (entry == null) return true;

    long now = 0;

    for (String scriptName : entry.dependencies) {
      ScriptCacheEntry depEntry = scriptCache.get(scriptName);
      if (depEntry.sourceNewer) return true;

      if (now == 0) {
        now = System.currentTimeMillis();
      }

      long nextSourceCheck = depEntry.lastCheck + config.getMinimumRecompilationInterval();
      if (nextSourceCheck > now) continue;

      long lastMod = getLastModified(scriptName);
      if (depEntry.lastModified < lastMod) {
        depEntry = new ScriptCacheEntry(depEntry, lastMod, true);
        scriptCache.put(scriptName, depEntry);
        return true;
      } else {
        depEntry = new ScriptCacheEntry(depEntry, now, false);
        scriptCache.put(scriptName, depEntry);
      }
    }

    return false;
  }
Пример #10
0
  ClassManager(
      PluginContext context,
      ResourceKind kind,
      Class<T> baseClass,
      Class<? extends Script> baseScriptClass) {
    CompilerConfiguration config = new CompilerConfiguration();
    config.setRecompileGroovySource(true);
    config.setScriptBaseClass(GroovyScriptCommand.class.getName());

    //
    this.context = context;
    this.baseScriptClass = baseScriptClass;
    this.config = config;
    this.baseClass = baseClass;
    this.kind = kind;
  }
Пример #11
0
  protected ClassVisitor createClassVisitor() {
    CompilerConfiguration config = getConfiguration();
    int computeMaxStackAndFrames = ClassWriter.COMPUTE_MAXS;
    if (CompilerConfiguration.isPostJDK7(config.getTargetBytecode())
        || Boolean.TRUE.equals(config.getOptimizationOptions().get("indy"))) {
      computeMaxStackAndFrames += ClassWriter.COMPUTE_FRAMES;
    }
    return new ClassWriter(computeMaxStackAndFrames) {
      private ClassNode getClassNode(String name) {
        // try classes under compilation
        CompileUnit cu = getAST();
        ClassNode cn = cu.getClass(name);
        if (cn != null) return cn;
        // try inner classes
        cn = cu.getGeneratedInnerClass(name);
        if (cn != null) return cn;
        // try class loader classes
        try {
          cn = ClassHelper.make(cu.getClassLoader().loadClass(name, false, true), false);
        } catch (Exception e) {
          throw new GroovyBugError(e);
        }
        return cn;
      }

      private ClassNode getCommonSuperClassNode(ClassNode c, ClassNode d) {
        // adapted from ClassWriter code
        if (c.isDerivedFrom(d)) return d;
        if (d.isDerivedFrom(c)) return c;
        if (c.isInterface() || d.isInterface()) return ClassHelper.OBJECT_TYPE;
        do {
          c = c.getSuperClass();
        } while (c != null && !d.isDerivedFrom(c));
        if (c == null) return ClassHelper.OBJECT_TYPE;
        return c;
      }

      @Override
      protected String getCommonSuperClass(String arg1, String arg2) {
        ClassNode a = getClassNode(arg1.replace('/', '.'));
        ClassNode b = getClassNode(arg2.replace('/', '.'));
        return getCommonSuperClassNode(a, b).getName().replace('.', '/');
      }
    };
  }
Пример #12
0
 public static void doCompilation(
     CompilerConfiguration configuration,
     CompilationUnit unit,
     String[] filenames,
     boolean lookupUnnamedFiles)
     throws Exception {
   File tmpDir = null;
   // if there are any joint compilation options set stubDir if not set
   try {
     if ((configuration.getJointCompilationOptions() != null)
         && !configuration.getJointCompilationOptions().containsKey("stubDir")) {
       tmpDir =
           DefaultGroovyStaticMethods.createTempDir(null, "groovy-generated-", "-java-source");
       configuration.getJointCompilationOptions().put("stubDir", tmpDir);
     }
     FileSystemCompiler compiler = new FileSystemCompiler(configuration, unit);
     if (lookupUnnamedFiles) {
       for (String filename : filenames) {
         File file = new File(filename);
         if (file.isFile()) {
           URL url = file.getAbsoluteFile().getParentFile().toURI().toURL();
           compiler.unit.getClassLoader().addURL(url);
         }
       }
     } else {
       compiler
           .unit
           .getClassLoader()
           .setResourceLoader(
               new GroovyResourceLoader() {
                 public URL loadGroovySource(String filename) throws MalformedURLException {
                   return null;
                 }
               });
     }
     compiler.compile(filenames);
   } finally {
     try {
       if (tmpDir != null) deleteRecursive(tmpDir);
     } catch (Throwable t) {
       System.err.println("error: could not delete temp files - " + tmpDir.getPath());
     }
   }
 }
Пример #13
0
 public FileSystemCompiler(CompilerConfiguration configuration, CompilationUnit cu)
     throws ConfigurationException {
   if (cu != null) {
     unit = cu;
   } else if (configuration.getJointCompilationOptions() != null) {
     unit = new JavaAwareCompilationUnit(configuration);
   } else {
     unit = new CompilationUnit(configuration);
   }
 }
Пример #14
0
 /**
  * Indicates if a class is recompilable. Recompilable means, that the classloader will try to
  * locate a groovy source file for this class and then compile it again, adding the resulting
  * class as entry to the cache. Giving null as class is like a recompilation, so the method should
  * always return true here. Only classes that are implementing GroovyObject are compilable and
  * only if the timestamp in the class is lower than Long.MAX_VALUE.
  *
  * <p>NOTE: First the parent loaders will be asked and only if they don't return a class the
  * recompilation will happen. Recompilation also only happen if the source file is newer.
  *
  * @param cls the class to be tested. If null the method should return true
  * @return true if the class should be compiled again
  * @see #isSourceNewer(URL, Class)
  */
 protected boolean isRecompilable(Class cls) {
   if (cls == null) return true;
   if (cls.getClassLoader() == this) return false;
   if (recompile == null && !config.getRecompileGroovySource()) return false;
   if (recompile != null && !recompile) return false;
   if (!GroovyObject.class.isAssignableFrom(cls)) return false;
   long timestamp = getTimeStamp(cls);
   if (timestamp == Long.MAX_VALUE) return false;
   return true;
 }
Пример #15
0
  protected GroovyClassLoader buildClassLoaderFor() {
    // GROOVY-5044
    if (!fork && !getIncludeantruntime()) {
      throw new IllegalArgumentException(
          "The includeAntRuntime=false option is not compatible with fork=false");
    }
    ClassLoader parent =
        getIncludeantruntime()
            ? getClass().getClassLoader()
            : new AntClassLoader(
                new RootLoader(EMPTY_URL_ARRAY, null), getProject(), getClasspath());
    if (parent instanceof AntClassLoader) {
      AntClassLoader antLoader = (AntClassLoader) parent;
      String[] pathElm = antLoader.getClasspath().split(File.pathSeparator);
      List<String> classpath = configuration.getClasspath();
      /*
       * Iterate over the classpath provided to groovyc, and add any missing path
       * entries to the AntClassLoader.  This is a workaround, since for some reason
       * 'directory' classpath entries were not added to the AntClassLoader' classpath.
       */
      for (String cpEntry : classpath) {
        boolean found = false;
        for (String path : pathElm) {
          if (cpEntry.equals(path)) {
            found = true;
            break;
          }
        }
        /*
         * fix for GROOVY-2284
         * seems like AntClassLoader doesn't check if the file
         * may not exist in the classpath yet
         */
        if (!found && new File(cpEntry).exists()) {
          try {
            antLoader.addPathElement(cpEntry);
          } catch (BuildException e) {
            log.warn("The classpath entry " + cpEntry + " is not a valid Java resource");
          }
        }
      }
    }

    GroovyClassLoader loader = new GroovyClassLoader(parent, configuration);
    if (!forceLookupUnnamedFiles) {
      // in normal case we don't need to do script lookups
      loader.setResourceLoader(
          new GroovyResourceLoader() {
            public URL loadGroovySource(String filename) throws MalformedURLException {
              return null;
            }
          });
    }
    return loader;
  }
Пример #16
0
  /**
   * Configures its debugging mode and classloader classpath from a given compiler configuration.
   * This cannot be done more than once due to limitations in {@link java.net.URLClassLoader
   * URLClassLoader}.
   */
  public void configure(CompilerConfiguration configuration) {
    super.configure(configuration);
    this.debug = configuration.getDebug();

    if (!this.configured && this.classLoader instanceof GroovyClassLoader) {
      appendCompilerConfigurationClasspathToClassLoader(
          configuration, (GroovyClassLoader) this.classLoader);
    }

    this.configured = true;
  }
Пример #17
0
 /**
  * creates a GroovyClassLoader.
  *
  * @param parent the parent class loader
  * @param config the compiler configuration
  * @param useConfigurationClasspath determines if the configurations classpath should be added
  */
 public GroovyClassLoader(
     ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath) {
   super(EMPTY_URL_ARRAY, parent);
   if (config == null) config = CompilerConfiguration.DEFAULT;
   this.config = config;
   if (useConfigurationClasspath) {
     for (String path : config.getClasspath()) {
       this.addClasspath(path);
     }
   }
 }
Пример #18
0
 private GroovyClassLoader createClassLoader(
     ClassLoader parentLoader,
     final boolean staticCompile,
     Class<? extends Script> scriptBaseClass) {
   final CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
   if (!scriptBaseClass.equals(Script.class)) {
     compilerConfiguration.setScriptBaseClass(scriptBaseClass.getName());
   }
   compilerConfiguration.addCompilationCustomizers(
       new CompilationCustomizer(CompilePhase.CONVERSION) {
         @Override
         public void call(SourceUnit source, GeneratorContext context, ClassNode classNode)
             throws org.codehaus.groovy.control.CompilationFailedException {
           if (staticCompile) {
             classNode.addAnnotation(new AnnotationNode(new ClassNode(CompileStatic.class)));
           }
           classNode.addAnnotation(new AnnotationNode(new ClassNode(InheritConstructors.class)));
         }
       });
   return new GroovyClassLoader(parentLoader, compilerConfiguration);
 }
Пример #19
0
    public String call() throws RuntimeException {
      // if we run locally, cl!=null. Otherwise the delegating classloader will be available as
      // context classloader.
      if (cl == null) cl = Thread.currentThread().getContextClassLoader();
      CompilerConfiguration cc = new CompilerConfiguration();
      cc.addCompilationCustomizers(
          new ImportCustomizer()
              .addStarImports("jenkins", "jenkins.model", "hudson", "hudson.model"));
      GroovyShell shell = new GroovyShell(cl, new Binding(), cc);

      StringWriter out = new StringWriter();
      PrintWriter pw = new PrintWriter(out);
      shell.setVariable("out", pw);
      try {
        Object output = shell.evaluate(script);
        if (output != null) pw.println("Result: " + output);
      } catch (Throwable t) {
        t.printStackTrace(pw);
      }
      return out.toString();
    }
 @Override
 protected ClassLoader getClassLoader() throws ServletException {
   if (cl == null) {
     final CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
     compilerConfiguration.setRecompileGroovySource(true);
     cl = new GroovyClassLoader(super.getClassLoader(), compilerConfiguration);
     String scriptsPath = getServletConfig().getInitParameter("scriptsPath");
     if (scriptsPath != null) {
       // Zemian Deng 2012/11/22 - Allow scriptsPath to set in relative to /WEB-INF folder.
       if (scriptsPath.startsWith("/WEB-INF")) {
         scriptsPath = getServletContext().getRealPath(scriptsPath);
       }
       final String scriptsPathFinal = scriptsPath;
       cl.setResourceLoader(
           new GroovyResourceLoader() {
             public URL loadGroovySource(final String name) throws MalformedURLException {
               return (URL)
                   AccessController.doPrivileged(
                       new PrivilegedAction() {
                         public Object run() {
                           String filename =
                               name.replace('.', '/')
                                   + compilerConfiguration.getDefaultScriptExtension();
                           try {
                             final File file = new File(scriptsPathFinal + "/" + filename);
                             if (!file.exists() || !file.isFile()) {
                               return null;
                             }
                             return new URL("file:///" + scriptsPathFinal + "/" + filename);
                           } catch (MalformedURLException e) {
                             return null;
                           }
                         }
                       });
             }
           });
     }
   }
   return cl;
 }
 @Test
 public void specialScript() throws Exception {
   CompilerConfiguration cc = GroovySandbox.createSecureCompilerConfiguration();
   cc.setScriptBaseClass(SpecialScript.class.getName());
   GroovyShell shell = new GroovyShell(cc);
   Whitelist wl =
       new AbstractWhitelist() {
         @Override
         public boolean permitsMethod(Method method, Object receiver, Object[] args) {
           return method.getDeclaringClass() == GroovyObject.class
               && method.getName().equals("getProperty")
               && receiver instanceof SpecialScript
               && args[0].equals("magic");
         }
       };
   assertEquals(42, GroovySandbox.run(shell.parse("magic"), wl));
   try {
     GroovySandbox.run(shell.parse("boring"), wl);
   } catch (MissingPropertyException x) {
     assertEquals("boring", x.getProperty());
   }
 }
Пример #22
0
  private Class doParseClass(GroovyCodeSource codeSource) {
    validate(codeSource);
    Class answer; // Was neither already loaded nor compiling, so compile and add to cache.
    CompilationUnit unit = createCompilationUnit(config, codeSource.getCodeSource());
    if (recompile != null && recompile || recompile == null && config.getRecompileGroovySource()) {
      unit.addFirstPhaseOperation(
          TimestampAdder.INSTANCE, CompilePhase.CLASS_GENERATION.getPhaseNumber());
    }
    SourceUnit su = null;
    File file = codeSource.getFile();
    if (file != null) {
      su = unit.addSource(file);
    } else {
      URL url = codeSource.getURL();
      if (url != null) {
        su = unit.addSource(url);
      } else {
        su = unit.addSource(codeSource.getName(), codeSource.getScriptText());
      }
    }

    ClassCollector collector = createCollector(unit, su);
    unit.setClassgenCallback(collector);
    int goalPhase = Phases.CLASS_GENERATION;
    if (config != null && config.getTargetDirectory() != null) goalPhase = Phases.OUTPUT;
    unit.compile(goalPhase);

    answer = collector.generatedClass;
    String mainClass = su.getAST().getMainClassName();
    for (Object o : collector.getLoadedClasses()) {
      Class clazz = (Class) o;
      String clazzName = clazz.getName();
      definePackage(clazzName);
      setClassCacheEntry(clazz);
      if (clazzName.equals(mainClass)) answer = clazz;
    }
    return answer;
  }
Пример #23
0
  /** @param args */
  public static void main(String[] args) {
    log("Groovy Compiler Test");
    final File[] files =
        FileFinder.newFileFinder("/tmp/groovy")
            .filterBuilder()
            .endsWithMatch(".groovy")
            .fileFinder()
            .find();
    final HeliosURLClassLoader hcl =
        new HeliosURLClassLoader("groovy", URLHelper.toURL("/tmp/groovy"));

    try {
      CompilerConfiguration compilerConfig =
          new CompilerConfiguration(CompilerConfiguration.DEFAULT);
      compilerConfig.setScriptBaseClass(NashScript.class.getName());
      GroovyShell groovyCompiler = new GroovyShell(compilerConfig);
      GroovyClassLoader groovyClassLoader = new GroovyClassLoader(hcl, compilerConfig);
      for (File f : files) {
        log("Compiling [%s]", f);
        Class<?> clazz = groovyClassLoader.parseClass(URLHelper.getTextFromFile(f));
        log("Compiled: [%s], parent:[%s]", clazz.getName(), clazz.getSuperclass().getName());
        Object o = clazz.newInstance();
        for (Field field : clazz.getDeclaredFields()) {
          if (!field.getName().contains("$")) {
            field.setAccessible(true);
            Object fieldValue = field.get(o);
            log(
                "\tField: [%s], type:[%s], valueType: [%s]",
                field.getName(), field.getType().getName(), fieldValue.getClass().getName());
          }
        }
      }

    } catch (Exception ex) {
      ex.printStackTrace(System.err);
    }
  }
Пример #24
0
  void readConfig() {
    File config = new File(new File(rootdir), "imprempta.groovy");
    if (config.exists()) {
      Binding binding = new Binding();
      binding.setVariable("binder", this);
      binding.setVariable("ext", ext);

      CompilerConfiguration conf = new CompilerConfiguration();
      conf.setVerbose(true);
      GroovyShell shell = new GroovyShell(binding, conf);

      try {
        String s = new Scanner(new FileInputStream(config)).useDelimiter("\\Z").next();
        s =
            "import net.anzix.imprempta.api.*;\n"
                + "import net.anzix.imprempta.impl.*;\n"
                + "import static net.anzix.imprempta.api.Phase.*;\n\n"
                + s;
        shell.evaluate(s);
      } catch (IOException e) {
        throw new GeneratorException("Can't execute config file", e);
      }
    }
  }
Пример #25
0
  /**
   * Decides if the given source is newer than a class.
   *
   * @param source the source we may want to compile
   * @param cls the former class
   * @return true if the source is newer, false else
   * @throws IOException if it is not possible to open an connection for the given source
   * @see #getTimeStamp(Class)
   */
  protected boolean isSourceNewer(URL source, Class cls) throws IOException {
    long lastMod;

    // Special handling for file:// protocol, as getLastModified() often reports
    // incorrect results (-1)
    if (isFile(source)) {
      // Coerce the file URL to a File
      // See ClassNodeResolver.isSourceNewer for another method that replaces '|' with ':'.
      // WTF: Why is this done and where is it documented?
      String path = source.getPath().replace('/', File.separatorChar).replace('|', ':');
      File file = new File(path);
      lastMod = file.lastModified();
    } else {
      URLConnection conn = source.openConnection();
      lastMod = conn.getLastModified();
      conn.getInputStream().close();
    }
    long classTime = getTimeStamp(cls);
    return classTime + config.getMinimumRecompilationInterval() < lastMod;
  }
Пример #26
0
 /**
  * (Re)Compiles the given source. This method starts the compilation of a given source, if the
  * source has changed since the class was created. For this isSourceNewer is called.
  *
  * @param source the source pointer for the compilation
  * @param className the name of the class to be generated
  * @param oldClass a possible former class
  * @return the old class if the source wasn't new enough, the new class else
  * @throws CompilationFailedException if the compilation failed
  * @throws IOException if the source is not readable
  * @see #isSourceNewer(URL, Class)
  */
 protected Class recompile(URL source, String className, Class oldClass)
     throws CompilationFailedException, IOException {
   if (source != null) {
     // found a source, compile it if newer
     if ((oldClass != null && isSourceNewer(source, oldClass)) || (oldClass == null)) {
       synchronized (sourceCache) {
         String name = source.toExternalForm();
         sourceCache.remove(name);
         if (isFile(source)) {
           try {
             return parseClass(
                 new GroovyCodeSource(new File(source.toURI()), config.getSourceEncoding()));
           } catch (URISyntaxException e) {
             // do nothing and fall back to the other version
           }
         }
         return parseClass(source.openStream(), name);
       }
     }
   }
   return oldClass;
 }
Пример #27
0
 protected CompilationUnit makeCompileUnit() {
   Map<String, Object> options = configuration.getJointCompilationOptions();
   if (options != null) {
     if (keepStubs) {
       options.put("keepStubs", Boolean.TRUE);
     }
     if (stubDir != null) {
       options.put("stubDir", stubDir);
     } else {
       try {
         File tempStubDir = FileSystemCompiler.createTempDir();
         temporaryFiles.add(tempStubDir);
         options.put("stubDir", tempStubDir);
       } catch (IOException ioe) {
         throw new BuildException(ioe);
       }
     }
     return new JavaAwareCompilationUnit(configuration, buildClassLoaderFor());
   } else {
     return new CompilationUnit(configuration, null, buildClassLoaderFor());
   }
 }
 public static CompilerConfiguration getCompilerConfiguration() {
   final CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
   compilerConfiguration.setScriptBaseClass(ConsoleScript.class.getName());
   return compilerConfiguration;
 }
 private CompilerConfiguration createBaseCompilerConfiguration(
     Class<? extends Script> scriptBaseClass) {
   CompilerConfiguration configuration = new CompilerConfiguration();
   configuration.setScriptBaseClass(scriptBaseClass.getName());
   return configuration;
 }
Пример #30
0
 /**
  * Parses the given file into a Java class capable of being run
  *
  * @param file the file name to parse
  * @return the main class defined in the given script
  */
 public Class parseClass(File file) throws CompilationFailedException, IOException {
   return parseClass(new GroovyCodeSource(file, config.getSourceEncoding()));
 }