Examples with Writer java.io.Writer used on opensource projects

Example 1 with Writer

use of java.io.Writer in project buck by facebook.

the class TestRunning method runTests.

@SuppressWarnings("PMD.EmptyCatchBlock")
public static int runTests(final CommandRunnerParams params, Iterable<TestRule> tests, ExecutionContext executionContext, final TestRunningOptions options, ListeningExecutorService service, BuildEngine buildEngine, final StepRunner stepRunner, SourcePathResolver sourcePathResolver, SourcePathRuleFinder ruleFinder) throws IOException, ExecutionException, InterruptedException {
    ImmutableSet<JavaLibrary> rulesUnderTestForCoverage;
    // If needed, we first run instrumentation on the class files.
    if (options.isCodeCoverageEnabled()) {
        rulesUnderTestForCoverage = getRulesUnderTest(tests);
        if (!rulesUnderTestForCoverage.isEmpty()) {
            try {
                // We'll use the filesystem of the first rule under test. This will fail if there are any
                // tests from a different repo, but it'll help us bootstrap ourselves to being able to
                // support multiple repos
                // TODO(t8220837): Support tests in multiple repos
                JavaLibrary library = rulesUnderTestForCoverage.iterator().next();
                stepRunner.runStepForBuildTarget(executionContext, new MakeCleanDirectoryStep(library.getProjectFilesystem(), JacocoConstants.getJacocoOutputDir(library.getProjectFilesystem())), Optional.empty());
            } catch (StepFailedException e) {
                params.getBuckEventBus().post(ConsoleEvent.severe(Throwables.getRootCause(e).getLocalizedMessage()));
                return 1;
            }
        }
    } else {
        rulesUnderTestForCoverage = ImmutableSet.of();
    }
    final ImmutableSet<String> testTargets = FluentIterable.from(tests).transform(BuildRule::getBuildTarget).transform(Object::toString).toSet();
    final int totalNumberOfTests = Iterables.size(tests);
    params.getBuckEventBus().post(TestRunEvent.started(options.isRunAllTests(), options.getTestSelectorList(), options.shouldExplainTestSelectorList(), testTargets));
    // Start running all of the tests. The result of each java_test() rule is represented as a
    // ListenableFuture.
    List<ListenableFuture<TestResults>> results = Lists.newArrayList();
    TestRuleKeyFileHelper testRuleKeyFileHelper = new TestRuleKeyFileHelper(buildEngine);
    final AtomicInteger lastReportedTestSequenceNumber = new AtomicInteger();
    final List<TestRun> separateTestRuns = Lists.newArrayList();
    List<TestRun> parallelTestRuns = Lists.newArrayList();
    for (final TestRule test : tests) {
        // Determine whether the test needs to be executed.
        final Callable<TestResults> resultsInterpreter = getCachingCallable(test.interpretTestResults(executionContext, /*isUsingTestSelectors*/
        !options.getTestSelectorList().isEmpty()));
        boolean isTestRunRequired;
        isTestRunRequired = isTestRunRequiredForTest(test, buildEngine, executionContext, testRuleKeyFileHelper, options.getTestResultCacheMode(), resultsInterpreter, !options.getTestSelectorList().isEmpty(), !options.getEnvironmentOverrides().isEmpty());
        final Map<String, UUID> testUUIDMap = new HashMap<>();
        final AtomicReference<TestStatusMessageEvent.Started> currentTestStatusMessageEvent = new AtomicReference<>();
        TestRule.TestReportingCallback testReportingCallback = new TestRule.TestReportingCallback() {

            @Override
            public void testsDidBegin() {
                LOG.debug("Tests for rule %s began", test.getBuildTarget());
            }

            @Override
            public void statusDidBegin(TestStatusMessage didBeginMessage) {
                LOG.debug("Test status did begin: %s", didBeginMessage);
                TestStatusMessageEvent.Started startedEvent = TestStatusMessageEvent.started(didBeginMessage);
                TestStatusMessageEvent.Started previousEvent = currentTestStatusMessageEvent.getAndSet(startedEvent);
                Preconditions.checkState(previousEvent == null, "Received begin status before end status (%s)", previousEvent);
                params.getBuckEventBus().post(startedEvent);
                String message = didBeginMessage.getMessage();
                if (message.toLowerCase().contains("debugger")) {
                    executionContext.getStdErr().println(executionContext.getAnsi().asWarningText(message));
                }
            }

            @Override
            public void statusDidEnd(TestStatusMessage didEndMessage) {
                LOG.debug("Test status did end: %s", didEndMessage);
                TestStatusMessageEvent.Started previousEvent = currentTestStatusMessageEvent.getAndSet(null);
                Preconditions.checkState(previousEvent != null, "Received end status before begin status (%s)", previousEvent);
                params.getBuckEventBus().post(TestStatusMessageEvent.finished(previousEvent, didEndMessage));
            }

            @Override
            public void testDidBegin(String testCaseName, String testName) {
                LOG.debug("Test rule %s test case %s test name %s began", test.getBuildTarget(), testCaseName, testName);
                UUID testUUID = UUID.randomUUID();
                // UUID is immutable and thread-safe as of Java 7, so it's
                // safe to stash in a map and use later:
                //
                // http://bugs.java.com/view_bug.do?bug_id=6611830
                testUUIDMap.put(testCaseName + ":" + testName, testUUID);
                params.getBuckEventBus().post(TestSummaryEvent.started(testUUID, testCaseName, testName));
            }

            @Override
            public void testDidEnd(TestResultSummary testResultSummary) {
                LOG.debug("Test rule %s test did end: %s", test.getBuildTarget(), testResultSummary);
                UUID testUUID = testUUIDMap.get(testResultSummary.getTestCaseName() + ":" + testResultSummary.getTestName());
                Preconditions.checkNotNull(testUUID);
                params.getBuckEventBus().post(TestSummaryEvent.finished(testUUID, testResultSummary));
            }

            @Override
            public void testsDidEnd(List<TestCaseSummary> testCaseSummaries) {
                LOG.debug("Test rule %s tests did end: %s", test.getBuildTarget(), testCaseSummaries);
            }
        };
        List<Step> steps;
        if (isTestRunRequired) {
            params.getBuckEventBus().post(IndividualTestEvent.started(testTargets));
            ImmutableList.Builder<Step> stepsBuilder = ImmutableList.builder();
            Preconditions.checkState(buildEngine.isRuleBuilt(test.getBuildTarget()));
            List<Step> testSteps = test.runTests(executionContext, options, sourcePathResolver, testReportingCallback);
            if (!testSteps.isEmpty()) {
                stepsBuilder.addAll(testSteps);
                stepsBuilder.add(testRuleKeyFileHelper.createRuleKeyInDirStep(test));
            }
            steps = stepsBuilder.build();
        } else {
            steps = ImmutableList.of();
        }
        TestRun testRun = TestRun.of(test, steps, getStatusTransformingCallable(isTestRunRequired, resultsInterpreter), testReportingCallback);
        // commands because the rule is cached, but its results must still be processed.
        if (test.runTestSeparately()) {
            LOG.debug("Running test %s in serial", test);
            separateTestRuns.add(testRun);
        } else {
            LOG.debug("Running test %s in parallel", test);
            parallelTestRuns.add(testRun);
        }
    }
    for (TestRun testRun : parallelTestRuns) {
        ListenableFuture<TestResults> testResults = runStepsAndYieldResult(stepRunner, executionContext, testRun.getSteps(), testRun.getTestResultsCallable(), testRun.getTest().getBuildTarget(), params.getBuckEventBus(), service);
        results.add(transformTestResults(params, testResults, testRun.getTest(), testRun.getTestReportingCallback(), testTargets, lastReportedTestSequenceNumber, totalNumberOfTests));
    }
    ListenableFuture<List<TestResults>> parallelTestStepsFuture = Futures.allAsList(results);
    final List<TestResults> completedResults = Lists.newArrayList();
    final ListeningExecutorService directExecutorService = MoreExecutors.newDirectExecutorService();
    ListenableFuture<Void> uberFuture = MoreFutures.addListenableCallback(parallelTestStepsFuture, new FutureCallback<List<TestResults>>() {

        @Override
        public void onSuccess(List<TestResults> parallelTestResults) {
            LOG.debug("Parallel tests completed, running separate tests...");
            completedResults.addAll(parallelTestResults);
            List<ListenableFuture<TestResults>> separateResultsList = Lists.newArrayList();
            for (TestRun testRun : separateTestRuns) {
                separateResultsList.add(transformTestResults(params, runStepsAndYieldResult(stepRunner, executionContext, testRun.getSteps(), testRun.getTestResultsCallable(), testRun.getTest().getBuildTarget(), params.getBuckEventBus(), directExecutorService), testRun.getTest(), testRun.getTestReportingCallback(), testTargets, lastReportedTestSequenceNumber, totalNumberOfTests));
            }
            ListenableFuture<List<TestResults>> serialResults = Futures.allAsList(separateResultsList);
            try {
                completedResults.addAll(serialResults.get());
            } catch (ExecutionException e) {
                LOG.error(e, "Error fetching serial test results");
                throw new HumanReadableException(e, "Error fetching serial test results");
            } catch (InterruptedException e) {
                LOG.error(e, "Interrupted fetching serial test results");
                try {
                    serialResults.cancel(true);
                } catch (CancellationException ignored) {
                // Rethrow original InterruptedException instead.
                }
                Thread.currentThread().interrupt();
                throw new HumanReadableException(e, "Test cancelled");
            }
            LOG.debug("Done running serial tests.");
        }

        @Override
        public void onFailure(Throwable e) {
            LOG.error(e, "Parallel tests failed, not running serial tests");
            throw new HumanReadableException(e, "Parallel tests failed");
        }
    }, directExecutorService);
    try {
        // Block until all the tests have finished running.
        uberFuture.get();
    } catch (ExecutionException e) {
        e.printStackTrace(params.getConsole().getStdErr());
        return 1;
    } catch (InterruptedException e) {
        try {
            uberFuture.cancel(true);
        } catch (CancellationException ignored) {
        // Rethrow original InterruptedException instead.
        }
        Thread.currentThread().interrupt();
        throw e;
    }
    params.getBuckEventBus().post(TestRunEvent.finished(testTargets, completedResults));
    // Write out the results as XML, if requested.
    Optional<String> path = options.getPathToXmlTestOutput();
    if (path.isPresent()) {
        try (Writer writer = Files.newWriter(new File(path.get()), Charsets.UTF_8)) {
            writeXmlOutput(completedResults, writer);
        }
    }
    // Generate the code coverage report.
    if (options.isCodeCoverageEnabled() && !rulesUnderTestForCoverage.isEmpty()) {
        try {
            JavaBuckConfig javaBuckConfig = params.getBuckConfig().getView(JavaBuckConfig.class);
            DefaultJavaPackageFinder defaultJavaPackageFinder = javaBuckConfig.createDefaultJavaPackageFinder();
            stepRunner.runStepForBuildTarget(executionContext, getReportCommand(rulesUnderTestForCoverage, defaultJavaPackageFinder, javaBuckConfig.getDefaultJavaOptions().getJavaRuntimeLauncher(), params.getCell().getFilesystem(), sourcePathResolver, ruleFinder, JacocoConstants.getJacocoOutputDir(params.getCell().getFilesystem()), options.getCoverageReportFormat(), options.getCoverageReportTitle(), javaBuckConfig.getDefaultJavacOptions().getSpoolMode() == JavacOptions.SpoolMode.INTERMEDIATE_TO_DISK, options.getCoverageIncludes(), options.getCoverageExcludes()), Optional.empty());
        } catch (StepFailedException e) {
            params.getBuckEventBus().post(ConsoleEvent.severe(Throwables.getRootCause(e).getLocalizedMessage()));
            return 1;
        }
    }
    boolean failures = Iterables.any(completedResults, results1 -> {
        LOG.debug("Checking result %s for failure", results1);
        return !results1.isSuccess();
    });
    return failures ? TEST_FAILURES_EXIT_CODE : 0;
}

Example 2 with Writer

use of java.io.Writer in project jetty.project by eclipse.

the class DumpHandler method doNonErrorHandle.

@Override
protected void doNonErrorHandle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    if (!isStarted())
        return;
    if (Boolean.valueOf(request.getParameter("flush")))
        response.flushBuffer();
    if (Boolean.valueOf(request.getParameter("empty"))) {
        baseRequest.setHandled(true);
        response.setStatus(200);
        return;
    }
    StringBuilder read = null;
    if (request.getParameter("read") != null) {
        read = new StringBuilder();
        int len = Integer.parseInt(request.getParameter("read"));
        Reader in = request.getReader();
        for (int i = len; i-- > 0; ) read.append((char) in.read());
    }
    if (request.getParameter("date") != null)
        response.setHeader("Date", request.getParameter("date"));
    if (request.getParameter("ISE") != null) {
        throw new IllegalStateException("Testing ISE");
    }
    if (request.getParameter("error") != null) {
        response.sendError(Integer.parseInt(request.getParameter("error")));
        return;
    }
    baseRequest.setHandled(true);
    response.setHeader(HttpHeader.CONTENT_TYPE.asString(), MimeTypes.Type.TEXT_HTML.asString());
    OutputStream out = response.getOutputStream();
    ByteArrayOutputStream buf = new ByteArrayOutputStream(2048);
    Writer writer = new OutputStreamWriter(buf, StandardCharsets.ISO_8859_1);
    writer.write("<html><h1>" + label + "</h1>");
    writer.write("<pre>\npathInfo=" + request.getPathInfo() + "\n</pre>\n");
    writer.write("<pre>\ncontentType=" + request.getContentType() + "\n</pre>\n");
    writer.write("<pre>\nencoding=" + request.getCharacterEncoding() + "\n</pre>\n");
    writer.write("<pre>\nservername=" + request.getServerName() + "\n</pre>\n");
    writer.write("<pre>\nlocal=" + request.getLocalAddr() + ":" + request.getLocalPort() + "\n</pre>\n");
    writer.write("<pre>\nremote=" + request.getRemoteAddr() + ":" + request.getRemotePort() + "\n</pre>\n");
    writer.write("<h3>Header:</h3><pre>");
    writer.write(request.getMethod() + " " + request.getRequestURI() + " " + request.getProtocol() + "\n");
    Enumeration<String> headers = request.getHeaderNames();
    while (headers.hasMoreElements()) {
        String name = headers.nextElement();
        writer.write(name);
        writer.write(": ");
        String value = request.getHeader(name);
        writer.write(value == null ? "" : value);
        writer.write("\n");
    }
    writer.write("</pre>\n<h3>Parameters:</h3>\n<pre>");
    Enumeration<String> names = request.getParameterNames();
    while (names.hasMoreElements()) {
        String name = names.nextElement();
        String[] values = request.getParameterValues(name);
        if (values == null || values.length == 0) {
            writer.write(name);
            writer.write("=\n");
        } else if (values.length == 1) {
            writer.write(name);
            writer.write("=");
            writer.write(values[0]);
            writer.write("\n");
        } else {
            for (int i = 0; i < values.length; i++) {
                writer.write(name);
                writer.write("[" + i + "]=");
                writer.write(values[i]);
                writer.write("\n");
            }
        }
    }
    String cookie_name = request.getParameter("CookieName");
    if (cookie_name != null && cookie_name.trim().length() > 0) {
        String cookie_action = request.getParameter("Button");
        try {
            String val = request.getParameter("CookieVal");
            val = val.replaceAll("[ \n\r=<>]", "?");
            Cookie cookie = new Cookie(cookie_name.trim(), val);
            if ("Clear Cookie".equals(cookie_action))
                cookie.setMaxAge(0);
            response.addCookie(cookie);
        } catch (IllegalArgumentException e) {
            writer.write("</pre>\n<h3>BAD Set-Cookie:</h3>\n<pre>");
            writer.write(e.toString());
        }
    }
    writer.write("</pre>\n<h3>Cookies:</h3>\n<pre>");
    Cookie[] cookies = request.getCookies();
    if (cookies != null && cookies.length > 0) {
        for (int c = 0; c < cookies.length; c++) {
            Cookie cookie = cookies[c];
            writer.write(cookie.getName());
            writer.write("=");
            writer.write(cookie.getValue());
            writer.write("\n");
        }
    }
    writer.write("</pre>\n<h3>Attributes:</h3>\n<pre>");
    Enumeration<String> attributes = request.getAttributeNames();
    if (attributes != null && attributes.hasMoreElements()) {
        while (attributes.hasMoreElements()) {
            String attr = attributes.nextElement().toString();
            writer.write(attr);
            writer.write("=");
            writer.write(request.getAttribute(attr).toString());
            writer.write("\n");
        }
    }
    writer.write("</pre>\n<h3>Content:</h3>\n<pre>");
    if (read != null) {
        writer.write(read.toString());
    } else {
        char[] content = new char[4096];
        int len;
        try {
            Reader in = request.getReader();
            while ((len = in.read(content)) >= 0) writer.write(new String(content, 0, len));
        } catch (IOException e) {
            if (LOG.isDebugEnabled())
                LOG.warn(e);
            else
                LOG.warn(e.toString());
            writer.write(e.toString());
        }
    }
    writer.write("</pre>\n");
    writer.write("</html>\n");
    writer.flush();
    // commit now
    if (!Boolean.valueOf(request.getParameter("no-content-length")))
        response.setContentLength(buf.size() + 1000);
    response.addHeader("Before-Flush", response.isCommitted() ? "Committed???" : "Not Committed");
    buf.writeTo(out);
    out.flush();
    response.addHeader("After-Flush", "These headers should not be seen in the response!!!");
    response.addHeader("After-Flush", response.isCommitted() ? "Committed" : "Not Committed?");
    // write remaining content after commit
    try {
        buf.reset();
        writer.flush();
        for (int pad = 998; pad-- > 0; ) writer.write(" ");
        writer.write("\r\n");
        writer.flush();
        buf.writeTo(out);
    } catch (Exception e) {
        LOG.ignore(e);
    }
}

Example 3 with Writer

use of java.io.Writer in project jetty.project by eclipse.

the class TextStreamTest method testMoreThanLargestMessageOneByteAtATime.

@Test
public void testMoreThanLargestMessageOneByteAtATime() throws Exception {
    int size = wsClient.getDefaultMaxBinaryMessageBufferSize() + 16;
    char[] data = randomChars(size);
    URI uri = URI.create("ws://localhost:" + connector.getLocalPort() + PATH);
    ClientTextStreamer client = new ClientTextStreamer();
    Session session = wsClient.connectToServer(client, uri);
    try (Writer output = session.getBasicRemote().getSendWriter()) {
        for (int i = 0; i < size; ++i) output.write(data[i]);
    }
    Assert.assertTrue(client.await(5, TimeUnit.SECONDS));
    Assert.assertArrayEquals(data, client.getEcho());
}

Example 4 with Writer

use of java.io.Writer in project jetty.project by eclipse.

the class PropertyUserStoreTest method initUsersText.

private File initUsersText() throws Exception {
    Path dir = testdir.getPath().toRealPath();
    FS.ensureDirExists(dir.toFile());
    File users = dir.resolve("users.txt").toFile();
    try (Writer writer = new BufferedWriter(new FileWriter(users))) {
        writer.append("tom: tom, roleA\n");
        writer.append("dick: dick, roleB\n");
        writer.append("harry: harry, roleA, roleB\n");
    }
    return users;
}

Example 5 with Writer

use of java.io.Writer in project druid by druid-io.

the class FileSmoosher method close.

@Override
public void close() throws IOException {
    //book keeping checks on created file.
    if (!completedFiles.isEmpty() || !filesInProcess.isEmpty()) {
        for (File file : completedFiles) {
            if (!file.delete()) {
                LOG.warn("Unable to delete file [%s]", file);
            }
        }
        for (File file : filesInProcess) {
            if (!file.delete()) {
                LOG.warn("Unable to delete file [%s]", file);
            }
        }
        throw new ISE("[%d] writers in progress and [%d] completed writers needs to be closed before closing smoosher.", filesInProcess.size(), completedFiles.size());
    }
    if (currOut != null) {
        currOut.close();
    }
    File metaFile = metaFile(baseDir);
    try (Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(metaFile), Charsets.UTF_8))) {
        out.write(String.format("v1,%d,%d", maxChunkSize, outFiles.size()));
        out.write("\n");
        for (Map.Entry<String, Metadata> entry : internalFiles.entrySet()) {
            final Metadata metadata = entry.getValue();
            out.write(joiner.join(entry.getKey(), metadata.getFileNum(), metadata.getStartOffset(), metadata.getEndOffset()));
            out.write("\n");
        }
    }
}