HDDS-13081. Add S3 Object tagging tests

hadoop-ozone/integration-test-s3/src/test/java/org/apache/hadoop/ozone/s3/awssdk/v1/AbstractS3SDKV1Tests.java

@@ -21,8 +21,12 @@
 import static org.apache.hadoop.ozone.s3.awssdk.S3SDKTestUtils.calculateDigest;
 import static org.apache.hadoop.ozone.s3.awssdk.S3SDKTestUtils.createFile;
 import static org.apache.hadoop.ozone.s3.util.S3Consts.CUSTOM_METADATA_HEADER_PREFIX;
+import static org.apache.hadoop.ozone.s3.util.S3Consts.TAG_KEY_LENGTH_LIMIT;
+import static org.apache.hadoop.ozone.s3.util.S3Consts.TAG_NUM_LIMIT;
+import static org.apache.hadoop.ozone.s3.util.S3Consts.TAG_VALUE_LENGTH_LIMIT;
 import static org.apache.hadoop.ozone.s3.util.S3Utils.stripQuotes;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -41,6 +45,7 @@
 import com.amazonaws.services.s3.model.CompleteMultipartUploadResult;
 import com.amazonaws.services.s3.model.CreateBucketRequest;
 import com.amazonaws.services.s3.model.GeneratePresignedUrlRequest;
+import com.amazonaws.services.s3.model.GetBucketAclRequest;
 import com.amazonaws.services.s3.model.GetObjectRequest;
 import com.amazonaws.services.s3.model.Grantee;
 import com.amazonaws.services.s3.model.InitiateMultipartUploadRequest;
@@ -94,18 +99,22 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import java.util.stream.Stream;
 import javax.xml.bind.DatatypeConverter;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.hadoop.hdds.client.OzoneQuota;
 import org.apache.hadoop.hdds.client.ReplicationConfig;
 import org.apache.hadoop.hdds.client.ReplicationFactor;
 import org.apache.hadoop.hdds.client.ReplicationType;
+import org.apache.hadoop.hdds.protocol.StorageType;
 import org.apache.hadoop.ozone.MiniOzoneCluster;
+import org.apache.hadoop.ozone.client.BucketArgs;
 import org.apache.hadoop.ozone.client.ObjectStore;
 import org.apache.hadoop.ozone.client.OzoneBucket;
 import org.apache.hadoop.ozone.client.OzoneClient;
@@ -129,6 +138,8 @@
 import org.junit.jupiter.api.TestMethodOrder;
 import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
 /**
@@ -535,6 +546,192 @@ public void testGetObjectWithoutETag() throws Exception {
     }
   }
 
+  @Test
+  public void testPutAndGetObjectTagging() throws Exception {
+    final String bucketName = getBucketName();
+    final String keyName = getKeyName();
+    final String content = "test content";
+    s3Client.createBucket(bucketName);
+    s3Client.putObject(bucketName, keyName, content);
+
+    Map<String, String> tags = new HashMap<>();
+    tags.put("env", "test");
+    tags.put("project", "ozone");
+
+    try (OzoneClient ozoneClient = cluster.newClient()) {
+      ObjectStore store = ozoneClient.getObjectStore();
+      OzoneVolume volume = store.getS3Volume();
+      OzoneBucket bucket = volume.getBucket(bucketName);
+      bucket.putObjectTagging(keyName, tags);
+
+      Map<String, String> retrievedTags = bucket.getObjectTagging(keyName);
+      assertEquals(tags.size(), retrievedTags.size());
+      assertEquals("test", retrievedTags.get("env"));
+      assertEquals("ozone", retrievedTags.get("project"));
+    }
+  }
+
+  @Test
+  public void testDeleteObjectTagging() throws Exception {
+    final String bucketName = getBucketName();
+    final String keyName = getKeyName();
+    final String content = "test content";
+    s3Client.createBucket(bucketName);
+    s3Client.putObject(bucketName, keyName, content);
+
+    Map<String, String> tags = new HashMap<>();
+    tags.put("temp", "data");
+
+    try (OzoneClient ozoneClient = cluster.newClient()) {
+      ObjectStore store = ozoneClient.getObjectStore();
+      OzoneVolume volume = store.getS3Volume();
+      OzoneBucket bucket = volume.getBucket(bucketName);
+      bucket.putObjectTagging(keyName, tags);
+
+      Map<String, String> beforeDelete = bucket.getObjectTagging(keyName);
+      assertEquals(1, beforeDelete.size());
+
+      bucket.deleteObjectTagging(keyName);
+
+      Map<String, String> afterDelete = bucket.getObjectTagging(keyName);
+      assertTrue(afterDelete.isEmpty());
+    }
+  }
+
+  @Test
+  public void testPutObjectTaggingExceedsLimit() throws Exception {
+    final String bucketName = getBucketName();
+    final String keyName = getKeyName();
+    s3Client.createBucket(bucketName);
+    s3Client.putObject(bucketName, keyName, "content");
+
+    Map<String, String> tags = new HashMap<>();
+    for (int i = 1; i <= TAG_NUM_LIMIT + 1; i++) {
+      tags.put("key" + i, "value" + i);
+    }
+
+    try (OzoneClient ozoneClient = cluster.newClient()) {
+      ObjectStore store = ozoneClient.getObjectStore();
+      OzoneVolume volume = store.getS3Volume();
+      OzoneBucket bucket = volume.getBucket(bucketName);
+      assertThrows(Exception.class, () -> bucket.putObjectTagging(keyName, tags));
+    }
+  }
+
+  @Test
+  public void testPutObjectTaggingReplacesExistingTags() throws Exception {
+    final String bucketName = getBucketName();
+    final String keyName = getKeyName();
+    s3Client.createBucket(bucketName);
+    s3Client.putObject(bucketName, keyName, "content");
+
+    Map<String, String> initialTags = new HashMap<>();
+    initialTags.put("tag1", "value1");
+    initialTags.put("tag2", "value2");
+
+    Map<String, String> replacementTags = new HashMap<>();
+    replacementTags.put("tag3", "value3");
+
+    try (OzoneClient ozoneClient = cluster.newClient()) {
+      ObjectStore store = ozoneClient.getObjectStore();
+      OzoneVolume volume = store.getS3Volume();
+      OzoneBucket bucket = volume.getBucket(bucketName);
+      bucket.putObjectTagging(keyName, initialTags);
+      bucket.putObjectTagging(keyName, replacementTags);
+
+      Map<String, String> retrievedTags = bucket.getObjectTagging(keyName);
+      assertEquals(1, retrievedTags.size());
+      assertEquals("value3", retrievedTags.get("tag3"));
+      assertFalse(retrievedTags.containsKey("tag1"));
+      assertFalse(retrievedTags.containsKey("tag2"));
+    }
+  }
+
+  private static String repeatChar(char c, int count) {
+    StringBuilder sb = new StringBuilder(count);
+    for (int i = 0; i < count; i++) {
+      sb.append(c);
+    }
+    return sb.toString();
+  }
+
+  private static Stream<Arguments> invalidTagConstraintsProvider() {
+    return Stream.of(
+        Arguments.of(
+            repeatChar('a', TAG_KEY_LENGTH_LIMIT + 1),
+            "value"
+        ),
+        Arguments.of(
+            "valid-key",
+            repeatChar('b', TAG_VALUE_LENGTH_LIMIT + 1)
+        ),
+        Arguments.of(
+            "t$ag@#invalid",
+            "value"
+        ),
+        Arguments.of(
+            "aws:test",
+            "value"
+        )
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("invalidTagConstraintsProvider")
+  public void testPutObjectTaggingInvalidConstraints(String tagKey, String tagValue)
+      throws Exception {
+    final String bucketName = getBucketName();
+    final String keyName = getKeyName();
+    s3Client.createBucket(bucketName);
+    s3Client.putObject(bucketName, keyName, "content");
+
+    Map<String, String> invalidTags = new HashMap<>();
+    invalidTags.put(tagKey, tagValue);
+
+    try (OzoneClient ozoneClient = cluster.newClient()) {
+      ObjectStore store = ozoneClient.getObjectStore();
+      OzoneVolume volume = store.getS3Volume();
+      OzoneBucket bucket = volume.getBucket(bucketName);
+      Exception exception = assertThrows(Exception.class,
+          () -> bucket.putObjectTagging(keyName, invalidTags));
+      assertTrue(exception.getMessage().contains("Invalid") ||
+          exception.getMessage().contains("exceed") ||
+          exception.getMessage().contains("aws:"));
+    }
+  }
+
+  @Test
+  public void testPutAndGetObjectTaggingOnNonExistentObject() throws Exception {
+    final String bucketName = getBucketName();
+    final String keyName = getKeyName();
+    s3Client.createBucket(bucketName);
+
+    Map<String, String> tags = new HashMap<>();
+    tags.put("env", "test");
+
+    try (OzoneClient ozoneClient = cluster.newClient()) {
+      ObjectStore store = ozoneClient.getObjectStore();
+      OzoneVolume volume = store.getS3Volume();
+      OzoneBucket bucket = volume.getBucket(bucketName);
+      assertThrows(Exception.class, () -> bucket.putObjectTagging(keyName, tags));
+      assertThrows(Exception.class, () -> bucket.getObjectTagging(keyName));
+    }
+  }
+
+  @Test
+  public void testDeleteObjectTaggingOnNonExistentObject() throws Exception {
+    final String bucketName = getBucketName();
+    final String keyName = getKeyName();
+    s3Client.createBucket(bucketName);
+
+    try (OzoneClient ozoneClient = cluster.newClient()) {
+      ObjectStore store = ozoneClient.getObjectStore();
+      OzoneVolume volume = store.getS3Volume();
+      OzoneBucket bucket = volume.getBucket(bucketName);
+      assertThrows(Exception.class, () -> bucket.deleteObjectTagging(keyName));
+    }
+  }
+
   @Test
   public void testListObjectsMany() throws Exception {
     testListObjectsMany(false);
@@ -1042,7 +1239,7 @@ public void testQuotaExceeded() throws IOException {
             RandomStringUtils.secure().nextAlphanumeric(1024)));
 
     assertEquals(ErrorType.Client, ase.getErrorType());
-    assertEquals(403, ase.getStatusCode());
+    assertEquals(HttpURLConnection.HTTP_FORBIDDEN, ase.getStatusCode());
     assertEquals("QuotaExceeded", ase.getErrorCode());
   }
 
@@ -1358,6 +1555,86 @@ public void testPresignedUrlDelete() throws IOException {
     }
   }
 
+  @Nested
+  @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+  class LinkBucketTests {
+    private String nonS3VolumeName;
+    private String linkBucketName;
+    private String sourceBucketName;
+    private String danglingSourceBucketName;
+    private String danglingLinkBucketName;
+    private OzoneVolume nonS3Volume;
+    private OzoneVolume s3Volume;
+
+    @BeforeAll
+    public void setup() throws Exception {
+      nonS3VolumeName = randomName("link-vol");
+      linkBucketName = randomName("link-bucket");
+      sourceBucketName = randomName("source");
+      danglingSourceBucketName = randomName("link-source");
+      danglingLinkBucketName = randomName("link-bucket-dangling");
+      try (OzoneClient ozoneClient = cluster.newClient()) {
+        ObjectStore store = ozoneClient.getObjectStore();
+        store.createVolume(nonS3VolumeName);
+        nonS3Volume = store.getVolume(nonS3VolumeName);
+        s3Volume = store.getS3Volume();
+      }
+    }
+
+    @Test
+    public void setBucketVerificationOnLinkBucket() throws Exception {
+      nonS3Volume.createBucket(sourceBucketName);
+      BucketArgs.Builder bb = new BucketArgs.Builder()
+          .setStorageType(StorageType.DEFAULT)
+          .setVersioning(false)
+          .setSourceVolume(nonS3VolumeName)
+          .setSourceBucket(sourceBucketName);
+      s3Volume.createBucket(linkBucketName, bb.build());
+
+      GetBucketAclRequest wrongRequest = new GetBucketAclRequest(linkBucketName)
+          .withExpectedBucketOwner("wrong-owner");
+      AmazonServiceException wrongOwner = assertThrows(AmazonServiceException.class,
+          () -> s3Client.getBucketAcl(wrongRequest));
+      assertEquals(HttpURLConnection.HTTP_FORBIDDEN, wrongOwner.getStatusCode());
+      assertEquals("Access Denied", wrongOwner.getErrorCode());
+
+      Owner owner = s3Client.getBucketAcl(linkBucketName).getOwner();
+      GetBucketAclRequest correctRequest = new GetBucketAclRequest(linkBucketName)
+          .withExpectedBucketOwner(owner.getDisplayName());
+      assertDoesNotThrow(() -> s3Client.getBucketAcl(correctRequest));
+    }
+
+    @Test
+    public void testDanglingBucket() throws Exception {
+      nonS3Volume.createBucket(danglingSourceBucketName);
+      BucketArgs.Builder bb = new BucketArgs.Builder()
+          .setStorageType(StorageType.DEFAULT)
+          .setVersioning(false)
+          .setSourceVolume(nonS3VolumeName)
+          .setSourceBucket(danglingSourceBucketName);
+      s3Volume.createBucket(danglingLinkBucketName, bb.build());
+
+      nonS3Volume.deleteBucket(danglingSourceBucketName);
+
+      GetBucketAclRequest wrongRequest = new GetBucketAclRequest(danglingLinkBucketName)
+          .withExpectedBucketOwner("wrong-owner");
+      AmazonServiceException wrongOwner = assertThrows(AmazonServiceException.class,
+          () -> s3Client.getBucketAcl(wrongRequest));
+      assertEquals(HttpURLConnection.HTTP_FORBIDDEN, wrongOwner.getStatusCode());
+      assertEquals("Access Denied", wrongOwner.getErrorCode());
+
+      Owner owner = s3Client.getBucketAcl(danglingLinkBucketName).getOwner();
+      GetBucketAclRequest correctRequest = new GetBucketAclRequest(danglingLinkBucketName)
+          .withExpectedBucketOwner(owner.getDisplayName());
+      assertDoesNotThrow(() -> s3Client.getBucketAcl(correctRequest));
+    }
+
+    private String randomName(String prefix) {
+      return (prefix + "-" + RandomStringUtils.secure().nextAlphanumeric(8))
+          .toLowerCase(Locale.ROOT);
+    }
+  }
+
   /**
    * Tests the functionality to create a snapshot of an Ozone bucket and then read files
    * from the snapshot directory using the S3 SDK.