ResolverImpl.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.felix.bundlerepository.impl;

import java.net.URL;
import java.util.*;

import org.apache.felix.bundlerepository.*;
import org.apache.felix.utils.log.Logger;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.Version;

public class ResolverImpl implements Resolver
{
    private final BundleContext m_context;
    private final Logger m_logger;
    private final Repository[] m_repositories;
    private final Set<Resource> m_addedSet = new HashSet<Resource>();
    private final Set<Requirement> m_addedRequirementSet = new HashSet<Requirement>();
    private final Set<Capability> m_globalCapabilities = new HashSet<Capability>();
    private final Set<Resource> m_failedSet = new HashSet<Resource>();
    private final Set<Resource> m_resolveSet = new HashSet<Resource>();
    private final Set<Resource> m_requiredSet = new HashSet<Resource>();
    private final Set<Resource> m_optionalSet = new HashSet<Resource>();
    private final Map<Resource, List<Reason>> m_reasonMap = new HashMap<Resource, List<Reason>>();
    private final Set<Reason> m_unsatisfiedSet = new HashSet<Reason>();
    private boolean m_resolved = false;
    private long m_resolveTimeStamp;
    private int m_resolutionFlags;

    public ResolverImpl(BundleContext context, Repository[] repositories, Logger logger)
    {
        m_context = context;
        m_logger = logger;
        m_repositories = repositories;
    }

    public synchronized void add(Resource resource)
    {
        m_resolved = false;
        m_addedSet.add(resource);
    }

    public synchronized Resource[] getAddedResources()
    {
        return m_addedSet.toArray(new Resource[m_addedSet.size()]);
    }

    public synchronized void add(Requirement requirement)
    {
        m_resolved = false;
        m_addedRequirementSet.add(requirement);
    }

    public synchronized Requirement[] getAddedRequirements()
    {
        return m_addedRequirementSet.toArray(new Requirement[m_addedRequirementSet.size()]);
    }

    public void addGlobalCapability(Capability capability)
    {
        m_globalCapabilities.add(capability);
    }

    public Capability[] getGlobalCapabilities()
    {
        return m_globalCapabilities.toArray(new Capability[m_globalCapabilities.size()]);
    }

    public synchronized Resource[] getRequiredResources()
    {
        if (m_resolved)
        {
            return m_requiredSet.toArray(new Resource[m_requiredSet.size()]);
        }
        throw new IllegalStateException("The resources have not been resolved.");
    }

    public synchronized Resource[] getOptionalResources()
    {
        if (m_resolved)
        {
            return m_optionalSet.toArray(new Resource[m_optionalSet.size()]);
        }
        throw new IllegalStateException("The resources have not been resolved.");
    }

    public synchronized Reason[] getReason(Resource resource)
    {
        if (m_resolved)
        {
            List<Reason> l = m_reasonMap.get(resource);
            return l != null ? l.toArray(new Reason[l.size()]) : null;
        }
        throw new IllegalStateException("The resources have not been resolved.");
    }

    public synchronized Reason[] getUnsatisfiedRequirements()
    {
        if (m_resolved)
        {
            return m_unsatisfiedSet.toArray(new Reason[m_unsatisfiedSet.size()]);
        }
        throw new IllegalStateException("The resources have not been resolved.");
    }

    protected LocalResource[] getLocalResources()
    {
        List<LocalResource> resources = new ArrayList<LocalResource>();
        for (Resource resource : getResources())
        {
            if (resource != null && resource.isLocal())
            {
                resources.add((LocalResource) resource);
            }
        }
        return resources.toArray(new LocalResource[resources.size()]);
    }

    private Resource[] getRemoteResources()
    {
        List<Resource> resources = new ArrayList<Resource>();
        for (Resource resource : getResources())
        {
            if (resource != null && !resource.isLocal())
            {
                resources.add(resource);
            }
        }
        return resources.toArray(new Resource[resources.size()]);
    }

    private Resource[] getResources()
    {
        List<Resource> resources = new ArrayList<Resource>();
        for (int repoIdx = 0; (m_repositories != null) && (repoIdx < m_repositories.length); repoIdx++)
        {
            boolean isLocal = m_repositories[repoIdx].getURI().equals(Repository.LOCAL);
            boolean isSystem = m_repositories[repoIdx].getURI().equals(Repository.SYSTEM);
            if (isLocal && (m_resolutionFlags & NO_LOCAL_RESOURCES) != 0) {
                continue;
            }
            if (isSystem && (m_resolutionFlags & NO_SYSTEM_BUNDLE) != 0) {
                continue;
            }
            Collections.addAll(resources, m_repositories[repoIdx].getResources());
        }
        return resources.toArray(new Resource[resources.size()]);
    }

    public synchronized boolean resolve()
    {
        return resolve(0);
    }

    public synchronized boolean resolve(int flags)
    {
        // Find resources
        Resource[] locals = getLocalResources();
        Resource[] remotes = getRemoteResources();

        // time of the resolution process start
        m_resolveTimeStamp = 0;
        for (int repoIdx = 0; (m_repositories != null) && (repoIdx < m_repositories.length); repoIdx++)
        {
            m_resolveTimeStamp = Math.max(m_resolveTimeStamp, m_repositories[repoIdx].getLastModified());
        }

        // Reset instance values.
        m_failedSet.clear();
        m_resolveSet.clear();
        m_requiredSet.clear();
        m_optionalSet.clear();
        m_reasonMap.clear();
        m_unsatisfiedSet.clear();
        m_resolved = true;
        m_resolutionFlags = flags;

        boolean result = true;

        // Add a fake resource if needed
        if (!m_addedRequirementSet.isEmpty() || !m_globalCapabilities.isEmpty())
        {
            ResourceImpl fake = new ResourceImpl();
            for (Capability cap : m_globalCapabilities) {
                fake.addCapability(cap);
            }
            for (Requirement req : m_addedRequirementSet) {
                fake.addRequire(req);
            }
            if (!resolve(fake, locals, remotes, false))
            {
                result = false;
            }
        }

        // Loop through each resource in added list and resolve.
        for (Resource aM_addedSet : m_addedSet) {
            if (!resolve(aM_addedSet, locals, remotes, false)) {
                // If any resource does not resolve, then the
                // entire result will be false.
                result = false;
            }
        }

        // Clean up the resulting data structures.
        m_requiredSet.removeAll(m_addedSet);
        if ((flags & NO_LOCAL_RESOURCES) == 0)
        {
            m_requiredSet.removeAll(Arrays.asList(locals));
        }
        m_optionalSet.removeAll(m_addedSet);
        m_optionalSet.removeAll(m_requiredSet);
        if ((flags & NO_LOCAL_RESOURCES) == 0)
        {
            m_optionalSet.removeAll(Arrays.asList(locals));
        }

        // Return final result.
        return result;
    }

    private boolean resolve(Resource resource, Resource[] locals, Resource[] remotes, boolean optional)
    {
        boolean result = true;

        // Check for cycles.
        if (m_resolveSet.contains(resource) || m_requiredSet.contains(resource) || m_optionalSet.contains(resource))
        {
            return true;
        }
        else if (m_failedSet.contains(resource))
        {
            return false;
        }

        // Add to resolve map to avoid cycles.
        m_resolveSet.add(resource);

        // Resolve the requirements for the resource according to the
        // search order of: added, resolving, local and finally remote
        // resources.
        Requirement[] reqs = resource.getRequirements();
        if (reqs != null)
        {
            Resource candidate;
            for (Requirement req : reqs) {
                // Do not resolve optional requirements
                if ((m_resolutionFlags & NO_OPTIONAL_RESOURCES) != 0 && req.isOptional()) {
                    continue;
                }
                candidate = searchResources(req, m_addedSet);
                if (candidate == null) {
                    candidate = searchResources(req, m_requiredSet);
                }
                if (candidate == null) {
                    candidate = searchResources(req, m_optionalSet);
                }
                if (candidate == null) {
                    candidate = searchResources(req, m_resolveSet);
                }
                if (candidate == null) {
                    List<ResourceCapability> candidateCapabilities = searchResources(req, locals);
                    candidateCapabilities.addAll(searchResources(req, remotes));

                    // Determine the best candidate available that
                    // can resolve.
                    while ((candidate == null) && !candidateCapabilities.isEmpty()) {
                        ResourceCapability bestCapability = getBestCandidate(candidateCapabilities);

                        // Try to resolve the best resource.
                        if (resolve(bestCapability.getResource(), locals, remotes, optional || req.isOptional())) {
                            candidate = bestCapability.getResource();
                        } else {
                            candidateCapabilities.remove(bestCapability);
                        }
                    }
                }

                if ((candidate == null) && !req.isOptional()) {
                    // The resolve failed.
                    result = false;
                    // Associated the current resource to the requirement
                    // in the unsatisfied requirement set.
                    m_unsatisfiedSet.add(new ReasonImpl(resource, req));
                } else if (candidate != null) {

                    // Try to resolve the candidate.
                    if (resolve(candidate, locals, remotes, optional || req.isOptional())) {
                        // The resolved succeeded; record the candidate
                        // as either optional or required.
                        if (optional || req.isOptional()) {
                            m_optionalSet.add(candidate);
                            m_resolveSet.remove(candidate);
                        } else {
                            m_requiredSet.add(candidate);
                            m_optionalSet.remove(candidate);
                            m_resolveSet.remove(candidate);
                        }

                        // Add the reason why the candidate was selected.
                        List<Reason> reasons = m_reasonMap.get(candidate);
                        if (reasons == null) {
                            reasons = new ArrayList<Reason>();
                            m_reasonMap.put(candidate, reasons);
                        }
                        reasons.add(new ReasonImpl(resource, req));
                    } else {
                        result = false;
                    }
                }
            }
        }

        // If the resolve failed, remove the resource from the resolve set and
        // add it to the failed set to avoid trying to resolve it again.
        if (!result)
        {
            m_resolveSet.remove(resource);
            m_failedSet.add(resource);
        }

        return result;
    }

    private Resource searchResources(Requirement req, Set<Resource> resourceSet)
    {
        for (Resource aResourceSet : resourceSet) {
            checkInterrupt();
            Capability[] caps = aResourceSet.getCapabilities();
            if (caps != null) {
                for (Capability cap : caps) {
                    if (req.isSatisfied(cap)) {
                        // The requirement is already satisfied an existing
                        // resource, return the resource.
                        return aResourceSet;
                    }
                }
            }
        }

        return null;
    }

    /**
     * Searches for resources that do meet the given requirement
     * @param req the the requirement that must be satisfied by resources
     * @param resources list of resources to look at
     * @return all resources meeting the given requirement
     */
    private List<ResourceCapability> searchResources(Requirement req, Resource[] resources)
    {
        List<ResourceCapability> matchingCapabilities = new ArrayList<ResourceCapability>();

        if (resources != null) {
            for (Resource resource : resources) {
                checkInterrupt();
                // We don't need to look at resources we've already looked at.
                if (!m_failedSet.contains(resource)) {
                    Capability[] caps = resource.getCapabilities();
                    if (caps != null) {
                        for (Capability cap : caps) {
                            if (req.isSatisfied(cap))
                                matchingCapabilities.add(new ResourceCapabilityImpl(resource, cap));
                        }
                    }
                }
            }
        }

        return matchingCapabilities;
    }

    /**
     * Determines which resource is preferred to deliver the required capability.
     * This method selects the resource providing the highest version of the capability.
     * If two resources provide the same version of the capability, the resource with
     * the largest number of cabailities be preferred
     * @param caps
     * @return
     */
    private ResourceCapability getBestCandidate(List<ResourceCapability> caps)
    {
        Version bestVersion = null;
        ResourceCapability best = null;
        boolean bestLocal = false;

        for (ResourceCapability cap : caps) {
            boolean isCurrentLocal = cap.getResource().isLocal();

            if (best == null) {
                best = cap;
                bestLocal = isCurrentLocal;
                Object v = cap.getCapability().getPropertiesAsMap().get(Resource.VERSION);
                if ((v != null) && (v instanceof Version)) {
                    bestVersion = (Version) v;
                }
            } else if ((m_resolutionFlags & DO_NOT_PREFER_LOCAL) != 0 || !bestLocal || isCurrentLocal) {
                Object v = cap.getCapability().getPropertiesAsMap().get(Resource.VERSION);

                // If there is no version, then select the resource
                // with the greatest number of capabilities.
                if ((v == null) && (bestVersion == null)
                        && (best.getResource().getCapabilities().length
                        < cap.getResource().getCapabilities().length)) {
                    best = cap;
                    bestLocal = isCurrentLocal;
                    bestVersion = null;
                } else if ((v != null) && (v instanceof Version)) {
                    // If there is no best version or if the current
                    // resource's version is lower, then select it.
                    if ((bestVersion == null) || (bestVersion.compareTo((Version) v) < 0)) {
                        best = cap;
                        bestLocal = isCurrentLocal;
                        bestVersion = (Version) v;
                    }
                    // If the current resource version is equal to the
                    // best
                    else if ((bestVersion.compareTo((Version) v) == 0)) {
                        // If the symbolic name is the same, use the highest
                        // bundle version.
                        if ((best.getResource().getSymbolicName() != null)
                                && best.getResource().getSymbolicName().equals(
                                cap.getResource().getSymbolicName())) {
                            if (best.getResource().getVersion().compareTo(
                                    cap.getResource().getVersion()) < 0) {
                                best = cap;
                                bestLocal = isCurrentLocal;
                                bestVersion = (Version) v;
                            }
                        }
                        // Otherwise select the one with the greatest
                        // number of capabilities.
                        else if (best.getResource().getCapabilities().length
                                < cap.getResource().getCapabilities().length) {
                            best = cap;
                            bestLocal = isCurrentLocal;
                            bestVersion = (Version) v;
                        }
                    }
                }
            }
        }

        return (best == null) ? null : best;
    }

    private void checkInterrupt()
    {
        if (Thread.interrupted())
        {
            throw new org.apache.felix.bundlerepository.InterruptedResolutionException();
        }
    }

    public synchronized void deploy(int flags)
    {
        // Must resolve if not already resolved.
        if (!m_resolved && !resolve(flags))
        {
            m_logger.log(Logger.LOG_ERROR, "Resolver: Cannot resolve target resources.");
            return;
        }

        // Check to make sure that our local state cache is up-to-date
        // and error if it is not. This is not completely safe, because
        // the state can still change during the operation, but we will
        // be optimistic. This could also be made smarter so that it checks
        // to see if the local state changes overlap with the resolver.
        for (int repoIdx = 0; (m_repositories != null) && (repoIdx < m_repositories.length); repoIdx++)
        {
            if (m_repositories[repoIdx].getLastModified() > m_resolveTimeStamp)
            {
                throw new IllegalStateException("Framework state has changed, must resolve again.");
            }
        }

        // Eliminate duplicates from target, required, optional resources.
        Set<Resource> resourceSet = new HashSet<Resource>();
        Resource[] resources = getAddedResources();
        for (int i = 0; (resources != null) && (i < resources.length); i++)
        {
            resourceSet.add(resources[i]);
        }
        resources = getRequiredResources();
        for (int i = 0; (resources != null) && (i < resources.length); i++)
        {
            resourceSet.add(resources[i]);
        }
        if ((flags & NO_OPTIONAL_RESOURCES) == 0)
        {
            resources = getOptionalResources();
            for (int i = 0; (resources != null) && (i < resources.length); i++)
            {
                resourceSet.add(resources[i]);
            }
        }
        Resource[] deployResources = resourceSet.toArray(new Resource[resourceSet.size()]);

        // List to hold all resources to be started.
        List<Bundle> startList = new ArrayList<Bundle>();

        // Deploy each resource, which will involve either finding a locally
        // installed resource to update or the installation of a new version
        // of the resource to be deployed.
        for (Resource deployResource : deployResources) {
            // For the resource being deployed, see if there is an older
            // version of the resource already installed that can potentially
            // be updated.
            LocalResource localResource = findUpdatableLocalResource(deployResource);
            // If a potentially updatable older version was found,
            // then verify that updating the local resource will not
            // break any of the requirements of any of the other
            // resources being deployed.
            if ((localResource != null) &&
                    isResourceUpdatable(localResource, deployResource, deployResources)) {
                // Only update if it is a different version.
                if (!localResource.equals(deployResource)) {
                    // Update the installed bundle.
                    try {
                        // stop the bundle before updating to prevent
                        // the bundle update from throwing due to not yet
                        // resolved dependencies
                        boolean doStartBundle = (flags & START) != 0;
                        if (localResource.getBundle().getState() == Bundle.ACTIVE) {
                            doStartBundle = true;
                            localResource.getBundle().stop();
                        }

                        localResource.getBundle().update(FileUtil.openURL(new URL(deployResource.getURI())));

                        // If necessary, save the updated bundle to be
                        // started later.
                        if (doStartBundle) {
                            Bundle bundle = localResource.getBundle();
                            if (!isFragmentBundle(bundle)) {
                                startList.add(bundle);
                            }
                        }
                    } catch (Exception ex) {
                        m_logger.log(
                                Logger.LOG_ERROR,
                                "Resolver: Update error - " + getBundleName(localResource.getBundle()),
                                ex);
                        return;
                    }
                }
            } else {
                // Install the bundle.
                try {
                    // Perform the install, but do not use the actual
                    // bundle JAR URL for the bundle location, since this will
                    // limit OBR's ability to manipulate bundle versions. Instead,
                    // use a unique timestamp as the bundle location.
                    URL url = new URL(deployResource.getURI());
                    Bundle bundle = m_context.installBundle(
                            "obr://"
                                    + deployResource.getSymbolicName()
                                    + "/-" + System.currentTimeMillis(),
                            FileUtil.openURL(url));

                    // If necessary, save the installed bundle to be
                    // started later.
                    if ((flags & START) != 0) {
                        if (!isFragmentBundle(bundle)) {
                            startList.add(bundle);
                        }
                    }
                } catch (Exception ex) {
                    m_logger.log(
                            Logger.LOG_ERROR,
                            "Resolver: Install error - " + deployResource.getSymbolicName(),
                            ex);
                    return;
                }
            }
        }

        for (Bundle aStartList : startList) {
            try {
                aStartList.start();
            } catch (BundleException ex) {
                m_logger.log(
                        Logger.LOG_ERROR,
                        "Resolver: Start error - " + aStartList.getSymbolicName(),
                        ex);
            }
        }
    }

    /**
     * Determines if the given bundle is a fragement bundle.
     *
     * @param bundle bundle to check
     * @return flag indicating if the given bundle is a fragement
     */
    private boolean isFragmentBundle(Bundle bundle)
    {
        return bundle.getHeaders().get(Constants.FRAGMENT_HOST) != null;
    }

    // TODO: OBR - Think about this again and make sure that deployment ordering
    // won't impact it...we need to update the local state too.
    private LocalResource findUpdatableLocalResource(Resource resource)
    {
        // Determine if any other versions of the specified resource
        // already installed.
        LocalResource[] localResources = findLocalResources(resource.getSymbolicName());
        // Since there are local resources with the same symbolic
        // name installed, then we must determine if we can
        // update an existing resource or if we must install
        // another one. Loop through all local resources with same
        // symbolic name and find the first one that can be updated
        // without breaking constraints of existing local resources.
        for (LocalResource localResource : localResources) {
            if (isResourceUpdatable(localResource, resource, localResources)) {
                return localResource;
            }
        }
        return null;
    }

    /**
     * Returns all local resources with the given symbolic name.
     * @param symName The symbolic name of the wanted local resources.
     * @return The local resources with the specified symbolic name.
     */
    private LocalResource[] findLocalResources(String symName)
    {
        LocalResource[] localResources = getLocalResources();

        List<LocalResource> matchList = new ArrayList<LocalResource>();
        for (LocalResource localResource : localResources) {
            String localSymName = localResource.getSymbolicName();
            if ((localSymName != null) && localSymName.equals(symName)) {
                matchList.add(localResource);
            }
        }
        return matchList.toArray(new LocalResource[matchList.size()]);
    }

    private boolean isResourceUpdatable(
        Resource oldVersion, Resource newVersion, Resource[] resources)
    {
        // Get all of the local resolvable requirements for the old
        // version of the resource from the specified resource array.
        Requirement[] reqs = getResolvableRequirements(oldVersion, resources);
        if (reqs == null)
        {
            return true;
        }

        // Now make sure that all of the requirements resolved by the
        // old version of the resource can also be resolved by the new
        // version of the resource.
        Capability[] caps = newVersion.getCapabilities();
        if (caps == null)
        {
            return false;
        }
        for (Requirement req : reqs) {
            boolean satisfied = false;
            for (int capIdx = 0; !satisfied && (capIdx < caps.length); capIdx++) {
                if (req.isSatisfied(caps[capIdx])) {
                    satisfied = true;
                }
            }

            // If any of the previously resolved requirements cannot
            // be resolved, then the resource is not updatable.
            if (!satisfied) {
                return false;
            }
        }

        return true;
    }

    private Requirement[] getResolvableRequirements(Resource resource, Resource[] resources)
    {
        // For the specified resource, find all requirements that are
        // satisfied by any of its capabilities in the specified resource
        // array.
        Capability[] caps = resource.getCapabilities();
        if ((caps != null) && (caps.length > 0))
        {
            List<Requirement> reqList = new ArrayList<Requirement>();
            for (Capability cap : caps) {
                boolean added = false;

                for (Resource aResource : resources) {
                    Requirement[] reqs = aResource.getRequirements();

                    if (reqs != null) {
                        for (Requirement req : reqs) {
                            if (req.isSatisfied(cap)) {
                                added = true;
                                reqList.add(req);
                            }
                        }
                    }

                    if (added) break;
                }
            }
            return reqList.toArray(new Requirement[reqList.size()]);
        }
        return null;
    }

    public static String getBundleName(Bundle bundle)
    {
        String name = bundle.getHeaders().get(Constants.BUNDLE_NAME);
        return (name == null)
            ? "Bundle " + Long.toString(bundle.getBundleId())
            : name;
    }

}