embulk-input-ftp 0.1.5 → 0.1.6

data/gradlew.bat

@@ -1,90 +0,0 @@
-@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/src/main/java/org/embulk/input/ftp/BlockingTransfer.java

@@ -1,267 +0,0 @@
-package org.embulk.input.ftp;
-
-import java.util.concurrent.Future;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.io.IOException;
-import java.io.EOFException;
-import java.io.InterruptedIOException;
-import java.nio.ByteBuffer;
-import java.nio.channels.ReadableByteChannel;
-import java.nio.channels.WritableByteChannel;
-import com.google.common.base.Function;
-
-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 ex) {
-                throw new InterruptedIOException();
-            } catch (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);
-            }
-        }
-    }
-}
-

data/src/main/java/org/embulk/input/ftp/SSLPlugins.java

@@ -1,245 +0,0 @@
-package org.embulk.input.ftp;
-
-import java.util.List;
-import java.io.Reader;
-import java.io.FileReader;
-import java.io.StringReader;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.FileNotFoundException;
-import java.security.KeyStore;
-import java.security.NoSuchAlgorithmException;
-import java.security.GeneralSecurityException;
-import java.security.cert.CertificateFactory;
-import java.security.cert.X509Certificate;
-import java.security.cert.CertificateException;
-import java.security.cert.CertificateEncodingException;
-import java.security.KeyManagementException;
-import javax.net.ssl.SSLSocketFactory;
-import javax.net.ssl.X509TrustManager;
-import com.google.common.base.Optional;
-import com.google.common.base.Function;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import org.embulk.config.Config;
-import org.embulk.config.ConfigDefault;
-import org.embulk.config.ConfigException;
-
-public class SSLPlugins
-{
-    // SSLPlugins is only for SSL clients. SSL server implementation is out ouf scope.
-
-    public interface SSLPluginTask
-    {
-        @Config("ssl_verify")
-        @ConfigDefault("null")
-        public Optional<Boolean> getSslVerify();
-
-        @Config("ssl_verify_hostname")
-        @ConfigDefault("true")
-        public boolean getSslVerifyHostname();
-
-        @Config("ssl_trusted_ca_cert_file")
-        @ConfigDefault("null")
-        public Optional<String> getSslTrustedCaCertFile();
-
-        @Config("ssl_trusted_ca_cert_data")
-        @ConfigDefault("null")
-        public Optional<String> getSslTrustedCaCertData();
-    }
-
-    private static enum VerifyMode
-    {
-        NO_VERIFY,
-        CERTIFICATES,
-        JVM_DEFAULT;
-    }
-
-    public static class SSLPluginConfig
-    {
-        static SSLPluginConfig NO_VERIFY = new SSLPluginConfig(VerifyMode.NO_VERIFY, false, ImmutableList.<byte[]>of());
-
-        private final VerifyMode verifyMode;
-        private final boolean verifyHostname;
-        private final List<X509Certificate> certificates;
-
-        @JsonCreator
-        private SSLPluginConfig(
-            @JsonProperty("verifyMode") VerifyMode verifyMode,
-            @JsonProperty("verifyHostname") boolean verifyHostname,
-            @JsonProperty("certificates") List<byte[]> certificates)
-        {
-            this.verifyMode = verifyMode;
-            this.verifyHostname = verifyHostname;
-            this.certificates = ImmutableList.copyOf(
-                    Lists.transform(certificates, new Function<byte[], X509Certificate>() {
-                        public X509Certificate apply(byte[] data)
-                        {
-                            try (ByteArrayInputStream in = new ByteArrayInputStream(data)) {
-                                CertificateFactory cf = CertificateFactory.getInstance("X.509");
-                                return (X509Certificate) cf.generateCertificate(in);
-                            } catch (IOException | CertificateException ex) {
-                                throw new RuntimeException(ex);
-                            }
-                        }
-                    })
-                );
-        }
-
-        SSLPluginConfig(List<X509Certificate> certificates, boolean verifyHostname)
-        {
-            this.verifyMode = VerifyMode.CERTIFICATES;
-            this.verifyHostname = verifyHostname;
-            this.certificates = certificates;
-        }
-
-        static SSLPluginConfig useJvmDefault(boolean verifyHostname)
-        {
-            return new SSLPluginConfig(VerifyMode.JVM_DEFAULT, verifyHostname, ImmutableList.<byte[]>of());
-        }
-
-        @JsonProperty("verifyMode")
-        private VerifyMode getVerifyMode()
-        {
-            return verifyMode;
-        }
-
-        @JsonProperty("verifyHostname")
-        private boolean getVerifyHostname()
-        {
-            return verifyHostname;
-        }
-
-        @JsonProperty("certificates")
-        private List<byte[]> getCertData()
-        {
-            return Lists.transform(certificates, new Function<X509Certificate, byte[]>() {
-                public byte[] apply(X509Certificate cert)
-                {
-                    try {
-                        return cert.getEncoded();
-                    } catch (CertificateEncodingException ex) {
-                        throw new RuntimeException(ex);
-                    }
-                }
-            });
-        }
-
-        @JsonIgnore
-        public X509TrustManager[] newTrustManager()
-        {
-            try {
-                switch (verifyMode) {
-                case NO_VERIFY:
-                    return new X509TrustManager[] { getNoVerifyTrustManager() };
-                case CERTIFICATES:
-                    return TrustManagers.newTrustManager(certificates);
-                default: // JVM_DEFAULT
-                    return TrustManagers.newDefaultJavaTrustManager();
-                }
-            } catch (IOException | GeneralSecurityException ex) {
-                throw new RuntimeException(ex);
-            }
-        }
-    }
-
-    public static enum DefaultVerifyMode
-    {
-        VERIFY_BY_JVM_TRUSTED_CA_CERTS,
-        NO_VERIFY;
-    };
-
-    public static SSLPluginConfig configure(SSLPluginTask task)
-    {
-        return configure(task, DefaultVerifyMode.VERIFY_BY_JVM_TRUSTED_CA_CERTS);
-    }
-
-    public static SSLPluginConfig configure(SSLPluginTask task, DefaultVerifyMode defaultVerifyMode)
-    {
-        boolean verify = task.getSslVerify().or(defaultVerifyMode != DefaultVerifyMode.NO_VERIFY);
-        if (verify) {
-            Optional<List<X509Certificate>> certs = readTrustedCertificates(task);
-            if (certs.isPresent()) {
-                return new SSLPluginConfig(certs.get(), task.getSslVerifyHostname());
-            } else {
-                return SSLPluginConfig.useJvmDefault(task.getSslVerifyHostname());
-            }
-        } else {
-            return SSLPluginConfig.NO_VERIFY;
-        }
-    }
-
-    private static Optional<List<X509Certificate>> readTrustedCertificates(SSLPluginTask task)
-    {
-        String optionName;
-        Reader reader;
-        if (task.getSslTrustedCaCertData().isPresent()) {
-            optionName = "ssl_trusted_ca_cert_data";
-            reader = new StringReader(task.getSslTrustedCaCertData().get());
-        } else if (task.getSslTrustedCaCertFile().isPresent()) {
-            optionName = "ssl_trusted_ca_cert_file '" + task.getSslTrustedCaCertFile().get() + "'";
-            try {
-                reader = new FileReader(task.getSslTrustedCaCertFile().get());
-            } catch (IOException ex) {
-                throw new ConfigException("Failed to open "+optionName, ex);
-            }
-        } else {
-            return Optional.absent();
-        }
-
-        List<X509Certificate> certs;
-        try (Reader r = reader) {
-            certs = TrustManagers.readPemEncodedX509Certificates(r);
-            if (certs.isEmpty()) {
-                throw new ConfigException(optionName + " does not include valid X.509 PEM certificates");
-            }
-        } catch (CertificateException | IOException ex) {
-            throw new ConfigException("Failed to read "+optionName, ex);
-        }
-
-        return Optional.of(certs);
-    }
-
-    public static SSLSocketFactory newSSLSocketFactory(SSLPluginConfig config, String hostname)
-    {
-        try {
-            return TrustManagers.newSSLSocketFactory(
-                    null,  // TODO sending client certificate is not implemented yet
-                    config.newTrustManager(),
-                    config.getVerifyHostname() ? hostname : null);
-        } catch (KeyManagementException ex) {
-            throw new RuntimeException(ex);
-        }
-    }
-
-    private static class NoVerifyTrustManager
-            implements X509TrustManager
-    {
-        static final NoVerifyTrustManager INSTANCE = new NoVerifyTrustManager();
-
-        private NoVerifyTrustManager()
-        { }
-
-        @Override
-        public X509Certificate[] getAcceptedIssuers()
-        {
-            return null;
-        }
-
-        @Override
-        public void checkClientTrusted(X509Certificate[] certs, String authType)
-        { }
-
-        @Override
-        public void checkServerTrusted(X509Certificate[] certs, String authType)
-        { }
-    }
-
-    private static X509TrustManager getNoVerifyTrustManager()
-    {
-        return NoVerifyTrustManager.INSTANCE;
-    }
-}