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