/** * Renames the file denoted by this abstract pathname. * * <p>Whether or not this method can move a file from one filesystem to another is * platform-dependent. The return value should always be checked to make sure that the rename * operation was successful. * * @param dest The new abstract pathname for the named file * @throws IllegalArgumentException If parameter <code>dest</code> is not a <code>GeneralFile * </code>. * @throws NullPointerException - If dest is null */ public boolean renameTo(GeneralFile dest) throws IllegalArgumentException, NullPointerException { try { if (dest instanceof FTPFile) { if (ftpClient.equals(((FTPFile) dest).ftpClient)) { ftpClient.rename(getPath(), dest.getPath()); } else { // TODO some ftp to ftp copy... if (!dest.exists()) { copyTo(dest); delete(); } else return false; } } else { if (!dest.exists()) { copyTo(dest); delete(); } else return false; } } catch (IOException e) { return false; } catch (FTPException e) { return false; } return true; }
/** * Deletes the file or directory denoted by this abstract pathname. If this pathname denotes a * directory, then the directory must be empty in order to be deleted. */ public boolean delete() { try { if (isDirectory()) { ftpClient.deleteDir(getPath()); } else { ftpClient.deleteFile(getPath()); } } catch (IOException e) { return false; } catch (FTPException e) { return false; } return true; }
@Override public void connect() { LOGGER.info("Connecting to " + username() + "@" + host() + ":" + String.valueOf(port())); reconnect = true; try { ftpClient.connect(host(), port()); } catch (IOException e) { throw new VirtualFileException(e); } if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) { disconnect(); return; } login(); setFileType(FTP.BINARY_FILE_TYPE); }
/** * Returns the length of the file denoted by this abstract pathname. * * @return The length, in bytes, of the file denoted by this abstract pathname, or <code>0L</code> * if the file does not exist */ public long length() { try { return ftpClient.size(getPath()); } catch (IOException e) { return 0; } catch (FTPException e) { return 0; } }
/** Creates the directory named by this abstract pathname. */ public boolean mkdir() { try { ftpClient.makeDir(getPath()); return true; } catch (IOException e) { return false; } catch (FTPException e) { return false; } }
/** * Returns the time that the file denoted by this abstract pathname was last modified. * * @return A <code>long</code> value representing the time the file was last modified, measured in * system-dependent way. */ public long lastModified() { try { Date date = ftpClient.lastModified(getPath()); return date.getTime(); } catch (IOException e) { return 0; } catch (FTPException e) { return 0; } }
/** * Tests whether the file denoted by this abstract pathname exists. * * @return <code>true</code> if and only if the file denoted by this abstract pathname exists; * <code>false</code> otherwise */ public boolean exists() { try { ftpClient.exists(getPath()); } catch (IOException e) { return false; } catch (FTPException e) { return false; } return true; }
/** * Copies this file to another file. This object is the source file. The destination file is given * as the argument. If the destination file, does not exist a new one will be created. Otherwise * the source file will be appended to the destination file. Directories will be copied * recursively. * * @param file The file to receive the data. * @throws NullPointerException If file is null. * @throws IOException If an IOException occurs. */ public void copyTo(GeneralFile file, boolean forceOverwrite) throws IOException { if (file == null) { throw new NullPointerException(); } if (isDirectory()) { // recursive copy GeneralFile[] fileList = listFiles(); file.mkdir(); if (fileList != null) { for (int i = 0; i < fileList.length; i++) { fileList[i].copyTo( FileFactory.newFile( file.getFileSystem(), file.getAbsolutePath(), fileList[i].getName()), forceOverwrite); } } } else { if (file.isDirectory()) { // change the destination from a directory to a file file = FileFactory.newFile(file, getName()); } try { if (file instanceof LocalFile) { ftpClient.get(getPath(), ((LocalFile) file).getFile()); } else if (file instanceof FTPFile) { ftpClient.transfer( getPath(), ((FTPFile) file).getFTPClient(), file.getPath(), !forceOverwrite, null); } else { super.copyTo(file); } } catch (FTPException e) { IOException io = new IOException(); io.initCause(e); throw io; } } }
/** * Copies this file to another file. This object is the source file. The destination file is given * as the argument. If the destination file, does not exist a new one will be created. Otherwise * the source file will be appended to the destination file. Directories will be copied * recursively. * * @param file The file to receive the data. * @throws NullPointerException If file is null. * @throws IOException If an IOException occurs. */ public void copyFrom(GeneralFile file, boolean forceOverwrite) throws IOException { if (file == null) { throw new NullPointerException(); } if (file.isDirectory()) { // recursive copy GeneralFile[] fileList = file.listFiles(); mkdir(); if (fileList != null) { for (int i = 0; i < fileList.length; i++) { FileFactory.newFile(this, fileList[i].getName()).copyFrom(fileList[i], forceOverwrite); } } } else { if (isDirectory()) { // change the destination from a directory to a file GeneralFile subFile = FileFactory.newFile(this, file.getName()); subFile.copyFrom(file); return; } try { if (file instanceof LocalFile) { ftpClient.put(((LocalFile) file).getFile(), getPath(), !forceOverwrite); } else if (file instanceof FTPFile) { ftpClient.transfer(file.getPath(), ftpClient, getPath(), !forceOverwrite, null); } else { super.copyTo(file); } } catch (FTPException e) { IOException io = new IOException(); io.initCause(e); throw io; } } }
/** * Returns an array of strings naming the files and directories in the directory denoted by this * abstract pathname. * * <p>There is no guarantee that the name strings in the resulting array will appear in any * specific order; they are not, in particular, guaranteed to appear in alphabetical order. * * <p>If this GeneralFile object denotes a file, the results are unspecified. * * @return An array of strings naming the files and directories in the directory denoted by this * abstract pathname. */ public String[] list() { try { // TODO which list? Vector list = ftpClient.list(getPath()); Object[] listO = list.toArray(); String[] listS = new String[listO.length]; for (int i = 0; i < listO.length; i++) { listS[i] = listO[i].toString(); } return listS; } catch (IOException e) { return null; } catch (FTPException e) { return null; } }
private void init() { LOGGER.debug("init"); ftpClient = new FTPClient(); ftpClient.setControlEncoding("UTF-8"); }
private void checkConnection() { if (!ftpClient.isConnected()) connect(); }