org.gradle.process.JavaExecSpec Java Examples

public void evaluate(String url, Writer writer) {
    RhinoWorkerHandle<String, EnvJsEvaluateSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final String result = handle.process(new EnvJsEvaluateSpec(envJsFactory.create(), url));

    try {
        IOUtils.copy(new StringReader(result), writer);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

@Override
public void execute(JavaExecSpec executor) {
    executor.classpath(classpath);
    executor.setMain("org.javacc.jjtree.Main");
    executor.args((Object[]) arguments.toArray());
    executor.setIgnoreExitValue(true);
}
 

public void evaluate(String url, Writer writer) {
    RhinoWorkerHandle<String, EnvJsEvaluateSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final String result = handle.process(new EnvJsEvaluateSpec(envJsFactory.create(), url));

    try {
        IOUtils.copy(new StringReader(result), writer);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

public WorkResult compile(CoffeeScriptCompileSpec spec) {
    RhinoWorkerHandle<Boolean, SerializableCoffeeScriptCompileSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final Boolean result = handle.process(new SerializableCoffeeScriptCompileSpec(spec));

    return new WorkResult() {
        public boolean getDidWork() {
            return result;
        }
    };
}
 

@Before
public void setUp() throws Exception {
    javaExecSpec = mock(JavaExecSpec.class);
    providedClasspath = mock(Configuration.class);
    providedArguments = new ProgramArguments();
    action = new JjdocExecutorAction(providedClasspath, providedArguments);
}
 

public void prepareJavaCommand(JavaExecSpec execSpec) {
    execSpec.setMain("jarjar." + GradleWorkerMain.class.getName());
    execSpec.classpath(classPathRegistry.getClassPath("WORKER_MAIN").getAsFiles());
    Object requestedSecurityManager = execSpec.getSystemProperties().get("java.security.manager");
    if (requestedSecurityManager != null) {
        execSpec.systemProperty("org.gradle.security.manager", requestedSecurityManager);
    }
    execSpec.systemProperty("java.security.manager", "jarjar." + BootstrapSecurityManager.class.getName());
    try {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        DataOutputStream outstr = new DataOutputStream(new EncodedStream.EncodedOutput(bytes));
        LOGGER.debug("Writing an application classpath to child process' standard input.");
        outstr.writeInt(processBuilder.getApplicationClasspath().size());
        for (File file : processBuilder.getApplicationClasspath()) {
            outstr.writeUTF(file.getAbsolutePath());
        }
        outstr.close();
        final InputStream originalStdin = execSpec.getStandardInput();
        InputStream input = ByteStreams.join(ByteStreams.newInputStreamSupplier(bytes.toByteArray()), new InputSupplier<InputStream>() {
            public InputStream getInput() throws IOException {
                return originalStdin;
            }
        }).getInput();
        execSpec.setStandardInput(input);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

@Before
public void setUp() throws Exception {
    javaExecSpec = mock(JavaExecSpec.class);
    providedClasspath = mock(Configuration.class);
    providedArguments = new ProgramArguments();
    action = new JavaccExecutorAction(providedClasspath, providedArguments);
}
 

@Override
public void execute(JavaExecSpec executor) {
    executor.classpath(classpath);
    executor.setMain("org.javacc.jjdoc.JJDocMain");
    executor.args((Object[]) arguments.toArray());
    executor.setIgnoreExitValue(true);
}
 

@Override
public void execute(JavaExecSpec executor) {
    executor.classpath(classpath);
    executor.setMain("org.javacc.parser.Main");
    executor.args((Object[]) arguments.toArray());
    executor.setIgnoreExitValue(true);
}
 

@Before
public void setUp() throws Exception {
    javaExecSpec = mock(JavaExecSpec.class);
    providedClasspath = mock(Configuration.class);
    providedArguments = new ProgramArguments();
    action = new JjtreeExecutorAction(providedClasspath, providedArguments);
}
 

public WorkResult compile(CoffeeScriptCompileSpec spec) {
    RhinoWorkerHandle<Boolean, SerializableCoffeeScriptCompileSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final Boolean result = handle.process(new SerializableCoffeeScriptCompileSpec(spec));

    return new WorkResult() {
        public boolean getDidWork() {
            return result;
        }
    };
}
 

public void prepareJavaCommand(JavaExecSpec execSpec) {
    execSpec.setMain("jarjar." + GradleWorkerMain.class.getName());
    execSpec.classpath(classPathRegistry.getClassPath("WORKER_MAIN").getAsFiles());
    Object requestedSecurityManager = execSpec.getSystemProperties().get("java.security.manager");
    if (requestedSecurityManager != null) {
        execSpec.systemProperty("org.gradle.security.manager", requestedSecurityManager);
    }
    execSpec.systemProperty("java.security.manager", "jarjar." + BootstrapSecurityManager.class.getName());
    try {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        DataOutputStream outstr = new DataOutputStream(new EncodedStream.EncodedOutput(bytes));
        LOGGER.debug("Writing an application classpath to child process' standard input.");
        outstr.writeInt(processBuilder.getApplicationClasspath().size());
        for (File file : processBuilder.getApplicationClasspath()) {
            outstr.writeUTF(file.getAbsolutePath());
        }
        outstr.close();
        final InputStream originalStdin = execSpec.getStandardInput();
        InputStream input = ByteStreams.join(ByteStreams.newInputStreamSupplier(bytes.toByteArray()), new InputSupplier<InputStream>() {
            public InputStream getInput() throws IOException {
                return originalStdin;
            }
        }).getInput();
        execSpec.setStandardInput(input);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

public <R extends Serializable, P extends Serializable> RhinoWorkerHandle<R, P> create(Iterable<File> rhinoClasspath, RhinoWorkerSpec<R, P> workerSpec, LogLevel logLevel, Action<JavaExecSpec> javaExecSpecAction) {
    WorkerProcessBuilder builder = workerProcessBuilderFactory.create();
    builder.setBaseName("Gradle Rhino Worker");
    builder.setLogLevel(logLevel);
    builder.applicationClasspath(rhinoClasspath);
    builder.sharedPackages("org.mozilla.javascript");

    JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
    if (javaExecSpecAction != null) {
        javaExecSpecAction.execute(javaCommand);
    }

    WorkerProcess workerProcess = builder.worker(new RhinoServer<R, P>(workerSpec)).build();
    return new DefaultRhinoWorkerHandle<R, P>(workerSpec.getResultType(), workerProcess);
}
 

public <R extends Serializable, P extends Serializable> RhinoWorkerHandle<R, P> create(Iterable<File> rhinoClasspath, RhinoWorkerSpec<R, P> workerSpec, LogLevel logLevel, Action<JavaExecSpec> javaExecSpecAction) {
    WorkerProcessBuilder builder = workerProcessBuilderFactory.create();
    builder.setBaseName("Gradle Rhino Worker");
    builder.setLogLevel(logLevel);
    builder.applicationClasspath(rhinoClasspath);
    builder.sharedPackages("org.mozilla.javascript");

    JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
    if (javaExecSpecAction != null) {
        javaExecSpecAction.execute(javaCommand);
    }

    WorkerProcess workerProcess = builder.worker(new RhinoServer<R, P>(workerSpec)).build();
    return new DefaultRhinoWorkerHandle<R, P>(workerSpec.getResultType(), workerProcess);
}
 

public void evaluate(String url, Writer writer) {
    RhinoWorkerHandle<String, EnvJsEvaluateSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final String result = handle.process(new EnvJsEvaluateSpec(envJsFactory.create(), url));

    try {
        IOUtils.copy(new StringReader(result), writer);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

public WorkResult compile(CoffeeScriptCompileSpec spec) {
    RhinoWorkerHandle<Boolean, SerializableCoffeeScriptCompileSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final Boolean result = handle.process(new SerializableCoffeeScriptCompileSpec(spec));

    return new WorkResult() {
        public boolean getDidWork() {
            return result;
        }
    };
}
 

public void prepareJavaCommand(JavaExecSpec execSpec) {
    execSpec.setMain("jarjar." + GradleWorkerMain.class.getName());
    execSpec.classpath(classPathRegistry.getClassPath("WORKER_MAIN").getAsFiles());
    Object requestedSecurityManager = execSpec.getSystemProperties().get("java.security.manager");
    if (requestedSecurityManager != null) {
        execSpec.systemProperty("org.gradle.security.manager", requestedSecurityManager);
    }
    execSpec.systemProperty("java.security.manager", "jarjar." + BootstrapSecurityManager.class.getName());
    try {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        DataOutputStream outstr = new DataOutputStream(new EncodedStream.EncodedOutput(bytes));
        LOGGER.debug("Writing an application classpath to child process' standard input.");
        outstr.writeInt(processBuilder.getApplicationClasspath().size());
        for (File file : processBuilder.getApplicationClasspath()) {
            outstr.writeUTF(file.getAbsolutePath());
        }
        outstr.close();
        final InputStream originalStdin = execSpec.getStandardInput();
        InputStream input = ByteStreams.join(ByteStreams.newInputStreamSupplier(bytes.toByteArray()), new InputSupplier<InputStream>() {
            public InputStream getInput() throws IOException {
                return originalStdin;
            }
        }).getInput();
        execSpec.setStandardInput(input);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

public void prepareJavaCommand(JavaExecSpec execSpec) {
    execSpec.setMain("jarjar." + GradleWorkerMain.class.getName());
    execSpec.classpath(classPathRegistry.getClassPath("WORKER_MAIN").getAsFiles());
    Object requestedSecurityManager = execSpec.getSystemProperties().get("java.security.manager");
    if (requestedSecurityManager != null) {
        execSpec.systemProperty("org.gradle.security.manager", requestedSecurityManager);
    }
    execSpec.systemProperty("java.security.manager", "jarjar." + BootstrapSecurityManager.class.getName());
    try {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        DataOutputStream outstr = new DataOutputStream(new EncodedStream.EncodedOutput(bytes));
        LOGGER.debug("Writing an application classpath to child process' standard input.");
        outstr.writeInt(processBuilder.getApplicationClasspath().size());
        for (File file : processBuilder.getApplicationClasspath()) {
            outstr.writeUTF(file.getAbsolutePath());
        }
        outstr.close();
        final InputStream originalStdin = execSpec.getStandardInput();
        InputStream input = ByteStreams.join(ByteStreams.newInputStreamSupplier(bytes.toByteArray()), new InputSupplier<InputStream>() {
            public InputStream getInput() throws IOException {
                return originalStdin;
            }
        }).getInput();
        execSpec.setStandardInput(input);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

@Override
public void execute(JavaExecSpec javaExecSpec) {
    javaExecSpec.classpath(new File(javaProcessInfo.getClasspath()));
    javaExecSpec.setMain(javaProcessInfo.getMainClass());
    javaExecSpec.args(javaProcessInfo.getArgs());
    javaExecSpec.jvmArgs(javaProcessInfo.getJvmArgs());
    javaExecSpec.environment(javaProcessInfo.getEnvironment());
    javaExecSpec.setStandardOutput(processOutput.getStandardOutput());
    javaExecSpec.setErrorOutput(processOutput.getErrorOutput());

    // we want the caller to be able to do its own thing.
    javaExecSpec.setIgnoreExitValue(true);
}
 

public <R extends Serializable, P extends Serializable> RhinoWorkerHandle<R, P> create(Iterable<File> rhinoClasspath, RhinoWorkerSpec<R, P> workerSpec, LogLevel logLevel, Action<JavaExecSpec> javaExecSpecAction) {
    WorkerProcessBuilder builder = workerProcessBuilderFactory.create();
    builder.setBaseName("Gradle Rhino Worker");
    builder.setLogLevel(logLevel);
    builder.applicationClasspath(rhinoClasspath);
    builder.sharedPackages("org.mozilla.javascript");

    JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
    if (javaExecSpecAction != null) {
        javaExecSpecAction.execute(javaCommand);
    }

    WorkerProcess workerProcess = builder.worker(new RhinoServer<R, P>(workerSpec)).build();
    return new DefaultRhinoWorkerHandle<R, P>(workerSpec.getResultType(), workerProcess);
}
 

public <R extends Serializable, P extends Serializable> RhinoWorkerHandle<R, P> create(Iterable<File> rhinoClasspath, RhinoWorkerSpec<R, P> workerSpec, LogLevel logLevel, Action<JavaExecSpec> javaExecSpecAction) {
    WorkerProcessBuilder builder = workerProcessBuilderFactory.create();
    builder.setBaseName("Gradle Rhino Worker");
    builder.setLogLevel(logLevel);
    builder.applicationClasspath(rhinoClasspath);
    builder.sharedPackages("org.mozilla.javascript");

    JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
    if (javaExecSpecAction != null) {
        javaExecSpecAction.execute(javaCommand);
    }

    WorkerProcess workerProcess = builder.worker(new RhinoServer<R, P>(workerSpec)).build();
    return new DefaultRhinoWorkerHandle<R, P>(workerSpec.getResultType(), workerProcess);
}
 

public void evaluate(String url, Writer writer) {
    RhinoWorkerHandle<String, EnvJsEvaluateSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final String result = handle.process(new EnvJsEvaluateSpec(envJsFactory.create(), url));

    try {
        IOUtils.copy(new StringReader(result), writer);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

public WorkResult compile(CoffeeScriptCompileSpec spec) {
    RhinoWorkerHandle<Boolean, SerializableCoffeeScriptCompileSpec> handle = rhinoWorkerHandleFactory.create(rhinoClasspath, createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(workingDir);
        }
    });

    final Boolean result = handle.process(new SerializableCoffeeScriptCompileSpec(spec));

    return new WorkResult() {
        public boolean getDidWork() {
            return result;
        }
    };
}
 

public void prepareJavaCommand(JavaExecSpec execSpec) {
    execSpec.setMain(GradleWorkerMain.class.getName());
    execSpec.classpath(classPathRegistry.getClassPath("WORKER_PROCESS").getAsFiles());
}
 

@Override
public JavaExecSpec setIgnoreExitValue(boolean ignoreExitValue) {
    super.setIgnoreExitValue(ignoreExitValue);
    return this;
}
 

public ExecResult javaexec(Action<? super JavaExecSpec> action) {
    JavaExecAction javaExecAction = instantiator.newInstance(DefaultJavaExecAction.class, fileResolver);
    action.execute(javaExecAction);
    return javaExecAction.execute();
}
 

public ExecResult javaexec(Action<? super JavaExecSpec> action) {
    return getProcessOperations().javaexec(action);
}
 

@TaskAction
public void doJsHint() {
    RhinoWorkerHandleFactory handleFactory = new DefaultRhinoWorkerHandleFactory(getWorkerProcessBuilderFactory());

    LogLevel logLevel = getProject().getGradle().getStartParameter().getLogLevel();
    RhinoWorkerHandle<JsHintResult, JsHintSpec> rhinoHandle = handleFactory.create(getRhinoClasspath(), createWorkerSpec(), logLevel, new Action<JavaExecSpec>() {
        public void execute(JavaExecSpec javaExecSpec) {
            javaExecSpec.setWorkingDir(getProject().getProjectDir());
        }
    });

    JsHintSpec spec = new JsHintSpec();
    spec.setSource(getSource().getFiles()); // flatten because we need to serialize
    spec.setEncoding(getEncoding());
    spec.setJsHint(getJsHint().getSingleFile());

    JsHintResult result = rhinoHandle.process(spec);
    setDidWork(true);

    // TODO - this is all terribly lame. We need some proper reporting here (which means implementing Reporting).

    Logger logger = getLogger();
    boolean anyErrors = false;

    Map<String, Map<?, ?>> reportData = new LinkedHashMap<String, Map<?, ?>>(result.getResults().size());
    for (Map.Entry<File, Map<String, Object>> fileEntry: result.getResults().entrySet()) {
        File file = fileEntry.getKey();
        Map<String, Object> data = fileEntry.getValue();

        reportData.put(file.getAbsolutePath(), data);

        if (data.containsKey("errors")) {
            anyErrors = true;

            URI projectDirUri = getProject().getProjectDir().toURI();
            @SuppressWarnings("unchecked") Map<String, Object> errors = (Map<String, Object>) data.get("errors");
            if (!errors.isEmpty()) {
                URI relativePath = projectDirUri.relativize(file.toURI());
                logger.warn("JsHint errors for file: {}", relativePath.getPath());
                for (Map.Entry<String, Object> errorEntry : errors.entrySet()) {
                    @SuppressWarnings("unchecked") Map<String, Object> error = (Map<String, Object>) errorEntry.getValue();
                    int line = Float.valueOf(error.get("line").toString()).intValue();
                    int character = Float.valueOf(error.get("character").toString()).intValue();
                    String reason = error.get("reason").toString();

                    logger.warn("  {}:{} > {}", new Object[] {line, character, reason});
                }
            }
        }
    }

    File jsonReportFile = getJsonReport();
    if (jsonReportFile != null) {
        try {
            FileWriter reportWriter = new FileWriter(jsonReportFile);
            new GsonBuilder().setPrettyPrinting().create().toJson(reportData, reportWriter);
            reportWriter.close();
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    if (anyErrors) {
        throw new TaskExecutionException(this, new GradleException("JsHint detected errors"));
    }
}
 

/**
 * {@inheritDoc}
 */
public JavaExecSpec setIgnoreExitValue(boolean ignoreExitValue) {
    javaExecHandleBuilder.setIgnoreExitValue(ignoreExitValue);
    return this;
}
 

public ExecResult javaexec(Closure closure) {
    return javaexec(new ClosureBackedAction<JavaExecSpec>(closure));
}