@Override public Config getConfig() throws IOException { PathMatcher pathMatcher; try { pathMatcher = FileSystems.getDefault().getPathMatcher(inputFilePattern); } catch (IllegalArgumentException e) { throw new IllegalArgumentException( "Invalid input file pattern: " + inputFilePattern); } try (Stream<Path> pathStream = Files.walk(baseDirectory)) { return pathStream .filter(p -> Files.isRegularFile(p) && pathMatcher.matches(p)) .map(p -> ConfigFactory.parseFile(p.toFile())) .reduce(ConfigFactory.empty(), Config::withFallback) .resolve( ConfigResolveOptions.defaults() .setAllowUnresolved(true) .setUseSystemEnvironment(false) ); } }
static Map<String, DatabaseReaderLazyLoader> loadDatabaseReaders(Path geoIpConfigDirectory, NodeCache cache) throws IOException { if (Files.exists(geoIpConfigDirectory) == false && Files.isDirectory(geoIpConfigDirectory)) { throw new IllegalStateException("the geoip directory [" + geoIpConfigDirectory + "] containing databases doesn't exist"); } Map<String, DatabaseReaderLazyLoader> databaseReaders = new HashMap<>(); try (Stream<Path> databaseFiles = Files.list(geoIpConfigDirectory)) { PathMatcher pathMatcher = geoIpConfigDirectory.getFileSystem().getPathMatcher("glob:**.mmdb.gz"); // Use iterator instead of forEach otherwise IOException needs to be caught twice... Iterator<Path> iterator = databaseFiles.iterator(); while (iterator.hasNext()) { Path databasePath = iterator.next(); if (Files.isRegularFile(databasePath) && pathMatcher.matches(databasePath)) { String databaseFileName = databasePath.getFileName().toString(); DatabaseReaderLazyLoader holder = new DatabaseReaderLazyLoader(databaseFileName, () -> { try (InputStream inputStream = new GZIPInputStream(Files.newInputStream(databasePath, StandardOpenOption.READ))) { return new DatabaseReader.Builder(inputStream).withCache(cache).build(); } }); databaseReaders.put(databaseFileName, holder); } } } return Collections.unmodifiableMap(databaseReaders); }
@Test public void testGlobPath() { PathMatcher matcher = MetricTree.createPathMatcher("asdf["); assertNull(matcher); Multimap<String, String> pattern2Candidates = generate(); for (Map.Entry<String, Collection<String>> pattern2CandidatesMap : pattern2Candidates.asMap().entrySet()) { String glob = pattern2CandidatesMap.getKey(); matcher = MetricTree.createPathMatcher(glob); if (matcher == null) { System.out.println("Wrong pattern " + glob); continue; } for (String node : pattern2CandidatesMap.getValue()) { System.out.println(String.format("%40s\t%40s\t%s", glob, node, MetricTree.matches(matcher, node))); } } }
/** * Reads in the given JSON file and parses the content. * Creates and returns a new settings object with it. * * @param path path to JSON file * @return settings object or null if impossible to read * @throws IllegalArgumentException if the given path is null * @throws FileNotFoundException if the given path can not be found */ public static Settings read(Path path) throws IllegalArgumentException, FileNotFoundException { if (path == null) { throw new IllegalArgumentException("The given file path is not initialized."); } PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**.json"); if (!matcher.matches(path)) { throw new IllegalArgumentException("The file ending does not match .json."); } Settings settings = null; // parse JSON document to a java object JSONSettings json = new Gson().fromJson(new FileReader(path.toFile()), JSONSettings.class); if (json != null) { // create the actual settings object with the information of the read in objects settings = new Settings(json); } return settings; }
/** * Package accessible constructor. From configuration context it represents a single * <code>filegroup</code> and encapsulates the corresponding <code>filePattern</code>. * <code>filePattern</code> consists of two parts: first part has to be a valid path to an * existing parent directory, second part has to be a valid regex * {@link java.util.regex.Pattern} that match any non-hidden file names within parent directory * . A valid example for filePattern is <code>/dir0/dir1/.*</code> given * <code>/dir0/dir1</code> is an existing directory structure readable by the running user. * <p></p> * An instance of this class is created for each fileGroup * * @param fileGroup arbitrary name of the group given by the config * @param filePattern parent directory plus regex pattern. No wildcards are allowed in directory * name * @param cachePatternMatching default true, recommended in every setup especially with huge * parent directories. Don't set when local system clock is not used * for stamping mtime (eg: remote filesystems) * @see TaildirSourceConfigurationConstants */ TaildirMatcher(String fileGroup, String filePattern, boolean cachePatternMatching) { // store whatever came from configuration this.fileGroup = fileGroup; this.filePattern = filePattern; this.cachePatternMatching = cachePatternMatching; // calculate final members File f = new File(filePattern); this.parentDir = f.getParentFile(); String regex = f.getName(); final PathMatcher matcher = FS.getPathMatcher("regex:" + regex); this.fileFilter = new DirectoryStream.Filter<Path>() { @Override public boolean accept(Path entry) throws IOException { return matcher.matches(entry.getFileName()) && !Files.isDirectory(entry); } }; // sanity check Preconditions.checkState(parentDir.exists(), "Directory does not exist: " + parentDir.getAbsolutePath()); }
static List<String> listClassNamesInPackage(String packageName) throws Exception { List<String> classes = new ArrayList<>(); Enumeration<URL> resources = Thread.currentThread().getContextClassLoader().getResources(packageName.replace('.', File.separatorChar)); if (!resources.hasMoreElements()) { throw new IllegalStateException("No package found: " + packageName); } PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:*.class"); while (resources.hasMoreElements()) { URL resource = resources.nextElement(); Files.walkFileTree(Paths.get(resource.toURI()), new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException { if (pathMatcher.matches(path.getFileName())) { try { String className = Paths.get(resource.toURI()).relativize(path).toString().replace(File.separatorChar, '.'); classes.add(packageName + '.' + className.substring(0, className.length() - 6)); } catch (URISyntaxException e) { throw new IllegalStateException(e); } } return FileVisitResult.CONTINUE; } }); } return classes; }
public static List<String> readFileWithPattern(File path) { PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:" + path.getAbsolutePath()); List<String> result = new ArrayList<String>(); String p = path.getAbsolutePath(); int index = p.lastIndexOf(File.separator); if(index == -1) { throw new IllegalArgumentException("Cannot parse path:" + p + ", please use like this : /f/example/*.bgz "); } File dir = new File(p.substring(0, index)); File[] files = dir.listFiles(); for (File file : files) { if(pathMatcher.matches(file.toPath())) { result.add(file.getAbsolutePath()); } } // if(result.size() > MAX_FILE) { // throw new IllegalArgumentException("Cannot handle files more than " + MAX_FILE + " at one time, please merge file first." ); // } return result; }
@Override public PathMatcher getPathMatcher(String syntaxAndInput) { int pos = syntaxAndInput.indexOf(':'); if (pos <= 0 || pos == syntaxAndInput.length()) { throw new IllegalArgumentException("pos is " + pos); } String syntax = syntaxAndInput.substring(0, pos); String input = syntaxAndInput.substring(pos + 1); String expr; if (syntax.equalsIgnoreCase("glob")) { expr = JrtUtils.toRegexPattern(input); } else if (syntax.equalsIgnoreCase("regex")) { expr = input; } else { throw new UnsupportedOperationException("Syntax '" + syntax + "' not recognized"); } // return matcher final Pattern pattern = Pattern.compile(expr); return (Path path) -> pattern.matcher(path.toString()).matches(); }
@Override public PathMatcher getPathMatcher(String syntaxAndInput) { int pos = syntaxAndInput.indexOf(':'); if (pos <= 0 || pos == syntaxAndInput.length()) { throw new IllegalArgumentException(); } String syntax = syntaxAndInput.substring(0, pos); String input = syntaxAndInput.substring(pos + 1); String expr; if (syntax.equalsIgnoreCase("glob")) { expr = JrtUtils.toRegexPattern(input); } else if (syntax.equalsIgnoreCase("regex")) { expr = input; } else { throw new UnsupportedOperationException("Syntax '" + syntax + "' not recognized"); } // return matcher final Pattern pattern = Pattern.compile(expr); return (Path path) -> pattern.matcher(path.toString()).matches(); }
/** * Opens a directory stream on provided 'dir' folder, filtering file names according * to the provided glob syntax. * <p> * See http://blog.eyallupu.com/2011/11/java-7-working-with-directories.html * * @param dir the directory to read from * @param glob the glob matching * @return the opened DirectoryStream (remaining to be closed) * @throws IOException */ public static DirectoryStream newDirectoryStream (Path dir, String glob) throws IOException { // create a matcher and return a filter that uses it. final FileSystem fs = dir.getFileSystem(); final PathMatcher matcher = fs.getPathMatcher("glob:" + glob); final DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() { @Override public boolean accept (Path entry) { return matcher.matches(entry.getFileName()); } }; return fs.provider().newDirectoryStream(dir, filter); }
@Override public PathMatcher getPathMatcher( String syntaxAndInput ) { int pos = syntaxAndInput.indexOf( ':' ); if( pos <= 0 || pos == syntaxAndInput.length() ) { throw new IllegalArgumentException(); } String syntax = syntaxAndInput.substring( 0, pos ); String input = syntaxAndInput.substring( pos + 1 ); String expr; if( syntax.equals( REGEX_SYNTAX ) ) { expr = input; } else { throw new UnsupportedOperationException( "Syntax '" + syntax + "' not recognized" ); } // return matcher final Pattern pattern = Pattern.compile( expr ); return path -> pattern.matcher( path.toString() ).matches(); }
@Override public PathMatcher getPathMatcher(final String syntaxAndPattern) { final int pos = syntaxAndPattern.indexOf(':'); if (pos <= 0 || pos == syntaxAndPattern.length()) { throw new IllegalArgumentException(); } final String syntax = syntaxAndPattern.substring(0, pos); final String pattern = syntaxAndPattern.substring(pos + 1); switch (syntax) { case "glob": return new MCRGlobPathMatcher(pattern); case "regex": return new MCRPathMatcher(pattern); default: throw new UnsupportedOperationException("If the pattern syntax '" + syntax + "' is not known."); } }
public static ESLintIgnore get(FileObject fileObject) { if (fileObject.isFolder() && fileObject.getFileObject(".eslintignore") != null) { try { FileObject ignore = fileObject.getFileObject(".eslintignore"); List<PathMatcher> pathMatchers = new ArrayList<>(); final List<String> lines = ignore.asLines(); for (String glob : lines) { glob = glob.endsWith("/") ? glob + "**/*" : glob; pathMatchers.add(FileSystems.getDefault().getPathMatcher("glob:" + glob)); } return new ESLintIgnore(fileObject, pathMatchers); } catch (IOException iOException) { Logger.getLogger(ESLintIgnore.class.getName()).log(Level.WARNING, "Failed to read ignore file"); return new ESLintIgnore(fileObject, Collections.EMPTY_LIST); } } else if (fileObject.isFolder()) { return new ESLintIgnore(fileObject, Collections.EMPTY_LIST); } else { throw new IllegalArgumentException("Not a folder " + fileObject); } }
public FileVisitor(PathMatcher pathMatcher, List<File> paths, File startDir, Operation operation) { mStartDir = startDir; mOperation = operation; mOperationListener = operation.getListener(); mFiles = paths; mPathMatcher = pathMatcher; mExcludePatterns = StringUtils.split(operation.getExcludePattern(), "::"); mDirToDesc = operation.getDirToDesc(); final DescriptionMode mode = operation.getProfileDescription().getMode(); mUseExternalDescription = mode == DescriptionMode.EXTERNAL; mExternalFileValue = operation.getProfileDescription().getExternalFileValue(); if (mode == DescriptionMode.EXTERNAL) { try { File file = new File(startDir, mExternalFileValue); if (file.isFile()) { mDefaultDescProperties.load(new InputStreamReader(new FileInputStream(file), Charset.defaultCharset())); } } catch (IOException ex) { // nvm } } }
/** Search for a glob pattern in a given directory and its sub directories * See http://javapapers.com/java/glob-with-java-nio/ * */ private static List<Path> match(String glob, String location) throws IOException { final List<Path> globbed= new ArrayList<Path>(); final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:" + glob); Files.walkFileTree(Paths.get(location), new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException { if (pathMatcher.matches(path)) { globbed.add(path); } return FileVisitResult.CONTINUE; } @Override public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException { return FileVisitResult.CONTINUE; } }); return globbed; }
/** * Deletes the files that match the PathMatcher. * * <p> Note that this method doesn't delete the directories, only the files inside those * directories. This is fine for our use case since the majority of SCMs don't care about empty * directories. * * @throws IOException If it fails traversing or deleting the tree. */ public static int deleteFilesRecursively(Path path, final PathMatcher pathMatcher) throws IOException { final AtomicInteger counter = new AtomicInteger(); Files.walkFileTree(path, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { if (pathMatcher.matches(file)) { Files.delete(file); counter.incrementAndGet(); } return FileVisitResult.CONTINUE; } }); return counter.get(); }
@Test public void testDestinationFilesPassedToDestination_iterative() throws Exception { destinationFiles = "glob(['**'], exclude = ['foo', 'bar/**'])"; origin.addSimpleChange(/*timestamp*/ 42); Workflow workflow = iterativeWorkflow(resolveHead()); origin.addSimpleChange(/*timestamp*/ 4242); workflow.run(workdir, HEAD); assertThat(destination.processed).hasSize(1); PathMatcher matcher = destination.processed.get(0).getDestinationFiles() .relativeTo(workdir); assertThat(matcher.matches(workdir.resolve("foo"))).isFalse(); assertThat(matcher.matches(workdir.resolve("foo/indir"))).isTrue(); assertThat(matcher.matches(workdir.resolve("bar/indir"))).isFalse(); }
private void publishContractFiles(PactBrokerClient pactBrokerClient, Path contractsLocation, String version) throws IOException { final PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**/*.json"); try (Stream<Path> stream = Files.walk(contractsLocation)) { stream .filter(matcher::matches) .peek(path -> logger.log(Level.INFO, String.format("Publishing to Pact Broker contract %s", path))) .forEach(path -> { final String result = (String) pactBrokerClient.uploadPactFile(path.toFile(), version); if (result.startsWith("FAILED!")) { throw new IllegalStateException(String.format("Failed to publish %s contract with server failure %s", path, result)); } }); } }
protected List<File> findCaseFiles() throws IOException { List<File> caseFiles = new ArrayList<>(); List<PathMatcher> inMatchers = getIncludeMatchers(); List<PathMatcher> exMatchers = getExcludeMatchers(); Files.walkFileTree(Paths.get(getAssetRoot().getPath()), EnumSet.of(FileVisitOption.FOLLOW_LINKS), Integer.MAX_VALUE, new SimpleFileVisitor<Path>() { public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException { Path p = Paths.get(getAssetPath(path.toFile())); if (matches(inMatchers, p) && !matches(exMatchers, p)) { caseFiles.add(p.toFile()); } return FileVisitResult.CONTINUE; } }); return caseFiles; }
List<CtClass> findClasses( final ClassPool classPool, final String classPathElement) { // TODO(ville): If we ever support finding classes in other ways extract this method into a strategy. getLog().debug(String.format("Searching classpath element: %s", classPathElement)); final PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**.{class}"); final Path basePath = Paths.get(classPathElement); final List<CtClass> ctClasses = new ArrayList<>(); try { Files.walkFileTree( basePath, new ClasspathSimpleFileVisitor(matcher, ctClasses, classPool, basePath)); } catch (final IOException e) { throw new CompletionException("Unable to resolve compile classpath elements", e); } return ctClasses; }
/** * Find files in path. * * @param path find path * @param pattern find patttern * @return a set of path * @throws IOException IOException */ public Set<Path> findFiles(String path, String pattern) throws IOException { try { Set<Path> paths = new HashSet<>(); PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher(pattern); Files.walkFileTree(Paths.get(path), new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path filePath, BasicFileAttributes attrs) { if (pathMatcher.matches(filePath.getFileName())) { paths.add(filePath); } return FileVisitResult.CONTINUE; } }); return paths; } catch (IOException e) { throw e; } }
@Override public boolean filterPath(Path filePath) { if (getIncludeMatchers().isEmpty() && getExcludeMatchers().isEmpty()) { return false; } // compensate for the fact that Flink paths are slashed final String path = filePath.hasWindowsDrive() ? filePath.getPath().substring(1) : filePath.getPath(); final java.nio.file.Path nioPath = Paths.get(path); for (PathMatcher matcher : getIncludeMatchers()) { if (matcher.matches(nioPath)) { return shouldExclude(nioPath); } } return true; }
public static Stream<Path> getFileOrFiles(Path fileOrDirectory, String filterExpression) { File[] files; PathMatcher matcher = FileSystems.getDefault().getPathMatcher(filterExpression); if(fileOrDirectory.getFileName().toString().contains("*")) return Lists.newArrayList(fileOrDirectory.toFile() .getParentFile() .listFiles((FileFilter)new WildcardFileFilter( fileOrDirectory.getFileName().toString()))) .stream() .map(File::toPath) .filter(p -> matcher.matches(p.getFileName())); else if(fileOrDirectory.toFile().isDirectory() && (files = fileOrDirectory.toFile().listFiles()) != null) return Lists.newArrayList(files) .stream() .map(File::toPath) .filter(p -> p.toFile().isDirectory() || matcher.matches(p.getFileName())); else return Lists.newArrayList(new Path[] {fileOrDirectory}).stream(); }
private void testDoMatchOk(String pathString) { Path path = Paths.get(pathString).normalize(); System.out.println("---------------------- " + pathString + ":" + path); PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**/*.txt"); assertTrue(matcher.matches(path)); assertTrue(pathString, JkPathMatcher.accept("**/*.txt").matches(path)); matcher = FileSystems.getDefault().getPathMatcher("glob:foo/bar.txt"); assertTrue(pathString , matcher.matches(path)); assertTrue(pathString, JkPathMatcher.accept("foo/bar.txt").matches(path)); assertTrue(JkPathMatcher.accept("foo/b?r.txt").matches(path)); assertTrue(JkPathMatcher.accept("f*/bar.txt").matches(path)); assertTrue(JkPathMatcher.accept("*/bar.txt").matches(path)); assertTrue(JkPathMatcher.accept("**").matches(path)); }
List<String> findProtoFiles(final Path sourcePath) { List<String> protoFiles = new ArrayList<>(); if (Files.exists(sourcePath) && Files.isDirectory(sourcePath)) { PathMatcher protoMatcher = FileSystems.getDefault().getPathMatcher("glob:**/*.proto"); try { Files.walkFileTree(sourcePath, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { if (protoMatcher.matches(file)) { String protoFile = sourcePath.relativize(file).toString(); String normalizedPath = normalizeProtoPath(protoFile); protoFiles.add(normalizedPath); } return super.visitFile(file, attrs); } }); } catch (IOException e) { LOGGER.error("Can not build source files list", e); } } return protoFiles; }
@Override public FileVisitResult visitFile(Path path, BasicFileAttributes arg1) throws IOException { FileSystem fileSystem = FileSystems.getDefault(); PathMatcher pathMatcher = fileSystem.getPathMatcher("glob:" + filePattern); if (pathMatcher.matches(path.getFileName())) { searchList.add(path); String charset = Charset.defaultCharset().name(); //System.out.println(charset); String content = new String(Files.readAllBytes(path), charset); content = content.replaceAll(this.searchPattern, this.replacePattern); Files.write(path, content.getBytes(charset)); fileCount++; } return FileVisitResult.CONTINUE; }
private Set<Path> searchMetadata(Path sipPath) { File dir = sipPath.toFile(); if (!dir.isDirectory()) { dir = sipPath.getParent().toFile(); } PathMatcher matcher = FileSystems.getDefault().getPathMatcher(Constants.MISC_GLOB + templateType); File[] foundFiles = dir.listFiles((dir1, name) -> matcher.matches(Paths.get(name))); Set<Path> result = new HashSet<>(); if (foundFiles != null && foundFiles.length > 0) { for (File foundFile : foundFiles) { result.add(foundFile.toPath()); } } return result; }
private void onServerInitialized( LanguageServerLauncher launcher, LanguageServer server, ServerCapabilities capabilities, String projectPath) { LanguageServerDescription description = launcher.getDescription(); FileSystem fileSystem = FileSystems.getDefault(); for (String pattern : description.getFileWatchPatterns()) { PathMatcher matcher = fileSystem.getPathMatcher(pattern); int watcherId = watcherManager.registerByMatcher( matcher, s -> send(server, s, FileChangeType.Created), s -> send(server, s, FileChangeType.Changed), s -> send(server, s, FileChangeType.Deleted)); watcherIds.add(watcherId); } }
@Test public void testRegisterFileWatcher() throws Exception { ArgumentCaptor<ServerInitializerObserver> argumentCaptor = ArgumentCaptor.forClass(ServerInitializerObserver.class); watcher = new LanguageServerFileWatcher(watcherManager, initializer); verify(initializer).addObserver(argumentCaptor.capture()); ServerInitializerObserver value = argumentCaptor.getValue(); LanguageServerDescription description = new LanguageServerDescription( "foo", Collections.singletonList("bar"), Collections.emptyList(), Collections.singletonList("glob:*.foo")); when(launcher.getDescription()).thenReturn(description); value.onServerInitialized(launcher, server, null, null); ArgumentCaptor<PathMatcher> pathMatcherCaptor = ArgumentCaptor.forClass(PathMatcher.class); verify(watcherManager).registerByMatcher(pathMatcherCaptor.capture(), any(), any(), any()); assertTrue(pathMatcherCaptor.getValue().matches(new File("bar.foo").toPath())); }
private void configureTreeWalker() { bind(FileTreeWalker.class).asEagerSingleton(); newSetBinder( binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.directory.update")); newSetBinder( binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.directory.create")); newSetBinder( binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.directory.delete")); newSetBinder( binder(), new TypeLiteral<PathMatcher>() {}, Names.named("che.fs.directory.excludes")); newSetBinder(binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.file.update")); newSetBinder(binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.file.create")); newSetBinder(binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.file.delete")); newSetBinder(binder(), new TypeLiteral<PathMatcher>() {}, Names.named("che.fs.file.excludes")); }
int watch( PathMatcher matcher, Consumer<String> create, Consumer<String> modify, Consumer<String> delete) { LOG.debug("Watching matcher '{}'", matcher); int operationId = operationIdCounter.getAndIncrement(); matchers.putIfAbsent(matcher, newConcurrentHashSet()); matchers.get(matcher).add(operationId); operations.put(operationId, new Operation(create, modify, delete)); LOG.debug("Registered matcher operation set with id '{}'", operationId); return operationId; }
@Inject public FileTreeWalker( @Named("che.user.workspaces.storage") File root, @Named("che.fs.directory.update") Set<Consumer<Path>> directoryUpdateConsumers, @Named("che.fs.directory.create") Set<Consumer<Path>> directoryCreateConsumers, @Named("che.fs.directory.delete") Set<Consumer<Path>> directoryDeleteConsumers, @Named("che.fs.directory.excludes") Set<PathMatcher> directoryExcludes, @Named("che.fs.file.update") Set<Consumer<Path>> fileUpdateConsumers, @Named("che.fs.file.create") Set<Consumer<Path>> fileCreateConsumers, @Named("che.fs.file.delete") Set<Consumer<Path>> fileDeleteConsumers, @Named("che.fs.file.excludes") Set<PathMatcher> fileExcludes) { this.root = root; this.directoryUpdateConsumers = directoryUpdateConsumers; this.directoryCreateConsumers = directoryCreateConsumers; this.directoryDeleteConsumers = directoryDeleteConsumers; this.fileUpdateConsumers = fileUpdateConsumers; this.fileCreateConsumers = fileCreateConsumers; this.fileDeleteConsumers = fileDeleteConsumers; this.directoryExcludes = directoryExcludes; this.fileExcludes = fileExcludes; }
@Override protected void configure() { bind(Searcher.class).to(LuceneSearcher.class); Multibinder<PathMatcher> excludeMatcher = newSetBinder(binder(), PathMatcher.class, Names.named("vfs.index_filter_matcher")); excludeMatcher.addBinding().to(MediaTypesExcludeMatcher.class); excludeMatcher.addBinding().to(DotCheExcludeMatcher.class); excludeMatcher.addBinding().to(DotNumberSignExcludeMatcher.class); excludeMatcher.addBinding().to(HiddenItemPathMatcher.class); newSetBinder(binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.file.create")) .addBinding() .to(IndexedFileCreateConsumer.class); newSetBinder(binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.file.update")) .addBinding() .to(IndexedFileUpdateConsumer.class); newSetBinder(binder(), new TypeLiteral<Consumer<Path>>() {}, Names.named("che.fs.file.delete")) .addBinding() .to(IndexedFileDeleteConsumer.class); }
@Inject protected LuceneSearcher( @Named("vfs.index_filter_matcher") Set<PathMatcher> excludePatterns, @Named("vfs.local.fs_index_root_dir") File indexDirectory, @Named("che.user.workspaces.storage") File root, PathTransformer pathTransformer) { this.indexDirectory = indexDirectory; this.root = root; this.excludePatterns = excludePatterns; this.pathTransformer = pathTransformer; executor = newSingleThreadExecutor( new ThreadFactoryBuilder() .setDaemon(true) .setUncaughtExceptionHandler(LoggingUncaughtExceptionHandler.getInstance()) .setNameFormat("LuceneSearcherInitThread") .build()); }
@Test public void Test_GlobPatternMatcher_AbsolutePath_InRoot() { Path root = Paths.get("c:\\temp"); Path examplePath = Paths.get("c:\\temp\\blabla.sql"); String pattern = String.format( "glob:%1$s%2$s%3$s", root.normalize().toString().replace('\\', '/'), "/", "**/*.sql"); PathMatcher testMatcher = FileSystems .getDefault() .getPathMatcher(pattern); Assert.assertFalse(testMatcher.matches(examplePath)); }
@Test public void Test_GlobPatternMatcher_AbsolutePath_InFolderUnderRoot() { Path root = Paths.get("c:\\temp"); Path examplePath = Paths.get("c:\\temp\\tra\\blabla.sql"); String pattern = String.format( "glob:%1$s%2$s%3$s", root.normalize().toString().replace('\\', '/'), "/", "**/*.sql"); PathMatcher testMatcher = FileSystems .getDefault() .getPathMatcher(pattern); Assert.assertTrue(testMatcher.matches(examplePath)); }
/** * Parse all IGFS log files in specified log directory. * * @param logDir Folder were log files located. * @return List of line with aggregated information by files. */ private List<VisorIgfsProfilerEntry> parse(Path logDir, String igfsName) throws IOException { List<VisorIgfsProfilerEntry> parsedFiles = new ArrayList<>(512); try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(logDir)) { PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:igfs-log-" + igfsName + "-*.csv"); for (Path p : dirStream) { if (matcher.matches(p.getFileName())) { try { parsedFiles.addAll(parseFile(p)); } catch (NoSuchFileException ignored) { // Files was deleted, skip it. } catch (Exception e) { ignite.log().warning("Failed to parse IGFS profiler log file: " + p, e); } } } } return parsedFiles; }
private String findExcelFile() throws IOException { // use the matcher to find the file PathMatcher matcher = FileSystems.getDefault().getPathMatcher( "glob:*.{xls,xlsx}"); // find the return Path dir = Paths.get(syncDirectory); DirectoryStream<Path> stream = Files.newDirectoryStream(dir); for (Path p : stream) { // here match the file name // not the path Path file = p.getFileName(); // match if (matcher.matches(file)) { return p.toString(); } } // return return null; }
private void validateInitialFileToProcess(List<ConfigIssue> issues) { if (conf.initialFileToProcess != null && !conf.initialFileToProcess.isEmpty()) { try { PathMatcher pathMatcher = DirectorySpooler.createPathMatcher(conf.filePattern, conf.pathMatcherMode); if (!pathMatcher.matches(new File(conf.initialFileToProcess).toPath().getFileName())) { issues.add( getContext().createConfigIssue( Groups.FILES.name(), SPOOLDIR_CONFIG_BEAN_PREFIX + "initialFileToProcess", Errors.SPOOLDIR_18, conf.initialFileToProcess, conf.filePattern ) ); } } catch (Exception ex) { } } }
@Override public PathMatcher getPathMatcher(String syntaxAndPattern) { if(syntaxAndPattern.startsWith("regex:")) { return regexPathMatcher(syntaxAndPattern.substring("regex:".length())); } else if(syntaxAndPattern.startsWith("glob:")) { String glob = syntaxAndPattern.substring("glob:".length()); String regex = GlobUtil.globToRegex(glob, settings.isPosix() ); return regexPathMatcher(regex); } else if(!Pattern.matches(".+:.+", syntaxAndPattern)) { throw new IllegalArgumentException("syntaxAndPattern must take the form syntax:patterbn, not" + syntaxAndPattern); } else { throw new UnsupportedOperationException("invlalid syntaxAndPattern:" + syntaxAndPattern); } }