/** * Close the stream without necessarily flushing immediately. * This may be called if the stream is in error such as after a * previous write or close threw an exception. */ @Override public void abort() throws IOException { super.abort(); } }
private Future<Void> asyncCloseAndComplete(boolean shouldThrow) { BKLogSegmentWriter segmentWriter = getCachedLogWriter(); BKLogWriteHandler writeHandler = getCachedWriteHandler(); if (null != segmentWriter && null != writeHandler) { cancelTruncation(); Promise<Void> completePromise = new Promise<Void>(); asyncCloseAndComplete(segmentWriter, writeHandler, completePromise, shouldThrow); return completePromise; } else { return closeNoThrow(); } }
@Override public void onSuccess(LogSegmentMetadata value) { cacheLogWriter(newSegmentWriter); removeAllocatedLogWriter(); FutureUtils.setValue(completePromise, newSegmentWriter); }
@Override public Future<Void> asyncAbort() { Promise<Void> closeFuture; synchronized (this) { if (null != closePromise) { return closePromise; } closeFuture = closePromise = new Promise<Void>(); } cancelTruncation(); Abortables.abortSequence(bkDistributedLogManager.getScheduler(), getCachedLogWriter(), getAllocatedLogWriter(), getCachedWriteHandler()).proxyTo(closeFuture); return closeFuture; }
protected BKLogSegmentWriter getLedgerWriter(final long startTxId, final boolean allowMaxTxID) throws IOException { Future<BKLogSegmentWriter> logSegmentWriterFuture = asyncGetLedgerWriter(true); BKLogSegmentWriter logSegmentWriter = null; if (null != logSegmentWriterFuture) { logSegmentWriter = FutureUtils.result(logSegmentWriterFuture); } if (null == logSegmentWriter || (shouldStartNewSegment(logSegmentWriter) || forceRolling)) { logSegmentWriter = FutureUtils.result(rollLogSegmentIfNecessary( logSegmentWriter, startTxId, true /* bestEffort */, allowMaxTxID)); } return logSegmentWriter; }
final BKLogWriteHandler writeHandler; try { writeHandler = getWriteHandler(); } catch (IOException e) { return Future.exception(e); rollPromise = closeOldLogSegmentAndStartNewOneWithPermit( segmentWriter, writeHandler, startTxId, bestEffort, allowMaxTxID); } else if (null == segmentWriter) { rollPromise = asyncStartNewLogSegment(writeHandler, startTxId, allowMaxTxID); } else { rollPromise = Future.value(segmentWriter);
@Override public Future<Void> asyncClose() { return asyncCloseAndComplete(false); }
@Override public void abort() throws IOException { FutureUtils.result(asyncAbort()); }
@Override public void close() throws IOException { FutureUtils.result(asyncClose()); }
private void complete(final Throwable cause) { closeNoThrow().ensure(new AbstractFunction0<BoxedUnit>() { @Override public BoxedUnit apply() { if (null != cause && shouldThrow) { FutureUtils.setException(completePromise, cause); } else { FutureUtils.setValue(completePromise, null); } return BoxedUnit.UNIT; } }); } });
@Override public Future<BKLogSegmentWriter> apply(BKLogSegmentWriter newSegmentWriter) { if (null == newSegmentWriter) { if (bestEffort) { return Future.value(oldSegmentWriter); } else { return Future.exception( new UnexpectedException("StartLogSegment returns null for bestEffort rolling")); } } cacheAllocatedLogWriter(newSegmentWriter); if (LOG.isDebugEnabled()) { LOG.debug("Allocated a new log segment from {} for {}.", startTxId, writeHandler.getFullyQualifiedName()); } return completeOldSegmentAndCacheNewLogSegmentWriter(oldSegmentWriter, newSegmentWriter); } });
/** * Close the writer and release all the underlying resources */ protected Future<Void> closeNoThrow() { Promise<Void> closeFuture; synchronized (this) { if (null != closePromise) { return closePromise; } closeFuture = closePromise = new Promise<Void>(); } cancelTruncation(); Utils.closeSequence(bkDistributedLogManager.getScheduler(), true, /** ignore close errors **/ getCachedLogWriter(), getAllocatedLogWriter(), getCachedWriteHandler() ).proxyTo(closeFuture); return closeFuture; }
protected Future<Void> asyncCloseAndComplete() { return asyncCloseAndComplete(true); }
@VisibleForTesting void closeAndComplete() throws IOException { FutureUtils.result(asyncCloseAndComplete(true)); }
@Override protected Future<Void> asyncCloseAndComplete() { Future<BKLogSegmentWriter> logSegmentWriterFuture; synchronized (this) { logSegmentWriterFuture = this.rollingFuture; } if (null == logSegmentWriterFuture) { return super.asyncCloseAndComplete(); } else { return logSegmentWriterFuture.flatMap(new AbstractFunction1<BKLogSegmentWriter, Future<Void>>() { @Override public Future<Void> apply(BKLogSegmentWriter segmentWriter) { return BKAsyncLogWriter.super.asyncCloseAndComplete(); } }); } }