embulk 0.8.18-java → 0.8.19-java

data/embulk-cli/src/main/java/org/embulk/cli/EmbulkNew.java

@@ -0,0 +1,419 @@
+package org.embulk.cli;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.base.CaseFormat;
+import com.google.common.base.Joiner;
+import com.google.common.io.CharStreams;
+
+import org.apache.velocity.VelocityContext;
+import org.apache.velocity.app.VelocityEngine;
+
+public class EmbulkNew
+{
+    public EmbulkNew(final String categoryWithLanguage, final String nameGiven, final String embulkVersion)
+            throws IOException
+    {
+        this.basePath = Paths.get(".").toAbsolutePath();
+
+        final LanguageAndCategory languageAndCategory = LanguageAndCategory.of(categoryWithLanguage);
+        this.language = languageAndCategory.getLanguage();
+        this.category = languageAndCategory.getCategory();
+        this.nameGiven = nameGiven;
+        this.embulkVersion = embulkVersion;
+
+        if (category.equals("file_input")) {
+            this.embulkCategory = "input";
+        }
+        else if (category.equals("file_output")) {
+            this.embulkCategory = "output";
+        }
+        else {
+            this.embulkCategory = category;
+        }
+
+        this.name = nameGiven.replaceAll("[^a-zA-Z0-9_]+", "_");
+
+        this.fullProjectName = "embulk-" + embulkCategory + "-" + name;
+        this.pluginDirectory = "lib/embulk";
+        this.pluginPath = pluginDirectory + "/" + embulkCategory + "/" + name + ".rb";
+
+        this.pluginBasePath = this.basePath.resolve(fullProjectName);
+
+        this.velocityEngine = new VelocityEngine();
+        this.velocityEngine.init();
+        this.velocityEngine.setProperty(VelocityEngine.RUNTIME_LOG_LOGSYSTEM_CLASS,
+                                        "org.apache.velocity.runtime.log.NullLogSystem");
+    }
+
+    public boolean newPlugin()
+            throws IOException
+    {
+        if (Files.exists(this.pluginBasePath)) {
+            throw new IOException("./" + this.fullProjectName + " already exists. Please delete it first.");
+        }
+
+        Files.createDirectories(this.pluginBasePath);
+
+        System.out.println("Creating " + this.fullProjectName + "/");
+
+        boolean success = false;
+        try {
+            //
+            // Generate gemspec
+            //
+            final String author = getGitConfig("user.name", "YOUR_NAME");
+            final String email = getGitConfig("user.email", "YOUR_NAME");
+            final String expectedGitHubAccount = email.split("@")[0];
+
+            // variables used in Velocity templates
+            final String rubyClassName = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, name);
+            final String javaClassName =
+                CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, name) +
+                CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, category) +
+                "Plugin";
+            final String javaPackageName = "org.embulk." + embulkCategory + "." + name;
+            final String displayName = getDisplayName(name);
+            final String displayCategory = category.replace("_", " ");
+
+            final HashMap<String, String> extraGuesses = new HashMap<String, String>();
+
+            final String description;
+            switch (category) {
+            case "input":
+                description = String.format("Loads records from %s.", displayName);
+                break;
+            case "file_input":
+                description = String.format("Reads files stored on %s.", displayName);
+                break;
+            case "parser":
+                description = String.format("Parses %s files read by other file input plugins.", displayName);
+                extraGuesses.put("embulk/data/new/ruby/parser_guess.rb.vm",
+                                 String.format("%s/guess/%s.rb", pluginDirectory, name));
+                break;
+            case "decoder":
+                description = String.format("Decodes %s-encoded files read by other file input plugins.", displayName);
+                extraGuesses.put("embulk/data/new/ruby/decoder_guess.rb.vm",
+                                 String.format("%s/guess/%s.rb", pluginDirectory, name));
+                break;
+            case "output":
+                description = String.format("Dumps records to %s.", displayName);
+                break;
+            case "file_output":
+                description = String.format("Stores files on %s.", displayName);
+                break;
+            case "formatter":
+                description = String.format("Formats %s files for other file output plugins.", displayName);
+                break;
+            case "encoder":
+                description = String.format("Encodes files using %s for other file output plugins.", displayName);
+                break;
+            case "filter":
+                description = String.format("%s", displayName);
+                break;
+            default:
+                throw new RuntimeException("FATAL: Invalid plugin category.");
+            }
+
+            //
+            // Generate project repository
+            //
+            final VelocityContext velocityContext = createVelocityContext(
+                author,
+                category,
+                description,
+                displayName,
+                displayCategory,
+                email,
+                embulkCategory,
+                this.embulkVersion,
+                expectedGitHubAccount,
+                fullProjectName,
+                javaClassName,
+                javaPackageName,
+                language,
+                name,
+                rubyClassName);
+            copyTemplated("embulk/data/new/README.md.vm", "README.md", velocityContext);
+            copy("embulk/data/new/LICENSE.txt", "LICENSE.txt");
+            copyTemplated("embulk/data/new/gitignore.vm", ".gitignore", velocityContext);
+
+            switch (language) {
+            case "ruby":
+                copy("embulk/data/new/ruby/Rakefile", "Rakefile");
+                copy("embulk/data/new/ruby/Gemfile", "Gemfile");
+                copy("embulk/data/new/ruby/.ruby-version", ".ruby-version");
+                copyTemplated("embulk/data/new/ruby/gemspec.vm",
+                              fullProjectName + ".gemspec",
+                              velocityContext);
+                copyTemplated(String.format("embulk/data/new/ruby/%s.rb.vm", category),
+                              this.pluginPath,
+                              velocityContext);
+                break;
+            case "java":
+                copy("embulk/data/new/java/gradle/wrapper/gradle-wrapper.jar",
+                     "gradle/wrapper/gradle-wrapper.jar");
+                copy("embulk/data/new/java/gradle/wrapper/gradle-wrapper.properties",
+                     "gradle/wrapper/gradle-wrapper.properties");
+                copy("embulk/data/new/java/gradlew.bat", "gradlew.bat");
+                copy("embulk/data/new/java/gradlew", "gradlew");
+                setExecutable("gradlew");
+                copy("embulk/data/new/java/config/checkstyle/checkstyle.xml", "config/checkstyle/checkstyle.xml");
+                copy("embulk/data/new/java/config/checkstyle/default.xml", "config/checkstyle/default.xml");
+                copyTemplated("embulk/data/new/java/build.gradle.vm", "build.gradle", velocityContext);
+                copyTemplated("embulk/data/new/java/plugin_loader.rb.vm", this.pluginPath, velocityContext);
+                copyTemplated(String.format("embulk/data/new/java/%s.java.vm", category),
+                              String.format("src/main/java/%s/%s.java",
+                                            javaPackageName.replaceAll("\\.", "/"),
+                                            javaClassName),
+                              velocityContext);
+                copyTemplated("embulk/data/new/java/test.java.vm",
+                              String.format("src/test/java/%s/Test%s.java",
+                                            javaPackageName.replaceAll("\\.", "/"),
+                                            javaClassName),
+                              velocityContext);
+                break;
+            }
+
+            for (Map.Entry<String, String> entry : extraGuesses.entrySet()) {
+                copyTemplated(entry.getKey(), entry.getValue(), velocityContext);
+            }
+
+            System.out.println("");
+            System.out.println("Plugin template is successfully generated.");
+
+            switch (language) {
+            case "ruby":
+                System.out.println("Next steps:");
+                System.out.println("");
+                System.out.printf("  $ cd %s\n", fullProjectName);
+                System.out.println("  $ bundle install                      # install one using rbenv & rbenv-build");
+                System.out.println("  $ bundle exec rake                    # build gem to be released");
+                System.out.println("  $ bundle exec embulk run config.yml   # you can run plugin using this command");
+                break;
+            case "java":
+                System.out.println("Next steps:");
+                System.out.println("");
+                System.out.printf("  $ cd %s\n", fullProjectName);
+                System.out.println("  $ ./gradlew package");
+            }
+
+            success = true;
+            System.out.println("");
+        }
+        catch (Exception ex) {
+            ex.printStackTrace();
+        }
+        finally {
+            if (!success) {
+                System.out.println("Failed. Removing the directory created.");
+                deleteDirectoryTree(Paths.get(fullProjectName));
+            }
+        }
+        return success;
+    }
+
+    private static class LanguageAndCategory
+    {
+        private LanguageAndCategory(final String language, final String category)
+        {
+            this.language = language;
+            this.category = category;
+        }
+
+        public static LanguageAndCategory of(final String categoryWithLanguage)
+        {
+            switch (categoryWithLanguage) {
+            case "java-input":       return new LanguageAndCategory("java", "input");
+            case "java-output":      return new LanguageAndCategory("java", "output");
+            case "java-filter":      return new LanguageAndCategory("java", "filter");
+            case "java-file-input":  return new LanguageAndCategory("java", "file_input");
+            case "java-file-output": return new LanguageAndCategory("java", "file_output");
+            case "java-parser":      return new LanguageAndCategory("java", "parser");
+            case "java-formatter":   return new LanguageAndCategory("java", "formatter");
+            case "java-decoder":     return new LanguageAndCategory("java", "decoder");
+            case "java-encoder":     return new LanguageAndCategory("java", "encoder");
+            case "ruby-input":       return new LanguageAndCategory("ruby", "input");
+            case "ruby-output":      return new LanguageAndCategory("ruby", "output");
+            case "ruby-filter":      return new LanguageAndCategory("ruby", "filter");
+            case "ruby-file-input":
+                throw new RuntimeException("ruby-file-input is not implemented yet. See #21 on github.");
+            case "ruby-file-output":
+                throw new RuntimeException("ruby-file-output is not implemented yet. See #22 on github.");
+            case "ruby-parser":      return new LanguageAndCategory("ruby", "parser");
+            case "ruby-formatter":   return new LanguageAndCategory("ruby", "formatter");
+            case "ruby-decoder":
+                throw new RuntimeException("ruby-decoder is not implemented yet. See #31 on github.");
+            case "ruby-encoder":
+                throw new RuntimeException("ruby-decoder is not implemented yet. See #32 on github.");
+            default:
+                throw new RuntimeException(String.format("Unknown category '%s'", categoryWithLanguage));
+            }
+        }
+
+        public String getLanguage()
+        {
+            return this.language;
+        }
+
+        public String getCategory()
+        {
+            return this.category;
+        }
+
+        private final String language;
+        private final String category;
+    }
+
+    private String getGitConfig(final String configName, final String defaultValue)
+    {
+        try {
+            final Process process = new ProcessBuilder("git", "config", configName).redirectErrorStream(true).start();
+            return CharStreams.toString(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8)).trim();
+        }
+        catch (Throwable ex) {
+            return "YOUR_NAME";
+        }
+    }
+
+    private Path deleteDirectoryTree(final Path path)
+            throws IOException
+    {
+        return Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
+                @Override
+                public FileVisitResult visitFile(Path file, BasicFileAttributes attributes)
+                        throws IOException
+                {
+                    Files.delete(file);
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult postVisitDirectory(Path directory, IOException exception)
+                        throws IOException
+                {
+                    Files.delete(directory);
+                    return FileVisitResult.CONTINUE;
+                }
+            });
+    }
+
+    private String getDisplayName(final String name)
+    {
+        final String[] nameSplit = name.split("_");
+        final ArrayList<String> nameComposition = new ArrayList<String>();
+        for (String namePart : nameSplit) {
+            nameComposition.add(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, namePart));
+        }
+        return Joiner.on(" ").join(nameComposition);
+    }
+
+    private VelocityContext createVelocityContext(final String author,
+                                                  final String category,
+                                                  final String description,
+                                                  final String displayName,
+                                                  final String displayCategory,
+                                                  final String email,
+                                                  final String embulkCategory,
+                                                  final String embulkVersion,
+                                                  final String expectedGitHubAccount,
+                                                  final String fullProjectName,
+                                                  final String javaClassName,
+                                                  final String javaPackageName,
+                                                  final String language,
+                                                  final String name,
+                                                  final String rubyClassName)
+    {
+        final VelocityContext velocityContext = new VelocityContext();
+        // TODO(dmikurube): Revisit this |argumentToRunEmbulkJava|.
+        // This is in the Velocity context because the value could not be in Velocity templates.
+        velocityContext.put("argumentToRunEmbulkJava", "\'-L ${file(\".\").absolutePath}\'");
+        velocityContext.put("author", author);
+        velocityContext.put("category", category);
+        velocityContext.put("description", description);
+        velocityContext.put("displayName", displayName);
+        velocityContext.put("displayCategory", displayCategory);
+        velocityContext.put("email", email);
+        velocityContext.put("embulkCategory", embulkCategory);
+        velocityContext.put("embulkVersion", embulkVersion);
+        velocityContext.put("expectedGitHubAccount", expectedGitHubAccount);
+        velocityContext.put("fullProjectName", fullProjectName);
+        velocityContext.put("javaClassName", javaClassName);
+        velocityContext.put("javaGuessClassName", javaClassName.replace("Plugin", "GuessPlugin"));
+        velocityContext.put("javaPackageName", javaPackageName);
+        velocityContext.put("language", language);
+        velocityContext.put("name", name);
+        velocityContext.put("rubyClassName", rubyClassName);
+        velocityContext.put("rubyGuessClassName", rubyClassName.replace("Plugin", "GuessPlugin"));
+        return velocityContext;
+    }
+
+    private void copy(String sourceResourcePath, String destinationFileName)
+            throws IOException
+    {
+        final Path destinationPath = this.pluginBasePath.resolve(destinationFileName);
+        Files.createDirectories(destinationPath.getParent());
+        Files.copy(EmbulkNew.class.getClassLoader().getResourceAsStream(sourceResourcePath), destinationPath);
+    }
+
+    private void copyTemplated(String sourceResourcePath, String destinationFileName, VelocityContext velocityContext)
+            throws IOException
+    {
+        try (InputStreamReader reader = new InputStreamReader(
+                 EmbulkNew.class.getClassLoader().getResourceAsStream(sourceResourcePath))) {
+            final Path destinationPath = this.pluginBasePath.resolve(destinationFileName);
+            Files.createDirectories(destinationPath.getParent());
+            try (BufferedWriter writer = Files.newBufferedWriter(destinationPath, StandardCharsets.UTF_8)) {
+                this.velocityEngine.evaluate(velocityContext,
+                                             writer,
+                                             "embulk-new",
+                                             reader);
+            }
+        }
+    }
+
+    private void setExecutable(String targetFileName)
+            throws IOException
+    {
+        final Path targetPath = this.pluginBasePath.resolve(targetFileName);
+        final Set<PosixFilePermission> permissions =
+            new HashSet<PosixFilePermission>(Files.getPosixFilePermissions(targetPath));
+        permissions.add(PosixFilePermission.OWNER_EXECUTE);
+        permissions.add(PosixFilePermission.GROUP_EXECUTE);
+        permissions.add(PosixFilePermission.OTHERS_EXECUTE);
+        Files.setPosixFilePermissions(targetPath, permissions);
+    }
+
+    private final Path basePath;
+
+    private final String nameGiven;
+    private final String language;
+    private final String category;
+    private final String embulkVersion;
+
+    private final String embulkCategory;
+    private final String name;
+
+    private final String fullProjectName;
+    private final String pluginDirectory;
+    private final String pluginPath;
+
+    private final Path pluginBasePath;
+
+    private final VelocityEngine velocityEngine;
+}

data/embulk-cli/src/main/java/org/embulk/cli/EmbulkSelfUpdate.java

@@ -0,0 +1,248 @@
+package org.embulk.cli;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.jar.Attributes;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.maven.artifact.versioning.ComparableVersion;
+
+// It uses |java.net.HttpURLConnection| so that embulk-cli does not need additional dependedcies.
+// TODO(dmikurube): Support HTTP proxy. The original Ruby version did not support as well, though.
+public class EmbulkSelfUpdate
+{
+    // TODO(dmikurube): Stop catching Exceptions here when embulk_run.rb is replaced to Java.
+    public void updateSelf(final String runningVersionString,
+                           final String specifiedVersionString,
+                           final String embulkRunRubyPathString,
+                           final boolean isForced)
+            throws IOException, URISyntaxException
+    {
+        try {
+            updateSelfWithExceptions(runningVersionString, specifiedVersionString, embulkRunRubyPathString, isForced);
+        }
+        catch (Throwable ex) {
+            ex.printStackTrace();
+            throw ex;
+        }
+    }
+
+    private void updateSelfWithExceptions(final String runningVersionString,
+                                          final String specifiedVersionString,
+                                          final String embulkRunRubyPathString,
+                                          final boolean isForced)
+            throws IOException, URISyntaxException
+    {
+        final Path jarPathJava = Paths.get(
+            EmbulkSelfUpdate.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath());
+
+        if ((!Files.exists(jarPathJava)) || (!Files.isRegularFile(jarPathJava))) {
+            throw exceptionNoSingleJar();
+        }
+
+        if (embulkRunRubyPathString != null) {
+            final String[] splitRubyFile = embulkRunRubyPathString.split("!", 2);
+            if (splitRubyFile.length < 2) {
+                throw exceptionNoSingleJar();
+            }
+            final Path jarPathRuby = Paths.get(splitRubyFile[0]);
+            if (!jarPathJava.equals(jarPathRuby)) {
+                throw exceptionNoSingleJar();
+            }
+        }
+
+        final String targetVersionString;
+        if (specifiedVersionString != null) {
+            System.out.printf("Checking version %s...\n", specifiedVersionString);
+            targetVersionString = checkTargetVersion(specifiedVersionString);
+            if (targetVersionString == null) {
+                throw new RuntimeException(String.format("Specified version does not exist: %s", specifiedVersionString));
+            }
+            System.out.printf("Found version %s.\n", specifiedVersionString);
+        }
+        else {
+            System.out.println("Checking the latest version...");
+            final ComparableVersion runningVersion = new ComparableVersion(runningVersionString);
+            targetVersionString = checkLatestVersion();
+            final ComparableVersion targetVersion = new ComparableVersion(targetVersionString);
+            if (targetVersion.compareTo(runningVersion) <= 0) {
+                System.out.printf("Already up-to-date. %s is the latest version.\n", runningVersion);
+                return;
+            }
+            System.out.printf("Found a newer version %s.\n", targetVersion);
+        }
+
+        if (!Files.isWritable(jarPathJava)) {
+            throw new RuntimeException(String.format("The existing %s is not writable. May need to sudo?",
+                                                     jarPathJava.toString()));
+        }
+
+        final URL downloadUrl = new URL(String.format("https://dl.bintray.com/embulk/maven/embulk-%s.jar",
+                                                      targetVersionString));
+        System.out.printf("Downloading %s ...\n", downloadUrl.toString());
+
+        Path jarPathTemp = Files.createTempFile("embulk-selfupdate", ".jar");
+        try {
+            final HttpURLConnection connection = (HttpURLConnection) downloadUrl.openConnection();
+            try {
+                // Follow the redicrect from the Bintray URL.
+                connection.setInstanceFollowRedirects(true);
+                connection.setRequestMethod("GET");
+                connection.connect();
+                final int statusCode = connection.getResponseCode();
+                if (HttpURLConnection.HTTP_OK != statusCode) {
+                    throw new FileNotFoundException(
+                        String.format("Unexpected HTTP status code: %d", statusCode));
+                }
+                InputStream input = connection.getInputStream();
+                // TODO(dmikurube): Confirm if it is okay to replace a temp file created by Files.createTempFile.
+                Files.copy(input, jarPathTemp, StandardCopyOption.REPLACE_EXISTING);
+                Files.setPosixFilePermissions(jarPathTemp, Files.getPosixFilePermissions(jarPathJava));
+            }
+            finally {
+                connection.disconnect();
+            }
+
+            if (!isForced) {  // Check corruption
+                final String versionJarTemp;
+                try {
+                    versionJarTemp = getJarVersion(jarPathTemp);
+                }
+                catch (FileNotFoundException ex) {
+                    throw new RuntimeException("Failed to check corruption. Downloaded version may include incompatible changes. Try the '-f' option to force updating without checking.", ex);
+                }
+                if (!versionJarTemp.equals(targetVersionString)) {
+                    throw new RuntimeException(
+                        String.format("Downloaded version does not match: %s (downloaded) / %s (target)",
+                                      versionJarTemp,
+                                      targetVersionString));
+                }
+            }
+            Files.move(jarPathTemp, jarPathJava, StandardCopyOption.REPLACE_EXISTING);
+        }
+        finally {
+            Files.deleteIfExists(jarPathTemp);
+        }
+        System.out.println(String.format("Updated to %s.", targetVersionString));
+    }
+
+    private RuntimeException exceptionNoSingleJar()
+    {
+        return new RuntimeException("Embulk is not installed as a single jar. \"selfupdate\" does not work. If you installed Embulk through gem, run \"gem install embulk\" instead.");
+    }
+
+    /**
+     * Checks the latest version from bintray.com.
+     *
+     * It passes all {@code IOException} and {@code RuntimeException} through out.
+     */
+    private String checkLatestVersion()
+            throws IOException
+    {
+        final URL bintrayUrl = new URL("https://bintray.com/embulk/maven/embulk/_latestVersion");
+        final HttpURLConnection connection = (HttpURLConnection) bintrayUrl.openConnection();
+        try {
+            // Stop HttpURLConnection from following redirects when the status code is 301 or 302.
+            connection.setInstanceFollowRedirects(false);
+            connection.setRequestMethod("GET");
+            connection.connect();
+            final int statusCode = connection.getResponseCode();
+            if (HttpURLConnection.HTTP_MOVED_TEMP != statusCode) {
+                throw new FileNotFoundException(
+                    String.format("Unexpected HTTP status code: %d", statusCode));
+            }
+            final String location = connection.getHeaderField("Location");
+            final Matcher versionMatcher = VERSION_URL_PATTERN.matcher(location);
+            if (!versionMatcher.matches()) {
+                throw new FileNotFoundException(
+                    String.format("Invalid version number in \"Location\" header: %s", location));
+            }
+            return versionMatcher.group(1);
+        }
+        finally {
+            connection.disconnect();
+        }
+    }
+
+    /**
+     * Checks the target version in bintray.com.
+     *
+     * It passes all {@code IOException} and {@code RuntimeException} through out.
+     */
+    private String checkTargetVersion(String version)
+            throws IOException
+    {
+        final URL bintrayUrl = new URL(String.format("https://bintray.com/embulk/maven/embulk/%s", version));
+        final HttpURLConnection connection = (HttpURLConnection) bintrayUrl.openConnection();
+        try {
+            connection.setInstanceFollowRedirects(false);
+            connection.setRequestMethod("GET");
+            connection.connect();
+            final int statusCode = connection.getResponseCode();
+            if (HttpURLConnection.HTTP_NOT_FOUND == statusCode) {
+                return null;
+            }
+            else if (HttpURLConnection.HTTP_OK != statusCode) {
+                throw new FileNotFoundException(
+                    String.format("Unexpected HTTP status code: %d", statusCode));
+            }
+            else {
+                return version;
+            }
+        }
+        finally {
+            connection.disconnect();
+        }
+    }
+
+    private String getJarVersion(Path jarPath)
+            throws IOException
+    {
+        try (final JarFile jarFile = new JarFile(jarPath.toFile())) {
+            final Manifest manifest;
+            try {
+                manifest = jarFile.getManifest();
+            }
+            catch (IOException ex) {
+                throw new IOException("Version not found. Failed to load the manifest.", ex);
+            }
+            String manifestContents;
+            try (final ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
+                manifest.write(outputStream);
+                manifestContents = outputStream.toString();
+            }
+            catch (IOException ex) {
+                manifestContents = "(Failed to read the contents of the manifest.)";
+            }
+            final Attributes mainAttributes = manifest.getMainAttributes();
+            final String implementationVersion = mainAttributes.getValue(Attributes.Name.IMPLEMENTATION_VERSION);
+            if (implementationVersion == null) {
+                throw new IOException("Version not found. Failed to read \""
+                                      + Attributes.Name.IMPLEMENTATION_VERSION
+                                      + "\": " + manifestContents);
+            }
+            return implementationVersion;
+        }
+        catch (IOException ex) {
+            throw new IOException("Version not found. Failed to load the jar file.", ex);
+        }
+
+        // NOTE: Checking embulk/version.rb is no longer needed.
+        // The jar manifest with "Implementation-Version" has been included in Embulk jars from v0.4.0.
+    }
+
+    private static final Pattern VERSION_URL_PATTERN = Pattern.compile("^https?://.*/embulk/(\\d+\\.\\d+[^\\/]+).*$");
+    private static final Pattern VERSION_RUBY_PATTERN = Pattern.compile("^\\s*VERSION\\s*\\=\\s*(\\p{Graph}+)\\s*$");
+}