Java tutorial
/* * Copyright (C) 2010 JFrog Ltd. * * Licensed 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.jfrog.build.extractor.clientConfiguration.util; import com.google.common.collect.HashMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import org.apache.commons.io.FilenameUtils; import org.apache.commons.lang.StringUtils; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.regex.Pattern; /** * Helper class for calculating published artifacts of a generic deployment. * * @author Noam Y. Tenne */ public class PublishedItemsHelper { /** * Splits a given property value to pairs of source and target strings (the splitter is '=>' * the source represents the Ant Pattern to search for * the target represents the target path to deploy the found artifacts * Multi values as acceptable by new lined or comma separated. * * @param publishedItemsPropertyValue the string value to split, if the splitter '=>' was not found * then the value is treated as a source only (target will be ""). * @return a Map containing the sources as keys and targets as values */ public static Multimap<String, String> getPublishedItemsPatternPairs(String publishedItemsPropertyValue) { Multimap<String, String> patternPairMap = HashMultimap.create(); if (StringUtils.isNotBlank(publishedItemsPropertyValue)) { List<String> patternPairs = parsePatternsFromProperty(publishedItemsPropertyValue); for (String patternPair : patternPairs) { String[] splitPattern = patternPair.split("=>"); String sourcePattern = ""; String targetPattern = ""; if (splitPattern.length > 0) { sourcePattern = FilenameUtils.separatorsToUnix(splitPattern[0].trim()); } // We allow an empty target, in that case it will be "" if (splitPattern.length > 1) { targetPattern = FilenameUtils.separatorsToUnix(splitPattern[1].trim()); } if (StringUtils.isNotBlank(sourcePattern)) { patternPairMap.put(sourcePattern, targetPattern); } } } return patternPairMap; } /** * Splits the given property value by new lines or by commas. * * @param publishedItemsPropertyValue The property value to split * @return a List of the splinted parameter by new lines or commas. */ public static List<String> parsePatternsFromProperty(String publishedItemsPropertyValue) { if (publishedItemsPropertyValue == null) { throw new IllegalArgumentException("Cannot parse null pattern."); } List<String> patterns = Lists.newArrayList(); if (StringUtils.isEmpty(publishedItemsPropertyValue)) { return patterns; } String[] newLineTokens = publishedItemsPropertyValue.split("\n"); for (String lineToken : newLineTokens) { if (StringUtils.isNotBlank(lineToken)) { String[] commaTokens = lineToken.trim().split(","); for (String commaToken : commaTokens) { if (StringUtils.isNotBlank(commaToken)) { patterns.add(commaToken.trim()); } } } } return patterns; } public static String removeDoubleDotsFromPattern(String pattern) { if (pattern == null) { throw new IllegalArgumentException("Cannot remove double dots from a null pattern."); } if (!pattern.contains("..")) { return pattern; } String[] splitPattern = pattern.split("/"); StringBuilder patternBuilder = new StringBuilder(); if (pattern.startsWith("/")) { patternBuilder.append("/"); } for (int i = 0; i < splitPattern.length; i++) { if (!"..".equals(splitPattern[i])) { patternBuilder.append(splitPattern[i]); if (i != (splitPattern.length - 1)) { patternBuilder.append("/"); } } } return StringUtils.removeEnd(patternBuilder.toString(), "/"); } /** * Building a multi map of target paths mapped to their files. * * @param checkoutDir the base directory of which to calculate the given source ant pattern * @param pattern the Ant pattern to calculate the files from * @param targetPath the target path for deployment of a file * @return a Multimap containing the targets as keys and the files as values * @throws IOException in case of any file system exception */ @Deprecated public static Multimap<String, File> buildPublishingData(File checkoutDir, String pattern, String targetPath) throws IOException { final Multimap<String, File> filePathsMap = HashMultimap.create(); File patternAbsolutePath = getAbsolutePath(checkoutDir, pattern); if (patternAbsolutePath.isFile()) { // The given pattern is an absolute path of just one file, let's add it to our result map filePathsMap.put(targetPath, patternAbsolutePath); } else { Pattern filePattern = null; File patternDir = null; if (patternAbsolutePath.isDirectory()) { // The given pattern is a path to a directory, we need to return all it's content filePattern = Pattern.compile(".*"); patternDir = patternAbsolutePath; } else if (pattern.indexOf('*') >= 0 || pattern.indexOf('?') >= 0) { // We are dealing with complex Ant pattern, need to analyze it File baseTruncationDir = getBaseTruncationDir(patternAbsolutePath); patternDir = baseTruncationDir != null ? baseTruncationDir : checkoutDir; // If the checkout dir is an ancestor of the pattern path then // we cut the checkout dir from the pattern boolean isCheckoutDirAncestor = isAncestor(checkoutDir, patternAbsolutePath); if (isCheckoutDirAncestor) { pattern = pattern.substring( patternDir.getAbsolutePath().length() - checkoutDir.getAbsolutePath().length()); } // If the pattern absolute path starts with the pattern directory path // then we need to cut the pattern to be only the relative path String patternAbsolutePathUrl = patternAbsolutePath.getAbsolutePath(); if (!StringUtils.isBlank(patternAbsolutePathUrl) && patternAbsolutePathUrl.startsWith(patternDir.getAbsolutePath())) { pattern = getRelativePath(patternDir, patternAbsolutePath); } // All done, we can now convert and compile from Ant pattern to regular expression filePattern = Pattern.compile(convertAntToRegexp(pattern)); } // If we successfully converted from Ant pattern to a regular expression // then it's time to collect all our artifacts according to this regular expression if (filePattern != null) { List<File> files = new ArrayList<File>(); collectMatchedFiles(patternDir, patternDir, filePattern, files); for (File file : files) { String fileTargetPath = calculateFileTargetPath(patternDir, file, targetPath); filePathsMap.put(fileTargetPath, file); } } } return filePathsMap; } /** * Building a multi map of target paths mapped to their files using wildcard pattern. * * @param checkoutDir the base directory of which to calculate the given source ant pattern * @param pattern the Ant pattern to calculate the files from * @param targetPath the target path for deployment of a file * @return a Multimap containing the targets as keys and the files as values * @throws IOException in case of any file system exception */ @Deprecated public static Multimap<String, File> wildCardBuildPublishingData(File checkoutDir, String pattern, String targetPath, boolean flat, boolean isRecursive, boolean regexp) throws IOException { if (!regexp) { pattern = PathsUtils.pathToRegExp(pattern); } Pattern regexPattern = Pattern.compile(pattern); List<File> files = new ArrayList<File>(); collectMatchedFiles(checkoutDir, checkoutDir, regexPattern, files, isRecursive); return getUploadPathsMap(files, checkoutDir, targetPath, flat, regexPattern); } /** * Building a multi map of target paths mapped to their files using wildcard pattern. * The pattern should contain slashes instead of backslashes in case of windows. * * @param checkoutDir the base directory of which to calculate the given source ant pattern * @param pattern the Ant pattern to calculate the files from * @param targetPath the target path for deployment of a file * @return a Multimap containing the targets as keys and the files as values * @throws IOException in case of any file system exception */ public static Multimap<String, File> buildPublishingData(File checkoutDir, String pattern, String targetPath, boolean flat, boolean recursive, boolean regexp) throws IOException { // This method determines the base directory - the directory where the files scan will be done String baseDir = getBaseDir(checkoutDir, pattern, regexp); // Part of the pattern might move to the base directory, this will remove this part from the pattern String newPattern = removeBaseDirFromPattern(checkoutDir, pattern, baseDir, regexp); // Collects candidate files to execute the regex List<String> candidatePaths = FileCollectionUtil.collectFiles(baseDir, newPattern, recursive, regexp); if (!regexp) { // Convert wildcard to regexp newPattern = PathsUtils.pathToRegExp(newPattern); } List<File> matchedFiles = new ArrayList<File>(); Pattern regexPattern = Pattern.compile(newPattern); File baseDirFile = new File(baseDir); for (String path : candidatePaths) { File file = new File(path); String relativePath = getRelativePath(baseDirFile, file).replace("\\", "/"); if (regexPattern.matcher(relativePath).matches()) { matchedFiles.add(file); } } return getUploadPathsMap(matchedFiles, baseDirFile, targetPath, flat, regexPattern); } /** * The user can provide pattern that will contain static path (without wildcards) that will become part of the base directory. * this method removes the part of the pattern that exists in the base directory. * @param checkoutDir the checkout directory * @param pattern the provided by the user pattern * @param baseDir the calculated base directory * @return new calculated pattern based on the provided patern and base directory */ private static String removeBaseDirFromPattern(File checkoutDir, String pattern, String baseDir, boolean regexp) { String absolutePattern = getAbsolutePattern(checkoutDir, pattern, regexp); // In case of absolute regexp pattern the pattern may contain escape chars. For correct new pattern extracting we need to make the base dir look the same. if (regexp && !absolutePattern.contains(baseDir)) { baseDir = PathsUtils.escapeRegexChars(baseDir); } // String.replaceFirst fails to find some strings with regexp therefore StringUtils.substringAfter is used String newPattern = StringUtils.substringAfter(absolutePattern, baseDir); if (newPattern.startsWith("/")) { // Remove the leading separator newPattern = newPattern.substring(1); } if (pattern.endsWith("/")) { if (regexp) { newPattern = newPattern + ".*"; } else { newPattern = newPattern + "*"; } } return newPattern; } private static Multimap<String, File> getUploadPathsMap(List<File> files, File checkoutDir, String targetPath, boolean flat, Pattern regexPattern) { Multimap<String, File> filePathsMap = HashMultimap.create(); for (File file : files) { String fileTargetPath = targetPath; String path; if (!StringUtils.endsWith(fileTargetPath, "/")) { path = StringUtils.substringBeforeLast(fileTargetPath, "/"); } else { path = targetPath; } if (!flat) { fileTargetPath = calculateFileTargetPath(checkoutDir, file, path); // handle win file system fileTargetPath = fileTargetPath.replace('\\', '/'); } fileTargetPath = PathsUtils.reformatRegexp(getRelativePath(checkoutDir, file), fileTargetPath, regexPattern); filePathsMap.put(fileTargetPath, file); } return filePathsMap; } /** * Returns base directory path with slash in the end. * The base directory is the path where the file collection starts from. * * Base directory is the last directory that not contains wildcards in case of regexp=false. * In case of regexp=true the base directory will be the last existing directory that not contains a regex char. * @param checkoutDir the checkout directory * @param pattern the pattern provided by the user * @param regexp the regexp value * @return String that represents the base directory */ private static String getBaseDir(File checkoutDir, String pattern, boolean regexp) throws FileNotFoundException { String baseDir = getAbsolutePattern(checkoutDir, pattern, regexp); if (regexp) { baseDir = getExistingPath(baseDir); if (StringUtils.isEmpty(baseDir)) { throw new FileNotFoundException("Could not find any base path in the pattern: " + pattern); } if (!baseDir.endsWith("/")) { baseDir = baseDir + "/"; } } else { baseDir = StringUtils.substringBefore(baseDir, "*"); baseDir = StringUtils.substringBefore(baseDir, "?"); baseDir = baseDir.substring(0, baseDir.lastIndexOf("/") + 1); } return baseDir; } /** * Returns the absolute path of pattern. * If the provided by the user pattern is absolute same pattern will be returned. * If the pattern is relative the checkout directory will be prepend. * in case of regexp=true escape chars will be prepended to regex chars in the checkout directory path. * @param checkoutDir the checkout directory * @param pattern the provided by the user patter, can be absolute or relative * @param regexp whether the pattern is regex or not * @return the absolute path of pattern */ private static String getAbsolutePattern(File checkoutDir, String pattern, boolean regexp) { File patternFile = new File(pattern); if (patternFile.isAbsolute()) { return pattern; } else { if (regexp) { String escapedCheckoutDir = PathsUtils .escapeRegexChars(checkoutDir.getAbsolutePath().replace("\\", "/")); return escapedCheckoutDir + "/" + pattern; } return checkoutDir.getAbsolutePath().replace("\\", "/") + "/" + pattern; } } /** * Returns the last existing directory of the provided baseDire that not contains a regex characters. * @param baseDir the path to search in * @return the last existing directory of the provided baseDire that not contains a regex characters */ private static String getExistingPath(String baseDir) { baseDir = PathsUtils.substringBeforeFirstRegex(baseDir); while (!new File(baseDir).isDirectory() && baseDir.contains("/")) { baseDir = StringUtils.substringBeforeLast(baseDir, "/"); } return baseDir; } private static String calculateFileTargetPath(File patternDir, File file, String targetPath) { String relativePath = getRelativePath(patternDir, file); relativePath = stripFileNameFromPath(relativePath); if (targetPath.length() == 0) { return relativePath; } if (relativePath.length() == 0) { return targetPath; } else { return (new StringBuilder()).append(targetPath).append('/').append(relativePath).toString(); } } private static String stripFileNameFromPath(String relativePath) { File file = new File(relativePath); return file.getPath().substring(0, file.getPath().length() - file.getName().length()); } /** * Calculates the absolute path of the given Ant pattern relatively to the given base directory * * @param baseDir the base directory to use in case the pattern is not absolute * @param pattern the pattern to which calculate an absolute path * @return File representation of the calculated absolute path */ private static File getAbsolutePath(File baseDir, String pattern) { File pathFile = new File(pattern); if (pathFile.isAbsolute()) { return pathFile; } File rawFile = new File(baseDir, pattern); if (baseDir.getPath().startsWith("\\\\")) { return rawFile; } return new File(rawFile.toURI().normalize().getPath()); } /** * Gets the base directory of a given File representation of an Ant pattern * without the pattern itself * * @param antPatternDir the Ant pattern directory to calculate the base directory from * @return the base directory of the given Ant pattern, null if there isn't any */ private static File getBaseTruncationDir(File antPatternDir) { String dirWithoutPattern = getDirWithoutPattern(antPatternDir.getPath()); if ("".equals(dirWithoutPattern)) { return null; } else { return new File(dirWithoutPattern); } } /** * Returns the directory path of the given Ant pattern without the pattern itself. * * @param pathWithWildCard an Ant pattern containing wildcards * @return the path to the directory without the Ant pattern */ private static String getDirWithoutPattern(String pathWithWildCard) { String t = pathWithWildCard.replace('\\', '/'); int firstStar = t.indexOf('*'); int firstQuestion = t.indexOf('?'); int mark; if (firstStar >= 0) { if (firstStar >= firstQuestion && firstQuestion >= 0) { mark = firstQuestion; } else { mark = firstStar; } } else { mark = firstQuestion; } int lastSlash = t.lastIndexOf('/', mark); return lastSlash <= 0 ? "" : pathWithWildCard.substring(0, lastSlash); } /** * Checks if a given directory is an ansector (file system speaking) * of a certain directory * * @param ancestor The directory to check if it's an ancestor of * @param child The child directory * @return true if ancestor if an ancestor of child, false otherwise * @throws IOException */ private static boolean isAncestor(File ancestor, File child) throws IOException { File parent = child; do { if (parent == null) { return false; } if (parent.equals(ancestor)) { return true; } parent = getParentFile(parent); } while (true); } private static File getParentFile(File file) { int skipCount = 0; File parentFile = file; do { do { parentFile = parentFile.getParentFile(); if (parentFile == null) { return null; } } while (".".equals(parentFile.getName())); if ("..".equals(parentFile.getName())) { skipCount++; } else if (skipCount > 0) { skipCount--; } else { return parentFile; } } while (true); } private static String convertAntToRegexp(String antPattern) { StringBuilder builder = new StringBuilder(antPattern.length()); int asteriskCount = 0; boolean recursive = true; int start = !antPattern.startsWith("/") && !antPattern.startsWith("\\") ? 0 : 1; for (int idx = start; idx < antPattern.length(); idx++) { char ch = antPattern.charAt(idx); if (ch == '*') { asteriskCount++; continue; } boolean foundRecursivePattern = recursive && asteriskCount == 2 && (ch == '/' || ch == '\\'); boolean asterisksFound = asteriskCount > 0; asteriskCount = 0; recursive = ch == '/' || ch == '\\'; if (foundRecursivePattern) { builder.append("(?:[^/]+/)*?"); continue; } if (asterisksFound) { builder.append("[^/]*?"); } if (ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '^' || ch == '$' || ch == '.' || ch == '{' || ch == '}' || ch == '+' || ch == '|') { builder.append('\\').append(ch); continue; } if (ch == '?') { builder.append("[^/]{1}"); continue; } if (ch == '\\') { builder.append('/'); } else { builder.append(ch); } } boolean isTrailingSlash = builder.length() > 0 && builder.charAt(builder.length() - 1) == '/'; if (asteriskCount == 0 && isTrailingSlash || recursive && asteriskCount == 2) { if (isTrailingSlash) { builder.setLength(builder.length() - 1); } if (builder.length() == 0) { builder.append(".*"); } else { builder.append("(?:$|/.+)"); } } else if (asteriskCount > 0) { builder.append("[^/]*?"); } return builder.toString(); } private static void collectMatchedFiles(File absoluteRoot, File root, Pattern pattern, List files) { File dirs[] = root.listFiles(); if (dirs == null) { return; } File arr[] = dirs; int len = arr.length; for (int i = 0; i < len; i++) { File dir = arr[i]; if (dir.isFile()) { String path = getRelativePath(absoluteRoot, dir).replace("\\", "/"); //String path = absoluteRoot.getAbsolutePath(); if (pattern.matcher(path).matches()) { files.add(dir); } } else { collectMatchedFiles(absoluteRoot, dir, pattern, files); } } } // We need also take into account if we are doing a recursive search private static void collectMatchedFiles(File absoluteRoot, File root, Pattern pattern, List files, boolean recursive) { File dirs[] = root.listFiles(); if (dirs == null) { return; } File arr[] = dirs; int len = arr.length; for (int i = 0; i < len; i++) { File dir = arr[i]; if (dir.isFile()) { String path = getRelativePath(absoluteRoot, dir).replace("\\", "/"); //String path = absoluteRoot.getAbsolutePath(); if (pattern.matcher(path).matches() || (recursive && pattern.matcher(StringUtils.substringAfterLast(path, "/")).matches())) { files.add(dir); } } else if (continueDepthSearch(absoluteRoot, dir, pattern, recursive)) { collectMatchedFiles(absoluteRoot, dir, pattern, files, recursive); } } } /** * Checks whether to continue searching recursively for files. * * @param absoluteRoot * @param dir * @param pattern * @param recursive * @return boolean */ private static boolean continueDepthSearch(File absoluteRoot, File dir, Pattern pattern, boolean recursive) { if (recursive) { return true; } int relativePathDepth = StringUtils.countMatches(getRelativePath(absoluteRoot, dir).replace("\\", "/"), "/"); int patternPathDepth = StringUtils.countMatches(pattern.toString(), "/"); return relativePathDepth < patternPathDepth; } /** * Gets the relative path of a given file to the base * * @param base the base path to calculate the relative path * @param file the file itself * @return the calculated relative path */ private static String getRelativePath(File base, File file) { if (base == null || file == null) { return null; } if (!base.isDirectory()) { base = base.getParentFile(); if (base == null) { return null; } } if (base.equals(file)) { return "."; } else { String filePath = file.getAbsolutePath(); String basePath = base.getAbsolutePath(); return getRelativePath(basePath, filePath, File.separatorChar); } } private static String getRelativePath(String basePath, String filePath, char separator) { basePath = ensureEnds(basePath, separator); int len = 0; int lastSeparatorIndex = 0; String basePathToCompare = basePath.toLowerCase(); String filePathToCompare = filePath.toLowerCase(); if (basePathToCompare.equals(ensureEnds(filePathToCompare, separator))) { return "."; } for (; len < filePath.length() && len < basePath.length() && filePathToCompare.charAt(len) == basePathToCompare.charAt(len); len++) { if (basePath.charAt(len) == separator) { lastSeparatorIndex = len; } } if (len == 0) { return null; } StringBuilder relativePath = new StringBuilder(); for (int i = len; i < basePath.length(); i++) { if (basePath.charAt(i) == separator) { relativePath.append(".."); relativePath.append(separator); } } relativePath.append(filePath.substring(lastSeparatorIndex + 1)); return relativePath.toString(); } private static String ensureEnds(String s, char endsWith) { return StringUtils.endsWith(s, "/") ? s : (new StringBuilder()).append(s).append(endsWith).toString(); } /** * Calculates the target deployment path of an artifact by it's name * * @param targetPattern a wildcard pattern of the target path * @param artifactFile the artifact file to calculate target deployment path for * @return the calculated target path (supports file renaming). */ public static String wildcardCalculateTargetPath(String targetPattern, File artifactFile) { if (targetPattern.endsWith("/") || targetPattern.equals("")) { return targetPattern + calculateTargetRelativePath(artifactFile); } return targetPattern; } /** * Calculates the target deployment path of an artifact by it's name * * @param targetPattern an Ant pattern of the target path * @param artifactFile the artifact file to calculate target deployment path for * @return the calculated target path */ public static String calculateTargetPath(String targetPattern, File artifactFile) { String relativePath = calculateTargetRelativePath(artifactFile); if (relativePath == null) { throw new IllegalArgumentException("Cannot calculate a target path given a null relative path."); } if (StringUtils.isBlank(targetPattern)) { return relativePath; } relativePath = FilenameUtils.separatorsToUnix(relativePath); targetPattern = FilenameUtils.separatorsToUnix(targetPattern); // take care of absolute path if (StringUtils.startsWith(targetPattern, "/")) { return targetPattern + "/" + artifactFile.getName(); } // take care of relative paths with patterns. StringBuilder itemPathBuilder = new StringBuilder(); String[] targetTokens = targetPattern.split("/"); boolean addedRelativeParent = false; for (int i = 0; i < targetTokens.length; i++) { boolean lastToken = (i == (targetTokens.length - 1)); String targetToken = targetTokens[i]; if ("**".equals(targetToken)) { if (!lastToken) { String relativeParentPath = FilenameUtils.getPathNoEndSeparator(relativePath); itemPathBuilder.append(relativeParentPath); addedRelativeParent = true; } else { itemPathBuilder.append(relativePath); } } else if (targetToken.startsWith("*.")) { String newFileName = FilenameUtils.removeExtension(FilenameUtils.getName(relativePath)) + targetToken.substring(1); itemPathBuilder.append(newFileName); } else if ("*".equals(targetToken)) { itemPathBuilder.append(FilenameUtils.getName(relativePath)); } else { if (StringUtils.isNotBlank(targetToken)) { itemPathBuilder.append(targetToken); } if (lastToken) { if (itemPathBuilder.length() > 0) { itemPathBuilder.append("/"); } if (addedRelativeParent) { itemPathBuilder.append(FilenameUtils.getName(relativePath)); } else { itemPathBuilder.append(relativePath); } } } if (!lastToken) { itemPathBuilder.append("/"); } } return itemPathBuilder.toString(); } private static String calculateTargetRelativePath(File artifactFile) { String relativePath = artifactFile.getAbsolutePath(); String parentDir = artifactFile.getParent(); if (!StringUtils.isBlank(parentDir)) { relativePath = StringUtils.removeStart(artifactFile.getAbsolutePath(), parentDir); } relativePath = FilenameUtils.separatorsToUnix(relativePath); relativePath = StringUtils.removeStart(relativePath, "/"); return relativePath; } }