@SneakyThrows(StreamSegmentNotExistsException.class) private TransactionalEventStreamWriter<byte[]> getTransactionalWriter(String streamName, int routingKey) { List<TransactionalEventStreamWriter<byte[]>> writers = this.transactionalWriters.getOrDefault(streamName, null); if (writers == null) { throw new StreamSegmentNotExistsException(streamName); } return writers.get(routingKey % writers.size()); }
if (transactionMetadata.getLength() == 0 && ex instanceof StreamSegmentNotExistsException && ((StreamSegmentNotExistsException) ex).getStreamSegmentName().equals(transactionMetadata.getName())) { log.warn("{}: Not applying '{}' because source segment is missing (storage) and had no data.", this.traceObjectId, mergeOp); return null;
@SneakyThrows(StreamSegmentNotExistsException.class) private UUID getTransactionId(String transactionName) { UUID txnId = this.transactionIds.getOrDefault(transactionName, null); if (txnId == null) { throw new StreamSegmentNotExistsException(transactionName); } return txnId; }
@Override public CompletableFuture<Void> append(String streamSegmentName, byte[] data, Collection<AttributeUpdate> attributeUpdates, Duration timeout) { if (this.segments.contains(streamSegmentName)) { return CompletableFuture.completedFuture(null); } else { return Futures.failedFuture(new StreamSegmentNotExistsException(streamSegmentName)); } }
@SneakyThrows(StreamSegmentNotExistsException.class) private EventStreamWriter<byte[]> getWriter(String streamName, int routingKey) { List<EventStreamWriter<byte[]>> writers = this.streamWriters.getOrDefault(streamName, null); if (writers == null) { throw new StreamSegmentNotExistsException(streamName); } return writers.get(routingKey % writers.size()); }
private StreamSegmentData getStreamSegmentData(String streamSegmentName) throws StreamSegmentNotExistsException { synchronized (this.lock) { StreamSegmentData data = this.streamSegments.getOrDefault(streamSegmentName, null); if (data == null) { throw new StreamSegmentNotExistsException(streamSegmentName); } return data; } }
private void ensureNotDeleted(RollingSegmentHandle handle) throws StreamSegmentNotExistsException { if (handle.isDeleted()) { throw new StreamSegmentNotExistsException(handle.getSegmentName()); } }
private void deleteInternal(SegmentHandle handle) throws StreamSegmentNotExistsException { synchronized (this.lock) { if (!this.streamSegments.containsKey(handle.getSegmentName())) { throw new StreamSegmentNotExistsException(handle.getSegmentName()); } this.streamSegments.remove(handle.getSegmentName()); } }
@SneakyThrows(StreamSegmentNotExistsException.class) private TableData getTableData(String segmentName) { synchronized (this.tables) { TableData result = this.tables.get(segmentName); if (result == null) { throw new StreamSegmentNotExistsException(segmentName); } return result; } }
@Override protected CompletableFuture<ArrayView> getSegmentInfoInternal(String segmentName, Duration timeout) { return applyToSegment( segmentName, (entry, t2) -> CompletableFuture.completedFuture(entry.getValue()), () -> Futures.failedFuture(new StreamSegmentNotExistsException(segmentName)), timeout); }
@Override public CompletableFuture<SegmentProperties> getStreamSegmentInfo(String streamSegmentName, Duration timeout) { if (this.segments.contains(streamSegmentName)) { return CompletableFuture.completedFuture(StreamSegmentInformation.builder().name(streamSegmentName).build()); } else { return Futures.failedFuture(new StreamSegmentNotExistsException(streamSegmentName)); } }
private SegmentHandle doOpenRead(String streamSegmentName) throws StreamSegmentNotExistsException { long traceId = LoggerHelpers.traceEnter(log, "openRead", streamSegmentName); Path path = Paths.get(config.getRoot(), streamSegmentName); if (!Files.exists(path)) { throw new StreamSegmentNotExistsException(streamSegmentName); } LoggerHelpers.traceLeave(log, "openRead", traceId, streamSegmentName); return FileSystemSegmentHandle.readHandle(streamSegmentName); }
private <T> T throwException(String segmentName, Exception e) throws StreamSegmentException { if (e instanceof NoSuchFileException || e instanceof FileNotFoundException) { throw new StreamSegmentNotExistsException(segmentName); } if (e instanceof FileAlreadyExistsException) { throw new StreamSegmentExistsException(segmentName); } if (e instanceof IndexOutOfBoundsException) { throw new IllegalArgumentException(e.getMessage()); } if (e instanceof AccessControlException || e instanceof AccessDeniedException || e instanceof NonWritableChannelException) { throw new StreamSegmentSealedException(segmentName, e); } throw Exceptions.sneakyThrow(e); }
private <T> T throwException(String segmentName, Exception e) throws StreamSegmentException { if (e instanceof S3Exception) { S3Exception s3Exception = (S3Exception) e; String errorCode = Strings.nullToEmpty(s3Exception.getErrorCode()); if (errorCode.equals("NoSuchKey")) { throw new StreamSegmentNotExistsException(segmentName); } if (errorCode.equals("PreconditionFailed")) { throw new StreamSegmentExistsException(segmentName); } if (errorCode.equals("InvalidRange") || errorCode.equals("InvalidArgument") || errorCode.equals("MethodNotAllowed") || s3Exception.getHttpCode() == HttpStatus.SC_REQUESTED_RANGE_NOT_SATISFIABLE) { throw new IllegalArgumentException(segmentName, e); } if (errorCode.equals("AccessDenied")) { throw new StreamSegmentSealedException(segmentName, e); } } if (e instanceof IndexOutOfBoundsException) { throw new ArrayIndexOutOfBoundsException(e.getMessage()); } throw Exceptions.sneakyThrow(e); }
private SegmentProperties getHeaderInfo(String segmentName) throws StreamSegmentException { String headerSegment = StreamSegmentNameUtils.getHeaderSegmentName(segmentName); val headerInfo = this.baseStorage.getStreamSegmentInfo(headerSegment); if (headerInfo.getLength() == 0) { // We treat empty header files as inexistent segments. throw new StreamSegmentNotExistsException(segmentName); } return headerInfo; }
@Override public CompletableFuture<Void> deleteSegment(String segmentName, boolean mustBeEmpty, Duration timeout) { Exceptions.checkNotClosed(this.closed.get(), this); return CompletableFuture.runAsync(() -> { synchronized (this.tables) { if (this.tables.remove(segmentName) == null) { throw new CompletionException(new StreamSegmentNotExistsException(segmentName)); } } }, this.executor); }
private SegmentHandle doOpenWrite(String streamSegmentName) throws StreamSegmentNotExistsException { long traceId = LoggerHelpers.traceEnter(log, "openWrite", streamSegmentName); Path path = Paths.get(config.getRoot(), streamSegmentName); if (!Files.exists(path)) { throw new StreamSegmentNotExistsException(streamSegmentName); } else if (Files.isWritable(path)) { LoggerHelpers.traceLeave(log, "openWrite", traceId); return FileSystemSegmentHandle.writeHandle(streamSegmentName); } else { LoggerHelpers.traceLeave(log, "openWrite", traceId); return FileSystemSegmentHandle.readHandle(streamSegmentName); } }
public void truncateDirectly(SegmentHandle handle, long offset) { if (!this.truncationOffsets.containsKey(handle.getSegmentName())) { throw new CompletionException(new StreamSegmentNotExistsException(handle.getSegmentName())); } this.truncationOffsets.put(handle.getSegmentName(), offset); }
@Override public CompletableFuture<Void> deleteStreamSegment(String streamSegmentName, Duration timeout) { ensureRunning(); logRequest("deleteStreamSegment", streamSegmentName); this.metrics.deleteSegment(); TimeoutTimer timer = new TimeoutTimer(timeout); long segmentId = this.metadata.getStreamSegmentId(streamSegmentName, false); SegmentMetadata toDelete = this.metadata.getStreamSegmentMetadata(segmentId); return this.metadataStore.deleteSegment(streamSegmentName, timer.getRemaining()) .thenAccept(deleted -> { if (!deleted) { // No segment to delete, which likely means Segment does not exist. throw new CompletionException(new StreamSegmentNotExistsException(streamSegmentName)); } if (toDelete != null) { // Notify any internal components that this Segment is no longer part of the metadata. notifyMetadataRemoved(Collections.singleton(toDelete)); } }); }
SegmentMetadata sm = this.containerMetadata.getStreamSegmentMetadata(streamSegmentId); if (sm.isDeleted()) { return Futures.failedFuture(new StreamSegmentNotExistsException(sm.getName()));