001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018package org.apache.hadoop.hbase.quotas; 019 020import static org.apache.hadoop.hbase.quotas.ThrottleQuotaTestUtil.triggerUserCacheRefresh; 021import static org.apache.hadoop.hbase.quotas.ThrottleQuotaTestUtil.waitMinuteQuota; 022 023import java.io.IOException; 024import java.util.UUID; 025import java.util.concurrent.TimeUnit; 026import org.apache.hadoop.hbase.HBaseClassTestRule; 027import org.apache.hadoop.hbase.HBaseTestingUtil; 028import org.apache.hadoop.hbase.HConstants; 029import org.apache.hadoop.hbase.TableName; 030import org.apache.hadoop.hbase.client.Admin; 031import org.apache.hadoop.hbase.client.Table; 032import org.apache.hadoop.hbase.security.User; 033import org.apache.hadoop.hbase.testclassification.MediumTests; 034import org.apache.hadoop.hbase.testclassification.RegionServerTests; 035import org.apache.hadoop.hbase.util.Bytes; 036import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; 037import org.junit.AfterClass; 038import org.junit.BeforeClass; 039import org.junit.ClassRule; 040import org.junit.Test; 041import org.junit.experimental.categories.Category; 042 043@Category({ RegionServerTests.class, MediumTests.class }) 044public class TestDefaultAtomicQuota { 045 @ClassRule 046 public static final HBaseClassTestRule CLASS_RULE = 047 HBaseClassTestRule.forClass(TestDefaultAtomicQuota.class); 048 private static final HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil(); 049 private static final TableName TABLE_NAME = TableName.valueOf(UUID.randomUUID().toString()); 050 private static final int REFRESH_TIME = 5; 051 private static final byte[] FAMILY = Bytes.toBytes("cf"); 052 private static final byte[] QUALIFIER = Bytes.toBytes("q"); 053 054 @AfterClass 055 public static void tearDown() throws Exception { 056 ThrottleQuotaTestUtil.clearQuotaCache(TEST_UTIL); 057 EnvironmentEdgeManager.reset(); 058 TEST_UTIL.deleteTable(TABLE_NAME); 059 TEST_UTIL.shutdownMiniCluster(); 060 } 061 062 @BeforeClass 063 public static void setUpBeforeClass() throws Exception { 064 // quotas enabled, using block bytes scanned 065 TEST_UTIL.getConfiguration().setBoolean(QuotaUtil.QUOTA_CONF_KEY, true); 066 TEST_UTIL.getConfiguration().setInt(QuotaCache.REFRESH_CONF_KEY, REFRESH_TIME); 067 TEST_UTIL.getConfiguration().setInt(QuotaUtil.QUOTA_DEFAULT_USER_MACHINE_ATOMIC_READ_SIZE, 1); 068 TEST_UTIL.getConfiguration().setInt(QuotaUtil.QUOTA_DEFAULT_USER_MACHINE_ATOMIC_REQUEST_NUM, 1); 069 TEST_UTIL.getConfiguration().setInt(QuotaUtil.QUOTA_DEFAULT_USER_MACHINE_ATOMIC_WRITE_SIZE, 1); 070 071 // don't cache blocks to make IO predictable 072 TEST_UTIL.getConfiguration().setFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY, 0.0f); 073 074 TEST_UTIL.startMiniCluster(1); 075 TEST_UTIL.waitTableAvailable(QuotaTableUtil.QUOTA_TABLE_NAME); 076 TEST_UTIL.createTable(TABLE_NAME, FAMILY); 077 TEST_UTIL.waitTableAvailable(TABLE_NAME); 078 TEST_UTIL.flush(TABLE_NAME); 079 } 080 081 @Test 082 public void testDefaultAtomicReadLimits() throws Exception { 083 // Should have a strict throttle by default 084 TEST_UTIL.waitFor(60_000, () -> runIncTest(100) < 100); 085 086 // Add big quota and should be effectively unlimited 087 configureLenientThrottle(ThrottleType.ATOMIC_READ_SIZE); 088 configureLenientThrottle(ThrottleType.ATOMIC_REQUEST_NUMBER); 089 refreshQuotas(); 090 // Should run without error 091 TEST_UTIL.waitFor(60_000, () -> runIncTest(100) == 100); 092 093 // Remove all the limits, and should revert to strict default 094 unsetQuota(); 095 TEST_UTIL.waitFor(60_000, () -> runIncTest(100) < 100); 096 } 097 098 @Test 099 public void testDefaultAtomicWriteLimits() throws Exception { 100 // Should have a strict throttle by default 101 TEST_UTIL.waitFor(60_000, () -> runIncTest(100) < 100); 102 103 // Add big quota and should be effectively unlimited 104 configureLenientThrottle(ThrottleType.ATOMIC_WRITE_SIZE); 105 refreshQuotas(); 106 // Should run without error 107 TEST_UTIL.waitFor(60_000, () -> runIncTest(100) == 100); 108 109 // Remove all the limits, and should revert to strict default 110 unsetQuota(); 111 TEST_UTIL.waitFor(60_000, () -> runIncTest(100) < 100); 112 } 113 114 private void configureLenientThrottle(ThrottleType throttleType) throws IOException { 115 try (Admin admin = TEST_UTIL.getAdmin()) { 116 admin.setQuota( 117 QuotaSettingsFactory.throttleUser(getUserName(), throttleType, 100_000, TimeUnit.SECONDS)); 118 } 119 } 120 121 private static String getUserName() throws IOException { 122 return User.getCurrent().getShortName(); 123 } 124 125 private void refreshQuotas() throws Exception { 126 triggerUserCacheRefresh(TEST_UTIL, false, TABLE_NAME); 127 waitMinuteQuota(); 128 } 129 130 private void unsetQuota() throws Exception { 131 try (Admin admin = TEST_UTIL.getAdmin()) { 132 admin.setQuota(QuotaSettingsFactory.unthrottleUser(getUserName())); 133 } 134 refreshQuotas(); 135 } 136 137 private long runIncTest(int attempts) throws Exception { 138 refreshQuotas(); 139 try (Table table = getTable()) { 140 return ThrottleQuotaTestUtil.doIncrements(attempts, FAMILY, QUALIFIER, table); 141 } 142 } 143 144 private Table getTable() throws IOException { 145 TEST_UTIL.getConfiguration().setInt("hbase.client.pause", 100); 146 TEST_UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 1); 147 return TEST_UTIL.getConnection().getTableBuilder(TABLE_NAME, null).setOperationTimeout(250) 148 .build(); 149 } 150}