HDDS-15376. Implement new ScmVersionManager.

hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/upgrade/DatanodeVersionManager.java

@@ -21,18 +21,20 @@
 import java.io.IOException;
 import java.util.Map;
 import org.apache.hadoop.hdds.ComponentVersion;
+import org.apache.hadoop.hdds.HDDSVersion;
 import org.apache.hadoop.hdds.upgrade.DatanodeUpgradeAction;
 import org.apache.hadoop.hdds.upgrade.DatanodeUpgradeActionProvider;
-import org.apache.hadoop.hdds.upgrade.HDDSVersionManager;
+import org.apache.hadoop.hdds.upgrade.HDDSVersionUtils;
 import org.apache.hadoop.ozone.container.common.DatanodeStorage;
 import org.apache.hadoop.ozone.container.common.statemachine.DatanodeStateMachine;
 import org.apache.hadoop.ozone.upgrade.ComponentUpgradeActionProvider;
+import org.apache.hadoop.ozone.upgrade.ComponentVersionManager;
 import org.apache.hadoop.ozone.upgrade.UpgradeException;
 
 /**
  * Datanode-specific version manager that wires upgrade actions internally.
  */
-public class DatanodeVersionManager extends HDDSVersionManager {
+public class DatanodeVersionManager extends ComponentVersionManager {
 
   private final Map<ComponentVersion, DatanodeUpgradeAction> upgradeActions;
   private final DatanodeStateMachine upgradeActionArg;
@@ -44,7 +46,9 @@ public DatanodeVersionManager(DatanodeStorage storage, DatanodeStateMachine upgr
   @VisibleForTesting
   public DatanodeVersionManager(DatanodeStorage storage, DatanodeStateMachine upgradeActionArg,
       ComponentUpgradeActionProvider<DatanodeUpgradeAction> upgradeActionProvider) throws IOException {
-    super(storage);
+    super(storage,
+        HDDSVersionUtils.deserializedPersistedApparentVersion(storage.getApparentVersion()),
+        HDDSVersion.SOFTWARE_VERSION);
     this.upgradeActionArg = upgradeActionArg;
     upgradeActions = upgradeActionProvider.load();
   }

hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/upgrade/HDDSVersionManager.java → hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/upgrade/HDDSVersionUtils.java

@@ -20,43 +20,52 @@
 import java.io.IOException;
 import org.apache.hadoop.hdds.ComponentVersion;
 import org.apache.hadoop.hdds.HDDSVersion;
-import org.apache.hadoop.ozone.common.Storage;
-import org.apache.hadoop.ozone.upgrade.ComponentVersionManager;
-import org.apache.hadoop.ozone.upgrade.UpgradeException;
 
 /**
  * Component version manager for HDDS (Datanodes and SCM).
  */
-public abstract class HDDSVersionManager extends ComponentVersionManager {
-  protected HDDSVersionManager(Storage storage) throws IOException {
-    super(storage, computeApparentVersion(storage.getApparentVersion()), HDDSVersion.SOFTWARE_VERSION);
+public final class HDDSVersionUtils {
+  private HDDSVersionUtils() {
   }
 
   /**
    * If the apparent version stored on the disk is >= {@link HDDSVersion#ZDU} serialized, the apparent version is
-   * resolved via {@link HDDSVersion#deserialize(int)}. Values with no matching {@link HDDSVersion} fail startup with
-   * the persisted integer in the exception message.
+   * resolved via {@link HDDSVersion#deserialize(int)}.
    * If the value is below that threshold, the apparent version is resolved as a {@link HDDSLayoutFeature}. Integers in
-   * the gap between the largest {@link HDDSLayoutFeature} and ZDU are not valid legacy layout values; startup fails
-   * with the persisted integer in the exception message.
+   * the gap between the largest {@link HDDSLayoutFeature} and ZDU are not valid legacy layout values.
+   *
+   * If the serialized version does not match any of these known versions, {@link HDDSVersion#UNKNOWN_VERSION} is
+   * returned.
    */
-  private static ComponentVersion computeApparentVersion(int serializedApparentVersion) throws IOException {
-    if (serializedApparentVersion >= HDDSVersion.ZDU.serialize()) {
-      HDDSVersion fromHdds = HDDSVersion.deserialize(serializedApparentVersion);
-      if (fromHdds != HDDSVersion.UNKNOWN_VERSION) {
-        return fromHdds;
-      }
+  public static ComponentVersion deserializeHDDSVersionOrLayoutVersion(int serializedVersion) {
+    if (serializedVersion >= HDDSVersion.ZDU.serialize()) {
+      return HDDSVersion.deserialize(serializedVersion);
     } else {
-      ComponentVersion fromLayout = HDDSLayoutFeature.deserialize(serializedApparentVersion);
+      ComponentVersion fromLayout = HDDSLayoutFeature.deserialize(serializedVersion);
       if (fromLayout != null) {
         return fromLayout;
+      } else {
+        return HDDSVersion.UNKNOWN_VERSION;
       }
     }
-    throw new IOException("Initialization failed. Disk contains unknown apparent version " + serializedApparentVersion +
-        " for software version " + HDDSVersion.SOFTWARE_VERSION + ". Make sure this component was not downgraded" +
-        " after finalization");
   }
 
-  @Override
-  protected abstract void runUpgradeAction(ComponentVersion version) throws UpgradeException;
+  /**
+   * If the apparent version stored on the disk is >= {@link HDDSVersion#ZDU} serialized, the apparent version is
+   * resolved via {@link HDDSVersion#deserialize(int)}. Values with no matching {@link HDDSVersion} fail startup with
+   * the persisted integer in the exception message.
+   * If the value is below that threshold, the apparent version is resolved as a {@link HDDSLayoutFeature}. Integers in
+   * the gap between the largest {@link HDDSLayoutFeature} and ZDU are not valid legacy layout values; startup fails
+   * with the persisted integer in the exception message.
+   */
+  public static ComponentVersion deserializedPersistedApparentVersion(int serializedApparentVersion)
+      throws IOException {
+    ComponentVersion persistedVersion = deserializeHDDSVersionOrLayoutVersion(serializedApparentVersion);
+    if (persistedVersion == HDDSVersion.UNKNOWN_VERSION) {
+      throw new IOException("Initialization failed. Disk contains unknown apparent version "
+          + serializedApparentVersion + " for software version " + HDDSVersion.SOFTWARE_VERSION
+          + ". Make sure this component was not downgraded after finalization");
+    }
+    return persistedVersion;
+  }
 }

hadoop-hdds/framework/src/main/java/org/apache/hadoop/ozone/upgrade/RatisBasedVersionManager.java

@@ -0,0 +1,69 @@
+/*
+ * 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.hadoop.ozone.upgrade;
+
+import static org.apache.hadoop.ozone.OzoneConsts.APPARENT_VERSION_KEY;
+
+import java.io.IOException;
+import org.apache.hadoop.hdds.ComponentVersion;
+import org.apache.hadoop.hdds.utils.db.Table;
+import org.apache.hadoop.ozone.common.Storage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Base version manager implementation for ratis-backed component versions.
+ */
+public abstract class RatisBasedVersionManager extends ComponentVersionManager {
+
+  private static final Logger LOG = LoggerFactory.getLogger(RatisBasedVersionManager.class);
+
+  protected RatisBasedVersionManager(Storage storage, ComponentVersion apparentVersion,
+      ComponentVersion softwareVersion) {
+    super(storage, apparentVersion, softwareVersion);
+  }
+
+  public void validateDBVersion(Table<String, String> finalizationStore) throws IOException {
+    ComponentVersion dbVersion = getApparentVersionInDB(finalizationStore);
+    ComponentVersion apparentVersion = getApparentVersion();
+
+    if (!apparentVersion.equals(dbVersion)) {
+      LOG.info("Version file has different apparent version ({}) than DB ({}). That is expected if this "
+          + "component has never been finalized to a newer version.", apparentVersion, dbVersion);
+    }
+  }
+
+  public void finalizeFromSnapshotIfRequired(Table<String, String> finalizationStore) throws IOException {
+    ComponentVersion apparentVersionInNewDB = getApparentVersionInDB(finalizationStore);
+    if (apparentVersionInNewDB != null && !isAllowed(apparentVersionInNewDB)) {
+      LOG.info("New snapshot received with higher apparent version {}. Attempting to finalize to that version.",
+          apparentVersionInNewDB);
+      finalizeUpgrade();
+      // Update the apparent version in the DB to match the VERSION file.
+      // When finalization is not done with a snapshot, this DB value is updated by OMFinalizeUpgradeRequest.
+      finalizationStore.put(APPARENT_VERSION_KEY, String.valueOf(getApparentVersion().serialize()));
+    }
+  }
+
+  protected abstract ComponentVersion computeApparentVersion(int serializedVersion) throws IOException;
+
+  private ComponentVersion getApparentVersionInDB(Table<String, String> finalizationStore) throws IOException {
+    String apparentVersion = finalizationStore.get(APPARENT_VERSION_KEY);
+    return (apparentVersion == null) ? null : computeApparentVersion(Integer.parseInt(apparentVersion));
+  }
+}

hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/server/upgrade/ScmOnFinalizeActionForDatanodeSchemaV2.java

@@ -19,6 +19,7 @@
 
 import static org.apache.hadoop.hdds.upgrade.HDDSLayoutFeature.DATANODE_SCHEMA_V2;
 
+import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager;
 import org.apache.hadoop.hdds.upgrade.ScmUpgradeAction;
 import org.apache.hadoop.ozone.upgrade.UpgradeActionScm;
 import org.slf4j.Logger;
@@ -28,13 +29,11 @@
  * SCM Upgrade Action for the very first Upgrade Version.
  */
 @UpgradeActionScm(feature = DATANODE_SCHEMA_V2)
-public class ScmOnFinalizeActionForDatanodeSchemaV2 implements
-    ScmUpgradeAction {
-  private static final Logger LOG =
-      LoggerFactory.getLogger(ScmOnFinalizeActionForDatanodeSchemaV2.class);
+public class ScmOnFinalizeActionForDatanodeSchemaV2 implements ScmUpgradeAction {
+  private static final Logger LOG = LoggerFactory.getLogger(ScmOnFinalizeActionForDatanodeSchemaV2.class);
 
   @Override
-  public void execute(SCMUpgradeFinalizationContext context) throws Exception {
+  public void execute(OzoneStorageContainerManager context) throws Exception {
     LOG.info("Executing SCM On Finalize action for layout feature {}",
         DATANODE_SCHEMA_V2);
   }

hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/server/upgrade/ScmVersionManager.java

@@ -0,0 +1,80 @@
+/*
+ * 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.hadoop.hdds.scm.server.upgrade;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.io.IOException;
+import java.util.Map;
+import org.apache.hadoop.hdds.ComponentVersion;
+import org.apache.hadoop.hdds.HDDSVersion;
+import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager;
+import org.apache.hadoop.hdds.scm.server.SCMStorageConfig;
+import org.apache.hadoop.hdds.upgrade.HDDSVersionUtils;
+import org.apache.hadoop.hdds.upgrade.ScmUpgradeAction;
+import org.apache.hadoop.hdds.upgrade.ScmUpgradeActionProvider;
+import org.apache.hadoop.ozone.upgrade.ComponentUpgradeActionProvider;
+import org.apache.hadoop.ozone.upgrade.RatisBasedVersionManager;
+import org.apache.hadoop.ozone.upgrade.UpgradeException;
+
+/**
+ * SCM-specific version manager that wires upgrade actions internally.
+ */
+public class ScmVersionManager extends RatisBasedVersionManager {
+
+  private final Map<ComponentVersion, ScmUpgradeAction> upgradeActions;
+  private final OzoneStorageContainerManager upgradeActionArg;
+
+  public ScmVersionManager(SCMStorageConfig storage, OzoneStorageContainerManager upgradeActionArg) throws IOException {
+    this(storage, upgradeActionArg, new ScmUpgradeActionProvider());
+  }
+
+  @VisibleForTesting
+  public ScmVersionManager(SCMStorageConfig storage,
+      OzoneStorageContainerManager upgradeActionArg,
+      ComponentUpgradeActionProvider<ScmUpgradeAction> upgradeActionProvider)
+      throws IOException {
+    super(storage, HDDSVersionUtils.deserializedPersistedApparentVersion(storage.getApparentVersion()),
+        HDDSVersion.SOFTWARE_VERSION);
+    this.upgradeActionArg = upgradeActionArg;
+    upgradeActions = upgradeActionProvider.load();
+  }
+
+  @VisibleForTesting
+  public Map<ComponentVersion, ScmUpgradeAction> getUpgradeActionsForTesting() {
+    return upgradeActions;
+  }
+
+  @Override
+  protected void runUpgradeAction(ComponentVersion version) throws UpgradeException {
+    ScmUpgradeAction action = upgradeActions.get(version);
+    if (action == null) {
+      return;
+    }
+    try {
+      action.execute(upgradeActionArg);
+    } catch (Exception e) {
+      logAndThrow(e, "SCM upgrade action for version " + version + " failed.",
+          UpgradeException.ResultCodes.FINALIZE_UPGRADE_ACTION_FAILED);
+    }
+  }
+
+  @Override
+  protected ComponentVersion computeApparentVersion(int serializedVersion) throws IOException {
+    return HDDSVersionUtils.deserializedPersistedApparentVersion(serializedVersion);
+  }
+}

hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/upgrade/ScmUpgradeAction.java

@@ -17,12 +17,12 @@
 
 package org.apache.hadoop.hdds.upgrade;
 
-import org.apache.hadoop.hdds.scm.server.upgrade.SCMUpgradeFinalizationContext;
+import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager;
 import org.apache.hadoop.ozone.upgrade.UpgradeAction;
 
 /**
  * Storage Container Manager Upgrade Action interface. An upgrade action is an operation that
  * needs to be executed during finalization.
  */
-public interface ScmUpgradeAction extends UpgradeAction<SCMUpgradeFinalizationContext> {
+public interface ScmUpgradeAction extends UpgradeAction<OzoneStorageContainerManager> {
 }