com.adobe.forms.foundation.cloudconfig.migration.CloudServicesMigrator Maven / Gradle / Ivy

Go to download
/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2017 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/

package com.adobe.forms.foundation.cloudconfig.migration;

import com.adobe.cq.cloudconfig.core.Constants;
import com.adobe.forms.foundation.migration.api.TaskContext;
import com.adobe.forms.foundation.migration.spi.MigrationTask;
import com.day.cq.wcm.api.NameConstants;
import org.apache.jackrabbit.vault.util.JcrConstants;
import org.apache.sling.api.resource.LoginException;
import org.apache.sling.api.resource.ModifiableValueMap;
import org.apache.sling.api.resource.PersistenceException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.jcr.resource.JcrResourceConstants;

import javax.annotation.Nonnull;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public abstract class CloudServicesMigrator extends MigrationTask {
    private static final String CLOUD_CONFIGURATION_GLOBAL_CONTAINER = "/conf/global";
    private static final String CLOUD_CONFIGURATION_BUCKET_PATH = CLOUD_CONFIGURATION_GLOBAL_CONTAINER + "/" + Constants.CLOUDCONFIG_BUCKET_PATH;
    private static final String MERGE_LIST = "mergeList";

    private Map migrationMappings = new HashMap();

    private ResourceResolver resourceResolver;

    protected abstract ResourceResolver getResourceResolver() throws LoginException;

    @Nonnull
    protected abstract String getCloudServiceName();

    @Nonnull
    protected abstract String getCloudConfigurationGroup();

    @Nonnull
    protected abstract String getLegacyConfigurationRootFolder();

    @Nonnull
    protected abstract String[] getResourcesRootFolders();

    protected void performPostMigrationUpdates(@Nonnull Resource configurationContainer) {

    }

    protected abstract void updateResource(@Nonnull Resource resource) throws PersistenceException;

    private Resource moveLegacyCloudServices(@Nonnull String legacyConfigurationRootFolder, @Nonnull String group)
            throws LoginException, PersistenceException, RepositoryException {
        Resource sourceContainer = resourceResolver.getResource(legacyConfigurationRootFolder);
        Resource destinationContainer = ResourceUtil.getOrCreateResource(resourceResolver,
                CLOUD_CONFIGURATION_BUCKET_PATH + "/" + group,
                JcrResourceConstants.NT_SLING_FOLDER, JcrResourceConstants.NT_SLING_FOLDER, false);

        ModifiableValueMap modifiableValueMap = destinationContainer.adaptTo(ModifiableValueMap.class);
        modifiableValueMap.put(MERGE_LIST, true);

        Session session = resourceResolver.adaptTo(Session.class);
        final String destination = CLOUD_CONFIGURATION_BUCKET_PATH + "/" + group;
        final Iterator iterator = sourceContainer.listChildren();
        Integer confCount = 0;
        while (iterator.hasNext()) {
            Resource configuration = iterator.next();
            confCount++;
            if (configuration.isResourceType(NameConstants.NT_PAGE)) {
                String source = configuration.getPath();
                String name = configuration.getName();
                ConfigurationProperty configurationProperty = null;
                if (resourceResolver.getResource(destination + "/" + name) == null) {
                    session.move(source, destination + "/" + name);
                    configurationProperty = new ConfigurationProperty(CLOUD_CONFIGURATION_GLOBAL_CONTAINER, name);
                }
                migrationMappings.put(source, configurationProperty);
            }
        }

        return destinationContainer;
    }

    private boolean isFolder(Resource resource) throws RepositoryException {
        Node node = resource.adaptTo(Node.class);
        return node.isNodeType(JcrResourceConstants.NT_SLING_FOLDER) ||
                node.isNodeType(JcrResourceConstants.NT_SLING_ORDERED_FOLDER) ||
                node.isNodeType(JcrConstants.NT_FOLDER);
    }

    private void updateResources(@Nonnull Resource root) throws PersistenceException, RepositoryException {
        if (isFolder(root)) {
            final Iterator iterator = root.listChildren();
            while(iterator.hasNext()) {
                Resource child = iterator.next();
                if (isFolder(child)) {
                    updateResources(child);
                } else {
                    updateResource(child);
                }
            }
        }
    }

    public final synchronized void migrateLegacyCloudServices(final TaskContext taskContext) throws LoginException,
            PersistenceException, RepositoryException {
        taskContext.info("Migration of " + getCloudServiceName() + " configurations started.");
        resourceResolver = getResourceResolver();
        String legacyCloudServicesRootFolder = getLegacyConfigurationRootFolder();
        String cloudConfigurationGroup = getCloudConfigurationGroup();
        Resource configurationContainer = moveLegacyCloudServices(legacyCloudServicesRootFolder,
                cloudConfigurationGroup);
        if (configurationContainer != null) {
            performPostMigrationUpdates(configurationContainer);
            String[] resourceRootPaths = getResourcesRootFolders();
            for(String resourceRootPath: resourceRootPaths) {
                Resource root = resourceResolver.getResource(resourceRootPath);
                updateResources(root);
            }
        }

        resourceResolver.commit();
        resourceResolver.close();

        boolean warnings = false;
        Set configurations = migrationMappings.keySet();
        for (String configuration : configurations) {
            ConfigurationProperty property = migrationMappings.get(configuration);
            if (property != null) {
                taskContext.info("Configuration at [" + configuration + "] is moved to [" + property.configurationContainer + "/" +
                        Constants.CLOUDCONFIG_BUCKET_PATH + "/" + cloudConfigurationGroup + "/" + property.configurationName + "].");
            } else {
                warnings = true;
                taskContext.warn("Configuration at [" + configuration + "] could not be moved.");
            }
        }
        if (warnings) {
            taskContext.info("Migration of " + getCloudServiceName() + " configurations finished successfully with warnings.");
        } else {
            taskContext.success("Migration of " + getCloudServiceName() + " configurations finished successfully without any warnings and errors.");
        }
        migrationMappings.clear();
    }

    /**
     * Start migration task for cloud configurations.
     *
     * @param taskContext task context to perform migration
     */
    public final void startTask(final TaskContext taskContext) {
        try {
            migrateLegacyCloudServices(taskContext);
        } catch (LoginException | PersistenceException | RepositoryException e ) {
            taskContext.error("Error during migration of " + getCloudServiceName() + " configurations", e);
        }
    }

    public final ConfigurationProperty getMigratedConfigurationPropertiesFor(@Nonnull String legacyConfigurationPath) {
        return migrationMappings.get(legacyConfigurationPath);
    }

    public class ConfigurationProperty {
        public String configurationContainer;

        public String configurationName;

        public ConfigurationProperty(String configurationContainer, String configurationName) {
            this.configurationContainer = configurationContainer;
            this.configurationName = configurationName;
        }
    }
}