diff --git a/flink-clients/src/main/java/org/apache/flink/client/deployment/application/ApplicationClusterEntryPoint.java b/flink-clients/src/main/java/org/apache/flink/client/deployment/application/ApplicationClusterEntryPoint.java index db290384..9307666f 100644 --- a/flink-clients/src/main/java/org/apache/flink/client/deployment/application/ApplicationClusterEntryPoint.java +++ b/flink-clients/src/main/java/org/apache/flink/client/deployment/application/ApplicationClusterEntryPoint.java @@ -117,9 +117,9 @@ public class ApplicationClusterEntryPoint extends ClusterEntrypoint { } @Override - protected void cleanupDirectories() throws IOException { + protected void cleanupDirectories(ShutdownBehaviour shutdownBehaviour) throws IOException { // Close the packaged program explicitly to clean up temporary jars. program.close(); - super.cleanupDirectories(); + super.cleanupDirectories(shutdownBehaviour); } } diff --git a/flink-core/src/main/java/org/apache/flink/configuration/CheckpointingOptions.java b/flink-core/src/main/java/org/apache/flink/configuration/CheckpointingOptions.java index 99859821..fce2f506 100644 --- a/flink-core/src/main/java/org/apache/flink/configuration/CheckpointingOptions.java +++ b/flink-core/src/main/java/org/apache/flink/configuration/CheckpointingOptions.java @@ -164,9 +164,18 @@ public class CheckpointingOptions { ConfigOptions.key("taskmanager.state.local.root-dirs") .noDefaultValue() .withDescription( - "The config parameter defining the root directories for storing file-based state for local " - + "recovery. Local recovery currently only covers keyed state backends. Currently, MemoryStateBackend does " - + "not support local recovery and ignore this option"); + Description.builder() + .text( + "The config parameter defining the root directories for storing file-based " + + "state for local recovery. Local recovery currently only covers keyed " + + "state backends. Currently, MemoryStateBackend does not support local " + + "recovery and ignores this option. If not configured it will default " + + "to /localState. The can be configured via %s", + TextElement.code( + ClusterOptions + .TASK_MANAGER_PROCESS_WORKING_DIR_BASE + .key())) + .build()); // ------------------------------------------------------------------------ // Options specific to the file-system-based state backends diff --git a/flink-core/src/main/java/org/apache/flink/configuration/ClusterOptions.java b/flink-core/src/main/java/org/apache/flink/configuration/ClusterOptions.java index 74b5a1de..a59f3183 100644 --- a/flink-core/src/main/java/org/apache/flink/configuration/ClusterOptions.java +++ b/flink-core/src/main/java/org/apache/flink/configuration/ClusterOptions.java @@ -22,6 +22,7 @@ import org.apache.flink.annotation.PublicEvolving; import org.apache.flink.annotation.docs.Documentation; import org.apache.flink.configuration.description.Description; import org.apache.flink.configuration.description.InlineElement; +import org.apache.flink.configuration.description.TextElement; import static org.apache.flink.configuration.ClusterOptions.UserSystemExitMode.THROW; import static org.apache.flink.configuration.ConfigOptions.key; @@ -157,6 +158,47 @@ public class ClusterOptions { UncaughtExceptionHandleMode.LOG.name(), UncaughtExceptionHandleMode.FAIL.name())); + @Documentation.OverrideDefault("io.tmp.dirs") + @Documentation.Section(Documentation.Sections.EXPERT_CLUSTER) + public static final ConfigOption PROCESS_WORKING_DIR_BASE = + ConfigOptions.key("process.working-dir") + .stringType() + .noDefaultValue() + .withDescription( + Description.builder() + .text( + "Working directory for Flink processes. " + + "The working directory can be used to store information that can be used upon process recovery. " + + "If not configured, then it will default to a randomly picked temporary directory defined via %s.", + TextElement.code(CoreOptions.TMP_DIRS.key())) + .build()); + + @Documentation.Section(Documentation.Sections.EXPERT_CLUSTER) + public static final ConfigOption JOB_MANAGER_PROCESS_WORKING_DIR_BASE = + ConfigOptions.key("process.jobmanager.working-dir") + .stringType() + .noDefaultValue() + .withFallbackKeys(PROCESS_WORKING_DIR_BASE.key()) + .withDescription( + Description.builder() + .text( + "Working directory for Flink JobManager processes. The working directory can be used to store information that can be used upon process recovery. If not configured, then it will default to %s.", + TextElement.code(PROCESS_WORKING_DIR_BASE.key())) + .build()); + + @Documentation.Section(Documentation.Sections.EXPERT_CLUSTER) + public static final ConfigOption TASK_MANAGER_PROCESS_WORKING_DIR_BASE = + ConfigOptions.key("process.taskmanager.working-dir") + .stringType() + .noDefaultValue() + .withFallbackKeys(PROCESS_WORKING_DIR_BASE.key()) + .withDescription( + Description.builder() + .text( + "Working directory for Flink TaskManager processes. The working directory can be used to store information that can be used upon process recovery. If not configured, then it will default to %s.", + TextElement.code(PROCESS_WORKING_DIR_BASE.key())) + .build()); + public static JobManagerOptions.SchedulerType getSchedulerType(Configuration configuration) { if (isAdaptiveSchedulerEnabled(configuration) || isReactiveModeEnabled(configuration)) { return JobManagerOptions.SchedulerType.Adaptive; diff --git a/flink-core/src/main/java/org/apache/flink/configuration/ConfigurationUtils.java b/flink-core/src/main/java/org/apache/flink/configuration/ConfigurationUtils.java index fe42f548..a2bce405 100755 --- a/flink-core/src/main/java/org/apache/flink/configuration/ConfigurationUtils.java +++ b/flink-core/src/main/java/org/apache/flink/configuration/ConfigurationUtils.java @@ -20,6 +20,7 @@ package org.apache.flink.configuration; import org.apache.flink.annotation.VisibleForTesting; import org.apache.flink.api.common.time.Time; +import org.apache.flink.util.Preconditions; import org.apache.flink.util.TimeUtils; import javax.annotation.Nonnull; @@ -34,6 +35,7 @@ import java.util.Map; import java.util.Optional; import java.util.Properties; import java.util.Set; +import java.util.concurrent.ThreadLocalRandom; import java.util.stream.Collectors; import static org.apache.flink.configuration.MetricOptions.SYSTEM_RESOURCE_METRICS; @@ -73,6 +75,27 @@ public class ConfigurationUtils { return splitPaths(configuration.getString(CoreOptions.TMP_DIRS)); } + /** + * Picks a temporary directory randomly from the given configuration. + * + * @param configuration to extract the temp directory from + * @return a randomly picked temporary directory + */ + @Nonnull + public static File getRandomTempDirectory(Configuration configuration) { + final String[] tmpDirectories = parseTempDirectories(configuration); + + Preconditions.checkState( + tmpDirectories.length > 0, + String.format( + "No temporary directory has been specified for %s", + CoreOptions.TMP_DIRS.key())); + + final int randomIndex = ThreadLocalRandom.current().nextInt(tmpDirectories.length); + + return new File(tmpDirectories[randomIndex]); + } + /** * Extracts the local state directories as defined by {@link * CheckpointingOptions#LOCAL_RECOVERY_TASK_MANAGER_STATE_ROOT_DIRS}. diff --git a/flink-core/src/main/java/org/apache/flink/configuration/JobManagerOptions.java b/flink-core/src/main/java/org/apache/flink/configuration/JobManagerOptions.java index caa01578..97a0f027 100644 --- a/flink-core/src/main/java/org/apache/flink/configuration/JobManagerOptions.java +++ b/flink-core/src/main/java/org/apache/flink/configuration/JobManagerOptions.java @@ -547,6 +547,17 @@ public class JobManagerOptions { code(SchedulerType.AdaptiveBatch.name())) .build()); + /** + * The JobManager's ResourceID. If not configured, the ResourceID will be generated randomly. + */ + @Documentation.Section(Documentation.Sections.ALL_JOB_MANAGER) + public static final ConfigOption JOB_MANAGER_RESOURCE_ID = + key("jobmanager.resource-id") + .stringType() + .noDefaultValue() + .withDescription( + "The JobManager's ResourceID. If not configured, the ResourceID will be generated randomly."); + // --------------------------------------------------------------------------------------------- private JobManagerOptions() { diff --git a/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointEnvironment.java b/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointEnvironment.java index e4a331e7..682c4cf3 100644 --- a/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointEnvironment.java +++ b/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointEnvironment.java @@ -150,7 +150,7 @@ public class SavepointEnvironment implements Environment { @Override public TaskManagerRuntimeInfo getTaskManagerInfo() { - return new SavepointTaskManagerRuntimeInfo(getIOManager()); + return new SavepointTaskManagerRuntimeInfo(getIOManager().getSpillingDirectories()[0]); } @Override diff --git a/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointTaskManagerRuntimeInfo.java b/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointTaskManagerRuntimeInfo.java index 5f481924..873fc244 100644 --- a/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointTaskManagerRuntimeInfo.java +++ b/flink-libraries/flink-state-processing-api/src/main/java/org/apache/flink/state/api/runtime/SavepointTaskManagerRuntimeInfo.java @@ -19,19 +19,20 @@ package org.apache.flink.state.api.runtime; import org.apache.flink.configuration.Configuration; -import org.apache.flink.runtime.io.disk.iomanager.IOManager; import org.apache.flink.runtime.taskmanager.TaskManagerRuntimeInfo; import org.apache.flink.util.Preconditions; +import java.io.File; + /** * A minimally implemented {@link TaskManagerRuntimeInfo} that provides the functionality required * to run the {@code state-processor-api}. */ class SavepointTaskManagerRuntimeInfo implements TaskManagerRuntimeInfo { - private final IOManager ioManager; + private final File tmpWorkingDirectory; - SavepointTaskManagerRuntimeInfo(IOManager ioManager) { - this.ioManager = Preconditions.checkNotNull(ioManager); + SavepointTaskManagerRuntimeInfo(File tmpWorkingDirectory) { + this.tmpWorkingDirectory = Preconditions.checkNotNull(tmpWorkingDirectory); } @Override @@ -41,7 +42,8 @@ class SavepointTaskManagerRuntimeInfo implements TaskManagerRuntimeInfo { @Override public String[] getTmpDirectories() { - return ioManager.getSpillingDirectoriesPaths(); + throw new UnsupportedOperationException( + "Tmp directories are not available with the SavepointTaskManagerRuntimeInfo"); } @Override @@ -54,4 +56,9 @@ class SavepointTaskManagerRuntimeInfo implements TaskManagerRuntimeInfo { throw new UnsupportedOperationException( "Getting external address of task manager is not supported in SavepointTaskManagerRuntimeInfo"); } + + @Override + public File getTmpWorkingDirectory() { + return tmpWorkingDirectory; + } } diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypoint.java b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypoint.java index b4d23b4e..4955b3b5 100755 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypoint.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypoint.java @@ -39,6 +39,7 @@ import org.apache.flink.core.security.FlinkSecurityManager; import org.apache.flink.management.jmx.JMXService; import org.apache.flink.runtime.blob.BlobServer; import org.apache.flink.runtime.clusterframework.ApplicationStatus; +import org.apache.flink.runtime.clusterframework.types.ResourceID; import org.apache.flink.runtime.dispatcher.ExecutionGraphInfoStore; import org.apache.flink.runtime.dispatcher.MiniDispatcher; import org.apache.flink.runtime.entrypoint.component.DispatcherResourceManagerComponent; @@ -123,6 +124,9 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro private final AtomicBoolean isShutDown = new AtomicBoolean(false); + @GuardedBy("lock") + private ResourceID resourceId; + @GuardedBy("lock") private DispatcherResourceManagerComponent clusterComponent; @@ -147,6 +151,9 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro @GuardedBy("lock") private ExecutorService ioExecutor; + @GuardedBy("lock") + private WorkingDirectory workingDirectory; + private ExecutionGraphInfoStore executionGraphInfoStore; private final Thread shutDownHook; @@ -202,7 +209,7 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro // clean up any partial state shutDownAsync( ApplicationStatus.FAILED, - ShutdownBehaviour.STOP_APPLICATION, + ShutdownBehaviour.GRACEFUL_SHUTDOWN, ExceptionUtils.stringifyException(strippedThrowable), false) .get( @@ -253,6 +260,7 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro clusterComponent = dispatcherResourceManagerComponentFactory.create( configuration, + resourceId, ioExecutor, commonRpcService, haServices, @@ -271,7 +279,7 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro if (throwable != null) { shutDownAsync( ApplicationStatus.UNKNOWN, - ShutdownBehaviour.STOP_APPLICATION, + ShutdownBehaviour.GRACEFUL_SHUTDOWN, ExceptionUtils.stringifyException(throwable), false); } else { @@ -280,7 +288,7 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro // already triggered, this will do nothing shutDownAsync( applicationStatus, - ShutdownBehaviour.STOP_APPLICATION, + ShutdownBehaviour.GRACEFUL_SHUTDOWN, null, true); } @@ -338,6 +346,21 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro executionGraphInfoStore = createSerializableExecutionGraphStore( configuration, commonRpcService.getScheduledExecutor()); + + resourceId = + configuration + .getOptional(JobManagerOptions.JOB_MANAGER_RESOURCE_ID) + .map(ResourceID::new) + .orElseGet(ResourceID::generate); + + LOG.debug( + "Initialize cluster entrypoint {} with resource id {}.", + getClass().getSimpleName(), + resourceId); + + workingDirectory = + ClusterEntrypointUtils.createJobManagerWorkingDirectory( + configuration, resourceId); } } @@ -386,7 +409,7 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro return shutDownAsync( ApplicationStatus.UNKNOWN, - ShutdownBehaviour.STOP_PROCESS, + ShutdownBehaviour.PROCESS_FAILURE, "Cluster entrypoint has been closed externally.", false) .thenAccept(ignored -> {}); @@ -509,7 +532,8 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro final CompletableFuture cleanupDirectoriesFuture = FutureUtils.runAfterwards( - rpcSystemClassLoaderCloseFuture, this::cleanupDirectories); + rpcSystemClassLoaderCloseFuture, + () -> cleanupDirectories(shutdownBehaviour)); cleanupDirectoriesFuture.whenComplete( (Void ignored2, Throwable serviceThrowable) -> { @@ -540,9 +564,9 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro synchronized (lock) { if (clusterComponent != null) { switch (shutdownBehaviour) { - case STOP_APPLICATION: + case GRACEFUL_SHUTDOWN: return clusterComponent.stopApplication(applicationStatus, diagnostics); - case STOP_PROCESS: + case PROCESS_FAILURE: default: return clusterComponent.stopProcess(); } @@ -555,12 +579,37 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro /** * Clean up of temporary directories created by the {@link ClusterEntrypoint}. * + * @param shutdownBehaviour specifying the shutdown behaviour * @throws IOException if the temporary directories could not be cleaned up */ - protected void cleanupDirectories() throws IOException { + protected void cleanupDirectories(ShutdownBehaviour shutdownBehaviour) throws IOException { + IOException ioException = null; + final String webTmpDir = configuration.getString(WebOptions.TMP_DIR); - FileUtils.deleteDirectory(new File(webTmpDir)); + try { + FileUtils.deleteDirectory(new File(webTmpDir)); + } catch (IOException ioe) { + ioException = ioe; + } + + // We only clean up the working directory if we gracefully shut down. If it is a process + // failure, then we want to keep the working directory for potential recoveries. + if (shutdownBehaviour == ShutdownBehaviour.GRACEFUL_SHUTDOWN) { + synchronized (lock) { + if (workingDirectory != null) { + try { + workingDirectory.delete(); + } catch (IOException ioe) { + ioException = ExceptionUtils.firstOrSuppressed(ioe, ioException); + } + } + } + } + + if (ioException != null) { + throw ioException; + } } // -------------------------------------------------- @@ -649,8 +698,11 @@ public abstract class ClusterEntrypoint implements AutoCloseableAsync, FatalErro DETACHED } - private enum ShutdownBehaviour { - STOP_APPLICATION, - STOP_PROCESS, + /** Shutdown behaviour of a {@link ClusterEntrypoint}. */ + protected enum ShutdownBehaviour { + // Graceful shutdown means that the process wants to terminate and will clean everything up + GRACEFUL_SHUTDOWN, + // Process failure means that we don't clean up things so that they could be recovered + PROCESS_FAILURE, } } diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypointUtils.java b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypointUtils.java index d02646bb..57f15f01 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypointUtils.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/ClusterEntrypointUtils.java @@ -18,9 +18,14 @@ package org.apache.flink.runtime.entrypoint; +import org.apache.flink.annotation.VisibleForTesting; import org.apache.flink.configuration.ClusterOptions; import org.apache.flink.configuration.ConfigConstants; +import org.apache.flink.configuration.ConfigOption; import org.apache.flink.configuration.Configuration; +import org.apache.flink.configuration.ConfigurationUtils; +import org.apache.flink.configuration.CoreOptions; +import org.apache.flink.runtime.clusterframework.types.ResourceID; import org.apache.flink.runtime.entrypoint.parser.CommandLineParser; import org.apache.flink.runtime.entrypoint.parser.ParserResultFactory; import org.apache.flink.runtime.util.ClusterUncaughtExceptionHandler; @@ -33,6 +38,7 @@ import org.slf4j.LoggerFactory; import javax.annotation.Nullable; import java.io.File; +import java.io.IOException; import java.util.Optional; /** Utility class for {@link org.apache.flink.runtime.entrypoint.ClusterEntrypoint}. */ @@ -128,4 +134,104 @@ public final class ClusterEntrypointUtils { new ClusterUncaughtExceptionHandler( config.get(ClusterOptions.UNCAUGHT_EXCEPTION_HANDLING))); } + + /** + * Creates the working directory for the TaskManager process. This method ensures that the + * working directory exists. + * + * @param configuration to extract the required settings from + * @param resourceId identifying the TaskManager process + * @return working directory + * @throws IOException if the working directory could not be created + */ + public static WorkingDirectory createTaskManagerWorkingDirectory( + Configuration configuration, ResourceID resourceId) throws IOException { + return WorkingDirectory.create( + generateTaskManagerWorkingDirectoryFile(configuration, resourceId)); + } + + /** + * Generates the working directory {@link File} for the TaskManager process. This method does + * not ensure that the working directory exists. + * + * @param configuration to extract the required settings from + * @param resourceId identifying the TaskManager process + * @return working directory file + */ + @VisibleForTesting + public static File generateTaskManagerWorkingDirectoryFile( + Configuration configuration, ResourceID resourceId) { + return generateWorkingDirectoryFile( + configuration, + Optional.of(ClusterOptions.TASK_MANAGER_PROCESS_WORKING_DIR_BASE), + "tm_" + resourceId); + } + + /** + * Generates the working directory {@link File} for the JobManager process. This method does not + * ensure that the working directory exists. + * + * @param configuration to extract the required settings from + * @param resourceId identifying the JobManager process + * @return working directory file + */ + @VisibleForTesting + public static File generateJobManagerWorkingDirectoryFile( + Configuration configuration, ResourceID resourceId) { + return generateWorkingDirectoryFile( + configuration, + Optional.of(ClusterOptions.JOB_MANAGER_PROCESS_WORKING_DIR_BASE), + "jm_" + resourceId); + } + + /** + * Generate the working directory from the given configuration. If a working dir option is + * specified, then this config option will be read first. At last, {@link CoreOptions#TMP_DIRS} + * will be used to extract the working directory base from. + * + * @param configuration to extract the working directory from + * @param workingDirOption optional working dir option + * @param workingDirectoryName name of the working directory to create + * @return working directory + */ + public static File generateWorkingDirectoryFile( + Configuration configuration, + Optional> workingDirOption, + String workingDirectoryName) { + final Optional optionalWorkingDirectory = + workingDirOption.flatMap(configuration::getOptional); + + final File workingDirectoryBase = + optionalWorkingDirectory + .map(File::new) + .orElseGet( + () -> { + final File tempDirectory = + ConfigurationUtils.getRandomTempDirectory( + configuration); + + LOG.debug( + "Picked {} randomly from the configured temporary directories to be used as working directory base.", + tempDirectory); + + return tempDirectory; + }); + + return new File(workingDirectoryBase, workingDirectoryName); + } + + /** + * Creates the working directory for the JobManager process. This method ensures that the + * working diretory exists. + * + * @param configuration to extract the required settings from + * @param resourceId identifying the TaskManager process + * @return working directory + * @throws IOException if the working directory could not be created + */ + public static WorkingDirectory createJobManagerWorkingDirectory( + Configuration configuration, ResourceID resourceId) throws IOException { + return WorkingDirectory.create( + generateJobManagerWorkingDirectoryFile(configuration, resourceId)); + } } diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/WorkingDirectory.java b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/WorkingDirectory.java new file mode 100644 index 00000000..df63ffe4 --- /dev/null +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/WorkingDirectory.java @@ -0,0 +1,83 @@ +/* + * 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.entrypoint; + +import org.apache.flink.util.FileUtils; + +import java.io.File; +import java.io.IOException; + +/** + * Class that manages a working directory for a process/instance. When being instantiated, this + * class makes sure that the specified working directory exists. + */ +public class WorkingDirectory { + private final File root; + private final File tmp; + private final File localState; + + private WorkingDirectory(File root) throws IOException { + this.root = root; + createDirectory(root); + + this.tmp = new File(root, "tmp"); + createDirectory(tmp); + FileUtils.cleanDirectory(tmp); + + localState = new File(root, "localState"); + createDirectory(localState); + } + + private static void createDirectory(File directory) throws IOException { + if (!directory.mkdirs() && !directory.exists()) { + throw new IOException( + String.format("Could not create the working directory %s.", directory)); + } + } + + public void delete() throws IOException { + FileUtils.deleteDirectory(root); + } + + public File getTmpDirectory() { + return tmp; + } + + public File getLocalStateDirectory() { + return localState; + } + + public WorkingDirectory createSubWorkingDirectory(String directoryName) throws IOException { + return createIn(root, directoryName); + } + + @Override + public String toString() { + return String.format("WorkingDirectory(%s)", root.toString()); + } + + public static WorkingDirectory create(File workingDirectory) throws IOException { + return new WorkingDirectory(workingDirectory); + } + + public static WorkingDirectory createIn(File parentDirectory, String directoryName) + throws IOException { + return create(new File(parentDirectory, directoryName)); + } +} diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DefaultDispatcherResourceManagerComponentFactory.java b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DefaultDispatcherResourceManagerComponentFactory.java index 83f630ee..0d514f51 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DefaultDispatcherResourceManagerComponentFactory.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DefaultDispatcherResourceManagerComponentFactory.java @@ -22,6 +22,7 @@ import org.apache.flink.configuration.Configuration; import org.apache.flink.configuration.MetricOptions; import org.apache.flink.configuration.RestOptions; import org.apache.flink.runtime.blob.BlobServer; +import org.apache.flink.runtime.clusterframework.types.ResourceID; import org.apache.flink.runtime.dispatcher.DispatcherGateway; import org.apache.flink.runtime.dispatcher.DispatcherId; import org.apache.flink.runtime.dispatcher.DispatcherOperationCaches; @@ -101,6 +102,7 @@ public class DefaultDispatcherResourceManagerComponentFactory @Override public DispatcherResourceManagerComponent create( Configuration configuration, + ResourceID resourceId, Executor ioExecutor, RpcService rpcService, HighAvailabilityServices highAvailabilityServices, @@ -178,6 +180,7 @@ public class DefaultDispatcherResourceManagerComponentFactory ResourceManagerServiceImpl.create( resourceManagerFactory, configuration, + resourceId, rpcService, highAvailabilityServices, heartbeatServices, diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DispatcherResourceManagerComponentFactory.java b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DispatcherResourceManagerComponentFactory.java index 8cddd193..9d9c9852 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DispatcherResourceManagerComponentFactory.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/entrypoint/component/DispatcherResourceManagerComponentFactory.java @@ -20,6 +20,7 @@ package org.apache.flink.runtime.entrypoint.component; import org.apache.flink.configuration.Configuration; import org.apache.flink.runtime.blob.BlobServer; +import org.apache.flink.runtime.clusterframework.types.ResourceID; import org.apache.flink.runtime.dispatcher.ExecutionGraphInfoStore; import org.apache.flink.runtime.heartbeat.HeartbeatServices; import org.apache.flink.runtime.highavailability.HighAvailabilityServices; @@ -35,6 +36,7 @@ public interface DispatcherResourceManagerComponentFactory { DispatcherResourceManagerComponent create( Configuration configuration, + ResourceID resourceId, Executor ioExecutor, RpcService rpcService, HighAvailabilityServices highAvailabilityServices, diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/minicluster/MiniCluster.java b/flink-runtime/src/main/java/org/apache/flink/runtime/minicluster/MiniCluster.java index 5b095743..b3f333a7 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/minicluster/MiniCluster.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/minicluster/MiniCluster.java @@ -45,6 +45,7 @@ import org.apache.flink.runtime.dispatcher.MemoryExecutionGraphInfoStore; import org.apache.flink.runtime.dispatcher.TriggerSavepointMode; import org.apache.flink.runtime.entrypoint.ClusterEntrypointUtils; import org.apache.flink.runtime.entrypoint.ClusterInformation; +import org.apache.flink.runtime.entrypoint.WorkingDirectory; import org.apache.flink.runtime.entrypoint.component.DefaultDispatcherResourceManagerComponentFactory; import org.apache.flink.runtime.entrypoint.component.DispatcherResourceManagerComponent; import org.apache.flink.runtime.entrypoint.component.DispatcherResourceManagerComponentFactory; @@ -201,6 +202,9 @@ public class MiniCluster implements AutoCloseableAsync { @GuardedBy("lock") private RpcServiceFactory taskManagerRpcServiceFactory; + @GuardedBy("lock") + private WorkingDirectory workingDirectory; + /** Flag marking the mini cluster as started/running. */ private volatile boolean running; @@ -283,6 +287,13 @@ public class MiniCluster implements AutoCloseableAsync { miniClusterConfiguration.getRpcServiceSharing() == RpcServiceSharing.SHARED; try { + workingDirectory = + WorkingDirectory.create( + ClusterEntrypointUtils.generateWorkingDirectoryFile( + configuration, + Optional.empty(), + "minicluster_" + ResourceID.generate())); + initializeIOFormatClasses(configuration); rpcSystem = RpcSystem.load(configuration); @@ -482,6 +493,7 @@ public class MiniCluster implements AutoCloseableAsync { return Collections.singleton( dispatcherResourceManagerComponentFactory.create( configuration, + ResourceID.generate(), ioExecutor, rpcServiceFactory.createRpcService(), haServices, @@ -580,7 +592,11 @@ public class MiniCluster implements AutoCloseableAsync { remainingServicesTerminationFuture, () -> terminateExecutors(shutdownTimeoutMillis)); - executorsTerminationFuture.whenComplete( + final CompletableFuture deleteDirectoriesFuture = + FutureUtils.runAfterwards( + executorsTerminationFuture, this::deleteDirectories); + + deleteDirectoriesFuture.whenComplete( (Void ignored, Throwable throwable) -> { if (throwable != null) { terminationFuture.completeExceptionally( @@ -653,6 +669,7 @@ public class MiniCluster implements AutoCloseableAsync { blobCacheService, useLocalCommunication(), ExternalResourceInfoProvider.NO_EXTERNAL_RESOURCES, + workingDirectory.createSubWorkingDirectory("tm_" + taskManagers.size()), taskManagerTerminatingFatalErrorHandlerFactory.create( taskManagers.size())); @@ -1175,6 +1192,14 @@ public class MiniCluster implements AutoCloseableAsync { } } + private void deleteDirectories() throws IOException { + synchronized (lock) { + if (workingDirectory != null) { + workingDirectory.delete(); + } + } + } + /** Internal factory for {@link RpcService}. */ protected interface RpcServiceFactory { RpcService createRpcService() throws Exception; diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerFactory.java b/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerFactory.java index fd8a9f6d..6bb6b7b3 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerFactory.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerFactory.java @@ -50,6 +50,7 @@ public abstract class ResourceManagerFactory { public ResourceManagerProcessContext createResourceManagerProcessContext( Configuration configuration, + ResourceID resourceId, RpcService rpcService, HighAvailabilityServices highAvailabilityServices, HeartbeatServices heartbeatServices, @@ -77,6 +78,7 @@ public abstract class ResourceManagerFactory { return new ResourceManagerProcessContext( rmConfig, + resourceId, runtimeServiceConfig, rpcService, highAvailabilityServices, @@ -90,8 +92,7 @@ public abstract class ResourceManagerFactory { } public ResourceManager createResourceManager( - ResourceManagerProcessContext context, UUID leaderSessionId, ResourceID resourceId) - throws Exception { + ResourceManagerProcessContext context, UUID leaderSessionId) throws Exception { final ResourceManagerRuntimeServices resourceManagerRuntimeServices = createResourceManagerRuntimeServices( @@ -102,7 +103,7 @@ public abstract class ResourceManagerFactory { return createResourceManager( context.getRmConfig(), - resourceId, + context.getResourceId(), context.getRpcService(), leaderSessionId, context.getHeartbeatServices(), diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerProcessContext.java b/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerProcessContext.java index 79d8ed13..994947de 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerProcessContext.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerProcessContext.java @@ -19,6 +19,7 @@ package org.apache.flink.runtime.resourcemanager; import org.apache.flink.configuration.Configuration; +import org.apache.flink.runtime.clusterframework.types.ResourceID; import org.apache.flink.runtime.entrypoint.ClusterInformation; import org.apache.flink.runtime.heartbeat.HeartbeatServices; import org.apache.flink.runtime.highavailability.HighAvailabilityServices; @@ -41,6 +42,7 @@ import static org.apache.flink.util.Preconditions.checkNotNull; */ public class ResourceManagerProcessContext { private final Configuration rmConfig; + private final ResourceID resourceId; private final ResourceManagerRuntimeServicesConfiguration rmRuntimeServicesConfig; private final RpcService rpcService; private final HighAvailabilityServices highAvailabilityServices; @@ -54,6 +56,7 @@ public class ResourceManagerProcessContext { public ResourceManagerProcessContext( Configuration rmConfig, + ResourceID resourceId, ResourceManagerRuntimeServicesConfiguration rmRuntimeServicesConfig, RpcService rpcService, HighAvailabilityServices highAvailabilityServices, @@ -65,6 +68,7 @@ public class ResourceManagerProcessContext { SlotManagerMetricGroup slotManagerMetricGroup, Executor ioExecutor) { this.rmConfig = checkNotNull(rmConfig); + this.resourceId = checkNotNull(resourceId); this.rmRuntimeServicesConfig = checkNotNull(rmRuntimeServicesConfig); this.rpcService = checkNotNull(rpcService); this.highAvailabilityServices = checkNotNull(highAvailabilityServices); @@ -82,6 +86,10 @@ public class ResourceManagerProcessContext { return rmConfig; } + public ResourceID getResourceId() { + return resourceId; + } + public ResourceManagerRuntimeServicesConfiguration getRmRuntimeServicesConfig() { return rmRuntimeServicesConfig; } diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerServiceImpl.java b/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerServiceImpl.java index 2486377f..c0c038fa 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerServiceImpl.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/resourcemanager/ResourceManagerServiceImpl.java @@ -242,8 +242,7 @@ public class ResourceManagerServiceImpl implements ResourceManagerService, Leade this.leaderSessionID = newLeaderSessionID; this.leaderResourceManager = - resourceManagerFactory.createResourceManager( - rmProcessContext, newLeaderSessionID, ResourceID.generate()); + resourceManagerFactory.createResourceManager(rmProcessContext, newLeaderSessionID); final ResourceManager newLeaderResourceManager = this.leaderResourceManager; @@ -334,6 +333,7 @@ public class ResourceManagerServiceImpl implements ResourceManagerService, Leade public static ResourceManagerServiceImpl create( ResourceManagerFactory resourceManagerFactory, Configuration configuration, + ResourceID resourceId, RpcService rpcService, HighAvailabilityServices highAvailabilityServices, HeartbeatServices heartbeatServices, @@ -349,6 +349,7 @@ public class ResourceManagerServiceImpl implements ResourceManagerService, Leade resourceManagerFactory, resourceManagerFactory.createResourceManagerProcessContext( configuration, + resourceId, rpcService, highAvailabilityServices, heartbeatServices, diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerConfiguration.java b/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerConfiguration.java index bae9b60c..d0780969 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerConfiguration.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerConfiguration.java @@ -70,6 +70,8 @@ public class TaskManagerConfiguration implements TaskManagerRuntimeInfo { private final String taskManagerExternalAddress; + private final File tmpWorkingDirectory; + private final RetryingRegistrationConfiguration retryingRegistrationConfiguration; public TaskManagerConfiguration( @@ -86,6 +88,7 @@ public class TaskManagerConfiguration implements TaskManagerRuntimeInfo { @Nullable String taskManagerStdoutPath, @Nullable String taskManagerLogDir, String taskManagerExternalAddress, + File tmpWorkingDirectory, RetryingRegistrationConfiguration retryingRegistrationConfiguration) { this.numberSlots = numberSlots; @@ -102,6 +105,7 @@ public class TaskManagerConfiguration implements TaskManagerRuntimeInfo { this.taskManagerStdoutPath = taskManagerStdoutPath; this.taskManagerLogDir = taskManagerLogDir; this.taskManagerExternalAddress = taskManagerExternalAddress; + this.tmpWorkingDirectory = tmpWorkingDirectory; this.retryingRegistrationConfiguration = retryingRegistrationConfiguration; } @@ -165,6 +169,11 @@ public class TaskManagerConfiguration implements TaskManagerRuntimeInfo { return taskManagerExternalAddress; } + @Override + public File getTmpWorkingDirectory() { + return tmpWorkingDirectory; + } + public RetryingRegistrationConfiguration getRetryingRegistrationConfiguration() { return retryingRegistrationConfiguration; } @@ -176,7 +185,8 @@ public class TaskManagerConfiguration implements TaskManagerRuntimeInfo { public static TaskManagerConfiguration fromConfiguration( Configuration configuration, TaskExecutorResourceSpec taskExecutorResourceSpec, - String externalAddress) { + String externalAddress, + File tmpWorkingDirectory) { int numberSlots = configuration.getInteger(TaskManagerOptions.NUM_TASK_SLOTS, 1); if (numberSlots == -1) { @@ -247,6 +257,7 @@ public class TaskManagerConfiguration implements TaskManagerRuntimeInfo { taskManagerStdoutPath, taskManagerLogDir, externalAddress, + tmpWorkingDirectory, retryingRegistrationConfiguration); } } diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerRunner.java b/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerRunner.java index 9d1e0483..2ebccca4 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerRunner.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerRunner.java @@ -37,6 +37,7 @@ import org.apache.flink.runtime.blob.TaskExecutorBlobService; import org.apache.flink.runtime.clusterframework.types.ResourceID; import org.apache.flink.runtime.entrypoint.ClusterEntrypointUtils; import org.apache.flink.runtime.entrypoint.FlinkParseException; +import org.apache.flink.runtime.entrypoint.WorkingDirectory; import org.apache.flink.runtime.externalresource.ExternalResourceInfoProvider; import org.apache.flink.runtime.externalresource.ExternalResourceUtils; import org.apache.flink.runtime.heartbeat.HeartbeatServices; @@ -79,6 +80,7 @@ import org.apache.flink.util.concurrent.FutureUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.IOException; import java.lang.reflect.UndeclaredThrowableException; import java.net.InetAddress; import java.time.Duration; @@ -127,6 +129,8 @@ public class TaskManagerRunner implements FatalErrorHandler { private final TaskExecutorService taskExecutorService; + private final WorkingDirectory workingDirectory; + private final CompletableFuture terminationFuture; private final RpcSystem rpcSystem; @@ -165,6 +169,11 @@ public class TaskManagerRunner implements FatalErrorHandler { getTaskManagerResourceID( configuration, rpcService.getAddress(), rpcService.getPort()); + this.workingDirectory = + ClusterEntrypointUtils.createTaskManagerWorkingDirectory(configuration, resourceId); + + LOG.info("Using working directory: {}", workingDirectory); + HeartbeatServices heartbeatServices = HeartbeatServices.fromConfiguration(configuration); metricRegistry = @@ -198,6 +207,7 @@ public class TaskManagerRunner implements FatalErrorHandler { blobCacheService, false, externalResourceInfoProvider, + workingDirectory, this); this.terminationFuture = new CompletableFuture<>(); @@ -256,8 +266,19 @@ public class TaskManagerRunner implements FatalErrorHandler { FutureUtils.composeAfterwards( taskManagerTerminationFuture, this::shutDownServices); + final CompletableFuture workingDirCleanupFuture; + + if (terminationResult == Result.SUCCESS) { + workingDirCleanupFuture = + FutureUtils.runAfterwards( + serviceTerminationFuture, this::deleteWorkingDir); + } else { + // keep the working directory in case of a failure + workingDirCleanupFuture = serviceTerminationFuture; + } + final CompletableFuture rpcSystemClassLoaderCloseFuture = - FutureUtils.runAfterwards(serviceTerminationFuture, rpcSystem::close); + FutureUtils.runAfterwards(workingDirCleanupFuture, rpcSystem::close); rpcSystemClassLoaderCloseFuture.whenComplete( (Void ignored, Throwable throwable) -> { @@ -273,6 +294,12 @@ public class TaskManagerRunner implements FatalErrorHandler { return terminationFuture; } + private void deleteWorkingDir() throws IOException { + if (workingDirectory != null) { + workingDirectory.delete(); + } + } + private CompletableFuture shutDownServices() { synchronized (lock) { Collection> terminationFutures = new ArrayList<>(3); @@ -455,6 +482,7 @@ public class TaskManagerRunner implements FatalErrorHandler { BlobCacheService blobCacheService, boolean localCommunicationOnly, ExternalResourceInfoProvider externalResourceInfoProvider, + WorkingDirectory workingDirectory, FatalErrorHandler fatalErrorHandler) throws Exception { @@ -469,6 +497,7 @@ public class TaskManagerRunner implements FatalErrorHandler { blobCacheService, localCommunicationOnly, externalResourceInfoProvider, + workingDirectory, fatalErrorHandler); return TaskExecutorToServiceAdapter.createFor(taskExecutor); @@ -484,6 +513,7 @@ public class TaskManagerRunner implements FatalErrorHandler { TaskExecutorBlobService taskExecutorBlobService, boolean localCommunicationOnly, ExternalResourceInfoProvider externalResourceInfoProvider, + WorkingDirectory workingDirectory, FatalErrorHandler fatalErrorHandler) throws Exception { @@ -505,7 +535,8 @@ public class TaskManagerRunner implements FatalErrorHandler { resourceID, externalAddress, localCommunicationOnly, - taskExecutorResourceSpec); + taskExecutorResourceSpec, + workingDirectory); Tuple2 taskManagerMetricGroup = MetricUtils.instantiateTaskManagerMetricGroup( @@ -534,7 +565,10 @@ public class TaskManagerRunner implements FatalErrorHandler { TaskManagerConfiguration taskManagerConfiguration = TaskManagerConfiguration.fromConfiguration( - configuration, taskExecutorResourceSpec, externalAddress); + configuration, + taskExecutorResourceSpec, + externalAddress, + workingDirectory.getTmpDirectory()); String metricQueryServiceAddress = metricRegistry.getMetricQueryServiceGatewayRpcAddress(); @@ -654,6 +688,7 @@ public class TaskManagerRunner implements FatalErrorHandler { BlobCacheService blobCacheService, boolean localCommunicationOnly, ExternalResourceInfoProvider externalResourceInfoProvider, + WorkingDirectory workingDirectory, FatalErrorHandler fatalErrorHandler) throws Exception; } diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerServicesConfiguration.java b/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerServicesConfiguration.java index 65963586..1f163828 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerServicesConfiguration.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/taskexecutor/TaskManagerServicesConfiguration.java @@ -29,6 +29,7 @@ import org.apache.flink.configuration.NettyShuffleEnvironmentOptions; import org.apache.flink.configuration.TaskManagerOptions; import org.apache.flink.runtime.clusterframework.types.ResourceID; import org.apache.flink.runtime.entrypoint.ClusterEntrypointUtils; +import org.apache.flink.runtime.entrypoint.WorkingDirectory; import org.apache.flink.runtime.execution.librarycache.FlinkUserCodeClassLoaders; import org.apache.flink.runtime.registration.RetryingRegistrationConfiguration; import org.apache.flink.runtime.util.ConfigurationParserUtils; @@ -36,6 +37,7 @@ import org.apache.flink.util.NetUtils; import javax.annotation.Nullable; +import java.io.File; import java.net.InetAddress; import java.util.Optional; @@ -239,6 +241,8 @@ public class TaskManagerServicesConfiguration { * accessible * @param localCommunicationOnly True if only local communication is possible. Use only in cases * where only one task manager runs. + * @param taskExecutorResourceSpec resource specification of the TaskManager to start + * @param workingDirectory working directory of the TaskManager * @return configuration of task manager services used to create them */ public static TaskManagerServicesConfiguration fromConfiguration( @@ -246,13 +250,15 @@ public class TaskManagerServicesConfiguration { ResourceID resourceID, String externalAddress, boolean localCommunicationOnly, - TaskExecutorResourceSpec taskExecutorResourceSpec) + TaskExecutorResourceSpec taskExecutorResourceSpec, + WorkingDirectory workingDirectory) throws Exception { - final String[] tmpDirs = ConfigurationUtils.parseTempDirectories(configuration); String[] localStateRootDir = ConfigurationUtils.parseLocalStateDirectories(configuration); + if (localStateRootDir.length == 0) { - // default to temp dirs. - localStateRootDir = tmpDirs; + final File localStateDir = workingDirectory.getLocalStateDirectory(); + + localStateRootDir = new String[] {localStateDir.getAbsolutePath()}; } boolean localRecoveryMode = configuration.getBoolean(CheckpointingOptions.LOCAL_RECOVERY); @@ -282,6 +288,8 @@ public class TaskManagerServicesConfiguration { final int numIoThreads = ClusterEntrypointUtils.getPoolSize(configuration); + final String[] tmpDirs = ConfigurationUtils.parseTempDirectories(configuration); + return new TaskManagerServicesConfiguration( configuration, resourceID, diff --git a/flink-runtime/src/main/java/org/apache/flink/runtime/taskmanager/TaskManagerRuntimeInfo.java b/flink-runtime/src/main/java/org/apache/flink/runtime/taskmanager/TaskManagerRuntimeInfo.java index 200cc533..6e3c886b 100644 --- a/flink-runtime/src/main/java/org/apache/flink/runtime/taskmanager/TaskManagerRuntimeInfo.java +++ b/flink-runtime/src/main/java/org/apache/flink/runtime/taskmanager/TaskManagerRuntimeInfo.java @@ -22,6 +22,8 @@ import org.apache.flink.configuration.Configuration; import org.apache.flink.configuration.TaskManagerOptions; import org.apache.flink.runtime.taskexecutor.TaskExecutor; +import java.io.File; + /** Interface to access {@link TaskExecutor} information. */ public interface TaskManagerRuntimeInfo { @@ -62,4 +64,11 @@ public interface TaskManagerRuntimeInfo { default String getTaskManagerBindAddress() { return getConfiguration().getString(TaskManagerOptions.BIND_HOST); } + + /** + * Gets the temporary working directory of the TaskManager instance. + * + * @return The temporary working directory of the TaskManager. + */ + File getTmpWorkingDirectory(); } diff --git a/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/EmbeddedRocksDBStateBackend.java b/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/EmbeddedRocksDBStateBackend.java index 7fa2e507..cb7e8d94 100644 --- a/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/EmbeddedRocksDBStateBackend.java +++ b/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/EmbeddedRocksDBStateBackend.java @@ -321,8 +321,7 @@ public class EmbeddedRocksDBStateBackend extends AbstractManagedMemoryStateBacke // initialize the paths where the local RocksDB files should be stored if (localRocksDbDirectories == null) { - // initialize from the temp directories - initializedDbBasePaths = env.getIOManager().getSpillingDirectories(); + initializedDbBasePaths = new File[] {env.getTaskManagerInfo().getTmpWorkingDirectory()}; } else { List dirs = new ArrayList<>(localRocksDbDirectories.length); StringBuilder errorMessage = new StringBuilder(); @@ -414,7 +413,7 @@ public class EmbeddedRocksDBStateBackend extends AbstractManagedMemoryStateBacke // first, make sure that the RocksDB JNI library is loaded // we do this explicitly here to have better error handling - String tempDir = env.getTaskManagerInfo().getTmpDirectories()[0]; + String tempDir = env.getTaskManagerInfo().getTmpWorkingDirectory().getAbsolutePath(); ensureRocksDBIsLoaded(tempDir); // replace all characters that are not legal for filenames with underscore diff --git a/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/RocksDBOptions.java b/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/RocksDBOptions.java index 0cf36028..f9d602d8 100644 --- a/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/RocksDBOptions.java +++ b/flink-state-backends/flink-statebackend-rocksdb/src/main/java/org/apache/flink/contrib/streaming/state/RocksDBOptions.java @@ -19,9 +19,12 @@ package org.apache.flink.contrib.streaming.state; import org.apache.flink.annotation.docs.Documentation; +import org.apache.flink.configuration.ClusterOptions; import org.apache.flink.configuration.ConfigOption; import org.apache.flink.configuration.ConfigOptions; import org.apache.flink.configuration.MemorySize; +import org.apache.flink.configuration.description.Description; +import org.apache.flink.configuration.description.TextElement; import static org.apache.flink.contrib.streaming.state.EmbeddedRocksDBStateBackend.PriorityQueueStateType.ROCKSDB; import static org.apache.flink.contrib.streaming.state.PredefinedOptions.DEFAULT; @@ -40,7 +43,14 @@ public class RocksDBOptions { .noDefaultValue() .withDeprecatedKeys("state.backend.rocksdb.checkpointdir") .withDescription( - "The local directory (on the TaskManager) where RocksDB puts its files."); + Description.builder() + .text( + "The local directory (on the TaskManager) where RocksDB puts its files. Per default, it will be /tmp. See %s for more details.", + TextElement.code( + ClusterOptions + .TASK_MANAGER_PROCESS_WORKING_DIR_BASE + .key())) + .build()); /** Choice of timer service implementation. */ @Documentation.Section(Documentation.Sections.STATE_BACKEND_ROCKSDB)