You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by tr...@apache.org on 2019/02/19 09:30:42 UTC

[flink] 12/12: [FLINK-11650] Remove FlinkResourceManager

This is an automated email from the ASF dual-hosted git repository.

trohrmann pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git

commit c51787c9913cd001d15328237c2a00c8fcf6f0e8
Author: Till Rohrmann <tr...@apache.org>
AuthorDate: Mon Feb 18 11:39:19 2019 +0100

    [FLINK-11650] Remove FlinkResourceManager
    
    - Replace FlinkResourceManager#RESOURCE_MANAGER_NAME with ResourceManager#RESOURCE_MANAGER_NAME
    
    This closes #7736.
---
 .../clusterframework/FlinkResourceManager.java     | 787 ---------------------
 .../runtime/clusterframework/types/ResourceID.java |   8 +-
 .../resourcemanager/ResourceManagerHATest.java     |   3 +-
 .../ResourceManagerJobMasterTest.java              |   3 +-
 .../ResourceManagerTaskExecutorTest.java           |   3 +-
 5 files changed, 8 insertions(+), 796 deletions(-)

diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/FlinkResourceManager.java b/flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/FlinkResourceManager.java
deleted file mode 100644
index e20dd9b..0000000
--- a/flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/FlinkResourceManager.java
+++ /dev/null
@@ -1,787 +0,0 @@
-/*
- * 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.clusterframework;
-
-import akka.actor.ActorRef;
-import akka.actor.ActorSelection;
-import akka.actor.ActorSystem;
-import akka.actor.Props;
-import akka.dispatch.OnComplete;
-import akka.pattern.Patterns;
-import akka.util.Timeout;
-
-import org.apache.flink.configuration.AkkaOptions;
-import org.apache.flink.configuration.Configuration;
-import org.apache.flink.runtime.akka.AkkaUtils;
-import org.apache.flink.runtime.akka.FlinkUntypedActor;
-import org.apache.flink.runtime.clusterframework.messages.CheckAndAllocateContainers;
-import org.apache.flink.runtime.clusterframework.messages.FatalErrorOccurred;
-import org.apache.flink.runtime.clusterframework.messages.InfoMessage;
-import org.apache.flink.runtime.clusterframework.messages.NewLeaderAvailable;
-import org.apache.flink.runtime.clusterframework.messages.NotifyResourceStarted;
-import org.apache.flink.runtime.clusterframework.messages.RegisterInfoMessageListener;
-import org.apache.flink.runtime.clusterframework.messages.RegisterInfoMessageListenerSuccessful;
-import org.apache.flink.runtime.clusterframework.messages.RegisterResourceManager;
-import org.apache.flink.runtime.clusterframework.messages.RegisterResourceManagerSuccessful;
-import org.apache.flink.runtime.clusterframework.messages.RemoveResource;
-import org.apache.flink.runtime.clusterframework.messages.ResourceRemoved;
-import org.apache.flink.runtime.clusterframework.messages.SetWorkerPoolSize;
-import org.apache.flink.runtime.clusterframework.messages.StopCluster;
-import org.apache.flink.runtime.clusterframework.messages.StopClusterSuccessful;
-import org.apache.flink.runtime.clusterframework.messages.TriggerRegistrationAtJobManager;
-import org.apache.flink.runtime.clusterframework.messages.UnRegisterInfoMessageListener;
-import org.apache.flink.runtime.clusterframework.types.ResourceID;
-import org.apache.flink.runtime.clusterframework.types.ResourceIDRetrievable;
-import org.apache.flink.runtime.leaderretrieval.LeaderRetrievalListener;
-import org.apache.flink.runtime.leaderretrieval.LeaderRetrievalService;
-import org.apache.flink.runtime.messages.Acknowledge;
-import org.apache.flink.runtime.messages.JobManagerMessages.LeaderSessionMessage;
-
-import org.apache.flink.util.Preconditions;
-
-import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
-import scala.concurrent.duration.FiniteDuration;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.TimeUnit;
-
-import static java.util.Objects.requireNonNull;
-
-/**
- *
- * <h1>Worker allocation steps</h1>
- *
- * <ol>
- *     <li>The resource manager decides to request more workers. This can happen in order
- *         to fill the initial pool, or as a result of the JobManager requesting more workers.</li>
- *
- *     <li>The resource master calls {@link #requestNewWorkers(int)}, which triggers requests
- *         for more containers. After that, the {@link #getNumWorkerRequestsPending()}
- *         should reflect the pending requests.</li>
- *
- *     <li>The concrete framework may acquire containers and then trigger to start TaskManagers
- *         in those containers. That should be reflected in {@link #getNumWorkersPendingRegistration()}.</li>
- *
- *     <li>At some point, the TaskManager processes will have started and send a registration
- *         message to the JobManager. The JobManager will perform
- *         a lookup with the ResourceManager to check if it really started this TaskManager.
- *         The method {@link #workerStarted(ResourceID)} will be called
- *         to inform about a registered worker.</li>
- * </ol>
- *
- */
-public abstract class FlinkResourceManager<WorkerType extends ResourceIDRetrievable> extends FlinkUntypedActor {
-
-	/** The exit code with which the process is stopped in case of a fatal error */
-	protected static final int EXIT_CODE_FATAL_ERROR = -13;
-
-	/** The default name of the resource manager actor */
-	public static final String RESOURCE_MANAGER_NAME = "resourcemanager";
-
-	// ------------------------------------------------------------------------
-
-	/** The Flink configuration object */
-	protected final Configuration config;
-
-	/** The timeout for actor messages sent to the JobManager / TaskManagers */
-	private final FiniteDuration messageTimeout;
-
-	/** The service to find the right leader JobManager (to support high availability) */
-	private final LeaderRetrievalService leaderRetriever;
-
-	/** Map which contains the workers from which we know that they have been successfully started
-	 * in a container. This notification is sent by the JM when a TM tries to register at it. */
-	private final Map<ResourceID, WorkerType> startedWorkers;
-
-	/** List of listeners for info messages */
-	private final Set<ActorRef> infoMessageListeners;
-
-	/** The JobManager that the framework master manages resources for */
-	private ActorRef jobManager;
-
-	/** Our JobManager's leader session */
-	private UUID leaderSessionID;
-
-	/** The size of the worker pool that the resource master strives to maintain */
-	private int designatedPoolSize;
-
-	// ------------------------------------------------------------------------
-
-	/**
-	 * Creates a AbstractFrameworkMaster actor.
-	 *
-	 * @param flinkConfig The Flink configuration object.
-	 */
-	protected FlinkResourceManager(
-			int numInitialTaskManagers,
-			Configuration flinkConfig,
-			LeaderRetrievalService leaderRetriever) {
-		this.config = requireNonNull(flinkConfig);
-		this.leaderRetriever = requireNonNull(leaderRetriever);
-		this.startedWorkers = new HashMap<>();
-
-		FiniteDuration lt;
-		try {
-			lt = AkkaUtils.getLookupTimeout(config);
-		}
-		catch (Exception e) {
-			lt = new FiniteDuration(
-				Duration.apply(AkkaOptions.LOOKUP_TIMEOUT.defaultValue()).toMillis(),
-				TimeUnit.MILLISECONDS);
-		}
-		this.messageTimeout = lt;
-		this.designatedPoolSize = numInitialTaskManagers;
-		this.infoMessageListeners = new HashSet<>();
-	}
-
-	// ------------------------------------------------------------------------
-	//  Actor Behavior
-	// ------------------------------------------------------------------------
-
-	@Override
-	public void preStart() {
-		try {
-			// we start our leader retrieval service to make sure we get informed
-			// about JobManager leader changes
-			leaderRetriever.start(new LeaderRetrievalListener() {
-
-				@Override
-				public void notifyLeaderAddress(String leaderAddress, UUID leaderSessionID) {
-					self().tell(
-						new NewLeaderAvailable(leaderAddress, leaderSessionID),
-						ActorRef.noSender());
-				}
-
-				@Override
-				public void handleError(Exception e) {
-					self().tell(
-						new FatalErrorOccurred("Leader retrieval service failed", e),
-						ActorRef.noSender());
-				}
-			});
-
-			// framework specific initialization
-			initialize();
-
-		}
-		catch (Throwable t) {
-			self().tell(
-				new FatalErrorOccurred("Error during startup of ResourceManager actor", t),
-				ActorRef.noSender());
-		}
-	}
-
-	@Override
-	public void postStop() {
-		try {
-			leaderRetriever.stop();
-		}
-		catch (Throwable t) {
-			LOG.error("Could not cleanly shut down leader retrieval service", t);
-		}
-	}
-
-	/**
-	 *
-	 * This method receives the actor messages after they have been filtered for
-	 * a match with the leader session.
-	 *
-	 * @param message The incoming actor message.
-	 */
-	@Override
-	protected void handleMessage(Object message) {
-		try {
-			// --- messages about worker allocation and pool sizes
-
-			if (message instanceof CheckAndAllocateContainers) {
-				checkWorkersPool();
-			}
-			else if (message instanceof SetWorkerPoolSize) {
-				SetWorkerPoolSize msg = (SetWorkerPoolSize) message;
-				adjustDesignatedNumberOfWorkers(msg.numberOfWorkers());
-			}
-			else if (message instanceof RemoveResource) {
-				RemoveResource msg = (RemoveResource) message;
-				removeRegisteredResource(msg.resourceId());
-			}
-
-			// --- lookup of registered resources
-
-			else if (message instanceof NotifyResourceStarted) {
-				NotifyResourceStarted msg = (NotifyResourceStarted) message;
-				handleResourceStarted(sender(), msg.getResourceID());
-			}
-
-			// --- messages about JobManager leader status and registration
-
-			else if (message instanceof NewLeaderAvailable) {
-				NewLeaderAvailable msg = (NewLeaderAvailable) message;
-				newJobManagerLeaderAvailable(msg.leaderAddress(), msg.leaderSessionId());
-			}
-			else if (message instanceof TriggerRegistrationAtJobManager) {
-				TriggerRegistrationAtJobManager msg = (TriggerRegistrationAtJobManager) message;
-				triggerConnectingToJobManager(msg.jobManagerAddress());
-			}
-			else if (message instanceof RegisterResourceManagerSuccessful) {
-				RegisterResourceManagerSuccessful msg = (RegisterResourceManagerSuccessful) message;
-				jobManagerLeaderConnected(msg.jobManager(), msg.currentlyRegisteredTaskManagers());
-			}
-
-			// --- end of application
-
-			else if (message instanceof StopCluster) {
-				StopCluster msg = (StopCluster) message;
-				shutdownCluster(msg.finalStatus(), msg.message());
-				sender().tell(decorateMessage(StopClusterSuccessful.getInstance()), ActorRef.noSender());
-			}
-
-			// --- miscellaneous messages
-
-			else if (message instanceof RegisterInfoMessageListener) {
-				if (jobManager != null) {
-					infoMessageListeners.add(sender());
-					sender().tell(decorateMessage(
-						RegisterInfoMessageListenerSuccessful.get()),
-						// answer as the JobManager
-						jobManager);
-				}
-			}
-
-			else if (message instanceof UnRegisterInfoMessageListener) {
-				infoMessageListeners.remove(sender());
-			}
-
-			else if (message instanceof FatalErrorOccurred) {
-				FatalErrorOccurred fatalErrorOccurred = (FatalErrorOccurred) message;
-				fatalError(fatalErrorOccurred.message(), fatalErrorOccurred.error());
-			}
-
-			// --- unknown messages
-
-			else {
-				LOG.error("Discarding unknown message: {}", message);
-			}
-		}
-		catch (Throwable t) {
-			// fatal error, needs master recovery
-			fatalError("Error processing actor message", t);
-		}
-	}
-
-	@Override
-	protected final UUID getLeaderSessionID() {
-		return leaderSessionID;
-	}
-
-	// ------------------------------------------------------------------------
-	//  Status
-	// ------------------------------------------------------------------------
-
-	/**
-	 * Gets the current designated worker pool size, meaning the number of workers
-	 * that the resource master strives to maintain. The actual number of workers
-	 * may be lower (if worker requests are still pending) or higher (if workers have
-	 * not yet been released).
-	 *
-	 * @return The designated worker pool size.
-	 */
-	public int getDesignatedWorkerPoolSize() {
-		return designatedPoolSize;
-	}
-
-	/**
-	 * Gets the number of currently started TaskManagers.
-	 *
-	 * @return The number of currently started TaskManagers.
-	 */
-	public int getNumberOfStartedTaskManagers() {
-		return startedWorkers.size();
-	}
-
-	/**
-	 * Gets the currently registered resources.
-	 * @return
-	 */
-	public Collection<WorkerType> getStartedTaskManagers() {
-		return startedWorkers.values();
-	}
-
-	/**
-	 * Gets the started worker for a given resource ID, if one is available.
-	 *
-	 * @param resourceId The resource ID for the worker.
-	 * @return True if already registered, otherwise false
-	 */
-	public boolean isStarted(ResourceID resourceId) {
-		return startedWorkers.containsKey(resourceId);
-	}
-
-	/**
-	 * Gets an iterable for all currently started TaskManagers.
-	 *
-	 * @return All currently started TaskManagers.
-	 */
-	public Collection<WorkerType> allStartedWorkers() {
-		return startedWorkers.values();
-	}
-
-	/**
-	 * Tells the ResourceManager that a TaskManager had been started in a container with the given
-	 * resource id.
-	 *
-	 * @param jobManager The sender (JobManager) of the message
-	 * @param resourceID The resource id of the started TaskManager
-	 */
-	private void handleResourceStarted(ActorRef jobManager, ResourceID resourceID) {
-		if (resourceID != null) {
-			// check if resourceID is already registered (TaskManager may send duplicate register messages)
-			WorkerType oldWorker = startedWorkers.get(resourceID);
-			if (oldWorker != null) {
-				LOG.debug("Notification that TaskManager {} had been started was sent before.", resourceID);
-			} else {
-				WorkerType newWorker = workerStarted(resourceID);
-
-				if (newWorker != null) {
-					startedWorkers.put(resourceID, newWorker);
-					LOG.info("TaskManager {} has started.", resourceID);
-				} else {
-					LOG.info("TaskManager {} has not been started by this resource manager.", resourceID);
-				}
-			}
-		}
-
-		// Acknowledge the resource registration
-		jobManager.tell(decorateMessage(Acknowledge.get()), self());
-	}
-
-	/**
-	 * Releases the given resource. Note that this does not automatically shrink
-	 * the designated worker pool size.
-	 *
-	 * @param resourceId The TaskManager's resource id.
-	 */
-	private void removeRegisteredResource(ResourceID resourceId) {
-
-		WorkerType worker = startedWorkers.remove(resourceId);
-		if (worker != null) {
-			releaseStartedWorker(worker);
-		} else {
-			LOG.warn("Resource {} could not be released", resourceId);
-		}
-	}
-
-
-	// ------------------------------------------------------------------------
-	//  Registration and consolidation with JobManager Leader
-	// ------------------------------------------------------------------------
-
-	/**
-	 * Called as soon as we discover (via leader election) that a JobManager lost leadership
-	 * or a different one gained leadership.
-	 *
-	 * @param leaderAddress The address (Akka URL) of the new leader. Null if there is currently no leader.
-	 * @param leaderSessionID The unique session ID marking the leadership session.
-	 */
-	private void newJobManagerLeaderAvailable(String leaderAddress, UUID leaderSessionID) {
-		LOG.debug("Received new leading JobManager {}. Connecting.", leaderAddress);
-
-		// disconnect from the current leader (no-op if no leader yet)
-		jobManagerLostLeadership();
-
-		// a null leader session id means that only a leader disconnect
-		// happened, without a new leader yet
-		if (leaderSessionID != null && leaderAddress != null) {
-			// the leaderSessionID implicitly filters out success and failure messages
-			// that come after leadership changed again
-			this.leaderSessionID = leaderSessionID;
-			triggerConnectingToJobManager(leaderAddress);
-		}
-	}
-
-	/**
-	 * Causes the resource manager to announce itself at the new leader JobManager and
-	 * obtains its connection information and currently known TaskManagers.
-	 *
-	 * @param leaderAddress The akka actor URL of the new leader JobManager.
-	 */
-	protected void triggerConnectingToJobManager(String leaderAddress) {
-
-		LOG.info("Trying to associate with JobManager leader " + leaderAddress);
-
-		final Object registerMessage = decorateMessage(new RegisterResourceManager(self()));
-		final Object retryMessage = decorateMessage(new TriggerRegistrationAtJobManager(leaderAddress));
-
-		// send the registration message to the JobManager
-		ActorSelection jobManagerSel = context().actorSelection(leaderAddress);
-		Future<Object> future = Patterns.ask(jobManagerSel, registerMessage, new Timeout(messageTimeout));
-
-		future.onComplete(new OnComplete<Object>() {
-
-			@Override
-			public void onComplete(Throwable failure, Object msg) {
-				// only process if we haven't been connected in the meantime
-				if (jobManager == null) {
-					if (msg != null) {
-						if (msg instanceof LeaderSessionMessage &&
-							((LeaderSessionMessage) msg).message() instanceof RegisterResourceManagerSuccessful) {
-							self().tell(msg, ActorRef.noSender());
-						} else {
-							LOG.error("Invalid response type to registration at JobManager: {}", msg);
-							self().tell(retryMessage, ActorRef.noSender());
-						}
-					} else {
-						// no success
-						LOG.error("Resource manager could not register at JobManager", failure);
-						self().tell(retryMessage, ActorRef.noSender());
-					}
-				}
-			}
-
-		}, context().dispatcher());
-	}
-
-	/**
-	 * This method disassociates from the current leader JobManager.
-	 */
-	private void jobManagerLostLeadership() {
-		if (jobManager != null) {
-			LOG.info("Associated JobManager {} lost leader status", jobManager);
-
-			jobManager = null;
-			leaderSessionID = null;
-
-			infoMessageListeners.clear();
-		}
-	}
-
-	/**
-	 * Callback when we're informed about a new leading JobManager.
-	 * @param newJobManagerLeader The ActorRef of the new jobManager
-	 * @param workers The existing workers the JobManager has registered.
-	 */
-	private void jobManagerLeaderConnected(
-						ActorRef newJobManagerLeader,
-						Collection<ResourceID> workers) {
-
-		if (jobManager == null) {
-			LOG.info("Resource Manager associating with leading JobManager {} - leader session {}",
-						newJobManagerLeader, leaderSessionID);
-
-			jobManager = newJobManagerLeader;
-
-			if (workers.size() > 0) {
-				LOG.info("Received TaskManagers that were registered at the leader JobManager. " +
-						"Trying to consolidate.");
-
-				// keep track of which TaskManagers are not handled
-				Set<ResourceID> toHandle = new HashSet<>(workers.size());
-				toHandle.addAll(workers);
-
-				try {
-					// ask the framework to tell us which ones we should keep for now
-					Collection<WorkerType> consolidated = reacceptRegisteredWorkers(workers);
-					LOG.info("Consolidated {} TaskManagers", consolidated.size());
-
-					// put the consolidated TaskManagers into our bookkeeping
-					for (WorkerType worker : consolidated) {
-						ResourceID resourceID = worker.getResourceID();
-						startedWorkers.put(resourceID, worker);
-						toHandle.remove(resourceID);
-					}
-				}
-				catch (Throwable t) {
-					LOG.error("Error during consolidation of known TaskManagers", t);
-					// the framework should release the remaining unclear resources
-					for (ResourceID id : toHandle) {
-						releasePendingWorker(id);
-					}
-				}
-
-			}
-
-			// trigger initial check for requesting new workers
-			checkWorkersPool();
-
-		} else {
-			String msg = "Attempting to associate with new JobManager leader " + newJobManagerLeader
-				+ " without previously disassociating from current leader " + jobManager;
-			fatalError(msg, new Exception(msg));
-		}
-	}
-
-	// ------------------------------------------------------------------------
-	//  ClusterClient Shutdown
-	// ------------------------------------------------------------------------
-
-	private void shutdownCluster(ApplicationStatus status, String diagnostics) {
-		LOG.info("Shutting down cluster with status {} : {}", status, diagnostics);
-
-		shutdownApplication(status, diagnostics);
-	}
-
-	// ------------------------------------------------------------------------
-	//  Worker pool size management
-	// ------------------------------------------------------------------------
-
-	/**
-	 * This method causes the resource framework master to <b>synchronously</b>re-examine
-	 * the set of available and pending workers containers, and allocate containers
-	 * if needed.
-	 *
-	 * This method does not automatically release workers, because it is not visible to
-	 * this resource master which workers can be released. Instead, the JobManager must
-	 * explicitly release individual workers.
-	 */
-	private void checkWorkersPool() {
-		int numWorkersPending = getNumWorkerRequestsPending();
-		int numWorkersPendingRegistration = getNumWorkersPendingRegistration();
-
-		// sanity checks
-		Preconditions.checkState(numWorkersPending >= 0,
-			"Number of pending workers should never be below 0.");
-		Preconditions.checkState(numWorkersPendingRegistration >= 0,
-			"Number of pending workers pending registration should never be below 0.");
-
-		// see how many workers we want, and whether we have enough
-		int allAvailableAndPending = startedWorkers.size() +
-			numWorkersPending + numWorkersPendingRegistration;
-
-		int missing = designatedPoolSize - allAvailableAndPending;
-
-		if (missing > 0) {
-			requestNewWorkers(missing);
-		}
-	}
-
-	/**
-	 * Sets the designated worker pool size. If this size is larger than the current pool
-	 * size, then the resource manager will try to acquire more TaskManagers.
-	 *
-	 * @param num The number of workers in the pool.
-	 */
-	private void adjustDesignatedNumberOfWorkers(int num) {
-		if (num >= 0) {
-			LOG.info("Adjusting designated worker pool size to {}", num);
-			designatedPoolSize = num;
-			checkWorkersPool();
-		} else {
-			LOG.warn("Ignoring invalid designated worker pool size: " + num);
-		}
-	}
-
-	// ------------------------------------------------------------------------
-	//  Callbacks
-	// ------------------------------------------------------------------------
-
-	/**
-	 * This method causes the resource framework master to <b>asynchronously</b>re-examine
-	 * the set of available and pending workers containers, and release or allocate
-	 * containers if needed. The method sends an actor message which will trigger the
-	 * re-examination.
-	 */
-	public void triggerCheckWorkers() {
-		self().tell(
-			decorateMessage(
-				CheckAndAllocateContainers.get()),
-			ActorRef.noSender());
-	}
-
-	/**
-	 * This method should be called by the framework once it detects that a currently registered
-	 * worker has failed.
-	 *
-	 * @param resourceID Id of the worker that has failed.
-	 * @param message An informational message that explains why the worker failed.
-	 */
-	public void notifyWorkerFailed(ResourceID resourceID, String message) {
-		WorkerType worker = startedWorkers.remove(resourceID);
-		if (worker != null) {
-			jobManager.tell(
-				decorateMessage(
-					new ResourceRemoved(resourceID, message)),
-				self());
-		}
-	}
-
-	// ------------------------------------------------------------------------
-	//  Framework specific behavior
-	// ------------------------------------------------------------------------
-
-	/**
-	 * Initializes the framework specific components.
-	 *
-	 * @throws Exception Exceptions during initialization cause the resource manager to fail.
-	 *                   If the framework is able to recover this resource manager, it will be
-	 *                   restarted.
-	 */
-	protected abstract void initialize() throws Exception;
-
-	/**
-	 * The framework specific code for shutting down the application. This should report the
-	 * application's final status and shut down the resource manager cleanly.
-	 *
-	 * This method also needs to make sure all pending containers that are not registered
-	 * yet are returned.
-	 *
-	 * @param finalStatus The application status to report.
-	 * @param optionalDiagnostics An optional diagnostics message.
-	 */
-	protected abstract void shutdownApplication(ApplicationStatus finalStatus, String optionalDiagnostics);
-
-	/**
-	 * Notifies the resource master of a fatal error.
-	 *
-	 * <p><b>IMPORTANT:</b> This should not cleanly shut down this master, but exit it in
-	 * such a way that a high-availability setting would restart this or fail over
-	 * to another master.
-	 */
-	protected abstract void fatalError(String message, Throwable error);
-
-	/**
-	 * Requests to allocate a certain number of new workers.
-	 *
-	 * @param numWorkers The number of workers to allocate.
-	 */
-	protected abstract void requestNewWorkers(int numWorkers);
-
-	/**
-	 * Trigger a release of a pending worker.
-	 * @param resourceID The worker resource id
-	 */
-	protected abstract void releasePendingWorker(ResourceID resourceID);
-
-	/**
-	 * Trigger a release of a started worker.
-	 * @param resourceID The worker resource id
-	 */
-	protected abstract void releaseStartedWorker(WorkerType resourceID);
-
-	/**
-	 * Callback when a worker was started.
-	 * @param resourceID The worker resource id
-	 */
-	protected abstract WorkerType workerStarted(ResourceID resourceID);
-
-	/**
-	 * This method is called when the resource manager starts after a failure and reconnects to
-	 * the leader JobManager, who still has some workers registered. The method is used to consolidate
-	 * the view between resource manager and JobManager. The resource manager gets the list of TaskManagers
-	 * that the JobManager considers available and should return a list or nodes that the
-	 * resource manager considers available.
-	 *
-	 * After that, the JobManager is informed of loss of all TaskManagers that are not part of the
-	 * returned list.
-	 *
-	 * It is possible that the resource manager initially confirms some TaskManagers to be alive, even
-	 * through they are in an uncertain status, if it later sends necessary failure notifications
-	 * via calling {@link #notifyWorkerFailed(ResourceID, String)}.
-	 *
-	 * @param registered The list of TaskManagers that the JobManager knows.
-	 * @return The subset of TaskManagers that the resource manager can confirm to be alive.
-	 */
-	protected abstract Collection<WorkerType> reacceptRegisteredWorkers(Collection<ResourceID> registered);
-
-	/**
-	 * Gets the number of requested workers that have not yet been granted.
-	 *
-	 * @return The number pending worker requests. Must never be smaller than 0.
-	 */
-	protected abstract int getNumWorkerRequestsPending();
-
-	/**
-	 * Gets the number of containers that have been started, but where the TaskManager
-	 * has not yet registered at the job manager.
-	 *
-	 * @return The number of started containers pending TaskManager registration.
-	 * Must never be smaller than 0.
-	 */
-	protected abstract int getNumWorkersPendingRegistration();
-
-	// ------------------------------------------------------------------------
-	//  Info messaging
-	// ------------------------------------------------------------------------
-
-	protected void sendInfoMessage(String message) {
-		for (ActorRef listener : infoMessageListeners) {
-			listener.tell(decorateMessage(new InfoMessage(message)), self());
-		}
-	}
-
-
-	// ------------------------------------------------------------------------
-	//  Startup
-	// ------------------------------------------------------------------------
-
-	/**
-	 * Starts the resource manager actors.
-	 * @param configuration The configuration for the resource manager
-	 * @param actorSystem The actor system to start the resource manager in
-	 * @param leaderRetriever The leader retriever service to initialize the resource manager
-	 * @param resourceManagerClass The class of the ResourceManager to be started
-	 * @return ActorRef of the resource manager
-	 */
-	public static ActorRef startResourceManagerActors(
-			Configuration configuration,
-			ActorSystem actorSystem,
-			LeaderRetrievalService leaderRetriever,
-			Class<? extends FlinkResourceManager<?>> resourceManagerClass) {
-
-		return startResourceManagerActors(
-			configuration, actorSystem, leaderRetriever, resourceManagerClass,
-			RESOURCE_MANAGER_NAME + "-" + UUID.randomUUID());
-	}
-
-	/**
-	 * Starts the resource manager actors.
-	 * @param configuration The configuration for the resource manager
-	 * @param actorSystem The actor system to start the resource manager in
-	 * @param leaderRetriever The leader retriever service to initialize the resource manager
-	 * @param resourceManagerClass The class of the ResourceManager to be started
-	 * @param resourceManagerActorName The name of the resource manager actor.
-	 * @return ActorRef of the resource manager
-	 */
-	public static ActorRef startResourceManagerActors(
-			Configuration configuration,
-			ActorSystem actorSystem,
-			LeaderRetrievalService leaderRetriever,
-			Class<? extends FlinkResourceManager<?>> resourceManagerClass,
-			String resourceManagerActorName) {
-
-		Props resourceMasterProps = getResourceManagerProps(
-			resourceManagerClass,
-			configuration,
-			leaderRetriever);
-
-		return actorSystem.actorOf(resourceMasterProps, resourceManagerActorName);
-	}
-
-	public static Props getResourceManagerProps(
-		Class<? extends FlinkResourceManager> resourceManagerClass,
-		Configuration configuration,
-		LeaderRetrievalService leaderRetrievalService) {
-
-		return Props.create(resourceManagerClass, configuration, leaderRetrievalService);
-	}
-}
diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/types/ResourceID.java b/flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/types/ResourceID.java
index 6b8a037..e9ec579 100644
--- a/flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/types/ResourceID.java
+++ b/flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/types/ResourceID.java
@@ -24,7 +24,7 @@ import org.apache.flink.util.Preconditions;
 import java.io.Serializable;
 
 /**
- * Class for Resource Ids assigned at the FlinkResourceManager.
+ * Class for Resource Ids identifying Flink's distributed components.
  */
 public final class ResourceID implements ResourceIDRetrievable, Serializable {
 
@@ -38,7 +38,8 @@ public final class ResourceID implements ResourceIDRetrievable, Serializable {
 	}
 
 	/**
-	 * Gets the Resource Id as string
+	 * Gets the Resource Id as string.
+	 *
 	 * @return Stringified version of the ResourceID
 	 */
 	public final String getResourceIdString() {
@@ -74,9 +75,10 @@ public final class ResourceID implements ResourceIDRetrievable, Serializable {
 	public ResourceID getResourceID() {
 		return this;
 	}
-	
+
 	/**
 	 * Generate a random resource id.
+	 *
 	 * @return A random resource id.
 	 */
 	public static ResourceID generate() {
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerHATest.java b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerHATest.java
index aa9571c..cea75d6 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerHATest.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerHATest.java
@@ -19,7 +19,6 @@
 package org.apache.flink.runtime.resourcemanager;
 
 import org.apache.flink.api.common.time.Time;
-import org.apache.flink.runtime.clusterframework.FlinkResourceManager;
 import org.apache.flink.runtime.clusterframework.types.ResourceID;
 import org.apache.flink.runtime.entrypoint.ClusterInformation;
 import org.apache.flink.runtime.heartbeat.TestingHeartbeatServices;
@@ -82,7 +81,7 @@ public class ResourceManagerHATest extends TestLogger {
 		final ResourceManager resourceManager =
 			new StandaloneResourceManager(
 				rpcService,
-				FlinkResourceManager.RESOURCE_MANAGER_NAME,
+				ResourceManager.RESOURCE_MANAGER_NAME,
 				rmResourceId,
 				highAvailabilityServices,
 				heartbeatServices,
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerJobMasterTest.java b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerJobMasterTest.java
index 3126891..aefbd87 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerJobMasterTest.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerJobMasterTest.java
@@ -20,7 +20,6 @@ package org.apache.flink.runtime.resourcemanager;
 
 import org.apache.flink.api.common.JobID;
 import org.apache.flink.api.common.time.Time;
-import org.apache.flink.runtime.clusterframework.FlinkResourceManager;
 import org.apache.flink.runtime.clusterframework.types.ResourceID;
 import org.apache.flink.runtime.entrypoint.ClusterInformation;
 import org.apache.flink.runtime.heartbeat.HeartbeatServices;
@@ -146,7 +145,7 @@ public class ResourceManagerJobMasterTest extends TestLogger {
 
 		ResourceManager<?> resourceManager = new StandaloneResourceManager(
 			rpcService,
-			FlinkResourceManager.RESOURCE_MANAGER_NAME,
+			ResourceManager.RESOURCE_MANAGER_NAME,
 			rmResourceId,
 			haServices,
 			heartbeatServices,
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerTaskExecutorTest.java b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerTaskExecutorTest.java
index a871ab2..ded8d85 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerTaskExecutorTest.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/ResourceManagerTaskExecutorTest.java
@@ -19,7 +19,6 @@
 package org.apache.flink.runtime.resourcemanager;
 
 import org.apache.flink.api.common.time.Time;
-import org.apache.flink.runtime.clusterframework.FlinkResourceManager;
 import org.apache.flink.runtime.clusterframework.types.ResourceID;
 import org.apache.flink.runtime.clusterframework.types.ResourceProfile;
 import org.apache.flink.runtime.clusterframework.types.SlotID;
@@ -151,7 +150,7 @@ public class ResourceManagerTaskExecutorTest extends TestLogger {
 		StandaloneResourceManager resourceManager =
 			new StandaloneResourceManager(
 				rpcService,
-				FlinkResourceManager.RESOURCE_MANAGER_NAME + UUID.randomUUID(),
+				ResourceManager.RESOURCE_MANAGER_NAME + UUID.randomUUID(),
 				resourceManagerResourceID,
 				highAvailabilityServices,
 				heartbeatServices,