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

Example 91 with PipedInputStream

use of java.io.PipedInputStream in project robovm by robovm.

the class OldPipedOutputStreamTest method test_write$BII.

public void test_write$BII() throws IOException {
    out = new PipedOutputStream();
    try {
        out.write(testString.getBytes(), 0, 5);
        fail("Test 1: IOException expected.");
    } catch (IOException e) {
    // Expected.
    }
    out = new PipedOutputStream(new PipedInputStream());
    try {
        out.write(testString.getBytes(), -1, 10);
        fail("Test 2: IndexOutOfBoundsException expected.");
    } catch (IndexOutOfBoundsException e) {
    // Expected.
    }
    try {
        out.write(testString.getBytes(), 0, -1);
        fail("Test 3: IndexOutOfBoundsException expected.");
    } catch (IndexOutOfBoundsException e) {
    // Expected.
    }
    try {
        out.write(testString.getBytes(), 5, testString.length());
        fail("Test 4: IndexOutOfBoundsException expected.");
    } catch (IndexOutOfBoundsException e) {
    // Expected.
    }
    out.close();
    out = new PipedOutputStream();
    try {
        rt = new Thread(reader = new PReader(out));
        rt.start();
        out.write(testString.getBytes(), 0, testString.length());
        out.flush();
        assertEquals("Test 5: Bytes read do not match the bytes written. ", testString, reader.read(testString.length()));
    } catch (IOException e) {
        fail("Test 5: Unexpected IOException: " + e.getMessage());
    }
    reader.getReader().close();
    try {
        out.write(testString.getBytes(), 0, 5);
        fail("Test 7: IOException expected.");
    } catch (IOException e) {
    // Expected.
    }
}

Example 92 with PipedInputStream

use of java.io.PipedInputStream in project robovm by robovm.

the class OldPipedOutputStreamTest method test_ConstructorLjava_io_PipedInputStream.

public void test_ConstructorLjava_io_PipedInputStream() throws IOException {
    try {
        out = new PipedOutputStream(new PipedInputStream());
        out.write('b');
    } catch (Exception e) {
        fail("Test 1: Constructor failed: " + e.getMessage());
    }
    out.close();
    PipedInputStream pis = new PipedInputStream(new PipedOutputStream());
    try {
        out = new PipedOutputStream(pis);
        fail("Test 2: IOException expected because the input stream is already connected.");
    } catch (IOException e) {
    // Expected.
    }
}

Example 93 with PipedInputStream

use of java.io.PipedInputStream in project antlr4 by antlr.

the class BaseJavaTest method execClass.

public String execClass(String className) {
    if (TEST_IN_SAME_PROCESS) {
        try {
            ClassLoader loader = new URLClassLoader(new URL[] { new File(tmpdir).toURI().toURL() }, ClassLoader.getSystemClassLoader());
            final Class<?> mainClass = (Class<?>) loader.loadClass(className);
            final Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
            PipedInputStream stdoutIn = new PipedInputStream();
            PipedInputStream stderrIn = new PipedInputStream();
            PipedOutputStream stdoutOut = new PipedOutputStream(stdoutIn);
            PipedOutputStream stderrOut = new PipedOutputStream(stderrIn);
            StreamVacuum stdoutVacuum = new StreamVacuum(stdoutIn);
            StreamVacuum stderrVacuum = new StreamVacuum(stderrIn);
            PrintStream originalOut = System.out;
            System.setOut(new PrintStream(stdoutOut));
            try {
                PrintStream originalErr = System.err;
                try {
                    System.setErr(new PrintStream(stderrOut));
                    stdoutVacuum.start();
                    stderrVacuum.start();
                    mainMethod.invoke(null, (Object) new String[] { new File(tmpdir, "input").getAbsolutePath() });
                } finally {
                    System.setErr(originalErr);
                }
            } finally {
                System.setOut(originalOut);
            }
            stdoutOut.close();
            stderrOut.close();
            stdoutVacuum.join();
            stderrVacuum.join();
            String output = stdoutVacuum.toString();
            if (output.length() == 0) {
                output = null;
            }
            if (stderrVacuum.toString().length() > 0) {
                this.stderrDuringParse = stderrVacuum.toString();
            }
            return output;
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
    try {
        String[] args = new String[] { "java", "-classpath", tmpdir + pathSep + CLASSPATH, "-Dfile.encoding=UTF-8", className, new File(tmpdir, "input").getAbsolutePath() };
        //			String cmdLine = Utils.join(args, " ");
        //			System.err.println("execParser: "+cmdLine);
        Process process = Runtime.getRuntime().exec(args, null, new File(tmpdir));
        StreamVacuum stdoutVacuum = new StreamVacuum(process.getInputStream());
        StreamVacuum stderrVacuum = new StreamVacuum(process.getErrorStream());
        stdoutVacuum.start();
        stderrVacuum.start();
        process.waitFor();
        stdoutVacuum.join();
        stderrVacuum.join();
        String output = stdoutVacuum.toString();
        if (output.length() == 0) {
            output = null;
        }
        if (stderrVacuum.toString().length() > 0) {
            this.stderrDuringParse = stderrVacuum.toString();
        }
        return output;
    } catch (Exception e) {
        System.err.println("can't exec recognizer");
        e.printStackTrace(System.err);
    }
    return null;
}

Example 94 with PipedInputStream

use of java.io.PipedInputStream in project async-http-client by AsyncHttpClient.

the class BodyDeferringAsyncHandlerTest method deferredInputStreamTrick.

@Test(groups = "standalone")
public void deferredInputStreamTrick() throws IOException, ExecutionException, TimeoutException, InterruptedException {
    try (AsyncHttpClient client = asyncHttpClient(getAsyncHttpClientConfig())) {
        BoundRequestBuilder r = client.prepareGet("http://localhost:" + port1 + "/deferredInputStreamTrick");
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos);
        BodyDeferringAsyncHandler bdah = new BodyDeferringAsyncHandler(pos);
        Future<Response> f = r.execute(bdah);
        BodyDeferringInputStream is = new BodyDeferringInputStream(f, bdah, pis);
        Response resp = is.getAsapResponse();
        assertNotNull(resp);
        assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK);
        assertEquals(resp.getHeader(CONTENT_LENGTH), String.valueOf(CONTENT_LENGTH_VALUE));
        // "consume" the body, but our code needs input stream
        CountingOutputStream cos = new CountingOutputStream();
        try {
            copy(is, cos);
        } finally {
            is.close();
            cos.close();
        }
        // now we don't need to be polite, since consuming and closing
        // BodyDeferringInputStream does all.
        // it all should be here now
        assertEquals(cos.getByteCount(), CONTENT_LENGTH_VALUE);
    }
}

Example 95 with PipedInputStream

use of java.io.PipedInputStream in project opennms by OpenNMS.

the class TcpStreamHandler method run.

/**
     * The main execution context for processing a remote XML document. Once the
     * document is processed and an event receipt is returned to the client the
     * thread will exit.
     */
@Override
public void run() {
    // get the context and stop if necessary
    m_context = Thread.currentThread();
    synchronized (m_context) {
        m_context.notifyAll();
    }
    // check the stop flag
    if (m_stop) {
        LOG.debug("The stop flag was set prior to thread entry, closing connection");
        try {
            m_connection.close();
        } catch (final IOException e) {
            LOG.error("An error occured while closing the connection.", e);
        }
        LOG.debug("Thread context exiting");
        return;
    }
    // Log the startup of this stream handler
    final InetAddress sender = m_connection.getInetAddress();
    LOG.debug("Event Log Stream Handler Started for {}", sender);
    /*
         * This linked list is used to exchange
         * instances of PipedOutputStreams. Whenever a
         * pipe output stream is recovered it must be
         * signaled to inform the EOT thread of the
         * ability to write to the pipe. Also, when
         * the descriptor is close a EOFException is
         * passed on the list.
         */
    final LinkedList<Object> pipeXchange = new LinkedList<Object>();
    final TcpRecordHandler chunker = new TcpRecordHandler(m_connection, pipeXchange);
    final Thread tchunker = new Thread(chunker, "TCPRecord Chunker[" + InetAddressUtils.str(m_connection.getInetAddress()) + ":" + m_connection.getPort() + "]");
    synchronized (tchunker) {
        tchunker.start();
        try {
            tchunker.wait();
        } catch (final InterruptedException e) {
            LOG.error("The thread was interrupted.", e);
        }
    }
    MAINLOOP: while (!m_stop && m_parent.getStatus() != Fiber.STOP_PENDING && m_parent.getStatus() != Fiber.STOPPED && m_recsPerConn != 0) {
        // get a new pipe input stream
        PipedInputStream pipeIn = null;
        synchronized (pipeXchange) {
            while (pipeXchange.isEmpty()) {
                if (chunker.isAlive()) {
                    try {
                        pipeXchange.wait(500);
                    } catch (final InterruptedException e) {
                        LOG.error("The thread was interrupted.", e);
                        break MAINLOOP;
                    }
                } else {
                    break MAINLOOP;
                }
            }
            // if an exception occured then just exit the BAL (Big Ass Loop)
            final Object o = pipeXchange.removeFirst();
            if (o instanceof Throwable) {
                break MAINLOOP;
            }
            // construct the other end of the pipe
            try {
                pipeIn = new PipedInputStream((PipedOutputStream) o);
            } catch (final IOException e) {
                LOG.error("An I/O exception occured construction a record reader.", e);
                break MAINLOOP;
            }
            // signal that we got the stream
            synchronized (o) {
                o.notify();
            }
        }
        // decrement the record count if greater than zero
        m_recsPerConn -= (m_recsPerConn > 0 ? 1 : 0);
        // convert the pipe input stream into a buffered input stream
        final InputStream stream = new BufferedInputStream(pipeIn);
        // Unmarshal the XML document
        Log eLog = null;
        boolean doCleanup = false;
        try {
            eLog = JaxbUtils.unmarshal(Log.class, new InputSource(stream));
            LOG.debug("Event record converted");
        } catch (final Exception e) {
            LOG.error("Could not unmarshall the XML record.", e);
            doCleanup = true;
        } finally {
            if (stream != null) {
                IOUtils.closeQuietly(stream);
            }
        }
        // clean up the data on the current pipe if necessary
        if (doCleanup) {
            /*
                 * Cleanup a failed record. Need to read
                 * the remaining bytes from the other thread
                 * to synchronize up. The other thread might
                 * be blocked writing.
                 */
            try {
                while (stream.read() != -1) {
                    /* do nothing */
                    ;
                }
            } catch (final IOException e) {
            // do nothing
            }
            // start from the top!
            continue MAINLOOP;
        }
        // Now that we have a list of events, process them
        final Event[] events = eLog.getEvents().getEvent();
        // sort the events by time
        Arrays.sort(events, new Comparator<Event>() {

            @Override
            public int compare(final Event e1, final Event e2) {
                final boolean e1t = (e1.getTime() != null);
                final boolean e2t = (e2.getTime() != null);
                if (e1t && !e2t) {
                    return 1;
                } else if (!e1t && e2t) {
                    return -1;
                } else if (!e1t && !e2t) {
                    return 0;
                }
                Date de1 = e1.getTime();
                Date de2 = e2.getTime();
                if (de1 != null && de2 != null) {
                    return (int) (de1.getTime() - de2.getTime());
                } else if (de1 == null && de2 != null) {
                    return -1;
                } else if (de1 != null && de2 == null) {
                    return 1;
                } else {
                    return 0;
                }
            }
        });
        // process the events
        if (events != null && events.length != 0) {
            final Collection<Event> okEvents = new LinkedHashSet<>(events.length);
            /*
                 * This synchronization loop will hold onto the lock
                 * for a while. If the handlers are going to change
                 * often, which is shouldn't then might want to consider
                 * duplicating the handlers into an array before processing
                 * the events.
                 *
                 * Doing the synchronization in the outer loop prevents spending
                 * lots of cycles doing synchronization when it should not
                 * normally be necesary.
                 */
            synchronized (m_handlers) {
                for (final EventHandler hdl : m_handlers) {
                    /*
                         * get the handler and then have it process all
                         * the events in the document before moving to the
                         * next event handler.
                         */
                    for (final Event event : events) {
                        /*
                             * Process the event and log any errors,
                             *  but don't die on these errors
                             */
                        try {
                            LOG.debug("handling event: {}", event);
                            // shortcut and BOTH parts MUST execute!
                            if (hdl.processEvent(event)) {
                                if (!okEvents.contains(event)) {
                                    okEvents.add(event);
                                }
                            }
                        } catch (final Throwable t) {
                            LOG.warn("An exception occured while processing an event.", t);
                        }
                    }
                }
            }
            // Now process the good events and send a receipt message
            boolean hasReceipt = false;
            final EventReceipt receipt = new EventReceipt();
            for (final Event event : okEvents) {
                if (event.getUuid() != null) {
                    receipt.addUuid(event.getUuid());
                    hasReceipt = true;
                }
            }
            if (hasReceipt) {
                // Transform it to XML and send it to the socket in one call
                try {
                    final Writer writer = new BufferedWriter(new OutputStreamWriter(m_connection.getOutputStream(), StandardCharsets.UTF_8));
                    JaxbUtils.marshal(receipt, writer);
                    writer.flush();
                    synchronized (m_handlers) {
                        for (final EventHandler hdl : m_handlers) {
                            /*
                                 * Get the handler and then have it process all
                                 * the events in the document before moving to
                                 * the next event hander.
                                 */
                            try {
                                hdl.receiptSent(receipt);
                            } catch (final Throwable t) {
                                LOG.warn("An exception occured while processing an event receipt.", t);
                            }
                        }
                    }
                    if (LOG.isDebugEnabled()) {
                        try {
                            final StringWriter swriter = new StringWriter();
                            JaxbUtils.marshal(receipt, swriter);
                            LOG.debug("Sent Event Receipt {");
                            LOG.debug(swriter.getBuffer().toString());
                            LOG.debug("}");
                        } catch (final Throwable e) {
                            LOG.error("An error occured during marshalling of event receipt for the log.", e);
                        }
                    }
                } catch (final IOException e) {
                    LOG.warn("Failed to send event-receipt XML document.", e);
                    break MAINLOOP;
                }
            }
        } else {
            LOG.debug("The agent sent an empty event stream");
        }
    }
    try {
        LOG.debug("stopping record handler");
        chunker.stop();
        LOG.debug("record handler stopped");
    } catch (final InterruptedException e) {
        LOG.warn("The thread was interrupted while trying to close the record handler.", e);
    }
    // regardless of any errors, be sure to release the socket.
    try {
        LOG.debug("closing connnection");
        m_connection.close();
        LOG.debug("connnection closed ");
    } catch (final IOException e) {
        LOG.warn("An I/O exception occured while closing the TCP/IP connection.", e);
    }
    LOG.debug("Thread exiting");
}