| |
| |
| |
| |
| @@ -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); |
| } |
| } |
| |
| |
| |
| |
| @@ -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 <WORKING_DIR>/localState. The <WORKING_DIR> 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 |
| |
| |
| |
| |
| @@ -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<String> 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<String> 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<String> 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; |
| |
| |
| |
| |
| @@ -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}. |
| |
| |
| |
| |
| @@ -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<String> 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() { |
| |
| |
| |
| |
| @@ -150,7 +150,7 @@ public class SavepointEnvironment implements Environment { |
| |
| @Override |
| public TaskManagerRuntimeInfo getTaskManagerInfo() { |
| - return new SavepointTaskManagerRuntimeInfo(getIOManager()); |
| + return new SavepointTaskManagerRuntimeInfo(getIOManager().getSpillingDirectories()[0]); |
| } |
| |
| @Override |
| |
| |
| |
| |
| @@ -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; |
| + } |
| } |
| |
| |
| |
| |
| @@ -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<Void> 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, |
| } |
| } |
| |
| |
| |
| |
| @@ -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<ConfigOption<String>> workingDirOption, |
| + String workingDirectoryName) { |
| + final Optional<String> 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)); |
| + } |
| } |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -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)); |
| + } |
| +} |
| |
| |
| |
| |
| @@ -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, |
| |
| |
| |
| |
| @@ -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, |
| |
| |
| |
| |
| @@ -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<Void> 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; |
| |
| |
| |
| |
| @@ -50,6 +50,7 @@ public abstract class ResourceManagerFactory<T extends ResourceIDRetrievable> { |
| |
| public ResourceManagerProcessContext createResourceManagerProcessContext( |
| Configuration configuration, |
| + ResourceID resourceId, |
| RpcService rpcService, |
| HighAvailabilityServices highAvailabilityServices, |
| HeartbeatServices heartbeatServices, |
| @@ -77,6 +78,7 @@ public abstract class ResourceManagerFactory<T extends ResourceIDRetrievable> { |
| |
| return new ResourceManagerProcessContext( |
| rmConfig, |
| + resourceId, |
| runtimeServiceConfig, |
| rpcService, |
| highAvailabilityServices, |
| @@ -90,8 +92,7 @@ public abstract class ResourceManagerFactory<T extends ResourceIDRetrievable> { |
| } |
| |
| public ResourceManager<T> 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<T extends ResourceIDRetrievable> { |
| |
| return createResourceManager( |
| context.getRmConfig(), |
| - resourceId, |
| + context.getResourceId(), |
| context.getRpcService(), |
| leaderSessionId, |
| context.getHeartbeatServices(), |
| |
| |
| |
| |
| @@ -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; |
| } |
| |
| |
| |
| |
| @@ -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, |
| |
| |
| |
| |
| @@ -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); |
| } |
| } |
| |
| |
| |
| |
| @@ -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<Result> 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<Void> 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<Void> 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<Void> shutDownServices() { |
| synchronized (lock) { |
| Collection<CompletableFuture<Void>> 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, MetricGroup> 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; |
| } |
| |
| |
| |
| |
| @@ -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, |
| |
| |
| |
| |
| @@ -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(); |
| } |
| |
| |
| |
| |
| @@ -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<File> 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 |
| |
| |
| |
| |
| @@ -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 <WORKING_DIR>/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) |
|
|
