Examples with FeaturePackPluginVisitor org.jboss.galleon.layout.FeaturePackPluginVisitor used on opensource projects

Example 1 with FeaturePackPluginVisitor

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