@Override public boolean isDone() { return getState().isDone(); }
@JsonProperty public boolean isFinalQueryInfo() { return state.isDone() && getAllStages(outputStage).stream().allMatch(StageInfo::isFinalStageInfo); }
@Override public boolean isDone() { return getState().isDone(); }
@Override public boolean isDone() { return getState().isDone(); }
public boolean isDone() { return queryState.get().isDone(); }
private ListenableFuture<?> queryDoneFuture(QueryState currentState) { if (currentState.isDone()) { return immediateFuture(null); } return Futures.transformAsync(queryManager.getStateChange(queryId, currentState), this::queryDoneFuture, directExecutor()); }
@GET @Produces(MediaType.APPLICATION_JSON) public List<QueryStateInfo> getQueryStateInfos(@QueryParam("user") String user) { List<BasicQueryInfo> queryInfos = queryManager.getQueries(); if (!isNullOrEmpty(user)) { queryInfos = queryInfos.stream() .filter(queryInfo -> Pattern.matches(user, queryInfo.getSession().getUser())) .collect(toImmutableList()); } return queryInfos.stream() .filter(queryInfo -> !queryInfo.getState().isDone()) .map(this::getQueryStateInfo) .collect(toImmutableList()); }
public static QueryStateInfo createQueryStateInfo(BasicQueryInfo queryInfo, Optional<ResourceGroupId> group) { Optional<QueryProgressStats> progress = Optional.empty(); if (!queryInfo.getState().isDone() && queryInfo.getState() != QUEUED) { progress = Optional.of(createQueryProgressStats(queryInfo.getQueryStats())); } return createQueryStateInfo(queryInfo, group, Optional.empty(), progress); }
private Response failQuery(QueryId queryId, PrestoException queryException) { requireNonNull(queryId, "queryId is null"); try { QueryState state = queryManager.getQueryState(queryId); // check before killing to provide the proper error code (this is racy) if (state.isDone()) { return Response.status(Status.CONFLICT).build(); } queryManager.failQuery(queryId, queryException); // verify if the query was failed (if not, we lost the race) if (!queryException.getErrorCode().equals(queryManager.getQueryInfo(queryId).getErrorCode())) { return Response.status(Status.CONFLICT).build(); } return Response.status(Status.OK).build(); } catch (NoSuchElementException e) { return Response.status(Status.GONE).build(); } }
private void addStatsListeners(QueryExecution queryExecution) { Object lock = new Object(); // QUEUED is the initial state, the counter can be incremented immediately stats.queryQueued(); AtomicBoolean started = new AtomicBoolean(); queryExecution.addStateChangeListener(newValue -> { synchronized (lock) { if (newValue == RUNNING && !started.getAndSet(true)) { stats.queryStarted(); } } }); AtomicBoolean stopped = new AtomicBoolean(); queryExecution.addStateChangeListener(newValue -> { synchronized (lock) { if (newValue.isDone() && !stopped.getAndSet(true) && started.get()) { stats.queryStopped(); } } }); }
@Override public boolean isDone() { return getState().isDone(); }
private void transitionToFinished() { cleanupQueryQuietly(); queryStateTimer.endQuery(); queryState.setIf(FINISHED, currentState -> !currentState.isDone()); }
private synchronized void closeExchangeClientIfNecessary(QueryInfo queryInfo) { // Close the exchange client if the query has failed, or if the query // is done and it does not have an output stage. The latter happens // for data definition executions, as those do not have output. if ((queryInfo.getState() == FAILED) || (queryInfo.getState().isDone() && !queryInfo.getOutputStage().isPresent())) { exchangeClient.close(); } }
private void cancelAllQueries() { QueryManager queryManager = coordinator.getQueryManager(); for (BasicQueryInfo queryInfo : queryManager.getQueries()) { if (!queryInfo.getState().isDone()) { queryManager.cancelQuery(queryInfo.getQueryId()); } } }
public boolean transitionToFailed(Throwable throwable) { cleanupQueryQuietly(); queryStateTimer.endQuery(); // NOTE: The failure cause must be set before triggering the state change, so // listeners can observe the exception. This is safe because the failure cause // can only be observed if the transition to FAILED is successful. requireNonNull(throwable, "throwable is null"); failureCause.compareAndSet(null, toFailure(throwable)); boolean failed = queryState.setIf(FAILED, currentState -> !currentState.isDone()); if (failed) { QUERY_STATE_LOG.debug(throwable, "Query %s failed", queryId); session.getTransactionId().ifPresent(transactionId -> { if (transactionManager.isAutoCommit(transactionId)) { transactionManager.asyncAbort(transactionId); } else { transactionManager.fail(transactionId); } }); } else { QUERY_STATE_LOG.debug(throwable, "Failure after query %s finished", queryId); } return failed; }
public boolean transitionToCanceled() { cleanupQueryQuietly(); queryStateTimer.endQuery(); // NOTE: The failure cause must be set before triggering the state change, so // listeners can observe the exception. This is safe because the failure cause // can only be observed if the transition to FAILED is successful. failureCause.compareAndSet(null, toFailure(new PrestoException(USER_CANCELED, "Query was canceled"))); boolean canceled = queryState.setIf(FAILED, currentState -> !currentState.isDone()); if (canceled) { session.getTransactionId().ifPresent(transactionId -> { if (transactionManager.isAutoCommit(transactionId)) { transactionManager.asyncAbort(transactionId); } else { transactionManager.fail(transactionId); } }); } return canceled; }
private static void assertFinalState(QueryStateMachine stateMachine, QueryState expectedState, Exception expectedException) { assertTrue(expectedState.isDone()); assertState(stateMachine, expectedState, expectedException); assertFalse(stateMachine.transitionToPlanning()); assertState(stateMachine, expectedState, expectedException); assertFalse(stateMachine.transitionToStarting()); assertState(stateMachine, expectedState, expectedException); assertFalse(stateMachine.transitionToRunning()); assertState(stateMachine, expectedState, expectedException); assertFalse(stateMachine.transitionToFinishing()); assertState(stateMachine, expectedState, expectedException); assertFalse(stateMachine.transitionToFailed(FAILED_CAUSE)); assertState(stateMachine, expectedState, expectedException); // attempt to fail with another exception, which will fail assertFalse(stateMachine.transitionToFailed(new IOException("failure after finish"))); assertState(stateMachine, expectedState, expectedException); }
private void waitForQueryToBeKilled(DistributedQueryRunner queryRunner) throws InterruptedException { while (true) { for (BasicQueryInfo info : queryRunner.getCoordinator().getQueryManager().getQueries()) { if (info.getState().isDone()) { assertNotNull(info.getErrorCode()); assertEquals(info.getErrorCode().getCode(), CLUSTER_OUT_OF_MEMORY.toErrorCode().getCode()); return; } } MILLISECONDS.sleep(10); } }
public static Query create( SessionContext sessionContext, String query, QueryManager queryManager, SessionPropertyManager sessionPropertyManager, ExchangeClient exchangeClient, Executor dataProcessorExecutor, ScheduledExecutorService timeoutExecutor, BlockEncodingSerde blockEncodingSerde) { Query result = new Query(sessionContext, query, queryManager, sessionPropertyManager, exchangeClient, dataProcessorExecutor, timeoutExecutor, blockEncodingSerde); // register listeners after submission finishes addSuccessCallback(result.submissionFuture, () -> { result.queryManager.addOutputInfoListener(result.getQueryId(), result::setQueryOutputInfo); result.queryManager.addStateChangeListener(result.getQueryId(), state -> { if (state.isDone()) { QueryInfo queryInfo = queryManager.getFullQueryInfo(result.getQueryId()); result.closeExchangeClientIfNecessary(queryInfo); } }); }); return result; }
@UsedByGeneratedCode public void killQuery(String queryId, String message) { QueryId query = parseQueryId(queryId); try { QueryState state = queryManager.getQueryState(query); // check before killing to provide the proper error message (this is racy) if (state.isDone()) { throw new PrestoException(NOT_SUPPORTED, "Target query is not running: " + queryId); } queryManager.failQuery(query, createKillQueryException(message)); // verify if the query was killed (if not, we lost the race) if (!ADMINISTRATIVELY_KILLED.toErrorCode().equals(queryManager.getQueryInfo(query).getErrorCode())) { throw new PrestoException(NOT_SUPPORTED, "Target query is not running: " + queryId); } } catch (NoSuchElementException e) { throw new PrestoException(NOT_FOUND, "Target query not found: " + queryId); } }