/** * 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 Object makeObject() throws Exception { FTPClient client = new FTPClient(); try { if (uri.getPort() > 0) { client.connect(uri.getHost(), uri.getPort()); } else { client.connect(uri.getHost()); } if (!FTPReply.isPositiveCompletion(client.getReplyCode())) { throw new IOException("Ftp error: " + client.getReplyCode()); } if (!client.login(uri.getUsername(), uri.getPassword())) { throw new IOException("Ftp error: " + client.getReplyCode()); } if (!client.setFileType(FTP.BINARY_FILE_TYPE)) { throw new IOException("Ftp error. Couldn't set BINARY transfer type."); } } catch (Exception e) { if (client.isConnected()) { client.disconnect(); } throw e; } return client; }
/** * Opens a new connection and performs login with user name and password if set. * * @throws IOException */ protected void connectAndLogin() throws IOException { if (!ftpClient.isConnected()) { ftpClient.connect(getEndpointConfiguration().getHost(), getEndpointConfiguration().getPort()); log.info("Connected to FTP server: " + ftpClient.getReplyString()); int reply = ftpClient.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { throw new CitrusRuntimeException("FTP server refused connection."); } log.info("Successfully opened connection to FTP server"); if (getEndpointConfiguration().getUser() != null) { log.info(String.format("Login as user: '******'", getEndpointConfiguration().getUser())); boolean login = ftpClient.login( getEndpointConfiguration().getUser(), getEndpointConfiguration().getPassword()); if (!login) { throw new CitrusRuntimeException( String.format( "Failed to login to FTP server using credentials: %s:%s", getEndpointConfiguration().getUser(), getEndpointConfiguration().getPassword())); } } } }
public static FTPClient getFTPClient() { FTPClient client = ftpClientThreadLocal.get(); if (client != null && client.isConnected()) { return client; } ftpClientThreadLocal.remove(); FTPClient ftpClient = new FTPClient(); // 创建ftpClient ftpClient.setControlEncoding("UTF-8"); // 设置字符编码 Boolean isConnect = connectFtp(ftpClient); ftpClient.enterLocalPassiveMode(); try { ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE); ftpClient.setSoTimeout(1000 * 30); } catch (Exception e) { e.printStackTrace(); } // 得到返回答复码 int reply = ftpClient.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { try { ftpClient.disconnect(); } catch (IOException e) { e.printStackTrace(); } } else { ftpClientThreadLocal.set(ftpClient); } return ftpClient; }
/** * @param path ex:/upload/2023 * @param filename xxx.jpg * @param input 输入流 * @return */ public static boolean uploadFile(String path, String filename, InputStream input) { boolean success = false; FTPClient ftpClient = null; try { ftpClient = getFTPClient(); int reply = ftpClient.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { return success; } // 使用二进制上传 ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE); ftpClient.setFileTransferMode(FTP.BINARY_FILE_TYPE); ftpClient.enterLocalPassiveMode(); ftpCreateDirectoryTree(ftpClient, path); success = ftpClient.storeFile(filename, input); input.close(); ftpClient.logout(); } catch (IOException e) { e.printStackTrace(); } finally { if (null != ftpClient && ftpClient.isConnected()) { try { ftpClient.disconnect(); } catch (IOException ioe) { } } } return success; }
/** * Function retrieved file on the remote server NOTE: This function closes output stream after * retrieving file content * * @param fileName * @param fileOutput * @return * @throws SocketException * @throws IOException */ public boolean retrieveFile(String fileName, OutputStream fileOutput) throws SocketException, IOException { boolean fileRetrieved = false; connect2Server(); if (oFtp.isConnected()) { try { fileRetrieved = oFtp.retrieveFile(fileName, fileOutput); if (fileRetrieved) { logMessage("File '" + fileName + "' retrieved"); } else { logError( "Can't retrieve file " + fileName + " FTP reply code: " + oFtp.getReplyCode() + " Ftp message: " + oFtp.getReplyString()); } fileOutput.close(); } catch (IOException ioe) { log.warning("FTPUtil - retrieveFile(): " + ioe.toString()); return false; } } this.closeFtpConnection(); return fileRetrieved; }
/** * Description: 向FTP服务器上传文件 * * @param host FTP服务器hostname * @param port FTP服务器端口 * @param username FTP登录账号 * @param password FTP登录密码 * @param basePath FTP服务器基础目录 * @param filePath FTP服务器文件存放路径。例如分日期存放:/2015/01/01。文件的路径为basePath+filePath * @param filename 上传到FTP服务器上的文件名 * @param input 输入流 * @return 成功返回true,否则返回false */ public static boolean uploadFile( String host, int port, String username, String password, String basePath, String filePath, String filename, InputStream input) { boolean result = false; FTPClient ftp = new FTPClient(); try { int reply; ftp.connect(host, port); // 连接FTP服务器 // 如果采用默认端口,可以使用ftp.connect(host)的方式直接连接FTP服务器 ftp.login(username, password); // 登录 reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { ftp.disconnect(); return result; } // 切换到上传目录 if (!ftp.changeWorkingDirectory(basePath + filePath)) { // 如果目录不存在创建目录 String[] dirs = filePath.split("/"); String tempPath = basePath; for (String dir : dirs) { if (null == dir || "".equals(dir)) continue; tempPath += "/" + dir; if (!ftp.changeWorkingDirectory(tempPath)) { if (!ftp.makeDirectory(tempPath)) { return result; } else { ftp.changeWorkingDirectory(tempPath); } } } } // 设置上传文件的类型为二进制类型 ftp.setFileType(FTP.BINARY_FILE_TYPE); // 上传文件 if (!ftp.storeFile(filename, input)) { return result; } input.close(); ftp.logout(); result = true; } catch (IOException e) { e.printStackTrace(); } finally { if (ftp.isConnected()) { try { ftp.disconnect(); } catch (IOException ioe) { } } } return result; }
private synchronized void closeFtpConnection() throws IOException { if (oFtp.isConnected()) { try { oFtp.logout(); } catch (org.apache.commons.net.ftp.FTPConnectionClosedException e) { } } oFtp.disconnect(); }
public void releaseFtp(UMOEndpointURI uri, FTPClient client) throws Exception { if (isCreateDispatcherPerRequest()) { destroyFtp(uri, client); } else { if (client != null && client.isConnected()) { ObjectPool pool = getFtpPool(uri); pool.returnObject(client); } } }
/** 서버와의 연결을 끊는다. */ public void disconnection() { try { client.logout(); if (client.isConnected()) { client.disconnect(); } } catch (IOException e) { e.printStackTrace(); } }
@Override public void upload(UploadRequest uploadRequest) { ServerInfo serverInfo = uploadRequest.getServerInfo(); String host = serverInfo.getHost(); if (uploadRequest.isUseProxy()) { initializeProxy(host); } int attemptCount = 0; while (true) { try { login(serverInfo.getHost(), serverInfo.getLogin(), serverInfo.getPassword()); try { ftpClient.setSoTimeout(DEFAULT_SOCKET_TIMEOUT); } catch (SocketException e) { LOGGER.error("socket exception: {} {}", e.getMessage(), e.getStackTrace()); throw new RuntimeException("socket exception: " + e.getMessage()); } String prefixDirectory = serverInfo.getPrefix(); if (prefixDirectory != null) { ftpClient.changeWorkingDirectory(prefixDirectory); } File directory = new File(uploadRequest.getUploadDir()); uploadDir(directory); ftpClient.logout(); break; } catch (IOException e) { LOGGER.error("i/o error: {}, retrying", e.getMessage()); attemptCount++; if (attemptCount > 5) { LOGGER.debug("choosing another proxy after 5 attempts"); initializeProxy(host); attemptCount = 0; } } finally { if (ftpClient.isConnected()) { try { ftpClient.disconnect(); } catch (IOException ioe) { // do nothing } } } } }
/** * Logout and disconnect the given FTPClient. * * * @param client * @throws IOException */ private void disconnect(FTPClient client) throws IOException { if (client != null) { if (!client.isConnected()) { throw new FTPException("Client not connected"); } boolean logoutSuccess = client.logout(); client.disconnect(); if (!logoutSuccess) { LOG.warn("Logout failed while disconnecting, error code - " + client.getReplyCode()); } } }
public boolean test() { int base = 0; boolean error = false; FTPFile[] ftpFiles; testMsg = null; try { int reply; ftpClient.connect(ftpVO.getServer(), ftpVO.getPortasInteger()); // Check connection reply = ftpClient.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { ftpClient.disconnect(); testMsg = Resource.getString("ftpchooser.msg.noconnect"); return false; } // Login if (!ftpClient.login(ftpVO.getUser(), ftpVO.getPassword())) { ftpClient.logout(); testMsg = Resource.getString("ftpchooser.msg.nologin"); return false; } ftpClient.syst(); // Change directory if (!ftpClient.changeWorkingDirectory(ftpVO.getDirectory())) { testMsg = Resource.getString("ftpchooser.msg.nodirectory"); return false; } testMsg = Resource.getString("ftpchooser.msg.success"); ftpClient.logout(); } catch (IOException ex) { testMsg = ex.getLocalizedMessage(); error = true; } finally { if (ftpClient.isConnected()) { try { ftpClient.disconnect(); } catch (IOException f) { } } } return !error; }
@Override public void destroy() throws Exception { if (ftpClient.isConnected()) { ftpClient.logout(); try { ftpClient.disconnect(); } catch (IOException e) { log.warn("Failed to disconnect from FTP server", e); } log.info("Successfully closed connection to FTP server"); } }
/** * @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; }
/** Disconnects. */ private void disconnectOnFailure() { try { if (ftp.isConnected()) { ftp.disconnect(); } } catch (IOException e) { /* * This exception is not re thrown, because * this method is used only by exception handling * blocks. */ logger.error(e.toString()); } finally { ftp = null; } }
public boolean open() { boolean isSuccessful = false; if (isOpen) { throw new IllegalStateException("Is already open, must be closed before!"); } try { int reply; ftpClient.connect(ftpVO.getServer(), ftpVO.getPortasInteger()); reply = ftpClient.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { ftpClient.disconnect(); throw new IOException("Can't connect!"); } if (!ftpClient.login(ftpVO.getUser(), ftpVO.getPassword())) { ftpClient.logout(); throw new IOException("Can't login!"); } if (!ftpClient.changeWorkingDirectory(ftpVO.getDirectory())) { ftpClient.logout(); throw new IOException("Can't change directory!"); } ftpClient.setFileType(FTP.BINARY_FILE_TYPE); ftpClient.enterLocalPassiveMode(); isSuccessful = true; } catch (Exception e) { if (ftpClient.isConnected()) { try { ftpClient.disconnect(); } catch (IOException f) { // do nothing } } isSuccessful = false; } isOpen = isSuccessful; return isSuccessful; }
/** * 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; }
private static void sendMockFTPScannedImg() throws IOException { log.info(String.format("ftp is connected at %s: %s", ftpClient.isConnected(), "IP_FTP_CLIENT")); String filename = dateFormat.format(new Date()).replace(' ', '_').replace(':', '_'); String remote = String.format("%s/%s.jpg", CLIENT_IMG_DIR, filename); BufferedInputStream bis = null; try { bis = new BufferedInputStream(new FileInputStream("test.jpg")); ftpClient.storeFile(remote, bis); log.info(String.format("Sending file as %s", remote)); bis.close(); } catch (FileNotFoundException e) { log.info("couldn't find file"); } }
/** * Description: 从FTP服务器下载单个文件 * * @param url FTP服务器hostname * @param port FTP服务器端口 * @param username FTP登录账号 * @param password FTP登录密码 * @param remotePath FTP服务器上的相对路径+文件名 example:/imagename.jpg * @param localPath 下载后保存到本地的路径 * @param fileName 保存为该文件名的文件 * @return */ public static boolean downSingleFile( String url, int port, String username, String password, String remotePath, String localPath, String fileName) { boolean success = false; FTPClient ftp = null; FileOutputStream fos = null; try { int reply; ftp = getConnection(url, port, username, password); reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { ftp.disconnect(); return success; } boolean changeWorkDirState = false; fos = new FileOutputStream(localPath + "/" + fileName); ftp.setBufferSize(1024); // 设置文件类型(二进制) ftp.setFileType(FTPClient.BINARY_FILE_TYPE); ftp.retrieveFile(remotePath, fos); changeWorkDirState = ftp.changeWorkingDirectory(remotePath); // 转移到FTP服务器目录 ftp.logout(); success = true; } catch (IOException e) { e.printStackTrace(); } finally { if (ftp.isConnected()) { try { ftp.disconnect(); } catch (IOException ioe) { } } } return success; }
public static void main(String[] args) { String server = "192.168.1.72"; int port = 21; String user = "******"; String pass = "******"; FTPClient ftpClient = new FTPClient(); try { ftpClient.connect(server, port); ftpClient.login(user, pass); ftpClient.enterLocalPassiveMode(); ftpClient.setFileType(FTP.BINARY_FILE_TYPE); // APPROACH #1: uploads first file using an InputStream File firstLocalFile = new File("D:/Shridhar/FolderTest/ItmtuResponsestatus_2012_1_18_15"); String firstRemoteFile = "/home/ftp/"; InputStream inputStream = new FileInputStream(firstLocalFile); System.out.println("Start uploading first file"); boolean done = ftpClient.storeFile(firstRemoteFile, inputStream); inputStream.close(); if (done) { System.out.println("The first file is uploaded successfully."); } } catch (IOException ex) { System.out.println("Error: " + ex.getMessage()); ex.printStackTrace(); } finally { try { if (ftpClient.isConnected()) { // ftpClient.logout(); ftpClient.disconnect(); } } catch (IOException ex) { ex.printStackTrace(); } } }
/** * @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(); }
public static void append( String server, String username, String password, String remotePath, InputStream is) throws IOException { FTPClient mFtp = new FTPClient(); try { mFtp.connect(server, FTP.DEFAULT_PORT); mFtp.login(username, password); mFtp.setFileType(FTP.BINARY_FILE_TYPE); mFtp.enterLocalPassiveMode(); mFtp.appendFile(remotePath, is); } finally { try { if (mFtp.isConnected()) { mFtp.logout(); mFtp.disconnect(); } } catch (IOException ex) { ex.printStackTrace(); } } }
/** * @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; }
/** * Delete file from server * * @param filename * @param ftpFolder * @throws SocketException * @throws IOException */ public void removeFile(String filename, String ftpFolder) throws SocketException, IOException { connect2Server(); if (oFtp.isConnected()) { String file = ftpFolder + filename; if (this.isExists(filename, ftpFolder)) { if (!oFtp.deleteFile(file)) { logError( "Can't delete file '" + filename + "' from " + ftpFolder + " FTP reply code: " + oFtp.getReplyCode() + " Ftp message: " + Arrays.asList(oFtp.getReplyStrings())); } else { logMessage("File '" + file + "' removed from server"); } } } this.closeFtpConnection(); }
/** * Description: 向FTP服务器上传文件 * * @param url FTP服务器 * @param port FTP服务器端口 * @param username FTP登录账号 * @param password FTP登录密码 * @param path FTP服务器保存目录 * @param filename 上传到FTP服务器上的文件名 * @param input 输入流 * @return 成功返回true,否则返回false */ public static boolean uploadFile( String url, int port, String username, String password, String path, String filename, InputStream input) { 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; } ftp.changeWorkingDirectory(path); ftp.storeFile(filename, input); input.close(); ftp.logout(); success = true; } catch (IOException e) { e.printStackTrace(); } finally { if (ftp.isConnected()) { try { ftp.disconnect(); } catch (IOException ioe) { } } } return success; }
/** * The method that handles file uploading, this method takes the absolute file path of a local * file to be uploaded to the remote FTP server, and the remote file will then be transfered to * the FTP server and saved as the relative path name specified in method setRemoteFile * * @param localfilename – the local absolute file name of the file in local hard drive that needs * to FTP over */ public synchronized boolean uploadFile(String localfilename, String remoteFile) { final BufferedInputStream bis; try { // URL url = new URL(this.getRemoteFileUrl(remoteFile)); // URLConnection urlFtpConnection = url.openConnection(); InputStream is = new FileInputStream(localfilename); bis = new BufferedInputStream(is); connect2Server(); if (oFtp.isConnected()) { String fileExtension = localfilename.substring(localfilename.lastIndexOf(".") + 1); String[] fileExtensions = {"png", "gif", "bmp", "jpg", "jpeg", "tiff"}; // If exporting to .csv or .tsv, add the gid parameter to specify which sheet to export if (Arrays.asList(fileExtensions).contains(fileExtension)) { oFtp.setFileType(FTP.BINARY_FILE_TYPE); } // OutputStream os = oFtp.storeFileStream(remoteFile); // if (os == null) // { // logError(oFtp.getReplyString()); // } // BufferedOutputStream bos = new BufferedOutputStream(os); // byte[] buffer = new byte[1024]; // int readCount; // // while ((readCount = bis.read(buffer)) > 0) // { // bos.write(buffer); // // bos.flush(); // } // bos.close(); if (!oFtp.storeFile(remoteFile, bis)) { logError( "Can't upload file " + localfilename + " FTP reply code: " + oFtp.getReplyCode() + " Ftp message: " + oFtp.getReplyString()); bis.close(); is.close(); this.closeFtpConnection(); return false; } else { logMessage("File `" + localfilename + "` is uploaded!"); } } /* * urlFtpConnection.getOutputStream(); * // * log.message("File `" + localfilename + "` is uploaded!"); */ bis.close(); is.close(); // this.closeFtpConnection(); return true; } catch (Exception ex) { StringWriter sw0 = new StringWriter(); PrintWriter p0 = new PrintWriter(sw0, true); ex.printStackTrace(p0); log.error(sw0.getBuffer().toString()); log.exception(ex); return false; } }
public void destroyFtp(UMOEndpointURI uri, FTPClient client) throws Exception { if (client != null && client.isConnected()) { ObjectPool pool = getFtpPool(uri); pool.invalidateObject(client); } }
public static Map<String, Object> putFile(DispatchContext dctx, Map<String, ?> context) { Locale locale = (Locale) context.get("locale"); Debug.logInfo("[putFile] starting...", module); InputStream localFile = null; try { localFile = new FileInputStream((String) context.get("localFilename")); } catch (IOException ioe) { Debug.logError(ioe, "[putFile] Problem opening local file", module); return ServiceUtil.returnError( UtilProperties.getMessage(resource, "CommonFtpFileCannotBeOpen", locale)); } List<String> errorList = new LinkedList<String>(); FTPClient ftp = new FTPClient(); try { Integer defaultTimeout = (Integer) context.get("defaultTimeout"); if (UtilValidate.isNotEmpty(defaultTimeout)) { Debug.logInfo( "[putFile] set default timeout to: " + defaultTimeout.intValue() + " milliseconds", module); ftp.setDefaultTimeout(defaultTimeout.intValue()); } Debug.logInfo("[putFile] connecting to: " + (String) context.get("hostname"), module); ftp.connect((String) context.get("hostname")); if (!FTPReply.isPositiveCompletion(ftp.getReplyCode())) { Debug.logInfo("[putFile] Server refused connection", module); errorList.add(UtilProperties.getMessage(resource, "CommonFtpConnectionRefused", locale)); } else { String username = (String) context.get("username"); String password = (String) context.get("password"); Debug.logInfo( "[putFile] logging in: username="******", password="******"[putFile] login failed", module); errorList.add( UtilProperties.getMessage( resource, "CommonFtpLoginFailure", UtilMisc.toMap("username", username, "password", password), locale)); } else { Boolean binaryTransfer = (Boolean) context.get("binaryTransfer"); boolean binary = (binaryTransfer == null) ? false : binaryTransfer.booleanValue(); if (binary) { ftp.setFileType(FTP.BINARY_FILE_TYPE); } Boolean passiveMode = (Boolean) context.get("passiveMode"); boolean passive = (passiveMode == null) ? true : passiveMode.booleanValue(); if (passive) { ftp.enterLocalPassiveMode(); } Debug.logInfo( "[putFile] storing local file remotely as: " + context.get("remoteFilename"), module); if (!ftp.storeFile((String) context.get("remoteFilename"), localFile)) { Debug.logInfo("[putFile] store was unsuccessful", module); errorList.add( UtilProperties.getMessage( resource, "CommonFtpFileNotSentSuccesfully", UtilMisc.toMap("replyString", ftp.getReplyString()), locale)); } else { Debug.logInfo("[putFile] store was successful", module); List<String> siteCommands = checkList(context.get("siteCommands"), String.class); if (siteCommands != null) { for (String command : siteCommands) { Debug.logInfo("[putFile] sending SITE command: " + command, module); if (!ftp.sendSiteCommand(command)) { errorList.add( UtilProperties.getMessage( resource, "CommonFtpSiteCommandFailed", UtilMisc.toMap("command", command, "replyString", ftp.getReplyString()), locale)); } } } } } ftp.logout(); } } catch (IOException ioe) { Debug.logWarning(ioe, "[putFile] caught exception: " + ioe.getMessage(), module); errorList.add( UtilProperties.getMessage( resource, "CommonFtpProblemWithTransfer", UtilMisc.toMap("errorString", ioe.getMessage()), locale)); } finally { try { if (ftp.isConnected()) { ftp.disconnect(); } } catch (Exception e) { Debug.logWarning(e, "[putFile] Problem with FTP disconnect: ", module); } try { localFile.close(); } catch (Exception e) { Debug.logWarning(e, "[putFile] Problem closing local file: ", module); } } if (errorList.size() > 0) { Debug.logError( "[putFile] The following error(s) (" + errorList.size() + ") occurred: " + errorList, module); return ServiceUtil.returnError(errorList); } Debug.logInfo("[putFile] finished successfully", module); return ServiceUtil.returnSuccess(); }
@Override public Future<Set<File>> download(LayerRequest currentLayer) throws Exception { this.currentLayer = currentLayer; currentLayer.setMetadata(this.includesMetadata()); File directory = getDirectory(); Set<File> fileSet = new HashSet<File>(); List<String> urls = this.getUrls(currentLayer); for (String url : urls) { InputStream inputStream = null; URL currentURL = new URL(url); String ftpServerAddress = currentURL.getHost(); String currentPath = currentURL.getPath(); FTPClient ftp = new FTPClient(); int delimiterIndex = currentPath.lastIndexOf("/"); String remoteDirectory = currentPath.substring(0, delimiterIndex); String fileName = currentPath.substring(delimiterIndex + 1); try { int reply; ftp.connect(ftpServerAddress); // Although they are open FTP servers, in order to access the files, a anonymous login is // necessary. ftp.login("anonymous", "anonymous"); System.out.println("Connected to " + ftpServerAddress + "."); System.out.print(ftp.getReplyString()); // 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); } reply = ftp.getReplyCode(); // enter passive mode ftp.enterLocalPassiveMode(); // change current directory ftp.changeWorkingDirectory(remoteDirectory); // check if the file with given name exists in ftp server try { FTPFile[] ftpFiles = ftp.listFiles(fileName); if (ftpFiles != null && ftpFiles.length > 0) { for (FTPFile file : ftpFiles) { if (!file.isFile()) continue; System.out.println("Found file:" + file.getName()); // transfer the file inputStream = ftp.retrieveFileStream(file.getName()); // save the file and add to fileset // TODO: ftp file does not contain MIME type. File outputFile = OgpFileUtils.createNewFileFromDownload(fileName, "ZIP", directory); // FileUtils with a BufferedInputStream seems to be the fastest method with a small // sample size. requires more testing BufferedInputStream bufferedIn = null; try { bufferedIn = new BufferedInputStream(inputStream); FileUtils.copyInputStreamToFile(bufferedIn, outputFile); fileSet.add(outputFile); } finally { IOUtils.closeQuietly(bufferedIn); } } } } catch (IOException e) { e.printStackTrace(); } finally { ftp.logout(); } } catch (IOException e) { e.printStackTrace(); } finally { if (ftp.isConnected()) { try { ftp.disconnect(); } catch (IOException ioe) { // do nothing } } IOUtils.closeQuietly(inputStream); } } return new AsyncResult<Set<File>>(fileSet); };