View Javadoc

1   /*
2    *
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
18   */
19  
20  package org.apache.hadoop.hbase.rest.client;
21  
22  import static org.junit.Assert.assertEquals;
23  import static org.junit.Assert.assertFalse;
24  import static org.junit.Assert.assertNotNull;
25  import static org.junit.Assert.assertNull;
26  import static org.junit.Assert.assertTrue;
27  
28  import java.io.IOException;
29  import java.util.ArrayList;
30  import java.util.Collections;
31  import java.util.Iterator;
32  import java.util.List;
33  
34  import org.apache.commons.httpclient.Header;
35  import org.apache.hadoop.hbase.Cell;
36  import org.apache.hadoop.hbase.CellUtil;
37  import org.apache.hadoop.hbase.HBaseTestingUtility;
38  import org.apache.hadoop.hbase.HColumnDescriptor;
39  import org.apache.hadoop.hbase.HTableDescriptor;
40  import org.apache.hadoop.hbase.client.HTable;
41  import org.apache.hadoop.hbase.testclassification.MediumTests;
42  import org.apache.hadoop.hbase.TableName;
43  import org.apache.hadoop.hbase.client.Admin;
44  import org.apache.hadoop.hbase.client.Delete;
45  import org.apache.hadoop.hbase.client.Get;
46  import org.apache.hadoop.hbase.client.Put;
47  import org.apache.hadoop.hbase.client.Result;
48  import org.apache.hadoop.hbase.client.ResultScanner;
49  import org.apache.hadoop.hbase.client.Scan;
50  import org.apache.hadoop.hbase.client.Table;
51  import org.apache.hadoop.hbase.rest.HBaseRESTTestingUtility;
52  import org.apache.hadoop.hbase.util.Bytes;
53  import org.junit.After;
54  import org.junit.AfterClass;
55  import org.junit.Before;
56  import org.junit.BeforeClass;
57  import org.junit.Test;
58  import org.junit.experimental.categories.Category;
59  
60  @Category(MediumTests.class)
61  public class TestRemoteTable {
62    private static final TableName TABLE = TableName.valueOf("TestRemoteTable");
63    private static final byte[] ROW_1 = Bytes.toBytes("testrow1");
64    private static final byte[] ROW_2 = Bytes.toBytes("testrow2");
65    private static final byte[] ROW_3 = Bytes.toBytes("testrow3");
66    private static final byte[] ROW_4 = Bytes.toBytes("testrow4");
67    private static final byte[] COLUMN_1 = Bytes.toBytes("a");
68    private static final byte[] COLUMN_2 = Bytes.toBytes("b");
69    private static final byte[] COLUMN_3 = Bytes.toBytes("c");
70    private static final byte[] QUALIFIER_1 = Bytes.toBytes("1");
71    private static final byte[] QUALIFIER_2 = Bytes.toBytes("2");
72    private static final byte[] VALUE_1 = Bytes.toBytes("testvalue1");
73    private static final byte[] VALUE_2 = Bytes.toBytes("testvalue2");
74  
75    private static final long ONE_HOUR = 60 * 60 * 1000;
76    private static final long TS_2 = System.currentTimeMillis();
77    private static final long TS_1 = TS_2 - ONE_HOUR;
78  
79    private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
80    private static final HBaseRESTTestingUtility REST_TEST_UTIL = 
81      new HBaseRESTTestingUtility();
82    private RemoteHTable remoteTable;
83  
84    @BeforeClass
85    public static void setUpBeforeClass() throws Exception {
86      TEST_UTIL.startMiniCluster();
87      REST_TEST_UTIL.startServletContainer(TEST_UTIL.getConfiguration());
88    }
89  
90    @Before
91    public void before() throws Exception  {
92      Admin admin = TEST_UTIL.getHBaseAdmin();
93      if (admin.tableExists(TABLE)) {
94        if (admin.isTableEnabled(TABLE)) admin.disableTable(TABLE);
95        admin.deleteTable(TABLE);
96      }
97      HTableDescriptor htd = new HTableDescriptor(TABLE);
98      htd.addFamily(new HColumnDescriptor(COLUMN_1).setMaxVersions(3));
99      htd.addFamily(new HColumnDescriptor(COLUMN_2).setMaxVersions(3));
100     htd.addFamily(new HColumnDescriptor(COLUMN_3).setMaxVersions(3));
101     admin.createTable(htd);
102     try (Table table = TEST_UTIL.getConnection().getTable(TABLE)) {
103       Put put = new Put(ROW_1);
104       put.add(COLUMN_1, QUALIFIER_1, TS_2, VALUE_1);
105       table.put(put);
106       put = new Put(ROW_2);
107       put.add(COLUMN_1, QUALIFIER_1, TS_1, VALUE_1);
108       put.add(COLUMN_1, QUALIFIER_1, TS_2, VALUE_2);
109       put.add(COLUMN_2, QUALIFIER_2, TS_2, VALUE_2);
110       table.put(put);
111     }
112     remoteTable = new RemoteHTable(
113       new Client(new Cluster().add("localhost", 
114           REST_TEST_UTIL.getServletPort())),
115         TEST_UTIL.getConfiguration(), TABLE.toBytes());
116   }
117   
118   @After
119   public void after() throws Exception {
120     remoteTable.close();
121   }
122   
123   @AfterClass
124   public static void tearDownAfterClass() throws Exception {
125     REST_TEST_UTIL.shutdownServletContainer();
126     TEST_UTIL.shutdownMiniCluster();
127   }
128 
129   @Test
130   public void testGetTableDescriptor() throws IOException {
131     Table table = null;
132     try {
133       table = new HTable(TEST_UTIL.getConfiguration(), TABLE);
134       HTableDescriptor local = table.getTableDescriptor();
135       assertEquals(remoteTable.getTableDescriptor(), local);
136     } finally {
137       if (null != table) table.close();
138     }
139   }
140 
141   @Test
142   public void testGet() throws IOException {
143     Get get = new Get(ROW_1);
144     Result result = remoteTable.get(get);
145     byte[] value1 = result.getValue(COLUMN_1, QUALIFIER_1);
146     byte[] value2 = result.getValue(COLUMN_2, QUALIFIER_2);
147     assertNotNull(value1);
148     assertTrue(Bytes.equals(VALUE_1, value1));
149     assertNull(value2);
150 
151     get = new Get(ROW_1);
152     get.addFamily(COLUMN_3);
153     result = remoteTable.get(get);
154     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
155     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
156     assertNull(value1);
157     assertNull(value2);
158 
159     get = new Get(ROW_1);
160     get.addColumn(COLUMN_1, QUALIFIER_1);
161     get.addColumn(COLUMN_2, QUALIFIER_2);
162     result = remoteTable.get(get);
163     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
164     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
165     assertNotNull(value1);
166     assertTrue(Bytes.equals(VALUE_1, value1));
167     assertNull(value2);
168 
169     get = new Get(ROW_2);
170     result = remoteTable.get(get);
171     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
172     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
173     assertNotNull(value1);
174     assertTrue(Bytes.equals(VALUE_2, value1)); // @TS_2
175     assertNotNull(value2);
176     assertTrue(Bytes.equals(VALUE_2, value2));
177 
178     get = new Get(ROW_2);
179     get.addFamily(COLUMN_1);
180     result = remoteTable.get(get);
181     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
182     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
183     assertNotNull(value1);
184     assertTrue(Bytes.equals(VALUE_2, value1)); // @TS_2
185     assertNull(value2);
186 
187     get = new Get(ROW_2);
188     get.addColumn(COLUMN_1, QUALIFIER_1);
189     get.addColumn(COLUMN_2, QUALIFIER_2);
190     result = remoteTable.get(get);
191     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
192     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
193     assertNotNull(value1);
194     assertTrue(Bytes.equals(VALUE_2, value1)); // @TS_2
195     assertNotNull(value2);
196     assertTrue(Bytes.equals(VALUE_2, value2));
197 
198     // test timestamp
199 
200     get = new Get(ROW_2);
201     get.addFamily(COLUMN_1);
202     get.addFamily(COLUMN_2);
203     get.setTimeStamp(TS_1);
204     result = remoteTable.get(get);
205     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
206     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
207     assertNotNull(value1);
208     assertTrue(Bytes.equals(VALUE_1, value1)); // @TS_1
209     assertNull(value2);
210 
211     // test timerange
212 
213     get = new Get(ROW_2);
214     get.addFamily(COLUMN_1);
215     get.addFamily(COLUMN_2);
216     get.setTimeRange(0, TS_1 + 1);
217     result = remoteTable.get(get);
218     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
219     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
220     assertNotNull(value1);
221     assertTrue(Bytes.equals(VALUE_1, value1)); // @TS_1
222     assertNull(value2);
223 
224     // test maxVersions
225 
226     get = new Get(ROW_2);
227     get.addFamily(COLUMN_1);
228     get.setMaxVersions(2);
229     result = remoteTable.get(get);
230     int count = 0;
231     for (Cell kv: result.listCells()) {
232       if (CellUtil.matchingFamily(kv, COLUMN_1) && TS_1 == kv.getTimestamp()) {
233         assertTrue(CellUtil.matchingValue(kv, VALUE_1)); // @TS_1
234         count++;
235       }
236       if (CellUtil.matchingFamily(kv, COLUMN_1) && TS_2 == kv.getTimestamp()) {
237         assertTrue(CellUtil.matchingValue(kv, VALUE_2)); // @TS_2
238         count++;
239       }
240     }
241     assertEquals(2, count);
242   }
243 
244   @Test
245   public void testMultiGet() throws Exception {
246     ArrayList<Get> gets = new ArrayList<Get>();
247     gets.add(new Get(ROW_1));
248     gets.add(new Get(ROW_2));
249     Result[] results = remoteTable.get(gets);
250     assertNotNull(results);
251     assertEquals(2, results.length);
252     assertEquals(1, results[0].size());
253     assertEquals(2, results[1].size());
254 
255     //Test Versions
256     gets = new ArrayList<Get>();
257     Get g = new Get(ROW_1);
258     g.setMaxVersions(3);
259     gets.add(g);
260     gets.add(new Get(ROW_2));
261     results = remoteTable.get(gets);
262     assertNotNull(results);
263     assertEquals(2, results.length);
264     assertEquals(1, results[0].size());
265     assertEquals(3, results[1].size());
266 
267     //404
268     gets = new ArrayList<Get>();
269     gets.add(new Get(Bytes.toBytes("RESALLYREALLYNOTTHERE")));
270     results = remoteTable.get(gets);
271     assertNotNull(results);
272     assertEquals(0, results.length);
273 
274     gets = new ArrayList<Get>();
275     gets.add(new Get(Bytes.toBytes("RESALLYREALLYNOTTHERE")));
276     gets.add(new Get(ROW_1));
277     gets.add(new Get(ROW_2));
278     results = remoteTable.get(gets);
279     assertNotNull(results);
280     assertEquals(2, results.length);
281   }
282 
283   @Test
284   public void testPut() throws IOException {
285     Put put = new Put(ROW_3);
286     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
287     remoteTable.put(put);
288 
289     Get get = new Get(ROW_3);
290     get.addFamily(COLUMN_1);
291     Result result = remoteTable.get(get);
292     byte[] value = result.getValue(COLUMN_1, QUALIFIER_1);
293     assertNotNull(value);
294     assertTrue(Bytes.equals(VALUE_1, value));
295 
296     // multiput
297 
298     List<Put> puts = new ArrayList<Put>();
299     put = new Put(ROW_3);
300     put.add(COLUMN_2, QUALIFIER_2, VALUE_2);
301     puts.add(put);
302     put = new Put(ROW_4);
303     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
304     puts.add(put);
305     put = new Put(ROW_4);
306     put.add(COLUMN_2, QUALIFIER_2, VALUE_2);
307     puts.add(put);
308     remoteTable.put(puts);
309 
310     get = new Get(ROW_3);
311     get.addFamily(COLUMN_2);
312     result = remoteTable.get(get);
313     value = result.getValue(COLUMN_2, QUALIFIER_2);
314     assertNotNull(value);
315     assertTrue(Bytes.equals(VALUE_2, value));
316     get = new Get(ROW_4);
317     result = remoteTable.get(get);
318     value = result.getValue(COLUMN_1, QUALIFIER_1);
319     assertNotNull(value);
320     assertTrue(Bytes.equals(VALUE_1, value));
321     value = result.getValue(COLUMN_2, QUALIFIER_2);
322     assertNotNull(value);
323     assertTrue(Bytes.equals(VALUE_2, value));
324     
325     assertTrue(Bytes.equals(Bytes.toBytes("TestRemoteTable"), remoteTable.getTableName()));
326   }
327 
328   @Test
329   public void testDelete() throws IOException {
330     Put put = new Put(ROW_3);
331     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
332     put.add(COLUMN_2, QUALIFIER_2, VALUE_2);
333     put.add(COLUMN_3, QUALIFIER_1, VALUE_1);
334     put.add(COLUMN_3, QUALIFIER_2, VALUE_2);
335     remoteTable.put(put);
336 
337     Get get = new Get(ROW_3);
338     get.addFamily(COLUMN_1);
339     get.addFamily(COLUMN_2);
340     get.addFamily(COLUMN_3);
341     Result result = remoteTable.get(get);
342     byte[] value1 = result.getValue(COLUMN_1, QUALIFIER_1);
343     byte[] value2 = result.getValue(COLUMN_2, QUALIFIER_2);
344     byte[] value3 = result.getValue(COLUMN_3, QUALIFIER_1);
345     byte[] value4 = result.getValue(COLUMN_3, QUALIFIER_2);
346     assertNotNull(value1);
347     assertTrue(Bytes.equals(VALUE_1, value1));
348     assertNotNull(value2);
349     assertTrue(Bytes.equals(VALUE_2, value2));
350     assertNotNull(value3);
351     assertTrue(Bytes.equals(VALUE_1, value3));
352     assertNotNull(value4);
353     assertTrue(Bytes.equals(VALUE_2, value4));
354 
355     Delete delete = new Delete(ROW_3);
356     delete.addColumn(COLUMN_2, QUALIFIER_2);
357     remoteTable.delete(delete);
358 
359     get = new Get(ROW_3);
360     get.addFamily(COLUMN_1);
361     get.addFamily(COLUMN_2);
362     result = remoteTable.get(get);
363     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
364     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
365     assertNotNull(value1);
366     assertTrue(Bytes.equals(VALUE_1, value1));
367     assertNull(value2);
368 
369     delete = new Delete(ROW_3);
370     delete.setTimestamp(1L);
371     remoteTable.delete(delete);
372 
373     get = new Get(ROW_3);
374     get.addFamily(COLUMN_1);
375     get.addFamily(COLUMN_2);
376     result = remoteTable.get(get);
377     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
378     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
379     assertNotNull(value1);
380     assertTrue(Bytes.equals(VALUE_1, value1));
381     assertNull(value2);
382 
383     // Delete column family from row
384     delete = new Delete(ROW_3);
385     delete.addFamily(COLUMN_3);
386     remoteTable.delete(delete);
387 
388     get = new Get(ROW_3);
389     get.addFamily(COLUMN_3);
390     result = remoteTable.get(get);
391     value3 = result.getValue(COLUMN_3, QUALIFIER_1);
392     value4 = result.getValue(COLUMN_3, QUALIFIER_2);
393     assertNull(value3);
394     assertNull(value4);
395 
396     delete = new Delete(ROW_3);
397     remoteTable.delete(delete);
398 
399     get = new Get(ROW_3);
400     get.addFamily(COLUMN_1);
401     get.addFamily(COLUMN_2);
402     result = remoteTable.get(get);
403     value1 = result.getValue(COLUMN_1, QUALIFIER_1);
404     value2 = result.getValue(COLUMN_2, QUALIFIER_2);
405     assertNull(value1);
406     assertNull(value2);
407   }
408   
409   /**
410    * Test RemoteHTable.Scanner 
411    */
412   @Test
413   public void testScanner() throws IOException {
414     List<Put> puts = new ArrayList<Put>();
415     Put put = new Put(ROW_1);
416     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
417     puts.add(put);
418     put = new Put(ROW_2);
419     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
420     puts.add(put);
421     put = new Put(ROW_3);
422     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
423     puts.add(put);
424     put = new Put(ROW_4);
425     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
426     puts.add(put);
427     remoteTable.put(puts);
428 
429     ResultScanner scanner = remoteTable.getScanner(new Scan());
430 
431     Result[] results = scanner.next(1);
432     assertNotNull(results);
433     assertEquals(1, results.length);
434     assertTrue(Bytes.equals(ROW_1, results[0].getRow()));
435 
436     Result result = scanner.next();
437     assertNotNull(result);
438     assertTrue(Bytes.equals(ROW_2, result.getRow()));
439 
440     results = scanner.next(2);
441     assertNotNull(results);
442     assertEquals(2, results.length);
443     assertTrue(Bytes.equals(ROW_3, results[0].getRow()));
444     assertTrue(Bytes.equals(ROW_4, results[1].getRow()));
445 
446     results = scanner.next(1);
447     assertNull(results);
448     scanner.close();
449     
450     scanner = remoteTable.getScanner(COLUMN_1);
451     results = scanner.next(4);
452     assertNotNull(results);
453     assertEquals(4, results.length);
454     assertTrue(Bytes.equals(ROW_1, results[0].getRow()));
455     assertTrue(Bytes.equals(ROW_2, results[1].getRow()));
456     assertTrue(Bytes.equals(ROW_3, results[2].getRow()));
457     assertTrue(Bytes.equals(ROW_4, results[3].getRow()));
458 
459     scanner.close();
460     
461     scanner = remoteTable.getScanner(COLUMN_1,QUALIFIER_1);
462     results = scanner.next(4);
463     assertNotNull(results);
464     assertEquals(4, results.length);
465     assertTrue(Bytes.equals(ROW_1, results[0].getRow()));
466     assertTrue(Bytes.equals(ROW_2, results[1].getRow()));
467     assertTrue(Bytes.equals(ROW_3, results[2].getRow()));
468     assertTrue(Bytes.equals(ROW_4, results[3].getRow()));
469     scanner.close();
470     assertTrue(remoteTable.isAutoFlush());
471 
472   }
473   
474   @Test
475   public void testCheckAndDelete() throws IOException {
476     Get get = new Get(ROW_1);
477     Result result = remoteTable.get(get);
478     byte[] value1 = result.getValue(COLUMN_1, QUALIFIER_1);
479     byte[] value2 = result.getValue(COLUMN_2, QUALIFIER_2);
480     assertNotNull(value1);
481     assertTrue(Bytes.equals(VALUE_1, value1));
482     assertNull(value2);
483     assertTrue(remoteTable.exists(get));
484     assertEquals(1, remoteTable.existsAll(Collections.singletonList(get)).length);
485     Delete delete = new Delete(ROW_1);
486 
487     remoteTable.checkAndDelete(ROW_1, COLUMN_1, QUALIFIER_1, VALUE_1, delete);
488     assertFalse(remoteTable.exists(get));
489 
490     Put put = new Put(ROW_1);
491     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
492     remoteTable.put(put);
493 
494     assertTrue(remoteTable.checkAndPut(ROW_1, COLUMN_1, QUALIFIER_1, VALUE_1,
495         put));
496     assertFalse(remoteTable.checkAndPut(ROW_1, COLUMN_1, QUALIFIER_1, VALUE_2,
497         put));
498   }
499   
500   /**
501    * Test RemoteHable.Scanner.iterator method  
502    */
503   @Test
504   public void testIteratorScaner() throws IOException {
505     List<Put> puts = new ArrayList<Put>();
506     Put put = new Put(ROW_1);
507     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
508     puts.add(put);
509     put = new Put(ROW_2);
510     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
511     puts.add(put);
512     put = new Put(ROW_3);
513     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
514     puts.add(put);
515     put = new Put(ROW_4);
516     put.add(COLUMN_1, QUALIFIER_1, VALUE_1);
517     puts.add(put);
518     remoteTable.put(puts);
519 
520     ResultScanner scanner = remoteTable.getScanner(new Scan());
521     Iterator<Result> iterator = scanner.iterator();
522     assertTrue(iterator.hasNext());
523     int counter = 0;
524     while (iterator.hasNext()) {
525       iterator.next();
526       counter++;
527     }
528     assertEquals(4, counter);
529   }
530   
531   /**
532    * Test a some methods of class Response.
533    */
534   @Test
535   public void testResponse(){
536     Response response = new Response(200);
537     assertEquals(200, response.getCode());
538     Header[] headers = new Header[2];
539     headers[0] = new Header("header1", "value1");
540     headers[1] = new Header("header2", "value2");
541     response = new Response(200, headers);
542     assertEquals("value1", response.getHeader("header1"));
543     assertFalse(response.hasBody());
544     response.setCode(404);
545     assertEquals(404, response.getCode());
546     headers = new Header[2];
547     headers[0] = new Header("header1", "value1.1");
548     headers[1] = new Header("header2", "value2");
549     response.setHeaders(headers);
550     assertEquals("value1.1", response.getHeader("header1"));
551     response.setBody(Bytes.toBytes("body"));
552     assertTrue(response.hasBody());    
553   }
554   
555 }
556