Example usage for org.apache.commons.net.ftp FTPClientConfig FTPClientConfig

List of usage examples for org.apache.commons.net.ftp FTPClientConfig FTPClientConfig

Introduction

In this page you can find the example usage for org.apache.commons.net.ftp FTPClientConfig FTPClientConfig.

Prototype

public FTPClientConfig() 

Source Link

Document

Convenience constructor mainly for use in testing.

Usage

From source file:com.sos.VirtualFileSystem.FTPS.SOSVfsFtpS.java

@Override
protected FTPSClient Client() {
    if (objFTPClient == null) {
        try {/*  ww  w  .j  a v a 2s .co  m*/
            String strProtocol = objConnection2Options.FtpS_protocol.Value();
            objFTPClient = new FTPSClient(strProtocol);
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new JobSchedulerException("can not create FTPS-Client");
        }
        FTPClientConfig conf = new FTPClientConfig();
        //         conf.setServerLanguageCode("fr");
        //         objFTPClient.configure(conf);
        /**
         * This listener is to write all commands and response from commands to system.out
         *
         */
        objProtocolCommandListener = new SOSFtpClientLogger(HostID(""));
        // TODO create a hidden debug-option to activate this listener
        if (objConnection2Options != null) {
            if (objConnection2Options.ProtocolCommandListener.isTrue()) {
                objFTPClient.addProtocolCommandListener(objProtocolCommandListener);
            }
        }

        String strAddFTPProtocol = System.getenv("AddFTPProtocol");
        if (strAddFTPProtocol != null && strAddFTPProtocol.equalsIgnoreCase("true")) {
            objFTPClient.addProtocolCommandListener(objProtocolCommandListener);
        }

    }
    return objFTPClient;
}

From source file:co.cask.hydrator.action.ftp.FTPCopyAction.java

@Override
public void run(ActionContext context) throws Exception {
    Path destination = new Path(config.getDestDirectory());
    FileSystem fileSystem = FileSystem.get(new Configuration());
    destination = fileSystem.makeQualified(destination);
    if (!fileSystem.exists(destination)) {
        fileSystem.mkdirs(destination);/*from   w  w  w .  j ava 2  s.  c om*/
    }

    FTPClient ftp;
    if ("ftp".equals(config.getProtocol().toLowerCase())) {
        ftp = new FTPClient();
    } else {
        ftp = new FTPSClient();
    }
    ftp.setControlKeepAliveTimeout(5);
    // UNIX type server
    FTPClientConfig ftpConfig = new FTPClientConfig();
    // Set additional parameters required for the ftp
    // for example config.setServerTimeZoneId("Pacific/Pitcairn")
    ftp.configure(ftpConfig);
    try {
        ftp.connect(config.getHost(), config.getPort());
        ftp.enterLocalPassiveMode();
        String replyString = ftp.getReplyString();
        LOG.info("Connected to server {} and port {} with reply from connect as {}.", config.getHost(),
                config.getPort(), replyString);

        // Check the reply code for actual success
        int replyCode = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(replyCode)) {
            ftp.disconnect();
            throw new RuntimeException(String.format("FTP server refused connection with code %s and reply %s.",
                    replyCode, replyString));
        }

        if (!ftp.login(config.getUserName(), config.getPassword())) {
            LOG.error("login command reply code {}, {}", ftp.getReplyCode(), ftp.getReplyString());
            ftp.logout();
            throw new RuntimeException(String.format(
                    "Login to the FTP server %s and port %s failed. " + "Please check user name and password.",
                    config.getHost(), config.getPort()));
        }

        FTPFile[] ftpFiles = ftp.listFiles(config.getSrcDirectory());
        LOG.info("listFiles command reply code: {}, {}.", ftp.getReplyCode(), ftp.getReplyString());
        // Check the reply code for listFiles call.
        // If its "522 Data connections must be encrypted" then it means data channel also need to be encrypted
        if (ftp.getReplyCode() == 522 && "sftp".equalsIgnoreCase(config.getProtocol())) {
            // encrypt data channel and listFiles again
            ((FTPSClient) ftp).execPROT("P");
            LOG.info("Attempting command listFiles on encrypted data channel.");
            ftpFiles = ftp.listFiles(config.getSrcDirectory());
        }
        for (FTPFile file : ftpFiles) {
            String source = config.getSrcDirectory() + "/" + file.getName();

            LOG.info("Current file {}, source {}", file.getName(), source);
            if (config.getExtractZipFiles() && file.getName().endsWith(".zip")) {
                copyZip(ftp, source, fileSystem, destination);
            } else {
                Path destinationPath = fileSystem.makeQualified(new Path(destination, file.getName()));
                LOG.debug("Downloading {} to {}", file.getName(), destinationPath.toString());
                try (OutputStream output = fileSystem.create(destinationPath)) {
                    InputStream is = ftp.retrieveFileStream(source);
                    ByteStreams.copy(is, output);
                }
            }
            if (!ftp.completePendingCommand()) {
                LOG.error("Error completing command.");
            }
        }
        ftp.logout();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (Throwable e) {
                LOG.error("Failure to disconnect the ftp connection.", e);
            }
        }
    }
}

From source file:net.audumla.climate.bom.BOMDataLoader.java

private synchronized FTPClient getFTPClient(String host) {
    FTPClient ftp = ftpClients.get(host);
    if (ftp == null || !ftp.isAvailable() || !ftp.isConnected()) {
        ftp = new FTPClient();
        FTPClientConfig config = new FTPClientConfig();
        ftp.configure(config);/* w w  w  . jav  a  2s  .c  o m*/
        try {
            ftp.setControlKeepAliveTimeout(30);
            ftp.setControlKeepAliveReplyTimeout(5);
            ftp.setDataTimeout(3000);
            ftp.setDefaultTimeout(1000);
            int reply;
            ftp.connect(host);
            LOG.debug("Connected to " + host);
            reply = ftp.getReplyCode();
            if (!FTPReply.isPositiveCompletion(reply)) {
                ftp.disconnect();
                LOG.error("FTP server '" + host + "' refused connection.");
            } else {
                if (!ftp.login("anonymous", "guest")) {
                    LOG.error("Unable to login to server " + host);
                }
                ftp.setSoTimeout(60000);
                ftp.enterLocalPassiveMode();
                ftp.setFileType(FTPClient.BINARY_FILE_TYPE);

            }
        } catch (IOException e) {
            LOG.error("Unable to connect to " + host, e);
        }
        ftpClients.put(host, ftp);
    }
    if (!ftp.isConnected() || !ftp.isAvailable()) {
        throw new UnsupportedOperationException("Cannot connect to " + host);
    }
    return ftp;
}

From source file:com.o6Systems.utils.net.FTPModule.java

private int executeFtpCommand(String[] args) throws UnknownHostException {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;/*from  w w  w  . jav a  2s.c om*/
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false;
    boolean lenient = false;
    long keepAliveTimeout = -1;
    int controlKeepAliveReplyTimeout = -1;
    int minParams = 5; // listings require 3 params
    String protocol = null; // SSL protocol
    String doCommand = null;
    String trustmgr = null;
    String proxyHost = null;
    int proxyPort = 80;
    String proxyUser = null;
    String proxyPassword = null;
    String username = null;
    String password = null;

    int base = 0;

    // Print the command

    System.out.println("----------FTP MODULE CALL----------");

    for (int i = 0; i < args.length; i++) {
        System.out.println(args[i]);
    }

    System.out.println("--------------------");
    //

    for (base = 0; base < args.length; base++) {
        if (args[base].equals("-s")) {
            storeFile = true;
        } else if (args[base].equals("-a")) {
            localActive = true;
        } else if (args[base].equals("-A")) {
            username = "anonymous";
            password = System.getProperty("user.name") + "@" + InetAddress.getLocalHost().getHostName();
        } else if (args[base].equals("-b")) {
            binaryTransfer = true;
        } else if (args[base].equals("-c")) {
            doCommand = args[++base];
            minParams = 3;
        } else if (args[base].equals("-d")) {
            mlsd = true;
            minParams = 3;
        } else if (args[base].equals("-e")) {
            useEpsvWithIPv4 = true;
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-k")) {
            keepAliveTimeout = Long.parseLong(args[++base]);
        } else if (args[base].equals("-l")) {
            listFiles = true;
            minParams = 3;
        } else if (args[base].equals("-L")) {
            lenient = true;
        } else if (args[base].equals("-n")) {
            listNames = true;
            minParams = 3;
        } else if (args[base].equals("-p")) {
            protocol = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-w")) {
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
        } else if (args[base].equals("-T")) {
            trustmgr = args[++base];
        } else if (args[base].equals("-PrH")) {
            proxyHost = args[++base];
            String parts[] = proxyHost.split(":");
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
        } else if (args[base].equals("-PrU")) {
            proxyUser = args[++base];
        } else if (args[base].equals("-PrP")) {
            proxyPassword = args[++base];
        } else if (args[base].equals("-#")) {
            printHash = true;
        } else {
            break;
        }
    }

    int remain = args.length - base;
    if (username != null) {
        minParams -= 2;
    }

    String server = args[base++];
    int port = 0;
    String parts[] = server.split(":");
    if (parts.length == 2) {
        server = parts[0];
        port = Integer.parseInt(parts[1]);
    }
    if (username == null) {
        username = args[base++];
        password = args[base++];
    }

    String remote = null;
    if (args.length - base > 0) {
        remote = args[base++];
    }

    String local = null;
    if (args.length - base > 0) {
        local = args[base++];
    }

    final FTPClient ftp;
    if (protocol == null) {
        if (proxyHost != null) {
            System.out.println("Using HTTP proxy server: " + proxyHost);
            ftp = new FTPHTTPClient(proxyHost, proxyPort, proxyUser, proxyPassword);
        } else {
            ftp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (protocol.equals("true")) {
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            ftps = new FTPSClient(false);
        } else {
            String prot[] = protocol.split(",");
            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                ftps = new FTPSClient(prot[0], Boolean.parseBoolean(prot[1]));
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (printHash) {
        ftp.setCopyStreamListener(createListener());
    }
    if (keepAliveTimeout >= 0) {
        ftp.setControlKeepAliveTimeout(keepAliveTimeout);
    }
    if (controlKeepAliveReplyTimeout >= 0) {
        ftp.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    ftp.setListHiddenFiles(hidden);

    // suppress login details
    ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out), true));

    try {
        int reply;
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }
        System.out.println("Connected to " + server + " on " + (port > 0 ? port : ftp.getDefaultPort()));

        // After connection attempt, you should check the reply code to verify
        // success.
        reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.err.println("FTP server refused connection.");
            return 1;
        }
    } catch (IOException e) {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        return 1;
    }

    __main: try {
        if (!ftp.login(username, password)) {
            ftp.logout();
            error = true;
            break __main;
        }

        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            // in theory this should not be necessary as servers should default to ASCII
            // but they don't all do so - see NET-500
            ftp.setFileType(FTP.ASCII_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (localActive) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4(useEpsvWithIPv4);

        if (storeFile) {
            InputStream input;

            input = new FileInputStream(local);

            ftp.storeFile(remote, input);

            input.close();
        } else if (listFiles) {
            if (lenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                ftp.configure(config);
            }

            for (FTPFile f : ftp.listFiles(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlsd) {
            for (FTPFile f : ftp.mlistDir(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlst) {
            FTPFile f = ftp.mlistFile(remote);
            if (f != null) {
                System.out.println(f.toFormattedString());
            }
        } else if (listNames) {
            for (String s : ftp.listNames(remote)) {
                System.out.println(s);
            }
        } else if (feat) {
            // boolean feature check
            if (remote != null) { // See if the command is present
                if (ftp.hasFeature(remote)) {
                    System.out.println("Has feature: " + remote);
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " was not detected");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }

                // Strings feature check
                String[] features = ftp.featureValues(remote);
                if (features != null) {
                    for (String f : features) {
                        System.out.println("FEAT " + remote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " is not present");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }
            } else {
                if (ftp.features()) {
                    //                        Command listener has already printed the output
                } else {
                    System.out.println("Failed: " + ftp.getReplyString());
                }
            }
        } else if (doCommand != null) {
            if (ftp.doCommand(doCommand, remote)) {
                //                  Command listener has already printed the output
                //                    for(String s : ftp.getReplyStrings()) {
                //                        System.out.println(s);
                //                    }
            } else {
                System.out.println("Failed: " + ftp.getReplyString());
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(local);

            ftp.retrieveFile(remote, output);

            output.close();
        }

        ftp.noop(); // check that control connection is working OK

        ftp.logout();
    } catch (FTPConnectionClosedException e) {
        error = true;
        System.err.println("Server closed connection.");
        e.printStackTrace();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

    return error ? 1 : 0;
}

From source file:ch.sdi.core.impl.ftp.FTPClientExample.java

/**
*
*//*from  w  ww.ja va 2s . c  o m*/
private void run() throws Throwable {
    if (myProtocol == null) {
        if (myProxyHost != null) {
            myLog.debug("Using HTTP proxy server: " + myProxyHost);
            myFtp = new FTPHTTPClient(myProxyHost, myProxyPort, myProxyUser, myProxyPassword);
        } else {
            myFtp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (myProtocol.equals("true")) {
            ftps = new FTPSClient(true);
        } else if (myProtocol.equals("false")) {
            ftps = new FTPSClient(false);
        } else {
            String prot[] = myProtocol.split(",");
            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(myProtocol);
            } else { // protocol,true|false
                ftps = new FTPSClient(prot[0], Boolean.parseBoolean(prot[1]));
            }
        }
        myFtp = ftps;
        if ("all".equals(myTrustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(myTrustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(myTrustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (myPrintHash) {
        myFtp.setCopyStreamListener(createListener());
    }
    if (myKeepAliveTimeout >= 0) {
        myFtp.setControlKeepAliveTimeout(myKeepAliveTimeout);
    }
    if (myControlKeepAliveReplyTimeout >= 0) {
        myFtp.setControlKeepAliveReplyTimeout(myControlKeepAliveReplyTimeout);
    }
    myFtp.setListHiddenFiles(myHidden);

    // intercept commands and write it to our logger
    myPrintCommandToLoggerListener = new PrintCommandToLoggerListener(myLog);
    PrintWriter writer = myPrintCommandToLoggerListener.getPrintWriter();
    myFtp.addProtocolCommandListener(new PrintCommandListener(writer, true, '\n', true));
    //        myFtp.addProtocolCommandListener( new PrintCommandListener( new PrintWriter( System.out ), true ) );

    try {
        int reply;
        if (myPort > 0) {
            myFtp.connect(myServer, myPort);
        } else {
            myFtp.connect(myServer);
        }

        myLog.debug("Connected to " + myServer + " on " + (myPort > 0 ? myPort : myFtp.getDefaultPort()));

        // After connection attempt, you should check the reply code to verify
        // success.
        reply = myFtp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            myFtp.disconnect();
            throw new Exception("FTP server refused connection.");
        }
    } catch (IOException e) {
        if (myFtp.isConnected()) {
            try {
                myFtp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        throw new Exception("Could not connect to server.", e);
    }

    try {
        if (!myFtp.login(myUsername, myPassword)) {
            myFtp.logout();
            throw createFtpException("Problems on login");
        }

        myLog.debug("Remote system is " + myFtp.getSystemType());

        if (myBinaryTransfer) {
            myFtp.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            // in theory this should not be necessary as servers should default to ASCII
            // but they don't all do so - see NET-500
            myFtp.setFileType(FTP.ASCII_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (myLocalActive) {
            myFtp.enterLocalActiveMode();
        } else {
            myFtp.enterLocalPassiveMode();
        }

        myFtp.setUseEPSVwithIPv4(myUseEpsvWithIPv4);

        if (myStoreFile) {
            InputStream input;

            input = new FileInputStream(myLocal);

            myFtp.storeFile(myRemote, input);

            input.close();
        } else if (myListFiles) {
            if (myLenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                myFtp.configure(config);
            }

            for (FTPFile f : myFtp.listFiles(myRemote)) {
                myLog.debug(f.getRawListing());
                myLog.debug(f.toFormattedString());
            }
        } else if (myMlsd) {
            for (FTPFile f : myFtp.mlistDir(myRemote)) {
                myLog.debug(f.getRawListing());
                myLog.debug(f.toFormattedString());
            }
        } else if (myMlst) {
            FTPFile f = myFtp.mlistFile(myRemote);
            if (f != null) {
                myLog.debug(f.toFormattedString());
            }
        } else if (myListNames) {
            for (String s : myFtp.listNames(myRemote)) {
                myLog.debug(s);
            }
        } else if (myFeat) {
            // boolean feature check
            if (myRemote != null) { // See if the command is present
                if (myFtp.hasFeature(myRemote)) {
                    myLog.debug("Has feature: " + myRemote);
                } else {
                    if (FTPReply.isPositiveCompletion(myFtp.getReplyCode())) {
                        myLog.debug("FEAT " + myRemote + " was not detected");
                    } else {
                        throw createFtpException("Command failed");
                    }
                }

                // Strings feature check
                String[] features = myFtp.featureValues(myRemote);
                if (features != null) {
                    for (String f : features) {
                        myLog.debug("FEAT " + myRemote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(myFtp.getReplyCode())) {
                        myLog.warn("FEAT " + myRemote + " is not present");
                    } else {
                        throw createFtpException("Command failed");
                    }
                }
            } else {
                if (myFtp.features()) {
                    // Command listener has already printed the output
                } else {
                    throw createFtpException("Command failed");
                }
            }
        } else if (myDoCommand != null) {
            if (myFtp.doCommand(myDoCommand, myRemote)) {
                // Command listener has already printed the output
            } else {
                throw createFtpException("Command failed");
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(myLocal);

            myFtp.retrieveFile(myRemote, output);

            output.close();
        }

        myFtp.noop(); // check that control connection is working OK

        myFtp.logout();
    } catch (FTPConnectionClosedException e) {
        throw createFtpException("Server closed connection.");
    } catch (IOException e) {
        throw createFtpException("IOException caught");
    } finally {
        myPrintCommandToLoggerListener.flushRest();

        if (myFtp.isConnected()) {
            try {
                myFtp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

}

From source file:com.sos.VirtualFileSystem.FTP.SOSVfsFtp.java

@Override
protected final FTPClient Client() {
    if (objFTPClient == null) {
        objFTPClient = new FTPClient();
        FTPClientConfig conf = new FTPClientConfig();
        // conf.setServerLanguageCode("fr");
        // objFTPClient.configure(conf);
        /**/*from  w  w  w  .j a  va  2  s . c  o  m*/
         * This listener is to write all commands and response from commands to system.out
         *
         */
        objProtocolCommandListener = new SOSFtpClientLogger(HostID(""));
        if (objConnection2Options != null) {
            if (objConnection2Options.ProtocolCommandListener.isTrue()) {
                objFTPClient.addProtocolCommandListener(objProtocolCommandListener);
                logger.debug("ProtocolcommandListener added and activated");
            }
        }

        // TODO implement as an additional Option-setting
        String strAddFTPProtocol = System.getenv("AddFTPProtocol");
        if (strAddFTPProtocol != null && strAddFTPProtocol.equalsIgnoreCase("true")) {
            objFTPClient.addProtocolCommandListener(objProtocolCommandListener);
        }

    }
    return objFTPClient;
}

From source file:nz.co.jsrsolutions.ds3.provider.CMEEodDataProvider.java

public CMEEodDataProvider(String hostname, String basePath, CMEEodDataProviderExchangeDescriptor[] descriptors)
        throws EodDataProviderException {

    _hostname = hostname;//from   w  ww . java 2s  .c  om
    _basePath = basePath;
    _descriptors = descriptors;

    FTPClient ftp = new FTPClient();
    FTPClientConfig config = new FTPClientConfig();
    ftp.configure(config);
    boolean error = false;
    try {
        int reply;
        ftp.connect(_hostname);
        _logger.info("Connected to " + _hostname);
        _logger.info(ftp.getReplyString());

        // After connection attempt, you should check the reply code to
        // verify
        // success.
        reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            _logger.error("FTP server refused connection.");
            throw new EodDataProviderException("FTP server refused connection.");
        }

        boolean result = ftp.login("anonymous", "jsr@argusat.com");

        result = ftp.changeWorkingDirectory(_basePath);
        reply = ftp.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            _logger.error(reply);
            throw new EodDataProviderException("Failed to cd into " + _basePath);
        }

        for (CMEEodDataProviderExchangeDescriptor descriptor : _descriptors) {

            OutputStream output = new ByteArrayOutputStream();

            String modificationTime = ftp.getModificationTime(descriptor.getFilename());

            // 213 20131202235804\r\n

            result = ftp.retrieveFile(descriptor.getFilename(), output);

            output.close();
        }

        ftp.logout();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException ioe) {
                // do nothing
            }
        }
    }
}

From source file:org.amanzi.neo.geoptima.loader.ui.page.impl.SelectFtpDataPage.java

/**
 *
 *//*from w w  w  .  ja  va  2  s .c  o  m*/
private void connectToFtp() {
    try {
        if (getConfiguration().getFtpClient() != null) {
            getConfiguration().getFtpClient().disconnect();
        }
        FTPClient client = new FTPClient();
        FTPClientConfig config = new FTPClientConfig();
        client.configure(config);

        client.connect(getUrl());
        client.login(userNameWidget.getText(), passwordWidget.getText());
        viewer.initialize(client);
        getConfiguration().setFtpClient(client);
    } catch (IOException e) {
        LOGGER.error("can't connect to server", e);
    }
}

From source file:org.apache.camel.component.file.remote.FromFtpClientConfigRefTest.java

@Override
protected JndiRegistry createRegistry() throws Exception {
    JndiRegistry jndi = super.createRegistry();

    FTPClientConfig config = new FTPClientConfig();
    config.setServerLanguageCode("fr");
    config.setLenientFutureDates(true);/*  w w  w  . ja  v a  2  s  .  co m*/

    jndi.bind("myConfig", config);
    return jndi;
}

From source file:org.apache.camel.component.file.remote.FtpEndpoint.java

public RemoteFileOperations<FTPFile> createRemoteFileOperations() throws Exception {
    // configure ftp client
    FTPClient client = ftpClient;//  w  ww. j  a  v a2 s.c o  m

    if (client == null) {
        // must use a new client if not explicit configured to use a custom client
        client = createFtpClient();
    }

    // set any endpoint configured timeouts
    if (getConfiguration().getConnectTimeout() > -1) {
        client.setConnectTimeout(getConfiguration().getConnectTimeout());
    }
    if (getConfiguration().getSoTimeout() > -1) {
        soTimeout = getConfiguration().getSoTimeout();
    }
    dataTimeout = getConfiguration().getTimeout();

    // then lookup ftp client parameters and set those
    if (ftpClientParameters != null) {
        Map<String, Object> localParameters = new HashMap<String, Object>(ftpClientParameters);
        // setting soTimeout has to be done later on FTPClient (after it has connected)
        Object timeout = localParameters.remove("soTimeout");
        if (timeout != null) {
            soTimeout = getCamelContext().getTypeConverter().convertTo(int.class, timeout);
        }
        // and we want to keep data timeout so we can log it later
        timeout = localParameters.remove("dataTimeout");
        if (timeout != null) {
            dataTimeout = getCamelContext().getTypeConverter().convertTo(int.class, dataTimeout);
        }
        setProperties(client, localParameters);
    }

    if (ftpClientConfigParameters != null) {
        // client config is optional so create a new one if we have parameter for it
        if (ftpClientConfig == null) {
            ftpClientConfig = new FTPClientConfig();
        }
        Map<String, Object> localConfigParameters = new HashMap<String, Object>(ftpClientConfigParameters);
        setProperties(ftpClientConfig, localConfigParameters);
    }

    if (dataTimeout > 0) {
        client.setDataTimeout(dataTimeout);
    }

    if (log.isDebugEnabled()) {
        log.debug("Created FTPClient [connectTimeout: {}, soTimeout: {}, dataTimeout: {}]: {}",
                new Object[] { client.getConnectTimeout(), getSoTimeout(), dataTimeout, client });
    }

    FtpOperations operations = new FtpOperations(client, getFtpClientConfig());
    operations.setEndpoint(this);
    return operations;
}