/**
* Description: 从FTP服务器下载指定文件夹下的所有文件
*
* @param url FTP服务器hostname
* @param port FTP服务器端口
* @param username FTP登录账号
* @param password FTP登录密码
* @param remotePath FTP服务器上的相对路径
* @param localPath 下载后保存到本地的路径
* @param fileName 保存为该文件名的文件
* @return
*/
public static boolean downFile(
String url,
int port,
String username,
String password,
String remotePath,
String localPath,
String fileName) {
boolean success = false;
FTPClient ftp = null;
try {
int reply;
ftp = getConnection(url, port, username, password);
reply = ftp.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
ftp.disconnect();
return success;
}
boolean changeWorkDirState = false;
changeWorkDirState = ftp.changeWorkingDirectory(remotePath); // 转移到FTP服务器目录
System.out.println(changeWorkDirState == true ? "切换FTP目录 成功" : "切换FTP目录 失败");
if (changeWorkDirState == false) return false;
FTPFile[] fs = ftp.listFiles();
for (FTPFile ff : fs) {
if (ff.getName().equals(fileName)) {
File localFile = new File(localPath + "/" + ff.getName());
OutputStream is = new FileOutputStream(localFile);
ftp.retrieveFile(ff.getName(), is);
is.close();
}
}
ftp.logout();
success = true;
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return success;
}
public String getAbsolutePath() {
// 如果是根结点
if (getURL() != null) {
return getURL().getPath();
}
String parentAbsolutePath = getParent().getAbsolutePath();
if (parentAbsolutePath.endsWith("/")) {
return parentAbsolutePath + ftpFile.getName();
} else {
return parentAbsolutePath + "/" + ftpFile.getName();
}
}
private void traverseDirectory(String directory) throws IOException {
log.info("---------- Traversing directory '" + directory + "'.");
ftpc.changeWorkingDirectory(directory);
printFTPCommandInfo("change directory (" + directory + ")");
FTPFile[] files = ftpc.listFiles();
printFTPCommandInfo("list files (" + directory + ")");
if (!directory.endsWith("/")) {
directory += "/";
}
String fileList = "";
for (FTPFile file : files) {
if (!fileList.equals("")) {
fileList += ",";
}
fileList += file.getName();
}
log.info("********** Files: [" + fileList + "].");
for (FTPFile file : files) {
String path = directory + file.getName();
Boolean complete = false;
if (processedDirectories.containsKey(path)) {
FTPManifestEntry existingEntry = processedDirectories.get(path);
complete = existingEntry.getCompleted();
}
if (!complete) {
FTPManifestEntryType type = FTPManifestEntryType.FILE;
if (file.getType() == FTPFile.DIRECTORY_TYPE) {
type = FTPManifestEntryType.DIRECTORY;
}
FTPManifestEntry entry = new FTPManifestEntry(path, file.getName(), type, false);
processedDirectories.put(directory + file.getName(), entry);
if (type.equals(FTPManifestEntryType.DIRECTORY)) {
traverseDirectory(path);
}
log.info("Completed entry '" + path + "'.");
entry.setCompleted(true);
}
}
}
public static lucee.runtime.type.Query toQuery(
FTPFile[] files, String prefix, String directory, String hostName) throws PageException {
String[] cols =
new String[] {
"name",
"isdirectory",
"lastmodified",
"length",
"mode",
"path",
"url",
"type",
"raw",
"attributes"
};
String[] types =
new String[] {
"VARCHAR", "BOOLEAN", "DATE", "DOUBLE", "VARCHAR", "VARCHAR", "VARCHAR", "VARCHAR",
"VARCHAR", "VARCHAR"
};
lucee.runtime.type.Query query = new QueryImpl(cols, types, 0, "query");
// translate directory path for display
if (directory.length() == 0) directory = "/";
else if (directory.startsWith("./")) directory = directory.substring(1);
else if (directory.charAt(0) != '/') directory = '/' + directory;
if (directory.charAt(directory.length() - 1) != '/') directory = directory + '/';
int row;
for (int i = 0; i < files.length; i++) {
FTPFile file = files[i];
if (file.getName().equals(".") || file.getName().equals("..")) continue;
row = query.addRow();
query.setAt("attributes", row, "");
query.setAt("isdirectory", row, Caster.toBoolean(file.isDirectory()));
query.setAt("lastmodified", row, new DateTimeImpl(file.getTimestamp()));
query.setAt("length", row, Caster.toDouble(file.getSize()));
query.setAt("mode", row, FTPConstant.getPermissionASInteger(file));
query.setAt("type", row, FTPConstant.getTypeAsString(file.getType()));
// query.setAt("permission",row,FTPConstant.getPermissionASInteger(file));
query.setAt("raw", row, file.getRawListing());
query.setAt("name", row, file.getName());
query.setAt("path", row, directory + file.getName());
query.setAt("url", row, prefix + "://" + hostName + "" + directory + file.getName());
}
return query;
}
protected void getDir(String dirPath) {
// TODO Auto-generated method stub
list = FTPConnector.list();
item = new ArrayList<String>();
if (!dirPath.equals(root)) {
item.add(root);
item.add("../");
}
for (int i = 0; i < list.length; i++) {
FTPFile file = list[i];
if (file.isDirectory()) item.add(file.getName() + "/");
else item.add(file.getName());
}
}
/**
* @param ftpClient
* @param allowFileTypes
* @return
*/
public static void listFiles(
FTPClient ftpClient,
List<String> filePath,
Set<String> allowFileTypes,
String changeToPath,
Boolean isFirst) {
try {
if (!isFirst) {
Boolean flag = ftpClient.changeWorkingDirectory(changeToPath);
if (!flag) {
return;
}
}
FTPFile[] files = ftpClient.listFiles();
if (null != files && files.length > 0) {
for (FTPFile file : files) {
String name = file.getName();
if (file.isDirectory()) {
listFiles(
ftpClient, filePath, allowFileTypes, changeToPath + "/" + name, Boolean.FALSE);
} else if (file.isFile()) {
String extAttr = getExt(name);
if (allowFileTypes.contains(extAttr)) {
filePath.add(getAfterUploadUrl(changeToPath + "/", name));
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Convenience method, so that we don't open a new connection when using this method from within
* another method. Otherwise every API invocation incurs the overhead of opening/closing a TCP
* connection.
*/
private FileStatus getFileStatus(FTPClient client, Path file) throws IOException {
FileStatus fileStat = null;
Path workDir = new Path(client.printWorkingDirectory());
Path absolute = makeAbsolute(workDir, file);
Path parentPath = absolute.getParent();
if (parentPath == null) { // root dir
long length = -1; // Length of root dir on server not known
boolean isDir = true;
int blockReplication = 1;
long blockSize = DEFAULT_BLOCK_SIZE; // Block Size not known.
long modTime = -1; // Modification time of root dir not known.
Path root = new Path("/");
return new FileStatus(
length, isDir, blockReplication, blockSize, modTime, root.makeQualified(this));
}
String pathName = parentPath.toUri().getPath();
FTPFile[] ftpFiles = client.listFiles(pathName);
if (ftpFiles != null) {
for (FTPFile ftpFile : ftpFiles) {
if (ftpFile.getName().equals(file.getName())) { // file found in dir
fileStat = getFileStatus(ftpFile, parentPath);
break;
}
}
if (fileStat == null) {
throw new FileNotFoundException("File " + file + " does not exist.");
}
} else {
throw new FileNotFoundException("File " + file + " does not exist.");
}
return fileStat;
}
@Override
public boolean accept(FTPFile file) {
String name = file.getName();
Pattern p = Pattern.compile("^" + reg + "$");
Matcher m = p.matcher(name);
return m.find();
}
/**
* Convert the file information in FTPFile to a {@link FileStatus} object. *
*
* @param ftpFile
* @param parentPath
* @return FileStatus
*/
private FileStatus getFileStatus(FTPFile ftpFile, Path parentPath) {
long length = ftpFile.getSize();
boolean isDir = ftpFile.isDirectory();
int blockReplication = 1;
// Using default block size since there is no way in FTP client to know of
// block sizes on server. The assumption could be less than ideal.
long blockSize = DEFAULT_BLOCK_SIZE;
long modTime = ftpFile.getTimestamp().getTimeInMillis();
long accessTime = 0;
FsPermission permission = getPermissions(ftpFile);
String user = ftpFile.getUser();
String group = ftpFile.getGroup();
Path filePath = new Path(parentPath, ftpFile.getName());
return new FileStatus(
length,
isDir,
blockReplication,
blockSize,
modTime,
accessTime,
permission,
user,
group,
filePath.makeQualified(this));
}
private static void ftpStuff() {
try {
FTPClient ftp = new FTPClient();
ftp.connect("ftp.ncbi.nih.gov");
System.out.println(ftp.getReplyString());
ftp.login("anonymous", "*****@*****.**");
System.out.println("before list files...");
// ftp.li
FTPFile[] files = ftp.listFiles(BASE_FOLDER);
System.out.println(files.length);
for (FTPFile file : files) {
if (file.getName().endsWith(".gbff.gz")) {
StringWriter writer = null;
String charset = "ASCII";
GZIPInputStream inputStream =
new GZIPInputStream(ftp.retrieveFileStream(BASE_FOLDER + "/" + file.getName()));
System.out.println("ftp.getControlEncoding() = " + ftp.getControlEncoding());
Reader decoder = new InputStreamReader(inputStream, charset);
BufferedReader buffered = new BufferedReader(decoder);
String line = null;
while ((line = buffered.readLine()) != null) {
System.out.println("line = " + line);
}
System.exit(0);
}
}
} catch (Exception ex) {
Logger.getLogger(ImportGenBank.class.getName()).log(Level.SEVERE, null, ex);
}
}
/**
* Description: 从FTP服务器下载文件
*
* @param host FTP服务器hostname
* @param port FTP服务器端口
* @param username FTP登录账号
* @param password FTP登录密码
* @param remotePath FTP服务器上的相对路径
* @param fileName 要下载的文件名
* @param localPath 下载后保存到本地的路径
* @return
*/
public static boolean downloadFile(
String host,
int port,
String username,
String password,
String remotePath,
String fileName,
String localPath) {
boolean result = false;
FTPClient ftp = new FTPClient();
try {
int reply;
ftp.connect(host, port);
// 如果采用默认端口，可以使用ftp.connect(host)的方式直接连接FTP服务器
ftp.login(username, password); // 登录
reply = ftp.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
ftp.disconnect();
return result;
}
ftp.changeWorkingDirectory(remotePath); // 转移到FTP服务器目录
FTPFile[] fs = ftp.listFiles();
for (FTPFile ff : fs) {
if (ff.getName().equals(fileName)) {
File localFile = new File(localPath + "/" + ff.getName());
OutputStream is = new FileOutputStream(localFile);
ftp.retrieveFile(ff.getName(), is);
is.close();
}
}
ftp.logout();
result = true;
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return result;
}
/** @see org.apache.commons.net.ftp.parser.FTPParseTestFramework#testParseFieldsOnDirectory() */
@Override
public void testParseFieldsOnDirectory() throws Exception {
FTPFile dir = getParser().parseFTPEntry(" 0 DIR 11-28-97 09:42 PC");
assertNotNull("Could not parse entry.", dir);
assertTrue("Should have been a directory.", dir.isDirectory());
assertEquals(0, dir.getSize());
assertEquals("PC", dir.getName());
assertEquals("Fri Nov 28 09:42:00 1997", df.format(dir.getTimestamp().getTime()));
}
private static void removeRecursive(AFTPClient client, String path, int type) throws IOException {
// directory
if (FTPFile.DIRECTORY_TYPE == type) {
if (!path.endsWith("/")) path += "/";
// first we remove the children
FTPFile[] children = client.listFiles(path);
for (FTPFile child : children) {
if (child.getName().equals(".") || child.getName().equals("..")) continue;
removeRecursive(client, path + child.getName(), child.getType());
}
// then the directory itself
client.removeDirectory(path);
}
// file
else if (FTPFile.FILE_TYPE == type) {
client.deleteFile(path);
}
}
/** @see org.apache.commons.net.ftp.parser.FTPParseTestFramework#testParseFieldsOnFile() */
@Override
public void testParseFieldsOnFile() throws Exception {
FTPFile file =
getParser().parseFTPEntry("5000000000 A 11-17-98 16:07 POPUPLOG.OS2");
assertNotNull("Could not parse entry.", file);
assertTrue("Should have been a file.", file.isFile());
assertEquals(5000000000L, file.getSize());
assertEquals("POPUPLOG.OS2", file.getName());
assertEquals("Tue Nov 17 16:07:00 1998", df.format(file.getTimestamp().getTime()));
}
public FTPProgressPanel(FTPFile file, String sourcePath, DefaultMutableTreeNode parent) {
this.file = file;
this.sourcePath = sourcePath;
if (file != null) {
label = new JLabel(file.getName() + " " + file.getSize());
}
add(label);
}
/**
* @param mask
* @param remoteFolder
* @throws SocketException
* @throws IOException
*/
public void removeFilesByMask(String mask, String remoteFolder)
throws SocketException, IOException {
connect2Server();
if (oFtp.isConnected()) {
FTPFile[] fileslist = oFtp.listFiles(remoteFolder);
Pattern pat = Pattern.compile("^" + mask);
for (FTPFile file : fileslist) {
java.util.regex.Matcher m = pat.matcher(file.getName());
boolean is_pat_file = m.find();
if (is_pat_file) {
oFtp.deleteFile(remoteFolder + file.getName());
}
}
}
this.closeFtpConnection();
}
/**
* download file from remote host and display the downloaded percentage
*
* @param folder remote directory
* @param fileName the file you want to download
* @param destfolder the destination folder you will store the file
*/
public void downloadFileInProgress(String folder, String fileName, String destfolder) {
try {
ftp.enterLocalPassiveMode();
ftp.changeWorkingDirectory(folder);
LogUtils.log("Changing to directory:[" + folder + "]");
String realFile = destfolder + File.separator + fileName;
File localFile = new File(realFile);
FileOutputStream fos = new FileOutputStream(localFile);
LogUtils.log("Start downloading..");
FTPFile[] fs = ftp.listFiles();
DecimalFormat df = new DecimalFormat("#.00%");
for (FTPFile f : fs) {
if (f.getName().equals(fileName)) {
InputStream is = ftp.retrieveFileStream(f.getName());
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String line = br.readLine();
long transfered = 0, total = f.getSize();
double ratio = 0.0;
while (line != null) {
byte[] buff = line.getBytes();
transfered += buff.length;
if (transfered * 1.0 / total - ratio >= 0.01) {
ratio = transfered * 1.0 / total;
LogUtils.log("Download size : " + df.format(ratio));
}
fos.write(buff);
line = br.readLine();
}
is.close();
ftp.logout();
ftp.disconnect();
LogUtils.log("Download done!");
}
}
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static FTPStorageDirectory createFromFTPFile(FTPFile file, String path)
throws FTPStorageNotADirectory {
if (file.getType() != FTPStorageSystem.FTP_STORAGE_DIRECTORY) {
throw new FTPStorageNotADirectory();
}
FTPStorageDirectory fsd =
new FTPStorageDirectory(file.getName(), StorageDirectory.buildFromPath(path, "/"));
fsd.setGroup(file.getGroup());
fsd.setUser(file.getUser());
fsd.setCreateDate(file.getTimestamp().getTime());
return fsd;
}
@Override
protected boolean isMatched(GenericFile<FTPFile> file, String doneFileName, List<FTPFile> files) {
String onlyName = FileUtil.stripPath(doneFileName);
for (FTPFile f : files) {
if (f.getName().equals(onlyName)) {
return true;
}
}
log.trace("Done file: {} does not exist", doneFileName);
return false;
}
private RemoteFile<FTPFile> asRemoteFile(String absolutePath, FTPFile file, String charset) {
RemoteFile<FTPFile> answer = new RemoteFile<FTPFile>();
answer.setCharset(charset);
answer.setEndpointPath(endpointPath);
answer.setFile(file);
answer.setFileNameOnly(file.getName());
answer.setFileLength(file.getSize());
answer.setDirectory(file.isDirectory());
if (file.getTimestamp() != null) {
answer.setLastModified(file.getTimestamp().getTimeInMillis());
}
answer.setHostname(((RemoteFileConfiguration) endpoint.getConfiguration()).getHost());
// absolute or relative path
boolean absolute = FileUtil.hasLeadingSeparator(absolutePath);
answer.setAbsolute(absolute);
// create a pseudo absolute name
String dir = FileUtil.stripTrailingSeparator(absolutePath);
String absoluteFileName = FileUtil.stripLeadingSeparator(dir + "/" + file.getName());
// if absolute start with a leading separator otherwise let it be relative
if (absolute) {
absoluteFileName = "/" + absoluteFileName;
}
answer.setAbsoluteFilePath(absoluteFileName);
// the relative filename, skip the leading endpoint configured path
String relativePath = ObjectHelper.after(absoluteFileName, endpointPath);
// skip leading /
relativePath = FileUtil.stripLeadingSeparator(relativePath);
answer.setRelativeFilePath(relativePath);
// the file name should be the relative path
answer.setFileName(answer.getRelativeFilePath());
return answer;
}
@Override
public EnumSet<AccessMode> getAccess(final String name) throws IOException {
try {
ftpClient.setFileType(FTP.ASCII_FILE_TYPE);
final FTPFile[] files = ftpClient.listFiles(name);
if (files.length == 0) throw new NoSuchFileException(name);
if (files.length == 1) return calculateAccess(files[0]);
for (final FTPFile file : files) if (".".equals(file.getName())) return calculateAccess(file);
throw new IllegalStateException();
} catch (FTPConnectionClosedException e) {
status = Status.DEAD;
throw new IOException("service unavailable", e);
}
}
/**
* @param remotePath 远程文件路径ַ ex：/upload/2012/xxxx.jpg
* @param out 文件输出流
* @return
*/
public static boolean downFile(String remotePath, OutputStream out) {
Boolean flag = Boolean.FALSE;
// 得到文件名 ex: xxxx.jpg
String fileName = getLastName(remotePath);
// 得到文件存储路径 ex：/upload/2012
String remoteStorePath = getFilePath(remotePath);
FTPClient ftpClient = null;
try {
ftpClient = getFTPClient();
// 得到返回答复码
int reply = ftpClient.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
try {
ftpClient.disconnect();
return flag;
} catch (IOException e) {
e.printStackTrace();
return flag;
}
}
ftpClient.changeWorkingDirectory(remoteStorePath);
// ftpClient.setFileType(FTP.BINARY_FILE_TYPE);//
FTPFile[] fs = ftpClient.listFiles();
for (FTPFile file : fs) {
if (fileName.equalsIgnoreCase(file.getName())) {
flag = ftpClient.retrieveFile(fileName, out);
break;
}
}
ftpClient.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != ftpClient && ftpClient.isConnected()) {
try {
ftpClient.disconnect();
} catch (IOException ioe) {
}
}
}
return flag;
}
/**
* download file from remote host without progress percentage display
*
* @param folder remote directory
* @param fileName the file you want to download
* @param destfolder the destination folder you will store the file
*/
public void downloadFile(String folder, String fileName, String destfolder) {
try {
ftp.enterLocalPassiveMode();
ftp.changeWorkingDirectory(folder);
LogUtils.log("Changing to directory:[" + folder + "]");
String realFile = destfolder + File.separator + fileName;
File localFile = new File(realFile);
FileOutputStream fos = new FileOutputStream(localFile);
FileInputStream fis = new FileInputStream(localFile);
LogUtils.log("Start downloading..");
FTPFile[] fs = ftp.listFiles();
for (FTPFile f : fs) {
if (f.getName().equals(fileName)) {
ftp.retrieveFile(f.getName(), fos);
LogUtils.log("Download done!");
break;
}
}
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @param remoteFile
* @param path
* @return
* @throws SocketException
* @throws IOException
*/
public boolean isExists(String remoteFile, String path) throws SocketException, IOException {
this.connect2Server();
if (this.oFtp.isConnected()) {
FTPFile[] files = oFtp.listFiles(path);
for (FTPFile file : files) {
if (file.getName().equalsIgnoreCase(remoteFile)) {
return true;
}
}
}
this.closeFtpConnection();
return false;
}
public String getPath() {
// 如果没有计算过
if (path == null) {
// 如果有父亲
if (getParent() != null) {
super.setPath(getParent().getPath() + "/" + getFileName());
} else {
if (ftpFile.isDirectory()) {
return "";
} else {
return "/" + ftpFile.getName();
}
}
}
return getPath();
}
@Override
public List<String> getDirectoryNames(final String dir) throws IOException {
try {
ftpClient.setFileType(FTP.ASCII_FILE_TYPE);
final FTPFile[] files = ftpClient.listFiles(dir);
if (files.length == 0) throw new NoSuchFileException(dir);
if (files.length == 1) handleFailedDirectoryList(dir, files[0]);
final List<String> ret = new ArrayList<>(files.length);
String name;
for (final FTPFile file : files) {
name = file.getName();
if (!(".".equals(name) || "..".equals(name))) ret.add(name);
}
return ret;
} catch (FTPConnectionClosedException e) {
status = Status.DEAD;
throw new IOException("service unavailable", e);
}
}
private void checkAlbumContent(List<ValidationError> errors, String album)
throws FtpManagerException {
List<FTPFile> pictures = ftpManager.listFilesFromAlbum(album);
Set<String> smallNames = new TreeSet<>();
Set<String> normalNames = new TreeSet<>();
for (FTPFile ftpFile : pictures) {
String ftpFileName = FilenameUtils.getBaseName(ftpFile.getName());
if (ftpFileName.contains(AlbumNamesHelper.PREFIX_SMALL_IMAGE)) {
smallNames.add(
StringUtils.remove(ftpFileName, AlbumNamesHelper.PREFIX_SMALL_IMAGE).toLowerCase());
} else {
normalNames.add(ftpFileName.toLowerCase());
}
}
// Teste si tuous les normal names sont présents.
if (smallNames.isEmpty() && normalNames.isEmpty()) {
errors.add(
new ValidationError(SeverityErrorEnum.WARNNING, "L'album " + album + " est vide."));
} else {
Set<String> differenceNormalNames = Sets.difference(smallNames, normalNames);
for (String pictureName : differenceNormalNames) {
errors.add(
new ValidationError(
SeverityErrorEnum.ERREUR,
"La photo " + pictureName + " de l'album " + album + " n'a pas sa mignature."));
}
Set<String> differenceSmallNames = Sets.difference(normalNames, smallNames);
for (String pictureName : differenceSmallNames) {
errors.add(
new ValidationError(
SeverityErrorEnum.ERREUR,
"La photo small"
+ pictureName
+ " de l'album "
+ album
+ " n'a pas sa photo taille réelle."));
}
}
}
/**
* @param mask
* @param path
* @return
* @throws SocketException
* @throws IOException
*/
public List<FTPFile> getFilesByMask(String mask, String path)
throws SocketException, IOException {
List<FTPFile> maskFiles = new ArrayList<FTPFile>();
connect2Server();
if (oFtp.isConnected()) {
FTPFile[] fileslist = oFtp.listFiles(path);
Pattern pat = Pattern.compile("^" + mask);
for (FTPFile file : fileslist) {
java.util.regex.Matcher m = pat.matcher(file.getName());
boolean is_pat_file = m.find();
if (is_pat_file) {
maskFiles.add(file);
}
}
}
this.closeFtpConnection();
return maskFiles;
}
@Override
public void onListItemClick(ListView l, View v, int position, long id) {
// TODO Auto-generated method stub
// super.onListItemClick(l, v, position, id);
FTPFile file = list[position];
final File file1 = new File("/" + file.getName());
if (list[position].isFile()) {
AlertDialog.Builder alert_confirm = new AlertDialog.Builder(getActivity());
alert_confirm
.setTitle("[" + list[position].getName() + "]")
.setMessage("다운로드")
.setCancelable(false)
.setPositiveButton(
"확인",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// 'YES'
threadList(file1);
}
})
.setNegativeButton(
"취소",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// 'No'
return;
}
});
AlertDialog alert = alert_confirm.create();
alert.show();
} else {
}
}
protected boolean doPollDirectory(
String absolutePath, String dirName, List<GenericFile<FTPFile>> fileList, int depth) {
log.trace("doPollDirectory from absolutePath: {}, dirName: {}", absolutePath, dirName);
depth++;
// remove trailing /
dirName = FileUtil.stripTrailingSeparator(dirName);
// compute dir depending on stepwise is enabled or not
String dir;
if (isStepwise()) {
dir = ObjectHelper.isNotEmpty(dirName) ? dirName : absolutePath;
operations.changeCurrentDirectory(dir);
} else {
dir = absolutePath;
}
log.trace("Polling directory: {}", dir);
List<FTPFile> files = null;
if (isUseList()) {
if (isStepwise()) {
files = operations.listFiles();
} else {
files = operations.listFiles(dir);
}
} else {
// we cannot use the LIST command(s) so we can only poll a named file
// so created a pseudo file with that name
FTPFile file = new FTPFile();
file.setType(FTPFile.FILE_TYPE);
fileExpressionResult = evaluateFileExpression();
if (fileExpressionResult != null) {
file.setName(fileExpressionResult);
files = new ArrayList<FTPFile>(1);
files.add(file);
}
}
if (files == null || files.isEmpty()) {
// no files in this directory to poll
log.trace("No files found in directory: {}", dir);
return true;
} else {
// we found some files
log.trace("Found {} in directory: {}", files.size(), dir);
}
for (FTPFile file : files) {
if (log.isTraceEnabled()) {
log.trace(
"FtpFile[name={}, dir={}, file={}]",
new Object[] {file.getName(), file.isDirectory(), file.isFile()});
}
// check if we can continue polling in files
if (!canPollMoreFiles(fileList)) {
return false;
}
if (file.isDirectory()) {
RemoteFile<FTPFile> remote = asRemoteFile(absolutePath, file, getEndpoint().getCharset());
if (endpoint.isRecursive()
&& depth < endpoint.getMaxDepth()
&& isValidFile(remote, true, files)) {
// recursive scan and add the sub files and folders
String subDirectory = file.getName();
String path = absolutePath + "/" + subDirectory;
boolean canPollMore = pollSubDirectory(path, subDirectory, fileList, depth);
if (!canPollMore) {
return false;
}
}
} else if (file.isFile()) {
RemoteFile<FTPFile> remote = asRemoteFile(absolutePath, file, getEndpoint().getCharset());
if (depth >= endpoint.getMinDepth() && isValidFile(remote, false, files)) {
// matched file so add
fileList.add(remote);
}
} else {
log.debug("Ignoring unsupported remote file type: " + file);
}
}
return true;
}
