From fa99a8471d6cfabc63d678caa8d4b6614f824be1 Mon Sep 17 00:00:00 2001 From: Chris Nauroth Date: Fri, 31 Jan 2014 23:02:45 +0000 Subject: [PATCH] HDFS-5858. Refactor common ACL test cases to be run through multiple FileSystem implementations. Contributed by Chris Nauroth. git-svn-id: https://svn.apache.org/repos/asf/hadoop/common/branches/HDFS-4685@1563325 13f79535-47bb-0310-9956-ffa450edef68 --- .../hadoop-hdfs/CHANGES-HDFS-4685.txt | 3 + .../hdfs/server/namenode/FSAclBaseTest.java | 819 ++++++++++++++++++ .../hdfs/server/namenode/TestNameNodeAcl.java | 786 +---------------- .../apache/hadoop/hdfs/web/TestWebHDFS.java | 698 --------------- .../hadoop/hdfs/web/TestWebHDFSAcl.java | 40 + 5 files changed, 866 insertions(+), 1480 deletions(-) create mode 100644 hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/FSAclBaseTest.java create mode 100644 hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFSAcl.java diff --git a/hadoop-hdfs-project/hadoop-hdfs/CHANGES-HDFS-4685.txt b/hadoop-hdfs-project/hadoop-hdfs/CHANGES-HDFS-4685.txt index 468a96a66b6..0399d79de26 100644 --- a/hadoop-hdfs-project/hadoop-hdfs/CHANGES-HDFS-4685.txt +++ b/hadoop-hdfs-project/hadoop-hdfs/CHANGES-HDFS-4685.txt @@ -53,6 +53,9 @@ HDFS-4685 (Unreleased) HDFS-5614. NameNode: implement handling of ACLs in combination with snapshots. (cnauroth) + HDFS-5858. Refactor common ACL test cases to be run through multiple + FileSystem implementations. (cnauroth) + OPTIMIZATIONS BUG FIXES diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/FSAclBaseTest.java b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/FSAclBaseTest.java new file mode 100644 index 00000000000..a17af6232da --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/FSAclBaseTest.java @@ -0,0 +1,819 @@ +/** + * 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. + */ +package org.apache.hadoop.hdfs.server.namenode; + +import static org.apache.hadoop.hdfs.server.namenode.AclTestHelpers.*; +import static org.apache.hadoop.fs.permission.AclEntryScope.*; +import static org.apache.hadoop.fs.permission.AclEntryType.*; +import static org.apache.hadoop.fs.permission.FsAction.*; +import static org.junit.Assert.*; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.List; + +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.fs.permission.AclEntry; +import org.apache.hadoop.fs.permission.AclStatus; +import org.apache.hadoop.fs.permission.FsPermission; +import org.apache.hadoop.hdfs.MiniDFSCluster; +import org.apache.hadoop.hdfs.protocol.AclException; +import org.apache.hadoop.io.IOUtils; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.Test; + +import com.google.common.collect.Lists; + +/** + * Tests NameNode interaction for all ACL modification APIs. This test suite + * also covers interaction of setPermission with inodes that have ACLs. + */ +public abstract class FSAclBaseTest { + + protected static MiniDFSCluster cluster; + protected static FileSystem fs; + private static int pathCount = 0; + private static Path path; + + @AfterClass + public static void shutdown() throws Exception { + IOUtils.cleanup(null, fs); + if (cluster != null) { + cluster.shutdown(); + } + } + + @Before + public void setUp() { + pathCount += 1; + path = new Path("/p" + pathCount); + } + + @Test + public void testModifyAclEntries() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo", READ_EXECUTE), + aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); + fs.modifyAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", READ_EXECUTE), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testModifyAclEntriesOnlyAccess() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo", READ_EXECUTE)); + fs.modifyAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", READ_EXECUTE), + aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testModifyAclEntriesOnlyDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); + fs.modifyAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testModifyAclEntriesMinimal() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo", READ_WRITE)); + fs.modifyAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", READ_WRITE), + aclEntry(ACCESS, GROUP, READ) }, returned); + assertPermission((short)02660); + assertAclFeature(true); + } + + @Test + public void testModifyAclEntriesMinimalDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE)); + fs.modifyAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testModifyAclEntriesCustomMask() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, MASK, NONE)); + fs.modifyAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ) }, returned); + assertPermission((short)02600); + assertAclFeature(true); + } + + @Test + public void testModifyAclEntriesStickyBit() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo", READ_EXECUTE), + aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); + fs.modifyAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", READ_EXECUTE), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)03750); + assertAclFeature(true); + } + + @Test(expected=FileNotFoundException.class) + public void testModifyAclEntriesPathNotFound() throws IOException { + // Path has not been created. + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE)); + fs.modifyAclEntries(path, aclSpec); + } + + @Test(expected=AclException.class) + public void testModifyAclEntriesDefaultOnFile() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.modifyAclEntries(path, aclSpec); + } + + @Test + public void testRemoveAclEntries() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo"), + aclEntry(DEFAULT, USER, "foo")); + fs.removeAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testRemoveAclEntriesOnlyAccess() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, USER, "bar", READ_WRITE), + aclEntry(ACCESS, GROUP, READ_WRITE), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo")); + fs.removeAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "bar", READ_WRITE), + aclEntry(ACCESS, GROUP, READ_WRITE) }, returned); + assertPermission((short)02760); + assertAclFeature(true); + } + + @Test + public void testRemoveAclEntriesOnlyDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL), + aclEntry(DEFAULT, USER, "bar", READ_EXECUTE)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, "foo")); + fs.removeAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "bar", READ_EXECUTE), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testRemoveAclEntriesMinimal() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0760)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_WRITE), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo"), + aclEntry(ACCESS, MASK)); + fs.removeAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)0760); + assertAclFeature(false); + } + + + @Test + public void testRemoveAclEntriesMinimalDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo"), + aclEntry(ACCESS, MASK), + aclEntry(DEFAULT, USER, "foo"), + aclEntry(DEFAULT, MASK)); + fs.removeAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testRemoveAclEntriesStickyBit() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo"), + aclEntry(DEFAULT, USER, "foo")); + fs.removeAclEntries(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)03750); + assertAclFeature(true); + } + + @Test(expected=FileNotFoundException.class) + public void testRemoveAclEntriesPathNotFound() throws IOException { + // Path has not been created. + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, "foo")); + fs.removeAclEntries(path, aclSpec); + } + + @Test + public void testRemoveDefaultAcl() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.removeDefaultAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); + assertPermission((short)02770); + assertAclFeature(true); + } + + @Test + public void testRemoveDefaultAclOnlyAccess() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + fs.removeDefaultAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); + assertPermission((short)02770); + assertAclFeature(true); + } + + @Test + public void testRemoveDefaultAclOnlyDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.removeDefaultAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)0750); + assertAclFeature(false); + } + + @Test + public void testRemoveDefaultAclMinimal() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + fs.removeDefaultAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)0750); + assertAclFeature(false); + } + + @Test + public void testRemoveDefaultAclStickyBit() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.removeDefaultAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); + assertPermission((short)03770); + assertAclFeature(true); + } + + @Test(expected=FileNotFoundException.class) + public void testRemoveDefaultAclPathNotFound() throws IOException { + // Path has not been created. + fs.removeDefaultAcl(path); + } + + @Test + public void testRemoveAcl() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.removeAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)0750); + assertAclFeature(false); + } + + @Test + public void testRemoveAclMinimalAcl() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + fs.removeAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)0640); + assertAclFeature(false); + } + + @Test + public void testRemoveAclStickyBit() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.removeAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)01750); + assertAclFeature(false); + } + + @Test + public void testRemoveAclOnlyDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.removeAcl(path); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)0750); + assertAclFeature(false); + } + + @Test(expected=FileNotFoundException.class) + public void testRemoveAclPathNotFound() throws IOException { + // Path has not been created. + fs.removeAcl(path); + } + + @Test + public void testSetAcl() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, ALL), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02770); + assertAclFeature(true); + } + + @Test + public void testSetAclOnlyAccess() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, READ_WRITE), + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ) }, returned); + assertPermission((short)02640); + assertAclFeature(true); + } + + @Test + public void testSetAclOnlyDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, ALL), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testSetAclMinimal() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0644)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, READ_WRITE), + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, READ_WRITE), + aclEntry(ACCESS, GROUP, READ), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { }, returned); + assertPermission((short)0640); + assertAclFeature(false); + } + + @Test + public void testSetAclMinimalDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE)); + fs.setAcl(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02750); + assertAclFeature(true); + } + + @Test + public void testSetAclCustomMask() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, READ_WRITE), + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ), + aclEntry(ACCESS, MASK, ALL), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ) }, returned); + assertPermission((short)02670); + assertAclFeature(true); + } + + @Test + public void testSetAclStickyBit() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, ALL), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)03770); + assertAclFeature(true); + } + + @Test(expected=FileNotFoundException.class) + public void testSetAclPathNotFound() throws IOException { + // Path has not been created. + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, READ_WRITE), + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + } + + @Test(expected=AclException.class) + public void testSetAclDefaultOnFile() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + } + + @Test + public void testSetPermission() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.setPermission(path, FsPermission.createImmutable((short)0700)); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, ALL), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02700); + assertAclFeature(true); + } + + @Test + public void testSetPermissionOnlyAccess() throws IOException { + fs.create(path).close(); + fs.setPermission(path, FsPermission.createImmutable((short)0640)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, READ_WRITE), + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ), + aclEntry(ACCESS, OTHER, NONE)); + fs.setAcl(path, aclSpec); + fs.setPermission(path, FsPermission.createImmutable((short)0600)); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(ACCESS, USER, "foo", READ), + aclEntry(ACCESS, GROUP, READ) }, returned); + assertPermission((short)02600); + assertAclFeature(true); + } + + @Test + public void testSetPermissionOnlyDefault() throws IOException { + FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); + List aclSpec = Lists.newArrayList( + aclEntry(ACCESS, USER, ALL), + aclEntry(ACCESS, GROUP, READ_EXECUTE), + aclEntry(ACCESS, OTHER, NONE), + aclEntry(DEFAULT, USER, "foo", ALL)); + fs.setAcl(path, aclSpec); + fs.setPermission(path, FsPermission.createImmutable((short)0700)); + AclStatus s = fs.getAclStatus(path); + AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); + assertArrayEquals(new AclEntry[] { + aclEntry(DEFAULT, USER, ALL), + aclEntry(DEFAULT, USER, "foo", ALL), + aclEntry(DEFAULT, GROUP, READ_EXECUTE), + aclEntry(DEFAULT, MASK, ALL), + aclEntry(DEFAULT, OTHER, NONE) }, returned); + assertPermission((short)02700); + assertAclFeature(true); + } + + /** + * Asserts whether or not the inode for the test path has an AclFeature. + * + * @param expectAclFeature boolean true if an AclFeature must be present, + * false if an AclFeature must not be present + * @throws IOException thrown if there is an I/O error + */ + private static void assertAclFeature(boolean expectAclFeature) + throws IOException { + INode inode = cluster.getNamesystem().getFSDirectory().getRoot() + .getNode(path.toUri().getPath(), false); + assertNotNull(inode); + AclFeature aclFeature = inode.getAclFeature(); + if (expectAclFeature) { + assertNotNull(aclFeature); + } else { + assertNull(aclFeature); + } + } + + /** + * Asserts the value of the FsPermission bits on the inode of the test path. + * + * @param perm short expected permission bits + * @throws IOException thrown if there is an I/O error + */ + private static void assertPermission(short perm) throws IOException { + assertEquals(FsPermission.createImmutable(perm), + fs.getFileStatus(path).getPermission()); + } +} diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestNameNodeAcl.java b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestNameNodeAcl.java index a2cf85c9982..53f8af67dac 100644 --- a/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestNameNodeAcl.java +++ b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestNameNodeAcl.java @@ -17,803 +17,25 @@ */ package org.apache.hadoop.hdfs.server.namenode; -import static org.apache.hadoop.hdfs.server.namenode.AclTestHelpers.*; -import static org.apache.hadoop.fs.permission.AclEntryScope.*; -import static org.apache.hadoop.fs.permission.AclEntryType.*; -import static org.apache.hadoop.fs.permission.FsAction.*; import static org.junit.Assert.*; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.util.List; - import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.fs.FileSystem; -import org.apache.hadoop.fs.Path; -import org.apache.hadoop.fs.permission.AclEntry; -import org.apache.hadoop.fs.permission.AclStatus; -import org.apache.hadoop.fs.permission.FsPermission; +import org.apache.hadoop.hdfs.DistributedFileSystem; import org.apache.hadoop.hdfs.MiniDFSCluster; -import org.apache.hadoop.hdfs.protocol.AclException; -import org.apache.hadoop.hdfs.server.namenode.snapshot.Snapshot; -import org.apache.hadoop.io.IOUtils; -import org.junit.AfterClass; -import org.junit.Before; import org.junit.BeforeClass; -import org.junit.Test; - -import com.google.common.collect.Lists; /** * Tests NameNode interaction for all ACL modification APIs. This test suite * also covers interaction of setPermission with inodes that have ACLs. */ -public class TestNameNodeAcl { - - private static MiniDFSCluster cluster; - private static Configuration conf; - private static FileSystem fs; - private static int pathCount = 0; - private static Path path; +public class TestNameNodeAcl extends FSAclBaseTest { @BeforeClass public static void init() throws Exception { - conf = new Configuration(); - + Configuration conf = new Configuration(); cluster = new MiniDFSCluster.Builder(conf).numDataNodes(1).build(); cluster.waitActive(); fs = cluster.getFileSystem(); - } - - @AfterClass - public static void shutdown() throws Exception { - IOUtils.cleanup(null, fs); - if (cluster != null) { - cluster.shutdown(); - } - } - - @Before - public void setUp() { - pathCount += 1; - path = new Path("/p" + pathCount); - } - - @Test - public void testModifyAclEntries() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); - fs.modifyAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testModifyAclEntriesOnlyAccess() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_EXECUTE)); - fs.modifyAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testModifyAclEntriesOnlyDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); - fs.modifyAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testModifyAclEntriesMinimal() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_WRITE)); - fs.modifyAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_WRITE), - aclEntry(ACCESS, GROUP, READ) }, returned); - assertPermission((short)02660); - assertAclFeature(true); - } - - @Test - public void testModifyAclEntriesMinimalDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE)); - fs.modifyAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testModifyAclEntriesCustomMask() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, MASK, NONE)); - fs.modifyAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ) }, returned); - assertPermission((short)02600); - assertAclFeature(true); - } - - @Test - public void testModifyAclEntriesStickyBit() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); - fs.modifyAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)03750); - assertAclFeature(true); - } - - @Test(expected=FileNotFoundException.class) - public void testModifyAclEntriesPathNotFound() throws IOException { - // Path has not been created. - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE)); - fs.modifyAclEntries(path, aclSpec); - } - - @Test(expected=AclException.class) - public void testModifyAclEntriesDefaultOnFile() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.modifyAclEntries(path, aclSpec); - } - - @Test - public void testRemoveAclEntries() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(DEFAULT, USER, "foo")); - fs.removeAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testRemoveAclEntriesOnlyAccess() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, USER, "bar", READ_WRITE), - aclEntry(ACCESS, GROUP, READ_WRITE), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo")); - fs.removeAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "bar", READ_WRITE), - aclEntry(ACCESS, GROUP, READ_WRITE) }, returned); - assertPermission((short)02760); - assertAclFeature(true); - } - - @Test - public void testRemoveAclEntriesOnlyDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, USER, "bar", READ_EXECUTE)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo")); - fs.removeAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "bar", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testRemoveAclEntriesMinimal() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0760)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_WRITE), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(ACCESS, MASK)); - fs.removeAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)0760); - assertAclFeature(false); - } - - - @Test - public void testRemoveAclEntriesMinimalDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(ACCESS, MASK), - aclEntry(DEFAULT, USER, "foo"), - aclEntry(DEFAULT, MASK)); - fs.removeAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testRemoveAclEntriesStickyBit() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(DEFAULT, USER, "foo")); - fs.removeAclEntries(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)03750); - assertAclFeature(true); - } - - @Test(expected=FileNotFoundException.class) - public void testRemoveAclEntriesPathNotFound() throws IOException { - // Path has not been created. - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo")); - fs.removeAclEntries(path, aclSpec); - } - - @Test - public void testRemoveDefaultAcl() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.removeDefaultAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - assertPermission((short)02770); - assertAclFeature(true); - } - - @Test - public void testRemoveDefaultAclOnlyAccess() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - fs.removeDefaultAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - assertPermission((short)02770); - assertAclFeature(true); - } - - @Test - public void testRemoveDefaultAclOnlyDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.removeDefaultAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)0750); - assertAclFeature(false); - } - - @Test - public void testRemoveDefaultAclMinimal() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - fs.removeDefaultAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)0750); - assertAclFeature(false); - } - - @Test - public void testRemoveDefaultAclStickyBit() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.removeDefaultAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - assertPermission((short)03770); - assertAclFeature(true); - } - - @Test(expected=FileNotFoundException.class) - public void testRemoveDefaultAclPathNotFound() throws IOException { - // Path has not been created. - fs.removeDefaultAcl(path); - } - - @Test - public void testRemoveAcl() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.removeAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)0750); - assertAclFeature(false); - } - - @Test - public void testRemoveAclMinimalAcl() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - fs.removeAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)0640); - assertAclFeature(false); - } - - @Test - public void testRemoveAclStickyBit() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.removeAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)01750); - assertAclFeature(false); - } - - @Test - public void testRemoveAclOnlyDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.removeAcl(path); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)0750); - assertAclFeature(false); - } - - @Test(expected=FileNotFoundException.class) - public void testRemoveAclPathNotFound() throws IOException { - // Path has not been created. - fs.removeAcl(path); - } - - @Test - public void testSetAcl() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02770); - assertAclFeature(true); - } - - @Test - public void testSetAclOnlyAccess() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ) }, returned); - assertPermission((short)02640); - assertAclFeature(true); - } - - @Test - public void testSetAclOnlyDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testSetAclMinimal() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0644)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - assertPermission((short)0640); - assertAclFeature(false); - } - - @Test - public void testSetAclMinimalDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE)); - fs.setAcl(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02750); - assertAclFeature(true); - } - - @Test - public void testSetAclCustomMask() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, MASK, ALL), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ) }, returned); - assertPermission((short)02670); - assertAclFeature(true); - } - - @Test - public void testSetAclStickyBit() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)03770); - assertAclFeature(true); - } - - @Test(expected=FileNotFoundException.class) - public void testSetAclPathNotFound() throws IOException { - // Path has not been created. - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - } - - @Test(expected=AclException.class) - public void testSetAclDefaultOnFile() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - } - - @Test - public void testSetPermission() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.setPermission(path, FsPermission.createImmutable((short)0700)); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02700); - assertAclFeature(true); - } - - @Test - public void testSetPermissionOnlyAccess() throws IOException { - FileSystem.create(fs, path, FsPermission.createImmutable((short)0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - fs.setAcl(path, aclSpec); - fs.setPermission(path, FsPermission.createImmutable((short)0600)); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ) }, returned); - assertPermission((short)02600); - assertAclFeature(true); - } - - @Test - public void testSetPermissionOnlyDefault() throws IOException { - FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - fs.setAcl(path, aclSpec); - fs.setPermission(path, FsPermission.createImmutable((short)0700)); - AclStatus s = fs.getAclStatus(path); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - assertPermission((short)02700); - assertAclFeature(true); - } - - /** - * Asserts whether or not the inode for the test path has an AclFeature. - * - * @param expectAclFeature boolean true if an AclFeature must be present, - * false if an AclFeature must not be present - * @throws IOException thrown if there is an I/O error - */ - private static void assertAclFeature(boolean expectAclFeature) - throws IOException { - INode inode = cluster.getNamesystem().getFSDirectory().getRoot() - .getNode(path.toUri().getPath(), false); - assertNotNull(inode); - AclFeature aclFeature = inode.getAclFeature(Snapshot.CURRENT_STATE_ID); - if (expectAclFeature) { - assertNotNull(aclFeature); - } else { - assertNull(aclFeature); - } - } - - /** - * Asserts the value of the FsPermission bits on the inode of the test path. - * - * @param perm short expected permission bits - * @throws IOException thrown if there is an I/O error - */ - private static void assertPermission(short perm) throws IOException { - assertEquals(FsPermission.createImmutable(perm), - fs.getFileStatus(path).getPermission()); + assertTrue(fs instanceof DistributedFileSystem); } } diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFS.java b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFS.java index c521472e873..a657cd8ba7d 100644 --- a/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFS.java +++ b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFS.java @@ -18,25 +18,9 @@ package org.apache.hadoop.hdfs.web; -import static org.apache.hadoop.fs.permission.AclEntryScope.ACCESS; -import static org.apache.hadoop.fs.permission.AclEntryScope.DEFAULT; -import static org.apache.hadoop.fs.permission.AclEntryType.GROUP; -import static org.apache.hadoop.fs.permission.AclEntryType.MASK; -import static org.apache.hadoop.fs.permission.AclEntryType.OTHER; -import static org.apache.hadoop.fs.permission.AclEntryType.USER; -import static org.apache.hadoop.fs.permission.FsAction.ALL; -import static org.apache.hadoop.fs.permission.FsAction.NONE; -import static org.apache.hadoop.fs.permission.FsAction.READ; -import static org.apache.hadoop.fs.permission.FsAction.READ_EXECUTE; -import static org.apache.hadoop.fs.permission.FsAction.READ_WRITE; -import static org.apache.hadoop.hdfs.server.namenode.AclTestHelpers.aclEntry; -import static org.junit.Assert.assertArrayEquals; - -import java.io.FileNotFoundException; import java.io.IOException; import java.net.URISyntaxException; import java.security.PrivilegedExceptionAction; -import java.util.List; import java.util.Random; import org.apache.commons.logging.Log; @@ -47,27 +31,18 @@ import org.apache.hadoop.fs.FSDataOutputStream; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.fs.permission.AclEntry; -import org.apache.hadoop.fs.permission.AclStatus; import org.apache.hadoop.fs.permission.FsAction; import org.apache.hadoop.fs.permission.FsPermission; import org.apache.hadoop.hdfs.DFSConfigKeys; import org.apache.hadoop.hdfs.HdfsConfiguration; import org.apache.hadoop.hdfs.MiniDFSCluster; import org.apache.hadoop.hdfs.TestDFSClientRetries; -import org.apache.hadoop.hdfs.protocol.AclException; import org.apache.hadoop.hdfs.server.namenode.web.resources.NamenodeWebHdfsMethods; -import org.apache.hadoop.io.IOUtils; import org.apache.hadoop.security.UserGroupInformation; import org.apache.log4j.Level; -import org.junit.AfterClass; import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; import org.junit.Test; -import com.google.common.collect.Lists; - /** Test WebHDFS */ public class TestWebHDFS { static final Log LOG = LogFactory.getLog(TestWebHDFS.class); @@ -76,35 +51,6 @@ public class TestWebHDFS { static final long systemStartTime = System.nanoTime(); - private static MiniDFSCluster testCluster; - private static Configuration testConf; - private static FileSystem testFs; - private static int pathCount = 0; - private static Path tmpPath; - - @BeforeClass - public static void init() throws Exception { - testConf = WebHdfsTestUtil.createConf(); - - testCluster = new MiniDFSCluster.Builder(testConf).numDataNodes(1).build(); - testCluster.waitActive(); - testFs = WebHdfsTestUtil.getWebHdfsFileSystem(testConf, WebHdfsFileSystem.SCHEME); - } - - @AfterClass - public static void shutdown() throws Exception { - IOUtils.cleanup(null, testFs); - if (testCluster != null) { - testCluster.shutdown(); - } - } - - @Before - public void setUp() { - pathCount += 1; - tmpPath = new Path("/p" + pathCount); - } - /** A timer for measuring performance. */ static class Ticker { final String name; @@ -354,648 +300,4 @@ public void testWebHdfsEnabledByDefault() throws Exception { Assert.assertTrue(conf.getBoolean(DFSConfigKeys.DFS_WEBHDFS_ENABLED_KEY, false)); } - - @Test - public void testModifyAclEntries() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - - - } - - @Test - public void testModifyAclEntriesOnlyAccess() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_EXECUTE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - } - - @Test - public void testModifyAclEntriesOnlyDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testModifyAclEntriesMinimal() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_WRITE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_WRITE), - aclEntry(ACCESS, GROUP, READ) }, returned); - } - - @Test - public void testModifyAclEntriesMinimalDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testModifyAclEntriesCustomMask() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, MASK, NONE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ) }, returned); - } - - @Test - public void testModifyAclEntriesStickyBit() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ_EXECUTE), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test(expected=FileNotFoundException.class) - public void testModifyAclEntriesPathNotFound() throws IOException { - // Path has not been created. - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE)); - testFs.modifyAclEntries(tmpPath, aclSpec); - } - - @Test(expected=AclException.class) - public void testModifyAclEntriesDefaultOnFile() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.modifyAclEntries(tmpPath, aclSpec); - } - - @Test - public void testRemoveAclEntries() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(DEFAULT, USER, "foo")); - testFs.removeAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testRemoveAclEntriesOnlyAccess() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, USER, "bar", READ_WRITE), - aclEntry(ACCESS, GROUP, READ_WRITE), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo")); - testFs.removeAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "bar", READ_WRITE), - aclEntry(ACCESS, GROUP, READ_WRITE) }, returned); - } - - @Test - public void testRemoveAclEntriesOnlyDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, USER, "bar", READ_EXECUTE)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo")); - testFs.removeAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "bar", READ_EXECUTE), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testRemoveAclEntriesMinimal() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_WRITE), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(ACCESS, MASK)); - System.out.println("AclSpec :"+aclSpec); - testFs.removeAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - } - - - @Test - public void testRemoveAclEntriesMinimalDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(ACCESS, MASK), - aclEntry(DEFAULT, USER, "foo"), - aclEntry(DEFAULT, MASK)); - testFs.removeAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testRemoveAclEntriesStickyBit() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo"), - aclEntry(DEFAULT, USER, "foo")); - testFs.removeAclEntries(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test(expected=FileNotFoundException.class) - public void testRemoveAclEntriesPathNotFound() throws IOException { - // Path has not been created. - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, "foo")); - testFs.removeAclEntries(tmpPath, aclSpec); - } - - @Test - public void testRemoveDefaultAcl() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - testFs.removeDefaultAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - } - - @Test - public void testRemoveDefaultAclOnlyAccess() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - testFs.removeDefaultAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - } - - @Test - public void testRemoveDefaultAclOnlyDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - testFs.removeDefaultAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - } - - @Test - public void testRemoveDefaultAclMinimal() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - testFs.removeDefaultAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - } - - @Test - public void testRemoveDefaultAclStickyBit() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - testFs.removeDefaultAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned); - } - - @Test(expected=FileNotFoundException.class) - public void testRemoveDefaultAclPathNotFound() throws IOException { - // Path has not been created. - testFs.removeDefaultAcl(tmpPath); - } - - @Test - public void testRemoveAcl() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - testFs.removeAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - } - - @Test - public void testRemoveAclMinimalAcl() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - testFs.removeAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - } - - @Test - public void testRemoveAclStickyBit() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - testFs.removeAcl(tmpPath); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - } - - @Test(expected=FileNotFoundException.class) - public void testRemoveAclPathNotFound() throws IOException { - // Path has not been created. - testFs.removeAcl(tmpPath); - } - - @Test - public void testSetAcl() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testSetAclOnlyAccess() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ) }, returned); - } - - @Test - public void testSetAclOnlyDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testSetAclMinimal() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { }, returned); - } - - @Test - public void testSetAclMinimalDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testSetAclCustomMask() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, MASK, ALL), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ) }, returned); - } - - @Test - public void testSetAclStickyBit() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test(expected=FileNotFoundException.class) - public void testSetAclPathNotFound() throws IOException { - // Path has not been created. - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - } - - @Test(expected=AclException.class) - public void testSetAclDefaultOnFile() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - } - - @Test - public void testSetPermission() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short)0700)); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } - - @Test - public void testSetPermissionOnlyAccess() throws IOException { - testFs.create(tmpPath).close(); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, READ_WRITE), - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ), - aclEntry(ACCESS, OTHER, NONE)); - testFs.setAcl(tmpPath, aclSpec); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short)0600)); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(ACCESS, USER, "foo", READ), - aclEntry(ACCESS, GROUP, READ) }, returned); - } - - @Test - public void testSetPermissionOnlyDefault() throws IOException { - FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750)); - List aclSpec = Lists.newArrayList( - aclEntry(ACCESS, USER, ALL), - aclEntry(ACCESS, GROUP, READ_EXECUTE), - aclEntry(ACCESS, OTHER, NONE), - aclEntry(DEFAULT, USER, "foo", ALL)); - testFs.setAcl(tmpPath, aclSpec); - testFs.setPermission(tmpPath, FsPermission.createImmutable((short)0700)); - AclStatus s = testFs.getAclStatus(tmpPath); - AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]); - assertArrayEquals(new AclEntry[] { - aclEntry(DEFAULT, USER, ALL), - aclEntry(DEFAULT, USER, "foo", ALL), - aclEntry(DEFAULT, GROUP, READ_EXECUTE), - aclEntry(DEFAULT, MASK, ALL), - aclEntry(DEFAULT, OTHER, NONE) }, returned); - } } diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFSAcl.java b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFSAcl.java new file mode 100644 index 00000000000..20c6178e422 --- /dev/null +++ b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFSAcl.java @@ -0,0 +1,40 @@ +/** + * 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. + */ +package org.apache.hadoop.hdfs.web; + +import static org.junit.Assert.*; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hdfs.MiniDFSCluster; +import org.apache.hadoop.hdfs.server.namenode.FSAclBaseTest; +import org.junit.BeforeClass; + +/** + * Tests ACL APIs via WebHDFS. + */ +public class TestWebHDFSAcl extends FSAclBaseTest { + + @BeforeClass + public static void init() throws Exception { + Configuration conf = WebHdfsTestUtil.createConf(); + cluster = new MiniDFSCluster.Builder(conf).numDataNodes(1).build(); + cluster.waitActive(); + fs = WebHdfsTestUtil.getWebHdfsFileSystem(conf, WebHdfsFileSystem.SCHEME); + assertTrue(fs instanceof WebHdfsFileSystem); + } +}