Examples with PathFilter org.jboss.modules.filter.PathFilter used on opensource projects

Example 6 with PathFilter

use of org.jboss.modules.filter.PathFilter in project jboss-modules by jboss-modules.

the class LocalModuleFinder method findModule.

public ModuleSpec findModule(final String name, final ModuleLoader delegateLoader) throws ModuleLoadException {
    final String child = PathUtils.basicModuleNameToPath(name);
    if (child == null) {
        // not valid, so not found
        return null;
    }
    final PathFilter pathFilter = this.pathFilter;
    if (pathFilter.accept(child + "/")) {
        try {
            return doPrivileged((PrivilegedExceptionAction<ModuleSpec>) () -> parseModuleXmlFile(resourceRootFactory, name, delegateLoader, repoRoots), accessControlContext);
        } catch (PrivilegedActionException e) {
            try {
                throw e.getCause();
            } catch (IOException e1) {
                throw new ModuleLoadException(e1);
            } catch (RuntimeException | Error | ModuleLoadException e1) {
                throw e1;
            } catch (Throwable t) {
                throw new UndeclaredThrowableException(t);
            }
        }
    }
    return null;
}

Example 7 with PathFilter

use of org.jboss.modules.filter.PathFilter in project jboss-modules by jboss-modules.

the class Module method addPaths.

private long addPaths(Dependency[] dependencies, Map<String, List<LocalLoader>> map, FastCopyHashSet<PathFilter> filterStack, FastCopyHashSet<ClassFilter> classFilterStack, final FastCopyHashSet<PathFilter> resourceFilterStack, Set<Visited> visited) throws ModuleLoadException {
    long subtract = 0L;
    moduleLoader.incScanCount();
    for (Dependency dependency : dependencies) {
        if (dependency instanceof ModuleDependency) {
            final ModuleDependency moduleDependency = (ModuleDependency) dependency;
            final ModuleLoader moduleLoader = moduleDependency.getModuleLoader();
            final String name = moduleDependency.getName();
            final Module module;
            try {
                long pauseStart = Metrics.getCurrentCPUTime();
                try {
                    module = moduleLoader.preloadModule(name);
                } finally {
                    subtract += Metrics.getCurrentCPUTime() - pauseStart;
                }
            } catch (ModuleLoadException ex) {
                if (moduleDependency.isOptional()) {
                    continue;
                } else {
                    log.trace("Module %s, dependency %s preload failed: %s", getIdentifier(), moduleDependency.getName(), ex);
                    throw ex;
                }
            }
            if (module == null) {
                if (!moduleDependency.isOptional()) {
                    throw new ModuleNotFoundException(name);
                }
                continue;
            }
            final PathFilter importFilter = dependency.getImportFilter();
            final FastCopyHashSet<PathFilter> nestedFilters;
            final FastCopyHashSet<ClassFilter> nestedClassFilters;
            final FastCopyHashSet<PathFilter> nestedResourceFilters;
            if (filterStack.contains(importFilter)) {
                nestedFilters = filterStack;
            } else {
                nestedFilters = filterStack.clone();
                nestedFilters.add(importFilter);
            }
            final ClassFilter classImportFilter = dependency.getClassImportFilter();
            if (classImportFilter == ClassFilters.acceptAll() || classFilterStack.contains(classImportFilter)) {
                nestedClassFilters = classFilterStack;
            } else {
                nestedClassFilters = classFilterStack.clone();
                if (classImportFilter != ClassFilters.acceptAll())
                    nestedClassFilters.add(classImportFilter);
            }
            final PathFilter resourceImportFilter = dependency.getResourceImportFilter();
            if (resourceImportFilter == PathFilters.acceptAll() || resourceFilterStack.contains(resourceImportFilter)) {
                nestedResourceFilters = resourceFilterStack;
            } else {
                nestedResourceFilters = resourceFilterStack.clone();
                if (resourceImportFilter != PathFilters.acceptAll())
                    nestedResourceFilters.add(resourceImportFilter);
            }
            subtract += module.addExportedPaths(module.getDependenciesInternal(), map, nestedFilters, nestedClassFilters, nestedResourceFilters, visited);
        } else if (dependency instanceof ModuleClassLoaderDependency) {
            final ModuleClassLoaderDependency classLoaderDependency = (ModuleClassLoaderDependency) dependency;
            LocalLoader localLoader = classLoaderDependency.getLocalLoader();
            for (Object filter : classFilterStack.getRawArray()) {
                if (filter != null && filter != ClassFilters.acceptAll()) {
                    localLoader = createClassFilteredLocalLoader((ClassFilter) filter, localLoader);
                }
            }
            for (Object filter : resourceFilterStack.getRawArray()) {
                if (filter != null && filter != PathFilters.acceptAll()) {
                    localLoader = createPathFilteredLocalLoader((PathFilter) filter, localLoader);
                }
            }
            ClassFilter classFilter = classLoaderDependency.getClassImportFilter();
            if (classFilter != ClassFilters.acceptAll()) {
                localLoader = createClassFilteredLocalLoader(classFilter, localLoader);
            }
            PathFilter resourceFilter = classLoaderDependency.getResourceImportFilter();
            if (resourceFilter != PathFilters.acceptAll()) {
                localLoader = createPathFilteredLocalLoader(resourceFilter, localLoader);
            }
            final PathFilter importFilter = classLoaderDependency.getImportFilter();
            final Set<String> paths = classLoaderDependency.getPaths();
            for (String path : paths) {
                if (importFilter.accept(path)) {
                    List<LocalLoader> list = map.get(path);
                    if (list == null) {
                        map.put(path, list = new ArrayList<LocalLoader>());
                        list.add(localLoader);
                    } else if (!list.contains(localLoader)) {
                        list.add(localLoader);
                    }
                }
            }
        } else if (dependency instanceof LocalDependency) {
            final LocalDependency localDependency = (LocalDependency) dependency;
            LocalLoader localLoader = localDependency.getLocalLoader();
            for (Object filter : classFilterStack.getRawArray()) {
                if (filter != null && filter != ClassFilters.acceptAll()) {
                    localLoader = createClassFilteredLocalLoader((ClassFilter) filter, localLoader);
                }
            }
            for (Object filter : resourceFilterStack.getRawArray()) {
                if (filter != null && filter != PathFilters.acceptAll()) {
                    localLoader = createPathFilteredLocalLoader((PathFilter) filter, localLoader);
                }
            }
            final ClassFilter classFilter = localDependency.getClassImportFilter();
            if (classFilter != ClassFilters.acceptAll()) {
                localLoader = createClassFilteredLocalLoader(classFilter, localLoader);
            }
            final PathFilter resourceFilter = localDependency.getResourceImportFilter();
            if (resourceFilter != PathFilters.acceptAll()) {
                localLoader = createPathFilteredLocalLoader(resourceFilter, localLoader);
            }
            final PathFilter importFilter = localDependency.getImportFilter();
            final Set<String> paths = localDependency.getPaths();
            for (String path : paths) {
                if (importFilter.accept(path)) {
                    List<LocalLoader> list = map.get(path);
                    if (list == null) {
                        map.put(path, list = new ArrayList<LocalLoader>());
                        list.add(localLoader);
                    } else if (!list.contains(localLoader)) {
                        list.add(localLoader);
                    }
                }
            }
        }
    // else unknown dep type so just skip
    }
    return subtract;
}

Example 8 with PathFilter

use of org.jboss.modules.filter.PathFilter in project jboss-modules by jboss-modules.

the class ModuleClassLoader method iterateResources.

/**
 * Iterate the resources within this module class loader.  Only resource roots which are inherently iterable will
 * be checked, thus the result of this method may only be a subset of the actual loadable resources.  The returned
 * resources are not sorted or grouped in any particular way.
 *
 * @param startName the directory name to search
 * @param recurse {@code true} to recurse into subdirectories, {@code false} otherwise
 * @return the resource iterator
 */
public final Iterator<Resource> iterateResources(final String startName, final boolean recurse) {
    final String realStartName = PathUtils.canonicalize(PathUtils.relativize(startName));
    final PathFilter filter;
    if (recurse) {
        if (realStartName.isEmpty()) {
            filter = PathFilters.acceptAll();
        } else {
            filter = PathFilters.any(PathFilters.is(realStartName), PathFilters.isChildOf(realStartName));
        }
    } else {
        filter = PathFilters.is(realStartName);
    }
    final Map<String, List<ResourceLoader>> paths = this.paths.get().getAllPaths();
    final Iterator<Map.Entry<String, List<ResourceLoader>>> iterator = paths.entrySet().iterator();
    return new Iterator<Resource>() {

        private String path;

        private Iterator<Resource> resourceIterator;

        private Iterator<ResourceLoader> loaderIterator;

        private Resource next;

        public boolean hasNext() {
            while (next == null) {
                if (resourceIterator != null) {
                    assert path != null;
                    if (resourceIterator.hasNext()) {
                        next = resourceIterator.next();
                        return true;
                    }
                    resourceIterator = null;
                }
                if (loaderIterator != null) {
                    assert path != null;
                    if (loaderIterator.hasNext()) {
                        final ResourceLoader loader = loaderIterator.next();
                        if (loader instanceof IterableResourceLoader) {
                            resourceIterator = ((IterableResourceLoader) loader).iterateResources(path, false);
                            continue;
                        }
                    }
                    loaderIterator = null;
                }
                if (!iterator.hasNext()) {
                    return false;
                }
                final Map.Entry<String, List<ResourceLoader>> entry = iterator.next();
                path = entry.getKey();
                if (filter.accept(path)) {
                    loaderIterator = entry.getValue().iterator();
                }
            }
            return true;
        }

        public Resource next() {
            if (!hasNext())
                throw new NoSuchElementException();
            try {
                return next;
            } finally {
                next = null;
            }
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    };
}

Example 9 with PathFilter

use of org.jboss.modules.filter.PathFilter in project jboss-modules by jboss-modules.

the class ModuleClassLoader method setResourceLoaders.

private boolean setResourceLoaders(final Paths<ResourceLoader, ResourceLoaderSpec> paths, final ResourceLoaderSpec[] resourceLoaders) {
    final Map<String, List<ResourceLoader>> allPaths = new HashMap<String, List<ResourceLoader>>();
    for (ResourceLoaderSpec loaderSpec : resourceLoaders) {
        final ResourceLoader loader = loaderSpec.getResourceLoader();
        final PathFilter filter = loaderSpec.getPathFilter();
        for (String path : loader.getPaths()) {
            if (filter.accept(path)) {
                final List<ResourceLoader> allLoaders = allPaths.get(path);
                if (allLoaders == null) {
                    ArrayList<ResourceLoader> newList = new ArrayList<ResourceLoader>(16);
                    newList.add(loader);
                    allPaths.put(path, newList);
                } else {
                    allLoaders.add(loader);
                }
            }
        }
    }
    return this.paths.compareAndSet(paths, new Paths<>(resourceLoaders, allPaths));
}

Example 10 with PathFilter

use of org.jboss.modules.filter.PathFilter in project jboss-modules by jboss-modules.

the class ModuleXmlParser method parseSystemDependency.

private static void parseSystemDependency(final XmlPullParser reader, final ArrayList<DependencySpec> dependencies) throws XmlPullParserException, IOException {
    boolean export = false;
    final int count = reader.getAttributeCount();
    for (int i = 0; i < count; i++) {
        validateAttributeNamespace(reader, i);
        final String attribute = reader.getAttributeName(i);
        switch(attribute) {
            case A_EXPORT:
                export = Boolean.parseBoolean(reader.getAttributeValue(i));
                break;
            default:
                throw unexpectedContent(reader);
        }
    }
    Set<String> paths = Collections.emptySet();
    final MultiplePathFilterBuilder exportBuilder = PathFilters.multiplePathFilterBuilder(export);
    int eventType;
    for (; ; ) {
        eventType = reader.nextTag();
        switch(eventType) {
            case END_TAG:
                {
                    final PathFilter exportFilter = exportBuilder.create();
                    dependencies.add(DependencySpec.createSystemDependencySpec(PathFilters.acceptAll(), exportFilter, paths));
                    return;
                }
            case START_TAG:
                {
                    validateNamespace(reader);
                    switch(reader.getName()) {
                        case E_PATHS:
                            {
                                paths = parseSet(reader);
                                break;
                            }
                        case E_EXPORTS:
                            {
                                parseFilterList(reader, exportBuilder);
                                break;
                            }
                        default:
                            {
                                throw unexpectedContent(reader);
                            }
                    }
                }
        }
    }
}