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

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.ow2.proactive.scheduler.examples.FTPConnector.java

private String downloadSingleFile(FTPClient ftpClient, String remoteFilePath, String savePath)
        throws IOException {
    getOut().println("About to DOWNLOAD the file: " + remoteFilePath);
    File downloadFile = new File(savePath);

    File parentDir = downloadFile.getParentFile();
    if (parentDir != null && !parentDir.exists()) {
        parentDir.mkdirs();//from  w  w w  .  j  a va2s .c om
    }

    try (OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(downloadFile))) {

        //retrieve a single file from the FTP server
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        if (ftpClient.retrieveFile(remoteFilePath, outputStream)) {
            getOut().println(
                    "DOWNLOADED successfully the file " + remoteFilePath + " to " + ftpLocalRelativePath);
            return savePath;
        } else {
            throw new IOException("Error: COULD NOT download the file: " + ftpRemoteRelativePath);
        }
    }
}

---

From source file:org.pepstock.jem.node.resources.impl.ftp.FtpFactory.java

/**
 * Creates and configures a FtpClient instance based on the
 * given properties./*from  w w  w  . j a va2 s . c  o  m*/
 * 
 * @param properties the ftp client configuration properties
 * @return remote input/output steam
 * @throws JNDIException if an error occurs creating the ftp client
 */
private Object createFtpClient(Properties properties) throws JNDIException {
    // URL is mandatory
    String ftpUrlString = properties.getProperty(CommonKeys.URL);
    if (ftpUrlString == null) {
        throw new JNDIException(NodeMessage.JEMC136E, CommonKeys.URL);
    }

    // creates URL objects
    // from URL string
    URL ftpUrl;
    try {
        ftpUrl = new URL(ftpUrlString);
    } catch (MalformedURLException e) {
        throw new JNDIException(NodeMessage.JEMC233E, e, ftpUrlString);
    }
    // checks scheme
    // if SSL, activates a FTPS
    if (!ftpUrl.getProtocol().equalsIgnoreCase(FTP_PROTOCOL)
            && !ftpUrl.getProtocol().equalsIgnoreCase(FTPS_PROTOCOL)) {
        throw new JNDIException(NodeMessage.JEMC137E, ftpUrl.getProtocol());
    }

    // gets port the host (from URL)
    int port = ftpUrl.getPort();
    String server = ftpUrl.getHost();

    // User id is mandatory
    String username = properties.getProperty(CommonKeys.USERID);
    if (username == null) {
        throw new JNDIException(NodeMessage.JEMC136E, CommonKeys.USERID);
    }

    // password is mandatory
    String password = properties.getProperty(CommonKeys.PASSWORD);
    if (password == null) {
        throw new JNDIException(NodeMessage.JEMC136E, CommonKeys.PASSWORD);
    }

    // checks if as input stream or not
    boolean asInputStream = Parser
            .parseBoolean(properties.getProperty(FtpResourceKeys.AS_INPUT_STREAM, "false"), false);

    String remoteFile = null;
    String accessMode = null;
    if (asInputStream) {
        // remote file is mandatory
        // it must be set by a data description
        remoteFile = properties.getProperty(FtpResourceKeys.REMOTE_FILE);
        if (remoteFile == null) {
            throw new JNDIException(NodeMessage.JEMC136E, FtpResourceKeys.REMOTE_FILE);
        }
        // access mode is mandatory
        // it must be set by a data description
        accessMode = properties.getProperty(FtpResourceKeys.ACTION_MODE, FtpResourceKeys.ACTION_READ);
    }

    // creates a FTPclient 
    FTPClient ftp = ftpUrl.getProtocol().equalsIgnoreCase(FTP_PROTOCOL) ? new FTPClient() : new FTPSClient();

    // checks if binary
    boolean binaryTransfer = Parser.parseBoolean(properties.getProperty(FtpResourceKeys.BINARY, "false"),
            false);

    // checks if must be restarted
    long restartOffset = Parser.parseLong(properties.getProperty(FtpResourceKeys.RESTART_OFFSET, "-1"), -1);

    // checks and sets buffer size
    int bufferSize = Parser.parseInt(properties.getProperty(FtpResourceKeys.BUFFER_SIZE, "-1"), -1);

    try {
        // reply code instance
        int reply;
        // connect to server
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }

        // After connection attempt, you should check the reply code to
        // verify
        // success.
        reply = ftp.getReplyCode();
        // if not connected for error, EXCEPTION
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            throw new JNDIException(NodeMessage.JEMC138E, reply);
        }
        // login!!
        if (!ftp.login(username, password)) {
            ftp.logout();
        }
        // set all ftp properties
        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        }

        // sets restart offset if has been set
        if (restartOffset >= 0) {
            ftp.setRestartOffset(restartOffset);
        }

        // sets buffer size
        if (bufferSize >= 0) {
            ftp.setBufferSize(bufferSize);
        }

        // if is not related to a data descritpion,
        // returns a FTP object
        if (!asInputStream) {
            return new Ftp(ftp);
        }

        // checks if is in WRITE mode
        if (accessMode.equalsIgnoreCase(FtpResourceKeys.ACTION_WRITE)) {
            // gets outputstream
            // using the file name passed by data descritpion
            OutputStream os = ftp.storeFileStream(remoteFile);
            if (os == null) {
                reply = ftp.getReplyCode();
                throw new JNDIException(NodeMessage.JEMC206E, remoteFile, reply);
            }
            // returns outputstream
            return new FtpOutputStream(os, ftp);
        } else {
            // gest inputstream
            // using the file name passed by data descritpion
            InputStream is = ftp.retrieveFileStream(remoteFile);
            if (is == null) {
                reply = ftp.getReplyCode();
                throw new JNDIException(NodeMessage.JEMC206E, remoteFile, reply);
            }
            // returns inputstream 
            return new FtpInputStream(is, ftp);
        }
    } catch (SocketException e) {
        throw new JNDIException(NodeMessage.JEMC234E, e);
    } catch (IOException e) {
        throw new JNDIException(NodeMessage.JEMC234E, e);
    }
}

---

From source file:org.protocoderrunner.apprunner.api.network.PFtpClient.java

@ProtoMethod(description = "Connect to a ftp server", example = "")
@ProtoMethodParam(params = { "host", "port", "username", "password", "function(connected)" })
public void connect(final String host, final int port, final String username, final String password,
        final FtpConnectedCb callback) {
    mFTPClient = new FTPClient();

    Thread t = new Thread(new Runnable() {
        @Override//from w  w  w  .j  a  va 2 s  . c  om
        public void run() {
            try {
                mFTPClient.connect(host, port);

                MLog.d(TAG, "1");

                if (FTPReply.isPositiveCompletion(mFTPClient.getReplyCode())) {
                    boolean logged = mFTPClient.login(username, password);
                    mFTPClient.setFileType(FTP.BINARY_FILE_TYPE);
                    mFTPClient.enterLocalPassiveMode();
                    isConnected = logged;

                    callback.event(logged);
                }
                MLog.d(TAG, "" + isConnected);

            } catch (Exception e) {
                MLog.d(TAG, "connection failed error:" + e);
            }
        }
    });
    t.start();
}

---

From source file:org.ramadda.repository.monitor.FtpAction.java

/**
 * _more_/*from  w  ww. ja  v a2  s  .c  om*/
 *
 *
 * @param monitor _more_
 * @param entry _more_
 */
protected void entryMatched(EntryMonitor monitor, Entry entry) {
    FTPClient ftpClient = new FTPClient();
    try {
        Resource resource = entry.getResource();
        if (!resource.isFile()) {
            return;
        }
        if (server.length() == 0) {
            return;
        }

        String passwordToUse = monitor.getRepository().getPageHandler().processTemplate(password, false);
        ftpClient.connect(server);
        if (user.length() > 0) {
            ftpClient.login(user, password);
        }
        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect();
            monitor.handleError("FTP server refused connection:" + server, null);

            return;
        }
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.enterLocalPassiveMode();
        if (directory.length() > 0) {
            ftpClient.changeWorkingDirectory(directory);
        }

        String filename = monitor.getRepository().getEntryManager().replaceMacros(entry, fileTemplate);

        InputStream is = new BufferedInputStream(
                monitor.getRepository().getStorageManager().getFileInputStream(new File(resource.getPath())));
        boolean ok = ftpClient.storeUniqueFile(filename, is);
        is.close();
        if (ok) {
            monitor.logInfo("Wrote file:" + directory + " " + filename);
        } else {
            monitor.handleError("Failed to write file:" + directory + " " + filename, null);
        }
    } catch (Exception exc) {
        monitor.handleError("Error posting to FTP:" + server, exc);
    } finally {
        try {
            ftpClient.logout();
        } catch (Exception exc) {
        }
        try {
            ftpClient.disconnect();
        } catch (Exception exc) {
        }
    }
}

---

From source file:org.ramadda.repository.type.FtpTypeHandler.java

/**
 * _more_//from w w w.j  av  a2s . c  o  m
 *
 * @param server _more_
 * @param baseDir _more_
 * @param user _more_
 * @param password _more_
 *
 * @return _more_
 *
 * @throws Exception _more_
 */
public static String test(String server, String baseDir, String user, String password) throws Exception {
    FTPClient ftpClient = new FTPClient();
    try {
        String file = baseDir;
        ftpClient.connect(server);
        //System.out.print(ftp.getReplyString());
        ftpClient.login(user, password);
        //            System.out.print(ftpClient.getReplyString());
        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect();
            System.err.println("FTP server refused connection.");

            return null;
        }
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.enterLocalPassiveMode();

        boolean isDir = isDir(ftpClient, file);
        //            System.err.println("file:" + file + " is dir: " + isDir);

        if (isDir) {
            FTPFile[] files = ftpClient.listFiles(file);
            for (int i = 0; i < files.length; i++) {
                //                    System.err.println ("f:" + files[i].getName() + " " + files[i].isDirectory() + "  " + files[i].isFile());
            }
        } else {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            if (ftpClient.retrieveFile(file, bos)) {
                //                    System.err.println(new String(bos.toByteArray()));
            } else {
                throw new IOException("Unable to retrieve file:" + file);
            }
        }

        return "";
    } finally {
        closeConnection(ftpClient);
    }
}

---

From source file:org.ramadda.repository.type.FtpTypeHandler.java

/**
 * _more_/*w  ww .j av  a  2s. c  o m*/
 *
 * @param parentEntry _more_
 *
 * @return _more_
 *
 * @throws Exception _more_
 */
private FTPClient getFtpClient(Entry parentEntry) throws Exception {
    Object[] values = parentEntry.getValues();
    if (values == null) {
        return null;
    }
    String server = (String) values[COL_SERVER];
    String baseDir = (String) values[COL_BASEDIR];
    String user = (String) values[COL_USER];
    String password = (String) values[COL_PASSWORD];
    if (password != null) {
        password = getRepository().getPageHandler().processTemplate(password, false);
    } else {
        password = "";
    }
    FTPClient ftpClient = new FTPClient();
    try {
        ftpClient.connect(server);
        if (user != null) {
            ftpClient.login(user, password);
        }
        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect();
            System.err.println("FTP server refused connection.");

            return null;
        }
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.enterLocalPassiveMode();

        return ftpClient;
    } catch (Exception exc) {
        System.err.println("Could not connect to ftp server:" + server + "\nError:" + exc);

        return null;
    }
}

---

From source file:org.ramadda.util.Utils.java

/**
 * _more_/*from   ww  w .j  av  a 2  s . c  om*/
 *
 * @param url _more_
 *
 * @return _more_
 *
 * @throws Exception _more_
 */
public static FTPClient makeFTPClient(URL url) throws Exception {
    FTPClient ftpClient = new FTPClient();
    ftpClient.connect(url.getHost());
    ftpClient.login("anonymous", "");
    int reply = ftpClient.getReplyCode();
    if (!FTPReply.isPositiveCompletion(reply)) {
        ftpClient.disconnect();
        System.err.println("FTP server refused connection.");

        return null;
    }
    ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    ftpClient.enterLocalPassiveMode();

    return ftpClient;
}

---

From source file:org.sipfoundry.sipxconfig.admin.ftp.FtpContextImpl.java

public void openConnection() {
    if (m_client != null) {
        return;//from w  w  w.  j a v a 2  s  . c  o m
    }
    m_client = new FTPClient();
    try {
        m_client.connect(m_host);
        int reply = m_client.getReplyCode();

        // After connection attempt, you should check the reply code to verify
        // success.
        if (!FTPReply.isPositiveCompletion(reply)) {
            closeConnection();
            throw new UserException("&message.refusedConnection");
        }
        if (!m_client.login(m_userId, m_password)) {
            closeConnection();
            throw new UserException("&message.userPass");
        }
        m_client.setFileType(FTP.BINARY_FILE_TYPE);
        m_client.enterLocalPassiveMode();
    } catch (IOException e) {
        LOG.error(e);
        throw new UserException("&message.notConnect");
    }
}

---

From source file:org.smartfrog.services.net.FTPClientImpl.java

/**
 * Sends or retrieve files over FTP using attributes specified in the
 * SmartFrog description of the component.
 *
 * @throws SmartFrogException in case of error in sending email
 * @throws RemoteException    in case of network/emi error
 *//*from w ww .jav  a  2  s .  c om*/
public synchronized void sfStart() throws SmartFrogException, RemoteException {
    super.sfStart();
    try {
        ftpClient = new FTPClient();
        int reply;

        // get password from password provider
        password = pwdProvider.getPassword();

        ftpClient.connect(ftpServer);

        reply = ftpClient.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect();
            throw new SmartFrogLifecycleException("FTP Server:[" + ftpServer + "] refused connection");
        }

        //login
        if (!ftpClient.login(user, password)) {
            ftpClient.logout();
        }

        //check type of file transfer
        if (BINARY.equals(transferMode)) {
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        ftpClient.enterLocalPassiveMode();

        if (GET.equals(transferType)) {
            getFiles(remoteFileList, localFileList);
        } else if (PUT.equals(transferType)) {
            putFiles(remoteFileList, localFileList);
        } else {
            throw new SmartFrogLifecycleException("Unsupported transfer type:" + transferType);
        }
        //logout
        ftpClient.logout();

        // check if it should terminate by itself
        if (shouldTerminate) {
            TerminationRecord termR = TerminationRecord.normal("FTP finished: ", sfCompleteName());
            TerminatorThread terminator = new TerminatorThread(this, termR);
            terminator.start();
        }
    } catch (FTPConnectionClosedException e) {
        throw new SmartFrogLifecycleException("Server Closed Connection" + e, e);
    } catch (IOException ioe) {
        throw new SmartFrogLifecycleException(ioe);
    } finally {
        disconnectQuietly();
    }
}

---

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

public void from(FTPClient ftp) throws IOException {
    if (!ftp.setFileType(FTP.BINARY_FILE_TYPE)) {
        throw new IllegalStateException("Unable to set mode to binary");
    }//from w w  w .  j av  a  2s. com

    for (String fileName : files.keySet()) {
        if (fileName.startsWith(Constants.RESULTS_DIR + "/__") && fileName.endsWith(".xml")) {
            if (files.get(fileName) == null) {
                ByteArrayOutputStream buf = new ByteArrayOutputStream();
                if (!ftp.retrieveFile(fileName, buf)) {
                    throw new IllegalStateException("Unable to retrieve " + fileName);
                }
                buf.close();
                files.put(fileName, ByteSource.wrap(buf.toByteArray()));
            }
        }
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• »