From 3720342a48754338f5b8a1a96da30e9cbcac4179 Mon Sep 17 00:00:00 2001 From: surbhi Date: Fri, 19 Jun 2020 16:21:22 -0700 Subject: [PATCH 1/5] HBASE-22146 SpaceQuotaViolationPolicy Disable is not working in Namespace level --- .../hbase/namespace/NamespaceAuditor.java | 5 +++ .../apache/hadoop/hbase/quotas/QuotaUtil.java | 8 ++++ .../quotas/SpaceQuotaHelperForTests.java | 43 +++++++++++++++++++ .../hbase/quotas/TestSpaceQuotaRemoval.java | 23 ++++++++++ 4 files changed, 79 insertions(+) diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java index 0a74b093a8d2..80e7a5446c61 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hbase.namespace; import java.io.IOException; +import java.util.Set; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.MetaTableAccessor; @@ -141,6 +142,10 @@ public void addNamespace(NamespaceDescriptor ns) throws IOException { public void deleteNamespace(String namespace) throws IOException { stateManager.deleteNamespace(namespace); + Set tableNameSet = getState(namespace).getTables(); + for (TableName tableName: tableNameSet) { + removeFromNamespaceUsage(tableName); + } } public void removeFromNamespaceUsage(TableName tableName) diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java index e6acc4befccf..db8992299c17 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java @@ -267,6 +267,14 @@ private static void deleteQuotas(final Connection connection, final byte[] rowKe delete.addColumns(QUOTA_FAMILY_INFO, qualifier); } doDelete(connection, delete); + if (isNamespaceRowKey(rowKey)) { + TableName[] tableArray = connection.getAdmin().listTableNamesByNamespace(getNamespaceFromRowKey(rowKey)); + for (TableName tableName: tableArray) { + if (QuotaUtil.getTableQuota(connection, tableName) == null) { + deleteTableQuota(connection,tableName); + } + } + } } public static Map fetchUserQuotas(final Connection connection, diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java index d522c0cc4ed8..6bce7eef831b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java @@ -158,6 +158,28 @@ TableName writeUntilViolation(SpaceViolationPolicy policyToViolate) throws Excep return tn; } + + TableName writeUntilViolationAndVerifyViolationInNamespace( + String ns, SpaceViolationPolicy policyToViolate, Mutation m) throws Exception { + final TableName tn = writeUntilViolationInNamespace(ns, policyToViolate); + verifyViolation(policyToViolate, tn, m); + return tn; + } + + TableName writeUntilViolationInNamespace(String ns, SpaceViolationPolicy policyToViolate) throws Exception { + TableName tn = createTableWithRegions(ns,10); + + setQuotaLimit(ns, policyToViolate, 4L); + + // Write more data than should be allowed and flush it to disk + writeData(tn, 5L * SpaceQuotaHelperForTests.ONE_MEGABYTE); + + // This should be sufficient time for the chores to run and see the change. + Thread.sleep(5000); + + return tn; + } + /** * Verifies that the given policy on the given table has been violated */ @@ -271,6 +293,17 @@ void setQuotaLimit(final TableName tn, SpaceViolationPolicy policy, long sizeInM LOG.debug("Quota limit set for table = {}, limit = {}", tn, sizeLimit); } + /** + * Sets the given quota (policy & limit) on the passed namespace. + */ + void setQuotaLimit(String ns, SpaceViolationPolicy policy, long sizeInMBs) + throws Exception { + final long sizeLimit = sizeInMBs * SpaceQuotaHelperForTests.ONE_MEGABYTE; + QuotaSettings settings = QuotaSettingsFactory.limitNamespaceSpace(ns, sizeLimit, policy); + testUtil.getAdmin().setQuota(settings); + LOG.debug("Quota limit set for namespace = {}, limit = {}", ns, sizeLimit); + } + /** * Removes the space quota from the given table */ @@ -280,6 +313,16 @@ void removeQuotaFromtable(final TableName tn) throws Exception { LOG.debug("Space quota settings removed from the table ", tn); } + /** + * Removes the space quota from the given namespace + */ + void removeQuotaFromNamespace(String ns) throws Exception { + QuotaSettings removeQuota = QuotaSettingsFactory.removeNamespaceSpaceLimit(ns); + Admin admin = testUtil.getAdmin(); + admin.setQuota(removeQuota); + LOG.debug("Space quota settings removed from the namespace ", ns); + } + /** * Removes all quotas defined in the HBase quota table. */ diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java index ba89990a053b..b903108acbef 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java @@ -20,6 +20,7 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.testclassification.LargeTests; @@ -139,6 +140,28 @@ private void setQuotaAndThenRemove(SpaceViolationPolicy policy) throws Exception helper.verifyNoViolation(tn, put); } + @Test + public void testSetNamespaceSizeQuotaAndThenRemove() throws Exception { + Put put = new Put(Bytes.toBytes("to_reject")); + put.addColumn(Bytes.toBytes(SpaceQuotaHelperForTests.F1), Bytes.toBytes("to"), + Bytes.toBytes("reject")); + + SpaceViolationPolicy policy = SpaceViolationPolicy.NO_INSERTS; + + //Create namespace + NamespaceDescriptor nsd = helper.createNamespace(); + String ns = nsd.getName(); + + // Do puts until we violate space policy on table tn1 + final TableName tn1 = helper.writeUntilViolationAndVerifyViolationInNamespace(ns, policy, put); + + // Now, remove the quota from namespace + helper.removeQuotaFromNamespace(ns); + + // Put a new row now on tn1: should not violate as quota settings removed from namespace + helper.verifyNoViolation(tn1, put); + } + private void setQuotaAndThenRemoveInOneAmongTwoTables(SpaceViolationPolicy policy) throws Exception { Put put = new Put(Bytes.toBytes("to_reject")); From 5805f27559fc7c09d11bafee572a4eed1e09ee20 Mon Sep 17 00:00:00 2001 From: surbhi Date: Thu, 25 Jun 2020 15:32:30 -0700 Subject: [PATCH 2/5] HBASE-22146 SpaceQuotaViolationPolicy Disable is not working in Namespace -update --- .../hbase/namespace/NamespaceAuditor.java | 4 --- .../apache/hadoop/hbase/quotas/QuotaUtil.java | 29 +++++++++++++++---- 2 files changed, 23 insertions(+), 10 deletions(-) diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java index 80e7a5446c61..7cef80a99012 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java @@ -142,10 +142,6 @@ public void addNamespace(NamespaceDescriptor ns) throws IOException { public void deleteNamespace(String namespace) throws IOException { stateManager.deleteNamespace(namespace); - Set tableNameSet = getState(namespace).getTables(); - for (TableName tableName: tableNameSet) { - removeFromNamespaceUsage(tableName); - } } public void removeFromNamespaceUsage(TableName tableName) diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java index db8992299c17..2adf5e6e6e55 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java @@ -32,6 +32,7 @@ import org.apache.hadoop.hbase.TableNotDisabledException; import org.apache.hadoop.hbase.TableNotEnabledException; import org.apache.hadoop.hbase.TableNotFoundException; +import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.Delete; @@ -264,17 +265,33 @@ private static void deleteQuotas(final Connection connection, final byte[] rowKe final byte[] qualifier) throws IOException { Delete delete = new Delete(rowKey); if (qualifier != null) { - delete.addColumns(QUOTA_FAMILY_INFO, qualifier); + if (Arrays.equals(qualifier,QUOTA_QUALIFIER_POLICY)) { + delete.addColumns(QUOTA_FAMILY_USAGE, qualifier); + } else + delete.addColumns(QUOTA_FAMILY_INFO, qualifier); } - doDelete(connection, delete); if (isNamespaceRowKey(rowKey)) { - TableName[] tableArray = connection.getAdmin().listTableNamesByNamespace(getNamespaceFromRowKey(rowKey)); - for (TableName tableName: tableArray) { - if (QuotaUtil.getTableQuota(connection, tableName) == null) { - deleteTableQuota(connection,tableName); + //Check namespace is not deleted before you get info about quota and list of tables in namespace + NamespaceDescriptor[] descs = connection.getAdmin().listNamespaceDescriptors(); + String ns = getNamespaceFromRowKey(rowKey); + int index = 0; + while (index < descs.length) { + if (ns.equals(descs[index].getName())) { + Quotas namespaceQuota = getNamespaceQuota(connection,ns); + if (namespaceQuota != null && namespaceQuota.hasSpace()) { + TableName[] tableArray = connection.getAdmin().listTableNamesByNamespace(ns); + for (TableName tableName : tableArray) { + deleteQuotas(connection, getTableRowKey(tableName), QUOTA_QUALIFIER_POLICY); + } + } + //Exit the while loop by moving to last index + index = descs.length; + } else { + index++; } } } + doDelete(connection, delete); } public static Map fetchUserQuotas(final Connection connection, From e2ba1259595c7aed98478f285e682f7fc4712cef Mon Sep 17 00:00:00 2001 From: surbhi Date: Wed, 1 Jul 2020 12:01:01 -0700 Subject: [PATCH 3/5] HBASE-22146 SpaceQuotaViolationPolicy Disable is not working in Namespace -update2 --- .../java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java | 1 - .../src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java index 7cef80a99012..0a74b093a8d2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/namespace/NamespaceAuditor.java @@ -18,7 +18,6 @@ package org.apache.hadoop.hbase.namespace; import java.io.IOException; -import java.util.Set; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.MetaTableAccessor; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java index 2adf5e6e6e55..d334dd8dd760 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java @@ -265,6 +265,7 @@ private static void deleteQuotas(final Connection connection, final byte[] rowKe final byte[] qualifier) throws IOException { Delete delete = new Delete(rowKey); if (qualifier != null) { + //Check if delete qualifier is for persisted space quota snapshot usage column family if (Arrays.equals(qualifier,QUOTA_QUALIFIER_POLICY)) { delete.addColumns(QUOTA_FAMILY_USAGE, qualifier); } else From d1874e343a16e40f08f9d5eb8546422e147de70b Mon Sep 17 00:00:00 2001 From: surbhi Date: Wed, 15 Jul 2020 16:16:47 -0700 Subject: [PATCH 4/5] HBASE-22146 SpaceQuotaViolationPolicy Disable in Namespace-upd4 --- .../hadoop/hbase/quotas/QuotaTableUtil.java | 28 +++++++++++++++++++ .../apache/hadoop/hbase/quotas/QuotaUtil.java | 27 +++--------------- 2 files changed, 32 insertions(+), 23 deletions(-) diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java index 4f1491136b62..d697c230e4e6 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java @@ -628,6 +628,34 @@ static List createDeletesForExistingSnapshotsFromScan(Connection connect } } + /** + * Remove table usage snapshots (u:p columns) for the namespace passed + * @param connection connection to re-use + * @param namespace the namespace to fetch the list of table usage snapshots + */ + static void deleteTableUsageSnapshotsForNamespace(Connection connection, String namespace) + throws IOException { + Scan s = new Scan(); + //Get rows for all tables in namespace + s.setRowPrefixFilter(Bytes.toBytes("t." + namespace)); + //Scan for table usage column (u:p) in quota table + s.addColumn(QUOTA_FAMILY_USAGE,QUOTA_QUALIFIER_POLICY); + //Scan for table quota column (q:s) if table has a space quota defined + s.addColumn(QUOTA_FAMILY_INFO,QUOTA_QUALIFIER_SETTINGS); + try (Table quotaTable = connection.getTable(QUOTA_TABLE_NAME); + ResultScanner rs = quotaTable.getScanner(s)) { + for (Result r : rs) { + byte[] data = r.getValue(QUOTA_FAMILY_INFO, QUOTA_QUALIFIER_SETTINGS); + //if table does not have a table space quota defined, delete table usage column (u:p) + if (data == null) { + Delete delete = new Delete(r.getRow()); + delete.addColumns(QUOTA_FAMILY_USAGE,QUOTA_QUALIFIER_POLICY); + quotaTable.delete(delete); + } + } + } + } + /** * Fetches the computed size of all snapshots against tables in a namespace for space quotas. */ diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java index d334dd8dd760..716b6fe92efe 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java @@ -32,7 +32,6 @@ import org.apache.hadoop.hbase.TableNotDisabledException; import org.apache.hadoop.hbase.TableNotEnabledException; import org.apache.hadoop.hbase.TableNotFoundException; -import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.Delete; @@ -265,31 +264,13 @@ private static void deleteQuotas(final Connection connection, final byte[] rowKe final byte[] qualifier) throws IOException { Delete delete = new Delete(rowKey); if (qualifier != null) { - //Check if delete qualifier is for persisted space quota snapshot usage column family - if (Arrays.equals(qualifier,QUOTA_QUALIFIER_POLICY)) { - delete.addColumns(QUOTA_FAMILY_USAGE, qualifier); - } else - delete.addColumns(QUOTA_FAMILY_INFO, qualifier); + delete.addColumns(QUOTA_FAMILY_INFO, qualifier); } if (isNamespaceRowKey(rowKey)) { - //Check namespace is not deleted before you get info about quota and list of tables in namespace - NamespaceDescriptor[] descs = connection.getAdmin().listNamespaceDescriptors(); String ns = getNamespaceFromRowKey(rowKey); - int index = 0; - while (index < descs.length) { - if (ns.equals(descs[index].getName())) { - Quotas namespaceQuota = getNamespaceQuota(connection,ns); - if (namespaceQuota != null && namespaceQuota.hasSpace()) { - TableName[] tableArray = connection.getAdmin().listTableNamesByNamespace(ns); - for (TableName tableName : tableArray) { - deleteQuotas(connection, getTableRowKey(tableName), QUOTA_QUALIFIER_POLICY); - } - } - //Exit the while loop by moving to last index - index = descs.length; - } else { - index++; - } + Quotas namespaceQuota = getNamespaceQuota(connection,ns); + if (namespaceQuota != null && namespaceQuota.hasSpace()) { + deleteTableUsageSnapshotsForNamespace(connection, ns); } } doDelete(connection, delete); From 69e7e899636497154042af99ae943c3f298db7a0 Mon Sep 17 00:00:00 2001 From: surbhi Date: Fri, 17 Jul 2020 07:51:36 -0700 Subject: [PATCH 5/5] HBASE-22146 SpaceQuotaViolationPolicy Disable in Namespace-upd5 --- .../hadoop/hbase/quotas/QuotaTableUtil.java | 2 +- .../apache/hadoop/hbase/quotas/QuotaUtil.java | 1 + .../quotas/SpaceQuotaHelperForTests.java | 21 ++++++++++- .../hbase/quotas/TestSpaceQuotaRemoval.java | 35 +++++++++++++++++++ 4 files changed, 57 insertions(+), 2 deletions(-) diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java index d697c230e4e6..624b4751b3d2 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/QuotaTableUtil.java @@ -637,7 +637,7 @@ static void deleteTableUsageSnapshotsForNamespace(Connection connection, String throws IOException { Scan s = new Scan(); //Get rows for all tables in namespace - s.setRowPrefixFilter(Bytes.toBytes("t." + namespace)); + s.setRowPrefixFilter(Bytes.add(QUOTA_TABLE_ROW_KEY_PREFIX, Bytes.toBytes(namespace + TableName.NAMESPACE_DELIM))); //Scan for table usage column (u:p) in quota table s.addColumn(QUOTA_FAMILY_USAGE,QUOTA_QUALIFIER_POLICY); //Scan for table quota column (q:s) if table has a space quota defined diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java index 716b6fe92efe..1d816d6fe3a0 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/QuotaUtil.java @@ -270,6 +270,7 @@ private static void deleteQuotas(final Connection connection, final byte[] rowKe String ns = getNamespaceFromRowKey(rowKey); Quotas namespaceQuota = getNamespaceQuota(connection,ns); if (namespaceQuota != null && namespaceQuota.hasSpace()) { + // When deleting namespace space quota, also delete table usage(u:p) snapshots deleteTableUsageSnapshotsForNamespace(connection, ns); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java index 6bce7eef831b..296d38f51673 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/SpaceQuotaHelperForTests.java @@ -282,6 +282,19 @@ void verifyNoViolation(TableName tn, Mutation m) throws Exception { assertTrue("Expected to succeed in writing data to a table not having quota ", sawSuccess); } + /** + * Verifies that table usage snapshot exists for the table + */ + void verifyTableUsageSnapshotForSpaceQuotaExist(TableName tn) throws Exception { + boolean sawUsageSnapshot = false; + try (Table quotaTable = testUtil.getConnection().getTable(QuotaTableUtil.QUOTA_TABLE_NAME)) { + Scan s = QuotaTableUtil.makeQuotaSnapshotScanForTable(tn); + ResultScanner rs = quotaTable.getScanner(s); + sawUsageSnapshot = (rs.next() != null); + } + assertTrue("Expected to succeed in getting table usage snapshots for space quota", sawUsageSnapshot); + } + /** * Sets the given quota (policy & limit) on the passed table. */ @@ -454,7 +467,13 @@ void writeData(TableName tn, long sizeInBytes, byte[] qual) throws IOException { } NamespaceDescriptor createNamespace() throws Exception { - NamespaceDescriptor nd = NamespaceDescriptor.create("ns" + counter.getAndIncrement()).build(); + return createNamespace(null); + } + + NamespaceDescriptor createNamespace(String namespace) throws Exception { + if (namespace == null || namespace.trim().isEmpty()) + namespace = "ns" + counter.getAndIncrement(); + NamespaceDescriptor nd = NamespaceDescriptor.create(namespace).build(); testUtil.getAdmin().createNamespace(nd); return nd; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java index b903108acbef..3ed6c716ec8c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaRemoval.java @@ -140,6 +140,41 @@ private void setQuotaAndThenRemove(SpaceViolationPolicy policy) throws Exception helper.verifyNoViolation(tn, put); } + @Test + public void testDeleteTableUsageSnapshotsForNamespace() throws Exception { + Put put = new Put(Bytes.toBytes("to_reject")); + put.addColumn(Bytes.toBytes(SpaceQuotaHelperForTests.F1), Bytes.toBytes("to"), + Bytes.toBytes("reject")); + + SpaceViolationPolicy policy = SpaceViolationPolicy.NO_INSERTS; + + //Create a namespace + String ns1 = "nsnew"; + NamespaceDescriptor nsd = helper.createNamespace(ns1); + + //Create 2nd namespace with name similar to ns1 + String ns2 = ns1 + "test"; + NamespaceDescriptor nsd2 = helper.createNamespace(ns2); + + // Do puts until we violate space policy on table tn1 in namesapce ns1 + final TableName tn1 = helper.writeUntilViolationAndVerifyViolationInNamespace(ns1, policy, put); + + // Do puts until we violate space policy on table tn2 in namespace ns2 + final TableName tn2 = helper.writeUntilViolationAndVerifyViolationInNamespace(ns2, policy, put); + + // Now, remove the quota from namespace ns1 which will remove table usage snapshots for ns1 + helper.removeQuotaFromNamespace(ns1); + + // Verify that table usage snapshot for table tn2 in namespace ns2 exist + helper.verifyTableUsageSnapshotForSpaceQuotaExist(tn2); + + // Put a new row on tn2: should violate as space quota exists on namespace ns2 + helper.verifyViolation(policy, tn2, put); + + // Put a new row on tn1: should not violate as quota settings removed from namespace ns1 + helper.verifyNoViolation(tn1, put); + } + @Test public void testSetNamespaceSizeQuotaAndThenRemove() throws Exception { Put put = new Put(Bytes.toBytes("to_reject"));