org.datacleaner.user.upgrade.DataCleanerHomeUpgrader Maven / Gradle / Ivy

Go to download
/**
 * DataCleaner (community edition)
 * Copyright (C) 2014 Free Software Foundation, Inc.
 *
 * This copyrighted material is made available to anyone wishing to use, modify,
 * copy, or redistribute it subject to the terms and conditions of the GNU
 * Lesser General Public License, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution; if not, write to:
 * Free Software Foundation, Inc.
 * 51 Franklin Street, Fifth Floor
 * Boston, MA  02110-1301  USA
 */
package org.datacleaner.user.upgrade;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.apache.commons.vfs2.AllFileSelector;
import org.apache.commons.vfs2.FileDepthSelector;
import org.apache.commons.vfs2.FileObject;
import org.apache.commons.vfs2.FileSystemException;
import org.apache.commons.vfs2.FileType;
import org.apache.metamodel.util.FileHelper;
import org.datacleaner.Version;
import org.datacleaner.VersionComparator;
import org.datacleaner.user.DataCleanerHome;
import org.datacleaner.util.ResourceManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Checks if there is DataCleanerHome set up for previous versions of
 * DataCleaner and upgrades.
 */
public final class DataCleanerHomeUpgrader {

    private static final Logger logger = LoggerFactory.getLogger(DataCleanerHomeUpgrader.class);

    private static final List candidateBlacklist = Arrays.asList("log", Version.UNKNOWN_VERSION);

    private static List validateVersionFolders(final List versionFolders) {
        final List validatedVersionFolders = new ArrayList<>();
        final Integer currentMajorVersion = Version.getMajorVersion();
        if (currentMajorVersion == null) {
            return validatedVersionFolders;
        }

        for (final FileObject versionFolder : versionFolders) {
            final String baseName = versionFolder.getName().getBaseName();

            final String[] versionParts = baseName.split("\\.");

            try {
                final int majorVersion = Integer.parseInt(versionParts[0]);
                if (majorVersion != currentMajorVersion) {
                    continue;
                }
            } catch (final NumberFormatException e) {
                continue;
            }

            boolean validated = true;
            for (String versionPart : versionParts) {
                if (versionPart.endsWith("-SNAPSHOT")) {
                    versionPart = versionPart.substring(0, versionPart.lastIndexOf("-SNAPSHOT"));
                }
                try {
                    Integer.parseInt(versionPart);
                } catch (final NumberFormatException e) {
                    logger.warn("Found a version folder in home directory ({}) with a part that could not be parsed "
                                    + "to an integer: {} Removing this folder from potential upgrade candidates.", baseName,
                            versionPart);
                    validated = false;
                }
            }
            if (validated) {
                validatedVersionFolders.add(versionFolder);
            }
        }
        return validatedVersionFolders;
    }

    private static FileObject overwriteFileWithDefaults(final FileObject targetDirectory, final String targetFilename)
            throws FileSystemException {
        final FileObject file = targetDirectory.resolveFile(targetFilename);
        final FileObject parentFile = file.getParent();
        if (!parentFile.exists()) {
            parentFile.createFolder();
        }

        final ResourceManager resourceManager = ResourceManager.get();
        final URL url = resourceManager.getUrl("datacleaner-home/" + targetFilename);
        if (url == null) {
            return null;
        }

        InputStream in = null;
        OutputStream out = null;
        try {
            in = url.openStream();
            out = file.getContent().getOutputStream();

            FileHelper.copy(in, out);
        } catch (final IOException e) {
            throw new IllegalArgumentException(e);
        } finally {
            FileHelper.safeClose(in, out);
        }

        return file;
    }

    /**
     * Finds a folder to upgrade from based on the "newFolder" parameter -
     * upgrades are performed only within the same major version.
     *
     * @param newFolder
     *            The folder we want to upgrade to (the new version)
     * @return true if upgrade was successful, false otherwise
     */
    public boolean upgrade(final FileObject newFolder) {
        try {
            if (newFolder.getChildren().length != 0) {
                // if the folder is not new then we don't want to touch it
                return false;
            }

            final FileObject upgradeFromFolderCandidate = findUpgradeCandidate(newFolder);

            if (upgradeFromFolderCandidate == null) {
                logger.info("Did not find a suitable upgrade candidate");
                return false;
            }

            logger.info("Upgrading DATACLEANER_HOME from : {}", upgradeFromFolderCandidate);
            newFolder.copyFrom(upgradeFromFolderCandidate, new AllFileSelector());

            // special handling of userpreferences.dat - we only want to keep
            // the good parts ;-)
            final UserPreferencesUpgrader userPreferencesUpgrader = new UserPreferencesUpgrader(newFolder);
            userPreferencesUpgrader.upgrade();

            // Overwrite example jobs
            final List allFilePaths = DataCleanerHome.getAllInitialFiles();
            for (final String filePath : allFilePaths) {
                overwriteFileWithDefaults(newFolder, filePath);
            }
            return true;
        } catch (final FileSystemException e) {
            logger.warn("Exception occured during upgrading: {}", e);
            return false;
        }
    }

    private FileObject findUpgradeCandidate(final FileObject target) throws FileSystemException {
        final FileObject parentFolder = target.getParent();

        final List versionFolders = new ArrayList<>();
        final FileObject[] allFoldersInParent = parentFolder.findFiles(new FileDepthSelector(1, 1));
        for (final FileObject folderInParent : allFoldersInParent) {
            final String folderInParentName = folderInParent.getName().getBaseName();
            if (folderInParent.getType().equals(FileType.FOLDER) && (!folderInParentName
                    .equals(target.getName().getBaseName())) && (!candidateBlacklist.contains(folderInParentName))) {
                versionFolders.add(folderInParent);
            }
        }

        final List validatedVersionFolders = validateVersionFolders(versionFolders);

        if (!validatedVersionFolders.isEmpty()) {

            final List versions = new ArrayList<>();
            for (final FileObject validatedVersionFolder : validatedVersionFolders) {
                final String baseName = validatedVersionFolder.getName().getBaseName();
                versions.add(baseName);
            }

            final Comparator comp = new VersionComparator();
            final String latestVersion = Collections.max(versions, comp);
            FileObject latestVersionFolder = null;
            for (final FileObject validatedVersionFolder : validatedVersionFolders) {
                if (validatedVersionFolder.getName().getBaseName().equals(latestVersion)) {
                    latestVersionFolder = validatedVersionFolder;
                }
            }
            return latestVersionFolder;
        } else {
            return null;
        }
    }

}