<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ConnectionUtils (Apache HBase 4.0.0-alpha-1-SNAPSHOT API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.hadoop.hbase.client, class: ConnectionUtils">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.6.1.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/ConnectionUtils.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.hadoop.hbase.client</a></div>
<h1 title="Class ConnectionUtils" class="title">Class ConnectionUtils</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.hadoop.hbase.client.ConnectionUtils</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="annotations">@Private
</span><span class="modifiers">public final class </span><span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-76">ConnectionUtils</a></span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block">Utility used by client connections.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>(package private) static interface&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="ConnectionUtils.Converter.html" class="type-name-link" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.Converter</a>&lt;<a href="ConnectionUtils.Converter.html" title="type parameter in ConnectionUtils.Converter">D</a>,<wbr><a href="ConnectionUtils.Converter.html" title="type parameter in ConnectionUtils.Converter">I</a>,<wbr><a href="ConnectionUtils.Converter.html" title="type parameter in ConnectionUtils.Converter">S</a>&gt;</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>(package private) static interface&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="ConnectionUtils.RpcCall.html" class="type-name-link" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.RpcCall</a>&lt;<a href="ConnectionUtils.RpcCall.html" title="type parameter in ConnectionUtils.RpcCall">RESP</a>,<wbr><a href="ConnectionUtils.RpcCall.html" title="type parameter in ConnectionUtils.RpcCall">REQ</a>&gt;</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#HBASE_CLIENT_CONNECTION_IMPL" class="member-name-link">HBASE_CLIENT_CONNECTION_IMPL</a></code></div>
<div class="col-last even-row-color">
<div class="block">Key for configuration in Configuration whose value is the class we implement making a new
 Connection instance.</div>
</div>
<div class="col-first odd-row-color"><code>private static final org.slf4j.Logger</code></div>
<div class="col-second odd-row-color"><code><a href="#LOG" class="member-name-link">LOG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>(package private) static final byte[]</code></div>
<div class="col-second even-row-color"><code><a href="#MAX_BYTE_ARRAY" class="member-name-link">MAX_BYTE_ARRAY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>private static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MY_ADDRESS" class="member-name-link">MY_ADDRESS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>(package private) static final <a href="NonceGenerator.html" title="interface in org.apache.hadoop.hbase.client">NonceGenerator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NO_NONCE_GENERATOR" class="member-name-link">NO_NONCE_GENERATOR</a></code></div>
<div class="col-last even-row-color">
<div class="block">Dummy nonce generator for disabled nonces.</div>
</div>
<div class="col-first odd-row-color"><code>static final long</code></div>
<div class="col-second odd-row-color"><code><a href="#SLEEP_DELTA_NS" class="member-name-link">SLEEP_DELTA_NS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier</div>
<div class="table-header col-second">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>private </code></div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">ConnectionUtils</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#calcEstimatedSize(org.apache.hadoop.hbase.client.Result)" class="member-name-link">calcEstimatedSize</a><wbr>(<a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a>&nbsp;rs)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#calcPriority(int,org.apache.hadoop.hbase.TableName)" class="member-name-link">calcPriority</a><wbr>(int&nbsp;priority,
 <a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Select the priority for the rpc call.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static &lt;REQ,<wbr>
PREQ,<wbr>
PRESP,<wbr>
RESP&gt;<br><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;RESP&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(org.apache.hadoop.hbase.ipc.HBaseRpcController,org.apache.hadoop.hbase.HRegionLocation,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface,REQ,org.apache.hadoop.hbase.client.ConnectionUtils.Converter,org.apache.hadoop.hbase.client.ConnectionUtils.RpcCall,org.apache.hadoop.hbase.client.ConnectionUtils.Converter)" class="member-name-link">call</a><wbr>(<a href="../ipc/HBaseRpcController.html" title="interface in org.apache.hadoop.hbase.ipc">HBaseRpcController</a>&nbsp;controller,
 <a href="../HRegionLocation.html" title="class in org.apache.hadoop.hbase">HRegionLocation</a>&nbsp;loc,
 org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface&nbsp;stub,
 REQ&nbsp;req,
 <a href="ConnectionUtils.Converter.html" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.Converter</a>&lt;PREQ,<wbr>byte[],<wbr>REQ&gt;&nbsp;reqConvert,
 <a href="ConnectionUtils.RpcCall.html" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.RpcCall</a>&lt;PRESP,<wbr>PREQ&gt;&nbsp;rpcCall,
 <a href="ConnectionUtils.Converter.html" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.Converter</a>&lt;RESP,<wbr><a href="../ipc/HBaseRpcController.html" title="interface in org.apache.hadoop.hbase.ipc">HBaseRpcController</a>,<wbr>PRESP&gt;&nbsp;respConverter)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#checkHasFamilies(org.apache.hadoop.hbase.client.Mutation)" class="member-name-link">checkHasFamilies</a><wbr>(<a href="Mutation.html" title="class in org.apache.hadoop.hbase.client">Mutation</a>&nbsp;mutation)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>private static &lt;T&gt;&nbsp;void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#connect(java.util.concurrent.CompletableFuture,java.util.concurrent.CompletableFuture,java.util.Optional)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&nbsp;srcFuture,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&nbsp;dstFuture,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;metrics)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Connect the two futures, if the src future is done, then mark the dst future as done.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static byte[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createCloseRowBefore(byte%5B%5D)" class="member-name-link">createCloseRowBefore</a><wbr>(byte[]&nbsp;row)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Create a row before the specified row and very close to the specified row.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static byte[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createClosestRowAfter(byte%5B%5D)" class="member-name-link">createClosestRowAfter</a><wbr>(byte[]&nbsp;row)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Create the closest row after the specified row</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ScanResultCache.html" title="interface in org.apache.hadoop.hbase.client">ScanResultCache</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createScanResultCache(org.apache.hadoop.hbase.client.Scan)" class="member-name-link">createScanResultCache</a><wbr>(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static <a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#filterCells(org.apache.hadoop.hbase.client.Result,org.apache.hadoop.hbase.ExtendedCell)" class="member-name-link">filterCells</a><wbr>(<a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a>&nbsp;result,
 <a href="../ExtendedCell.html" title="interface in org.apache.hadoop.hbase">ExtendedCell</a>&nbsp;keepCellsAfter)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static <a href="RegionLocateType.html" title="enum class in org.apache.hadoop.hbase.client">RegionLocateType</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getLocateType(org.apache.hadoop.hbase.client.Scan)" class="member-name-link">getLocateType</a><wbr>(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>private static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getMyAddress()" class="member-name-link">getMyAddress</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getOrFetch(java.util.concurrent.atomic.AtomicReference,java.util.concurrent.atomic.AtomicReference,boolean,java.util.function.Supplier,java.util.function.Predicate,java.lang.String)" class="member-name-link">getOrFetch</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/atomic/AtomicReference.html" title="class or interface in java.util.concurrent.atomic" class="external-link">AtomicReference</a>&lt;T&gt;&nbsp;cacheRef,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/atomic/AtomicReference.html" title="class or interface in java.util.concurrent.atomic" class="external-link">AtomicReference</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;futureRef,
 boolean&nbsp;reload,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;fetch,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;T&gt;&nbsp;validator,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPauseTime(long,int)" class="member-name-link">getPauseTime</a><wbr>(long&nbsp;pause,
 int&nbsp;tries)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Calculate pause time.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPriority(org.apache.hadoop.hbase.TableName)" class="member-name-link">getPriority</a><wbr>(<a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getStubKey(java.lang.String,org.apache.hadoop.hbase.ServerName)" class="member-name-link">getStubKey</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;serviceName,
 <a href="../ServerName.html" title="class in org.apache.hadoop.hbase">ServerName</a>&nbsp;serverName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a unique key for the rpc stub to the given server.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#incRegionCountMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics)" class="member-name-link">incRegionCountMetrics</a><wbr>(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#incRPCCallsMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,boolean)" class="member-name-link">incRPCCallsMetrics</a><wbr>(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 boolean&nbsp;isRegionServerRemote)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#incRPCRetriesMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,boolean)" class="member-name-link">incRPCRetriesMetrics</a><wbr>(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 boolean&nbsp;isRegionServerRemote)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isEmptyStartRow(byte%5B%5D)" class="member-name-link">isEmptyStartRow</a><wbr>(byte[]&nbsp;row)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isEmptyStopRow(byte%5B%5D)" class="member-name-link">isEmptyStopRow</a><wbr>(byte[]&nbsp;row)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isRemote(java.lang.String)" class="member-name-link">isRemote</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isUnexpectedPreambleHeaderException(java.io.IOException)" class="member-name-link">isUnexpectedPreambleHeaderException</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a>&nbsp;e)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#noMoreResultsForReverseScan(org.apache.hadoop.hbase.client.Scan,org.apache.hadoop.hbase.client.RegionInfo)" class="member-name-link">noMoreResultsForReverseScan</a><wbr>(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan,
 <a href="RegionInfo.html" title="interface in org.apache.hadoop.hbase.client">RegionInfo</a>&nbsp;info)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#noMoreResultsForScan(org.apache.hadoop.hbase.client.Scan,org.apache.hadoop.hbase.client.RegionInfo)" class="member-name-link">noMoreResultsForScan</a><wbr>(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan,
 <a href="RegionInfo.html" title="interface in org.apache.hadoop.hbase.client">RegionInfo</a>&nbsp;info)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#resetController(org.apache.hadoop.hbase.ipc.HBaseRpcController,long,int,org.apache.hadoop.hbase.TableName)" class="member-name-link">resetController</a><wbr>(<a href="../ipc/HBaseRpcController.html" title="interface in org.apache.hadoop.hbase.ipc">HBaseRpcController</a>&nbsp;controller,
 long&nbsp;timeoutNs,
 int&nbsp;priority,
 <a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#retries2Attempts(int)" class="member-name-link">retries2Attempts</a><wbr>(int&nbsp;retries)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Return retires + 1.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>private static &lt;T&gt;&nbsp;void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sendRequestsToSecondaryReplicas(java.util.function.Function,org.apache.hadoop.hbase.RegionLocations,java.util.concurrent.CompletableFuture,java.util.Optional)" class="member-name-link">sendRequestsToSecondaryReplicas</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;requestReplica,
 <a href="../RegionLocations.html" title="class in org.apache.hadoop.hbase">RegionLocations</a>&nbsp;locs,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&nbsp;future,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;metrics)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#setCoprocessorError(org.apache.hbase.thirdparty.com.google.protobuf.RpcController,java.lang.Throwable)" class="member-name-link">setCoprocessorError</a><wbr>(org.apache.hbase.thirdparty.com.google.protobuf.RpcController&nbsp;controller,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;error)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#setServerSideHConnectionRetriesConfig(org.apache.hadoop.conf.Configuration,java.lang.String,org.slf4j.Logger)" class="member-name-link">setServerSideHConnectionRetriesConfig</a><wbr>(org.apache.hadoop.conf.Configuration&nbsp;c,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sn,
 org.slf4j.Logger&nbsp;log)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Changes the configuration to set the number of retries needed when using Connection internally,
 e.g.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#shutdownPool(java.util.concurrent.ExecutorService)" class="member-name-link">shutdownPool</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/ExecutorService.html" title="class or interface in java.util.concurrent" class="external-link">ExecutorService</a>&nbsp;pool)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timelineConsistentRead(org.apache.hadoop.hbase.client.AsyncRegionLocator,org.apache.hadoop.hbase.TableName,org.apache.hadoop.hbase.client.Query,byte%5B%5D,org.apache.hadoop.hbase.client.RegionLocateType,java.util.function.Function,long,long,org.apache.hbase.thirdparty.io.netty.util.Timer,java.util.Optional)" class="member-name-link">timelineConsistentRead</a><wbr>(<a href="AsyncRegionLocator.html" title="class in org.apache.hadoop.hbase.client">AsyncRegionLocator</a>&nbsp;locator,
 <a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName,
 <a href="Query.html" title="class in org.apache.hadoop.hbase.client">Query</a>&nbsp;query,
 byte[]&nbsp;row,
 <a href="RegionLocateType.html" title="enum class in org.apache.hadoop.hbase.client">RegionLocateType</a>&nbsp;locateType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;requestReplica,
 long&nbsp;rpcTimeoutNs,
 long&nbsp;primaryCallTimeoutNs,
 org.apache.hbase.thirdparty.io.netty.util.Timer&nbsp;retryTimer,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;metrics)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toCheckExistenceOnly(java.util.List)" class="member-name-link">toCheckExistenceOnly</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a>&gt;&nbsp;gets)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static <a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toCheckExistenceOnly(org.apache.hadoop.hbase.client.Get)" class="member-name-link">toCheckExistenceOnly</a><wbr>(<a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a>&nbsp;get)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#translateException(java.lang.Throwable)" class="member-name-link">translateException</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;t)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#updateResultsMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,org.apache.hadoop.hbase.client.Result%5B%5D,boolean)" class="member-name-link">updateResultsMetrics</a><wbr>(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 <a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a>[]&nbsp;rrs,
 boolean&nbsp;isRegionServerRemote)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#updateServerSideMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ScanResponse)" class="member-name-link">updateServerSideMetrics</a><wbr>(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ScanResponse&nbsp;response)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Use the scan metrics returned by the server to add to the identically named counters in the
 client side metrics.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#updateStats(java.util.Optional,java.util.Optional,org.apache.hadoop.hbase.ServerName,org.apache.hadoop.hbase.client.MultiResponse)" class="member-name-link">updateStats</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="ServerStatisticTracker.html" title="class in org.apache.hadoop.hbase.client">ServerStatisticTracker</a>&gt;&nbsp;optStats,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;optMetrics,
 <a href="../ServerName.html" title="class in org.apache.hadoop.hbase">ServerName</a>&nbsp;serverName,
 <a href="MultiResponse.html" title="class in org.apache.hadoop.hbase.client">MultiResponse</a>&nbsp;resp)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#validatePut(org.apache.hadoop.hbase.client.Put,int)" class="member-name-link">validatePut</a><wbr>(<a href="Put.html" title="class in org.apache.hadoop.hbase.client">Put</a>&nbsp;put,
 int&nbsp;maxKeyValueSize)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>(package private) static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#validatePutsInRowMutations(org.apache.hadoop.hbase.client.RowMutations,int)" class="member-name-link">validatePutsInRowMutations</a><wbr>(<a href="RowMutations.html" title="class in org.apache.hadoop.hbase.client">RowMutations</a>&nbsp;rowMutations,
 int&nbsp;maxKeyValueSize)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="LOG">
<h3>LOG</h3>
<div class="member-signature"><span class="modifiers">private static final</span>&nbsp;<span class="return-type">org.slf4j.Logger</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-79">LOG</a></span></div>
</section>
</li>
<li>
<section class="detail" id="HBASE_CLIENT_CONNECTION_IMPL">
<h3>HBASE_CLIENT_CONNECTION_IMPL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-85">HBASE_CLIENT_CONNECTION_IMPL</a></span></div>
<div class="block">Key for configuration in Configuration whose value is the class we implement making a new
 Connection instance.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.hadoop.hbase.client.ConnectionUtils.HBASE_CLIENT_CONNECTION_IMPL">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="NO_NONCE_GENERATOR">
<h3>NO_NONCE_GENERATOR</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="NonceGenerator.html" title="interface in org.apache.hadoop.hbase.client">NonceGenerator</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-151">NO_NONCE_GENERATOR</a></span></div>
<div class="block">Dummy nonce generator for disabled nonces.</div>
</section>
</li>
<li>
<section class="detail" id="MAX_BYTE_ARRAY">
<h3>MAX_BYTE_ARRAY</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type">byte[]</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-166">MAX_BYTE_ARRAY</a></span></div>
</section>
</li>
<li>
<section class="detail" id="SLEEP_DELTA_NS">
<h3>SLEEP_DELTA_NS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-264">SLEEP_DELTA_NS</a></span></div>
</section>
</li>
<li>
<section class="detail" id="MY_ADDRESS">
<h3>MY_ADDRESS</h3>
<div class="member-signature"><span class="modifiers">private static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-325">MY_ADDRESS</a></span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>ConnectionUtils</h3>
<div class="member-signature"><span class="modifiers">private</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-87">ConnectionUtils</a></span>()</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getPauseTime(long,int)">
<h3>getPauseTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-96">getPauseTime</a></span><wbr><span class="parameters">(long&nbsp;pause,
 int&nbsp;tries)</span></div>
<div class="block">Calculate pause time. Built on <a href="../HConstants.html#RETRY_BACKOFF"><code>HConstants.RETRY_BACKOFF</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>pause</code> - time to pause</dd>
<dd><code>tries</code> - amount of tries</dd>
<dt>Returns:</dt>
<dd>How long to wait after <code>tries</code> retries</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setServerSideHConnectionRetriesConfig(org.apache.hadoop.conf.Configuration,java.lang.String,org.slf4j.Logger)">
<h3>setServerSideHConnectionRetriesConfig</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-117">setServerSideHConnectionRetriesConfig</a></span><wbr><span class="parameters">(org.apache.hadoop.conf.Configuration&nbsp;c,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sn,
 org.slf4j.Logger&nbsp;log)</span></div>
<div class="block">Changes the configuration to set the number of retries needed when using Connection internally,
 e.g. for updating catalog tables, etc. Call this method before we create any Connections.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>c</code> - The Configuration instance to set the retries into.</dd>
<dd><code>log</code> - Used to log what we set in here.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getStubKey(java.lang.String,org.apache.hadoop.hbase.ServerName)">
<h3>getStubKey</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-134">getStubKey</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;serviceName,
 <a href="../ServerName.html" title="class in org.apache.hadoop.hbase">ServerName</a>&nbsp;serverName)</span></div>
<div class="block">Get a unique key for the rpc stub to the given server.</div>
</section>
</li>
<li>
<section class="detail" id="retries2Attempts(int)">
<h3>retries2Attempts</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-141">retries2Attempts</a></span><wbr><span class="parameters">(int&nbsp;retries)</span></div>
<div class="block">Return retires + 1. The returned value will be in range [1, Integer.MAX_VALUE].</div>
</section>
</li>
<li>
<section class="detail" id="checkHasFamilies(org.apache.hadoop.hbase.client.Mutation)">
<h3>checkHasFamilies</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-145">checkHasFamilies</a></span><wbr><span class="parameters">(<a href="Mutation.html" title="class in org.apache.hadoop.hbase.client">Mutation</a>&nbsp;mutation)</span></div>
</section>
</li>
<li>
<section class="detail" id="createClosestRowAfter(byte[])">
<h3>createClosestRowAfter</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">byte[]</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-171">createClosestRowAfter</a></span><wbr><span class="parameters">(byte[]&nbsp;row)</span></div>
<div class="block">Create the closest row after the specified row</div>
</section>
</li>
<li>
<section class="detail" id="createCloseRowBefore(byte[])">
<h3>createCloseRowBefore</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">byte[]</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-178">createCloseRowBefore</a></span><wbr><span class="parameters">(byte[]&nbsp;row)</span></div>
<div class="block">Create a row before the specified row and very close to the specified row.</div>
</section>
</li>
<li>
<section class="detail" id="isEmptyStartRow(byte[])">
<h3>isEmptyStartRow</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-193">isEmptyStartRow</a></span><wbr><span class="parameters">(byte[]&nbsp;row)</span></div>
</section>
</li>
<li>
<section class="detail" id="isEmptyStopRow(byte[])">
<h3>isEmptyStopRow</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-197">isEmptyStopRow</a></span><wbr><span class="parameters">(byte[]&nbsp;row)</span></div>
</section>
</li>
<li>
<section class="detail" id="resetController(org.apache.hadoop.hbase.ipc.HBaseRpcController,long,int,org.apache.hadoop.hbase.TableName)">
<h3>resetController</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-201">resetController</a></span><wbr><span class="parameters">(<a href="../ipc/HBaseRpcController.html" title="interface in org.apache.hadoop.hbase.ipc">HBaseRpcController</a>&nbsp;controller,
 long&nbsp;timeoutNs,
 int&nbsp;priority,
 <a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName)</span></div>
</section>
</li>
<li>
<section class="detail" id="translateException(java.lang.Throwable)">
<h3>translateException</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-214">translateException</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;t)</span></div>
</section>
</li>
<li>
<section class="detail" id="calcEstimatedSize(org.apache.hadoop.hbase.client.Result)">
<h3>calcEstimatedSize</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-227">calcEstimatedSize</a></span><wbr><span class="parameters">(<a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a>&nbsp;rs)</span></div>
</section>
</li>
<li>
<section class="detail" id="filterCells(org.apache.hadoop.hbase.client.Result,org.apache.hadoop.hbase.ExtendedCell)">
<h3>filterCells</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type"><a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-236">filterCells</a></span><wbr><span class="parameters">(<a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a>&nbsp;result,
 <a href="../ExtendedCell.html" title="interface in org.apache.hadoop.hbase">ExtendedCell</a>&nbsp;keepCellsAfter)</span></div>
</section>
</li>
<li>
<section class="detail" id="toCheckExistenceOnly(org.apache.hadoop.hbase.client.Get)">
<h3>toCheckExistenceOnly</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type"><a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-266">toCheckExistenceOnly</a></span><wbr><span class="parameters">(<a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a>&nbsp;get)</span></div>
</section>
</li>
<li>
<section class="detail" id="toCheckExistenceOnly(java.util.List)">
<h3>toCheckExistenceOnly</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a>&gt;</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-273">toCheckExistenceOnly</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Get.html" title="class in org.apache.hadoop.hbase.client">Get</a>&gt;&nbsp;gets)</span></div>
</section>
</li>
<li>
<section class="detail" id="getLocateType(org.apache.hadoop.hbase.client.Scan)">
<h3>getLocateType</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type"><a href="RegionLocateType.html" title="enum class in org.apache.hadoop.hbase.client">RegionLocateType</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-277">getLocateType</a></span><wbr><span class="parameters">(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan)</span></div>
</section>
</li>
<li>
<section class="detail" id="noMoreResultsForScan(org.apache.hadoop.hbase.client.Scan,org.apache.hadoop.hbase.client.RegionInfo)">
<h3>noMoreResultsForScan</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-289">noMoreResultsForScan</a></span><wbr><span class="parameters">(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan,
 <a href="RegionInfo.html" title="interface in org.apache.hadoop.hbase.client">RegionInfo</a>&nbsp;info)</span></div>
</section>
</li>
<li>
<section class="detail" id="noMoreResultsForReverseScan(org.apache.hadoop.hbase.client.Scan,org.apache.hadoop.hbase.client.RegionInfo)">
<h3>noMoreResultsForReverseScan</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-303">noMoreResultsForReverseScan</a></span><wbr><span class="parameters">(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan,
 <a href="RegionInfo.html" title="interface in org.apache.hadoop.hbase.client">RegionInfo</a>&nbsp;info)</span></div>
</section>
</li>
<li>
<section class="detail" id="createScanResultCache(org.apache.hadoop.hbase.client.Scan)">
<h3>createScanResultCache</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ScanResultCache.html" title="interface in org.apache.hadoop.hbase.client">ScanResultCache</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-315">createScanResultCache</a></span><wbr><span class="parameters">(<a href="Scan.html" title="class in org.apache.hadoop.hbase.client">Scan</a>&nbsp;scan)</span></div>
</section>
</li>
<li>
<section class="detail" id="getMyAddress()">
<h3>getMyAddress</h3>
<div class="member-signature"><span class="modifiers">private static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-327">getMyAddress</a></span>()</div>
</section>
</li>
<li>
<section class="detail" id="isRemote(java.lang.String)">
<h3>isRemote</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-336">isRemote</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host)</span></div>
</section>
</li>
<li>
<section class="detail" id="incRPCCallsMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,boolean)">
<h3>incRPCCallsMetrics</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-340">incRPCCallsMetrics</a></span><wbr><span class="parameters">(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 boolean&nbsp;isRegionServerRemote)</span></div>
</section>
</li>
<li>
<section class="detail" id="incRPCRetriesMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,boolean)">
<h3>incRPCRetriesMetrics</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-350">incRPCRetriesMetrics</a></span><wbr><span class="parameters">(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 boolean&nbsp;isRegionServerRemote)</span></div>
</section>
</li>
<li>
<section class="detail" id="updateResultsMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,org.apache.hadoop.hbase.client.Result[],boolean)">
<h3>updateResultsMetrics</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-360">updateResultsMetrics</a></span><wbr><span class="parameters">(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 <a href="Result.html" title="class in org.apache.hadoop.hbase.client">Result</a>[]&nbsp;rrs,
 boolean&nbsp;isRegionServerRemote)</span></div>
</section>
</li>
<li>
<section class="detail" id="updateServerSideMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ScanResponse)">
<h3>updateServerSideMetrics</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-382">updateServerSideMetrics</a></span><wbr><span class="parameters">(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics,
 org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ScanResponse&nbsp;response)</span></div>
<div class="block">Use the scan metrics returned by the server to add to the identically named counters in the
 client side metrics. If a counter does not exist with the same name as the server side metric,
 the attempt to increase the counter will fail.</div>
</section>
</li>
<li>
<section class="detail" id="incRegionCountMetrics(org.apache.hadoop.hbase.client.metrics.ScanMetrics)">
<h3>incRegionCountMetrics</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-389">incRegionCountMetrics</a></span><wbr><span class="parameters">(<a href="metrics/ScanMetrics.html" title="class in org.apache.hadoop.hbase.client.metrics">ScanMetrics</a>&nbsp;scanMetrics)</span></div>
</section>
</li>
<li>
<section class="detail" id="connect(java.util.concurrent.CompletableFuture,java.util.concurrent.CompletableFuture,java.util.Optional)">
<h3>connect</h3>
<div class="member-signature"><span class="modifiers">private static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-403">connect</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&nbsp;srcFuture,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&nbsp;dstFuture,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;metrics)</span></div>
<div class="block">Connect the two futures, if the src future is done, then mark the dst future as done. And if
 the dst future is done, then cancel the src future. This is used for timeline consistent read.
 <p/>
 Pass empty metrics if you want to link the primary future and the dst future so we will not
 increase the hedge read related metrics.</div>
</section>
</li>
<li>
<section class="detail" id="sendRequestsToSecondaryReplicas(java.util.function.Function,org.apache.hadoop.hbase.RegionLocations,java.util.concurrent.CompletableFuture,java.util.Optional)">
<h3>sendRequestsToSecondaryReplicas</h3>
<div class="member-signature"><span class="modifiers">private static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-422">sendRequestsToSecondaryReplicas</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;requestReplica,
 <a href="../RegionLocations.html" title="class in org.apache.hadoop.hbase">RegionLocations</a>&nbsp;locs,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&nbsp;future,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;metrics)</span></div>
</section>
</li>
<li>
<section class="detail" id="timelineConsistentRead(org.apache.hadoop.hbase.client.AsyncRegionLocator,org.apache.hadoop.hbase.TableName,org.apache.hadoop.hbase.client.Query,byte[],org.apache.hadoop.hbase.client.RegionLocateType,java.util.function.Function,long,long,org.apache.hbase.thirdparty.io.netty.util.Timer,java.util.Optional)">
<h3>timelineConsistentRead</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-437">timelineConsistentRead</a></span><wbr><span class="parameters">(<a href="AsyncRegionLocator.html" title="class in org.apache.hadoop.hbase.client">AsyncRegionLocator</a>&nbsp;locator,
 <a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName,
 <a href="Query.html" title="class in org.apache.hadoop.hbase.client">Query</a>&nbsp;query,
 byte[]&nbsp;row,
 <a href="RegionLocateType.html" title="enum class in org.apache.hadoop.hbase.client">RegionLocateType</a>&nbsp;locateType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;requestReplica,
 long&nbsp;rpcTimeoutNs,
 long&nbsp;primaryCallTimeoutNs,
 org.apache.hbase.thirdparty.io.netty.util.Timer&nbsp;retryTimer,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;metrics)</span></div>
</section>
</li>
<li>
<section class="detail" id="validatePut(org.apache.hadoop.hbase.client.Put,int)">
<h3>validatePut</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-484">validatePut</a></span><wbr><span class="parameters">(<a href="Put.html" title="class in org.apache.hadoop.hbase.client">Put</a>&nbsp;put,
 int&nbsp;maxKeyValueSize)</span></div>
</section>
</li>
<li>
<section class="detail" id="validatePutsInRowMutations(org.apache.hadoop.hbase.client.RowMutations,int)">
<h3>validatePutsInRowMutations</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-499">validatePutsInRowMutations</a></span><wbr><span class="parameters">(<a href="RowMutations.html" title="class in org.apache.hadoop.hbase.client">RowMutations</a>&nbsp;rowMutations,
 int&nbsp;maxKeyValueSize)</span></div>
</section>
</li>
<li>
<section class="detail" id="calcPriority(int,org.apache.hadoop.hbase.TableName)">
<h3>calcPriority</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-519">calcPriority</a></span><wbr><span class="parameters">(int&nbsp;priority,
 <a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName)</span></div>
<div class="block">Select the priority for the rpc call.
 <p/>
 The rules are:
 <ol>
 <li>If user set a priority explicitly, then just use it.</li>
 <li>For system table, use <a href="../HConstants.html#SYSTEMTABLE_QOS"><code>HConstants.SYSTEMTABLE_QOS</code></a>.</li>
 <li>For other tables, use <a href="../HConstants.html#NORMAL_QOS"><code>HConstants.NORMAL_QOS</code></a>.</li>
 </ol></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>priority</code> - the priority set by user, can be <a href="../HConstants.html#PRIORITY_UNSET"><code>HConstants.PRIORITY_UNSET</code></a>.</dd>
<dd><code>tableName</code> - the table we operate on</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPriority(org.apache.hadoop.hbase.TableName)">
<h3>getPriority</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-527">getPriority</a></span><wbr><span class="parameters">(<a href="../TableName.html" title="class in org.apache.hadoop.hbase">TableName</a>&nbsp;tableName)</span></div>
</section>
</li>
<li>
<section class="detail" id="getOrFetch(java.util.concurrent.atomic.AtomicReference,java.util.concurrent.atomic.AtomicReference,boolean,java.util.function.Supplier,java.util.function.Predicate,java.lang.String)">
<h3>getOrFetch</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-535">getOrFetch</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/atomic/AtomicReference.html" title="class or interface in java.util.concurrent.atomic" class="external-link">AtomicReference</a>&lt;T&gt;&nbsp;cacheRef,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/atomic/AtomicReference.html" title="class or interface in java.util.concurrent.atomic" class="external-link">AtomicReference</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;futureRef,
 boolean&nbsp;reload,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;T&gt;&gt;&nbsp;fetch,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;T&gt;&nbsp;validator,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</span></div>
</section>
</li>
<li>
<section class="detail" id="updateStats(java.util.Optional,java.util.Optional,org.apache.hadoop.hbase.ServerName,org.apache.hadoop.hbase.client.MultiResponse)">
<h3>updateStats</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-579">updateStats</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="ServerStatisticTracker.html" title="class in org.apache.hadoop.hbase.client">ServerStatisticTracker</a>&gt;&nbsp;optStats,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="MetricsConnection.html" title="class in org.apache.hadoop.hbase.client">MetricsConnection</a>&gt;&nbsp;optMetrics,
 <a href="../ServerName.html" title="class in org.apache.hadoop.hbase">ServerName</a>&nbsp;serverName,
 <a href="MultiResponse.html" title="class in org.apache.hadoop.hbase.client">MultiResponse</a>&nbsp;resp)</span></div>
</section>
</li>
<li>
<section class="detail" id="call(org.apache.hadoop.hbase.ipc.HBaseRpcController,org.apache.hadoop.hbase.HRegionLocation,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface,REQ,org.apache.hadoop.hbase.client.ConnectionUtils.Converter,org.apache.hadoop.hbase.client.ConnectionUtils.RpcCall,org.apache.hadoop.hbase.client.ConnectionUtils.Converter)">
<h3 id="call(org.apache.hadoop.hbase.ipc.HBaseRpcController,org.apache.hadoop.hbase.HRegionLocation,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface,java.lang.Object,org.apache.hadoop.hbase.client.ConnectionUtils.Converter,org.apache.hadoop.hbase.client.ConnectionUtils.RpcCall,org.apache.hadoop.hbase.client.ConnectionUtils.Converter)">call</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="type-parameters">&lt;REQ,<wbr>
PREQ,<wbr>
PRESP,<wbr>
RESP&gt;</span>
<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html" title="class or interface in java.util.concurrent" class="external-link">CompletableFuture</a>&lt;RESP&gt;</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-613">call</a></span><wbr><span class="parameters">(<a href="../ipc/HBaseRpcController.html" title="interface in org.apache.hadoop.hbase.ipc">HBaseRpcController</a>&nbsp;controller,
 <a href="../HRegionLocation.html" title="class in org.apache.hadoop.hbase">HRegionLocation</a>&nbsp;loc,
 org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface&nbsp;stub,
 REQ&nbsp;req,
 <a href="ConnectionUtils.Converter.html" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.Converter</a>&lt;PREQ,<wbr>byte[],<wbr>REQ&gt;&nbsp;reqConvert,
 <a href="ConnectionUtils.RpcCall.html" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.RpcCall</a>&lt;PRESP,<wbr>PREQ&gt;&nbsp;rpcCall,
 <a href="ConnectionUtils.Converter.html" title="interface in org.apache.hadoop.hbase.client">ConnectionUtils.Converter</a>&lt;RESP,<wbr><a href="../ipc/HBaseRpcController.html" title="interface in org.apache.hadoop.hbase.ipc">HBaseRpcController</a>,<wbr>PRESP&gt;&nbsp;respConverter)</span></div>
</section>
</li>
<li>
<section class="detail" id="shutdownPool(java.util.concurrent.ExecutorService)">
<h3>shutdownPool</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-641">shutdownPool</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/ExecutorService.html" title="class or interface in java.util.concurrent" class="external-link">ExecutorService</a>&nbsp;pool)</span></div>
</section>
</li>
<li>
<section class="detail" id="setCoprocessorError(org.apache.hbase.thirdparty.com.google.protobuf.RpcController,java.lang.Throwable)">
<h3>setCoprocessorError</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-652">setCoprocessorError</a></span><wbr><span class="parameters">(org.apache.hbase.thirdparty.com.google.protobuf.RpcController&nbsp;controller,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;error)</span></div>
</section>
</li>
<li>
<section class="detail" id="isUnexpectedPreambleHeaderException(java.io.IOException)">
<h3>isUnexpectedPreambleHeaderException</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name"><a href="../../../../../src-html/org/apache/hadoop/hbase/client/ConnectionUtils.html#line-669">isUnexpectedPreambleHeaderException</a></span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a>&nbsp;e)</span></div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2007&#x2013;2020 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
