You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ozone.apache.org by ad...@apache.org on 2024/11/17 08:11:24 UTC
(ozone) branch master updated: HDDS-10655. Support PutObjectTagging, GetObjectTagging, and DeleteObjectTagging (#6756)
This is an automated email from the ASF dual-hosted git repository.
adoroszlai 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 3e278b7609 HDDS-10655. Support PutObjectTagging, GetObjectTagging, and DeleteObjectTagging (#6756)
3e278b7609 is described below
commit 3e278b76090c5d32f175a879c567e2636d87d39e
Author: Ivan Andika <iv...@rocketmail.com>
AuthorDate: Sun Nov 17 16:11:18 2024 +0800
HDDS-10655. Support PutObjectTagging, GetObjectTagging, and DeleteObjectTagging (#6756)
---
.../apache/hadoop/ozone/OzoneManagerVersion.java | 3 +
.../apache/hadoop/ozone/client/OzoneBucket.java | 31 +++
.../ozone/client/protocol/ClientProtocol.java | 34 +++
.../apache/hadoop/ozone/client/rpc/RpcClient.java | 55 +++++
.../main/java/org/apache/hadoop/ozone/OmUtils.java | 3 +
.../apache/hadoop/ozone/om/IOmMetadataReader.java | 8 +
.../hadoop/ozone/om/helpers/KeyValueUtil.java | 4 +-
.../ozone/om/protocol/OzoneManagerProtocol.java | 25 ++
...OzoneManagerProtocolClientSideTranslatorPB.java | 70 ++++++
.../dist/src/main/smoketest/s3/objectputget.robot | 1 +
.../dist/src/main/smoketest/s3/objecttagging.robot | 73 ++++++
.../src/main/smoketest/s3/s3_compatbility_check.sh | 1 +
.../hadoop/ozone/TestMultipartObjectGet.java | 4 +-
.../ozone/client/rpc/OzoneRpcClientTests.java | 132 +++++++++++
.../org/apache/hadoop/ozone/om/TestOmMetrics.java | 32 ++-
.../src/main/proto/OmClientProtocol.proto | 34 +++
.../org/apache/hadoop/ozone/audit/OMAction.java | 6 +-
.../org/apache/hadoop/ozone/om/KeyManager.java | 12 +
.../org/apache/hadoop/ozone/om/KeyManagerImpl.java | 10 +
.../java/org/apache/hadoop/ozone/om/OMMetrics.java | 37 +++
.../hadoop/ozone/om/OMPerformanceMetrics.java | 20 +-
.../apache/hadoop/ozone/om/OmMetadataReader.java | 40 ++++
.../hadoop/ozone/om/OmMetadataReaderMetrics.java | 4 +
.../org/apache/hadoop/ozone/om/OmSnapshot.java | 6 +
.../apache/hadoop/ozone/om/OmSnapshotMetrics.java | 17 ++
.../org/apache/hadoop/ozone/om/OzoneManager.java | 9 +
.../hadoop/ozone/om/helpers/OMAuditLogger.java | 3 +
.../om/ratis/utils/OzoneManagerRatisUtils.java | 10 +
.../BucketLayoutAwareOMKeyRequestFactory.java | 21 ++
.../ozone/om/request/OMClientRequestUtils.java | 13 +
.../s3/tagging/S3DeleteObjectTaggingRequest.java | 190 +++++++++++++++
.../S3DeleteObjectTaggingRequestWithFSO.java | 169 +++++++++++++
.../s3/tagging/S3PutObjectTaggingRequest.java | 192 +++++++++++++++
.../tagging/S3PutObjectTaggingRequestWithFSO.java | 171 ++++++++++++++
.../s3/tagging/package-info.java} | 36 +--
.../s3/tagging/S3DeleteObjectTaggingResponse.java | 73 ++++++
.../S3DeleteObjectTaggingResponseWithFSO.java | 72 ++++++
.../s3/tagging/S3PutObjectTaggingResponse.java | 72 ++++++
.../tagging/S3PutObjectTaggingResponseWithFSO.java | 72 ++++++
.../s3/tagging/package-info.java} | 36 +--
.../protocolPB/OzoneManagerRequestHandler.java | 27 +++
.../request/TestBucketLayoutAwareOMKeyFactory.java | 6 +-
.../tagging/TestS3DeleteObjectTaggingRequest.java | 202 ++++++++++++++++
.../TestS3DeleteObjectTaggingRequestWithFSO.java | 74 ++++++
.../s3/tagging/TestS3PutObjectTaggingRequest.java | 254 ++++++++++++++++++++
.../TestS3PutObjectTaggingRequestWithFSO.java | 95 ++++++++
.../tagging/TestS3DeleteObjectTaggingResponse.java | 89 +++++++
.../TestS3DeleteObjectTaggingResponseWithFSO.java | 74 ++++++
.../s3/tagging/TestS3PutObjectTaggingResponse.java | 88 +++++++
.../TestS3PutObjectTaggingResponseWithFSO.java | 70 ++++++
.../org/apache/hadoop/ozone/audit/S3GAction.java | 5 +-
.../hadoop/ozone/s3/endpoint/EndpointBase.java | 68 +++---
.../hadoop/ozone/s3/endpoint/ObjectEndpoint.java | 115 ++++++++-
.../ozone/s3/endpoint/PutTaggingUnmarshaller.java | 70 ++++++
.../apache/hadoop/ozone/s3/endpoint/S3Tagging.java | 155 ++++++++++++
.../hadoop/ozone/s3/exception/S3ErrorTable.java | 4 +
.../hadoop/ozone/s3/metrics/S3GatewayMetrics.java | 90 +++++++
.../org/apache/hadoop/ozone/s3/util/S3Consts.java | 1 +
.../hadoop/ozone/client/ClientProtocolStub.java | 16 ++
.../hadoop/ozone/client/OzoneBucketStub.java | 31 +++
.../s3/endpoint/TestAbortMultipartUpload.java | 4 +-
.../hadoop/ozone/s3/endpoint/TestListParts.java | 14 +-
.../s3/endpoint/TestMultipartUploadComplete.java | 2 +-
.../s3/endpoint/TestMultipartUploadWithCopy.java | 6 +-
.../hadoop/ozone/s3/endpoint/TestObjectDelete.java | 2 +-
.../hadoop/ozone/s3/endpoint/TestObjectGet.java | 22 +-
.../hadoop/ozone/s3/endpoint/TestObjectPut.java | 66 +++---
.../ozone/s3/endpoint/TestObjectTaggingDelete.java | 152 ++++++++++++
.../ozone/s3/endpoint/TestObjectTaggingGet.java | 125 ++++++++++
.../ozone/s3/endpoint/TestObjectTaggingPut.java | 263 +++++++++++++++++++++
.../hadoop/ozone/s3/endpoint/TestPartUpload.java | 14 +-
.../s3/endpoint/TestPartUploadWithStream.java | 8 +-
.../ozone/s3/endpoint/TestPermissionCheck.java | 48 +++-
.../ozone/s3/endpoint/TestUploadWithStream.java | 4 +-
.../ozone/s3/metrics/TestS3GatewayMetrics.java | 146 ++++++++++--
75 files changed, 4009 insertions(+), 202 deletions(-)
diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneManagerVersion.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneManagerVersion.java
index 982b559c7a..2d0b2bb56f 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneManagerVersion.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneManagerVersion.java
@@ -47,6 +47,9 @@ public enum OzoneManagerVersion implements ComponentVersion {
LIGHTWEIGHT_LIST_STATUS(8, "OzoneManager version that supports lightweight"
+ " listStatus API."),
+ S3_OBJECT_TAGGING_API(9, "OzoneManager version that supports S3 object tagging APIs, such as " +
+ "PutObjectTagging, GetObjectTagging, and DeleteObjectTagging"),
+
FUTURE_VERSION(-1, "Used internally in the client when the server side is "
+ " newer and an unknown server version has arrived to the client.");
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneBucket.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneBucket.java
index 216b51b8e8..405f3a42e9 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneBucket.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/OzoneBucket.java
@@ -1046,6 +1046,37 @@ public class OzoneBucket extends WithMetadata {
proxy.setTimes(ozoneObj, keyName, mtime, atime);
}
+ /**
+ * Gets the tags for an existing key.
+ * @param keyName Key name.
+ * @return Tags for the specified key.
+ * @throws IOException
+ */
+ public Map<String, String> getObjectTagging(String keyName)
+ throws IOException {
+ return proxy.getObjectTagging(volumeName, name, keyName);
+ }
+
+ /**
+ * Sets the tags to an existing key.
+ * @param keyName Key name.
+ * @param tags Tags to set on the key.
+ * @throws IOException
+ */
+ public void putObjectTagging(String keyName, Map<String, String> tags)
+ throws IOException {
+ proxy.putObjectTagging(volumeName, name, keyName, tags);
+ }
+
+ /**
+ * Removes all the tags from an existing key.
+ * @param keyName Key name
+ * @throws IOException
+ */
+ public void deleteObjectTagging(String keyName) throws IOException {
+ proxy.deleteObjectTagging(volumeName, name, keyName);
+ }
+
public void setSourcePathExist(boolean b) {
this.sourcePathExist = b;
}
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/protocol/ClientProtocol.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/protocol/ClientProtocol.java
index 8d9614b554..c0bffaf895 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/protocol/ClientProtocol.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/protocol/ClientProtocol.java
@@ -1311,4 +1311,38 @@ public interface ClientProtocol {
* @throws IOException
*/
void recoverKey(OmKeyArgs args, long clientID) throws IOException;
+
+ /**
+ * Gets the tags for an existing key.
+ * @param volumeName Volume name.
+ * @param bucketName Bucket name.
+ * @param keyName Key name.
+ * @return tags for the specified key.
+ * @throws IOException
+ */
+ Map<String, String> getObjectTagging(String volumeName, String bucketName, String keyName)
+ throws IOException;
+
+ /**
+ * Sets the tags to an existing key.
+ * @param volumeName Volume name.
+ * @param bucketName Bucket name.
+ * @param keyName Key name.
+ * @param tags Tags to set on the key.
+ * @throws IOException
+ */
+ void putObjectTagging(String volumeName, String bucketName, String keyName,
+ Map<String, String> tags) throws IOException;
+
+
+ /**
+ * Removes all the tags from the specified key.
+ * @param volumeName Volume name.
+ * @param bucketName Bucket name.
+ * @param keyName Key name.
+ * @throws IOException
+ */
+ void deleteObjectTagging(String volumeName, String bucketName, String keyName)
+ throws IOException;
+
}
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java
index fe98664017..73692b37c5 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java
@@ -2727,6 +2727,61 @@ public class RpcClient implements ClientProtocol {
ozoneManagerClient.recoverKey(args, clientID);
}
+ @Override
+ public Map<String, String> getObjectTagging(String volumeName, String bucketName, String keyName)
+ throws IOException {
+ if (omVersion.compareTo(OzoneManagerVersion.S3_OBJECT_TAGGING_API) < 0) {
+ throw new IOException("OzoneManager does not support S3 object tagging API");
+ }
+
+ verifyVolumeName(volumeName);
+ verifyBucketName(bucketName);
+ Preconditions.checkNotNull(keyName);
+ OmKeyArgs keyArgs = new OmKeyArgs.Builder()
+ .setVolumeName(volumeName)
+ .setBucketName(bucketName)
+ .setKeyName(keyName)
+ .build();
+ return ozoneManagerClient.getObjectTagging(keyArgs);
+ }
+
+ @Override
+ public void putObjectTagging(String volumeName, String bucketName,
+ String keyName, Map<String, String> tags) throws IOException {
+ if (omVersion.compareTo(OzoneManagerVersion.S3_OBJECT_TAGGING_API) < 0) {
+ throw new IOException("OzoneManager does not support S3 object tagging API");
+ }
+
+ verifyVolumeName(volumeName);
+ verifyBucketName(bucketName);
+ Preconditions.checkNotNull(keyName);
+ OmKeyArgs keyArgs = new OmKeyArgs.Builder()
+ .setVolumeName(volumeName)
+ .setBucketName(bucketName)
+ .setKeyName(keyName)
+ .addAllTags(tags)
+ .build();
+ ozoneManagerClient.putObjectTagging(keyArgs);
+ }
+
+ @Override
+ public void deleteObjectTagging(String volumeName, String bucketName,
+ String keyName) throws IOException {
+ if (omVersion.compareTo(OzoneManagerVersion.S3_OBJECT_TAGGING_API) < 0) {
+ throw new IOException("OzoneManager does not support S3 object tagging API");
+ }
+
+ verifyVolumeName(volumeName);
+ verifyBucketName(bucketName);
+ Preconditions.checkNotNull(keyName);
+ OmKeyArgs keyArgs = new OmKeyArgs.Builder()
+ .setVolumeName(volumeName)
+ .setBucketName(bucketName)
+ .setKeyName(keyName)
+ .build();
+ ozoneManagerClient.deleteObjectTagging(keyArgs);
+ }
+
private static ExecutorService createThreadPoolExecutor(
int corePoolSize, int maximumPoolSize, String threadNameFormat) {
return new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java
index 9565d2db8e..8d24f2de15 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java
@@ -278,6 +278,7 @@ public final class OmUtils {
case SetSafeMode:
case PrintCompactionLogDag:
case GetSnapshotInfo:
+ case GetObjectTagging:
case GetQuotaRepairStatus:
case StartQuotaRepair:
return true;
@@ -339,6 +340,8 @@ public final class OmUtils {
case AbortExpiredMultiPartUploads:
case SetSnapshotProperty:
case QuotaRepair:
+ case PutObjectTagging:
+ case DeleteObjectTagging:
case UnknownCommand:
return false;
case EchoRPC:
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/IOmMetadataReader.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/IOmMetadataReader.java
index 7d4e769365..99e2759117 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/IOmMetadataReader.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/IOmMetadataReader.java
@@ -30,6 +30,7 @@ import org.apache.hadoop.ozone.security.acl.OzoneObj;
import java.io.IOException;
import java.util.List;
+import java.util.Map;
/**
* Protocol for OmMetadataReader's.
@@ -165,4 +166,11 @@ public interface IOmMetadataReader {
* @throws IOException if there is error.
*/
List<OzoneAcl> getAcl(OzoneObj obj) throws IOException;
+
+ /**
+ * Gets the tags for the specified key.
+ * @param args Key args
+ * @return Tags associated with the key.
+ */
+ Map<String, String> getObjectTagging(OmKeyArgs args) throws IOException;
}
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/KeyValueUtil.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/KeyValueUtil.java
index db07a19b21..0b9b4b38a5 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/KeyValueUtil.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/helpers/KeyValueUtil.java
@@ -34,8 +34,8 @@ public final class KeyValueUtil {
/**
* Parse Key,Value map data from protobuf representation.
*/
- public static Map<String, String> getFromProtobuf(List<KeyValue> metadata) {
- return metadata.stream()
+ public static Map<String, String> getFromProtobuf(List<KeyValue> keyValueList) {
+ return keyValueList.stream()
.collect(Collectors.toMap(KeyValue::getKey,
KeyValue::getValue));
}
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocol/OzoneManagerProtocol.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocol/OzoneManagerProtocol.java
index 94822630f8..7f633d7ea7 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocol/OzoneManagerProtocol.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocol/OzoneManagerProtocol.java
@@ -1145,6 +1145,31 @@ public interface OzoneManagerProtocol
boolean setSafeMode(SafeModeAction action, boolean isChecked)
throws IOException;
+ /**
+ * Gets the tags for the specified key.
+ * @param args Key args
+ * @return Tags associated with the key.
+ */
+ Map<String, String> getObjectTagging(OmKeyArgs args) throws IOException;
+
+ /**
+ * Sets the tags to an existing key.
+ * @param args Key args
+ */
+ default void putObjectTagging(OmKeyArgs args) throws IOException {
+ throw new UnsupportedOperationException("OzoneManager does not require " +
+ "this to be implemented, as write requests use a new approach.");
+ }
+
+ /**
+ * Removes all the tags from the specified key.
+ * @param args Key args
+ */
+ default void deleteObjectTagging(OmKeyArgs args) throws IOException {
+ throw new UnsupportedOperationException("OzoneManager does not require " +
+ "this to be implemented, as write requests use a new approach.");
+ }
+
/**
* Get status of last triggered quota repair in OM.
* @return String
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocolPB/OzoneManagerProtocolClientSideTranslatorPB.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocolPB/OzoneManagerProtocolClientSideTranslatorPB.java
index b140cf95e6..a748efac72 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocolPB/OzoneManagerProtocolClientSideTranslatorPB.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/protocolPB/OzoneManagerProtocolClientSideTranslatorPB.java
@@ -108,6 +108,7 @@ import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteB
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteKeyArgs;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteKeyRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteKeysRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteObjectTaggingRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteSnapshotRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteTenantRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteTenantResponse;
@@ -125,6 +126,8 @@ import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetFile
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetFileStatusResponse;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetKeyInfoRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetKeyInfoResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetObjectTaggingResponse;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetS3SecretRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetS3SecretResponse;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetS3VolumeContextRequest;
@@ -174,6 +177,7 @@ import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.Prepare
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PrepareStatusRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PrepareStatusResponse;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PrintCompactionLogDagRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PutObjectTaggingRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.RangerBGSyncRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.RangerBGSyncResponse;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.RecoverLeaseRequest;
@@ -2580,6 +2584,72 @@ public final class OzoneManagerProtocolClientSideTranslatorPB
handleError(submitRequest(omRequest));
}
+ @Override
+ public Map<String, String> getObjectTagging(OmKeyArgs args) throws IOException {
+ KeyArgs keyArgs = KeyArgs.newBuilder()
+ .setVolumeName(args.getVolumeName())
+ .setBucketName(args.getBucketName())
+ .setKeyName(args.getKeyName())
+ .build();
+
+ GetObjectTaggingRequest req =
+ GetObjectTaggingRequest.newBuilder()
+ .setKeyArgs(keyArgs)
+ .build();
+
+ OMRequest omRequest = createOMRequest(Type.GetObjectTagging)
+ .setGetObjectTaggingRequest(req)
+ .build();
+
+ GetObjectTaggingResponse resp =
+ handleError(submitRequest(omRequest)).getGetObjectTaggingResponse();
+
+ return KeyValueUtil.getFromProtobuf(resp.getTagsList());
+ }
+
+ @Override
+ public void putObjectTagging(OmKeyArgs args) throws IOException {
+ KeyArgs keyArgs = KeyArgs.newBuilder()
+ .setVolumeName(args.getVolumeName())
+ .setBucketName(args.getBucketName())
+ .setKeyName(args.getKeyName())
+ .addAllTags(KeyValueUtil.toProtobuf(args.getTags()))
+ .build();
+
+ PutObjectTaggingRequest req =
+ PutObjectTaggingRequest.newBuilder()
+ .setKeyArgs(keyArgs)
+ .build();
+
+ OMRequest omRequest = createOMRequest(Type.PutObjectTagging)
+ .setPutObjectTaggingRequest(req)
+ .build();
+
+ OMResponse omResponse = submitRequest(omRequest);
+ handleError(omResponse);
+ }
+
+ @Override
+ public void deleteObjectTagging(OmKeyArgs args) throws IOException {
+ KeyArgs keyArgs = KeyArgs.newBuilder()
+ .setVolumeName(args.getVolumeName())
+ .setBucketName(args.getBucketName())
+ .setKeyName(args.getKeyName())
+ .build();
+
+ DeleteObjectTaggingRequest req =
+ DeleteObjectTaggingRequest.newBuilder()
+ .setKeyArgs(keyArgs)
+ .build();
+
+ OMRequest omRequest = createOMRequest(Type.DeleteObjectTagging)
+ .setDeleteObjectTaggingRequest(req)
+ .build();
+
+ OMResponse omResponse = submitRequest(omRequest);
+ handleError(omResponse);
+ }
+
private SafeMode toProtoBuf(SafeModeAction action) {
switch (action) {
case ENTER:
diff --git a/hadoop-ozone/dist/src/main/smoketest/s3/objectputget.robot b/hadoop-ozone/dist/src/main/smoketest/s3/objectputget.robot
index 12fb985348..82a985f1d5 100644
--- a/hadoop-ozone/dist/src/main/smoketest/s3/objectputget.robot
+++ b/hadoop-ozone/dist/src/main/smoketest/s3/objectputget.robot
@@ -44,6 +44,7 @@ Put object to s3
Get object from s3
${result} = Execute AWSS3ApiCli get-object --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1 /tmp/testfile.result
Compare files /tmp/testfile /tmp/testfile.result
+ Should not contain ${result} TagCount
${result} = Execute AWSS3ApiCli get-object --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/zerobyte /tmp/zerobyte.result
Compare files /tmp/zerobyte /tmp/zerobyte.result
diff --git a/hadoop-ozone/dist/src/main/smoketest/s3/objecttagging.robot b/hadoop-ozone/dist/src/main/smoketest/s3/objecttagging.robot
new file mode 100644
index 0000000000..9098673680
--- /dev/null
+++ b/hadoop-ozone/dist/src/main/smoketest/s3/objecttagging.robot
@@ -0,0 +1,73 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+*** Settings ***
+Documentation S3 gateway test with aws cli
+Library OperatingSystem
+Library String
+Resource ../commonlib.robot
+Resource commonawslib.robot
+Test Timeout 5 minutes
+Suite Setup Setup s3 tests
+
+*** Variables ***
+${ENDPOINT_URL} http://s3g:9878
+${OZONE_TEST} true
+${BUCKET} generated
+
+
+*** Test Cases ***
+
+Put object tagging
+# Create an object and call put-object-tagging
+ Execute echo "Randomtext" > /tmp/testfile
+ ${result} = Execute AWSS3ApiCli put-object --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1 --body /tmp/testfile
+ ${result} = Execute AWSS3ApiCli list-objects --bucket ${BUCKET} --prefix ${PREFIX}/putobject/key=value/
+ Should contain ${result} f1
+
+ ${result} = Execute AWSS3ApiCli put-object-tagging --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1 --tagging '{"TagSet": [{ "Key": "tag-key1", "Value": "tag-value1" }]}'
+ ${result} = Execute AWSS3APICli get-object --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1 /tmp/testfile2.result
+ Should contain ${result} TagCount
+ ${tagCount} = Execute and checkrc echo '${result}' | jq -r '.TagCount' 0
+ Should Be Equal ${tagCount} 1
+
+# Calling put-object-tagging again to overwrite the existing tags
+ ${result} = Execute AWSS3ApiCli put-object-tagging --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1 --tagging '{"TagSet": [{ "Key": "tag-key2", "Value": "tag-value2" },{ "Key": "tag-key3", "Value": "tag-value3" }]}'
+ ${result} = Execute AWSS3APICli get-object --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1 /tmp/testfile2.result
+ Should contain ${result} TagCount
+ ${tagCount} = Execute and checkrc echo '${result}' | jq -r '.TagCount' 0
+ Should Be Equal ${tagCount} 2
+
+# Calling put-object-tagging on non-existent key
+ ${result} = Execute AWSS3APICli and checkrc put-object-tagging --bucket ${BUCKET} --key ${PREFIX}/nonexistent --tagging '{"TagSet": [{ "Key": "tag-key1", "Value": "tag-value1" }]}' 255
+ Should contain ${result} NoSuchKey
+
+#This test depends on the previous test case. Can't be executes alone
+Get object tagging
+
+ ${result} = Execute AWSS3ApiCli get-object-tagging --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1
+ Should contain ${result} TagSet
+ ${tagCount} = Execute and checkrc echo '${result}' | jq '.TagSet | length' 0
+ Should Be Equal ${tagCount} 2
+
+
+#This test depends on the previous test case. Can't be executes alone
+Delete object tagging
+
+ ${result} = Execute AWSS3ApiCli delete-object-tagging --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1
+ ${result} = Execute AWSS3ApiCli get-object-tagging --bucket ${BUCKET} --key ${PREFIX}/putobject/key=value/f1
+ Should contain ${result} TagSet
+ ${tagCount} = Execute and checkrc echo '${result}' | jq '.TagSet | length' 0
+ Should Be Equal ${tagCount} 0
diff --git a/hadoop-ozone/dist/src/main/smoketest/s3/s3_compatbility_check.sh b/hadoop-ozone/dist/src/main/smoketest/s3/s3_compatbility_check.sh
index b9a4c68587..ab2807167d 100755
--- a/hadoop-ozone/dist/src/main/smoketest/s3/s3_compatbility_check.sh
+++ b/hadoop-ozone/dist/src/main/smoketest/s3/s3_compatbility_check.sh
@@ -83,5 +83,6 @@ run_robot_test objectcopy
run_robot_test objectmultidelete
run_robot_test objecthead
run_robot_test MultipartUpload
+run_robot_test objecttagging
rebot --outputdir results/ results/*.xml
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMultipartObjectGet.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMultipartObjectGet.java
index 8a55dc7b7d..6d9bd23e2e 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMultipartObjectGet.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMultipartObjectGet.java
@@ -139,7 +139,7 @@ public class TestMultipartObjectGet {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
Response response = REST.put(BUCKET, KEY, content.length(),
- partNumber, uploadID, body);
+ partNumber, uploadID, null, body);
assertEquals(200, response.getStatus());
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
@@ -168,7 +168,7 @@ public class TestMultipartObjectGet {
private void getObjectMultipart(int partNumber, long bytes)
throws IOException, OS3Exception {
Response response =
- REST.get(BUCKET, KEY, partNumber, null, 100, null);
+ REST.get(BUCKET, KEY, partNumber, null, 100, null, null);
assertEquals(200, response.getStatus());
assertEquals(bytes, response.getLength());
assertEquals("3", response.getHeaderString(MP_PARTS_COUNT));
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/OzoneRpcClientTests.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/OzoneRpcClientTests.java
index 9ed0b182d3..69d516b9f5 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/OzoneRpcClientTests.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/OzoneRpcClientTests.java
@@ -4988,4 +4988,136 @@ abstract class OzoneRpcClientTests extends OzoneTestBase {
init();
}
}
+
+ @ParameterizedTest
+ @MethodSource("bucketLayouts")
+ public void testPutObjectTagging(BucketLayout bucketLayout) throws Exception {
+ String volumeName = UUID.randomUUID().toString();
+ String bucketName = UUID.randomUUID().toString();
+
+ String value = "sample value";
+ store.createVolume(volumeName);
+ OzoneVolume volume = store.getVolume(volumeName);
+ BucketArgs bucketArgs =
+ BucketArgs.newBuilder().setBucketLayout(bucketLayout).build();
+ volume.createBucket(bucketName, bucketArgs);
+ OzoneBucket bucket = volume.getBucket(bucketName);
+
+ String keyName = UUID.randomUUID().toString();
+
+ OzoneOutputStream out = bucket.createKey(keyName,
+ value.getBytes(UTF_8).length, anyReplication(), new HashMap<>());
+ out.write(value.getBytes(UTF_8));
+ out.close();
+
+ OzoneKey key = bucket.getKey(keyName);
+ assertTrue(key.getTags().isEmpty());
+
+ Map<String, String> tags = new HashMap<>();
+ tags.put("tag-key-1", "tag-value-1");
+ tags.put("tag-key-2", "tag-value-2");
+
+ bucket.putObjectTagging(keyName, tags);
+
+ OzoneKey updatedKey = bucket.getKey(keyName);
+ assertEquals(tags.size(), updatedKey.getTags().size());
+ assertEquals(key.getModificationTime(), updatedKey.getModificationTime());
+ assertThat(updatedKey.getTags()).containsAllEntriesOf(tags);
+
+ // Do another putObjectTagging, it should override the previous one
+ Map<String, String> secondTags = new HashMap<>();
+ secondTags.put("tag-key-3", "tag-value-3");
+
+ bucket.putObjectTagging(keyName, secondTags);
+
+ updatedKey = bucket.getKey(keyName);
+ assertEquals(secondTags.size(), updatedKey.getTags().size());
+ assertThat(updatedKey.getTags()).containsAllEntriesOf(secondTags);
+ assertThat(updatedKey.getTags()).doesNotContainKeys("tag-key-1", "tag-key-2");
+
+ if (bucketLayout.equals(BucketLayout.FILE_SYSTEM_OPTIMIZED)) {
+ String dirKey = "dir1/";
+ bucket.createDirectory(dirKey);
+ OMException exception = assertThrows(OMException.class,
+ () -> bucket.putObjectTagging(dirKey, tags));
+ assertThat(exception.getResult()).isEqualTo(ResultCodes.NOT_SUPPORTED_OPERATION);
+ }
+ }
+
+ @ParameterizedTest
+ @MethodSource("bucketLayouts")
+ public void testDeleteObjectTagging(BucketLayout bucketLayout) throws Exception {
+ String volumeName = UUID.randomUUID().toString();
+ String bucketName = UUID.randomUUID().toString();
+
+ String value = "sample value";
+ store.createVolume(volumeName);
+ OzoneVolume volume = store.getVolume(volumeName);
+ BucketArgs bucketArgs =
+ BucketArgs.newBuilder().setBucketLayout(bucketLayout).build();
+ volume.createBucket(bucketName, bucketArgs);
+ OzoneBucket bucket = volume.getBucket(bucketName);
+
+ String keyName = UUID.randomUUID().toString();
+
+ Map<String, String> tags = new HashMap<>();
+ tags.put("tag-key-1", "tag-value-1");
+ tags.put("tag-key-2", "tag-value-2");
+
+ OzoneOutputStream out = bucket.createKey(keyName,
+ value.getBytes(UTF_8).length, anyReplication(), new HashMap<>(), tags);
+ out.write(value.getBytes(UTF_8));
+ out.close();
+
+ OzoneKey key = bucket.getKey(keyName);
+ assertFalse(key.getTags().isEmpty());
+
+ bucket.deleteObjectTagging(keyName);
+
+ OzoneKey updatedKey = bucket.getKey(keyName);
+ assertEquals(0, updatedKey.getTags().size());
+ assertEquals(key.getModificationTime(), updatedKey.getModificationTime());
+
+ if (bucketLayout.equals(BucketLayout.FILE_SYSTEM_OPTIMIZED)) {
+ String dirKey = "dir1/";
+ bucket.createDirectory(dirKey);
+ OMException exception = assertThrows(OMException.class,
+ () -> bucket.deleteObjectTagging(dirKey));
+ assertThat(exception.getResult()).isEqualTo(ResultCodes.NOT_SUPPORTED_OPERATION);
+ }
+ }
+
+ @ParameterizedTest
+ @MethodSource("bucketLayouts")
+ public void testGetObjectTagging(BucketLayout bucketLayout) throws Exception {
+ String volumeName = UUID.randomUUID().toString();
+ String bucketName = UUID.randomUUID().toString();
+
+ String value = "sample value";
+ store.createVolume(volumeName);
+ OzoneVolume volume = store.getVolume(volumeName);
+ BucketArgs bucketArgs =
+ BucketArgs.newBuilder().setBucketLayout(bucketLayout).build();
+ volume.createBucket(bucketName, bucketArgs);
+ OzoneBucket bucket = volume.getBucket(bucketName);
+
+ String keyName = UUID.randomUUID().toString();
+
+ Map<String, String> tags = new HashMap<>();
+ tags.put("tag-key-1", "tag-value-1");
+ tags.put("tag-key-2", "tag-value-2");
+
+ OzoneOutputStream out = bucket.createKey(keyName,
+ value.getBytes(UTF_8).length, anyReplication(), new HashMap<>(), tags);
+ out.write(value.getBytes(UTF_8));
+ out.close();
+
+ OzoneKey key = bucket.getKey(keyName);
+ assertEquals(tags.size(), key.getTags().size());
+
+ Map<String, String> tagsRetrieved = bucket.getObjectTagging(keyName);
+
+ assertEquals(tags.size(), tagsRetrieved.size());
+ assertThat(tagsRetrieved).containsAllEntriesOf(tags);
+ }
}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmMetrics.java
index 0481ee4a86..eafa193ae2 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmMetrics.java
@@ -340,6 +340,9 @@ public class TestOmMetrics {
long initialNumKeyLists = getLongCounter("NumKeyLists", omMetrics);
long initialNumKeys = getLongCounter("NumKeys", omMetrics);
long initialNumInitiateMultipartUploads = getLongCounter("NumInitiateMultipartUploads", omMetrics);
+ long initialNumGetObjectTagging = getLongCounter("NumGetObjectTagging", omMetrics);
+ long initialNumPutObjectTagging = getLongCounter("NumPutObjectTagging", omMetrics);
+ long initialNumDeleteObjectTagging = getLongCounter("NumDeleteObjectTagging", omMetrics);
long initialEcKeyCreateTotal = getLongCounter("EcKeyCreateTotal", omMetrics);
long initialNumKeyAllocateFails = getLongCounter("NumKeyAllocateFails", omMetrics);
@@ -349,6 +352,9 @@ public class TestOmMetrics {
long initialNumBlockAllocationFails = getLongCounter("NumBlockAllocationFails", omMetrics);
long initialNumKeyListFails = getLongCounter("NumKeyListFails", omMetrics);
long initialEcKeyCreateFailsTotal = getLongCounter("EcKeyCreateFailsTotal", omMetrics);
+ long initialNumGetObjectTaggingFails = getLongCounter("NumGetObjectTaggingFails", omMetrics);
+ long initialNumPutObjectTaggingFails = getLongCounter("NumPutObjectTaggingFails", omMetrics);
+ long initialNumDeleteObjectTaggingFails = getLongCounter("NumDeleteObjectTaggingFails", omMetrics);
// see HDDS-10078 for making this work with FILE_SYSTEM_OPTIMIZED layout
TestDataUtil.createVolumeAndBucket(client, volumeName, bucketName, BucketLayout.LEGACY);
@@ -358,13 +364,16 @@ public class TestOmMetrics {
omMetrics = getMetrics("OMMetrics");
- assertEquals(initialNumKeyOps + 7, getLongCounter("NumKeyOps", omMetrics));
+ assertEquals(initialNumKeyOps + 10, getLongCounter("NumKeyOps", omMetrics));
assertEquals(initialNumKeyAllocate + 1, getLongCounter("NumKeyAllocate", omMetrics));
assertEquals(initialNumKeyLookup + 1, getLongCounter("NumKeyLookup", omMetrics));
assertEquals(initialNumKeyDeletes + 1, getLongCounter("NumKeyDeletes", omMetrics));
assertEquals(initialNumKeyLists + 1, getLongCounter("NumKeyLists", omMetrics));
assertEquals(initialNumKeys, getLongCounter("NumKeys", omMetrics));
assertEquals(initialNumInitiateMultipartUploads + 1, getLongCounter("NumInitiateMultipartUploads", omMetrics));
+ assertEquals(initialNumGetObjectTagging + 1, getLongCounter("NumGetObjectTagging", omMetrics));
+ assertEquals(initialNumPutObjectTagging + 1, getLongCounter("NumPutObjectTagging", omMetrics));
+ assertEquals(initialNumDeleteObjectTagging + 1, getLongCounter("NumDeleteObjectTagging", omMetrics));
keyArgs = createKeyArgs(volumeName, bucketName,
new ECReplicationConfig("rs-3-2-1024K"));
@@ -406,6 +415,7 @@ public class TestOmMetrics {
doThrow(exception).when(mockKm).lookupKey(any(), any(), any());
doThrow(exception).when(mockKm).listKeys(
any(), any(), any(), any(), anyInt());
+ doThrow(exception).when(mockKm).getObjectTagging(any(), any());
OmMetadataReader omMetadataReader =
(OmMetadataReader) ozoneManager.getOmMetadataReader().get();
HddsWhiteboxTestUtils.setInternalState(
@@ -421,7 +431,7 @@ public class TestOmMetrics {
doKeyOps(keyArgs);
omMetrics = getMetrics("OMMetrics");
- assertEquals(initialNumKeyOps + 28, getLongCounter("NumKeyOps", omMetrics));
+ assertEquals(initialNumKeyOps + 37, getLongCounter("NumKeyOps", omMetrics));
assertEquals(initialNumKeyAllocate + 6, getLongCounter("NumKeyAllocate", omMetrics));
assertEquals(initialNumKeyLookup + 3, getLongCounter("NumKeyLookup", omMetrics));
assertEquals(initialNumKeyDeletes + 4, getLongCounter("NumKeyDeletes", omMetrics));
@@ -435,6 +445,9 @@ public class TestOmMetrics {
assertEquals(initialNumInitiateMultipartUploadFails + 1, getLongCounter(
"NumInitiateMultipartUploadFails", omMetrics));
assertEquals(initialNumKeys + 2, getLongCounter("NumKeys", omMetrics));
+ assertEquals(initialNumGetObjectTaggingFails + 1, getLongCounter("NumGetObjectTaggingFails", omMetrics));
+ assertEquals(initialNumPutObjectTaggingFails + 1, getLongCounter("NumPutObjectTaggingFails", omMetrics));
+ assertEquals(initialNumDeleteObjectTaggingFails + 1, getLongCounter("NumDeleteObjectTaggingFails", omMetrics));
keyArgs = createKeyArgs(volumeName, bucketName,
new ECReplicationConfig("rs-3-2-1024K"));
@@ -836,6 +849,21 @@ public class TestOmMetrics {
} catch (IOException ignored) {
}
+ try {
+ writeClient.putObjectTagging(keyArgs);
+ } catch (IOException ignored) {
+ }
+
+ try {
+ writeClient.getObjectTagging(keyArgs);
+ } catch (IOException ignored) {
+ }
+
+ try {
+ writeClient.deleteObjectTagging(keyArgs);
+ } catch (IOException ignored) {
+ }
+
try {
writeClient.deleteKey(keyArgs);
} catch (IOException ignored) {
diff --git a/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto b/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto
index f71dc44fec..9971506fa9 100644
--- a/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto
+++ b/hadoop-ozone/interface-client/src/main/proto/OmClientProtocol.proto
@@ -153,6 +153,9 @@ enum Type {
GetQuotaRepairStatus = 135;
StartQuotaRepair = 136;
SnapshotMoveTableKeys = 137;
+ PutObjectTagging = 140;
+ GetObjectTagging = 141;
+ DeleteObjectTagging = 142;
}
enum SafeMode {
@@ -292,9 +295,14 @@ message OMRequest {
optional RenameSnapshotRequest RenameSnapshotRequest = 129;
optional ListOpenFilesRequest ListOpenFilesRequest = 130;
optional QuotaRepairRequest QuotaRepairRequest = 131;
+
optional GetQuotaRepairStatusRequest GetQuotaRepairStatusRequest = 133;
optional StartQuotaRepairRequest StartQuotaRepairRequest = 134;
optional SnapshotMoveTableKeysRequest SnapshotMoveTableKeysRequest = 135;
+
+ optional GetObjectTaggingRequest getObjectTaggingRequest = 140;
+ optional PutObjectTaggingRequest putObjectTaggingRequest = 141;
+ optional DeleteObjectTaggingRequest deleteObjectTaggingRequest = 142;
}
message OMResponse {
@@ -424,6 +432,10 @@ message OMResponse {
optional QuotaRepairResponse QuotaRepairResponse = 134;
optional GetQuotaRepairStatusResponse GetQuotaRepairStatusResponse = 136;
optional StartQuotaRepairResponse StartQuotaRepairResponse = 137;
+
+ optional GetObjectTaggingResponse getObjectTaggingResponse = 140;
+ optional PutObjectTaggingResponse putObjectTaggingResponse = 141;
+ optional DeleteObjectTaggingResponse deleteObjectTaggingResponse = 142;
}
enum Status {
@@ -2259,6 +2271,28 @@ message OMLockDetailsProto {
optional uint64 writeLockNanos = 4;
}
+message PutObjectTaggingRequest {
+ required KeyArgs keyArgs = 1;
+}
+
+message PutObjectTaggingResponse {
+}
+
+message GetObjectTaggingRequest {
+ required KeyArgs keyArgs = 1;
+}
+
+message GetObjectTaggingResponse {
+ repeated hadoop.hdds.KeyValue tags = 1;
+}
+
+message DeleteObjectTaggingRequest {
+ required KeyArgs keyArgs = 1;
+}
+
+message DeleteObjectTaggingResponse {
+}
+
/**
The OM service that takes care of Ozone namespace.
*/
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/audit/OMAction.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/audit/OMAction.java
index 081477adf4..5fd9fd6d59 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/audit/OMAction.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/audit/OMAction.java
@@ -109,7 +109,11 @@ public enum OMAction implements AuditAction {
UPGRADE_CANCEL,
UPGRADE_FINALIZE,
- LIST_OPEN_FILES;
+ LIST_OPEN_FILES,
+
+ GET_OBJECT_TAGGING,
+ PUT_OBJECT_TAGGING,
+ DELETE_OBJECT_TAGGING;
@Override
public String getAction() {
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManager.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManager.java
index a0f3053d73..9f6d8b81c1 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManager.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManager.java
@@ -39,6 +39,7 @@ import java.io.IOException;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
/**
* Handles key level commands.
@@ -177,6 +178,17 @@ public interface KeyManager extends OzoneManagerFS, IOzoneAcl {
List<ExpiredMultipartUploadsBucket> getExpiredMultipartUploads(
Duration expireThreshold, int maxParts) throws IOException;
+ /**
+ * Look up an existing key from the OM table and retrieve the tags from
+ * the key info.
+ *
+ * @param args the args of the key provided by client.
+ * @param bucket the resolved parent bucket of the key.
+ * @return Map of the tag set associated with the key.
+ * @throws IOException
+ */
+ Map<String, String> getObjectTagging(OmKeyArgs args, ResolvedBucket bucket) throws IOException;
+
/**
* Returns the metadataManager.
* @return OMMetadataManager.
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java
index e99bdea85e..7532cf8b32 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java
@@ -735,6 +735,16 @@ public class KeyManagerImpl implements KeyManager {
maxParts);
}
+ @Override
+ public Map<String, String> getObjectTagging(OmKeyArgs args, ResolvedBucket bucket) throws IOException {
+ Preconditions.checkNotNull(args);
+
+ OmKeyInfo value = captureLatencyNs(metrics.getLookupReadKeyInfoLatencyNs(),
+ () -> readKeyInfo(args, bucket.bucketLayout()));
+
+ return value.getTags();
+ }
+
@Override
public OMMetadataManager getMetadataManager() {
return metadataManager;
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java
index cbe5205c10..de4241b7ac 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java
@@ -103,6 +103,10 @@ public class OMMetrics implements OmMetadataReaderMetrics {
private @Metric MutableCounterLong numSetTime;
private @Metric MutableCounterLong numGetKeyInfo;
+ private @Metric MutableCounterLong numGetObjectTagging;
+ private @Metric MutableCounterLong numPutObjectTagging;
+ private @Metric MutableCounterLong numDeleteObjectTagging;
+
// Failure Metrics
private @Metric MutableCounterLong numVolumeCreateFails;
private @Metric MutableCounterLong numVolumeUpdateFails;
@@ -184,6 +188,10 @@ public class OMMetrics implements OmMetadataReaderMetrics {
private @Metric MutableCounterLong numListOpenFilesFails;
private @Metric MutableCounterLong getNumGetKeyInfoFails;
+ private @Metric MutableCounterLong numGetObjectTaggingFails;
+ private @Metric MutableCounterLong numPutObjectTaggingFails;
+ private @Metric MutableCounterLong numDeleteObjectTaggingFails;
+
private @Metric MutableCounterLong numRecoverLeaseFails;
// Metrics for total amount of data written
@@ -913,6 +921,35 @@ public class OMMetrics implements OmMetadataReaderMetrics {
getNumGetKeyInfoFails.incr();
}
+ @Override
+ public void incNumGetObjectTagging() {
+ numGetObjectTagging.incr();
+ numKeyOps.incr();
+ }
+
+ @Override
+ public void incNumGetObjectTaggingFails() {
+ numGetObjectTaggingFails.incr();
+ }
+
+ public void incNumPutObjectTagging() {
+ numPutObjectTagging.incr();
+ numKeyOps.incr();
+ }
+
+ public void incNumPutObjectTaggingFails() {
+ numPutObjectTaggingFails.incr();
+ }
+
+ public void incNumDeleteObjectTagging() {
+ numDeleteObjectTagging.incr();
+ numKeyOps.incr();
+ }
+
+ public void incNumDeleteObjectTaggingFails() {
+ numDeleteObjectTaggingFails.incr();
+ }
+
@VisibleForTesting
public long getNumVolumeCreates() {
return numVolumeCreates.value();
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMPerformanceMetrics.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMPerformanceMetrics.java
index a01855d1b6..fc1d9e0e96 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMPerformanceMetrics.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMPerformanceMetrics.java
@@ -144,6 +144,12 @@ public class OMPerformanceMetrics {
@Metric(about = "readFromRockDb latency in listKeys")
private MutableRate listKeysReadFromRocksDbLatencyNs;
+ @Metric(about = "resolveBucketLink latency in getObjectTagging")
+ private MutableRate getObjectTaggingResolveBucketLatencyNs;
+
+ @Metric(about = "ACLs check in getObjectTagging")
+ private MutableRate getObjectTaggingAclCheckLatencyNs;
+
public void addLookupLatency(long latencyInNs) {
lookupLatencyNs.add(latencyInNs);
}
@@ -248,7 +254,7 @@ public class OMPerformanceMetrics {
public void setListKeysOpsPerSec(float opsPerSec) {
listKeysOpsPerSec.set(opsPerSec);
}
-
+
MutableRate getListKeysAclCheckLatencyNs() {
return listKeysAclCheckLatencyNs;
}
@@ -280,4 +286,16 @@ public class OMPerformanceMetrics {
public void addListKeysReadFromRocksDbLatencyNs(long latencyInNs) {
listKeysReadFromRocksDbLatencyNs.add(latencyInNs);
}
+
+ public MutableRate getGetObjectTaggingResolveBucketLatencyNs() {
+ return getObjectTaggingResolveBucketLatencyNs;
+ }
+
+ public MutableRate getGetObjectTaggingAclCheckLatencyNs() {
+ return getObjectTaggingAclCheckLatencyNs;
+ }
+
+ public void addGetObjectTaggingLatencyNs(long latencyInNs) {
+ getObjectTaggingAclCheckLatencyNs.add(latencyInNs);
+ }
}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReader.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReader.java
index fdee1b7128..08f2115387 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReader.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReader.java
@@ -382,6 +382,7 @@ public class OmMetadataReader implements IOmMetadataReader, Auditor {
* @param obj Ozone object.
* @throws IOException if there is error.
*/
+ @Override
public List<OzoneAcl> getAcl(OzoneObj obj) throws IOException {
String volumeName = obj.getVolumeName();
@@ -428,6 +429,45 @@ public class OmMetadataReader implements IOmMetadataReader, Auditor {
}
}
+ @Override
+ public Map<String, String> getObjectTagging(OmKeyArgs args) throws IOException {
+ long start = Time.monotonicNowNanos();
+
+ ResolvedBucket bucket = captureLatencyNs(
+ perfMetrics.getLookupResolveBucketLatencyNs(),
+ () -> ozoneManager.resolveBucketLink(args));
+
+ boolean auditSuccess = true;
+ Map<String, String> auditMap = bucket.audit(args.toAuditMap());
+
+ OmKeyArgs resolvedArgs = bucket.update(args);
+
+ try {
+ if (isAclEnabled) {
+ captureLatencyNs(perfMetrics.getGetObjectTaggingAclCheckLatencyNs(),
+ () -> checkAcls(ResourceType.KEY, StoreType.OZONE,
+ ACLType.READ, bucket,
+ args.getKeyName())
+ );
+ }
+ metrics.incNumGetObjectTagging();
+ return keyManager.getObjectTagging(resolvedArgs, bucket);
+ } catch (Exception ex) {
+ metrics.incNumGetObjectTaggingFails();
+ auditSuccess = false;
+ audit.logReadFailure(buildAuditMessageForFailure(OMAction.GET_OBJECT_TAGGING,
+ auditMap, ex));
+ throw ex;
+ } finally {
+ if (auditSuccess) {
+ audit.logReadSuccess(buildAuditMessageForSuccess(OMAction.GET_OBJECT_TAGGING,
+ auditMap));
+ }
+
+ perfMetrics.addGetObjectTaggingLatencyNs(Time.monotonicNowNanos() - start);
+ }
+ }
+
/**
* Checks if current caller has acl permissions.
*
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java
index 21b2e8b990..171242310a 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java
@@ -46,4 +46,8 @@ public interface OmMetadataReaderMetrics {
void incNumKeyListFails();
void incNumGetAcl();
+
+ void incNumGetObjectTagging();
+
+ void incNumGetObjectTaggingFails();
}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java
index f863c08602..acb3a41e12 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java
@@ -47,6 +47,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
@@ -185,6 +186,11 @@ public class OmSnapshot implements IOmMetadataReader, Closeable {
return omMetadataReader.getAcl(normalizeOzoneObj(obj));
}
+ @Override
+ public Map<String, String> getObjectTagging(OmKeyArgs args) throws IOException {
+ return omMetadataReader.getObjectTagging(normalizeOmKeyArgs(args));
+ }
+
private OzoneObj normalizeOzoneObj(OzoneObj o) {
if (o == null) {
return null;
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotMetrics.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotMetrics.java
index 7560d453eb..d00b12e94c 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotMetrics.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotMetrics.java
@@ -162,5 +162,22 @@ public final class OmSnapshotMetrics implements OmMetadataReaderMetrics {
MutableCounterLong numKeyOps;
private @Metric
MutableCounterLong numFSOps;
+
+
+ private @Metric
+ MutableCounterLong numGetObjectTagging;
+ private @Metric
+ MutableCounterLong numGetObjectTaggingFails;
+
+ @Override
+ public void incNumGetObjectTagging() {
+ numGetObjectTagging.incr();
+ numKeyOps.incr();
+ }
+
+ @Override
+ public void incNumGetObjectTaggingFails() {
+ numGetObjectTaggingFails.incr();
+ }
}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java
index b5ae80a02d..705f7c9a01 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java
@@ -4792,6 +4792,15 @@ public final class OzoneManager extends ServiceRuntimeInfoImpl
new QuotaRepairTask(this).repair(buckets);
}
+ @Override
+ public Map<String, String> getObjectTagging(final OmKeyArgs args)
+ throws IOException {
+ try (ReferenceCounted<IOmMetadataReader> rcReader = getReader(args)) {
+ return rcReader.get().getObjectTagging(args);
+ }
+ }
+
+
/**
* Write down Layout version of a finalized feature to DB on finalization.
* @param lvm OMLayoutVersionManager
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/helpers/OMAuditLogger.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/helpers/OMAuditLogger.java
index 18ee42756e..491f2dadbf 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/helpers/OMAuditLogger.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/helpers/OMAuditLogger.java
@@ -91,6 +91,9 @@ public final class OMAuditLogger {
CMD_AUDIT_ACTION_MAP.put(Type.Prepare, OMAction.UPGRADE_PREPARE);
CMD_AUDIT_ACTION_MAP.put(Type.CancelPrepare, OMAction.UPGRADE_CANCEL);
CMD_AUDIT_ACTION_MAP.put(Type.FinalizeUpgrade, OMAction.UPGRADE_FINALIZE);
+ CMD_AUDIT_ACTION_MAP.put(Type.GetObjectTagging, OMAction.GET_OBJECT_TAGGING);
+ CMD_AUDIT_ACTION_MAP.put(Type.PutObjectTagging, OMAction.PUT_OBJECT_TAGGING);
+ CMD_AUDIT_ACTION_MAP.put(Type.DeleteObjectTagging, OMAction.DELETE_OBJECT_TAGGING);
}
private static OMAction getAction(OzoneManagerProtocolProtos.OMRequest request) {
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/utils/OzoneManagerRatisUtils.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/utils/OzoneManagerRatisUtils.java
index 30e14bc017..dc634248c2 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/utils/OzoneManagerRatisUtils.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/utils/OzoneManagerRatisUtils.java
@@ -340,6 +340,16 @@ public final class OzoneManagerRatisUtils {
return new S3ExpiredMultipartUploadsAbortRequest(omRequest);
case QuotaRepair:
return new OMQuotaRepairRequest(omRequest);
+ case PutObjectTagging:
+ keyArgs = omRequest.getPutObjectTaggingRequest().getKeyArgs();
+ volumeName = keyArgs.getVolumeName();
+ bucketName = keyArgs.getBucketName();
+ break;
+ case DeleteObjectTagging:
+ keyArgs = omRequest.getDeleteObjectTaggingRequest().getKeyArgs();
+ volumeName = keyArgs.getVolumeName();
+ bucketName = keyArgs.getBucketName();
+ break;
default:
throw new OMException("Unrecognized write command type request "
+ cmdType, OMException.ResultCodes.INVALID_REQUEST);
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/BucketLayoutAwareOMKeyRequestFactory.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/BucketLayoutAwareOMKeyRequestFactory.java
index 4a5558ed7f..5d542bfb91 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/BucketLayoutAwareOMKeyRequestFactory.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/BucketLayoutAwareOMKeyRequestFactory.java
@@ -49,6 +49,10 @@ import org.apache.hadoop.ozone.om.request.s3.multipart.S3MultipartUploadCommitPa
import org.apache.hadoop.ozone.om.request.s3.multipart.S3MultipartUploadCommitPartRequestWithFSO;
import org.apache.hadoop.ozone.om.request.s3.multipart.S3MultipartUploadAbortRequest;
import org.apache.hadoop.ozone.om.request.s3.multipart.S3MultipartUploadAbortRequestWithFSO;
+import org.apache.hadoop.ozone.om.request.s3.tagging.S3DeleteObjectTaggingRequest;
+import org.apache.hadoop.ozone.om.request.s3.tagging.S3DeleteObjectTaggingRequestWithFSO;
+import org.apache.hadoop.ozone.om.request.s3.tagging.S3PutObjectTaggingRequest;
+import org.apache.hadoop.ozone.om.request.s3.tagging.S3PutObjectTaggingRequestWithFSO;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.Type;
import jakarta.annotation.Nonnull;
@@ -191,6 +195,23 @@ public final class BucketLayoutAwareOMKeyRequestFactory {
addRequestClass(Type.SetTimes,
OMKeySetTimesRequestWithFSO.class,
BucketLayout.FILE_SYSTEM_OPTIMIZED);
+
+ // PutObjectTagging
+ addRequestClass(Type.PutObjectTagging,
+ S3PutObjectTaggingRequest.class,
+ BucketLayout.OBJECT_STORE);
+ addRequestClass(Type.PutObjectTagging,
+ S3PutObjectTaggingRequestWithFSO.class,
+ BucketLayout.FILE_SYSTEM_OPTIMIZED);
+
+ // DeleteObjectTagging
+ addRequestClass(Type.DeleteObjectTagging,
+ S3DeleteObjectTaggingRequest.class,
+ BucketLayout.OBJECT_STORE);
+ addRequestClass(Type.DeleteObjectTagging,
+ S3DeleteObjectTaggingRequestWithFSO.class,
+ BucketLayout.FILE_SYSTEM_OPTIMIZED);
+
}
private BucketLayoutAwareOMKeyRequestFactory() {
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/OMClientRequestUtils.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/OMClientRequestUtils.java
index 26487935a6..1b318354ee 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/OMClientRequestUtils.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/OMClientRequestUtils.java
@@ -99,4 +99,17 @@ public final class OMClientRequestUtils {
}
return false;
}
+
+ public static boolean shouldLogClientRequestFailure(IOException exception) {
+ if (!(exception instanceof OMException)) {
+ return true;
+ }
+ OMException omException = (OMException) exception;
+ switch (omException.getResult()) {
+ case KEY_NOT_FOUND:
+ return false;
+ default:
+ return true;
+ }
+ }
}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3DeleteObjectTaggingRequest.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3DeleteObjectTaggingRequest.java
new file mode 100644
index 0000000000..6146e1ac10
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3DeleteObjectTaggingRequest.java
@@ -0,0 +1,190 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import com.google.common.base.Preconditions;
+import org.apache.hadoop.hdds.utils.db.cache.CacheKey;
+import org.apache.hadoop.hdds.utils.db.cache.CacheValue;
+import org.apache.hadoop.ozone.audit.OMAction;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.OMMetrics;
+import org.apache.hadoop.ozone.om.OzoneManager;
+import org.apache.hadoop.ozone.om.exceptions.OMException;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMClientRequestUtils;
+import org.apache.hadoop.ozone.om.request.key.OMKeyRequest;
+import org.apache.hadoop.ozone.om.request.util.OmResponseUtil;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.s3.tagging.S3DeleteObjectTaggingResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteObjectTaggingResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.KeyArgs;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+import org.apache.hadoop.ozone.security.acl.IAccessAuthorizer.ACLType;
+import org.apache.ratis.server.protocol.TermIndex;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.KEY_NOT_FOUND;
+import static org.apache.hadoop.ozone.om.lock.OzoneManagerLock.Resource.BUCKET_LOCK;
+
+/**
+ * Handles delete object tagging request.
+ */
+public class S3DeleteObjectTaggingRequest extends OMKeyRequest {
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(S3DeleteObjectTaggingRequest.class);
+
+ public S3DeleteObjectTaggingRequest(OMRequest omRequest, BucketLayout bucketLayout) {
+ super(omRequest, bucketLayout);
+ }
+
+ @Override
+ public OMRequest preExecute(OzoneManager ozoneManager) throws IOException {
+ DeleteObjectTaggingRequest deleteObjectTaggingRequest =
+ super.preExecute(ozoneManager).getDeleteObjectTaggingRequest();
+ Preconditions.checkNotNull(deleteObjectTaggingRequest);
+
+ KeyArgs keyArgs = deleteObjectTaggingRequest.getKeyArgs();
+
+ String keyPath = keyArgs.getKeyName();
+ keyPath = validateAndNormalizeKey(ozoneManager.getEnableFileSystemPaths(),
+ keyPath, getBucketLayout());
+
+ KeyArgs.Builder newKeyArgs =
+ keyArgs.toBuilder()
+ .setKeyName(keyPath);
+
+ KeyArgs resolvedArgs = resolveBucketAndCheckKeyAcls(newKeyArgs.build(),
+ ozoneManager, ACLType.WRITE);
+ return getOmRequest().toBuilder()
+ .setUserInfo(getUserInfo())
+ .setDeleteObjectTaggingRequest(
+ deleteObjectTaggingRequest.toBuilder().setKeyArgs(resolvedArgs))
+ .build();
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager, TermIndex termIndex) {
+ final long trxnLogIndex = termIndex.getIndex();
+
+ DeleteObjectTaggingRequest deleteObjectTaggingRequest = getOmRequest().getDeleteObjectTaggingRequest();
+
+ KeyArgs keyArgs = deleteObjectTaggingRequest.getKeyArgs();
+ String volumeName = keyArgs.getVolumeName();
+ String bucketName = keyArgs.getBucketName();
+ String keyName = keyArgs.getKeyName();
+
+ OMMetrics omMetrics = ozoneManager.getMetrics();
+ omMetrics.incNumDeleteObjectTagging();
+
+ Map<String, String> auditMap = buildKeyArgsAuditMap(keyArgs);
+
+ OMResponse.Builder omResponse = OmResponseUtil.getOMResponseBuilder(
+ getOmRequest());
+
+ OMMetadataManager omMetadataManager = ozoneManager.getMetadataManager();
+ boolean acquiredLock = false;
+ OMClientResponse omClientResponse = null;
+ IOException exception = null;
+ Result result = null;
+ try {
+ mergeOmLockDetails(
+ omMetadataManager.getLock()
+ .acquireWriteLock(BUCKET_LOCK, volumeName, bucketName)
+ );
+ acquiredLock = getOmLockDetails().isLockAcquired();
+
+ validateBucketAndVolume(omMetadataManager, volumeName, bucketName);
+
+ String dbOzoneKey =
+ omMetadataManager.getOzoneKey(volumeName, bucketName, keyName);
+
+ OmKeyInfo omKeyInfo =
+ omMetadataManager.getKeyTable(getBucketLayout()).get(dbOzoneKey);
+ if (omKeyInfo == null) {
+ throw new OMException("Key not found", KEY_NOT_FOUND);
+ }
+
+ // Clear / delete the tags
+ omKeyInfo.getTags().clear();
+ // Set the UpdateID to the current transactionLogIndex
+ omKeyInfo.setUpdateID(trxnLogIndex, ozoneManager.isRatisEnabled());
+
+ // Note: Key modification time is not changed because S3 last modified
+ // time only changes when there are changes in the object content
+
+ // Update table cache
+ omMetadataManager.getKeyTable(getBucketLayout()).addCacheEntry(
+ new CacheKey<>(dbOzoneKey),
+ CacheValue.get(trxnLogIndex, omKeyInfo)
+ );
+
+ omClientResponse = new S3DeleteObjectTaggingResponse(
+ omResponse.setDeleteObjectTaggingResponse(DeleteObjectTaggingResponse.newBuilder()).build(),
+ omKeyInfo
+ );
+
+ result = Result.SUCCESS;
+ } catch (IOException ex) {
+ result = Result.FAILURE;
+ exception = ex;
+ omClientResponse = new S3DeleteObjectTaggingResponse(
+ createErrorOMResponse(omResponse, exception),
+ getBucketLayout()
+ );
+ } finally {
+ if (acquiredLock) {
+ mergeOmLockDetails(omMetadataManager.getLock()
+ .releaseWriteLock(BUCKET_LOCK, volumeName, bucketName));
+ }
+ if (omClientResponse != null) {
+ omClientResponse.setOmLockDetails(getOmLockDetails());
+ }
+ }
+
+ markForAudit(ozoneManager.getAuditLogger(), buildAuditMessage(
+ OMAction.DELETE_OBJECT_TAGGING, auditMap, exception, getOmRequest().getUserInfo()
+ ));
+
+ switch (result) {
+ case SUCCESS:
+ LOG.debug("Delete object tagging success. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName);
+ break;
+ case FAILURE:
+ omMetrics.incNumDeleteObjectTaggingFails();
+ if (OMClientRequestUtils.shouldLogClientRequestFailure(exception)) {
+ LOG.error("Delete object tagging failed. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName, exception);
+ }
+ break;
+ default:
+ LOG.error("Unrecognized Result for S3DeleteObjectTaggingRequest: {}",
+ deleteObjectTaggingRequest);
+ }
+
+ return omClientResponse;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3DeleteObjectTaggingRequestWithFSO.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3DeleteObjectTaggingRequestWithFSO.java
new file mode 100644
index 0000000000..fb0561702a
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3DeleteObjectTaggingRequestWithFSO.java
@@ -0,0 +1,169 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import org.apache.hadoop.hdds.utils.db.cache.CacheKey;
+import org.apache.hadoop.hdds.utils.db.cache.CacheValue;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.OMMetrics;
+import org.apache.hadoop.ozone.om.OzoneManager;
+import org.apache.hadoop.ozone.om.exceptions.OMException;
+import org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.helpers.OzoneFileStatus;
+import org.apache.hadoop.ozone.om.request.file.OMFileRequest;
+import org.apache.hadoop.ozone.om.request.util.OmResponseUtil;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.s3.tagging.S3DeleteObjectTaggingResponseWithFSO;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteObjectTaggingResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.KeyArgs;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+import org.apache.ratis.server.protocol.TermIndex;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.apache.hadoop.ozone.om.lock.OzoneManagerLock.Resource.BUCKET_LOCK;
+
+/**
+ * Handles delete object tagging request for FSO bucket.
+ */
+public class S3DeleteObjectTaggingRequestWithFSO extends S3DeleteObjectTaggingRequest {
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(S3DeleteObjectTaggingRequestWithFSO.class);
+
+ public S3DeleteObjectTaggingRequestWithFSO(OMRequest omRequest,
+ BucketLayout bucketLayout) {
+ super(omRequest, bucketLayout);
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager, TermIndex termIndex) {
+ final long trxnLogIndex = termIndex.getIndex();
+
+ DeleteObjectTaggingRequest deleteObjectTaggingRequest = getOmRequest().getDeleteObjectTaggingRequest();
+
+ KeyArgs keyArgs = deleteObjectTaggingRequest.getKeyArgs();
+ String volumeName = keyArgs.getVolumeName();
+ String bucketName = keyArgs.getBucketName();
+ String keyName = keyArgs.getKeyName();
+
+ OMMetrics omMetrics = ozoneManager.getMetrics();
+ omMetrics.incNumDeleteObjectTagging();
+
+ Map<String, String> auditMap = buildKeyArgsAuditMap(keyArgs);
+
+ OMResponse.Builder omResponse = OmResponseUtil.getOMResponseBuilder(
+ getOmRequest());
+
+ OMMetadataManager omMetadataManager = ozoneManager.getMetadataManager();
+ boolean acquiredLock = false;
+ OMClientResponse omClientResponse = null;
+ IOException exception = null;
+ Result result = null;
+ try {
+ mergeOmLockDetails(
+ omMetadataManager.getLock()
+ .acquireWriteLock(BUCKET_LOCK, volumeName, bucketName)
+ );
+ acquiredLock = getOmLockDetails().isLockAcquired();
+
+ validateBucketAndVolume(omMetadataManager, volumeName, bucketName);
+
+ OzoneFileStatus keyStatus = OMFileRequest.getOMKeyInfoIfExists(
+ omMetadataManager, volumeName, bucketName, keyName, 0,
+ ozoneManager.getDefaultReplicationConfig());
+
+ if (keyStatus == null) {
+ throw new OMException("Key not found. Key: " + keyName, ResultCodes.KEY_NOT_FOUND);
+ }
+
+ boolean isDirectory = keyStatus.isDirectory();
+
+ if (isDirectory) {
+ throw new OMException("DeleteObjectTagging is not currently supported for FSO directory",
+ ResultCodes.NOT_SUPPORTED_OPERATION);
+ }
+
+ OmKeyInfo omKeyInfo = keyStatus.getKeyInfo();
+ final long volumeId = omMetadataManager.getVolumeId(volumeName);
+ final long bucketId = omMetadataManager.getBucketId(volumeName, bucketName);
+ final String dbKey = omMetadataManager.getOzonePathKey(volumeId, bucketId,
+ omKeyInfo.getParentObjectID(), omKeyInfo.getFileName());
+
+ // Clear / delete the tags
+ omKeyInfo.getTags().clear();
+ // Set the UpdateId to the current transactionLogIndex
+ omKeyInfo.setUpdateID(trxnLogIndex, ozoneManager.isRatisEnabled());
+
+ // Note: Key modification time is not changed because S3 last modified
+ // time only changes when there are changes in the object content
+
+ // Update table cache for file table. No need to check directory table since
+ // DeleteObjectTagging rejects operations on FSO directory
+ omMetadataManager.getKeyTable(getBucketLayout())
+ .addCacheEntry(new CacheKey<>(dbKey),
+ CacheValue.get(trxnLogIndex, omKeyInfo));
+
+ omClientResponse = new S3DeleteObjectTaggingResponseWithFSO(
+ omResponse.setDeleteObjectTaggingResponse(DeleteObjectTaggingResponse.newBuilder()).build(),
+ omKeyInfo, volumeId, bucketId
+ );
+
+ result = Result.SUCCESS;
+ } catch (IOException ex) {
+ result = Result.FAILURE;
+ exception = ex;
+ omClientResponse = new S3DeleteObjectTaggingResponseWithFSO(
+ createErrorOMResponse(omResponse, exception),
+ getBucketLayout()
+ );
+ } finally {
+ if (acquiredLock) {
+ mergeOmLockDetails(omMetadataManager.getLock()
+ .releaseWriteLock(BUCKET_LOCK, volumeName, bucketName));
+ }
+ if (omClientResponse != null) {
+ omClientResponse.setOmLockDetails(getOmLockDetails());
+ }
+ }
+
+ switch (result) {
+ case SUCCESS:
+ LOG.debug("Delete object tagging success. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName);
+ break;
+ case FAILURE:
+ omMetrics.incNumDeleteObjectTaggingFails();
+ LOG.error("Delete object tagging failed. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName, exception);
+ break;
+ default:
+ LOG.error("Unrecognized Result for S3DeleteObjectTaggingRequest: {}",
+ deleteObjectTaggingRequest);
+ }
+
+ return omClientResponse;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3PutObjectTaggingRequest.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3PutObjectTaggingRequest.java
new file mode 100644
index 0000000000..aab6783038
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3PutObjectTaggingRequest.java
@@ -0,0 +1,192 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import com.google.common.base.Preconditions;
+import org.apache.hadoop.hdds.utils.db.cache.CacheKey;
+import org.apache.hadoop.hdds.utils.db.cache.CacheValue;
+import org.apache.hadoop.ozone.audit.OMAction;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.OMMetrics;
+import org.apache.hadoop.ozone.om.OzoneManager;
+import org.apache.hadoop.ozone.om.exceptions.OMException;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.KeyValueUtil;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMClientRequestUtils;
+import org.apache.hadoop.ozone.om.request.key.OMKeyRequest;
+import org.apache.hadoop.ozone.om.request.util.OmResponseUtil;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.s3.tagging.S3PutObjectTaggingResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.KeyArgs;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PutObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PutObjectTaggingResponse;
+import org.apache.hadoop.ozone.security.acl.IAccessAuthorizer.ACLType;
+import org.apache.ratis.server.protocol.TermIndex;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.KEY_NOT_FOUND;
+import static org.apache.hadoop.ozone.om.lock.OzoneManagerLock.Resource.BUCKET_LOCK;
+
+/**
+ * Handles put object tagging request.
+ */
+public class S3PutObjectTaggingRequest extends OMKeyRequest {
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(S3PutObjectTaggingRequest.class);
+
+ public S3PutObjectTaggingRequest(OMRequest omRequest, BucketLayout bucketLayout) {
+ super(omRequest, bucketLayout);
+ }
+
+ @Override
+ public OMRequest preExecute(OzoneManager ozoneManager) throws IOException {
+ PutObjectTaggingRequest putObjectTaggingRequest =
+ super.preExecute(ozoneManager).getPutObjectTaggingRequest();
+ Preconditions.checkNotNull(putObjectTaggingRequest);
+
+ KeyArgs keyArgs = putObjectTaggingRequest.getKeyArgs();
+
+ String keyPath = keyArgs.getKeyName();
+ keyPath = validateAndNormalizeKey(ozoneManager.getEnableFileSystemPaths(),
+ keyPath, getBucketLayout());
+
+ KeyArgs.Builder newKeyArgs =
+ keyArgs.toBuilder()
+ .setKeyName(keyPath);
+
+ KeyArgs resolvedArgs = resolveBucketAndCheckKeyAcls(newKeyArgs.build(),
+ ozoneManager, ACLType.WRITE);
+ return getOmRequest().toBuilder()
+ .setUserInfo(getUserInfo())
+ .setPutObjectTaggingRequest(
+ putObjectTaggingRequest.toBuilder().setKeyArgs(resolvedArgs))
+ .build();
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager, TermIndex termIndex) {
+ final long trxnLogIndex = termIndex.getIndex();
+
+ PutObjectTaggingRequest putObjectTaggingRequest = getOmRequest().getPutObjectTaggingRequest();
+
+ KeyArgs keyArgs = putObjectTaggingRequest.getKeyArgs();
+ String volumeName = keyArgs.getVolumeName();
+ String bucketName = keyArgs.getBucketName();
+ String keyName = keyArgs.getKeyName();
+
+ OMMetrics omMetrics = ozoneManager.getMetrics();
+ omMetrics.incNumPutObjectTagging();
+
+ Map<String, String> auditMap = buildKeyArgsAuditMap(keyArgs);
+
+ OMResponse.Builder omResponse = OmResponseUtil.getOMResponseBuilder(
+ getOmRequest());
+
+ OMMetadataManager omMetadataManager = ozoneManager.getMetadataManager();
+ boolean acquiredLock = false;
+ OMClientResponse omClientResponse = null;
+ IOException exception = null;
+ Result result = null;
+ try {
+ mergeOmLockDetails(
+ omMetadataManager.getLock()
+ .acquireWriteLock(BUCKET_LOCK, volumeName, bucketName)
+ );
+ acquiredLock = getOmLockDetails().isLockAcquired();
+
+ validateBucketAndVolume(omMetadataManager, volumeName, bucketName);
+
+ String dbOzoneKey =
+ omMetadataManager.getOzoneKey(volumeName, bucketName, keyName);
+
+ OmKeyInfo omKeyInfo =
+ omMetadataManager.getKeyTable(getBucketLayout()).get(dbOzoneKey);
+ if (omKeyInfo == null) {
+ throw new OMException("Key not found", KEY_NOT_FOUND);
+ }
+
+ // Set the tags
+ omKeyInfo.getTags().clear();
+ omKeyInfo.getTags().putAll(KeyValueUtil.getFromProtobuf(keyArgs.getTagsList()));
+ // Set the UpdateID to the current transactionLogIndex
+ omKeyInfo.setUpdateID(trxnLogIndex, ozoneManager.isRatisEnabled());
+
+ // Note: Key modification time is not changed because S3 last modified
+ // time only changes when there are changes in the object content
+
+ // Update table cache
+ omMetadataManager.getKeyTable(getBucketLayout()).addCacheEntry(
+ new CacheKey<>(dbOzoneKey),
+ CacheValue.get(trxnLogIndex, omKeyInfo)
+ );
+
+ omClientResponse = new S3PutObjectTaggingResponse(
+ omResponse.setPutObjectTaggingResponse(PutObjectTaggingResponse.newBuilder()).build(),
+ omKeyInfo
+ );
+
+ result = Result.SUCCESS;
+ } catch (IOException ex) {
+ result = Result.FAILURE;
+ exception = ex;
+ omClientResponse = new S3PutObjectTaggingResponse(
+ createErrorOMResponse(omResponse, exception),
+ getBucketLayout()
+ );
+ } finally {
+ if (acquiredLock) {
+ mergeOmLockDetails(omMetadataManager.getLock()
+ .releaseWriteLock(BUCKET_LOCK, volumeName, bucketName));
+ }
+ if (omClientResponse != null) {
+ omClientResponse.setOmLockDetails(getOmLockDetails());
+ }
+ }
+
+ markForAudit(ozoneManager.getAuditLogger(), buildAuditMessage(
+ OMAction.PUT_OBJECT_TAGGING, auditMap, exception, getOmRequest().getUserInfo()
+ ));
+
+ switch (result) {
+ case SUCCESS:
+ LOG.debug("Put object tagging success. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName);
+ break;
+ case FAILURE:
+ omMetrics.incNumPutObjectTaggingFails();
+ if (OMClientRequestUtils.shouldLogClientRequestFailure(exception)) {
+ LOG.error("Put object tagging failed. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName, exception);
+ }
+ break;
+ default:
+ LOG.error("Unrecognized Result for S3PutObjectTaggingRequest: {}",
+ putObjectTaggingRequest);
+ }
+
+ return omClientResponse;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3PutObjectTaggingRequestWithFSO.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3PutObjectTaggingRequestWithFSO.java
new file mode 100644
index 0000000000..2b6ca8601c
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/S3PutObjectTaggingRequestWithFSO.java
@@ -0,0 +1,171 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import org.apache.hadoop.hdds.utils.db.cache.CacheKey;
+import org.apache.hadoop.hdds.utils.db.cache.CacheValue;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.OMMetrics;
+import org.apache.hadoop.ozone.om.OzoneManager;
+import org.apache.hadoop.ozone.om.exceptions.OMException;
+import org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.KeyValueUtil;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.helpers.OzoneFileStatus;
+import org.apache.hadoop.ozone.om.request.file.OMFileRequest;
+import org.apache.hadoop.ozone.om.request.util.OmResponseUtil;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.s3.tagging.S3PutObjectTaggingResponseWithFSO;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.KeyArgs;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PutObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PutObjectTaggingResponse;
+import org.apache.ratis.server.protocol.TermIndex;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.apache.hadoop.ozone.om.lock.OzoneManagerLock.Resource.BUCKET_LOCK;
+
+/**
+ * Handles put object tagging request for FSO bucket.
+ */
+public class S3PutObjectTaggingRequestWithFSO extends S3PutObjectTaggingRequest {
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(S3PutObjectTaggingRequestWithFSO.class);
+
+ public S3PutObjectTaggingRequestWithFSO(OMRequest omRequest,
+ BucketLayout bucketLayout) {
+ super(omRequest, bucketLayout);
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager, TermIndex termIndex) {
+ final long trxnLogIndex = termIndex.getIndex();
+
+ PutObjectTaggingRequest putObjectTaggingRequest = getOmRequest().getPutObjectTaggingRequest();
+
+ KeyArgs keyArgs = putObjectTaggingRequest.getKeyArgs();
+ String volumeName = keyArgs.getVolumeName();
+ String bucketName = keyArgs.getBucketName();
+ String keyName = keyArgs.getKeyName();
+
+ OMMetrics omMetrics = ozoneManager.getMetrics();
+ omMetrics.incNumPutObjectTagging();
+
+ Map<String, String> auditMap = buildKeyArgsAuditMap(keyArgs);
+
+ OMResponse.Builder omResponse = OmResponseUtil.getOMResponseBuilder(
+ getOmRequest());
+
+ OMMetadataManager omMetadataManager = ozoneManager.getMetadataManager();
+ boolean acquiredLock = false;
+ OMClientResponse omClientResponse = null;
+ IOException exception = null;
+ Result result = null;
+ try {
+ mergeOmLockDetails(
+ omMetadataManager.getLock()
+ .acquireWriteLock(BUCKET_LOCK, volumeName, bucketName)
+ );
+ acquiredLock = getOmLockDetails().isLockAcquired();
+
+ validateBucketAndVolume(omMetadataManager, volumeName, bucketName);
+
+ OzoneFileStatus keyStatus = OMFileRequest.getOMKeyInfoIfExists(
+ omMetadataManager, volumeName, bucketName, keyName, 0,
+ ozoneManager.getDefaultReplicationConfig());
+
+ if (keyStatus == null) {
+ throw new OMException("Key not found. Key: " + keyName, ResultCodes.KEY_NOT_FOUND);
+ }
+
+ boolean isDirectory = keyStatus.isDirectory();
+
+ if (isDirectory) {
+ throw new OMException("PutObjectTagging is not currently supported for FSO directory",
+ ResultCodes.NOT_SUPPORTED_OPERATION);
+ }
+
+ OmKeyInfo omKeyInfo = keyStatus.getKeyInfo();
+ final long volumeId = omMetadataManager.getVolumeId(volumeName);
+ final long bucketId = omMetadataManager.getBucketId(volumeName, bucketName);
+ final String dbKey = omMetadataManager.getOzonePathKey(volumeId, bucketId,
+ omKeyInfo.getParentObjectID(), omKeyInfo.getFileName());
+
+ // Set the tags
+ omKeyInfo.getTags().clear();
+ omKeyInfo.getTags().putAll(KeyValueUtil.getFromProtobuf(keyArgs.getTagsList()));
+ // Set the UpdateId to the current transactionLogIndex
+ omKeyInfo.setUpdateID(trxnLogIndex, ozoneManager.isRatisEnabled());
+
+ // Note: Key modification time is not changed because S3 last modified
+ // time only changes when there are changes in the object content
+
+ // Update table cache for file table. No need to check directory table since
+ // PutObjectTagging rejects operations on FSO directory
+ omMetadataManager.getKeyTable(getBucketLayout())
+ .addCacheEntry(new CacheKey<>(dbKey),
+ CacheValue.get(trxnLogIndex, omKeyInfo));
+
+ omClientResponse = new S3PutObjectTaggingResponseWithFSO(
+ omResponse.setPutObjectTaggingResponse(PutObjectTaggingResponse.newBuilder()).build(),
+ omKeyInfo, volumeId, bucketId
+ );
+
+ result = Result.SUCCESS;
+ } catch (IOException ex) {
+ result = Result.FAILURE;
+ exception = ex;
+ omClientResponse = new S3PutObjectTaggingResponseWithFSO(
+ createErrorOMResponse(omResponse, exception),
+ getBucketLayout()
+ );
+ } finally {
+ if (acquiredLock) {
+ mergeOmLockDetails(omMetadataManager.getLock()
+ .releaseWriteLock(BUCKET_LOCK, volumeName, bucketName));
+ }
+ if (omClientResponse != null) {
+ omClientResponse.setOmLockDetails(getOmLockDetails());
+ }
+ }
+
+ switch (result) {
+ case SUCCESS:
+ LOG.debug("Put object tagging success. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName);
+ break;
+ case FAILURE:
+ omMetrics.incNumPutObjectTaggingFails();
+ LOG.error("Put object tagging failed. Volume:{}, Bucket:{}, Key:{}.", volumeName,
+ bucketName, keyName, exception);
+ break;
+ default:
+ LOG.error("Unrecognized Result for S3PutObjectTaggingRequest: {}",
+ putObjectTaggingRequest);
+ }
+
+ return omClientResponse;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/package-info.java
similarity index 59%
copy from hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java
copy to hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/package-info.java
index 21b2e8b990..d3f26d195a 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/s3/tagging/package-info.java
@@ -1,4 +1,4 @@
-/**
+/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with this
* work for additional information regarding copyright ownership. The ASF
@@ -9,41 +9,13 @@
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,WITHOUT
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
-package org.apache.hadoop.ozone.om;
-
/**
- * Interface OM Metadata Reading metrics classes.
+ * Package contains classes related to S3 tagging requests.
*/
-public interface OmMetadataReaderMetrics {
- void incNumKeyLookups();
-
- void incNumKeyLookupFails();
-
- void incNumGetKeyInfo();
-
- void incNumGetKeyInfoFails();
-
- void incNumListStatus();
-
- void incNumListStatusFails();
-
- void incNumGetFileStatus();
-
- void incNumGetFileStatusFails();
-
- void incNumLookupFile();
-
- void incNumLookupFileFails();
-
- void incNumKeyLists();
-
- void incNumKeyListFails();
-
- void incNumGetAcl();
-}
+package org.apache.hadoop.ozone.om.request.s3.tagging;
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3DeleteObjectTaggingResponse.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3DeleteObjectTaggingResponse.java
new file mode 100644
index 0000000000..10181c9468
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3DeleteObjectTaggingResponse.java
@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import jakarta.annotation.Nonnull;
+import org.apache.hadoop.hdds.utils.db.BatchOperation;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.response.CleanupTableInfo;
+import org.apache.hadoop.ozone.om.response.key.OmKeyResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+
+import java.io.IOException;
+
+import static org.apache.hadoop.ozone.om.OmMetadataManagerImpl.KEY_TABLE;
+
+/**
+ * Response for delete object tagging request.
+ */
+@CleanupTableInfo(cleanupTables = {KEY_TABLE})
+public class S3DeleteObjectTaggingResponse extends OmKeyResponse {
+
+ private OmKeyInfo omKeyInfo;
+
+ public S3DeleteObjectTaggingResponse(@Nonnull OMResponse omResponse,
+ @Nonnull OmKeyInfo omKeyInfo) {
+ super(omResponse);
+ this.omKeyInfo = omKeyInfo;
+ }
+
+ /**
+ * For when the request is not successful.
+ * For a successful request, the other constructor should be used.
+ */
+ public S3DeleteObjectTaggingResponse(@Nonnull OMResponse omResponse,
+ @Nonnull BucketLayout bucketLayout) {
+ super(omResponse, bucketLayout);
+ checkStatusNotOK();
+ }
+
+ @Override
+ protected void addToDBBatch(OMMetadataManager omMetadataManager,
+ BatchOperation batchOperation) throws IOException {
+ omMetadataManager.getKeyTable(getBucketLayout()).putWithBatch(batchOperation,
+ omMetadataManager.getOzoneKey(
+ omKeyInfo.getVolumeName(),
+ omKeyInfo.getBucketName(),
+ omKeyInfo.getKeyName()),
+ omKeyInfo
+ );
+ }
+
+ protected OmKeyInfo getOmKeyInfo() {
+ return omKeyInfo;
+ }
+
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3DeleteObjectTaggingResponseWithFSO.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3DeleteObjectTaggingResponseWithFSO.java
new file mode 100644
index 0000000000..bb42668ad0
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3DeleteObjectTaggingResponseWithFSO.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import jakarta.annotation.Nonnull;
+import org.apache.hadoop.hdds.utils.db.BatchOperation;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.response.CleanupTableInfo;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+
+import java.io.IOException;
+
+import static org.apache.hadoop.ozone.om.OmMetadataManagerImpl.FILE_TABLE;
+
+/**
+ * Response for delete object tagging request for FSO bucket.
+ */
+@CleanupTableInfo(cleanupTables = {FILE_TABLE})
+public class S3DeleteObjectTaggingResponseWithFSO extends S3DeleteObjectTaggingResponse {
+
+ private long volumeId;
+ private long bucketId;
+
+ public S3DeleteObjectTaggingResponseWithFSO(@Nonnull OMResponse omResponse,
+ @Nonnull OmKeyInfo omKeyInfo,
+ @Nonnull long volumeId,
+ @Nonnull long bucketId) {
+ super(omResponse, omKeyInfo);
+ this.volumeId = volumeId;
+ this.bucketId = bucketId;
+ }
+
+ /**
+ * For when the request is not successful.
+ * For a successful request, the other constructor should be used.
+ */
+ public S3DeleteObjectTaggingResponseWithFSO(@Nonnull OMResponse omResponse,
+ @Nonnull BucketLayout bucketLayout) {
+ super(omResponse, bucketLayout);
+ }
+
+ @Override
+ protected void addToDBBatch(OMMetadataManager omMetadataManager,
+ BatchOperation batchOperation) throws IOException {
+ String ozoneDbKey = omMetadataManager.getOzonePathKey(volumeId, bucketId,
+ getOmKeyInfo().getParentObjectID(), getOmKeyInfo().getFileName());
+ omMetadataManager.getKeyTable(getBucketLayout())
+ .putWithBatch(batchOperation, ozoneDbKey, getOmKeyInfo());
+ }
+
+ @Override
+ public BucketLayout getBucketLayout() {
+ return BucketLayout.FILE_SYSTEM_OPTIMIZED;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3PutObjectTaggingResponse.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3PutObjectTaggingResponse.java
new file mode 100644
index 0000000000..2acefe2ec6
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3PutObjectTaggingResponse.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import jakarta.annotation.Nonnull;
+import org.apache.hadoop.hdds.utils.db.BatchOperation;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.response.CleanupTableInfo;
+import org.apache.hadoop.ozone.om.response.key.OmKeyResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+
+import java.io.IOException;
+
+import static org.apache.hadoop.ozone.om.OmMetadataManagerImpl.KEY_TABLE;
+
+/**
+ * Response for put object tagging request.
+ */
+@CleanupTableInfo(cleanupTables = {KEY_TABLE})
+public class S3PutObjectTaggingResponse extends OmKeyResponse {
+
+ private OmKeyInfo omKeyInfo;
+
+ public S3PutObjectTaggingResponse(@Nonnull OMResponse omResponse,
+ @Nonnull OmKeyInfo omKeyinfo) {
+ super(omResponse);
+ this.omKeyInfo = omKeyinfo;
+ }
+
+ /**
+ * For when the request is not successful.
+ * For a successful request, the other constructor should be used.
+ */
+ public S3PutObjectTaggingResponse(@Nonnull OMResponse omResponse,
+ @Nonnull BucketLayout bucketLayout) {
+ super(omResponse, bucketLayout);
+ checkStatusNotOK();
+ }
+
+ @Override
+ protected void addToDBBatch(OMMetadataManager omMetadataManager,
+ BatchOperation batchOperation) throws IOException {
+ omMetadataManager.getKeyTable(getBucketLayout()).putWithBatch(batchOperation,
+ omMetadataManager.getOzoneKey(
+ omKeyInfo.getVolumeName(),
+ omKeyInfo.getBucketName(),
+ omKeyInfo.getKeyName()),
+ omKeyInfo
+ );
+ }
+
+ protected OmKeyInfo getOmKeyInfo() {
+ return omKeyInfo;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3PutObjectTaggingResponseWithFSO.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3PutObjectTaggingResponseWithFSO.java
new file mode 100644
index 0000000000..6152fbabe8
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/S3PutObjectTaggingResponseWithFSO.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import jakarta.annotation.Nonnull;
+import org.apache.hadoop.hdds.utils.db.BatchOperation;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.response.CleanupTableInfo;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+
+import java.io.IOException;
+
+import static org.apache.hadoop.ozone.om.OmMetadataManagerImpl.FILE_TABLE;
+
+/**
+ * Response for put object tagging request for FSO bucket.
+ */
+@CleanupTableInfo(cleanupTables = {FILE_TABLE})
+public class S3PutObjectTaggingResponseWithFSO extends S3PutObjectTaggingResponse {
+
+ private long volumeId;
+ private long bucketId;
+
+ public S3PutObjectTaggingResponseWithFSO(@Nonnull OMResponse omResponse,
+ @Nonnull OmKeyInfo omKeyInfo,
+ @Nonnull long volumeId,
+ @Nonnull long bucketId) {
+ super(omResponse, omKeyInfo);
+ this.volumeId = volumeId;
+ this.bucketId = bucketId;
+ }
+
+ /**
+ * For when the request is not successful.
+ * For a successful request, the other constructor should be used.
+ */
+ public S3PutObjectTaggingResponseWithFSO(@Nonnull OMResponse omResponse,
+ @Nonnull BucketLayout bucketLayout) {
+ super(omResponse, bucketLayout);
+ }
+
+ @Override
+ protected void addToDBBatch(OMMetadataManager omMetadataManager,
+ BatchOperation batchOperation) throws IOException {
+ String ozoneDbKey = omMetadataManager.getOzonePathKey(volumeId, bucketId,
+ getOmKeyInfo().getParentObjectID(), getOmKeyInfo().getFileName());
+ omMetadataManager.getKeyTable(getBucketLayout())
+ .putWithBatch(batchOperation, ozoneDbKey, getOmKeyInfo());
+ }
+
+ @Override
+ public BucketLayout getBucketLayout() {
+ return BucketLayout.FILE_SYSTEM_OPTIMIZED;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/package-info.java
similarity index 59%
copy from hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java
copy to hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/package-info.java
index 21b2e8b990..9a104c4663 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataReaderMetrics.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/s3/tagging/package-info.java
@@ -1,4 +1,4 @@
-/**
+/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with this
* work for additional information regarding copyright ownership. The ASF
@@ -9,41 +9,13 @@
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,WITHOUT
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
-package org.apache.hadoop.ozone.om;
-
/**
- * Interface OM Metadata Reading metrics classes.
+ * Package contains classes related to S3 tagging responses.
*/
-public interface OmMetadataReaderMetrics {
- void incNumKeyLookups();
-
- void incNumKeyLookupFails();
-
- void incNumGetKeyInfo();
-
- void incNumGetKeyInfoFails();
-
- void incNumListStatus();
-
- void incNumListStatusFails();
-
- void incNumGetFileStatus();
-
- void incNumGetFileStatusFails();
-
- void incNumLookupFile();
-
- void incNumLookupFileFails();
-
- void incNumKeyLists();
-
- void incNumKeyListFails();
-
- void incNumGetAcl();
-}
+package org.apache.hadoop.ozone.om.response.s3.tagging;
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/protocolPB/OzoneManagerRequestHandler.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/protocolPB/OzoneManagerRequestHandler.java
index 5682b040e8..594b862bd1 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/protocolPB/OzoneManagerRequestHandler.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/protocolPB/OzoneManagerRequestHandler.java
@@ -21,6 +21,7 @@ import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.stream.Collectors;
@@ -42,6 +43,9 @@ import org.apache.hadoop.hdds.scm.protocolPB.OzonePBHelper;
import org.apache.hadoop.hdds.utils.FaultInjector;
import org.apache.hadoop.ozone.OzoneAcl;
import org.apache.hadoop.ozone.om.helpers.OMAuditLogger;
+import org.apache.hadoop.ozone.om.helpers.KeyValueUtil;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.GetObjectTaggingResponse;
import org.apache.hadoop.ozone.util.PayloadUtils;
import org.apache.hadoop.ozone.om.OzoneManager;
import org.apache.hadoop.ozone.om.OzoneManagerPrepareState;
@@ -385,6 +389,11 @@ public class OzoneManagerRequestHandler implements RequestHandler {
startQuotaRepair(request.getStartQuotaRepairRequest());
responseBuilder.setStartQuotaRepairResponse(startQuotaRepairRsp);
break;
+ case GetObjectTagging:
+ OzoneManagerProtocolProtos.GetObjectTaggingResponse getObjectTaggingResponse =
+ getObjectTagging(request.getGetObjectTaggingRequest());
+ responseBuilder.setGetObjectTaggingResponse(getObjectTaggingResponse);
+ break;
default:
responseBuilder.setSuccess(false);
responseBuilder.setMessage("Unrecognized Command Type: " + cmdType);
@@ -1508,6 +1517,24 @@ public class OzoneManagerRequestHandler implements RequestHandler {
.build();
}
+ private GetObjectTaggingResponse getObjectTagging(GetObjectTaggingRequest request)
+ throws IOException {
+ KeyArgs keyArgs = request.getKeyArgs();
+ OmKeyArgs omKeyArgs = new OmKeyArgs.Builder()
+ .setVolumeName(keyArgs.getVolumeName())
+ .setBucketName(keyArgs.getBucketName())
+ .setKeyName(keyArgs.getKeyName())
+ .build();
+
+ GetObjectTaggingResponse.Builder resp =
+ GetObjectTaggingResponse.newBuilder();
+
+ Map<String, String> result = impl.getObjectTagging(omKeyArgs);
+
+ resp.addAllTags(KeyValueUtil.toProtobuf(result));
+ return resp.build();
+ }
+
private SafeModeAction toSafeModeAction(
OzoneManagerProtocolProtos.SafeMode safeMode) {
switch (safeMode) {
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/TestBucketLayoutAwareOMKeyFactory.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/TestBucketLayoutAwareOMKeyFactory.java
index bb3e393005..c0f63e4d55 100644
--- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/TestBucketLayoutAwareOMKeyFactory.java
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/TestBucketLayoutAwareOMKeyFactory.java
@@ -110,9 +110,9 @@ public class TestBucketLayoutAwareOMKeyFactory {
LOG.info("Validated request class instantiation for cmdType " + k);
});
- assertEquals(13, omKeyReqsFSO.size());
- assertEquals(14, omKeyReqsLegacy.size());
- assertEquals(14, omKeyReqsOBS.size());
+ assertEquals(15, omKeyReqsFSO.size());
+ assertEquals(16, omKeyReqsLegacy.size());
+ assertEquals(16, omKeyReqsOBS.size());
// Check if the number of instantiated OMKeyRequest classes is equal to
// the number of keys in the mapping.
assertEquals(
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3DeleteObjectTaggingRequest.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3DeleteObjectTaggingRequest.java
new file mode 100644
index 0000000000..9c307d8567
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3DeleteObjectTaggingRequest.java
@@ -0,0 +1,202 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
+import org.apache.hadoop.ozone.OzoneConsts;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.om.request.key.TestOMKeyRequest;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.DeleteObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.KeyArgs;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.Type;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+/**
+ * Test delete object tagging request.
+ */
+public class TestS3DeleteObjectTaggingRequest extends TestOMKeyRequest {
+
+ @Test
+ public void testPreExecute() throws Exception {
+ doPreExecute(volumeName, bucketName, keyName);
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheSuccess() throws Exception {
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName, omMetadataManager, getBucketLayout());
+ Map<String, String> tags = getTags(5);
+ String ozoneKey = addKeyToTable(tags);
+
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotNull(omKeyInfo);
+ assertEquals(tags.size(), omKeyInfo.getTags().size());
+
+ OMRequest originalRequest = createDeleteObjectTaggingRequest(volumeName, bucketName, keyName);
+
+ S3DeleteObjectTaggingRequest request = getDeleteObjectTaggingRequest(originalRequest);
+
+ OMRequest modifiedRequest = request.preExecute(ozoneManager);
+
+ request = getDeleteObjectTaggingRequest(modifiedRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+ OMResponse omResponse = omClientResponse.getOMResponse();
+
+ assertNotNull(omResponse.getDeleteObjectTaggingResponse());
+ assertEquals(OzoneManagerProtocolProtos.Status.OK, omResponse.getStatus());
+ assertEquals(Type.DeleteObjectTagging, omResponse.getCmdType());
+
+ OmKeyInfo updatedKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotNull(updatedKeyInfo);
+ assertEquals(omKeyInfo.getVolumeName(), updatedKeyInfo.getVolumeName());
+ assertEquals(omKeyInfo.getBucketName(), updatedKeyInfo.getBucketName());
+ assertEquals(omKeyInfo.getKeyName(), updatedKeyInfo.getKeyName());
+ assertEquals(0, updatedKeyInfo.getTags().size());
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheVolumeNotFound() throws Exception {
+ OMRequest modifiedOmRequest =
+ doPreExecute(volumeName, bucketName, keyName);
+
+ S3DeleteObjectTaggingRequest request = getDeleteObjectTaggingRequest(modifiedOmRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+
+ assertEquals(OzoneManagerProtocolProtos.Status.VOLUME_NOT_FOUND,
+ omClientResponse.getOMResponse().getStatus());
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheBucketNotFound() throws Exception {
+ OMRequestTestUtils.addVolumeToDB(volumeName, OzoneConsts.OZONE, omMetadataManager);
+
+ OMRequest modifiedOmRequest =
+ doPreExecute(volumeName, bucketName, keyName);
+
+ S3DeleteObjectTaggingRequest request = getDeleteObjectTaggingRequest(modifiedOmRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+
+ assertEquals(OzoneManagerProtocolProtos.Status.BUCKET_NOT_FOUND,
+ omClientResponse.getOMResponse().getStatus());
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheKeyNotFound() throws Exception {
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName, omMetadataManager, getBucketLayout());
+
+ OMRequest modifiedOmRequest =
+ doPreExecute(volumeName, bucketName, keyName);
+
+ S3DeleteObjectTaggingRequest request = getDeleteObjectTaggingRequest(modifiedOmRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+
+ assertEquals(OzoneManagerProtocolProtos.Status.KEY_NOT_FOUND,
+ omClientResponse.getOMResponse().getStatus());
+ }
+
+ protected OMRequest doPreExecute(String volumeName, String bucketName,
+ String keyName) throws Exception {
+ OMRequest originalRequest = createDeleteObjectTaggingRequest(
+ volumeName, bucketName, keyName);
+
+ S3DeleteObjectTaggingRequest request = getDeleteObjectTaggingRequest(originalRequest);
+
+ OMRequest modifiedRequest = request.preExecute(ozoneManager);
+ verifyRequest(modifiedRequest, originalRequest);
+
+ return modifiedRequest;
+ }
+
+ public OMRequest createDeleteObjectTaggingRequest(String volumeName,
+ String bucketName,
+ String keyName) {
+ KeyArgs.Builder keyArgs = KeyArgs.newBuilder()
+ .setVolumeName(volumeName)
+ .setBucketName(bucketName)
+ .setKeyName(keyName);
+
+
+ DeleteObjectTaggingRequest deleteObjectTaggingRequest =
+ DeleteObjectTaggingRequest.newBuilder()
+ .setKeyArgs(keyArgs)
+ .build();
+
+ return OMRequest.newBuilder()
+ .setDeleteObjectTaggingRequest(deleteObjectTaggingRequest)
+ .setCmdType(Type.DeleteObjectTagging)
+ .setClientId(UUID.randomUUID().toString())
+ .build();
+ }
+
+ private void verifyRequest(OMRequest modifiedRequest, OMRequest originalRequest) {
+
+ KeyArgs original = originalRequest.getDeleteObjectTaggingRequest().getKeyArgs();
+
+ KeyArgs updated = modifiedRequest.getDeleteObjectTaggingRequest().getKeyArgs();
+
+ assertEquals(original.getVolumeName(), updated.getVolumeName());
+ assertEquals(original.getBucketName(), updated.getBucketName());
+ assertEquals(original.getKeyName(), updated.getKeyName());
+ assertEquals(original.getTagsList(), updated.getTagsList());
+ // Modification time will not be set for object tagging request
+ assertFalse(updated.hasModificationTime());
+ }
+
+ protected String addKeyToTable(Map<String, String> tags) throws Exception {
+ OmKeyInfo omKeyInfo = OMRequestTestUtils.createOmKeyInfo(volumeName, bucketName, keyName,
+ RatisReplicationConfig.getInstance(HddsProtos.ReplicationFactor.ONE))
+ .addAllTags(tags)
+ .build();
+ OMRequestTestUtils.addKeyToTable(false, false, omKeyInfo,
+ clientID, 1L, omMetadataManager);
+ return omMetadataManager.getOzoneKey(volumeName, bucketName, keyName);
+ }
+
+ protected S3DeleteObjectTaggingRequest getDeleteObjectTaggingRequest(OMRequest originalRequest) {
+ return new S3DeleteObjectTaggingRequest(originalRequest, getBucketLayout());
+ }
+
+ protected Map<String, String> getTags(int size) {
+ Map<String, String> tags = new HashMap<>();
+ for (int i = 0; i < size; i++) {
+ tags.put("tag-key-" + UUID.randomUUID(), "tag-value-" + UUID.randomUUID());
+ }
+ return tags;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3DeleteObjectTaggingRequestWithFSO.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3DeleteObjectTaggingRequestWithFSO.java
new file mode 100644
index 0000000000..ca3010a9b2
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3DeleteObjectTaggingRequestWithFSO.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+
+import java.util.Map;
+
+import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.ONE;
+
+/**
+ * Test delete object tagging request for FSO bucket.
+ */
+public class TestS3DeleteObjectTaggingRequestWithFSO extends TestS3DeleteObjectTaggingRequest {
+
+ private static final String PARENT_DIR = "c/d/e";
+ private static final String FILE_NAME = "file1";
+ private static final String FILE_KEY = PARENT_DIR + "/" + FILE_NAME;
+
+ @Override
+ protected String addKeyToTable(Map<String, String> tags) throws Exception {
+ keyName = FILE_KEY; // updated key name
+
+ // Create parent dirs for the path
+ long parentId = OMRequestTestUtils.addParentsToDirTable(volumeName,
+ bucketName, PARENT_DIR, omMetadataManager);
+
+ OmKeyInfo omKeyInfo =
+ OMRequestTestUtils.createOmKeyInfo(volumeName, bucketName, FILE_KEY, RatisReplicationConfig.getInstance(ONE))
+ .setObjectID(parentId + 1L)
+ .setParentObjectID(parentId)
+ .setUpdateID(1L)
+ .addAllTags(tags)
+ .build();
+ OMRequestTestUtils.addFileToKeyTable(false, false,
+ FILE_NAME, omKeyInfo, -1, 50, omMetadataManager);
+ final long volumeId = omMetadataManager.getVolumeId(
+ omKeyInfo.getVolumeName());
+ final long bucketId = omMetadataManager.getBucketId(
+ omKeyInfo.getVolumeName(), omKeyInfo.getBucketName());
+ return omMetadataManager.getOzonePathKey(
+ volumeId, bucketId, omKeyInfo.getParentObjectID(),
+ omKeyInfo.getFileName());
+ }
+
+ @Override
+ public BucketLayout getBucketLayout() {
+ return BucketLayout.FILE_SYSTEM_OPTIMIZED;
+ }
+
+ @Override
+ protected S3DeleteObjectTaggingRequest getDeleteObjectTaggingRequest(OMRequest originalRequest) {
+ return new S3DeleteObjectTaggingRequestWithFSO(originalRequest, getBucketLayout());
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3PutObjectTaggingRequest.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3PutObjectTaggingRequest.java
new file mode 100644
index 0000000000..c70c258733
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3PutObjectTaggingRequest.java
@@ -0,0 +1,254 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
+import org.apache.hadoop.ozone.OzoneConsts;
+import org.apache.hadoop.ozone.om.helpers.KeyValueUtil;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.om.request.key.TestOMKeyRequest;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.KeyArgs;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.PutObjectTaggingRequest;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.Type;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Test put object tagging request.
+ */
+public class TestS3PutObjectTaggingRequest extends TestOMKeyRequest {
+
+ @Test
+ public void testPreExecute() throws Exception {
+ Map<String, String> tags = new HashMap<>();
+ getTags(2);
+ doPreExecute(volumeName, bucketName, keyName, tags);
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheSuccess() throws Exception {
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName, omMetadataManager, getBucketLayout());
+ String ozoneKey = addKeyToTable();
+
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+
+ assertNotNull(omKeyInfo);
+ assertTrue(omKeyInfo.getTags().isEmpty());
+
+ Map<String, String> tags = getTags(5);
+
+ OMRequest originalRequest = createPutObjectTaggingRequest(volumeName, bucketName, keyName, tags);
+
+ S3PutObjectTaggingRequest request = getPutObjectTaggingRequest(originalRequest);
+
+ OMRequest modifiedRequest = request.preExecute(ozoneManager);
+
+ request = getPutObjectTaggingRequest(modifiedRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+ OMResponse omResponse = omClientResponse.getOMResponse();
+
+ assertNotNull(omResponse.getPutObjectTaggingResponse());
+ assertEquals(OzoneManagerProtocolProtos.Status.OK, omResponse.getStatus());
+ assertEquals(Type.PutObjectTagging, omResponse.getCmdType());
+
+ OmKeyInfo updatedKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotNull(updatedKeyInfo);
+ assertEquals(omKeyInfo.getVolumeName(), updatedKeyInfo.getVolumeName());
+ assertEquals(omKeyInfo.getBucketName(), updatedKeyInfo.getBucketName());
+ assertEquals(omKeyInfo.getKeyName(), updatedKeyInfo.getKeyName());
+ assertEquals(tags.size(), updatedKeyInfo.getTags().size());
+ for (Map.Entry<String, String> tag: tags.entrySet()) {
+ String value = updatedKeyInfo.getTags().get(tag.getKey());
+ assertNotNull(value);
+ assertEquals(tag.getValue(), value);
+ }
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheVolumeNotFound() throws Exception {
+ OMRequest modifiedOmRequest =
+ doPreExecute(volumeName, bucketName, keyName, getTags(2));
+
+ S3PutObjectTaggingRequest request = getPutObjectTaggingRequest(modifiedOmRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+
+ assertEquals(OzoneManagerProtocolProtos.Status.VOLUME_NOT_FOUND,
+ omClientResponse.getOMResponse().getStatus());
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheBucketNotFound() throws Exception {
+ OMRequestTestUtils.addVolumeToDB(volumeName, OzoneConsts.OZONE, omMetadataManager);
+
+ OMRequest modifiedOmRequest =
+ doPreExecute(volumeName, bucketName, keyName, getTags(2));
+
+ S3PutObjectTaggingRequest request = getPutObjectTaggingRequest(modifiedOmRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+
+ assertEquals(OzoneManagerProtocolProtos.Status.BUCKET_NOT_FOUND,
+ omClientResponse.getOMResponse().getStatus());
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheKeyNotFound() throws Exception {
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName, omMetadataManager, getBucketLayout());
+
+ OMRequest modifiedOmRequest =
+ doPreExecute(volumeName, bucketName, keyName, getTags(2));
+
+ S3PutObjectTaggingRequest request = getPutObjectTaggingRequest(modifiedOmRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+
+ assertEquals(OzoneManagerProtocolProtos.Status.KEY_NOT_FOUND,
+ omClientResponse.getOMResponse().getStatus());
+ }
+
+ @Test
+ public void testValidateAndUpdateCacheEmptyTagSet() throws Exception {
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName, omMetadataManager, getBucketLayout());
+ String ozoneKey = addKeyToTable();
+
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotNull(omKeyInfo);
+ assertTrue(omKeyInfo.getTags().isEmpty());
+
+ Map<String, String> tags = getTags(0);
+
+ OMRequest originalRequest = createPutObjectTaggingRequest(volumeName, bucketName, keyName, tags);
+
+ S3PutObjectTaggingRequest request = getPutObjectTaggingRequest(originalRequest);
+
+ OMRequest modifiedRequest = request.preExecute(ozoneManager);
+
+ request = getPutObjectTaggingRequest(modifiedRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 1L);
+ OMResponse omResponse = omClientResponse.getOMResponse();
+
+ assertNotNull(omResponse.getPutObjectTaggingResponse());
+ assertEquals(OzoneManagerProtocolProtos.Status.OK, omResponse.getStatus());
+ assertEquals(Type.PutObjectTagging, omResponse.getCmdType());
+
+ OmKeyInfo updatedKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertEquals(omKeyInfo.getVolumeName(), updatedKeyInfo.getVolumeName());
+ assertEquals(omKeyInfo.getBucketName(), updatedKeyInfo.getBucketName());
+ assertEquals(omKeyInfo.getKeyName(), updatedKeyInfo.getKeyName());
+ assertTrue(omKeyInfo.getTags().isEmpty());
+ assertEquals(tags.size(), updatedKeyInfo.getTags().size());
+ }
+
+
+ protected OMRequest doPreExecute(String volumeName,
+ String bucketName,
+ String keyName,
+ Map<String, String> tags) throws Exception {
+ OMRequest originalRequest = createPutObjectTaggingRequest(
+ volumeName, bucketName, keyName, tags);
+
+ S3PutObjectTaggingRequest request = getPutObjectTaggingRequest(originalRequest);
+
+ OMRequest modifiedRequest = request.preExecute(ozoneManager);
+ verifyRequest(modifiedRequest, originalRequest);
+
+ return modifiedRequest;
+ }
+
+ private OMRequest createPutObjectTaggingRequest(String volumeName,
+ String bucketName,
+ String keyName,
+ Map<String, String> tags) {
+ KeyArgs.Builder keyArgs = KeyArgs.newBuilder()
+ .setVolumeName(volumeName)
+ .setBucketName(bucketName)
+ .setKeyName(keyName);
+
+ if (tags != null && !tags.isEmpty()) {
+ keyArgs.addAllTags(KeyValueUtil.toProtobuf(tags));
+ }
+
+ PutObjectTaggingRequest putObjectTaggingRequest =
+ PutObjectTaggingRequest.newBuilder()
+ .setKeyArgs(keyArgs)
+ .build();
+
+ return OMRequest.newBuilder()
+ .setPutObjectTaggingRequest(putObjectTaggingRequest)
+ .setCmdType(Type.PutObjectTagging)
+ .setClientId(UUID.randomUUID().toString())
+ .build();
+ }
+
+ private void verifyRequest(OMRequest modifiedRequest, OMRequest originalRequest) {
+
+ KeyArgs original = originalRequest.getPutObjectTaggingRequest().getKeyArgs();
+
+ KeyArgs updated = modifiedRequest.getPutObjectTaggingRequest().getKeyArgs();
+
+ assertEquals(original.getVolumeName(), updated.getVolumeName());
+ assertEquals(original.getBucketName(), updated.getBucketName());
+ assertEquals(original.getKeyName(), updated.getKeyName());
+ assertEquals(original.getTagsList(), updated.getTagsList());
+ // Modification time will not be set for object tagging request
+ assertFalse(updated.hasModificationTime());
+ }
+
+ protected String addKeyToTable() throws Exception {
+ OMRequestTestUtils.addKeyToTable(false, false, volumeName, bucketName,
+ keyName, clientID, RatisReplicationConfig.getInstance(HddsProtos.ReplicationFactor.ONE), 1L,
+ omMetadataManager);
+
+ return omMetadataManager.getOzoneKey(volumeName, bucketName,
+ keyName);
+ }
+
+ protected S3PutObjectTaggingRequest getPutObjectTaggingRequest(OMRequest originalRequest) {
+ return new S3PutObjectTaggingRequest(originalRequest, getBucketLayout());
+ }
+
+ protected Map<String, String> getTags(int size) {
+ Map<String, String> tags = new HashMap<>();
+ for (int i = 0; i < size; i++) {
+ tags.put("tag-key-" + UUID.randomUUID(), "tag-value-" + UUID.randomUUID());
+ }
+ return tags;
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3PutObjectTaggingRequestWithFSO.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3PutObjectTaggingRequestWithFSO.java
new file mode 100644
index 0000000000..38ea5facad
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/s3/tagging/TestS3PutObjectTaggingRequestWithFSO.java
@@ -0,0 +1,95 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.request.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMRequest;
+import org.junit.jupiter.api.Test;
+
+import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.ONE;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Test put object tagging request for FSO bucket.
+ */
+public class TestS3PutObjectTaggingRequestWithFSO extends TestS3PutObjectTaggingRequest {
+
+ private static final String PARENT_DIR = "c/d/e";
+ private static final String FILE_NAME = "file1";
+ private static final String FILE_KEY = PARENT_DIR + "/" + FILE_NAME;
+
+ @Test
+ public void testValidateAndUpdateCachePutObjectTaggingToDir() throws Exception {
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName, omMetadataManager, getBucketLayout());
+
+ addKeyToTable();
+
+ OMRequest modifiedOmRequest =
+ doPreExecute(volumeName, bucketName, PARENT_DIR, getTags(2));
+
+ S3PutObjectTaggingRequest request = getPutObjectTaggingRequest(modifiedOmRequest);
+
+ OMClientResponse omClientResponse =
+ request.validateAndUpdateCache(ozoneManager, 2L);
+
+ assertEquals(OzoneManagerProtocolProtos.Status.NOT_SUPPORTED_OPERATION,
+ omClientResponse.getOMResponse().getStatus());
+ }
+
+ @Override
+ protected String addKeyToTable() throws Exception {
+ keyName = FILE_KEY; // updated key name
+
+ // Create parent dirs for the path
+ long parentId = OMRequestTestUtils.addParentsToDirTable(volumeName,
+ bucketName, PARENT_DIR, omMetadataManager);
+
+ OmKeyInfo omKeyInfo =
+ OMRequestTestUtils.createOmKeyInfo(volumeName, bucketName, FILE_KEY, RatisReplicationConfig.getInstance(ONE))
+ .setObjectID(parentId + 1L)
+ .setParentObjectID(parentId)
+ .setUpdateID(1L)
+ .build();
+ OMRequestTestUtils.addFileToKeyTable(false, false,
+ FILE_NAME, omKeyInfo, -1, 50, omMetadataManager);
+ final long volumeId = omMetadataManager.getVolumeId(
+ omKeyInfo.getVolumeName());
+ final long bucketId = omMetadataManager.getBucketId(
+ omKeyInfo.getVolumeName(), omKeyInfo.getBucketName());
+ return omMetadataManager.getOzonePathKey(
+ volumeId, bucketId, omKeyInfo.getParentObjectID(),
+ omKeyInfo.getFileName());
+ }
+
+ @Override
+ public BucketLayout getBucketLayout() {
+ return BucketLayout.FILE_SYSTEM_OPTIMIZED;
+ }
+
+ @Override
+ protected S3PutObjectTaggingRequest getPutObjectTaggingRequest(OMRequest originalRequest) {
+ return new S3PutObjectTaggingRequestWithFSO(originalRequest, getBucketLayout());
+ }
+
+
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3DeleteObjectTaggingResponse.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3DeleteObjectTaggingResponse.java
new file mode 100644
index 0000000000..26daacf6f2
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3DeleteObjectTaggingResponse.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.om.response.key.TestOMKeyResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+
+/**
+ * Test delete object tagging response.
+ */
+public class TestS3DeleteObjectTaggingResponse extends TestOMKeyResponse {
+
+ @Test
+ public void testAddToBatch() throws Exception {
+ OzoneManagerProtocolProtos.OMResponse omResponse =
+ OzoneManagerProtocolProtos.OMResponse.newBuilder().setDeleteObjectTaggingResponse(
+ OzoneManagerProtocolProtos.DeleteObjectTaggingResponse.getDefaultInstance())
+ .setStatus(OzoneManagerProtocolProtos.Status.OK)
+ .setCmdType(OzoneManagerProtocolProtos.Type.DeleteObjectTagging)
+ .build();
+
+ Map<String, String> tags = new HashMap<>();
+ tags.put("tag-key1", "tag-value1");
+ tags.put("tag-key2", "tag-value2");
+
+ String ozoneKey = addKeyToTable(tags);
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotNull(omKeyInfo);
+ assertEquals(2, omKeyInfo.getTags().size());
+
+ omKeyInfo.getTags().clear();
+
+ S3DeleteObjectTaggingResponse deleteObjectTaggingResponse = getDeleteObjectTaggingResponse(omKeyInfo, omResponse);
+
+ deleteObjectTaggingResponse.addToDBBatch(omMetadataManager, batchOperation);
+
+ // Do manual commit and see whether addToBatch is successful or not.
+ omMetadataManager.getStore().commitBatchOperation(batchOperation);
+
+ OmKeyInfo updatedOmKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotSame(omKeyInfo, updatedOmKeyInfo);
+ assertNotNull(updatedOmKeyInfo);
+ assertEquals(0, updatedOmKeyInfo.getTags().size());
+ }
+
+ protected String addKeyToTable(Map<String, String> tags) throws Exception {
+ OmKeyInfo omKeyInfo = OMRequestTestUtils.createOmKeyInfo(volumeName, bucketName, keyName,
+ RatisReplicationConfig.getInstance(HddsProtos.ReplicationFactor.ONE))
+ .addAllTags(tags)
+ .build();
+ OMRequestTestUtils.addKeyToTable(false, false, omKeyInfo,
+ clientID, 1L, omMetadataManager);
+ return omMetadataManager.getOzoneKey(volumeName, bucketName, keyName);
+ }
+
+ protected S3DeleteObjectTaggingResponse getDeleteObjectTaggingResponse(OmKeyInfo omKeyInfo,
+ OzoneManagerProtocolProtos.OMResponse omResponse)
+ throws IOException {
+ return new S3DeleteObjectTaggingResponse(omResponse, omKeyInfo);
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3DeleteObjectTaggingResponseWithFSO.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3DeleteObjectTaggingResponseWithFSO.java
new file mode 100644
index 0000000000..923ff441e9
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3DeleteObjectTaggingResponseWithFSO.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.ONE;
+
+/**
+ * Test delete object tagging response for FSO bucket.
+ */
+public class TestS3DeleteObjectTaggingResponseWithFSO extends TestS3DeleteObjectTaggingResponse {
+
+ @Override
+ public BucketLayout getBucketLayout() {
+ return BucketLayout.FILE_SYSTEM_OPTIMIZED;
+ }
+
+ @Override
+ protected String addKeyToTable(Map<String, String> tags) throws Exception {
+ // Add volume, bucket and key entries to OM DB.
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName,
+ omMetadataManager);
+
+ // Create parent dirs for the path
+ long parentId = OMRequestTestUtils.addParentsToDirTable(volumeName,
+ bucketName, "", omMetadataManager);
+
+ OmKeyInfo omKeyInfo =
+ OMRequestTestUtils.createOmKeyInfo(volumeName, bucketName, keyName, RatisReplicationConfig.getInstance(ONE))
+ .setObjectID(parentId + 1)
+ .setParentObjectID(parentId)
+ .setUpdateID(1L)
+ .addAllTags(tags)
+ .build();
+ OMRequestTestUtils.addFileToKeyTable(false, false,
+ keyName, omKeyInfo, -1, 50, omMetadataManager);
+ return omMetadataManager.getOzonePathKey(
+ omMetadataManager.getVolumeId(volumeName),
+ omMetadataManager.getBucketId(volumeName, bucketName),
+ omKeyInfo.getParentObjectID(), keyName);
+ }
+
+ @Override
+ protected S3DeleteObjectTaggingResponse getDeleteObjectTaggingResponse(OmKeyInfo omKeyInfo,
+ OzoneManagerProtocolProtos.OMResponse omResponse)
+ throws IOException {
+ return new S3DeleteObjectTaggingResponseWithFSO(omResponse, omKeyInfo,
+ omMetadataManager.getVolumeId(volumeName), omBucketInfo.getObjectID());
+ }
+
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3PutObjectTaggingResponse.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3PutObjectTaggingResponse.java
new file mode 100644
index 0000000000..af6565a447
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3PutObjectTaggingResponse.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.om.response.key.TestOMKeyResponse;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+
+/**
+ * Test put object tagging response.
+ */
+public class TestS3PutObjectTaggingResponse extends TestOMKeyResponse {
+
+ @Test
+ public void testAddToDBBatch() throws Exception {
+ OzoneManagerProtocolProtos.OMResponse omResponse =
+ OzoneManagerProtocolProtos.OMResponse.newBuilder().setPutObjectTaggingResponse(
+ OzoneManagerProtocolProtos.PutObjectTaggingResponse.getDefaultInstance())
+ .setStatus(OzoneManagerProtocolProtos.Status.OK)
+ .setCmdType(OzoneManagerProtocolProtos.Type.PutObjectTagging)
+ .build();
+
+ String ozoneKey = addKeyToTable();
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotNull(omKeyInfo);
+ assertEquals(0, omKeyInfo.getTags().size());
+
+ Map<String, String> tags = new HashMap<>();
+ tags.put("tag-key1", "tag-value1");
+ tags.put("tag-key2", "tag-value2");
+
+ omKeyInfo.setTags(tags);
+
+ S3PutObjectTaggingResponse putObjectTaggingResponse = getPutObjectTaggingResponse(omKeyInfo, omResponse);
+
+ putObjectTaggingResponse.addToDBBatch(omMetadataManager, batchOperation);
+
+ // Do manual commit and see whether addToBatch is successful or not.
+ omMetadataManager.getStore().commitBatchOperation(batchOperation);
+
+ OmKeyInfo updatedOmKeyInfo = omMetadataManager.getKeyTable(getBucketLayout()).get(ozoneKey);
+ assertNotSame(omKeyInfo, updatedOmKeyInfo);
+ assertNotNull(updatedOmKeyInfo);
+ assertEquals(tags.size(), updatedOmKeyInfo.getTags().size());
+ }
+
+ protected String addKeyToTable() throws Exception {
+ OMRequestTestUtils.addKeyToTable(false, false, volumeName, bucketName,
+ keyName, clientID, RatisReplicationConfig.getInstance(HddsProtos.ReplicationFactor.ONE),
+ omMetadataManager);
+
+ return omMetadataManager.getOzoneKey(volumeName, bucketName,
+ keyName);
+ }
+
+ protected S3PutObjectTaggingResponse getPutObjectTaggingResponse(OmKeyInfo omKeyInfo,
+ OzoneManagerProtocolProtos.OMResponse omResponse)
+ throws IOException {
+ return new S3PutObjectTaggingResponse(omResponse, omKeyInfo);
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3PutObjectTaggingResponseWithFSO.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3PutObjectTaggingResponseWithFSO.java
new file mode 100644
index 0000000000..1c93a52771
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/response/s3/tagging/TestS3PutObjectTaggingResponseWithFSO.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.om.response.s3.tagging;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.OMRequestTestUtils;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.OMResponse;
+
+import java.io.IOException;
+
+import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.ONE;
+
+/**
+ * Test put object tagging response for FSO bucket.
+ */
+public class TestS3PutObjectTaggingResponseWithFSO extends TestS3PutObjectTaggingResponse {
+
+ @Override
+ public BucketLayout getBucketLayout() {
+ return BucketLayout.FILE_SYSTEM_OPTIMIZED;
+ }
+
+ @Override
+ protected String addKeyToTable() throws Exception {
+ // Add volume, bucket and key entries to OM DB.
+ OMRequestTestUtils.addVolumeAndBucketToDB(volumeName, bucketName,
+ omMetadataManager);
+
+ // Create parent dirs for the path
+ long parentId = OMRequestTestUtils.addParentsToDirTable(volumeName,
+ bucketName, "", omMetadataManager);
+
+ OmKeyInfo omKeyInfo =
+ OMRequestTestUtils.createOmKeyInfo(volumeName, bucketName, keyName, RatisReplicationConfig.getInstance(ONE))
+ .setObjectID(parentId + 1)
+ .setParentObjectID(parentId)
+ .setUpdateID(1L)
+ .build();
+ OMRequestTestUtils.addFileToKeyTable(false, false,
+ keyName, omKeyInfo, -1, 50, omMetadataManager);
+ return omMetadataManager.getOzonePathKey(
+ omMetadataManager.getVolumeId(volumeName),
+ omMetadataManager.getBucketId(volumeName, bucketName),
+ omKeyInfo.getParentObjectID(), keyName);
+ }
+
+ @Override
+ protected S3PutObjectTaggingResponse getPutObjectTaggingResponse(OmKeyInfo omKeyInfo, OMResponse omResponse)
+ throws IOException {
+ return new S3PutObjectTaggingResponseWithFSO(omResponse, omKeyInfo,
+ omMetadataManager.getVolumeId(volumeName), omBucketInfo.getObjectID());
+ }
+}
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/audit/S3GAction.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/audit/S3GAction.java
index 20c2f4c627..8e3bcaf34a 100644
--- a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/audit/S3GAction.java
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/audit/S3GAction.java
@@ -48,7 +48,10 @@ public enum S3GAction implements AuditAction {
DELETE_KEY,
CREATE_DIRECTORY,
GENERATE_SECRET,
- REVOKE_SECRET;
+ REVOKE_SECRET,
+ GET_OBJECT_TAGGING,
+ PUT_OBJECT_TAGGING,
+ DELETE_OBJECT_TAGGING;
@Override
public String getAction() {
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/EndpointBase.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/EndpointBase.java
index 4ffc301193..fbb0614c4f 100644
--- a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/EndpointBase.java
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/EndpointBase.java
@@ -72,6 +72,7 @@ import static org.apache.hadoop.ozone.OzoneConsts.ETAG;
import static org.apache.hadoop.ozone.OzoneConsts.KB;
import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.INVALID_TAG;
import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.newError;
+import static org.apache.hadoop.ozone.s3.util.S3Consts.AWS_TAG_PREFIX;
import static org.apache.hadoop.ozone.s3.util.S3Consts.CUSTOM_METADATA_HEADER_PREFIX;
import static org.apache.hadoop.ozone.s3.util.S3Consts.TAG_HEADER;
import static org.apache.hadoop.ozone.s3.util.S3Consts.TAG_KEY_LENGTH_LIMIT;
@@ -363,59 +364,70 @@ public abstract class EndpointBase implements Auditor {
List<NameValuePair> tagPairs = URLEncodedUtils.parse(tagString, UTF_8);
- if (tagPairs.isEmpty()) {
- return Collections.emptyMap();
- }
+ return validateAndGetTagging(tagPairs, NameValuePair::getName, NameValuePair::getValue);
+ }
- Map<String, String> tags = new HashMap<>();
- // Tag restrictions: https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3Tag.html
- for (NameValuePair tagPair: tagPairs) {
- if (StringUtils.isEmpty(tagPair.getName())) {
- OS3Exception ex = newError(INVALID_TAG, TAG_HEADER);
- ex.setErrorMessage("Some tag keys are empty, please specify the non-empty tag keys");
+ protected static <KV> Map<String, String> validateAndGetTagging(
+ List<KV> tagList,
+ Function<KV, String> getTagKey,
+ Function<KV, String> getTagValue
+ ) throws OS3Exception {
+ final Map<String, String> tags = new HashMap<>();
+ for (KV tagPair : tagList) {
+ final String tagKey = getTagKey.apply(tagPair);
+ final String tagValue = getTagValue.apply(tagPair);
+ // Tag restrictions: https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_S3Tag.html
+ if (StringUtils.isEmpty(tagKey)) {
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, TAG_HEADER);
+ ex.setErrorMessage("Some tag keys are empty, please only specify non-empty tag keys");
throw ex;
}
- if (tagPair.getValue() == null) {
- // For example for query parameter with only value (e.g. "tag1")
- OS3Exception ex = newError(INVALID_TAG, tagPair.getName());
- ex.setErrorMessage("Some tag values are not specified, please specify the tag values");
+ if (StringUtils.startsWith(tagKey, AWS_TAG_PREFIX)) {
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, tagKey);
+ ex.setErrorMessage("Tag key cannot start with \"aws:\" prefix");
throw ex;
}
- if (tags.containsKey(tagPair.getName())) {
- // Tags that are associated with an object must have unique tag keys
- // Reject request if the same key is used twice on the same resource
- OS3Exception ex = newError(INVALID_TAG, tagPair.getName());
- ex.setErrorMessage("There are tags with duplicate tag keys, tag keys should be unique");
+ if (tagValue == null) {
+ // For example for query parameter with only value (e.g. "tag1")
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, tagKey);
+ ex.setErrorMessage("Some tag values are not specified, please specify the tag values");
throw ex;
}
- if (tagPair.getName().length() > TAG_KEY_LENGTH_LIMIT) {
- OS3Exception ex = newError(INVALID_TAG, tagPair.getName());
+ if (tagKey.length() > TAG_KEY_LENGTH_LIMIT) {
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, tagKey);
ex.setErrorMessage("The tag key exceeds the maximum length of " + TAG_KEY_LENGTH_LIMIT);
throw ex;
}
- if (tagPair.getValue().length() > TAG_VALUE_LENGTH_LIMIT) {
- OS3Exception ex = newError(INVALID_TAG, tagPair.getValue());
+ if (tagValue.length() > TAG_VALUE_LENGTH_LIMIT) {
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, tagValue);
ex.setErrorMessage("The tag value exceeds the maximum length of " + TAG_VALUE_LENGTH_LIMIT);
throw ex;
}
- if (!TAG_REGEX_PATTERN.matcher(tagPair.getName()).matches()) {
- OS3Exception ex = newError(INVALID_TAG, tagPair.getName());
+ if (!TAG_REGEX_PATTERN.matcher(tagKey).matches()) {
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, tagKey);
ex.setErrorMessage("The tag key does not have a valid pattern");
throw ex;
}
- if (!TAG_REGEX_PATTERN.matcher(tagPair.getValue()).matches()) {
- OS3Exception ex = newError(INVALID_TAG, tagPair.getValue());
+ if (!TAG_REGEX_PATTERN.matcher(tagValue).matches()) {
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, tagValue);
ex.setErrorMessage("The tag value does not have a valid pattern");
throw ex;
}
- tags.put(tagPair.getName(), tagPair.getValue());
+ final String previous = tags.put(tagKey, tagValue);
+ if (previous != null) {
+ // Tags that are associated with an object must have unique tag keys
+ // Reject request if the same key is used twice on the same resource
+ OS3Exception ex = S3ErrorTable.newError(INVALID_TAG, tagKey);
+ ex.setErrorMessage("There are tags with duplicate tag keys, tag keys should be unique");
+ throw ex;
+ }
}
if (tags.size() > TAG_NUM_LIMIT) {
@@ -426,7 +438,7 @@ public abstract class EndpointBase implements Auditor {
throw ex;
}
- return tags;
+ return Collections.unmodifiableMap(tags);
}
private AuditMessage.Builder auditMessageBaseBuilder(AuditAction op,
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java
index 9dbc7b9aab..21ad28254d 100644
--- a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java
@@ -68,6 +68,7 @@ import org.apache.hadoop.ozone.om.helpers.OmMultipartInfo;
import org.apache.hadoop.ozone.om.helpers.OmMultipartUploadCompleteInfo;
import org.apache.hadoop.ozone.s3.HeaderPreprocessor;
import org.apache.hadoop.ozone.s3.SignedChunksInputStream;
+import org.apache.hadoop.ozone.s3.endpoint.S3Tagging.Tag;
import org.apache.hadoop.ozone.s3.exception.OS3Exception;
import org.apache.hadoop.ozone.s3.exception.S3ErrorTable;
import org.apache.hadoop.ozone.s3.util.RFC1123Util;
@@ -212,7 +213,7 @@ public class ObjectEndpoint extends EndpointBase {
* See: https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html for
* more details.
*/
- @SuppressWarnings("checkstyle:MethodLength")
+ @SuppressWarnings({"checkstyle:MethodLength", "checkstyle:ParameterNumber"})
@PUT
public Response put(
@PathParam("bucket") String bucketName,
@@ -220,6 +221,7 @@ public class ObjectEndpoint extends EndpointBase {
@HeaderParam("Content-Length") long length,
@QueryParam("partNumber") int partNumber,
@QueryParam("uploadId") @DefaultValue("") String uploadID,
+ @QueryParam("tagging") String taggingMarker,
final InputStream body) throws IOException, OS3Exception {
long startNanos = Time.monotonicNowNanos();
S3GAction s3GAction = S3GAction.CREATE_KEY;
@@ -230,6 +232,11 @@ public class ObjectEndpoint extends EndpointBase {
DigestInputStream digestInputStream = null;
try {
OzoneVolume volume = getVolume();
+ if (taggingMarker != null) {
+ s3GAction = S3GAction.PUT_OBJECT_TAGGING;
+ return putObjectTagging(volume, bucketName, keyPath, body);
+ }
+
if (uploadID != null && !uploadID.equals("")) {
if (headers.getHeaderString(COPY_SOURCE_HEADER) == null) {
s3GAction = S3GAction.CREATE_MULTIPART_KEY;
@@ -336,7 +343,9 @@ public class ObjectEndpoint extends EndpointBase {
} catch (OMException ex) {
auditSuccess = false;
auditWriteFailure(s3GAction, ex);
- if (copyHeader != null) {
+ if (taggingMarker != null) {
+ getMetrics().updatePutObjectTaggingFailureStats(startNanos);
+ } else if (copyHeader != null) {
getMetrics().updateCopyObjectFailureStats(startNanos);
} else {
getMetrics().updateCreateKeyFailureStats(startNanos);
@@ -360,7 +369,9 @@ public class ObjectEndpoint extends EndpointBase {
} catch (Exception ex) {
auditSuccess = false;
auditWriteFailure(s3GAction, ex);
- if (copyHeader != null) {
+ if (taggingMarker != null) {
+ getMetrics().updatePutObjectTaggingFailureStats(startNanos);
+ } else if (copyHeader != null) {
getMetrics().updateCopyObjectFailureStats(startNanos);
} else {
getMetrics().updateCreateKeyFailureStats(startNanos);
@@ -390,7 +401,7 @@ public class ObjectEndpoint extends EndpointBase {
* https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html
* for more details.
*/
- @SuppressWarnings("checkstyle:MethodLength")
+ @SuppressWarnings({"checkstyle:MethodLength", "checkstyle:ParameterNumber"})
@GET
public Response get(
@PathParam("bucket") String bucketName,
@@ -398,12 +409,18 @@ public class ObjectEndpoint extends EndpointBase {
@QueryParam("partNumber") int partNumber,
@QueryParam("uploadId") String uploadId,
@QueryParam("max-parts") @DefaultValue("1000") int maxParts,
- @QueryParam("part-number-marker") String partNumberMarker)
+ @QueryParam("part-number-marker") String partNumberMarker,
+ @QueryParam("tagging") String taggingMarker)
throws IOException, OS3Exception {
long startNanos = Time.monotonicNowNanos();
S3GAction s3GAction = S3GAction.GET_KEY;
PerformanceStringBuilder perf = new PerformanceStringBuilder();
try {
+ if (taggingMarker != null) {
+ s3GAction = S3GAction.GET_OBJECT_TAGGING;
+ return getObjectTagging(bucketName, keyPath);
+ }
+
if (uploadId != null) {
// When we have uploadId, this is the request for list Parts.
s3GAction = S3GAction.LIST_PARTS;
@@ -532,7 +549,9 @@ public class ObjectEndpoint extends EndpointBase {
AUDIT.logReadFailure(
buildAuditMessageForFailure(s3GAction, getAuditParameters(), ex)
);
- if (uploadId != null) {
+ if (taggingMarker != null) {
+ getMetrics().updateGetObjectTaggingFailureStats(startNanos);
+ } else if (uploadId != null) {
getMetrics().updateListPartsFailureStats(startNanos);
} else {
getMetrics().updateGetKeyFailureStats(startNanos);
@@ -699,13 +718,19 @@ public class ObjectEndpoint extends EndpointBase {
public Response delete(
@PathParam("bucket") String bucketName,
@PathParam("path") String keyPath,
- @QueryParam("uploadId") @DefaultValue("") String uploadId) throws
+ @QueryParam("uploadId") @DefaultValue("") String uploadId,
+ @QueryParam("tagging") String taggingMarker) throws
IOException, OS3Exception {
long startNanos = Time.monotonicNowNanos();
S3GAction s3GAction = S3GAction.DELETE_KEY;
try {
OzoneVolume volume = getVolume();
+ if (taggingMarker != null) {
+ s3GAction = S3GAction.DELETE_OBJECT_TAGGING;
+ return deleteObjectTagging(volume, bucketName, keyPath);
+ }
+
if (uploadId != null && !uploadId.equals("")) {
s3GAction = S3GAction.ABORT_MULTIPART_UPLOAD;
return abortMultipartUpload(volume, bucketName, keyPath, uploadId);
@@ -732,13 +757,18 @@ public class ObjectEndpoint extends EndpointBase {
// keys. Just return 204
} else if (isAccessDenied(ex)) {
throw newError(S3ErrorTable.ACCESS_DENIED, keyPath, ex);
+ } else if (ex.getResult() == ResultCodes.NOT_SUPPORTED_OPERATION) {
+ // When deleteObjectTagging operation is applied on FSO directory
+ throw S3ErrorTable.newError(S3ErrorTable.NOT_IMPLEMENTED, keyPath);
} else {
throw ex;
}
} catch (Exception ex) {
AUDIT.logWriteFailure(
buildAuditMessageForFailure(s3GAction, getAuditParameters(), ex));
- if (uploadId != null && !uploadId.equals("")) {
+ if (taggingMarker != null) {
+ getMetrics().updateDeleteObjectTaggingFailureStats(startNanos);
+ } else if (uploadId != null && !uploadId.equals("")) {
getMetrics().updateAbortMultipartUploadFailureStats(startNanos);
} else {
getMetrics().updateDeleteKeyFailureStats(startNanos);
@@ -1381,6 +1411,75 @@ public class ObjectEndpoint extends EndpointBase {
(lastModificationTime <= copySourceIfUnmodifiedSince);
}
+ private Response putObjectTagging(OzoneVolume volume, String bucketName, String keyName, InputStream body)
+ throws IOException, OS3Exception {
+ long startNanos = Time.monotonicNowNanos();
+ S3Tagging tagging = null;
+ try {
+ tagging = new PutTaggingUnmarshaller().readFrom(body);
+ tagging.validate();
+ } catch (Exception ex) {
+ OS3Exception exception = S3ErrorTable.newError(S3ErrorTable.MALFORMED_XML, keyName);
+ exception.setErrorMessage(exception.getErrorMessage() + ". " + ex.getMessage());
+ throw exception;
+ }
+
+ Map<String, String> tags = validateAndGetTagging(
+ tagging.getTagSet().getTags(), // Nullity check was done in previous parsing step
+ Tag::getKey,
+ Tag::getValue
+ );
+
+ try {
+ volume.getBucket(bucketName).putObjectTagging(keyName, tags);
+ } catch (OMException ex) {
+ if (ex.getResult() == ResultCodes.INVALID_REQUEST) {
+ throw S3ErrorTable.newError(S3ErrorTable.INVALID_REQUEST, keyName);
+ } else if (ex.getResult() == ResultCodes.PERMISSION_DENIED) {
+ throw S3ErrorTable.newError(S3ErrorTable.ACCESS_DENIED, keyName);
+ } else if (ex.getResult() == ResultCodes.KEY_NOT_FOUND) {
+ throw S3ErrorTable.newError(S3ErrorTable.NO_SUCH_KEY, keyName);
+ } else if (ex.getResult() == ResultCodes.NOT_SUPPORTED_OPERATION) {
+ // When putObjectTagging operation is applied on FSO directory
+ throw S3ErrorTable.newError(S3ErrorTable.NOT_IMPLEMENTED, keyName);
+ }
+ throw ex;
+ }
+ getMetrics().updatePutObjectTaggingSuccessStats(startNanos);
+ return Response.ok().build();
+ }
+
+ private Response getObjectTagging(String bucketName, String keyName) throws IOException {
+ long startNanos = Time.monotonicNowNanos();
+
+ OzoneVolume volume = getVolume();
+
+ Map<String, String> tagMap = volume.getBucket(bucketName).getObjectTagging(keyName);
+
+ getMetrics().updateGetObjectTaggingSuccessStats(startNanos);
+ return Response.ok(S3Tagging.fromMap(tagMap), MediaType.APPLICATION_XML_TYPE).build();
+ }
+
+ private Response deleteObjectTagging(OzoneVolume volume, String bucketName, String keyName)
+ throws IOException, OS3Exception {
+ long startNanos = Time.monotonicNowNanos();
+
+ try {
+ volume.getBucket(bucketName).deleteObjectTagging(keyName);
+ } catch (OMException ex) {
+ // Unlike normal key deletion that ignores the key not found exception
+ // DeleteObjectTagging should throw the exception if the key does not exist
+ if (ex.getResult() == ResultCodes.KEY_NOT_FOUND) {
+ throw S3ErrorTable.newError(S3ErrorTable.NO_SUCH_KEY, keyName);
+ }
+ throw ex;
+ }
+
+ getMetrics().updateDeleteObjectTaggingSuccessStats(startNanos);
+ return Response.noContent().build();
+ }
+
+
@VisibleForTesting
public void setOzoneConfiguration(OzoneConfiguration config) {
this.ozoneConfiguration = config;
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/PutTaggingUnmarshaller.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/PutTaggingUnmarshaller.java
new file mode 100644
index 0000000000..eb5c8a1487
--- /dev/null
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/PutTaggingUnmarshaller.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.s3.endpoint;
+
+import org.xml.sax.InputSource;
+import org.xml.sax.XMLReader;
+
+import javax.ws.rs.WebApplicationException;
+import javax.xml.XMLConstants;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.UnmarshallerHandler;
+import javax.xml.parsers.SAXParserFactory;
+import java.io.InputStream;
+
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.INVALID_REQUEST;
+import static org.apache.hadoop.ozone.s3.util.S3Consts.S3_XML_NAMESPACE;
+import static org.apache.hadoop.ozone.s3.util.S3Utils.wrapOS3Exception;
+
+/**
+ * Custom unmarshaller to read Tagging request body.
+ */
+public class PutTaggingUnmarshaller {
+
+ private JAXBContext context;
+ private SAXParserFactory saxParserFactory;
+
+ public PutTaggingUnmarshaller() {
+ try {
+ context = JAXBContext.newInstance(S3Tagging.class);
+ saxParserFactory = SAXParserFactory.newInstance();
+ saxParserFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+ } catch (Exception ex) {
+ throw new AssertionError("Can not instantiate " +
+ "PutTaggingUnmarshaller parser", ex);
+ }
+ }
+
+ public S3Tagging readFrom(InputStream inputStream)
+ throws WebApplicationException {
+ try {
+ XMLReader xmlReader = saxParserFactory.newSAXParser().getXMLReader();
+ UnmarshallerHandler unmarshallerHandler =
+ context.createUnmarshaller().getUnmarshallerHandler();
+ XmlNamespaceFilter filter =
+ new XmlNamespaceFilter(S3_XML_NAMESPACE);
+ filter.setContentHandler(unmarshallerHandler);
+ filter.setParent(xmlReader);
+ filter.parse(new InputSource(inputStream));
+ return (S3Tagging) unmarshallerHandler.getResult();
+ } catch (Exception e) {
+ throw wrapOS3Exception(INVALID_REQUEST.withMessage(e.getMessage()));
+ }
+ }
+
+}
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/S3Tagging.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/S3Tagging.java
new file mode 100644
index 0000000000..0a0f289f1d
--- /dev/null
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/S3Tagging.java
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.s3.endpoint;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * S3 tagging.
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlRootElement(name = "Tagging",
+ namespace = "http://s3.amazonaws.com/doc/2006-03-01/")
+public class S3Tagging {
+
+ @XmlElement(name = "TagSet")
+ private TagSet tagSet;
+
+ public S3Tagging() {
+
+ }
+
+ public S3Tagging(TagSet tagSet) {
+ this.tagSet = tagSet;
+ }
+
+ public TagSet getTagSet() {
+ return tagSet;
+ }
+
+ public void setTagSet(TagSet tagSet) {
+ this.tagSet = tagSet;
+ }
+
+ /**
+ * Entity for child element TagSet.
+ */
+ @XmlAccessorType(XmlAccessType.FIELD)
+ @XmlRootElement(name = "TagSet")
+ public static class TagSet {
+ @XmlElement(name = "Tag")
+ private List<Tag> tags = new ArrayList<>();
+
+ public TagSet() {
+ }
+
+ public TagSet(List<Tag> tags) {
+ this.tags = tags;
+ }
+
+ public List<Tag> getTags() {
+ return tags;
+ }
+
+ public void setTags(List<Tag> tags) {
+ this.tags = tags;
+ }
+ }
+
+ /**
+ * Entity for child element Tag.
+ */
+ @XmlAccessorType(XmlAccessType.FIELD)
+ @XmlRootElement(name = "Tag")
+ public static class Tag {
+ @XmlElement(name = "Key")
+ private String key;
+
+ @XmlElement(name = "Value")
+ private String value;
+
+ public Tag() {
+ }
+
+ public Tag(String key, String value) {
+ this.key = key;
+ this.value = value;
+ }
+
+ public String getKey() {
+ return key;
+ }
+
+ public void setKey(String key) {
+ this.key = key;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ /**
+ * Creates a S3 tagging instance (xml representation) from a Map retrieved
+ * from OM.
+ * @param tagMap Map representing the tags.
+ * @return {@link S3Tagging}
+ */
+ public static S3Tagging fromMap(Map<String, String> tagMap) {
+ List<Tag> tags = tagMap.entrySet()
+ .stream()
+ .map(
+ tagEntry -> new Tag(tagEntry.getKey(), tagEntry.getValue())
+ )
+ .collect(Collectors.toList());
+ return new S3Tagging(new TagSet(tags));
+ }
+
+ /**
+ * Additional XML validation logic for S3 tagging.
+ */
+ public void validate() {
+ if (tagSet == null) {
+ throw new IllegalArgumentException("TagSet needs to be specified");
+ }
+
+ if (tagSet.getTags().isEmpty()) {
+ throw new IllegalArgumentException("Tags need to be specified and cannot be empty");
+ }
+
+ for (Tag tag: tagSet.getTags()) {
+ if (tag.getKey() == null) {
+ throw new IllegalArgumentException("Some tag keys are not specified");
+ }
+ if (tag.getValue() == null) {
+ throw new IllegalArgumentException("Tag value for tag " + tag.getKey() + " is not specified");
+ }
+ }
+ }
+}
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/exception/S3ErrorTable.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/exception/S3ErrorTable.java
index 42c044086b..49761f89a3 100644
--- a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/exception/S3ErrorTable.java
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/exception/S3ErrorTable.java
@@ -145,6 +145,10 @@ public final class S3ErrorTable {
public static final OS3Exception NO_SUCH_TAG_SET = new OS3Exception(
"NoSuchTagSet", "The specified tag does not exist.", HTTP_NOT_FOUND);
+ public static final OS3Exception MALFORMED_XML = new OS3Exception(
+ "MalformedXML", "The XML you provided was not well-formed or did not " +
+ "validate against our published schema", HTTP_BAD_REQUEST);
+
public static OS3Exception newError(OS3Exception e, String resource) {
return newError(e, resource, null);
}
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/metrics/S3GatewayMetrics.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/metrics/S3GatewayMetrics.java
index ea34be638e..c13bad5d66 100644
--- a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/metrics/S3GatewayMetrics.java
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/metrics/S3GatewayMetrics.java
@@ -95,6 +95,12 @@ public final class S3GatewayMetrics implements Closeable, MetricsSource {
private @Metric MutableCounterLong copyObjectSuccessLength;
private @Metric MutableCounterLong putKeySuccessLength;
private @Metric MutableCounterLong getKeySuccessLength;
+ private @Metric MutableCounterLong getObjectTaggingSuccess;
+ private @Metric MutableCounterLong getObjectTaggingFailure;
+ private @Metric MutableCounterLong putObjectTaggingSuccess;
+ private @Metric MutableCounterLong putObjectTaggingFailure;
+ private @Metric MutableCounterLong deleteObjectTaggingSuccess;
+ private @Metric MutableCounterLong deleteObjectTaggingFailure;
// S3 Gateway Latency Metrics
// BucketEndpoint
@@ -246,6 +252,24 @@ public final class S3GatewayMetrics implements Closeable, MetricsSource {
@Metric(about = "Latency for copy metadata of an key in nanoseconds")
private PerformanceMetrics copyKeyMetadataLatencyNs;
+ @Metric(about = "Latency for successful get object tagging of a key in nanoseconds")
+ private PerformanceMetrics getObjectTaggingSuccessLatencyNs;
+
+ @Metric(about = "Latency for failing to get object tagging of a key in nanoseconds")
+ private PerformanceMetrics getObjectTaggingFailureLatencyNs;
+
+ @Metric(about = "Latency for successful put object tagging of a key in nanoseconds")
+ private PerformanceMetrics putObjectTaggingSuccessLatencyNs;
+
+ @Metric(about = "Latency for failing to put object tagging of a key in nanoseconds")
+ private PerformanceMetrics putObjectTaggingFailureLatencyNs;
+
+ @Metric(about = "Latency for successful delete object tagging of a key in nanoseconds")
+ private PerformanceMetrics deleteObjectTaggingSuccessLatencyNs;
+
+ @Metric(about = "Latency for failing to delete object tagging of a key in nanoseconds")
+ private PerformanceMetrics deleteObjectTaggingFailureLatencyNs;
+
private final Map<String, PerformanceMetrics> performanceMetrics;
/**
@@ -375,6 +399,18 @@ public final class S3GatewayMetrics implements Closeable, MetricsSource {
putKeySuccessLength.snapshot(recordBuilder, true);
getKeySuccessLength.snapshot(recordBuilder, true);
listKeyCount.snapshot(recordBuilder, true);
+ getObjectTaggingSuccess.snapshot(recordBuilder, true);
+ getObjectTaggingSuccessLatencyNs.snapshot(recordBuilder, true);
+ getObjectTaggingFailure.snapshot(recordBuilder, true);
+ getObjectTaggingFailureLatencyNs.snapshot(recordBuilder, true);
+ putObjectTaggingSuccess.snapshot(recordBuilder, true);
+ putObjectTaggingSuccessLatencyNs.snapshot(recordBuilder, true);
+ putObjectTaggingFailure.snapshot(recordBuilder, true);
+ putObjectTaggingFailureLatencyNs.snapshot(recordBuilder, true);
+ deleteObjectTaggingSuccess.snapshot(recordBuilder, true);
+ deleteObjectTaggingSuccessLatencyNs.snapshot(recordBuilder, true);
+ deleteObjectTaggingFailure.snapshot(recordBuilder, true);
+ deleteObjectTaggingFailureLatencyNs.snapshot(recordBuilder, true);
}
// INC and UPDATE
@@ -596,6 +632,36 @@ public final class S3GatewayMetrics implements Closeable, MetricsSource {
getKeySuccessLength.incr(bytes);
}
+ public void updateGetObjectTaggingSuccessStats(long startNanos) {
+ this.getObjectTaggingSuccess.incr();
+ this.getObjectTaggingSuccessLatencyNs.add(Time.monotonicNowNanos() - startNanos);
+ }
+
+ public void updateGetObjectTaggingFailureStats(long startNanos) {
+ this.getObjectTaggingFailure.incr();
+ this.getObjectTaggingFailureLatencyNs.add(Time.monotonicNowNanos() - startNanos);
+ }
+
+ public void updatePutObjectTaggingSuccessStats(long startNanos) {
+ this.putObjectTaggingSuccess.incr();
+ this.putObjectTaggingSuccessLatencyNs.add(Time.monotonicNowNanos() - startNanos);
+ }
+
+ public void updatePutObjectTaggingFailureStats(long startNanos) {
+ this.putObjectTaggingFailure.incr();
+ this.putObjectTaggingFailureLatencyNs.add(Time.monotonicNowNanos() - startNanos);
+ }
+
+ public void updateDeleteObjectTaggingSuccessStats(long startNanos) {
+ this.deleteObjectTaggingSuccess.incr();
+ this.deleteObjectTaggingSuccessLatencyNs.add(Time.monotonicNowNanos() - startNanos);
+ }
+
+ public void updateDeleteObjectTaggingFailureStats(long startNanos) {
+ this.deleteObjectTaggingFailure.incr();
+ this.deleteObjectTaggingFailureLatencyNs.add(Time.monotonicNowNanos() - startNanos);
+ }
+
// GET
public long getListS3BucketsSuccess() {
return listS3BucketsSuccess.value();
@@ -737,6 +803,30 @@ public final class S3GatewayMetrics implements Closeable, MetricsSource {
return listS3BucketsFailure.value();
}
+ public long getGetObjectTaggingSuccess() {
+ return getObjectTaggingSuccess.value();
+ }
+
+ public long getGetObjectTaggingFailure() {
+ return getObjectTaggingFailure.value();
+ }
+
+ public long getPutObjectTaggingSuccess() {
+ return putObjectTaggingSuccess.value();
+ }
+
+ public long getPutObjectTaggingFailure() {
+ return putObjectTaggingFailure.value();
+ }
+
+ public long getDeleteObjectTaggingSuccess() {
+ return deleteObjectTaggingSuccess.value();
+ }
+
+ public long getDeleteObjectTaggingFailure() {
+ return deleteObjectTaggingFailure.value();
+ }
+
private long updateAndGetStats(PerformanceMetrics metric, long startNanos) {
long value = Time.monotonicNowNanos() - startNanos;
metric.add(value);
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/util/S3Consts.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/util/S3Consts.java
index cbdbef0e0a..7b82d5c2a7 100644
--- a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/util/S3Consts.java
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/util/S3Consts.java
@@ -74,6 +74,7 @@ public final class S3Consts {
public static final String TAG_HEADER = "x-amz-tagging";
public static final String TAG_DIRECTIVE_HEADER = "x-amz-tagging-directive";
public static final String TAG_COUNT_HEADER = "x-amz-tagging-count";
+ public static final String AWS_TAG_PREFIX = "aws:";
public static final int TAG_NUM_LIMIT = 10;
public static final int TAG_KEY_LENGTH_LIMIT = 128;
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/ClientProtocolStub.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/ClientProtocolStub.java
index e3e3537b1c..41584c9786 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/ClientProtocolStub.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/ClientProtocolStub.java
@@ -771,4 +771,20 @@ public class ClientProtocolStub implements ClientProtocol {
}
+ @Override
+ public Map<String, String> getObjectTagging(String volumeName, String bucketName, String keyName) throws IOException {
+ return getBucket(volumeName, bucketName).getObjectTagging(keyName);
+ }
+
+ @Override
+ public void putObjectTagging(String volumeName, String bucketName, String keyName, Map<String, String> tags)
+ throws IOException {
+ getBucket(volumeName, bucketName).putObjectTagging(keyName, tags);
+ }
+
+ @Override
+ public void deleteObjectTagging(String volumeName, String bucketName, String keyName) throws IOException {
+ getBucket(volumeName, bucketName).deleteObjectTagging(keyName);
+ }
+
}
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/OzoneBucketStub.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/OzoneBucketStub.java
index 06b6a8efb7..21f2414c0a 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/OzoneBucketStub.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/client/OzoneBucketStub.java
@@ -596,6 +596,37 @@ public final class OzoneBucketStub extends OzoneBucket {
return aclList.addAll(acls);
}
+ @Override
+ public Map<String, String> getObjectTagging(String keyName) throws IOException {
+ if (keyDetails.containsKey(keyName)) {
+ OzoneKeyDetails ozoneKeyDetails = keyDetails.get(keyName);
+ return ozoneKeyDetails.getTags();
+ } else {
+ throw new OMException(ResultCodes.KEY_NOT_FOUND);
+ }
+ }
+
+ @Override
+ public void putObjectTagging(String keyName, Map<String, String> tags) throws IOException {
+ if (keyDetails.containsKey(keyName)) {
+ OzoneKeyDetails ozoneKeyDetails = keyDetails.get(keyName);
+ ozoneKeyDetails.getTags().clear();
+ ozoneKeyDetails.getTags().putAll(tags);
+ } else {
+ throw new OMException(ResultCodes.KEY_NOT_FOUND);
+ }
+ }
+
+ @Override
+ public void deleteObjectTagging(String keyName) throws IOException {
+ if (keyDetails.containsKey(keyName)) {
+ OzoneKeyDetails ozoneKeyDetails = keyDetails.get(keyName);
+ ozoneKeyDetails.getTags().clear();
+ } else {
+ throw new OMException(ResultCodes.KEY_NOT_FOUND);
+ }
+ }
+
/**
* Class used to hold part information in a upload part request.
*/
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestAbortMultipartUpload.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestAbortMultipartUpload.java
index 9c107bdb5b..1356b50ad3 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestAbortMultipartUpload.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestAbortMultipartUpload.java
@@ -69,13 +69,13 @@ public class TestAbortMultipartUpload {
// Abort multipart upload
- response = rest.delete(bucket, key, uploadID);
+ response = rest.delete(bucket, key, uploadID, null);
assertEquals(204, response.getStatus());
// test with unknown upload Id.
try {
- rest.delete(bucket, key, "random");
+ rest.delete(bucket, key, "random", null);
} catch (OS3Exception ex) {
assertEquals(S3ErrorTable.NO_SUCH_UPLOAD.getCode(), ex.getCode());
assertEquals(S3ErrorTable.NO_SUCH_UPLOAD.getErrorMessage(),
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestListParts.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestListParts.java
index 677367e6d8..bf4768e081 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestListParts.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestListParts.java
@@ -77,17 +77,17 @@ public class TestListParts {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
response = REST.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
response = REST.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY,
- content.length(), 2, uploadID, body);
+ content.length(), 2, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
response = REST.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY,
- content.length(), 3, uploadID, body);
+ content.length(), 3, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
}
@@ -95,7 +95,7 @@ public class TestListParts {
@Test
public void testListParts() throws Exception {
Response response = REST.get(OzoneConsts.S3_BUCKET, OzoneConsts.KEY, 0,
- uploadID, 3, "0");
+ uploadID, 3, "0", null);
ListPartsResponse listPartsResponse =
(ListPartsResponse) response.getEntity();
@@ -108,7 +108,7 @@ public class TestListParts {
@Test
public void testListPartsContinuation() throws Exception {
Response response = REST.get(OzoneConsts.S3_BUCKET, OzoneConsts.KEY, 0,
- uploadID, 2, "0");
+ uploadID, 2, "0", null);
ListPartsResponse listPartsResponse =
(ListPartsResponse) response.getEntity();
@@ -117,7 +117,7 @@ public class TestListParts {
// Continue
response = REST.get(OzoneConsts.S3_BUCKET, OzoneConsts.KEY, 0, uploadID, 2,
- Integer.toString(listPartsResponse.getNextPartNumberMarker()));
+ Integer.toString(listPartsResponse.getNextPartNumberMarker()), null);
listPartsResponse = (ListPartsResponse) response.getEntity();
assertFalse(listPartsResponse.getTruncated());
@@ -129,7 +129,7 @@ public class TestListParts {
public void testListPartsWithUnknownUploadID() throws Exception {
try {
REST.get(OzoneConsts.S3_BUCKET, OzoneConsts.KEY, 0,
- uploadID, 2, "0");
+ uploadID, 2, "0", null);
} catch (OS3Exception ex) {
assertEquals(S3ErrorTable.NO_SUCH_UPLOAD.getErrorMessage(),
ex.getErrorMessage());
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadComplete.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadComplete.java
index b23dbfb9c0..57529cc9d8 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadComplete.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadComplete.java
@@ -109,7 +109,7 @@ public class TestMultipartUploadComplete {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
Response response = REST.put(OzoneConsts.S3_BUCKET, key, content.length(),
- partNumber, uploadID, body);
+ partNumber, uploadID, null, body);
assertEquals(200, response.getStatus());
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
Part part = new Part();
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadWithCopy.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadWithCopy.java
index d9595aeff7..8caf55dd82 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadWithCopy.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestMultipartUploadWithCopy.java
@@ -330,7 +330,7 @@ public class TestMultipartUploadWithCopy {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
Response response = REST.put(OzoneConsts.S3_BUCKET, key, content.length(),
- partNumber, uploadID, body);
+ partNumber, uploadID, null, body);
assertEquals(200, response.getStatus());
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
Part part = new Part();
@@ -375,7 +375,7 @@ public class TestMultipartUploadWithCopy {
ByteArrayInputStream body = new ByteArrayInputStream("".getBytes(UTF_8));
Response response = REST.put(OzoneConsts.S3_BUCKET, key, 0, partNumber,
- uploadID, body);
+ uploadID, null, body);
assertEquals(200, response.getStatus());
CopyPartResult result = (CopyPartResult) response.getEntity();
@@ -402,7 +402,7 @@ public class TestMultipartUploadWithCopy {
OzoneConsts.S3_BUCKET + "/" + EXISTING_KEY);
additionalHeaders.put(COPY_SOURCE_HEADER_RANGE, "bytes=0-3");
setHeaders(additionalHeaders);
- REST.put(OzoneConsts.S3_BUCKET, KEY, 0, 1, uploadID, body);
+ REST.put(OzoneConsts.S3_BUCKET, KEY, 0, 1, uploadID, null, body);
OzoneMultipartUploadPartListParts parts =
CLIENT.getObjectStore().getS3Bucket(OzoneConsts.S3_BUCKET)
.listParts(KEY, uploadID, 0, 100);
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectDelete.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectDelete.java
index 90695f03ff..340ed1984e 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectDelete.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectDelete.java
@@ -51,7 +51,7 @@ public class TestObjectDelete {
rest.setOzoneConfiguration(new OzoneConfiguration());
//WHEN
- rest.delete("b1", "key1", null);
+ rest.delete("b1", "key1", null, null);
//THEN
assertFalse(bucket.listKeys("").hasNext(),
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectGet.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectGet.java
index 8cf8da95cf..cc7f43b286 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectGet.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectGet.java
@@ -95,11 +95,11 @@ public class TestObjectGet {
ByteArrayInputStream body = new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
rest.put(BUCKET_NAME, KEY_NAME, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
// Create a key with object tags
when(headers.getHeaderString(TAG_HEADER)).thenReturn("tag1=value1&tag2=value2");
rest.put(BUCKET_NAME, KEY_WITH_TAG, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
context = mock(ContainerRequestContext.class);
when(context.getUriInfo()).thenReturn(mock(UriInfo.class));
@@ -111,7 +111,7 @@ public class TestObjectGet {
@Test
public void get() throws IOException, OS3Exception {
//WHEN
- Response response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null);
+ Response response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null, null);
//THEN
OzoneInputStream ozoneInputStream =
@@ -133,7 +133,7 @@ public class TestObjectGet {
@Test
public void getKeyWithTag() throws IOException, OS3Exception {
//WHEN
- Response response = rest.get(BUCKET_NAME, KEY_WITH_TAG, 0, null, 0, null);
+ Response response = rest.get(BUCKET_NAME, KEY_WITH_TAG, 0, null, 0, null, null);
//THEN
OzoneInputStream ozoneInputStream =
@@ -155,7 +155,7 @@ public class TestObjectGet {
public void inheritRequestHeader() throws IOException, OS3Exception {
setDefaultHeader();
- Response response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null);
+ Response response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null, null);
assertEquals(CONTENT_TYPE1,
response.getHeaderString("Content-Type"));
@@ -188,7 +188,7 @@ public class TestObjectGet {
when(context.getUriInfo().getQueryParameters())
.thenReturn(queryParameter);
- Response response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null);
+ Response response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null, null);
assertEquals(CONTENT_TYPE2,
response.getHeaderString("Content-Type"));
@@ -209,13 +209,13 @@ public class TestObjectGet {
Response response;
when(headers.getHeaderString(RANGE_HEADER)).thenReturn("bytes=0-0");
- response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null);
+ response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null, null);
assertEquals("1", response.getHeaderString("Content-Length"));
assertEquals(String.format("bytes 0-0/%s", CONTENT.length()),
response.getHeaderString("Content-Range"));
when(headers.getHeaderString(RANGE_HEADER)).thenReturn("bytes=0-");
- response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null);
+ response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null, null);
assertEquals(String.valueOf(CONTENT.length()),
response.getHeaderString("Content-Length"));
assertEquals(
@@ -228,7 +228,7 @@ public class TestObjectGet {
@Test
public void getStatusCode() throws IOException, OS3Exception {
Response response;
- response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null);
+ response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null, null);
assertEquals(response.getStatus(),
Response.Status.OK.getStatusCode());
@@ -236,7 +236,7 @@ public class TestObjectGet {
// The 206 (Partial Content) status code indicates that the server is
// successfully fulfilling a range request for the target resource
when(headers.getHeaderString(RANGE_HEADER)).thenReturn("bytes=0-1");
- response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null);
+ response = rest.get(BUCKET_NAME, KEY_NAME, 0, null, 0, null, null);
assertEquals(response.getStatus(),
Response.Status.PARTIAL_CONTENT.getStatusCode());
assertNull(response.getHeaderString(TAG_COUNT_HEADER));
@@ -270,7 +270,7 @@ public class TestObjectGet {
// WHEN
final OS3Exception ex = assertThrows(OS3Exception.class,
- () -> rest.get(BUCKET_NAME, keyPath, 0, null, 0, null));
+ () -> rest.get(BUCKET_NAME, keyPath, 0, null, 0, null, null));
// THEN
assertEquals(NO_SUCH_KEY.getCode(), ex.getCode());
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectPut.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectPut.java
index 8b3d9e1ad2..4049e03b43 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectPut.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectPut.java
@@ -157,7 +157,7 @@ class TestObjectPut {
bucket.setReplicationConfig(replication);
//WHEN
- Response response = objectEndpoint.put(BUCKET_NAME, KEY_NAME, length, 1, null, body);
+ Response response = objectEndpoint.put(BUCKET_NAME, KEY_NAME, length, 1, null, null, body);
//THEN
assertEquals(200, response.getStatus());
@@ -184,7 +184,7 @@ class TestObjectPut {
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
long dataSize = CONTENT.length();
- objectEndpoint.put(BUCKET_NAME, KEY_NAME, dataSize, 0, null, body);
+ objectEndpoint.put(BUCKET_NAME, KEY_NAME, dataSize, 0, null, null, body);
assertEquals(dataSize, getKeyDataSize());
}
@@ -201,7 +201,7 @@ class TestObjectPut {
when(headers.getHeaderString(DECODED_CONTENT_LENGTH_HEADER))
.thenReturn("15");
- objectEndpoint.put(BUCKET_NAME, KEY_NAME, chunkedContent.length(), 0, null,
+ objectEndpoint.put(BUCKET_NAME, KEY_NAME, chunkedContent.length(), 0, null, null,
new ByteArrayInputStream(chunkedContent.getBytes(UTF_8)));
assertEquals(15, getKeyDataSize());
}
@@ -216,7 +216,7 @@ class TestObjectPut {
objectEndpoint.setHeaders(headersWithTags);
Response response = objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
assertEquals(200, response.getStatus());
@@ -239,7 +239,7 @@ class TestObjectPut {
try {
objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
fail("request with invalid query param should fail");
} catch (OS3Exception ex) {
assertEquals(INVALID_TAG.getCode(), ex.getCode());
@@ -257,7 +257,7 @@ class TestObjectPut {
objectEndpoint.setHeaders(headersWithDuplicateTagKey);
try {
objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
fail("request with duplicate tag key should fail");
} catch (OS3Exception ex) {
assertEquals(INVALID_TAG.getCode(), ex.getCode());
@@ -276,7 +276,7 @@ class TestObjectPut {
objectEndpoint.setHeaders(headersWithLongTagKey);
try {
objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
fail("request with tag key exceeding the length limit should fail");
} catch (OS3Exception ex) {
assertEquals(INVALID_TAG.getCode(), ex.getCode());
@@ -295,7 +295,7 @@ class TestObjectPut {
when(headersWithLongTagValue.getHeaderString(TAG_HEADER)).thenReturn("tag1=" + longTagValue);
try {
objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
fail("request with tag value exceeding the length limit should fail");
} catch (OS3Exception ex) {
assertEquals(INVALID_TAG.getCode(), ex.getCode());
@@ -320,7 +320,7 @@ class TestObjectPut {
objectEndpoint.setHeaders(headersWithTooManyTags);
try {
objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT.length(),
- 1, null, body);
+ 1, null, null, body);
fail("request with number of tags exceeding limit should fail");
} catch (OS3Exception ex) {
assertEquals(INVALID_TAG.getCode(), ex.getCode());
@@ -349,7 +349,7 @@ class TestObjectPut {
//WHEN
Response response = objectEndpoint.put(BUCKET_NAME, KEY_NAME,
- chunkedContent.length(), 1, null,
+ chunkedContent.length(), 1, null, null,
new ByteArrayInputStream(chunkedContent.getBytes(UTF_8)));
//THEN
@@ -378,7 +378,7 @@ class TestObjectPut {
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
try {
objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT
- .length(), 1, null, body);
+ .length(), 1, null, null, body);
fail("Should throw IOException");
} catch (IOException ignored) {
// Verify that the message digest is reset so that the instance can be reused for the
@@ -403,7 +403,7 @@ class TestObjectPut {
when(headers.getHeaderString(CUSTOM_METADATA_COPY_DIRECTIVE_HEADER)).thenReturn("COPY");
Response response = objectEndpoint.put(BUCKET_NAME, KEY_NAME,
- CONTENT.length(), 1, null, body);
+ CONTENT.length(), 1, null, null, body);
OzoneInputStream ozoneInputStream = clientStub.getObjectStore()
.getS3Bucket(BUCKET_NAME)
@@ -429,7 +429,7 @@ class TestObjectPut {
BUCKET_NAME + "/" + urlEncode(KEY_NAME));
response = objectEndpoint.put(DEST_BUCKET_NAME, DEST_KEY, CONTENT.length(), 1,
- null, body);
+ null, null, body);
// Check destination key and response
ozoneInputStream = clientStub.getObjectStore().getS3Bucket(DEST_BUCKET_NAME)
@@ -459,7 +459,7 @@ class TestObjectPut {
metadataHeaders.remove(CUSTOM_METADATA_HEADER_PREFIX + "custom-key-2");
response = objectEndpoint.put(DEST_BUCKET_NAME, DEST_KEY, CONTENT.length(), 1,
- null, body);
+ null, null, body);
ozoneInputStream = clientStub.getObjectStore().getS3Bucket(DEST_BUCKET_NAME)
.readKey(DEST_KEY);
@@ -486,7 +486,7 @@ class TestObjectPut {
// wrong copy metadata directive
when(headers.getHeaderString(CUSTOM_METADATA_COPY_DIRECTIVE_HEADER)).thenReturn("INVALID");
OS3Exception e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(
- DEST_BUCKET_NAME, DEST_KEY, CONTENT.length(), 1, null, body),
+ DEST_BUCKET_NAME, DEST_KEY, CONTENT.length(), 1, null, null, body),
"test copy object failed");
assertThat(e.getHttpCode()).isEqualTo(400);
assertThat(e.getCode()).isEqualTo("InvalidArgument");
@@ -496,7 +496,7 @@ class TestObjectPut {
// source and dest same
e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(
- BUCKET_NAME, KEY_NAME, CONTENT.length(), 1, null, body),
+ BUCKET_NAME, KEY_NAME, CONTENT.length(), 1, null, null, body),
"test copy object failed");
assertThat(e.getErrorMessage()).contains("This copy request is illegal");
@@ -504,28 +504,28 @@ class TestObjectPut {
when(headers.getHeaderString(COPY_SOURCE_HEADER)).thenReturn(
NO_SUCH_BUCKET + "/" + urlEncode(KEY_NAME));
e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(DEST_BUCKET_NAME,
- DEST_KEY, CONTENT.length(), 1, null, body), "test copy object failed");
+ DEST_KEY, CONTENT.length(), 1, null, null, body), "test copy object failed");
assertThat(e.getCode()).contains("NoSuchBucket");
// dest bucket not found
when(headers.getHeaderString(COPY_SOURCE_HEADER)).thenReturn(
BUCKET_NAME + "/" + urlEncode(KEY_NAME));
e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(NO_SUCH_BUCKET,
- DEST_KEY, CONTENT.length(), 1, null, body), "test copy object failed");
+ DEST_KEY, CONTENT.length(), 1, null, null, body), "test copy object failed");
assertThat(e.getCode()).contains("NoSuchBucket");
//Both source and dest bucket not found
when(headers.getHeaderString(COPY_SOURCE_HEADER)).thenReturn(
NO_SUCH_BUCKET + "/" + urlEncode(KEY_NAME));
e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(NO_SUCH_BUCKET,
- DEST_KEY, CONTENT.length(), 1, null, body), "test copy object failed");
+ DEST_KEY, CONTENT.length(), 1, null, null, body), "test copy object failed");
assertThat(e.getCode()).contains("NoSuchBucket");
// source key not found
when(headers.getHeaderString(COPY_SOURCE_HEADER)).thenReturn(
BUCKET_NAME + "/" + urlEncode(NO_SUCH_BUCKET));
e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(
- "nonexistent", KEY_NAME, CONTENT.length(), 1, null, body),
+ "nonexistent", KEY_NAME, CONTENT.length(), 1, null, null, body),
"test copy object failed");
assertThat(e.getCode()).contains("NoSuchBucket");
}
@@ -537,7 +537,7 @@ class TestObjectPut {
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
Response response = objectEndpoint.put(BUCKET_NAME, KEY_NAME,
- CONTENT.length(), 1, null, body);
+ CONTENT.length(), 1, null, null, body);
OzoneInputStream ozoneInputStream = clientStub.getObjectStore()
.getS3Bucket(BUCKET_NAME)
@@ -564,7 +564,7 @@ class TestObjectPut {
try {
objectEndpoint.put(DEST_BUCKET_NAME, DEST_KEY, CONTENT.length(), 1,
- null, body);
+ null, null, body);
fail("Should throw IOException");
} catch (IOException ignored) {
// Verify that the message digest is reset so that the instance can be reused for the
@@ -586,7 +586,7 @@ class TestObjectPut {
String sourceKeyName = "sourceKey";
Response putResponse = objectEndpoint.put(BUCKET_NAME, sourceKeyName,
- CONTENT.length(), 1, null, body);
+ CONTENT.length(), 1, null, null, body);
OzoneKeyDetails keyDetails =
clientStub.getObjectStore().getS3Bucket(BUCKET_NAME).getKey(sourceKeyName);
@@ -603,7 +603,7 @@ class TestObjectPut {
BUCKET_NAME + "/" + urlEncode(sourceKeyName));
objectEndpoint.setHeaders(headersForCopy);
- Response copyResponse = objectEndpoint.put(DEST_BUCKET_NAME, destKey, CONTENT.length(), 1, null, body);
+ Response copyResponse = objectEndpoint.put(DEST_BUCKET_NAME, destKey, CONTENT.length(), 1, null, null, body);
OzoneKeyDetails destKeyDetails = clientStub.getObjectStore()
.getS3Bucket(DEST_BUCKET_NAME).getKey(destKey);
@@ -622,7 +622,7 @@ class TestObjectPut {
// With x-amz-tagging-directive = COPY with a different x-amz-tagging
when(headersForCopy.getHeaderString(TAG_HEADER)).thenReturn("tag3=value3");
- copyResponse = objectEndpoint.put(DEST_BUCKET_NAME, destKey, CONTENT.length(), 1, null, body);
+ copyResponse = objectEndpoint.put(DEST_BUCKET_NAME, destKey, CONTENT.length(), 1, null, null, body);
assertEquals(200, copyResponse.getStatus());
destKeyDetails = clientStub.getObjectStore()
@@ -637,7 +637,7 @@ class TestObjectPut {
// Copy object with x-amz-tagging-directive = REPLACE
when(headersForCopy.getHeaderString(TAG_DIRECTIVE_HEADER)).thenReturn("REPLACE");
- copyResponse = objectEndpoint.put(DEST_BUCKET_NAME, destKey, CONTENT.length(), 1, null, body);
+ copyResponse = objectEndpoint.put(DEST_BUCKET_NAME, destKey, CONTENT.length(), 1, null, null, body);
assertEquals(200, copyResponse.getStatus());
destKeyDetails = clientStub.getObjectStore()
@@ -659,7 +659,7 @@ class TestObjectPut {
HttpHeaders headersForCopy = Mockito.mock(HttpHeaders.class);
when(headersForCopy.getHeaderString(TAG_DIRECTIVE_HEADER)).thenReturn("INVALID");
try {
- objectEndpoint.put(DEST_BUCKET_NAME, "somekey", CONTENT.length(), 1, null, body);
+ objectEndpoint.put(DEST_BUCKET_NAME, "somekey", CONTENT.length(), 1, null, null, body);
} catch (OS3Exception ex) {
assertEquals(INVALID_ARGUMENT.getCode(), ex.getCode());
assertThat(ex.getErrorMessage()).contains("The tagging copy directive specified is invalid");
@@ -674,7 +674,7 @@ class TestObjectPut {
when(headers.getHeaderString(STORAGE_CLASS_HEADER)).thenReturn("random");
OS3Exception e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(
- BUCKET_NAME, KEY_NAME, CONTENT.length(), 1, null, body));
+ BUCKET_NAME, KEY_NAME, CONTENT.length(), 1, null, null, body));
assertEquals(S3ErrorTable.INVALID_ARGUMENT.getErrorMessage(),
e.getErrorMessage());
assertEquals("random", e.getResource());
@@ -687,7 +687,7 @@ class TestObjectPut {
when(headers.getHeaderString(STORAGE_CLASS_HEADER)).thenReturn("");
objectEndpoint.put(BUCKET_NAME, KEY_NAME, CONTENT
- .length(), 1, null, body);
+ .length(), 1, null, null, body);
OzoneKeyDetails key =
clientStub.getObjectStore().getS3Bucket(BUCKET_NAME)
.getKey(KEY_NAME);
@@ -706,7 +706,7 @@ class TestObjectPut {
// WHEN
try (Response response = objectEndpoint.put(fsoBucket.getName(), path,
- 0L, 0, "", null)) {
+ 0L, 0, "", null, null)) {
assertEquals(HttpStatus.SC_OK, response.getStatus());
}
@@ -721,12 +721,12 @@ class TestObjectPut {
final String path = "key";
final ByteArrayInputStream body =
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
- objectEndpoint.put(FSO_BUCKET_NAME, path, CONTENT.length(), 0, "", body);
+ objectEndpoint.put(FSO_BUCKET_NAME, path, CONTENT.length(), 0, "", null, body);
// WHEN
final OS3Exception exception = assertThrows(OS3Exception.class,
() -> objectEndpoint
- .put(FSO_BUCKET_NAME, path + "/", 0, 0, "", null)
+ .put(FSO_BUCKET_NAME, path + "/", 0, 0, "", null, null)
.close());
// THEN
@@ -741,7 +741,7 @@ class TestObjectPut {
ByteArrayInputStream body = new ByteArrayInputStream(emptyString.getBytes(UTF_8));
objectEndpoint.setHeaders(headersWithTags);
- Response putResponse = objectEndpoint.put(BUCKET_NAME, KEY_NAME, emptyString.length(), 1, null, body);
+ Response putResponse = objectEndpoint.put(BUCKET_NAME, KEY_NAME, emptyString.length(), 1, null, null, body);
assertEquals(200, putResponse.getStatus());
OzoneKeyDetails keyDetails = clientStub.getObjectStore().getS3Bucket(BUCKET_NAME).getKey(KEY_NAME);
assertEquals(0, keyDetails.getDataSize());
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingDelete.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingDelete.java
new file mode 100644
index 0000000000..edf4c9856d
--- /dev/null
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingDelete.java
@@ -0,0 +1,152 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.s3.endpoint;
+
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.ozone.client.ObjectStore;
+import org.apache.hadoop.ozone.client.OzoneBucket;
+import org.apache.hadoop.ozone.client.OzoneClient;
+import org.apache.hadoop.ozone.client.OzoneClientStub;
+import org.apache.hadoop.ozone.client.OzoneVolume;
+import org.apache.hadoop.ozone.om.exceptions.OMException;
+import org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes;
+import org.apache.hadoop.ozone.s3.exception.OS3Exception;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+import static java.net.HttpURLConnection.HTTP_NOT_FOUND;
+import static java.net.HttpURLConnection.HTTP_NOT_IMPLEMENTED;
+import static java.net.HttpURLConnection.HTTP_NO_CONTENT;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NOT_IMPLEMENTED;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NO_SUCH_BUCKET;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NO_SUCH_KEY;
+import static org.apache.hadoop.ozone.s3.util.S3Consts.TAG_HEADER;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Tests for DeleteObjectTagging.
+ */
+public class TestObjectTaggingDelete {
+
+ private static final String CONTENT = "0123456789";
+ private static final String BUCKET_NAME = "b1";
+ private static final String KEY_WITH_TAG = "keyWithTag";
+ private HttpHeaders headers;
+ private ObjectEndpoint rest;
+ private OzoneClient client;
+ private ByteArrayInputStream body;
+ private ContainerRequestContext context;
+
+ @BeforeEach
+ public void init() throws OS3Exception, IOException {
+ //GIVEN
+ OzoneConfiguration config = new OzoneConfiguration();
+ client = new OzoneClientStub();
+ client.getObjectStore().createS3Bucket(BUCKET_NAME);
+
+ rest = new ObjectEndpoint();
+ rest.setClient(client);
+ rest.setOzoneConfiguration(config);
+ headers = Mockito.mock(HttpHeaders.class);
+ rest.setHeaders(headers);
+ body = new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
+ // Create a key with object tags
+ Mockito.when(headers.getHeaderString(TAG_HEADER)).thenReturn("tag1=value1&tag2=value2");
+ rest.put(BUCKET_NAME, KEY_WITH_TAG, CONTENT.length(),
+ 1, null, null, body);
+
+
+ context = Mockito.mock(ContainerRequestContext.class);
+ Mockito.when(context.getUriInfo()).thenReturn(Mockito.mock(UriInfo.class));
+ Mockito.when(context.getUriInfo().getQueryParameters())
+ .thenReturn(new MultivaluedHashMap<>());
+ rest.setContext(context);
+ }
+
+ @Test
+ public void testDeleteTagging() throws IOException, OS3Exception {
+ Response response = rest.delete(BUCKET_NAME, KEY_WITH_TAG, null, "");
+ assertEquals(HTTP_NO_CONTENT, response.getStatus());
+
+ assertTrue(client.getObjectStore().getS3Bucket(BUCKET_NAME)
+ .getKey(KEY_WITH_TAG).getTags().isEmpty());
+ }
+
+ @Test
+ public void testDeleteTaggingNoKeyFound() throws Exception {
+ try {
+ rest.delete(BUCKET_NAME, "nonexistent", null, "");
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
+ assertEquals(NO_SUCH_KEY.getCode(), ex.getCode());
+ }
+ }
+
+ @Test
+ public void testDeleteTaggingNoBucketFound() throws Exception {
+ try {
+ rest.delete("nonexistent", "nonexistent", null, "");
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
+ assertEquals(NO_SUCH_BUCKET.getCode(), ex.getCode());
+ }
+ }
+
+ @Test
+ public void testDeleteObjectTaggingNotImplemented() throws Exception {
+ OzoneClient mockClient = mock(OzoneClient.class);
+ ObjectStore mockObjectStore = mock(ObjectStore.class);
+ OzoneVolume mockVolume = mock(OzoneVolume.class);
+ OzoneBucket mockBucket = mock(OzoneBucket.class);
+
+ when(mockClient.getObjectStore()).thenReturn(mockObjectStore);
+ when(mockObjectStore.getS3Volume()).thenReturn(mockVolume);
+ when(mockVolume.getBucket("fsoBucket")).thenReturn(mockBucket);
+
+ ObjectEndpoint endpoint = new ObjectEndpoint();
+ endpoint.setClient(mockClient);
+
+ doThrow(new OMException("DeleteObjectTagging is not currently supported for FSO directory",
+ ResultCodes.NOT_SUPPORTED_OPERATION)).when(mockBucket).deleteObjectTagging("dir/");
+
+ try {
+ endpoint.delete("fsoBucket", "dir/", null, "");
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_IMPLEMENTED, ex.getHttpCode());
+ assertEquals(NOT_IMPLEMENTED.getCode(), ex.getCode());
+ }
+ }
+}
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingGet.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingGet.java
new file mode 100644
index 0000000000..fe746f5b29
--- /dev/null
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingGet.java
@@ -0,0 +1,125 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.s3.endpoint;
+
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.ozone.client.OzoneClient;
+import org.apache.hadoop.ozone.client.OzoneClientStub;
+import org.apache.hadoop.ozone.s3.endpoint.S3Tagging.Tag;
+import org.apache.hadoop.ozone.s3.exception.OS3Exception;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+import static java.net.HttpURLConnection.HTTP_NOT_FOUND;
+import static java.net.HttpURLConnection.HTTP_OK;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NO_SUCH_BUCKET;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NO_SUCH_KEY;
+import static org.apache.hadoop.ozone.s3.util.S3Consts.TAG_HEADER;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Tests for GetObjectTagging.
+ */
+public class TestObjectTaggingGet {
+
+ private static final String CONTENT = "0123456789";
+ private static final String BUCKET_NAME = "b1";
+ private static final String KEY_WITH_TAG = "keyWithTag";
+ private ObjectEndpoint rest;
+
+ @BeforeEach
+ public void init() throws OS3Exception, IOException {
+ //GIVEN
+ OzoneConfiguration config = new OzoneConfiguration();
+ OzoneClient client = new OzoneClientStub();
+ client.getObjectStore().createS3Bucket(BUCKET_NAME);
+
+ rest = new ObjectEndpoint();
+ rest.setClient(client);
+ rest.setOzoneConfiguration(config);
+ HttpHeaders headers = Mockito.mock(HttpHeaders.class);
+ rest.setHeaders(headers);
+ ByteArrayInputStream body = new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
+ // Create a key with object tags
+ Mockito.when(headers.getHeaderString(TAG_HEADER)).thenReturn("tag1=value1&tag2=value2");
+ rest.put(BUCKET_NAME, KEY_WITH_TAG, CONTENT.length(),
+ 1, null, null, body);
+
+
+ ContainerRequestContext context = Mockito.mock(ContainerRequestContext.class);
+ Mockito.when(context.getUriInfo()).thenReturn(Mockito.mock(UriInfo.class));
+ Mockito.when(context.getUriInfo().getQueryParameters())
+ .thenReturn(new MultivaluedHashMap<>());
+ rest.setContext(context);
+ }
+
+ @Test
+ public void testGetTagging() throws IOException, OS3Exception {
+ //WHEN
+ Response response = rest.get(BUCKET_NAME, KEY_WITH_TAG, 0, null, 0, null, "");
+
+ assertEquals(HTTP_OK, response.getStatus());
+ S3Tagging s3Tagging = (S3Tagging) response.getEntity();
+ assertNotNull(s3Tagging);
+ assertNotNull(s3Tagging.getTagSet());
+ assertEquals(2, s3Tagging.getTagSet().getTags().size());
+ for (Tag tag: s3Tagging.getTagSet().getTags()) {
+ if (tag.getKey().equals("tag1")) {
+ assertEquals("value1", tag.getValue());
+ } else if (tag.getKey().equals("tag2")) {
+ assertEquals("value2", tag.getValue());
+ } else {
+ fail("Unknown tag found");
+ }
+ }
+ }
+
+ @Test
+ public void testGetTaggingNoKeyFound() throws Exception {
+ try {
+ rest.get(BUCKET_NAME, "nonexistent", 0, null, 0, null, "");
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
+ assertEquals(NO_SUCH_KEY.getCode(), ex.getCode());
+ }
+ }
+
+ @Test
+ public void testGetTaggingNoBucketFound() throws Exception {
+ try {
+ rest.get("nonexistent", "nonexistent", 0, null, 0, null, "");
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
+ assertEquals(NO_SUCH_BUCKET.getCode(), ex.getCode());
+ }
+ }
+}
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingPut.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingPut.java
new file mode 100644
index 0000000000..1067dea86b
--- /dev/null
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestObjectTaggingPut.java
@@ -0,0 +1,263 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.hadoop.ozone.s3.endpoint;
+
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.ozone.client.ObjectStore;
+import org.apache.hadoop.ozone.client.OzoneBucket;
+import org.apache.hadoop.ozone.client.OzoneClient;
+import org.apache.hadoop.ozone.client.OzoneClientStub;
+import org.apache.hadoop.ozone.client.OzoneKeyDetails;
+import org.apache.hadoop.ozone.client.OzoneVolume;
+import org.apache.hadoop.ozone.om.exceptions.OMException;
+import org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes;
+import org.apache.hadoop.ozone.s3.exception.OS3Exception;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.ws.rs.core.HttpHeaders;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+import static java.net.HttpURLConnection.HTTP_BAD_REQUEST;
+import static java.net.HttpURLConnection.HTTP_NOT_FOUND;
+import static java.net.HttpURLConnection.HTTP_NOT_IMPLEMENTED;
+import static java.net.HttpURLConnection.HTTP_OK;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.MALFORMED_XML;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NOT_IMPLEMENTED;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NO_SUCH_BUCKET;
+import static org.apache.hadoop.ozone.s3.exception.S3ErrorTable.NO_SUCH_KEY;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Tests for PutObjectTagging.
+ */
+public class TestObjectTaggingPut {
+
+ private OzoneClient clientStub;
+ private ObjectEndpoint objectEndpoint;
+
+ private static final String BUCKET_NAME = "b1";
+ private static final String KEY_NAME = "key=value/1";
+
+ @BeforeEach
+ void setup() throws IOException, OS3Exception {
+ OzoneConfiguration config = new OzoneConfiguration();
+
+ //Create client stub and object store stub.
+ clientStub = new OzoneClientStub();
+
+ // Create bucket
+ clientStub.getObjectStore().createS3Bucket(BUCKET_NAME);
+
+ // Create PutObject and setClient to OzoneClientStub
+ objectEndpoint = new ObjectEndpoint();
+ objectEndpoint.setClient(clientStub);
+ objectEndpoint.setOzoneConfiguration(config);
+
+ HttpHeaders headers = mock(HttpHeaders.class);
+ ByteArrayInputStream body =
+ new ByteArrayInputStream("".getBytes(UTF_8));
+ objectEndpoint.setHeaders(headers);
+
+ objectEndpoint.put(BUCKET_NAME, KEY_NAME, 0, 1, null, null, body);
+ }
+
+ @Test
+ public void testPutObjectTaggingWithEmptyBody() throws Exception {
+ try {
+ objectEndpoint.put(BUCKET_NAME, KEY_NAME, 0, 1, null, "",
+ null);
+ fail();
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_BAD_REQUEST, ex.getHttpCode());
+ assertEquals(MALFORMED_XML.getCode(), ex.getCode());
+ }
+ }
+
+ @Test
+ public void testPutValidObjectTagging() throws Exception {
+ assertEquals(HTTP_OK, objectEndpoint.put(BUCKET_NAME, KEY_NAME, 0, 1,
+ null, "", twoTags()).getStatus());
+ OzoneKeyDetails keyDetails =
+ clientStub.getObjectStore().getS3Bucket(BUCKET_NAME).getKey(KEY_NAME);
+ assertEquals(2, keyDetails.getTags().size());
+ assertEquals("val1", keyDetails.getTags().get("tag1"));
+ assertEquals("val2", keyDetails.getTags().get("tag2"));
+ }
+
+ @Test
+ public void testPutInvalidObjectTagging() throws Exception {
+ testInvalidObjectTagging(this::emptyBody, HTTP_BAD_REQUEST, MALFORMED_XML.getCode());
+ testInvalidObjectTagging(this::invalidXmlStructure, HTTP_BAD_REQUEST, MALFORMED_XML.getCode());
+ testInvalidObjectTagging(this::noTagSet, HTTP_BAD_REQUEST, MALFORMED_XML.getCode());
+ testInvalidObjectTagging(this::emptyTags, HTTP_BAD_REQUEST, MALFORMED_XML.getCode());
+ testInvalidObjectTagging(this::tagKeyNotSpecified, HTTP_BAD_REQUEST, MALFORMED_XML.getCode());
+ testInvalidObjectTagging(this::tagValueNotSpecified, HTTP_BAD_REQUEST, MALFORMED_XML.getCode());
+ }
+
+ private void testInvalidObjectTagging(Supplier<InputStream> inputStream,
+ int expectedHttpCode, String expectedErrorCode) throws Exception {
+ try {
+ objectEndpoint.put(BUCKET_NAME, KEY_NAME, 0, 1, null, "",
+ inputStream.get());
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(expectedHttpCode, ex.getHttpCode());
+ assertEquals(expectedErrorCode, ex.getCode());
+ }
+ }
+
+ @Test
+ public void testPutObjectTaggingNoKeyFound() throws Exception {
+ try {
+ objectEndpoint.put(BUCKET_NAME, "nonexistent", 0, 1,
+ null, "", twoTags());
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
+ assertEquals(NO_SUCH_KEY.getCode(), ex.getCode());
+ }
+ }
+
+ @Test
+ public void testPutObjectTaggingNoBucketFound() throws Exception {
+ try {
+ objectEndpoint.put("nonexistent", "nonexistent", 0, 1,
+ null, "", twoTags());
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
+ assertEquals(NO_SUCH_BUCKET.getCode(), ex.getCode());
+ }
+ }
+
+ @Test
+ public void testPutObjectTaggingNotImplemented() throws Exception {
+ OzoneClient mockClient = mock(OzoneClient.class);
+ ObjectStore mockObjectStore = mock(ObjectStore.class);
+ OzoneVolume mockVolume = mock(OzoneVolume.class);
+ OzoneBucket mockBucket = mock(OzoneBucket.class);
+
+ when(mockClient.getObjectStore()).thenReturn(mockObjectStore);
+ when(mockObjectStore.getS3Volume()).thenReturn(mockVolume);
+ when(mockVolume.getBucket("fsoBucket")).thenReturn(mockBucket);
+
+ ObjectEndpoint endpoint = new ObjectEndpoint();
+ Map<String, String> twoTagsMap = new HashMap<>();
+ twoTagsMap.put("tag1", "val1");
+ twoTagsMap.put("tag2", "val2");
+ endpoint.setClient(mockClient);
+
+ doThrow(new OMException("PutObjectTagging is not currently supported for FSO directory",
+ ResultCodes.NOT_SUPPORTED_OPERATION)).when(mockBucket).putObjectTagging("dir/", twoTagsMap);
+
+ try {
+ endpoint.put("fsoBucket", "dir/", 0, 1, null, "", twoTags());
+ fail("Expected an OS3Exception to be thrown");
+ } catch (OS3Exception ex) {
+ assertEquals(HTTP_NOT_IMPLEMENTED, ex.getHttpCode());
+ assertEquals(NOT_IMPLEMENTED.getCode(), ex.getCode());
+ }
+ }
+
+ private InputStream emptyBody() {
+ return null;
+ }
+
+ private InputStream invalidXmlStructure() {
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ " <TagSet>" +
+ " </Ta" +
+ "Tagging>";
+
+ return new ByteArrayInputStream(xml.getBytes(UTF_8));
+ }
+
+ private InputStream twoTags() {
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ " <TagSet>" +
+ " <Tag>" +
+ " <Key>tag1</Key>" +
+ " <Value>val1</Value>" +
+ " </Tag>" +
+ " <Tag>" +
+ " <Key>tag2</Key>" +
+ " <Value>val2</Value>" +
+ " </Tag>" +
+ " </TagSet>" +
+ "</Tagging>";
+
+ return new ByteArrayInputStream(xml.getBytes(UTF_8));
+ }
+
+ private InputStream noTagSet() {
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ "</Tagging>";
+ return new ByteArrayInputStream(xml.getBytes(UTF_8));
+ }
+
+ private InputStream emptyTags() {
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ " <TagSet>" +
+ " </TagSet>" +
+ "</Tagging>";
+
+ return new ByteArrayInputStream(xml.getBytes(UTF_8));
+ }
+
+ public InputStream tagKeyNotSpecified() {
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ " <TagSet>" +
+ " <Tag>" +
+ " <Value>val1</Value>" +
+ " </Tag>" +
+ " </TagSet>" +
+ "</Tagging>";
+
+ return new ByteArrayInputStream(xml.getBytes(UTF_8));
+ }
+
+ public InputStream tagValueNotSpecified() {
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ " <TagSet>" +
+ " <Tag>" +
+ " <Key>tag1</Key>" +
+ " </Tag>" +
+ " </TagSet>" +
+ "</Tagging>";
+
+ return new ByteArrayInputStream(xml.getBytes(UTF_8));
+ }
+}
+
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUpload.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUpload.java
index fbff764829..6341e3d178 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUpload.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUpload.java
@@ -100,7 +100,7 @@ public class TestPartUpload {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
response = REST.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
@@ -122,7 +122,7 @@ public class TestPartUpload {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
response = REST.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
@@ -131,7 +131,7 @@ public class TestPartUpload {
// Upload part again with same part Number, the ETag should be changed.
content = "Multipart Upload Changed";
response = REST.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
assertNotEquals(eTag, response.getHeaderString(OzoneConsts.ETAG));
@@ -145,7 +145,7 @@ public class TestPartUpload {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
REST.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY, content.length(), 1,
- "random", body);
+ "random", null, body);
});
assertEquals("NoSuchUpload", ex.getCode());
assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
@@ -179,7 +179,7 @@ public class TestPartUpload {
long contentLength = chunkedContent.length();
objectEndpoint.put(OzoneConsts.S3_BUCKET, keyName, contentLength, 1,
- uploadID, new ByteArrayInputStream(chunkedContent.getBytes(UTF_8)));
+ uploadID, null, new ByteArrayInputStream(chunkedContent.getBytes(UTF_8)));
assertContentLength(uploadID, keyName, 15);
}
@@ -202,7 +202,7 @@ public class TestPartUpload {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
REST.put(OzoneConsts.S3_BUCKET, keyName,
- contentLength, 1, uploadID, body);
+ contentLength, 1, uploadID, null, body);
assertContentLength(uploadID, keyName, content.length());
}
@@ -243,7 +243,7 @@ public class TestPartUpload {
new ByteArrayInputStream(content.getBytes(UTF_8));
try {
objectEndpoint.put(OzoneConsts.S3_BUCKET, OzoneConsts.KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
fail("Should throw IOException");
} catch (IOException ignored) {
// Verify that the message digest is reset so that the instance can be reused for the
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java
index 28ce32e747..507e997b29 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java
@@ -94,7 +94,7 @@ public class TestPartUploadWithStream {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
response = REST.put(S3BUCKET, S3KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
@@ -115,7 +115,7 @@ public class TestPartUploadWithStream {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
response = REST.put(S3BUCKET, S3KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
@@ -124,7 +124,7 @@ public class TestPartUploadWithStream {
// Upload part again with same part Number, the ETag should be changed.
content = "Multipart Upload Changed";
response = REST.put(S3BUCKET, S3KEY,
- content.length(), 1, uploadID, body);
+ content.length(), 1, uploadID, null, body);
assertNotNull(response.getHeaderString(OzoneConsts.ETAG));
assertNotEquals(eTag, response.getHeaderString(OzoneConsts.ETAG));
@@ -137,7 +137,7 @@ public class TestPartUploadWithStream {
ByteArrayInputStream body =
new ByteArrayInputStream(content.getBytes(UTF_8));
REST.put(S3BUCKET, S3KEY, content.length(), 1,
- "random", body);
+ "random", null, body);
});
assertEquals("NoSuchUpload", ex.getCode());
assertEquals(HTTP_NOT_FOUND, ex.getHttpCode());
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPermissionCheck.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPermissionCheck.java
index b74808de95..70e5665f17 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPermissionCheck.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPermissionCheck.java
@@ -38,12 +38,14 @@ import javax.ws.rs.core.HttpHeaders;
import java.io.ByteArrayInputStream;
import java.io.IOException;
+import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static java.net.HttpURLConnection.HTTP_FORBIDDEN;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.anyLong;
@@ -245,7 +247,7 @@ public class TestPermissionCheck {
objectEndpoint.setOzoneConfiguration(conf);
OS3Exception e = assertThrows(OS3Exception.class, () -> objectEndpoint.get(
- "bucketName", "keyPath", 0, null, 1000, "marker"));
+ "bucketName", "keyPath", 0, null, 1000, "marker", null));
assertEquals(HTTP_FORBIDDEN, e.getHttpCode());
}
@@ -261,7 +263,7 @@ public class TestPermissionCheck {
objectEndpoint.setOzoneConfiguration(conf);
OS3Exception e = assertThrows(OS3Exception.class, () -> objectEndpoint.put(
- "bucketName", "keyPath", 1024, 0, null,
+ "bucketName", "keyPath", 1024, 0, null, null,
new ByteArrayInputStream(new byte[]{})));
assertEquals(HTTP_FORBIDDEN, e.getHttpCode());
}
@@ -277,7 +279,7 @@ public class TestPermissionCheck {
objectEndpoint.setOzoneConfiguration(conf);
OS3Exception e = assertThrows(OS3Exception.class, () ->
- objectEndpoint.delete("bucketName", "keyPath", null));
+ objectEndpoint.delete("bucketName", "keyPath", null, null));
assertEquals(HTTP_FORBIDDEN, e.getHttpCode());
}
@@ -294,4 +296,44 @@ public class TestPermissionCheck {
objectEndpoint.initializeMultipartUpload("bucketName", "keyPath"));
assertEquals(HTTP_FORBIDDEN, e.getHttpCode());
}
+
+ @Test
+ public void testObjectTagging() throws Exception {
+ when(objectStore.getVolume(anyString())).thenReturn(volume);
+ when(objectStore.getS3Volume()).thenReturn(volume);
+ when(objectStore.getS3Bucket(anyString())).thenReturn(bucket);
+ when(volume.getBucket("bucketName")).thenReturn(bucket);
+ when(bucket.getObjectTagging(anyString())).thenThrow(exception);
+ doThrow(exception).when(bucket).putObjectTagging(anyString(), anyMap());
+ doThrow(exception).when(bucket).deleteObjectTagging(anyString());
+
+ ObjectEndpoint objectEndpoint = new ObjectEndpoint();
+ objectEndpoint.setClient(client);
+
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ " <TagSet>" +
+ " <Tag>" +
+ " <Key>tag1</Key>" +
+ " <Value>val1</Value>" +
+ " </Tag>" +
+ " </TagSet>" +
+ "</Tagging>";
+
+ InputStream tagInput = new ByteArrayInputStream(xml.getBytes(UTF_8));
+
+ OS3Exception e = assertThrows(OS3Exception.class, () ->
+ objectEndpoint.put("bucketName", "keyPath", 0, 1,
+ null, "", tagInput));
+ assertEquals(HTTP_FORBIDDEN, e.getHttpCode());
+
+ e = assertThrows(OS3Exception.class, () ->
+ objectEndpoint.delete("bucketName", "keyPath", "", ""));
+ assertEquals(HTTP_FORBIDDEN, e.getHttpCode());
+
+ e = assertThrows(OS3Exception.class, () ->
+ objectEndpoint.get("bucketName", "keyPath", 0, null,
+ 0, null, ""));
+ assertEquals(HTTP_FORBIDDEN, e.getHttpCode());
+ }
}
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java
index d988b43023..6dbcada1df 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java
@@ -106,7 +106,7 @@ public class TestUploadWithStream {
byte[] keyContent = S3_COPY_EXISTING_KEY_CONTENT.getBytes(UTF_8);
ByteArrayInputStream body =
new ByteArrayInputStream(keyContent);
- Response response = REST.put(S3BUCKET, S3KEY, 0, 0, null, body);
+ Response response = REST.put(S3BUCKET, S3KEY, 0, 0, null, null, body);
assertEquals(200, response.getStatus());
}
@@ -140,7 +140,7 @@ public class TestUploadWithStream {
.forEach((k, v) -> when(headers.getHeaderString(k)).thenReturn(v));
REST.setHeaders(headers);
- Response response = REST.put(S3BUCKET, S3KEY, 0, 0, null, null);
+ Response response = REST.put(S3BUCKET, S3KEY, 0, 0, null, null, null);
assertEquals(200, response.getStatus());
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/metrics/TestS3GatewayMetrics.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/metrics/TestS3GatewayMetrics.java
index 947b0986c8..5bf4201b98 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/metrics/TestS3GatewayMetrics.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/metrics/TestS3GatewayMetrics.java
@@ -310,7 +310,7 @@ public class TestS3GatewayMetrics {
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
// Create the file
keyEndpoint.put(bucketName, keyName, CONTENT
- .length(), 1, null, body);
+ .length(), 1, null, null, body);
body.close();
long curMetric = metrics.getCreateKeySuccess();
assertEquals(1L, curMetric - oriMetric);
@@ -322,7 +322,7 @@ public class TestS3GatewayMetrics {
// Create the file in a bucket that does not exist
OS3Exception e = assertThrows(OS3Exception.class, () -> keyEndpoint.put(
- "unknownBucket", keyName, CONTENT.length(), 1, null, null));
+ "unknownBucket", keyName, CONTENT.length(), 1, null, null, null));
assertEquals(S3ErrorTable.NO_SUCH_BUCKET.getCode(), e.getCode());
long curMetric = metrics.getCreateKeyFailure();
assertEquals(1L, curMetric - oriMetric);
@@ -334,7 +334,7 @@ public class TestS3GatewayMetrics {
long oriMetric = metrics.getDeleteKeySuccess();
bucket.createKey(keyName, 0).close();
- keyEndpoint.delete(bucketName, keyName, null);
+ keyEndpoint.delete(bucketName, keyName, null, null);
long curMetric = metrics.getDeleteKeySuccess();
assertEquals(1L, curMetric - oriMetric);
}
@@ -343,7 +343,7 @@ public class TestS3GatewayMetrics {
public void testDeleteKeyFailure() throws Exception {
long oriMetric = metrics.getDeleteKeyFailure();
OS3Exception e = assertThrows(OS3Exception.class, () -> keyEndpoint.delete(
- "unknownBucket", keyName, null));
+ "unknownBucket", keyName, null, null));
assertEquals(S3ErrorTable.NO_SUCH_BUCKET.getCode(), e.getCode());
long curMetric = metrics.getDeleteKeyFailure();
assertEquals(1L, curMetric - oriMetric);
@@ -358,9 +358,9 @@ public class TestS3GatewayMetrics {
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
// Create the file
keyEndpoint.put(bucketName, keyName, CONTENT
- .length(), 1, null, body);
+ .length(), 1, null, null, body);
// GET the key from the bucket
- Response response = keyEndpoint.get(bucketName, keyName, 0, null, 0, null);
+ Response response = keyEndpoint.get(bucketName, keyName, 0, null, 0, null, null);
StreamingOutput stream = (StreamingOutput) response.getEntity();
stream.write(new ByteArrayOutputStream());
long curMetric = metrics.getGetKeySuccess();
@@ -373,7 +373,7 @@ public class TestS3GatewayMetrics {
// Fetching a non-existent key
OS3Exception e = assertThrows(OS3Exception.class, () -> keyEndpoint.get(
- bucketName, "unknownKey", 0, null, 0, null));
+ bucketName, "unknownKey", 0, null, 0, null, null));
assertEquals(S3ErrorTable.NO_SUCH_KEY.getCode(), e.getCode());
long curMetric = metrics.getGetKeyFailure();
assertEquals(1L, curMetric - oriMetric);
@@ -407,7 +407,7 @@ public class TestS3GatewayMetrics {
long oriMetric = metrics.getAbortMultiPartUploadSuccess();
// Abort the Upload Successfully by deleting the key using the Upload-Id
- keyEndpoint.delete(bucketName, keyName, uploadID);
+ keyEndpoint.delete(bucketName, keyName, uploadID, null);
long curMetric = metrics.getAbortMultiPartUploadSuccess();
assertEquals(1L, curMetric - oriMetric);
@@ -419,7 +419,7 @@ public class TestS3GatewayMetrics {
// Fail the Abort Method by providing wrong uploadID
OS3Exception e = assertThrows(OS3Exception.class, () -> keyEndpoint.delete(
- bucketName, keyName, "wrongId"));
+ bucketName, keyName, "wrongId", null));
assertEquals(S3ErrorTable.NO_SUCH_UPLOAD.getCode(), e.getCode());
long curMetric = metrics.getAbortMultiPartUploadFailure();
assertEquals(1L, curMetric - oriMetric);
@@ -466,7 +466,7 @@ public class TestS3GatewayMetrics {
ByteArrayInputStream body =
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
keyEndpoint.put(bucketName, keyName, CONTENT.length(),
- 1, uploadID, body);
+ 1, uploadID, null, body);
long curMetric = metrics.getCreateMultipartKeySuccess();
assertEquals(1L, curMetric - oriMetric);
}
@@ -475,7 +475,7 @@ public class TestS3GatewayMetrics {
public void testCreateMultipartKeyFailure() throws Exception {
long oriMetric = metrics.getCreateMultipartKeyFailure();
OS3Exception e = assertThrows(OS3Exception.class, () -> keyEndpoint.put(
- bucketName, keyName, CONTENT.length(), 1, "randomId", null));
+ bucketName, keyName, CONTENT.length(), 1, "randomId", null, null));
assertEquals(S3ErrorTable.NO_SUCH_UPLOAD.getCode(), e.getCode());
long curMetric = metrics.getCreateMultipartKeyFailure();
assertEquals(1L, curMetric - oriMetric);
@@ -490,7 +490,7 @@ public class TestS3GatewayMetrics {
// Listing out the parts by providing the uploadID
keyEndpoint.get(bucketName, keyName, 0,
- uploadID, 3, null);
+ uploadID, 3, null, null);
long curMetric = metrics.getListPartsSuccess();
assertEquals(1L, curMetric - oriMetric);
}
@@ -501,7 +501,7 @@ public class TestS3GatewayMetrics {
long oriMetric = metrics.getListPartsFailure();
// Listing out the parts by providing the uploadID after aborting
OS3Exception e = assertThrows(OS3Exception.class, () -> keyEndpoint.get(
- bucketName, keyName, 0, "wrong_id", 3, null));
+ bucketName, keyName, 0, "wrong_id", 3, null, null));
assertEquals(S3ErrorTable.NO_SUCH_UPLOAD.getCode(), e.getCode());
long curMetric = metrics.getListPartsFailure();
assertEquals(1L, curMetric - oriMetric);
@@ -522,14 +522,14 @@ public class TestS3GatewayMetrics {
new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
keyEndpoint.put(bucketName, keyName,
- CONTENT.length(), 1, null, body);
+ CONTENT.length(), 1, null, null, body);
// Add copy header, and then call put
when(headers.getHeaderString(COPY_SOURCE_HEADER)).thenReturn(
bucketName + "/" + urlEncode(keyName));
keyEndpoint.put(destBucket, destKey, CONTENT.length(), 1,
- null, body);
+ null, null, body);
long curMetric = metrics.getCopyObjectSuccess();
assertEquals(1L, curMetric - oriMetric);
@@ -538,13 +538,113 @@ public class TestS3GatewayMetrics {
// source and dest same
when(headers.getHeaderString(STORAGE_CLASS_HEADER)).thenReturn("");
OS3Exception e = assertThrows(OS3Exception.class, () -> keyEndpoint.put(
- bucketName, keyName, CONTENT.length(), 1, null, body),
+ bucketName, keyName, CONTENT.length(), 1, null, null, body),
"Test for CopyObjectMetric failed");
assertThat(e.getErrorMessage()).contains("This copy request is illegal");
curMetric = metrics.getCopyObjectFailure();
assertEquals(1L, curMetric - oriMetric);
}
+ @Test
+ public void testPutObjectTaggingSuccess() throws Exception {
+ long oriMetric = metrics.getPutObjectTaggingSuccess();
+
+ ByteArrayInputStream body =
+ new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
+ // Create the file
+ keyEndpoint.put(bucketName, keyName, CONTENT
+ .length(), 1, null, null, body);
+ body.close();
+
+ // Put object tagging
+ keyEndpoint.put(bucketName, keyName, 0, 1, null, "", getPutTaggingBody());
+
+ long curMetric = metrics.getPutObjectTaggingSuccess();
+ assertEquals(1L, curMetric - oriMetric);
+ }
+
+ @Test
+ public void testPutObjectTaggingFailure() throws Exception {
+ long oriMetric = metrics.getPutObjectTaggingFailure();
+
+ // Put object tagging for nonexistent key
+ OS3Exception ex = assertThrows(OS3Exception.class, () ->
+ keyEndpoint.put(bucketName, "nonexistent", 0, 1, null, "", getPutTaggingBody())
+ );
+ assertEquals(S3ErrorTable.NO_SUCH_KEY.getCode(), ex.getCode());
+
+ long curMetric = metrics.getPutObjectTaggingFailure();
+ assertEquals(1L, curMetric - oriMetric);
+ }
+
+ @Test
+ public void testGetObjectTaggingSuccess() throws Exception {
+ long oriMetric = metrics.getGetObjectTaggingSuccess();
+
+ // Create the file
+ ByteArrayInputStream body =
+ new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
+ keyEndpoint.put(bucketName, keyName, CONTENT
+ .length(), 1, null, null, body);
+ body.close();
+
+ // Put object tagging
+ keyEndpoint.put(bucketName, keyName, 0, 1, null, "", getPutTaggingBody());
+
+ // Get object tagging
+ keyEndpoint.get(bucketName, keyName, 0,
+ null, 0, null, "");
+
+ long curMetric = metrics.getGetObjectTaggingSuccess();
+ assertEquals(1L, curMetric - oriMetric);
+ }
+
+ @Test
+ public void testGetObjectTaggingFailure() throws Exception {
+ long oriMetric = metrics.getGetObjectTaggingFailure();
+
+ // Get object tagging for nonexistent key
+ OS3Exception ex = assertThrows(OS3Exception.class, () ->
+ keyEndpoint.get(bucketName, "nonexistent", 0, null,
+ 0, null, ""));
+ assertEquals(S3ErrorTable.NO_SUCH_KEY.getCode(), ex.getCode());
+ long curMetric = metrics.getGetObjectTaggingFailure();
+ assertEquals(1L, curMetric - oriMetric);
+ }
+
+ @Test
+ public void testDeleteObjectTaggingSuccess() throws Exception {
+ long oriMetric = metrics.getDeleteObjectTaggingSuccess();
+
+ // Create the file
+ ByteArrayInputStream body =
+ new ByteArrayInputStream(CONTENT.getBytes(UTF_8));
+ keyEndpoint.put(bucketName, keyName, CONTENT
+ .length(), 1, null, null, body);
+ body.close();
+
+ // Put object tagging
+ keyEndpoint.put(bucketName, keyName, 0, 1, null, "", getPutTaggingBody());
+
+ // Delete object tagging
+ keyEndpoint.delete(bucketName, keyName, null, "");
+
+ long curMetric = metrics.getDeleteObjectTaggingSuccess();
+ assertEquals(1L, curMetric - oriMetric);
+ }
+
+ @Test
+ public void testDeleteObjectTaggingFailure() throws Exception {
+ long oriMetric = metrics.getDeleteObjectTaggingFailure();
+
+ // Delete object tagging for nonexistent key
+ OS3Exception ex = assertThrows(OS3Exception.class, () ->
+ keyEndpoint.delete(bucketName, "nonexistent", null, ""));
+ assertEquals(S3ErrorTable.NO_SUCH_KEY.getCode(), ex.getCode());
+ long curMetric = metrics.getDeleteObjectTaggingFailure();
+ assertEquals(1L, curMetric - oriMetric);
+ }
+
private OzoneClient createClientWithKeys(String... keys) throws IOException {
for (String key : keys) {
bucket.createKey(key, 0).close();
@@ -567,4 +667,18 @@ public class TestS3GatewayMetrics {
}
return "Invalid-Id";
}
+
+ private static InputStream getPutTaggingBody() {
+ String xml =
+ "<Tagging xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">" +
+ " <TagSet>" +
+ " <Tag>" +
+ " <Key>tag1</Key>" +
+ " <Value>val1</Value>" +
+ " </Tag>" +
+ " </TagSet>" +
+ "</Tagging>";
+
+ return new ByteArrayInputStream(xml.getBytes(UTF_8));
+ }
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@ozone.apache.org
For additional commands, e-mail: commits-help@ozone.apache.org