Java RequestHeader.Builder方法代码示例

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForRequestCalledBySuperUser() throws Exception {
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  headerBuilder.setMethodName("foo");
  RequestHeader header = headerBuilder.build();
  PriorityFunction qosFunc = regionServer.rpcServices.getPriority();

  //test superusers
  regionServer.conf.set(Superusers.SUPERUSER_CONF_KEY, "samplesuperuser");
  Superusers.initialize(regionServer.conf);
  assertEquals(HConstants.ADMIN_QOS, qosFunc.getPriority(header, null,
    User.createUserForTesting(regionServer.conf, "samplesuperuser",
      new String[]{"somegroup"})));

  //test supergroups
  regionServer.conf.set(Superusers.SUPERUSER_CONF_KEY, "@samplesupergroup");
  Superusers.initialize(regionServer.conf);
  assertEquals(HConstants.ADMIN_QOS, qosFunc.getPriority(header, null,
    User.createUserForTesting(regionServer.conf, "regularuser",
      new String[]{"samplesupergroup"})));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForMeta() throws IOException {
  priority = regionServer.rpcServices.getPriority();
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  //create a rpc request that has references to hbase:meta region and also
  //uses one of the known argument classes (known argument classes are
  //listed in HRegionServer.QosFunctionImpl.knownArgumentClasses)
  headerBuilder.setMethodName("foo");

  GetRequest.Builder getRequestBuilder = GetRequest.newBuilder();
  RegionSpecifier.Builder regionSpecifierBuilder = RegionSpecifier.newBuilder();
  regionSpecifierBuilder.setType(RegionSpecifierType.REGION_NAME);
  ByteString name = ByteStringer.wrap(HRegionInfo.FIRST_META_REGIONINFO.getRegionName());
  regionSpecifierBuilder.setValue(name);
  RegionSpecifier regionSpecifier = regionSpecifierBuilder.build();
  getRequestBuilder.setRegion(regionSpecifier);
  Get.Builder getBuilder = Get.newBuilder();
  getBuilder.setRow(ByteStringer.wrap("somerow".getBytes()));
  getRequestBuilder.setGet(getBuilder.build());
  GetRequest getRequest = getRequestBuilder.build();
  RequestHeader header = headerBuilder.build();
  HRegion mockRegion = Mockito.mock(HRegion.class);
  HRegionServer mockRS = Mockito.mock(HRegionServer.class);
  RSRpcServices mockRpc = Mockito.mock(RSRpcServices.class);
  Mockito.when(mockRS.getRSRpcServices()).thenReturn(mockRpc);
  HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
  Mockito.when(mockRpc.getRegion((RegionSpecifier) Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(true);
  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);
  assertEquals(HConstants.SYSTEMTABLE_QOS, priority.getPriority(header, getRequest,
    User.createUserForTesting(regionServer.conf, "someuser", new String[]{"somegroup"})));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionWithoutKnownArgument() throws IOException {
  //The request is not using any of the
  //known argument classes (it uses one random request class)
  //(known argument classes are listed in
  //HRegionServer.QosFunctionImpl.knownArgumentClasses)
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  headerBuilder.setMethodName("foo");
  RequestHeader header = headerBuilder.build();
  PriorityFunction qosFunc = regionServer.rpcServices.getPriority();
  assertEquals(HConstants.NORMAL_QOS, qosFunc.getPriority(header, null,
    User.createUserForTesting(regionServer.conf, "someuser", new String[]{"somegroup"})));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForMeta() throws IOException {
  priority = regionServer.rpcServices.getPriority();
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  //create a rpc request that has references to hbase:meta region and also
  //uses one of the known argument classes (known argument classes are
  //listed in HRegionServer.QosFunctionImpl.knownArgumentClasses)
  headerBuilder.setMethodName("foo");

  GetRequest.Builder getRequestBuilder = GetRequest.newBuilder();
  RegionSpecifier.Builder regionSpecifierBuilder = RegionSpecifier.newBuilder();
  regionSpecifierBuilder.setType(RegionSpecifierType.REGION_NAME);
  ByteString name = ByteStringer.wrap(HRegionInfo.FIRST_META_REGIONINFO.getRegionName());
  regionSpecifierBuilder.setValue(name);
  RegionSpecifier regionSpecifier = regionSpecifierBuilder.build();
  getRequestBuilder.setRegion(regionSpecifier);
  Get.Builder getBuilder = Get.newBuilder();
  getBuilder.setRow(ByteStringer.wrap("somerow".getBytes()));
  getRequestBuilder.setGet(getBuilder.build());
  GetRequest getRequest = getRequestBuilder.build();
  RequestHeader header = headerBuilder.build();
  HRegion mockRegion = Mockito.mock(HRegion.class);
  HRegionServer mockRS = Mockito.mock(HRegionServer.class);
  RSRpcServices mockRpc = Mockito.mock(RSRpcServices.class);
  Mockito.when(mockRS.getRSRpcServices()).thenReturn(mockRpc);
  HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
  Mockito.when(mockRpc.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(true);
  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);
  assertEquals(HConstants.SYSTEMTABLE_QOS, priority.getPriority(header, getRequest));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionWithoutKnownArgument() throws IOException {
  //The request is not using any of the
  //known argument classes (it uses one random request class)
  //(known argument classes are listed in
  //HRegionServer.QosFunctionImpl.knownArgumentClasses)
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  headerBuilder.setMethodName("foo");
  RequestHeader header = headerBuilder.build();
  PriorityFunction qosFunc = regionServer.rpcServices.getPriority();
  assertEquals(HConstants.NORMAL_QOS, qosFunc.getPriority(header, null));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForMeta() throws IOException {
  priority = regionServer.getPriority();
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  //create a rpc request that has references to hbase:meta region and also
  //uses one of the known argument classes (known argument classes are
  //listed in HRegionServer.QosFunctionImpl.knownArgumentClasses)
  headerBuilder.setMethodName("foo");

  GetRequest.Builder getRequestBuilder = GetRequest.newBuilder();
  RegionSpecifier.Builder regionSpecifierBuilder = RegionSpecifier.newBuilder();
  regionSpecifierBuilder.setType(RegionSpecifierType.REGION_NAME);
  ByteString name = HBaseZeroCopyByteString.wrap(HRegionInfo.FIRST_META_REGIONINFO.getRegionName());
  regionSpecifierBuilder.setValue(name);
  RegionSpecifier regionSpecifier = regionSpecifierBuilder.build();
  getRequestBuilder.setRegion(regionSpecifier);
  Get.Builder getBuilder = Get.newBuilder();
  getBuilder.setRow(HBaseZeroCopyByteString.wrap("somerow".getBytes()));
  getRequestBuilder.setGet(getBuilder.build());
  GetRequest getRequest = getRequestBuilder.build();
  RequestHeader header = headerBuilder.build();
  HRegion mockRegion = Mockito.mock(HRegion.class);
  HRegionServer mockRS = Mockito.mock(HRegionServer.class);
  HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
  Mockito.when(mockRS.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isMetaTable()).thenReturn(true);
  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);
  assertEquals(HConstants.HIGH_QOS, priority.getPriority(header, getRequest));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionWithoutKnownArgument() throws IOException {
  //The request is not using any of the
  //known argument classes (it uses one random request class)
  //(known argument classes are listed in
  //HRegionServer.QosFunctionImpl.knownArgumentClasses)
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  headerBuilder.setMethodName("foo");
  RequestHeader header = headerBuilder.build();
  PriorityFunction qosFunc = regionServer.getPriority();
  assertEquals(HConstants.NORMAL_QOS, qosFunc.getPriority(header, null));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
/**
 * Initiates a call by sending the parameter to the remote server.
 * Note: this is not called from the Connection thread, but by other
 * threads.
 * @param call
 * @param priority
 * @see #readResponse()
 */
protected void writeRequest(Call call, final int priority) {
  if (shouldCloseConnection.get()) return;
  try {
    RequestHeader.Builder builder = RequestHeader.newBuilder();
    builder.setCallId(call.id);
    if (Trace.isTracing()) {
      Span s = Trace.currentSpan();
      builder.setTraceInfo(RPCTInfo.newBuilder().
        setParentId(s.getSpanId()).setTraceId(s.getTraceId()));
    }
    builder.setMethodName(call.md.getName());
    builder.setRequestParam(call.param != null);
    ByteBuffer cellBlock = ipcUtil.buildCellBlock(this.codec, this.compressor, call.cells);
    if (cellBlock != null) {
      CellBlockMeta.Builder cellBlockBuilder = CellBlockMeta.newBuilder();
      cellBlockBuilder.setLength(cellBlock.limit());
      builder.setCellBlockMeta(cellBlockBuilder.build());
    }
    // Only pass priority if there one.  Let zero be same as no priority.
    if (priority != 0) builder.setPriority(priority);
    //noinspection SynchronizeOnNonFinalField
    RequestHeader header = builder.build();
    synchronized (this.out) { // FindBugs IS2_INCONSISTENT_SYNC
      IPCUtil.write(this.out, header, call.param, cellBlock);
    }
    if (LOG.isDebugEnabled()) {
      LOG.debug(getName() + ": wrote request header " + TextFormat.shortDebugString(header));
    }
  } catch(IOException e) {
    markClosed(e);
  }
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForMeta() throws IOException {
  priority = regionServer.rpcServices.getPriority();
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  //create a rpc request that has references to hbase:meta region and also
  //uses one of the known argument classes (known argument classes are
  //listed in HRegionServer.QosFunctionImpl.knownArgumentClasses)
  headerBuilder.setMethodName("foo");

  GetRequest.Builder getRequestBuilder = GetRequest.newBuilder();
  RegionSpecifier.Builder regionSpecifierBuilder = RegionSpecifier.newBuilder();
  regionSpecifierBuilder.setType(RegionSpecifierType.REGION_NAME);
  ByteString name = HBaseZeroCopyByteString.wrap(HRegionInfo.FIRST_META_REGIONINFO.getRegionName());
  regionSpecifierBuilder.setValue(name);
  RegionSpecifier regionSpecifier = regionSpecifierBuilder.build();
  getRequestBuilder.setRegion(regionSpecifier);
  Get.Builder getBuilder = Get.newBuilder();
  getBuilder.setRow(HBaseZeroCopyByteString.wrap("somerow".getBytes()));
  getRequestBuilder.setGet(getBuilder.build());
  GetRequest getRequest = getRequestBuilder.build();
  RequestHeader header = headerBuilder.build();
  HRegion mockRegion = Mockito.mock(HRegion.class);
  HRegionServer mockRS = Mockito.mock(HRegionServer.class);
  RSRpcServices mockRpc = Mockito.mock(RSRpcServices.class);
  Mockito.when(mockRS.getRSRpcServices()).thenReturn(mockRpc);
  HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
  Mockito.when(mockRpc.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isMetaTable()).thenReturn(true);
  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);
  assertEquals(HConstants.HIGH_QOS, priority.getPriority(header, getRequest));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForMeta() throws IOException {
  qosFunction = regionServer.getQosFunction();
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  //create a rpc request that has references to hbase:meta region and also
  //uses one of the known argument classes (known argument classes are
  //listed in HRegionServer.QosFunction.knownArgumentClasses)
  headerBuilder.setMethodName("foo");

  GetRequest.Builder getRequestBuilder = GetRequest.newBuilder();
  RegionSpecifier.Builder regionSpecifierBuilder = RegionSpecifier.newBuilder();
  regionSpecifierBuilder.setType(RegionSpecifierType.REGION_NAME);
  ByteString name = ZeroCopyLiteralByteString.wrap(HRegionInfo.FIRST_META_REGIONINFO.getRegionName());
  regionSpecifierBuilder.setValue(name);
  RegionSpecifier regionSpecifier = regionSpecifierBuilder.build();
  getRequestBuilder.setRegion(regionSpecifier);
  Get.Builder getBuilder = Get.newBuilder();
  getBuilder.setRow(ZeroCopyLiteralByteString.wrap("somerow".getBytes()));
  getRequestBuilder.setGet(getBuilder.build());
  GetRequest getRequest = getRequestBuilder.build();
  RequestHeader header = headerBuilder.build();
  HRegion mockRegion = Mockito.mock(HRegion.class);
  HRegionServer mockRS = Mockito.mock(HRegionServer.class);
  HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
  Mockito.when(mockRS.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isMetaTable()).thenReturn(true);
  qosFunction.setRegionServer(mockRS);
  assertTrue (qosFunction.apply(new Pair<RequestHeader, Message>(header, getRequest)) ==
    HConstants.HIGH_QOS);
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionWithoutKnownArgument() throws IOException {
  //The request is not using any of the
  //known argument classes (it uses one random request class)
  //(known argument classes are listed in
  //HRegionServer.QosFunction.knownArgumentClasses)
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  headerBuilder.setMethodName("foo");
  RequestHeader header = headerBuilder.build();
  QosFunction qosFunc = regionServer.getQosFunction();
  assertTrue (qosFunc.apply(new Pair<RequestHeader, Message>(header, null)) ==
    HConstants.NORMAL_QOS);
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
private void checkMethod(final String methodName, final int expected, final QosFunction qosf) {
  RequestHeader.Builder builder = RequestHeader.newBuilder();
  builder.setMethodName(methodName);
  Pair<RequestHeader, Message> headerAndParam =
    new Pair<RequestHeader, Message>(builder.build(), null);
  assertEquals(methodName, expected, qosf.apply(headerAndParam).intValue());
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForScanMethod() throws IOException {
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  headerBuilder.setMethodName("Scan");
  RequestHeader header = headerBuilder.build();

  //build an empty scan request
  ScanRequest.Builder scanBuilder = ScanRequest.newBuilder();
  ScanRequest scanRequest = scanBuilder.build();
  HRegion mockRegion = Mockito.mock(HRegion.class);
  HRegionServer mockRS = Mockito.mock(HRegionServer.class);
  RSRpcServices mockRpc = Mockito.mock(RSRpcServices.class);
  Mockito.when(mockRS.getRSRpcServices()).thenReturn(mockRpc);
  HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
  Mockito.when(mockRpc.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(false);
  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);
  int qos = priority.getPriority(header, scanRequest,
    User.createUserForTesting(regionServer.conf, "someuser", new String[]{"somegroup"}));
  assertTrue ("" + qos, qos == HConstants.NORMAL_QOS);

  //build a scan request with scannerID
  scanBuilder = ScanRequest.newBuilder();
  scanBuilder.setScannerId(12345);
  scanRequest = scanBuilder.build();
  //mock out a high priority type handling and see the QoS returned
  RegionScanner mockRegionScanner = Mockito.mock(RegionScanner.class);
  Mockito.when(mockRpc.getScanner(12345)).thenReturn(mockRegionScanner);
  Mockito.when(mockRegionScanner.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRpc.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(true);

  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);

  assertEquals(HConstants.SYSTEMTABLE_QOS, priority.getPriority(header, scanRequest,
    User.createUserForTesting(regionServer.conf, "someuser", new String[]{"somegroup"})));

  //the same as above but with non-meta region
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(false);
  assertEquals(HConstants.NORMAL_QOS, priority.getPriority(header, scanRequest,
    User.createUserForTesting(regionServer.conf, "someuser", new String[]{"somegroup"})));
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
/**
 * Initiates a call by sending the parameter to the remote server.
 * Note: this is not called from the Connection thread, but by other
 * threads.
 * @see #readResponse()
 */
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value="IS2_INCONSISTENT_SYNC",
    justification="Findbugs is misinterpreting locking missing fact that this.outLock is held")
private void writeRequest(Call call, final int priority, Span span) throws IOException {
  RequestHeader.Builder builder = RequestHeader.newBuilder();
  builder.setCallId(call.id);
  if (span != null) {
    builder.setTraceInfo(
        RPCTInfo.newBuilder().setParentId(span.getSpanId()).setTraceId(span.getTraceId()));
  }
  builder.setMethodName(call.md.getName());
  builder.setRequestParam(call.param != null);
  ByteBuffer cellBlock = ipcUtil.buildCellBlock(this.codec, this.compressor, call.cells);
  if (cellBlock != null) {
    CellBlockMeta.Builder cellBlockBuilder = CellBlockMeta.newBuilder();
    cellBlockBuilder.setLength(cellBlock.limit());
    builder.setCellBlockMeta(cellBlockBuilder.build());
  }
  // Only pass priority if there one.  Let zero be same as no priority.
  if (priority != 0) builder.setPriority(priority);
  RequestHeader header = builder.build();

  setupIOstreams();

  // Now we're going to write the call. We take the lock, then check that the connection
  //  is still valid, and, if so we do the write to the socket. If the write fails, we don't
  //  know where we stand, we have to close the connection.
  checkIsOpen();
  IOException writeException = null;
  synchronized (this.outLock) {
    if (Thread.interrupted()) throw new InterruptedIOException();

    calls.put(call.id, call); // We put first as we don't want the connection to become idle.
    checkIsOpen(); // Now we're checking that it didn't became idle in between.

    try {
      call.callStats.setRequestSizeBytes(IPCUtil.write(this.out, header, call.param,
          cellBlock));
    } catch (IOException e) {
      // We set the value inside the synchronized block, this way the next in line
      //  won't even try to write. Otherwise we might miss a call in the calls map?
      shouldCloseConnection.set(true);
      writeException = e;
      interrupt();
    }
  }

  // call close outside of the synchronized (outLock) to prevent deadlock - HBASE-14474
  if (writeException != null) {
    markClosed(writeException);
    close();
  }

  // We added a call, and may be started the connection close. In both cases, we
  //  need to notify the reader.
  doNotify();

  // Now that we notified, we can rethrow the exception if any. Otherwise we're good.
  if (writeException != null) throw writeException;
}
 

import org.apache.hadoop.hbase.protobuf.generated.RPCProtos.RequestHeader; //导入方法依赖的package包/类
@Test
public void testQosFunctionForScanMethod() throws IOException {
  RequestHeader.Builder headerBuilder = RequestHeader.newBuilder();
  headerBuilder.setMethodName("Scan");
  RequestHeader header = headerBuilder.build();

  //build an empty scan request
  ScanRequest.Builder scanBuilder = ScanRequest.newBuilder();
  ScanRequest scanRequest = scanBuilder.build();
  HRegion mockRegion = Mockito.mock(HRegion.class);
  HRegionServer mockRS = Mockito.mock(HRegionServer.class);
  RSRpcServices mockRpc = Mockito.mock(RSRpcServices.class);
  Mockito.when(mockRS.getRSRpcServices()).thenReturn(mockRpc);
  HRegionInfo mockRegionInfo = Mockito.mock(HRegionInfo.class);
  Mockito.when(mockRpc.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(false);
  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);
  int qos = priority.getPriority(header, scanRequest);
  assertTrue ("" + qos, qos == HConstants.NORMAL_QOS);

  //build a scan request with scannerID
  scanBuilder = ScanRequest.newBuilder();
  scanBuilder.setScannerId(12345);
  scanRequest = scanBuilder.build();
  //mock out a high priority type handling and see the QoS returned
  RegionScanner mockRegionScanner = Mockito.mock(RegionScanner.class);
  Mockito.when(mockRpc.getScanner(12345)).thenReturn(mockRegionScanner);
  Mockito.when(mockRegionScanner.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRpc.getRegion((RegionSpecifier)Mockito.any())).thenReturn(mockRegion);
  Mockito.when(mockRegion.getRegionInfo()).thenReturn(mockRegionInfo);
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(true);

  // Presume type.
  ((AnnotationReadingPriorityFunction)priority).setRegionServer(mockRS);

  assertEquals(HConstants.SYSTEMTABLE_QOS, priority.getPriority(header, scanRequest));

  //the same as above but with non-meta region
  Mockito.when(mockRegionInfo.isSystemTable()).thenReturn(false);
  assertEquals(HConstants.NORMAL_QOS, priority.getPriority(header, scanRequest));
}