org.apache.flink.runtime.jobmaster.JobResult Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.flink.runtime.jobmaster;

import org.apache.flink.annotation.Internal;
import org.apache.flink.api.common.JobExecutionResult;
import org.apache.flink.api.common.JobID;
import org.apache.flink.api.common.accumulators.AccumulatorHelper;
import org.apache.flink.runtime.dispatcher.Dispatcher;
import org.apache.flink.runtime.executiongraph.AccessExecutionGraph;
import org.apache.flink.runtime.executiongraph.ErrorInfo;
import org.apache.flink.runtime.jobgraph.JobStatus;
import org.apache.flink.util.FlinkException;
import org.apache.flink.util.OptionalFailure;
import org.apache.flink.util.SerializedThrowable;
import org.apache.flink.util.SerializedValue;

import javax.annotation.Nullable;

import java.io.IOException;
import java.io.Serializable;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;

import static java.util.Objects.requireNonNull;
import static org.apache.flink.util.Preconditions.checkArgument;

/**
 * Similar to {@link org.apache.flink.api.common.JobExecutionResult} but with an optional
 * {@link SerializedThrowable} when the job failed.
 *
 * This is used by the {@link JobMaster} to send the results to the {@link Dispatcher}.
 */
public class JobResult implements Serializable {

	private static final long serialVersionUID = 1L;

	private final JobID jobId;

	private final Map>> accumulatorResults;

	private final long netRuntime;

	/** Stores the cause of the job failure, or {@code null} if the job finished successfully. */
	@Nullable
	private final SerializedThrowable serializedThrowable;

	private JobResult(
			final JobID jobId,
			final Map>> accumulatorResults,
			final long netRuntime,
			@Nullable final SerializedThrowable serializedThrowable) {

		checkArgument(netRuntime >= 0, "netRuntime must be greater than or equals 0");

		this.jobId = requireNonNull(jobId);
		this.accumulatorResults = requireNonNull(accumulatorResults);
		this.netRuntime = netRuntime;
		this.serializedThrowable = serializedThrowable;
	}

	/**
	 * Returns {@code true} if the job finished successfully.
	 */
	public boolean isSuccess() {
		return serializedThrowable == null;
	}

	public JobID getJobId() {
		return jobId;
	}

	public Map>> getAccumulatorResults() {
		return accumulatorResults;
	}

	public long getNetRuntime() {
		return netRuntime;
	}

	/**
	 * Returns an empty {@code Optional} if the job finished successfully, otherwise the
	 * {@code Optional} will carry the failure cause.
	 */
	public Optional getSerializedThrowable() {
		return Optional.ofNullable(serializedThrowable);
	}

	/**
	 * Converts the {@link JobResult} to a {@link JobExecutionResult}.
	 *
	 * @param classLoader to use for deserialization
	 * @return JobExecutionResult
	 * @throws WrappedJobException if the JobResult contains a serialized exception
	 * @throws IOException if the accumulator could not be deserialized
	 * @throws ClassNotFoundException if the accumulator could not deserialized
	 */
	public JobExecutionResult toJobExecutionResult(ClassLoader classLoader) throws WrappedJobException, IOException, ClassNotFoundException {
		if (serializedThrowable != null) {
			final Throwable throwable = serializedThrowable.deserializeError(classLoader);
			throw new WrappedJobException(throwable);
		}

		return new JobExecutionResult(
			jobId,
			netRuntime,
			AccumulatorHelper.deserializeAccumulators(
				accumulatorResults,
				classLoader));
	}

	/**
	 * Builder for {@link JobResult}.
	 */
	@Internal
	public static class Builder {

		private JobID jobId;

		private Map>> accumulatorResults;

		private long netRuntime = -1;

		private SerializedThrowable serializedThrowable;

		public Builder jobId(final JobID jobId) {
			this.jobId = jobId;
			return this;
		}

		public Builder accumulatorResults(final Map>> accumulatorResults) {
			this.accumulatorResults = accumulatorResults;
			return this;
		}

		public Builder netRuntime(final long netRuntime) {
			this.netRuntime = netRuntime;
			return this;
		}

		public Builder serializedThrowable(final SerializedThrowable serializedThrowable) {
			this.serializedThrowable = serializedThrowable;
			return this;
		}

		public JobResult build() {
			return new JobResult(
				jobId,
				accumulatorResults == null ? Collections.emptyMap() : accumulatorResults,
				netRuntime,
				serializedThrowable);
		}
	}

	/**
	 * Creates the {@link JobResult} from the given {@link AccessExecutionGraph} which
	 * must be in a globally terminal state.
	 *
	 * @param accessExecutionGraph to create the JobResult from
	 * @return JobResult of the given AccessExecutionGraph
	 */
	public static JobResult createFrom(AccessExecutionGraph accessExecutionGraph) {
		final JobID jobId = accessExecutionGraph.getJobID();
		final JobStatus jobStatus = accessExecutionGraph.getState();

		checkArgument(
			jobStatus.isGloballyTerminalState(),
			"The job " + accessExecutionGraph.getJobName() + '(' + jobId + ") is not in a globally " +
				"terminal state. It is in state " + jobStatus + '.');

		final JobResult.Builder builder = new JobResult.Builder();
		builder.jobId(jobId);

		final long netRuntime = accessExecutionGraph.getStatusTimestamp(jobStatus) - accessExecutionGraph.getStatusTimestamp(JobStatus.CREATED);
		// guard against clock changes
		final long guardedNetRuntime = Math.max(netRuntime, 0L);
		builder.netRuntime(guardedNetRuntime);
		builder.accumulatorResults(accessExecutionGraph.getAccumulatorsSerialized());

		if (jobStatus != JobStatus.FINISHED) {
			final ErrorInfo errorInfo = accessExecutionGraph.getFailureInfo();

			if (errorInfo != null) {
				builder.serializedThrowable(errorInfo.getException());
			}
		}

		return builder.build();
	}

	/**
	 * Exception which indicates that the job has finished with an {@link Exception}.
	 */
	public static final class WrappedJobException extends FlinkException {

		private static final long serialVersionUID = 6535061898650156019L;

		public WrappedJobException(Throwable cause) {
			super(cause);
		}
	}

}