开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网格计算 > 查看源码
TestQuota.java
资源名称：hadoop-0.20.0.tar.gz　[点击查看]
上传用户：quxuerui
上传日期：2018-01-08
资源大小：41811k
文件大小：23k
源码类别：

网格计算

开发平台：

Java

TestQuota.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.hdfs;
  20. import java.io.OutputStream;
  22. import org.apache.hadoop.conf.Configuration;
  23. import org.apache.hadoop.fs.ContentSummary;
  24. import org.apache.hadoop.fs.FileSystem;
  25. import org.apache.hadoop.fs.Path;
  26. import org.apache.hadoop.hdfs.protocol.FSConstants;
  27. import org.apache.hadoop.hdfs.protocol.QuotaExceededException;
  28. import org.apache.hadoop.hdfs.tools.DFSAdmin;
  29. import org.apache.hadoop.io.IOUtils;
  30. import org.apache.hadoop.security.UnixUserGroupInformation;
  32. import junit.framework.TestCase;
  34. /** A class for testing quota-related commands */
  35. public class TestQuota extends TestCase {
  36.   
  37.   private void runCommand(DFSAdmin admin, boolean expectError, String... args) 
  38.                          throws Exception {
  39.     runCommand(admin, args, expectError);
  40.   }
  41.   
  42.   private void runCommand(DFSAdmin admin, String args[], boolean expectEror)
  43.   throws Exception {
  44.     int val = admin.run(args);
  45.     if (expectEror) {
  46.       assertEquals(val, -1);
  47.     } else {
  48.       assertTrue(val>=0);
  49.     }
  50.   }
  51.   
  52.   /** Test quota related commands: 
  53.    *    setQuota, clrQuota, setSpaceQuota, clrSpaceQuota, and count 
  54.    */
  55.   public void testQuotaCommands() throws Exception {
  56.     final Configuration conf = new Configuration();
  57.     // set a smaller block size so that we can test with smaller 
  58.     // Space quotas
  59.     conf.set("dfs.block.size", "512");
  60.     conf.setBoolean("dfs.support.append", true);
  61.     final MiniDFSCluster cluster = new MiniDFSCluster(conf, 2, true, null);
  62.     final FileSystem fs = cluster.getFileSystem();
  63.     assertTrue("Not a HDFS: "+fs.getUri(),
  64.                 fs instanceof DistributedFileSystem);
  65.     final DistributedFileSystem dfs = (DistributedFileSystem)fs;
  66.     DFSAdmin admin = new DFSAdmin(conf);
  67.     
  68.     try {
  69.       final int fileLen = 1024;
  70.       final short replication = 5;
  71.       final long spaceQuota = fileLen * replication * 15 / 8;
  73.       // 1: create a directory /test and set its quota to be 3
  74.       final Path parent = new Path("/test");
  75.       assertTrue(dfs.mkdirs(parent));
  76.       String[] args = new String[]{"-setQuota", "3", parent.toString()};
  77.       runCommand(admin, args, false);
  79.       //try setting space quota with a 'binary prefix'
  80.       runCommand(admin, false, "-setSpaceQuota", "2t", parent.toString());
  81.       assertEquals(2L<<40, dfs.getContentSummary(parent).getSpaceQuota());
  82.       
  83.       // set diskspace quota to 10000 
  84.       runCommand(admin, false, "-setSpaceQuota", 
  85.                  Long.toString(spaceQuota), parent.toString());
  86.       
  87.       // 2: create directory /test/data0
  88.       final Path childDir0 = new Path(parent, "data0");
  89.       assertTrue(dfs.mkdirs(childDir0));
  91.       // 3: create a file /test/datafile0
  92.       final Path childFile0 = new Path(parent, "datafile0");
  93.       DFSTestUtil.createFile(fs, childFile0, fileLen, replication, 0);
  94.       
  95.       // 4: count -q /test
  96.       ContentSummary c = dfs.getContentSummary(parent);
  97.       assertEquals(c.getFileCount()+c.getDirectoryCount(), 3);
  98.       assertEquals(c.getQuota(), 3);
  99.       assertEquals(c.getSpaceConsumed(), fileLen*replication);
  100.       assertEquals(c.getSpaceQuota(), spaceQuota);
  101.       
  102.       // 5: count -q /test/data0
  103.       c = dfs.getContentSummary(childDir0);
  104.       assertEquals(c.getFileCount()+c.getDirectoryCount(), 1);
  105.       assertEquals(c.getQuota(), -1);
  106.       // check disk space consumed
  107.       c = dfs.getContentSummary(parent);
  108.       assertEquals(c.getSpaceConsumed(), fileLen*replication);
  110.       // 6: create a directory /test/data1
  111.       final Path childDir1 = new Path(parent, "data1");
  112.       boolean hasException = false;
  113.       try {
  114.         assertFalse(dfs.mkdirs(childDir1));
  115.       } catch (QuotaExceededException e) {
  116.         hasException = true;
  117.       }
  118.       assertTrue(hasException);
  119.       
  120.       OutputStream fout;
  121.       
  122.       // 7: create a file /test/datafile1
  123.       final Path childFile1 = new Path(parent, "datafile1");
  124.       hasException = false;
  125.       try {
  126.         fout = dfs.create(childFile1);
  127.       } catch (QuotaExceededException e) {
  128.         hasException = true;
  129.       }
  130.       assertTrue(hasException);
  131.       
  132.       // 8: clear quota /test
  133.       runCommand(admin, new String[]{"-clrQuota", parent.toString()}, false);
  134.       c = dfs.getContentSummary(parent);
  135.       assertEquals(c.getQuota(), -1);
  136.       assertEquals(c.getSpaceQuota(), spaceQuota);
  137.       
  138.       // 9: clear quota /test/data0
  139.       runCommand(admin, new String[]{"-clrQuota", childDir0.toString()}, false);
  140.       c = dfs.getContentSummary(childDir0);
  141.       assertEquals(c.getQuota(), -1);
  142.       
  143.       // 10: create a file /test/datafile1
  144.       fout = dfs.create(childFile1, replication);
  145.       
  146.       // 10.s: but writing fileLen bytes should result in an quota exception
  147.       hasException = false;
  148.       try {
  149.         fout.write(new byte[fileLen]);
  150.         fout.close();
  151.       } catch (QuotaExceededException e) {
  152.         hasException = true;
  153.         IOUtils.closeStream(fout);
  154.       }
  155.       assertTrue(hasException);
  156.       
  157.       //delete the file
  158.       dfs.delete(childFile1, false);
  159.       
  160.       // 9.s: clear diskspace quota
  161.       runCommand(admin, false, "-clrSpaceQuota", parent.toString());
  162.       c = dfs.getContentSummary(parent);
  163.       assertEquals(c.getQuota(), -1);
  164.       assertEquals(c.getSpaceQuota(), -1);       
  165.       
  166.       // now creating childFile1 should succeed
  167.       DFSTestUtil.createFile(dfs, childFile1, fileLen, replication, 0);
  168.       
  169.       // 11: set the quota of /test to be 1
  170.       args = new String[]{"-setQuota", "1", parent.toString()};
  171.       runCommand(admin, args, true);
  172.       runCommand(admin, true, "-setSpaceQuota",  // for space quota
  173.                  Integer.toString(fileLen), args[2]);
  174.       
  175.       // 12: set the quota of /test/data0 to be 1
  176.       args = new String[]{"-setQuota", "1", childDir0.toString()};
  177.       runCommand(admin, args, false);
  178.       
  179.       // 13: not able create a directory under data0
  180.       hasException = false;
  181.       try {
  182.         assertFalse(dfs.mkdirs(new Path(childDir0, "in")));
  183.       } catch (QuotaExceededException e) {
  184.         hasException = true;
  185.       }
  186.       assertTrue(hasException);
  187.       c = dfs.getContentSummary(childDir0);
  188.       assertEquals(c.getDirectoryCount()+c.getFileCount(), 1);
  189.       assertEquals(c.getQuota(), 1);
  190.       
  191.       // 14a: set quota on a non-existent directory
  192.       Path nonExistentPath = new Path("/test1");
  193.       assertFalse(dfs.exists(nonExistentPath));
  194.       args = new String[]{"-setQuota", "1", nonExistentPath.toString()};
  195.       runCommand(admin, args, true);
  196.       runCommand(admin, true, "-setSpaceQuota", "1g", // for space quota
  197.                  nonExistentPath.toString());
  198.       
  199.       // 14b: set quota on a file
  200.       assertTrue(dfs.isFile(childFile0));
  201.       args[1] = childFile0.toString();
  202.       runCommand(admin, args, true);
  203.       // same for space quota
  204.       runCommand(admin, true, "-setSpaceQuota", "1t", args[1]);
  205.       
  206.       // 15a: clear quota on a file
  207.       args[0] = "-clrQuota";
  208.       runCommand(admin, args, true);
  209.       runCommand(admin, true, "-clrSpaceQuota", args[1]);
  210.       
  211.       // 15b: clear quota on a non-existent directory
  212.       args[1] = nonExistentPath.toString();
  213.       runCommand(admin, args, true);
  214.       runCommand(admin, true, "-clrSpaceQuota", args[1]);
  215.       
  216.       // 16a: set the quota of /test to be 0
  217.       args = new String[]{"-setQuota", "0", parent.toString()};
  218.       runCommand(admin, args, true);
  219.       runCommand(admin, true, "-setSpaceQuota", "0", args[2]);
  220.       
  221.       // 16b: set the quota of /test to be -1
  222.       args[1] = "-1";
  223.       runCommand(admin, args, true);
  224.       runCommand(admin, true, "-setSpaceQuota", args[1], args[2]);
  225.       
  226.       // 16c: set the quota of /test to be Long.MAX_VALUE+1
  227.       args[1] = String.valueOf(Long.MAX_VALUE+1L);
  228.       runCommand(admin, args, true);
  229.       runCommand(admin, true, "-setSpaceQuota", args[1], args[2]);
  230.       
  231.       // 16d: set the quota of /test to be a non integer
  232.       args[1] = "33aa1.5";
  233.       runCommand(admin, args, true);
  234.       runCommand(admin, true, "-setSpaceQuota", args[1], args[2]);
  235.       
  236.       // 16e: set space quota with a value larger than Long.MAX_VALUE
  237.       runCommand(admin, true, "-setSpaceQuota", 
  238.                  (Long.MAX_VALUE/1024/1024 + 1024) + "m", args[2]);
  239.       
  240.       // 17:  setQuota by a non-administrator
  241.       UnixUserGroupInformation.saveToConf(conf, 
  242.           UnixUserGroupInformation.UGI_PROPERTY_NAME, 
  243.           new UnixUserGroupInformation(new String[]{"userxxn", "groupyyn"}));
  244.       DFSAdmin userAdmin = new DFSAdmin(conf);
  245.       args[1] = "100";
  246.       runCommand(userAdmin, args, true);
  247.       runCommand(userAdmin, true, "-setSpaceQuota", "1g", args[2]);
  248.       
  249.       // 18: clrQuota by a non-administrator
  250.       args = new String[] {"-clrQuota", parent.toString()};
  251.       runCommand(userAdmin, args, true);
  252.       runCommand(userAdmin, true, "-clrSpaceQuota",  args[1]);      
  253.     } finally {
  254.       cluster.shutdown();
  255.     }
  256.   }
  257.   
  258.   /** Test commands that change the size of the name space:
  259.    *  mkdirs, rename, and delete */
  260.   public void testNamespaceCommands() throws Exception {
  261.     final Configuration conf = new Configuration();
  262.     final MiniDFSCluster cluster = new MiniDFSCluster(conf, 2, true, null);
  263.     final FileSystem fs = cluster.getFileSystem();
  264.     assertTrue("Not a HDFS: "+fs.getUri(),
  265.                 fs instanceof DistributedFileSystem);
  266.     final DistributedFileSystem dfs = (DistributedFileSystem)fs;
  267.     
  268.     try {
  269.       // 1: create directory /nqdir0/qdir1/qdir20/nqdir30
  270.       assertTrue(dfs.mkdirs(new Path("/nqdir0/qdir1/qdir20/nqdir30")));
  272.       // 2: set the quota of /nqdir0/qdir1 to be 6
  273.       final Path quotaDir1 = new Path("/nqdir0/qdir1");
  274.       dfs.setQuota(quotaDir1, 6, FSConstants.QUOTA_DONT_SET);
  275.       ContentSummary c = dfs.getContentSummary(quotaDir1);
  276.       assertEquals(c.getDirectoryCount(), 3);
  277.       assertEquals(c.getQuota(), 6);
  279.       // 3: set the quota of /nqdir0/qdir1/qdir20 to be 7
  280.       final Path quotaDir2 = new Path("/nqdir0/qdir1/qdir20");
  281.       dfs.setQuota(quotaDir2, 7, FSConstants.QUOTA_DONT_SET);
  282.       c = dfs.getContentSummary(quotaDir2);
  283.       assertEquals(c.getDirectoryCount(), 2);
  284.       assertEquals(c.getQuota(), 7);
  286.       // 4: Create directory /nqdir0/qdir1/qdir21 and set its quota to 2
  287.       final Path quotaDir3 = new Path("/nqdir0/qdir1/qdir21");
  288.       assertTrue(dfs.mkdirs(quotaDir3));
  289.       dfs.setQuota(quotaDir3, 2, FSConstants.QUOTA_DONT_SET);
  290.       c = dfs.getContentSummary(quotaDir3);
  291.       assertEquals(c.getDirectoryCount(), 1);
  292.       assertEquals(c.getQuota(), 2);
  294.       // 5: Create directory /nqdir0/qdir1/qdir21/nqdir32
  295.       Path tempPath = new Path(quotaDir3, "nqdir32");
  296.       assertTrue(dfs.mkdirs(tempPath));
  297.       c = dfs.getContentSummary(quotaDir3);
  298.       assertEquals(c.getDirectoryCount(), 2);
  299.       assertEquals(c.getQuota(), 2);
  301.       // 6: Create directory /nqdir0/qdir1/qdir21/nqdir33
  302.       tempPath = new Path(quotaDir3, "nqdir33");
  303.       boolean hasException = false;
  304.       try {
  305.         assertFalse(dfs.mkdirs(tempPath));
  306.       } catch (QuotaExceededException e) {
  307.         hasException = true;
  308.       }
  309.       assertTrue(hasException);
  310.       c = dfs.getContentSummary(quotaDir3);
  311.       assertEquals(c.getDirectoryCount(), 2);
  312.       assertEquals(c.getQuota(), 2);
  314.       // 7: Create directory /nqdir0/qdir1/qdir20/nqdir31
  315.       tempPath = new Path(quotaDir2, "nqdir31");
  316.       assertTrue(dfs.mkdirs(tempPath));
  317.       c = dfs.getContentSummary(quotaDir2);
  318.       assertEquals(c.getDirectoryCount(), 3);
  319.       assertEquals(c.getQuota(), 7);
  320.       c = dfs.getContentSummary(quotaDir1);
  321.       assertEquals(c.getDirectoryCount(), 6);
  322.       assertEquals(c.getQuota(), 6);
  324.       // 8: Create directory /nqdir0/qdir1/qdir20/nqdir33
  325.       tempPath = new Path(quotaDir2, "nqdir33");
  326.       hasException = false;
  327.       try {
  328.         assertFalse(dfs.mkdirs(tempPath));
  329.       } catch (QuotaExceededException e) {
  330.         hasException = true;
  331.       }
  332.       assertTrue(hasException);
  334.       // 9: Move /nqdir0/qdir1/qdir21/nqdir32 /nqdir0/qdir1/qdir20/nqdir30
  335.       tempPath = new Path(quotaDir2, "nqdir30");
  336.       dfs.rename(new Path(quotaDir3, "nqdir32"), tempPath);
  337.       c = dfs.getContentSummary(quotaDir2);
  338.       assertEquals(c.getDirectoryCount(), 4);
  339.       assertEquals(c.getQuota(), 7);
  340.       c = dfs.getContentSummary(quotaDir1);
  341.       assertEquals(c.getDirectoryCount(), 6);
  342.       assertEquals(c.getQuota(), 6);
  344.       // 10: Move /nqdir0/qdir1/qdir20/nqdir30 to /nqdir0/qdir1/qdir21
  345.       hasException = false;
  346.       try {
  347.         assertFalse(dfs.rename(tempPath, quotaDir3));
  348.       } catch (QuotaExceededException e) {
  349.         hasException = true;
  350.       }
  351.       assertTrue(hasException);
  352.       assertTrue(dfs.exists(tempPath));
  353.       assertFalse(dfs.exists(new Path(quotaDir3, "nqdir30")));
  354.       
  355.       // 10.a: Rename /nqdir0/qdir1/qdir20/nqdir30 to /nqdir0/qdir1/qdir21/nqdir32
  356.       hasException = false;
  357.       try {
  358.         assertFalse(dfs.rename(tempPath, new Path(quotaDir3, "nqdir32")));
  359.       } catch (QuotaExceededException e) {
  360.         hasException = true;
  361.       }
  362.       assertTrue(hasException);
  363.       assertTrue(dfs.exists(tempPath));
  364.       assertFalse(dfs.exists(new Path(quotaDir3, "nqdir32")));
  366.       // 11: Move /nqdir0/qdir1/qdir20/nqdir30 to /nqdir0
  367.       assertTrue(dfs.rename(tempPath, new Path("/nqdir0")));
  368.       c = dfs.getContentSummary(quotaDir2);
  369.       assertEquals(c.getDirectoryCount(), 2);
  370.       assertEquals(c.getQuota(), 7);
  371.       c = dfs.getContentSummary(quotaDir1);
  372.       assertEquals(c.getDirectoryCount(), 4);
  373.       assertEquals(c.getQuota(), 6);
  375.       // 12: Create directory /nqdir0/nqdir30/nqdir33
  376.       assertTrue(dfs.mkdirs(new Path("/nqdir0/nqdir30/nqdir33")));
  378.       // 13: Move /nqdir0/nqdir30 /nqdir0/qdir1/qdir20/qdir30
  379.       hasException = false;
  380.       try {
  381.         assertFalse(dfs.rename(new Path("/nqdir0/nqdir30"), tempPath));
  382.       } catch (QuotaExceededException e) {
  383.         hasException = true;
  384.       }
  385.       assertTrue(hasException);
  387.       // 14: Move /nqdir0/qdir1/qdir21 /nqdir0/qdir1/qdir20
  388.       assertTrue(dfs.rename(quotaDir3, quotaDir2));
  389.       c = dfs.getContentSummary(quotaDir1);
  390.       assertEquals(c.getDirectoryCount(), 4);
  391.       assertEquals(c.getQuota(), 6);
  392.       c = dfs.getContentSummary(quotaDir2);
  393.       assertEquals(c.getDirectoryCount(), 3);
  394.       assertEquals(c.getQuota(), 7);
  395.       tempPath = new Path(quotaDir2, "qdir21");
  396.       c = dfs.getContentSummary(tempPath);
  397.       assertEquals(c.getDirectoryCount(), 1);
  398.       assertEquals(c.getQuota(), 2);
  400.       // 15: Delete /nqdir0/qdir1/qdir20/qdir21
  401.       dfs.delete(tempPath, true);
  402.       c = dfs.getContentSummary(quotaDir2);
  403.       assertEquals(c.getDirectoryCount(), 2);
  404.       assertEquals(c.getQuota(), 7);
  405.       c = dfs.getContentSummary(quotaDir1);
  406.       assertEquals(c.getDirectoryCount(), 3);
  407.       assertEquals(c.getQuota(), 6);
  409.       // 16: Move /nqdir0/qdir30 /nqdir0/qdir1/qdir20
  410.       assertTrue(dfs.rename(new Path("/nqdir0/nqdir30"), quotaDir2));
  411.       c = dfs.getContentSummary(quotaDir2);
  412.       assertEquals(c.getDirectoryCount(), 5);
  413.       assertEquals(c.getQuota(), 7);
  414.       c = dfs.getContentSummary(quotaDir1);
  415.       assertEquals(c.getDirectoryCount(), 6);
  416.       assertEquals(c.getQuota(), 6);
  417.     } finally {
  418.       cluster.shutdown();
  419.     }
  420.   }
  421.   
  422.   /**
  423.    * Test HDFS operations that change disk space consumed by a directory tree.
  424.    * namely create, rename, delete, append, and setReplication.
  425.    * 
  426.    * This is based on testNamespaceCommands() above.
  427.    */
  428.   public void testSpaceCommands() throws Exception {
  429.     final Configuration conf = new Configuration();
  430.     // set a smaller block size so that we can test with smaller 
  431.     // diskspace quotas
  432.     conf.set("dfs.block.size", "512");
  433.     conf.setBoolean("dfs.support.append", true);
  434.     final MiniDFSCluster cluster = new MiniDFSCluster(conf, 2, true, null);
  435.     final FileSystem fs = cluster.getFileSystem();
  436.     assertTrue("Not a HDFS: "+fs.getUri(),
  437.                 fs instanceof DistributedFileSystem);
  438.     final DistributedFileSystem dfs = (DistributedFileSystem)fs;
  440.     try {
  441.       int fileLen = 1024;
  442.       short replication = 3;
  443.       int fileSpace = fileLen * replication;
  444.       
  445.       // create directory /nqdir0/qdir1/qdir20/nqdir30
  446.       assertTrue(dfs.mkdirs(new Path("/nqdir0/qdir1/qdir20/nqdir30")));
  448.       // set the quota of /nqdir0/qdir1 to 4 * fileSpace 
  449.       final Path quotaDir1 = new Path("/nqdir0/qdir1");
  450.       dfs.setQuota(quotaDir1, FSConstants.QUOTA_DONT_SET, 4 * fileSpace);
  451.       ContentSummary c = dfs.getContentSummary(quotaDir1);
  452.       assertEquals(c.getSpaceQuota(), 4 * fileSpace);
  453.       
  454.       // set the quota of /nqdir0/qdir1/qdir20 to 6 * fileSpace 
  455.       final Path quotaDir20 = new Path("/nqdir0/qdir1/qdir20");
  456.       dfs.setQuota(quotaDir20, FSConstants.QUOTA_DONT_SET, 6 * fileSpace);
  457.       c = dfs.getContentSummary(quotaDir20);
  458.       assertEquals(c.getSpaceQuota(), 6 * fileSpace);
  461.       // Create /nqdir0/qdir1/qdir21 and set its space quota to 2 * fileSpace
  462.       final Path quotaDir21 = new Path("/nqdir0/qdir1/qdir21");
  463.       assertTrue(dfs.mkdirs(quotaDir21));
  464.       dfs.setQuota(quotaDir21, FSConstants.QUOTA_DONT_SET, 2 * fileSpace);
  465.       c = dfs.getContentSummary(quotaDir21);
  466.       assertEquals(c.getSpaceQuota(), 2 * fileSpace);
  468.       // 5: Create directory /nqdir0/qdir1/qdir21/nqdir32
  469.       Path tempPath = new Path(quotaDir21, "nqdir32");
  470.       assertTrue(dfs.mkdirs(tempPath));
  471.       
  472.       // create a file under nqdir32/fileDir
  473.       DFSTestUtil.createFile(dfs, new Path(tempPath, "fileDir/file1"), fileLen, 
  474.                              replication, 0);
  475.       c = dfs.getContentSummary(quotaDir21);
  476.       assertEquals(c.getSpaceConsumed(), fileSpace);
  477.       
  478.       // Create a larger file /nqdir0/qdir1/qdir21/nqdir33/
  479.       boolean hasException = false;
  480.       try {
  481.         DFSTestUtil.createFile(dfs, new Path(quotaDir21, "nqdir33/file2"), 
  482.                                2*fileLen, replication, 0);
  483.       } catch (QuotaExceededException e) {
  484.         hasException = true;
  485.       }
  486.       assertTrue(hasException);
  487.       // delete nqdir33
  488.       assertTrue(dfs.delete(new Path(quotaDir21, "nqdir33"), true));
  489.       c = dfs.getContentSummary(quotaDir21);
  490.       assertEquals(c.getSpaceConsumed(), fileSpace);
  491.       assertEquals(c.getSpaceQuota(), 2*fileSpace);
  493.       // Verify space before the move:
  494.       c = dfs.getContentSummary(quotaDir20);
  495.       assertEquals(c.getSpaceConsumed(), 0);
  496.       
  497.       // Move /nqdir0/qdir1/qdir21/nqdir32 /nqdir0/qdir1/qdir20/nqdir30
  498.       Path dstPath = new Path(quotaDir20, "nqdir30");
  499.       Path srcPath = new Path(quotaDir21, "nqdir32");
  500.       assertTrue(dfs.rename(srcPath, dstPath));
  501.       
  502.       // verify space after the move
  503.       c = dfs.getContentSummary(quotaDir20);
  504.       assertEquals(c.getSpaceConsumed(), fileSpace);
  505.       // verify space for its parent
  506.       c = dfs.getContentSummary(quotaDir1);
  507.       assertEquals(c.getSpaceConsumed(), fileSpace);
  508.       // verify space for source for the move
  509.       c = dfs.getContentSummary(quotaDir21);
  510.       assertEquals(c.getSpaceConsumed(), 0);
  511.       
  512.       final Path file2 = new Path(dstPath, "fileDir/file2");
  513.       int file2Len = 2 * fileLen;
  514.       // create a larger file under /nqdir0/qdir1/qdir20/nqdir30
  515.       DFSTestUtil.createFile(dfs, file2, file2Len, replication, 0);
  516.       
  517.       c = dfs.getContentSummary(quotaDir20);
  518.       assertEquals(c.getSpaceConsumed(), 3 * fileSpace);
  519.       c = dfs.getContentSummary(quotaDir21);
  520.       assertEquals(c.getSpaceConsumed(), 0);
  521.       
  522.       // Reverse: Move /nqdir0/qdir1/qdir20/nqdir30 to /nqdir0/qdir1/qdir21/
  523.       hasException = false;
  524.       try {
  525.         assertFalse(dfs.rename(dstPath, srcPath));
  526.       } catch (QuotaExceededException e) {
  527.         hasException = true;
  528.       }
  529.       assertTrue(hasException);
  530.       
  531.       // make sure no intermediate directories left by failed rename
  532.       assertFalse(dfs.exists(srcPath));
  533.       // directory should exist
  534.       assertTrue(dfs.exists(dstPath));
  535.             
  536.       // verify space after the failed move
  537.       c = dfs.getContentSummary(quotaDir20);
  538.       assertEquals(c.getSpaceConsumed(), 3 * fileSpace);
  539.       c = dfs.getContentSummary(quotaDir21);
  540.       assertEquals(c.getSpaceConsumed(), 0);
  541.       
  542.       // Test Append :
  543.       
  544.       // verify space quota
  545.       c = dfs.getContentSummary(quotaDir1);
  546.       assertEquals(c.getSpaceQuota(), 4 * fileSpace);
  547.       
  548.       // verify space before append;
  549.       c = dfs.getContentSummary(dstPath);
  550.       assertEquals(c.getSpaceConsumed(), 3 * fileSpace);
  551.       
  552.       OutputStream out = dfs.append(file2);
  553.       // appending 1 fileLen should succeed
  554.       out.write(new byte[fileLen]);
  555.       out.close();
  556.       
  557.       file2Len += fileLen; // after append
  558.       
  559.       // verify space after append;
  560.       c = dfs.getContentSummary(dstPath);
  561.       assertEquals(c.getSpaceConsumed(), 4 * fileSpace);
  562.       
  563.       // now increase the quota for quotaDir1
  564.       dfs.setQuota(quotaDir1, FSConstants.QUOTA_DONT_SET, 5 * fileSpace);
  565.       // Now, appending more than 1 fileLen should result in an error
  566.       out = dfs.append(file2);
  567.       hasException = false;
  568.       try {
  569.         out.write(new byte[fileLen + 1024]);
  570.         out.flush();
  571.         out.close();
  572.       } catch (QuotaExceededException e) {
  573.         hasException = true;
  574.         IOUtils.closeStream(out);
  575.       }
  576.       assertTrue(hasException);
  577.       
  578.       file2Len += fileLen; // after partial append
  579.       
  580.       // verify space after partial append
  581.       c = dfs.getContentSummary(dstPath);
  582.       assertEquals(c.getSpaceConsumed(), 5 * fileSpace);
  583.       
  584.       // Test set replication :
  585.       
  586.       // first reduce the replication
  587.       dfs.setReplication(file2, (short)(replication-1));
  588.       
  589.       // verify that space is reduced by file2Len
  590.       c = dfs.getContentSummary(dstPath);
  591.       assertEquals(c.getSpaceConsumed(), 5 * fileSpace - file2Len);
  592.       
  593.       // now try to increase the replication and and expect an error.
  594.       hasException = false;
  595.       try {
  596.         dfs.setReplication(file2, (short)(replication+1));
  597.       } catch (QuotaExceededException e) {
  598.         hasException = true;
  599.       }
  600.       assertTrue(hasException);
  602.       // verify space consumed remains unchanged.
  603.       c = dfs.getContentSummary(dstPath);
  604.       assertEquals(c.getSpaceConsumed(), 5 * fileSpace - file2Len);
  605.       
  606.       // now increase the quota for quotaDir1 and quotaDir20
  607.       dfs.setQuota(quotaDir1, FSConstants.QUOTA_DONT_SET, 10 * fileSpace);
  608.       dfs.setQuota(quotaDir20, FSConstants.QUOTA_DONT_SET, 10 * fileSpace);
  609.       
  610.       // then increasing replication should be ok.
  611.       dfs.setReplication(file2, (short)(replication+1));
  612.       // verify increase in space
  613.       c = dfs.getContentSummary(dstPath);
  614.       assertEquals(c.getSpaceConsumed(), 5 * fileSpace + file2Len);
  615.       
  616.     } finally {
  617.       cluster.shutdown();
  618.     }
  619.   }
  620. }