Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * JBossOSGi Framework
   * %%
   * Copyright (C) 2010 - 2012 JBoss by Red Hat
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 2.1 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Lesser Public License for more details.
  *
  * You should have received a copy of the GNU General Lesser Public
  * License along with this program.  If not, see
  * <http://www.gnu.org/licenses/lgpl-2.1.html>.
  * #L%
  */
 package org.jboss.osgi.framework.internal;
 
 import static org.jboss.osgi.framework.FrameworkLogger.LOGGER;
 import static org.osgi.framework.Constants.SYSTEM_BUNDLE_SYMBOLICNAME;
 import static org.osgi.framework.Constants.VISIBILITY_REEXPORT;
 
 import java.io.File;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
The module manager plugin.

Author(s):
thomas.diesler@jboss.com
Since:
06-Jul-2009
 
 public final class ModuleManagerImpl implements ModuleManager {
 
     private final XEnvironment environment;
     private final SystemPaths systemPaths;
     private final FrameworkModuleLoader moduleLoader;
     private final FrameworkModuleProvider moduleProvider;
 
     public ModuleManagerImpl(XEnvironment envSystemPaths syspathsFrameworkModuleProvider moduleProviderFrameworkModuleLoader moduleLoader) {
         this. = env;
         this. = syspaths;
         this. = moduleProvider;
         this. = moduleLoader;
     }
 
     @Override
    public Module getFrameworkModule() {
        return .getFrameworkModule();
    }
    @Override
    public ModuleIdentifier getModuleIdentifier(final XBundleRevision brev) {
        assert brev != null : "Null resource";
        assert !brev.isFragment() : "A fragment is not a module";
        ModuleIdentifier identifier = brev.getAttachment(ModuleIdentifier.class);
        if (identifier != null)
            return identifier;
        XIdentityCapability icap = brev.getIdentityCapability();
        Module module = brev.getAttachment(Module.class);
        if (module != null) {
            identifier = module.getIdentifier();
        } else if (.equals(icap.getSymbolicName())) {
            identifier = getFrameworkModule().getIdentifier();
        } else {
            identifier = .getModuleIdentifier(brev);
        }
        return identifier;
    }

    
Get the module with the given identifier

Returns:
The module or null
    @Override
    public Module getModule(ModuleIdentifier identifier) {
        Module frameworkModule = getFrameworkModule();
        if (frameworkModule.getIdentifier().equals(identifier)) {
            return frameworkModule;
        }
        try {
            return .getModuleLoader().loadModule(identifier);
        } catch (ModuleLoadException ex) {
            return null;
        }
    }

    
Get the bundle for the given class

Returns:
The bundle or null
    @Override
    public XBundle getBundleState(Class<?> clazz) {
        assert clazz != null : "Null clazz";
        XBundle result = null;
        ClassLoader loader = clazz.getClassLoader();
        if (loader instanceof BundleReference) {
            BundleReference bundleRef = (BundleReferenceloader;
            result = (XBundlebundleRef.getBundle();
        } else if (loader instanceof ModuleClassLoader) {
            Module module = ((ModuleClassLoaderloader).getModule();
            XBundleRevision brev = getBundleRevision(module);
            result = brev != null ? brev.getBundle() : null;
        }
        if (result == null)
            .debugf("Cannot obtain bundle for: %s"clazz.getName());
        return result;
    }
    private XBundleRevision getBundleRevision(Module module) {
        XBundleRevision result = null;
            Module resmod = res.getAttachment(Module.class);
            if (module == resmod) {
                result = (XBundleRevisionres;
                break;
            }
        }
        return result;
    }
    @Override
    public ModuleIdentifier addModule(final XBundleRevision brevfinal List<BundleWirewires) {
        assert brev != null : "Null res";
        assert wires != null : "Null wires";
        assert !brev.isFragment() : "Fragments cannot be added: " + brev;
        Module module = brev.getAttachment(Module.class);
        if (module != null) {
            ModuleIdentifier identifier = module.getIdentifier();
            FrameworkModuleLoader moduleLoaderPlugin = ;
            moduleLoaderPlugin.addModule(brevmodule);
            return identifier;
        }
        ModuleIdentifier identifier;
        XIdentityCapability icap = brev.getIdentityCapability();
        if (.equals(icap.getSymbolicName())) {
            identifier = getFrameworkModule().getIdentifier();
        } else {
            HostBundleRevision hostRev = HostBundleRevision.assertHostRevision(brev);
            identifier = createHostModule(hostRevwires);
        }
        return identifier;
    }

    
Create a org.jboss.modules.ModuleSpec from the given resolver module definition
    private ModuleIdentifier createHostModule(final HostBundleRevision hostRevfinal List<BundleWirewires) {
        HostBundleState hostBundle = hostRev.getBundleState();
        List<RevisionContentcontentRoots = hostRev.getClassPathContent();
        final ModuleIdentifier identifier = getModuleIdentifier(hostRev);
        final ModuleSpec.Builder specBuilder = ModuleSpec.build(identifier);
        final Map<ModuleIdentifierDependencySpecmoduleDependencies = new LinkedHashMap<ModuleIdentifierDependencySpec>();
        // Add a system dependency
        Set<StringbootPaths = .getBootDelegationPaths();
        PathFilter bootFilter = .getBootDelegationFilter();
        PathFilter acceptAll = PathFilters.acceptAll();
        specBuilder.addDependency(DependencySpec.createSystemDependencySpec(bootFilteracceptAllbootPaths));
        // Map the dependency for (the likely) case that the same exporter is choosen for multiple wires
        // For every {@link XWire} add a dependency on the exporter
        processModuleWireList(wiresspecHolderMap);
        // Process fragment wires
        Set<StringallPaths = new HashSet<String>();
        // Add the holder values to dependencies
        for (ModuleDependencyHolder holder : specHolderMap.values()) {
            moduleDependencies.put(holder.getIdentifier(), holder.create());
        }
        // Add the module dependencies to the builder
        for (DependencySpec dep : moduleDependencies.values())
            specBuilder.addDependency(dep);
        // Add resource roots the local bundle content
        for (RevisionContent revContent : contentRoots) {
            ResourceLoader resLoader = new RevisionContentResourceLoader(revContent);
            specBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(resLoader));
            allPaths.addAll(resLoader.getPaths());
        }
        // Process fragment local content and more resource roots
        Set<FragmentBundleRevisionfragRevs = hostRev.getAttachedFragments();
        for (FragmentBundleRevision fragRev : fragRevs) {
            for (RevisionContent revContent : fragRev.getClassPathContent()) {
                ResourceLoader resLoader = new RevisionContentResourceLoader(revContent);
                specBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(resLoader));
                allPaths.addAll(resLoader.getPaths());
            }
        }
        // Get the set of imported paths
        Set<StringimportedPaths = new HashSet<String>();
        for (ModuleDependencyHolder holder : specHolderMap.values()) {
            Set<Stringpaths = holder.getImportPaths();
            if (paths != null) {
                importedPaths.addAll(paths);
            }
        }
        // Setup the local loader dependency
        PathFilter importFilter = acceptAll;
        PathFilter exportFilter = acceptAll;
        if (importedPaths.isEmpty() == false) {
            importFilter = PathFilters.not(PathFilters.in(importedPaths));
        }
        PathFilter resImportFilter = PathFilters.acceptAll();
        PathFilter resExportFilter = PathFilters.acceptAll();
        ClassFilter classImportFilter = new ClassFilter() {
            @Override
            public boolean accept(String className) {
                return true;
            }
        };
        final PathFilter cefPath = getExportClassFilter(hostRev);
        ClassFilter classExportFilter = new ClassFilter() {
            @Override
            public boolean accept(String className) {
                return cefPath.accept(className);
            }
        };
        .tracef("createLocalDependencySpec: [if=%s,ef=%s,rif=%s,ref=%s,cf=%s]"importFilterexportFilterresImportFilterresExportFiltercefPath);
        DependencySpec localDep = DependencySpec.createLocalDependencySpec(importFilterexportFilterresImportFilterresExportFilterclassImportFilter,
                classExportFilter);
        specBuilder.addDependency(localDep);
        // Native - Hack
        addNativeResourceLoader(hostRevspecBuilder);
        PathFilter lazyActivationFilter = getLazyPackagesFilter(hostBundle);
        specBuilder.setModuleClassLoaderFactory(new HostBundleClassLoader.Factory(hostBundlelazyActivationFilter));
        specBuilder.setFallbackLoader(new FallbackLoader(hostRevimportedPaths));
        ModuleSpecBuilderContext context = new ModuleSpecBuilderContext() {
            @Override
            public XBundleRevision getBundleRevision() {
                return hostRev;
            }
            @Override
            public Builder getModuleSpecBuilder() {
                return specBuilder;
            }
            @Override
            public Map<ModuleIdentifierDependencySpecgetModuleDependencies() {
                return Collections.unmodifiableMap(moduleDependencies);
            }
        };
        // Add integration dependencies, build the spec and add it to the module loader
        FrameworkModuleLoader moduleLoaderPlugin = ;
        moduleLoaderPlugin.addIntegrationDependencies(context);
        moduleLoaderPlugin.addModuleSpec(hostRevspecBuilder.create());
        return identifier;
    }
    private void processModuleWireList(List<BundleWirewiresMap<BundleRevisionModuleDependencyHolderdepBuilderMap) {
        // A bundle may both import packages (via Import-Package) and require one
        // or more bundles (via Require-Bundle), but if a package is imported via
        // Import-Package, it is not also visible via Require-Bundle: Import-Package
        // takes priority over Require-Bundle, and packages which are exported by a
        // required bundle and imported via Import-Package must not be treated as
        // split packages.
        // Collect bundle and package wires
        List<BundleWirebundleWires = new ArrayList<BundleWire>();
        List<BundleWirepackageWires = new ArrayList<BundleWire>();
        for (BundleWire wire : wires) {
            XRequirement req = (XRequirementwire.getRequirement();
            XBundleRevision importer = (XBundleRevisionwire.getRequirer();
            XBundleRevision exporter = (XBundleRevisionwire.getProvider();
            // Skip dependencies on the module itself
            if (exporter == importer)
                continue;
            // Dependency for Import-Package
            if (req.adapt(XPackageRequirement.class) != null) {
                packageWires.add(wire);
                continue;
            }
            // Dependency for Require-Bundle
            if (req.adapt(XResourceRequirement.class) != null) {
                bundleWires.add(wire);
                continue;
            }
        }
        Set<StringimportedPaths = new HashSet<String>();
        Set<ResourcepackageExporters = new HashSet<Resource>();
        for (BundleWire wire : packageWires) {
            XBundleRevision exporter = (XBundleRevisionwire.getProvider();
            packageExporters.add(exporter);
            XRequirement xreq = (XRequirementwire.getRequirement();
            XPackageRequirement packreq = xreq.adapt(XPackageRequirement.class);
            ModuleDependencyHolder holder = getDependencyHolder(depBuilderMapexporter);
            String path = VFSUtils.getPathFromPackageName(packreq.getPackageName());
            holder.setOptional(packreq.isOptional());
            holder.addImportPath(path);
            importedPaths.add(path);
        }
        PathFilter importedPathsFilter = PathFilters.in(importedPaths);
        for (BundleWire wire : bundleWires) {
            XBundleRevision exporter = (XBundleRevisionwire.getProvider();
            if (packageExporters.contains(exporter))
                continue;
            XRequirement xreq = (XRequirementwire.getRequirement();
            XResourceRequirement resreq = xreq.adapt(XResourceRequirement.class);
            ModuleDependencyHolder holder = getDependencyHolder(depBuilderMapexporter);
            holder.setImportFilter(PathFilters.not(importedPathsFilter));
            holder.setOptional(resreq.isOptional());
            boolean reexport = .equals(resreq.getVisibility());
            if (reexport == true) {
                Set<StringexportedPaths = new HashSet<String>();
                for (Capability auxcap : exporter.getCapabilities(.)) {
                    XCapability xcap = (XCapabilityauxcap;
                    XPackageCapability packcap = xcap.adapt(XPackageCapability.class);
                    String path = packcap.getPackageName().replace('.''/');
                    if (importedPaths.contains(path) == false)
                        exportedPaths.add(path);
                }
                PathFilter exportedPathsFilter = PathFilters.in(exportedPaths);
                holder.setImportFilter(exportedPathsFilter);
                holder.setExportFilter(exportedPathsFilter);
            }
        }
    }
    private PathFilter getExportClassFilter(XResource resModule) {
        PathFilter includeFilter = null;
        PathFilter excludeFilter = null;
        for (Capability auxcap : resModule.getCapabilities(.)) {
            XCapability xcap = (XCapabilityauxcap;
            XPackageCapability packcap = xcap.adapt(XPackageCapability.class);
            String includeDirective = packcap.getDirective(.);
            if (includeDirective != null) {
                String packageName = packcap.getPackageName();
                String[] patterns = includeDirective.split(",");
                List<PathFilterincludes = new ArrayList<PathFilter>();
                for (String pattern : patterns) {
                    includes.add(PathFilters.match(packageName + "." + pattern));
                }
                includeFilter = PathFilters.any(includes);
            }
            String excludeDirective = packcap.getDirective(.);
            if (excludeDirective != null) {
                String packageName = packcap.getPackageName();
                String[] patterns = excludeDirective.split(",");
                List<PathFilterexcludes = new ArrayList<PathFilter>();
                for (String pattern : patterns) {
                    excludes.add(PathFilters.match(packageName + "." + pattern));
                }
                excludeFilter = PathFilters.not(PathFilters.any(excludes));
            }
        }
        // Accept all classes for export if there is no filter specified
        if (includeFilter == null && excludeFilter == null)
            return PathFilters.acceptAll();
        if (includeFilter == null)
            includeFilter = PathFilters.acceptAll();
        if (excludeFilter == null)
            excludeFilter = PathFilters.rejectAll();
        return PathFilters.all(includeFilterexcludeFilter);
    }

    
Get a path filter for packages that trigger bundle activation for a host bundle with lazy ActivationPolicy
    private PathFilter getLazyPackagesFilter(HostBundleState hostBundle) {
        // By default all packages are loaded lazily
        PathFilter result = PathFilters.acceptAll();
        ActivationPolicyMetaData activationPolicy = hostBundle.getActivationPolicy();
        if (activationPolicy != null) {
            List<Stringincludes = activationPolicy.getIncludes();
            if (includes != null) {
                Set<Stringpaths = new HashSet<String>();
                for (String packageName : includes)
                    paths.add(packageName.replace('.''/'));
                result = PathFilters.in(paths);
            }
            List<Stringexcludes = activationPolicy.getExcludes();
            if (excludes != null) {
                // The set of packages on the exclude list determines the packages that can be loaded eagerly
                Set<Stringpaths = new HashSet<String>();
                for (String packageName : excludes)
                    paths.add(packageName.replace('.''/'));
                if (includes != null)
                    result = PathFilters.all(result, PathFilters.not(PathFilters.in(paths)));
                else
                    result = PathFilters.not(PathFilters.in(paths));
            }
        }
        return result;
    }
    private void addNativeResourceLoader(HostBundleRevision hostrevModuleSpec.Builder specBuilder) {
        Deployment deployment = hostrev.getDeployment();
        addNativeResourceLoader(specBuilderhostrevdeployment);
        if (hostrev instanceof HostBundleRevision) {
            for (FragmentBundleRevision fragRev : hostrev.getAttachedFragments()) {
                addNativeResourceLoader(specBuilderhostrevfragRev.getDeployment());
            }
        }
    }
    private void addNativeResourceLoader(ModuleSpec.Builder specBuilderHostBundleRevision hostrevDeployment deployment) {
        NativeLibraryMetaData libMetaData = deployment.getAttachment(NativeLibraryMetaData.class);
        if (libMetaData != null) {
            NativeResourceLoader nativeLoader = new NativeResourceLoader();
            for (NativeLibrary library : libMetaData.getNativeLibraries()) {
                String libpath = library.getLibraryPath();
                String libfile = new File(libpath).getName();
                String libname = libfile.substring(0, libfile.lastIndexOf('.'));
                // Add the library provider to the policy
                NativeLibraryProvider libProvider = new NativeCodeImpl.BundleNativeLibraryProvider(hostrevlibnamelibpath);
                nativeLoader.addNativeLibrary(libProvider);
                // [TODO] why does the TCK use 'Native' to mean 'libNative' ?
                if (libname.startsWith("lib")) {
                    libname = libname.substring(3);
                    libProvider = new NativeCodeImpl.BundleNativeLibraryProvider(hostrevlibnamelibpath);
                    nativeLoader.addNativeLibrary(libProvider);
                }
            }
            specBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(nativeLoader));
        }
    }
    // Get or create the dependency builder for the exporter
        ModuleIdentifier exporterId = getModuleIdentifier(exporter);
        ModuleDependencyHolder holder = depBuilderMap.get(exporter);
        if (holder == null) {
            holder = new ModuleDependencyHolder(exporterId);
            depBuilderMap.put(exporterholder);
        }
        return holder;
    }

    
Load the module for the given identifier

Throws:
org.jboss.modules.ModuleLoadException If the module cannot be loaded
    @Override
    public Module loadModule(ModuleIdentifier identifierthrows ModuleLoadException {
        if (getFrameworkModule().getIdentifier().equals(identifier))
            return getFrameworkModule();
        else
            return .getModuleLoader().loadModule(identifier);
    }

    
Remove the module with the given identifier
    @Override
    public void removeModule(XBundleRevision brevModuleIdentifier identifier) {
        .removeModule(brev);
    }
    private class ModuleDependencyHolder {
        private final ModuleIdentifier identifier;
        private DependencySpec dependencySpec;
        private Set<StringimportPaths;
        private PathFilter importFilter;
        private PathFilter exportFilter;
        private boolean optional;
        ModuleDependencyHolder(ModuleIdentifier identifier) {
            this. = identifier;
        }
        ModuleIdentifier getIdentifier() {
            return ;
        }
        void addImportPath(String path) {
            assertNotCreated();
            if ( == null)
                 = new HashSet<String>();
            .add(path);
        }
        Set<StringgetImportPaths() {
            return ;
        }
        void setImportFilter(PathFilter importFilter) {
            assertNotCreated();
            this. = importFilter;
        }
        void setExportFilter(PathFilter exportFilter) {
            assertNotCreated();
            this. = exportFilter;
        }
        void setOptional(boolean optional) {
            assertNotCreated();
            this. = optional;
        }
        DependencySpec create() {
            if ( == null) {
                 = PathFilters.rejectAll();
            }
            if ( == null) {
                 = ( != null ? PathFilters.in() : PathFilters.acceptAll());
            }
            Module frameworkModule = getFrameworkModule();
            ModuleLoader depLoader = (frameworkModule.getIdentifier().equals() ? frameworkModule.getModuleLoader() : 
                    .getModuleLoader());
            .tracef("createModuleDependencySpec: [id=%s,if=%s,ef=%s,loader=%s,optional=%s]"depLoader);
            return DependencySpec.createModuleDependencySpec(depLoader);
        }
        private void assertNotCreated() {
            assert  == null : "DependencySpec already created";
        }
    }
New to GrepCode? Check out our FAQ X