@Override public void onWritePossible() { _wh.done(); }
@Override public void request(int n) { notifyError(); }
private static Exception getAbortedException() { return new AbortedException("Reader aborted"); } }
@Test public void testWrite() throws ExecutionException, InterruptedException { String singleton = "singleton"; Writer<Object> singletonWriter = new SingletonWriter<>(singleton); EntityStream<Object> singletonStream = EntityStreams.newEntityStream(singletonWriter); CollectingReader<Object, ?, Set<Object>> reader = new CollectingReader<>(Collectors.toSet()); singletonStream.setReader(reader); Assert.assertEquals(reader.getResult().toCompletableFuture().get(), Collections.singleton(singleton)); } }
checkInit(); _state = State.ACTIVE; _reader = r; final WriteHandle<T> wh = new WriteHandleImpl(); Throwable writerInitEx = null; try _writer.onInit(wh); safeAbortWriter(ex); writerInitEx = ex; if (writerInitEx == null) rh = new ReadHandleImpl(); _reader.onInit(rh); doCancel(ex, true); safeNotifyErrorToObservers(ex); safeNotifyErrorToReader(ex);
public static <T> EntityStream<T> emptyStream() { return newEntityStream(new Writer<T>() { private WriteHandle<? super T> _wh; @Override public void onInit(WriteHandle<? super T> wh) { _wh = wh; } @Override public void onWritePossible() { _wh.done(); } @Override public void onAbort(Throwable e) { // do nothing } }); }
@Override public void onDataAvailable(T data) { try { _collector.accumulator().accept(_intermediateResult, data); } catch (Throwable e) { handleException(e); } _readHandle.request(1); }
private void doCancel(Throwable e, boolean notifyReader) { safeAbortWriter(e); safeNotifyErrorToObservers(e); if (notifyReader) { safeNotifyErrorToReader(e); } }
private void handleException(Throwable e) { _readHandle.cancel(); _completable.completeExceptionally(e); }
private void safeAbortWriter(Throwable throwable) { try { _writer.onAbort(throwable); } catch (Throwable ex) { LOG.warn("Writer throws exception at onAbort", ex); } }
private void safeNotifyErrorToReader(Throwable throwable) { try { _reader.onError(throwable); } catch (Throwable ex) { LOG.error("Reader throws exception at onError", ex); } }
private void safeNotifyErrorToObservers(Throwable throwable) { for (Observer<? super T> observer : _observers) { try { observer.onError(throwable); } catch (Throwable ex) { LOG.warn("Observer throws exception at onError, ignored.", ex); } } }
/** * The method to create a new EntityStream with a writer for the stream. * * @param writer the writer for the stream who would provide the data * @return an instance of EntityStream */ public static <T> EntityStream<T> newEntityStream(Writer<? extends T> writer) { return new EntityStreamImpl<T>(writer); } }
public void addObserver(Observer<? super T> o) { synchronized (_lock) { checkInit(); _observers.add(o); } }
@Override public void onDone() { R result; try { result = _collector.finisher().apply(_intermediateResult); } catch (Throwable e) { handleException(e); return; } _completable.complete(result); }
@Test(dataProvider = "data") public void testWrite(int chunkSize) throws InterruptedException, ExecutionException, TimeoutException { Writer<ByteString> writer = new ChunkedByteStringWriter(DATA, chunkSize); EntityStream<ByteString> stream = EntityStreams.newEntityStream(writer); CollectingReader<ByteString, ?, ChunkedByteStringCollector.Result> reader = new CollectingReader<>(new ChunkedByteStringCollector()); stream.setReader(reader); ChunkedByteStringCollector.Result result = reader.getResult().toCompletableFuture().get(); Assert.assertEquals(result.data, DATA); Assert.assertEquals(result.chunkCount, (DATA.length - 1) / chunkSize + 1); } }
@Override public void onWritePossible() { while (_writeHandle.remaining() > 0) { if (_offset < _bytes.length) { int length = Math.min(_chunkSize, _bytes.length - _offset); ByteString chunk = ByteString.copy(_bytes, _offset, length); _offset += length; _writeHandle.write(chunk); } else { _writeHandle.done(); } } }
@Override public void onInit(ReadHandle rh) { _readHandle = rh; _completable = new CompletableFuture<>(); try { _intermediateResult = _collector.supplier().get(); } catch (Throwable e) { handleException(e); } rh.request(1); }
@Override public void cancel() { notifyError(); }