Example usage for org.apache.commons.net.ftp FTPReply isPositiveCompletion

List of usage examples for org.apache.commons.net.ftp FTPReply isPositiveCompletion

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.net.ftp.*
  5. FTPReply
  6. isPositiveCompletion

Introduction

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

Prototype

public static boolean isPositiveCompletion(int reply)

Source Link

Document

Determine if a reply code is a positive completion response.

Usage

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Deletes a file on the FTP server.//from ww  w .ja  v a  2s.c  o m
 * <p>
 * @param pathname   The pathname of the file to be deleted.
 * @return True if successfully completed, false if not.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *      command to the server or receiving a reply from the server.
 */
public boolean deleteFile(String pathname) throws IOException {
    return FTPReply.isPositiveCompletion(dele(pathname));
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Removes a directory on the FTP server (if empty).
 * <p>//from   w  ww  .  j a  v  a2 s  .c o m
 * @param pathname  The pathname of the directory to remove.
 * @return True if successfully completed, false if not.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *      command to the server or receiving a reply from the server.
 */
public boolean removeDirectory(String pathname) throws IOException {
    return FTPReply.isPositiveCompletion(rmd(pathname));
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Creates a new subdirectory on the FTP server in the current directory
 * (if a relative pathname is given) or where specified (if an absolute
 * pathname is given).//w w w. jav  a2  s . co  m
 * <p>
 * @param pathname The pathname of the directory to create.
 * @return True if successfully completed, false if not.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *      command to the server or receiving a reply from the server.
 */
public boolean makeDirectory(String pathname) throws IOException {
    return FTPReply.isPositiveCompletion(mkd(pathname));
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Send a site specific command./*w ww  . j  a  va2  s.c  o m*/
 * @param arguments The site specific command and arguments.
 * @return True if successfully completed, false if not.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *      command to the server or receiving a reply from the server.
 */
public boolean sendSiteCommand(String arguments) throws IOException {
    return FTPReply.isPositiveCompletion(site(arguments));
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Fetches the system type from the server and returns the string.
 * This value is cached for the duration of the connection after the
 * first call to this method.  In other words, only the first time
 * that you invoke this method will it issue a SYST command to the
 * FTP server.  FTPClient will remember the value and return the
 * cached value until a call to disconnect.
 * <p>//from w  ww  . j av  a2s  .c o m
 * If the SYST command fails, and the system property
 * {@link #FTP_SYSTEM_TYPE_DEFAULT} is defined, then this is used instead.
 * @return The system type obtained from the server. Never null.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *  command to the server or receiving a reply from the server (and the default
 *  system type property is not defined)
 *  @since 2.2
 */
public String getSystemType() throws IOException {
    //if (syst() == FTPReply.NAME_SYSTEM_TYPE)
    // Technically, we should expect a NAME_SYSTEM_TYPE response, but
    // in practice FTP servers deviate, so we soften the condition to
    // a positive completion.
    if (__systemName == null) {
        if (FTPReply.isPositiveCompletion(syst())) {
            // Assume that response is not empty here (cannot be null)
            __systemName = _replyLines.get(_replyLines.size() - 1).substring(4);
        } else {
            // Check if the user has provided a default for when the SYST command fails
            String systDefault = System.getProperty(FTP_SYSTEM_TYPE_DEFAULT);
            if (systDefault != null) {
                __systemName = systDefault;
            } else {
                throw new IOException("Unable to determine system type - response: " + getReplyString());
            }
        }
    }
    return __systemName;
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Fetches the system help information from the server and returns the
 * full string./*from   ww w.j  a v a  2s .  co m*/
 * <p>
 * @return The system help string obtained from the server.  null if the
 *       information could not be obtained.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *  command to the server or receiving a reply from the server.
 */
public String listHelp() throws IOException {
    if (FTPReply.isPositiveCompletion(help())) {
        return getReplyString();
    }
    return null;
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Fetches the help information for a given command from the server and
 * returns the full string.//from  w w  w .j  av a  2s  .  c om
 * @param command The command on which to ask for help.
 * @return The command help string obtained from the server.  null if the
 *       information could not be obtained.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *  command to the server or receiving a reply from the server.
 */
public String listHelp(String command) throws IOException {
    if (FTPReply.isPositiveCompletion(help(command))) {
        return getReplyString();
    }
    return null;
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Sends a NOOP command to the FTP server.  This is useful for preventing
 * server timeouts.// w w w  .j  av  a 2 s.c  o m
 * <p>
 * @return True if successfully completed, false if not.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *      command to the server or receiving a reply from the server.
 */
public boolean sendNoOp() throws IOException {
    return FTPReply.isPositiveCompletion(noop());
}

From source file:com.ibm.cics.ca1y.Emit.java

/**
 * Get the contents of a file from an FTP server.
 * // w  w  w  . j  a v  a2 s .  com
 * @param filename
 *            -
 * @param server
 *            -
 * @param useraname
 *            -
 * @param userpassword
 *            -
 * @param transfer
 *            -
 * @param mode
 *            -
 * @param epsv
 *            -
 * @param protocol
 *            -
 * @param trustmgr
 *            -
 * @param datatimeout
 *            -
 * @param proxyserver
 *            -
 * @param proxyusername
 *            -
 * @param proxypassword
 *            -
 * @param anonymouspassword
 *            -
 * @return byte[] representing the retrieved file, null otherwise.
 */
private static byte[] getFileUsingFTP(String filename, String server, String username, String userpassword,
        String transfer, String mode, String epsv, String protocol, String trustmgr, String datatimeout,
        String proxyserver, String proxyusername, String proxypassword, String anonymouspassword) {

    FTPClient ftp;

    if (filename == null || server == null)
        return null;
    int port = 0;
    if (server != null) {
        String parts[] = server.split(":");
        if (parts.length == 2) {
            server = parts[0];
            try {
                port = Integer.parseInt(parts[1]);
            } catch (Exception _ex) {
            }
        }
    }

    int proxyport = 0;
    if (proxyserver != null) {
        String parts[] = proxyserver.split(":");

        if (parts.length == 2) {
            proxyserver = parts[0];

            try {
                proxyport = Integer.parseInt(parts[1]);

            } catch (Exception _ex) {
            }
        }
    }

    if (username == null) {
        username = "anonymous";

        if (userpassword == null)
            userpassword = anonymouspassword;
    }

    if (protocol == null) {
        if (proxyserver != null)
            ftp = new FTPHTTPClient(proxyserver, proxyport, proxyusername, proxypassword);
        else
            ftp = new FTPClient();

    } else {
        FTPSClient ftps = null;

        if ("true".equalsIgnoreCase(protocol)) {
            ftps = new FTPSClient(true);

        } else if ("false".equalsIgnoreCase(protocol)) {
            ftps = new FTPSClient(false);

        } else if (protocol != null) {
            String parts[] = protocol.split(",");

            if (parts.length == 1)
                ftps = new FTPSClient(protocol);
            else
                ftps = new FTPSClient(parts[0], Boolean.parseBoolean(parts[1]));
        }

        ftp = ftps;

        if ("all".equalsIgnoreCase(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());

        } else if ("valid".equalsIgnoreCase(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());

        } else if ("none".equalsIgnoreCase(trustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (datatimeout != null) {
        try {
            ftp.setDataTimeout(Integer.parseInt(datatimeout));

        } catch (Exception _ex) {
            ftp.setDataTimeout(-1);
        }
    }

    if (port <= 0) {
        port = ftp.getDefaultPort();
    }

    if (logger.isLoggable(Level.FINE)) {
        StringBuilder sb = new StringBuilder();

        sb.append(Emit.messages.getString("FTPAboutToGetFileFromServer")).append(" - ").append("file name:")
                .append(filename).append(",server:").append(server).append(":").append(port)
                .append(",username:").append(username).append(",userpassword:")
                .append(userpassword != null && !"anonymous".equals(username) ? "<obscured>" : userpassword)
                .append(",transfer:").append(transfer).append(",mode:").append(mode).append(",epsv:")
                .append(epsv).append(",protocol:").append(protocol).append(",trustmgr:").append(trustmgr)
                .append(",datatimeout:").append(datatimeout).append(",proxyserver:").append(proxyserver)
                .append(":").append(proxyport).append(",proxyusername:").append(proxyusername)
                .append(",proxypassword:").append(proxypassword != null ? "<obscured>" : null);

        logger.fine(sb.toString());
    }

    try {
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }

        int reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            logger.warning(Emit.messages.getString("FTPCouldNotConnectToServer"));
            return null;
        }

    } catch (IOException _ex) {
        logger.warning(Emit.messages.getString("FTPCouldNotConnectToServer"));

        if (ftp.isConnected())
            try {
                ftp.disconnect();
            } catch (IOException _ex2) {
            }

        return null;
    }

    ByteArrayOutputStream output;
    try {
        if (!ftp.login(username, userpassword)) {
            ftp.logout();
            logger.warning(Emit.messages.getString("FTPServerRefusedLoginCredentials"));
            return null;
        }
        if ("binary".equalsIgnoreCase(transfer)) {
            ftp.setFileType(2);
        } else {
            ftp.setFileType(0);
        }

        if ("localactive".equalsIgnoreCase(mode)) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4("true".equalsIgnoreCase(epsv));
        output = new ByteArrayOutputStream();
        ftp.retrieveFile(filename, output);
        output.close();
        ftp.noop();
        ftp.logout();

    } catch (IOException _ex) {
        logger.warning(Emit.messages.getString("FTPFailedToTransferFile"));

        if (ftp.isConnected())
            try {
                ftp.disconnect();
            } catch (IOException _ex2) {
            }
        return null;
    }

    return output.toByteArray();
}

From source file:com.atomicleopard.thundr.ftp.commons.FTPClient.java

/**
 * Issue the FTP STAT command to the server.
 * <p>/*from  w  w w .j  ava  2 s .  com*/
 * @return The status information returned by the server.
 * @exception FTPConnectionClosedException
 *      If the FTP server prematurely closes the connection as a result
 *      of the client being idle or some other reason causing the server
 *      to send FTP reply code 421.  This exception may be caught either
 *      as an IOException or independently as itself.
 * @exception IOException  If an I/O error occurs while either sending a
 *      command to the server or receiving a reply from the server.
 */
public String getStatus() throws IOException {
    if (FTPReply.isPositiveCompletion(stat())) {
        return getReplyString();
    }
    return null;
}