HDDS-13176. containerIds table value format change to proto from string

hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/upgrade/HDDSLayoutFeature.java

@@ -41,7 +41,8 @@ public enum HDDSLayoutFeature implements LayoutFeature {
   HADOOP_PRC_PORTS_IN_DATANODEDETAILS(7, "Adding Hadoop RPC ports " +
                                      "to DatanodeDetails."),
   HBASE_SUPPORT(8, "Datanode RocksDB Schema Version 3 has an extra table " +
-          "for the last chunk of blocks to support HBase.)");
+          "for the last chunk of blocks to support HBase.)"),
+  WITNESSED_CONTAINER_DB_PROTO_VALUE(9, "ContainerID table schema to use value type as proto");
 
   //////////////////////////////  //////////////////////////////
 

hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/impl/ContainerSet.java

@@ -23,6 +23,7 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
 import com.google.protobuf.Message;
+import jakarta.annotation.Nullable;
 import java.io.IOException;
 import java.time.Clock;
 import java.util.ArrayList;
@@ -43,11 +44,12 @@
 import org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.ContainerReportsProto;
 import org.apache.hadoop.hdds.scm.container.ContainerID;
 import org.apache.hadoop.hdds.scm.container.common.helpers.StorageContainerException;
-import org.apache.hadoop.hdds.utils.db.Table;
 import org.apache.hadoop.ozone.container.common.interfaces.Container;
 import org.apache.hadoop.ozone.container.common.statemachine.StateContext;
 import org.apache.hadoop.ozone.container.common.utils.ContainerLogger;
 import org.apache.hadoop.ozone.container.common.volume.HddsVolume;
+import org.apache.hadoop.ozone.container.metadata.ContainerCreateInfo;
+import org.apache.hadoop.ozone.container.metadata.WitnessedContainerMetadataStore;
 import org.apache.hadoop.ozone.container.ozoneimpl.OnDemandContainerScanner;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -67,26 +69,28 @@ public class ContainerSet implements Iterable<Container<?>> {
       new ConcurrentSkipListMap<>();
   private final Clock clock;
   private long recoveringTimeout;
-  private final Table<ContainerID, String> containerIdsTable;
+  @Nullable
+  private final WitnessedContainerMetadataStore containerMetadataStore;
   // Handler that will be invoked when a scan of a container in this set is requested.
   private OnDemandContainerScanner containerScanner;
 
   public static ContainerSet newReadOnlyContainerSet(long recoveringTimeout) {
     return new ContainerSet(null, recoveringTimeout);
   }
 
-  public static ContainerSet newRwContainerSet(Table<ContainerID, String> containerIdsTable, long recoveringTimeout) {
-    Objects.requireNonNull(containerIdsTable, "containerIdsTable == null");
-    return new ContainerSet(containerIdsTable, recoveringTimeout);
+  public static ContainerSet newRwContainerSet(
+      WitnessedContainerMetadataStore metadataStore, long recoveringTimeout) {
+    Objects.requireNonNull(metadataStore, "WitnessedContainerMetadataStore == null");
+    return new ContainerSet(metadataStore, recoveringTimeout);
   }
 
-  private ContainerSet(Table<ContainerID, String> continerIdsTable, long recoveringTimeout) {
-    this(continerIdsTable, recoveringTimeout, null);
+  private ContainerSet(WitnessedContainerMetadataStore containerMetadataStore, long recoveringTimeout) {
+    this(containerMetadataStore, recoveringTimeout, null);
   }
 
-  ContainerSet(Table<ContainerID, String> continerIdsTable, long recoveringTimeout, Clock clock) {
+  ContainerSet(WitnessedContainerMetadataStore containerMetadataStore, long recoveringTimeout, Clock clock) {
     this.clock = clock != null ? clock : Clock.systemUTC();
-    this.containerIdsTable = continerIdsTable;
+    this.containerMetadataStore = containerMetadataStore;
     this.recoveringTimeout = recoveringTimeout;
   }
 
@@ -188,13 +192,7 @@ private boolean addContainer(Container<?> container, boolean overwrite) throws
         LOG.debug("Container with container Id {} is added to containerMap",
             containerId);
       }
-      try {
-        if (containerIdsTable != null) {
-          containerIdsTable.put(ContainerID.valueOf(containerId), containerState.toString());
-        }
-      } catch (IOException e) {
-        throw new StorageContainerException(e, ContainerProtos.Result.IO_EXCEPTION);
-      }
+      updateContainerIdTable(containerId, containerState);
       missingContainerSet.remove(containerId);
       if (container.getContainerData().getState() == RECOVERING) {
         recoveringContainerMap.put(
@@ -209,6 +207,17 @@ private boolean addContainer(Container<?> container, boolean overwrite) throws
     }
   }
 
+  private void updateContainerIdTable(long containerId, State containerState) throws StorageContainerException {
+    if (null != containerMetadataStore) {
+      try {
+        containerMetadataStore.getContainerCreateInfoTable().put(ContainerID.valueOf(containerId),
+            ContainerCreateInfo.valueOf(containerState));
+      } catch (IOException e) {
+        throw new StorageContainerException(e, ContainerProtos.Result.IO_EXCEPTION);
+      }
+    }
+  }
+
   /**
    * Returns the Container with specified containerId.
    * @param containerId ID of the container to get
@@ -270,13 +279,7 @@ private boolean removeContainer(long containerId, boolean markMissing, boolean r
     }
     Container<?> removed = containerMap.remove(containerId);
     if (removeFromDB) {
-      try {
-        if (containerIdsTable != null) {
-          containerIdsTable.delete(ContainerID.valueOf(containerId));
-        }
-      } catch (IOException e) {
-        throw new StorageContainerException(e, ContainerProtos.Result.IO_EXCEPTION);
-      }
+      deleteFromContainerTable(containerId);
     }
     if (removed == null) {
       LOG.debug("Container with containerId {} is not present in " +
@@ -289,6 +292,16 @@ private boolean removeContainer(long containerId, boolean markMissing, boolean r
     }
   }
 
+  private void deleteFromContainerTable(long containerId) throws StorageContainerException {
+    if (null != containerMetadataStore) {
+      try {
+        containerMetadataStore.getContainerCreateInfoTable().delete(ContainerID.valueOf(containerId));
+      } catch (IOException e) {
+        throw new StorageContainerException(e, ContainerProtos.Result.IO_EXCEPTION);
+      }
+    }
+  }
+
   /**
    * Removes the Recovering Container matching with specified containerId.
    * @param containerId ID of the container to remove.
@@ -503,10 +516,6 @@ public Set<Long> getMissingContainerSet() {
     return missingContainerSet;
   }
 
-  public Table<ContainerID, String> getContainerIdsTable() {
-    return containerIdsTable;
-  }
-
   /**
    * Builds the missing container set by taking a diff between total no
    * containers actually found and number of containers which actually

hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/metadata/ContainerCreateInfo.java

@@ -0,0 +1,76 @@
+/*
+ * 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.container.metadata;
+
+import java.util.function.Supplier;
+import net.jcip.annotations.Immutable;
+import org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos;
+import org.apache.hadoop.hdds.utils.db.Codec;
+import org.apache.hadoop.hdds.utils.db.DelegatedCodec;
+import org.apache.hadoop.hdds.utils.db.Proto3Codec;
+import org.apache.ratis.util.MemoizedSupplier;
+
+/**
+ * ContainerCreateInfo is a class that holds information about the state and other information on creation
+ * This class is immutable.
+ */
+@Immutable
+public final class ContainerCreateInfo {
+  private static final Codec<ContainerCreateInfo> CODEC = new DelegatedCodec<>(
+      Proto3Codec.get(ContainerProtos.ContainerCreateInfo.getDefaultInstance()),
+      ContainerCreateInfo::getFromProtobuf, ContainerCreateInfo::getProtobuf,
+      ContainerCreateInfo.class);
+
+  private final ContainerProtos.ContainerDataProto.State state;
+  private final Supplier<ContainerProtos.ContainerCreateInfo> proto;
+
+  public static Codec<ContainerCreateInfo> getCodec() {
+    return CODEC;
+  }
+
+  public static Codec<ContainerCreateInfo> getNewCodec() {
+    return CODEC;
+  }
+
+  private ContainerCreateInfo(ContainerProtos.ContainerDataProto.State state) {
+    this.state = state;
+    this.proto = MemoizedSupplier.valueOf(
+        () -> ContainerProtos.ContainerCreateInfo.newBuilder().setState(state).build());
+  }
+
+  /**
+   * Factory method for creation of ContainerCreateInfo.
+   * @param state  State
+   * @return ContainerCreateInfo.
+   */
+  public static ContainerCreateInfo valueOf(final ContainerProtos.ContainerDataProto.State state) {
+    return new ContainerCreateInfo(state);
+  }
+
+  public ContainerProtos.ContainerCreateInfo getProtobuf() {
+    return proto.get();
+  }
+
+  public static ContainerCreateInfo getFromProtobuf(ContainerProtos.ContainerCreateInfo proto) {
+    return ContainerCreateInfo.valueOf(proto.getState());
+  }
+
+  public ContainerProtos.ContainerDataProto.State getState() {
+    return state;
+  }
+}

hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/metadata/WitnessedContainerDBDefinition.java

@@ -22,25 +22,24 @@
 import org.apache.hadoop.hdds.scm.container.ContainerID;
 import org.apache.hadoop.hdds.utils.db.DBColumnFamilyDefinition;
 import org.apache.hadoop.hdds.utils.db.DBDefinition;
-import org.apache.hadoop.hdds.utils.db.StringCodec;
 import org.apache.hadoop.ozone.OzoneConsts;
 
 /**
  * Class for defining the schema for master volume in a datanode.
  */
 public final class WitnessedContainerDBDefinition extends DBDefinition.WithMap {
 
-  private static final String CONTAINER_IDS_TABLE_NAME = "containerIds";
+  private static final String CONTAINER_CREATE_INFO_TABLE_NAME = "ContainerCreateInfoTable";
 
-  public static final DBColumnFamilyDefinition<ContainerID, String>
-      CONTAINER_IDS_TABLE = new DBColumnFamilyDefinition<>(
-      CONTAINER_IDS_TABLE_NAME,
+  public static final DBColumnFamilyDefinition<ContainerID, ContainerCreateInfo>
+      CONTAINER_CREATE_INFO_TABLE_DEF = new DBColumnFamilyDefinition<>(
+      CONTAINER_CREATE_INFO_TABLE_NAME,
       ContainerID.getCodec(),
-      StringCodec.get());
+      ContainerCreateInfo.getCodec());
 
   private static final Map<String, DBColumnFamilyDefinition<?, ?>>
       COLUMN_FAMILIES = DBColumnFamilyDefinition.newUnmodifiableMap(
-      CONTAINER_IDS_TABLE);
+      CONTAINER_CREATE_INFO_TABLE_DEF);
 
   private static final WitnessedContainerDBDefinition INSTANCE = new WitnessedContainerDBDefinition();
 
@@ -62,7 +61,7 @@ public String getLocationConfigKey() {
     return ScmConfigKeys.OZONE_SCM_DATANODE_ID_DIR;
   }
 
-  DBColumnFamilyDefinition<ContainerID, String> getContainerIdsTable() {
-    return CONTAINER_IDS_TABLE;
+  DBColumnFamilyDefinition<ContainerID, ContainerCreateInfo> getContainerCreateInfoTableDef() {
+    return CONTAINER_CREATE_INFO_TABLE_DEF;
   }
 }

hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/metadata/WitnessedContainerMetadataStore.java

@@ -29,5 +29,5 @@ public interface WitnessedContainerMetadataStore extends DBStoreManager {
    *
    * @return Table
    */
-  Table<ContainerID, String> getContainerIdsTable();
+  Table<ContainerID, ContainerCreateInfo> getContainerCreateInfoTable();
 }

hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/metadata/WitnessedContainerMetadataStoreImpl.java

@@ -22,21 +22,28 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import org.apache.hadoop.hdds.conf.ConfigurationSource;
+import org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos;
 import org.apache.hadoop.hdds.scm.container.ContainerID;
+import org.apache.hadoop.hdds.upgrade.HDDSLayoutFeature;
 import org.apache.hadoop.hdds.utils.db.CodecException;
 import org.apache.hadoop.hdds.utils.db.DBStore;
 import org.apache.hadoop.hdds.utils.db.DBStoreBuilder;
+import org.apache.hadoop.hdds.utils.db.DelegatedCodec;
 import org.apache.hadoop.hdds.utils.db.RocksDatabaseException;
+import org.apache.hadoop.hdds.utils.db.StringCodec;
 import org.apache.hadoop.hdds.utils.db.Table;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedDBOptions;
+import org.apache.hadoop.ozone.container.upgrade.VersionedDatanodeFeatures;
 
 /**
  * Class for interacting with database in the master volume of a datanode.
  */
 public final class WitnessedContainerMetadataStoreImpl extends AbstractRDBStore<WitnessedContainerDBDefinition>
     implements WitnessedContainerMetadataStore {
 
-  private Table<ContainerID, String> containerIdsTable;
+  private Table<ContainerID, ContainerCreateInfo> containerCreateInfoTable;
+  private PreviousVersionTables previousVersionTables;
+
   private static final ConcurrentMap<String, WitnessedContainerMetadataStore> INSTANCES =
       new ConcurrentHashMap<>();
 
@@ -67,13 +74,53 @@ private WitnessedContainerMetadataStoreImpl(ConfigurationSource config, boolean
   @Override
   protected DBStore initDBStore(DBStoreBuilder dbStoreBuilder, ManagedDBOptions options, ConfigurationSource config)
       throws RocksDatabaseException, CodecException {
+    previousVersionTables = new PreviousVersionTables();
+    previousVersionTables.addTables(dbStoreBuilder);
     final DBStore dbStore = dbStoreBuilder.build();
-    this.containerIdsTable = this.getDbDef().getContainerIdsTable().getTable(dbStore);
+    previousVersionTables.init(dbStore);
+    this.containerCreateInfoTable = this.getDbDef().getContainerCreateInfoTableDef().getTable(dbStore);
     return dbStore;
   }
 
   @Override
-  public Table<ContainerID, String> getContainerIdsTable() {
-    return containerIdsTable;
+  public Table<ContainerID, ContainerCreateInfo> getContainerCreateInfoTable() {
+    if (!VersionedDatanodeFeatures.isFinalized(HDDSLayoutFeature.WITNESSED_CONTAINER_DB_PROTO_VALUE)) {
+      return previousVersionTables.getContainerIdsTable();
+    }
+    return containerCreateInfoTable;
+  }
+
+  public PreviousVersionTables getPreviousVersionTables() {
+    return previousVersionTables;
+  }
+
+  /**
+   * this will hold old version tables required during upgrade, and these are initialized based on version only.
+   */
+  public static class PreviousVersionTables {
+    private static final String CONTAINER_IDS_STR_VAL_TABLE = "containerIds";
+    private Table<ContainerID, ContainerCreateInfo> containerIdsTable;
+
+    public PreviousVersionTables() {
+    }
+
+    public void addTables(DBStoreBuilder dbStoreBuilder) {
+      if (!VersionedDatanodeFeatures.isFinalized(HDDSLayoutFeature.WITNESSED_CONTAINER_DB_PROTO_VALUE)) {
+        dbStoreBuilder.addTable(CONTAINER_IDS_STR_VAL_TABLE);
+      }
+    }
+
+    public void init(DBStore dbStore) throws RocksDatabaseException, CodecException {
+      if (!VersionedDatanodeFeatures.isFinalized(HDDSLayoutFeature.WITNESSED_CONTAINER_DB_PROTO_VALUE)) {
+        this.containerIdsTable = dbStore.getTable(CONTAINER_IDS_STR_VAL_TABLE, ContainerID.getCodec(),
+            new DelegatedCodec<>(StringCodec.get(),
+                (strVal) -> ContainerCreateInfo.valueOf(ContainerProtos.ContainerDataProto.State.valueOf(strVal)),
+                (obj) -> obj.getState().name(), ContainerCreateInfo.class));
+      }
+    }
+
+    public Table<ContainerID, ContainerCreateInfo> getContainerIdsTable() {
+      return containerIdsTable;
+    }
   }
 }

hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/ozoneimpl/OzoneContainer.java

@@ -197,8 +197,7 @@ public OzoneContainer(HddsDatanodeService hddsDatanodeService,
         OZONE_RECOVERING_CONTAINER_TIMEOUT,
         OZONE_RECOVERING_CONTAINER_TIMEOUT_DEFAULT, TimeUnit.MILLISECONDS);
     this.witnessedContainerMetadataStore = WitnessedContainerMetadataStoreImpl.get(conf);
-    containerSet = ContainerSet.newRwContainerSet(witnessedContainerMetadataStore.getContainerIdsTable(),
-        recoveringContainerTimeout);
+    containerSet = ContainerSet.newRwContainerSet(witnessedContainerMetadataStore, recoveringContainerTimeout);
     volumeSet.setGatherContainerUsages(this::gatherContainerUsages);
     metadataScanner = null;
 
@@ -351,7 +350,8 @@ public void buildContainerSet() throws IOException {
       for (Thread volumeThread : volumeThreads) {
         volumeThread.join();
       }
-      try (TableIterator<ContainerID, ContainerID> itr = containerSet.getContainerIdsTable().keyIterator()) {
+      try (TableIterator<ContainerID, ContainerID> itr
+               = getWitnessedContainerMetadataStore().getContainerCreateInfoTable().keyIterator()) {
         final Map<ContainerID, Long> containerIds = new HashMap<>();
         while (itr.hasNext()) {
           containerIds.put(itr.next(), 0L);
@@ -686,4 +686,7 @@ public void compactDb() {
     }
   }
 
+  public WitnessedContainerMetadataStore getWitnessedContainerMetadataStore() {
+    return witnessedContainerMetadataStore;
+  }
 }