use of org.jboss.galleon.spec.PackageDependencySpec in project galleon by wildfly.
the class FeatureContainers method populateFeatureContainer.
private static void populateFeatureContainer(FeatureContainer fp, PmSession session, ProvisioningRuntime runtime, boolean allSpecs) throws ProvisioningException, IOException {
// Need a Map of FeaturePack to resolve external packages/
Map<String, FeaturePackRuntime> gavs = new HashMap<>();
for (FeaturePackRuntime rt : runtime.getFeaturePacks()) {
gavs.put(Identity.buildOrigin(rt.getFPID().getProducer()), rt);
}
List<CliPlugin> cliPlugins = new ArrayList<>();
FeaturePackPluginVisitor<CliPlugin> visitor = new FeaturePackPluginVisitor<CliPlugin>() {
@Override
public void visitPlugin(CliPlugin plugin) throws ProvisioningException {
cliPlugins.add(plugin);
}
};
runtime.getLayout().visitPlugins(visitor, CliPlugin.class);
CliPlugin plugin = cliPlugins.isEmpty() ? null : cliPlugins.get(0);
PackageGroupsBuilder pkgBuilder = new PackageGroupsBuilder();
FeatureSpecsBuilder specsBuilder = new FeatureSpecsBuilder();
String optionalOption = runtime.getProvisioningConfig().getOption(ProvisioningOption.OPTIONAL_PACKAGES.getName());
if (optionalOption == null) {
optionalOption = Constants.ALL;
}
boolean includeOptional = false;
boolean includePassive = false;
boolean checkPassive = false;
if (optionalOption.equals(Constants.ALL)) {
includePassive = true;
includeOptional = true;
} else {
if (optionalOption.equals(Constants.NONE)) {
// No optional included.
includeOptional = false;
includePassive = false;
} else {
if (optionalOption.equals(Constants.PASSIVE)) {
// Include passives that have dependencies present.
includeOptional = false;
includePassive = true;
checkPassive = true;
} else {
if (optionalOption.equals(Constants.PASSIVE_PLUS)) {
// Include passives that have dependencies present and optionals
includeOptional = true;
includePassive = true;
checkPassive = true;
} else {
throw new ProvisioningException("Not recognized value for " + Constants.OPTIONAL_PACKAGES);
}
}
}
}
boolean includeOptionalF = includeOptional;
boolean includePassiveF = includePassive;
Map<String, Map<String, PackageRuntime>> allPackages = new HashMap<>();
for (FeaturePackRuntime rt : runtime.getFeaturePacks()) {
fp.addLayers(rt.loadLayers());
pkgBuilder.resetRoots();
allPackages.put(rt.getFPID().getProducer().toString(), new HashMap<>());
for (PackageRuntime pkg : rt.getPackages()) {
if (checkPassive && pkg.isPassive() && !pkg.isPassiveIncluded()) {
// exclude passives that don't match.
continue;
}
allPackages.get(rt.getFPID().getProducer().toString()).put(pkg.getName(), pkg);
pkgBuilder.buildGroups(new PackageInfo(pkg, Identity.fromChannel(rt.getFPID().getProducer(), pkg.getName()), plugin), new PackageGroupsBuilder.PackageInfoBuilder() {
@Override
public PackageInfo build(Identity identity, PackageInfo parent) {
try {
// Packages that have no origin, doesn't mean that they are local.
// It depends on the way FP dependencies have an origin or not.
// If a FP dependency has no origin, the "local" package could be
// located in this dependency.
FeaturePackRuntime currentRuntime = parent.getFeaturePackRuntime();
Identity resolvedIdentity = null;
PackageRuntime p = null;
if (identity.getOrigin().equals(Identity.EMPTY)) {
// First local to the parent package.
p = currentRuntime.getPackage(identity.getName());
if (p == null) {
// Then lookup dependencies with no origin.
for (FeaturePackConfig fpdep : currentRuntime.getSpec().getFeaturePackDeps()) {
if (currentRuntime.getSpec().originOf(fpdep.getLocation().getProducer()) == null) {
FeaturePackRuntime depRuntime = gavs.get(Identity.buildOrigin(fpdep.getLocation().getProducer()));
p = depRuntime.getPackage(identity.getName());
if (p != null) {
resolvedIdentity = Identity.fromChannel(fpdep.getLocation().getProducer(), identity.getName());
break;
}
}
}
} else {
resolvedIdentity = Identity.fromChannel(currentRuntime.getFPID().getProducer(), identity.getName());
}
} else {
// Could be a free text, maps that to ga. Only ga are exposed as origin for now.
// XXX JFDENISE, TODO, we could expose actual origin but would require to expose the mapping.
FeaturePackRuntime extRt = gavs.get(identity.getOrigin());
if (extRt == null) {
FeaturePackConfig fpdep = currentRuntime.getSpec().getFeaturePackDep(identity.getOrigin());
if (fpdep != null) {
resolvedIdentity = Identity.fromChannel(fpdep.getLocation().getProducer(), identity.getName());
extRt = gavs.get(resolvedIdentity.getOrigin());
}
} else {
resolvedIdentity = identity;
}
if (extRt != null) {
p = extRt.getPackage(identity.getName());
}
}
if (p == null) {
// Optional package that has been excluded
return null;
}
return new PackageInfo(p, resolvedIdentity, plugin);
} catch (IOException | ProvisioningException e) {
throw new RuntimeException(e);
}
}
});
}
fp.setPackagesRoot(Identity.buildOrigin(rt.getFPID().getProducer()), pkgBuilder.getPackagesRoot());
// Attach the full set, this targets the container dependency that expose them all.
if (allSpecs) {
Group specsRoot = specsBuilder.buildTree(runtime.getLayout(), session, rt.getFPID(), fp.getFPID(), pkgBuilder.getPackages(), allSpecs, null);
fp.setFeatureSpecRoot(Identity.buildOrigin(rt.getFPID().getProducer()), specsRoot);
}
}
fp.setAllPackages(pkgBuilder.getPackages());
Map<ProducerSpec, Set<ResolvedSpecId>> actualSet = new HashMap<>();
Map<ResolvedSpecId, List<FeatureInfo>> features = new HashMap<>();
for (ProvisionedConfig c : runtime.getConfigs()) {
ConfigInfo config = new ConfigInfo(c.getModel(), c.getName(), c.getLayers());
fp.addFinalConfig(config);
FeatureGroupsBuilder grpBuilder = new FeatureGroupsBuilder();
c.handle(new ProvisionedConfigHandler() {
@Override
public void nextFeature(ProvisionedFeature feature) throws ProvisioningException {
FeaturePackRuntime rt = runtime.getFeaturePack(feature.getSpecId().getProducer());
FeatureSpec featureSpec = rt.getFeatureSpec(feature.getSpecId().getName());
ProducerSpec producer = feature.getSpecId().getProducer();
for (PackageDependencySpec spec : featureSpec.getLocalPackageDeps()) {
PackageRuntime pkg = allPackages.get(producer.toString()).get(spec.getName());
if (pkg != null) {
if (includePassiveF && pkg.isPassive()) {
fp.addPassivePackage(producer.toString(), feature.getSpecId().getName(), spec.getName());
} else {
if (includeOptionalF && pkg.isOptional()) {
fp.addOptionalPackage(producer.toString(), feature.getSpecId().getName(), spec.getName());
}
}
}
}
if (featureSpec.hasExternalPackageDeps()) {
for (String origin : featureSpec.getPackageOrigins()) {
for (PackageDependencySpec spec : featureSpec.getExternalPackageDeps(origin)) {
PackageRuntime pkg = allPackages.get(origin).get(spec.getName());
if (pkg != null) {
if (includePassiveF && pkg.isPassive()) {
fp.addPassivePackage(origin, feature.getSpecId().getName(), spec.getName());
} else if (includeOptionalF && pkg.isOptional()) {
fp.addOptionalPackage(origin, feature.getSpecId().getName(), spec.getName());
}
}
}
}
}
Set<ResolvedSpecId> set = actualSet.get(feature.getSpecId().getProducer());
if (set == null) {
set = new HashSet<>();
actualSet.put(feature.getSpecId().getProducer(), set);
}
set.add(feature.getSpecId());
String fullSpecName = feature.getSpecId().getName();
List<String> path = new ArrayList<>();
Group parent = grpBuilder.buildFeatureGroups(fullSpecName, feature.getId(), path);
FeatureInfo featInfo = new FeatureInfo(config, feature, path, fp.getFPID());
List<FeatureInfo> lst = features.get(feature.getSpecId());
if (lst == null) {
lst = new ArrayList<>();
features.put(feature.getSpecId(), lst);
}
lst.add(featInfo);
parent.setFeature(featInfo);
// Specs have already been computed first place.
if (allSpecs) {
FeatureSpecInfo spec = specsBuilder.getAllSpecs().get(feature.getSpecId());
featInfo.attachSpecInfo(spec);
parent.setFeature(featInfo);
}
}
});
config.setFeatureGroupRoot(grpBuilder.getRoot());
}
// Handle packages that are not directly referenced from a feature.
for (Entry<String, Map<String, PackageRuntime>> packageEntry : allPackages.entrySet()) {
String producer = packageEntry.getKey();
Set<String> allOptionals = new HashSet<>();
Set<String> allPassives = new HashSet<>();
Map<String, Set<String>> optionals = fp.getOptionalPackages().get(producer);
if (optionals != null) {
for (Set<String> vals : optionals.values()) {
allOptionals.addAll(vals);
}
}
Map<String, Set<String>> passives = fp.getPassivePackages().get(producer);
if (passives != null) {
for (Set<String> vals : passives.values()) {
allPassives.addAll(vals);
}
}
Map<String, PackageRuntime> packages = packageEntry.getValue();
for (Entry<String, PackageRuntime> entry : packages.entrySet()) {
String name = entry.getKey();
PackageRuntime pkg = entry.getValue();
if (!allOptionals.contains(name) && !allPassives.contains(name)) {
if (includePassiveF && pkg.isPassive()) {
fp.addOrphanPassivePackage(producer, name);
} else if (includeOptionalF && pkg.isOptional()) {
fp.addOrphanOptionalPackage(producer, name);
}
}
}
}
if (!allSpecs) {
// packages and feature-specs.
for (Entry<ProducerSpec, Set<ResolvedSpecId>> entry : actualSet.entrySet()) {
Group specsRoot = specsBuilder.buildTree(runtime.getLayout(), session, entry.getKey().getLocation().getFPID(), fp.getFPID(), pkgBuilder.getPackages(), false, entry.getValue());
for (ResolvedSpecId rs : entry.getValue()) {
List<FeatureInfo> lst = features.get(rs);
for (FeatureInfo fi : lst) {
fi.attachSpecInfo(specsBuilder.getAllSpecs().get(rs));
}
}
fp.setFeatureSpecRoot(Identity.buildOrigin(entry.getKey()), specsRoot);
}
}
fp.seAllFeatureSpecs(specsBuilder.getAllSpecs());
fp.setAllFeatures(features);
}
use of org.jboss.galleon.spec.PackageDependencySpec in project galleon by wildfly.
the class FeatureSpecsBuilder method buildTree.
public Group buildTree(ProvisioningLayout<FeaturePackRuntime> layout, PmSession session, FPID fpid, FPID id, Map<Identity, Group> allPackages, boolean useCache, Set<ResolvedSpecId> wantedSpecs) throws IOException, ProvisioningException {
// Build the tree of specs located in all feature-packs
FeatureGroupsBuilder grpBuilder = new FeatureGroupsBuilder();
Set<FeatureSpecInfo> specs = new HashSet<>();
for (ResolvedFeatureSpec resolvedSpec : layout.getFeaturePack(fpid.getProducer()).getFeatureSpecs()) {
ResolvedSpecId resolved = resolvedSpec.getId();
if (wantedSpecs == null || wantedSpecs.contains(resolved)) {
FeatureSpecInfo specInfo = allspecs.get(resolved);
if (specInfo == null) {
Set<Identity> missingPackages = new HashSet<>();
FeatureSpec spec = resolvedSpec.getSpec();
specInfo = new FeatureSpecInfo(resolved, id, spec);
Identity specId = Identity.fromChannel(resolved.getProducer(), resolved.getName());
boolean featureEnabled = true;
for (PackageDependencySpec p : spec.getLocalPackageDeps()) {
Identity identity = Identity.fromChannel(resolved.getProducer(), p.getName());
Group grp = allPackages.get(identity);
// Group can be null if the modules have not been installed.
if (grp != null) {
specInfo.addPackage(grp.getPackage());
attachProvider(specId, grp, new HashSet<>());
} else {
featureEnabled = false;
missingPackages.add(identity);
}
}
for (String o : spec.getPackageOrigins()) {
for (PackageDependencySpec p : spec.getExternalPackageDeps(o)) {
Identity identity = Identity.fromString(o, p.getName());
Group grp = allPackages.get(identity);
if (grp != null) {
specInfo.addPackage(grp.getPackage());
attachProvider(specId, grp, new HashSet<>());
} else {
featureEnabled = false;
missingPackages.add(identity);
}
}
}
specInfo.setEnabled(featureEnabled);
specInfo.setMissingPackages(missingPackages);
allspecs.put(resolved, specInfo);
specs.add(specInfo);
}
String fullSpecName = resolved.getName();
List<String> path = new ArrayList<>();
Group parent = grpBuilder.buildFeatureSpecGroups(fullSpecName, specInfo, path);
parent.setFeatureSpec(specInfo);
}
}
return grpBuilder.getRoot();
}
use of org.jboss.galleon.spec.PackageDependencySpec in project galleon by wildfly.
the class PackageGroupsBuilder method buildGroups.
private void buildGroups(Group grp, PackageInfo pkg, PackageInfoBuilder builder) {
if (pkg == null) {
// Excluded optional package referenced from other package.
return;
}
Group gp = allPackagesGroups.get(pkg.getIdentity());
if (gp == null) {
gp = Group.fromIdentity(pkg.getIdentity());
allPackagesGroups.put(pkg.getIdentity(), gp);
gp.setPackage(pkg);
for (PackageDependencySpec s : pkg.getSpec().getLocalPackageDeps()) {
buildGroups(gp, builder.build(Identity.fromString(s.getName()), pkg), builder);
}
for (String o : pkg.getSpec().getPackageOrigins()) {
for (PackageDependencySpec p : pkg.getSpec().getExternalPackageDeps(o)) {
buildGroups(gp, builder.build(Identity.fromString(o, p.getName()), pkg), builder);
}
}
}
grp.addGroup(gp);
}
use of org.jboss.galleon.spec.PackageDependencySpec in project galleon by wildfly.
the class PackageXmlWriterTestCase method testOrderOfPackageDeps.
@Test
public void testOrderOfPackageDeps() throws Exception {
PackageSpec originalState = PackageSpec.builder().setName("test-package").addPackageDep("test-dep").addPackageDep("test-dep2").addPackageDep("test-dep3").build();
Path path = marshallToTempFile(originalState);
PackageSpec newState = validator.validateAndParse(path);
assertEquals(originalState, newState);
Iterator<PackageDependencySpec> depsIterator = newState.getLocalPackageDeps().iterator();
assertEquals("test-dep", depsIterator.next().getName());
assertEquals("test-dep2", depsIterator.next().getName());
assertEquals("test-dep3", depsIterator.next().getName());
}
use of org.jboss.galleon.spec.PackageDependencySpec in project galleon by wildfly.
the class PackageXmlWriter method writeOrigin.
private static void writeOrigin(ElementNode deps, String origin, Collection<PackageDependencySpec> depGroup, String ns) {
final ElementNode fpElement = addElement(deps, PackageDepsSpecXmlParser.ORIGIN, ns);
addAttribute(fpElement, Attribute.NAME, origin);
for (PackageDependencySpec depSpec : depGroup) {
writePackageDependency(fpElement, depSpec, ns);
}
}
Aggregations