Java tutorial
/** * 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; import static org.junit.Assert.assertEquals; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; import java.net.URI; import java.security.PrivilegedExceptionAction; import java.util.ArrayList; import java.util.Arrays; import org.apache.commons.lang.StringUtils; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.FileSystemTestHelper; import org.apache.hadoop.fs.FsShell; import org.apache.hadoop.fs.Path; import org.apache.hadoop.fs.permission.FsPermission; import org.apache.hadoop.security.UserGroupInformation; import org.junit.Test; /** * This test covers privilege related aspects of FsShell * */ public class TestFsShellPermission { static private final String TEST_ROOT = "/testroot"; static UserGroupInformation createUGI(String ownername, String groupName) { return UserGroupInformation.createUserForTesting(ownername, new String[] { groupName }); } private class FileEntry { private String path; private boolean isDir; private String owner; private String group; private String permission; public FileEntry(String path, boolean isDir, String owner, String group, String permission) { this.path = path; this.isDir = isDir; this.owner = owner; this.group = group; this.permission = permission; } String getPath() { return path; } boolean isDirectory() { return isDir; } String getOwner() { return owner; } String getGroup() { return group; } String getPermission() { return permission; } } private void createFiles(FileSystem fs, String topdir, FileEntry[] entries) throws IOException { for (FileEntry entry : entries) { String newPathStr = topdir + "/" + entry.getPath(); Path newPath = new Path(newPathStr); if (entry.isDirectory()) { fs.mkdirs(newPath); } else { FileSystemTestHelper.createFile(fs, newPath); } fs.setPermission(newPath, new FsPermission(entry.getPermission())); fs.setOwner(newPath, entry.getOwner(), entry.getGroup()); } } /** delete directory and everything underneath it.*/ private static void deldir(FileSystem fs, String topdir) throws IOException { fs.delete(new Path(topdir), true); } static String execCmd(FsShell shell, final String[] args) throws Exception { ByteArrayOutputStream baout = new ByteArrayOutputStream(); PrintStream out = new PrintStream(baout, true); PrintStream old = System.out; System.setOut(out); int ret = shell.run(args); out.close(); System.setOut(old); return String.valueOf(ret); } /* * Each instance of TestDeleteHelper captures one testing scenario. * * To create all files listed in fileEntries, and then delete as user * doAsuser the deleteEntry with command+options specified in cmdAndOptions. * * When expectedToDelete is true, the deleteEntry is expected to be deleted; * otherwise, it's not expected to be deleted. At the end of test, * the existence of deleteEntry is checked against expectedToDelete * to ensure the command is finished with expected result */ private class TestDeleteHelper { private FileEntry[] fileEntries; private FileEntry deleteEntry; private String cmdAndOptions; private boolean expectedToDelete; final String doAsGroup; final UserGroupInformation userUgi; public TestDeleteHelper(FileEntry[] fileEntries, FileEntry deleteEntry, String cmdAndOptions, String doAsUser, boolean expectedToDelete) { this.fileEntries = fileEntries; this.deleteEntry = deleteEntry; this.cmdAndOptions = cmdAndOptions; this.expectedToDelete = expectedToDelete; doAsGroup = doAsUser.equals("hdfs") ? "supergroup" : "users"; userUgi = createUGI(doAsUser, doAsGroup); } public void execute(Configuration conf, FileSystem fs) throws Exception { fs.mkdirs(new Path(TEST_ROOT)); createFiles(fs, TEST_ROOT, fileEntries); final FsShell fsShell = new FsShell(conf); final String deletePath = TEST_ROOT + "/" + deleteEntry.getPath(); String[] tmpCmdOpts = StringUtils.split(cmdAndOptions); ArrayList<String> tmpArray = new ArrayList<String>(Arrays.asList(tmpCmdOpts)); tmpArray.add(deletePath); final String[] cmdOpts = tmpArray.toArray(new String[tmpArray.size()]); userUgi.doAs(new PrivilegedExceptionAction<String>() { public String run() throws Exception { return execCmd(fsShell, cmdOpts); } }); boolean deleted = !fs.exists(new Path(deletePath)); assertEquals(expectedToDelete, deleted); deldir(fs, TEST_ROOT); } } private TestDeleteHelper genDeleteEmptyDirHelper(final String cmdOpts, final String targetPerm, final String asUser, boolean expectedToDelete) { FileEntry[] files = { new FileEntry("userA", true, "userA", "users", "755"), new FileEntry("userA/userB", true, "userB", "users", targetPerm) }; FileEntry deleteEntry = files[1]; return new TestDeleteHelper(files, deleteEntry, cmdOpts, asUser, expectedToDelete); } // Expect target to be deleted private TestDeleteHelper genRmrEmptyDirWithReadPerm() { return genDeleteEmptyDirHelper("-rm -r", "744", "userA", true); } // Expect target to be deleted private TestDeleteHelper genRmrEmptyDirWithNoPerm() { return genDeleteEmptyDirHelper("-rm -r", "700", "userA", true); } // Expect target to be deleted private TestDeleteHelper genRmrfEmptyDirWithNoPerm() { return genDeleteEmptyDirHelper("-rm -r -f", "700", "userA", true); } private TestDeleteHelper genDeleteNonEmptyDirHelper(final String cmd, final String targetPerm, final String asUser, boolean expectedToDelete) { FileEntry[] files = { new FileEntry("userA", true, "userA", "users", "755"), new FileEntry("userA/userB", true, "userB", "users", targetPerm), new FileEntry("userA/userB/xyzfile", false, "userB", "users", targetPerm) }; FileEntry deleteEntry = files[1]; return new TestDeleteHelper(files, deleteEntry, cmd, asUser, expectedToDelete); } // Expect target not to be deleted private TestDeleteHelper genRmrNonEmptyDirWithReadPerm() { return genDeleteNonEmptyDirHelper("-rm -r", "744", "userA", false); } // Expect target not to be deleted private TestDeleteHelper genRmrNonEmptyDirWithNoPerm() { return genDeleteNonEmptyDirHelper("-rm -r", "700", "userA", false); } // Expect target to be deleted private TestDeleteHelper genRmrNonEmptyDirWithAllPerm() { return genDeleteNonEmptyDirHelper("-rm -r", "777", "userA", true); } // Expect target not to be deleted private TestDeleteHelper genRmrfNonEmptyDirWithNoPerm() { return genDeleteNonEmptyDirHelper("-rm -r -f", "700", "userA", false); } // Expect target to be deleted public TestDeleteHelper genDeleteSingleFileNotAsOwner() throws Exception { FileEntry[] files = { new FileEntry("userA", true, "userA", "users", "755"), new FileEntry("userA/userB", false, "userB", "users", "700") }; FileEntry deleteEntry = files[1]; return new TestDeleteHelper(files, deleteEntry, "-rm -r", "userA", true); } @Test public void testDelete() throws Exception { Configuration conf = null; MiniDFSCluster cluster = null; try { conf = new Configuration(); cluster = new MiniDFSCluster.Builder(conf).numDataNodes(2).build(); String nnUri = FileSystem.getDefaultUri(conf).toString(); FileSystem fs = FileSystem.get(URI.create(nnUri), conf); ArrayList<TestDeleteHelper> ta = new ArrayList<TestDeleteHelper>(); // Add empty dir tests ta.add(genRmrEmptyDirWithReadPerm()); // ta.add(genRmrEmptyDirWithNoPerm()); // ta.add(genRmrfEmptyDirWithNoPerm()); // Add non-empty dir tests // ta.add(genRmrNonEmptyDirWithReadPerm()); // ta.add(genRmrNonEmptyDirWithNoPerm()); // ta.add(genRmrNonEmptyDirWithAllPerm()); // ta.add(genRmrfNonEmptyDirWithNoPerm()); // Add single tile test // ta.add(genDeleteSingleFileNotAsOwner()); // Run all tests for (TestDeleteHelper t : ta) { t.execute(conf, fs); } } finally { if (cluster != null) { cluster.shutdown(); } } } }