1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.quotas;
20
21 import java.util.concurrent.TimeUnit;
22
23 import org.apache.hadoop.hbase.classification.InterfaceAudience;
24 import org.apache.hadoop.hbase.classification.InterfaceStability;
25
26 import com.google.common.annotations.VisibleForTesting;
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 @InterfaceAudience.Private
47 @InterfaceStability.Evolving
48 public abstract class RateLimiter {
49 public static final String QUOTA_RATE_LIMITER_CONF_KEY = "hbase.quota.rate.limiter";
50 private long tunit = 1000;
51 private long limit = Long.MAX_VALUE;
52 private long avail = Long.MAX_VALUE;
53
54
55
56
57
58
59 abstract long refill(long limit);
60
61
62
63
64
65
66
67
68 abstract long getWaitInterval(long limit, long available, long amount);
69
70
71
72
73
74
75
76 public void set(final long limit, final TimeUnit timeUnit) {
77 switch (timeUnit) {
78 case MILLISECONDS:
79 tunit = 1;
80 break;
81 case SECONDS:
82 tunit = 1000;
83 break;
84 case MINUTES:
85 tunit = 60 * 1000;
86 break;
87 case HOURS:
88 tunit = 60 * 60 * 1000;
89 break;
90 case DAYS:
91 tunit = 24 * 60 * 60 * 1000;
92 break;
93 default:
94 throw new RuntimeException("Unsupported " + timeUnit.name() + " TimeUnit.");
95 }
96 this.limit = limit;
97 this.avail = limit;
98 }
99
100 public String toString() {
101 String rateLimiter = this.getClass().getSimpleName();
102 if (limit == Long.MAX_VALUE) {
103 return rateLimiter + "(Bypass)";
104 }
105 return rateLimiter + "(avail=" + avail + " limit=" + limit + " tunit=" + tunit + ")";
106 }
107
108
109
110
111
112
113
114 public synchronized void update(final RateLimiter other) {
115 this.tunit = other.tunit;
116 if (this.limit < other.limit) {
117 this.avail += (other.limit - this.limit);
118 }
119 this.limit = other.limit;
120 }
121
122 public synchronized boolean isBypass() {
123 return limit == Long.MAX_VALUE;
124 }
125
126 public synchronized long getLimit() {
127 return limit;
128 }
129
130 public synchronized long getAvailable() {
131 return avail;
132 }
133
134 protected long getTimeUnitInMillis() {
135 return tunit;
136 }
137
138
139
140
141
142 public boolean canExecute() {
143 return canExecute(1);
144 }
145
146
147
148
149
150
151 public synchronized boolean canExecute(final long amount) {
152 long refillAmount = refill(limit);
153 if (refillAmount == 0 && avail < amount) {
154 return false;
155 }
156
157 if (avail <= Long.MAX_VALUE - refillAmount) {
158 avail = Math.max(0, Math.min(avail + refillAmount, limit));
159 } else {
160 avail = Math.max(0, limit);
161 }
162 if (avail >= amount) {
163 return true;
164 }
165 return false;
166 }
167
168
169
170
171 public void consume() {
172 consume(1);
173 }
174
175
176
177
178
179 public synchronized void consume(final long amount) {
180 this.avail -= amount;
181 if (this.avail < 0) {
182 this.avail = 0;
183 }
184 }
185
186
187
188
189 public long waitInterval() {
190 return waitInterval(1);
191 }
192
193
194
195
196 public synchronized long waitInterval(final long amount) {
197
198 return (amount <= avail) ? 0 : getWaitInterval(limit, avail, amount);
199 }
200
201
202 @VisibleForTesting
203 public abstract void setNextRefillTime(long nextRefillTime);
204
205 @VisibleForTesting
206 public abstract long getNextRefillTime();
207 }