TestPermission.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:8k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.security;
  19. import java.io.IOException;
  20. import java.util.Random;
  21. import org.apache.commons.logging.Log;
  22. import org.apache.commons.logging.LogFactory;
  23. import org.apache.commons.logging.impl.Log4JLogger;
  24. import org.apache.hadoop.conf.Configuration;
  25. import org.apache.hadoop.hdfs.MiniDFSCluster;
  26. import org.apache.hadoop.fs.*;
  27. import org.apache.hadoop.fs.permission.*;
  28. import org.apache.hadoop.util.StringUtils;
  29. import org.apache.log4j.Level;
  30. import junit.framework.TestCase;
  31. /** Unit tests for permission */
  32. public class TestPermission extends TestCase {
  33.   public static final Log LOG = LogFactory.getLog(TestPermission.class);
  34.   {
  35.     ((Log4JLogger)UserGroupInformation.LOG).getLogger().setLevel(Level.ALL);
  36.   }
  37.   final private static Path ROOT_PATH = new Path("/data");
  38.   final private static Path CHILD_DIR1 = new Path(ROOT_PATH, "child1");
  39.   final private static Path CHILD_DIR2 = new Path(ROOT_PATH, "child2");
  40.   final private static Path CHILD_FILE1 = new Path(ROOT_PATH, "file1");
  41.   final private static Path CHILD_FILE2 = new Path(ROOT_PATH, "file2");
  42.   final private static int FILE_LEN = 100;
  43.   final private static Random RAN = new Random();
  44.   final private static String USER_NAME = "user" + RAN.nextInt();
  45.   final private static String[] GROUP_NAMES = {"group1", "group2"};
  46.   static FsPermission checkPermission(FileSystem fs,
  47.       String path, FsPermission expected) throws IOException {
  48.     FileStatus s = fs.getFileStatus(new Path(path));
  49.     LOG.info(s.getPath() + ": " + s.isDir() + " " + s.getPermission()
  50.         + ":" + s.getOwner() + ":" + s.getGroup());
  51.     if (expected != null) {
  52.       assertEquals(expected, s.getPermission());
  53.       assertEquals(expected.toShort(), s.getPermission().toShort());
  54.     }
  55.     return s.getPermission();
  56.   }
  57.   public void testCreate() throws Exception {
  58.     Configuration conf = new Configuration();
  59.     conf.setBoolean("dfs.permissions", true);
  60.     conf.setInt(FsPermission.UMASK_LABEL, 0);
  61.     MiniDFSCluster cluster = null;
  62.     FileSystem fs = null;
  63.     try {
  64.       cluster = new MiniDFSCluster(conf, 3, true, null);
  65.       cluster.waitActive();
  66.       fs = FileSystem.get(conf);
  67.       FsPermission rootPerm = checkPermission(fs, "/", null);
  68.       FsPermission inheritPerm = FsPermission.createImmutable(
  69.           (short)(rootPerm.toShort() | 0300));
  70.       FsPermission dirPerm = new FsPermission((short)0777);
  71.       fs.mkdirs(new Path("/a1/a2/a3"), dirPerm);
  72.       checkPermission(fs, "/a1", inheritPerm);
  73.       checkPermission(fs, "/a1/a2", inheritPerm);
  74.       checkPermission(fs, "/a1/a2/a3", dirPerm);
  75.       FsPermission filePerm = new FsPermission((short)0444);
  76.       FSDataOutputStream out = fs.create(new Path("/b1/b2/b3.txt"), filePerm,
  77.           true, conf.getInt("io.file.buffer.size", 4096),
  78.           fs.getDefaultReplication(), fs.getDefaultBlockSize(), null);
  79.       out.write(123);
  80.       out.close();
  81.       checkPermission(fs, "/b1", inheritPerm);
  82.       checkPermission(fs, "/b1/b2", inheritPerm);
  83.       checkPermission(fs, "/b1/b2/b3.txt", filePerm);
  84.       
  85.       conf.setInt(FsPermission.UMASK_LABEL, 0022);
  86.       FsPermission permission = 
  87.         FsPermission.createImmutable((short)0666);
  88.       FileSystem.mkdirs(fs, new Path("/c1"), new FsPermission(permission));
  89.       FileSystem.create(fs, new Path("/c1/c2.txt"),
  90.           new FsPermission(permission));
  91.       checkPermission(fs, "/c1", permission);
  92.       checkPermission(fs, "/c1/c2.txt", permission);
  93.     } finally {
  94.       try {
  95.         if(fs != null) fs.close();
  96.       } catch(Exception e) {
  97.         LOG.error(StringUtils.stringifyException(e));
  98.       }
  99.       try {
  100.         if(cluster != null) cluster.shutdown();
  101.       } catch(Exception e) {
  102.         LOG.error(StringUtils.stringifyException(e));
  103.       }
  104.     }
  105.   }
  106.   public void testFilePermision() throws Exception {
  107.     Configuration conf = new Configuration();
  108.     conf.setBoolean("dfs.permissions", true);
  109.     MiniDFSCluster cluster = new MiniDFSCluster(conf, 3, true, null);
  110.     cluster.waitActive();
  111.     try {
  112.       FileSystem nnfs = FileSystem.get(conf);
  113.       // test permissions on files that do not exist
  114.       assertFalse(nnfs.exists(CHILD_FILE1));
  115.       try {
  116.         nnfs.setOwner(CHILD_FILE1, "foo", "bar");
  117.         assertTrue(false);
  118.       }
  119.       catch(java.io.FileNotFoundException e) {
  120.         LOG.info("GOOD: got " + e);
  121.       }
  122.       try {
  123.         nnfs.setPermission(CHILD_FILE1, new FsPermission((short)0777));
  124.         assertTrue(false);
  125.       }
  126.       catch(java.io.FileNotFoundException e) {
  127.         LOG.info("GOOD: got " + e);
  128.       }
  129.       // following dir/file creations are legal
  130.       nnfs.mkdirs(CHILD_DIR1);
  131.       FSDataOutputStream out = nnfs.create(CHILD_FILE1);
  132.       byte data[] = new byte[FILE_LEN];
  133.       RAN.nextBytes(data);
  134.       out.write(data);
  135.       out.close();
  136.       nnfs.setPermission(CHILD_FILE1, new FsPermission((short)0700));
  137.       // following read is legal
  138.       byte dataIn[] = new byte[FILE_LEN];
  139.       FSDataInputStream fin = nnfs.open(CHILD_FILE1);
  140.       int bytesRead = fin.read(dataIn);
  141.       assertTrue(bytesRead == FILE_LEN);
  142.       for(int i=0; i<FILE_LEN; i++) {
  143.         assertEquals(data[i], dataIn[i]);
  144.       }
  145.       ////////////////////////////////////////////////////////////////
  146.       // test illegal file/dir creation
  147.       UnixUserGroupInformation userGroupInfo = new UnixUserGroupInformation(
  148.           USER_NAME, GROUP_NAMES );
  149.       UnixUserGroupInformation.saveToConf(conf,
  150.           UnixUserGroupInformation.UGI_PROPERTY_NAME, userGroupInfo);
  151.       FileSystem userfs = FileSystem.get(conf);
  152.       // make sure mkdir of a existing directory that is not owned by 
  153.       // this user does not throw an exception.
  154.       userfs.mkdirs(CHILD_DIR1);
  155.       
  156.       // illegal mkdir
  157.       assertTrue(!canMkdirs(userfs, CHILD_DIR2));
  158.       // illegal file creation
  159.       assertTrue(!canCreate(userfs, CHILD_FILE2));
  160.       // illegal file open
  161.       assertTrue(!canOpen(userfs, CHILD_FILE1));
  162.       nnfs.setPermission(ROOT_PATH, new FsPermission((short)0755));
  163.       nnfs.setPermission(CHILD_DIR1, new FsPermission((short)0777));
  164.       nnfs.setPermission(new Path("/"), new FsPermission((short)0777));
  165.       final Path RENAME_PATH = new Path("/foo/bar");
  166.       userfs.mkdirs(RENAME_PATH);
  167.       assertTrue(canRename(userfs, RENAME_PATH, CHILD_DIR1));
  168.     } finally {
  169.       if(cluster != null) cluster.shutdown();
  170.     }
  171.   }
  172.   static boolean canMkdirs(FileSystem fs, Path p) throws IOException {
  173.     try {
  174.       fs.mkdirs(p);
  175.       return true;
  176.     } catch(AccessControlException e) {
  177.       return false;
  178.     }
  179.   }
  180.   static boolean canCreate(FileSystem fs, Path p) throws IOException {
  181.     try {
  182.       fs.create(p);
  183.       return true;
  184.     } catch(AccessControlException e) {
  185.       return false;
  186.     }
  187.   }
  188.   static boolean canOpen(FileSystem fs, Path p) throws IOException {
  189.     try {
  190.       fs.open(p);
  191.       return true;
  192.     } catch(AccessControlException e) {
  193.       return false;
  194.     }
  195.   }
  196.   static boolean canRename(FileSystem fs, Path src, Path dst
  197.       ) throws IOException {
  198.     try {
  199.       fs.rename(src, dst);
  200.       return true;
  201.     } catch(AccessControlException e) {
  202.       return false;
  203.     }
  204.   }
  205. }