public void setDriverStatus(DriverQueryStatus.DriverQueryState state, String message) { if (getDriverStatus().getState().getOrder() > state.getOrder()) { log.info("current driver status: {}, ignoring transition request to {}", getDriverStatus().getState(), state); return; case INITIALIZED: case PENDING: getDriverStatus().setProgress(0.0); case RUNNING: if (getDriverStatus().getDriverStartTime() == null || getDriverStatus().getDriverStartTime() <= 0) { getDriverStatus().setDriverStartTime(System.currentTimeMillis()); case FAILED: case CANCELED: getDriverStatus().setProgress(1.0); if (getDriverStatus().getDriverFinishTime() == null || getDriverStatus().getDriverFinishTime() <= 0) { getDriverStatus().setDriverFinishTime(System.currentTimeMillis()); getDriverStatus().setErrorMessage(message); } else { getDriverStatus().setStatusMessage(message); if (getDriverStatus().getStatusMessage() == null) { getDriverStatus().setStatusMessage("Query " + getQueryHandleString() + " " + state.name().toLowerCase()); getDriverStatus().setState(state);
private DriverQueryStatus updateDriverStateFromOperationStatus(OperationHandle handle, DriverQueryStatus status) throws LensException, HiveSQLException, IOException { if (status == null) { status = new DriverQueryStatus(); switch (opStatus.getState()) { case CANCELED: status.setState(DriverQueryState.CANCELED); status.setStatusMessage("Query has been cancelled!"); break; case CLOSED: status.setState(DriverQueryState.CLOSED); status.setStatusMessage("Query has been closed!"); break; case ERROR: status.setState(DriverQueryState.FAILED); status.setStatusMessage("Query execution failed!"); status.setErrorMessage( "Query failed with errorCode:" + opStatus.getOperationException().getErrorCode() + " with errorMessage: " + opStatus.getOperationException().getMessage()); break; case FINISHED: status.setState(DriverQueryState.SUCCESSFUL); status.setStatusMessage("Query is successful!"); status.setResultSetAvailable(handle.hasResultSet()); break; case INITIALIZED: status.setState(DriverQueryState.INITIALIZED); status.setStatusMessage("Query is initiazed in HiveServer!"); break;
checkConfigured(); JdbcQueryContext ctx = getQueryContext(context.getQueryHandle()); if (ctx.getLensContext().getDriverStatus().isFinished()) { if (!context.getDriverStatus().isCanceled()) { context.getDriverStatus().setProgress(1.0); context.getDriverStatus().setState(DriverQueryState.CANCELED); context.getDriverStatus().setStatusMessage("Query Canceled"); context.getDriverStatus().setProgress(1.0); if (!context.getDriverStatus().isFailed()) { context.getDriverStatus().setState(DriverQueryState.FAILED); context.getDriverStatus().setStatusMessage("Query execution failed!"); context.getDriverStatus().setErrorMessage(ctx.getQueryResult().error.getMessage()); if (!context.getDriverStatus().isFinished()) { context.getDriverStatus().setState(DriverQueryState.SUCCESSFUL); context.getDriverStatus().setStatusMessage(context.getQueryHandle() + " successful"); context.getDriverStatus().setResultSetAvailable(true); if (!context.getDriverStatus().isRunning()) { context.getDriverStatus().setState(DriverQueryState.RUNNING); context.getDriverStatus().setStatusMessage(context.getQueryHandle() + " is running");
public void extractFailedAttempt(LensDriver selectedDriver) { failedAttempts.add(new FailedAttempt(selectedDriver.getFullyQualifiedName(), getDriverStatus().getProgress(), getDriverStatus().getProgressMessage(), getDriverStatus().getErrorMessage(), getDriverStatus().getDriverStartTime(), getDriverStatus().getDriverFinishTime())); getDriverStatus().clear(); }
@Override public void updateStatus(QueryContext context) { final QueryHandle queryHandle = context.getQueryHandle(); final Future<LensResultSet> lensResultSetFuture = resultSetMap.get(queryHandle); if (lensResultSetFuture == null) { context.getDriverStatus().setState(DriverQueryStatus.DriverQueryState.CLOSED); context.getDriverStatus().setStatusMessage(queryHandle + " closed"); context.getDriverStatus().setResultSetAvailable(false); } else if (lensResultSetFuture.isDone()) { context.getDriverStatus().setState(DriverQueryStatus.DriverQueryState.SUCCESSFUL); context.getDriverStatus().setStatusMessage(queryHandle + " successful"); context.getDriverStatus().setResultSetAvailable(true); } else if (lensResultSetFuture.isCancelled()) { context.getDriverStatus().setState(DriverQueryStatus.DriverQueryState.CANCELED); context.getDriverStatus().setStatusMessage(queryHandle + " cancelled"); context.getDriverStatus().setResultSetAvailable(false); } }
@Override public void onDriverStatusUpdated(QueryHandle handle, DriverQueryStatus status) { switch (status.getState()) { case SUCCESSFUL: onCompletion(handle); break; case FAILED: onError(handle, status.getErrorMessage()); break; case CANCELED: onError(handle, "Query cancelled"); break; default: break; } } }
driver.registerForCompletionNotification(ctx, 0, listener); while (!ctx.getDriverStatus().isFinished()) { driver.updateStatus(ctx); System.out.println("Query: " + handle + " Status: " + ctx.getDriverStatus()); Thread.sleep(500); assertEquals(ctx.getDriverStatus().getState(), DriverQueryState.FAILED); assertEquals(ctx.getDriverStatus().getProgress(), 1.0); assertTrue(ctx.getDriverStatus().getDriverStartTime() > 0); assertTrue(ctx.getDriverStatus().getDriverFinishTime() > 0);
/** * Wait for async query. * * @param ctx the ctx * @param driver the driver * @throws Exception the exception */ private void waitForAsyncQuery(QueryContext ctx, HiveDriver driver) throws Exception { while (true) { driver.updateStatus(ctx); System.out.println("#W Waiting for query " + ctx.getQueryHandle() + " status: " + ctx.getDriverStatus().getState()); assertNotNull(ctx.getDriverStatus()); if (ctx.getDriverStatus().isFinished()) { assertTrue(ctx.getDriverStatus().getDriverFinishTime() > 0); break; } System.out.println("Progress:" + ctx.getDriverStatus().getProgressMessage()); Thread.sleep(1000); assertTrue(ctx.getDriverStatus().getDriverStartTime() > 0); } }
/** * To lens query. * * @return the lens query */ public LensQuery toLensQuery() { return new LensQuery(queryHandle, userQuery, super.getSubmittedUser(), getPriority(), isPersistent, getSelectedDriver() != null ? getSelectedDriver().getFullyQualifiedName() : null, getSelectedDriverQuery(), status, resultSetPath, driverOpHandle, lensConf, submissionTime, launchTime, driverStatus.getDriverStartTime(), driverStatus.getDriverFinishTime(), endTime, closedTime, queryName, getFailedAttempts()); }
context.getDriverStatus().setState(DriverQueryState.RUNNING); } else { context.getDriverStatus().setState(DriverQueryState.CANCELED); context.getDriverStatus().setDriverFinishTime(System.currentTimeMillis()); context.getDriverStatus().setProgress(1.0); context.getDriverStatus().setStatusMessage("Done"); context.getDriverStatus().setState(DriverQueryState.SUCCESSFUL); context.getDriverStatus().setDriverFinishTime(System.currentTimeMillis());
/** * Validate execute async. * * @param ctx the ctx * @param finalState the final state * @param isPersistent the is persistent * @param formatNulls the format nulls * @param driver the driver * @throws Exception the exception */ protected void validateExecuteAsync(QueryContext ctx, DriverQueryState finalState, boolean isPersistent, boolean formatNulls, HiveDriver driver) throws Exception { waitForAsyncQuery(ctx, driver); driver.updateStatus(ctx); assertEquals(ctx.getDriverStatus().getState(), finalState, "Expected query to finish with" + finalState); assertTrue(ctx.getDriverStatus().getDriverFinishTime() > 0); if (finalState.equals(DriverQueryState.SUCCESSFUL)) { System.out.println("Progress:" + ctx.getDriverStatus().getProgressMessage()); assertNotNull(ctx.getDriverStatus().getProgressMessage()); if (!isPersistent) { validateInMemoryResult(driver.fetchResultSet(ctx)); } else { validatePersistentResult(driver.fetchResultSet(ctx), TEST_DATA_FILE, ctx.getHDFSResultDir(), formatNulls); } } else if (finalState.equals(DriverQueryState.FAILED)) { System.out.println("Error:" + ctx.getDriverStatus().getErrorMessage()); System.out.println("Status:" + ctx.getDriverStatus().getStatusMessage()); assertNotNull(ctx.getDriverStatus().getErrorMessage()); } }
if (queryContext.getLensContext().getDriverStatus().isCanceled()) { return result; result.resultSet = stmt.getResultSet(); queryContext.getLensContext().getDriverStatus().setResultSetAvailable(isResultAvailable); queryContext.getLensContext().setDriverStatus(DriverQueryState.SUCCESSFUL); } catch (Exception e) { if (queryContext.getLensContext().getDriverStatus().isCanceled()) { return result; Long endTime = queryContext.getLensContext().getDriverStatus().getDriverFinishTime(); if (endTime == null || endTime <= 0) { queryContext.getLensContext().getDriverStatus().setDriverFinishTime(System.currentTimeMillis());
@Override public void updateStatus(QueryContext context) throws LensException { if (context.getFailedAttempts().size() < numRetries) { String errorMessage = getDriverProperty(context, "error.message"); if (errorMessage == null) { errorMessage = "Simulated Failure"; } context.getDriverStatus().setState(DriverQueryStatus.DriverQueryState.FAILED); context.getDriverStatus().setErrorMessage(errorMessage); } else { context.getDriverStatus().setState(DriverQueryStatus.DriverQueryState.SUCCESSFUL); } context.getDriverStatus().setDriverFinishTime(System.currentTimeMillis()); }
/** * Test cancel query. * * @throws Exception the exception */ @Test(dataProvider = "waitBeforeCancel") public void testCancelQuery(boolean waitBeforeCancel) throws Exception { setupCancelQuery(); // picked function as positive with udf mapping to sleep - sothat the signature of both are same. // Here we need a UDF mapping because the function sleep is not available in Hive functions and semantic analysis // would fail otherwise. final String query = "SELECT positive(5) FROM cancel_query_test"; QueryContext context = createQueryContext(query); System.out.println("@@@ test_cancel:" + context.getQueryHandle()); executeAsync(context); QueryHandle handle = context.getQueryHandle(); // without wait query may not be launched. if (waitBeforeCancel) { Thread.sleep(1000); } boolean isCancelled = driver.cancelQuery(handle); driver.updateStatus(context); assertTrue(isCancelled); assertEquals(context.getDriverStatus().getState(), DriverQueryState.CANCELED); assertTrue(context.getDriverStatus().getDriverStartTime() > 0); assertTrue(context.getDriverStatus().getDriverFinishTime() > 0); driver.closeQuery(handle); }
public QueryContext toQueryContext(Configuration conf, Collection<LensDriver> drivers) { if (null == selectedDriver && null != driverName) { selectedDriver = getDriverFromName(drivers); } QueryContext qctx = new QueryContext(userQuery, submitter, this.conf, conf, drivers, selectedDriver, submissionTime, false); qctx.setQueryHandle(QueryHandle.fromString(handle)); qctx.setLaunchTime(this.startTime); qctx.setEndTime(getEndTime()); qctx.setStatusSkippingTransitionTest(new QueryStatus(0.0, null, QueryStatus.Status.valueOf(getStatus()), null, getResult() != null, null, getErrorMessage() == null ? "" : getErrorMessage(), null)); qctx.getDriverStatus().setDriverStartTime(getDriverStartTime()); qctx.getDriverStatus().setDriverFinishTime(getDriverEndTime()); qctx.setResultSetPath(getResult()); qctx.setQueryName(getQueryName()); if (null != driverQuery){ qctx.setSelectedDriverQuery(driverQuery); } if (getPriority() != null) { qctx.setPriority(Priority.valueOf(getPriority())); } qctx.setFailedAttempts(getFailedAttempts()); return qctx; }
@Override public void run() { SessionState.setCurrentSessionState(state); for (int i = 0; i < 1000; i++) { try { thrDriver.updateStatus(qctx); if (qctx.getDriverStatus().isFinished()) { log.info("@@ " + handle.getHandleId() + " >> " + qctx.getDriverStatus().getState()); break; } Thread.sleep(POLL_DELAY); } catch (LensException e) { log.error("Got Exception " + e.getCause(), e); errCount.incrementAndGet(); break; } catch (InterruptedException e) { log.error("Encountred Interrupted exception", e); break; } } } });
@Test public void testSingleRetrySameDriver() throws LensException, InterruptedException { QueryHandle handle = getQueryService().executeAsync(session, "select 1", getLensConf("driver.retry/single_failure.cost", "1", "driver.retry/double_failure.cost", "2"), "random query"); QueryContext ctx = getQueryService().getQueryContext(handle); while (!ctx.getStatus().finished()) { ctx = getQueryService().getQueryContext(handle); Thread.sleep(1000); } assertEquals(ctx.getFailedAttempts().size(), 1); FailedAttempt failedAttempt = ctx.getFailedAttempts().get(0); assertEquals(failedAttempt.getDriverName(), "retry/single_failure"); assertEquals(ctx.getSelectedDriver().getFullyQualifiedName(), "retry/single_failure"); assertTrue(failedAttempt.getDriverFinishTime() > failedAttempt.getDriverStartTime()); assertTrue(ctx.getDriverStatus().getDriverStartTime() > failedAttempt.getDriverFinishTime()); }
@Override public void updateStatus(QueryContext context) throws LensException { log.debug("GetStatus: {}", context.getQueryHandle()); if (context.getDriverStatus().isFinished()) { return; } OperationHandle hiveHandle = getHiveHandle(context.getQueryHandle()); try { // Get operation status from hive server log.debug("GetStatus hiveHandle: {}", hiveHandle); fetchLogs(hiveHandle); updateDriverStateFromOperationStatus(hiveHandle, context.getDriverStatus()); } catch (Exception e) { log.error("Error getting query status", e); handleHiveServerError(context, e); throw new LensException("Error getting query status", e); } }
long softExpiryTime = ctx.getDriverStatus().getDriverFinishTime() + queryService.getInMemoryResultsetTTLMillis() - 1000; //Keeping buffer of 1 secs int checkCount = 0;
private BackOffRetryHandler<QueryContext> getDriverRetryPolicy(QueryContext ctx) { if (ctx.getDriverRetryPolicy() == null) { String errorMessage = ctx.getDriverStatus().getErrorMessage() != null ? ctx.getDriverStatus().getErrorMessage() : ctx.getStatus().getErrorMessage(); ctx.setDriverRetryPolicy(ctx.getSelectedDriver().getRetryPolicyDecider() .decidePolicy(errorMessage)); } return ctx.getDriverRetryPolicy(); }