oscar.java

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

        // Set the start level to zero in order to stop
        // all bundles in the framework.
        setStartLevelInternal(0);

        // Just like initialize() called the system bundle's start()
        // method, we must call its stop() method here so that it
        // can perform any necessary clean up.
        try {
            getBundle(0).stop();
        } catch (Exception ex) {
            fireFrameworkEvent(FrameworkEvent.ERROR, getBundle(0), ex);
            Oscar.error("Error stopping system bundle.", ex);
        }

        // Loop through all bundles and update any updated bundles.
        Bundle[] bundles = getBundles();
        for (int i = 0; i < bundles.length; i++)
        {
            BundleImpl bundle = (BundleImpl) bundles[i];
            if (bundle.getInfo().isRemovalPending())
            {
                try
                {
                    purgeBundle(bundle);
                }
                catch (Exception ex)
                {
                    fireFrameworkEvent(FrameworkEvent.ERROR, bundle, ex);
                    Oscar.error("Oscar: Unable to purge bundle "
                        + bundle.getInfo().getLocation());
                }
            }
        }

        // Remove any uninstalled bundles.
        for (int i = 0;
            (m_uninstalledBundles != null) && (i < m_uninstalledBundles.length);
            i++)
        {
            try
            {
                removeBundle(m_uninstalledBundles[i]);
            }
            catch (Exception ex)
            {
                Oscar.error("Oscar: Unable to remove "
                    + m_uninstalledBundles[i].getInfo().getLocation());
            }
        }

        // Shutdown event dispatching queue.
        DispatchQueue.shutdown();

        // Oscar is no longer in a usable state.
        m_oscarStatus = UNKNOWN_STATUS;
    }

    /**
     * Returns the active start level of the framework; this method
     * implements functionality for the Start Level service.
     * @return the active start level of the framework.
    **/
    protected int getStartLevel()
    {
        return m_activeStartLevel;
    }

    /**
     * Implements the functionality of the <tt>setStartLevel()</tt>
     * method for the StartLevel service, but does not do the security or
     * parameter check. The security and parameter check are done in the
     * StartLevel service implementation because this method is called on
     * a separate thread and the caller's thread would already be gone if
     * we did the checks in this method.
     * @param requestedLevel the new start level of the framework.
    **/
    protected void setStartLevelInternal(int requestedLevel)
    {
        // Determine if we are lowering or raising the
        // active start level.
        boolean lowering = (requestedLevel < m_activeStartLevel);

        // Record new start level.
        m_activeStartLevel = requestedLevel;

        // Get exclusion lock to make sure that no one starts
        // an operation that might affect the bundle list.
        synchronized (m_adminLock)
        {
            // Get array of all installed bundles.
            Bundle[] bundles = getBundles();

            // Sort bundle array by start level either ascending or
            // descending depending on whether the start level is being
            // lowered or raised.
            Comparator comparator = null;
            if (lowering)
            {
                // Sort descending to stop highest start level first.
                comparator = new Comparator() {
                    public int compare(Object o1, Object o2)
                    {
                        BundleImpl b1 = (BundleImpl) o1;
                        BundleImpl b2 = (BundleImpl) o2;
                        if (b1.getInfo().getStartLevel(getInitialBundleStartLevel())
                            < b2.getInfo().getStartLevel(getInitialBundleStartLevel()))
                        {
                            return 1;
                        }
                        else if (b1.getInfo().getStartLevel(getInitialBundleStartLevel())
                            > b2.getInfo().getStartLevel(getInitialBundleStartLevel()))
                        {
                            return -1;
                        }
                        return 0;
                    }
                };
            }
            else
            {
                // Sort ascending to start lowest start level first.
                comparator = new Comparator() {
                    public int compare(Object o1, Object o2)
                    {
                        BundleImpl b1 = (BundleImpl) o1;
                        BundleImpl b2 = (BundleImpl) o2;
                        if (b1.getInfo().getStartLevel(getInitialBundleStartLevel())
                            > b2.getInfo().getStartLevel(getInitialBundleStartLevel()))
                        {
                            return 1;
                        }
                        else if (b1.getInfo().getStartLevel(getInitialBundleStartLevel())
                            < b2.getInfo().getStartLevel(getInitialBundleStartLevel()))
                        {
                            return -1;
                        }
                        return 0;
                    }
                };
            }

            Arrays.sort(bundles, comparator);

            // Stop or start the bundles according to the start level.
            for (int i = 0; (bundles != null) && (i < bundles.length); i++)
            {
                BundleImpl impl = (BundleImpl) bundles[i];

                // Ignore the system bundle, since its start() and
                // stop() methods get called explicitly in initialize()
                // and shutdown(), respectively.
                if (impl.getInfo().getBundleId() == 0)
                {
                    continue;
                }

                // Start or stop bundle accordingly.
                if (impl.getInfo().getStartLevel(getInitialBundleStartLevel())
                    <= m_activeStartLevel)
                {
                    try
                    {
                        startBundleWithStartLevel(impl);
                    }
                    catch (Throwable th)
                    {
th.printStackTrace();
                        fireFrameworkEvent(FrameworkEvent.ERROR, impl, th);
                        Oscar.error("Oscar: Error starting "
                            + impl.getInfo().getLocation());
                    }
                }
                else if (impl.getInfo().getStartLevel(getInitialBundleStartLevel())
                    > m_activeStartLevel)
                {
                    try
                    {
                        stopBundleWithStartLevel(impl);
                    }
                    catch (Throwable th)
                    {
                        fireFrameworkEvent(FrameworkEvent.ERROR, impl, th);
                        Oscar.error("Oscar: Error stopping "
                            + impl.getInfo().getLocation());
                    }
                }
            }
        }

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

    /**
     * Returns the start level into which newly installed bundles will
     * be placed by default; this method implements functionality for
     * the Start Level service.
     * @return the default start level for newly installed bundles.
    **/
    protected int getInitialBundleStartLevel()
    {
        String s = getConfigProperty(OscarConstants.BUNDLE_STARTLEVEL_PROP);

        if (s != null)
        {
            try
            {
                return Integer.parseInt(s);
            }
            catch (NumberFormatException ex)
            {
                // Ignore and return the default value.
            }
        }
        return OscarConstants.BUNDLE_DEFAULT_STARTLEVEL;
    }

    /**
     * Sets the default start level into which newly installed bundles
     * will be placed; this method implements functionality for the Start
     * Level service.
     * @param startLevel the new default start level for newly installed
     *        bundles.
     * @throws java.lang.IllegalArgumentException if the specified start
     *         level is not greater than zero.
     * @throws java.security.SecurityException if the caller does not
     *         have <tt>AdminPermission</tt>.
    **/
    protected void setInitialBundleStartLevel(int startLevel)
    {
        if (System.getSecurityManager() != null)
        {
            AccessController.checkPermission(m_adminPerm);
        }

        if (startLevel <= 0)
        {
            throw new IllegalArgumentException(
                "Initial start level must be greater than zero.");
        }

        setConfigProperty(
            OscarConstants.BUNDLE_STARTLEVEL_PROP,
            Integer.toString(startLevel));
    }

    /**
     * Returns the start level for the specified bundle; this method
     * implements functionality for the Start Level service.
     * @param bundle the bundle to examine.
     * @return the start level of the specified bundle.
     * @throws java.lang.IllegalArgumentException if the specified
     *          bundle has been uninstalled.
    **/
    protected int getBundleStartLevel(Bundle bundle)
    {
        if (bundle.getState() == Bundle.UNINSTALLED)
        {
            throw new IllegalArgumentException("Bundle is uninstalled.");
        }

        return ((BundleImpl) bundle).getInfo().getStartLevel(getInitialBundleStartLevel());
    }

    /**
     * Sets the start level of the specified bundle; this method
     * implements functionality for the Start Level service.
     * @param bundle the bundle whose start level is to be modified.
     * @param startLevel the new start level of the specified bundle.
     * @throws java.lang.IllegalArgumentException if the specified
     *          bundle is the system bundle or if the bundle has been
     *          uninstalled.
     * @throws java.security.SecurityException if the caller does not
     *          have <tt>AdminPermission</tt>.
    **/
    protected void setBundleStartLevel(Bundle bundle, int startLevel)
    {
        if (System.getSecurityManager() != null)
        {
            AccessController.checkPermission(m_adminPerm);
        }

        // Cannot change the system bundle.
        if (bundle.getBundleId() == 0)
        {
            throw new IllegalArgumentException(
                "Cannot change system bundle start level.");
        }
        else if (bundle.getState() == Bundle.UNINSTALLED)
        {
            throw new IllegalArgumentException("Bundle is uninstalled.");
        }

        if (startLevel >= 1)
        {
            BundleImpl impl = (BundleImpl) bundle;
            impl.getInfo().setStartLevel(startLevel);
            try
            {
                m_cache.getArchive(impl.getBundleId()).setStartLevel(startLevel);
            }
            catch (Exception ex)
            {
                Oscar.error("Unable to save start level.", ex);
            }

            try
            {
                // Start or stop the bundle if necessary.
                if (impl.getInfo().getStartLevel(getInitialBundleStartLevel())
                    <= getStartLevel())
                {
                    startBundleWithStartLevel(impl);
                }
                else
                {
                    stopBundleWithStartLevel(impl);
                }
            }
            catch (Throwable th)
            {
                fireFrameworkEvent(FrameworkEvent.ERROR, impl, th);
                Oscar.error("Error starting/stopping bundle.", th);
            }
        }
    }

    /**
     * Returns whether a bundle is persistently started; this is an
     * method implementation for the Start Level service.
     * @param bundle the bundle to examine.
     * @return <tt>true</tt> if the bundle is marked as persistently
     *          started, <tt>false</tt> otherwise.
     * @throws java.lang.IllegalArgumentException if the specified