oscar.java

OSGI 的 源码实现,采用JAVA书写

                    map.put(new Long(target.getBundleId()),
                        new RefreshHelper(target));
                    // Add all importing bundles to map.
                    populateImportGraph(target, map);
                }

                // At this point the map contains every bundle that has been
                // updated and/or removed as well as all bundles that import
                // packages from these bundles.
                for (Iterator iter = map.values().iterator(); iter.hasNext(); )
                {
                    RefreshHelper helper = (RefreshHelper) iter.next();
                    helper.stop();
                    helper.purgeOrRemove();
                    helper.reinitialize();
                }

                // Now restart bundles that were previously running.
                for (Iterator iter = map.values().iterator(); iter.hasNext(); )
                {
                    RefreshHelper helper = (RefreshHelper) iter.next();
                    helper.restart();
                }
            }
        }

        fireFrameworkEvent(FrameworkEvent.PACKAGES_REFRESHED, getBundle(0), null);
    }

    private void populateImportGraph(BundleImpl target, HashMap map)
    {
        // Get the exported packages for the specified bundle.
        ExportedPackage[] pkgs = getExportedPackages(target);

        for (int pkgIdx = 0; (pkgs != null) && (pkgIdx < pkgs.length); pkgIdx++)
        {
            // Get all imports of this package.
            Bundle[] importers = getImportingBundles(pkgs[pkgIdx]);

            // Add importing bundle to map if not already present.
            for (int impIdx = 0;
                (importers != null) && (impIdx < importers.length);
                impIdx++)
            {
                Long id = new Long(importers[impIdx].getBundleId());
                if (map.get(id) == null)
                {
                    map.put(id, new RefreshHelper(importers[impIdx]));
                    // Now recurse into each bundle to get its importers.
                    populateImportGraph(
                        (BundleImpl) importers[impIdx], map);
                }
            }
        }
    }

    /**
     * This method adds a import target to the IMPORTS_ATTR attribute
     * array associated with the specified module. If the module is
     * already validated, then this method will not add the new
     * import target if it will cause the specified module to become
     * invalidate. It is possible to "force" the method to add the
     * new import target, but doing so might cause module and modules
     * that depend on it to be invalidated.
     * @param module the module whose IMPORTS_ATTR meta-data is to be modified.
     * @param target the target to import.
     * @param version the version of the target to import.
     * @param force indicates whether to force the operation, even in the
     *        case where the module will be invalidated.
     * @return <tt>true</tt> if the import target was added, <tt>false</tt>
     *         otherwise.
    **/
    protected boolean addImport(
        Module module, Object target, Object version, boolean force)
    {
// TODO: Import permission check
        // Synchronize on the module manager, because we don't want
        // anything to change while we are in the middle of this
        // operation.
// TODO: Is this lock sufficient?
        synchronized (m_mgr)
        {
            ImportSearchPolicy search = (ImportSearchPolicy) m_mgr.getSearchPolicy();
            boolean added = false;
            Module exporter = null;

            // Get the valid attribute.
            boolean valid = ImportSearchPolicy.getValidAttribute(module).booleanValue();

            // Only attempt to resolve the new import target if the
            // module is already valid.
            if (valid)
            {
                exporter = search.resolveImportTarget(target, version);
            }

            // There are three situations that will cause us to add the
            // new import target to the existing module: 1) we are
            // being forced to do so, 2) the module is not currently
            // validated so adding imports is okay, or 3) the module
            // is currently valid and we were able to resolve the new
            // import target. The follow if-statement checks for these
            // three cases.
            if (force
                || !valid
                || (valid && (exporter != null)))
            {
                // Create a new imports attribute array and
                // copy the old values into it.
                Object[][] imports = ImportSearchPolicy.getImportsAttribute(module);
                Object[][] newImports = new Object[imports.length + 1][3];
                for (int i = 0; i < imports.length; i++)
                {
                    newImports[i] = imports[i];
                }

                // This is the new import target.
                newImports[newImports.length - 1] = new Object[] { target, version, exporter };
                module.setAttribute(ImportSearchPolicy.IMPORTS_ATTR, newImports);
                added = true;

                // If it was not possible to resolve the new import target
                // and the module is currently valid, then the module must
                // be invalidated.
                if ((exporter == null) && valid)
                {
                    search.invalidate(
                        module, module.getAttributes(), module.getResourceSources(),
                        module.getLibrarySources());
                }
            }

            return added;
        }
    }

    //
    // Implementations for Bundle interface methods.
    //

    /**
     * Implementation for Bundle.getBundleId().
    **/
    protected long getBundleId(BundleImpl bundle)
    {
        return bundle.getInfo().getBundleId();
    }

    /**
     * Implementation for Bundle.getHeaders().
    **/
    protected Dictionary getBundleHeaders(BundleImpl bundle)
    {
        if (System.getSecurityManager() != null)
        {
            AccessController.checkPermission(m_adminPerm);
        }
        return new MapToDictionary(bundle.getInfo().getCurrentHeader());
    }

    /**
     * Implementation for Bundle.getLocation().
    **/
    protected String getBundleLocation(BundleImpl bundle)
    {
        if (System.getSecurityManager() != null)
        {
            AccessController.checkPermission(m_adminPerm);
        }
        return bundle.getInfo().getLocation();
    }

    /**
     * Implementation for Bundle.getResource().
    **/
    protected URL getBundleResource(BundleImpl bundle, String name)
    {
        if (bundle.getInfo().getState() == Bundle.UNINSTALLED)
        {
            throw new IllegalStateException("The bundle is uninstalled.");
        }
        else if (System.getSecurityManager() != null)
        {
            AccessController.checkPermission(m_adminPerm);
        }
        return bundle.getInfo().getCurrentModule().getClassLoader().getResource(name);
// We previously search the old revisions of the bundle for resources
// first, but this caused multiple resolves when a bundle was updated
// but not resolved yet. I think the following is the better way, but
// other frameworks do it like above.
//        Module[] modules = bundle.getInfo().getModules();
//        for (int modIdx = 0; modIdx < modules.length; modIdx++)
//        {
//            URL url = modules[modIdx].getClassLoader().getResource(name);
//            if (url != null)
//            {
//                return url;
//            }
//        }
//        return null;
    }

    /**
     * Implementation for Bundle.getRegisteredServices().
    **/
    protected ServiceReference[] getBundleRegisteredServices(BundleImpl bundle)
    {
        if (bundle.getInfo().getState() == Bundle.UNINSTALLED)
        {
            throw new IllegalStateException("The bundle is uninstalled.");
        }

        synchronized (m_quickLock)
        {
            BundleInfo info = bundle.getInfo();

            if (info.getServiceRegistrationCount() > 0)
            {
                // Create a list of service references.
                ArrayList list = new ArrayList();
                for (int regIdx = 0; regIdx < info.getServiceRegistrationCount(); regIdx++)
                {
                    // Get service registration.
                    ServiceRegistrationImpl reg = (ServiceRegistrationImpl)
                        info.getServiceRegistration(regIdx);

                    // Check that the current security context has permission
                    // to get at least one of the service interfaces; the
                    // objectClass property of the service stores its service
                    // interfaces.
                    boolean hasPermission = false;
                    if (System.getSecurityManager() != null)
                    {
                        String[] objectClass = (String[])
                            reg.getProperty(Constants.OBJECTCLASS);
                        if (objectClass == null)
                        {
                            return null;
                        }
                        for (int ifcIdx = 0;
                            !hasPermission && (ifcIdx < objectClass.length);
                            ifcIdx++)
                        {
                            try
                            {
                                ServicePermission perm =
                                    new ServicePermission(
                                        objectClass[ifcIdx], ServicePermission.GET);
                                AccessController.checkPermission(perm);
                                hasPermission = true;
                            }
                            catch (Exception ex)
                            {
                            }
                        }
                    }
                    else
                    {
                        hasPermission = true;
                    }

                    if (hasPermission)
                    {
                        list.add(reg.getReference());
                    }
                }

                if (list.size() > 0)
                {
                    return (ServiceReference[])
                        list.toArray(new ServiceReference[list.size()]);
                }
            }
        }

        return null;
    }

    /**
     * Implementation for Bundle.getServicesInUse().
    **/
    protected ServiceReference[] getBundleServicesInUse(BundleImpl bundle)
    {
        synchronized (m_quickLock)
        {
            BundleInfo info = bundle.getInfo();
            Iterator iter = info.getServiceUsageCounters();
            if (iter.hasNext())
            {
                // Create a list of service references.
                ArrayList list = new ArrayList();
                while (iter.hasNext())
                {
                    // Get service reference.
                    ServiceReference ref = (ServiceReference) iter.next();

                    // Check that the current security context has permission
                    // to get at least one of the service interfaces; the
                    // objectClass property of the service stores its service
                    // interfaces.
                    boolean hasPermission = false;
                    if (System.getSecurityManager() != null)
                    {
                        String[] objectClass = (String[])
                            ref.getProperty(Constants.OBJECTCLASS);
                        if (objectClass == null)
                        {
                            return null;
                        }
                        for (int i = 0;
                            !hasPermission && (i < objectClass.length);
                            i++)
                        {
                            try
                            {
                                ServicePermission perm =
                                    new ServicePermission(
                                        objectClass[i], ServicePermission.GET);
                                AccessController.checkPermission(perm);
                                hasPermission = true;
                            }
                            catch (Exception ex)
                            {
                            }
                        }
                    }
                    else
                    {
                        hasPermission = true;
                    }

                    if (hasPermission)