Example usage for org.apache.commons.net.ftp FTP BINARY_FILE

Introduction

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

Prototype

int BINARY_FILE_TYPE

To view the source code for org.apache.commons.net.ftp FTP BINARY_FILE_TYPE.

Click Source Link

Document

A constant used to indicate the file(s) being transfered should be treated as a binary image, i.e., no translations should be performed.

Usage

From source file:org.spka.cursus.publish.website.ftp.Uploader.java

public void to(FTPClient ftp, Map<String, ByteSource> newFiles) throws IOException {
    if (!ftp.setFileType(FTP.BINARY_FILE_TYPE)) {
        throw new IllegalStateException("Unable to set mode to binary");
    }//from  ww  w  .  j  a v a 2  s  . c  o m

    for (Map.Entry<String, ByteSource> file : newFiles.entrySet()) {
        ByteSource other = null;

        if (existingFiles.containsKey(file.getKey())) {
            other = existingFiles.get(file.getKey());

            if (other == null) {
                ByteArrayOutputStream buf = new ByteArrayOutputStream();
                if (!ftp.retrieveFile(file.getKey(), buf)) {
                    throw new IllegalStateException("Unable to retrieve " + file.getKey());
                }
                buf.close();
                other = ByteSource.wrap(buf.toByteArray());
                existingFiles.put(file.getKey(), other);
            }
        }

        if (other == null || !file.getValue().contentEquals(other)) {
            InputStream in = file.getValue().openStream();
            if (!ftp.storeFile(file.getKey(), in)) {
                throw new IllegalStateException("Unable to store " + file.getKey());
            }
            in.close();

            existingFiles.put(file.getKey(), file.getValue());
        }
    }
}

From source file:org.spongepowered.repoindexer.FTPUtils.java

public static boolean uploadFTP(String user, String pass, String server, File local, String remoteLocation) {
    FTPClient ftpClient = new FTPClient();
    boolean done = false;
    try {/*  w w w .ja  v  a  2 s  .com*/

        ftpClient.connect(server);
        ftpClient.login(user, pass);
        ftpClient.enterLocalPassiveMode();

        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

        InputStream inputStream = new FileInputStream(local);
        done = ftpClient.storeFile(remoteLocation, inputStream);
        inputStream.close();
    } catch (IOException ex) {
        System.out.println("Error: " + ex.getMessage());
        ex.printStackTrace();
        return false;
    } finally {
        try {
            if (ftpClient.isConnected()) {
                ftpClient.logout();
                ftpClient.disconnect();
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return done;
    }
}

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

private void connectFtpServer() {
    try {//from  ww w  .j  av a  2  s .co 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:org.umit.icm.mobile.connectivity.ServiceFTP.java

/**
 * Returns an FTP Response String.//from  ww  w . j a v  a 2 s. c o m
 * 
 *                                                                                                 
              
@return      String
 *
         
@see FTPClient
 */
@Override
public String connect() {

    FTPClient ftpClient = new FTPClient();
    try {
        ftpClient.connect(getServiceURL());
        ftpClient.login("test", "test");
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.enterLocalPassiveMode();
        String reply = ftpClient.getReplyString();
        ftpClient.logout();
        ftpClient.disconnect();
        if (reply != null)
            return "normal";
        return "blocked";
    } catch (SocketException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return null;
}

From source file:org.ut.biolab.medsavant.shared.util.SeekableFTPStream.java

private FTPClient getFTPClient() throws IOException {
    if (ftpClient == null) {
        FTPClient client = new FTPClient();
        try {//w ww.  jav  a 2s . c o  m
            client.connect(host, port);
            int reply = client.getReplyCode();
            if (!FTPReply.isPositiveCompletion(reply)) {
                throw new IOException("Unable to connect to " + host);
            }
            if (!client.login(username, password)) {
                throw new IOException("Unable to login to " + host + " as " + username);
            }
            client.setFileType(FTP.BINARY_FILE_TYPE);
            client.enterLocalPassiveMode();
            client.setSoTimeout(SOCKET_TIMEOUT);
            ftpClient = client;
            client = null;
        } finally {
            if (client != null) {
                client.disconnect();
            }
        }
    }

    return ftpClient;
}

From source file:org.vle.aid.medline.DownloadMedline.java

private void setFTPPath(String path) throws IOException {
    if (!mFTPClient.changeWorkingDirectory(path)) {
        printLastReply("Server error changing directory to path=" + path);
        exitIncomplete();//w w  w.j  a v  a2s  .c om
    }
    if (!mFTPClient.setFileType(FTP.BINARY_FILE_TYPE)) {
        printLastReply("Server error changing type to binary.");
        exitIncomplete();
    }
}

From source file:org.waarp.ftp.client.FTPClientExample.java

public static final void main(String[] args) {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;/*w  w w . ja  v  a2 s .  c  o m*/
    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;

    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("-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 (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        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]);
    }
    String username = args[base++];
    String password = args[base++];
    String account = args[base++];

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

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

    boolean mustCallProtP = false;
    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")) {
            System.out.println("Implicit FTPS");
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            System.out.println("Explicit FTPS");
            ftps = new FTPSClient(false);
            mustCallProtP = true;
        } else {
            String prot[] = protocol.split(",");
            System.out.println("Protocl FTPS: " + protocol);

            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                mustCallProtP = !Boolean.parseBoolean(prot[1]);
                ftps = new FTPSClient(prot[0], !mustCallProtP);
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            System.out.println("Accept all");
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            System.out.println("Accept after valid");
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            System.out.println("Accept none");
            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.");
            System.exit(1);
        }
    } catch (IOException e) {
        if (ftp.getDataConnectionMode() == FTPClient.ACTIVE_LOCAL_DATA_CONNECTION_MODE) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        System.exit(1);
    }

    __main: try {
        if (account == null) {
            if (!ftp.login(username, password)) {
                ftp.logout();
                error = true;
                break __main;
            }
        } else {
            if (!ftp.login(username, password, account)) {
                ftp.logout();
                error = true;
                break __main;
            }
        }
        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_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 (mustCallProtP) {
            ((FTPSClient) ftp).execPBSZ(0);
            ((FTPSClient) ftp).execPROT("P");
        }

        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.getDataConnectionMode() == FTPClient.ACTIVE_LOCAL_DATA_CONNECTION_MODE) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

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

From source file:org.waarp.ftp.client.WaarpFtpClient.java

/**
 * Try to connect to the server and goes with the authentication
 * /*from  ww w.  j  a v  a2s.com*/
 * @return True if connected and authenticated, else False
 */
public boolean connect() {
    result = null;
    boolean isActive = false;
    try {
        try {
            this.ftpClient.connect(this.server, this.port);
        } catch (SocketException e) {
            result = "Connection in error";
            logger.error(result, e);
            return false;
        } catch (IOException e) {
            result = "Connection in error";
            logger.error(result, e);
            return false;
        }
        int reply = this.ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            this.disconnect();
            result = "Connection in error: " + reply;
            logger.error(result);
            return false;
        }
        try {
            if (this.acct == null) {
                // no account
                if (!this.ftpClient.login(this.user, this.pwd)) {
                    this.logout();
                    result = "Login in error";
                    logger.error(result);
                    return false;
                }
            } else if (!this.ftpClient.login(this.user, this.pwd, this.acct)) {
                this.logout();
                result = "Login in error";
                logger.error(result);
                return false;
            }
        } catch (IOException e) {
            result = "Login in error";
            logger.error(result, e);
            return false;
        }
        try {
            this.ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        } catch (IOException e1) {
            result = "Set BINARY in error";
            logger.error(result, e1);
            return false;
        }
        changeMode(isPassive);
        this.ftpClient.setUseEPSVwithIPv4(false);
        if (ssl == 1) {
            // now send request for PROT (AUTH already sent)
            try {
                ((FTPSClient) this.ftpClient).execPBSZ(0);
                logger.debug("PBSZ 0");
                ((FTPSClient) this.ftpClient).execPROT("P");
                logger.debug("Info: " + ((FTPSClient) this.ftpClient).getEnableSessionCreation());
            } catch (IOException e) {
                this.logout();
                result = "Explicit SSL in error";
                logger.error(result, e);
                return false;
            }
        }
        isActive = true;
        return true;
    } finally {
        if ((!isActive)
                && this.ftpClient.getDataConnectionMode() == FTPClient.ACTIVE_LOCAL_DATA_CONNECTION_MODE) {
            this.disconnect();
        }
    }
}

From source file:org.waarp.ftp.client.WaarpFtpClient.java

/**
 * Change the FileType of Transfer (Binary true, ASCII false)
 * /*  w  w w .  j  av a  2 s  .c om*/
 * @param binaryTransfer1
 * @return True if the change is OK
 */
public boolean changeFileType(boolean binaryTransfer1) {
    result = null;
    this.binaryTransfer = binaryTransfer1;
    try {
        if (this.binaryTransfer) {
            return this.ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            return this.ftpClient.setFileType(FTP.ASCII_FILE_TYPE);
        }
    } catch (IOException e) {
        result = "FileType in error";
        logger.warn(result, e);
        return false;
    }
}

From source file:org.wavescale.sourcesync.synchronizer.FTPFileSynchronizer.java

@Override
public void syncFile(String sourcePath, String destinationPath) {
    // preserve timestamp for now
    boolean preserveTimestamp = true;
    File localFile = new File(getProject().getBasePath(), sourcePath);
    String finalSourcePath = Utils.getUnixPath(localFile.getAbsolutePath());
    String remotePath = Utils.buildUnixPath(this.getConnectionInfo().getRootPath(), destinationPath);
    String[] dirsToCreate = Utils.splitPath(destinationPath);
    // change location to root path
    try {//w w  w .j a  v a2  s .co  m
        this.ftp.changeWorkingDirectory(Utils.getUnixPath(this.getConnectionInfo().getRootPath()));
    } catch (IOException e) {
        EventDataLogger.logError("Remote dir <b>" + this.getConnectionInfo().getRootPath()
                + "</b> might not exist or you don't have permission on this path!", this.getProject());
        return;
    }
    // try to create
    for (String dirToCreate : dirsToCreate) {
        try {
            this.ftp.makeDirectory(dirToCreate);
        } catch (IOException e) {
            // this dir probably exist so just ignore now it will fail later
            // if there are other reasons this could not be executed.
        }
        try {
            this.ftp.changeWorkingDirectory(dirToCreate);
        } catch (IOException e) {
            // probably it doesn't exist or maybe no permission
            EventDataLogger.logError(
                    "Remote dir <b>" + remotePath
                            + "</b> might not exist or you don't have permission on this path!",
                    this.getProject());
            return;
        }
    }

    // upload
    try {
        this.ftp.setFileType(FTP.BINARY_FILE_TYPE);
        FileInputStream in = new FileInputStream(finalSourcePath);
        OutputStream outputStream = this.ftp.storeFileStream(localFile.getName());
        this.getIndicator().setIndeterminate(false);
        this.getIndicator().setText("Uploading...[" + localFile.getName() + "]");
        byte[] buffer = new byte[1024];
        int len;
        double totalSize = localFile.length() + 0.0;
        long totalUploaded = 0;
        while (true) {
            len = in.read(buffer, 0, buffer.length);
            if (len <= 0) {
                break;
            }
            outputStream.write(buffer, 0, len);
            totalUploaded += len;
            this.getIndicator().setFraction(totalUploaded / totalSize);
        }
        if (preserveTimestamp) {
            // TODO - implement preserve timestamp mechanism
        }
        in.close();
        outputStream.close();
    } catch (FileNotFoundException e) {
        EventDataLogger.logWarning(e.toString(), getProject());
    } catch (IOException e) {
        EventDataLogger.logError(e.toString(), getProject());
    }

}

Example usage for org.apache.commons.net.ftp FTP BINARY_FILE_TYPE

Introduction

Prototype

Document

Usage