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
220
221 handler.deleteAllTs(tableAname, rowAname, columnBname, time1);
222 handler.deleteAllRowTs(tableAname, rowBname, time2);
223
224
225 int size = handler.getVerTs(tableAname, rowAname, columnBname, time1, MAXVERSIONS).size();
226 assertEquals(0, size);
227
228 size = handler.getVerTs(tableAname, rowAname, columnBname, time2, MAXVERSIONS).size();
229 assertEquals(1, size);
230
231
232 assertTrue(Bytes.equals(handler.get(tableAname, rowAname, columnBname).get(0).value, valueCname));
233
234 assertEquals(0, handler.getRow(tableAname, rowBname).size());
235
236
237 handler.disableTable(tableAname);
238 handler.deleteTable(tableAname);
239 }
240
241
242
243
244
245
246
247 public void doTestTableScanners() throws Exception {
248
249 ThriftServer.HBaseHandler handler = new ThriftServer.HBaseHandler(this.conf);
250 handler.createTable(tableAname, getColumnDescriptors());
251
252
253 long time1 = System.currentTimeMillis();
254 handler.mutateRowTs(tableAname, rowAname, getMutations(), time1);
255
256
257
258 Thread.sleep(1000);
259
260
261 long time2 = System.currentTimeMillis();
262 handler.mutateRowsTs(tableAname, getBatchMutations(), time2);
263
264 time1 += 1;
265
266
267 int scanner1 = handler.scannerOpen(tableAname, rowAname, getColumnList(true, true));
268 TRowResult rowResult1a = handler.scannerGet(scanner1).get(0);
269 assertTrue(Bytes.equals(rowResult1a.row, rowAname));
270
271
272
273 assertEquals(rowResult1a.columns.size(), 1);
274 assertTrue(Bytes.equals(rowResult1a.columns.get(columnBname).value, valueCname));
275
276 TRowResult rowResult1b = handler.scannerGet(scanner1).get(0);
277 assertTrue(Bytes.equals(rowResult1b.row, rowBname));
278 assertEquals(rowResult1b.columns.size(), 2);
279 assertTrue(Bytes.equals(rowResult1b.columns.get(columnAname).value, valueCname));
280 assertTrue(Bytes.equals(rowResult1b.columns.get(columnBname).value, valueDname));
281 closeScanner(scanner1, handler);
282
283
284 int scanner2 = handler.scannerOpenTs(tableAname, rowAname, getColumnList(true, true), time1);
285 TRowResult rowResult2a = handler.scannerGet(scanner2).get(0);
286 assertEquals(rowResult2a.columns.size(), 1);
287
288
289 assertTrue(Bytes.equals(rowResult2a.columns.get(columnBname).value, valueBname));
290 closeScanner(scanner2, handler);
291
292
293 int scanner3 = handler.scannerOpenWithStop(tableAname, rowAname, rowBname,
294 getColumnList(true, false));
295 closeScanner(scanner3, handler);
296
297
298 int scanner4 = handler.scannerOpenWithStopTs(tableAname, rowAname, rowBname,
299 getColumnList(false, true), time1);
300 TRowResult rowResult4a = handler.scannerGet(scanner4).get(0);
301 assertEquals(rowResult4a.columns.size(), 1);
302 assertTrue(Bytes.equals(rowResult4a.columns.get(columnBname).value, valueBname));
303
304
305 handler.disableTable(tableAname);
306 handler.deleteTable(tableAname);
307 }
308
309
310
311
312
313
314 private List<ColumnDescriptor> getColumnDescriptors() {
315 ArrayList<ColumnDescriptor> cDescriptors = new ArrayList<ColumnDescriptor>();
316
317
318 ColumnDescriptor cDescA = new ColumnDescriptor();
319 cDescA.name = columnAname;
320 cDescriptors.add(cDescA);
321
322
323 ColumnDescriptor cDescB = new ColumnDescriptor(columnBname, 2, "NONE",
324 false, "NONE", 0, 0, false, -1);
325 cDescriptors.add(cDescB);
326
327 return cDescriptors;
328 }
329
330
331
332
333
334
335
336 private List<byte[]> getColumnList(boolean includeA, boolean includeB) {
337 List<byte[]> columnList = new ArrayList<byte[]>();
338 if (includeA) columnList.add(columnAname);
339 if (includeB) columnList.add(columnBname);
340 return columnList;
341 }
342
343
344
345
346
347
348 private List<Mutation> getMutations() {
349 List<Mutation> mutations = new ArrayList<Mutation>();
350 mutations.add(new Mutation(false, columnAname, valueAname));
351 mutations.add(new Mutation(false, columnBname, valueBname));
352 return mutations;
353 }
354
355
356
357
358
359
360
361
362
363 private List<BatchMutation> getBatchMutations() {
364 List<BatchMutation> batchMutations = new ArrayList<BatchMutation>();
365
366
367 List<Mutation> rowAmutations = new ArrayList<Mutation>();
368 rowAmutations.add(new Mutation(true, columnAname, null));
369 batchMutations.add(new BatchMutation(rowAname, rowAmutations));
370
371 rowAmutations = new ArrayList<Mutation>();
372 rowAmutations.add(new Mutation(false, columnBname, valueCname));
373 batchMutations.add(new BatchMutation(rowAname, rowAmutations));
374
375
376 List<Mutation> rowBmutations = new ArrayList<Mutation>();
377 rowBmutations.add(new Mutation(false, columnAname, valueCname));
378 rowBmutations.add(new Mutation(false, columnBname, valueDname));
379 batchMutations.add(new BatchMutation(rowBname, rowBmutations));
380
381 return batchMutations;
382 }
383
384
385
386
387
388
389
390
391
392 private void closeScanner(int scannerId, ThriftServer.HBaseHandler handler) throws Exception {
393 handler.scannerGet(scannerId);
394 handler.scannerClose(scannerId);
395 }
396 }