DatabaseVersionHierarchy.java

// 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 com.cloud.upgrade;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import com.google.common.collect.ImmutableList;

import org.apache.cloudstack.utils.CloudStackVersion;

import com.cloud.upgrade.dao.DbUpgrade;

/**
 * @since 4.12.0.0
 */
public final class DatabaseVersionHierarchy {
    private final ImmutableList<VersionNode> hierarchy;

    private DatabaseVersionHierarchy(ImmutableList<VersionNode> hierarchy) {
        this.hierarchy = hierarchy;
    }

    public static DatabaseVersionHierarchyBuilder builder() {
        return new DatabaseVersionHierarchyBuilder();
    }

    /**
     * Check if current hierarchy of Database Versions contains <code>version</code>.
     *
     * @param version The version to check if hierarchy contains it
     *
     * @return true if hierarchy contains the version, false if not
     */
    public boolean contains(final CloudStackVersion version) {
        return toList().contains(version);
    }

    /**
     * Calculates an  upgrade path for the  passed <code>fromVersion</code>.  If the  <code>fromVersion</code>
     * doesn't exist in list  of  available <code>VersionNode</code> hierarchy,  then calculation assumes that
     * the <code>fromVersion</code> required no schema migrations or data conversions and no  upgrade path was
     * defined  for it.  Therefore,  we  find  the most  recent  version  with  database migrations before the
     * <code>fromVersion</code> and adopt that upgrade path list.
     *
     * @param fromVersion The version from which the upgrade will occur
     *
     * @return The upgrade path from <code>fromVersion</code> to <code>LATEST</code> version.
     */
    public DbUpgrade[] getPath(final CloudStackVersion fromVersion) {
        return getPath(fromVersion, null);
    }

    /**
     * Calculates an  upgrade path for the  passed <code>fromVersion</code> and <code>toVersion</code>. If the
     * <code>fromVersion</code> doesn't exist in list  of available <code>VersionNode</code> hierarchy,   then
     * calculation assumes that the <code>fromVersion</code> required no schema migrations or data conversions
     * and no  upgrade path was defined  for it.  Therefore, we find  the most recent  version  with  database
     * migrations before the <code>fromVersion</code> and adopt that upgrade path list up to <code>toVersion</code>.
     * If <code>toVersion</code> is null, we're going to find the upgrade path up to the latest available version.
     *
     * @param fromVersion The version from which the upgrade will occur
     * @param toVersion The version up to which the upgrade will occur (can be null)
     *
     * @return The upgrade path from <code>fromVersion</code> to <code>toVersion</code>
     */
    public DbUpgrade[] getPath(final CloudStackVersion fromVersion, final CloudStackVersion toVersion) {
        if (fromVersion == null) {
            return new DbUpgrade[0];
        }

        // The CloudStack version is latest or higher than latest
        if (fromVersion.compareTo(getLatestVersion()) >= 0) {
            return new DbUpgrade[0];
        }

        // we cannot find the version specified, so get the
        // most recent one immediately before this version
        if (!contains(fromVersion)) {
            DbUpgrade[] dbUpgrades = getPath(getRecentVersion(fromVersion), toVersion);
            return Arrays.stream(dbUpgrades).filter(up -> CloudStackVersion.compare(up.getUpgradedVersion(), fromVersion.toString()) > 0)
                    .toArray(DbUpgrade[]::new);
        }

        final Predicate<? super VersionNode> predicate;

        if (toVersion == null) {
            // all the available versions greater than or equal to fromVersion
            predicate = node -> node.version.compareTo(fromVersion) > -1;
        } else {
            // all the available versions greater than or equal to fromVersion AND less than toVersion
            predicate = node -> node.version.compareTo(fromVersion) > -1 && node.version.compareTo(toVersion) < 0;
        }

        // get upgrade path from version forward (include version itself in the path)
        return hierarchy
                    .stream()
                    .filter(predicate)
                    .filter(distinct(node -> node.upgrader.getUpgradedVersion()))
                    .map(node -> node.upgrader)
                    .toArray(DbUpgrade[]::new);
    }

    /**
     * Find the most recent <code>CloudStackVersion</code> immediately before <code>fromVersion</code>
     *
     * @param fromVersion The version to look up its immediate previous available version
     *
     * @return The <code>CloudStackVersion</code> or null
     *
     * @since 4.8.2.0 (refactored in 4.11.1.0)
     */
    protected CloudStackVersion getRecentVersion(final CloudStackVersion fromVersion) {
        if (fromVersion == null) {
            return null;
        }

        // find the most recent version immediately before fromVersion
        return toList()
                 .reverse()
                 .stream()
                 .filter(version -> fromVersion.compareTo(version) > 0)
                 .findFirst()
                 .orElse(null);
    }

    /**
     * Generate immutable list of available <code>CloudstackVersion</code> in the hierarchy
     *
     * @return list of available versions
     */
    public ImmutableList<CloudStackVersion> toList() {
        List<CloudStackVersion> versions = hierarchy
                                                .stream()
                                                .map(node -> node.version)
                                                .collect(Collectors.toList());

        return ImmutableList.copyOf(versions);
    }

    /**
     * Find the distinct <code>VersionNode</code> based on the provided <code>getUpgradedVersion()</code>
     */
    private Predicate<VersionNode> distinct(Function<VersionNode, String> keyExtractor) {
        Map<String, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    protected static class VersionNode {
        final CloudStackVersion version;
        final DbUpgrade upgrader;

        protected VersionNode(final CloudStackVersion version, final DbUpgrade upgrader) {
            this.version = version;
            this.upgrader = upgrader;
        }
    }


    public static final class DatabaseVersionHierarchyBuilder {
        private final List<VersionNode> hierarchyBuilder = new LinkedList<>();

        private DatabaseVersionHierarchyBuilder() {
        }

        public DatabaseVersionHierarchyBuilder next(final String version, final DbUpgrade upgrader) {
            hierarchyBuilder.add(new VersionNode(CloudStackVersion.parse(version), upgrader));
            return this;
        }

        public DatabaseVersionHierarchy build() {
            return new DatabaseVersionHierarchy(ImmutableList.copyOf(hierarchyBuilder));
        }
    }

    public CloudStackVersion getLatestVersion() {
        return CloudStackVersion.parse(hierarchy.get(hierarchy.size() - 1).upgrader.getUpgradedVersion());
    }
}