@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()); }
@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 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> append(String logName, Event event, Duration timeout) { ensureRunning(); DurableDataLog log = this.logs.getOrDefault(logName, null); if (log == null) { return Futures.failedFuture(new StreamSegmentNotExistsException(logName)); } ArrayView s = event.getSerialization(); return Futures.toVoid(log.append(s, timeout)); }
@Override public CompletableFuture<DirectSegmentAccess> forSegment(String segmentName, Duration timeout) { Exceptions.checkNotClosed(this.closed.get(), this); SegmentMock segment = this.segment.get(); if (segment == null) { return Futures.failedFuture(new StreamSegmentNotExistsException(segmentName)); } Assert.assertEquals("Unexpected segment name.", segment.getInfo().getName(), segmentName); return CompletableFuture.supplyAsync(() -> segment, executorService()); }
@Override public CompletableFuture<Void> deleteStreamSegment(String segmentName, Duration timeout) { SegmentMock segment = this.segment.get(); if (segment == null) { return Futures.failedFuture(new StreamSegmentNotExistsException(segmentName)); } Assert.assertEquals("Unexpected segment name.", segment.getInfo().getName(), segmentName); Assert.assertTrue(this.segment.compareAndSet(segment, null)); return CompletableFuture.completedFuture(null); }
/** * Updates information about a Segment. * * @param segmentMetadata A {@link SegmentMetadata} that will be saved in the Metadata Store. * @param timeout Timeout for the operation. * @return A CompletableFuture that, when completed, will indicate the operation succeeded. */ CompletableFuture<Void> updateSegmentInfo(SegmentMetadata segmentMetadata, Duration timeout) { if (segmentMetadata.isMerged()) { return Futures.failedFuture(new StreamSegmentMergedException(segmentMetadata.getName())); } else if (segmentMetadata.isDeleted()) { return Futures.failedFuture(new StreamSegmentNotExistsException(segmentMetadata.getName())); } ArrayView toWrite = SegmentInfo.serialize(new SegmentInfo(segmentMetadata.getId(), segmentMetadata.getSnapshot())); return updateSegmentInfo(segmentMetadata.getName(), toWrite, timeout); }