Using OutputToReadStream to write into a HttpServerResponse

[evial]

Hi Guss77,

First of all, thanks for your library. I need to write a large amount of data into a HttpServerResponse to return these data to an http client without overloading the server's memory. I tried to customize your code from OutputToReadStreamTest as follows:

HttpServerResponse response = requestContext.getResponse();
OutputToReadStream stream = new OutputToReadStream(vertx);
stream.pipeTo(response);
vertx.runOnContext(p -> {
  try {
    byte[] data = new byte[...];
    while (...) {
       readMyData(data);
       stream.write(data);
    }
    stream.close();
    p.complete();
  } catch (IOException e) {
   p.fail(e);
  }
  ...
  response.end();
});

The problem is that the "stream.write(data)" command is blocking on the first write. Is the OutputToReadStream class supposed to work with an HttpServerResponse as WriteStream? Dit I do something wrong in my implementation ?

Thanks

Eric

[guss77]

I think your implementation is correct and as far as I understand (some details are missing from your report) the implementation works as intended: please note that the way Java IO handles back-pressure is by blocking, which is what this library does - the write() waits until the client handles all the data before returning.

If you'd look at the code for OutputToReadStream.push() you'd note that it does not implement any buffering - each byte array is immediately offered to the data handler - using the Vert.x thread context - and waits for the data handler to finish.

So this may be the issue in your code - you call write() from the same Vert.x context that is supposed to run the HttpServerResponse data handler. The purpose of this library is to bridge Java IO semantics with Vert.x semantics, so it is assumes that one side (the Read/Write stream) is running on the Vert.x context, and the other (the Java IO reading/writing code) is running on standard Java blocking context - i.e. some kind of Executor thread or something. The Vert.x context thread must never be blocked, but Java IO is by definition blocking, so they are incompatible.

I suggest either changing the Java byte array read/write process to use a standard Java thread, or - if you want to run it on the Vert.x context - make it non-blocking, in which case you probably want to re-implement it as a ReadStream and not bother with this library 😄 .