1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.hadoop.hbase.thrift;
21
22 import static org.junit.Assert.*;
23
24 import java.io.IOException;
25 import java.nio.ByteBuffer;
26 import java.util.ArrayList;
27 import java.util.List;
28
29 import org.apache.hadoop.hbase.HBaseTestingUtility;
30 import org.apache.hadoop.hbase.thrift.generated.BatchMutation;
31 import org.apache.hadoop.hbase.thrift.generated.ColumnDescriptor;
32 import org.apache.hadoop.hbase.thrift.generated.Mutation;
33 import org.apache.hadoop.hbase.thrift.generated.TCell;
34 import org.apache.hadoop.hbase.thrift.generated.TRowResult;
35 import org.apache.hadoop.hbase.util.Bytes;
36 import org.junit.AfterClass;
37 import org.junit.BeforeClass;
38 import org.junit.Test;
39
40
41
42
43
44 public class TestThriftServer {
45 private static final HBaseTestingUtility UTIL = new HBaseTestingUtility();
46 protected static final int MAXVERSIONS = 3;
47 private static ByteBuffer $bb(String i) {
48 return ByteBuffer.wrap(Bytes.toBytes(i));
49 }
50
51 private static ByteBuffer tableAname = $bb("tableA");
52 private static ByteBuffer tableBname = $bb("tableB");
53 private static ByteBuffer columnAname = $bb("columnA:");
54 private static ByteBuffer columnBname = $bb("columnB:");
55 private static ByteBuffer rowAname = $bb("rowA");
56 private static ByteBuffer rowBname = $bb("rowB");
57 private static ByteBuffer valueAname = $bb("valueA");
58 private static ByteBuffer valueBname = $bb("valueB");
59 private static ByteBuffer valueCname = $bb("valueC");
60 private static ByteBuffer valueDname = $bb("valueD");
61
62 @BeforeClass
63 public static void beforeClass() throws Exception {
64 UTIL.startMiniCluster();
65 }
66
67 @AfterClass
68 public static void afterClass() throws Exception {
69 UTIL.shutdownMiniCluster();
70 }
71
72
73
74
75
76
77
78
79
80 public void testAll() throws Exception {
81
82 doTestTableCreateDrop();
83 doTestTableMutations();
84 doTestTableTimestampsAndColumns();
85 doTestTableScanners();
86 doTestGetTableRegions();
87 }
88
89
90
91
92
93
94
95
96 @Test
97 public void doTestTableCreateDrop() throws Exception {
98 ThriftServer.HBaseHandler handler =
99 new ThriftServer.HBaseHandler(UTIL.getConfiguration());
100
101
102 assertEquals(handler.getTableNames().size(), 0);
103 handler.createTable(tableAname, getColumnDescriptors());
104 assertEquals(handler.getTableNames().size(), 1);
105 assertEquals(handler.getColumnDescriptors(tableAname).size(), 2);
106 assertTrue(handler.isTableEnabled(tableAname));
107 handler.createTable(tableBname, new ArrayList<ColumnDescriptor>());
108 assertEquals(handler.getTableNames().size(), 2);
109 handler.disableTable(tableBname);
110 assertFalse(handler.isTableEnabled(tableBname));
111 handler.deleteTable(tableBname);
112 assertEquals(handler.getTableNames().size(), 1);
113 handler.disableTable(tableAname);
114
115
116
117
118
119 handler.deleteTable(tableAname);
120 }
121
122
123
124
125
126
127
128
129 public void doTestTableMutations() throws Exception {
130
131 ThriftServer.HBaseHandler handler =
132 new ThriftServer.HBaseHandler(UTIL.getConfiguration());
133 handler.createTable(tableAname, getColumnDescriptors());
134
135
136
137
138 handler.mutateRow(tableAname, rowAname, getMutations());
139
140
141 assertEquals(valueAname,
142 handler.get(tableAname, rowAname, columnAname).get(0).value);
143 TRowResult rowResult1 = handler.getRow(tableAname, rowAname).get(0);
144 assertEquals(rowAname, rowResult1.row);
145 assertEquals(valueBname,
146 rowResult1.columns.get(columnBname).value);
147
148
149
150
151
152
153
154
155
156 handler.mutateRows(tableAname, getBatchMutations());
157
158
159 List<TCell> cells = handler.get(tableAname, rowAname, columnAname);
160 assertFalse(cells.size() > 0);
161 assertEquals(valueCname, handler.get(tableAname, rowAname, columnBname).get(0).value);
162 List<TCell> versions = handler.getVer(tableAname, rowAname, columnBname, MAXVERSIONS);
163 assertEquals(valueCname, versions.get(0).value);
164 assertEquals(valueBname, versions.get(1).value);
165
166
167 TRowResult rowResult2 = handler.getRow(tableAname, rowBname).get(0);
168 assertEquals(rowBname, rowResult2.row);
169 assertEquals(valueCname, rowResult2.columns.get(columnAname).value);
170 assertEquals(valueDname, rowResult2.columns.get(columnBname).value);
171
172
173 handler.deleteAll(tableAname, rowAname, columnBname);
174 handler.deleteAllRow(tableAname, rowBname);
175
176
177 int size = handler.get(tableAname, rowAname, columnBname).size();
178 assertEquals(0, size);
179 size = handler.getRow(tableAname, rowBname).size();
180 assertEquals(0, size);
181
182
183 List<Mutation> mutations = new ArrayList<Mutation>();
184 mutations.add(new Mutation(false, columnAname, null));
185 handler.mutateRow(tableAname, rowAname, mutations);
186 TRowResult rowResult3 = handler.getRow(tableAname, rowAname).get(0);
187 assertEquals(rowAname, rowResult3.row);
188 assertEquals(0, rowResult3.columns.get(columnAname).value.array().length);
189
190
191 handler.disableTable(tableAname);
192 handler.deleteTable(tableAname);
193 }
194
195
196
197
198
199
200
201
202 public void doTestTableTimestampsAndColumns() throws Exception {
203
204 ThriftServer.HBaseHandler handler =
205 new ThriftServer.HBaseHandler(UTIL.getConfiguration());
206 handler.createTable(tableAname, getColumnDescriptors());
207
208
209 long time1 = System.currentTimeMillis();
210 handler.mutateRowTs(tableAname, rowAname, getMutations(), time1);
211
212 Thread.sleep(1000);
213
214
215 long time2 = System.currentTimeMillis();
216 handler.mutateRowsTs(tableAname, getBatchMutations(), time2);
217
218
219 handler.mutateRowTs(tableAname, rowBname, getMutations(), time2);
220
221
222 time1 += 1;
223 time2 += 2;
224
225
226 assertEquals(2, handler.getVerTs(tableAname, rowAname, columnBname, time2,
227 MAXVERSIONS).size());
228 assertEquals(1, handler.getVerTs(tableAname, rowAname, columnBname, time1,
229 MAXVERSIONS).size());
230
231 TRowResult rowResult1 = handler.getRowTs(tableAname, rowAname, time1).get(0);
232 TRowResult rowResult2 = handler.getRowTs(tableAname, rowAname, time2).get(0);
233
234
235 assertEquals(rowResult1.columns.get(columnBname).value, valueBname);
236 assertEquals(rowResult2.columns.get(columnBname).value, valueCname);
237
238
239 assertFalse(rowResult2.columns.containsKey(columnAname));
240
241 List<ByteBuffer> columns = new ArrayList<ByteBuffer>();
242 columns.add(columnBname);
243
244 rowResult1 = handler.getRowWithColumns(tableAname, rowAname, columns).get(0);
245 assertEquals(rowResult1.columns.get(columnBname).value, valueCname);
246 assertFalse(rowResult1.columns.containsKey(columnAname));
247
248 rowResult1 = handler.getRowWithColumnsTs(tableAname, rowAname, columns, time1).get(0);
249 assertEquals(rowResult1.columns.get(columnBname).value, valueBname);
250 assertFalse(rowResult1.columns.containsKey(columnAname));
251
252
253
254
255 handler.deleteAllTs(tableAname, rowAname, columnBname, time1);
256 handler.deleteAllRowTs(tableAname, rowBname, time2);
257
258
259 int size = handler.getVerTs(tableAname, rowAname, columnBname, time1, MAXVERSIONS).size();
260 assertEquals(0, size);
261
262 size = handler.getVerTs(tableAname, rowAname, columnBname, time2, MAXVERSIONS).size();
263 assertEquals(1, size);
264
265
266 assertEquals(handler.get(tableAname, rowAname, columnBname).get(0).value, valueCname);
267
268 assertEquals(0, handler.getRow(tableAname, rowBname).size());
269
270
271 handler.disableTable(tableAname);
272 handler.deleteTable(tableAname);
273 }
274
275
276
277
278
279
280
281 public void doTestTableScanners() throws Exception {
282
283 ThriftServer.HBaseHandler handler =
284 new ThriftServer.HBaseHandler(UTIL.getConfiguration());
285 handler.createTable(tableAname, getColumnDescriptors());
286
287
288 long time1 = System.currentTimeMillis();
289 handler.mutateRowTs(tableAname, rowAname, getMutations(), time1);
290
291
292
293 Thread.sleep(1000);
294
295
296 long time2 = System.currentTimeMillis();
297 handler.mutateRowsTs(tableAname, getBatchMutations(), time2);
298
299 time1 += 1;
300
301
302 int scanner1 = handler.scannerOpen(tableAname, rowAname, getColumnList(true, true));
303 TRowResult rowResult1a = handler.scannerGet(scanner1).get(0);
304 assertEquals(rowResult1a.row, rowAname);
305
306
307
308 assertEquals(rowResult1a.columns.size(), 1);
309 assertEquals(rowResult1a.columns.get(columnBname).value, valueCname);
310
311 TRowResult rowResult1b = handler.scannerGet(scanner1).get(0);
312 assertEquals(rowResult1b.row, rowBname);
313 assertEquals(rowResult1b.columns.size(), 2);
314 assertEquals(rowResult1b.columns.get(columnAname).value, valueCname);
315 assertEquals(rowResult1b.columns.get(columnBname).value, valueDname);
316 closeScanner(scanner1, handler);
317
318
319 int scanner2 = handler.scannerOpenTs(tableAname, rowAname, getColumnList(true, true), time1);
320 TRowResult rowResult2a = handler.scannerGet(scanner2).get(0);
321 assertEquals(rowResult2a.columns.size(), 1);
322
323
324 assertEquals(rowResult2a.columns.get(columnBname).value, valueBname);
325 closeScanner(scanner2, handler);
326
327
328 int scanner3 = handler.scannerOpenWithStop(tableAname, rowAname, rowBname,
329 getColumnList(true, false));
330 closeScanner(scanner3, handler);
331
332
333 int scanner4 = handler.scannerOpenWithStopTs(tableAname, rowAname, rowBname,
334 getColumnList(false, true), time1);
335 TRowResult rowResult4a = handler.scannerGet(scanner4).get(0);
336 assertEquals(rowResult4a.columns.size(), 1);
337 assertEquals(rowResult4a.columns.get(columnBname).value, valueBname);
338
339
340 handler.disableTable(tableAname);
341 handler.deleteTable(tableAname);
342 }
343
344
345
346
347
348
349
350 public void doTestGetTableRegions() throws Exception {
351 ThriftServer.HBaseHandler handler =
352 new ThriftServer.HBaseHandler(UTIL.getConfiguration());
353 handler.createTable(tableAname, getColumnDescriptors());
354 int regionCount = handler.getTableRegions(tableAname).size();
355 assertEquals("empty table should have only 1 region, " +
356 "but found " + regionCount, regionCount, 1);
357 handler.disableTable(tableAname);
358 handler.deleteTable(tableAname);
359 regionCount = handler.getTableRegions(tableAname).size();
360 assertEquals("non-existing table should have 0 region, " +
361 "but found " + regionCount, regionCount, 0);
362 }
363
364
365
366
367
368
369 private List<ColumnDescriptor> getColumnDescriptors() {
370 ArrayList<ColumnDescriptor> cDescriptors = new ArrayList<ColumnDescriptor>();
371
372
373 ColumnDescriptor cDescA = new ColumnDescriptor();
374 cDescA.name = columnAname;
375 cDescriptors.add(cDescA);
376
377
378 ColumnDescriptor cDescB = new ColumnDescriptor(columnBname, 2, "NONE",
379 false, "NONE", 0, 0, false, -1);
380 cDescriptors.add(cDescB);
381
382 return cDescriptors;
383 }
384
385
386
387
388
389
390
391 private List<ByteBuffer> getColumnList(boolean includeA, boolean includeB) {
392 List<ByteBuffer> columnList = new ArrayList<ByteBuffer>();
393 if (includeA) columnList.add(columnAname);
394 if (includeB) columnList.add(columnBname);
395 return columnList;
396 }
397
398
399
400
401
402
403 private List<Mutation> getMutations() {
404 List<Mutation> mutations = new ArrayList<Mutation>();
405 mutations.add(new Mutation(false, columnAname, valueAname));
406 mutations.add(new Mutation(false, columnBname, valueBname));
407 return mutations;
408 }
409
410
411
412
413
414
415
416
417
418 private List<BatchMutation> getBatchMutations() {
419 List<BatchMutation> batchMutations = new ArrayList<BatchMutation>();
420
421
422 List<Mutation> rowAmutations = new ArrayList<Mutation>();
423 rowAmutations.add(new Mutation(true, columnAname, null));
424 batchMutations.add(new BatchMutation(rowAname, rowAmutations));
425
426 rowAmutations = new ArrayList<Mutation>();
427 rowAmutations.add(new Mutation(false, columnBname, valueCname));
428 batchMutations.add(new BatchMutation(rowAname, rowAmutations));
429
430
431 List<Mutation> rowBmutations = new ArrayList<Mutation>();
432 rowBmutations.add(new Mutation(false, columnAname, valueCname));
433 rowBmutations.add(new Mutation(false, columnBname, valueDname));
434 batchMutations.add(new BatchMutation(rowBname, rowBmutations));
435
436 return batchMutations;
437 }
438
439
440
441
442
443
444
445
446
447 private void closeScanner(int scannerId, ThriftServer.HBaseHandler handler) throws Exception {
448 handler.scannerGet(scannerId);
449 handler.scannerClose(scannerId);
450 }
451 }