<!DOCTYPE HTML>
<html lang="de">
<head>
<!-- Generated by javadoc (17) -->
<title>StormClusterStateImpl (Storm 2.6.2 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.storm.cluster, class: StormClusterStateImpl">
<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/StormClusterStateImpl.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>Nested&nbsp;|&nbsp;</li>
<li>Field&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>Field&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.storm.cluster</a></div>
<h1 title="Class StormClusterStateImpl" class="title">Class StormClusterStateImpl</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/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.storm.cluster.StormClusterStateImpl</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">StormClusterStateImpl</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></span></div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== 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 two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.storm.cluster.IStateStorage,org.apache.storm.assignments.ILocalAssignmentsBackend,org.apache.storm.cluster.ClusterStateContext,boolean)" class="member-name-link">StormClusterStateImpl</a><wbr>(<a href="IStateStorage.html" title="interface in org.apache.storm.cluster">IStateStorage</a>&nbsp;stateStorage,
 <a href="../assignments/ILocalAssignmentsBackend.html" title="interface in org.apache.storm.assignments">ILocalAssignmentsBackend</a>&nbsp;assignmentsassignmentsBackend,
 <a href="ClusterStateContext.html" title="class in org.apache.storm.cluster">ClusterStateContext</a>&nbsp;context,
 boolean&nbsp;shouldCloseStateStorageOnDisconnect)</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-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance 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-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#activateStorm(java.lang.String,org.apache.storm.generated.StormBase,java.util.Map)" class="member-name-link">activateStorm</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/StormBase.html" title="class in org.apache.storm.generated">StormBase</a>&nbsp;stormBase,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#activeKeys()" class="member-name-link">activeKeys</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#activeStorms()" class="member-name-link">activeStorms</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addNimbusHost(java.lang.String,org.apache.storm.generated.NimbusSummary)" class="member-name-link">addNimbusHost</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;nimbusId,
 <a href="../generated/NimbusSummary.html" title="class in org.apache.storm.generated">NimbusSummary</a>&nbsp;nimbusSummary)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long,org.apache.storm.generated.PrivateWorkerKey)" class="member-name-link">addPrivateWorkerKey</a><wbr>(<a href="../generated/WorkerTokenServiceType.html" title="enum in org.apache.storm.generated">WorkerTokenServiceType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId,
 long&nbsp;keyVersion,
 <a href="../generated/PrivateWorkerKey.html" title="class in org.apache.storm.generated">PrivateWorkerKey</a>&nbsp;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Store a new version of a private key.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#assignmentInfo(java.lang.String,java.lang.Runnable)" class="member-name-link">assignmentInfo</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the assignment based on storm id from local backend.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="VersionedData.html" title="class in org.apache.storm.cluster">VersionedData</a>&lt;<a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#assignmentInfoWithVersion(java.lang.String,java.lang.Runnable)" class="member-name-link">assignmentInfoWithVersion</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#assignments(java.lang.Runnable)" class="member-name-link">assignments</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#assignmentsInfo()" class="member-name-link">assignmentsInfo</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get all the topologies assignments mapping stormId -> Assignment from local backend.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#assignmentVersion(java.lang.String,java.lang.Runnable)" class="member-name-link">assignmentVersion</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#backpressureTopologies()" class="member-name-link">backpressureTopologies</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get backpressure topologies.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#blobstore(java.lang.Runnable)" class="member-name-link">blobstore</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#blobstoreInfo(java.lang.String)" class="member-name-link">blobstoreInfo</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;blobKey)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/Credentials.html" title="class in org.apache.storm.generated">Credentials</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#credentials(java.lang.String,java.lang.Runnable)" class="member-name-link">credentials</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#deleteTopologyProfileRequests(java.lang.String,org.apache.storm.generated.ProfileRequest)" class="member-name-link">deleteTopologyProfileRequests</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&nbsp;profileRequest)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#disconnect()" class="member-name-link">disconnect</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/ErrorInfo.html" title="class in org.apache.storm.generated">ErrorInfo</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#errors(java.lang.String,java.lang.String)" class="member-name-link">errors</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;componentId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#errorTopologies()" class="member-name-link">errorTopologies</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../generated/ExecutorInfo.html" title="class in org.apache.storm.generated">ExecutorInfo</a>,<wbr><a href="ExecutorBeat.html" title="class in org.apache.storm.cluster">ExecutorBeat</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#executorBeats(java.lang.String,java.util.Map)" class="member-name-link">executorBeats</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&gt;,<wbr><a href="../generated/NodeInfo.html" title="class in org.apache.storm.generated">NodeInfo</a>&gt;&nbsp;executorNodePort)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">need to take executor->node+port in explicitly so that we don't run into a situation where a long dead worker with a skewed clock
 overrides all the timestamps.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../nimbus/NimbusInfo.html" title="class in org.apache.storm.nimbus">NimbusInfo</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getLeader(java.lang.Runnable)" class="member-name-link">getLeader</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get leader info from state store, which was written when a master gains leadership.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNextPrivateWorkerKeyVersion(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String)" class="member-name-link">getNextPrivateWorkerKeyVersion</a><wbr>(<a href="../generated/WorkerTokenServiceType.html" title="enum in org.apache.storm.generated">WorkerTokenServiceType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the next key version number that should be used for this topology id.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/PrivateWorkerKey.html" title="class in org.apache.storm.generated">PrivateWorkerKey</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long)" class="member-name-link">getPrivateWorkerKey</a><wbr>(<a href="../generated/WorkerTokenServiceType.html" title="enum in org.apache.storm.generated">WorkerTokenServiceType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId,
 long&nbsp;keyVersion)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get a private key used to validate a token is correct.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTopologyProfileRequests(java.lang.String)" class="member-name-link">getTopologyProfileRequests</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/ClusterWorkerHeartbeat.html" title="class in org.apache.storm.generated">ClusterWorkerHeartbeat</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getWorkerHeartbeat(java.lang.String,java.lang.String,java.lang.Long)" class="member-name-link">getWorkerHeartbeat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getWorkerProfileRequests(java.lang.String,org.apache.storm.generated.NodeInfo)" class="member-name-link">getWorkerProfileRequests</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/NodeInfo.html" title="class in org.apache.storm.generated">NodeInfo</a>&nbsp;nodeInfo)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#heartbeatStorms()" class="member-name-link">heartbeatStorms</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#idsOfTopologiesWithPrivateWorkerKeys()" class="member-name-link">idsOfTopologiesWithPrivateWorkerKeys</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get a list of all topologyIds that currently have private worker keys stored, of any kind.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isAssignmentsBackendSynchronized()" class="member-name-link">isAssignmentsBackendSynchronized</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Flag to indicate if the assignments synced successfully, see <a href="IStormClusterState.html#syncRemoteAssignments(java.util.Map)"><code>IStormClusterState.syncRemoteAssignments(Map)</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isPacemakerStateStore()" class="member-name-link">isPacemakerStateStore</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Flag to indicate if the Pacameker is backend store.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#issueCallback(java.util.concurrent.atomic.AtomicReference)" class="member-name-link">issueCallback</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/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/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&gt;&nbsp;cb)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#issueMapCallback(java.util.concurrent.ConcurrentHashMap,java.lang.String)" class="member-name-link">issueMapCallback</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html" title="class or interface in java.util.concurrent" class="external-link">ConcurrentHashMap</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&gt;&nbsp;callbackConcurrentHashMap,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/ErrorInfo.html" title="class in org.apache.storm.generated">ErrorInfo</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#lastError(java.lang.String,java.lang.String)" class="member-name-link">lastError</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;componentId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/NimbusSummary.html" title="class in org.apache.storm.generated">NimbusSummary</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#nimbuses()" class="member-name-link">nimbuses</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#remoteAssignmentInfo(java.lang.String,java.lang.Runnable)" class="member-name-link">remoteAssignmentInfo</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the assignment based on storm id from remote state store, eg: ZK.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeAllPrivateWorkerKeys(java.lang.String)" class="member-name-link">removeAllPrivateWorkerKeys</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Remove all of the worker keys for a given topology.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeBackpressure(java.lang.String)" class="member-name-link">removeBackpressure</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Remove backpressure.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeBlobstoreKey(java.lang.String)" class="member-name-link">removeBlobstoreKey</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;blobKey)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeExpiredPrivateWorkerKeys(java.lang.String)" class="member-name-link">removeExpiredPrivateWorkerKeys</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Remove all keys for the given topology that have expired.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeKeyVersion(java.lang.String)" class="member-name-link">removeKeyVersion</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;blobKey)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeStorm(java.lang.String)" class="member-name-link">removeStorm</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeStormBase(java.lang.String)" class="member-name-link">removeStormBase</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeWorkerBackpressure(java.lang.String,java.lang.String,java.lang.Long)" class="member-name-link">removeWorkerBackpressure</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Remove worker backpressure.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeWorkerHeartbeat(java.lang.String,java.lang.String,java.lang.Long)" class="member-name-link">removeWorkerHeartbeat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#reportError(java.lang.String,java.lang.String,java.lang.String,java.lang.Long,java.lang.Throwable)" class="member-name-link">reportError</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;componentId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port,
 <a href="https://docs.oracle.com/en/java/javase/11/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-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setAssignment(java.lang.String,org.apache.storm.generated.Assignment,java.util.Map)" class="member-name-link">setAssignment</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a>&nbsp;info,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setAssignmentsBackendSynchronized()" class="member-name-link">setAssignmentsBackendSynchronized</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Mark the assignments as synced successfully, see <a href="IStormClusterState.html#isAssignmentsBackendSynchronized()"><code>IStormClusterState.isAssignmentsBackendSynchronized()</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setCredentials(java.lang.String,org.apache.storm.generated.Credentials,java.util.Map)" class="member-name-link">setCredentials</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/Credentials.html" title="class in org.apache.storm.generated">Credentials</a>&nbsp;creds,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setTopologyLogConfig(java.lang.String,org.apache.storm.generated.LogConfig,java.util.Map)" class="member-name-link">setTopologyLogConfig</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/LogConfig.html" title="class in org.apache.storm.generated">LogConfig</a>&nbsp;logConfig,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setupBackpressure(java.lang.String,java.util.Map)" class="member-name-link">setupBackpressure</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Setup backpressure.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setupBlob(java.lang.String,org.apache.storm.nimbus.NimbusInfo,java.lang.Integer)" class="member-name-link">setupBlob</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="../nimbus/NimbusInfo.html" title="class in org.apache.storm.nimbus">NimbusInfo</a>&nbsp;nimbusInfo,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;versionInfo)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setupErrors(java.lang.String,java.util.Map)" class="member-name-link">setupErrors</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setupHeatbeats(java.lang.String,java.util.Map)" class="member-name-link">setupHeatbeats</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setWorkerProfileRequest(java.lang.String,org.apache.storm.generated.ProfileRequest)" class="member-name-link">setWorkerProfileRequest</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&nbsp;profileRequest)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/StormBase.html" title="class in org.apache.storm.generated">StormBase</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#stormBase(java.lang.String,java.lang.Runnable)" class="member-name-link">stormBase</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get a storm base for a topology.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/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-tab2 method-summary-table-tab4"><code><a href="#stormId(java.lang.String)" class="member-name-link">stormId</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get storm id from passed name, null if the name doesn't exist on cluster.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supervisorHeartbeat(java.lang.String,org.apache.storm.generated.SupervisorInfo)" class="member-name-link">supervisorHeartbeat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;supervisorId,
 <a href="../generated/SupervisorInfo.html" title="class in org.apache.storm.generated">SupervisorInfo</a>&nbsp;info)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/SupervisorInfo.html" title="class in org.apache.storm.generated">SupervisorInfo</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supervisorInfo(java.lang.String)" class="member-name-link">supervisorInfo</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;supervisorId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supervisors(java.lang.Runnable)" class="member-name-link">supervisors</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#syncRemoteAssignments(java.util.Map)" class="member-name-link">syncRemoteAssignments</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>byte[]&gt;&nbsp;remote)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sync the remote state store assignments to local backend, used when master gains leadership,
 see <code>org.apache.storm.nimbus.LeaderListenerCallback</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#syncRemoteIds(java.util.Map)" class="member-name-link">syncRemoteIds</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;remote)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sync all the active storm ids of the cluster, used now when master gains leadership.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#teardownHeartbeats(java.lang.String)" class="member-name-link">teardownHeartbeats</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#teardownTopologyErrors(java.lang.String)" class="member-name-link">teardownTopologyErrors</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#topologyBackpressure(java.lang.String,long,java.lang.Runnable)" class="member-name-link">topologyBackpressure</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 long&nbsp;timeoutMs,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Check whether a topology is in throttle-on status or not: if the backpresure/storm-id dir is not empty, this topology has
 throttle-on, otherwise throttle-off.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../generated/LogConfig.html" title="class in org.apache.storm.generated">LogConfig</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#topologyLogConfig(java.lang.String,java.lang.Runnable)" class="member-name-link">topologyLogConfig</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;cb)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#updateStorm(java.lang.String,org.apache.storm.generated.StormBase)" class="member-name-link">updateStorm</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/StormBase.html" title="class in org.apache.storm.generated">StormBase</a>&nbsp;newElems)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">To update this function due to APersistentMap/APersistentSet is clojure's structure.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#workerHeartbeat(java.lang.String,java.lang.String,java.lang.Long,org.apache.storm.generated.ClusterWorkerHeartbeat)" class="member-name-link">workerHeartbeat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port,
 <a href="../generated/ClusterWorkerHeartbeat.html" title="class in org.apache.storm.generated">ClusterWorkerHeartbeat</a>&nbsp;info)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 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/11/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/11/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/11/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/11/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/11/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/11/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/11/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/11/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/11/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/11/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/11/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/11/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>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.storm.cluster.IStormClusterState">Methods inherited from interface&nbsp;org.apache.storm.cluster.<a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></h3>
<code><a href="IStormClusterState.html#allSupervisorInfo()">allSupervisorInfo</a>, <a href="IStormClusterState.html#allSupervisorInfo(java.lang.Runnable)">allSupervisorInfo</a>, <a href="IStormClusterState.html#getTopoId(java.lang.String)">getTopoId</a>, <a href="IStormClusterState.html#topologyBases()">topologyBases</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= 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;(org.apache.storm.cluster.IStateStorage,org.apache.storm.assignments.ILocalAssignmentsBackend,org.apache.storm.cluster.ClusterStateContext,boolean)">
<h3>StormClusterStateImpl</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">StormClusterStateImpl</span><wbr><span class="parameters">(<a href="IStateStorage.html" title="interface in org.apache.storm.cluster">IStateStorage</a>&nbsp;stateStorage,
 <a href="../assignments/ILocalAssignmentsBackend.html" title="interface in org.apache.storm.assignments">ILocalAssignmentsBackend</a>&nbsp;assignmentsassignmentsBackend,
 <a href="ClusterStateContext.html" title="class in org.apache.storm.cluster">ClusterStateContext</a>&nbsp;context,
 boolean&nbsp;shouldCloseStateStorageOnDisconnect)</span>
                      throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a></span></div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a></code></dd>
</dl>
</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="issueCallback(java.util.concurrent.atomic.AtomicReference)">
<h3>issueCallback</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">issueCallback</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/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/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&gt;&nbsp;cb)</span></div>
</section>
</li>
<li>
<section class="detail" id="issueMapCallback(java.util.concurrent.ConcurrentHashMap,java.lang.String)">
<h3>issueMapCallback</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">issueMapCallback</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html" title="class or interface in java.util.concurrent" class="external-link">ConcurrentHashMap</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&gt;&nbsp;callbackConcurrentHashMap,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</span></div>
</section>
</li>
<li>
<section class="detail" id="assignments(java.lang.Runnable)">
<h3>assignments</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">assignments</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#assignments(java.lang.Runnable)">assignments</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="assignmentInfo(java.lang.String,java.lang.Runnable)">
<h3>assignmentInfo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a></span>&nbsp;<span class="element-name">assignmentInfo</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#assignmentInfo(java.lang.String,java.lang.Runnable)">IStormClusterState</a></code></span></div>
<div class="block">Get the assignment based on storm id from local backend.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#assignmentInfo(java.lang.String,java.lang.Runnable)">assignmentInfo</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stormId</code> - topology id</dd>
<dd><code>callback</code> - callback function</dd>
<dt>Returns:</dt>
<dd><a href="../generated/Assignment.html" title="class in org.apache.storm.generated"><code>Assignment</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="remoteAssignmentInfo(java.lang.String,java.lang.Runnable)">
<h3>remoteAssignmentInfo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a></span>&nbsp;<span class="element-name">remoteAssignmentInfo</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#remoteAssignmentInfo(java.lang.String,java.lang.Runnable)">IStormClusterState</a></code></span></div>
<div class="block">Get the assignment based on storm id from remote state store, eg: ZK.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#remoteAssignmentInfo(java.lang.String,java.lang.Runnable)">remoteAssignmentInfo</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stormId</code> - topology id</dd>
<dd><code>callback</code> - callback function</dd>
<dt>Returns:</dt>
<dd><a href="../generated/Assignment.html" title="class in org.apache.storm.generated"><code>Assignment</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="assignmentsInfo()">
<h3>assignmentsInfo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a>&gt;</span>&nbsp;<span class="element-name">assignmentsInfo</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#assignmentsInfo()">IStormClusterState</a></code></span></div>
<div class="block">Get all the topologies assignments mapping stormId -> Assignment from local backend.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#assignmentsInfo()">assignmentsInfo</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Returns:</dt>
<dd>stormId -> Assignment mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="syncRemoteAssignments(java.util.Map)">
<h3>syncRemoteAssignments</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">syncRemoteAssignments</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>byte[]&gt;&nbsp;remote)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#syncRemoteAssignments(java.util.Map)">IStormClusterState</a></code></span></div>
<div class="block">Sync the remote state store assignments to local backend, used when master gains leadership,
 see <code>org.apache.storm.nimbus.LeaderListenerCallback</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#syncRemoteAssignments(java.util.Map)">syncRemoteAssignments</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>remote</code> - assigned assignments for a specific <a href="IStormClusterState.html" title="interface in org.apache.storm.cluster"><code>IStormClusterState</code></a> instance, usually a supervisor/node.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isAssignmentsBackendSynchronized()">
<h3>isAssignmentsBackendSynchronized</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isAssignmentsBackendSynchronized</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#isAssignmentsBackendSynchronized()">IStormClusterState</a></code></span></div>
<div class="block">Flag to indicate if the assignments synced successfully, see <a href="IStormClusterState.html#syncRemoteAssignments(java.util.Map)"><code>IStormClusterState.syncRemoteAssignments(Map)</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#isAssignmentsBackendSynchronized()">isAssignmentsBackendSynchronized</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Returns:</dt>
<dd>true if is synced successfully</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isPacemakerStateStore()">
<h3>isPacemakerStateStore</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isPacemakerStateStore</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#isPacemakerStateStore()">IStormClusterState</a></code></span></div>
<div class="block">Flag to indicate if the Pacameker is backend store.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#isPacemakerStateStore()">isPacemakerStateStore</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Returns:</dt>
<dd>true if Pacemaker is being used as StateStore</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setAssignmentsBackendSynchronized()">
<h3>setAssignmentsBackendSynchronized</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setAssignmentsBackendSynchronized</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#setAssignmentsBackendSynchronized()">IStormClusterState</a></code></span></div>
<div class="block">Mark the assignments as synced successfully, see <a href="IStormClusterState.html#isAssignmentsBackendSynchronized()"><code>IStormClusterState.isAssignmentsBackendSynchronized()</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setAssignmentsBackendSynchronized()">setAssignmentsBackendSynchronized</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="assignmentInfoWithVersion(java.lang.String,java.lang.Runnable)">
<h3>assignmentInfoWithVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="VersionedData.html" title="class in org.apache.storm.cluster">VersionedData</a>&lt;<a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a>&gt;</span>&nbsp;<span class="element-name">assignmentInfoWithVersion</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#assignmentInfoWithVersion(java.lang.String,java.lang.Runnable)">assignmentInfoWithVersion</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="assignmentVersion(java.lang.String,java.lang.Runnable)">
<h3>assignmentVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">assignmentVersion</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span>
                          throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a></span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#assignmentVersion(java.lang.String,java.lang.Runnable)">assignmentVersion</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="blobstoreInfo(java.lang.String)">
<h3>blobstoreInfo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">blobstoreInfo</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;blobKey)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#blobstoreInfo(java.lang.String)">blobstoreInfo</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="nimbuses()">
<h3>nimbuses</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/NimbusSummary.html" title="class in org.apache.storm.generated">NimbusSummary</a>&gt;</span>&nbsp;<span class="element-name">nimbuses</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#nimbuses()">nimbuses</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addNimbusHost(java.lang.String,org.apache.storm.generated.NimbusSummary)">
<h3>addNimbusHost</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addNimbusHost</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;nimbusId,
 <a href="../generated/NimbusSummary.html" title="class in org.apache.storm.generated">NimbusSummary</a>&nbsp;nimbusSummary)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#addNimbusHost(java.lang.String,org.apache.storm.generated.NimbusSummary)">addNimbusHost</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="activeStorms()">
<h3>activeStorms</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">activeStorms</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#activeStorms()">activeStorms</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="stormBase(java.lang.String,java.lang.Runnable)">
<h3>stormBase</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/StormBase.html" title="class in org.apache.storm.generated">StormBase</a></span>&nbsp;<span class="element-name">stormBase</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#stormBase(java.lang.String,java.lang.Runnable)">IStormClusterState</a></code></span></div>
<div class="block">Get a storm base for a topology.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#stormBase(java.lang.String,java.lang.Runnable)">stormBase</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stormId</code> - the id of the topology</dd>
<dd><code>callback</code> - something to call if the data changes (best effort)</dd>
<dt>Returns:</dt>
<dd>the StormBase or null if it is not alive.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="stormId(java.lang.String)">
<h3>stormId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/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">stormId</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormName)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#stormId(java.lang.String)">IStormClusterState</a></code></span></div>
<div class="block">Get storm id from passed name, null if the name doesn't exist on cluster.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#stormId(java.lang.String)">stormId</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stormName</code> - storm name</dd>
<dt>Returns:</dt>
<dd>storm id</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="syncRemoteIds(java.util.Map)">
<h3>syncRemoteIds</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">syncRemoteIds</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;remote)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#syncRemoteIds(java.util.Map)">IStormClusterState</a></code></span></div>
<div class="block">Sync all the active storm ids of the cluster, used now when master gains leadership.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#syncRemoteIds(java.util.Map)">syncRemoteIds</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>remote</code> - stormName -> stormId mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWorkerHeartbeat(java.lang.String,java.lang.String,java.lang.Long)">
<h3>getWorkerHeartbeat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/ClusterWorkerHeartbeat.html" title="class in org.apache.storm.generated">ClusterWorkerHeartbeat</a></span>&nbsp;<span class="element-name">getWorkerHeartbeat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#getWorkerHeartbeat(java.lang.String,java.lang.String,java.lang.Long)">getWorkerHeartbeat</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWorkerProfileRequests(java.lang.String,org.apache.storm.generated.NodeInfo)">
<h3>getWorkerProfileRequests</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&gt;</span>&nbsp;<span class="element-name">getWorkerProfileRequests</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/NodeInfo.html" title="class in org.apache.storm.generated">NodeInfo</a>&nbsp;nodeInfo)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#getWorkerProfileRequests(java.lang.String,org.apache.storm.generated.NodeInfo)">getWorkerProfileRequests</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTopologyProfileRequests(java.lang.String)">
<h3>getTopologyProfileRequests</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&gt;</span>&nbsp;<span class="element-name">getTopologyProfileRequests</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#getTopologyProfileRequests(java.lang.String)">getTopologyProfileRequests</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setWorkerProfileRequest(java.lang.String,org.apache.storm.generated.ProfileRequest)">
<h3>setWorkerProfileRequest</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setWorkerProfileRequest</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&nbsp;profileRequest)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setWorkerProfileRequest(java.lang.String,org.apache.storm.generated.ProfileRequest)">setWorkerProfileRequest</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="deleteTopologyProfileRequests(java.lang.String,org.apache.storm.generated.ProfileRequest)">
<h3>deleteTopologyProfileRequests</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">deleteTopologyProfileRequests</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/ProfileRequest.html" title="class in org.apache.storm.generated">ProfileRequest</a>&nbsp;profileRequest)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#deleteTopologyProfileRequests(java.lang.String,org.apache.storm.generated.ProfileRequest)">deleteTopologyProfileRequests</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="executorBeats(java.lang.String,java.util.Map)">
<h3>executorBeats</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../generated/ExecutorInfo.html" title="class in org.apache.storm.generated">ExecutorInfo</a>,<wbr><a href="ExecutorBeat.html" title="class in org.apache.storm.cluster">ExecutorBeat</a>&gt;</span>&nbsp;<span class="element-name">executorBeats</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&gt;,<wbr><a href="../generated/NodeInfo.html" title="class in org.apache.storm.generated">NodeInfo</a>&gt;&nbsp;executorNodePort)</span></div>
<div class="block">need to take executor->node+port in explicitly so that we don't run into a situation where a long dead worker with a skewed clock
 overrides all the timestamps. By only checking heartbeats with an assigned node+port, and only reading executors from that heartbeat
 that are actually assigned, we avoid situations like that.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#executorBeats(java.lang.String,java.util.Map)">executorBeats</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stormId</code> - topology id</dd>
<dd><code>executorNodePort</code> - executor id -> node + port</dd>
<dt>Returns:</dt>
<dd>mapping of executorInfo -> executor beat</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="supervisors(java.lang.Runnable)">
<h3>supervisors</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">supervisors</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#supervisors(java.lang.Runnable)">supervisors</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="supervisorInfo(java.lang.String)">
<h3>supervisorInfo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/SupervisorInfo.html" title="class in org.apache.storm.generated">SupervisorInfo</a></span>&nbsp;<span class="element-name">supervisorInfo</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;supervisorId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#supervisorInfo(java.lang.String)">supervisorInfo</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setupHeatbeats(java.lang.String,java.util.Map)">
<h3>setupHeatbeats</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setupHeatbeats</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setupHeatbeats(java.lang.String,java.util.Map)">setupHeatbeats</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="teardownHeartbeats(java.lang.String)">
<h3>teardownHeartbeats</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">teardownHeartbeats</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#teardownHeartbeats(java.lang.String)">teardownHeartbeats</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="teardownTopologyErrors(java.lang.String)">
<h3>teardownTopologyErrors</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">teardownTopologyErrors</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#teardownTopologyErrors(java.lang.String)">teardownTopologyErrors</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLeader(java.lang.Runnable)">
<h3>getLeader</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../nimbus/NimbusInfo.html" title="class in org.apache.storm.nimbus">NimbusInfo</a></span>&nbsp;<span class="element-name">getLeader</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#getLeader(java.lang.Runnable)">IStormClusterState</a></code></span></div>
<div class="block">Get leader info from state store, which was written when a master gains leadership.

 <p>Caution: it can not be used for fencing and is only for informational purposes because we use ZK as our
 backend now, which could have a overdue info of nodes.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#getLeader(java.lang.Runnable)">getLeader</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>callback</code> - callback func</dd>
<dt>Returns:</dt>
<dd><a href="../nimbus/NimbusInfo.html" title="class in org.apache.storm.nimbus"><code>NimbusInfo</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="backpressureTopologies()">
<h3>backpressureTopologies</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">backpressureTopologies</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#backpressureTopologies()">IStormClusterState</a></code></span></div>
<div class="block">Get backpressure topologies.
 Note: In Storm 2.0. Retained for enabling transition from 1.x. Will be removed soon.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#backpressureTopologies()">backpressureTopologies</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="heartbeatStorms()">
<h3>heartbeatStorms</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">heartbeatStorms</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#heartbeatStorms()">heartbeatStorms</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="errorTopologies()">
<h3>errorTopologies</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">errorTopologies</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#errorTopologies()">errorTopologies</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setTopologyLogConfig(java.lang.String,org.apache.storm.generated.LogConfig,java.util.Map)">
<h3>setTopologyLogConfig</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setTopologyLogConfig</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/LogConfig.html" title="class in org.apache.storm.generated">LogConfig</a>&nbsp;logConfig,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setTopologyLogConfig(java.lang.String,org.apache.storm.generated.LogConfig,java.util.Map)">setTopologyLogConfig</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="topologyLogConfig(java.lang.String,java.lang.Runnable)">
<h3>topologyLogConfig</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/LogConfig.html" title="class in org.apache.storm.generated">LogConfig</a></span>&nbsp;<span class="element-name">topologyLogConfig</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;cb)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#topologyLogConfig(java.lang.String,java.lang.Runnable)">topologyLogConfig</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="workerHeartbeat(java.lang.String,java.lang.String,java.lang.Long,org.apache.storm.generated.ClusterWorkerHeartbeat)">
<h3>workerHeartbeat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">workerHeartbeat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port,
 <a href="../generated/ClusterWorkerHeartbeat.html" title="class in org.apache.storm.generated">ClusterWorkerHeartbeat</a>&nbsp;info)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#workerHeartbeat(java.lang.String,java.lang.String,java.lang.Long,org.apache.storm.generated.ClusterWorkerHeartbeat)">workerHeartbeat</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeWorkerHeartbeat(java.lang.String,java.lang.String,java.lang.Long)">
<h3>removeWorkerHeartbeat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeWorkerHeartbeat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeWorkerHeartbeat(java.lang.String,java.lang.String,java.lang.Long)">removeWorkerHeartbeat</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="supervisorHeartbeat(java.lang.String,org.apache.storm.generated.SupervisorInfo)">
<h3>supervisorHeartbeat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">supervisorHeartbeat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;supervisorId,
 <a href="../generated/SupervisorInfo.html" title="class in org.apache.storm.generated">SupervisorInfo</a>&nbsp;info)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#supervisorHeartbeat(java.lang.String,org.apache.storm.generated.SupervisorInfo)">supervisorHeartbeat</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="topologyBackpressure(java.lang.String,long,java.lang.Runnable)">
<h3>topologyBackpressure</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">topologyBackpressure</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 long&nbsp;timeoutMs,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<div class="block">Check whether a topology is in throttle-on status or not: if the backpresure/storm-id dir is not empty, this topology has
 throttle-on, otherwise throttle-off. But if the backpresure/storm-id dir is not empty and has not been updated for more than
 timeoutMs, we treat it as throttle-off. This will prevent the spouts from getting stuck indefinitely if something wrong happens.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#topologyBackpressure(java.lang.String,long,java.lang.Runnable)">topologyBackpressure</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stormId</code> - The topology Id</dd>
<dd><code>timeoutMs</code> - How long until the backpressure znode is invalid.</dd>
<dd><code>callback</code> - The callback function</dd>
<dt>Returns:</dt>
<dd>True is backpresure/storm-id dir is not empty and at least one of the backpressure znodes has not timed out; false otherwise.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setupBackpressure(java.lang.String,java.util.Map)">
<h3>setupBackpressure</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setupBackpressure</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#setupBackpressure(java.lang.String,java.util.Map)">IStormClusterState</a></code></span></div>
<div class="block">Setup backpressure.
 Note: In Storm 2.0. Retained for enabling transition from 1.x. Will be removed soon.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setupBackpressure(java.lang.String,java.util.Map)">setupBackpressure</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeBackpressure(java.lang.String)">
<h3>removeBackpressure</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeBackpressure</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#removeBackpressure(java.lang.String)">IStormClusterState</a></code></span></div>
<div class="block">Remove backpressure.
 Note: In Storm 2.0. Retained for enabling transition from 1.x. Will be removed soon.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeBackpressure(java.lang.String)">removeBackpressure</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeWorkerBackpressure(java.lang.String,java.lang.String,java.lang.Long)">
<h3>removeWorkerBackpressure</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeWorkerBackpressure</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#removeWorkerBackpressure(java.lang.String,java.lang.String,java.lang.Long)">IStormClusterState</a></code></span></div>
<div class="block">Remove worker backpressure.
 Note: In Storm 2.0. Retained for enabling transition from 1.x. Will be removed soon.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeWorkerBackpressure(java.lang.String,java.lang.String,java.lang.Long)">removeWorkerBackpressure</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="activateStorm(java.lang.String,org.apache.storm.generated.StormBase,java.util.Map)">
<h3>activateStorm</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">activateStorm</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/StormBase.html" title="class in org.apache.storm.generated">StormBase</a>&nbsp;stormBase,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#activateStorm(java.lang.String,org.apache.storm.generated.StormBase,java.util.Map)">activateStorm</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="updateStorm(java.lang.String,org.apache.storm.generated.StormBase)">
<h3>updateStorm</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">updateStorm</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/StormBase.html" title="class in org.apache.storm.generated">StormBase</a>&nbsp;newElems)</span></div>
<div class="block">To update this function due to APersistentMap/APersistentSet is clojure's structure.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#updateStorm(java.lang.String,org.apache.storm.generated.StormBase)">updateStorm</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeStormBase(java.lang.String)">
<h3>removeStormBase</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeStormBase</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeStormBase(java.lang.String)">removeStormBase</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setAssignment(java.lang.String,org.apache.storm.generated.Assignment,java.util.Map)">
<h3>setAssignment</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setAssignment</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/Assignment.html" title="class in org.apache.storm.generated">Assignment</a>&nbsp;info,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setAssignment(java.lang.String,org.apache.storm.generated.Assignment,java.util.Map)">setAssignment</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setupBlob(java.lang.String,org.apache.storm.nimbus.NimbusInfo,java.lang.Integer)">
<h3>setupBlob</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setupBlob</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="../nimbus/NimbusInfo.html" title="class in org.apache.storm.nimbus">NimbusInfo</a>&nbsp;nimbusInfo,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;versionInfo)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setupBlob(java.lang.String,org.apache.storm.nimbus.NimbusInfo,java.lang.Integer)">setupBlob</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="activeKeys()">
<h3>activeKeys</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">activeKeys</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#activeKeys()">activeKeys</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="blobstore(java.lang.Runnable)">
<h3>blobstore</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">blobstore</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#blobstore(java.lang.Runnable)">blobstore</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeStorm(java.lang.String)">
<h3>removeStorm</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeStorm</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeStorm(java.lang.String)">removeStorm</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeBlobstoreKey(java.lang.String)">
<h3>removeBlobstoreKey</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeBlobstoreKey</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;blobKey)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeBlobstoreKey(java.lang.String)">removeBlobstoreKey</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeKeyVersion(java.lang.String)">
<h3>removeKeyVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeKeyVersion</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;blobKey)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeKeyVersion(java.lang.String)">removeKeyVersion</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setupErrors(java.lang.String,java.util.Map)">
<h3>setupErrors</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setupErrors</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setupErrors(java.lang.String,java.util.Map)">setupErrors</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reportError(java.lang.String,java.lang.String,java.lang.String,java.lang.Long,java.lang.Throwable)">
<h3>reportError</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">reportError</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;componentId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;port,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;error)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#reportError(java.lang.String,java.lang.String,java.lang.String,java.lang.Long,java.lang.Throwable)">reportError</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="errors(java.lang.String,java.lang.String)">
<h3>errors</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../generated/ErrorInfo.html" title="class in org.apache.storm.generated">ErrorInfo</a>&gt;</span>&nbsp;<span class="element-name">errors</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;componentId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#errors(java.lang.String,java.lang.String)">errors</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="lastError(java.lang.String,java.lang.String)">
<h3>lastError</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/ErrorInfo.html" title="class in org.apache.storm.generated">ErrorInfo</a></span>&nbsp;<span class="element-name">lastError</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;componentId)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#lastError(java.lang.String,java.lang.String)">lastError</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setCredentials(java.lang.String,org.apache.storm.generated.Credentials,java.util.Map)">
<h3>setCredentials</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setCredentials</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="../generated/Credentials.html" title="class in org.apache.storm.generated">Credentials</a>&nbsp;creds,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;topoConf)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#setCredentials(java.lang.String,org.apache.storm.generated.Credentials,java.util.Map)">setCredentials</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="credentials(java.lang.String,java.lang.Runnable)">
<h3>credentials</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/Credentials.html" title="class in org.apache.storm.generated">Credentials</a></span>&nbsp;<span class="element-name">credentials</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;stormId,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;callback)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#credentials(java.lang.String,java.lang.Runnable)">credentials</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="disconnect()">
<h3>disconnect</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">disconnect</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#disconnect()">disconnect</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long)">
<h3>getPrivateWorkerKey</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../generated/PrivateWorkerKey.html" title="class in org.apache.storm.generated">PrivateWorkerKey</a></span>&nbsp;<span class="element-name">getPrivateWorkerKey</span><wbr><span class="parameters">(<a href="../generated/WorkerTokenServiceType.html" title="enum in org.apache.storm.generated">WorkerTokenServiceType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId,
 long&nbsp;keyVersion)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#getPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long)">IStormClusterState</a></code></span></div>
<div class="block">Get a private key used to validate a token is correct. This is expected to be called from a privileged daemon, and the ACLs should be
 set up to only allow nimbus and these privileged daemons access to these private keys.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#getPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long)">getPrivateWorkerKey</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>type</code> - the type of service the key is for.</dd>
<dd><code>topologyId</code> - the topology id the key is for.</dd>
<dd><code>keyVersion</code> - the version of the key this is for.</dd>
<dt>Returns:</dt>
<dd>the private key or null if it could not be found.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long,org.apache.storm.generated.PrivateWorkerKey)">
<h3>addPrivateWorkerKey</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addPrivateWorkerKey</span><wbr><span class="parameters">(<a href="../generated/WorkerTokenServiceType.html" title="enum in org.apache.storm.generated">WorkerTokenServiceType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId,
 long&nbsp;keyVersion,
 <a href="../generated/PrivateWorkerKey.html" title="class in org.apache.storm.generated">PrivateWorkerKey</a>&nbsp;key)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#addPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long,org.apache.storm.generated.PrivateWorkerKey)">IStormClusterState</a></code></span></div>
<div class="block">Store a new version of a private key. This is expected to only ever be called from nimbus.  All ACLs however need to be setup to
 allow the given services access to the stored information.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#addPrivateWorkerKey(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String,long,org.apache.storm.generated.PrivateWorkerKey)">addPrivateWorkerKey</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>type</code> - the type of service this key is for.</dd>
<dd><code>topologyId</code> - the topology this key is for</dd>
<dd><code>keyVersion</code> - the version of the key this is for.</dd>
<dd><code>key</code> - the key to store.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNextPrivateWorkerKeyVersion(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String)">
<h3>getNextPrivateWorkerKeyVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getNextPrivateWorkerKeyVersion</span><wbr><span class="parameters">(<a href="../generated/WorkerTokenServiceType.html" title="enum in org.apache.storm.generated">WorkerTokenServiceType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#getNextPrivateWorkerKeyVersion(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String)">IStormClusterState</a></code></span></div>
<div class="block">Get the next key version number that should be used for this topology id. This is expected to only ever be called from nimbus, but it
 is acceptable if the ACLs are setup so that it can work from a privileged daemon for the given service.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#getNextPrivateWorkerKeyVersion(org.apache.storm.generated.WorkerTokenServiceType,java.lang.String)">getNextPrivateWorkerKeyVersion</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>type</code> - the type of service this is for.</dd>
<dd><code>topologyId</code> - the topology id this is for.</dd>
<dt>Returns:</dt>
<dd>the next version number.  It should be 0 for a new topology id/service combination.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeExpiredPrivateWorkerKeys(java.lang.String)">
<h3>removeExpiredPrivateWorkerKeys</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeExpiredPrivateWorkerKeys</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#removeExpiredPrivateWorkerKeys(java.lang.String)">IStormClusterState</a></code></span></div>
<div class="block">Remove all keys for the given topology that have expired. The number of keys should be small enough that doing an exhaustive scan of
 them all is acceptable as there is no guarantee that expiration time and version number are related.  This should be for all service
 types. This is expected to only ever be called from nimbus and some ACLs may be setup so being called from other daemons will cause
 it to fail.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeExpiredPrivateWorkerKeys(java.lang.String)">removeExpiredPrivateWorkerKeys</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>topologyId</code> - the id of the topology to scan.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeAllPrivateWorkerKeys(java.lang.String)">
<h3>removeAllPrivateWorkerKeys</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeAllPrivateWorkerKeys</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;topologyId)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#removeAllPrivateWorkerKeys(java.lang.String)">IStormClusterState</a></code></span></div>
<div class="block">Remove all of the worker keys for a given topology.  Used to clean up after a topology finishes. This is expected to only ever be
 called from nimbus and ideally should only ever work from nimbus.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#removeAllPrivateWorkerKeys(java.lang.String)">removeAllPrivateWorkerKeys</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Parameters:</dt>
<dd><code>topologyId</code> - the topology to clean up after.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="idsOfTopologiesWithPrivateWorkerKeys()">
<h3>idsOfTopologiesWithPrivateWorkerKeys</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">idsOfTopologiesWithPrivateWorkerKeys</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="IStormClusterState.html#idsOfTopologiesWithPrivateWorkerKeys()">IStormClusterState</a></code></span></div>
<div class="block">Get a list of all topologyIds that currently have private worker keys stored, of any kind. This is expected to only ever be called
 from nimbus.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="IStormClusterState.html#idsOfTopologiesWithPrivateWorkerKeys()">idsOfTopologiesWithPrivateWorkerKeys</a></code>&nbsp;in interface&nbsp;<code><a href="IStormClusterState.html" title="interface in org.apache.storm.cluster">IStormClusterState</a></code></dd>
<dt>Returns:</dt>
<dd>the list of topology ids with any kind of private worker key stored.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2023 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
