@Override public boolean needsInput() { if (finishing || outputPage != null) { return false; } if (channelSet == null) { channelSet = tryGetFutureValue(channelSetFuture).orElse(null); } return channelSet != null; }
@Override public boolean needsInput() { if (finishing || probePage != null) { return false; } if (buildPages == null) { Optional<NestedLoopJoinPages> nestedLoopJoinPages = tryGetFutureValue(nestedLoopJoinPagesFuture); if (nestedLoopJoinPages.isPresent()) { buildPages = nestedLoopJoinPages.get().getPages(); } } return buildPages != null; }
private static <T> T requireFutureValue(Future<T> future) { return tryGetFutureValue(future).orElseThrow(AssertionError::new); }
static void assertFutureIsDone(Future<?> future) { tryGetFutureValue(future, 5, SECONDS); assertTrue(future.isDone()); }
static BufferResult getFuture(ListenableFuture<BufferResult> future, Duration maxWait) { Optional<BufferResult> bufferResult = tryGetFutureValue(future, (int) maxWait.toMillis(), MILLISECONDS); checkArgument(bufferResult.isPresent(), "bufferResult is empty"); return bufferResult.get(); }
private static SerializedPage getNextPage(ExchangeClient exchangeClient) { ListenableFuture<SerializedPage> futurePage = Futures.transform(exchangeClient.isBlocked(), ignored -> exchangeClient.pollPage(), directExecutor()); return tryGetFutureValue(futurePage, 100, TimeUnit.SECONDS).orElse(null); }
Optional<String> errorMessage = tryGetFutureValue(readStderr, 100, MILLISECONDS) .flatMap(value -> Optional.ofNullable(emptyToNull(value.trim())));
private static SettableFuture<State> addTestListener(StateMachine<State> stateMachine) { State initialState = stateMachine.get(); SettableFuture<Boolean> initialStateNotified = SettableFuture.create(); SettableFuture<State> stateChanged = SettableFuture.create(); Thread addingThread = Thread.currentThread(); stateMachine.addStateChangeListener(newState -> { Thread callbackThread = Thread.currentThread(); if (callbackThread == addingThread) { stateChanged.setException(new AssertionError("Listener was not called back on a different thread")); return; } if (newState == initialState) { initialStateNotified.set(true); } else { stateChanged.set(newState); } }); assertTrue(tryGetFutureValue(initialStateNotified, 10, SECONDS).isPresent(), "Initial state notification not fired"); return stateChanged; }
private static boolean handledBlocked(Operator operator) { ListenableFuture<?> isBlocked = operator.isBlocked(); if (!isBlocked.isDone()) { tryGetFutureValue(isBlocked, 1, TimeUnit.MILLISECONDS); return true; } return false; }
@Test public void testFinished() { QueryStateMachine stateMachine = createQueryStateMachine(); assertTrue(stateMachine.transitionToFinishing()); tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); assertFinalState(stateMachine, FINISHED); }
outerPositions = tryGetFutureValue(outerPositionsFuture).orElse(null); if (outerPositions == null) { return null;
@Test public void testBasicStateChanges() { QueryStateMachine stateMachine = createQueryStateMachine(); assertState(stateMachine, QUEUED); assertTrue(stateMachine.transitionToPlanning()); assertState(stateMachine, PLANNING); assertTrue(stateMachine.transitionToStarting()); assertState(stateMachine, STARTING); assertTrue(stateMachine.transitionToRunning()); assertState(stateMachine, RUNNING); assertTrue(stateMachine.transitionToFinishing()); tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); assertState(stateMachine, FINISHED); }
@Test public void testStateChangesWithResourceWaiting() { QueryStateMachine stateMachine = createQueryStateMachine(); assertState(stateMachine, QUEUED); assertTrue(stateMachine.transitionToWaitingForResources()); assertState(stateMachine, WAITING_FOR_RESOURCES); assertTrue(stateMachine.transitionToPlanning()); assertState(stateMachine, PLANNING); assertTrue(stateMachine.transitionToStarting()); assertState(stateMachine, STARTING); assertTrue(stateMachine.transitionToRunning()); assertState(stateMachine, RUNNING); assertTrue(stateMachine.transitionToFinishing()); tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); assertState(stateMachine, FINISHED); }
tryGetFutureValue(whenAnyComplete(blockedStages), 1, SECONDS);
@Test public void testRunning() { QueryStateMachine stateMachine = createQueryStateMachine(); assertTrue(stateMachine.transitionToRunning()); assertState(stateMachine, RUNNING); assertFalse(stateMachine.transitionToPlanning()); assertState(stateMachine, RUNNING); assertFalse(stateMachine.transitionToStarting()); assertState(stateMachine, RUNNING); assertFalse(stateMachine.transitionToRunning()); assertState(stateMachine, RUNNING); assertTrue(stateMachine.transitionToFinishing()); tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); assertState(stateMachine, FINISHED); stateMachine = createQueryStateMachine(); stateMachine.transitionToRunning(); assertTrue(stateMachine.transitionToFailed(FAILED_CAUSE)); assertState(stateMachine, FAILED, FAILED_CAUSE); }
@Test public void testStarting() { QueryStateMachine stateMachine = createQueryStateMachine(); assertTrue(stateMachine.transitionToStarting()); assertState(stateMachine, STARTING); assertFalse(stateMachine.transitionToPlanning()); assertState(stateMachine, STARTING); assertFalse(stateMachine.transitionToStarting()); assertState(stateMachine, STARTING); assertTrue(stateMachine.transitionToRunning()); assertState(stateMachine, RUNNING); stateMachine = createQueryStateMachine(); stateMachine.transitionToStarting(); assertTrue(stateMachine.transitionToFinishing()); tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); assertState(stateMachine, FINISHED); stateMachine = createQueryStateMachine(); stateMachine.transitionToStarting(); assertTrue(stateMachine.transitionToFailed(FAILED_CAUSE)); assertState(stateMachine, FAILED, FAILED_CAUSE); }
@Test public void testPlanning() { QueryStateMachine stateMachine = createQueryStateMachine(); assertTrue(stateMachine.transitionToPlanning()); assertState(stateMachine, PLANNING); assertFalse(stateMachine.transitionToPlanning()); assertState(stateMachine, PLANNING); assertTrue(stateMachine.transitionToStarting()); assertState(stateMachine, STARTING); stateMachine = createQueryStateMachine(); stateMachine.transitionToPlanning(); assertTrue(stateMachine.transitionToRunning()); assertState(stateMachine, RUNNING); stateMachine = createQueryStateMachine(); stateMachine.transitionToPlanning(); assertTrue(stateMachine.transitionToFinishing()); tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); assertState(stateMachine, FINISHED); stateMachine = createQueryStateMachine(); stateMachine.transitionToPlanning(); assertTrue(stateMachine.transitionToFailed(FAILED_CAUSE)); assertState(stateMachine, FAILED, FAILED_CAUSE); }
@Test public void testQueued() { // all time before the first state transition is accounted to queueing assertAllTimeSpentInQueueing(QUEUED, queryStateMachine -> {}); assertAllTimeSpentInQueueing(WAITING_FOR_RESOURCES, QueryStateMachine::transitionToWaitingForResources); assertAllTimeSpentInQueueing(PLANNING, QueryStateMachine::transitionToPlanning); assertAllTimeSpentInQueueing(STARTING, QueryStateMachine::transitionToStarting); assertAllTimeSpentInQueueing(RUNNING, QueryStateMachine::transitionToRunning); assertAllTimeSpentInQueueing(FINISHED, stateMachine -> { stateMachine.transitionToFinishing(); tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); }); assertAllTimeSpentInQueueing(FAILED, stateMachine -> stateMachine.transitionToFailed(FAILED_CAUSE)); }
tryGetFutureValue(stateMachine.getStateChange(FINISHING), 2, SECONDS); assertState(stateMachine, FINISHED);
assertPageEquals(getNextPage(exchangeClient), createPage(3)); assertFalse(tryGetFutureValue(exchangeClient.isBlocked(), 10, MILLISECONDS).isPresent()); assertEquals(exchangeClient.isClosed(), false); assertPageEquals(getNextPage(exchangeClient), createPage(6)); assertFalse(tryGetFutureValue(exchangeClient.isBlocked(), 10, MILLISECONDS).isPresent()); assertEquals(exchangeClient.isClosed(), false);