Java TaskExecutionException类代码示例

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private TaskResult processFinish(int result, Config state) {
    if (result != 0) {
        throw new TaskExecutionException(String.format(
                "retz_run: Job(id=%s) failed. " +
                        "| retz-info: state=%s, reason=%s " +
                        "| log: `digdag log %s %s`",
                state.get(STATE_JOB_ID, String.class),
                state.get(STATE_JOB_STATE, String.class), state.get(STATE_REASON, String.class),
                request.getAttemptId(), request.getTaskName()));
    }

    TaskResult taskResult = TaskResult.empty(request);
    taskResult.getStoreParams()
            .getNestedOrSetEmpty(RetzOperatorConfig.KEY_CONFIG_ROOT)
            .set("last_job_id", state.get(STATE_JOB_ID, String.class));

    return taskResult;
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private Job processSchedule(Client webClient, Config state) {
    Job job = createJob();
    Response res;
    try {
        res = webClient.schedule(job);
    } catch (IOException ex) {
        throw new RuntimeException("Failed to schedule Retz job", ex);
    }
    if (!(res instanceof ScheduleResponse)) {
        throw new TaskExecutionException(String.format(
                "Failed to schedule Retz job: %s",
                res.status()));
    }

    Job scheduled = ((ScheduleResponse) res).job();
    LOGGER.info("Job(id={}) scheduled: {}", scheduled.id(), scheduled.state());

    initializeTaskState(scheduled, state);

    return scheduled;
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private TaskExecutionException processGetFile(Job job, Client webClient, Config state) {

        switch(job.state()) {
            case QUEUED:
                checkTimeout(job, webClient);
                return nextPolling(state);
            case STARTING:
            case STARTED:
                checkTimeout(job, webClient);
                getWholeFileByState(job, webClient, "stdout", state);
                return nextPolling(state);
            case FINISHED:
            case KILLED:
                getWholeFileByState(job, webClient, "stdout", state);
                if (config.getVerbose()) {
                    LOGGER.info("Job(id={}) finished to get stdout, will get stderr", job.id());
                }
                getWholeFile(job, webClient, "stderr", 0);
                return finishJob(job, state);
            default:
                throw new IllegalStateException("unexpected status: " + job.state());
        }
    }
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private TaskExecutionException finishJob(Job job, Config state) {
    String duration = getDuration(job.started(), job.finished());

    LOGGER.info("Job(id={}) finished in {}. status: {}",
            job.id(), duration, job.state());

    state.set(STATE_RESULT_CODE, job.result());
    state.set(STATE_DURATION, duration);
    state.remove(STATE_POLL_ITERATION);
    state.remove(STATE_OFFSET);

    if (job.result() != 0) {
        state.set(STATE_REASON, job.reason());
    }

    return TaskExecutionException.ofNextPolling(0, ConfigElement.copyOf(state));
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private Job getJob(int id, Client webClient) {
    Response res;
    try {
        res = webClient.getJob(id);
    } catch (IOException ex) {
        throw Throwables.propagate(ex);
    }

    if (res instanceof GetJobResponse) {
        GetJobResponse getJobResponse = (GetJobResponse) res;
        if (getJobResponse.job().isPresent()) {
            return getJobResponse.job().get();
        } else {
            throw Throwables.propagate(new JobNotFoundException(id));
        }
    } else {
        throw new TaskExecutionException(String.format(
                "Job(id=%s) getJob received invalid response: %s",
                id, res.status()));
    }
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private void storeResultsInTaskResult(JdbcResultSet jdbcResultSet, StoreLastResultsOption option, ImmutableTaskResult.Builder builder)
{
    int columnsCount = jdbcResultSet.getColumnNames().size();
    if (columnsCount > maxStoreLastResultsColumns) {
        throw new TaskExecutionException("The number of result columns exceeded the limit: " + columnsCount + " > " + maxStoreLastResultsColumns);
    }

    Object lastResults;
    switch (option) {
    case ALL:
        lastResults = collectAllResults(jdbcResultSet);
        break;
    case FIRST:
        lastResults = collectFirstResults(jdbcResultSet);
        break;
    default:
        throw new AssertionError("Unexpected StoreLastResultsOption: " + option);
    }

    Config storeParams = request.getConfig().getFactory().create();
    storeParams.getNestedOrSetEmpty(type())
        .set("last_results", lastResults);
    builder.storeParams(storeParams);
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private List<Map<String, Object>> collectAllResults(JdbcResultSet jdbcResultSet)
{
    List<String> columnNames = jdbcResultSet.getColumnNames();
    ImmutableList.Builder<Map<String, Object>> lastResults = ImmutableList.builder();

    long rows = 0;
    while (true) {
        List<Object> values = jdbcResultSet.next();
        if (values == null) {
            break;
        }

        rows += 1;
        if (rows > maxStoreLastResultsRows) {
            throw new TaskExecutionException("The number of result rows exceeded the limit: " + rows + " > " + maxStoreLastResultsRows);
        }

        lastResults.add(buildResultsMap(columnNames, values));
    }

    return lastResults.build();
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private RuntimeException error(Request req, boolean uriIsSecret, Response res)
{
    if (HttpStatus.isClientError(res.getStatus())) {
        switch (res.getStatus()) {
            case HttpStatus.REQUEST_TIMEOUT_408:
            case HttpStatus.TOO_MANY_REQUESTS_429:
                // Retry these.
                return new RuntimeException("Failed HTTP request: " + requestStatus(req, res, uriIsSecret));
            default:
                // 4xx: The request is invalid for this resource. Fail hard without retrying.
                return new TaskExecutionException("HTTP 4XX Client Error: " + requestStatus(req, res, uriIsSecret));
        }
    }
    else if (res.getStatus() >= 500 && res.getStatus() < 600) {
        // 5xx: Server Error. This is hopefully ephemeral.
        return ephemeralError("HTTP 5XX Server Error: " + requestStatus(req, res, uriIsSecret));
    }
    else {
        // Unknown status code. Treat as an ephemeral error.
        return ephemeralError("Unexpected HTTP status: " + requestStatus(req, res, uriIsSecret));
    }
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private HttpClient client()
{
    boolean insecure = params.get("insecure", boolean.class, false);

    HttpClient httpClient = new HttpClient(new SslContextFactory(insecure));

    configureProxy(httpClient);

    boolean followRedirects = params.get("follow_redirects", boolean.class, true);

    httpClient.setFollowRedirects(followRedirects);
    httpClient.setMaxRedirects(maxRedirects);

    httpClient.setUserAgentField(new HttpField(
            USER_AGENT, userAgent + ' ' + httpClient.getUserAgentField().getValue()));

    try {
        httpClient.start();
    }
    catch (Exception e) {
        throw new TaskExecutionException(e);
    }
    return httpClient;
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private List<Config> fetchRows(TDJobOperator job)
{
    return PollingRetryExecutor.pollingRetryExecutor(state, RESULT)
            .retryUnless(TDOperator::isDeterministicClientException)
            .withErrorMessage("Failed to download result of job '%s'", job.getJobId())
            .run(s -> {
                List<String> columnNames = job.getResultColumnNames();
                List<Config> result = job.getResult(ite -> {
                    List<Config> rows = new ArrayList<>();
                    while (ite.hasNext()) {
                        rows.add(row(columnNames, ite.next().asArrayValue()));
                        if (rows.size() > Limits.maxWorkflowTasks()) {
                            TaskLimitExceededException cause = new TaskLimitExceededException("Too many tasks. Limit: " + Limits.maxWorkflowTasks());
                            throw new TaskExecutionException(cause);
                        }
                    }
                    return rows;
                });
                return result;
            });
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
private boolean fetchJobResult(TDJobOperator job)
{
    Optional<ArrayValue> firstRow = pollingRetryExecutor(state, RESULT)
            .retryUnless(TDOperator::isDeterministicClientException)
            .withErrorMessage("Failed to download result of job '%s'", job.getJobId())
            .run(s -> job.getResult(
                    ite -> ite.hasNext()
                            ? Optional.of(ite.next())
                            : Optional.absent()));

    // There must be at least one row in the result for the wait condition to be fulfilled.
    if (!firstRow.isPresent()) {
        return false;
    }

    ArrayValue row = firstRow.get();
    if (row.size() < 1) {
        throw new TaskExecutionException("Got empty row in result of query");
    }

    Value firstCol = row.get(0);
    return isTruthy(firstCol);
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
@Test
public void respondSlowlyThanTimeout() throws IOException {
	stubFor(get("/api/foobar")
			.willReturn(aResponse()
					.withStatus(200)
					.withFixedDelay(5000)));

	Operator op = factory.newOperator(newContext(
			tempPath,
			newTaskRequest().withConfig(config)));
	try {
		op.run();
		fail("should be thrown Exception.");
	} catch (TaskExecutionException ignore) {
	}
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
@Test
public void respondQuicklyThanTimeout() throws IOException {
	stubFor(get("/api/foobar")
			.willReturn(aResponse()
					.withStatus(200)
					.withFixedDelay(1000)));

	Operator op = factory.newOperator(newContext(
			tempPath,
			newTaskRequest().withConfig(config)));
	try {
		op.run();
	} catch (TaskExecutionException ignore) {
		fail("should be success.");
	}
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
@Test
public void testVersionId()
        throws Exception
{
    Config config = newConfig();
    config.set("_command", BUCKET + "/" + KEY);
    config.set("version_id", VERSION_ID);
    when(taskRequest.getConfig()).thenReturn(config);

    when(s3Secrets.getSecretOptional("region")).thenReturn(Optional.of(REGION));

    when(s3Client.getObjectMetadata(objectMetadataRequestCaptor.capture())).thenThrow(NOT_FOUND_EXCEPTION);

    Operator operator = factory.newOperator(newContext(projectPath, taskRequest));

    try {
        operator.run();
        fail();
    }
    catch (TaskExecutionException ignore) {
    }

    GetObjectMetadataRequest objectMetadataRequest = objectMetadataRequestCaptor.getValue();

    assertThat(objectMetadataRequest.getVersionId(), is(VERSION_ID));
}
 

import io.digdag.spi.TaskExecutionException; //导入依赖的package包/类
@Test
public void testSSEC()
        throws Exception
{
    Config config = newConfig();
    config.set("_command", BUCKET + "/" + KEY);
    when(taskRequest.getConfig()).thenReturn(config);

    when(s3Secrets.getSecretOptional("sse_c_key")).thenReturn(Optional.of(SSE_C_KEY));

    when(s3Client.getObjectMetadata(objectMetadataRequestCaptor.capture())).thenThrow(NOT_FOUND_EXCEPTION);

    Operator operator = factory.newOperator(newContext(projectPath, taskRequest));

    try {
        operator.run();
        fail();
    }
    catch (TaskExecutionException ignore) {
    }

    GetObjectMetadataRequest objectMetadataRequest = objectMetadataRequestCaptor.getValue();
    assertThat(objectMetadataRequest.getSSECustomerKey().getKey(), is(SSE_C_KEY));
    assertThat(objectMetadataRequest.getSSECustomerKey().getAlgorithm(), is("AES256"));
    assertThat(objectMetadataRequest.getSSECustomerKey().getMd5(), is(nullValue()));
}