Examples with CommandlineJava org.apache.tools.ant.types.CommandlineJava used on opensource projects

Example 6 with CommandlineJava

use of org.apache.tools.ant.types.CommandlineJava in project ant by apache.

the class JUnitTask method getCommandline.

/**
 * Get the command line used to run the tests.
 * @return the command line.
 * @since Ant 1.6.2
 */
protected CommandlineJava getCommandline() {
    if (commandline == null) {
        commandline = new CommandlineJava();
        commandline.setClassname("org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner");
    }
    return commandline;
}

Example 7 with CommandlineJava

use of org.apache.tools.ant.types.CommandlineJava in project ant by apache.

the class JasperC method setupJasperCommand.

/**
 * build up a command line
 * @return a command line for jasper
 */
private CommandlineJava setupJasperCommand() {
    CommandlineJava cmd = new CommandlineJava();
    JspC jspc = getJspc();
    addArg(cmd, "-d", jspc.getDestdir());
    addArg(cmd, "-p", jspc.getPackage());
    if (!isTomcat5x()) {
        addArg(cmd, "-v" + jspc.getVerbose());
    } else {
        getProject().log("this task doesn't support Tomcat 5.x properly, " + "please use the Tomcat provided jspc task " + "instead");
    }
    addArg(cmd, "-uriroot", jspc.getUriroot());
    addArg(cmd, "-uribase", jspc.getUribase());
    addArg(cmd, "-ieplugin", jspc.getIeplugin());
    addArg(cmd, "-webinc", jspc.getWebinc());
    addArg(cmd, "-webxml", jspc.getWebxml());
    addArg(cmd, "-die9");
    if (jspc.isMapped()) {
        addArg(cmd, "-mapped");
    }
    if (jspc.getWebApp() != null) {
        File dir = jspc.getWebApp().getDirectory();
        addArg(cmd, "-webapp", dir);
    }
    logAndAddFilesToCompile(getJspc(), getJspc().getCompileList(), cmd);
    return cmd;
}

Example 8 with CommandlineJava

use of org.apache.tools.ant.types.CommandlineJava in project randomizedtesting by randomizedtesting.

the class JUnit4 method executeSlave.

/**
 * Attach listeners and execute a slave process.
 */
private void executeSlave(final ForkedJvmInfo slave, final EventBus aggregatedBus) throws Exception {
    final String uniqueSeed = new SimpleDateFormat("yyyyMMdd_HHmmss_SSS", Locale.ROOT).format(new Date());
    final Path classNamesFile = tempFile(uniqueSeed, "junit4-J" + slave.id, ".suites", getTempDir());
    temporaryFiles.add(classNamesFile);
    final Path classNamesDynamic = tempFile(uniqueSeed, "junit4-J" + slave.id, ".dynamic-suites", getTempDir());
    final Path streamsBufferFile = tempFile(uniqueSeed, "junit4-J" + slave.id, ".spill", getTempDir());
    // Dump all test class names to a temporary file.
    String testClassPerLine = Joiner.on("\n").join(slave.testSuites);
    log("Test class names:\n" + testClassPerLine, Project.MSG_VERBOSE);
    Files.write(classNamesFile, testClassPerLine.getBytes(StandardCharsets.UTF_8));
    // Prepare command line for java execution.
    CommandlineJava commandline;
    commandline = (CommandlineJava) getCommandline().clone();
    commandline.createClasspath(getProject()).add(addSlaveClasspath());
    commandline.setClassname(SlaveMainSafe.class.getName());
    if (slave.slaves == 1) {
        commandline.createArgument().setValue(SlaveMain.OPTION_FREQUENT_FLUSH);
    }
    // Set up full output files.
    Path sysoutFile = tempFile(uniqueSeed, "junit4-J" + slave.id, ".sysout", getTempDir());
    Path syserrFile = tempFile(uniqueSeed, "junit4-J" + slave.id, ".syserr", getTempDir());
    // Set up communication channel.
    Path eventFile = tempFile(uniqueSeed, "junit4-J" + slave.id, ".events", getTempDir());
    temporaryFiles.add(eventFile);
    commandline.createArgument().setValue(SlaveMain.OPTION_EVENTSFILE);
    commandline.createArgument().setFile(eventFile.toFile());
    if (sysouts) {
        commandline.createArgument().setValue(SlaveMain.OPTION_SYSOUTS);
    }
    if (debugStream) {
        commandline.createArgument().setValue(SlaveMain.OPTION_DEBUGSTREAM);
    }
    TailInputStream eventStream = new TailInputStream(eventFile);
    // Process user-defined RunListener classes.
    if (!runListeners.isEmpty()) {
        String classNames = runListeners.stream().map(x -> x.getClassName()).collect(Collectors.joining(","));
        commandline.createArgument().setValue(SlaveMain.OPTION_RUN_LISTENERS);
        commandline.createArgument().setValue(classNames);
    }
    // Set up input suites file.
    commandline.createArgument().setValue("@" + classNamesFile.toAbsolutePath().normalize());
    // not using it.
    if (dynamicAssignmentRatio > 0) {
        commandline.createArgument().setValue(SlaveMain.OPTION_STDIN);
    }
    final EventBus eventBus = new EventBus("slave-" + slave.id);
    final DiagnosticsListener diagnosticsListener = new DiagnosticsListener(slave, this);
    eventBus.register(diagnosticsListener);
    eventBus.register(new AggregatingListener(aggregatedBus, slave));
    final AtomicReference<Charset> clientCharset = new AtomicReference<Charset>();
    final AtomicBoolean clientWithLimitedCharset = new AtomicBoolean();
    final PrintWriter w = new PrintWriter(Files.newBufferedWriter(classNamesDynamic, StandardCharsets.UTF_8));
    eventBus.register(new Object() {

        @Subscribe
        public void onIdleSlave(final SlaveIdle idleSlave) {
            aggregatedBus.post(new SlaveIdle() {

                @Override
                public void finished() {
                    idleSlave.finished();
                }

                @Override
                public void newSuite(String suiteName) {
                    if (!clientCharset.get().newEncoder().canEncode(suiteName)) {
                        clientWithLimitedCharset.set(true);
                        log("Forked JVM J" + slave.id + " skipped suite (cannot encode suite name in charset " + clientCharset.get() + "): " + suiteName, Project.MSG_WARN);
                        return;
                    }
                    log("Forked JVM J" + slave.id + " stole suite: " + suiteName, Project.MSG_VERBOSE);
                    w.println(suiteName);
                    w.flush();
                    idleSlave.newSuite(suiteName);
                }
            });
        }

        @Subscribe
        public void onBootstrap(final BootstrapEvent e) {
            Charset cs = Charset.forName(((BootstrapEvent) e).getDefaultCharsetName());
            clientCharset.set(cs);
            slave.start = System.currentTimeMillis();
            slave.setBootstrapEvent(e);
            aggregatedBus.post(new ChildBootstrap(slave));
        }

        @Subscribe
        public void receiveQuit(QuitEvent e) {
            slave.end = System.currentTimeMillis();
        }
    });
    Closer closer = Closer.create();
    closer.register(eventStream);
    closer.register(w);
    try {
        OutputStream sysout = closer.register(new BufferedOutputStream(Files.newOutputStream(sysoutFile)));
        OutputStream syserr = closer.register(new BufferedOutputStream(Files.newOutputStream(syserrFile)));
        RandomAccessFile streamsBuffer = closer.register(new RandomAccessFile(streamsBufferFile.toFile(), "rw"));
        Execute execute = forkProcess(slave, eventBus, commandline, eventStream, sysout, syserr, streamsBuffer);
        log("Forked JVM J" + slave.id + " finished with exit code: " + execute.getExitValue(), Project.MSG_DEBUG);
        if (execute.isFailure()) {
            final int exitStatus = execute.getExitValue();
            switch(exitStatus) {
                case SlaveMain.ERR_NO_JUNIT:
                    throw new BuildException("Forked JVM's classpath must include a junit4 JAR.");
                case SlaveMain.ERR_OLD_JUNIT:
                    throw new BuildException("Forked JVM's classpath must use JUnit 4.10 or newer.");
                default:
                    Closeables.close(sysout, false);
                    Closeables.close(syserr, false);
                    StringBuilder message = new StringBuilder();
                    if (exitStatus == SlaveMain.ERR_OOM) {
                        message.append("Forked JVM ran out of memory.");
                    } else {
                        message.append("Forked process returned with error code: ").append(exitStatus).append(".");
                    }
                    if (Files.size(sysoutFile) > 0 || Files.size(syserrFile) > 0) {
                        if (exitStatus != SlaveMain.ERR_OOM) {
                            message.append(" Very likely a JVM crash. ");
                        }
                        if (jvmOutputAction.contains(JvmOutputAction.PIPE)) {
                            message.append(" Process output piped in logs above.");
                        } else if (!jvmOutputAction.contains(JvmOutputAction.IGNORE)) {
                            if (Files.size(sysoutFile) > 0) {
                                message.append(" See process stdout at: " + sysoutFile.toAbsolutePath());
                            }
                            if (Files.size(syserrFile) > 0) {
                                message.append(" See process stderr at: " + syserrFile.toAbsolutePath());
                            }
                        }
                    }
                    throw new BuildException(message.toString());
            }
        }
    } catch (Throwable t) {
        throw closer.rethrow(t);
    } finally {
        try {
            closer.close();
        } finally {
            com.google.common.io.Files.asByteSource(classNamesDynamic.toFile()).copyTo(com.google.common.io.Files.asByteSink(classNamesFile.toFile(), FileWriteMode.APPEND));
            Files.delete(classNamesDynamic);
            Files.delete(streamsBufferFile);
            // Check sysout/syserr lengths.
            checkJvmOutput(aggregatedBus, sysoutFile, slave, "stdout");
            checkJvmOutput(aggregatedBus, syserrFile, slave, "stderr");
        }
    }
    if (!diagnosticsListener.quitReceived()) {
        throw new BuildException("Quit event not received from the forked process? This may indicate JVM crash or runner bugs.");
    }
    if (clientWithLimitedCharset.get() && dynamicAssignmentRatio > 0) {
        throw new BuildException("Forked JVM J" + slave.id + " was not be able to decode class names when using" + " charset: " + clientCharset + ". Do not use " + "dynamic suite balancing to work around this problem (-DdynamicAssignmentRatio=0).");
    }
}

Example 9 with CommandlineJava

use of org.apache.tools.ant.types.CommandlineJava in project randomizedtesting by randomizedtesting.

the class JUnit4 method forkProcess.

/**
 * Execute a slave process. Pump events to the given event bus.
 */
@SuppressForbidden("legitimate sysstreams.")
private Execute forkProcess(ForkedJvmInfo slaveInfo, EventBus eventBus, CommandlineJava commandline, TailInputStream eventStream, OutputStream sysout, OutputStream syserr, RandomAccessFile streamsBuffer) {
    try {
        String tempDir = commandline.getSystemProperties().getVariablesVector().stream().filter(v -> v.getKey().equals("java.io.tmpdir")).map(v -> v.getValue()).findAny().orElse(null);
        final LocalSlaveStreamHandler streamHandler = new LocalSlaveStreamHandler(eventBus, testsClassLoader, System.err, eventStream, sysout, syserr, heartbeat, streamsBuffer);
        // Add certain properties to allow identification of the forked JVM from within
        // the subprocess. This can be used for policy files etc.
        final Path cwd = getWorkingDirectory(slaveInfo, tempDir);
        Variable v = new Variable();
        v.setKey(CHILDVM_SYSPROP_CWD);
        v.setFile(cwd.toAbsolutePath().normalize().toFile());
        commandline.addSysproperty(v);
        v = new Variable();
        v.setKey(SYSPROP_TEMPDIR);
        v.setFile(getTempDir().toAbsolutePath().normalize().toFile());
        commandline.addSysproperty(v);
        v = new Variable();
        v.setKey(SysGlobals.CHILDVM_SYSPROP_JVM_ID);
        v.setValue(Integer.toString(slaveInfo.id));
        commandline.addSysproperty(v);
        v = new Variable();
        v.setKey(SysGlobals.CHILDVM_SYSPROP_JVM_COUNT);
        v.setValue(Integer.toString(slaveInfo.slaves));
        commandline.addSysproperty(v);
        // Emit command line before -stdin to avoid confusion.
        slaveInfo.slaveCommandLine = escapeAndJoin(commandline.getCommandline());
        log("Forked child JVM at '" + cwd.toAbsolutePath().normalize() + "', command (may need escape sequences for your shell):\n" + slaveInfo.slaveCommandLine, Project.MSG_VERBOSE);
        final Execute execute = new Execute();
        execute.setCommandline(commandline.getCommandline());
        execute.setVMLauncher(true);
        execute.setWorkingDirectory(cwd.toFile());
        execute.setStreamHandler(streamHandler);
        execute.setNewenvironment(newEnvironment);
        if (env.getVariables() != null)
            execute.setEnvironment(env.getVariables());
        log("Starting JVM J" + slaveInfo.id, Project.MSG_DEBUG);
        execute.execute();
        return execute;
    } catch (IOException e) {
        throw new BuildException("Could not start the child process. Run ant with -verbose to get" + " the execution details.", e);
    }
}