Example usage for org.apache.commons.net.ftp FTPListParseEngine hasNext

List of usage examples for org.apache.commons.net.ftp FTPListParseEngine hasNext

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.net.ftp.*
  5. FTPListParseEngine
  6. hasNext

Introduction

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

Prototype

public boolean hasNext()

Source Link

Document

convenience method to allow clients to know whether this object's internal iterator's current position is at the end of the list.

Usage

From source file:jenkins.plugins.publish_over_ftp.BapFtpClient.java

private void delete() throws IOException {
    final FTPListParseEngine listParser = ftpClient.initiateListParsing();
    if (listParser == null)
        throw new BapPublisherException(Messages.exception_client_listParserNull());
    while (listParser.hasNext())
        delete(listParser.getNext(1)[0]);
}

From source file:jenkins.plugins.publish_over_ftp.BapFtpClientTest.java

private FTPFile expectFtpFile(final FTPListParseEngine mockListEngine, final String filename) {
    expect(mockListEngine.hasNext()).andReturn(true);
    final FTPFile file = mockControl.createMock(FTPFile.class);
    expect(mockListEngine.getNext(1)).andReturn(new FTPFile[] { file });
    expect(file.getName()).andReturn(filename);
    return file;/*from ww w  .  jav a  2 s .  c o m*/
}

From source file:com.atomicleopard.thundr.ftp.FtpSession.java

/**
 * List remote contents in batches - includes both files and directories
 * /* w  w w .  java2s . c  o m*/
 * @param directory
 * @param batchSize
 * @return
 */
public Iterable<FTPFile[]> listBatch(final String directory, final int batchSize) {
    return timeLogAndCatch("List files in batch", new Callable<Iterable<FTPFile[]>>() {
        @Override
        public Iterable<FTPFile[]> call() throws Exception {
            final FTPListParseEngine engine = preparedClient.initiateListParsing(directory);
            return new Iterable<FTPFile[]>() {
                @Override
                public Iterator<FTPFile[]> iterator() {
                    return new Iterator<FTPFile[]>() {

                        @Override
                        public boolean hasNext() {
                            return engine.hasNext();
                        }

                        @Override
                        public FTPFile[] next() {
                            return engine.getNext(batchSize);
                        }

                        @Override
                        public void remove() {
                            throw new UnsupportedOperationException();
                        }
                    };
                }
            };
        }
    });
}

From source file:jenkins.plugins.publish_over_ftp.BapFtpClientTest.java

@Test
public void testDeleteTreeDeletesFiles() throws Exception {
    mockFTPClient.setListHiddenFiles(true);
    final FTPListParseEngine mockListEngine = mockControl.createMock(FTPListParseEngine.class);
    expect(mockFTPClient.initiateListParsing()).andReturn(mockListEngine);
    expectDeleteFiles(mockListEngine, "file1", "file2", "anotherOne");
    expect(mockListEngine.hasNext()).andReturn(false);
    mockControl.replay();/*from   w  ww . j  ava2 s.  c o m*/
    bapFtpClient.deleteTree();
    mockControl.verify();
}

From source file:jenkins.plugins.publish_over_ftp.BapFtpClientTest.java

@Test
public void testDeleteTreeDeletesDirectoryWithFiles() throws Exception {
    mockFTPClient.setListHiddenFiles(true);
    final FTPListParseEngine mockListEngine = mockControl.createMock(FTPListParseEngine.class);
    expect(mockFTPClient.initiateListParsing()).andReturn(mockListEngine);
    final String dirname = "directory";
    expectDirectory(mockListEngine, dirname);
    expect(mockFTPClient.changeWorkingDirectory(dirname)).andReturn(true);

    final FTPListParseEngine mockListEngineSubDir = mockControl.createMock(FTPListParseEngine.class);
    expect(mockFTPClient.initiateListParsing()).andReturn(mockListEngineSubDir);
    expectDeleteFiles(mockListEngineSubDir, "file1", "file2", "anotherOne");
    expect(mockListEngineSubDir.hasNext()).andReturn(false);

    expect(mockFTPClient.changeToParentDirectory()).andReturn(true);
    expect(mockFTPClient.removeDirectory(dirname)).andReturn(true);
    expect(mockListEngine.hasNext()).andReturn(false);
    mockControl.replay();//  w  w  w.j  ava2  s  .  co m
    bapFtpClient.deleteTree();
    mockControl.verify();
}

From source file:jenkins.plugins.publish_over_ftp.BapFtpClientTest.java

@Test
public void testDeleteTreeIgnoresCurrentDirAndParentDirEntries() throws Exception {
    mockFTPClient.setListHiddenFiles(true);
    final FTPListParseEngine mockListEngine = mockControl.createMock(FTPListParseEngine.class);
    expect(mockFTPClient.initiateListParsing()).andReturn(mockListEngine);
    expectFtpFile(mockListEngine, ".");
    expectFtpFile(mockListEngine, "..");
    expectDeleteFiles(mockListEngine, "file1", "file2", "anotherOne");
    expect(mockListEngine.hasNext()).andReturn(false);
    mockControl.replay();/*from ww  w .jav a  2s.co m*/
    bapFtpClient.deleteTree();
    mockControl.verify();
}

From source file:org.apache.sqoop.util.MainframeFTPClientUtils.java

public static List<String> listSequentialDatasets(String pdsName, Configuration conf) throws IOException {
    List<String> datasets = new ArrayList<String>();
    String dsName = pdsName;// www  . jav a 2 s  .com
    String fileName = "";
    MainframeDatasetPath p = null;
    try {
        p = new MainframeDatasetPath(dsName, conf);
    } catch (Exception e) {
        LOG.error(e.getMessage());
        LOG.error("MainframeDatasetPath helper class incorrectly initialised");
        e.printStackTrace();
    }
    String dsType = conf.get(MainframeConfiguration.MAINFRAME_INPUT_DATASET_TYPE);
    boolean isTape = Boolean.parseBoolean(conf.get(MainframeConfiguration.MAINFRAME_INPUT_DATASET_TAPE));
    boolean isSequentialDs = false;
    boolean isGDG = false;
    if (dsType != null && p != null) {
        isSequentialDs = p.getMainframeDatasetType().toString()
                .equals(MainframeConfiguration.MAINFRAME_INPUT_DATASET_TYPE_SEQUENTIAL);
        isGDG = p.getMainframeDatasetType().toString()
                .equals(MainframeConfiguration.MAINFRAME_INPUT_DATASET_TYPE_GDG);
        pdsName = p.getMainframeDatasetFolder();
        fileName = p.getMainframeDatasetFileName();
    }
    FTPClient ftp = null;
    try {
        ftp = getFTPConnection(conf);
        if (ftp != null) {
            ftp.changeWorkingDirectory("'" + pdsName + "'");
            FTPFile[] ftpFiles = null;
            if (isTape) {
                FTPListParseEngine parser = ftp.initiateListParsing(
                        MainframeConfiguration.MAINFRAME_FTP_FILE_ENTRY_PARSER_CLASSNAME, "");
                List<FTPFile> listing = new ArrayList<FTPFile>();
                while (parser.hasNext()) {
                    FTPFile[] files = parser.getNext(25);
                    for (FTPFile file : files) {
                        if (file != null) {
                            listing.add(file);
                            LOG.info(String.format("Name: %s Type: %s", file.getName(), file.getType()));
                        }
                        // skip nulls returned from parser
                    }
                    ftpFiles = new FTPFile[listing.size()];
                    for (int i = 0; i < listing.size(); i++) {
                        ftpFiles[i] = listing.get(i);
                    }
                    LOG.info("Files returned from mainframe parser:-");
                    for (FTPFile f : ftpFiles) {
                        LOG.info(String.format("Name: %s, Type: %s", f.getName(), f.getType()));
                    }
                }
            } else {
                ftpFiles = ftp.listFiles();
            }
            if (!isGDG) {
                for (FTPFile f : ftpFiles) {
                    LOG.info(String.format("Name: %s Type: %s", f.getName(), f.getType()));
                    if (f.getType() == FTPFile.FILE_TYPE) {
                        // only add datasets if default behaviour of partitioned data sets
                        // or if it is a sequential data set, only add if the file name matches exactly
                        if (!isSequentialDs
                                || isSequentialDs && f.getName().equals(fileName) && !fileName.equals("")) {
                            datasets.add(f.getName());
                        }
                    }
                }
            } else {
                LOG.info("GDG branch. File list:-");
                for (FTPFile f : ftpFiles) {
                    LOG.info(String.format("Name: %s Type: %s", f.getName(), f.getType()));
                }
                if (ftpFiles.length > 0 && ftpFiles[ftpFiles.length - 1].getType() == FTPFile.FILE_TYPE) {
                    // for GDG - add the last file in the collection
                    datasets.add(ftpFiles[ftpFiles.length - 1].getName());
                }
            }
        }
    } catch (IOException ioe) {
        throw new IOException("Could not list datasets from " + pdsName + ":" + ioe.toString());
    } finally {
        if (ftp != null) {
            closeFTPConnection(ftp);
        }
    }
    return datasets;
}

From source file:org.mule.transport.ftp.FtpMessageReceiver.java

protected FTPFile[] listFiles() throws Exception {
    FTPClient client = null;//from  ww w  .  j a  v  a  2 s . com
    try {
        client = connector.createFtpClient(endpoint);
        FTPListParseEngine engine = client.initiateListParsing();
        FTPFile[] files = null;
        List<FTPFile> v = new ArrayList<FTPFile>();
        while (engine.hasNext()) {
            if (getLifecycleState().isStopping()) {
                break;
            }
            files = engine.getNext(FTP_LIST_PAGE_SIZE);
            if (files == null || files.length == 0) {
                return files;
            }
            for (FTPFile file : files) {
                if (file.isFile()) {
                    if (filenameFilter == null || filenameFilter.accept(null, file.getName())) {
                        v.add(file);
                    }
                }
            }
        }

        if (!FTPReply.isPositiveCompletion(client.getReplyCode())) {
            throw new IOException("Failed to list files. Ftp error: " + client.getReplyCode());
        }

        return v.toArray(new FTPFile[v.size()]);
    } finally {
        if (client != null) {
            connector.releaseFtp(endpoint.getEndpointURI(), client);
        }
    }
}

From source file:org.mule.transport.ftp.FtpMessageRequester.java

protected FTPFile findFileToProcess(FTPClient client) throws Exception {
    FTPListParseEngine engine = client.initiateListParsing();
    FTPFile[] files = null;/*from  ww  w  .j ava  2  s  . c  o  m*/
    while (engine.hasNext()) {
        files = engine.getNext(FTP_LIST_PAGE_SIZE);
        if (files == null) {
            break;
        }
        FilenameFilter filenameFilter = getFilenameFilter();
        for (int i = 0; i < files.length; i++) {
            FTPFile file = files[i];
            if (file.isFile()) {
                if (filenameFilter.accept(null, file.getName())) {
                    if (connector.validateFile(file)) {
                        // only read the first one
                        return file;
                    }
                }
            }
        }
    }
    if (!FTPReply.isPositiveCompletion(client.getReplyCode())) {
        throw new IOException("Ftp error: " + client.getReplyCode());
    }

    return null;
}

From source file:org.mule.transport.ftps.FtpsMessageReceiver.java

protected FTPFile[] listFiles() throws Exception {
    FTPSClient client = null;// w  ww .  ja  v a 2 s . c om
    try {
        client = connector.createFTPSClient(endpoint);
        FTPListParseEngine engine = client.initiateListParsing();
        FTPFile[] files = null;
        List<FTPFile> v = new ArrayList<FTPFile>();
        while (engine.hasNext()) {
            if (getLifecycleState().isStopping()) {
                break;
            }
            files = engine.getNext(FTP_LIST_PAGE_SIZE);
            if (files == null || files.length == 0) {
                return files;
            }
            for (FTPFile file : files) {
                if (file.isFile()) {
                    if (filenameFilter == null || filenameFilter.accept(null, file.getName())) {
                        v.add(file);
                    }
                }
            }
        }

        if (!FTPReply.isPositiveCompletion(client.getReplyCode())) {
            throw new IOException("Failed to list files. Ftp error: " + client.getReplyCode());
        }

        return v.toArray(new FTPFile[v.size()]);
    } finally {
        if (client != null) {
            connector.releaseFtp(endpoint.getEndpointURI(), client);
        }
    }
}