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.regionserver;
21  
22  import static org.junit.Assert.*;
23  
24  import java.io.IOException;
25  
26  import org.apache.hadoop.conf.Configuration;
27  import org.apache.hadoop.hbase.HBaseConfiguration;
28  import org.apache.hadoop.hbase.HConstants;
29  import org.apache.hadoop.hbase.HRegionInfo;
30  import org.apache.hadoop.hbase.MediumTests;
31  import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.Get;
32  import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.GetRequest;
33  import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ScanRequest;
34  import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionSpecifier;
35  import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionSpecifier.RegionSpecifierType;
36  import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader;
37  import org.apache.hadoop.hbase.util.Pair;
38  import org.junit.Before;
39  import org.junit.Test;
40  import org.junit.experimental.categories.Category;
41  import org.mockito.Mockito;
42  
43  import com.google.protobuf.ByteString;
44  import com.google.protobuf.Message;
45  /**
46   * Tests that verify certain RPCs get a higher QoS.
47   */
48  @Category(MediumTests.class)
49  public class TestPriorityRpc {
50    private HRegionServer regionServer = null;
51    private QosFunction qosFunction = null;
52  
53    @Before
54    public void setup() {
55      Configuration conf = HBaseConfiguration.create();
56      regionServer = HRegionServer.constructRegionServer(HRegionServer.class, conf);
57      qosFunction = regionServer.getQosFunction();
58    }
59  
60    @Test
61    public void testQosFunctionForMeta() throws IOException {
62      qosFunction = regionServer.getQosFunction();
63      RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
64      //create a rpc request that has references to META region and also
65      //uses one of the known argument classes (known argument classes are
66      //listed in HRegionServer.QosFunction.knownArgumentClasses)
67      headerBuilder.setMethodName("foo");
68  
69      GetRequest.Builder getRequestBuilder = GetRequest.newBuilder();
70      RegionSpecifier.Builder regionSpecifierBuilder = RegionSpecifier.newBuilder();
71      regionSpecifierBuilder.setType(RegionSpecifierType.REGION_NAME);
72      ByteString name = ByteString.copyFrom(HRegionInfo.FIRST_META_REGIONINFO.getRegionName());
73      regionSpecifierBuilder.setValue(name);
74      RegionSpecifier regionSpecifier = regionSpecifierBuilder.build();
75      getRequestBuilder.setRegion(regionSpecifier);
76      Get.Builder getBuilder = Get.newBuilder();
77      getBuilder.setRow(ByteString.copyFrom("somerow".getBytes()));
78      getRequestBuilder.setGet(getBuilder.build());
79      GetRequest getRequest = getRequestBuilder.build();
80      RequestHeader header = headerBuilder.build();
81      HRegion mockRegion = Mockito.mock(HRegion.class);
82      HRegionServer mockRS = Mockito.mock(HRegionServer.class);
83      HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
84      Mockito.when(mockRS.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
85      Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
86      Mockito.when(mockRegionInfo.isMetaTable()).thenReturn(true);
87      qosFunction.setRegionServer(mockRS);
88      assertTrue (qosFunction.apply(new Pair<RequestHeader, Message>(header, getRequest)) ==
89        HConstants.HIGH_QOS);
90    }
91  
92    @Test
93    public void testQosFunctionWithoutKnownArgument() throws IOException {
94      //The request is not using any of the
95      //known argument classes (it uses one random request class)
96      //(known argument classes are listed in
97      //HRegionServer.QosFunction.knownArgumentClasses)
98      RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
99      headerBuilder.setMethodName("foo");
100     RequestHeader header = headerBuilder.build();
101     QosFunction qosFunc = regionServer.getQosFunction();
102     assertTrue (qosFunc.apply(new Pair<RequestHeader, Message>(header, null)) ==
103       HConstants.NORMAL_QOS);
104   }
105 
106   @Test
107   public void testQosFunctionForScanMethod() throws IOException {
108     RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
109     headerBuilder.setMethodName("scan");
110     RequestHeader header = headerBuilder.build();
111 
112     //build an empty scan request
113     ScanRequest.Builder scanBuilder = ScanRequest.newBuilder();
114     ScanRequest scanRequest = scanBuilder.build();
115     HRegion mockRegion = Mockito.mock(HRegion.class);
116     HRegionServer mockRS = Mockito.mock(HRegionServer.class);
117     HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
118     Mockito.when(mockRS.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
119     Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
120     Mockito.when(mockRegionInfo.isMetaRegion()).thenReturn(false);
121     qosFunction.setRegionServer(mockRS);
122     int qos = qosFunction.apply(new Pair<RequestHeader, Message>(header, scanRequest));
123     assertTrue ("" + qos, qos == HConstants.NORMAL_QOS);
124 
125     //build a scan request with scannerID
126     scanBuilder = ScanRequest.newBuilder();
127     scanBuilder.setScannerId(12345);
128     scanRequest = scanBuilder.build();
129     //mock out a high priority type handling and see the QoS returned
130     RegionScanner mockRegionScanner = Mockito.mock(RegionScanner.class);
131     Mockito.when(mockRS.getScanner(12345)).thenReturn(mockRegionScanner);
132     Mockito.when(mockRegionScanner.getRegionInfo()).thenReturn(mockRegionInfo);
133     Mockito.when(mockRS.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
134     Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
135     Mockito.when(mockRegionInfo.isMetaRegion()).thenReturn(true);
136 
137     qosFunction.setRegionServer(mockRS);
138 
139     assertTrue (qosFunction.apply(new Pair<RequestHeader, Message>(header, scanRequest)) ==
140       HConstants.HIGH_QOS);
141 
142     //the same as above but with non-meta region
143     Mockito.when(mockRegionInfo.isMetaRegion()).thenReturn(false);
144     assertTrue (qosFunction.apply(new Pair<RequestHeader, Message>(header, scanRequest)) ==
145       HConstants.NORMAL_QOS);
146   }
147 }