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

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

Introduction

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

Prototype

public void setServerTimeZoneId(String serverTimeZoneId) 

Source Link

Document

setter for the serverTimeZoneId property.

Usage

From source file:com.github.carlosrubio.org.apache.tools.ant.taskdefs.optional.net.FTPConfigurator.java

/**
 * configures the supplied FTPClient with the various
 * attributes set in the supplied FTP task.
 * @param client the FTPClient to be configured
 * @param task the FTP task whose attributes are used to
 * configure the client/*from www  .  j  a v  a2 s.c o m*/
 * @return the client as configured.
 */
static FTPClient configure(FTPClient client, FTP task) {
    task.log("custom configuration", Project.MSG_VERBOSE);
    FTPClientConfig config;
    String systemTypeKey = task.getSystemTypeKey();
    if (systemTypeKey != null && !"".equals(systemTypeKey)) {
        config = new FTPClientConfig(systemTypeKey);
        task.log("custom config: system key = " + systemTypeKey, Project.MSG_VERBOSE);
    } else {
        config = new FTPClientConfig();
        task.log("custom config: system key = default (UNIX)", Project.MSG_VERBOSE);
    }

    String defaultDateFormatConfig = task.getDefaultDateFormatConfig();
    if (defaultDateFormatConfig != null) {
        config.setDefaultDateFormatStr(defaultDateFormatConfig);
        task.log("custom config: default date format = " + defaultDateFormatConfig, Project.MSG_VERBOSE);
    }

    String recentDateFormatConfig = task.getRecentDateFormatConfig();
    if (recentDateFormatConfig != null) {
        config.setRecentDateFormatStr(recentDateFormatConfig);
        task.log("custom config: recent date format = " + recentDateFormatConfig, Project.MSG_VERBOSE);
    }

    String serverLanguageCodeConfig = task.getServerLanguageCodeConfig();
    if (serverLanguageCodeConfig != null) {
        if (!"".equals(serverLanguageCodeConfig)
                && !FTPClientConfig.getSupportedLanguageCodes().contains(serverLanguageCodeConfig)) {
            throw new BuildException("unsupported language code" + serverLanguageCodeConfig);
        }
        config.setServerLanguageCode(serverLanguageCodeConfig);
        task.log("custom config: server language code = " + serverLanguageCodeConfig, Project.MSG_VERBOSE);
    }

    String serverTimeZoneConfig = task.getServerTimeZoneConfig();
    if (serverTimeZoneConfig != null) {
        config.setServerTimeZoneId(serverTimeZoneConfig);
        task.log("custom config: server time zone ID = " + serverTimeZoneConfig, Project.MSG_VERBOSE);
    }

    String shortMonthNamesConfig = task.getShortMonthNamesConfig();
    if (shortMonthNamesConfig != null) {
        config.setShortMonthNames(shortMonthNamesConfig);
        task.log("custom config: short month names = " + shortMonthNamesConfig, Project.MSG_VERBOSE);
    }
    client.configure(config);
    return client;
}

From source file:fr.acxio.tools.agia.ftp.DefaultFtpClientFactory.java

public FTPClient getFtpClient() throws IOException {
    FTPClient aClient = new FTPClient();

    // Debug output
    // aClient.addProtocolCommandListener(new PrintCommandListener(new
    // PrintWriter(System.out), true));

    if (activeExternalIPAddress != null) {
        aClient.setActiveExternalIPAddress(activeExternalIPAddress);
    }//w w w  .ja  va  2s . c  o  m
    if (activeMinPort != null && activeMaxPort != null) {
        aClient.setActivePortRange(activeMinPort, activeMaxPort);
    }
    if (autodetectUTF8 != null) {
        aClient.setAutodetectUTF8(autodetectUTF8);
    }
    if (bufferSize != null) {
        aClient.setBufferSize(bufferSize);
    }
    if (charset != null) {
        aClient.setCharset(charset);
    }
    if (connectTimeout != null) {
        aClient.setConnectTimeout(connectTimeout);
    }
    if (controlEncoding != null) {
        aClient.setControlEncoding(controlEncoding);
    }
    if (controlKeepAliveReplyTimeout != null) {
        aClient.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    if (controlKeepAliveTimeout != null) {
        aClient.setControlKeepAliveTimeout(controlKeepAliveTimeout);
    }
    if (dataTimeout != null) {
        aClient.setDataTimeout(dataTimeout);
    }
    if (defaultPort != null) {
        aClient.setDefaultPort(defaultPort);
    }
    if (defaultTimeout != null) {
        aClient.setDefaultTimeout(defaultTimeout);
    }
    if (fileStructure != null) {
        aClient.setFileStructure(fileStructure);
    }
    if (keepAlive != null) {
        aClient.setKeepAlive(keepAlive);
    }
    if (listHiddenFiles != null) {
        aClient.setListHiddenFiles(listHiddenFiles);
    }
    if (parserFactory != null) {
        aClient.setParserFactory(parserFactory);
    }
    if (passiveLocalIPAddress != null) {
        aClient.setPassiveLocalIPAddress(passiveLocalIPAddress);
    }
    if (passiveNatWorkaround != null) {
        aClient.setPassiveNatWorkaround(passiveNatWorkaround);
    }
    if (proxy != null) {
        aClient.setProxy(proxy);
    }
    if (receieveDataSocketBufferSize != null) {
        aClient.setReceieveDataSocketBufferSize(receieveDataSocketBufferSize);
    }
    if (receiveBufferSize != null) {
        aClient.setReceiveBufferSize(receiveBufferSize);
    }
    if (remoteVerificationEnabled != null) {
        aClient.setRemoteVerificationEnabled(remoteVerificationEnabled);
    }
    if (reportActiveExternalIPAddress != null) {
        aClient.setReportActiveExternalIPAddress(reportActiveExternalIPAddress);
    }
    if (sendBufferSize != null) {
        aClient.setSendBufferSize(sendBufferSize);
    }
    if (sendDataSocketBufferSize != null) {
        aClient.setSendDataSocketBufferSize(sendDataSocketBufferSize);
    }
    if (strictMultilineParsing != null) {
        aClient.setStrictMultilineParsing(strictMultilineParsing);
    }
    if (tcpNoDelay != null) {
        aClient.setTcpNoDelay(tcpNoDelay);
    }
    if (useEPSVwithIPv4 != null) {
        aClient.setUseEPSVwithIPv4(useEPSVwithIPv4);
    }

    if (systemKey != null) {
        FTPClientConfig aClientConfig = new FTPClientConfig(systemKey);
        if (defaultDateFormat != null) {
            aClientConfig.setDefaultDateFormatStr(defaultDateFormat);
        }
        if (recentDateFormat != null) {
            aClientConfig.setRecentDateFormatStr(recentDateFormat);
        }
        if (serverLanguageCode != null) {
            aClientConfig.setServerLanguageCode(serverLanguageCode);
        }
        if (shortMonthNames != null) {
            aClientConfig.setShortMonthNames(shortMonthNames);
        }
        if (serverTimeZoneId != null) {
            aClientConfig.setServerTimeZoneId(serverTimeZoneId);
        }
        aClient.configure(aClientConfig);
    }

    if (LOGGER.isInfoEnabled()) {
        LOGGER.info("Connecting to : {}", host);
    }

    if (port == null) {
        aClient.connect(host);
    } else {
        aClient.connect(host, port);
    }

    int aReplyCode = aClient.getReplyCode();

    if (!FTPReply.isPositiveCompletion(aReplyCode)) {
        aClient.disconnect();
        throw new IOException("Cannot connect to " + host + ". Returned code : " + aReplyCode);
    }

    try {
        if (localPassiveMode) {
            aClient.enterLocalPassiveMode();
        }

        boolean aIsLoggedIn = false;
        if (account == null) {
            aIsLoggedIn = aClient.login(username, password);
        } else {
            aIsLoggedIn = aClient.login(username, password, account);
        }
        if (!aIsLoggedIn) {
            throw new IOException(aClient.getReplyString());
        }
    } catch (IOException e) {
        aClient.disconnect();
        throw e;
    }

    if (fileTransferMode != null) {
        aClient.setFileTransferMode(fileTransferMode);
    }
    if (fileType != null) {
        aClient.setFileType(fileType);
    }

    return aClient;
}

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

private FTPClientConfig createConfig() {
    FTPClientConfig config = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
    config.setServerTimeZoneId("Europe/Paris");
    return config;
}

From source file:org.apache.commons.net.examples.ftp.FTPClientExample.java

public static void main(String[] args) throws UnknownHostException {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;//from  ww w . j a va2 s.  co m
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false, mdtm = false, saveUnparseable = false;
    boolean size = 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;
    String encoding = null;
    String serverTimeZoneId = null;
    String displayTimeZoneId = null;
    String serverType = null;
    String defaultDateFormat = null;
    String recentDateFormat = null;

    int base = 0;
    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("-E")) {
            encoding = args[++base];
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-i")) {
            size = true;
            minParams = 3;
        } 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("-m")) {
            mdtm = 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("-S")) {
            serverType = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-U")) {
            saveUnparseable = true;
        } 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("-y")) {
            defaultDateFormat = args[++base];
        } else if (args[base].equals("-Y")) {
            recentDateFormat = args[++base];
        } else if (args[base].equals("-Z")) {
            serverTimeZoneId = args[++base];
        } else if (args[base].equals("-z")) {
            displayTimeZoneId = 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;
    }
    if (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        if (args.length > 0) {
            System.err.println("Actual Parameters: " + Arrays.toString(args));
        }
        System.err.println(USAGE);
        System.exit(1);
    }

    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);
    }
    if (encoding != null) {
        ftp.setControlEncoding(encoding);
    }
    ftp.setListHiddenFiles(hidden);

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

    final FTPClientConfig config;
    if (serverType != null) {
        config = new FTPClientConfig(serverType);
    } else {
        config = new FTPClientConfig();
    }
    config.setUnparseableEntries(saveUnparseable);
    if (defaultDateFormat != null) {
        config.setDefaultDateFormatStr(defaultDateFormat);
    }
    if (recentDateFormat != null) {
        config.setRecentDateFormatStr(recentDateFormat);
    }
    ftp.configure(config);

    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.");
            System.exit(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();
        System.exit(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();

            if (keepAliveTimeout > 0) {
                showCslStats(ftp);
            }
        }
        // Allow multiple list types for single invocation
        else if (listFiles || mlsd || mdtm || mlst || listNames || size) {
            if (mlsd) {
                for (FTPFile f : ftp.mlistDir(remote)) {
                    System.out.println(f.getRawListing());
                    System.out.println(f.toFormattedString(displayTimeZoneId));
                }
            }
            if (mdtm) {
                FTPFile f = ftp.mdtmFile(remote);
                if (f != null) {
                    System.out.println(f.getRawListing());
                    System.out.println(f.toFormattedString(displayTimeZoneId));
                } else {
                    System.out.println("File not found");
                }
            }
            if (mlst) {
                FTPFile f = ftp.mlistFile(remote);
                if (f != null) {
                    System.out.println(f.toFormattedString(displayTimeZoneId));
                }
            }
            if (listNames) {
                for (String s : ftp.listNames(remote)) {
                    System.out.println(s);
                }
            }
            if (size) {
                System.out.println("Size=" + ftp.getSize(remote));
            }
            // Do this last because it changes the client
            if (listFiles) {
                if (lenient || serverTimeZoneId != null) {
                    config.setLenientFutureDates(lenient);
                    if (serverTimeZoneId != null) {
                        config.setServerTimeZoneId(serverTimeZoneId);
                    }
                    ftp.configure(config);
                }

                for (FTPFile f : ftp.listFiles(remote)) {
                    System.out.println(f.getRawListing());
                    System.out.println(f.toFormattedString(displayTimeZoneId));
                }
            }
        } 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();

            if (keepAliveTimeout > 0) {
                showCslStats(ftp);
            }
        }

        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
            }
        }
    }

    System.exit(error ? 1 : 0);
}

From source file:org.apache.tools.ant.taskdefs.optional.net.FTPConfigurator.java

/**
 * configures the supplied FTPClient with the various
 * attributes set in the supplied FTP task.
 * @param client the FTPClient to be configured
 * @param task the FTP task whose attributes are used to
 * configure the client/*from www  .  ja  va 2s  . co  m*/
 * @return the client as configured.
 */
static FTPClient configure(FTPClient client, FTPTaskConfig task) {
    task.log("custom configuration", Project.MSG_VERBOSE);
    FTPClientConfig config;
    String systemTypeKey = task.getSystemTypeKey();
    if (systemTypeKey != null && !"".equals(systemTypeKey)) {
        config = new FTPClientConfig(systemTypeKey);
        task.log("custom config: system key = " + systemTypeKey, Project.MSG_VERBOSE);
    } else {
        config = new FTPClientConfig();
        task.log("custom config: system key = default (UNIX)", Project.MSG_VERBOSE);
    }

    String defaultDateFormatConfig = task.getDefaultDateFormatConfig();
    if (defaultDateFormatConfig != null) {
        config.setDefaultDateFormatStr(defaultDateFormatConfig);
        task.log("custom config: default date format = " + defaultDateFormatConfig, Project.MSG_VERBOSE);
    }

    String recentDateFormatConfig = task.getRecentDateFormatConfig();
    if (recentDateFormatConfig != null) {
        config.setRecentDateFormatStr(recentDateFormatConfig);
        task.log("custom config: recent date format = " + recentDateFormatConfig, Project.MSG_VERBOSE);
    }

    String serverLanguageCodeConfig = task.getServerLanguageCodeConfig();
    if (serverLanguageCodeConfig != null) {
        if (!"".equals(serverLanguageCodeConfig)
                && !FTPClientConfig.getSupportedLanguageCodes().contains(serverLanguageCodeConfig)) {
            throw new BuildException("unsupported language code" + serverLanguageCodeConfig);
        }
        config.setServerLanguageCode(serverLanguageCodeConfig);
        task.log("custom config: server language code = " + serverLanguageCodeConfig, Project.MSG_VERBOSE);
    }

    String serverTimeZoneConfig = task.getServerTimeZoneConfig();
    if (serverTimeZoneConfig != null) {
        config.setServerTimeZoneId(serverTimeZoneConfig);
        task.log("custom config: server time zone ID = " + serverTimeZoneConfig, Project.MSG_VERBOSE);
    }

    String shortMonthNamesConfig = task.getShortMonthNamesConfig();
    if (shortMonthNamesConfig != null) {
        config.setShortMonthNames(shortMonthNamesConfig);
        task.log("custom config: short month names = " + shortMonthNamesConfig, Project.MSG_VERBOSE);
    }
    client.configure(config);
    return client;
}

From source file:org.openo.nfvo.emsdriver.commons.ftp.FTPSrv.java

/**
 * login FTP//from w  w w  .  j  a  va  2 s  .  c om
 * @param host
 * @param port
 * @param user
 * @param pwd
 * @param encode
 * @param timeout
 * @throws Exception
 */
public void login(String host, int port, String user, String pwd, String encode, boolean isPassiveMode,
        int timeout) throws Exception {
    ftpClient = new FTPClient();

    FTPClientConfig ftpClientConfig = new FTPClientConfig();
    ftpClientConfig.setServerTimeZoneId(TimeZone.getDefault().getID());
    this.ftpClient.setControlEncoding("GBK");
    this.ftpClient.configure(ftpClientConfig);
    ftpClient.setParserFactory(new ExtendsDefaultFTPFileEntryParserFactory());

    if (encode != null && encode.length() > 0) {
        ftpClient.setControlEncoding(encode);
    }

    ftpClient.connect(host, port);
    int reply = this.ftpClient.getReplyCode();
    if (!FTPReply.isPositiveCompletion(reply)) {
        this.ftpClient.disconnect();
        return;
    }

    if (!ftpClient.login(user, pwd)) {
        throw new Exception("login[" + host + "],port[" + port + "] fail, please check user and password");
    }
    if (isPassiveMode) {
        ftpClient.enterLocalPassiveMode();
    } else {
        ftpClient.enterLocalActiveMode();
    }
    ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    this.ftpClient.setBufferSize(1024 * 2);
    this.ftpClient.setDataTimeout(3 * 60 * 1000);
    try {
        this.ftpClient.setSoTimeout(timeout);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:org.tinygroup.vfs.impl.FtpFileObject.java

private void connectFtpServer() {
    try {/*from  ww w  .ja  v a 2 s.c  o  m*/
        ftpClient = new FTPClient();
        FTPClientConfig ftpClientConfig = new FTPClientConfig();
        ftpClientConfig.setServerTimeZoneId(TimeZone.getDefault().getID());
        ftpClient.configure(ftpClientConfig);
        URL url = getURL();
        if (url.getPort() <= 0) {
            ftpClient.connect(url.getHost());
        } else {
            ftpClient.connect(url.getHost(), url.getPort());
        }
        if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
            throw new VFSRuntimeException("?");
        }
        if (url.getUserInfo() != null) {
            String userInfo[] = url.getUserInfo().split(":");
            String userName = null;
            String password = null;
            if (userInfo.length >= 1) {
                userName = userInfo[0];
            }
            if (userInfo.length >= 2) {
                password = userInfo[1];
            }
            if (!ftpClient.login(userName, password)) {
                throw new VFSRuntimeException("" + url.toString());
            }
            if (!ftpClient.setFileType(FTP.BINARY_FILE_TYPE)) {
                throw new VFSRuntimeException("");
            }
            ftpClient.setBufferSize(BUF_SIZE);
            ftpClient.setControlEncoding("utf-8");
        }
    } catch (Exception e) {
        throw new VFSRuntimeException(e);
    }
}

From source file:uk.co.nickthecoder.pinkwino.optional.publish.FtpSync.java

public void upload() throws IOException {

    _logger.info("Uploading");

    _ftp = new FTPClient();

    if (_ftpDetails.getTimeZoneId() != null) {
        // _logger.debug( "Setting time zone to " +
        // _ftpDetails.getTimeZoneId() );
        FTPClientConfig config = new FTPClientConfig();
        config.setServerTimeZoneId(_ftpDetails.getTimeZoneId());
        _ftp.configure(config);/*from www  .  ja  v a 2s. c  o  m*/
    }

    try {

        _ftp.connect(_ftpDetails.getServer());

        int reply = _ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            _logger.error("FTP Connection failed");

        } else {

            _ftp.login(_ftpDetails.getUsername(), _ftpDetails.getPassword());

            uploadDirectory(new File(_ftpDetails.getLocalBase()), _ftpDetails.getRemoteBase(), 0);

            _ftp.logout();

        }

    } catch (IOException e) {

        e.printStackTrace();

    } finally {

        if (_ftp.isConnected()) {
            try {
                _ftp.disconnect();
            } catch (IOException ioe) {
                // do nothing
            }
        }
    }

    _logger.info("Uploading Complete");

}