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 <[email protected]> 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: [email protected] For additional commands, e-mail: [email protected]
