You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ozone.apache.org by ra...@apache.org on 2021/04/08 03:56:32 UTC
[ozone] 26/32: HDDS-4917.[FSO]Implement ACL requests for new layout
(#2024)
This is an automated email from the ASF dual-hosted git repository.
rakeshr pushed a commit to branch HDDS-2939
in repository https://gitbox.apache.org/repos/asf/ozone.git
commit 81361d6e1bb35614e160ec43d4fb0514f133f9d1
Author: Sadanand Shenoy <sa...@gmail.com>
AuthorDate: Mon Mar 15 21:40:23 2021 +0530
HDDS-4917.[FSO]Implement ACL requests for new layout (#2024)
---
.../org/apache/hadoop/ozone/om/KeyManagerImpl.java | 8 +-
.../om/ratis/utils/OzoneManagerRatisUtils.java | 12 ++
.../om/request/key/acl/OMKeyAclRequestV1.java | 165 +++++++++++++++++++++
.../om/request/key/acl/OMKeyAddAclRequestV1.java | 149 +++++++++++++++++++
.../request/key/acl/OMKeyRemoveAclRequestV1.java | 153 +++++++++++++++++++
.../om/request/key/acl/OMKeySetAclRequestV1.java | 146 ++++++++++++++++++
.../om/response/key/acl/OMKeyAclResponse.java | 3 +
.../om/response/key/acl/OMKeyAclResponseV1.java | 75 ++++++++++
.../ozone/om/request/key/TestOMKeyAclRequest.java | 81 ++++++----
.../om/request/key/TestOMKeyAclRequestV1.java | 81 ++++++++++
10 files changed, 845 insertions(+), 28 deletions(-)
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 f45a96b..b2ff866 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
@@ -1698,12 +1698,16 @@ public class KeyManagerImpl implements KeyManager {
String volume = obj.getVolumeName();
String bucket = obj.getBucketName();
String keyName = obj.getKeyName();
-
+ OmKeyInfo keyInfo;
metadataManager.getLock().acquireReadLock(BUCKET_LOCK, volume, bucket);
try {
validateBucket(volume, bucket);
String objectKey = metadataManager.getOzoneKey(volume, bucket, keyName);
- OmKeyInfo keyInfo = metadataManager.getKeyTable().get(objectKey);
+ if (OzoneManagerRatisUtils.isBucketFSOptimized()) {
+ keyInfo = getOmKeyInfoV1(volume, bucket, keyName);
+ } else {
+ keyInfo = getOmKeyInfo(volume, bucket, keyName);
+ }
if (keyInfo == null) {
throw new OMException("Key not found. Key:" + objectKey, KEY_NOT_FOUND);
}
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 52305253..b3e6c4f 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
@@ -50,8 +50,11 @@ import org.apache.hadoop.ozone.om.request.key.OMKeyRenameRequestV1;
import org.apache.hadoop.ozone.om.request.key.OMKeysRenameRequest;
import org.apache.hadoop.ozone.om.request.key.OMTrashRecoverRequest;
import org.apache.hadoop.ozone.om.request.key.acl.OMKeyAddAclRequest;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeyAddAclRequestV1;
import org.apache.hadoop.ozone.om.request.key.acl.OMKeyRemoveAclRequest;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeyRemoveAclRequestV1;
import org.apache.hadoop.ozone.om.request.key.acl.OMKeySetAclRequest;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeySetAclRequestV1;
import org.apache.hadoop.ozone.om.request.key.acl.prefix.OMPrefixAddAclRequest;
import org.apache.hadoop.ozone.om.request.key.acl.prefix.OMPrefixRemoveAclRequest;
import org.apache.hadoop.ozone.om.request.key.acl.prefix.OMPrefixSetAclRequest;
@@ -230,6 +233,9 @@ public final class OzoneManagerRatisUtils {
} else if (ObjectType.BUCKET == type) {
return new OMBucketAddAclRequest(omRequest);
} else if (ObjectType.KEY == type) {
+ if (isBucketFSOptimized()){
+ return new OMKeyAddAclRequestV1(omRequest);
+ }
return new OMKeyAddAclRequest(omRequest);
} else {
return new OMPrefixAddAclRequest(omRequest);
@@ -241,6 +247,9 @@ public final class OzoneManagerRatisUtils {
} else if (ObjectType.BUCKET == type) {
return new OMBucketRemoveAclRequest(omRequest);
} else if (ObjectType.KEY == type) {
+ if (isBucketFSOptimized()){
+ return new OMKeyRemoveAclRequestV1(omRequest);
+ }
return new OMKeyRemoveAclRequest(omRequest);
} else {
return new OMPrefixRemoveAclRequest(omRequest);
@@ -252,6 +261,9 @@ public final class OzoneManagerRatisUtils {
} else if (ObjectType.BUCKET == type) {
return new OMBucketSetAclRequest(omRequest);
} else if (ObjectType.KEY == type) {
+ if (isBucketFSOptimized()){
+ return new OMKeySetAclRequestV1(omRequest);
+ }
return new OMKeySetAclRequest(omRequest);
} else {
return new OMPrefixSetAclRequest(omRequest);
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyAclRequestV1.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyAclRequestV1.java
new file mode 100644
index 0000000..3dfb29e
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyAclRequestV1.java
@@ -0,0 +1,165 @@
+/**
+ * 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.key.acl;
+
+import com.google.common.base.Optional;
+import org.apache.hadoop.hdds.utils.db.Table;
+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.OzoneManager;
+import org.apache.hadoop.ozone.om.exceptions.OMException;
+import org.apache.hadoop.ozone.om.helpers.OmDirectoryInfo;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.helpers.OzoneFileStatus;
+import org.apache.hadoop.ozone.om.ratis.utils.OzoneManagerDoubleBufferHelper;
+import org.apache.hadoop.ozone.om.request.file.OMFileRequest;
+import org.apache.hadoop.ozone.om.request.util.ObjectParser;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.key.acl.OMKeyAclResponseV1;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.ozone.security.acl.IAccessAuthorizer;
+import org.apache.hadoop.ozone.security.acl.OzoneObj;
+
+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 key ACL requests layout version V1.
+ */
+public abstract class OMKeyAclRequestV1 extends OMKeyAclRequest {
+
+ public OMKeyAclRequestV1(OzoneManagerProtocolProtos.OMRequest omRequest) {
+ super(omRequest);
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager,
+ long trxnLogIndex, OzoneManagerDoubleBufferHelper omDoubleBufferHelper) {
+ OmKeyInfo omKeyInfo = null;
+
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse = onInit();
+ OMClientResponse omClientResponse = null;
+ IOException exception = null;
+
+ OMMetadataManager omMetadataManager = ozoneManager.getMetadataManager();
+ boolean lockAcquired = false;
+ String volume = null;
+ String bucket = null;
+ String key = null;
+ boolean operationResult = false;
+ Result result = null;
+ try {
+ ObjectParser objectParser = new ObjectParser(getPath(),
+ OzoneManagerProtocolProtos.OzoneObj.ObjectType.KEY);
+
+ volume = objectParser.getVolume();
+ bucket = objectParser.getBucket();
+ key = objectParser.getKey();
+
+ // check Acl
+ if (ozoneManager.getAclsEnabled()) {
+ checkAcls(ozoneManager, OzoneObj.ResourceType.VOLUME,
+ OzoneObj.StoreType.OZONE, IAccessAuthorizer.ACLType.WRITE_ACL,
+ volume, bucket, key);
+ }
+ lockAcquired = omMetadataManager.getLock()
+ .acquireWriteLock(BUCKET_LOCK, volume, bucket);
+ OzoneFileStatus keyStatus = OMFileRequest
+ .getOMKeyInfoIfExists(omMetadataManager, volume, bucket, key, 0);
+ if (keyStatus == null) {
+ throw new OMException("Key not found. Key:" + key, KEY_NOT_FOUND);
+ }
+ omKeyInfo = keyStatus.getKeyInfo();
+ String dbKey = omKeyInfo.getPath();
+ boolean isDirectory = keyStatus.isDirectory();
+ operationResult = apply(omKeyInfo, trxnLogIndex);
+ omKeyInfo.setUpdateID(trxnLogIndex, ozoneManager.isRatisEnabled());
+
+ // Update the modification time when updating ACLs of Key.
+ long modificationTime = omKeyInfo.getModificationTime();
+ if (getOmRequest().getAddAclRequest().hasObj() && operationResult) {
+ modificationTime =
+ getOmRequest().getAddAclRequest().getModificationTime();
+ } else if (getOmRequest().getSetAclRequest().hasObj()) {
+ modificationTime =
+ getOmRequest().getSetAclRequest().getModificationTime();
+ } else if (getOmRequest().getRemoveAclRequest().hasObj()
+ && operationResult) {
+ modificationTime =
+ getOmRequest().getRemoveAclRequest().getModificationTime();
+ }
+ omKeyInfo.setModificationTime(modificationTime);
+
+ // update cache.
+ if (isDirectory) {
+ Table<String, OmDirectoryInfo> dirTable =
+ omMetadataManager.getDirectoryTable();
+ dirTable.addCacheEntry(new CacheKey<>(dbKey),
+ new CacheValue<>(Optional.of(OMFileRequest.
+ getDirectoryInfo(omKeyInfo)), trxnLogIndex));
+ } else {
+ omMetadataManager.getKeyTable().addCacheEntry(new CacheKey<>(dbKey),
+ new CacheValue<>(Optional.of(omKeyInfo), trxnLogIndex));
+ }
+ omClientResponse =
+ onSuccess(omResponse, omKeyInfo, operationResult, isDirectory);
+ result = Result.SUCCESS;
+ } catch (IOException ex) {
+ result = Result.FAILURE;
+ exception = ex;
+ omClientResponse = onFailure(omResponse, ex);
+ } finally {
+ addResponseToDoubleBuffer(trxnLogIndex, omClientResponse,
+ omDoubleBufferHelper);
+ if (lockAcquired) {
+ omMetadataManager.getLock()
+ .releaseWriteLock(BUCKET_LOCK, volume, bucket);
+ }
+ }
+
+ OzoneObj obj = getObject();
+ Map<String, String> auditMap = obj.toAuditMap();
+ onComplete(result, operationResult, exception, trxnLogIndex,
+ ozoneManager.getAuditLogger(), auditMap);
+
+ return omClientResponse;
+ }
+
+ /**
+ * Get the om client response on failure case with lock.
+ *
+ * @param omResponse
+ * @param exception
+ * @return OMClientResponse
+ */
+ @Override OMClientResponse onFailure(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ IOException exception) {
+ return new OMKeyAclResponseV1(createErrorOMResponse(omResponse, exception));
+ }
+
+ abstract OMClientResponse onSuccess(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ OmKeyInfo omKeyInfo, boolean operationResult, boolean isDirectory);
+
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyAddAclRequestV1.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyAddAclRequestV1.java
new file mode 100644
index 0000000..dbe0289
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyAddAclRequestV1.java
@@ -0,0 +1,149 @@
+/**
+ * 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.key.acl;
+
+import com.google.common.collect.Lists;
+import org.apache.hadoop.ozone.OzoneAcl;
+import org.apache.hadoop.ozone.OzoneConsts;
+import org.apache.hadoop.ozone.audit.AuditLogger;
+import org.apache.hadoop.ozone.audit.OMAction;
+import org.apache.hadoop.ozone.om.OzoneManager;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.ratis.utils.OzoneManagerDoubleBufferHelper;
+import org.apache.hadoop.ozone.om.request.util.OmResponseUtil;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.key.acl.OMKeyAclResponse;
+import org.apache.hadoop.ozone.om.response.key.acl.OMKeyAclResponseV1;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.ozone.security.acl.OzoneObj;
+import org.apache.hadoop.ozone.security.acl.OzoneObjInfo;
+import org.apache.hadoop.util.Time;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Handle add Acl request for bucket for layout version V1.
+ */
+public class OMKeyAddAclRequestV1 extends OMKeyAclRequestV1 {
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(OMKeyAddAclRequestV1.class);
+
+ @Override public OzoneManagerProtocolProtos.OMRequest preExecute(
+ OzoneManager ozoneManager) throws IOException {
+ long modificationTime = Time.now();
+ OzoneManagerProtocolProtos.AddAclRequest.Builder addAclRequestBuilder =
+ getOmRequest().getAddAclRequest().toBuilder()
+ .setModificationTime(modificationTime);
+
+ return getOmRequest().toBuilder().setAddAclRequest(addAclRequestBuilder)
+ .setUserInfo(getUserInfo()).build();
+ }
+
+ private String path;
+ private List<OzoneAcl> ozoneAcls;
+ private OzoneObj obj;
+
+ public OMKeyAddAclRequestV1(OzoneManagerProtocolProtos.OMRequest omRequest) {
+ super(omRequest);
+ OzoneManagerProtocolProtos.AddAclRequest addAclRequest =
+ getOmRequest().getAddAclRequest();
+ obj = OzoneObjInfo.fromProtobuf(addAclRequest.getObj());
+ path = obj.getPath();
+ ozoneAcls =
+ Lists.newArrayList(OzoneAcl.fromProtobuf(addAclRequest.getAcl()));
+ }
+
+ @Override String getPath() {
+ return path;
+ }
+
+ @Override OzoneObj getObject() {
+ return obj;
+ }
+
+ @Override OzoneManagerProtocolProtos.OMResponse.Builder onInit() {
+ return OmResponseUtil.getOMResponseBuilder(getOmRequest());
+ }
+
+ @Override OMClientResponse onSuccess(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ OmKeyInfo omKeyInfo, boolean operationResult) {
+ omResponse.setSuccess(operationResult);
+ omResponse.setAddAclResponse(
+ OzoneManagerProtocolProtos.AddAclResponse.newBuilder()
+ .setResponse(operationResult));
+ return new OMKeyAclResponse(omResponse.build(), omKeyInfo);
+ }
+
+ @Override void onComplete(Result result, boolean operationResult,
+ IOException exception, long trxnLogIndex, AuditLogger auditLogger,
+ Map<String, String> auditMap) {
+ switch (result) {
+ case SUCCESS:
+ if (LOG.isDebugEnabled()) {
+ if (operationResult) {
+ LOG.debug("Add acl: {} to path: {} success!", ozoneAcls, path);
+ } else {
+ LOG.debug("Acl {} already exists in path {}", ozoneAcls, path);
+ }
+ }
+ break;
+ case FAILURE:
+ LOG.error("Add acl {} to path {} failed!", ozoneAcls, path, exception);
+ break;
+ default:
+ LOG.error("Unrecognized Result for OMKeyAddAclRequest: {}",
+ getOmRequest());
+ }
+
+ if (ozoneAcls != null) {
+ auditMap.put(OzoneConsts.ACL, ozoneAcls.toString());
+ }
+ auditLog(auditLogger,
+ buildAuditMessage(OMAction.ADD_ACL, auditMap, exception,
+ getOmRequest().getUserInfo()));
+ }
+
+ @Override boolean apply(OmKeyInfo omKeyInfo, long trxnLogIndex) {
+ // No need to check not null here, this will be never called with null.
+ return omKeyInfo.addAcl(ozoneAcls.get(0));
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager,
+ long trxnLogIndex, OzoneManagerDoubleBufferHelper omDoubleBufferHelper) {
+ ozoneManager.getMetrics().incNumAddAcl();
+ return super.validateAndUpdateCache(ozoneManager, trxnLogIndex,
+ omDoubleBufferHelper);
+ }
+
+ @Override OMClientResponse onSuccess(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ OmKeyInfo omKeyInfo, boolean operationResult, boolean isDirectory) {
+ omResponse.setSuccess(operationResult);
+ omResponse.setAddAclResponse(
+ OzoneManagerProtocolProtos.AddAclResponse.newBuilder()
+ .setResponse(operationResult));
+ return new OMKeyAclResponseV1(omResponse.build(), omKeyInfo, isDirectory);
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyRemoveAclRequestV1.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyRemoveAclRequestV1.java
new file mode 100644
index 0000000..2d377d1
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeyRemoveAclRequestV1.java
@@ -0,0 +1,153 @@
+/**
+ * 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.key.acl;
+
+import com.google.common.collect.Lists;
+import org.apache.hadoop.ozone.OzoneAcl;
+import org.apache.hadoop.ozone.OzoneConsts;
+import org.apache.hadoop.ozone.audit.AuditLogger;
+import org.apache.hadoop.ozone.audit.OMAction;
+import org.apache.hadoop.ozone.om.OzoneManager;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.ratis.utils.OzoneManagerDoubleBufferHelper;
+import org.apache.hadoop.ozone.om.request.util.OmResponseUtil;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.key.acl.OMKeyAclResponse;
+import org.apache.hadoop.ozone.om.response.key.acl.OMKeyAclResponseV1;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.ozone.security.acl.OzoneObj;
+import org.apache.hadoop.ozone.security.acl.OzoneObjInfo;
+import org.apache.hadoop.util.Time;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Handle remove Acl request for bucket for layout version V1.
+ */
+public class OMKeyRemoveAclRequestV1 extends OMKeyAclRequestV1 {
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(OMKeyRemoveAclRequestV1.class);
+
+ @Override public OzoneManagerProtocolProtos.OMRequest preExecute(
+ OzoneManager ozoneManager) throws IOException {
+ long modificationTime = Time.now();
+ OzoneManagerProtocolProtos.RemoveAclRequest.Builder
+ removeAclRequestBuilder =
+ getOmRequest().getRemoveAclRequest().toBuilder()
+ .setModificationTime(modificationTime);
+
+ return getOmRequest().toBuilder()
+ .setRemoveAclRequest(removeAclRequestBuilder).setUserInfo(getUserInfo())
+ .build();
+ }
+
+ private String path;
+ private List<OzoneAcl> ozoneAcls;
+ private OzoneObj obj;
+
+ public OMKeyRemoveAclRequestV1(
+ OzoneManagerProtocolProtos.OMRequest omRequest) {
+ super(omRequest);
+ OzoneManagerProtocolProtos.RemoveAclRequest removeAclRequest =
+ getOmRequest().getRemoveAclRequest();
+ obj = OzoneObjInfo.fromProtobuf(removeAclRequest.getObj());
+ path = obj.getPath();
+ ozoneAcls =
+ Lists.newArrayList(OzoneAcl.fromProtobuf(removeAclRequest.getAcl()));
+ }
+
+ @Override String getPath() {
+ return path;
+ }
+
+ @Override OzoneObj getObject() {
+ return obj;
+ }
+
+ @Override OzoneManagerProtocolProtos.OMResponse.Builder onInit() {
+ return OmResponseUtil.getOMResponseBuilder(getOmRequest());
+ }
+
+ @Override OMClientResponse onSuccess(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ OmKeyInfo omKeyInfo, boolean operationResult) {
+ omResponse.setSuccess(operationResult);
+ omResponse.setRemoveAclResponse(
+ OzoneManagerProtocolProtos.RemoveAclResponse.newBuilder()
+ .setResponse(operationResult));
+ return new OMKeyAclResponse(omResponse.build(), omKeyInfo);
+ }
+
+ @Override void onComplete(Result result, boolean operationResult,
+ IOException exception, long trxnLogIndex, AuditLogger auditLogger,
+ Map<String, String> auditMap) {
+ switch (result) {
+ case SUCCESS:
+ if (LOG.isDebugEnabled()) {
+ if (operationResult) {
+ LOG.debug("Remove acl: {} to path: {} success!", ozoneAcls, path);
+ } else {
+ LOG.debug("Acl {} not removed from path {} as it does not exist",
+ ozoneAcls, path);
+ }
+ }
+ break;
+ case FAILURE:
+ LOG.error("Remove acl {} to path {} failed!", ozoneAcls, path, exception);
+ break;
+ default:
+ LOG.error("Unrecognized Result for OMKeyRemoveAclRequest: {}",
+ getOmRequest());
+ }
+
+ if (ozoneAcls != null) {
+ auditMap.put(OzoneConsts.ACL, ozoneAcls.toString());
+ }
+ auditLog(auditLogger,
+ buildAuditMessage(OMAction.REMOVE_ACL, auditMap, exception,
+ getOmRequest().getUserInfo()));
+ }
+
+ @Override boolean apply(OmKeyInfo omKeyInfo, long trxnLogIndex) {
+ // No need to check not null here, this will be never called with null.
+ return omKeyInfo.removeAcl(ozoneAcls.get(0));
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager,
+ long trxnLogIndex, OzoneManagerDoubleBufferHelper omDoubleBufferHelper) {
+ ozoneManager.getMetrics().incNumRemoveAcl();
+ return super.validateAndUpdateCache(ozoneManager, trxnLogIndex,
+ omDoubleBufferHelper);
+ }
+
+ @Override OMClientResponse onSuccess(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ OmKeyInfo omKeyInfo, boolean operationResult, boolean isDirectory) {
+ omResponse.setSuccess(operationResult);
+ omResponse.setRemoveAclResponse(
+ OzoneManagerProtocolProtos.RemoveAclResponse.newBuilder()
+ .setResponse(operationResult));
+ return new OMKeyAclResponseV1(omResponse.build(), omKeyInfo, isDirectory);
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeySetAclRequestV1.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeySetAclRequestV1.java
new file mode 100644
index 0000000..6b6811e
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/acl/OMKeySetAclRequestV1.java
@@ -0,0 +1,146 @@
+/**
+ * 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.key.acl;
+
+import com.google.common.collect.Lists;
+import org.apache.hadoop.ozone.OzoneAcl;
+import org.apache.hadoop.ozone.OzoneConsts;
+import org.apache.hadoop.ozone.audit.AuditLogger;
+import org.apache.hadoop.ozone.audit.OMAction;
+import org.apache.hadoop.ozone.om.OzoneManager;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.helpers.OzoneAclUtil;
+import org.apache.hadoop.ozone.om.ratis.utils.OzoneManagerDoubleBufferHelper;
+import org.apache.hadoop.ozone.om.request.util.OmResponseUtil;
+import org.apache.hadoop.ozone.om.response.OMClientResponse;
+import org.apache.hadoop.ozone.om.response.key.acl.OMKeyAclResponse;
+import org.apache.hadoop.ozone.om.response.key.acl.OMKeyAclResponseV1;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.ozone.security.acl.OzoneObj;
+import org.apache.hadoop.ozone.security.acl.OzoneObjInfo;
+import org.apache.hadoop.util.Time;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Handle set Acl request for bucket for layout version V1.
+ */
+public class OMKeySetAclRequestV1 extends OMKeyAclRequestV1 {
+
+ private static final Logger LOG =
+ LoggerFactory.getLogger(OMKeySetAclRequestV1.class);
+
+ @Override public OzoneManagerProtocolProtos.OMRequest preExecute(
+ OzoneManager ozoneManager) throws IOException {
+ long modificationTime = Time.now();
+ OzoneManagerProtocolProtos.SetAclRequest.Builder setAclRequestBuilder =
+ getOmRequest().getSetAclRequest().toBuilder()
+ .setModificationTime(modificationTime);
+
+ return getOmRequest().toBuilder().setSetAclRequest(setAclRequestBuilder)
+ .setUserInfo(getUserInfo()).build();
+ }
+
+ private String path;
+ private List<OzoneAcl> ozoneAcls;
+ private OzoneObj obj;
+
+ public OMKeySetAclRequestV1(OzoneManagerProtocolProtos.OMRequest omRequest) {
+ super(omRequest);
+ OzoneManagerProtocolProtos.SetAclRequest setAclRequest =
+ getOmRequest().getSetAclRequest();
+ obj = OzoneObjInfo.fromProtobuf(setAclRequest.getObj());
+ path = obj.getPath();
+ ozoneAcls = Lists
+ .newArrayList(OzoneAclUtil.fromProtobuf(setAclRequest.getAclList()));
+ }
+
+ @Override String getPath() {
+ return path;
+ }
+
+ @Override OzoneObj getObject() {
+ return obj;
+ }
+
+ @Override OzoneManagerProtocolProtos.OMResponse.Builder onInit() {
+ return OmResponseUtil.getOMResponseBuilder(getOmRequest());
+ }
+
+ @Override OMClientResponse onSuccess(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ OmKeyInfo omKeyInfo, boolean operationResult) {
+ omResponse.setSuccess(operationResult);
+ omResponse.setSetAclResponse(
+ OzoneManagerProtocolProtos.SetAclResponse.newBuilder()
+ .setResponse(operationResult));
+ return new OMKeyAclResponse(omResponse.build(), omKeyInfo);
+ }
+
+ @Override void onComplete(Result result, boolean operationResult,
+ IOException exception, long trxnLogIndex, AuditLogger auditLogger,
+ Map<String, String> auditMap) {
+ switch (result) {
+ case SUCCESS:
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Set acl: {} to path: {} success!", ozoneAcls, path);
+ }
+ break;
+ case FAILURE:
+ LOG.error("Set acl {} to path {} failed!", ozoneAcls, path, exception);
+ break;
+ default:
+ LOG.error("Unrecognized Result for OMKeySetAclRequest: {}",
+ getOmRequest());
+ }
+
+ if (ozoneAcls != null) {
+ auditMap.put(OzoneConsts.ACL, ozoneAcls.toString());
+ }
+ auditLog(auditLogger,
+ buildAuditMessage(OMAction.SET_ACL, auditMap, exception,
+ getOmRequest().getUserInfo()));
+ }
+
+ @Override boolean apply(OmKeyInfo omKeyInfo, long trxnLogIndex) {
+ // No need to check not null here, this will be never called with null.
+ return omKeyInfo.setAcls(ozoneAcls);
+ }
+
+ @Override
+ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager,
+ long trxnLogIndex, OzoneManagerDoubleBufferHelper omDoubleBufferHelper) {
+ ozoneManager.getMetrics().incNumSetAcl();
+ return super.validateAndUpdateCache(ozoneManager, trxnLogIndex,
+ omDoubleBufferHelper);
+ }
+
+ @Override OMClientResponse onSuccess(
+ OzoneManagerProtocolProtos.OMResponse.Builder omResponse,
+ OmKeyInfo omKeyInfo, boolean operationResult, boolean isDirectory) {
+ omResponse.setSuccess(operationResult);
+ omResponse.setSetAclResponse(
+ OzoneManagerProtocolProtos.SetAclResponse.newBuilder()
+ .setResponse(operationResult));
+ return new OMKeyAclResponseV1(omResponse.build(), omKeyInfo, isDirectory);
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/key/acl/OMKeyAclResponse.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/key/acl/OMKeyAclResponse.java
index 2bbeae0..299c063 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/key/acl/OMKeyAclResponse.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/key/acl/OMKeyAclResponse.java
@@ -64,5 +64,8 @@ public class OMKeyAclResponse extends OMClientResponse {
omKeyInfo);
}
+ public OmKeyInfo getOmKeyInfo() {
+ return omKeyInfo;
+ }
}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/key/acl/OMKeyAclResponseV1.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/key/acl/OMKeyAclResponseV1.java
new file mode 100644
index 0000000..046a024
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/response/key/acl/OMKeyAclResponseV1.java
@@ -0,0 +1,75 @@
+/**
+ * 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.key.acl;
+
+import org.apache.hadoop.hdds.utils.db.BatchOperation;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.helpers.OmDirectoryInfo;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.request.file.OMFileRequest;
+import org.apache.hadoop.ozone.om.response.CleanupTableInfo;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+
+import static org.apache.hadoop.ozone.om.OmMetadataManagerImpl.DIRECTORY_TABLE;
+import static org.apache.hadoop.ozone.om.OmMetadataManagerImpl.FILE_TABLE;
+
+/**
+ * Response for Bucket acl request for layout version V1.
+ */
+@CleanupTableInfo(cleanupTables = { FILE_TABLE, DIRECTORY_TABLE })
+public class OMKeyAclResponseV1 extends OMKeyAclResponse {
+
+ private boolean isDirectory;
+
+ public OMKeyAclResponseV1(
+ @NotNull OzoneManagerProtocolProtos.OMResponse omResponse,
+ @NotNull OmKeyInfo omKeyInfo, boolean isDirectory) {
+ super(omResponse, omKeyInfo);
+ this.isDirectory = isDirectory;
+ }
+
+ /**
+ * For when the request is not successful.
+ * For a successful request, the other constructor should be used.
+ *
+ * @param omResponse
+ */
+ public OMKeyAclResponseV1(
+ @NotNull OzoneManagerProtocolProtos.OMResponse omResponse) {
+ super(omResponse);
+ }
+
+ @Override public void addToDBBatch(OMMetadataManager omMetadataManager,
+ BatchOperation batchOperation) throws IOException {
+
+ String ozoneDbKey = omMetadataManager
+ .getOzonePathKey(getOmKeyInfo().getParentObjectID(),
+ getOmKeyInfo().getFileName());
+ if (isDirectory) {
+ OmDirectoryInfo dirInfo = OMFileRequest.getDirectoryInfo(getOmKeyInfo());
+ omMetadataManager.getDirectoryTable()
+ .putWithBatch(batchOperation, ozoneDbKey, dirInfo);
+ } else {
+ omMetadataManager.getKeyTable()
+ .putWithBatch(batchOperation, ozoneDbKey, getOmKeyInfo());
+ }
+ }
+}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/TestOMKeyAclRequest.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/TestOMKeyAclRequest.java
index 470cf60..0e28e4b 100644
--- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/TestOMKeyAclRequest.java
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/TestOMKeyAclRequest.java
@@ -20,7 +20,9 @@ package org.apache.hadoop.ozone.om.request.key;
import java.util.List;
import java.util.UUID;
import org.apache.hadoop.ozone.OzoneAcl;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
import org.apache.hadoop.ozone.om.request.TestOMRequestUtils;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeyAclRequest;
import org.apache.hadoop.ozone.om.request.key.acl.OMKeyAddAclRequest;
import org.apache.hadoop.ozone.om.request.key.acl.OMKeyRemoveAclRequest;
import org.apache.hadoop.ozone.om.request.key.acl.OMKeySetAclRequest;
@@ -46,16 +48,18 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
// Manually add volume, bucket and key to DB
TestOMRequestUtils.addVolumeAndBucketToDB(volumeName, bucketName,
omMetadataManager);
- TestOMRequestUtils.addKeyToTable(false, false, volumeName, bucketName,
- keyName, clientID, replicationType, replicationFactor, 1L,
- omMetadataManager);
+ String ozoneKey = addKeyToTable();
+
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable().get(ozoneKey);
+
+ // As we added manually to key table.
+ Assert.assertNotNull(omKeyInfo);
OzoneAcl acl = OzoneAcl.parseAcl("user:bilbo:rwdlncxy[ACCESS]");
// Create KeyAddAcl request
OMRequest originalRequest = createAddAclkeyRequest(acl);
- OMKeyAddAclRequest omKeyAddAclRequest = new OMKeyAddAclRequest(
- originalRequest);
+ OMKeyAclRequest omKeyAddAclRequest = getOmKeyAddAclRequest(originalRequest);
OMRequest preExecuteRequest = omKeyAddAclRequest.preExecute(ozoneManager);
// When preExecute() of adding acl,
@@ -68,7 +72,7 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
// Execute original request
OMClientResponse omClientResponse = omKeyAddAclRequest
- .validateAndUpdateCache(ozoneManager, 2,
+ .validateAndUpdateCache(ozoneManager, 100L,
ozoneManagerDoubleBufferHelper);
Assert.assertEquals(OzoneManagerProtocolProtos.Status.OK,
omClientResponse.getOMResponse().getStatus());
@@ -79,19 +83,22 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
public void testKeyRemoveAclRequest() throws Exception {
TestOMRequestUtils.addVolumeAndBucketToDB(volumeName, bucketName,
omMetadataManager);
- TestOMRequestUtils.addKeyToTable(false, false, volumeName, bucketName,
- keyName, clientID, replicationType, replicationFactor, 1L,
- omMetadataManager);
+ String ozoneKey = addKeyToTable();
+
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable().get(ozoneKey);
+
+ // As we added manually to key table.
+ Assert.assertNotNull(omKeyInfo);
OzoneAcl acl = OzoneAcl.parseAcl("user:bilbo:rwdlncxy[ACCESS]");
// Add acl.
OMRequest addAclRequest = createAddAclkeyRequest(acl);
- OMKeyAddAclRequest omKeyAddAclRequest =
- new OMKeyAddAclRequest(addAclRequest);
+ OMKeyAclRequest omKeyAddAclRequest =
+ getOmKeyAddAclRequest(addAclRequest);
omKeyAddAclRequest.preExecute(ozoneManager);
OMClientResponse omClientAddAclResponse = omKeyAddAclRequest
- .validateAndUpdateCache(ozoneManager, 1,
+ .validateAndUpdateCache(ozoneManager, 100L,
ozoneManagerDoubleBufferHelper);
OMResponse omAddAclResponse = omClientAddAclResponse.getOMResponse();
Assert.assertNotNull(omAddAclResponse.getAddAclResponse());
@@ -99,8 +106,6 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
omAddAclResponse.getStatus());
// Verify result of adding acl.
- String ozoneKey = omMetadataManager
- .getOzoneKey(volumeName, bucketName, keyName);
List<OzoneAcl> keyAcls = omMetadataManager.getKeyTable().get(ozoneKey)
.getAcls();
Assert.assertEquals(1, keyAcls.size());
@@ -108,8 +113,8 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
// Remove acl.
OMRequest removeAclRequest = createRemoveAclKeyRequest(acl);
- OMKeyRemoveAclRequest omKeyRemoveAclRequest =
- new OMKeyRemoveAclRequest(removeAclRequest);
+ OMKeyAclRequest omKeyRemoveAclRequest =
+ getOmKeyRemoveAclRequest(removeAclRequest);
OMRequest preExecuteRequest = omKeyRemoveAclRequest
.preExecute(ozoneManager);
@@ -122,7 +127,7 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
Assert.assertTrue(newModTime > originModTime);
OMClientResponse omClientRemoveAclResponse = omKeyRemoveAclRequest
- .validateAndUpdateCache(ozoneManager, 2,
+ .validateAndUpdateCache(ozoneManager, 100L,
ozoneManagerDoubleBufferHelper);
OMResponse omRemoveAclResponse = omClientRemoveAclResponse.getOMResponse();
Assert.assertNotNull(omRemoveAclResponse.getRemoveAclResponse());
@@ -139,15 +144,18 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
public void testKeySetAclRequest() throws Exception {
TestOMRequestUtils.addVolumeAndBucketToDB(volumeName, bucketName,
omMetadataManager);
- TestOMRequestUtils.addKeyToTable(false, false, volumeName, bucketName,
- keyName, clientID, replicationType, replicationFactor, 1L,
- omMetadataManager);
+ String ozoneKey = addKeyToTable();
+
+ OmKeyInfo omKeyInfo = omMetadataManager.getKeyTable().get(ozoneKey);
+
+ // As we added manually to key table.
+ Assert.assertNotNull(omKeyInfo);
OzoneAcl acl = OzoneAcl.parseAcl("user:bilbo:rwdlncxy[ACCESS]");
OMRequest setAclRequest = createSetAclKeyRequest(acl);
- OMKeySetAclRequest omKeySetAclRequest =
- new OMKeySetAclRequest(setAclRequest);
+ OMKeyAclRequest omKeySetAclRequest =
+ getOmKeySetAclRequest(setAclRequest);
OMRequest preExecuteRequest = omKeySetAclRequest.preExecute(ozoneManager);
// When preExecute() of setting acl,
@@ -159,7 +167,7 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
Assert.assertTrue(newModTime > originModTime);
OMClientResponse omClientResponse = omKeySetAclRequest
- .validateAndUpdateCache(ozoneManager, 1,
+ .validateAndUpdateCache(ozoneManager, 100L,
ozoneManagerDoubleBufferHelper);
OMResponse omSetAclResponse = omClientResponse.getOMResponse();
Assert.assertNotNull(omSetAclResponse.getSetAclResponse());
@@ -167,8 +175,6 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
omSetAclResponse.getStatus());
// Verify result of setting acl.
- String ozoneKey = omMetadataManager
- .getOzoneKey(volumeName, bucketName, keyName);
List<OzoneAcl> newAcls = omMetadataManager.getKeyTable().get(ozoneKey)
.getAcls();
Assert.assertEquals(newAcls.get(0), acl);
@@ -177,7 +183,7 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
/**
* Create OMRequest which encapsulates OMKeyAddAclRequest.
*/
- private OMRequest createAddAclkeyRequest(OzoneAcl acl) {
+ protected OMRequest createAddAclkeyRequest(OzoneAcl acl) {
OzoneObj obj = OzoneObjInfo.Builder.newBuilder()
.setBucketName(bucketName)
.setVolumeName(volumeName)
@@ -233,4 +239,27 @@ public class TestOMKeyAclRequest extends TestOMKeyRequest {
.setSetAclRequest(setAclRequest)
.build();
}
+
+ protected String addKeyToTable() throws Exception {
+ TestOMRequestUtils.addKeyToTable(false, false, volumeName, bucketName,
+ keyName, clientID, replicationType, replicationFactor, 1L,
+ omMetadataManager);
+
+ return omMetadataManager.getOzoneKey(volumeName, bucketName,
+ keyName);
+ }
+
+ protected OMKeyAclRequest getOmKeyAddAclRequest(OMRequest originalRequest) {
+ return new OMKeyAddAclRequest(
+ originalRequest);
+ }
+
+ protected OMKeyAclRequest getOmKeyRemoveAclRequest(
+ OMRequest removeAclRequest) {
+ return new OMKeyRemoveAclRequest(removeAclRequest);
+ }
+
+ protected OMKeyAclRequest getOmKeySetAclRequest(OMRequest setAclRequest) {
+ return new OMKeySetAclRequest(setAclRequest);
+ }
}
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/TestOMKeyAclRequestV1.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/TestOMKeyAclRequestV1.java
new file mode 100644
index 0000000..12e745c
--- /dev/null
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/TestOMKeyAclRequestV1.java
@@ -0,0 +1,81 @@
+/**
+ * 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.key;
+
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.om.ratis.utils.OzoneManagerRatisUtils;
+import org.apache.hadoop.ozone.om.request.TestOMRequestUtils;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeyAclRequest;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeyAddAclRequestV1;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeyRemoveAclRequestV1;;
+import org.apache.hadoop.ozone.om.request.key.acl.OMKeySetAclRequestV1;
+import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
+import org.apache.hadoop.util.Time;
+
+/**
+ * Test Key ACL requests for layout version V1.
+ */
+public class TestOMKeyAclRequestV1 extends TestOMKeyAclRequest {
+
+ protected String addKeyToTable() throws Exception {
+ String parentDir = "c/d/e";
+ String fileName = "file1";
+ String key = parentDir + "/" + fileName;
+ keyName = key; // updated key name
+
+ // Create parent dirs for the path
+ long parentId = TestOMRequestUtils
+ .addParentsToDirTable(volumeName, bucketName, parentDir,
+ omMetadataManager);
+
+ OmKeyInfo omKeyInfo = TestOMRequestUtils
+ .createOmKeyInfo(volumeName, bucketName, key,
+ HddsProtos.ReplicationType.RATIS, HddsProtos.ReplicationFactor.ONE,
+ parentId + 1, parentId, 100, Time.now());
+ TestOMRequestUtils
+ .addFileToKeyTable(false, false, fileName, omKeyInfo, -1, 50,
+ omMetadataManager);
+ return omKeyInfo.getPath();
+ }
+
+ @Override protected OMKeyAclRequest getOmKeyAddAclRequest(
+ OzoneManagerProtocolProtos.OMRequest originalRequest) {
+ return new OMKeyAddAclRequestV1(originalRequest);
+ }
+
+ @Override protected OMKeyAclRequest getOmKeyRemoveAclRequest(
+ OzoneManagerProtocolProtos.OMRequest removeAclRequest) {
+ return new OMKeyRemoveAclRequestV1(removeAclRequest);
+ }
+
+ @Override protected OMKeyAclRequest getOmKeySetAclRequest(
+ OzoneManagerProtocolProtos.OMRequest setAclRequest) {
+ return new OMKeySetAclRequestV1(setAclRequest);
+ }
+
+ @Override protected OzoneConfiguration getOzoneConfiguration() {
+ OzoneConfiguration config = super.getOzoneConfiguration();
+ // omLayoutVersionV1 flag will be set while invoking OzoneManager#start()
+ // and its not invoked in this test. Hence it is explicitly setting
+ // this configuration to populate prefix tables.
+ OzoneManagerRatisUtils.setBucketFSOptimized(true);
+ return config;
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@ozone.apache.org
For additional commands, e-mail: commits-help@ozone.apache.org