// Populate mandatory resources; since these are mandatory
// resources, failure throws a resolve exception.
for (Iterator<Resource> it = mandatoryResources.iterator();
it.hasNext();)
{
Resource resource = it.next();
if (Util.isFragment(resource) || (rc.getWirings().get(resource) == null))
{
allCandidates.populate(rc, resource, Candidates.MANDATORY);
}
else
{
it.remove();
}
}
// Populate optional resources; since these are optional
// resources, failure does not throw a resolve exception.
for (Resource resource : optionalResources)
{
boolean isFragment = Util.isFragment(resource);
if (isFragment || (rc.getWirings().get(resource) == null))
{
allCandidates.populate(rc, resource, Candidates.OPTIONAL);
}
}
// Merge any fragments into hosts.
allCandidates.prepare(rc);
// Create a combined list of populated resources; for
// optional resources. We do not need to consider ondemand
// fragments, since they will only be pulled in if their
// host is already present.
Set<Resource> allResources =
new HashSet<Resource>(mandatoryResources);
for (Resource resource : optionalResources)
{
if (allCandidates.isPopulated(resource))
{
allResources.add(resource);
}
}
List<Candidates> usesPermutations = session.getUsesPermutations();
List<Candidates> importPermutations = session.getImportPermutations();
// Record the initial candidate permutation.
usesPermutations.add(allCandidates);
ResolutionException rethrow = null;
// If a populated resource is a fragment, then its host
// must ultimately be verified, so store its host requirement
// to use for package space calculation.
Map<Resource, List<Requirement>> hostReqs =
new HashMap<Resource, List<Requirement>>();
for (Resource resource : allResources)
{
if (Util.isFragment(resource))
{
hostReqs.put(
resource,
resource.getRequirements(HostNamespace.HOST_NAMESPACE));
}
}
Map<Resource, ResolutionException> faultyResources = null;
do
{
rethrow = null;
resourcePkgMap.clear();
session.getPackageSourcesCache().clear();
// Null out each time a new permutation is attempted.
// We only use this to store a valid permutation which is a
// delta of the current permutation.
session.setMultipleCardCandidates(null);
allCandidates = (usesPermutations.size() > 0)
? usesPermutations.remove(0)
: importPermutations.remove(0);
//allCandidates.dump();
Map<Resource, ResolutionException> currentFaultyResources = null;
try
{
allCandidates.checkSubstitutes(importPermutations);
}
catch (ResolutionException e)
{
rethrow = e;
continue;
}
// Reuse a resultCache map for checking package consistency
// for all resources.
Map<Resource, Object> resultCache =
new HashMap<Resource, Object>(allResources.size());
// Check the package space consistency for all 'root' resources.
for (Resource resource : allResources)
{
Resource target = resource;
// If we are resolving a fragment, then get its
// host candidate and verify it instead.
List<Requirement> hostReq = hostReqs.get(resource);
if (hostReq != null)
{
target = allCandidates.getCandidates(hostReq.get(0))
.iterator().next().getResource();
}
calculatePackageSpaces(
session, allCandidates.getWrappedHost(target), allCandidates,
resourcePkgMap, new HashMap(), new HashSet());
//System.out.println("+++ PACKAGE SPACES START +++");
//dumpResourcePkgMap(resourcePkgMap);
//System.out.println("+++ PACKAGE SPACES END +++");
try
{
checkPackageSpaceConsistency(
session, allCandidates.getWrappedHost(target),
allCandidates, resourcePkgMap, resultCache);
}
catch (ResolutionException ex)
{
rethrow = ex;
if (currentFaultyResources == null)
{
currentFaultyResources = new HashMap<Resource, ResolutionException>();
}
Resource faultyResource = resource;
// check that the faulty requirement is not from a fragment
for (Requirement faultyReq : ex.getUnresolvedRequirements())
{
if (faultyReq instanceof WrappedRequirement)
{
faultyResource =
((WrappedRequirement) faultyReq)
.getDeclaredRequirement().getResource();
break;
}
}
currentFaultyResources.put(faultyResource, ex);
}
}
if (currentFaultyResources != null)
{
if (faultyResources == null)
{
faultyResources = currentFaultyResources;
}
else if (faultyResources.size() > currentFaultyResources.size())
{
// save the optimal faultyResources which has less
faultyResources = currentFaultyResources;
}
}
}
while ((rethrow != null)
&& ((usesPermutations.size() > 0) || (importPermutations.size() > 0)));
// If there is a resolve exception, then determine if an
// optionally resolved resource is to blame (typically a fragment).
// If so, then remove the optionally resolved resolved and try
// again; otherwise, rethrow the resolve exception.
if (rethrow != null)
{
if (faultyResources != null)
{
Set<Resource> resourceKeys = faultyResources.keySet();
retry = (optionalResources.removeAll(resourceKeys));
for (Resource faultyResource : resourceKeys)
{
Boolean valid = validOnDemandResources.get(faultyResource);
if (valid != null && valid.booleanValue())
{
// This was an ondemand resource.
// Invalidate it and try again.
validOnDemandResources.put(faultyResource, Boolean.FALSE);
retry = true;
}
}
// log all the resolution exceptions for the uses constraint violations
for (Map.Entry<Resource, ResolutionException> usesError : faultyResources.entrySet())
{
m_logger.logUsesConstraintViolation(usesError.getKey(), usesError.getValue());
}
}
if (!retry)
{
throw rethrow;
}
}
// If there is no exception to rethrow, then this was a clean
// resolve, so populate the wire map.
else
{
if (session.getMultipleCardCandidates() != null)
{
// Candidates for multiple cardinality requirements were
// removed in order to provide a consistent class space.
// Use the consistent permutation
allCandidates = session.getMultipleCardCandidates();
}
for (Resource resource : allResources)
{
Resource target = resource;
// If we are resolving a fragment, then we
// actually want to populate its host's wires.
List<Requirement> hostReq = hostReqs.get(resource);
if (hostReq != null)