private CompletableFuture<Void> checkReady() { if (!ready) { return Futures.failedFuture(new IllegalStateException(getClass().getName() + " not yet ready")); } else { return CompletableFuture.completedFuture(null); } }
@Override public CompletableFuture<Void> createStreamSegment(String streamSegmentName, Collection<AttributeUpdate> attributes, Duration timeout) { if (this.segments.add(streamSegmentName)) { return CompletableFuture.completedFuture(null); } else { return Futures.failedFuture(new StreamSegmentExistsException(streamSegmentName)); } }
@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)); } }
@Override CompletableFuture<Data> getCompletedTx(UUID txId) { Preconditions.checkNotNull(txId); synchronized (txnsLock) { Data value = completedTxns.getIfPresent(txId.toString()); if (value == null) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, "Stream: " + getName() + " Transaction: " + txId.toString())); } return CompletableFuture.completedFuture(copy(value)); } }
@Override @Synchronized public CompletableFuture<String> getScopeConfiguration(final String scopeName) { if (scopes.containsKey(scopeName)) { return CompletableFuture.completedFuture(scopeName); } else { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, scopeName)); } }
@Override CompletableFuture<Data> getActiveTx(int epoch, UUID txId) { synchronized (txnsLock) { if (!activeTxns.containsKey(txId.toString())) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, "Stream: " + getName() + " Transaction: " + txId.toString())); } return CompletableFuture.completedFuture(copy(activeTxns.get(txId.toString()))); } }
@Override public CompletableFuture<Void> process(RequestProcessor processor) { return Futures.failedFuture(new RuntimeException("This should not be called")); } }
@Override CompletableFuture<Data> getStreamCutRecordData(long recordingTime) { synchronized (lock) { if (!this.streamCutRecords.containsKey(recordingTime)) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, getName())); } return CompletableFuture.completedFuture(copy(streamCutRecords.get(recordingTime))); } }
@Override CompletableFuture<Data> getSealedSegmentSizesMapShardData(int shard) { synchronized (lock) { if (!this.sealedSegmentsShards.containsKey(shard)) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, getName())); } return CompletableFuture.completedFuture(copy(sealedSegmentsShards.get(shard))); } }
@Override CompletableFuture<Data> getMarkerData(long segmentId) { synchronized (markersLock) { if (!markers.containsKey(segmentId)) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, "Stream: " + getName() + " Segment: " + segmentId)); } return CompletableFuture.completedFuture(copy(markers.get(segmentId))); } }
@Override CompletableFuture<Data> getHistoryTimeSeriesChunkData(int chunkNumber, boolean ignoreCached) { synchronized (lock) { if (!this.historyTimeSeries.containsKey(chunkNumber)) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, getName())); } return CompletableFuture.completedFuture(copy(historyTimeSeries.get(chunkNumber))); } }
@Override CompletableFuture<Data> getEpochRecordData(int epoch) { synchronized (lock) { if (!this.epochRecords.containsKey(epoch)) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, getName())); } return CompletableFuture.completedFuture(copy(this.epochRecords.get(epoch))); } }
@Override public CompletableFuture<Void> handleFailedProcess(String failedHost) { if (!transactionMetadataTasks.isReady()) { return Futures.failedFuture(new IllegalStateException(getClass().getName() + " not yet ready")); } log.info("Host={}, sweeping orphaned transactions", failedHost); CompletableFuture<Void> delay = Futures.delayedFuture(Duration.ofMillis(2 * maxTxnTimeoutMillis), executor); return delay.thenComposeAsync(x -> withRetriesAsync(() -> sweepOrphanedTxnsWithoutDelay(failedHost), RETRYABLE_PREDICATE, Integer.MAX_VALUE, executor)); }
@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 CompletableFuture<Data> getConfigurationData(boolean ignoreCached) { synchronized (lock) { if (this.configuration == null) { return Futures.failedFuture(StoreException.create(StoreException.Type.DATA_NOT_FOUND, getName())); } return CompletableFuture.completedFuture(copy(this.configuration)); } }
@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)); } }
@SneakyThrows private List<CompletableFuture<Void>> getWriteResultSequence(int count) { List<CompletableFuture<Void>> ackFutures = new ArrayList<>(); for (int i = 0; i < count; i++) { CompletableFuture<Void> spy = spy(CompletableFuture.completedFuture(null)); Mockito.when(spy.get()).thenThrow(InterruptedException.class); ackFutures.add(spy); ackFutures.add(Futures.failedFuture(new WriteFailedException())); ackFutures.add(CompletableFuture.completedFuture(null)); } return ackFutures; }
@Override public CompletableFuture<Void> process(RequestProcessor processor) { state.compareAndSet("ACTIVE", "STATE2"); if (state.get().equals("STATE2")) { return CompletableFuture.completedFuture(null) .thenAccept(x -> state.compareAndSet("STATE2", "ACTIVE")) .thenAccept(x -> result2.complete(null)); } else { return Futures.failedFuture(new OperationDisallowedException()); } } }
@Override public CompletableFuture<Void> process(RequestProcessor processor) { state.compareAndSet("ACTIVE", "STATE3"); if (state.get().equals("STATE3")) { return CompletableFuture.completedFuture(null) .thenAccept(x -> state.compareAndSet("STATE3", "ACTIVE")) .thenAccept(x -> result3.complete(null)); } else { return Futures.failedFuture(new OperationDisallowedException()); } } }
@Override public CompletableFuture<UUID> answer(InvocationOnMock invocation) throws Throwable { // first time throw exception. if (count.getAndIncrement() == 0) { return Futures.failedFuture(StoreException.create(StoreException.Type.WRITE_CONFLICT, "write conflict on counter update")); } // subsequent times call origin method @SuppressWarnings("unchecked") CompletableFuture<UUID> future = (CompletableFuture<UUID>) invocation.callRealMethod(); return future; } }).when(streamStoreMock).generateTransactionId(eq(SCOPE), eq(STREAM), any(), any());