embulk 0.8.27 → 0.8.28

data/embulk-cli/src/main/java/org/embulk/cli/parse/HelpMessageAsCliOption.java

@@ -0,0 +1,36 @@
+package org.embulk.cli.parse;
+
+import org.apache.commons.cli.Option;
+
+final class HelpMessageAsCliOption
+        extends Option
+{
+    public HelpMessageAsCliOption(final String message)
+    {
+        super("_", message);
+    }
+
+    @Override
+    public final String toString()
+    {
+        return this.getDescription();
+    }
+
+    @Override
+    public final boolean equals(Object other)
+    {
+        return this == other;
+    }
+
+    @Override
+    public final int hashCode()
+    {
+        return this.getDescription().hashCode();
+    }
+
+    @Override
+    public final Object clone()
+    {
+        return new HelpMessageAsCliOption(this.getDescription());
+    }
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/HelpMessageLineDefinition.java

@@ -0,0 +1,20 @@
+package org.embulk.cli.parse;
+
+import org.apache.commons.cli.Option;
+
+class HelpMessageLineDefinition
+        extends AbstractHelpLineDefinition
+{
+    HelpMessageLineDefinition(final String message)
+    {
+        this.cliOption = new HelpMessageAsCliOption(message);
+    }
+
+    @Override
+    final Option getCliOption()
+    {
+        return this.cliOption;
+    }
+
+    private final Option cliOption;
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/OptionBehavior.java

@@ -0,0 +1,39 @@
+package org.embulk.cli.parse;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import org.embulk.cli.EmbulkCommandLine;
+
+public abstract class OptionBehavior
+{
+    public OptionBehavior()
+    {
+        this.helpWriter = SYSTEM_HELP_WRITER;
+        this.errorWriter = SYSTEM_ERROR_WRITER;
+    }
+
+    public OptionBehavior(final OutputStream helpStream, final OutputStream errorStream)
+    {
+        this.helpWriter = new PrintWriter(helpStream, true);
+        this.errorWriter = new PrintWriter(errorStream, true);
+    }
+
+    public abstract void behave(final EmbulkCommandLine.Builder commandLineBuilder, final String argument)
+            throws EmbulkCommandLineParseException;
+
+    protected final PrintWriter helpWriter()
+    {
+        return this.helpWriter;
+    }
+
+    protected final PrintWriter errorWriter()
+    {
+        return this.errorWriter;
+    }
+
+    private static final PrintWriter SYSTEM_HELP_WRITER = new PrintWriter(System.out, true);
+    private static final PrintWriter SYSTEM_ERROR_WRITER = new PrintWriter(System.err, true);
+
+    private final PrintWriter helpWriter;
+    private final PrintWriter errorWriter;
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/OptionDefinition.java

@@ -0,0 +1,120 @@
+package org.embulk.cli.parse;
+
+import org.apache.commons.cli.Option;
+import org.embulk.cli.EmbulkCommandLine;
+
+public class OptionDefinition
+        extends AbstractHelpLineDefinition
+{
+    private OptionDefinition(
+            final String shortOption,
+            final String longOption,
+            final boolean hasArgument,
+            final String argumentNameDisplayed,
+            final String description,
+            final boolean printsHelp,
+            final OptionBehavior behavior)
+    {
+        final Option.Builder builder;
+
+        if (shortOption == null) {
+            builder = Option.builder();
+        }
+        else {
+            builder = Option.builder(shortOption);
+        }
+
+        if (longOption != null) {
+            builder.longOpt(longOption);
+        }
+
+        if (hasArgument) {
+            builder.hasArg(true);
+            builder.argName(argumentNameDisplayed);
+        }
+        if (description != null) {
+            builder.desc(description);
+        }
+        this.cliOption = builder.build();
+        this.printsHelp = printsHelp;
+        this.behavior = behavior;
+    }
+
+    public static OptionDefinition defineOnlyLongOptionWithArgument(
+            final String longOption,
+            final String argumentNameDisplayed,
+            final String description,
+            final OptionBehavior behavior)
+    {
+        return new OptionDefinition(null, longOption, true, argumentNameDisplayed, description, false, behavior);
+    }
+
+    public static OptionDefinition defineOnlyShortOptionWithArgument(
+            final String shortOption,
+            final String argumentNameDisplayed,
+            final String description,
+            final OptionBehavior behavior)
+    {
+        return new OptionDefinition(shortOption, null, true, argumentNameDisplayed, description, false, behavior);
+    }
+
+    public static OptionDefinition defineOnlyShortOptionWithoutArgument(
+            final String shortOption,
+            final String description,
+            final OptionBehavior behavior)
+    {
+        return new OptionDefinition(shortOption, null, false, null, description, false, behavior);
+    }
+
+    public static OptionDefinition defineOptionWithoutArgument(
+            final String shortOption,
+            final String longOption,
+            final String description,
+            final OptionBehavior behavior)
+    {
+        return new OptionDefinition(shortOption, longOption, false, null, description, false, behavior);
+    }
+
+    public static OptionDefinition defineOptionWithArgument(
+            final String shortOption,
+            final String longOption,
+            final String argumentNameDisplayed,
+            final String description,
+            final OptionBehavior behavior)
+    {
+        return new OptionDefinition(shortOption, longOption, true, argumentNameDisplayed, description, false, behavior);
+    }
+
+    public static OptionDefinition defineHelpOption(
+            final String shortOption,
+            final String longOption,
+            final String description)
+    {
+        return new OptionDefinition(shortOption, longOption, false, null, description, true, new OptionBehavior() {
+                public void behave(final EmbulkCommandLine.Builder commandLineBuilder, final String argument)
+                {
+                }
+            });
+    }
+
+    @Override
+    final Option getCliOption()
+    {
+        return this.cliOption;
+    }
+
+    final void behave(final EmbulkCommandLine.Builder commandLineBuilder, final String argument)
+            throws EmbulkCommandLineParseException
+    {
+        this.behavior.behave(commandLineBuilder, argument);
+    }
+
+    final boolean printsHelp()
+    {
+        return this.printsHelp;
+    }
+
+    private final Option cliOption;
+    private final boolean printsHelp;
+    private final OptionBehavior behavior;
+}

data/embulk-cli/src/main/sh/{selfrun.sh → selfrun.sh.template}

@@ -64,7 +64,7 @@ done
 if test -z ${EMBULK_BUNDLE_PATH}; then
     unset EMBULK_BUNDLE_PATH
     unset BUNDLE_GEMFILE
-    GEM_HOME="`cd && pwd`/.embulk/jruby/`java -cp $0 org.jruby.Main -e 'print RbConfig::CONFIG["ruby_version"]'`"
+    GEM_HOME="`cd && pwd`/.embulk/jruby/<%= ruby_version %>"
     export GEM_HOME
     GEM_PATH=""
     export GEM_PATH

data/embulk-cli/src/test/java/org/embulk/cli/SelfrunTest.java

@@ -40,7 +40,11 @@ public class SelfrunTest {
             .replaceAll("java ",
                         "java -classpath "
                         + classpath.getAbsolutePath().replaceAll("\\\\", "\\\\\\\\")
-                        + " org.embulk.cli.DummyMain ");
+                        + " org.embulk.cli.DummyMain ")
+            // The following version string emulates RbConfig::CONFIG["ruby_version"].
+            // RbConfig::CONFIG["ruby_version"] is different from org.jruby.runtime.Constants.RUBY_VERSION.
+            // https://github.com/jruby/jruby/blob/9.1.5.0/core/src/main/java/org/jruby/ext/rbconfig/RbConfigLibrary.java#L229-L235
+            .replace("<%= ruby_version %>", org.jruby.runtime.Constants.RUBY_MAJOR_VERSION + ".0");
 
         // Modify selfrun so that arguments are written in 'args.txt' .
         Files.write(fileSystem.getPath(testSelfrunFile.getAbsolutePath()),
@@ -288,9 +292,9 @@ public class SelfrunTest {
             folder = new File(folder, "embulk-cli");
         }
         if (System.getProperty("file.separator").equals("\\")) {
-            return new File(new File(new File(new File(folder, "src"), "main"), "bat"), "selfrun.bat");
+            return new File(new File(new File(new File(folder, "src"), "main"), "bat"), "selfrun.bat.template");
         } else {
-            return new File(new File(new File(new File(folder, "src"), "main"), "sh"), "selfrun.sh");
+            return new File(new File(new File(new File(folder, "src"), "main"), "sh"), "selfrun.sh.template");
         }
     }
 }

data/embulk-core/src/main/java/org/embulk/EmbulkRunner.java

@@ -0,0 +1,526 @@
+package org.embulk;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Map;
+import java.util.regex.Pattern;
+import org.embulk.command.PreviewPrinter;
+import org.embulk.command.TablePreviewPrinter;
+import org.embulk.command.VerticalPreviewPrinter;
+import org.embulk.config.ConfigDiff;
+import org.embulk.config.ConfigException;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.DataSource;
+import org.embulk.config.ModelManager;
+import org.embulk.exec.ExecutionResult;
+import org.embulk.exec.PreviewResult;
+import org.embulk.exec.ResumeState;
+import org.embulk.exec.TransactionStage;
+import org.jruby.RubyHash;
+import org.jruby.embed.ScriptingContainer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * EmbulkRunner runs the guess, preview, or run subcommand.
+ *
+ * NOTE: Developers should not depend on this EmbulkRunner class. This class is created tentatively, and may be
+ * re-implemented again in a different style.
+ */
+public class EmbulkRunner
+{
+    // |EmbulkSetup.setup| initializes:
+    // new EmbulkRunner(embed, globalJRubyContainer)
+    public EmbulkRunner(final EmbulkEmbed embed, final ScriptingContainer globalJRubyContainer)
+    {
+        this.embed = embed;  // org.embulk.EmbulkEmbed
+        this.globalJRubyContainer = globalJRubyContainer;
+    }
+
+    /**
+     * Runs the guess subcommand.
+     *
+     * It receives Java Paths to be called from Java EmbulkRun in embulk-cli.
+     */
+    public void guess(final Path configFilePath, final Path outputPath)
+    {
+        // TODO: Utilize |templateParams| and |templateIncludePath|.
+        // They have not been used from embulk-cli while |template_params| and |template_include_path| are implemented
+        // in Ruby Embulk::EmbulkRunner.
+        final ConfigSource configSource;
+        try {
+            configSource = readConfig(
+                configFilePath, new RubyHash(this.globalJRubyContainer.getProvider().getRuntime()), null);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        try {
+            guessInternal(configSource, outputPath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    /**
+     * Runs the guess subcommand.
+     *
+     * It receives Strings as parameters to be called from Ruby (embulk/runner.rb).
+     */
+    public void guess(final String configFilePathString, final String outputPathString)
+    {
+        final Path outputPath = (outputPathString == null ? null : Paths.get(outputPathString));
+        guess(Paths.get(configFilePathString), outputPath);
+    }
+
+    /**
+     * Runs the guess subcommand.
+     *
+     * It receives a ConfigSource and a String as parameters to be called from Ruby (embulk/runner.rb).
+     */
+    public void guess(final ConfigSource configSource, final String outputPathString)
+    {
+        final Path outputPath = (outputPathString == null ? null : Paths.get(outputPathString));
+        try {
+            guessInternal(configSource, outputPath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    /**
+     * Runs the guess subcommand.
+     *
+     * It receives a Java Path and a String to be called from Java's EmbulkRun in embulk-cli.
+     */
+    public void preview(final Path configFilePath, final String format)
+    {
+        // TODO: Utilize |templateParams| and |templateIncludePath|.
+        // They have not been used from embulk-cli while |template_params| and |template_include_path| are implemented
+        // in Ruby Embulk::EmbulkRunner.
+        final ConfigSource configSource;
+        try {
+            configSource = readConfig(
+                configFilePath, new RubyHash(this.globalJRubyContainer.getProvider().getRuntime()), null);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        try {
+            previewInternal(configSource, format);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    /**
+     * Runs the preview subcommand.
+     *
+     * It receives Strings as parameters to be called from Ruby (embulk/runner.rb).
+     */
+    public void preview(final String configFilePathString, final String format)
+    {
+        preview(Paths.get(configFilePathString), format);
+    }
+
+    /**
+     * Runs the preview subcommand.
+     *
+     * It receives a ConfigSource and a String as parameters to be called from Ruby (embulk/runner.rb).
+     */
+    public void preview(final ConfigSource configSource, final String format)
+    {
+        try {
+            previewInternal(configSource, format);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    /**
+     * Runs the run subcommand.
+     *
+     * It receives Java Paths to be called from Java EmbulkRun in embulk-cli.
+     */
+    public void run(
+            final Path configFilePath,
+            final Path configDiffPath,
+            final Path outputPath,
+            final Path resumeStatePath)
+    {
+        // TODO: Utilize |templateParams| and |templateIncludePath|.
+        // They have not been used from embulk-cli while |template_params| and |template_include_path| are implemented
+        // in Ruby Embulk::EmbulkRunner.
+        final ConfigSource configSource;
+        try {
+            configSource = readConfig(
+                configFilePath, new RubyHash(this.globalJRubyContainer.getProvider().getRuntime()), null);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        try {
+            runInternal(configSource, configDiffPath, outputPath, resumeStatePath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    /**
+     * Runs the run subcommand.
+     *
+     * It receives Strings as parameters to be called from Ruby (embulk/runner.rb).
+     */
+    public void run(final String configFilePathString,
+                    final String configDiffPathString,
+                    final String outputPathString,
+                    final String resumeStatePathString)
+    {
+        final Path configDiffPath = (configDiffPathString == null ? null : Paths.get(configDiffPathString));
+        final Path outputPath = (outputPathString == null ? null : Paths.get(outputPathString));
+        final Path resumeStatePath = (resumeStatePathString == null ? null : Paths.get(resumeStatePathString));
+        run(Paths.get(configFilePathString), configDiffPath, outputPath, resumeStatePath);
+    }
+
+    /**
+     * Runs the run subcommand.
+     *
+     * It receives a ConfigSource and a String as parameters to be called from Ruby (embulk/runner.rb).
+     */
+    public void run(final ConfigSource configSource,
+                    final String configDiffPathString,
+                    final String outputPathString,
+                    final String resumeStatePathString)
+    {
+        final Path configDiffPath = (configDiffPathString == null ? null : Paths.get(configDiffPathString));
+        final Path outputPath = (outputPathString == null ? null : Paths.get(outputPathString));
+        final Path resumeStatePath = (resumeStatePathString == null ? null : Paths.get(resumeStatePathString));
+        try {
+            runInternal(configSource, configDiffPath, outputPath, resumeStatePath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    private void guessInternal(final ConfigSource configSource, final Path outputPath)
+            throws IOException
+    {
+        try {
+            checkFileWritable(outputPath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException("Not writable: " + outputPath.toString());
+        }
+
+        final ConfigDiff configDiff = this.embed.guess(configSource);
+        final ConfigSource guessedConfigSource = configSource.merge(configDiff);
+        final String yaml = writeConfig(outputPath, guessedConfigSource);
+        System.err.println(yaml);
+        if (outputPath != null) {
+            System.out.println("Created '" + outputPath + "' file.");
+        }
+        else {
+            System.out.println("Use -o PATH option to write the guessed config file to a file.");
+        }
+    }
+
+    private void previewInternal(final ConfigSource configSource, final String format)
+            throws IOException
+    {
+        final PreviewResult previewResult = this.embed.preview(configSource);
+        final ModelManager modelManager = this.embed.getModelManager();
+
+        final PreviewPrinter printer;
+        switch (format != null ? format : "table") {
+        case "table":
+            printer = new TablePreviewPrinter(System.out, modelManager, previewResult.getSchema());
+            break;
+        case "vertical":
+            printer = new VerticalPreviewPrinter(System.out, modelManager, previewResult.getSchema());
+            break;
+        default:
+            throw new IllegalArgumentException(
+                "Unknown preview output format '" + format + "'. Supported formats: table, vertical");
+        }
+
+        printer.printAllPages(previewResult.getPages());
+        printer.finish();
+    }
+
+    private void runInternal(
+            final ConfigSource originalConfigSource,
+            final Path configDiffPath,
+            final Path outputPath,  // deprecated
+            final Path resumeStatePath)
+            throws IOException
+    {
+        try {
+            checkFileWritable(outputPath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException("Not writable: " + outputPath.toString());
+        }
+        try {
+            checkFileWritable(configDiffPath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException("Not writable: " + configDiffPath.toString());
+        }
+        try {
+            checkFileWritable(resumeStatePath);
+        }
+        catch (IOException ex) {
+            throw new RuntimeException("Not writable: " + resumeStatePath.toString());
+        }
+
+        final ConfigSource configSource;
+        if (configDiffPath != null && Files.size(configDiffPath) > 0L) {
+            final ConfigSource lastConfigDiff =
+                readConfig(configDiffPath, new RubyHash(this.globalJRubyContainer.getProvider().getRuntime()), null);
+            configSource = originalConfigSource.merge(lastConfigDiff);
+        }
+        else {
+            configSource = originalConfigSource;
+        }
+
+        final ConfigSource resumeConfig;
+        if (resumeStatePath != null) {
+            ConfigSource resumeConfigTemp = null;
+            try {
+                resumeConfigTemp = readYamlConfigFile(resumeStatePath);
+            }
+            catch (Throwable ex) {
+                // TODO log?
+                resumeConfigTemp = null;
+            }
+            if (resumeConfigTemp == null || resumeConfigTemp.isEmpty()) {
+                resumeConfig = null;
+            }
+            else {
+                resumeConfig = resumeConfigTemp;
+            }
+        }
+        else {
+            resumeConfig = null;
+        }
+
+        final EmbulkEmbed.ResumableResult resumableResult;
+        final ExecutionResult executionResultTemp;
+        if (resumeConfig != null) {
+            resumableResult = this.embed.resumeState(configSource, resumeConfig).resume();
+            executionResultTemp = null;
+        }
+        else if (resumeStatePath != null) {
+            resumableResult = this.embed.runResumable(configSource);
+            executionResultTemp = null;
+        }
+        else {
+            resumableResult = null;
+            executionResultTemp = this.embed.run(configSource);
+        }
+
+        final ExecutionResult executionResult;
+        if (executionResultTemp == null) {
+            if (!resumableResult.isSuccessful()) {
+                if (resumableResult.getTransactionStage().isBefore(TransactionStage.RUN)) {
+                    // retry without resume state file if no tasks started yet
+                    // delete resume file
+                    if (resumeStatePath != null) {
+                        try {
+                            Files.deleteIfExists(resumeStatePath);
+                        }
+                        catch (Throwable ex) {
+                            System.err.println("Failed to delete: " + resumeStatePath.toString());
+                        }
+                    }
+                }
+                else {
+                    rootLogger.info("Writing resume state to '" + resumeStatePath.toString() + "'");
+                    try {
+                        writeResumeState(resumeStatePath, resumableResult.getResumeState());
+                    }
+                    catch (IOException ex) {
+                        throw new RuntimeException(ex);
+                    }
+                    rootLogger.info("Resume state is written. Run the transaction again with -r option to resume or use \"cleanup\" subcommand to delete intermediate data.");
+                }
+                throw new RuntimeException(resumableResult.getCause());
+            }
+            executionResult = resumableResult.getSuccessfulResult();
+        }
+        else {
+            executionResult = executionResultTemp;
+        }
+
+        // delete resume file
+        if (resumeStatePath != null) {
+            try {
+                Files.deleteIfExists(resumeStatePath);
+            }
+            catch (Throwable ex) {
+                System.err.println("Failed to delete: " + resumeStatePath.toString());
+            }
+        }
+
+        final ConfigDiff configDiff = executionResult.getConfigDiff();
+        rootLogger.info("Committed.");
+        rootLogger.info("Next config diff: " + configDiff.toString());
+
+        writeConfig(configDiffPath, configDiff);
+        writeConfig(outputPath, configSource.merge(configDiff));  // deprecated
+    }
+
+    // def resume_state(config, options={})
+    //   configSource = read_config(config, options)
+    //   Resumed.new(self, DataSource.from_java(configSource), options)
+    // end
+
+    private ConfigSource readConfig(
+            final Path configFilePath,
+            final RubyHash templateParams,
+            final String templateIncludePath)
+            throws IOException
+    {
+        final String configString = configFilePath.toString();
+        if (EXT_YAML_LIQUID.matcher(configFilePath.toString()).matches()) {
+            return this.embed.newConfigLoader().fromYamlString(
+                runLiquid(new String(Files.readAllBytes(configFilePath), StandardCharsets.UTF_8),
+                          templateParams,
+                          templateIncludePath));
+        }
+        else if (EXT_YAML.matcher(configFilePath.toString()).matches()) {
+            return this.embed.newConfigLoader().fromYamlString(
+                new String(Files.readAllBytes(configFilePath), StandardCharsets.UTF_8));
+        }
+        else {
+            throw new ConfigException(
+                "Unsupported file extension. Supported file extensions are .yml and .yml.liquid: " +
+                configFilePath.toString());
+        }
+    }
+
+    private ConfigSource readYamlConfigFile(final Path path)
+            throws IOException
+    {
+        return this.embed.newConfigLoader().fromYamlString(
+            new String(Files.readAllBytes(path), StandardCharsets.UTF_8));
+    }
+
+    private String runLiquid(
+            final String templateSource,
+            final RubyHash templateParams,
+            final String templateIncludePath)
+    {
+        this.globalJRubyContainer.runScriptlet("require 'liquid'");
+
+        this.globalJRubyContainer.put("__internal_liquid_template_source__", templateSource);
+        this.globalJRubyContainer.runScriptlet("template = Liquid::Template.parse(__internal_liquid_template_source__, :error_mode => :strict)");
+        this.globalJRubyContainer.remove("__internal_liquid_template_source__");
+
+        if (templateIncludePath != null) {
+            this.globalJRubyContainer.put("__internal_liquid_template_include_path_java__", templateIncludePath);
+            this.globalJRubyContainer.runScriptlet("__internal_liquid_template_include_path__ = File.expand_path(__internal_liquid_template_include_path_java__ || File.dirname(config)) unless __internal_liquid_template_include_path_java__ == false");
+            this.globalJRubyContainer.runScriptlet("template.registers[:file_system] = Liquid::LocalFileSystem.new(__internal_liquid_template_include_path__, \"_%s.yml.liquid\")");
+            this.globalJRubyContainer.remove("__internal_liquid_template_include_path__");
+        }
+
+        this.globalJRubyContainer.put("__internal_liquid_template_params__", templateParams);
+        this.globalJRubyContainer.runScriptlet("__internal_liquid_template_data__ = { 'env' => ENV.to_h }.merge(__internal_liquid_template_params__)");
+        this.globalJRubyContainer.remove("__internal_liquid_template_params__");
+
+        final Object renderedObject =
+            this.globalJRubyContainer.runScriptlet("template.render(__internal_liquid_template_data__)");
+        return renderedObject.toString();
+    }
+
+    private boolean checkFileWritable(final Path path)
+            throws IOException
+    {
+        if (path != null) {
+            // Open file with append mode and do nothing.
+            // If file is not writable, it throws an exception.
+            // NOTE: |Files.isWritable| does not work for the purpose as it expects the file exists.
+            // Using |Files.newOutputStream| for the binary mode.
+            try (final OutputStream output =
+                     Files.newOutputStream(path, StandardOpenOption.APPEND, StandardOpenOption.CREATE)) {
+                ;
+            }
+        }
+        return true;
+    }
+
+    private String writeConfig(final Path path, final DataSource modelObject)
+            throws IOException
+    {
+        final String yamlString = dumpDataSourceInYaml(modelObject);
+        if (path != null) {
+            Files.write(path, yamlString.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+        }
+        return yamlString;
+    }
+
+    private String writeResumeState(final Path path, final ResumeState modelObject)
+            throws IOException
+    {
+        final String yamlString = dumpResumeStateInYaml(modelObject);
+        if (path != null) {
+            Files.write(path, yamlString.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+        }
+        return yamlString;
+    }
+
+    private String dumpDataSourceInYaml(final DataSource modelObject)
+    {
+        final ModelManager modelManager = this.embed.getModelManager();
+        final Object object = modelManager.readObject(Object.class, modelManager.writeObject(modelObject));
+        return (new org.yaml.snakeyaml.Yaml()).dump(object);
+    }
+
+    private String dumpResumeStateInYaml(final ResumeState modelObject)
+    {
+        final ModelManager modelManager = this.embed.getModelManager();
+        final Object object = modelManager.readObject(Object.class, modelManager.writeObject(modelObject));
+        return (new org.yaml.snakeyaml.Yaml()).dump(object);
+    }
+
+    // class Runnable
+    //   def initialize(runner, config, options)
+    //     @runner = runner
+    //     @config = config
+    //     @options = options
+    //   end
+    //
+    //   attr_reader :config
+    //
+    //   def preview(options={})
+    //     @runner.preview(@config, @options.merge(options))
+    //   end
+    //
+    //   def run(options={})
+    //     @runner.run(@config, @options.merge(options))
+    //   end
+    // end
+
+    // NOTE: The root logger directly from |LoggerFactory|, not from |Exec.getLogger| as it's outside of |Exec.doWith|.
+    private static final Logger rootLogger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+
+    private final Pattern EXT_YAML = Pattern.compile(".*\\.ya?ml$");
+    private final Pattern EXT_YAML_LIQUID = Pattern.compile(".*\\.ya?ml\\.liquid$");
+
+    private final EmbulkEmbed embed;
+    private final ScriptingContainer globalJRubyContainer;
+}