Examples with FeaturePackConfig org.jboss.galleon.config.FeaturePackConfig used on opensource projects

Example 1 with FeaturePackConfig

use of org.jboss.galleon.config.FeaturePackConfig in project galleon by wildfly.

the class CliTestUtils method installAndCheck.

public static Path installAndCheck(CliWrapper cli, String dirName, FeaturePackLocation toInstall, FeaturePackLocation expected) throws Exception {
    Path dir = cli.newDir(dirName, false);
    cli.execute("install " + toInstall + " --dir=" + dir.toString());
    Assert.assertTrue(dir.toFile().exists());
    ProvisioningConfig config = CliTestUtils.getConfig(dir);
    FeaturePackConfig cf = config.getFeaturePackDep(toInstall.getProducer());
    Assert.assertEquals(cf.getLocation().toString(), expected, cf.getLocation());
    return dir;
}

Example 2 with FeaturePackConfig

use of org.jboss.galleon.config.FeaturePackConfig in project galleon by wildfly.

the class FeatureContainers method buildFullRuntime.

private static ProvisioningRuntime buildFullRuntime(FPID fpid, PmSession pmSession) throws ProvisioningException {
    FeaturePackConfig config = FeaturePackConfig.forLocation(fpid.getLocation());
    ProvisioningConfig provisioning = ProvisioningConfig.builder().addFeaturePackDep(config).build();
    ProvisioningRuntime runtime = ProvisioningRuntimeBuilder.newInstance(pmSession.getMessageWriter(false)).initLayout(pmSession.getLayoutFactory(), provisioning).build();
    return runtime;
}

Example 3 with FeaturePackConfig

use of org.jboss.galleon.config.FeaturePackConfig 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);
}

Example 4 with FeaturePackConfig

use of org.jboss.galleon.config.FeaturePackConfig in project galleon by wildfly.

the class ProvisioningLayout method layout.

private void layout(FeaturePackDepsConfig config, Map<ProducerSpec, FPID> branch, int type) throws ProvisioningException {
    if (!config.hasFeaturePackDeps()) {
        return;
    }
    List<ProducerSpec> added = Collections.emptyList();
    if (config.hasTransitiveDeps()) {
        if (transitiveDeps == null) {
            transitiveDeps = new HashSet<>();
        }
        for (FeaturePackConfig transitiveConfig : config.getTransitiveDeps()) {
            FeaturePackLocation fpl = transitiveConfig.getLocation();
            if (transitiveConfig.hasPatches()) {
                addPatches(transitiveConfig);
            }
            final FPID branchId = branch.get(fpl.getProducer());
            if (branchId != null) {
                if (!branchId.getChannel().getName().equals(fpl.getChannel().getName())) {
                    addConflict(fpl.getFPID(), branchId);
                }
                continue;
            }
            if (fpl.isMavenCoordinates()) {
                final F f = resolveFeaturePack(fpl, FeaturePackLayout.TRANSITIVE_DEP, true);
                fpl = f.getSpec().getFPID().getLocation();
                registerResolvedVersion(transitiveConfig.getLocation().getProducer(), fpl);
                registerMavenProducer(transitiveConfig.getLocation().getProducer(), f);
            }
            transitiveDeps.add(fpl.getProducer());
            branch.put(fpl.getProducer(), fpl.getFPID());
            added = CollectionUtils.add(added, fpl.getProducer());
        }
    }
    final Collection<FeaturePackConfig> fpDeps = config.getFeaturePackDeps();
    List<F> queue = new ArrayList<>(fpDeps.size());
    for (FeaturePackConfig fpConfig : fpDeps) {
        FeaturePackLocation fpl = fpConfig.getLocation();
        if (fpConfig.hasPatches()) {
            addPatches(fpConfig);
        }
        FPID branchId = branch.get(fpl.getProducer());
        fpl = resolveVersion(fpl, branchId);
        F fp = null;
        if (!fpl.isMavenCoordinates()) {
            fp = featurePacks.get(fpl.getProducer());
            if (fp != null) {
                converge(branchId, fpl.getFPID(), fp.getFPID());
                continue;
            }
        }
        fp = resolveFeaturePack(fpl, type, true);
        if (fpl.isMavenCoordinates()) {
            if (branchId == null) {
                branchId = branch.get(fp.getFPID().getProducer());
            }
            final FeaturePackLocation resolvedFpl = resolveVersion(fp.getFPID().getLocation(), branchId);
            F resolvedFp = featurePacks.get(resolvedFpl.getProducer());
            if (resolvedFp != null) {
                converge(branchId, resolvedFpl.getFPID(), resolvedFp.getFPID());
                if (!fpl.equals(resolvedFpl)) {
                    registerMavenProducer(fpl.getProducer(), resolvedFp);
                }
                continue;
            }
            if (!fpl.equals(resolvedFpl)) {
                if (branchId != null) {
                    fp = resolveFeaturePack(resolvedFpl, type, true);
                } else {
                    registerResolvedVersion(fpl.getProducer(), resolvedFpl);
                }
                registerMavenProducer(fpl.getProducer(), fp);
                fpl = resolvedFpl;
            }
        }
        registerFeaturePack(fpl.getProducer(), fp);
        queue.add(fp);
        if (branchId == null || branchId.getBuild() == null) {
            branch.put(fpl.getProducer(), fpl.getFPID());
            added = CollectionUtils.add(added, fpl.getProducer());
        }
    }
    if (!queue.isEmpty()) {
        for (F p : queue) {
            final FeaturePackSpec spec = p.getSpec();
            layout(spec, branch, FeaturePackLayout.TRANSITIVE_DEP);
            if (spec.hasPlugins()) {
                pluginLocations = CollectionUtils.putAll(pluginLocations, spec.getPlugins());
            }
            handle.copyResources(p.getDir());
            ordered.add(p);
        }
    }
    if (!added.isEmpty()) {
        for (ProducerSpec producer : added) {
            branch.remove(producer);
        }
    }
}

Example 5 with FeaturePackConfig

use of org.jboss.galleon.config.FeaturePackConfig in project galleon by wildfly.

the class ProvisioningLayout method dependsOn.

private boolean dependsOn(F f, ProducerSpec dep, Set<ProducerSpec> visitedFps) throws ProvisioningException {
    final FeaturePackSpec spec = f.getSpec();
    if (!spec.hasFeaturePackDeps()) {
        return false;
    }
    if (spec.hasFeaturePackDep(dep) || spec.hasTransitiveDep(dep)) {
        return true;
    }
    for (FeaturePackConfig fpConfig : spec.getFeaturePackDeps()) {
        final ProducerSpec producer = fpConfig.getLocation().getProducer();
        if (!visitedFps.add(producer)) {
            continue;
        }
        if (dependsOn(featurePacks.get(producer), dep, visitedFps)) {
            return true;
        }
        visitedFps.remove(producer);
    }
    return false;
}