| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.maven.wagon.providers.ftp; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.util.ArrayList; |
| import java.util.Calendar; |
| import java.util.List; |
| |
| import org.apache.commons.io.IOUtils; |
| import org.apache.commons.net.ProtocolCommandEvent; |
| import org.apache.commons.net.ProtocolCommandListener; |
| import org.apache.commons.net.ftp.FTP; |
| import org.apache.commons.net.ftp.FTPClient; |
| import org.apache.commons.net.ftp.FTPFile; |
| import org.apache.commons.net.ftp.FTPReply; |
| import org.apache.maven.wagon.ConnectionException; |
| import org.apache.maven.wagon.InputData; |
| import org.apache.maven.wagon.OutputData; |
| import org.apache.maven.wagon.PathUtils; |
| import org.apache.maven.wagon.ResourceDoesNotExistException; |
| import org.apache.maven.wagon.StreamWagon; |
| import org.apache.maven.wagon.TransferFailedException; |
| import org.apache.maven.wagon.WagonConstants; |
| import org.apache.maven.wagon.authentication.AuthenticationException; |
| import org.apache.maven.wagon.authentication.AuthenticationInfo; |
| import org.apache.maven.wagon.authorization.AuthorizationException; |
| import org.apache.maven.wagon.repository.RepositoryPermissions; |
| import org.apache.maven.wagon.resource.Resource; |
| |
| /** |
| * FtpWagon |
| * |
| * |
| * @plexus.component role="org.apache.maven.wagon.Wagon" |
| * role-hint="ftp" |
| * instantiation-strategy="per-lookup" |
| */ |
| public class FtpWagon extends StreamWagon { |
| private FTPClient ftp; |
| |
| /** |
| * @plexus.configuration default-value="true" |
| */ |
| private boolean passiveMode = true; |
| |
| /** |
| * @plexus.configuration default-value="ISO-8859-1" |
| */ |
| private String controlEncoding = FTP.DEFAULT_CONTROL_ENCODING; |
| |
| public boolean isPassiveMode() { |
| return passiveMode; |
| } |
| |
| public void setPassiveMode(boolean passiveMode) { |
| this.passiveMode = passiveMode; |
| } |
| |
| @Override |
| protected void openConnectionInternal() throws ConnectionException, AuthenticationException { |
| AuthenticationInfo authInfo = getAuthenticationInfo(); |
| |
| if (authInfo == null) { |
| throw new NullPointerException("authenticationInfo cannot be null"); |
| } |
| |
| if (authInfo.getUserName() == null) { |
| authInfo.setUserName(System.getProperty("user.name")); |
| } |
| |
| String username = authInfo.getUserName(); |
| |
| String password = authInfo.getPassword(); |
| |
| if (username == null) { |
| throw new AuthenticationException( |
| "Username not specified for repository " + getRepository().getId()); |
| } |
| if (password == null) { |
| throw new AuthenticationException( |
| "Password not specified for repository " + getRepository().getId()); |
| } |
| |
| String host = getRepository().getHost(); |
| |
| ftp = createClient(); |
| ftp.setDefaultTimeout(getTimeout()); |
| ftp.setDataTimeout(getTimeout()); |
| ftp.setControlEncoding(getControlEncoding()); |
| |
| ftp.addProtocolCommandListener(new PrintCommandListener(this)); |
| |
| try { |
| if (getRepository().getPort() != WagonConstants.UNKNOWN_PORT) { |
| ftp.connect(host, getRepository().getPort()); |
| } else { |
| ftp.connect(host); |
| } |
| |
| // After connection attempt, you should check the reply code to |
| // verify |
| // success. |
| int reply = ftp.getReplyCode(); |
| |
| if (!FTPReply.isPositiveCompletion(reply)) { |
| ftp.disconnect(); |
| |
| throw new AuthenticationException("FTP server refused connection."); |
| } |
| } catch (IOException e) { |
| if (ftp.isConnected()) { |
| try { |
| fireSessionError(e); |
| |
| ftp.disconnect(); |
| } catch (IOException f) { |
| // do nothing |
| } |
| } |
| |
| throw new AuthenticationException("Could not connect to server.", e); |
| } |
| |
| try { |
| if (!ftp.login(username, password)) { |
| throw new AuthenticationException("Cannot login to remote system"); |
| } |
| |
| fireSessionDebug("Remote system is " + ftp.getSystemName()); |
| |
| // Set to binary mode. |
| ftp.setFileType(FTP.BINARY_FILE_TYPE); |
| ftp.setListHiddenFiles(true); |
| |
| // Use passive mode as default because most of us are |
| // behind firewalls these days. |
| if (isPassiveMode()) { |
| ftp.enterLocalPassiveMode(); |
| } |
| } catch (IOException e) { |
| throw new ConnectionException("Cannot login to remote system", e); |
| } |
| } |
| |
| protected FTPClient createClient() { |
| return new FTPClient(); |
| } |
| |
| @Override |
| protected void firePutCompleted(Resource resource, File file) { |
| try { |
| // TODO [BP]: verify the order is correct |
| ftp.completePendingCommand(); |
| |
| RepositoryPermissions permissions = repository.getPermissions(); |
| |
| if (permissions != null && permissions.getGroup() != null) { |
| // ignore failures |
| ftp.sendSiteCommand("CHGRP " + permissions.getGroup() + " " + resource.getName()); |
| } |
| |
| if (permissions != null && permissions.getFileMode() != null) { |
| // ignore failures |
| ftp.sendSiteCommand("CHMOD " + permissions.getFileMode() + " " + resource.getName()); |
| } |
| } catch (IOException e) { |
| // TODO: handle |
| // michal I am not sure what error means in that context |
| // I think that we will be able to recover or simply we will fail later on |
| } |
| |
| super.firePutCompleted(resource, file); |
| } |
| |
| @Override |
| protected void fireGetCompleted(Resource resource, File localFile) { |
| try { |
| ftp.completePendingCommand(); |
| } catch (IOException e) { |
| // TODO: handle |
| // michal I am not sure what error means in that context |
| // actually I am not even sure why we have to invoke that command |
| // I think that we will be able to recover or simply we will fail later on |
| } |
| super.fireGetCompleted(resource, localFile); |
| } |
| |
| @Override |
| public void closeConnection() throws ConnectionException { |
| if (ftp != null && ftp.isConnected()) { |
| try { |
| // This is a NPE rethink shutting down the streams |
| ftp.disconnect(); |
| } catch (IOException e) { |
| throw new ConnectionException("Failed to close connection to FTP repository", e); |
| } |
| } |
| } |
| |
| @Override |
| public void fillOutputData(OutputData outputData) throws TransferFailedException { |
| OutputStream os; |
| |
| Resource resource = outputData.getResource(); |
| |
| RepositoryPermissions permissions = repository.getPermissions(); |
| |
| try { |
| if (!ftp.changeWorkingDirectory(getRepository().getBasedir())) { |
| throw new TransferFailedException( |
| "Required directory: '" + getRepository().getBasedir() + "' " + "is missing"); |
| } |
| |
| String[] dirs = PathUtils.dirnames(resource.getName()); |
| |
| for (String dir : dirs) { |
| boolean dirChanged = ftp.changeWorkingDirectory(dir); |
| |
| if (!dirChanged) { |
| // first, try to create it |
| boolean success = ftp.makeDirectory(dir); |
| |
| if (success) { |
| if (permissions != null && permissions.getGroup() != null) { |
| // ignore failures |
| ftp.sendSiteCommand("CHGRP " + permissions.getGroup() + " " + dir); |
| } |
| |
| if (permissions != null && permissions.getDirectoryMode() != null) { |
| // ignore failures |
| ftp.sendSiteCommand("CHMOD " + permissions.getDirectoryMode() + " " + dir); |
| } |
| |
| dirChanged = ftp.changeWorkingDirectory(dir); |
| } |
| } |
| |
| if (!dirChanged) { |
| throw new TransferFailedException("Unable to create directory " + dir); |
| } |
| } |
| |
| // we come back to original basedir so |
| // FTP wagon is ready for next requests |
| if (!ftp.changeWorkingDirectory(getRepository().getBasedir())) { |
| throw new TransferFailedException("Unable to return to the base directory"); |
| } |
| |
| os = ftp.storeFileStream(resource.getName()); |
| |
| if (os == null) { |
| String msg = "Cannot transfer resource: '" + resource |
| + "'. Output stream is null. FTP Server response: " + ftp.getReplyString(); |
| |
| throw new TransferFailedException(msg); |
| } |
| |
| fireTransferDebug("resource = " + resource); |
| |
| } catch (IOException e) { |
| throw new TransferFailedException("Error transferring over FTP", e); |
| } |
| |
| outputData.setOutputStream(os); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // |
| // ---------------------------------------------------------------------- |
| |
| @Override |
| public void fillInputData(InputData inputData) throws TransferFailedException, ResourceDoesNotExistException { |
| InputStream is; |
| |
| Resource resource = inputData.getResource(); |
| |
| try { |
| ftpChangeDirectory(resource); |
| |
| String filename = PathUtils.filename(resource.getName()); |
| FTPFile[] ftpFiles = ftp.listFiles(filename); |
| |
| if (ftpFiles == null || ftpFiles.length <= 0) { |
| throw new ResourceDoesNotExistException("Could not find file: '" + resource + "'"); |
| } |
| |
| long contentLength = ftpFiles[0].getSize(); |
| |
| // @todo check how it works! javadoc of common login says: |
| // Returns the file timestamp. This usually the last modification time. |
| // |
| Calendar timestamp = ftpFiles[0].getTimestamp(); |
| long lastModified = timestamp != null ? timestamp.getTimeInMillis() : 0; |
| |
| resource.setContentLength(contentLength); |
| |
| resource.setLastModified(lastModified); |
| |
| is = ftp.retrieveFileStream(filename); |
| } catch (IOException e) { |
| throw new TransferFailedException("Error transferring file via FTP", e); |
| } |
| |
| inputData.setInputStream(is); |
| } |
| |
| private void ftpChangeDirectory(Resource resource) |
| throws IOException, TransferFailedException, ResourceDoesNotExistException { |
| if (!ftp.changeWorkingDirectory(getRepository().getBasedir())) { |
| throw new ResourceDoesNotExistException( |
| "Required directory: '" + getRepository().getBasedir() + "' " + "is missing"); |
| } |
| |
| String[] dirs = PathUtils.dirnames(resource.getName()); |
| |
| for (String dir : dirs) { |
| boolean dirChanged = ftp.changeWorkingDirectory(dir); |
| |
| if (!dirChanged) { |
| String msg = "Resource " + resource + " not found. Directory " + dir + " does not exist"; |
| |
| throw new ResourceDoesNotExistException(msg); |
| } |
| } |
| } |
| |
| /** |
| * |
| */ |
| public class PrintCommandListener implements ProtocolCommandListener { |
| private FtpWagon wagon; |
| |
| public PrintCommandListener(FtpWagon wagon) { |
| this.wagon = wagon; |
| } |
| |
| @Override |
| public void protocolCommandSent(ProtocolCommandEvent event) { |
| wagon.fireSessionDebug("Command sent: " + event.getMessage()); |
| } |
| |
| @Override |
| public void protocolReplyReceived(ProtocolCommandEvent event) { |
| wagon.fireSessionDebug("Reply received: " + event.getMessage()); |
| } |
| } |
| |
| @Override |
| protected void fireSessionDebug(String msg) { |
| super.fireSessionDebug(msg); |
| } |
| |
| @Override |
| public List<String> getFileList(String destinationDirectory) |
| throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException { |
| Resource resource = new Resource(destinationDirectory); |
| |
| try { |
| ftpChangeDirectory(resource); |
| |
| String filename = PathUtils.filename(resource.getName()); |
| FTPFile[] ftpFiles = ftp.listFiles(filename); |
| |
| if (ftpFiles == null || ftpFiles.length <= 0) { |
| throw new ResourceDoesNotExistException("Could not find file: '" + resource + "'"); |
| } |
| |
| List<String> ret = new ArrayList<>(); |
| for (FTPFile file : ftpFiles) { |
| String name = file.getName(); |
| |
| if (file.isDirectory() && !name.endsWith("/")) { |
| name += "/"; |
| } |
| |
| ret.add(name); |
| } |
| |
| return ret; |
| } catch (IOException e) { |
| throw new TransferFailedException("Error transferring file via FTP", e); |
| } |
| } |
| |
| @Override |
| public boolean resourceExists(String resourceName) throws TransferFailedException, AuthorizationException { |
| Resource resource = new Resource(resourceName); |
| |
| try { |
| ftpChangeDirectory(resource); |
| |
| String filename = PathUtils.filename(resource.getName()); |
| int status = ftp.stat(filename); |
| |
| return ((status == FTPReply.FILE_STATUS) |
| || (status == FTPReply.DIRECTORY_STATUS) |
| || (status == FTPReply.FILE_STATUS_OK) // not in the RFC but used by some FTP servers |
| || (status == FTPReply.COMMAND_OK) // not in the RFC but used by some FTP servers |
| || (status == FTPReply.SYSTEM_STATUS)); |
| } catch (IOException e) { |
| throw new TransferFailedException("Error transferring file via FTP", e); |
| } catch (ResourceDoesNotExistException e) { |
| return false; |
| } |
| } |
| |
| @Override |
| public boolean supportsDirectoryCopy() { |
| return true; |
| } |
| |
| @Override |
| public void putDirectory(File sourceDirectory, String destinationDirectory) |
| throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException { |
| |
| // Change to root. |
| try { |
| if (!ftp.changeWorkingDirectory(getRepository().getBasedir())) { |
| RepositoryPermissions permissions = getRepository().getPermissions(); |
| if (!makeFtpDirectoryRecursive(getRepository().getBasedir(), permissions)) { |
| throw new TransferFailedException( |
| "Required directory: '" + getRepository().getBasedir() + "' " + "could not get created"); |
| } |
| |
| // try it again sam ... |
| if (!ftp.changeWorkingDirectory(getRepository().getBasedir())) { |
| throw new TransferFailedException("Required directory: '" |
| + getRepository().getBasedir() + "' " + "is missing and could not get created"); |
| } |
| } |
| } catch (IOException e) { |
| throw new TransferFailedException( |
| "Cannot change to root path " + getRepository().getBasedir(), e); |
| } |
| |
| fireTransferDebug( |
| "Recursively uploading directory " + sourceDirectory.getAbsolutePath() + " as " + destinationDirectory); |
| ftpRecursivePut(sourceDirectory, destinationDirectory); |
| } |
| |
| private void ftpRecursivePut(File sourceFile, String fileName) throws TransferFailedException { |
| final RepositoryPermissions permissions = repository.getPermissions(); |
| |
| fireTransferDebug("processing = " + sourceFile.getAbsolutePath() + " as " + fileName); |
| |
| if (sourceFile.isDirectory()) { |
| if (!fileName.equals(".")) { |
| try { |
| // change directory if it already exists. |
| if (!ftp.changeWorkingDirectory(fileName)) { |
| // first, try to create it |
| if (makeFtpDirectoryRecursive(fileName, permissions)) { |
| if (!ftp.changeWorkingDirectory(fileName)) { |
| throw new TransferFailedException("Unable to change cwd on ftp server to " + fileName |
| + " when processing " + sourceFile.getAbsolutePath()); |
| } |
| } else { |
| throw new TransferFailedException("Unable to create directory " + fileName |
| + " when processing " + sourceFile.getAbsolutePath()); |
| } |
| } |
| } catch (IOException e) { |
| throw new TransferFailedException( |
| "IOException caught while processing path at " + sourceFile.getAbsolutePath(), e); |
| } |
| } |
| |
| File[] files = sourceFile.listFiles(); |
| if (files != null && files.length > 0) { |
| fireTransferDebug("listing children of = " + sourceFile.getAbsolutePath() + " found " + files.length); |
| |
| // Directories first, then files. Let's go deep early. |
| for (File file : files) { |
| if (file.isDirectory()) { |
| ftpRecursivePut(file, file.getName()); |
| } |
| } |
| for (File file : files) { |
| if (!file.isDirectory()) { |
| ftpRecursivePut(file, file.getName()); |
| } |
| } |
| } |
| |
| // Step back up a directory once we're done with the contents of this one. |
| try { |
| ftp.changeToParentDirectory(); |
| } catch (IOException e) { |
| throw new TransferFailedException( |
| "IOException caught while attempting to step up to parent directory" |
| + " after successfully processing " |
| + sourceFile.getAbsolutePath(), |
| e); |
| } |
| } else { |
| // Oh how I hope and pray, in denial, but today I am still just a file. |
| |
| FileInputStream sourceFileStream = null; |
| try { |
| sourceFileStream = new FileInputStream(sourceFile); |
| |
| // It's a file. Upload it in the current directory. |
| if (ftp.storeFile(fileName, sourceFileStream)) { |
| if (permissions != null) { |
| // Process permissions; note that if we get errors or exceptions here, they are ignored. |
| // This appears to be a conscious decision, based on other parts of this code. |
| String group = permissions.getGroup(); |
| if (group != null) { |
| try { |
| ftp.sendSiteCommand("CHGRP " + permissions.getGroup()); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| String mode = permissions.getFileMode(); |
| if (mode != null) { |
| try { |
| ftp.sendSiteCommand("CHMOD " + permissions.getDirectoryMode()); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| } else { |
| String msg = "Cannot transfer resource: '" + sourceFile.getAbsolutePath() |
| + "' FTP Server response: " + ftp.getReplyString(); |
| throw new TransferFailedException(msg); |
| } |
| |
| sourceFileStream.close(); |
| sourceFileStream = null; |
| } catch (IOException e) { |
| throw new TransferFailedException( |
| "IOException caught while attempting to upload " + sourceFile.getAbsolutePath(), e); |
| } finally { |
| IOUtils.closeQuietly(sourceFileStream); |
| } |
| } |
| |
| fireTransferDebug("completed = " + sourceFile.getAbsolutePath()); |
| } |
| |
| /** |
| * Set the permissions (if given) for the underlying folder. |
| * Note: Since the FTP SITE command might be server dependent, we cannot |
| * rely on the functionality available on each FTP server! |
| * So we can only try and hope it works (and catch away all Exceptions). |
| * |
| * @param permissions group and directory permissions |
| */ |
| private void setPermissions(RepositoryPermissions permissions) { |
| if (permissions != null) { |
| // Process permissions; note that if we get errors or exceptions here, they are ignored. |
| // This appears to be a conscious decision, based on other parts of this code. |
| String group = permissions.getGroup(); |
| if (group != null) { |
| try { |
| ftp.sendSiteCommand("CHGRP " + permissions.getGroup()); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| String mode = permissions.getDirectoryMode(); |
| if (mode != null) { |
| try { |
| ftp.sendSiteCommand("CHMOD " + permissions.getDirectoryMode()); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| } |
| |
| /** |
| * Recursively create directories. |
| * |
| * @param fileName the path to create (might be nested) |
| * @param permissions |
| * @return ok |
| * @throws IOException |
| */ |
| private boolean makeFtpDirectoryRecursive(String fileName, RepositoryPermissions permissions) throws IOException { |
| if (fileName == null |
| || fileName.length() == 0 |
| || fileName.replace('/', '_').trim().length() == 0) // if a string is '/', '//' or similar |
| { |
| return false; |
| } |
| |
| int slashPos = fileName.indexOf("/"); |
| String oldPwd = null; |
| boolean ok = true; |
| |
| if (slashPos == 0) { |
| // this is an absolute directory |
| oldPwd = ftp.printWorkingDirectory(); |
| |
| // start with the root |
| ftp.changeWorkingDirectory("/"); |
| fileName = fileName.substring(1); |
| |
| // look up the next path separator |
| slashPos = fileName.indexOf("/"); |
| } |
| |
| if (slashPos >= 0 && slashPos < (fileName.length() - 1)) // not only a slash at the end, like in 'newDir/' |
| { |
| if (oldPwd == null) { |
| oldPwd = ftp.printWorkingDirectory(); |
| } |
| |
| String nextDir = fileName.substring(0, slashPos); |
| |
| boolean changedDir = false; |
| // we only create the nextDir if it doesn't yet exist |
| if (!ftp.changeWorkingDirectory(nextDir)) { |
| ok &= ftp.makeDirectory(nextDir); |
| } else { |
| changedDir = true; |
| } |
| |
| if (ok) { |
| // set the permissions for the freshly created directory |
| setPermissions(permissions); |
| |
| if (!changedDir) { |
| ftp.changeWorkingDirectory(nextDir); |
| } |
| |
| // now create the deeper directories |
| final String remainingDirs = fileName.substring(slashPos + 1); |
| ok &= makeFtpDirectoryRecursive(remainingDirs, permissions); |
| } |
| } else { |
| ok = ftp.makeDirectory(fileName); |
| } |
| |
| if (oldPwd != null) { |
| // change back to the old working directory |
| ftp.changeWorkingDirectory(oldPwd); |
| } |
| |
| return ok; |
| } |
| |
| public String getControlEncoding() { |
| return controlEncoding; |
| } |
| |
| public void setControlEncoding(String controlEncoding) { |
| this.controlEncoding = controlEncoding; |
| } |
| } |