This is an automated email from the ASF dual-hosted git repository.
prashantpogde pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ozone.git
The following commit(s) were added to refs/heads/master by this push:
new 9c6cd4b93e Changed snapshotId to UUID (#4848)
9c6cd4b93e is described below
commit 9c6cd4b93e0427fc12bbedae8156c746cbe6cea1
Author: Hemant Kumar <[email protected]>
AuthorDate: Fri Jun 9 22:03:19 2023 -0700
Changed snapshotId to UUID (#4848)
---
.../java/org/apache/hadoop/hdds/HddsUtils.java | 23 ++
.../apache/ozone/rocksdiff/DifferSnapshotInfo.java | 15 +-
.../rocksdiff/TestRocksDBCheckpointDiffer.java | 12 +-
.../apache/hadoop/ozone/client/OzoneSnapshot.java | 23 +-
.../hadoop/ozone/om/helpers/SnapshotInfo.java | 138 +++----
.../ozone/om/helpers/TestOmSnapshotInfo.java | 25 +-
.../fs/ozone/TestSnapshotDeletingService.java | 14 +-
.../hadoop/ozone/freon/TestOMSnapshotDAG.java | 2 +-
.../ozone/om/TestOzoneManagerHASnapshot.java | 4 +-
.../src/main/proto/OmClientProtocol.proto | 8 +-
.../hadoop/ozone/om/OmMetadataManagerImpl.java | 54 ++-
.../apache/hadoop/ozone/om/OmSnapshotManager.java | 12 +-
.../apache/hadoop/ozone/om/SnapshotChainInfo.java | 45 +--
.../hadoop/ozone/om/SnapshotChainManager.java | 423 +++++++++------------
.../hadoop/ozone/om/SstFilteringService.java | 7 +-
.../request/snapshot/OMSnapshotCreateRequest.java | 34 +-
.../snapshot/OMSnapshotMoveDeletedKeysRequest.java | 17 +-
.../response/snapshot/OMSnapshotPurgeResponse.java | 55 ++-
.../ozone/om/service/SnapshotDeletingService.java | 14 +-
.../ozone/om/snapshot/SnapshotDiffManager.java | 6 +-
.../hadoop/ozone/om/TestOmSnapshotManager.java | 10 +-
.../apache/hadoop/ozone/om/TestSnapshotChain.java | 248 ++++++------
.../apache/hadoop/ozone/om/TestSnapshotInfo.java | 16 +-
.../hadoop/ozone/om/TestSstFilteringService.java | 2 +-
.../ozone/om/request/OMRequestTestUtils.java | 7 +-
.../TestOMSnapshotPurgeRequestAndResponse.java | 41 +-
.../snapshot/TestOMSnapshotCreateResponse.java | 2 +-
.../snapshot/TestOMSnapshotDeleteResponse.java | 2 +-
28 files changed, 598 insertions(+), 661 deletions(-)
diff --git
a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/HddsUtils.java
b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/HddsUtils.java
index e55b7340d4..b22b16ce4d 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/HddsUtils.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/HddsUtils.java
@@ -39,6 +39,7 @@ import java.util.Objects;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.TreeMap;
+import java.util.UUID;
import org.apache.hadoop.conf.ConfigRedactor;
import org.apache.hadoop.fs.CommonConfigurationKeysPublic;
@@ -51,6 +52,7 @@ import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos;
import
org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos.ContainerCommandRequestProtoOrBuilder;
import
org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos.ContainerDataProto.State;
+import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
import org.apache.hadoop.hdds.scm.ScmConfigKeys;
import org.apache.hadoop.hdds.scm.ha.SCMHAUtils;
import org.apache.hadoop.hdds.scm.ha.SCMNodeInfo;
@@ -849,6 +851,27 @@ public final class HddsUtils {
}
}
+ /**
+ * Transform a protobuf UUID to Java UUID.
+ */
+ public static UUID fromProtobuf(HddsProtos.UUID uuid) {
+ Objects.requireNonNull(uuid,
+ "HddsProtos.UUID can't be null to transform to java UUID.");
+ return new UUID(uuid.getMostSigBits(), uuid.getLeastSigBits());
+ }
+
+ /**
+ * Transform a Java UUID to protobuf UUID.
+ */
+ public static HddsProtos.UUID toProtobuf(UUID uuid) {
+ Objects.requireNonNull(uuid,
+ "UUID can't be null to transform to protobuf UUID.");
+ return HddsProtos.UUID.newBuilder()
+ .setMostSigBits(uuid.getMostSignificantBits())
+ .setLeastSigBits(uuid.getLeastSignificantBits())
+ .build();
+ }
+
/** Concatenate stack trace {@code elements} (one per line) starting at
* {@code startIndex}. */
public static @Nonnull String formatStackTrace(
diff --git
a/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdiff/DifferSnapshotInfo.java
b/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdiff/DifferSnapshotInfo.java
index fb82bd280f..a9f2f23bc8 100644
---
a/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdiff/DifferSnapshotInfo.java
+++
b/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdiff/DifferSnapshotInfo.java
@@ -18,21 +18,22 @@
package org.apache.ozone.rocksdiff;
import java.util.Map;
+import java.util.UUID;
/**
* Snapshot information node class for the differ.
*/
public class DifferSnapshotInfo {
private final String dbPath;
- private final String snapshotID;
+ private final UUID snapshotId;
private final long snapshotGeneration;
private final Map<String, String> tablePrefixes;
- public DifferSnapshotInfo(String db, String id, long gen,
+ public DifferSnapshotInfo(String db, UUID id, long gen,
Map<String, String> prefixes) {
dbPath = db;
- snapshotID = id;
+ snapshotId = id;
snapshotGeneration = gen;
tablePrefixes = prefixes;
}
@@ -41,8 +42,8 @@ public class DifferSnapshotInfo {
return dbPath;
}
- public String getSnapshotID() {
- return snapshotID;
+ public UUID getSnapshotId() {
+ return snapshotId;
}
public long getSnapshotGeneration() {
@@ -56,8 +57,8 @@ public class DifferSnapshotInfo {
@Override
public String toString() {
return String.format("DifferSnapshotInfo{dbPath='%s', snapshotID='%s', " +
- "snapshotGeneration=%d, tablePrefixes size=%s}",
- dbPath, snapshotID, snapshotGeneration, tablePrefixes.size());
+ "snapshotGeneration=%d, tablePrefixes size=%s}",
+ dbPath, snapshotId, snapshotGeneration, tablePrefixes.size());
}
}
diff --git
a/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdiff/TestRocksDBCheckpointDiffer.java
b/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdiff/TestRocksDBCheckpointDiffer.java
index a531aed071..69ceaa231c 100644
---
a/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdiff/TestRocksDBCheckpointDiffer.java
+++
b/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdiff/TestRocksDBCheckpointDiffer.java
@@ -175,13 +175,13 @@ public class TestRocksDBCheckpointDiffer {
private static Stream<Arguments> casesGetSSTDiffListWithoutDB() {
DifferSnapshotInfo snapshotInfo1 = new DifferSnapshotInfo(
- "/path/to/dbcp1", "ssUUID1", 3008L, null);
+ "/path/to/dbcp1", UUID.randomUUID(), 3008L, null);
DifferSnapshotInfo snapshotInfo2 = new DifferSnapshotInfo(
- "/path/to/dbcp2", "ssUUID2", 14980L, null);
+ "/path/to/dbcp2", UUID.randomUUID(), 14980L, null);
DifferSnapshotInfo snapshotInfo3 = new DifferSnapshotInfo(
- "/path/to/dbcp3", "ssUUID3", 17975L, null);
+ "/path/to/dbcp3", UUID.randomUUID(), 17975L, null);
DifferSnapshotInfo snapshotInfo4 = new DifferSnapshotInfo(
- "/path/to/dbcp4", "ssUUID4", 18000L, null);
+ "/path/to/dbcp4", UUID.randomUUID(), 18000L, null);
Set<String> snapshotSstFiles1 = new HashSet<>(asList(
"000059", "000053"));
@@ -432,14 +432,14 @@ public class TestRocksDBCheckpointDiffer {
final long dbLatestSequenceNumber = rocksDB.getLatestSequenceNumber();
createCheckPoint(activeDbDirName, cpPath, rocksDB);
- final String snapshotId = "snap_id_" + snapshotGeneration;
+ final UUID snapshotId = UUID.randomUUID();
final DifferSnapshotInfo currentSnapshot =
new DifferSnapshotInfo(cpPath, snapshotId, snapshotGeneration, null);
this.snapshots.add(currentSnapshot);
// Same as what OmSnapshotManager#createOmSnapshotCheckpoint would do
differ.appendSnapshotInfoToCompactionLog(dbLatestSequenceNumber,
- snapshotId,
+ snapshotId.toString(),
System.currentTimeMillis());
differ.setCurrentCompactionLog(dbLatestSequenceNumber);
diff --git
a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneSnapshot.java
b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneSnapshot.java
index 6ddb5854e9..91cf655090 100644
---
a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneSnapshot.java
+++
b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneSnapshot.java
@@ -19,6 +19,8 @@ package org.apache.hadoop.ozone.client;
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo.SnapshotStatus;
+import java.util.UUID;
+
/**
* A class that encapsulates OzoneSnapshot.
*/
@@ -29,7 +31,7 @@ public class OzoneSnapshot {
private final String name;
private final long creationTime;
private final SnapshotStatus snapshotStatus;
- private final String snapshotID; // UUID
+ private final UUID snapshotId; // UUID
private final String snapshotPath; // snapshot mask
private final String checkpointDir;
@@ -40,22 +42,25 @@ public class OzoneSnapshot {
* @param name Name of the snapshot.
* @param creationTime Creation time of the snapshot.
* @param snapshotStatus Status of the snapshot.
- * @param snapshotID ID of the snapshot.
+ * @param snapshotId ID of the snapshot.
* @param snapshotPath Path of the snapshot.
* @param checkpointDir Snapshot checkpoint directory.
*/
@SuppressWarnings("parameternumber")
- public OzoneSnapshot(String volumeName, String bucketName,
- String name, long creationTime,
+ public OzoneSnapshot(String volumeName,
+ String bucketName,
+ String name,
+ long creationTime,
SnapshotStatus snapshotStatus,
- String snapshotID, String snapshotPath,
+ UUID snapshotId,
+ String snapshotPath,
String checkpointDir) {
this.volumeName = volumeName;
this.bucketName = bucketName;
this.name = name;
this.creationTime = creationTime;
this.snapshotStatus = snapshotStatus;
- this.snapshotID = snapshotID;
+ this.snapshotId = snapshotId;
this.snapshotPath = snapshotPath;
this.checkpointDir = checkpointDir;
}
@@ -110,8 +115,8 @@ public class OzoneSnapshot {
*
* @return snapshotID
*/
- public String getSnapshotID() {
- return snapshotID;
+ public UUID getSnapshotId() {
+ return snapshotId;
}
/**
@@ -138,7 +143,7 @@ public class OzoneSnapshot {
snapshotInfo.getName(),
snapshotInfo.getCreationTime(),
snapshotInfo.getSnapshotStatus(),
- snapshotInfo.getSnapshotID(),
+ snapshotInfo.getSnapshotId(),
snapshotInfo.getSnapshotPath(),
snapshotInfo.getCheckpointDir());
}
diff --git
a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/SnapshotInfo.java
b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/SnapshotInfo.java
index 33d650a774..1be0ace8aa 100644
---
a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/SnapshotInfo.java
+++
b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/SnapshotInfo.java
@@ -40,6 +40,8 @@ import java.util.UUID;
import java.util.Map;
import java.util.LinkedHashMap;
+import static org.apache.hadoop.hdds.HddsUtils.fromProtobuf;
+import static org.apache.hadoop.hdds.HddsUtils.toProtobuf;
import static org.apache.hadoop.ozone.OzoneConsts.OM_KEY_PREFIX;
/**
@@ -106,28 +108,27 @@ public final class SnapshotInfo implements Auditable {
private static final String SEPARATOR = "-";
private static final long INVALID_TIMESTAMP = -1;
- private static final String INITIAL_SNAPSHOT_ID =
- UUID.randomUUID().toString();
-
- private final String snapshotID; // UUID
+ private static final UUID INITIAL_SNAPSHOT_ID = UUID.randomUUID();
+
+ private final UUID snapshotId;
private String name;
private String volumeName;
private String bucketName;
private SnapshotStatus snapshotStatus;
private final long creationTime;
private long deletionTime;
- private String pathPreviousSnapshotID;
- private String globalPreviousSnapshotID;
+ private UUID pathPreviousSnapshotId;
+ private UUID globalPreviousSnapshotId;
private String snapshotPath; // snapshot mask
private String checkpointDir;
/**
- * RocksDB transaction sequence number at the time of checkpoint creation.
+ * RocksDB's transaction sequence number at the time of checkpoint creation.
*/
private long dbTxSequenceNumber;
/**
* Private constructor, constructed via builder.
- * @param snapshotID - Snapshot UUID.
+ * @param snapshotId - Snapshot UUID.
* @param name - snapshot name.
* @param volumeName - volume name.
* @param bucketName - bucket name.
@@ -135,33 +136,33 @@ public final class SnapshotInfo implements Auditable {
* SNAPSHOT_RECLAIMED
* @param creationTime - Snapshot creation time.
* @param deletionTime - Snapshot deletion time.
- * @param pathPreviousSnapshotID - Snapshot path previous snapshot id.
- * @param globalPreviousSnapshotID - Snapshot global previous snapshot id.
+ * @param pathPreviousSnapshotId - Snapshot path previous snapshot id.
+ * @param globalPreviousSnapshotId - Snapshot global previous snapshot id.
* @param snapshotPath - Snapshot path, bucket .snapshot path.
* @param checkpointDir - Snapshot checkpoint directory.
*/
@SuppressWarnings("checkstyle:ParameterNumber")
- private SnapshotInfo(String snapshotID,
+ private SnapshotInfo(UUID snapshotId,
String name,
String volumeName,
String bucketName,
SnapshotStatus snapshotStatus,
long creationTime,
long deletionTime,
- String pathPreviousSnapshotID,
- String globalPreviousSnapshotID,
+ UUID pathPreviousSnapshotId,
+ UUID globalPreviousSnapshotId,
String snapshotPath,
String checkpointDir,
long dbTxSequenceNumber) {
- this.snapshotID = snapshotID;
+ this.snapshotId = snapshotId;
this.name = name;
this.volumeName = volumeName;
this.bucketName = bucketName;
this.snapshotStatus = snapshotStatus;
this.creationTime = creationTime;
this.deletionTime = deletionTime;
- this.pathPreviousSnapshotID = pathPreviousSnapshotID;
- this.globalPreviousSnapshotID = globalPreviousSnapshotID;
+ this.pathPreviousSnapshotId = pathPreviousSnapshotId;
+ this.globalPreviousSnapshotId = globalPreviousSnapshotId;
this.snapshotPath = snapshotPath;
this.checkpointDir = checkpointDir;
this.dbTxSequenceNumber = dbTxSequenceNumber;
@@ -187,12 +188,12 @@ public final class SnapshotInfo implements Auditable {
this.deletionTime = delTime;
}
- public void setPathPreviousSnapshotID(String pathPreviousSnapshotID) {
- this.pathPreviousSnapshotID = pathPreviousSnapshotID;
+ public void setPathPreviousSnapshotId(UUID pathPreviousSnapshotId) {
+ this.pathPreviousSnapshotId = pathPreviousSnapshotId;
}
- public void setGlobalPreviousSnapshotID(String globalPreviousSnapshotID) {
- this.globalPreviousSnapshotID = globalPreviousSnapshotID;
+ public void setGlobalPreviousSnapshotId(UUID globalPreviousSnapshotId) {
+ this.globalPreviousSnapshotId = globalPreviousSnapshotId;
}
public void setSnapshotPath(String snapshotPath) {
@@ -203,8 +204,8 @@ public final class SnapshotInfo implements Auditable {
this.checkpointDir = checkpointDir;
}
- public String getSnapshotID() {
- return snapshotID;
+ public UUID getSnapshotId() {
+ return snapshotId;
}
public String getName() {
@@ -231,12 +232,12 @@ public final class SnapshotInfo implements Auditable {
return deletionTime;
}
- public String getPathPreviousSnapshotID() {
- return pathPreviousSnapshotID;
+ public UUID getPathPreviousSnapshotId() {
+ return pathPreviousSnapshotId;
}
- public String getGlobalPreviousSnapshotID() {
- return globalPreviousSnapshotID;
+ public UUID getGlobalPreviousSnapshotId() {
+ return globalPreviousSnapshotId;
}
public String getSnapshotPath() {
@@ -254,15 +255,15 @@ public final class SnapshotInfo implements Auditable {
public SnapshotInfo.Builder toBuilder() {
return new SnapshotInfo.Builder()
- .setSnapshotID(snapshotID)
+ .setSnapshotId(snapshotId)
.setName(name)
.setVolumeName(volumeName)
.setBucketName(bucketName)
.setSnapshotStatus(snapshotStatus)
.setCreationTime(creationTime)
.setDeletionTime(deletionTime)
- .setPathPreviousSnapshotID(pathPreviousSnapshotID)
- .setGlobalPreviousSnapshotID(globalPreviousSnapshotID)
+ .setPathPreviousSnapshotId(pathPreviousSnapshotId)
+ .setGlobalPreviousSnapshotId(globalPreviousSnapshotId)
.setSnapshotPath(snapshotPath)
.setCheckpointDir(checkpointDir);
}
@@ -271,15 +272,15 @@ public final class SnapshotInfo implements Auditable {
* Builder of SnapshotInfo.
*/
public static class Builder {
- private String snapshotID;
+ private UUID snapshotId;
private String name;
private String volumeName;
private String bucketName;
private SnapshotStatus snapshotStatus;
private long creationTime;
private long deletionTime;
- private String pathPreviousSnapshotID;
- private String globalPreviousSnapshotID;
+ private UUID pathPreviousSnapshotId;
+ private UUID globalPreviousSnapshotId;
private String snapshotPath;
private String checkpointDir;
private long dbTxSequenceNumber;
@@ -289,8 +290,8 @@ public final class SnapshotInfo implements Auditable {
this.snapshotStatus = SnapshotStatus.DEFAULT;
}
- public Builder setSnapshotID(String snapshotID) {
- this.snapshotID = snapshotID;
+ public Builder setSnapshotId(UUID snapshotId) {
+ this.snapshotId = snapshotId;
return this;
}
@@ -324,14 +325,13 @@ public final class SnapshotInfo implements Auditable {
return this;
}
- public Builder setPathPreviousSnapshotID(String pathPreviousSnapshotID) {
- this.pathPreviousSnapshotID = pathPreviousSnapshotID;
+ public Builder setPathPreviousSnapshotId(UUID pathPreviousSnapshotId) {
+ this.pathPreviousSnapshotId = pathPreviousSnapshotId;
return this;
}
- public Builder setGlobalPreviousSnapshotID(
- String globalPreviousSnapshotID) {
- this.globalPreviousSnapshotID = globalPreviousSnapshotID;
+ public Builder setGlobalPreviousSnapshotId(UUID globalPreviousSnapshotId) {
+ this.globalPreviousSnapshotId = globalPreviousSnapshotId;
return this;
}
@@ -353,15 +353,15 @@ public final class SnapshotInfo implements Auditable {
public SnapshotInfo build() {
Preconditions.checkNotNull(name);
return new SnapshotInfo(
- snapshotID,
+ snapshotId,
name,
volumeName,
bucketName,
snapshotStatus,
creationTime,
deletionTime,
- pathPreviousSnapshotID,
- globalPreviousSnapshotID,
+ pathPreviousSnapshotId,
+ globalPreviousSnapshotId,
snapshotPath,
checkpointDir,
dbTxSequenceNumber
@@ -375,7 +375,7 @@ public final class SnapshotInfo implements Auditable {
public OzoneManagerProtocolProtos.SnapshotInfo getProtobuf() {
OzoneManagerProtocolProtos.SnapshotInfo.Builder sib =
OzoneManagerProtocolProtos.SnapshotInfo.newBuilder()
- .setSnapshotID(snapshotID)
+ .setSnapshotID(toProtobuf(snapshotId))
.setName(name)
.setVolumeName(volumeName)
.setBucketName(bucketName)
@@ -383,12 +383,12 @@ public final class SnapshotInfo implements Auditable {
.setCreationTime(creationTime)
.setDeletionTime(deletionTime);
- if (pathPreviousSnapshotID != null) {
- sib.setPathPreviousSnapshotID(pathPreviousSnapshotID);
+ if (pathPreviousSnapshotId != null) {
+ sib.setPathPreviousSnapshotID(toProtobuf(pathPreviousSnapshotId));
}
- if (globalPreviousSnapshotID != null) {
- sib.setGlobalPreviousSnapshotID(globalPreviousSnapshotID);
+ if (globalPreviousSnapshotId != null) {
+ sib.setGlobalPreviousSnapshotID(toProtobuf(globalPreviousSnapshotId));
}
sib.setSnapshotPath(snapshotPath)
@@ -404,8 +404,9 @@ public final class SnapshotInfo implements Auditable {
*/
public static SnapshotInfo getFromProtobuf(
OzoneManagerProtocolProtos.SnapshotInfo snapshotInfoProto) {
+
SnapshotInfo.Builder osib = SnapshotInfo.newBuilder()
- .setSnapshotID(snapshotInfoProto.getSnapshotID())
+ .setSnapshotId(fromProtobuf(snapshotInfoProto.getSnapshotID()))
.setName(snapshotInfoProto.getName())
.setVolumeName(snapshotInfoProto.getVolumeName())
.setBucketName(snapshotInfoProto.getBucketName())
@@ -415,13 +416,13 @@ public final class SnapshotInfo implements Auditable {
.setDeletionTime(snapshotInfoProto.getDeletionTime());
if (snapshotInfoProto.hasPathPreviousSnapshotID()) {
- osib.setPathPreviousSnapshotID(snapshotInfoProto.
- getPathPreviousSnapshotID());
+ osib.setPathPreviousSnapshotId(
+ fromProtobuf(snapshotInfoProto.getPathPreviousSnapshotID()));
}
if (snapshotInfoProto.hasGlobalPreviousSnapshotID()) {
- osib.setGlobalPreviousSnapshotID(snapshotInfoProto.
- getGlobalPreviousSnapshotID());
+ osib.setGlobalPreviousSnapshotId(
+ fromProtobuf(snapshotInfoProto.getGlobalPreviousSnapshotID()));
}
osib.setSnapshotPath(snapshotInfoProto.getSnapshotPath())
@@ -443,14 +444,16 @@ public final class SnapshotInfo implements Auditable {
/**
* Get the name of the checkpoint directory.
*/
- public static String getCheckpointDirName(String snapshotId) {
+ public static String getCheckpointDirName(UUID snapshotId) {
+ Objects.requireNonNull(snapshotId,
+ "SnapshotId is needed to create checkpoint directory");
return SEPARATOR + snapshotId;
}
/**
* Get the name of the checkpoint directory, (non-static).
*/
public String getCheckpointDirName() {
- return getCheckpointDirName(getSnapshotID());
+ return getCheckpointDirName(getSnapshotId());
}
public long getDbTxSequenceNumber() {
@@ -492,22 +495,25 @@ public final class SnapshotInfo implements Auditable {
public static SnapshotInfo newInstance(String volumeName,
String bucketName,
String snapshotName,
- String snapshotId,
+ UUID snapshotId,
long creationTime) {
SnapshotInfo.Builder builder = new SnapshotInfo.Builder();
if (StringUtils.isBlank(snapshotName)) {
snapshotName = generateName(creationTime);
}
- builder.setSnapshotID(snapshotId)
+ builder.setSnapshotId(snapshotId)
.setName(snapshotName)
.setCreationTime(creationTime)
.setDeletionTime(INVALID_TIMESTAMP)
- .setPathPreviousSnapshotID(INITIAL_SNAPSHOT_ID)
- .setGlobalPreviousSnapshotID(INITIAL_SNAPSHOT_ID)
+ .setPathPreviousSnapshotId(INITIAL_SNAPSHOT_ID)
+ .setGlobalPreviousSnapshotId(INITIAL_SNAPSHOT_ID)
.setSnapshotPath(volumeName + OM_KEY_PREFIX + bucketName)
.setVolumeName(volumeName)
- .setBucketName(bucketName)
- .setCheckpointDir(getCheckpointDirName(snapshotId));
+ .setBucketName(bucketName);
+
+ if (snapshotId != null) {
+ builder.setCheckpointDir(getCheckpointDirName(snapshotId));
+ }
return builder.build();
}
@@ -522,22 +528,22 @@ public final class SnapshotInfo implements Auditable {
SnapshotInfo that = (SnapshotInfo) o;
return creationTime == that.creationTime &&
deletionTime == that.deletionTime &&
- snapshotID.equals(that.snapshotID) &&
+ snapshotId.equals(that.snapshotId) &&
name.equals(that.name) && volumeName.equals(that.volumeName) &&
bucketName.equals(that.bucketName) &&
snapshotStatus == that.snapshotStatus &&
- Objects.equals(pathPreviousSnapshotID, that.pathPreviousSnapshotID) &&
+ Objects.equals(pathPreviousSnapshotId, that.pathPreviousSnapshotId) &&
Objects.equals(
- globalPreviousSnapshotID, that.globalPreviousSnapshotID) &&
+ globalPreviousSnapshotId, that.globalPreviousSnapshotId) &&
snapshotPath.equals(that.snapshotPath) &&
checkpointDir.equals(that.checkpointDir);
}
@Override
public int hashCode() {
- return Objects.hash(snapshotID, name, volumeName, bucketName,
+ return Objects.hash(snapshotId, name, volumeName, bucketName,
snapshotStatus,
- creationTime, deletionTime, pathPreviousSnapshotID,
- globalPreviousSnapshotID, snapshotPath, checkpointDir);
+ creationTime, deletionTime, pathPreviousSnapshotId,
+ globalPreviousSnapshotId, snapshotPath, checkpointDir);
}
}
diff --git
a/hadoop-ozone/common/src/test/java/org/apache/hadoop/ozone/om/helpers/TestOmSnapshotInfo.java
b/hadoop-ozone/common/src/test/java/org/apache/hadoop/ozone/om/helpers/TestOmSnapshotInfo.java
index 4fd9e2335c..c081c11a66 100644
---
a/hadoop-ozone/common/src/test/java/org/apache/hadoop/ozone/om/helpers/TestOmSnapshotInfo.java
+++
b/hadoop-ozone/common/src/test/java/org/apache/hadoop/ozone/om/helpers/TestOmSnapshotInfo.java
@@ -29,13 +29,15 @@ import org.junit.Assert;
import java.util.UUID;
+import static org.apache.hadoop.hdds.HddsUtils.toProtobuf;
+
/**
* Tests SnapshotInfo metadata data structure holding state info for
* object storage snapshots.
*/
public class TestOmSnapshotInfo {
- private static final String SNAPSHOT_ID = UUID.randomUUID().toString();
+ private static final UUID SNAPSHOT_ID = UUID.randomUUID();
private static final String NAME = "snapshot1";
private static final String VOLUME_NAME = "vol1";
private static final String BUCKET_NAME = "bucket1";
@@ -43,9 +45,8 @@ public class TestOmSnapshotInfo {
SnapshotStatus.SNAPSHOT_ACTIVE;
private static final long CREATION_TIME = Time.now();
private static final long DELETION_TIME = -1;
- private static final String PATH_PREVIOUS_SNAPSHOT_ID =
- UUID.randomUUID().toString();
- private static final String GLOBAL_PREVIOUS_SNAPSHOT_ID =
+ private static final UUID PATH_PREVIOUS_SNAPSHOT_ID = UUID.randomUUID();
+ private static final UUID GLOBAL_PREVIOUS_SNAPSHOT_ID =
PATH_PREVIOUS_SNAPSHOT_ID;
private static final String SNAPSHOT_PATH = "test/path";
private static final String CHECKPOINT_DIR = "checkpoint.testdir";
@@ -53,15 +54,15 @@ public class TestOmSnapshotInfo {
private SnapshotInfo createSnapshotInfo() {
return new SnapshotInfo.Builder()
- .setSnapshotID(SNAPSHOT_ID)
+ .setSnapshotId(SNAPSHOT_ID)
.setName(NAME)
.setVolumeName(VOLUME_NAME)
.setBucketName(BUCKET_NAME)
.setSnapshotStatus(SNAPSHOT_STATUS)
.setCreationTime(CREATION_TIME)
.setDeletionTime(DELETION_TIME)
- .setPathPreviousSnapshotID(PATH_PREVIOUS_SNAPSHOT_ID)
- .setGlobalPreviousSnapshotID(GLOBAL_PREVIOUS_SNAPSHOT_ID)
+ .setPathPreviousSnapshotId(PATH_PREVIOUS_SNAPSHOT_ID)
+ .setGlobalPreviousSnapshotId(GLOBAL_PREVIOUS_SNAPSHOT_ID)
.setSnapshotPath(SNAPSHOT_PATH)
.setCheckpointDir(CHECKPOINT_DIR)
.setDbTxSequenceNumber(DB_TX_SEQUENCE_NUMBER)
@@ -70,15 +71,15 @@ public class TestOmSnapshotInfo {
private OzoneManagerProtocolProtos.SnapshotInfo createSnapshotInfoProto() {
return OzoneManagerProtocolProtos.SnapshotInfo.newBuilder()
- .setSnapshotID(SNAPSHOT_ID)
+ .setSnapshotID(toProtobuf(SNAPSHOT_ID))
.setName(NAME)
.setVolumeName(VOLUME_NAME)
.setBucketName(BUCKET_NAME)
.setSnapshotStatus(SnapshotStatusProto.SNAPSHOT_ACTIVE)
.setCreationTime(CREATION_TIME)
.setDeletionTime(DELETION_TIME)
- .setPathPreviousSnapshotID(PATH_PREVIOUS_SNAPSHOT_ID)
- .setGlobalPreviousSnapshotID(GLOBAL_PREVIOUS_SNAPSHOT_ID)
+ .setPathPreviousSnapshotID(toProtobuf(PATH_PREVIOUS_SNAPSHOT_ID))
+ .setGlobalPreviousSnapshotID(toProtobuf(GLOBAL_PREVIOUS_SNAPSHOT_ID))
.setSnapshotPath(SNAPSHOT_PATH)
.setCheckpointDir(CHECKPOINT_DIR)
.setDbTxSequenceNumber(DB_TX_SEQUENCE_NUMBER)
@@ -124,8 +125,8 @@ public class TestOmSnapshotInfo {
SnapshotInfo snapshotInfoActual = SnapshotInfo
.getFromProtobuf(snapshotInfoEntry);
- Assert.assertEquals(snapshotInfoExpected.getSnapshotID(),
- snapshotInfoActual.getSnapshotID());
+ Assert.assertEquals(snapshotInfoExpected.getSnapshotId(),
+ snapshotInfoActual.getSnapshotId());
Assert.assertEquals(snapshotInfoExpected.getName(),
snapshotInfoActual.getName());
Assert.assertEquals(snapshotInfoExpected.getVolumeName(),
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSnapshotDeletingService.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSnapshotDeletingService.java
index 1f2a1b657e..7f884ba64d 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSnapshotDeletingService.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSnapshotDeletingService.java
@@ -50,6 +50,7 @@ import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.List;
import java.util.Objects;
+import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
@@ -427,9 +428,10 @@ public class TestSnapshotDeletingService {
throws Exception {
OmMetadataManagerImpl metadataManager = (OmMetadataManagerImpl)
om.getMetadataManager();
- String pathPreviousSnapshotID =
deletedSnapshot.getPathPreviousSnapshotID();
- String globalPreviousSnapshotID = deletedSnapshot
- .getGlobalPreviousSnapshotID();
+ UUID pathPreviousSnapshotId = deletedSnapshot.getPathPreviousSnapshotId();
+ UUID globalPreviousSnapshotId =
+ deletedSnapshot.getGlobalPreviousSnapshotId();
+
GenericTestUtils.waitFor(() -> {
try {
SnapshotInfo snapshotInfo = metadataManager.getSnapshotInfoTable()
@@ -445,9 +447,9 @@ public class TestSnapshotDeletingService {
SnapshotInfo nextSnapshotInfo = metadataManager
.getSnapshotInfoTable().get(nextSnapshot);
GenericTestUtils.waitFor(() -> Objects.equals(
- nextSnapshotInfo.getPathPreviousSnapshotID(), pathPreviousSnapshotID)
- && Objects.equals(nextSnapshotInfo.getGlobalPreviousSnapshotID(),
- globalPreviousSnapshotID), 100, 10000);
+ nextSnapshotInfo.getPathPreviousSnapshotId(), pathPreviousSnapshotId)
+ && Objects.equals(nextSnapshotInfo.getGlobalPreviousSnapshotId(),
+ globalPreviousSnapshotId), 100, 10000);
}
}
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java
index d8222ce8c0..7ed6eace55 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java
@@ -150,7 +150,7 @@ public class TestOMSnapshotDAG {
// Use RocksDB transaction sequence number in SnapshotInfo, which is
// persisted at the time of snapshot creation, as the snapshot generation
- return new DifferSnapshotInfo(checkpointPath, snapshotInfo.getSnapshotID(),
+ return new DifferSnapshotInfo(checkpointPath, snapshotInfo.getSnapshotId(),
snapshotInfo.getDbTxSequenceNumber(),
getTablePrefixes(omMetadataManager, volumeName, bucketName));
}
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOzoneManagerHASnapshot.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOzoneManagerHASnapshot.java
index 960633c32a..b294707e2f 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOzoneManagerHASnapshot.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOzoneManagerHASnapshot.java
@@ -161,7 +161,7 @@ public class TestOzoneManagerHASnapshot {
store.createSnapshot(volumeName, bucketName, snapshotName);
List<OzoneManager> ozoneManagers = cluster.getOzoneManagersList();
- List<String> snapshotIds = new ArrayList<>();
+ List<UUID> snapshotIds = new ArrayList<>();
for (OzoneManager ozoneManager : ozoneManagers) {
await().atMost(Duration.ofSeconds(120))
@@ -178,7 +178,7 @@ public class TestOzoneManagerHASnapshot {
}
if (snapshotInfo != null) {
- snapshotIds.add(snapshotInfo.getSnapshotID());
+ snapshotIds.add(snapshotInfo.getSnapshotId());
}
return snapshotInfo != null;
});
diff --git
a/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto
b/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto
index f77cbbb007..9e7fa19a33 100644
--- a/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto
+++ b/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto
@@ -786,15 +786,15 @@ enum SnapshotStatusProto {
* SnapshotInfo table entry for Bucket/Volume snapshot metadata
*/
message SnapshotInfo {
- optional string snapshotID = 1;
+ optional hadoop.hdds.UUID snapshotID = 1;
optional string name = 2;
optional string volumeName = 3;
optional string bucketName = 4;
optional SnapshotStatusProto snapshotStatus = 5;
optional uint64 creationTime = 6;
optional uint64 deletionTime = 7;
- optional string pathPreviousSnapshotID = 8;
- optional string globalPreviousSnapshotID = 9;
+ optional hadoop.hdds.UUID pathPreviousSnapshotID = 8;
+ optional hadoop.hdds.UUID globalPreviousSnapshotID = 9;
optional string snapshotPath = 10;
optional string checkpointDir = 11;
optional int64 dbTxSequenceNumber = 12;
@@ -1701,7 +1701,7 @@ message CreateSnapshotRequest {
optional string volumeName = 1;
optional string bucketName = 2;
optional string snapshotName = 3;
- optional string snapshotId = 4;
+ optional hadoop.hdds.UUID snapshotId = 4;
optional uint64 creationTime = 5;
}
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java
index 1f122f6eeb..f6519bb098 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java
@@ -27,9 +27,12 @@ import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
+import java.util.UUID;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -1117,8 +1120,8 @@ public class OmMetadataManagerImpl implements
OMMetadataManager,
result.add(omBucketInfo);
currentCount++;
} else if (
- StringUtils.isNotEmpty(
- snapshotChainManager.getLatestPathSnapshot(volumeName +
+ Objects.nonNull(
+ snapshotChainManager.getLatestPathSnapshotId(volumeName +
OM_KEY_PREFIX + omBucketInfo.getBucketName()))) {
// Snapshot filter on.
// Add to result list only when the bucket has at least one
snapshot
@@ -1618,37 +1621,46 @@ public class OmMetadataManagerImpl implements
OMMetadataManager,
OmSnapshotManager snapshotManager)
throws IOException {
+
String snapshotPath = volumeName + OM_KEY_PREFIX + bucketName;
- String latestPathSnapshot = snapshotChainManager
- .getLatestPathSnapshot(snapshotPath);
+ Optional<UUID> latestPathSnapshot = Optional.ofNullable(
+ snapshotChainManager.getLatestPathSnapshotId(snapshotPath));
+
+ Optional<SnapshotInfo> snapshotInfo = Optional.empty();
+
+ while (latestPathSnapshot.isPresent()) {
+ Optional<String> snapTableKey = latestPathSnapshot
+ .map(uuid -> snapshotChainManager.getTableKey(uuid));
- SnapshotInfo snapInfo = null;
- while (latestPathSnapshot != null) {
- String snapTableKey = snapshotChainManager
- .getTableKey(latestPathSnapshot);
- snapInfo = getSnapshotInfoTable().get(snapTableKey);
+ snapshotInfo = snapTableKey.isPresent() ?
+ Optional.ofNullable(getSnapshotInfoTable().get(snapTableKey.get())) :
+ Optional.empty();
- if (snapInfo != null && snapInfo.getSnapshotStatus() ==
+ if (snapshotInfo.isPresent() && snapshotInfo.get().getSnapshotStatus() ==
SnapshotInfo.SnapshotStatus.SNAPSHOT_ACTIVE) {
break;
}
// Update latestPathSnapshot if current snapshot is deleted.
- if (snapshotChainManager.hasPreviousPathSnapshot(
- snapshotPath, latestPathSnapshot)) {
- latestPathSnapshot = snapshotChainManager
- .previousPathSnapshot(snapshotPath, latestPathSnapshot);
+ if (snapshotChainManager.hasPreviousPathSnapshot(snapshotPath,
+ latestPathSnapshot.get())) {
+ latestPathSnapshot = Optional.ofNullable(snapshotChainManager
+ .previousPathSnapshot(snapshotPath, latestPathSnapshot.get()));
} else {
- latestPathSnapshot = null;
+ latestPathSnapshot = Optional.empty();
}
}
- OmSnapshot omSnapshot = null;
- if (snapInfo != null) {
- omSnapshot = (OmSnapshot) snapshotManager.checkForSnapshot(volumeName,
- bucketName, getSnapshotPrefix(snapInfo.getName()), true);
- }
- return omSnapshot;
+ Optional<OmSnapshot> omSnapshot = snapshotInfo.isPresent() ?
+ Optional.ofNullable(
+ (OmSnapshot) snapshotManager.checkForSnapshot(volumeName,
+ bucketName,
+ getSnapshotPrefix(snapshotInfo.get().getName()),
+ true)
+ ) :
+ Optional.empty();
+
+ return omSnapshot.orElse(null);
}
@Override
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java
index 537e9c712f..cdd39ead34 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java
@@ -416,10 +416,12 @@ public final class OmSnapshotManager implements
AutoCloseable {
if (dbCpDiffer != null) {
final long dbLatestSequenceNumber = snapshotInfo.getDbTxSequenceNumber();
+ Objects.requireNonNull(snapshotInfo.getSnapshotId(),
+ "SnapshotId is null for snapshot: " + snapshotInfo.getName());
// Write snapshot generation (latest sequence number) to compaction log.
// This will be used for DAG reconstruction as snapshotGeneration.
dbCpDiffer.appendSnapshotInfoToCompactionLog(dbLatestSequenceNumber,
- snapshotInfo.getSnapshotID(),
+ snapshotInfo.getSnapshotId().toString(),
snapshotInfo.getCreationTime());
// Set compaction log filename to the latest DB sequence number
@@ -586,18 +588,18 @@ public final class OmSnapshotManager implements
AutoCloseable {
// one by one.
}
- // Get OmSnapshot if the keyname has ".snapshot" key indicator
+ // Get OmSnapshot if the keyName has ".snapshot" key indicator
public IOmMetadataReader checkForSnapshot(String volumeName,
String bucketName,
- String keyname,
+ String keyName,
boolean skipActiveCheck)
throws IOException {
- if (keyname == null || !ozoneManager.isFilesystemSnapshotEnabled()) {
+ if (keyName == null || !ozoneManager.isFilesystemSnapshotEnabled()) {
return ozoneManager.getOmMetadataReader();
}
// see if key is for a snapshot
- String[] keyParts = keyname.split("/");
+ String[] keyParts = keyName.split("/");
if (isSnapshotKey(keyParts)) {
String snapshotName = keyParts[1];
if (snapshotName == null || snapshotName.isEmpty()) {
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainInfo.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainInfo.java
index 7d4d5165db..239ed9be64 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainInfo.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainInfo.java
@@ -17,43 +17,44 @@
package org.apache.hadoop.ozone.om;
import java.util.Objects;
+import java.util.UUID;
/**
* SnapshotChain supporting SnapshotInfo class.
- *
+ * <p>
* Defines and provides the interface to the SnapshotChainInfo
* entry that comprises a SnapshotChain.
* Getters / setters for current, prev, next element in snapshot chain.
*/
public class SnapshotChainInfo {
- private String snapshotID;
- private String previousSnapshotID;
- private String nextSnapshotID;
+ private final UUID snapshotId;
+ private UUID previousSnapshotId;
+ private UUID nextSnapshotId;
- public SnapshotChainInfo(String snapshotID, String prev, String next) {
- this.snapshotID = snapshotID;
- previousSnapshotID = prev;
- nextSnapshotID = next;
+ public SnapshotChainInfo(UUID snapshotID, UUID prev, UUID next) {
+ this.snapshotId = snapshotID;
+ this.previousSnapshotId = prev;
+ this.nextSnapshotId = next;
}
- public void setNextSnapshotID(String snapsID) {
- nextSnapshotID = snapsID;
+ public void setNextSnapshotId(UUID snapsID) {
+ nextSnapshotId = snapsID;
}
- public void setPreviousSnapshotID(String snapsID) {
- previousSnapshotID = snapsID;
+ public void setPreviousSnapshotId(UUID snapsID) {
+ previousSnapshotId = snapsID;
}
- public String getSnapshotID() {
- return snapshotID;
+ public UUID getSnapshotId() {
+ return snapshotId;
}
- public String getNextSnapshotID() {
- return nextSnapshotID;
+ public UUID getNextSnapshotId() {
+ return nextSnapshotId;
}
- public String getPreviousSnapshotID() {
- return previousSnapshotID;
+ public UUID getPreviousSnapshotId() {
+ return previousSnapshotId;
}
@Override
@@ -65,13 +66,13 @@ public class SnapshotChainInfo {
return false;
}
SnapshotChainInfo that = (SnapshotChainInfo) o;
- return Objects.equals(snapshotID, that.snapshotID) &&
- Objects.equals(previousSnapshotID, that.previousSnapshotID) &&
- Objects.equals(nextSnapshotID, that.nextSnapshotID);
+ return Objects.equals(snapshotId, that.snapshotId) &&
+ Objects.equals(previousSnapshotId, that.previousSnapshotId) &&
+ Objects.equals(nextSnapshotId, that.nextSnapshotId);
}
@Override
public int hashCode() {
- return Objects.hash(snapshotID, previousSnapshotID, nextSnapshotID);
+ return Objects.hash(snapshotId, previousSnapshotId, nextSnapshotId);
}
}
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainManager.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainManager.java
index dad450328f..0e343631f6 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainManager.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SnapshotChainManager.java
@@ -20,16 +20,18 @@ import com.google.common.annotations.VisibleForTesting;
import org.apache.hadoop.hdds.utils.db.Table;
import org.apache.hadoop.hdds.utils.db.TableIterator;
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import java.io.IOException;
-import java.util.HashMap;
+import java.util.Collections;
+import java.util.LinkedHashMap;
import java.util.Map;
import java.util.NoSuchElementException;
-import java.util.LinkedHashMap;
import java.util.TreeMap;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
/**
* This class is used for creating and accessing Snapshot Chains.
@@ -47,222 +49,198 @@ public class SnapshotChainManager {
private static final Logger LOG =
LoggerFactory.getLogger(SnapshotChainManager.class);
- private final LinkedHashMap<String, SnapshotChainInfo> snapshotChainGlobal;
- private final Map<String, LinkedHashMap<String, SnapshotChainInfo>>
- snapshotChainPath;
- private String latestGlobalSnapshotID;
- private final Map<String, String> latestPathSnapshotID;
- private final Map<String, String> snapshotIdToTableKey;
+ private final Map<UUID, SnapshotChainInfo> globalSnapshotChain;
+ private final ConcurrentMap<String, LinkedHashMap<UUID, SnapshotChainInfo>>
+ snapshotChainByPath;
+ private final ConcurrentMap<String, UUID> latestSnapshotIdByPath;
+ private final ConcurrentMap<UUID, String> snapshotIdToTableKey;
+ private UUID latestGlobalSnapshotId;
public SnapshotChainManager(OMMetadataManager metadataManager)
throws IOException {
- snapshotChainGlobal = new LinkedHashMap<>();
- snapshotChainPath = new HashMap<>();
- latestPathSnapshotID = new HashMap<>();
- snapshotIdToTableKey = new HashMap<>();
- latestGlobalSnapshotID = null;
+ globalSnapshotChain = Collections.synchronizedMap(new LinkedHashMap<>());
+ snapshotChainByPath = new ConcurrentHashMap<>();
+ latestSnapshotIdByPath = new ConcurrentHashMap<>();
+ snapshotIdToTableKey = new ConcurrentHashMap<>();
+ latestGlobalSnapshotId = null;
loadFromSnapshotInfoTable(metadataManager);
}
/**
* Add snapshot to global snapshot chain.
*/
- private void addSnapshotGlobal(String snapshotID,
- String prevGlobalID) throws IOException {
- // set previous snapshotID to null if it is "" for
- // internal in-mem structure
- if (prevGlobalID != null && prevGlobalID.isEmpty()) {
- prevGlobalID = null;
- }
- // on add snapshot; set previous snapshot entry nextSnapshotID =
- // snapshotID
- if (prevGlobalID != null &&
- snapshotChainGlobal.containsKey(prevGlobalID)) {
- snapshotChainGlobal
- .get(prevGlobalID)
- .setNextSnapshotID(snapshotID);
+ private void addSnapshotGlobal(UUID snapshotID,
+ UUID prevGlobalID) throws IOException {
+ // On add snapshot, set previous snapshot entry nextSnapshotID = snapshotID
+ if (prevGlobalID != null && globalSnapshotChain.containsKey(prevGlobalID))
{
+ globalSnapshotChain.get(prevGlobalID).setNextSnapshotId(snapshotID);
}
+
if (prevGlobalID != null &&
- !snapshotChainGlobal.containsKey(prevGlobalID)) {
+ !globalSnapshotChain.containsKey(prevGlobalID)) {
throw new IOException(String.format("Snapshot chain corruption. " +
- "Previous snapshotId: %s is set for snapshotId: %s but no " +
- "associated snapshot found in snapshot chain.", prevGlobalID,
+ "Previous snapshotId: %s is set for snapshotId: %s but no " +
+ "associated snapshot found in snapshot chain.", prevGlobalID,
snapshotID));
}
- snapshotChainGlobal.put(snapshotID,
+ globalSnapshotChain.put(snapshotID,
new SnapshotChainInfo(snapshotID, prevGlobalID, null));
// set state variable latestGlobal snapshot entry to this snapshotID
- latestGlobalSnapshotID = snapshotID;
+ latestGlobalSnapshotId = snapshotID;
}
/**
* Add snapshot to bucket snapshot chain(path based).
*/
private void addSnapshotPath(String snapshotPath,
- String snapshotID,
- String prevPathID) throws IOException {
- // set previous snapshotID to null if it is "" for
- // internal in-mem structure
- if (prevPathID != null && prevPathID.isEmpty()) {
- prevPathID = null;
- }
-
- // on add snapshot; set previous snapshot entry nextSnapshotID =
- // snapshotID
+ UUID snapshotID,
+ UUID prevPathID) throws IOException {
+ // On add snapshot, set previous snapshot entry nextSnapshotId = snapshotId
if (prevPathID != null &&
- ((!snapshotChainPath
- .containsKey(snapshotPath)) ||
- (!snapshotChainPath
- .get(snapshotPath)
- .containsKey(prevPathID)))) {
+ ((!snapshotChainByPath.containsKey(snapshotPath)) ||
+ (!snapshotChainByPath.get(snapshotPath).containsKey(prevPathID))))
{
throw new IOException(String.format("Snapshot chain corruption. " +
"Previous snapshotId: %s is set for snapshotId: %s but no " +
"associated snapshot found in snapshot chain.", prevPathID,
snapshotID));
}
- if (prevPathID != null &&
- snapshotChainPath.containsKey(snapshotPath)) {
- snapshotChainPath
+ if (prevPathID != null && snapshotChainByPath.containsKey(snapshotPath)) {
+ snapshotChainByPath
.get(snapshotPath)
.get(prevPathID)
- .setNextSnapshotID(snapshotID);
+ .setNextSnapshotId(snapshotID);
}
- if (!snapshotChainPath.containsKey(snapshotPath)) {
- snapshotChainPath.put(snapshotPath, new LinkedHashMap<>());
+ if (!snapshotChainByPath.containsKey(snapshotPath)) {
+ snapshotChainByPath.put(snapshotPath, new LinkedHashMap<>());
}
- snapshotChainPath
- .get(snapshotPath)
- .put(snapshotID,
- new SnapshotChainInfo(snapshotID, prevPathID, null));
+ snapshotChainByPath.get(snapshotPath)
+ .put(snapshotID, new SnapshotChainInfo(snapshotID, prevPathID, null));
// set state variable latestPath snapshot entry to this snapshotID
- latestPathSnapshotID.put(snapshotPath, snapshotID);
+ latestSnapshotIdByPath.put(snapshotPath, snapshotID);
}
- private boolean deleteSnapshotGlobal(String snapshotID) throws IOException {
- boolean status = true;
- if (snapshotChainGlobal.containsKey(snapshotID)) {
+ private boolean deleteSnapshotGlobal(UUID snapshotID) throws IOException {
+ if (globalSnapshotChain.containsKey(snapshotID)) {
// reset prev and next snapshot entries in chain ordered list
// for node removal
- String next = snapshotChainGlobal.get(snapshotID).getNextSnapshotID();
- String prev =
snapshotChainGlobal.get(snapshotID).getPreviousSnapshotID();
+ UUID next = globalSnapshotChain.get(snapshotID).getNextSnapshotId();
+ UUID prev = globalSnapshotChain.get(snapshotID).getPreviousSnapshotId();
- if (prev != null && !snapshotChainGlobal.containsKey(prev)) {
+ if (prev != null && !globalSnapshotChain.containsKey(prev)) {
throw new IOException(String.format("Snapshot chain corruption. " +
"SnapshotId: %s to be deleted has previous snapshotId: %s " +
"but associated snapshot is not found in snapshot chain.",
snapshotID, prev));
}
- if (next != null && !snapshotChainGlobal.containsKey(next)) {
+ if (next != null && !globalSnapshotChain.containsKey(next)) {
throw new IOException(String.format("Snapshot chain corruption. " +
"SnapshotId: {%s} to be deleted has next snapshotId: %s " +
"but associated snapshot is not found in snapshot chain.",
snapshotID, next));
}
- snapshotChainGlobal.remove(snapshotID);
+ globalSnapshotChain.remove(snapshotID);
if (next != null) {
- snapshotChainGlobal.get(next).setPreviousSnapshotID(prev);
+ globalSnapshotChain.get(next).setPreviousSnapshotId(prev);
}
if (prev != null) {
- snapshotChainGlobal.get(prev).setNextSnapshotID(next);
+ globalSnapshotChain.get(prev).setNextSnapshotId(next);
}
// remove from latest list if necessary
- if (latestGlobalSnapshotID.equals(snapshotID)) {
- latestGlobalSnapshotID = prev;
+ if (latestGlobalSnapshotId.equals(snapshotID)) {
+ latestGlobalSnapshotId = prev;
}
+ return true;
} else {
// snapshotID not found in snapshot chain, log warning and return
LOG.warn("Snapshot chain corruption. SnapshotID: {} is not found in " +
"snapshot chain.", snapshotID);
- status = false;
+ return false;
}
-
- return status;
}
private boolean deleteSnapshotPath(String snapshotPath,
- String snapshotID) throws IOException {
- if (snapshotChainPath.containsKey(snapshotPath) &&
- snapshotChainPath.get(snapshotPath).containsKey(snapshotID)) {
+ UUID snapshotId) throws IOException {
+ if (snapshotChainByPath.containsKey(snapshotPath) &&
+ snapshotChainByPath.get(snapshotPath).containsKey(snapshotId)) {
// reset prev and next snapshot entries in chain ordered list
// for node removal
- String nextSnapshotID = snapshotChainPath
+ UUID nextSnapshotId = snapshotChainByPath
.get(snapshotPath)
- .get(snapshotID)
- .getNextSnapshotID();
- String previousSnapshotID = snapshotChainPath
+ .get(snapshotId)
+ .getNextSnapshotId();
+ UUID previousSnapshotId = snapshotChainByPath
.get(snapshotPath)
- .get(snapshotID)
- .getPreviousSnapshotID();
+ .get(snapshotId)
+ .getPreviousSnapshotId();
- if (previousSnapshotID != null &&
- !snapshotChainPath.get(snapshotPath)
- .containsKey(previousSnapshotID)) {
+ if (previousSnapshotId != null &&
+ !snapshotChainByPath.get(snapshotPath)
+ .containsKey(previousSnapshotId)) {
throw new IOException(String.format("Snapshot chain corruption. " +
"SnapshotId: %s at snapshotPath: %s to be deleted has " +
"previous snapshotId: %s but associated snapshot is not " +
- "found in snapshot chain.", snapshotID, snapshotPath,
- previousSnapshotID));
+ "found in snapshot chain.", snapshotId, snapshotPath,
+ previousSnapshotId));
}
- if (nextSnapshotID != null && !snapshotChainPath.get(snapshotPath)
- .containsKey(nextSnapshotID)) {
+ if (nextSnapshotId != null && !snapshotChainByPath.get(snapshotPath)
+ .containsKey(nextSnapshotId)) {
throw new IOException(String.format("Snapshot chain corruption. " +
"SnapshotId: %s at snapshotPath: %s to be deleted has next " +
"snapshotId: %s but associated snapshot is not found in " +
- "snapshot chain.", snapshotID, snapshotPath,
- nextSnapshotID));
+ "snapshot chain.", snapshotId, snapshotPath,
+ nextSnapshotId));
}
- snapshotChainPath.get(snapshotPath).remove(snapshotID);
- if (nextSnapshotID != null) {
- snapshotChainPath.get(snapshotPath)
- .get(nextSnapshotID)
- .setPreviousSnapshotID(previousSnapshotID);
+ snapshotChainByPath.get(snapshotPath).remove(snapshotId);
+ if (nextSnapshotId != null) {
+ snapshotChainByPath.get(snapshotPath)
+ .get(nextSnapshotId)
+ .setPreviousSnapshotId(previousSnapshotId);
}
- if (previousSnapshotID != null) {
- snapshotChainPath.get(snapshotPath)
- .get(previousSnapshotID)
- .setNextSnapshotID(nextSnapshotID);
+ if (previousSnapshotId != null) {
+ snapshotChainByPath.get(snapshotPath)
+ .get(previousSnapshotId)
+ .setNextSnapshotId(nextSnapshotId);
}
// remove path if no entries
- if (snapshotChainPath.get(snapshotPath).isEmpty()) {
- snapshotChainPath.remove(snapshotPath);
+ if (snapshotChainByPath.get(snapshotPath).isEmpty()) {
+ snapshotChainByPath.remove(snapshotPath);
}
// remove from latest list if necessary
- if (latestPathSnapshotID.get(snapshotPath).equals(snapshotID)) {
- latestPathSnapshotID.remove(snapshotPath);
- if (previousSnapshotID != null) {
- latestPathSnapshotID.put(snapshotPath, previousSnapshotID);
+ if (latestSnapshotIdByPath.get(snapshotPath).equals(snapshotId)) {
+ latestSnapshotIdByPath.remove(snapshotPath);
+ if (previousSnapshotId != null) {
+ latestSnapshotIdByPath.put(snapshotPath, previousSnapshotId);
}
}
return true;
} else {
- // snapshotID not found in snapshot chain, log warning and return
+ // snapshotId not found in snapshot chain, log warning and return
LOG.warn("Snapshot chain corruption. SnapshotId: {} is not in chain " +
- "found for snapshot path {}.", snapshotID, snapshotPath);
+ "found for snapshot path {}.", snapshotId, snapshotPath);
return false;
}
}
/**
* Loads the snapshot chain from SnapshotInfo table.
- * @param metadataManager OMMetadataManager
*/
private void loadFromSnapshotInfoTable(OMMetadataManager metadataManager)
throws IOException {
// read from snapshotInfo table to populate
// snapshot chains - both global and local path
try (TableIterator<String, ? extends Table.KeyValue<String, SnapshotInfo>>
- keyIter = metadataManager.getSnapshotInfoTable().iterator()) {
+ keyIter = metadataManager.getSnapshotInfoTable().iterator()) {
Map<Long, SnapshotInfo> snaps = new TreeMap<>();
Table.KeyValue<String, SnapshotInfo> kv;
- snapshotChainGlobal.clear();
- snapshotChainPath.clear();
- latestPathSnapshotID.clear();
+ globalSnapshotChain.clear();
+ snapshotChainByPath.clear();
+ latestSnapshotIdByPath.clear();
snapshotIdToTableKey.clear();
while (keyIter.hasNext()) {
@@ -277,235 +255,182 @@ public class SnapshotChainManager {
/**
* Add snapshot to snapshot chain.
- * @param snapshotInfo SnapshotInfo of snapshot to add to chain.
*/
public void addSnapshot(SnapshotInfo snapshotInfo) throws IOException {
- addSnapshotGlobal(snapshotInfo.getSnapshotID(),
- snapshotInfo.getGlobalPreviousSnapshotID());
+ addSnapshotGlobal(snapshotInfo.getSnapshotId(),
+ snapshotInfo.getGlobalPreviousSnapshotId());
addSnapshotPath(snapshotInfo.getSnapshotPath(),
- snapshotInfo.getSnapshotID(),
snapshotInfo.getPathPreviousSnapshotID());
+ snapshotInfo.getSnapshotId(),
snapshotInfo.getPathPreviousSnapshotId());
// store snapshot ID to snapshot DB table key in the map
- snapshotIdToTableKey.put(snapshotInfo.getSnapshotID(),
+ snapshotIdToTableKey.put(snapshotInfo.getSnapshotId(),
snapshotInfo.getTableKey());
}
/**
* Delete snapshot from snapshot chain.
- * @param snapshotInfo SnapshotInfo of snapshot to remove from chain.
- * @return boolean
*/
public boolean deleteSnapshot(SnapshotInfo snapshotInfo) throws IOException {
- boolean status = deleteSnapshotGlobal(snapshotInfo.getSnapshotID()) &&
+ boolean status = deleteSnapshotGlobal(snapshotInfo.getSnapshotId()) &&
deleteSnapshotPath(snapshotInfo.getSnapshotPath(),
- snapshotInfo.getSnapshotID());
+ snapshotInfo.getSnapshotId());
if (status) {
- snapshotIdToTableKey.remove(snapshotInfo.getSnapshotID());
+ snapshotIdToTableKey.remove(snapshotInfo.getSnapshotId());
}
return status;
}
/**
* Get latest global snapshot in snapshot chain.
- * @return String, snapshot UUID of latest snapshot in global chain;
- * null if empty chain.
*/
- public String getLatestGlobalSnapshot() {
- return latestGlobalSnapshotID;
+ public UUID getLatestGlobalSnapshotId() {
+ return latestGlobalSnapshotId;
}
/**
* Get latest path snapshot in snapshot chain.
- * @param snapshotPath String, snapshot directory path.
- * @return String, snapshot UUID of latest snapshot in path chain;
- * null if empty chain.
*/
- public String getLatestPathSnapshot(String snapshotPath) {
- return latestPathSnapshotID.get(snapshotPath);
+ public UUID getLatestPathSnapshotId(String snapshotPath) {
+ return latestSnapshotIdByPath.get(snapshotPath);
}
/**
- * Returns true if snapshot from given snapshotID has a
- * next snapshot entry in the global snapshot chain.
- * @param snapshotID String, snapshot UUID
- * @return boolean
+ * Returns true if snapshot from given snapshotId has a next snapshot entry
+ * in the global snapshot chain.
*/
- public boolean hasNextGlobalSnapshot(String snapshotID) {
- if (!snapshotChainGlobal.containsKey(snapshotID)) {
- LOG.error("No snapshot for provided snapshotId: {}", snapshotID);
+ public boolean hasNextGlobalSnapshot(UUID snapshotId) {
+ if (!globalSnapshotChain.containsKey(snapshotId)) {
+ LOG.error("No snapshot for provided snapshotId: {}", snapshotId);
throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain.", snapshotID));
+ "found in snapshot chain.", snapshotId));
}
- return snapshotChainGlobal.get(snapshotID).getNextSnapshotID() != null;
+ return globalSnapshotChain.get(snapshotId).getNextSnapshotId() != null;
}
/**
* Get next global snapshot in snapshot chain from given snapshot.
- * @param snapshotID String, snapshot UUID
- * @return String, snapshot UUID of next snapshot in chain from
- * snapshotID
*/
- public String nextGlobalSnapshot(String snapshotID) {
- if (!hasNextGlobalSnapshot(snapshotID)) {
- LOG.error("No following snapshot found in snapshot chain for provided " +
- "snapshotId: {}.", snapshotID);
+ public UUID nextGlobalSnapshot(UUID snapshotId) {
+ if (!hasNextGlobalSnapshot(snapshotId)) {
+ LOG.error("No snapshot for provided snapshotId: {}", snapshotId);
throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain.", snapshotID));
+ "found in snapshot chain.", snapshotId));
}
- return snapshotChainGlobal.get(snapshotID).getNextSnapshotID();
+ return globalSnapshotChain.get(snapshotId).getNextSnapshotId();
}
/**
- * Returns true if snapshot from given snapshotID has a
- * previous snapshot entry in the global snapshot chain.
- * @param snapshotID String, snapshot UUID
- * @return boolean
+ * Returns true if snapshot from given snapshotId has a previous snapshot
+ * entry in the global snapshot chain.
*/
- public boolean hasPreviousGlobalSnapshot(String snapshotID) {
- if (!snapshotChainGlobal.containsKey(snapshotID)) {
+ public boolean hasPreviousGlobalSnapshot(UUID snapshotId) {
+ if (!globalSnapshotChain.containsKey(snapshotId)) {
LOG.error("No snapshot found in snapshot chain for provided " +
- "snapshotId: {}.", snapshotID);
+ "snapshotId: {}.", snapshotId);
throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain.", snapshotID));
+ "found in snapshot chain.", snapshotId));
}
- return snapshotChainGlobal.get(snapshotID).getPreviousSnapshotID() != null;
+ return globalSnapshotChain.get(snapshotId).getPreviousSnapshotId() != null;
}
/**
* Get previous global snapshot in snapshot chain from given snapshot.
- * @param snapshotID String, snapshot UUID
- * @return String, snapshot UUID of previous snapshot in chain from
- * snapshotID
*/
- public String previousGlobalSnapshot(String snapshotID) {
- if (!hasPreviousGlobalSnapshot(snapshotID)) {
+ public UUID previousGlobalSnapshot(UUID snapshotId) {
+ if (!hasPreviousGlobalSnapshot(snapshotId)) {
LOG.error("No preceding snapshot found in snapshot chain for provided " +
- "snapshotId: {}.", snapshotID);
+ "snapshotId: {}.", snapshotId);
throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain.", snapshotID));
+ "found in snapshot chain.", snapshotId));
}
- return snapshotChainGlobal.get(snapshotID).getPreviousSnapshotID();
+ return globalSnapshotChain.get(snapshotId).getPreviousSnapshotId();
}
/**
- * Returns true if snapshot path from given snapshotID has a
- * next snapshot entry in the path snapshot chain.
- * @param snapshotPath String, snapshot directory path.
- * @param snapshotID String, snapshot UUID
- * @return boolean
+ * Returns true if snapshot path from given snapshotId has a next snapshot
+ * entry in the path snapshot chain.
*/
- public boolean hasNextPathSnapshot(String snapshotPath, String snapshotID) {
- if (!snapshotChainPath.containsKey(snapshotPath) ||
- !snapshotChainPath.get(snapshotPath).containsKey(snapshotID)) {
+ public boolean hasNextPathSnapshot(String snapshotPath, UUID snapshotId) {
+ if (!snapshotChainByPath.containsKey(snapshotPath) ||
+ !snapshotChainByPath.get(snapshotPath).containsKey(snapshotId)) {
LOG.error("No snapshot found for provided snapshotId: {} and " +
- "snapshotPath: {}", snapshotID, snapshotPath);
+ "snapshotPath: {}", snapshotId, snapshotPath);
throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain for snapshotPath: %s.", snapshotID,
+ "found in snapshot chain for snapshotPath: %s.", snapshotId,
snapshotPath));
}
- return snapshotChainPath
+ return snapshotChainByPath
.get(snapshotPath)
- .get(snapshotID)
- .getNextSnapshotID() != null;
+ .get(snapshotId)
+ .getNextSnapshotId() != null;
}
/**
- * Returns true if snapshot path from given snapshotID has a
- * previous snapshot entry in the path snapshot chain.
- * @param snapshotPath String, snapshot directory path.
- * @param snapshotID String, snapshot UUID
- * @return boolean
+ * Get next path snapshot in snapshot chain from given snapshot.
*/
- public boolean hasPreviousPathSnapshot(String snapshotPath,
- String snapshotID) {
- if (!snapshotChainPath.containsKey(snapshotPath) ||
- !snapshotChainPath.get(snapshotPath).containsKey(snapshotID)) {
- LOG.error("No snapshot found for provided snapshotId: {} and " +
- "snapshotPath: {}", snapshotID, snapshotPath);
- throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain for snapshotPath: %s.", snapshotID,
- snapshotPath));
+ public UUID nextPathSnapshot(String snapshotPath, UUID snapshotId) {
+ if (!hasNextPathSnapshot(snapshotPath, snapshotId)) {
+ LOG.error("No following snapshot for provided snapshotId {} and " +
+ "snapshotPath {}.", snapshotId, snapshotPath);
+ throw new NoSuchElementException(String.format("No following snapshot " +
+ "found in snapshot chain for snapshotId: %s and snapshotPath: " +
+ "%s.", snapshotId, snapshotPath));
}
- return snapshotChainPath.get(snapshotPath)
- .get(snapshotID)
- .getPreviousSnapshotID() != null;
+ return snapshotChainByPath.get(snapshotPath)
+ .get(snapshotId)
+ .getNextSnapshotId();
}
/**
- * Get next path snapshot in snapshot chain from given snapshot.
- * @param snapshotPath String, snapshot directory path.
- * @param snapshotID String, snapshot UUID
- * @return String, snapshot UUID of next snapshot in chain from
- * snapshotID
+ * Returns true if snapshot path from given snapshotId has a
+ * previous snapshot entry in the path snapshot chain.
*/
- public String nextPathSnapshot(String snapshotPath, String snapshotID) {
- if (!snapshotChainPath.containsKey(snapshotPath) ||
- !snapshotChainPath.get(snapshotPath).containsKey(snapshotID)) {
+ public boolean hasPreviousPathSnapshot(String snapshotPath,
+ UUID snapshotId) {
+ if (!snapshotChainByPath.containsKey(snapshotPath) ||
+ !snapshotChainByPath.get(snapshotPath).containsKey(snapshotId)) {
LOG.error("No snapshot found for provided snapshotId: {} and " +
- "snapshotPath: {}", snapshotID, snapshotPath);
+ "snapshotPath: {}", snapshotId, snapshotPath);
throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain for snapshotPath: %s.", snapshotID,
+ "found in snapshot chain for snapshotPath: %s.", snapshotId,
snapshotPath));
}
- if (snapshotChainPath.get(snapshotPath).get(snapshotID)
- .getNextSnapshotID() == null) {
- LOG.error("No following snapshot for provided snapshotId {} and " +
- "snapshotPath {}.", snapshotID, snapshotPath);
- throw new NoSuchElementException(String.format("No following snapshot " +
- "found in snapshot chain for snapshotId: %s and snapshotPath: " +
- "%s.", snapshotID, snapshotPath));
- }
- return snapshotChainPath.get(snapshotPath)
- .get(snapshotID)
- .getNextSnapshotID();
+ return snapshotChainByPath.get(snapshotPath)
+ .get(snapshotId)
+ .getPreviousSnapshotId() != null;
}
/**
* Get previous path snapshot in snapshot chain from given snapshot.
- * @param snapshotPath String, snapshot directory path.
- * @param snapshotID String, snapshot UUID
- * @return String, snapshot UUID of previous snapshot in chain from
- * snapshotID
*/
- public String previousPathSnapshot(String snapshotPath, String snapshotID) {
- if (!snapshotChainPath.containsKey(snapshotPath) ||
- !snapshotChainPath.get(snapshotPath).containsKey(snapshotID)) {
- LOG.error("No snapshot found for provided snapshotId: {} and " +
- "snapshotPath: {}", snapshotID, snapshotPath);
- throw new NoSuchElementException(String.format("SnapshotId: %s is not " +
- "found in snapshot chain for snapshotPath: %s.", snapshotID,
- snapshotPath));
- }
- if (snapshotChainPath
- .get(snapshotPath)
- .get(snapshotID)
- .getPreviousSnapshotID() == null) {
+ public UUID previousPathSnapshot(String snapshotPath,
+ UUID snapshotId) {
+ if (!hasPreviousPathSnapshot(snapshotPath, snapshotId)) {
LOG.error("No preceding snapshot for provided snapshotId: {} and " +
- "snapshotPath: {}", snapshotID, snapshotPath);
+ "snapshotPath: {}", snapshotId, snapshotPath);
throw new NoSuchElementException(String.format("No preceding snapshot " +
- "found in snapshot chain for snapshotId: %s and snapshotPath: " +
- "%s.", snapshotID, snapshotPath));
+ "found in snapshot chain for snapshotId: %s and snapshotPath: " +
+ "%s.", snapshotId, snapshotPath));
}
- return snapshotChainPath
+ return snapshotChainByPath
.get(snapshotPath)
- .get(snapshotID)
- .getPreviousSnapshotID();
+ .get(snapshotId)
+ .getPreviousSnapshotId();
}
- public String getTableKey(String snapshotId) {
+ public String getTableKey(UUID snapshotId) {
return snapshotIdToTableKey.get(snapshotId);
}
@VisibleForTesting
- public void loadSnapshotInfo(OMMetadataManager metadataManager)
- throws IOException {
+ void loadSnapshotInfo(OMMetadataManager metadataManager) throws IOException {
loadFromSnapshotInfoTable(metadataManager);
}
@VisibleForTesting
- public LinkedHashMap<String, SnapshotChainInfo> getSnapshotChainPath(
+ public LinkedHashMap<UUID, SnapshotChainInfo> getSnapshotChainPath(
String path) {
- return snapshotChainPath.get(path);
+ return snapshotChainByPath.get(path);
}
}
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SstFilteringService.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SstFilteringService.java
index 32b317f0b7..e1190fce00 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SstFilteringService.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/SstFilteringService.java
@@ -47,6 +47,7 @@ import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
+import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
@@ -126,6 +127,7 @@ public class SstFilteringService extends BackgroundService
Table.KeyValue<String, SnapshotInfo> keyValue = iterator.next();
String snapShotTableKey = keyValue.getKey();
SnapshotInfo snapshotInfo = keyValue.getValue();
+ UUID snapshotId = snapshotInfo.getSnapshotId();
File omMetadataDir =
OMStorage.getOmDbDir(ozoneManager.getConfiguration());
@@ -137,7 +139,8 @@ public class SstFilteringService extends BackgroundService
// it has already undergone filtering.
if (Files.exists(filePath)) {
List<String> processedSnapshotIds = Files.readAllLines(filePath);
- if (processedSnapshotIds.contains(snapshotInfo.getSnapshotID())) {
+ if (snapshotId != null &&
+ processedSnapshotIds.contains(snapshotId.toString())) {
continue;
}
}
@@ -164,7 +167,7 @@ public class SstFilteringService extends BackgroundService
}
// mark the snapshot as filtered by writing to the file
- String content = snapshotInfo.getSnapshotID() + "\n";
+ String content = snapshotInfo.getSnapshotId() + "\n";
Files.write(filePath, content.getBytes(StandardCharsets.UTF_8),
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
snapshotLimit--;
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotCreateRequest.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotCreateRequest.java
index 1bb1ce2d04..5903edb520 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotCreateRequest.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotCreateRequest.java
@@ -18,7 +18,6 @@
package org.apache.hadoop.ozone.om.request.snapshot;
-import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.hdds.utils.db.RDBStore;
import org.apache.hadoop.hdds.utils.db.cache.CacheKey;
import org.apache.hadoop.hdds.utils.db.cache.CacheValue;
@@ -54,6 +53,8 @@ import java.io.IOException;
import java.util.Objects;
import java.util.UUID;
+import static org.apache.hadoop.hdds.HddsUtils.fromProtobuf;
+import static org.apache.hadoop.hdds.HddsUtils.toProtobuf;
import static
org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.FILE_ALREADY_EXISTS;
import static
org.apache.hadoop.ozone.om.lock.OzoneManagerLock.Resource.BUCKET_LOCK;
import static
org.apache.hadoop.ozone.om.lock.OzoneManagerLock.Resource.SNAPSHOT_LOCK;
@@ -70,7 +71,6 @@ public class OMSnapshotCreateRequest extends OMClientRequest {
private final String volumeName;
private final String bucketName;
private final String snapshotName;
- private final String snapshotId;
private final SnapshotInfo snapshotInfo;
public OMSnapshotCreateRequest(OMRequest omRequest) {
@@ -79,7 +79,8 @@ public class OMSnapshotCreateRequest extends OMClientRequest {
.getCreateSnapshotRequest();
volumeName = createSnapshotRequest.getVolumeName();
bucketName = createSnapshotRequest.getBucketName();
- snapshotId = createSnapshotRequest.getSnapshotId();
+ UUID snapshotId = createSnapshotRequest.hasSnapshotId() ?
+ fromProtobuf(createSnapshotRequest.getSnapshotId()) : null;
String possibleName = createSnapshotRequest.getSnapshotName();
snapshotInfo = SnapshotInfo.newInstance(volumeName,
@@ -111,7 +112,7 @@ public class OMSnapshotCreateRequest extends
OMClientRequest {
return omRequest.toBuilder().setCreateSnapshotRequest(
omRequest.getCreateSnapshotRequest().toBuilder()
- .setSnapshotId(UUID.randomUUID().toString())
+ .setSnapshotId(toProtobuf(UUID.randomUUID()))
.setCreationTime(Time.now())
.build()).build();
}
@@ -163,22 +164,13 @@ public class OMSnapshotCreateRequest extends
OMClientRequest {
snapshotInfo.setDbTxSequenceNumber(dbLatestSequenceNumber);
// Set previous path and global snapshot
- String latestPathSnapshot =
- snapshotChainManager.getLatestPathSnapshot(snapshotPath);
- String latestGlobalSnapshot =
- snapshotChainManager.getLatestGlobalSnapshot();
+ UUID latestPathSnapshot =
+ snapshotChainManager.getLatestPathSnapshotId(snapshotPath);
+ UUID latestGlobalSnapshot =
+ snapshotChainManager.getLatestGlobalSnapshotId();
- if (StringUtils.isEmpty(latestPathSnapshot)) {
- snapshotInfo.setPathPreviousSnapshotID(null);
- } else {
- snapshotInfo.setPathPreviousSnapshotID(latestPathSnapshot);
- }
-
- if (StringUtils.isEmpty(latestGlobalSnapshot)) {
- snapshotInfo.setGlobalPreviousSnapshotID(null);
- } else {
- snapshotInfo.setGlobalPreviousSnapshotID(latestGlobalSnapshot);
- }
+ snapshotInfo.setPathPreviousSnapshotId(latestPathSnapshot);
+ snapshotInfo.setGlobalPreviousSnapshotId(latestGlobalSnapshot);
snapshotChainManager.addSnapshot(snapshotInfo);
@@ -202,8 +194,8 @@ public class OMSnapshotCreateRequest extends
OMClientRequest {
// SnapshotChainManager#loadFromSnapshotInfoTable because it could not
// find the previous snapshot which doesn't exist because it was never
// added to the SnapshotInfo table.
- if (Objects.equals(snapshotInfo.getSnapshotID(),
- snapshotChainManager.getLatestGlobalSnapshot())) {
+ if (Objects.equals(snapshotInfo.getSnapshotId(),
+ snapshotChainManager.getLatestGlobalSnapshotId())) {
removeSnapshotInfoFromSnapshotChainManager(snapshotChainManager,
snapshotInfo);
}
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotMoveDeletedKeysRequest.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotMoveDeletedKeysRequest.java
index dc6a24370d..8d7b533f11 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotMoveDeletedKeysRequest.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/snapshot/OMSnapshotMoveDeletedKeysRequest.java
@@ -41,6 +41,7 @@ import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.List;
+import java.util.UUID;
import static org.apache.hadoop.ozone.om.OmSnapshotManager.getSnapshotPrefix;
import static
org.apache.hadoop.ozone.om.upgrade.OMLayoutFeature.FILESYSTEM_SNAPSHOT;
@@ -125,15 +126,16 @@ public class OMSnapshotMoveDeletedKeysRequest extends
OMClientRequest {
/**
* Get the next non deleted snapshot in the snapshot chain.
*/
- private SnapshotInfo getNextActiveSnapshot(SnapshotInfo snapInfo,
- SnapshotChainManager chainManager, OmSnapshotManager omSnapshotManager)
- throws IOException {
+ private SnapshotInfo getNextActiveSnapshot(
+ SnapshotInfo snapInfo,
+ SnapshotChainManager chainManager,
+ OmSnapshotManager omSnapshotManager
+ ) throws IOException {
while (chainManager.hasNextPathSnapshot(snapInfo.getSnapshotPath(),
- snapInfo.getSnapshotID())) {
+ snapInfo.getSnapshotId())) {
- String nextPathSnapshot =
- chainManager.nextPathSnapshot(
- snapInfo.getSnapshotPath(), snapInfo.getSnapshotID());
+ UUID nextPathSnapshot = chainManager.nextPathSnapshot(
+ snapInfo.getSnapshotPath(), snapInfo.getSnapshotId());
String tableKey = chainManager.getTableKey(nextPathSnapshot);
SnapshotInfo nextSnapshotInfo =
@@ -143,7 +145,6 @@ public class OMSnapshotMoveDeletedKeysRequest extends
OMClientRequest {
SnapshotInfo.SnapshotStatus.SNAPSHOT_ACTIVE)) {
return nextSnapshotInfo;
}
-
snapInfo = nextSnapshotInfo;
}
return null;
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/snapshot/OMSnapshotPurgeResponse.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/snapshot/OMSnapshotPurgeResponse.java
index 941813afcb..6aafdd9403 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/snapshot/OMSnapshotPurgeResponse.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/snapshot/OMSnapshotPurgeResponse.java
@@ -37,6 +37,7 @@ import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.NoSuchElementException;
+import java.util.UUID;
import static
org.apache.hadoop.ozone.om.OmMetadataManagerImpl.SNAPSHOT_INFO_TABLE;
@@ -47,7 +48,7 @@ import static
org.apache.hadoop.ozone.om.OmMetadataManagerImpl.SNAPSHOT_INFO_TAB
public class OMSnapshotPurgeResponse extends OMClientResponse {
private static final Logger LOG =
LoggerFactory.getLogger(OMSnapshotPurgeResponse.class);
- private List<String> snapshotDbKeys;
+ private final List<String> snapshotDbKeys;
public OMSnapshotPurgeResponse(@Nonnull OMResponse omResponse,
@Nonnull List<String> snapshotDbKeys) {
@@ -82,46 +83,44 @@ public class OMSnapshotPurgeResponse extends
OMClientResponse {
/**
* Cleans up the snapshot chain and updates next snapshot's
* previousPath and previousGlobal IDs.
- * @param metadataManager
- * @param snapInfo
- * @param batchOperation
*/
private void cleanupSnapshotChain(OmMetadataManagerImpl metadataManager,
- SnapshotInfo snapInfo, BatchOperation batchOperation) throws IOException
{
+ SnapshotInfo snapInfo,
+ BatchOperation batchOperation)
+ throws IOException {
SnapshotChainManager snapshotChainManager = metadataManager
.getSnapshotChainManager();
SnapshotInfo nextPathSnapInfo = null;
- SnapshotInfo nextGlobalSnapInfo = null;
+ SnapshotInfo nextGlobalSnapInfo;
// If the snapshot is deleted in the previous run, then the in-memory
// SnapshotChainManager might throw NoSuchElementException as the snapshot
// is removed in-memory but OMDoubleBuffer has not flushed yet.
- boolean hasNextPathSnapshot = false;
- boolean hasNextGlobalSnapshot = false;
+ boolean hasNextPathSnapshot;
+ boolean hasNextGlobalSnapshot;
try {
hasNextPathSnapshot = snapshotChainManager.hasNextPathSnapshot(
- snapInfo.getSnapshotPath(), snapInfo.getSnapshotID());
+ snapInfo.getSnapshotPath(), snapInfo.getSnapshotId());
hasNextGlobalSnapshot = snapshotChainManager.hasNextGlobalSnapshot(
- snapInfo.getSnapshotID());
+ snapInfo.getSnapshotId());
} catch (NoSuchElementException ex) {
LOG.warn("The Snapshot {} could have been deleted in the previous run.",
- snapInfo.getSnapshotID(), ex);
+ snapInfo.getSnapshotId(), ex);
return;
}
// Updates next path snapshot's previous snapshot ID
if (hasNextPathSnapshot) {
- String nextPathSnapshotId =
- snapshotChainManager.nextPathSnapshot(
- snapInfo.getSnapshotPath(), snapInfo.getSnapshotID());
+ UUID nextPathSnapshotId = snapshotChainManager.nextPathSnapshot(
+ snapInfo.getSnapshotPath(), snapInfo.getSnapshotId());
String snapshotTableKey = snapshotChainManager
.getTableKey(nextPathSnapshotId);
- nextPathSnapInfo = metadataManager
- .getSnapshotInfoTable().get(snapshotTableKey);
+ nextPathSnapInfo = metadataManager.getSnapshotInfoTable()
+ .get(snapshotTableKey);
if (nextPathSnapInfo != null) {
- nextPathSnapInfo.setPathPreviousSnapshotID(
- snapInfo.getPathPreviousSnapshotID());
+ nextPathSnapInfo.setPathPreviousSnapshotId(
+ snapInfo.getPathPreviousSnapshotId());
metadataManager.getSnapshotInfoTable().putWithBatch(batchOperation,
nextPathSnapInfo.getTableKey(), nextPathSnapInfo);
}
@@ -129,8 +128,8 @@ public class OMSnapshotPurgeResponse extends
OMClientResponse {
// Updates next global snapshot's previous snapshot ID
if (hasNextGlobalSnapshot) {
- String nextGlobalSnapshotId =
- snapshotChainManager.nextGlobalSnapshot(snapInfo.getSnapshotID());
+ UUID nextGlobalSnapshotId =
+ snapshotChainManager.nextGlobalSnapshot(snapInfo.getSnapshotId());
String snapshotTableKey = snapshotChainManager
.getTableKey(nextGlobalSnapshotId);
@@ -140,15 +139,15 @@ public class OMSnapshotPurgeResponse extends
OMClientResponse {
// nextPathSnapInfo.setPathPreviousSnapshotID(), adding this check
// will prevent it.
if (nextGlobalSnapInfo != null && nextPathSnapInfo != null &&
- nextGlobalSnapInfo.getSnapshotID().equals(
- nextPathSnapInfo.getSnapshotID())) {
- nextPathSnapInfo.setGlobalPreviousSnapshotID(
- snapInfo.getPathPreviousSnapshotID());
+ nextGlobalSnapInfo.getSnapshotId().equals(
+ nextPathSnapInfo.getSnapshotId())) {
+ nextPathSnapInfo.setGlobalPreviousSnapshotId(
+ snapInfo.getPathPreviousSnapshotId());
metadataManager.getSnapshotInfoTable().putWithBatch(batchOperation,
nextPathSnapInfo.getTableKey(), nextPathSnapInfo);
} else if (nextGlobalSnapInfo != null) {
- nextGlobalSnapInfo.setGlobalPreviousSnapshotID(
- snapInfo.getPathPreviousSnapshotID());
+ nextGlobalSnapInfo.setGlobalPreviousSnapshotId(
+ snapInfo.getPathPreviousSnapshotId());
metadataManager.getSnapshotInfoTable().putWithBatch(batchOperation,
nextGlobalSnapInfo.getTableKey(), nextGlobalSnapInfo);
}
@@ -160,11 +159,9 @@ public class OMSnapshotPurgeResponse extends
OMClientResponse {
/**
* Deletes the checkpoint directory for a snapshot.
- * @param omMetadataManager
- * @param snapshotInfo
*/
private void deleteCheckpointDirectory(OMMetadataManager omMetadataManager,
- SnapshotInfo snapshotInfo) {
+ SnapshotInfo snapshotInfo) {
RDBStore store = (RDBStore) omMetadataManager.getStore();
String checkpointPrefix = store.getDbLocation().getName();
Path snapshotDirPath = Paths.get(store.getSnapshotsParentDir(),
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/service/SnapshotDeletingService.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/service/SnapshotDeletingService.java
index fb81d083dc..58fa8e6074 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/service/SnapshotDeletingService.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/service/SnapshotDeletingService.java
@@ -61,6 +61,7 @@ import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
+import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
@@ -285,7 +286,7 @@ public class SnapshotDeletingService extends
AbstractKeyDeletingService {
} catch (IOException ex) {
LOG.error("Error while running Snapshot Deleting Service for " +
"snapshot " + snapInfo.getTableKey() + " with snapshotId " +
- snapInfo.getSnapshotID() + ". Processed " + deletionCount +
+ snapInfo.getSnapshotId() + ". Processed " + deletionCount +
" keys and " + (keyLimitPerSnapshot - remainNum) +
" directories and files", ex);
}
@@ -541,14 +542,14 @@ public class SnapshotDeletingService extends
AbstractKeyDeletingService {
throws IOException {
SnapshotInfo currSnapInfo = snapInfo;
while (chainManager.hasPreviousPathSnapshot(
- currSnapInfo.getSnapshotPath(), currSnapInfo.getSnapshotID())) {
+ currSnapInfo.getSnapshotPath(), currSnapInfo.getSnapshotId())) {
- String prevPathSnapshot = chainManager.previousPathSnapshot(
- currSnapInfo.getSnapshotPath(), currSnapInfo.getSnapshotID());
+ UUID prevPathSnapshot = chainManager.previousPathSnapshot(
+ currSnapInfo.getSnapshotPath(), currSnapInfo.getSnapshotId());
String tableKey = chainManager.getTableKey(prevPathSnapshot);
SnapshotInfo prevSnapInfo =
omSnapshotManager.getSnapshotInfo(tableKey);
- if (prevSnapInfo.getSnapshotStatus().equals(
- SnapshotInfo.SnapshotStatus.SNAPSHOT_ACTIVE)) {
+ if (prevSnapInfo.getSnapshotStatus() ==
+ SnapshotInfo.SnapshotStatus.SNAPSHOT_ACTIVE) {
return prevSnapInfo;
}
currSnapInfo = prevSnapInfo;
@@ -646,4 +647,3 @@ public class SnapshotDeletingService extends
AbstractKeyDeletingService {
successRunCount.getAndSet(num);
}
}
-
diff --git
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java
index 9861ac0ac4..d01d8fb60e 100644
---
a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java
+++
b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java
@@ -350,7 +350,7 @@ public class SnapshotDiffManager implements AutoCloseable {
final OMMetadataManager snapshotOMMM = omSnapshot.getMetadataManager();
final String checkpointPath =
snapshotOMMM.getStore().getDbLocation().getPath();
- final String snapshotId = snapshotInfo.getSnapshotID();
+ final UUID snapshotId = snapshotInfo.getSnapshotId();
final long dbTxSequenceNumber = snapshotInfo.getDbTxSequenceNumber();
return new DifferSnapshotInfo(
@@ -382,8 +382,8 @@ public class SnapshotDiffManager implements AutoCloseable {
SnapshotInfo tsInfo = getSnapshotInfo(ozoneManager,
volumeName, bucketName, toSnapshotName);
- String snapDiffJobKey = fsInfo.getSnapshotID() + DELIMITER +
- tsInfo.getSnapshotID();
+ String snapDiffJobKey = fsInfo.getSnapshotId() + DELIMITER +
+ tsInfo.getSnapshotId();
SnapshotDiffJob snapDiffJob = getSnapDiffReportStatus(snapDiffJobKey,
volumeName, bucketName, fromSnapshotName, toSnapshotName,
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestOmSnapshotManager.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestOmSnapshotManager.java
index ad8ce91c71..6e0b98657a 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestOmSnapshotManager.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestOmSnapshotManager.java
@@ -219,14 +219,12 @@ public class TestOmSnapshotManager {
}
}
- private SnapshotInfo createSnapshotInfo(
- String volumeName, String bucketName) {
- String snapshotName = UUID.randomUUID().toString();
- String snapshotId = UUID.randomUUID().toString();
+ private SnapshotInfo createSnapshotInfo(String volumeName,
+ String bucketName) {
return SnapshotInfo.newInstance(volumeName,
bucketName,
- snapshotName,
- snapshotId,
+ UUID.randomUUID().toString(),
+ UUID.randomUUID(),
Time.now());
}
}
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotChain.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotChain.java
index 7d790ec042..4a63eb6887 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotChain.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotChain.java
@@ -21,12 +21,11 @@ import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.hadoop.hdds.utils.db.Table;
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
import org.apache.hadoop.util.Time;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
@@ -35,6 +34,10 @@ import java.util.NoSuchElementException;
import java.util.UUID;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_DB_DIRS;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests SnapshotChain that stores in chronological order
@@ -45,158 +48,144 @@ import static
org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_DB_DIRS;
*/
public class TestSnapshotChain {
private OMMetadataManager omMetadataManager;
- private Map<String, SnapshotInfo> sinfos;
+ private Map<UUID, SnapshotInfo> snapshotIdToSnapshotInfoMap;
private SnapshotChainManager chainManager;
- @Rule
- public TemporaryFolder folder = new TemporaryFolder();
+ @TempDir
+ private File folder;
- @Before
+ @BeforeEach
public void setup() throws Exception {
OzoneConfiguration conf = new OzoneConfiguration();
- conf.set(OZONE_OM_DB_DIRS,
- folder.getRoot().getAbsolutePath());
+ conf.set(OZONE_OM_DB_DIRS, folder.toString());
omMetadataManager = new OmMetadataManagerImpl(conf);
- sinfos = new HashMap<>();
+ snapshotIdToSnapshotInfoMap = new HashMap<>();
chainManager = new SnapshotChainManager(omMetadataManager);
}
- private SnapshotInfo createSnapshotInfo(String volName,
- String bucketName,
- String snapshotName,
- String snapshotID,
- String pathPrevID,
- String globalPrevID) {
+ private SnapshotInfo createSnapshotInfo(UUID snapshotID,
+ UUID pathPrevID,
+ UUID globalPrevID) {
return new SnapshotInfo.Builder()
- .setSnapshotID(snapshotID)
- .setName(snapshotName)
- .setVolumeName(volName)
- .setBucketName(bucketName)
+ .setSnapshotId(snapshotID)
+ .setName("test")
+ .setVolumeName("vol1")
+ .setBucketName("bucket1")
.setSnapshotStatus(SnapshotInfo.SnapshotStatus.SNAPSHOT_ACTIVE)
.setCreationTime(Time.now())
.setDeletionTime(-1L)
- .setPathPreviousSnapshotID(pathPrevID)
- .setGlobalPreviousSnapshotID(globalPrevID)
- .setSnapshotPath(String.join("/", volName, bucketName))
+ .setPathPreviousSnapshotId(pathPrevID)
+ .setGlobalPreviousSnapshotId(globalPrevID)
+ .setSnapshotPath(String.join("/", "vol1", "bucket1"))
.setCheckpointDir("checkpoint.testdir")
.build();
}
- private void deleteSnapshot(String snapshotID) throws IOException {
+ private void deleteSnapshot(UUID snapshotID) throws IOException {
SnapshotInfo sinfo = null;
final String snapshotPath = "vol1/bucket1";
// reset the next snapshotInfo.globalPreviousSnapshotID
// to the previous in the entry to be deleted.
if (chainManager.hasNextGlobalSnapshot(snapshotID)) {
- sinfo = sinfos
- .get(chainManager.nextGlobalSnapshot(snapshotID));
+ sinfo = snapshotIdToSnapshotInfoMap.get(
+ chainManager.nextGlobalSnapshot(snapshotID));
if (chainManager.hasPreviousGlobalSnapshot(snapshotID)) {
- sinfo.setGlobalPreviousSnapshotID(chainManager
- .previousGlobalSnapshot(snapshotID));
+ sinfo.setGlobalPreviousSnapshotId(
+ chainManager.previousGlobalSnapshot(snapshotID));
} else {
- sinfo.setGlobalPreviousSnapshotID(null);
+ sinfo.setGlobalPreviousSnapshotId(null);
}
- sinfos.put(sinfo.getSnapshotID(), sinfo);
+ snapshotIdToSnapshotInfoMap.put(sinfo.getSnapshotId(), sinfo);
}
// reset the next snapshotInfo.pathPreviousSnapshotID
// to the previous in the entry to be deleted.
- if (chainManager.hasNextPathSnapshot(snapshotPath,
- snapshotID)) {
- sinfo = sinfos.get(chainManager
- .nextPathSnapshot(snapshotPath,
- snapshotID));
- if (chainManager.hasPreviousPathSnapshot(snapshotPath,
- snapshotID)) {
- sinfo.setPathPreviousSnapshotID(chainManager
- .previousPathSnapshot(snapshotPath,
- snapshotID));
+ if (chainManager.hasNextPathSnapshot(snapshotPath, snapshotID)) {
+ sinfo = snapshotIdToSnapshotInfoMap.get(
+ chainManager.nextPathSnapshot(snapshotPath, snapshotID));
+
+ if (chainManager.hasPreviousPathSnapshot(snapshotPath, snapshotID)) {
+ sinfo.setPathPreviousSnapshotId(
+ chainManager.previousPathSnapshot(snapshotPath, snapshotID));
} else {
- sinfo.setPathPreviousSnapshotID(null);
+ sinfo.setPathPreviousSnapshotId(null);
}
- sinfos.put(sinfo.getSnapshotID(), sinfo);
+ snapshotIdToSnapshotInfoMap.put(sinfo.getSnapshotId(), sinfo);
}
+
+ UUID latestGlobalSnapshot = chainManager.getLatestGlobalSnapshotId();
// append snapshot to the sinfos (the end).
- if (chainManager.getLatestGlobalSnapshot() != null) {
- sinfo = sinfos.get(snapshotID);
- sinfo.setGlobalPreviousSnapshotID(chainManager
- .getLatestGlobalSnapshot());
- sinfo.setPathPreviousSnapshotID(chainManager
- .getLatestPathSnapshot(String
- .join("/", "vol1", "bucket1")));
- sinfos.put(snapshotID, sinfo);
+ if (latestGlobalSnapshot != null) {
+ sinfo = snapshotIdToSnapshotInfoMap.get(snapshotID);
+ sinfo.setGlobalPreviousSnapshotId(latestGlobalSnapshot);
+ UUID latestPathSnapshot = chainManager.getLatestPathSnapshotId(
+ String.join("/", "vol1", "bucket1"));
+ if (latestPathSnapshot != null) {
+ sinfo.setPathPreviousSnapshotId(latestPathSnapshot);
+ }
+ snapshotIdToSnapshotInfoMap.put(snapshotID, sinfo);
}
- chainManager.deleteSnapshot(sinfos.get(snapshotID));
+ chainManager.deleteSnapshot(snapshotIdToSnapshotInfoMap.get(snapshotID));
}
@Test
public void testAddSnapshot() throws Exception {
final String snapshotPath = "vol1/bucket1";
// add three snapshots
- String snapshotID1 = UUID.randomUUID().toString();
- String snapshotID2 = UUID.randomUUID().toString();
- String snapshotID3 = UUID.randomUUID().toString();
+ UUID snapshotID1 = UUID.randomUUID();
+ UUID snapshotID2 = UUID.randomUUID();
+ UUID snapshotID3 = UUID.randomUUID();
- ArrayList<String> snapshotIDs = new ArrayList<>();
+ ArrayList<UUID> snapshotIDs = new ArrayList<>();
snapshotIDs.add(snapshotID1);
snapshotIDs.add(snapshotID2);
snapshotIDs.add(snapshotID3);
- String prevSnapshotID = null;
+ UUID prevSnapshotID = null;
// add 3 snapshots
- for (String snapshotID : snapshotIDs) {
- chainManager.addSnapshot(createSnapshotInfo("vol1",
- "bucket1",
- "test",
+ for (UUID snapshotID : snapshotIDs) {
+ chainManager.addSnapshot(createSnapshotInfo(
snapshotID,
prevSnapshotID,
prevSnapshotID));
prevSnapshotID = snapshotID;
}
- Assert.assertEquals(snapshotID3,
- chainManager
- .getLatestGlobalSnapshot());
- Assert.assertEquals(snapshotID3,
- chainManager
- .getLatestPathSnapshot(String
- .join("/", "vol1", "bucket1")));
+ assertEquals(snapshotID3, chainManager.getLatestGlobalSnapshotId());
+ assertEquals(snapshotID3, chainManager.getLatestPathSnapshotId(
+ String.join("/", "vol1", "bucket1")));
int i = 0;
- String curID = snapshotIDs.get(i);
+ UUID curID = snapshotIDs.get(i);
while (chainManager.hasNextGlobalSnapshot(curID)) {
i++;
- Assert.assertEquals(snapshotIDs.get(i),
- chainManager.nextGlobalSnapshot(curID));
+ assertEquals(snapshotIDs.get(i), chainManager.nextGlobalSnapshot(curID));
curID = snapshotIDs.get(i);
}
curID = snapshotIDs.get(i);
while (chainManager.hasPreviousGlobalSnapshot(curID)) {
i--;
- Assert.assertEquals(snapshotIDs.get(i),
- chainManager.previousGlobalSnapshot(curID));
+ assertEquals(snapshotIDs.get(i),
+ chainManager.previousGlobalSnapshot(curID));
curID = snapshotIDs.get(i);
}
i = 0;
curID = snapshotIDs.get(i);
- while (chainManager.hasNextPathSnapshot(snapshotPath,
- curID)) {
+ while (chainManager.hasNextPathSnapshot(snapshotPath, curID)) {
i++;
- Assert.assertEquals(snapshotIDs.get(i),
- chainManager.nextPathSnapshot(snapshotPath,
- curID));
+ assertEquals(snapshotIDs.get(i),
+ chainManager.nextPathSnapshot(snapshotPath, curID));
curID = snapshotIDs.get(i);
}
curID = snapshotIDs.get(i);
while (chainManager.hasPreviousPathSnapshot(snapshotPath,
- curID)) {
+ curID)) {
i--;
- Assert.assertEquals(snapshotIDs.get(i),
- chainManager.previousPathSnapshot(snapshotPath,
- curID));
+ assertEquals(snapshotIDs.get(i),
+ chainManager.previousPathSnapshot(snapshotPath, curID));
curID = snapshotIDs.get(i);
}
}
@@ -204,29 +193,26 @@ public class TestSnapshotChain {
@Test
public void testDeleteSnapshot() throws Exception {
// add three snapshots
- String snapshotID1 = UUID.randomUUID().toString();
- String snapshotID2 = UUID.randomUUID().toString();
- String snapshotID3 = UUID.randomUUID().toString();
+ UUID snapshotID1 = UUID.randomUUID();
+ UUID snapshotID2 = UUID.randomUUID();
+ UUID snapshotID3 = UUID.randomUUID();
- ArrayList<String> snapshotIDs = new ArrayList<>();
+ ArrayList<UUID> snapshotIDs = new ArrayList<>();
snapshotIDs.add(snapshotID1);
snapshotIDs.add(snapshotID2);
snapshotIDs.add(snapshotID3);
- String prevSnapshotID = null;
+ UUID prevSnapshotID = null;
// add 3 snapshots
- for (String snapshotID : snapshotIDs) {
- sinfos.put(snapshotID,
- createSnapshotInfo("vol1",
- "bucket1",
- "test",
+ for (UUID snapshotID : snapshotIDs) {
+ snapshotIdToSnapshotInfoMap.put(snapshotID,
+ createSnapshotInfo(
snapshotID,
prevSnapshotID,
prevSnapshotID));
- chainManager
- .addSnapshot(sinfos.get(snapshotID));
+ chainManager.addSnapshot(snapshotIdToSnapshotInfoMap.get(snapshotID));
prevSnapshotID = snapshotID;
}
@@ -235,31 +221,22 @@ public class TestSnapshotChain {
deleteSnapshot(snapshotID2);
// start with first snapshot in snapshot chain
- Assert.assertEquals(false, chainManager
- .hasPreviousGlobalSnapshot(snapshotID1));
- Assert.assertEquals(true, chainManager
- .hasNextGlobalSnapshot(snapshotID1));
- Assert.assertEquals(snapshotID3, chainManager
- .nextGlobalSnapshot(snapshotID1));
- Assert.assertEquals(false, chainManager
- .hasNextGlobalSnapshot(snapshotID3));
+ assertFalse(chainManager.hasPreviousGlobalSnapshot(snapshotID1));
+ assertTrue(chainManager.hasNextGlobalSnapshot(snapshotID1));
+ assertFalse(chainManager.hasNextGlobalSnapshot(snapshotID3));
+ assertEquals(snapshotID3,
+ chainManager.nextGlobalSnapshot(snapshotID1));
// add snapshotID2 and delete snapshotID1
// should have snapshotID3 and snapshotID2
deleteSnapshot(snapshotID1);
- chainManager
- .addSnapshot(sinfos.get(snapshotID2));
-
- Assert.assertEquals(false,
- chainManager.hasPreviousGlobalSnapshot(snapshotID3));
- Assert.assertEquals(true,
- chainManager.hasNextGlobalSnapshot(snapshotID3));
- Assert.assertEquals(snapshotID2,
- chainManager.nextGlobalSnapshot(snapshotID3));
- Assert.assertEquals(false,
- chainManager.hasNextGlobalSnapshot(snapshotID2));
- Assert.assertEquals(snapshotID3, chainManager
- .previousGlobalSnapshot(snapshotID2));
+ chainManager.addSnapshot(snapshotIdToSnapshotInfoMap.get(snapshotID2));
+
+ assertFalse(chainManager.hasPreviousGlobalSnapshot(snapshotID3));
+ assertTrue(chainManager.hasNextGlobalSnapshot(snapshotID3));
+ assertEquals(snapshotID2, chainManager.nextGlobalSnapshot(snapshotID3));
+ assertFalse(chainManager.hasNextGlobalSnapshot(snapshotID2));
+ assertEquals(snapshotID3,
chainManager.previousGlobalSnapshot(snapshotID2));
}
@Test
@@ -268,39 +245,32 @@ public class TestSnapshotChain {
omMetadataManager.getSnapshotInfoTable();
// add two snapshots to the snapshotInfo
- String snapshotID1 = UUID.randomUUID().toString();
- String snapshotID2 = UUID.randomUUID().toString();
+ UUID snapshotID1 = UUID.randomUUID();
+ UUID snapshotID2 = UUID.randomUUID();
- ArrayList<String> snapshotIDs = new ArrayList<>();
+ ArrayList<UUID> snapshotIDs = new ArrayList<>();
snapshotIDs.add(snapshotID1);
snapshotIDs.add(snapshotID2);
- String prevSnapshotID = "";
+ UUID prevSnapshotID = null;
// add 3 snapshots
- for (String snapshotID : snapshotIDs) {
- snapshotInfo.put(snapshotID,
- createSnapshotInfo("vol1",
- "bucket1",
- "test",
- snapshotID,
- prevSnapshotID,
- prevSnapshotID));
-
+ for (UUID snapshotID : snapshotIDs) {
+ snapshotInfo.put(snapshotID.toString(),
+ createSnapshotInfo(snapshotID, prevSnapshotID, prevSnapshotID));
prevSnapshotID = snapshotID;
}
chainManager.loadSnapshotInfo(omMetadataManager);
// check if snapshots loaded correctly from snapshotInfoTable
- Assert.assertEquals(snapshotID2, chainManager.getLatestGlobalSnapshot());
- Assert.assertEquals(snapshotID2, chainManager
- .nextGlobalSnapshot(snapshotID1));
- Assert.assertEquals(snapshotID1, chainManager.previousPathSnapshot(String
- .join("/", "vol1", "bucket1"), snapshotID2));
- Assert.assertThrows(NoSuchElementException.class,
- () -> chainManager.nextGlobalSnapshot(snapshotID2));
- Assert.assertThrows(NoSuchElementException.class,
- () -> chainManager.previousPathSnapshot(String
- .join("/", "vol1", "bucket1"), snapshotID1));
+ assertEquals(snapshotID2, chainManager.getLatestGlobalSnapshotId());
+ assertEquals(snapshotID2, chainManager.nextGlobalSnapshot(snapshotID1));
+ assertEquals(snapshotID1, chainManager.previousPathSnapshot(String
+ .join("/", "vol1", "bucket1"), snapshotID2));
+ assertThrows(NoSuchElementException.class,
+ () -> chainManager.nextGlobalSnapshot(snapshotID2));
+ assertThrows(NoSuchElementException.class,
+ () -> chainManager.previousPathSnapshot(String
+ .join("/", "vol1", "bucket1"), snapshotID1));
}
}
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotInfo.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotInfo.java
index bafe1d33eb..d3651b06d2 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotInfo.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotInfo.java
@@ -19,9 +19,9 @@
package org.apache.hadoop.ozone.om;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.utils.db.Table;
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo.SnapshotStatus;
-import org.apache.hadoop.hdds.utils.db.Table;
import org.apache.hadoop.util.Time;
import org.junit.Assert;
import org.junit.Before;
@@ -40,10 +40,8 @@ public class TestSnapshotInfo {
private OMMetadataManager omMetadataManager;
private static final String EXPECTED_SNAPSHOT_KEY = "snapshot1";
- private static final String EXPECTED_SNAPSHOT_ID =
- UUID.randomUUID().toString();
- private static final String EXPECTED_PREVIOUS_SNAPSHOT_ID =
- UUID.randomUUID().toString();
+ private static final UUID EXPECTED_SNAPSHOT_ID = UUID.randomUUID();
+ private static final UUID EXPECTED_PREVIOUS_SNAPSHOT_ID = UUID.randomUUID();
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@@ -58,15 +56,15 @@ public class TestSnapshotInfo {
private SnapshotInfo createSnapshotInfo() {
return new SnapshotInfo.Builder()
- .setSnapshotID(EXPECTED_SNAPSHOT_ID)
+ .setSnapshotId(EXPECTED_SNAPSHOT_ID)
.setName("snapshot1")
.setVolumeName("vol1")
.setBucketName("bucket1")
.setSnapshotStatus(SnapshotStatus.SNAPSHOT_ACTIVE)
.setCreationTime(Time.now())
.setDeletionTime(-1L)
- .setPathPreviousSnapshotID(EXPECTED_PREVIOUS_SNAPSHOT_ID)
- .setGlobalPreviousSnapshotID(EXPECTED_PREVIOUS_SNAPSHOT_ID)
+ .setPathPreviousSnapshotId(EXPECTED_PREVIOUS_SNAPSHOT_ID)
+ .setGlobalPreviousSnapshotId(EXPECTED_PREVIOUS_SNAPSHOT_ID)
.setSnapshotPath("test/path")
.setCheckpointDir("checkpoint.testdir")
.build();
@@ -85,7 +83,7 @@ public class TestSnapshotInfo {
omMetadataManager.getSnapshotInfoTable();
snapshotInfo.put(EXPECTED_SNAPSHOT_KEY, createSnapshotInfo());
Assert.assertEquals(EXPECTED_SNAPSHOT_ID,
- snapshotInfo.get(EXPECTED_SNAPSHOT_KEY).getSnapshotID());
+ snapshotInfo.get(EXPECTED_SNAPSHOT_KEY).getSnapshotId());
}
@Test
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSstFilteringService.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSstFilteringService.java
index 9b6061447f..54eb3a74f2 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSstFilteringService.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestSstFilteringService.java
@@ -223,7 +223,7 @@ public class TestSstFilteringService {
List<String> processedSnapshotIds = Files
.readAllLines(Paths.get(dbSnapshots, OzoneConsts.FILTERED_SNAPSHOTS));
Assert.assertTrue(
- processedSnapshotIds.contains(snapshotInfo.getSnapshotID()));
+
processedSnapshotIds.contains(snapshotInfo.getSnapshotId().toString()));
long count;
// Prevent the new snapshot from being filtered
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/OMRequestTestUtils.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/OMRequestTestUtils.java
index 1dac4ac364..1be049ef78 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/OMRequestTestUtils.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/OMRequestTestUtils.java
@@ -26,6 +26,7 @@ import java.util.List;
import java.util.UUID;
import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hdds.HddsUtils;
import org.apache.hadoop.hdds.client.BlockID;
import org.apache.hadoop.hdds.client.ReplicationConfig;
import org.apache.hadoop.hdds.client.ReplicationConfigValidator;
@@ -365,7 +366,7 @@ public final class OMRequestTestUtils {
String volumeName, String bucketName, String snapshotName,
OMMetadataManager omMetadataManager) throws IOException {
SnapshotInfo snapshotInfo = SnapshotInfo.newInstance(volumeName,
- bucketName, snapshotName, UUID.randomUUID().toString(), Time.now());
+ bucketName, snapshotName, UUID.randomUUID(), Time.now());
addSnapshotToTable(false, 0L, snapshotInfo, omMetadataManager);
}
@@ -376,7 +377,7 @@ public final class OMRequestTestUtils {
String volumeName, String bucketName, String snapshotName,
OMMetadataManager omMetadataManager) throws IOException {
SnapshotInfo snapshotInfo = SnapshotInfo.newInstance(volumeName,
bucketName,
- snapshotName, UUID.randomUUID().toString(), Time.now());
+ snapshotName, UUID.randomUUID(), Time.now());
addSnapshotToTable(true, 0L, snapshotInfo, omMetadataManager);
}
@@ -1126,7 +1127,7 @@ public final class OMRequestTestUtils {
OzoneManagerProtocolProtos.CreateSnapshotRequest.newBuilder()
.setVolumeName(volumeName)
.setBucketName(bucketName)
- .setSnapshotId(UUID.randomUUID().toString())
+ .setSnapshotId(HddsUtils.toProtobuf(UUID.randomUUID()))
.setSnapshotName(snapshotName)
.build();
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/snapshot/TestOMSnapshotPurgeRequestAndResponse.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/snapshot/TestOMSnapshotPurgeRequestAndResponse.java
index 1a04916ea4..82d5ca3f97 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/snapshot/TestOMSnapshotPurgeRequestAndResponse.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/snapshot/TestOMSnapshotPurgeRequestAndResponse.java
@@ -82,12 +82,9 @@ public class TestOMSnapshotPurgeRequestAndResponse {
private String bucketName;
private String keyName;
-
// Just setting ozoneManagerDoubleBuffer which does nothing.
- private static OzoneManagerDoubleBufferHelper ozoneManagerDoubleBufferHelper
=
- ((response, transactionIndex) -> {
- return null;
- });
+ private static final OzoneManagerDoubleBufferHelper
+ DOUBLE_BUFFER_HELPER = ((response, transactionIndex) -> null);
@BeforeEach
public void setup() throws Exception {
@@ -178,7 +175,7 @@ public class TestOMSnapshotPurgeRequestAndResponse {
// validateAndUpdateCache OMSnapshotCreateResponse.
OMSnapshotCreateResponse omClientResponse = (OMSnapshotCreateResponse)
omSnapshotCreateRequest.validateAndUpdateCache(ozoneManager, 1,
- ozoneManagerDoubleBufferHelper);
+ DOUBLE_BUFFER_HELPER);
// Add to batch and commit to DB.
omClientResponse.addToDBBatch(omMetadataManager, batchOperation);
omMetadataManager.getStore().commitBatchOperation(batchOperation);
@@ -217,7 +214,7 @@ public class TestOMSnapshotPurgeRequestAndResponse {
// validateAndUpdateCache for OMSnapshotPurgeRequest.
OMSnapshotPurgeResponse omSnapshotPurgeResponse = (OMSnapshotPurgeResponse)
omSnapshotPurgeRequest.validateAndUpdateCache(ozoneManager, 200L,
- ozoneManagerDoubleBufferHelper);
+ DOUBLE_BUFFER_HELPER);
// Commit to DB.
batchOperation = omMetadataManager.getStore().initBatchOperation();
@@ -259,28 +256,30 @@ public class TestOMSnapshotPurgeRequestAndResponse {
// Get previous and next snapshotInfos to verify if the SnapInfo
// is changed.
- String prevPathSnapId = null;
- String prevGlobalSnapId = null;
- String nextPathSnapId = null;
- String nextGlobalSnapId = null;
+ // Get previous and next snapshotInfos to verify if the SnapInfo
+ // is changed.
+ UUID prevPathSnapId = null;
+ UUID prevGlobalSnapId = null;
+ UUID nextPathSnapId = null;
+ UUID nextGlobalSnapId = null;
if (chainManager.hasPreviousPathSnapshot(snapInfo.getSnapshotPath(),
- snapInfo.getSnapshotID())) {
+ snapInfo.getSnapshotId())) {
prevPathSnapId = chainManager.previousPathSnapshot(
- snapInfo.getSnapshotPath(), snapInfo.getSnapshotID());
+ snapInfo.getSnapshotPath(), snapInfo.getSnapshotId());
}
- if (chainManager.hasPreviousGlobalSnapshot(snapInfo.getSnapshotID())) {
+ if (chainManager.hasPreviousGlobalSnapshot(snapInfo.getSnapshotId())) {
prevGlobalSnapId = chainManager.previousGlobalSnapshot(
- snapInfo.getSnapshotID());
+ snapInfo.getSnapshotId());
}
if (chainManager.hasNextPathSnapshot(snapInfo.getSnapshotPath(),
- snapInfo.getSnapshotID())) {
+ snapInfo.getSnapshotId())) {
nextPathSnapId = chainManager.nextPathSnapshot(
- snapInfo.getSnapshotPath(), snapInfo.getSnapshotID());
+ snapInfo.getSnapshotPath(), snapInfo.getSnapshotId());
}
- if (chainManager.hasNextGlobalSnapshot(snapInfo.getSnapshotID())) {
+ if (chainManager.hasNextGlobalSnapshot(snapInfo.getSnapshotId())) {
nextGlobalSnapId = chainManager.nextGlobalSnapshot(
- snapInfo.getSnapshotID());
+ snapInfo.getSnapshotId());
}
long rowsInTableBeforePurge = omMetadataManager
@@ -296,7 +295,7 @@ public class TestOMSnapshotPurgeRequestAndResponse {
SnapshotInfo nextPathSnapshotInfoAfterPurge = metadataManager
.getSnapshotInfoTable().get(chainManager.getTableKey(nextPathSnapId));
Assertions.assertEquals(nextPathSnapshotInfoAfterPurge
- .getGlobalPreviousSnapshotID(), prevPathSnapId);
+ .getGlobalPreviousSnapshotId(), prevPathSnapId);
}
if (nextGlobalSnapId != null) {
@@ -304,7 +303,7 @@ public class TestOMSnapshotPurgeRequestAndResponse {
.getSnapshotInfoTable().get(chainManager
.getTableKey(nextGlobalSnapId));
Assertions.assertEquals(nextGlobalSnapshotInfoAfterPurge
- .getGlobalPreviousSnapshotID(), prevGlobalSnapId);
+ .getGlobalPreviousSnapshotId(), prevGlobalSnapId);
}
Assertions.assertNotEquals(rowsInTableBeforePurge, omMetadataManager
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotCreateResponse.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotCreateResponse.java
index d50a1539e1..b4071b6a92 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotCreateResponse.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotCreateResponse.java
@@ -89,7 +89,7 @@ public class TestOMSnapshotCreateResponse {
String volumeName = UUID.randomUUID().toString();
String bucketName = UUID.randomUUID().toString();
String snapshotName = UUID.randomUUID().toString();
- String snapshotId = UUID.randomUUID().toString();
+ UUID snapshotId = UUID.randomUUID();
SnapshotInfo snapshotInfo = SnapshotInfo.newInstance(volumeName,
bucketName,
snapshotName,
diff --git
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotDeleteResponse.java
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotDeleteResponse.java
index a568bf6db6..dfbbf6b223 100644
---
a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotDeleteResponse.java
+++
b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/snapshot/TestOMSnapshotDeleteResponse.java
@@ -82,7 +82,7 @@ public class TestOMSnapshotDeleteResponse {
String volumeName = UUID.randomUUID().toString();
String bucketName = UUID.randomUUID().toString();
String snapshotName = UUID.randomUUID().toString();
- String snapshotId = UUID.randomUUID().toString();
+ UUID snapshotId = UUID.randomUUID();
SnapshotInfo snapshotInfo = SnapshotInfo.newInstance(volumeName,
bucketName,
snapshotName,
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
