org.apache.sling.feature.cpconverter.ContentPackage2FeatureModelConverter Maven / Gradle / Ivy
/*
* 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.sling.feature.cpconverter;
import static java.util.Objects.requireNonNull;
import static org.apache.sling.feature.cpconverter.vltpkg.VaultPackageUtils.detectPackageType;
import static org.apache.sling.feature.cpconverter.vltpkg.VaultPackageUtils.getDependencies;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.jackrabbit.vault.fs.io.Archive;
import org.apache.jackrabbit.vault.fs.io.Archive.Entry;
import org.apache.jackrabbit.vault.packaging.Dependency;
import org.apache.jackrabbit.vault.packaging.PackageId;
import org.apache.jackrabbit.vault.packaging.PackageProperties;
import org.apache.jackrabbit.vault.packaging.PackageType;
import org.apache.jackrabbit.vault.packaging.VaultPackage;
import org.apache.sling.feature.ArtifactId;
import org.apache.sling.feature.cpconverter.accesscontrol.AclManager;
import org.apache.sling.feature.cpconverter.accesscontrol.DefaultAclManager;
import org.apache.sling.feature.cpconverter.artifacts.ArtifactsDeployer;
import org.apache.sling.feature.cpconverter.artifacts.FileArtifactWriter;
import org.apache.sling.feature.cpconverter.features.FeaturesManager;
import org.apache.sling.feature.cpconverter.filtering.ResourceFilter;
import org.apache.sling.feature.cpconverter.handlers.DefaultHandler;
import org.apache.sling.feature.cpconverter.handlers.EntryHandler;
import org.apache.sling.feature.cpconverter.handlers.EntryHandlersManager;
import org.apache.sling.feature.cpconverter.handlers.NodeTypesEntryHandler;
import org.apache.sling.feature.cpconverter.handlers.slinginitialcontent.BundleSlingInitialContentExtractor;
import org.apache.sling.feature.cpconverter.index.DefaultIndexManager;
import org.apache.sling.feature.cpconverter.index.IndexManager;
import org.apache.sling.feature.cpconverter.vltpkg.BaseVaultPackageScanner;
import org.apache.sling.feature.cpconverter.vltpkg.PackagesEventsEmitter;
import org.apache.sling.feature.cpconverter.vltpkg.RecollectorVaultPackageScanner;
import org.apache.sling.feature.cpconverter.vltpkg.VaultPackageAssembler;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ContentPackage2FeatureModelConverter extends BaseVaultPackageScanner implements Closeable {
public static final String ZIP_TYPE = "zip";
public static final String PACKAGE_CLASSIFIER = "cp2fm-converted";
private static final String DEFAULT_VERSION = "0.0.0";
private final Map subContentPackages = new HashMap<>();
private final List assemblers = new LinkedList<>();
private final Map> mutableContentsIds = new LinkedHashMap<>();
private EntryHandlersManager handlersManager;
private AclManager aclManager = new DefaultAclManager();
private FeaturesManager featuresManager;
private ResourceFilter resourceFilter;
private ArtifactsDeployer artifactsDeployer;
private ArtifactsDeployer unreferencedArtifactsDeployer;
private VaultPackageAssembler mainPackageAssembler;
private final RecollectorVaultPackageScanner recollectorVaultPackageScanner;
private final List emitters = new ArrayList<>();
private final List deployTasks = new ArrayList<>();
private final File tmpDirectory;
private boolean failOnMixedPackages = false;
private PackagePolicy contentTypePackagePolicy = PackagePolicy.REFERENCE;
private boolean removeInstallHooks = false;
private boolean disablePackageTypeRecalculation = false;
private BundleSlingInitialContentExtractor bundleSlingInitialContentExtractor = new BundleSlingInitialContentExtractor();
private IndexManager indexManager = new DefaultIndexManager();
private RunModePolicy runModePolicy = RunModePolicy.DIRECT_ONLY;
public enum RunModePolicy {
/**
* Only path within containing package is considered for run mode evaluation
*/
DIRECT_ONLY,
/**
* For nesting of multiple levels, run mode constraints are inherited down and prepended
*/
PREPEND_INHERITED
}
public enum PackagePolicy {
/**
* References the content package in the feature model and deploys via the {@link ContentPackage2FeatureModelConverter#artifactsDeployer}
*/
REFERENCE,
/**
* Drops the content package completely (i.e. neither reference it in the feature model nor deploy anywhere)
*
* @deprecated
*/
DROP,
/**
* Deploys the content package via the {@link ContentPackage2FeatureModelConverter#unreferencedArtifactsDeployer}
*/
PUT_IN_DEDICATED_FOLDER
}
public enum SlingInitialContentPolicy {
/**
* Keep in bundle and don't extract
*/
KEEP,
/**
* Extract from bundle into content-packages and feature model
*/
EXTRACT_AND_REMOVE,
/**
* Extract from bundle into content-packages and feature model but keep in bundle as well
*/
EXTRACT_AND_KEEP
}
public ContentPackage2FeatureModelConverter() throws IOException {
this(false, SlingInitialContentPolicy.KEEP, false);
}
public ContentPackage2FeatureModelConverter(boolean strictValidation, @NotNull SlingInitialContentPolicy slingInitialContentPolicy) throws IOException {
this(strictValidation, slingInitialContentPolicy, false);
}
public ContentPackage2FeatureModelConverter(boolean strictValidation, @NotNull SlingInitialContentPolicy slingInitialContentPolicy, boolean disablePackageTypeRecalculation) throws IOException {
this(strictValidation, slingInitialContentPolicy, disablePackageTypeRecalculation, RunModePolicy.DIRECT_ONLY);
}
public ContentPackage2FeatureModelConverter(boolean strictValidation, @NotNull SlingInitialContentPolicy slingInitialContentPolicy, boolean disablePackageTypeRecalculation, @NotNull RunModePolicy runModePolicy) throws IOException {
super(strictValidation);
this.disablePackageTypeRecalculation = disablePackageTypeRecalculation;
this.recollectorVaultPackageScanner = new RecollectorVaultPackageScanner(this, this.packageManager, strictValidation, subContentPackages, slingInitialContentPolicy);
this.tmpDirectory = Files.createTempDirectory("cp2fm-converter").toFile();
this.runModePolicy = runModePolicy;
}
public @NotNull ContentPackage2FeatureModelConverter setEntryHandlersManager(@Nullable EntryHandlersManager handlersManager) {
this.handlersManager = handlersManager;
return this;
}
public @Nullable FeaturesManager getFeaturesManager() {
return featuresManager;
}
public @NotNull ContentPackage2FeatureModelConverter setFeaturesManager(@NotNull FeaturesManager featuresManager) {
this.featuresManager = featuresManager;
if (featuresManager instanceof PackagesEventsEmitter) {
this.emitters.add((PackagesEventsEmitter) featuresManager);
}
return this;
}
public @NotNull ContentPackage2FeatureModelConverter setResourceFilter(@Nullable ResourceFilter resourceFilter) {
this.resourceFilter = resourceFilter;
return this;
}
public @Nullable ArtifactsDeployer getArtifactsDeployer() {
return artifactsDeployer;
}
public @NotNull ContentPackage2FeatureModelConverter setBundlesDeployer(@NotNull ArtifactsDeployer bundlesDeployer) {
this.artifactsDeployer = bundlesDeployer;
return this;
}
public @NotNull ContentPackage2FeatureModelConverter setUnreferencedArtifactsDeployer(@NotNull ArtifactsDeployer unreferencedArtifactsDeployer) {
this.unreferencedArtifactsDeployer = unreferencedArtifactsDeployer;
return this;
}
public @NotNull AclManager getAclManager() {
return aclManager;
}
public @NotNull ContentPackage2FeatureModelConverter setAclManager(@NotNull AclManager aclManager) {
this.aclManager = aclManager;
return this;
}
public boolean hasMainPackageAssembler() {
return mainPackageAssembler != null;
}
public @NotNull VaultPackageAssembler getMainPackageAssembler() {
// verify that mainPackageAssembler has been set before retrieving it
return Objects.requireNonNull(mainPackageAssembler);
}
public @NotNull ContentPackage2FeatureModelConverter setMainPackageAssembler(@NotNull VaultPackageAssembler assembler) {
this.mainPackageAssembler = assembler;
return this;
}
public @NotNull ContentPackage2FeatureModelConverter setEmitter(@NotNull PackagesEventsEmitter emitter) {
this.emitters.add(emitter);
return this;
}
public @NotNull ContentPackage2FeatureModelConverter setContentTypePackagePolicy(@NotNull PackagePolicy contentTypePackagePolicy) {
this.contentTypePackagePolicy = contentTypePackagePolicy;
return this;
}
public @NotNull ContentPackage2FeatureModelConverter setFailOnMixedPackages(boolean failOnMixedPackages) {
this.failOnMixedPackages = failOnMixedPackages;
return this;
}
public @NotNull ContentPackage2FeatureModelConverter setRemoveInstallHooks(boolean removeInstallHook) {
this.removeInstallHooks = removeInstallHook;
return this;
}
public @NotNull ContentPackage2FeatureModelConverter setRunModePolicy(@NotNull RunModePolicy runModePolicy) {
this.runModePolicy = runModePolicy;
return this;
}
public RunModePolicy getRunModePolicy() {
return this.runModePolicy;
}
public @Nullable IndexManager getIndexManager() {
return indexManager;
}
public @NotNull ContentPackage2FeatureModelConverter setIndexManager(IndexManager indexManager) {
this.indexManager = indexManager;
return this;
}
public @NotNull File getTempDirectory() {
return this.tmpDirectory;
}
public void cleanup() throws IOException {
if (this.tmpDirectory.exists()) {
logger.info("Cleaning up tmp directory {}", this.tmpDirectory);
FileUtils.deleteDirectory(this.tmpDirectory);
}
}
public void convert(@NotNull File... contentPackages) throws IOException, ConverterException {
requireNonNull(contentPackages, "Null content-package(s) can not be converted.");
secondPass(firstPass(contentPackages));
}
protected @NotNull Collection firstPass(@NotNull File... contentPackages) throws IOException, ConverterException {
Map idFileMap = new LinkedHashMap<>();
Map idPackageMapping = new ConcurrentHashMap<>();
for (File contentPackage : contentPackages) {
requireNonNull(contentPackage, "Null content-package can not be converted.");
if (!contentPackage.exists() || !contentPackage.isFile()) {
throw new IllegalArgumentException("File " + contentPackage + " does not exist or it is a directory");
}
logger.info("Reading content-package '{}'...", contentPackage);
VaultPackage pack = open(contentPackage);
idPackageMapping.put(pack.getId(), pack);
// analyze sub-content packages in order to filter out
// possible outdated conflicting packages
recollectorVaultPackageScanner.traverse(pack, null);
logger.info("content-package '{}' successfully read!", contentPackage);
aclManager.reset();
bundleSlingInitialContentExtractor.reset();
}
logger.info("Ordering input content-package(s) {}...", idPackageMapping.keySet());
for (VaultPackage pack : idPackageMapping.values()) {
orderDependencies(idFileMap, idPackageMapping, pack, new HashSet<>());
}
logger.info("New content-package(s) order: {}", idFileMap.keySet());
return idFileMap.values();
}
private void secondPass(@NotNull Collection orderedContentPackages) throws IOException, ConverterException {
emitters.stream().forEach(PackagesEventsEmitter::start);
for (VaultPackage vaultPackage : orderedContentPackages) {
try {
emitters.stream().forEach(e -> e.startPackage(vaultPackage));
setMainPackageAssembler(VaultPackageAssembler.create(this.getTempDirectory(), vaultPackage, removeInstallHooks, disablePackageTypeRecalculation));
assemblers.add(getMainPackageAssembler());
ArtifactId mvnPackageId = toArtifactId(vaultPackage.getId(), vaultPackage.getFile());
featuresManager.init(mvnPackageId);
logger.info("Converting content-package '{}'...", vaultPackage.getId());
traverse(vaultPackage, null);
// retrieve the resulting zip-content-package and deploy it to the local mvn bundles dir.
try (VaultPackage result = processContentPackageArchive(getMainPackageAssembler(), null)) {
// finally serialize the Feature Model(s) file(s)
aclManager.addRepoinitExtension(assemblers, featuresManager);
bundleSlingInitialContentExtractor.addRepoInitExtension(assemblers, featuresManager);
indexManager.addRepoinitExtension(featuresManager);
logger.info("Conversion complete!");
featuresManager.serialize();
emitters.stream().forEach(e -> e.endPackage(vaultPackage.getId(), result));
}
} finally {
aclManager.reset();
bundleSlingInitialContentExtractor.reset();
indexManager.reset();
assemblers.clear();
try {
vaultPackage.close();
} catch (Exception e) {
// close quietly
}
}
}
deployPackages();
mutableContentsIds.clear();
emitters.stream().forEach(PackagesEventsEmitter::end);
}
private static void orderDependencies(@NotNull Map idFileMap,
@NotNull Map idPackageMapping,
@NotNull VaultPackage pack,
@NotNull Set visited) throws IOException, ConverterException {
if (!visited.add(pack.getId())) {
throw new ConverterException("Cyclic dependency detected, " + pack.getId() + " was previously visited already");
}
for (Dependency dep : pack.getDependencies()) {
for (java.util.Map.Entry entry : idPackageMapping.entrySet()) {
if (dep.matches(entry.getKey())) {
orderDependencies(idFileMap, idPackageMapping, entry.getValue(), visited);
break;
}
}
}
idFileMap.put(pack.getId(), pack);
idPackageMapping.remove(pack.getId());
}
public void processSubPackage(@NotNull String path, @Nullable String runMode, @NotNull VaultPackage vaultPackage, boolean isEmbeddedPackage) throws IOException, ConverterException {
requireNonNull(path, "Impossible to process a null vault package");
requireNonNull(vaultPackage, "Impossible to process a null vault package");
if (!isSubContentPackageIncluded(path)) {
logger.info("Sub content-package {} is filtered out, so it won't be processed.", path);
return;
}
emitters.stream().forEach(e -> e.startSubPackage(path, vaultPackage));
VaultPackageAssembler clonedPackage = VaultPackageAssembler.create(this.getTempDirectory(), vaultPackage, removeInstallHooks,disablePackageTypeRecalculation);
// Please note: THIS IS A HACK to meet the new requirement without drastically change the original design
// temporary swap the main handler to collect stuff
VaultPackageAssembler handler = getMainPackageAssembler();
Properties parentProps = handler.getPackageProperties();
String parentTypeStr = (String)parentProps.get(PackageProperties.NAME_PACKAGE_TYPE);
boolean isContainerPackage = StringUtils.isNotBlank(parentTypeStr) ? PackageType.CONTAINER.equals(PackageType.valueOf(parentTypeStr.toUpperCase(Locale.ENGLISH))) : false;
setMainPackageAssembler(clonedPackage);
assemblers.add(clonedPackage);
// scan the detected package, first
traverse(vaultPackage, runMode);
//set dependency to parent package if the parent package is an application package & subpackage is embedded
if (isEmbeddedPackage && !isContainerPackage) {
PackageId parentId = new PackageId((String) parentProps.get(PackageProperties.NAME_GROUP),
(String) parentProps.get(PackageProperties.NAME_NAME),
(String) parentProps.get(PackageProperties.NAME_VERSION));
clonedPackage.addDependency(new Dependency(parentId));
}
// deploy the new content-package to the local mvn bundles dir and attach it to the feature
try (VaultPackage result = processContentPackageArchive(clonedPackage, runMode)) {
emitters.stream().forEach(e -> e.endSubPackage(path, vaultPackage.getId(), result));
}
// restore the previous assembler
setMainPackageAssembler(handler);
}
private @NotNull VaultPackage processContentPackageArchive(@NotNull VaultPackageAssembler assembler,
@Nullable String runMode) throws IOException, ConverterException {
File contentPackageArchive = assembler.createPackage();
VaultPackage vaultPackage = open(contentPackageArchive);
PackageType packageType = detectPackageType(vaultPackage);
// SLING-8608 - Fail the conversion if the resulting attached content-package is MIXED type
if (PackageType.MIXED == packageType && failOnMixedPackages) {
throw new ConverterException("Generated content-package '"
+ vaultPackage.getId()
+ "' located in file "
+ contentPackageArchive
+ " is of MIXED type");
}
ArtifactId mvnPackageId = toArtifactId(vaultPackage.getId(), contentPackageArchive);
// special handling for converted packages of type content
if (PackageType.CONTENT == packageType) {
switch (contentTypePackagePolicy) {
case DROP:
mutableContentsIds.put(vaultPackage.getId(), getDependencies(vaultPackage));
logger.info("Dropping package of PackageType.CONTENT {} (content-package id: {})",
mvnPackageId.getArtifactId(), vaultPackage.getId());
break;
case PUT_IN_DEDICATED_FOLDER:
mutableContentsIds.put(vaultPackage.getId(), getDependencies(vaultPackage));
// deploy the new content-package to the unreferenced artifacts deployer
if (unreferencedArtifactsDeployer == null) {
throw new IllegalStateException("ContentTypePackagePolicy PUT_IN_DEDICATED_FOLDER requires a valid deployer ");
}
final String location = unreferencedArtifactsDeployer.deploy(new FileArtifactWriter(contentPackageArchive), runMode, mvnPackageId);
logger.info("Put converted package of PackageType.CONTENT {} (content-package id: {}) at {} (not referenced in feature model)",
mvnPackageId.getArtifactId(), vaultPackage.getId(), location);
break;
case REFERENCE:
deploy(assembler, mvnPackageId, runMode);
}
} else {
deploy(assembler, mvnPackageId, runMode);
}
return vaultPackage;
}
public void deployPackages() {
try {
mutableContentsIds.values().forEach(
value -> value.removeIf(dep -> mutableContentsIds.keySet().stream().anyMatch(dep::matches)));
deployTasks.forEach(Runnable::run);
} catch (RuntimeException ex) {
if (ex.getCause() instanceof Exception) {
throw ex;
}
throw ex;
}
deployTasks.clear();
}
private void deploy(@NotNull VaultPackageAssembler assembler, @NotNull ArtifactId mvnPackageId, @Nullable String runMode) {
Objects.requireNonNull(getFeaturesManager()).addArtifact(runMode, mvnPackageId);
ArtifactsDeployer deployer = Objects.requireNonNull(getArtifactsDeployer());
deployTasks.add(() -> {
assembler.updateDependencies(mutableContentsIds);
try {
File finalContentPackageArchive = assembler.createPackage();
// deploy the new content-package to the local mvn bundles dir
deployer.deploy(new FileArtifactWriter(finalContentPackageArchive), runMode, mvnPackageId);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
});
}
public boolean isSubContentPackageIncluded(@NotNull String path) {
return subContentPackages.containsValue(path);
}
private void process(@NotNull String entryPath, @NotNull Archive archive, @Nullable Entry entry, String runMode) throws IOException, ConverterException {
if (resourceFilter != null && resourceFilter.isFilteredOut(entryPath)) {
throw new ConverterException("Path '"
+ entryPath
+ "' in archive "
+ archive.getMetaInf().getPackageProperties().getId()
+ " not allowed by user configuration, please check configured filtering patterns");
}
EntryHandler entryHandler = handlersManager.getEntryHandlerByEntryPath(entryPath);
if (entryHandler == null) {
entryHandler = new DefaultHandler(getMainPackageAssembler(), removeInstallHooks);
}
if (entry == null) {
entry = archive.getEntry(entryPath);
if (entry == null) {
throw new IllegalArgumentException("Archive '" + archive.getMetaInf().getPackageProperties().getId() + "' does not contain entry with path '" + entryPath + "'");
}
}
entryHandler.handle(entryPath, archive, entry, this, runMode);
if (!getMainPackageAssembler().recordEntryPath(entryPath)) {
logger.warn("Duplicate entry path {}", entryPath);
}
}
public ContentPackage2FeatureModelConverter setBundleSlingInitialContentExtractor(BundleSlingInitialContentExtractor bundleSlingInitialContentExtractor) {
this.bundleSlingInitialContentExtractor = bundleSlingInitialContentExtractor;
return this;
}
@Override
protected void onFile(@NotNull String entryPath, @NotNull Archive archive, @NotNull Entry entry, String runMode) throws IOException, ConverterException {
try {
process(entryPath, archive, entry, runMode);
} catch (ConverterException ex) {
throw new ConverterException("ConverterException occured on path " + entryPath + " with message: " + ex.getMessage(), ex);
} catch (IOException ex) {
throw new IOException("IOException occured on path " + entryPath + " with message: " + ex.getMessage(), ex);
}
}
public static @NotNull ArtifactId toArtifactId(@NotNull PackageId packageId, @NotNull File file) {
String groupId = requireNonNull(packageId.getGroup(),
PackageProperties.NAME_GROUP
+ " property not found in content-package "
+ file
+ ", please check META-INF/vault/properties.xml").replace('/', '.');
// Replace any space with an underscore to adhere to Maven Group Id specification
groupId = groupId.replace(" ", "_");
String artifactId = requireNonNull(packageId.getName(),
PackageProperties.NAME_NAME
+ " property not found in content-package "
+ file
+ ", please check META-INF/vault/properties.xml");
// Replace any space with an underscore to adhere to Maven Artifact Id specification
artifactId = artifactId.replace(" ", "_");
// package versions may use suffix "-cp2fm-converted" which is redundant as for artifactIds this is set as dedicated classifier
String version = packageId.getVersionString();
if (version.endsWith(VaultPackageAssembler.VERSION_SUFFIX)) {
version = version.substring(0, version.length() - VaultPackageAssembler.VERSION_SUFFIX.length());
}
if (version.isEmpty()) {
version = DEFAULT_VERSION;
}
return new ArtifactId(groupId, artifactId, version, PACKAGE_CLASSIFIER, ZIP_TYPE);
}
@Override
protected void addCdnPattern(@NotNull Pattern cndPattern) {
handlersManager.addEntryHandler(NodeTypesEntryHandler.forCndPattern(cndPattern));
}
@Override
public void close() throws IOException {
cleanup();
}
public List getAssemblers() {
return new ArrayList<>(assemblers);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy