embulk-output-ftp 0.1.0

data/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

data/lib/embulk/output/ftp.rb

@@ -0,0 +1,3 @@
+Embulk::JavaPlugin.register_output(
+  "ftp", "org.embulk.output.ftp.FtpFileOutputPlugin",
+  File.expand_path('../../../../classpath', __FILE__))

data/src/main/java/org/embulk/output/ftp/BlockingTransfer.java

@@ -0,0 +1,277 @@
+package org.embulk.output.ftp;
+
+import com.google.common.base.Function;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+public class BlockingTransfer
+{
+    private final WriterChannel writerChannel;
+    private final ReaderChannel readerChannel;
+    private Future<?> transferCompletionFuture;
+
+    public static BlockingTransfer submit(ExecutorService executor,
+            Function<BlockingTransfer, Runnable> starterFactory)
+    {
+        BlockingTransfer transfer = new BlockingTransfer();
+        final Runnable starter = starterFactory.apply(transfer);
+        transfer.setTransferCompletionFuture(
+                executor.submit(new Callable<Void>() {
+                    public Void call() throws Exception
+                    {
+                        starter.run();
+                        return null;
+                    }
+                })
+            );
+        return transfer;
+    }
+
+    private BlockingTransfer()
+    {
+        this.writerChannel = new WriterChannel();
+        this.readerChannel = new ReaderChannel();
+    }
+
+    private void setTransferCompletionFuture(Future<?> future)
+    {
+        this.transferCompletionFuture = future;
+    }
+
+    public ReadableByteChannel getReaderChannel()
+    {
+        return readerChannel;
+    }
+
+    public WritableByteChannel getWriterChannel()
+    {
+        return writerChannel;
+    }
+
+    public void transferFailed(Throwable exception)
+    {
+        readerChannel.overwriteException(exception);
+    }
+
+    void waitForTransferCompletion() throws IOException
+    {
+        Future<?> f = transferCompletionFuture;
+        if (f != null) {
+            try {
+                f.get();
+            }
+            catch (CancellationException | InterruptedException ex) {
+                throw new InterruptedIOException();
+            }
+            catch (ExecutionException ex) {
+                // transfer failed
+                Throwable e = ex.getCause();
+                if (e instanceof IOException) {
+                    throw (IOException) e;
+                }
+                else if (e instanceof RuntimeException) {
+                    throw (RuntimeException) e;
+                }
+                else if (e instanceof Error) {
+                    throw (Error) e;
+                }
+                else {
+                    throw new IOException(e);
+                }
+            }
+        }
+    }
+
+    public class WriterChannel implements WritableByteChannel
+    {
+        public int write(ByteBuffer src) throws IOException
+        {
+            int sz = src.remaining();
+            if (sz <= 0) {
+                return sz;
+            }
+
+            synchronized (readerChannel) {
+                if (!readerChannel.waitForWritable()) {
+                    return -1;
+                }
+
+                readerChannel.setBuffer(src);
+
+                if (!readerChannel.waitForWritable()) {  // wait for complete processing src
+                    return -1;
+                }
+            }
+
+            return sz - src.remaining();
+        }
+
+        public boolean isOpen()
+        {
+            return readerChannel.isOpen();
+        }
+
+        public void close() throws IOException
+        {
+            readerChannel.closePeer();
+            waitForTransferCompletion();
+        }
+    }
+
+    private static int transferByteBuffer(ByteBuffer src, ByteBuffer dst)
+    {
+        int pos = dst.position();
+
+        int srcrem = src.remaining();
+        int dstrem = dst.remaining();
+        if (dstrem < srcrem) {
+            int lim = src.limit();
+            try {
+                src.limit(src.position() + dstrem);
+                dst.put(src);
+            }
+            finally {
+                src.limit(lim);
+            }
+        }
+        else {
+            dst.put(src);
+        }
+
+        return dst.position() - pos;
+    }
+
+    public class ReaderChannel implements ReadableByteChannel
+    {
+        private ByteBuffer buffer;
+        private Throwable exception;
+
+        public synchronized int read(ByteBuffer dst) throws IOException
+        {
+            if (!waitForReadable()) {
+                return -1;
+            }
+
+            int len = transferByteBuffer(buffer, dst);
+            if (!buffer.hasRemaining()) {
+                setBuffer(null);
+                notifyAll();
+            }
+
+            return len;
+        }
+
+        public synchronized boolean isOpen()
+        {
+            return exception == null;
+        }
+
+        public void close() throws IOException
+        {
+            setException(new EOFException("reader closed channel"));
+        }
+
+        private void setBuffer(ByteBuffer buffer)
+        {
+            this.buffer = buffer;
+            notifyAll();
+        }
+
+        private synchronized boolean waitForWritable() throws IOException
+        {
+            while (buffer != null) {
+                if (exception != null) {
+                    if (exception instanceof EOFException) {
+                        return false;
+                    }
+                    throwException();
+                }
+
+                try {
+                    wait();
+                }
+                catch (InterruptedException ex) {
+                    // TODO throws ClosedByInterruptException or InterruptedIOException?
+                }
+            }
+
+            return true;
+        }
+
+        private boolean waitForReadable() throws IOException
+        {
+            while (buffer == null) {
+                if (exception != null) {
+                    if (exception instanceof EOFException) {
+                        return false;
+                    }
+                    throwException();
+                }
+
+                try {
+                    wait();
+                }
+                catch (InterruptedException ex) {
+                    // TODO throws ClosedByInterruptException or InterruptedIOException?
+                }
+            }
+
+            return true;
+        }
+
+        public synchronized void closePeer() throws IOException
+        {
+            waitForWritable();
+            if (exception != null && !(exception instanceof EOFException)) {
+                throwException();
+            }
+            setException(new EOFException("writer closed channel"));
+        }
+
+        public synchronized void setException(Throwable exception)
+        {
+            if (this.exception == null) {
+                this.exception = exception;
+            }
+            notifyAll();
+        }
+
+        public synchronized void overwriteException(Throwable exception)
+        {
+            this.exception = exception;
+            notifyAll();
+        }
+
+        public boolean hasException()
+        {
+            return exception != null;
+        }
+
+        public void throwException() throws IOException
+        {
+            Throwable ex = exception;
+            if (ex instanceof IOException) {
+                throw (IOException) ex;
+            }
+            else if (ex instanceof RuntimeException) {
+                throw (RuntimeException) ex;
+            }
+            else if (ex instanceof Error) {
+                throw (Error) ex;
+            }
+            else {
+                throw new IOException(ex);
+            }
+        }
+    }
+}