Example usage for io.vertx.core.streams WriteStream exceptionHandler

Introduction

In this page you can find the example usage for io.vertx.core.streams WriteStream exceptionHandler.

Prototype

@Override
WriteStream<T> exceptionHandler(Handler<Throwable> handler);

Source Link

Document

Set an exception handler on the write stream.

Usage

From source file:org.apache.servicecomb.foundation.vertx.stream.PumpCommon.java

License:Apache License

/**
 *
 * @param context//from   www  .  j  a v  a2 s.co  m
 * @param readStream
 * @param writeStream
 * @return future of save action<br>
 * <p>important:
 * <p>  if writeStream is AsyncCloseable, future means write complete
 * <p>  if writeStream is not AsyncCloseable, future only means read complete
 */
@SuppressWarnings("unchecked")
public CompletableFuture<Void> pump(Context context, ReadStream<Buffer> readStream,
        WriteStream<Buffer> writeStream) {
    CompletableFuture<Void> readFuture = new CompletableFuture<>();

    writeStream.exceptionHandler(readFuture::completeExceptionally);
    readStream.exceptionHandler(readFuture::completeExceptionally);
    // just means read finished, not means write finished
    readStream.endHandler(readFuture::complete);

    // if readStream(HttpClientResponse) and awriteStream(HttpServerResponse)
    // belongs to difference eventloop
    // maybe will cause deadlock
    // if happened, vertx will print deadlock stacks
    Pump.pump(readStream, writeStream).start();
    try {
        context.runOnContext(v -> readStream.resume());
    } catch (Throwable e) {
        readFuture.completeExceptionally(e);
    }

    if (!AsyncCloseable.class.isInstance(writeStream)) {
        return readFuture;
    }

    return closeWriteStream((AsyncCloseable<Void>) writeStream, readFuture);
}

---

From source file:org.sfs.io.AsyncIO.java

License:Apache License

public static Observable<Void> append(Buffer buffer, final WriteStream<Buffer> ws) {
    return Observable.defer(() -> {

        ObservableFuture<Void> drainHandler = RxHelper.observableFuture();
        ws.exceptionHandler(drainHandler::fail);
        if (ws.writeQueueFull()) {
            ws.drainHandler(drainHandler::complete);
        } else {/*from   w  ww  . j  a v a2s . com*/
            drainHandler.complete(null);
        }

        return drainHandler.flatMap(aVoid -> {
            ObservableFuture<Void> writeHandler = RxHelper.observableFuture();
            ws.exceptionHandler(writeHandler::fail);
            ws.write(buffer);
            if (ws.writeQueueFull()) {
                ws.drainHandler(writeHandler::complete);
            } else {
                writeHandler.complete(null);
            }
            return writeHandler;
        });
    });
}

---