Example usage for org.apache.commons.net.ftp FTPClient getReplyString

List of usage examples for org.apache.commons.net.ftp FTPClient getReplyString

Introduction

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

Prototype

public String getReplyString() 

Source Link

Document

Returns the entire text of the last FTP server response exactly as it was received, including all end of line markers in NETASCII format.

Usage

From source file:smilehouse.opensyncro.defaultcomponents.ftp.FTPDestination.java

public void take(String data, DestinationInfo info, MessageLogger logger)
        throws FailTransferException, AbortTransferException {

    FTPClient ftp = new FTPClient();

    try {//w w w  .j  av  a2 s.  com
        // -----------------
        // Try to connect...
        // -----------------
        String host = this.data.getAttribute(HOST_ATTR);
        int port = -1;
        String portStr = this.data.getAttribute(PORT_ATTR);
        if (portStr != null && portStr.length() > 0) {
            try {
                port = Integer.parseInt(portStr);
            } catch (NumberFormatException nfe) {
                logger.logMessage("Invalid value '" + portStr + "' for port.", this, MessageLogger.ERROR);
                PipeComponentUtils.failTransfer();
            }
        }
        int reply;

        try {
            if (port != -1) {
                ftp.connect(host, port);
            } else {
                ftp.connect(host);
            }
        } catch (SocketException e) {
            logger.logMessage("SocketException while connecting to host " + host + ", aborting", this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        } catch (IOException e) {
            logger.logMessage("IOException while connecting to host " + host + ", aborting", this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

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

        if (!FTPReply.isPositiveCompletion(reply)) {
            try {
                ftp.disconnect();
            } catch (IOException e) {
                /**
                 * ftp.disconnect() is called only as additional clean-up here, so we choose to
                 * ignore possible exceptions
                 */
            }
            logger.logMessage("Couldn't connect to the FTP server: " + ftp.getReplyString(), this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

        // -----------
        // Then log in
        // -----------

        try {
            if (!ftp.login(this.data.getAttribute(USER_ATTR), this.data.getAttribute(PASSWORD_ATTR))) {
                logger.logMessage("Could not log in, check your username and password settings.", this,
                        MessageLogger.ERROR);
                ftp.logout();

                PipeComponentUtils.failTransfer();
            }
        } catch (IOException e) {
            logger.logMessage("IOException while logging in to FTP server", this, MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

        // Use passive mode
        ftp.enterLocalPassiveMode();

        // -----------------
        // ASCII or binary ?
        // -----------------
        boolean fileTypeSetOk = false;

        try {
            switch (getFileType()) {
            case FILE_TYPE_ASCII:
                fileTypeSetOk = ftp.setFileType(FTP.ASCII_FILE_TYPE);
                break;
            case FILE_TYPE_BINARY:
                fileTypeSetOk = ftp.setFileType(FTP.BINARY_FILE_TYPE);
            }
            if (!fileTypeSetOk) {
                logger.logMessage("Could not set file type: " + ftp.getReplyString(), this,
                        MessageLogger.WARNING);
            }
        } catch (IOException e) {
            logger.logMessage("IOException while setting file transfer type parameter", this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

        // -------------
        // Send the data
        // -------------
        String fileName = getFileName();
        logger.logMessage("Storing file: " + fileName, this, MessageLogger.DEBUG);
        String charSet = this.data.getAttribute(CHARSET_ATTR);
        if (charSet == null || charSet.length() == 0)
            charSet = DEFAULT_CHARSET;
        InputStream dataStream = null;
        try {
            dataStream = new ByteArrayInputStream(data.getBytes(charSet));
        } catch (UnsupportedEncodingException e1) {

            logger.logMessage(charSet + " charset not supported", this, MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }
        try {
            if (!ftp.storeFile(fileName, dataStream)) {
                logger.logMessage("Could not store file '" + fileName + "': " + ftp.getReplyString(), this,
                        MessageLogger.ERROR);
                PipeComponentUtils.failTransfer();
            }
        } catch (IOException e) {
            logger.logMessage("IOException while uploading the file to FTP server", this, MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }
}

From source file:smilehouse.opensyncro.defaultcomponents.ftp.FTPSource.java

public String[] give(SourceInfo info, MessageLogger logger)
        throws FailTransferException, AbortTransferException {

    // This component does not support iteration, so we output all our data
    // once (and only once)
    if (this.allDataOutput == true)
        return null;
    else//  w w  w .j  ava  2 s.  c o m
        this.allDataOutput = true;

    String[] dataArray = new String[1];
    FTPClient ftp = new FTPClient();

    try {
        // -----------------
        // Try to connect...
        // -----------------
        String host = this.data.getAttribute(HOST_ATTR);
        int port = -1;
        String portStr = this.data.getAttribute(PORT_ATTR);
        if (portStr != null && portStr.length() > 0) {
            try {
                port = Integer.parseInt(portStr);
            } catch (NumberFormatException nfe) {
                logger.logMessage("Invalid value '" + portStr + "' for port.", this, MessageLogger.ERROR);
                PipeComponentUtils.failTransfer();
            }
        }
        int reply;

        try {

            if (port != -1) {
                ftp.connect(host, port);
            } else {
                ftp.connect(host);
            }

        } catch (SocketException e) {
            logger.logMessage("SocketException while connecting to host " + host + ", aborting", this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        } catch (IOException e) {
            logger.logMessage("IOException while connecting to host " + host + ", aborting", this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

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

        if (!FTPReply.isPositiveCompletion(reply)) {
            try {
                ftp.disconnect();
            } catch (IOException e) {
                /**
                 * ftp.disconnect() is called only as additional clean-up here, so we choose to
                 * ignore possible exceptions
                 */
            }
            logger.logMessage("Couldn't connect to the FTP server: " + ftp.getReplyString(), this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

        // -----------
        // Then log in
        // -----------
        try {
            if (!ftp.login(this.data.getAttribute(USER_ATTR), this.data.getAttribute(PASSWORD_ATTR))) {
                logger.logMessage("Could not log in, check your username and password settings.", this,
                        MessageLogger.ERROR);
                ftp.logout();

                PipeComponentUtils.failTransfer();
            }

        } catch (IOException e) {
            logger.logMessage("IOException while logging in to FTP server", this, MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

        // Use passive mode
        ftp.enterLocalPassiveMode();

        // -----------------
        // ASCII or binary ?
        // -----------------
        boolean fileTypeSetOk = false;
        try {
            switch (getFileType()) {
            case FILE_TYPE_ASCII:
                fileTypeSetOk = ftp.setFileType(FTP.ASCII_FILE_TYPE);
                break;
            case FILE_TYPE_BINARY:
                fileTypeSetOk = ftp.setFileType(FTP.BINARY_FILE_TYPE);
            }
            if (!fileTypeSetOk) {
                logger.logMessage("Could not set file type: " + ftp.getReplyString(), this,
                        MessageLogger.WARNING);
            }
        } catch (IOException e) {
            logger.logMessage("IOException while setting file transfer type parameter", this,
                    MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }

        // -----------------
        // Retrieve the data
        // -----------------
        String fileName = getFileName(logger);
        logger.logMessage("Retrieving file: " + fileName, this, MessageLogger.DEBUG);
        OutputStream dataStream = new ByteArrayOutputStream();
        try {
            if (!ftp.retrieveFile(fileName, dataStream)) {
                logger.logMessage("Could not retrieve file '" + fileName + "': " + ftp.getReplyString(), this,
                        MessageLogger.WARNING);
                PipeComponentUtils.abortTransfer();
            }
            String charSet = this.data.getAttribute(CHARSET_ATTR);
            if (charSet == null || charSet.length() == 0)
                charSet = DEFAULT_CHARSET;
            dataArray[0] = ((ByteArrayOutputStream) dataStream).toString(charSet);
        } catch (IOException e) {
            logger.logMessage("IOException while downloading file from FTP server", this, MessageLogger.ERROR);
            PipeComponentUtils.failTransfer();
        }
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }
    return dataArray;
}

From source file:testing.FTPClientExample.java

public static final void main(String[] args) {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;/*from w ww  .j av a  2s  .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;

    args = new String[100];

    args[0] = "-d";
    args[1] = "localhost";
    args[2] = "adminroot";
    args[3] = "adminroot";

    args[4] = "RSAPrivate.key";
    args[5] = ".\\FTPServer2\\RSAPrivate.key";

    int base = 0;
    OUTER: for (base = 0; base < args.length; base++) {
        switch (args[base]) {
        case "-s":
            storeFile = true;
            break;
        case "-a":
            localActive = true;
            break;
        case "-b":
            binaryTransfer = true;
            break;
        case "-c":
            doCommand = args[++base];
            minParams = 3;
            break;
        case "-d":
            mlsd = true;
            minParams = 3;
            break;
        case "-e":
            useEpsvWithIPv4 = true;
            break;
        case "-f":
            feat = true;
            minParams = 3;
            break;
        case "-h":
            hidden = true;
            break;
        case "-k":
            keepAliveTimeout = Long.parseLong(args[++base]);
            break;
        case "-l":
            listFiles = true;
            minParams = 3;
            break;
        case "-L":
            lenient = true;
            break;
        case "-n":
            listNames = true;
            minParams = 3;
            break;
        case "-p":
            protocol = args[++base];
            break;
        case "-t":
            mlst = true;
            minParams = 3;
            break;
        case "-w":
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
            break;
        case "-T":
            trustmgr = args[++base];
            break;
        case "-PrH":
            proxyHost = args[++base];
            String parts[] = proxyHost.split(":");
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
            break;
        case "-PrU":
            proxyUser = args[++base];
            break;
        case "-PrP":
            proxyPassword = args[++base];
            break;
        case "-#":
            printHash = true;
            break;
        default:
            break OUTER;
        }
    }

    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 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.");
            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);
        }

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

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

From source file:ubicrypt.core.provider.ftp.FTProvider.java

private Observable<FTPClient> connect() {
    return Observable.<FTPClient>create(subscriber -> {
        final FTPClient client = new FTPClient();
        try {// w ww . jav  a  2s.  co  m
            client.connect(conf.getHost(), getConf().getPort() == -1 ? 21 : getConf().getPort());
            final int reply = client.getReplyCode();
            if (!FTPReply.isPositiveCompletion(reply)) {
                log.error("FTP server refused connection:" + client.getReplyString());
                if (client.isConnected()) {
                    client.disconnect();
                }
                subscriber.onError(
                        new RuntimeException("FTP server refused connection:" + client.getReplyString()));
                return;
            }
            if (!getConf().isAnonymous()) {
                if (!client.login(getConf().getUsername(), new String(getConf().getPassword()))) {
                    client.disconnect();
                    log.warn("FTP wrong credentials:" + client.getReplyString());
                    subscriber.onError(new RuntimeException("FTP wrong credentials"));
                }
            }
            client.setFileType(FTP.BINARY_FILE_TYPE);
            client.setBufferSize(1 << 64);
            client.enterLocalPassiveMode();
            client.setControlKeepAliveTimeout(60 * 60); //1h
            if (!isEmpty(conf.getFolder())) {
                final String directory = startsWith("/", conf.getFolder()) ? conf.getFolder()
                        : "/" + conf.getFolder();
                if (!client.changeWorkingDirectory(directory)) {
                    if (!client.makeDirectory(directory)) {
                        disconnect(client);
                        subscriber.onError(new ProviderException(showServerReply(client)));
                        return;
                    }
                    if (!client.changeWorkingDirectory(directory)) {
                        disconnect(client);
                        subscriber.onError(new ProviderException(showServerReply(client)));
                        return;
                    }
                }
            }
            subscriber.onNext(client);
            subscriber.onCompleted();
        } catch (final IOException e) {
            disconnect(client);
            subscriber.onError(e);
        }
    }).subscribeOn(Schedulers.io());
}

From source file:ucar.unidata.idv.ui.ImageGenerator.java

/**
 * IS the FtpClient in an ok state. If it isn't then disconnect it and throw and IllegalStateException
 *
 * @param f Ftp client//ww  w  . j a  v a 2 s.co m
 * @param msg Message to use if in error
 *
 * @throws Exception On badness
 */
private static void checkFtp(FTPClient f, String msg) throws Exception {
    int replyCode = f.getReplyCode();
    if (!FTPReply.isPositiveCompletion(replyCode)) {
        String reply = f.getReplyString();
        f.disconnect();
        throw new IllegalStateException("Error with ftp: " + replyCode + " " + msg + "\n" + reply);
    }
}

From source file:uk.ac.bbsrc.tgac.miso.core.util.TransmissionUtils.java

public static FTPClient ftpConnect(String host, String username, String password) throws IOException {
    FTPClient ftp = new FTPClient();
    try {/*from www .ja  v a  2s  . co m*/

        ftp.connect(host);
        log.debug("Trying " + host);
        log.debug(ftp.getReplyString());
        int reply = ftp.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            throw new IOException("FTP server refused connection: " + reply);
        } else {
            log.info("Connected");
        }

        ftp.login(username, password);
        ftp.setFileType(FTP.BINARY_FILE_TYPE);
        ftp.enterLocalPassiveMode();
    } catch (NoRouteToHostException e) {
        throw new IOException("Couldn't connect to printer: " + e.getMessage(), e);
    } catch (UnknownHostException e) {
        throw new IOException("Couldn't connect to printer: " + e.getMessage(), e);
    }
    return ftp;
}

From source file:uk.ac.bbsrc.tgac.miso.core.util.TransmissionUtils.java

public static FTPClient ftpConnect(String host, int port, String username, String password) throws IOException {
    FTPClient ftp = new FTPClient();
    try {/*from   w w w  .  j  a v  a2s.co m*/
        ftp.connect(host, port);
        log.debug("Trying " + host + ":" + port);
        log.debug(ftp.getReplyString());
        int reply = ftp.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            throw new IOException("FTP server refused connection: " + reply);
        } else {
            log.debug("Connected");
        }

        ftp.login(username, password);
        ftp.setFileType(FTP.BINARY_FILE_TYPE);
        ftp.enterLocalPassiveMode();
    } catch (NoRouteToHostException e) {
        throw new IOException("Couldn't connect to printer: " + e.getMessage(), e);
    } catch (UnknownHostException e) {
        throw new IOException("Couldn't connect to printer: " + e.getMessage(), e);
    }
    return ftp;
}

From source file:uk.ac.bbsrc.tgac.miso.core.util.TransmissionUtils.java

public static boolean ftpPutListen(FTPClient ftp, String path, File file, boolean autoLogout, boolean autoMkdir,
        CopyStreamListener listener) throws IOException {
    boolean error = false;
    FileInputStream fis = null;//from  w  ww.j a  v  a 2  s .  c om

    log.info("ftpPutListen has been called for file:" + file.getName());
    try {
        if (ftp == null || !ftp.isConnected()) {
            error = true;
            throw new IOException(
                    "FTP client isn't connected. Please supply a client that has connected to the host.");
        }

        if (path != null) {
            if (autoMkdir) {
                if (!ftp.makeDirectory(path)) {
                    error = true;
                    throw new IOException("Cannot create desired path on the server.");
                }
            }
            log.info("Working dir =" + ftp.printWorkingDirectory());
            if (!ftp.changeWorkingDirectory(path)) {
                error = true;
                throw new IOException("Desired path does not exist on the server");
            }
        }

        fis = new FileInputStream(file);

        OutputStream ops = new BufferedOutputStream(ftp.storeFileStream(file.getName()), ftp.getBufferSize());

        log.info("TransmissionUtils putListen: FTP server responded: " + ftp.getReplyString());

        copyStream(fis, ops, ftp.getBufferSize(), file.length(), listener);

        ops.close();
        fis.close();
        log.info("TransmissionUtils putListen: FTP server responded: " + ftp.getReplyString());

        if (autoLogout) {
            ftp.logout();
        }
    } catch (IOException e) {
        error = true;
        log.error("ftp put listen", e);
    } finally {
        try {
            log.info("TransmissionUtils putListen:finally: " + ftp.getReplyString());
            if (fis != null) {
                fis.close();
            }

            if (autoLogout) {
                if (ftp != null && ftp.isConnected()) {
                    ftp.disconnect();
                }
            }
        } catch (IOException ioe) {
            log.error("ftp put listen close", ioe);
        }
    }

    // return inverse error boolean, just to make downstream conditionals easier
    log.info("result of transmissionutils.putListen:", !error);
    return !error;

}

From source file:uk.sipperfly.utils.FTPUtil.java

/**
 * Upload whole directory (including its nested sub directories and files) to FTP server.
 *
 * @param ftpClient       an instance of org.apache.commons.net.ftp.FTPClient class.
 * @param remoteDirPath   Path of the destination directory on the server.
 * @param localParentDir  Path of the local directory being uploaded.
 * @param remoteParentDir Path of the parent directory of the current directory on the server (used by recursive calls).
 * @throws IOException if any network or IO error occurred.
 *///from  w w w .  j  a va  2s .c om
public static boolean uploadDirectory(FTPClient ftpClient, String remoteDirPath, String localParentDir,
        String remoteParentDir) throws IOException {

    System.out.println("LISTING directory: " + localParentDir);
    Logger.getLogger(GACOM).log(Level.INFO, "LISTING directory: {0}".concat(localParentDir));
    File localDir = new File(localParentDir);
    File[] subFiles = localDir.listFiles();
    if (subFiles != null && subFiles.length > 0) {
        for (File item : subFiles) {
            boolean answer = ftpClient.sendNoOp();
            if (!answer) {
                reconnect();
            }
            String status = ftpClient.getStatus();
            boolean a = ftpClient.isAvailable();
            //            if (!ftpClient.isConnected()) {
            //               reconnect();
            //            }
            String remoteFilePath = remoteDirPath + "/" + remoteParentDir + "/" + item.getName();
            if (remoteParentDir.equals("")) {
                remoteFilePath = remoteDirPath + "/" + item.getName();
            }
            if (item.isFile()) {
                // upload the file
                String localFilePath = item.getAbsolutePath();
                Logger.getLogger(GACOM).log(Level.INFO, "About to upload the file: ".concat(localFilePath));
                System.out.println("About to upload the file: " + localFilePath);
                boolean uploaded = uploadSingleFile(ftpClient, localFilePath, remoteFilePath);

                if (uploaded) {
                    Logger.getLogger(GACOM).log(Level.INFO, "UPLOADED a file to: ".concat(remoteFilePath));
                    System.out.println("UPLOADED a file to: " + remoteFilePath);
                } else {
                    System.out.println("COULD NOT upload the file: " + localFilePath);
                    Logger.getLogger(GACOM).log(Level.INFO,
                            "COULD NOT upload the file: ".concat(localFilePath));
                    Logger.getLogger(GACOM).log(Level.INFO, ftpClient.getReplyString());
                    return false;
                }
            } else {
                // create directory on the server
                boolean created = ftpClient.makeDirectory(remoteFilePath);
                if (created) {
                    System.out.println("CREATED the directory: " + remoteFilePath);
                    Logger.getLogger(GACOM).log(Level.INFO, "CREATED the directory: ".concat(remoteFilePath));
                } else {
                    System.out.println("COULD NOT create the directory: " + remoteFilePath);
                    Logger.getLogger(GACOM).log(Level.INFO,
                            "COULD NOT create the directory: ".concat(remoteFilePath));
                    Logger.getLogger(GACOM).log(Level.INFO, ftpClient.getReplyString());
                    return false;
                }

                // upload the sub directory
                String parent = remoteParentDir + "/" + item.getName();
                if (remoteParentDir.equals("")) {
                    parent = item.getName();
                }

                localParentDir = item.getAbsolutePath();
                uploadDirectory(ftpClient, remoteDirPath, localParentDir, parent);
            }
        }
    }
    return true;
}

From source file:uk.sipperfly.utils.FTPUtil.java

public static void reconnect() throws SocketException, IOException {
    FTPClient ftpClient = new FTPClient();
    ftpClient.setControlEncoding("UTF-8");
    ftpClient.connect(host, port);//  w  ww .  j  a  v  a 2s  .c  om
    ftpClient.login(username, password);
    if (mode.equalsIgnoreCase("passive")) {
        ftpClient.enterLocalPassiveMode();
    } else if (mode.equalsIgnoreCase("active")) {
        ftpClient.enterLocalActiveMode();
    }
    int reply = ftpClient.getReplyCode();
    if (!FTPReply.isPositiveCompletion(reply)) {
        Logger.getLogger(GACOM).log(Level.INFO, "FTP Login: ".concat(ftpClient.getReplyString()));
        ftpClient.disconnect();
    }
    ftpClient.setKeepAlive(true);
    ftpClient.setFileType(FTP.BINARY_FILE_TYPE, FTP.BINARY_FILE_TYPE);
    ftpClient.setFileTransferMode(FTP.BINARY_FILE_TYPE);
    ftpClient.setControlKeepAliveTimeout(300);
    //      ftpClient.sendSiteCommand("RECFM=FB");
    //      ftpClient.sendSiteCommand("LRECL=2000");
    //      ftpClient.sendSiteCommand("BLKSIZE=27000");
    //      ftpClient.sendSiteCommand("CY");
    //      ftpClient.sendSiteCommand("PRI= 50");
    //      ftpClient.sendSiteCommand("SEC=25");

    //      ftpClient.sendSiteCommand("RECFM=FB");
    //      ftpClient.sendSiteCommand("LRECL=2000");
    //      ftpClient.sendSiteCommand("BLOCKSIZE=27000");
    //      ftpClient.sendSiteCommand("SPACE=(CYL,(30,300),RLSE)"); 
    //      ftpClient.sendSiteCommand("TR");
    //      ftpClient.sendSiteCommand("PRI=450");
    //      ftpClient.sendSiteCommand("SEC=4500");

    Logger.getLogger(GACOM).log(Level.INFO, "Reconnected FTP");
    System.out.println("reconnected");
}