embulk-filter-copy 0.0.1

data/src/main/java/org/embulk/filter/copy/service/StandardColumnVisitor.java

@@ -0,0 +1,64 @@
+package org.embulk.filter.copy.service;
+
+import org.embulk.spi.Column;
+import org.embulk.spi.ColumnVisitor;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.PageReader;
+
+public class StandardColumnVisitor
+    implements ColumnVisitor
+{
+    private final PageReader reader;
+    private final PageBuilder builder;
+
+    public StandardColumnVisitor(PageReader reader, PageBuilder builder)
+    {
+        this.reader = reader;
+        this.builder = builder;
+    }
+
+    private void nullOr(Column column, Runnable runnable)
+    {
+        if (reader.isNull(column)) {
+            builder.setNull(column);
+            return;
+        }
+        runnable.run();
+    }
+
+    @Override
+    public void booleanColumn(Column column)
+    {
+        nullOr(column, () -> builder.setBoolean(column, reader.getBoolean(column)));
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        nullOr(column, () -> builder.setLong(column, reader.getLong(column)));
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        nullOr(column, () -> builder.setDouble(column, reader.getDouble(column)));
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        nullOr(column, () -> builder.setString(column, reader.getString(column)));
+    }
+
+    @Override
+    public void timestampColumn(Column column)
+    {
+        nullOr(column, () -> builder.setTimestamp(column, reader.getTimestamp(column)));
+    }
+
+    @Override
+    public void jsonColumn(Column column)
+    {
+        nullOr(column, () -> builder.setJson(column, reader.getJson(column)));
+    }
+}

data/src/main/java/org/embulk/filter/copy/util/ElapsedTime.java

@@ -0,0 +1,165 @@
+package org.embulk.filter.copy.util;
+
+import org.slf4j.Logger;
+
+import java.util.function.Supplier;
+
+public class ElapsedTime
+{
+    private ElapsedTime()
+    {
+    }
+
+    private final static String TEMPLATE = " ({} ms)";
+    private enum LogLevel {TRACE, DEBUG, INFO, WARN, ERROR}
+    private enum Status {START, RUNNING, FINISHED}
+
+    private static void log(Logger logger, LogLevel level, String message, long elapsed)
+    {
+        String msgWithTmpl = message + TEMPLATE;
+        switch (level)
+        {
+            case TRACE:
+                logger.trace(msgWithTmpl, elapsed);
+                break;
+            case DEBUG:
+                logger.debug(msgWithTmpl, elapsed);
+                break;
+            case INFO:
+                logger.info(msgWithTmpl, elapsed);
+                break;
+            case WARN:
+                logger.warn(msgWithTmpl, elapsed);
+                break;
+            case ERROR:
+                logger.error(msgWithTmpl, elapsed);
+                break;
+        }
+    }
+
+    private static <T>T run(Logger logger, LogLevel level, String message, Supplier<T> proc)
+    {
+        long start = System.currentTimeMillis();
+        try {
+            return proc.get();
+        }
+        finally {
+            log(logger, level, message, System.currentTimeMillis() - start);
+        }
+    }
+
+    private static void run(Logger logger, LogLevel level, String message, Runnable proc)
+    {
+        long start = System.currentTimeMillis();
+        try {
+            proc.run();
+        }
+        finally {
+            log(logger, level, message, System.currentTimeMillis() - start);
+        }
+    }
+
+    public static <T>T trace(Logger logger, String message, Supplier<T> proc)
+    {
+        return run(logger, LogLevel.TRACE, message, proc);
+    }
+
+    public static <T>T debug(Logger logger, String message, Supplier<T> proc)
+    {
+        return run(logger, LogLevel.DEBUG, message, proc);
+    }
+
+    public static <T>T info(Logger logger, String message, Supplier<T> proc)
+    {
+        return run(logger, LogLevel.INFO, message, proc);
+    }
+
+    public static <T>T warn(Logger logger, String message, Supplier<T> proc)
+    {
+        return run(logger, LogLevel.WARN, message, proc);
+    }
+
+    public static <T>T error(Logger logger, String message, Supplier<T> proc)
+    {
+        return run(logger, LogLevel.ERROR, message, proc);
+    }
+
+    public static void trace(Logger logger, String message, Runnable proc)
+    {
+        run(logger, LogLevel.TRACE, message, proc);
+    }
+
+    public static void debug(Logger logger, String message, Runnable proc)
+    {
+        run(logger, LogLevel.DEBUG, message, proc);
+    }
+
+    public static void info(Logger logger, String message, Runnable proc)
+    {
+        run(logger, LogLevel.INFO, message, proc);
+    }
+
+    public static void warn(Logger logger, String message, Runnable proc)
+    {
+        run(logger, LogLevel.WARN, message, proc);
+    }
+
+    public static void error(Logger logger, String message, Runnable proc)
+    {
+        run(logger, LogLevel.ERROR, message, proc);
+    }
+
+    private static void logUntil(Supplier<Boolean> condition,
+            Logger logger, LogLevel level, String message, long sleep)
+    {
+        long start = System.currentTimeMillis();
+        log(logger, level, String.format("(%s) %s", Status.START, message),
+                System.currentTimeMillis() - start);
+        while (true) {
+            if (condition.get()) {
+                log(logger, level, String.format("(%s) %s", Status.FINISHED, message),
+                        System.currentTimeMillis() - start);
+                break;
+            }
+            try {
+                Thread.sleep(sleep);
+            }
+            catch (InterruptedException e) {
+                logger.warn(e.getMessage(), e);
+            }
+
+            log(logger, level, String.format("(%s) %s", Status.RUNNING, message),
+                    System.currentTimeMillis() - start);
+        }
+    }
+
+    public static void traceUntil(Supplier<Boolean> condition,
+            Logger logger, String message, long sleep)
+    {
+        logUntil(condition, logger, LogLevel.TRACE, message, sleep);
+    }
+
+    public static void debugUntil(Supplier<Boolean> condition,
+            Logger logger, String message, long sleep)
+    {
+        logUntil(condition, logger, LogLevel.DEBUG, message, sleep);
+    }
+
+    public static void infoUntil(Supplier<Boolean> condition,
+            Logger logger, String message, long sleep)
+    {
+        logUntil(condition, logger, LogLevel.INFO, message, sleep);
+    }
+
+    public static void warnUntil(Supplier<Boolean> condition,
+            Logger logger, String message, long sleep)
+    {
+        logUntil(condition, logger, LogLevel.WARN, message, sleep);
+    }
+
+    public static void errorUntil(Supplier<Boolean> condition,
+            Logger logger, String message, long sleep)
+    {
+        logUntil(condition, logger, LogLevel.ERROR, message, sleep);
+    }
+}

data/src/test/java/org/embulk/filter/copy/TestCopyFilterPlugin.java

@@ -0,0 +1,5 @@
+package org.embulk.filter.copy;
+
+public class TestCopyFilterPlugin
+{
+}

data/src/test/java/org/embulk/filter/copy/plugin/TestInternalForwardInputPlugin.java

@@ -0,0 +1,5 @@
+package org.embulk.filter.copy.plugin;
+
+public class TestInternalForwardInputPlugin
+{
+}

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: embulk-filter-copy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Civitaspo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2017-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Copy records and run another embulk by using them as input data source.
+email:
+- civitaspo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- build.gradle
+- config/checkstyle/checkstyle.xml
+- config/checkstyle/default.xml
+- example/config.yml
+- example/data.tsv
+- gradle/wrapper/gradle-wrapper.jar
+- gradle/wrapper/gradle-wrapper.properties
+- gradlew
+- gradlew.bat
+- lib/embulk/filter/copy.rb
+- settings.gradle
+- src/main/java/org/embulk/filter/copy/CopyFilterPlugin.java
+- src/main/java/org/embulk/filter/copy/forward/ForwardBaseTask.java
+- src/main/java/org/embulk/filter/copy/forward/InForwardEventReader.java
+- src/main/java/org/embulk/filter/copy/forward/InForwardService.java
+- src/main/java/org/embulk/filter/copy/forward/InForwardVisitor.java
+- src/main/java/org/embulk/filter/copy/forward/OutForwardEventBuilder.java
+- src/main/java/org/embulk/filter/copy/forward/OutForwardService.java
+- src/main/java/org/embulk/filter/copy/forward/OutForwardVisitor.java
+- src/main/java/org/embulk/filter/copy/plugin/InternalForwardInputPlugin.java
+- src/main/java/org/embulk/filter/copy/service/EmbulkExecutorService.java
+- src/main/java/org/embulk/filter/copy/service/StandardColumnVisitor.java
+- src/main/java/org/embulk/filter/copy/util/ElapsedTime.java
+- src/test/java/org/embulk/filter/copy/TestCopyFilterPlugin.java
+- src/test/java/org/embulk/filter/copy/plugin/TestInternalForwardInputPlugin.java
+- classpath/embulk-filter-copy-0.0.1.jar
+- classpath/fluency-1.1.0.jar
+- classpath/influent-java-0.2.0.jar
+- classpath/influent-transport-0.2.0.jar
+- classpath/jackson-annotations-2.7.0.jar
+- classpath/jackson-core-2.7.1.jar
+- classpath/jackson-databind-2.7.1.jar
+- classpath/jackson-dataformat-msgpack-0.8.11.jar
+- classpath/phi-accural-failure-detector-0.0.4.jar
+- classpath/slf4j-api-1.7.22.jar
+homepage: https://github.com/civitaspo/embulk-filter-copy
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: Copy filter plugin for Embulk
+test_files: []