embulk 0.7.0-java

data/embulk-core/src/main/java/org/embulk/plugin/compat/TransactionalFileOutputWrapper.java

@@ -0,0 +1,102 @@
+package org.embulk.plugin.compat;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import com.google.common.base.Throwables;
+import org.embulk.config.TaskReport;
+import org.embulk.config.CommitReport;
+import org.embulk.spi.Buffer;
+import org.embulk.spi.TransactionalFileOutput;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TransactionalFileOutputWrapper
+        implements TransactionalFileOutput
+{
+    private final Logger logger = LoggerFactory.getLogger(PluginWrappers.class);
+
+    public static TransactionalFileOutput wrapIfNecessary(TransactionalFileOutput object)
+    {
+        Method runMethod = wrapCommitMethod(object);
+        if (runMethod != null) {
+            return new TransactionalFileOutputWrapper(object, runMethod);
+        }
+        return object;
+    }
+
+    private static Method wrapCommitMethod(TransactionalFileOutput object)
+    {
+        try {
+            Method m = object.getClass().getMethod("commit");
+            if (m.getReturnType().equals(CommitReport.class)) {
+                return m;
+            } else {
+                return null;
+            }
+        }
+        catch (NoSuchMethodException ex) {
+            return null;
+        }
+    }
+
+    private final TransactionalFileOutput object;
+    private final Method commitMethod;
+
+    private TransactionalFileOutputWrapper(TransactionalFileOutput object,
+            Method commitMethod)
+    {
+        this.object = object;
+        this.commitMethod = commitMethod;
+        logger.warn("A file output plugin is compiled with old Embulk plugin API. Please update the plugin version using \"embulk gem install\" command, or contact a developer of the plugin to upgrade the plugin code using \"embulk migrate\" command: {}", object.getClass());
+    }
+
+    @Override
+    public void nextFile()
+    {
+        object.nextFile();
+    }
+
+    @Override
+    public void add(Buffer buffer)
+    {
+        object.add(buffer);
+    }
+
+    @Override
+    public void finish()
+    {
+        object.finish();
+    }
+
+    @Override
+    public void close()
+    {
+        object.close();
+    }
+
+    @Override
+    public void abort()
+    {
+        object.abort();
+    }
+
+    @Override
+    public TaskReport commit()
+    {
+        if (commitMethod != null) {
+            try {
+                return (TaskReport) commitMethod.invoke(object);
+            }
+            catch (IllegalAccessException | IllegalArgumentException ex) {
+                throw Throwables.propagate(ex);
+            }
+            catch (InvocationTargetException ex) {
+                throw Throwables.propagate(ex.getCause());
+            }
+
+        } else {
+            return object.commit();
+        }
+    }
+}
+

data/embulk-core/src/main/java/org/embulk/plugin/compat/TransactionalPageOutputWrapper.java

@@ -0,0 +1,95 @@
+package org.embulk.plugin.compat;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import com.google.common.base.Throwables;
+import org.embulk.config.TaskReport;
+import org.embulk.config.CommitReport;
+import org.embulk.spi.Page;
+import org.embulk.spi.TransactionalPageOutput;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TransactionalPageOutputWrapper
+        implements TransactionalPageOutput
+{
+    private final Logger logger = LoggerFactory.getLogger(PluginWrappers.class);
+
+    public static TransactionalPageOutput wrapIfNecessary(TransactionalPageOutput object)
+    {
+        Method runMethod = wrapCommitMethod(object);
+        if (runMethod != null) {
+            return new TransactionalPageOutputWrapper(object, runMethod);
+        }
+        return object;
+    }
+
+    private static Method wrapCommitMethod(TransactionalPageOutput object)
+    {
+        try {
+            Method m = object.getClass().getMethod("commit");
+            if (m.getReturnType().equals(CommitReport.class)) {
+                return m;
+            } else {
+                return null;
+            }
+        }
+        catch (NoSuchMethodException ex) {
+            return null;
+        }
+    }
+
+    private final TransactionalPageOutput object;
+    private final Method commitMethod;
+
+    private TransactionalPageOutputWrapper(TransactionalPageOutput object,
+            Method commitMethod)
+    {
+        this.object = object;
+        this.commitMethod = commitMethod;
+        logger.warn("An output plugin is compiled with old Embulk plugin API. Please update the plugin version using \"embulk gem install\" command, or contact a developer of the plugin to upgrade the plugin code using \"embulk migrate\" command: {}", object.getClass());
+    }
+
+    @Override
+    public void add(Page page)
+    {
+        object.add(page);
+    }
+
+    @Override
+    public void finish()
+    {
+        object.finish();
+    }
+
+    @Override
+    public void close()
+    {
+        object.close();
+    }
+
+    @Override
+    public void abort()
+    {
+        object.abort();
+    }
+
+    @Override
+    public TaskReport commit()
+    {
+        if (commitMethod != null) {
+            try {
+                return (TaskReport) commitMethod.invoke(object);
+            }
+            catch (IllegalAccessException | IllegalArgumentException ex) {
+                throw Throwables.propagate(ex);
+            }
+            catch (InvocationTargetException ex) {
+                throw Throwables.propagate(ex.getCause());
+            }
+
+        } else {
+            return object.commit();
+        }
+    }
+}

data/embulk-core/src/main/java/org/embulk/spi/Buffer.java

@@ -0,0 +1,148 @@
+package org.embulk.spi;
+
+import java.util.Arrays;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+public class Buffer
+{
+    public static final Buffer EMPTY = Buffer.allocate(0);
+
+    private final byte[] array;
+    private int offset;
+    private int filled;
+    private final int capacity;
+
+    protected Buffer(byte[] wrap, int offset, int capacity)
+    {
+        this.array = wrap;
+        this.offset = offset;
+        this.capacity = capacity;
+        this.filled = offset;
+        if (array.length < offset + capacity) {
+            // TODO
+            throw new IllegalStateException("capacity out of bound");
+        }
+    }
+
+    public static Buffer allocate(int length)
+    {
+        return new Buffer(new byte[length], 0, length);
+    }
+
+    public static Buffer copyOf(byte[] src)
+    {
+        return copyOf(src, 0, src.length);
+    }
+
+    public static Buffer copyOf(byte[] src, int index, int length)
+    {
+        return wrap(Arrays.copyOfRange(src, index, length));
+    }
+
+    public static Buffer wrap(byte[] src)
+    {
+        return wrap(src, 0, src.length);
+    }
+
+    public static Buffer wrap(byte[] src, int offset, int size)
+    {
+        return new Buffer(src, offset, size).limit(size);
+    }
+
+    @SuppressFBWarnings(value = "EI_EXPOSE_REP")
+    public byte[] array()
+    {
+        return array;
+    }
+
+    public int offset()
+    {
+        return offset;
+    }
+
+    public Buffer offset(int offset)
+    {
+        this.offset = offset;
+        return this;
+    }
+
+    public int limit()
+    {
+        return filled - offset;
+    }
+
+    public Buffer limit(int limit)
+    {
+        if (capacity < limit) {
+            // TODO
+            throw new IllegalStateException("limit index out of bound: capacity="+capacity+" limit="+limit);
+        }
+        this.filled = offset + limit;
+        return this;
+    }
+
+    public int capacity()
+    {
+        return capacity;
+    }
+
+    public void setBytes(int index, byte[] source, int sourceIndex, int length)
+    {
+        System.arraycopy(source, sourceIndex, array, offset + index, length);
+    }
+
+    public void setBytes(int index, Buffer source, int sourceIndex, int length)
+    {
+        setBytes(index, source.array(), source.offset() + sourceIndex, length);
+    }
+
+    public void getBytes(int index, byte[] dest, int destIndex, int length)
+    {
+        System.arraycopy(array, offset + index, dest, destIndex, length);
+    }
+
+    public void getBytes(int index, Buffer dest, int destIndex, int length)
+    {
+        getBytes(index, dest.array(), dest.offset() + destIndex, length);
+    }
+
+    public void release()
+    {
+    }
+
+    @Override
+    public boolean equals(Object other)
+    {
+        if (!(other instanceof Buffer)) {
+            return false;
+        }
+        Buffer o = (Buffer) other;
+
+        // TODO optimize
+        if (limit() != o.limit()) {
+            return false;
+        }
+        int i = offset;
+        int io = o.offset;
+        while (i < filled) {
+            if (array[i] != o.array[io]) {
+                return false;
+            }
+            i++;
+            io++;
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode()
+    {
+        // TODO optimize
+        int result = 1;
+        for (int i = offset; i < filled; i++) {
+            result = 31 * result + array[i];
+        }
+        return result;
+    }
+}

data/embulk-core/src/main/java/org/embulk/spi/BufferAllocator.java

@@ -0,0 +1,8 @@
+package org.embulk.spi;
+
+public interface BufferAllocator
+{
+    Buffer allocate();
+
+    Buffer allocate(int minimumCapacity);
+}

data/embulk-core/src/main/java/org/embulk/spi/Column.java

@@ -0,0 +1,92 @@
+package org.embulk.spi;
+
+import java.util.Objects;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.BooleanType;
+import org.embulk.spi.type.DoubleType;
+import org.embulk.spi.type.LongType;
+import org.embulk.spi.type.TimestampType;
+import org.embulk.spi.type.StringType;
+
+public class Column
+{
+    private final int index;
+    private final String name;
+    private final Type type;
+
+    @JsonCreator
+    public Column(
+            @JsonProperty("index") int index,
+            @JsonProperty("name") String name,
+            @JsonProperty("type") Type type)
+    {
+        this.index = index;
+        this.name = name;
+        this.type = type;
+    }
+
+    @JsonProperty("index")
+    public int getIndex()
+    {
+        return index;
+    }
+
+    @JsonProperty("name")
+    public String getName()
+    {
+        return name;
+    }
+
+    @JsonProperty("type")
+    public Type getType()
+    {
+        return type;
+    }
+
+    public void visit(ColumnVisitor visitor)
+    {
+        if (type instanceof BooleanType) {
+            visitor.booleanColumn(this);
+        } else if (type instanceof LongType) {
+            visitor.longColumn(this);
+        } else if (type instanceof DoubleType) {
+            visitor.doubleColumn(this);
+        } else if (type instanceof StringType) {
+            visitor.stringColumn(this);
+        } else if (type instanceof TimestampType) {
+            visitor.timestampColumn(this);
+        } else {
+            assert(false);
+        }
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Column)) {
+            return false;
+        }
+        Column other = (Column) obj;
+        return Objects.equals(index, other.index) &&
+            Objects.equals(name, other.name) &&
+            Objects.equals(type, other.type);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return Objects.hash(index, name, type);
+    }
+
+    @Override
+    public String toString()
+    {
+        return String.format("Column{index:%d, name:%s, type:%s}",
+                getIndex(), getName(), getType().getName());
+    }
+}