java.io.PipedInputStream#connect

Source File: MicrophoneInputStream.java From android-sdk with Apache License 2.0

6 votes

/**
 * Instantiates a new microphone input stream.
 *
 * @param opusEncoded the opus encoded
 */
public MicrophoneInputStream(boolean opusEncoded) {
  captureThread = new MicrophoneCaptureThread(this, opusEncoded);
  if (opusEncoded == true) {
    CONTENT_TYPE = ContentType.OPUS;
  } else {
    CONTENT_TYPE = ContentType.RAW;
  }
  os = new PipedOutputStream();
  is = new PipedInputStream();
  try {
    is.connect(os);
  } catch (IOException e) {
    Log.e(TAG, e.getMessage());
  }
  captureThread.start();
}

Source File: LauncherTest.java From lsp4j with Eclipse Public License 2.0

6 votes

@Before public void setup() throws IOException {
	PipedInputStream inClient = new PipedInputStream();
	PipedOutputStream outClient = new PipedOutputStream();
	PipedInputStream inServer = new PipedInputStream();
	PipedOutputStream outServer = new PipedOutputStream();
	
	inClient.connect(outServer);
	outClient.connect(inServer);
	server = new AssertingEndpoint();
	serverLauncher = LSPLauncher.createServerLauncher(ServiceEndpoints.toServiceObject(server, LanguageServer.class), inServer, outServer);
	serverListening = serverLauncher.startListening();
	
	client = new AssertingEndpoint();
	clientLauncher = LSPLauncher.createClientLauncher(ServiceEndpoints.toServiceObject(client, LanguageClient.class), inClient, outClient);
	clientListening = clientLauncher.startListening();
	
	Logger logger = Logger.getLogger(StreamMessageProducer.class.getName());
	logLevel = logger.getLevel();
	logger.setLevel(Level.SEVERE);
}

Source File: SupportBundleManager.java From datacollector with Apache License 2.0

6 votes

/**
 * Return InputStream from which a new generated resource bundle can be retrieved.
 */
public SupportBundle generateNewBundle(List<String> generatorNames, BundleType bundleType) throws IOException {
  List<BundleContentGeneratorDefinition> defs = getRequestedDefinitions(generatorNames);

  PipedInputStream inputStream = new PipedInputStream();
  PipedOutputStream outputStream = new PipedOutputStream();
  inputStream.connect(outputStream);
  ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);

  executor.submit(() -> generateNewBundleInternal(defs, bundleType, zipOutputStream));

  String bundleName = generateBundleName(bundleType);
  String bundleKey = generateBundleDate(bundleType) + "/" + bundleName;

  return new SupportBundle(
    bundleKey,
    bundleName,
    inputStream
  );
}

Source File: ClientImpl.java From datamill with ISC License

6 votes

private CloseableHttpResponse doWithEntity(Body body, CloseableHttpClient httpClient, HttpUriRequest request) throws IOException {
    if (!(request instanceof HttpEntityEnclosingRequestBase)) {
        throw new IllegalArgumentException("Expecting to write an body for a request type that does not support it!");
    }

    PipedOutputStream pipedOutputStream = buildPipedOutputStream();
    PipedInputStream pipedInputStream = buildPipedInputStream();

    pipedInputStream.connect(pipedOutputStream);

    BasicHttpEntity httpEntity = new BasicHttpEntity();
    httpEntity.setContent(pipedInputStream);
    ((HttpEntityEnclosingRequestBase) request).setEntity(httpEntity);

    writeEntityOutOverConnection(body, pipedOutputStream);

    return doExecute(httpClient, request);
}

Source File: DockerMultiplexedInputStreamTest.java From docker-plugin with MIT License

5 votes

public DemuxTester() throws IOException {
    feeder = new PipedOutputStream();

    feeder_input_stream = new PipedInputStream();
    feeder_input_stream.connect(feeder);
    
    stream = new DockerMultiplexedInputStream(feeder_input_stream);
    sink = new ByteArrayOutputStream();
    eof = false;
    exc = null;

    thread = new Thread(this);
    thread.start();
}

Source File: ReplaceInStringExample.java From ExpectIt with Apache License 2.0

5 votes

public static void main(String[] args) throws IOException {
    PipedInputStream pipedInputStream = new PipedInputStream();
    PipedOutputStream pipedOutputStream = new PipedOutputStream();

    System.out.println("Connecting pipes");
    pipedInputStream.connect(pipedOutputStream);

    System.out.println("Building expect");
    Expect expect = new ExpectBuilder()
            .withInputs(pipedInputStream)
            .withTimeout(30, TimeUnit.SECONDS)
            .withExceptionOnFailure()
            .withInputFilters(myFilter())
            .build();

    System.out.println("Writing data to output");
    for (int i = 0; i < 1500; i++) {
        pipedOutputStream.write("removeSome text hereremove\n".getBytes());
    }
    pipedOutputStream.write("done\n".getBytes());

    System.out.println("Flushing output");
    pipedOutputStream.flush();

    System.out.println("Waiting for 'done'");
    Result r = expect.expect(Matchers.contains("done"));

    System.out.println("Printing data");
    System.out.println(r.getBefore());

    System.out.println("Done");

    expect.close();
}

Source File: DownloadSchema.java From servicecomb-java-chassis with Apache License 2.0

5 votes

@ApiResponses({@ApiResponse(code = 200, response = File.class, message = "")})
@GetMapping(path = "/slowInputStream")
public ResponseEntity<InputStream> slowInputStream() throws IOException {
  PipedInputStream in = new PipedInputStream();
  PipedOutputStream out = new PipedOutputStream();
  in.connect(out);

  slowInputStreamThread = new Thread(() -> {
    Thread.currentThread().setName("download thread");
    byte[] bytes = "1".getBytes();
    for (; ; ) {
      try {
        out.write(bytes);
        out.flush();
        Thread.sleep(1000);
      } catch (Throwable e) {
        break;
      }
    }
    try {
      out.close();
    } catch (final IOException ioe) {
      // ignore
    }
  });
  slowInputStreamThread.start();

  ResponseEntity<InputStream> responseEntity = ResponseEntity
      .ok()
      .header(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN_VALUE)
      .header(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=slowInputStream.txt")
      .body(in);
  return responseEntity;
}

Source File: HttpUrlConnectionImpl.java From whiskey with Apache License 2.0

5 votes

@Override
public OutputStream getOutputStream() throws IOException {

    PipedOutputStream out = new PipedOutputStream();
    PipedInputStream in = new PipedInputStream();
    in.connect(out);
    requestBuilder.body(in);
    return out;
}

Source File: SchematronValidatingParser.java From teamengine with Apache License 2.0

5 votes

/**
 * Converts an org.w3c.dom.Document element to an java.io.InputStream.
 * 
 * @param edoc
 *            The org.w3c.dom.Document to be converted
 * @return The InputStream value of the passed doument
 */
public InputStream DocumentToInputStream(org.w3c.dom.Document edoc)
        throws IOException {

    final org.w3c.dom.Document doc = edoc;
    final PipedOutputStream pos = new PipedOutputStream();
    PipedInputStream pis = new PipedInputStream();
    pis.connect(pos);

    (new Thread(new Runnable() {

        public void run() {
            // Use the Transformer.transform() method to save the Document
            // to a StreamResult
            try {
                TransformerFactory tFactory = TransformerFactory.newInstance();
                  // Fortify Mod: prevent external entity injection 
                tFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
                Transformer transformer = tFactory.newTransformer();
                transformer.setOutputProperty("encoding", "ISO-8859-1");
                transformer.setOutputProperty("indent", "yes");
                transformer.transform(new DOMSource(doc), new StreamResult(
                        pos));
            } catch (Exception _ex) {
                throw new RuntimeException(
                        "Failed to tranform org.w3c.dom.Document to PipedOutputStream",
                        _ex);
            } finally {
                try {
                    pos.close();
                } catch (IOException e) {

                }
            }
        }
    }, "MyClassName.convert(org.w3c.dom.Document edoc)")).start();

    return pis;
}

Source File: ExtendableConcurrentMessageProcessorTest.java From lsp4j with Eclipse Public License 2.0

5 votes

/**
 * Test that an adopter making use of these APIs is able to 
 * identify which client is making any given request. 
 */
@Test
public void testIdentifyClientRequest() throws Exception {
	// create client side
	PipedInputStream in = new PipedInputStream();
	PipedOutputStream out = new PipedOutputStream();
	PipedInputStream in2 = new PipedInputStream();
	PipedOutputStream out2 = new PipedOutputStream();
	
	in.connect(out2);
	out.connect(in2);
	
	MyClient client = new MyClientImpl();
	Launcher<MyServer> clientSideLauncher = Launcher.createLauncher(client, MyServer.class, in, out);
	
	// create server side
	MyServer server = new MyServerImpl();
	MessageContextStore<MyClient> contextStore = new MessageContextStore<>();
	Launcher<MyClient> serverSideLauncher = createLauncher(createBuilder(contextStore), server, MyClient.class, in2, out2);
	
	TestContextWrapper.setMap(contextStore);
	
	clientSideLauncher.startListening();
	serverSideLauncher.startListening();
	
	CompletableFuture<MyParam> fooFuture = clientSideLauncher.getRemoteProxy().askServer(new MyParam("FOO"));
	CompletableFuture<MyParam> barFuture = serverSideLauncher.getRemoteProxy().askClient(new MyParam("BAR"));
	
	Assert.assertEquals("FOO", fooFuture.get(TIMEOUT, TimeUnit.MILLISECONDS).value);
	Assert.assertEquals("BAR", barFuture.get(TIMEOUT, TimeUnit.MILLISECONDS).value);
	Assert.assertFalse(TestContextWrapper.error);
}