1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase;
20
21
22 import static org.junit.Assert.assertEquals;
23 import static org.junit.Assert.assertNotNull;
24 import static org.junit.Assert.assertTrue;
25
26 import java.io.ByteArrayInputStream;
27 import java.io.ByteArrayOutputStream;
28 import java.io.DataInputStream;
29 import java.io.DataOutputStream;
30 import java.util.List;
31 import java.util.Map;
32 import java.util.NavigableSet;
33 import java.util.Set;
34
35 import org.apache.hadoop.hbase.client.Get;
36 import org.apache.hadoop.hbase.client.Scan;
37 import org.apache.hadoop.hbase.exceptions.DeserializationException;
38 import org.apache.hadoop.hbase.filter.BinaryComparator;
39 import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
40 import org.apache.hadoop.hbase.filter.Filter;
41 import org.apache.hadoop.hbase.filter.PrefixFilter;
42 import org.apache.hadoop.hbase.filter.RowFilter;
43 import org.apache.hadoop.hbase.io.TimeRange;
44 import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
45 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos;
46 import org.apache.hadoop.hbase.util.Bytes;
47 import org.apache.hadoop.hbase.util.Writables;
48 import org.apache.hadoop.io.DataInputBuffer;
49 import org.junit.Test;
50 import org.junit.experimental.categories.Category;
51
52
53
54
55 @Category(SmallTests.class)
56 public class TestSerialization {
57 @Test public void testKeyValue() throws Exception {
58 final String name = "testKeyValue2";
59 byte[] row = name.getBytes();
60 byte[] fam = "fam".getBytes();
61 byte[] qf = "qf".getBytes();
62 long ts = System.currentTimeMillis();
63 byte[] val = "val".getBytes();
64 KeyValue kv = new KeyValue(row, fam, qf, ts, val);
65 ByteArrayOutputStream baos = new ByteArrayOutputStream();
66 DataOutputStream dos = new DataOutputStream(baos);
67 long l = KeyValue.write(kv, dos);
68 dos.close();
69 byte [] mb = baos.toByteArray();
70 ByteArrayInputStream bais = new ByteArrayInputStream(mb);
71 DataInputStream dis = new DataInputStream(bais);
72 KeyValue deserializedKv = KeyValue.create(dis);
73 assertTrue(Bytes.equals(kv.getBuffer(), deserializedKv.getBuffer()));
74 assertEquals(kv.getOffset(), deserializedKv.getOffset());
75 assertEquals(kv.getLength(), deserializedKv.getLength());
76 }
77
78 @Test
79 public void testSplitLogTask() throws DeserializationException {
80 SplitLogTask slt = new SplitLogTask.Unassigned(ServerName.valueOf("mgr,1,1"));
81 byte [] bytes = slt.toByteArray();
82 SplitLogTask sltDeserialized = SplitLogTask.parseFrom(bytes);
83 assertTrue(slt.equals(sltDeserialized));
84 }
85
86 @Test public void testCompareFilter() throws Exception {
87 Filter f = new RowFilter(CompareOp.EQUAL,
88 new BinaryComparator(Bytes.toBytes("testRowOne-2")));
89 byte [] bytes = f.toByteArray();
90 Filter ff = RowFilter.parseFrom(bytes);
91 assertNotNull(ff);
92 }
93
94 @Test public void testTableDescriptor() throws Exception {
95 final String name = "testTableDescriptor";
96 HTableDescriptor htd = createTableDescriptor(name);
97 byte [] mb = Writables.getBytes(htd);
98 HTableDescriptor deserializedHtd =
99 (HTableDescriptor)Writables.getWritable(mb, new HTableDescriptor());
100 assertEquals(htd.getTableName(), deserializedHtd.getTableName());
101 }
102
103
104
105
106
107 @Test public void testRegionInfo() throws Exception {
108 HRegionInfo hri = createRandomRegion("testRegionInfo");
109
110
111 byte [] hrib = hri.toByteArray();
112 HRegionInfo deserializedHri = HRegionInfo.parseFrom(hrib);
113 assertEquals(hri.getEncodedName(), deserializedHri.getEncodedName());
114 assertEquals(hri, deserializedHri);
115
116
117 hrib = hri.toDelimitedByteArray();
118 DataInputBuffer buf = new DataInputBuffer();
119 try {
120 buf.reset(hrib, hrib.length);
121 deserializedHri = HRegionInfo.parseFrom(buf);
122 assertEquals(hri.getEncodedName(), deserializedHri.getEncodedName());
123 assertEquals(hri, deserializedHri);
124 } finally {
125 buf.close();
126 }
127 }
128
129 @Test public void testRegionInfos() throws Exception {
130 HRegionInfo hri = createRandomRegion("testRegionInfos");
131 byte[] triple = HRegionInfo.toDelimitedByteArray(hri, hri, hri);
132 List<HRegionInfo> regions = HRegionInfo.parseDelimitedFrom(triple, 0, triple.length);
133 assertTrue(regions.size() == 3);
134 assertTrue(regions.get(0).equals(regions.get(1)));
135 assertTrue(regions.get(0).equals(regions.get(2)));
136 }
137
138 private HRegionInfo createRandomRegion(final String name) {
139 HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(name));
140 String [] families = new String [] {"info", "anchor"};
141 for (int i = 0; i < families.length; i++) {
142 htd.addFamily(new HColumnDescriptor(families[i]));
143 }
144 return new HRegionInfo(htd.getTableName(), HConstants.EMPTY_START_ROW,
145 HConstants.EMPTY_END_ROW);
146 }
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255 @Test public void testGet() throws Exception{
256 byte[] row = "row".getBytes();
257 byte[] fam = "fam".getBytes();
258 byte[] qf1 = "qf1".getBytes();
259
260 long ts = System.currentTimeMillis();
261 int maxVersions = 2;
262
263 Get get = new Get(row);
264 get.addColumn(fam, qf1);
265 get.setTimeRange(ts, ts+1);
266 get.setMaxVersions(maxVersions);
267
268 ClientProtos.Get getProto = ProtobufUtil.toGet(get);
269 Get desGet = ProtobufUtil.toGet(getProto);
270
271 assertTrue(Bytes.equals(get.getRow(), desGet.getRow()));
272 Set<byte[]> set = null;
273 Set<byte[]> desSet = null;
274
275 for(Map.Entry<byte[], NavigableSet<byte[]>> entry :
276 get.getFamilyMap().entrySet()){
277 assertTrue(desGet.getFamilyMap().containsKey(entry.getKey()));
278 set = entry.getValue();
279 desSet = desGet.getFamilyMap().get(entry.getKey());
280 for(byte [] qualifier : set){
281 assertTrue(desSet.contains(qualifier));
282 }
283 }
284
285 assertEquals(get.getMaxVersions(), desGet.getMaxVersions());
286 TimeRange tr = get.getTimeRange();
287 TimeRange desTr = desGet.getTimeRange();
288 assertEquals(tr.getMax(), desTr.getMax());
289 assertEquals(tr.getMin(), desTr.getMin());
290 }
291
292
293 @Test public void testScan() throws Exception {
294
295 byte[] startRow = "startRow".getBytes();
296 byte[] stopRow = "stopRow".getBytes();
297 byte[] fam = "fam".getBytes();
298 byte[] qf1 = "qf1".getBytes();
299
300 long ts = System.currentTimeMillis();
301 int maxVersions = 2;
302
303 Scan scan = new Scan(startRow, stopRow);
304 scan.addColumn(fam, qf1);
305 scan.setTimeRange(ts, ts+1);
306 scan.setMaxVersions(maxVersions);
307
308 ClientProtos.Scan scanProto = ProtobufUtil.toScan(scan);
309 Scan desScan = ProtobufUtil.toScan(scanProto);
310
311 assertTrue(Bytes.equals(scan.getStartRow(), desScan.getStartRow()));
312 assertTrue(Bytes.equals(scan.getStopRow(), desScan.getStopRow()));
313 assertEquals(scan.getCacheBlocks(), desScan.getCacheBlocks());
314 Set<byte[]> set = null;
315 Set<byte[]> desSet = null;
316
317 for(Map.Entry<byte[], NavigableSet<byte[]>> entry :
318 scan.getFamilyMap().entrySet()){
319 assertTrue(desScan.getFamilyMap().containsKey(entry.getKey()));
320 set = entry.getValue();
321 desSet = desScan.getFamilyMap().get(entry.getKey());
322 for(byte[] column : set){
323 assertTrue(desSet.contains(column));
324 }
325
326
327 scan = new Scan(startRow);
328 final String name = "testScan";
329 byte [] prefix = Bytes.toBytes(name);
330 scan.setFilter(new PrefixFilter(prefix));
331 scanProto = ProtobufUtil.toScan(scan);
332 desScan = ProtobufUtil.toScan(scanProto);
333 Filter f = desScan.getFilter();
334 assertTrue(f instanceof PrefixFilter);
335 }
336
337 assertEquals(scan.getMaxVersions(), desScan.getMaxVersions());
338 TimeRange tr = scan.getTimeRange();
339 TimeRange desTr = desScan.getTimeRange();
340 assertEquals(tr.getMax(), desTr.getMax());
341 assertEquals(tr.getMin(), desTr.getMin());
342 }
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521 protected static final int MAXVERSIONS = 3;
522 protected final static byte [] fam1 = Bytes.toBytes("colfamily1");
523 protected final static byte [] fam2 = Bytes.toBytes("colfamily2");
524 protected final static byte [] fam3 = Bytes.toBytes("colfamily3");
525 protected static final byte [][] COLUMNS = {fam1, fam2, fam3};
526
527
528
529
530
531
532
533 protected HTableDescriptor createTableDescriptor(final String name) {
534 return createTableDescriptor(name, MAXVERSIONS);
535 }
536
537
538
539
540
541
542
543
544 protected HTableDescriptor createTableDescriptor(final String name,
545 final int versions) {
546 HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(name));
547 htd.addFamily(new HColumnDescriptor(fam1)
548 .setMaxVersions(versions)
549 .setBlockCacheEnabled(false)
550 );
551 htd.addFamily(new HColumnDescriptor(fam2)
552 .setMaxVersions(versions)
553 .setBlockCacheEnabled(false)
554 );
555 htd.addFamily(new HColumnDescriptor(fam3)
556 .setMaxVersions(versions)
557 .setBlockCacheEnabled(false)
558 );
559 return htd;
560 }
561 }