<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Config (Storm 2.0.0 API)</title>
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="Config (Storm 2.0.0 API)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":9,"i1":10,"i2":9,"i3":10,"i4":10,"i5":9,"i6":9,"i7":10,"i8":10,"i9":10,"i10":9,"i11":9,"i12":9,"i13":10,"i14":10,"i15":9,"i16":9,"i17":9,"i18":10,"i19":10,"i20":9,"i21":10,"i22":9,"i23":10,"i24":9,"i25":10,"i26":9,"i27":10,"i28":9,"i29":10,"i30":9,"i31":10,"i32":9,"i33":10,"i34":9,"i35":10,"i36":9,"i37":10,"i38":9,"i39":10,"i40":9,"i41":10,"i42":9,"i43":10,"i44":10,"i45":10,"i46":10,"i47":9,"i48":10,"i49":10};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Config.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">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev&nbsp;Class</li>
<li><a href="../../../org/apache/storm/Constants.html" title="class in org.apache.storm"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?org/apache/storm/Config.html" target="_top">Frames</a></li>
<li><a href="Config.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested.classes.inherited.from.class.java.util.AbstractMap">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.storm</div>
<h2 title="Class Config" class="title">Class Config</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.html?is-external=true" title="class or interface in java.util">java.util.AbstractMap</a>&lt;K,V&gt;</li>
<li>
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">java.util.HashMap</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;</li>
<li>
<ul class="inheritance">
<li>org.apache.storm.Config</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><a href="https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io">Serializable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Cloneable.html?is-external=true" title="class or interface in java.lang">Cloneable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;</dd>
</dl>
<hr>
<br>
<pre>public class <span class="typeNameLabel">Config</span>
extends <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;</pre>
<div class="block"><p>Topology configs are specified as a plain old map. This class provides a convenient way to create a topology config map by providing setter methods for all the configs that can be set. It also makes it easier to do things like add serializations.</p><p>This class also provides constants for all the configurations possible on a Storm cluster and Storm topology. Each constant is paired with an annotation that defines the validity criterion of the corresponding field. Default values for these configs can be found in defaults.yaml.</p><p>Note that you may put other configurations in any of the configs. Storm will ignore anything it doesn&rsquo;t recognize, but your topologies are free to make use of them by reading them in the prepare method of Bolts or the open method of Spouts.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../serialized-form.html#org.apache.storm.Config">Serialized Form</a></dd>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="nested.class.summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<ul class="blockList">
<li class="blockList"><a name="nested.classes.inherited.from.class.java.util.AbstractMap">
<!--   -->
</a>
<h3>Nested classes/interfaces inherited from class&nbsp;java.util.<a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.html?is-external=true" title="class or interface in java.util">AbstractMap</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.SimpleEntry.html?is-external=true" title="class or interface in java.util">AbstractMap.SimpleEntry</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.SimpleEntry.html?is-external=true" title="class or interface in java.util">K</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.SimpleEntry.html?is-external=true" title="class or interface in java.util">V</a>&gt;, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.SimpleImmutableEntry.html?is-external=true" title="class or interface in java.util">AbstractMap.SimpleImmutableEntry</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.SimpleImmutableEntry.html?is-external=true" title="class or interface in java.util">K</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.SimpleImmutableEntry.html?is-external=true" title="class or interface in java.util">V</a>&gt;</code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a name="nested.classes.inherited.from.class.java.util.Map">
<!--   -->
</a>
<h3>Nested classes/interfaces inherited from interface&nbsp;java.util.<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html?is-external=true" title="class or interface in java.util">Map.Entry</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html?is-external=true" title="class or interface in java.util">K</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html?is-external=true" title="class or interface in java.util">V</a>&gt;</code></li>
</ul>
</li>
</ul>
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#BLOBSTORE_CLEANUP_ENABLE">BLOBSTORE_CLEANUP_ENABLE</a></span></code>
<div class="block">Enable the blobstore cleaner.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#BLOBSTORE_DIR">BLOBSTORE_DIR</a></span></code>
<div class="block">What directory to use for the blobstore.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#BLOBSTORE_HDFS_KEYTAB">BLOBSTORE_HDFS_KEYTAB</a></span></code>
<div class="block">keytab for nimbus/supervisor to use to access secure hdfs for the blobstore.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#BLOBSTORE_HDFS_PRINCIPAL">BLOBSTORE_HDFS_PRINCIPAL</a></span></code>
<div class="block">principal for nimbus/supervisor to use to access secure hdfs for the blobstore.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#CLIENT_BLOBSTORE">CLIENT_BLOBSTORE</a></span></code>
<div class="block">What blobstore implementation the storm client should use.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DISABLE_SYMLINKS">DISABLE_SYMLINKS</a></span></code>
<div class="block">On some systems (windows for example) symlinks require special privileges that not everyone wants to grant a headless user.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_AUTHORIZER_ACL">DRPC_AUTHORIZER_ACL</a></span></code>
<div class="block">The Access Control List for the DRPC Authorizer.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_AUTHORIZER_ACL_FILENAME">DRPC_AUTHORIZER_ACL_FILENAME</a></span></code>
<div class="block">File name of the DRPC Authorizer ACL.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_AUTHORIZER_ACL_STRICT">DRPC_AUTHORIZER_ACL_STRICT</a></span></code>
<div class="block">Whether the DRPCSimpleAclAuthorizer should deny requests for operations involving functions that have no explicit ACL entry.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_INVOCATIONS_PORT">DRPC_INVOCATIONS_PORT</a></span></code>
<div class="block">This port on Storm DRPC is used by DRPC topologies to receive function invocations and send results back.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_INVOCATIONS_THREADS">DRPC_INVOCATIONS_THREADS</a></span></code>
<div class="block">DRPC invocations thrift server worker threads</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_INVOCATIONS_THRIFT_TRANSPORT_PLUGIN">DRPC_INVOCATIONS_THRIFT_TRANSPORT_PLUGIN</a></span></code>
<div class="block">The DRPC invocations transport plug-in for Thrift client/server communication</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_MAX_BUFFER_SIZE">DRPC_MAX_BUFFER_SIZE</a></span></code>
<div class="block">The maximum buffer size thrift should use when reading messages for DRPC.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_PORT">DRPC_PORT</a></span></code>
<div class="block">This port is used by Storm DRPC for receiving DPRC requests from clients.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_QUEUE_SIZE">DRPC_QUEUE_SIZE</a></span></code>
<div class="block">DRPC thrift server queue size</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_SERVERS">DRPC_SERVERS</a></span></code>
<div class="block">List of DRPC servers so that the DRPCSpout knows who to talk to.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_THRIFT_TRANSPORT_PLUGIN">DRPC_THRIFT_TRANSPORT_PLUGIN</a></span></code>
<div class="block">The DRPC transport plug-in for Thrift client/server communication</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#DRPC_WORKER_THREADS">DRPC_WORKER_THREADS</a></span></code>
<div class="block">DRPC thrift server worker threads</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#EXECUTOR_METRICS_FREQUENCY_SECS">EXECUTOR_METRICS_FREQUENCY_SECS</a></span></code>
<div class="block">How often executor metrics should report to master, used for RPC heartbeat mode.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_ADMINS">NIMBUS_ADMINS</a></span></code>
<div class="block">A list of users that are cluster admins and can run any command.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_ADMINS_GROUPS">NIMBUS_ADMINS_GROUPS</a></span></code>
<div class="block">A list of groups that are cluster admins and can run any command.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_AUTO_CRED_PLUGINS">NIMBUS_AUTO_CRED_PLUGINS</a></span></code>
<div class="block">A list of plugins that nimbus should load during submit topology to populate credentials on user&rsquo;s behalf.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_CREDENTIAL_RENEWERS">NIMBUS_CREDENTIAL_RENEWERS</a></span></code>
<div class="block">A list of credential renewers that nimbus should load.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_DAEMON_USERS">NIMBUS_DAEMON_USERS</a></span></code>
<div class="block">A list of users that nimbus runs as and should be authorized to interact with the supervisor as nimbus would.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_GROUPS">NIMBUS_GROUPS</a></span></code>
<div class="block">A list of groups , users belong to these groups are the only ones allowed to run user operation on storm cluster.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_IMPERSONATION_ACL">NIMBUS_IMPERSONATION_ACL</a></span></code>
<div class="block">Impersonation user ACL config entries.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_LOCAL_ASSIGNMENTS_BACKEND_CLASS">NIMBUS_LOCAL_ASSIGNMENTS_BACKEND_CLASS</a></span></code>
<div class="block">Nimbus assignments backend for storing local assignments.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_QUEUE_SIZE">NIMBUS_QUEUE_SIZE</a></span></code>
<div class="block">Nimbus thrift server queue size, default is 100000.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_SCHEDULER_STRATEGY_CLASS_WHITELIST">NIMBUS_SCHEDULER_STRATEGY_CLASS_WHITELIST</a></span></code>
<div class="block">A whitelist of the RAS scheduler strategies allowed by nimbus.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_SEEDS">NIMBUS_SEEDS</a></span></code>
<div class="block">List of seed nimbus hosts to use for leader nimbus discovery.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_SUPERVISOR_USERS">NIMBUS_SUPERVISOR_USERS</a></span></code>
<div class="block">A list of users that run the supervisors and should be authorized to interact with nimbus as a supervisor would.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_THRIFT_MAX_BUFFER_SIZE">NIMBUS_THRIFT_MAX_BUFFER_SIZE</a></span></code>
<div class="block">The maximum buffer size thrift should use when reading messages.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_THRIFT_PORT">NIMBUS_THRIFT_PORT</a></span></code>
<div class="block">Which port the Thrift interface of Nimbus should run on.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_THRIFT_THREADS">NIMBUS_THRIFT_THREADS</a></span></code>
<div class="block">The number of threads that should be used by the nimbus thrift server.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_THRIFT_TRANSPORT_PLUGIN">NIMBUS_THRIFT_TRANSPORT_PLUGIN</a></span></code>
<div class="block">The Nimbus transport plug-in for Thrift client/server communication</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NIMBUS_USERS">NIMBUS_USERS</a></span></code>
<div class="block">A list of users that are the only ones allowed to run user operation on storm cluster.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#NUM_STAT_BUCKETS">NUM_STAT_BUCKETS</a></span></code>
<div class="block">The number of Buckets</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#PACEMAKER_AUTH_METHOD">PACEMAKER_AUTH_METHOD</a></span></code>
<div class="block">This should be one of &ldquo;DIGEST&rdquo;, &ldquo;KERBEROS&rdquo;, or &ldquo;NONE&rdquo; Determines the mode of authentication the pacemaker server and client use.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#PACEMAKER_CLIENT_MAX_THREADS">PACEMAKER_CLIENT_MAX_THREADS</a></span></code>
<div class="block">The maximum number of threads that should be used by the Pacemaker client.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#PACEMAKER_PORT">PACEMAKER_PORT</a></span></code>
<div class="block">The port Pacemaker should run on.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#PACEMAKER_SERVERS">PACEMAKER_SERVERS</a></span></code>
<div class="block">The list of servers that Pacemaker is running on.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#PACEMAKER_THRIFT_MESSAGE_SIZE_MAX">PACEMAKER_THRIFT_MESSAGE_SIZE_MAX</a></span></code>
<div class="block">Pacemaker Thrift Max Message Size (bytes).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_BLOBSTORE_ACL_VALIDATION_ENABLED">STORM_BLOBSTORE_ACL_VALIDATION_ENABLED</a></span></code>
<div class="block">For secure mode we would want to turn on this config By default this is turned off assuming the default is insecure</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_BLOBSTORE_INPUTSTREAM_BUFFER_SIZE_BYTES">STORM_BLOBSTORE_INPUTSTREAM_BUFFER_SIZE_BYTES</a></span></code>
<div class="block">What buffer size to use for the blobstore uploads.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_BLOBSTORE_REPLICATION_FACTOR">STORM_BLOBSTORE_REPLICATION_FACTOR</a></span></code>
<div class="block">Set replication factor for a blob in HDFS Blobstore Implementation</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_CGROUP_HIERARCHY_DIR">STORM_CGROUP_HIERARCHY_DIR</a></span></code>
<div class="block">root directory of the storm cgroup hierarchy</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_CLUSTER_MODE">STORM_CLUSTER_MODE</a></span></code>
<div class="block">The mode this Storm cluster is running in.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_CLUSTER_STATE_STORE">STORM_CLUSTER_STATE_STORE</a></span></code>
<div class="block">The ClusterState factory that worker will use to create a ClusterState to store state in.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_DAEMON_METRICS_REPORTER_PLUGIN_DURATION_UNIT">STORM_DAEMON_METRICS_REPORTER_PLUGIN_DURATION_UNIT</a></span></code>
<div class="block">A specify duration-unit in TimeUnit to specify reporting window for daemon metrics reporter plugin.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_DAEMON_METRICS_REPORTER_PLUGIN_LOCALE">STORM_DAEMON_METRICS_REPORTER_PLUGIN_LOCALE</a></span></code>
<div class="block">A specify Locale for daemon metrics reporter plugin.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_DAEMON_METRICS_REPORTER_PLUGIN_RATE_UNIT">STORM_DAEMON_METRICS_REPORTER_PLUGIN_RATE_UNIT</a></span></code>
<div class="block">A specify rate-unit in TimeUnit to specify reporting frequency for daemon metrics reporter plugin.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_DO_AS_USER">STORM_DO_AS_USER</a></span></code>
<div class="block">The user as which the nimbus client should be acquired to perform the operation.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_EXHIBITOR_POLL">STORM_EXHIBITOR_POLL</a></span></code>
<div class="block">How often to poll Exhibitor cluster in millis.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_EXHIBITOR_PORT">STORM_EXHIBITOR_PORT</a></span></code>
<div class="block">The port Storm will use to connect to each of the exhibitor servers.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_EXHIBITOR_RETRY_INTERVAL">STORM_EXHIBITOR_RETRY_INTERVAL</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_EXHIBITOR_RETRY_INTERVAL_CEILING">STORM_EXHIBITOR_RETRY_INTERVAL_CEILING</a></span></code>
<div class="block">The ceiling of the interval between retries of an Exhibitor operation.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_EXHIBITOR_RETRY_TIMES">STORM_EXHIBITOR_RETRY_TIMES</a></span></code>
<div class="block">The number of times to retry an Exhibitor operation.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_EXHIBITOR_SERVERS">STORM_EXHIBITOR_SERVERS</a></span></code>
<div class="block">A list of hosts of Exhibitor servers used to discover/maintain connection to ZooKeeper cluster.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_EXHIBITOR_URIPATH">STORM_EXHIBITOR_URIPATH</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_GROUP_MAPPING_SERVICE_CACHE_DURATION_SECS">STORM_GROUP_MAPPING_SERVICE_CACHE_DURATION_SECS</a></span></code>
<div class="block">Max no.of seconds group mapping service will cache user groups</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_GROUP_MAPPING_SERVICE_PARAMS">STORM_GROUP_MAPPING_SERVICE_PARAMS</a></span></code>
<div class="block">Initialization parameters for the group mapping service plugin.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_GROUP_MAPPING_SERVICE_PROVIDER_PLUGIN">STORM_GROUP_MAPPING_SERVICE_PROVIDER_PLUGIN</a></span></code>
<div class="block">The plugin that will provide user groups service</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ID">STORM_ID</a></span></code>
<div class="block">The id assigned to a running topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_LOCAL_DIR">STORM_LOCAL_DIR</a></span></code>
<div class="block">A directory on the local filesystem used by Storm for any local filesystem usage it needs.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_LOCAL_HOSTNAME">STORM_LOCAL_HOSTNAME</a></span></code>
<div class="block">The hostname the supervisors/workers should report to nimbus.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_LOCAL_MODE_ZMQ">STORM_LOCAL_MODE_ZMQ</a></span></code>
<div class="block">Whether or not to use ZeroMQ for messaging in local mode.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_AUTHENTICATION">STORM_MESSAGING_NETTY_AUTHENTICATION</a></span></code>
<div class="block">Netty based messaging: Is authentication required for Netty messaging from client worker process to server worker process.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_BUFFER_HIGH_WATERMARK">STORM_MESSAGING_NETTY_BUFFER_HIGH_WATERMARK</a></span></code>
<div class="block">Netty based messaging: The netty write buffer high watermark in bytes.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_BUFFER_LOW_WATERMARK">STORM_MESSAGING_NETTY_BUFFER_LOW_WATERMARK</a></span></code>
<div class="block">Netty based messaging: The netty write buffer low watermark in bytes.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_BUFFER_SIZE">STORM_MESSAGING_NETTY_BUFFER_SIZE</a></span></code>
<div class="block">Netty based messaging: The buffer size for send/recv buffer</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_CLIENT_WORKER_THREADS">STORM_MESSAGING_NETTY_CLIENT_WORKER_THREADS</a></span></code>
<div class="block">Netty based messaging: The # of worker threads for the client.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_MAX_SLEEP_MS">STORM_MESSAGING_NETTY_MAX_SLEEP_MS</a></span></code>
<div class="block">Netty based messaging: The max # of milliseconds that a peer will wait.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_MIN_SLEEP_MS">STORM_MESSAGING_NETTY_MIN_SLEEP_MS</a></span></code>
<div class="block">Netty based messaging: The min # of milliseconds that a peer will wait.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS">STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS</a></span></code>
<div class="block">Netty based messaging: The # of worker threads for the server.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_SOCKET_BACKLOG">STORM_MESSAGING_NETTY_SOCKET_BACKLOG</a></span></code>
<div class="block">Netty based messaging: Sets the backlog value to specify when the channel binds to a local address</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_TRANSPORT">STORM_MESSAGING_TRANSPORT</a></span></code>
<div class="block">The transporter for communication among Storm tasks</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_META_SERIALIZATION_DELEGATE">STORM_META_SERIALIZATION_DELEGATE</a></span></code>
<div class="block">The delegate for serializing metadata, should be used for serialized objects stored in zookeeper and on disk.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_METRICS_REPORTERS">STORM_METRICS_REPORTERS</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_NETTY_MESSAGE_BATCH_SIZE">STORM_NETTY_MESSAGE_BATCH_SIZE</a></span></code>
<div class="block">If the Netty messaging layer is busy, the Netty client will try to batch message as more as possible up to the size of STORM_NETTY_MESSAGE_BATCH_SIZE bytes</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_NETWORK_TOPOGRAPHY_PLUGIN">STORM_NETWORK_TOPOGRAPHY_PLUGIN</a></span></code>
<div class="block">What Network Topography detection classes should we use.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_NIMBUS_RETRY_INTERVAL">STORM_NIMBUS_RETRY_INTERVAL</a></span></code>
<div class="block">The starting interval between exponential backoff retries of a Nimbus operation.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_NIMBUS_RETRY_INTERVAL_CEILING">STORM_NIMBUS_RETRY_INTERVAL_CEILING</a></span></code>
<div class="block">The ceiling of the interval between retries of a client connect to Nimbus operation.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_NIMBUS_RETRY_TIMES">STORM_NIMBUS_RETRY_TIMES</a></span></code>
<div class="block">The number of times to retry a Nimbus operation.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_PRINCIPAL_TO_LOCAL_PLUGIN">STORM_PRINCIPAL_TO_LOCAL_PLUGIN</a></span></code>
<div class="block">The plugin that will convert a principal to a local user.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_THRIFT_SOCKET_TIMEOUT_MS">STORM_THRIFT_SOCKET_TIMEOUT_MS</a></span></code>
<div class="block">How long before a Thrift Client socket hangs before timeout and restart the socket.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_THRIFT_TRANSPORT_PLUGIN">STORM_THRIFT_TRANSPORT_PLUGIN</a></span></code>
<div class="block">The default transport plug-in for Thrift client/server communication</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_TOPOLOGY_SUBMISSION_NOTIFIER_PLUGIN">STORM_TOPOLOGY_SUBMISSION_NOTIFIER_PLUGIN</a></span></code>
<div class="block">FQCN of a class that implements <code>ISubmitterHook</code> @see ISubmitterHook for details.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_WORKERS_ARTIFACTS_DIR">STORM_WORKERS_ARTIFACTS_DIR</a></span></code>
<div class="block">The workers-artifacts directory (where we place all workers&rsquo; logs), can be either absolute or relative.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_AUTH_PAYLOAD">STORM_ZOOKEEPER_AUTH_PAYLOAD</a></span></code>
<div class="block">A string representing the payload for cluster Zookeeper authentication.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_AUTH_SCHEME">STORM_ZOOKEEPER_AUTH_SCHEME</a></span></code>
<div class="block">The cluster Zookeeper authentication scheme to use, e.g.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_CONNECTION_TIMEOUT">STORM_ZOOKEEPER_CONNECTION_TIMEOUT</a></span></code>
<div class="block">The connection timeout for clients to ZooKeeper.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_DRPC_ACL">STORM_ZOOKEEPER_DRPC_ACL</a></span></code>
<div class="block">The ACL of the drpc user in zookeeper so the drpc servers can verify worker tokens.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_PORT">STORM_ZOOKEEPER_PORT</a></span></code>
<div class="block">The port Storm will use to connect to each of the ZooKeeper servers.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_RETRY_INTERVAL">STORM_ZOOKEEPER_RETRY_INTERVAL</a></span></code>
<div class="block">The interval between retries of a Zookeeper operation.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_RETRY_INTERVAL_CEILING">STORM_ZOOKEEPER_RETRY_INTERVAL_CEILING</a></span></code>
<div class="block">The ceiling of the interval between retries of a Zookeeper operation.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_RETRY_TIMES">STORM_ZOOKEEPER_RETRY_TIMES</a></span></code>
<div class="block">The number of times to retry a Zookeeper operation.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_ROOT">STORM_ZOOKEEPER_ROOT</a></span></code>
<div class="block">The root location at which Storm stores data in ZooKeeper.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_SERVERS">STORM_ZOOKEEPER_SERVERS</a></span></code>
<div class="block">A list of hosts of ZooKeeper servers used to manage the cluster.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_SESSION_TIMEOUT">STORM_ZOOKEEPER_SESSION_TIMEOUT</a></span></code>
<div class="block">The session timeout for clients to ZooKeeper.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_SUPERACL">STORM_ZOOKEEPER_SUPERACL</a></span></code>
<div class="block">This is part of a temporary workaround to a ZK bug, it is the &lsquo;scheme:acl&rsquo; for the user Nimbus and Supervisors use to authenticate with ZK.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_TOPOLOGY_AUTH_PAYLOAD">STORM_ZOOKEEPER_TOPOLOGY_AUTH_PAYLOAD</a></span></code>
<div class="block">A string representing the payload for topology Zookeeper authentication.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#STORM_ZOOKEEPER_TOPOLOGY_AUTH_SCHEME">STORM_ZOOKEEPER_TOPOLOGY_AUTH_SCHEME</a></span></code>
<div class="block">The topology Zookeeper authentication scheme to use, e.g.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_CPU_CAPACITY">SUPERVISOR_CPU_CAPACITY</a></span></code>
<div class="block">The total amount of CPU resources a supervisor is allowed to give to its workers.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_MEMORY_CAPACITY_MB">SUPERVISOR_MEMORY_CAPACITY_MB</a></span></code>
<div class="block">The total amount of memory (in MiB) a supervisor is allowed to give to its workers.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_QUEUE_SIZE">SUPERVISOR_QUEUE_SIZE</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_RESOURCES_MAP">SUPERVISOR_RESOURCES_MAP</a></span></code>
<div class="block">A map of resources the Supervisor has e.g {&ldquo;cpu.pcore.percent&rdquo; : 200.0.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_RUN_WORKER_AS_USER">SUPERVISOR_RUN_WORKER_AS_USER</a></span></code>
<div class="block">Should the supervior try to run the worker as the lauching user or not.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_THRIFT_MAX_BUFFER_SIZE">SUPERVISOR_THRIFT_MAX_BUFFER_SIZE</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_THRIFT_PORT">SUPERVISOR_THRIFT_PORT</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_THRIFT_SOCKET_TIMEOUT_MS">SUPERVISOR_THRIFT_SOCKET_TIMEOUT_MS</a></span></code>
<div class="block">How long before a supervisor Thrift Client socket hangs before timeout and restart the socket.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_THRIFT_THREADS">SUPERVISOR_THRIFT_THREADS</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_THRIFT_TRANSPORT_PLUGIN">SUPERVISOR_THRIFT_TRANSPORT_PLUGIN</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_DEFAULT_VERSION">SUPERVISOR_WORKER_DEFAULT_VERSION</a></span></code>
<div class="block">The version of storm to assume a topology should run as if not version is given by the client when submitting the topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_HEARTBEATS_MAX_TIMEOUT_SECS">SUPERVISOR_WORKER_HEARTBEATS_MAX_TIMEOUT_SECS</a></span></code>
<div class="block">max timeout for supervisor reported heartbeats when master gains leadership</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_LAUNCHER">SUPERVISOR_WORKER_LAUNCHER</a></span></code>
<div class="block">Full path to the worker-laucher executable that will be used to lauch workers when SUPERVISOR_RUN_WORKER_AS_USER is set to true.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_SHUTDOWN_SLEEP_SECS">SUPERVISOR_WORKER_SHUTDOWN_SLEEP_SECS</a></span></code>
<div class="block">How many seconds to allow for graceful worker shutdown when killing workers before resorting to force kill.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_TIMEOUT_SECS">SUPERVISOR_WORKER_TIMEOUT_SECS</a></span></code>
<div class="block">How long a worker can go without heartbeating before the supervisor tries to restart the worker process.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP">SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP</a></span></code>
<div class="block">Map a version of storm to a worker classpath that can be used to run it.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_VERSION_LOGWRITER_MAP">SUPERVISOR_WORKER_VERSION_LOGWRITER_MAP</a></span></code>
<div class="block">Map a version of storm to a worker&rsquo;s logwriter class.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#SUPERVISOR_WORKER_VERSION_MAIN_MAP">SUPERVISOR_WORKER_VERSION_MAIN_MAP</a></span></code>
<div class="block">Map a version of storm to a worker&rsquo;s main class.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TASK_CREDENTIALS_POLL_SECS">TASK_CREDENTIALS_POLL_SECS</a></span></code>
<div class="block">How often a task should sync credentials, worst case.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TASK_HEARTBEAT_FREQUENCY_SECS">TASK_HEARTBEAT_FREQUENCY_SECS</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TASK_REFRESH_POLL_SECS">TASK_REFRESH_POLL_SECS</a></span></code>
<div class="block">How often a task should sync its connections with other tasks (if a task is reassigned, the other tasks sending messages to it need to refresh their connections).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ACKER_CPU_PCORE_PERCENT">TOPOLOGY_ACKER_CPU_PCORE_PERCENT</a></span></code>
<div class="block">The config indicates the percentage of cpu for a core an instance(executor) of an acker will use.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ACKER_EXECUTORS">TOPOLOGY_ACKER_EXECUTORS</a></span></code>
<div class="block">How many executors to spawn for ackers.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ACKER_RESOURCES_OFFHEAP_MEMORY_MB">TOPOLOGY_ACKER_RESOURCES_OFFHEAP_MEMORY_MB</a></span></code>
<div class="block">The maximum amount of memory an instance of an acker will take off heap.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ACKER_RESOURCES_ONHEAP_MEMORY_MB">TOPOLOGY_ACKER_RESOURCES_ONHEAP_MEMORY_MB</a></span></code>
<div class="block">The maximum amount of memory an instance of an acker will take on heap.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_AUTO_CREDENTIALS">TOPOLOGY_AUTO_CREDENTIALS</a></span></code>
<div class="block">A list of IAutoCredentials that the topology should load and use.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_AUTO_TASK_HOOKS">TOPOLOGY_AUTO_TASK_HOOKS</a></span></code>
<div class="block">A list of task hooks that are automatically added to every spout and bolt in the topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BACKPRESSURE_CHECK_MILLIS">TOPOLOGY_BACKPRESSURE_CHECK_MILLIS</a></span></code>
<div class="block">How often a worker should check and notify upstream workers about its tasks that are no longer experiencing BP and able to receive new messages</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BACKPRESSURE_ENABLE">TOPOLOGY_BACKPRESSURE_ENABLE</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BACKPRESSURE_WAIT_PARK_MICROSEC">TOPOLOGY_BACKPRESSURE_WAIT_PARK_MICROSEC</a></span></code>
<div class="block">Configures park time if using WaitStrategyPark for BackPressure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL1_COUNT">TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL1_COUNT</a></span></code>
<div class="block">Configures steps used to determine progression to the next level of wait ..</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL2_COUNT">TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL2_COUNT</a></span></code>
<div class="block">Configures steps used to determine progression to the next level of wait ..</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</a></span></code>
<div class="block">Configures sleep time if using WaitStrategyProgressive for BackPressure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BACKPRESSURE_WAIT_STRATEGY">TOPOLOGY_BACKPRESSURE_WAIT_STRATEGY</a></span></code>
<div class="block">A class that implements a wait strategy for an upstream component (spout/bolt) trying to write to a downstream component whose recv queue is full</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BATCH_FLUSH_INTERVAL_MILLIS">TOPOLOGY_BATCH_FLUSH_INTERVAL_MILLIS</a></span></code>
<div class="block">How often to send flush tuple to the executors for flushing out batched events.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BLOBSTORE_MAP">TOPOLOGY_BLOBSTORE_MAP</a></span></code>
<div class="block">A map with blobstore keys mapped to each filename the worker will have access to in the launch directory to the blob by local file name, uncompress flag, and if the worker should restart when the blob is updated.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLT_WAIT_PARK_MICROSEC">TOPOLOGY_BOLT_WAIT_PARK_MICROSEC</a></span></code>
<div class="block">Configures park time for WaitStrategyPark.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL1_COUNT">TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL1_COUNT</a></span></code>
<div class="block">Configures number of iterations to spend in level 1 of WaitStrategyProgressive, before progressing to level 2</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL2_COUNT">TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL2_COUNT</a></span></code>
<div class="block">Configures number of iterations to spend in level 2 of WaitStrategyProgressive, before progressing to level 3</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</a></span></code>
<div class="block">Configures sleep time for WaitStrategyProgressive.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLT_WAIT_STRATEGY">TOPOLOGY_BOLT_WAIT_STRATEGY</a></span></code>
<div class="block">Selects the Bolt&rsquo;s Wait Strategy to use when there are no incoming msgs.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_LATE_TUPLE_STREAM">TOPOLOGY_BOLTS_LATE_TUPLE_STREAM</a></span></code>
<div class="block">Bolt-specific configuration for windowed bolts to specify the name of the stream on which late tuples are going to be emitted.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_MESSAGE_ID_FIELD_NAME">TOPOLOGY_BOLTS_MESSAGE_ID_FIELD_NAME</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_SLIDING_INTERVAL_COUNT">TOPOLOGY_BOLTS_SLIDING_INTERVAL_COUNT</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_SLIDING_INTERVAL_DURATION_MS">TOPOLOGY_BOLTS_SLIDING_INTERVAL_DURATION_MS</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_TUPLE_TIMESTAMP_MAX_LAG_MS">TOPOLOGY_BOLTS_TUPLE_TIMESTAMP_MAX_LAG_MS</a></span></code>
<div class="block">Bolt-specific configuration for windowed bolts to specify the maximum time lag of the tuple timestamp in milliseconds.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_WATERMARK_EVENT_INTERVAL_MS">TOPOLOGY_BOLTS_WATERMARK_EVENT_INTERVAL_MS</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_WINDOW_LENGTH_COUNT">TOPOLOGY_BOLTS_WINDOW_LENGTH_COUNT</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BOLTS_WINDOW_LENGTH_DURATION_MS">TOPOLOGY_BOLTS_WINDOW_LENGTH_DURATION_MS</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS">TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS</a></span></code>
<div class="block">The time period that builtin metrics data in bucketed into.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_CLASSPATH">TOPOLOGY_CLASSPATH</a></span></code>
<div class="block">Topology-specific classpath for the worker child process.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_CLASSPATH_BEGINNING">TOPOLOGY_CLASSPATH_BEGINNING</a></span></code>
<div class="block">Topology-specific classpath for the worker child process.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_COMPONENT_CPU_PCORE_PERCENT">TOPOLOGY_COMPONENT_CPU_PCORE_PERCENT</a></span></code>
<div class="block">The config indicates the percentage of cpu for a core an instance(executor) of a component will use.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_COMPONENT_RESOURCES_MAP">TOPOLOGY_COMPONENT_RESOURCES_MAP</a></span></code>
<div class="block">A map of resources used by each component e.g {&ldquo;cpu.pcore.percent&rdquo; : 200.0.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_COMPONENT_RESOURCES_OFFHEAP_MEMORY_MB">TOPOLOGY_COMPONENT_RESOURCES_OFFHEAP_MEMORY_MB</a></span></code>
<div class="block">The maximum amount of memory an instance of a spout/bolt will take off heap.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_COMPONENT_RESOURCES_ONHEAP_MEMORY_MB">TOPOLOGY_COMPONENT_RESOURCES_ONHEAP_MEMORY_MB</a></span></code>
<div class="block">The maximum amount of memory an instance of a spout/bolt will take on heap.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_DEBUG">TOPOLOGY_DEBUG</a></span></code>
<div class="block">When set to true, Storm will log every message that&rsquo;s emitted.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_DISABLE_LOADAWARE_MESSAGING">TOPOLOGY_DISABLE_LOADAWARE_MESSAGING</a></span></code>
<div class="block">Disable load aware grouping support.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ENABLE_MESSAGE_TIMEOUTS">TOPOLOGY_ENABLE_MESSAGE_TIMEOUTS</a></span></code>
<div class="block">True if Storm should timeout messages or not.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ENVIRONMENT">TOPOLOGY_ENVIRONMENT</a></span></code>
<div class="block">Topology-specific environment variables for the worker child process.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS">TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS</a></span></code>
<div class="block">The interval in seconds to use for determining whether to throttle error reported to Zookeeper.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_EVENT_LOGGER_REGISTER">TOPOLOGY_EVENT_LOGGER_REGISTER</a></span></code>
<div class="block">A list of classes implementing IEventLogger (See storm.yaml.example for exact config format).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_EVENTLOGGER_EXECUTORS">TOPOLOGY_EVENTLOGGER_EXECUTORS</a></span></code>
<div class="block">How many executors to spawn for event logger.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_EXECUTOR_OVERFLOW_LIMIT">TOPOLOGY_EXECUTOR_OVERFLOW_LIMIT</a></span></code>
<div class="block">If number of items in task&rsquo;s overflowQ exceeds this, new messages coming from other workers to this task will be dropped This prevents OutOfMemoryException that can occur in rare scenarios in the presence of BackPressure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_EXECUTOR_RECEIVE_BUFFER_SIZE">TOPOLOGY_EXECUTOR_RECEIVE_BUFFER_SIZE</a></span></code>
<div class="block">The size of the receive queue for each executor.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION">TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION</a></span></code>
<div class="block">Whether or not to use Java serialization in a topology.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_GROUPS">TOPOLOGY_GROUPS</a></span></code>
<div class="block">A list of groups that are allowed to interact with the topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_ISOLATED_MACHINES">TOPOLOGY_ISOLATED_MACHINES</a></span></code>
<div class="block">The number of machines that should be used by this topology to isolate it from all others.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_KRYO_DECORATORS">TOPOLOGY_KRYO_DECORATORS</a></span></code>
<div class="block">A list of classes that customize storm&rsquo;s kryo instance during start-up.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_KRYO_FACTORY">TOPOLOGY_KRYO_FACTORY</a></span></code>
<div class="block">Class that specifies how to create a Kryo instance for serialization.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_KRYO_REGISTER">TOPOLOGY_KRYO_REGISTER</a></span></code>
<div class="block">A list of serialization registrations for Kryo ( <a href="https://github.com/EsotericSoftware/kryo">https://github.com/EsotericSoftware/kryo</a> ), the underlying serialization framework for Storm.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_LOCALITYAWARE_HIGHER_BOUND">TOPOLOGY_LOCALITYAWARE_HIGHER_BOUND</a></span></code>
<div class="block">This signifies the load congestion among target tasks in scope.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_LOCALITYAWARE_LOWER_BOUND">TOPOLOGY_LOCALITYAWARE_LOWER_BOUND</a></span></code>
<div class="block">This signifies the load congestion among target tasks in scope.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_LOGGING_CONFIG_FILE">TOPOLOGY_LOGGING_CONFIG_FILE</a></span></code>
<div class="block">Log file the user can use to configure Log4j2.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_LOGGING_SENSITIVITY">TOPOLOGY_LOGGING_SENSITIVITY</a></span></code>
<div class="block">Topology central logging sensitivity to determine who has access to logs in central logging system.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MAX_ERROR_REPORT_PER_INTERVAL">TOPOLOGY_MAX_ERROR_REPORT_PER_INTERVAL</a></span></code>
<div class="block">See doc for TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MAX_REPLICATION_WAIT_TIME_SEC">TOPOLOGY_MAX_REPLICATION_WAIT_TIME_SEC</a></span></code>
<div class="block">Maximum wait time for the nimbus host replication to achieve the nimbus.min.replication.count.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MAX_SPOUT_PENDING">TOPOLOGY_MAX_SPOUT_PENDING</a></span></code>
<div class="block">The maximum number of tuples that can be pending on a spout task at any given time.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MAX_TASK_PARALLELISM">TOPOLOGY_MAX_TASK_PARALLELISM</a></span></code>
<div class="block">The maximum parallelism allowed for a component in this topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MESSAGE_TIMEOUT_SECS">TOPOLOGY_MESSAGE_TIMEOUT_SECS</a></span></code>
<div class="block">The maximum amount of time given to the topology to fully process a message emitted by a spout.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_METRICS_CONSUMER_CPU_PCORE_PERCENT">TOPOLOGY_METRICS_CONSUMER_CPU_PCORE_PERCENT</a></span></code>
<div class="block">The config indicates the percentage of cpu for a core an instance(executor) of a metrics consumer will use.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_METRICS_CONSUMER_REGISTER">TOPOLOGY_METRICS_CONSUMER_REGISTER</a></span></code>
<div class="block">A list of classes implementing IMetricsConsumer (See storm.yaml.example for exact config format).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_METRICS_CONSUMER_RESOURCES_OFFHEAP_MEMORY_MB">TOPOLOGY_METRICS_CONSUMER_RESOURCES_OFFHEAP_MEMORY_MB</a></span></code>
<div class="block">The maximum amount of memory an instance of a metrics consumer will take off heap.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_METRICS_CONSUMER_RESOURCES_ONHEAP_MEMORY_MB">TOPOLOGY_METRICS_CONSUMER_RESOURCES_ONHEAP_MEMORY_MB</a></span></code>
<div class="block">The maximum amount of memory an instance of a metrics consumer will take on heap.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MIN_REPLICATION_COUNT">TOPOLOGY_MIN_REPLICATION_COUNT</a></span></code>
<div class="block">Minimum number of nimbus hosts where the code must be replicated before leader nimbus is allowed to perform topology activation tasks like setting up heartbeats/assignments and marking the topology as active.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MULTILANG_LOG_HANDLER">TOPOLOGY_MULTILANG_LOG_HANDLER</a></span></code>
<div class="block">The fully qualified name of a <code>ShellLogHandler</code> to handle output from non-JVM processes e.g.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_MULTILANG_SERIALIZER">TOPOLOGY_MULTILANG_SERIALIZER</a></span></code>
<div class="block">The serializer for communication between shell components and non-JVM processes.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_NAME">TOPOLOGY_NAME</a></span></code>
<div class="block">Name of the topology.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_PRIORITY">TOPOLOGY_PRIORITY</a></span></code>
<div class="block">Sets the priority for a topology</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_PRODUCER_BATCH_SIZE">TOPOLOGY_PRODUCER_BATCH_SIZE</a></span></code>
<div class="block">The number of tuples to batch before sending to the destination executor.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_RAS_CONSTRAINT_MAX_STATE_SEARCH">TOPOLOGY_RAS_CONSTRAINT_MAX_STATE_SEARCH</a></span></code>
<div class="block">The maximum number of states that will be searched looking for a solution in the constraint solver strategy.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_RAS_CONSTRAINT_MAX_TIME_SECS">TOPOLOGY_RAS_CONSTRAINT_MAX_TIME_SECS</a></span></code>
<div class="block">The maximum number of seconds to spend scheduling a topology using the constraint solver.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_RAS_CONSTRAINTS">TOPOLOGY_RAS_CONSTRAINTS</a></span></code>
<div class="block">Declare scheduling constraints for a topology used by the constraint solver strategy.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_READONLY_GROUPS">TOPOLOGY_READONLY_GROUPS</a></span></code>
<div class="block">A list of readonly groups that are allowed to interact with the topology.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_READONLY_USERS">TOPOLOGY_READONLY_USERS</a></span></code>
<div class="block">A list of readonly users that are allowed to interact with the topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SCHEDULER_FAVORED_NODES">TOPOLOGY_SCHEDULER_FAVORED_NODES</a></span></code>
<div class="block">A list of host names that this topology would prefer to be scheduled on (no guarantee is given though).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SCHEDULER_STRATEGY">TOPOLOGY_SCHEDULER_STRATEGY</a></span></code>
<div class="block">The strategy to use when scheduling a topology with Resource Aware Scheduler.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SCHEDULER_UNFAVORED_NODES">TOPOLOGY_SCHEDULER_UNFAVORED_NODES</a></span></code>
<div class="block">A list of host names that this topology would prefer to NOT be scheduled on (no guarantee is given though).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SERIALIZED_MESSAGE_SIZE_METRICS">TOPOLOGY_SERIALIZED_MESSAGE_SIZE_METRICS</a></span></code>
<div class="block">Enable tracking of network message byte counts per source-destination task.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SHELLBOLT_MAX_PENDING">TOPOLOGY_SHELLBOLT_MAX_PENDING</a></span></code>
<div class="block">Max pending tuples in one ShellBolt</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SKIP_MISSING_KRYO_REGISTRATIONS">TOPOLOGY_SKIP_MISSING_KRYO_REGISTRATIONS</a></span></code>
<div class="block">Whether or not Storm should skip the loading of kryo registrations for which it does not know the class or have the serializer implementation.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SLEEP_SPOUT_WAIT_STRATEGY_TIME_MS">TOPOLOGY_SLEEP_SPOUT_WAIT_STRATEGY_TIME_MS</a></span></code>
<div class="block">The amount of milliseconds the SleepEmptyEmitStrategy should sleep for.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SPOUT_RECVQ_SKIPS">TOPOLOGY_SPOUT_RECVQ_SKIPS</a></span></code>
<div class="block">Check recvQ after every N invocations of Spout&rsquo;s nextTuple() [when ACKing is disabled].</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SPOUT_WAIT_PARK_MICROSEC">TOPOLOGY_SPOUT_WAIT_PARK_MICROSEC</a></span></code>
<div class="block">Configures park time for WaitStrategyPark for spout.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL1_COUNT">TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL1_COUNT</a></span></code>
<div class="block">Configures number of iterations to spend in level 1 of WaitStrategyProgressive, before progressing to level 2</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL2_COUNT">TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL2_COUNT</a></span></code>
<div class="block">Configures number of iterations to spend in level 2 of WaitStrategyProgressive, before progressing to level 3</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</a></span></code>
<div class="block">Configures sleep time for WaitStrategyProgressive.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SPOUT_WAIT_STRATEGY">TOPOLOGY_SPOUT_WAIT_STRATEGY</a></span></code>
<div class="block">A class that implements a wait strategy for spout.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SPREAD_COMPONENTS">TOPOLOGY_SPREAD_COMPONENTS</a></span></code>
<div class="block">Array of components that scheduler should try to place on separate hosts when using the constraint solver strategy or the multi-tenant scheduler.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_STATE_CHECKPOINT_INTERVAL">TOPOLOGY_STATE_CHECKPOINT_INTERVAL</a></span></code>
<div class="block">Topology configuration to specify the checkpoint interval (in millis) at which the topology state is saved when <a href="../../../org/apache/storm/topology/IStatefulBolt.html" title="interface in org.apache.storm.topology"><code>IStatefulBolt</code></a> bolts are involved.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_STATE_KRYO_REGISTER">TOPOLOGY_STATE_KRYO_REGISTER</a></span></code>
<div class="block">List of classes to register during state serialization.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_STATE_PROVIDER">TOPOLOGY_STATE_PROVIDER</a></span></code>
<div class="block">The class name of the <a href="../../../org/apache/storm/state/StateProvider.html" title="interface in org.apache.storm.state"><code>StateProvider</code></a> implementation.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_STATE_PROVIDER_CONFIG">TOPOLOGY_STATE_PROVIDER_CONFIG</a></span></code>
<div class="block">The configuration specific to the <a href="../../../org/apache/storm/state/StateProvider.html" title="interface in org.apache.storm.state"><code>StateProvider</code></a> implementation.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_STATE_SYNCHRONIZATION_TIMEOUT_SECS">TOPOLOGY_STATE_SYNCHRONIZATION_TIMEOUT_SECS</a></span></code>
<div class="block">The maximum amount of time a component gives a source of state to synchronize before it requests synchronization again.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_STATS_SAMPLE_RATE">TOPOLOGY_STATS_SAMPLE_RATE</a></span></code>
<div class="block">The percentage of tuples to sample to produce stats for a task.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SUBMITTER_PRINCIPAL">TOPOLOGY_SUBMITTER_PRINCIPAL</a></span></code>
<div class="block">The principal who submitted a topology</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SUBMITTER_USER">TOPOLOGY_SUBMITTER_USER</a></span></code>
<div class="block">The local user name of the user who submitted a topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_SUBPROCESS_TIMEOUT_SECS">TOPOLOGY_SUBPROCESS_TIMEOUT_SECS</a></span></code>
<div class="block">How long a subprocess can go without heartbeating before the ShellSpout/ShellBolt tries to suicide itself.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TASKS">TOPOLOGY_TASKS</a></span></code>
<div class="block">How many instances to create for a spout/bolt.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TESTING_ALWAYS_TRY_SERIALIZE">TOPOLOGY_TESTING_ALWAYS_TRY_SERIALIZE</a></span></code>
<div class="block">Try to serialize all tuples, even for local transfers.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TICK_TUPLE_FREQ_SECS">TOPOLOGY_TICK_TUPLE_FREQ_SECS</a></span></code>
<div class="block">How often a tick tuple from the &ldquo;_<em>system&ldquo; component and &rdquo;</em>_tick&rdquo; stream should be sent to tasks.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TRANSACTIONAL_ID">TOPOLOGY_TRANSACTIONAL_ID</a></span></code>
<div class="block">This config is available for TransactionalSpouts, and contains the id ( a String) for the transactional topology.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TRANSFER_BATCH_SIZE">TOPOLOGY_TRANSFER_BATCH_SIZE</a></span></code>
<div class="block">The size of the transfer queue for each worker.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TRANSFER_BUFFER_SIZE">TOPOLOGY_TRANSFER_BUFFER_SIZE</a></span></code>
<div class="block">The size of the transfer queue for each worker.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TRIDENT_BATCH_EMIT_INTERVAL_MILLIS">TOPOLOGY_TRIDENT_BATCH_EMIT_INTERVAL_MILLIS</a></span></code>
<div class="block">How often a batch can be emitted in a Trident topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TRIDENT_WINDOWING_INMEMORY_CACHE_LIMIT">TOPOLOGY_TRIDENT_WINDOWING_INMEMORY_CACHE_LIMIT</a></span></code>
<div class="block">Maximum number of tuples that can be stored inmemory cache in windowing operators for fast access without fetching them from store.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_TUPLE_SERIALIZER">TOPOLOGY_TUPLE_SERIALIZER</a></span></code>
<div class="block">The serializer class for ListDelegate (tuple payload).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_USERS">TOPOLOGY_USERS</a></span></code>
<div class="block">A list of users that are allowed to interact with the topology.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_VERSION">TOPOLOGY_VERSION</a></span></code>
<div class="block">User defined version of this topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_WORKER_CHILDOPTS">TOPOLOGY_WORKER_CHILDOPTS</a></span></code>
<div class="block">Topology-specific options for the worker child process.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_WORKER_GC_CHILDOPTS">TOPOLOGY_WORKER_GC_CHILDOPTS</a></span></code>
<div class="block">Topology-specific options GC for the worker child process.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_WORKER_LOGWRITER_CHILDOPTS">TOPOLOGY_WORKER_LOGWRITER_CHILDOPTS</a></span></code>
<div class="block">Topology-specific options for the logwriter process of a worker.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_WORKER_MAX_HEAP_SIZE_MB">TOPOLOGY_WORKER_MAX_HEAP_SIZE_MB</a></span></code>
<div class="block">A per topology config that specifies the maximum amount of memory a worker can use for that specific topology.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_WORKER_METRICS">TOPOLOGY_WORKER_METRICS</a></span></code>
<div class="block">A map of metric name to class name implementing IMetric that will be created once per worker JVM.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_WORKER_SHARED_THREAD_POOL_SIZE">TOPOLOGY_WORKER_SHARED_THREAD_POOL_SIZE</a></span></code>
<div class="block">The size of the shared thread pool for worker tasks to make use of.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TOPOLOGY_WORKERS">TOPOLOGY_WORKERS</a></span></code>
<div class="block">How many processes should be spawned around the cluster to execute this topology.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TRANSACTIONAL_ZOOKEEPER_PORT">TRANSACTIONAL_ZOOKEEPER_PORT</a></span></code>
<div class="block">The port to use to connect to the transactional zookeeper servers.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TRANSACTIONAL_ZOOKEEPER_ROOT">TRANSACTIONAL_ZOOKEEPER_ROOT</a></span></code>
<div class="block">The root directory in ZooKeeper for metadata about TransactionalSpouts.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#TRANSACTIONAL_ZOOKEEPER_SERVERS">TRANSACTIONAL_ZOOKEEPER_SERVERS</a></span></code>
<div class="block">The list of zookeeper servers in which to keep the transactional state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#WORKER_BLOB_UPDATE_POLL_INTERVAL_SECS">WORKER_BLOB_UPDATE_POLL_INTERVAL_SECS</a></span></code>
<div class="block">Interval to check for the worker to check for updated blobs and refresh worker state accordingly.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#WORKER_CHILDOPTS">WORKER_CHILDOPTS</a></span></code>
<div class="block">The jvm opts provided to workers launched by this supervisor.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#WORKER_GC_CHILDOPTS">WORKER_GC_CHILDOPTS</a></span></code>
<div class="block">The jvm opts provided to workers launched by this supervisor for GC.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#WORKER_HEAP_MEMORY_MB">WORKER_HEAP_MEMORY_MB</a></span></code>
<div class="block">The default heap memory size in MB per worker, used in the jvm -Xmx opts for launching the worker</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#WORKER_HEARTBEAT_FREQUENCY_SECS">WORKER_HEARTBEAT_FREQUENCY_SECS</a></span></code>
<div class="block">How often this worker should heartbeat to the supervisor.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#WORKER_LOG_LEVEL_RESET_POLL_SECS">WORKER_LOG_LEVEL_RESET_POLL_SECS</a></span></code>
<div class="block">How often a worker should check dynamic log level timeouts for expiration.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#WORKER_METRICS">WORKER_METRICS</a></span></code>
<div class="block">A map of metric name to class name implementing IMetric that will be created once per worker JVM.</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#Config--">Config</a></span>()</code>&nbsp;</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">Static Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#getBlobstoreHDFSPrincipal-java.util.Map-">getBlobstoreHDFSPrincipal</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&nbsp;conf)</code>&nbsp;</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerDecorator-java.lang.Class-">registerDecorator</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoDecorator.html" title="interface in org.apache.storm.serialization">IKryoDecorator</a>&gt;&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerDecorator-java.util.Map-java.lang.Class-">registerDecorator</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoDecorator.html" title="interface in org.apache.storm.serialization">IKryoDecorator</a>&gt;&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerEventLogger-java.lang.Class-">registerEventLogger</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerEventLogger-java.lang.Class-java.util.Map-">registerEventLogger</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;argument)</code>&nbsp;</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerEventLogger-java.util.Map-java.lang.Class-">registerEventLogger</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerEventLogger-java.util.Map-java.lang.Class-java.util.Map-">registerEventLogger</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;argument)</code>&nbsp;</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerMetricsConsumer-java.lang.Class-">registerMetricsConsumer</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerMetricsConsumer-java.lang.Class-long-">registerMetricsConsumer</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                       long&nbsp;parallelismHint)</code>&nbsp;</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerMetricsConsumer-java.lang.Class-java.lang.Object-long-">registerMetricsConsumer</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;argument,
                       long&nbsp;parallelismHint)</code>&nbsp;</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerMetricsConsumer-java.util.Map-java.lang.Class-">registerMetricsConsumer</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerMetricsConsumer-java.util.Map-java.lang.Class-long-">registerMetricsConsumer</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                       long&nbsp;parallelismHint)</code>&nbsp;</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerMetricsConsumer-java.util.Map-java.lang.Class-java.lang.Object-long-">registerMetricsConsumer</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;argument,
                       long&nbsp;parallelismHint)</code>&nbsp;</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerSerialization-java.lang.Class-">registerSerialization</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerSerialization-java.lang.Class-java.lang.Class-">registerSerialization</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends com.esotericsoftware.kryo.Serializer&gt;&nbsp;serializerClass)</code>&nbsp;</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerSerialization-java.util.Map-java.lang.Class-">registerSerialization</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#registerSerialization-java.util.Map-java.lang.Class-java.lang.Class-">registerSerialization</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends com.esotericsoftware.kryo.Serializer&gt;&nbsp;serializerClass)</code>&nbsp;</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setClasspath-java.util.Map-java.lang.String-">setClasspath</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
            <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cp)</code>&nbsp;</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setClasspath-java.lang.String-">setClasspath</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cp)</code>&nbsp;</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setDebug-boolean-">setDebug</a></span>(boolean&nbsp;isOn)</code>&nbsp;</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setDebug-java.util.Map-boolean-">setDebug</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
        boolean&nbsp;isOn)</code>&nbsp;</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setEnvironment-java.util.Map-">setEnvironment</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;env)</code>&nbsp;</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setEnvironment-java.util.Map-java.util.Map-">setEnvironment</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
              <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;env)</code>&nbsp;</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setFallBackOnJavaSerialization-boolean-">setFallBackOnJavaSerialization</a></span>(boolean&nbsp;fallback)</code>&nbsp;</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setFallBackOnJavaSerialization-java.util.Map-boolean-">setFallBackOnJavaSerialization</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                              boolean&nbsp;fallback)</code>&nbsp;</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setKryoFactory-java.lang.Class-">setKryoFactory</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoFactory.html" title="interface in org.apache.storm.serialization">IKryoFactory</a>&gt;&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setKryoFactory-java.util.Map-java.lang.Class-">setKryoFactory</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
              <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoFactory.html" title="interface in org.apache.storm.serialization">IKryoFactory</a>&gt;&nbsp;klass)</code>&nbsp;</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setMaxSpoutPending-int-">setMaxSpoutPending</a></span>(int&nbsp;max)</code>&nbsp;</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setMaxSpoutPending-java.util.Map-int-">setMaxSpoutPending</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                  int&nbsp;max)</code>&nbsp;</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setMaxTaskParallelism-int-">setMaxTaskParallelism</a></span>(int&nbsp;max)</code>&nbsp;</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setMaxTaskParallelism-java.util.Map-int-">setMaxTaskParallelism</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                     int&nbsp;max)</code>&nbsp;</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setMessageTimeoutSecs-int-">setMessageTimeoutSecs</a></span>(int&nbsp;secs)</code>&nbsp;</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setMessageTimeoutSecs-java.util.Map-int-">setMessageTimeoutSecs</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                     int&nbsp;secs)</code>&nbsp;</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setNumAckers-int-">setNumAckers</a></span>(int&nbsp;numExecutors)</code>&nbsp;</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setNumAckers-java.util.Map-int-">setNumAckers</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
            int&nbsp;numExecutors)</code>&nbsp;</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setNumEventLoggers-int-">setNumEventLoggers</a></span>(int&nbsp;numExecutors)</code>&nbsp;</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setNumEventLoggers-java.util.Map-int-">setNumEventLoggers</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                  int&nbsp;numExecutors)</code>&nbsp;</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setNumWorkers-int-">setNumWorkers</a></span>(int&nbsp;workers)</code>&nbsp;</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setNumWorkers-java.util.Map-int-">setNumWorkers</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
             int&nbsp;workers)</code>&nbsp;</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setSkipMissingKryoRegistrations-boolean-">setSkipMissingKryoRegistrations</a></span>(boolean&nbsp;skip)</code>&nbsp;</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setSkipMissingKryoRegistrations-java.util.Map-boolean-">setSkipMissingKryoRegistrations</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                               boolean&nbsp;skip)</code>&nbsp;</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setStatsSampleRate-double-">setStatsSampleRate</a></span>(double&nbsp;rate)</code>&nbsp;</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setStatsSampleRate-java.util.Map-double-">setStatsSampleRate</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                  double&nbsp;rate)</code>&nbsp;</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setTopologyComponentWorkerConstraints-java.lang.String-java.lang.String-">setTopologyComponentWorkerConstraints</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;component1,
                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;component2)</code>
<div class="block">Declares executors of component1 cannot be on the same worker as executors of component2.</div>
</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setTopologyConstraintsMaxStateSearch-int-">setTopologyConstraintsMaxStateSearch</a></span>(int&nbsp;numStates)</code>
<div class="block">Sets the maximum number of states that will be searched in the constraint solver strategy.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setTopologyPriority-int-">setTopologyPriority</a></span>(int&nbsp;priority)</code>
<div class="block">Set the priority for a topology.</div>
</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setTopologyStrategy-java.lang.String-">setTopologyStrategy</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;strategy)</code>&nbsp;</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setTopologyVersion-java.util.Map-java.lang.String-">setTopologyVersion</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;version)</code>&nbsp;</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setTopologyVersion-java.lang.String-">setTopologyVersion</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;version)</code>&nbsp;</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/Config.html#setTopologyWorkerMaxHeapSize-java.lang.Number-">setTopologyWorkerMaxHeapSize</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang">Number</a>&nbsp;size)</code>
<div class="block">Set the max heap size allow per worker for this topology.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.util.HashMap">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.util.<a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#clear--" title="class or interface in java.util">clear</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#clone--" title="class or interface in java.util">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#compute-K-java.util.function.BiFunction-" title="class or interface in java.util">compute</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#computeIfAbsent-K-java.util.function.Function-" title="class or interface in java.util">computeIfAbsent</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#computeIfPresent-K-java.util.function.BiFunction-" title="class or interface in java.util">computeIfPresent</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#containsKey-java.lang.Object-" title="class or interface in java.util">containsKey</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#containsValue-java.lang.Object-" title="class or interface in java.util">containsValue</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#entrySet--" title="class or interface in java.util">entrySet</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#forEach-java.util.function.BiConsumer-" title="class or interface in java.util">forEach</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#get-java.lang.Object-" title="class or interface in java.util">get</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#getOrDefault-java.lang.Object-V-" title="class or interface in java.util">getOrDefault</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#isEmpty--" title="class or interface in java.util">isEmpty</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#keySet--" title="class or interface in java.util">keySet</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#merge-K-V-java.util.function.BiFunction-" title="class or interface in java.util">merge</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#put-K-V-" title="class or interface in java.util">put</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#putAll-java.util.Map-" title="class or interface in java.util">putAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#putIfAbsent-K-V-" title="class or interface in java.util">putIfAbsent</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#remove-java.lang.Object-" title="class or interface in java.util">remove</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#remove-java.lang.Object-java.lang.Object-" title="class or interface in java.util">remove</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#replace-K-V-" title="class or interface in java.util">replace</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#replace-K-V-V-" title="class or interface in java.util">replace</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#replaceAll-java.util.function.BiFunction-" title="class or interface in java.util">replaceAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#size--" title="class or interface in java.util">size</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html?is-external=true#values--" title="class or interface in java.util">values</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.util.AbstractMap">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.util.<a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.html?is-external=true" title="class or interface in java.util">AbstractMap</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.util">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.html?is-external=true#hashCode--" title="class or interface in java.util">hashCode</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractMap.html?is-external=true#toString--" title="class or interface in java.util">toString</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize--" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.util.Map">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;java.util.<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.util">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true#hashCode--" title="class or interface in java.util">hashCode</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="TOPOLOGY_TUPLE_SERIALIZER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TUPLE_SERIALIZER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TUPLE_SERIALIZER</pre>
<div class="block"><p>The serializer class for ListDelegate (tuple payload). The default serializer will be ListDelegateSerializer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TUPLE_SERIALIZER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_DISABLE_LOADAWARE_MESSAGING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_DISABLE_LOADAWARE_MESSAGING</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_DISABLE_LOADAWARE_MESSAGING</pre>
<div class="block"><p>Disable load aware grouping support.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_DISABLE_LOADAWARE_MESSAGING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_LOCALITYAWARE_HIGHER_BOUND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_LOCALITYAWARE_HIGHER_BOUND</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_LOCALITYAWARE_HIGHER_BOUND</pre>
<div class="block"><p>This signifies the load congestion among target tasks in scope. Currently it&rsquo;s only used in LoadAwareShuffleGrouping. When the average load is higher than the higher bound, the executor should choose target tasks in a higher scope, The scopes and their orders are: EVERYTHING &gt; RACK_LOCAL &gt; HOST_LOCAL &gt; WORKER_LOCAL</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_LOCALITYAWARE_HIGHER_BOUND">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_LOCALITYAWARE_LOWER_BOUND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_LOCALITYAWARE_LOWER_BOUND</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_LOCALITYAWARE_LOWER_BOUND</pre>
<div class="block"><p>This signifies the load congestion among target tasks in scope. Currently it&rsquo;s only used in LoadAwareShuffleGrouping. When the average load is lower than the lower bound, the executor should choose target tasks in a lower scope. The scopes and their orders are: EVERYTHING &gt; RACK_LOCAL &gt; HOST_LOCAL &gt; WORKER_LOCAL</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_LOCALITYAWARE_LOWER_BOUND">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TESTING_ALWAYS_TRY_SERIALIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TESTING_ALWAYS_TRY_SERIALIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TESTING_ALWAYS_TRY_SERIALIZE</pre>
<div class="block"><p>Try to serialize all tuples, even for local transfers. This should only be used for testing, as a sanity check that all of your tuples are setup properly.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TESTING_ALWAYS_TRY_SERIALIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BLOBSTORE_MAP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BLOBSTORE_MAP</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BLOBSTORE_MAP</pre>
<div class="block"><p>A map with blobstore keys mapped to each filename the worker will have access to in the launch directory to the blob by local file name, uncompress flag, and if the worker should restart when the blob is updated. localname, workerRestart, and uncompress are optional. If localname is not specified the name of the key is used instead. Each topologywill have different map of blobs. Example: topology.blobstore.map: {&ldquo;blobstorekey&rdquo; : {&ldquo;localname&rdquo;: &ldquo;myblob&rdquo;, &ldquo;uncompress&rdquo;: false}, &ldquo;blobstorearchivekey&rdquo; : {&ldquo;localname&rdquo;: &ldquo;myarchive&rdquo;, &ldquo;uncompress&rdquo;: true, &ldquo;workerRestart&rdquo;: true}}</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BLOBSTORE_MAP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_LOG_LEVEL_RESET_POLL_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_LOG_LEVEL_RESET_POLL_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> WORKER_LOG_LEVEL_RESET_POLL_SECS</pre>
<div class="block"><p>How often a worker should check dynamic log level timeouts for expiration. For expired logger settings, the clean up polling task will reset the log levels to the original levels (detected at startup), and will clean up the timeout map</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.WORKER_LOG_LEVEL_RESET_POLL_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TASK_CREDENTIALS_POLL_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TASK_CREDENTIALS_POLL_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TASK_CREDENTIALS_POLL_SECS</pre>
<div class="block"><p>How often a task should sync credentials, worst case.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TASK_CREDENTIALS_POLL_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BACKPRESSURE_ENABLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BACKPRESSURE_ENABLE</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BACKPRESSURE_ENABLE</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block"><p>Whether to enable backpressure in for a certain topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BACKPRESSURE_ENABLE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_USERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_USERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_USERS</pre>
<div class="block"><p>A list of users that are allowed to interact with the topology. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_USERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_GROUPS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_GROUPS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_GROUPS</pre>
<div class="block"><p>A list of groups that are allowed to interact with the topology. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_GROUPS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_READONLY_USERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_READONLY_USERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_READONLY_USERS</pre>
<div class="block"><p>A list of readonly users that are allowed to interact with the topology. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_READONLY_USERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_READONLY_GROUPS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_READONLY_GROUPS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_READONLY_GROUPS</pre>
<div class="block"><p>A list of readonly groups that are allowed to interact with the topology. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_READONLY_GROUPS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ENABLE_MESSAGE_TIMEOUTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ENABLE_MESSAGE_TIMEOUTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ENABLE_MESSAGE_TIMEOUTS</pre>
<div class="block"><p>True if Storm should timeout messages or not. Defaults to true. This is meant to be used in unit tests to prevent tuples from being accidentally timed out during the test.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ENABLE_MESSAGE_TIMEOUTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_DEBUG">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_DEBUG</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_DEBUG</pre>
<div class="block"><p>When set to true, Storm will log every message that&rsquo;s emitted.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_DEBUG">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_VERSION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_VERSION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_VERSION</pre>
<div class="block"><p>User defined version of this topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_VERSION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MULTILANG_LOG_HANDLER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MULTILANG_LOG_HANDLER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MULTILANG_LOG_HANDLER</pre>
<div class="block"><p>The fully qualified name of a <code>ShellLogHandler</code> to handle output from non-JVM processes e.g. &ldquo;com.mycompany.CustomShellLogHandler&rdquo;. If not provided, org.apache.storm.utils.DefaultLogHandler will be used.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MULTILANG_LOG_HANDLER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MULTILANG_SERIALIZER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MULTILANG_SERIALIZER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MULTILANG_SERIALIZER</pre>
<div class="block"><p>The serializer for communication between shell components and non-JVM processes.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MULTILANG_SERIALIZER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_WORKERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_WORKERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_WORKERS</pre>
<div class="block"><p>How many processes should be spawned around the cluster to execute this topology. Each process will execute some number of tasks as threads within them. This parameter should be used in conjunction with the parallelism hints on each component in the topology to tune the performance of a topology. The number of workers will be dynamically calculated when the Resource Aware scheduler is used, in which case this parameter will not be honored.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_WORKERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TASKS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TASKS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TASKS</pre>
<div class="block"><p>How many instances to create for a spout/bolt. A task runs on a thread with zero or more other tasks for the same spout/bolt. The number of tasks for a spout/bolt is always the same throughout the lifetime of a topology, but the number of executors (threads) for a spout/bolt can change over time. This allows a topology to scale to more or less resources without redeploying the topology or violating the constraints of Storm (such as a fields grouping guaranteeing that the same value goes to the same task).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TASKS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_COMPONENT_RESOURCES_MAP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_COMPONENT_RESOURCES_MAP</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_COMPONENT_RESOURCES_MAP</pre>
<div class="block"><p>A map of resources used by each component e.g {&ldquo;cpu.pcore.percent&rdquo; : 200.0. &ldquo;onheap.memory.mb&rdquo;: 256.0, &ldquo;gpu.count&rdquo; : 2 }</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_COMPONENT_RESOURCES_MAP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_COMPONENT_RESOURCES_ONHEAP_MEMORY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_COMPONENT_RESOURCES_ONHEAP_MEMORY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_COMPONENT_RESOURCES_ONHEAP_MEMORY_MB</pre>
<div class="block"><p>The maximum amount of memory an instance of a spout/bolt will take on heap. This enables the scheduler to allocate slots on machines with enough available memory. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_COMPONENT_RESOURCES_ONHEAP_MEMORY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_COMPONENT_RESOURCES_OFFHEAP_MEMORY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_COMPONENT_RESOURCES_OFFHEAP_MEMORY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_COMPONENT_RESOURCES_OFFHEAP_MEMORY_MB</pre>
<div class="block"><p>The maximum amount of memory an instance of a spout/bolt will take off heap. This enables the scheduler to allocate slots on machines with enough available memory. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_COMPONENT_RESOURCES_OFFHEAP_MEMORY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_COMPONENT_CPU_PCORE_PERCENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_COMPONENT_CPU_PCORE_PERCENT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_COMPONENT_CPU_PCORE_PERCENT</pre>
<div class="block"><p>The config indicates the percentage of cpu for a core an instance(executor) of a component will use. Assuming the a core value to be 100, a value of 10 indicates 10% of the core. The P in PCORE represents the term &ldquo;physical&rdquo;. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_COMPONENT_CPU_PCORE_PERCENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ACKER_RESOURCES_ONHEAP_MEMORY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ACKER_RESOURCES_ONHEAP_MEMORY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ACKER_RESOURCES_ONHEAP_MEMORY_MB</pre>
<div class="block"><p>The maximum amount of memory an instance of an acker will take on heap. This enables the scheduler to allocate slots on machines with enough available memory. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ACKER_RESOURCES_ONHEAP_MEMORY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ACKER_RESOURCES_OFFHEAP_MEMORY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ACKER_RESOURCES_OFFHEAP_MEMORY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ACKER_RESOURCES_OFFHEAP_MEMORY_MB</pre>
<div class="block"><p>The maximum amount of memory an instance of an acker will take off heap. This enables the scheduler to allocate slots on machines with enough available memory. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ACKER_RESOURCES_OFFHEAP_MEMORY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ACKER_CPU_PCORE_PERCENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ACKER_CPU_PCORE_PERCENT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ACKER_CPU_PCORE_PERCENT</pre>
<div class="block"><p>The config indicates the percentage of cpu for a core an instance(executor) of an acker will use. Assuming the a core value to be 100, a value of 10 indicates 10% of the core. The P in PCORE represents the term &ldquo;physical&rdquo;. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ACKER_CPU_PCORE_PERCENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_METRICS_CONSUMER_RESOURCES_ONHEAP_MEMORY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_METRICS_CONSUMER_RESOURCES_ONHEAP_MEMORY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_METRICS_CONSUMER_RESOURCES_ONHEAP_MEMORY_MB</pre>
<div class="block"><p>The maximum amount of memory an instance of a metrics consumer will take on heap. This enables the scheduler to allocate slots on machines with enough available memory. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_METRICS_CONSUMER_RESOURCES_ONHEAP_MEMORY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_METRICS_CONSUMER_RESOURCES_OFFHEAP_MEMORY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_METRICS_CONSUMER_RESOURCES_OFFHEAP_MEMORY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_METRICS_CONSUMER_RESOURCES_OFFHEAP_MEMORY_MB</pre>
<div class="block"><p>The maximum amount of memory an instance of a metrics consumer will take off heap. This enables the scheduler to allocate slots on machines with enough available memory. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_METRICS_CONSUMER_RESOURCES_OFFHEAP_MEMORY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_METRICS_CONSUMER_CPU_PCORE_PERCENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_METRICS_CONSUMER_CPU_PCORE_PERCENT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_METRICS_CONSUMER_CPU_PCORE_PERCENT</pre>
<div class="block"><p>The config indicates the percentage of cpu for a core an instance(executor) of a metrics consumer will use. Assuming the a core value to be 100, a value of 10 indicates 10% of the core. The P in PCORE represents the term &ldquo;physical&rdquo;. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_METRICS_CONSUMER_CPU_PCORE_PERCENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_STATE_PROVIDER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_STATE_PROVIDER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_STATE_PROVIDER</pre>
<div class="block"><p>The class name of the <a href="../../../org/apache/storm/state/StateProvider.html" title="interface in org.apache.storm.state"><code>StateProvider</code></a> implementation. If not specified defaults to <a href="../../../org/apache/storm/state/InMemoryKeyValueStateProvider.html" title="class in org.apache.storm.state"><code>InMemoryKeyValueStateProvider</code></a>. This can be overridden at the component level.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_STATE_PROVIDER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_STATE_PROVIDER_CONFIG">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_STATE_PROVIDER_CONFIG</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_STATE_PROVIDER_CONFIG</pre>
<div class="block"><p>The configuration specific to the <a href="../../../org/apache/storm/state/StateProvider.html" title="interface in org.apache.storm.state"><code>StateProvider</code></a> implementation. This can be overridden at the component level. The value and the interpretation of this config is based on the state provider implementation. For e.g. this could be just a config file name which contains the config for the state provider implementation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_STATE_PROVIDER_CONFIG">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_STATE_CHECKPOINT_INTERVAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_STATE_CHECKPOINT_INTERVAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_STATE_CHECKPOINT_INTERVAL</pre>
<div class="block"><p>Topology configuration to specify the checkpoint interval (in millis) at which the topology state is saved when <a href="../../../org/apache/storm/topology/IStatefulBolt.html" title="interface in org.apache.storm.topology"><code>IStatefulBolt</code></a> bolts are involved.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_STATE_CHECKPOINT_INTERVAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_WORKER_MAX_HEAP_SIZE_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_WORKER_MAX_HEAP_SIZE_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_WORKER_MAX_HEAP_SIZE_MB</pre>
<div class="block"><p>A per topology config that specifies the maximum amount of memory a worker can use for that specific topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_WORKER_MAX_HEAP_SIZE_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SCHEDULER_STRATEGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SCHEDULER_STRATEGY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SCHEDULER_STRATEGY</pre>
<div class="block"><p>The strategy to use when scheduling a topology with Resource Aware Scheduler.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SCHEDULER_STRATEGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_RAS_CONSTRAINTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_RAS_CONSTRAINTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_RAS_CONSTRAINTS</pre>
<div class="block"><p>Declare scheduling constraints for a topology used by the constraint solver strategy. A List of pairs (also a list) of components that cannot coexist in the same worker.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_RAS_CONSTRAINTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SPREAD_COMPONENTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SPREAD_COMPONENTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SPREAD_COMPONENTS</pre>
<div class="block"><p>Array of components that scheduler should try to place on separate hosts when using the constraint solver strategy or the multi-tenant scheduler.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SPREAD_COMPONENTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_RAS_CONSTRAINT_MAX_STATE_SEARCH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_RAS_CONSTRAINT_MAX_STATE_SEARCH</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_RAS_CONSTRAINT_MAX_STATE_SEARCH</pre>
<div class="block"><p>The maximum number of states that will be searched looking for a solution in the constraint solver strategy.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_RAS_CONSTRAINT_MAX_STATE_SEARCH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_RAS_CONSTRAINT_MAX_TIME_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_RAS_CONSTRAINT_MAX_TIME_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_RAS_CONSTRAINT_MAX_TIME_SECS</pre>
<div class="block"><p>The maximum number of seconds to spend scheduling a topology using the constraint solver. Null means no limit.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_RAS_CONSTRAINT_MAX_TIME_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SCHEDULER_FAVORED_NODES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SCHEDULER_FAVORED_NODES</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SCHEDULER_FAVORED_NODES</pre>
<div class="block"><p>A list of host names that this topology would prefer to be scheduled on (no guarantee is given though). This is intended for debugging only.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SCHEDULER_FAVORED_NODES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SCHEDULER_UNFAVORED_NODES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SCHEDULER_UNFAVORED_NODES</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SCHEDULER_UNFAVORED_NODES</pre>
<div class="block"><p>A list of host names that this topology would prefer to NOT be scheduled on (no guarantee is given though). This is intended for debugging only.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SCHEDULER_UNFAVORED_NODES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ACKER_EXECUTORS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ACKER_EXECUTORS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ACKER_EXECUTORS</pre>
<div class="block"><p>How many executors to spawn for ackers.</p>
<p>By not setting this variable or setting it as null, Storm will set the number of acker executors to be equal to
the number of workers configured for this topology (or the estimated number of workers if the Resource Aware Scheduler is used).
If this variable is set to 0, then Storm will immediately ack tuples as soon as they come off the spout,
effectively disabling reliability.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ACKER_EXECUTORS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_EVENT_LOGGER_REGISTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_EVENT_LOGGER_REGISTER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_EVENT_LOGGER_REGISTER</pre>
<div class="block"><p>A list of classes implementing IEventLogger (See storm.yaml.example for exact config format). Each listed class will be routed all the events sampled from emitting tuples. If there&rsquo;s no class provided to the option, default event logger will be initialized and used unless you disable event logger executor.</p><p>Note that EventLoggerBolt takes care of all the implementations of IEventLogger, hence registering many implementations (especially they&rsquo;re implemented as &lsquo;blocking&rsquo; manner) would slow down overall topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_EVENT_LOGGER_REGISTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_EVENTLOGGER_EXECUTORS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_EVENTLOGGER_EXECUTORS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_EVENTLOGGER_EXECUTORS</pre>
<div class="block"><p>How many executors to spawn for event logger.</p>
<p>By setting it as null, Storm will set the number of eventlogger executors to be equal to the number of workers
configured for this topology (or the estimated number of workers if the Resource Aware Scheduler is used).
If this variable is set to 0, event logging will be disabled.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_EVENTLOGGER_EXECUTORS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MESSAGE_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MESSAGE_TIMEOUT_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MESSAGE_TIMEOUT_SECS</pre>
<div class="block"><p>The maximum amount of time given to the topology to fully process a message emitted by a spout. If the message is not acked within this time frame, Storm will fail the message on the spout. Some spouts implementations will then replay the message at a later time.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_KRYO_REGISTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_KRYO_REGISTER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_KRYO_REGISTER</pre>
<div class="block"><p>A list of serialization registrations for Kryo ( <a href="https://github.com/EsotericSoftware/kryo">https://github.com/EsotericSoftware/kryo</a> ), the underlying serialization framework for Storm. A serialization can either be the name of a class (in which case Kryo will automatically create a serializer for the class that saves all the object&rsquo;s fields), or an implementation of com.esotericsoftware.kryo.Serializer.</p><p>See Kryo&rsquo;s documentation for more information about writing custom serializers.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_KRYO_REGISTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_KRYO_DECORATORS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_KRYO_DECORATORS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_KRYO_DECORATORS</pre>
<div class="block"><p>A list of classes that customize storm&rsquo;s kryo instance during start-up. Each listed class name must implement IKryoDecorator. During start-up the listed class is instantiated with 0 arguments, then its &lsquo;decorate&rsquo; method is called with storm&rsquo;s kryo instance as the only argument.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_KRYO_DECORATORS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_KRYO_FACTORY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_KRYO_FACTORY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_KRYO_FACTORY</pre>
<div class="block"><p>Class that specifies how to create a Kryo instance for serialization. Storm will then apply topology.kryo.register and topology.kryo.decorators on top of this. The default implementation implements topology.fall.back.on.java.serialization and turns references off.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_KRYO_FACTORY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SKIP_MISSING_KRYO_REGISTRATIONS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SKIP_MISSING_KRYO_REGISTRATIONS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SKIP_MISSING_KRYO_REGISTRATIONS</pre>
<div class="block"><p>Whether or not Storm should skip the loading of kryo registrations for which it does not know the class or have the serializer implementation. Otherwise, the task will fail to load and will throw an error at runtime. The use case of this is if you want to declare your serializations on the storm.yaml files on the cluster rather than every single time you submit a topology. Different applications may use different serializations and so a single application may not have the code for the other serializers used by other apps. By setting this config to true, Storm will ignore that it doesn&rsquo;t have those other serializations rather than throw an error.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SKIP_MISSING_KRYO_REGISTRATIONS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_STATE_KRYO_REGISTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_STATE_KRYO_REGISTER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_STATE_KRYO_REGISTER</pre>
<div class="block"><p>List of classes to register during state serialization.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_STATE_KRYO_REGISTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_METRICS_CONSUMER_REGISTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_METRICS_CONSUMER_REGISTER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_METRICS_CONSUMER_REGISTER</pre>
<div class="block"><p>A list of classes implementing IMetricsConsumer (See storm.yaml.example for exact config format). Each listed class will be routed all the metrics data generated by the storm metrics API. Each listed class maps 1:1 to a system bolt named __metrics_ClassName#N, and it&rsquo;s parallelism is configurable.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_METRICS_CONSUMER_REGISTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SERIALIZED_MESSAGE_SIZE_METRICS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SERIALIZED_MESSAGE_SIZE_METRICS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SERIALIZED_MESSAGE_SIZE_METRICS</pre>
<div class="block"><p>Enable tracking of network message byte counts per source-destination task. This is off by default as it creates tasks^2 metric values, but is useful for debugging as it exposes data skew when tuple sizes are uneven.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SERIALIZED_MESSAGE_SIZE_METRICS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_WORKER_METRICS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_WORKER_METRICS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_WORKER_METRICS</pre>
<div class="block"><p>A map of metric name to class name implementing IMetric that will be created once per worker JVM.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_WORKER_METRICS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_METRICS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_METRICS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> WORKER_METRICS</pre>
<div class="block"><p>A map of metric name to class name implementing IMetric that will be created once per worker JVM.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.WORKER_METRICS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MAX_TASK_PARALLELISM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MAX_TASK_PARALLELISM</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MAX_TASK_PARALLELISM</pre>
<div class="block"><p>The maximum parallelism allowed for a component in this topology. This configuration is typically used in testing to limit the number of threads spawned in local mode.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MAX_TASK_PARALLELISM">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MAX_SPOUT_PENDING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MAX_SPOUT_PENDING</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MAX_SPOUT_PENDING</pre>
<div class="block"><p>The maximum number of tuples that can be pending on a spout task at any given time. This config applies to individual tasks, not to spouts or topologies as a whole.</p><p>A pending tuple is one that has been emitted from a spout but has not been acked or failed yet. Note that this config parameter has no effect for unreliable spouts that don&rsquo;t tag their tuples with a message id.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MAX_SPOUT_PENDING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SLEEP_SPOUT_WAIT_STRATEGY_TIME_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SLEEP_SPOUT_WAIT_STRATEGY_TIME_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SLEEP_SPOUT_WAIT_STRATEGY_TIME_MS</pre>
<div class="block"><p>The amount of milliseconds the SleepEmptyEmitStrategy should sleep for.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SLEEP_SPOUT_WAIT_STRATEGY_TIME_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_STATE_SYNCHRONIZATION_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_STATE_SYNCHRONIZATION_TIMEOUT_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_STATE_SYNCHRONIZATION_TIMEOUT_SECS</pre>
<div class="block"><p>The maximum amount of time a component gives a source of state to synchronize before it requests synchronization again.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_STATE_SYNCHRONIZATION_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_STATS_SAMPLE_RATE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_STATS_SAMPLE_RATE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_STATS_SAMPLE_RATE</pre>
<div class="block"><p>The percentage of tuples to sample to produce stats for a task.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_STATS_SAMPLE_RATE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS</pre>
<div class="block"><p>The time period that builtin metrics data in bucketed into.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION</pre>
<div class="block"><p>Whether or not to use Java serialization in a topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_FALL_BACK_ON_JAVA_SERIALIZATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_WORKER_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_WORKER_CHILDOPTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_WORKER_CHILDOPTS</pre>
<div class="block"><p>Topology-specific options for the worker child process. This is used in addition to WORKER_CHILDOPTS.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_WORKER_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_WORKER_GC_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_WORKER_GC_CHILDOPTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_WORKER_GC_CHILDOPTS</pre>
<div class="block"><p>Topology-specific options GC for the worker child process. This overrides WORKER_GC_CHILDOPTS.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_WORKER_GC_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_WORKER_LOGWRITER_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_WORKER_LOGWRITER_CHILDOPTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_WORKER_LOGWRITER_CHILDOPTS</pre>
<div class="block"><p>Topology-specific options for the logwriter process of a worker.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_WORKER_LOGWRITER_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_CLASSPATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_CLASSPATH</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_CLASSPATH</pre>
<div class="block"><p>Topology-specific classpath for the worker child process. This is combined to the usual classpath.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_CLASSPATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_CLASSPATH_BEGINNING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_CLASSPATH_BEGINNING</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_CLASSPATH_BEGINNING</pre>
<div class="block"><p>Topology-specific classpath for the worker child process. This will be <em>prepended</em> to the usual classpath, meaning it can override the Storm classpath. This is for debugging purposes, and is disabled by default. To allow topologies to be submitted with user-first classpaths, set the storm.topology.classpath.beginning.enabled config to true.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_CLASSPATH_BEGINNING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ENVIRONMENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ENVIRONMENT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ENVIRONMENT</pre>
<div class="block"><p>Topology-specific environment variables for the worker child process. This is added to the existing environment (that of the supervisor)</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ENVIRONMENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_WINDOW_LENGTH_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_WINDOW_LENGTH_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_WINDOW_LENGTH_COUNT</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_WINDOW_LENGTH_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_WINDOW_LENGTH_DURATION_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_WINDOW_LENGTH_DURATION_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_WINDOW_LENGTH_DURATION_MS</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_WINDOW_LENGTH_DURATION_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_SLIDING_INTERVAL_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_SLIDING_INTERVAL_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_SLIDING_INTERVAL_COUNT</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_SLIDING_INTERVAL_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_SLIDING_INTERVAL_DURATION_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_SLIDING_INTERVAL_DURATION_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_SLIDING_INTERVAL_DURATION_MS</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_SLIDING_INTERVAL_DURATION_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_LATE_TUPLE_STREAM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_LATE_TUPLE_STREAM</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_LATE_TUPLE_STREAM</pre>
<div class="block"><p>Bolt-specific configuration for windowed bolts to specify the name of the stream on which late tuples are going to be emitted. This configuration should only be used from the BaseWindowedBolt.withLateTupleStream builder method, and not as global parameter, otherwise IllegalArgumentException is going to be thrown.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_LATE_TUPLE_STREAM">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_TUPLE_TIMESTAMP_MAX_LAG_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_TUPLE_TIMESTAMP_MAX_LAG_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_TUPLE_TIMESTAMP_MAX_LAG_MS</pre>
<div class="block"><p>Bolt-specific configuration for windowed bolts to specify the maximum time lag of the tuple timestamp in milliseconds. It means that the tuple timestamps cannot be out of order by more than this amount. This config will be effective only if <a href="../../../org/apache/storm/windowing/TimestampExtractor.html" title="interface in org.apache.storm.windowing"><code>TimestampExtractor</code></a> is specified.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_TUPLE_TIMESTAMP_MAX_LAG_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_WATERMARK_EVENT_INTERVAL_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_WATERMARK_EVENT_INTERVAL_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_WATERMARK_EVENT_INTERVAL_MS</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_WATERMARK_EVENT_INTERVAL_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLTS_MESSAGE_ID_FIELD_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLTS_MESSAGE_ID_FIELD_NAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLTS_MESSAGE_ID_FIELD_NAME</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLTS_MESSAGE_ID_FIELD_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TRANSACTIONAL_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TRANSACTIONAL_ID</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TRANSACTIONAL_ID</pre>
<div class="block"><p>This config is available for TransactionalSpouts, and contains the id ( a String) for the transactional topology. This id is used to store the state of the transactional topology in Zookeeper.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TRANSACTIONAL_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_AUTO_TASK_HOOKS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_AUTO_TASK_HOOKS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_AUTO_TASK_HOOKS</pre>
<div class="block"><p>A list of task hooks that are automatically added to every spout and bolt in the topology. An example of when you&rsquo;d do this is to add a hook that integrates with your internal monitoring system. These hooks are instantiated using the zero-arg constructor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_AUTO_TASK_HOOKS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_EXECUTOR_RECEIVE_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_EXECUTOR_RECEIVE_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_EXECUTOR_RECEIVE_BUFFER_SIZE</pre>
<div class="block"><p>The size of the receive queue for each executor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_EXECUTOR_RECEIVE_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TRANSFER_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TRANSFER_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TRANSFER_BUFFER_SIZE</pre>
<div class="block"><p>The size of the transfer queue for each worker.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TRANSFER_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TRANSFER_BATCH_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TRANSFER_BATCH_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TRANSFER_BATCH_SIZE</pre>
<div class="block"><p>The size of the transfer queue for each worker.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TRANSFER_BATCH_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TICK_TUPLE_FREQ_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TICK_TUPLE_FREQ_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TICK_TUPLE_FREQ_SECS</pre>
<div class="block"><p>How often a tick tuple from the &ldquo;_<em>system&ldquo; component and &rdquo;</em>_tick&rdquo; stream should be sent to tasks. Meant to be used as a component-specific configuration.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TICK_TUPLE_FREQ_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_PRODUCER_BATCH_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_PRODUCER_BATCH_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_PRODUCER_BATCH_SIZE</pre>
<div class="block"><p>The number of tuples to batch before sending to the destination executor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_PRODUCER_BATCH_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_EXECUTOR_OVERFLOW_LIMIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_EXECUTOR_OVERFLOW_LIMIT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_EXECUTOR_OVERFLOW_LIMIT</pre>
<div class="block"><p>If number of items in task&rsquo;s overflowQ exceeds this, new messages coming from other workers to this task will be dropped This prevents OutOfMemoryException that can occur in rare scenarios in the presence of BackPressure. This affects only inter-worker messages. Messages originating from within the same worker will not be dropped.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_EXECUTOR_OVERFLOW_LIMIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BACKPRESSURE_CHECK_MILLIS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BACKPRESSURE_CHECK_MILLIS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BACKPRESSURE_CHECK_MILLIS</pre>
<div class="block"><p>How often a worker should check and notify upstream workers about its tasks that are no longer experiencing BP and able to receive new messages</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BACKPRESSURE_CHECK_MILLIS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BATCH_FLUSH_INTERVAL_MILLIS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BATCH_FLUSH_INTERVAL_MILLIS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BATCH_FLUSH_INTERVAL_MILLIS</pre>
<div class="block"><p>How often to send flush tuple to the executors for flushing out batched events.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BATCH_FLUSH_INTERVAL_MILLIS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_WORKER_SHARED_THREAD_POOL_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_WORKER_SHARED_THREAD_POOL_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_WORKER_SHARED_THREAD_POOL_SIZE</pre>
<div class="block"><p>The size of the shared thread pool for worker tasks to make use of. The thread pool can be accessed via the TopologyContext.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_WORKER_SHARED_THREAD_POOL_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS</pre>
<div class="block"><p>The interval in seconds to use for determining whether to throttle error reported to Zookeeper. For example, an interval of 10 seconds with topology.max.error.report.per.interval set to 5 will only allow 5 errors to be reported to Zookeeper per task for every 10 second interval of time.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MAX_ERROR_REPORT_PER_INTERVAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MAX_ERROR_REPORT_PER_INTERVAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MAX_ERROR_REPORT_PER_INTERVAL</pre>
<div class="block"><p>See doc for TOPOLOGY_ERROR_THROTTLE_INTERVAL_SECS</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MAX_ERROR_REPORT_PER_INTERVAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TRIDENT_BATCH_EMIT_INTERVAL_MILLIS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TRIDENT_BATCH_EMIT_INTERVAL_MILLIS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TRIDENT_BATCH_EMIT_INTERVAL_MILLIS</pre>
<div class="block"><p>How often a batch can be emitted in a Trident topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TRIDENT_BATCH_EMIT_INTERVAL_MILLIS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_TRIDENT_WINDOWING_INMEMORY_CACHE_LIMIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_TRIDENT_WINDOWING_INMEMORY_CACHE_LIMIT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_TRIDENT_WINDOWING_INMEMORY_CACHE_LIMIT</pre>
<div class="block"><p>Maximum number of tuples that can be stored inmemory cache in windowing operators for fast access without fetching them from store.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_TRIDENT_WINDOWING_INMEMORY_CACHE_LIMIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ID</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ID</pre>
<div class="block"><p>The id assigned to a running topology. The id is the storm name with a unique nonce appended.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_NAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_NAME</pre>
<div class="block"><p>Name of the topology. This config is automatically set by Storm when the topology is submitted.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SUBMITTER_PRINCIPAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SUBMITTER_PRINCIPAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SUBMITTER_PRINCIPAL</pre>
<div class="block"><p>The principal who submitted a topology</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SUBMITTER_PRINCIPAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SUBMITTER_USER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SUBMITTER_USER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SUBMITTER_USER</pre>
<div class="block"><p>The local user name of the user who submitted a topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SUBMITTER_USER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_AUTO_CREDENTIALS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_AUTO_CREDENTIALS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_AUTO_CREDENTIALS</pre>
<div class="block"><p>A list of IAutoCredentials that the topology should load and use.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_AUTO_CREDENTIALS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SHELLBOLT_MAX_PENDING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SHELLBOLT_MAX_PENDING</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SHELLBOLT_MAX_PENDING</pre>
<div class="block"><p>Max pending tuples in one ShellBolt</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SHELLBOLT_MAX_PENDING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SUBPROCESS_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SUBPROCESS_TIMEOUT_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SUBPROCESS_TIMEOUT_SECS</pre>
<div class="block"><p>How long a subprocess can go without heartbeating before the ShellSpout/ShellBolt tries to suicide itself.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SUBPROCESS_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_LOGGING_SENSITIVITY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_LOGGING_SENSITIVITY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_LOGGING_SENSITIVITY</pre>
<div class="block"><p>Topology central logging sensitivity to determine who has access to logs in central logging system. The possible values are: S0 - Public (open to all users on grid) S1 - Restricted S2 - Confidential S3 - Secret (default.)</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_LOGGING_SENSITIVITY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_LOGGING_CONFIG_FILE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_LOGGING_CONFIG_FILE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_LOGGING_CONFIG_FILE</pre>
<div class="block"><p>Log file the user can use to configure Log4j2. Can be a resource in the jar (specified with classpath:/path/to/resource) or a file. This configuration is applied in addition to the regular worker log4j2 configuration. The configs are merged according to the rules here:  <a href="https://logging.apache.org/log4j/2.x/manual/configuration.html#CompositeConfiguration">https://logging.apache.org/log4j/2.x/manual/configuration.html#CompositeConfiguration</a></p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_LOGGING_CONFIG_FILE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_PRIORITY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_PRIORITY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_PRIORITY</pre>
<div class="block"><p>Sets the priority for a topology</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_PRIORITY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRANSACTIONAL_ZOOKEEPER_ROOT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRANSACTIONAL_ZOOKEEPER_ROOT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TRANSACTIONAL_ZOOKEEPER_ROOT</pre>
<div class="block"><p>The root directory in ZooKeeper for metadata about TransactionalSpouts.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TRANSACTIONAL_ZOOKEEPER_ROOT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRANSACTIONAL_ZOOKEEPER_SERVERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRANSACTIONAL_ZOOKEEPER_SERVERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TRANSACTIONAL_ZOOKEEPER_SERVERS</pre>
<div class="block"><p>The list of zookeeper servers in which to keep the transactional state. If null (which is default), will use storm.zookeeper.servers</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TRANSACTIONAL_ZOOKEEPER_SERVERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRANSACTIONAL_ZOOKEEPER_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRANSACTIONAL_ZOOKEEPER_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TRANSACTIONAL_ZOOKEEPER_PORT</pre>
<div class="block"><p>The port to use to connect to the transactional zookeeper servers. If null (which is default), will use storm.zookeeper.port</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TRANSACTIONAL_ZOOKEEPER_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_DO_AS_USER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_DO_AS_USER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_DO_AS_USER</pre>
<div class="block"><p>The user as which the nimbus client should be acquired to perform the operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_DO_AS_USER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_ISOLATED_MACHINES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_ISOLATED_MACHINES</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_ISOLATED_MACHINES</pre>
<div class="block"><p>The number of machines that should be used by this topology to isolate it from all others. Set storm.scheduler to org.apache.storm.scheduler.multitenant.MultitenantScheduler</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_ISOLATED_MACHINES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SPOUT_WAIT_STRATEGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SPOUT_WAIT_STRATEGY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SPOUT_WAIT_STRATEGY</pre>
<div class="block"><p>A class that implements a wait strategy for spout. Waiting is triggered in one of two conditions:</p>
<ol>
  <li>nextTuple emits no tuples 2. The spout has hit maxSpoutPending and can&rsquo;t emit any more tuples</li>
</ol><p>This class must implement <a href="../../../org/apache/storm/policy/IWaitStrategy.html" title="interface in org.apache.storm.policy"><code>IWaitStrategy</code></a>.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SPOUT_WAIT_STRATEGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SPOUT_WAIT_PARK_MICROSEC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SPOUT_WAIT_PARK_MICROSEC</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SPOUT_WAIT_PARK_MICROSEC</pre>
<div class="block"><p>Configures park time for WaitStrategyPark for spout. If set to 0, returns immediately (i.e busy wait).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SPOUT_WAIT_PARK_MICROSEC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL1_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL1_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL1_COUNT</pre>
<div class="block"><p>Configures number of iterations to spend in level 1 of WaitStrategyProgressive, before progressing to level 2</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL1_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL2_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL2_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL2_COUNT</pre>
<div class="block"><p>Configures number of iterations to spend in level 2 of WaitStrategyProgressive, before progressing to level 3</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL2_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</pre>
<div class="block"><p>Configures sleep time for WaitStrategyProgressive.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SPOUT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLT_WAIT_STRATEGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLT_WAIT_STRATEGY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLT_WAIT_STRATEGY</pre>
<div class="block"><p>Selects the Bolt&rsquo;s Wait Strategy to use when there are no incoming msgs. Used to trade off latency vs CPU usage. This class must implement <a href="../../../org/apache/storm/policy/IWaitStrategy.html" title="interface in org.apache.storm.policy"><code>IWaitStrategy</code></a>.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLT_WAIT_STRATEGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLT_WAIT_PARK_MICROSEC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLT_WAIT_PARK_MICROSEC</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLT_WAIT_PARK_MICROSEC</pre>
<div class="block"><p>Configures park time for WaitStrategyPark. If set to 0, returns immediately (i.e busy wait).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLT_WAIT_PARK_MICROSEC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL1_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL1_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL1_COUNT</pre>
<div class="block"><p>Configures number of iterations to spend in level 1 of WaitStrategyProgressive, before progressing to level 2</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL1_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL2_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL2_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL2_COUNT</pre>
<div class="block"><p>Configures number of iterations to spend in level 2 of WaitStrategyProgressive, before progressing to level 3</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL2_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</pre>
<div class="block"><p>Configures sleep time for WaitStrategyProgressive.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BOLT_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BACKPRESSURE_WAIT_STRATEGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BACKPRESSURE_WAIT_STRATEGY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BACKPRESSURE_WAIT_STRATEGY</pre>
<div class="block"><p>A class that implements a wait strategy for an upstream component (spout/bolt) trying to write to a downstream component whose recv queue is full</p>
<ol>
  <li>nextTuple emits no tuples 2. The spout has hit maxSpoutPending and can&rsquo;t emit any more tuples</li>
</ol><p>This class must implement <a href="../../../org/apache/storm/policy/IWaitStrategy.html" title="interface in org.apache.storm.policy"><code>IWaitStrategy</code></a>.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BACKPRESSURE_WAIT_STRATEGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BACKPRESSURE_WAIT_PARK_MICROSEC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BACKPRESSURE_WAIT_PARK_MICROSEC</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BACKPRESSURE_WAIT_PARK_MICROSEC</pre>
<div class="block"><p>Configures park time if using WaitStrategyPark for BackPressure. If set to 0, returns immediately (i.e busy wait).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BACKPRESSURE_WAIT_PARK_MICROSEC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS</pre>
<div class="block"><p>Configures sleep time if using WaitStrategyProgressive for BackPressure.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL3_SLEEP_MILLIS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL1_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL1_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL1_COUNT</pre>
<div class="block"><p>Configures steps used to determine progression to the next level of wait .. if using WaitStrategyProgressive for BackPressure.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL1_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL2_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL2_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL2_COUNT</pre>
<div class="block"><p>Configures steps used to determine progression to the next level of wait .. if using WaitStrategyProgressive for BackPressure.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_BACKPRESSURE_WAIT_PROGRESSIVE_LEVEL2_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_SPOUT_RECVQ_SKIPS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_SPOUT_RECVQ_SKIPS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_SPOUT_RECVQ_SKIPS</pre>
<div class="block"><p>Check recvQ after every N invocations of Spout&rsquo;s nextTuple() [when ACKing is disabled]. Spouts receive very few msgs if ACK is disabled. This avoids checking the recvQ after each nextTuple().</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_SPOUT_RECVQ_SKIPS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MIN_REPLICATION_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MIN_REPLICATION_COUNT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MIN_REPLICATION_COUNT</pre>
<div class="block"><p>Minimum number of nimbus hosts where the code must be replicated before leader nimbus is allowed to perform topology activation tasks like setting up heartbeats/assignments and marking the topology as active. default is 0.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MIN_REPLICATION_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TOPOLOGY_MAX_REPLICATION_WAIT_TIME_SEC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TOPOLOGY_MAX_REPLICATION_WAIT_TIME_SEC</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TOPOLOGY_MAX_REPLICATION_WAIT_TIME_SEC</pre>
<div class="block"><p>Maximum wait time for the nimbus host replication to achieve the nimbus.min.replication.count. Once this time is elapsed nimbus will go ahead and perform topology activation tasks even if required nimbus.min.replication.count is not achieved. The default is 0 seconds, a value of -1 indicates to wait for ever.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TOPOLOGY_MAX_REPLICATION_WAIT_TIME_SEC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PACEMAKER_SERVERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PACEMAKER_SERVERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PACEMAKER_SERVERS</pre>
<div class="block"><p>The list of servers that Pacemaker is running on.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.PACEMAKER_SERVERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PACEMAKER_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PACEMAKER_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PACEMAKER_PORT</pre>
<div class="block"><p>The port Pacemaker should run on. Clients should connect to this port to submit or read heartbeats.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.PACEMAKER_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PACEMAKER_CLIENT_MAX_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PACEMAKER_CLIENT_MAX_THREADS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PACEMAKER_CLIENT_MAX_THREADS</pre>
<div class="block"><p>The maximum number of threads that should be used by the Pacemaker client. When Pacemaker gets loaded it will spawn new threads, up to this many total, to handle the load.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.PACEMAKER_CLIENT_MAX_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PACEMAKER_AUTH_METHOD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PACEMAKER_AUTH_METHOD</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PACEMAKER_AUTH_METHOD</pre>
<div class="block"><p>This should be one of &ldquo;DIGEST&rdquo;, &ldquo;KERBEROS&rdquo;, or &ldquo;NONE&rdquo; Determines the mode of authentication the pacemaker server and client use. The client must either match the server, or be NONE. In the case of NONE, no authentication is performed for the client, and if the server is running with DIGEST or KERBEROS, the client can only write to the server (no reads). This is intended to provide a primitive form of access-control.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.PACEMAKER_AUTH_METHOD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PACEMAKER_THRIFT_MESSAGE_SIZE_MAX">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PACEMAKER_THRIFT_MESSAGE_SIZE_MAX</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> PACEMAKER_THRIFT_MESSAGE_SIZE_MAX</pre>
<div class="block"><p>Pacemaker Thrift Max Message Size (bytes).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.PACEMAKER_THRIFT_MESSAGE_SIZE_MAX">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_GROUP_MAPPING_SERVICE_CACHE_DURATION_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_GROUP_MAPPING_SERVICE_CACHE_DURATION_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_GROUP_MAPPING_SERVICE_CACHE_DURATION_SECS</pre>
<div class="block"><p>Max no.of seconds group mapping service will cache user groups</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_GROUP_MAPPING_SERVICE_CACHE_DURATION_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_SERVERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_SERVERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_SERVERS</pre>
<div class="block"><p>List of DRPC servers so that the DRPCSpout knows who to talk to.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_SERVERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_INVOCATIONS_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_INVOCATIONS_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_INVOCATIONS_PORT</pre>
<div class="block"><p>This port on Storm DRPC is used by DRPC topologies to receive function invocations and send results back.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_INVOCATIONS_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_NIMBUS_RETRY_TIMES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NIMBUS_RETRY_TIMES</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_NIMBUS_RETRY_TIMES</pre>
<div class="block"><p>The number of times to retry a Nimbus operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_NIMBUS_RETRY_TIMES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_NIMBUS_RETRY_INTERVAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NIMBUS_RETRY_INTERVAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_NIMBUS_RETRY_INTERVAL</pre>
<div class="block"><p>The starting interval between exponential backoff retries of a Nimbus operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_NIMBUS_RETRY_INTERVAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_NIMBUS_RETRY_INTERVAL_CEILING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NIMBUS_RETRY_INTERVAL_CEILING</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_NIMBUS_RETRY_INTERVAL_CEILING</pre>
<div class="block"><p>The ceiling of the interval between retries of a client connect to Nimbus operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_NIMBUS_RETRY_INTERVAL_CEILING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_THRIFT_TRANSPORT_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_THRIFT_TRANSPORT_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_THRIFT_TRANSPORT_PLUGIN</pre>
<div class="block"><p>The Nimbus transport plug-in for Thrift client/server communication</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_THRIFT_TRANSPORT_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_THRIFT_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_THRIFT_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_THRIFT_PORT</pre>
<div class="block"><p>Which port the Thrift interface of Nimbus should run on. Clients should connect to this port to upload jars and submit topologies.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_THRIFT_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_QUEUE_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_QUEUE_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_QUEUE_SIZE</pre>
<div class="block"><p>Nimbus thrift server queue size, default is 100000. This is the request queue size , when there are more requests than number of threads to serve the requests, those requests will be queued to this queue. If the request queue size &gt; this config, then the incoming requests will be rejected.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_QUEUE_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_LOCAL_ASSIGNMENTS_BACKEND_CLASS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_LOCAL_ASSIGNMENTS_BACKEND_CLASS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_LOCAL_ASSIGNMENTS_BACKEND_CLASS</pre>
<div class="block"><p>Nimbus assignments backend for storing local assignments. We will use it to store physical plan and runtime storm ids.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_LOCAL_ASSIGNMENTS_BACKEND_CLASS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_THRIFT_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_THRIFT_THREADS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_THRIFT_THREADS</pre>
<div class="block"><p>The number of threads that should be used by the nimbus thrift server.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_THRIFT_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_THRIFT_MAX_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_THRIFT_MAX_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_THRIFT_MAX_BUFFER_SIZE</pre>
<div class="block"><p>The maximum buffer size thrift should use when reading messages.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_THRIFT_MAX_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_THRIFT_SOCKET_TIMEOUT_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_THRIFT_SOCKET_TIMEOUT_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_THRIFT_SOCKET_TIMEOUT_MS</pre>
<div class="block"><p>How long before a Thrift Client socket hangs before timeout and restart the socket.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_THRIFT_SOCKET_TIMEOUT_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_THRIFT_TRANSPORT_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_THRIFT_TRANSPORT_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_THRIFT_TRANSPORT_PLUGIN</pre>
<div class="block"><p>The DRPC transport plug-in for Thrift client/server communication</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_THRIFT_TRANSPORT_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_PORT</pre>
<div class="block"><p>This port is used by Storm DRPC for receiving DPRC requests from clients.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_QUEUE_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_QUEUE_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_QUEUE_SIZE</pre>
<div class="block"><p>DRPC thrift server queue size</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_QUEUE_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_WORKER_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_WORKER_THREADS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_WORKER_THREADS</pre>
<div class="block"><p>DRPC thrift server worker threads</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_WORKER_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_MAX_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_MAX_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_MAX_BUFFER_SIZE</pre>
<div class="block"><p>The maximum buffer size thrift should use when reading messages for DRPC.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_MAX_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_INVOCATIONS_THRIFT_TRANSPORT_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_INVOCATIONS_THRIFT_TRANSPORT_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_INVOCATIONS_THRIFT_TRANSPORT_PLUGIN</pre>
<div class="block"><p>The DRPC invocations transport plug-in for Thrift client/server communication</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_INVOCATIONS_THRIFT_TRANSPORT_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_INVOCATIONS_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_INVOCATIONS_THREADS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_INVOCATIONS_THREADS</pre>
<div class="block"><p>DRPC invocations thrift server worker threads</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DRPC_INVOCATIONS_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_GROUP_MAPPING_SERVICE_PARAMS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_GROUP_MAPPING_SERVICE_PARAMS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_GROUP_MAPPING_SERVICE_PARAMS</pre>
<div class="block"><p>Initialization parameters for the group mapping service plugin. Provides a way for a</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_GROUP_MAPPING_SERVICE_PARAMS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_THRIFT_TRANSPORT_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_THRIFT_TRANSPORT_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_THRIFT_TRANSPORT_PLUGIN</pre>
<div class="block"><p>The default transport plug-in for Thrift client/server communication</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_THRIFT_TRANSPORT_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_TIMEOUT_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_TIMEOUT_SECS</pre>
<div class="block"><p>How long a worker can go without heartbeating before the supervisor tries to restart the worker process.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_SHUTDOWN_SLEEP_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_SHUTDOWN_SLEEP_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_SHUTDOWN_SLEEP_SECS</pre>
<div class="block"><p>How many seconds to allow for graceful worker shutdown when killing workers before resorting to force kill. If a worker fails to shut down gracefully within this delay, it will either suicide or be forcibly killed by the supervisor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_SHUTDOWN_SLEEP_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_SERVERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_SERVERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_SERVERS</pre>
<div class="block"><p>A list of hosts of ZooKeeper servers used to manage the cluster.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_SERVERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_PORT</pre>
<div class="block"><p>The port Storm will use to connect to each of the ZooKeeper servers.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_SUPERACL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_SUPERACL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_SUPERACL</pre>
<div class="block"><p>This is part of a temporary workaround to a ZK bug, it is the &lsquo;scheme:acl&rsquo; for the user Nimbus and Supervisors use to authenticate with ZK.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_SUPERACL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_DRPC_ACL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_DRPC_ACL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_DRPC_ACL</pre>
<div class="block"><p>The ACL of the drpc user in zookeeper so the drpc servers can verify worker tokens.</p><p>Should be in the form &lsquo;scheme:acl&rsquo; just like STORM_ZOOKEEPER_SUPERACL.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_DRPC_ACL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_TOPOLOGY_AUTH_SCHEME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_TOPOLOGY_AUTH_SCHEME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_TOPOLOGY_AUTH_SCHEME</pre>
<div class="block"><p>The topology Zookeeper authentication scheme to use, e.g. &ldquo;digest&rdquo;. It is the internal config and user shouldn&rsquo;t set it.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_TOPOLOGY_AUTH_SCHEME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_META_SERIALIZATION_DELEGATE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_META_SERIALIZATION_DELEGATE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_META_SERIALIZATION_DELEGATE</pre>
<div class="block"><p>The delegate for serializing metadata, should be used for serialized objects stored in zookeeper and on disk. This is NOT used for compressing serialized tuples sent between topologies.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_META_SERIALIZATION_DELEGATE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_METRICS_REPORTERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_METRICS_REPORTERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_METRICS_REPORTERS</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_METRICS_REPORTERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CLIENT_BLOBSTORE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CLIENT_BLOBSTORE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> CLIENT_BLOBSTORE</pre>
<div class="block"><p>What blobstore implementation the storm client should use.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.CLIENT_BLOBSTORE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLOBSTORE_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLOBSTORE_DIR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> BLOBSTORE_DIR</pre>
<div class="block"><p>What directory to use for the blobstore. The directory is expected to be an absolute path when using HDFS blobstore, for LocalFsBlobStore it could be either absolute or relative. If the setting is a relative directory, it is relative to root directory of Storm installation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.BLOBSTORE_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLOBSTORE_CLEANUP_ENABLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLOBSTORE_CLEANUP_ENABLE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> BLOBSTORE_CLEANUP_ENABLE</pre>
<div class="block"><p>Enable the blobstore cleaner. Certain blobstores may only want to run the cleaner on one daemon. Currently Nimbus handles setting this.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.BLOBSTORE_CLEANUP_ENABLE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLOBSTORE_HDFS_PRINCIPAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLOBSTORE_HDFS_PRINCIPAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> BLOBSTORE_HDFS_PRINCIPAL</pre>
<div class="block"><p>principal for nimbus/supervisor to use to access secure hdfs for the blobstore. The format is generally &ldquo;primary/instance@REALM&rdquo;, where &ldquo;instance&rdquo; field is optional. If the instance field of the principal is the string &ldquo;_HOST&rdquo;, it will  + be replaced with the host name of the server the daemon is running on (by calling <a href="../../../org/apache/storm/Config.html#getBlobstoreHDFSPrincipal-java.util.Map-"><code>getBlobstoreHDFSPrincipal(Map conf)</code></a> method).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.BLOBSTORE_HDFS_PRINCIPAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLOBSTORE_HDFS_KEYTAB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLOBSTORE_HDFS_KEYTAB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> BLOBSTORE_HDFS_KEYTAB</pre>
<div class="block"><p>keytab for nimbus/supervisor to use to access secure hdfs for the blobstore.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.BLOBSTORE_HDFS_KEYTAB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_BLOBSTORE_REPLICATION_FACTOR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_BLOBSTORE_REPLICATION_FACTOR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_BLOBSTORE_REPLICATION_FACTOR</pre>
<div class="block"><p>Set replication factor for a blob in HDFS Blobstore Implementation</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_BLOBSTORE_REPLICATION_FACTOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_LOCAL_HOSTNAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_LOCAL_HOSTNAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_LOCAL_HOSTNAME</pre>
<div class="block"><p>The hostname the supervisors/workers should report to nimbus. If unset, Storm will get the hostname to report by calling <code>InetAddress.getLocalHost().getCanonicalHostName()</code>.</p><p>You should set this config when you don&rsquo;t have a DNS which supervisors/workers can utilize to find each other based on hostname got from calls to <code>InetAddress.getLocalHost().getCanonicalHostName()</code>.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_LOCAL_HOSTNAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_SEEDS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_SEEDS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_SEEDS</pre>
<div class="block"><p>List of seed nimbus hosts to use for leader nimbus discovery.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_SEEDS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_USERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_USERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_USERS</pre>
<div class="block"><p>A list of users that are the only ones allowed to run user operation on storm cluster. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_USERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_GROUPS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_GROUPS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_GROUPS</pre>
<div class="block"><p>A list of groups , users belong to these groups are the only ones allowed to run user operation on storm cluster. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_GROUPS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_CLUSTER_MODE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CLUSTER_MODE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_CLUSTER_MODE</pre>
<div class="block"><p>The mode this Storm cluster is running in. Either &ldquo;distributed&rdquo; or &ldquo;local&rdquo;.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_CLUSTER_MODE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_ROOT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_ROOT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_ROOT</pre>
<div class="block"><p>The root location at which Storm stores data in ZooKeeper.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_ROOT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_TOPOLOGY_AUTH_PAYLOAD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_TOPOLOGY_AUTH_PAYLOAD</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_TOPOLOGY_AUTH_PAYLOAD</pre>
<div class="block"><p>A string representing the payload for topology Zookeeper authentication. It gets serialized using UTF-8 encoding during authentication.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_TOPOLOGY_AUTH_PAYLOAD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_AUTH_SCHEME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_AUTH_SCHEME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_AUTH_SCHEME</pre>
<div class="block"><p>The cluster Zookeeper authentication scheme to use, e.g. &ldquo;digest&rdquo;. Defaults to no authentication.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_AUTH_SCHEME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_AUTH_PAYLOAD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_AUTH_PAYLOAD</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_AUTH_PAYLOAD</pre>
<div class="block"><p>A string representing the payload for cluster Zookeeper authentication. It gets serialized using UTF-8 encoding during authentication. Note that if this is set to something with a secret (as when using digest authentication) then it should only be set in the storm-cluster-auth.yaml file. This file storm-cluster-auth.yaml should then be protected with appropriate permissions that deny access from workers.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_AUTH_PAYLOAD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_NETWORK_TOPOGRAPHY_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NETWORK_TOPOGRAPHY_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_NETWORK_TOPOGRAPHY_PLUGIN</pre>
<div class="block"><p>What Network Topography detection classes should we use. Given a list of supervisor hostnames (or IP addresses), this class would return a list of rack names that correspond to the supervisors. This information is stored in Cluster.java, and is used in the resource aware scheduler.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_NETWORK_TOPOGRAPHY_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_GC_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_GC_CHILDOPTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> WORKER_GC_CHILDOPTS</pre>
<div class="block"><p>The jvm opts provided to workers launched by this supervisor for GC. All &ldquo;%ID%&rdquo; substrings are replaced with an identifier for this worker. Because the JVM complains about multiple GC opts the topology can override this default value by setting topology.worker.gc.childopts.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.WORKER_GC_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_CHILDOPTS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> WORKER_CHILDOPTS</pre>
<div class="block"><p>The jvm opts provided to workers launched by this supervisor. All &ldquo;%ID%&rdquo;, &ldquo;%WORKER-ID%&rdquo;, &ldquo;%TOPOLOGY-ID%&rdquo;, &ldquo;%WORKER-PORT%&rdquo; and &ldquo;%HEAP-MEM%&rdquo; substrings are replaced with: %ID% -&gt; port (for backward compatibility), %WORKER-ID% -&gt; worker-id, %TOPOLOGY-ID% -&gt; topology-id, %WORKER-PORT% -&gt; port. %HEAP-MEM% -&gt; mem-onheap.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.WORKER_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_HEAP_MEMORY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_HEAP_MEMORY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> WORKER_HEAP_MEMORY_MB</pre>
<div class="block"><p>The default heap memory size in MB per worker, used in the jvm -Xmx opts for launching the worker</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.WORKER_HEAP_MEMORY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_MEMORY_CAPACITY_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_MEMORY_CAPACITY_MB</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_MEMORY_CAPACITY_MB</pre>
<div class="block"><p>The total amount of memory (in MiB) a supervisor is allowed to give to its workers. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_MEMORY_CAPACITY_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_CPU_CAPACITY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_CPU_CAPACITY</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_CPU_CAPACITY</pre>
<div class="block"><p>The total amount of CPU resources a supervisor is allowed to give to its workers. By convention 1 cpu core should be about 100, but this can be adjusted if needed using 100 makes it simple to set the desired value to the capacity measurement for single threaded bolts. A default value will be set for this config if user does not override</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_CPU_CAPACITY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_THRIFT_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_THRIFT_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_THRIFT_PORT</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_THRIFT_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_THRIFT_TRANSPORT_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_THRIFT_TRANSPORT_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_THRIFT_TRANSPORT_PLUGIN</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_THRIFT_TRANSPORT_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_QUEUE_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_QUEUE_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_QUEUE_SIZE</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_QUEUE_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_THRIFT_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_THRIFT_THREADS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_THRIFT_THREADS</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_THRIFT_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_THRIFT_MAX_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_THRIFT_MAX_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_THRIFT_MAX_BUFFER_SIZE</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_THRIFT_MAX_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_THRIFT_SOCKET_TIMEOUT_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_THRIFT_SOCKET_TIMEOUT_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_THRIFT_SOCKET_TIMEOUT_MS</pre>
<div class="block"><p>How long before a supervisor Thrift Client socket hangs before timeout and restart the socket.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_THRIFT_SOCKET_TIMEOUT_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_RESOURCES_MAP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_RESOURCES_MAP</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_RESOURCES_MAP</pre>
<div class="block"><p>A map of resources the Supervisor has e.g {&ldquo;cpu.pcore.percent&rdquo; : 200.0. &ldquo;onheap.memory.mb&rdquo;: 256.0, &ldquo;gpu.count&rdquo; : 2.0 }</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_RESOURCES_MAP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_LOCAL_MODE_ZMQ">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_LOCAL_MODE_ZMQ</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_LOCAL_MODE_ZMQ</pre>
<div class="block"><p>Whether or not to use ZeroMQ for messaging in local mode. If this is set to false, then Storm will use a pure-Java messaging system. The purpose of this flag is to make it easy to run Storm in local mode by eliminating the need for native dependencies, which can be difficult to install.</p><p>Defaults to false.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_LOCAL_MODE_ZMQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_TRANSPORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_TRANSPORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_TRANSPORT</pre>
<div class="block"><p>The transporter for communication among Storm tasks</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_TRANSPORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_AUTHENTICATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_AUTHENTICATION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_AUTHENTICATION</pre>
<div class="block"><p>Netty based messaging: Is authentication required for Netty messaging from client worker process to server worker process.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_AUTHENTICATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_BUFFER_SIZE</pre>
<div class="block"><p>Netty based messaging: The buffer size for send/recv buffer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_BUFFER_HIGH_WATERMARK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_BUFFER_HIGH_WATERMARK</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_BUFFER_HIGH_WATERMARK</pre>
<div class="block"><p>Netty based messaging: The netty write buffer high watermark in bytes. <p> If the number of bytes queued in the netty&rsquo;s write buffer exceeds this value, the netty <code>Channel.isWritable()</code> will start to return <code>false</code>. The client will wait until the value falls below the <a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_BUFFER_LOW_WATERMARK">low water mark</a>. </p></p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_BUFFER_HIGH_WATERMARK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_BUFFER_LOW_WATERMARK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_BUFFER_LOW_WATERMARK</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_BUFFER_LOW_WATERMARK</pre>
<div class="block"><p>Netty based messaging: The netty write buffer low watermark in bytes. <p> Once the number of bytes queued in the write buffer exceeded the <a href="../../../org/apache/storm/Config.html#STORM_MESSAGING_NETTY_BUFFER_HIGH_WATERMARK">high water
mark</a> and then dropped down below this value, the netty <code>Channel.isWritable()</code> will start to return true. </p></p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_BUFFER_LOW_WATERMARK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_SOCKET_BACKLOG">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_SOCKET_BACKLOG</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_SOCKET_BACKLOG</pre>
<div class="block"><p>Netty based messaging: Sets the backlog value to specify when the channel binds to a local address</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_SOCKET_BACKLOG">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS</pre>
<div class="block"><p>Netty based messaging: The # of worker threads for the server.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_NETTY_MESSAGE_BATCH_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NETTY_MESSAGE_BATCH_SIZE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_NETTY_MESSAGE_BATCH_SIZE</pre>
<div class="block"><p>If the Netty messaging layer is busy, the Netty client will try to batch message as more as possible up to the size of STORM_NETTY_MESSAGE_BATCH_SIZE bytes</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_NETTY_MESSAGE_BATCH_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_MIN_SLEEP_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_MIN_SLEEP_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_MIN_SLEEP_MS</pre>
<div class="block"><p>Netty based messaging: The min # of milliseconds that a peer will wait.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_MIN_SLEEP_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_MAX_SLEEP_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_MAX_SLEEP_MS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_MAX_SLEEP_MS</pre>
<div class="block"><p>Netty based messaging: The max # of milliseconds that a peer will wait.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_MAX_SLEEP_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_MESSAGING_NETTY_CLIENT_WORKER_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_MESSAGING_NETTY_CLIENT_WORKER_THREADS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_MESSAGING_NETTY_CLIENT_WORKER_THREADS</pre>
<div class="block"><p>Netty based messaging: The # of worker threads for the client.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_MESSAGING_NETTY_CLIENT_WORKER_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_RUN_WORKER_AS_USER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_RUN_WORKER_AS_USER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_RUN_WORKER_AS_USER</pre>
<div class="block"><p>Should the supervior try to run the worker as the lauching user or not. Defaults to false.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_RUN_WORKER_AS_USER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_HEARTBEATS_MAX_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_HEARTBEATS_MAX_TIMEOUT_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_HEARTBEATS_MAX_TIMEOUT_SECS</pre>
<div class="block"><p>max timeout for supervisor reported heartbeats when master gains leadership</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_HEARTBEATS_MAX_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DISABLE_SYMLINKS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DISABLE_SYMLINKS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DISABLE_SYMLINKS</pre>
<div class="block"><p>On some systems (windows for example) symlinks require special privileges that not everyone wants to grant a headless user. You can completely disable the use of symlinks by setting this config to true, but by doing so you may also lose some features from storm. For example the blobstore feature does not currently work without symlinks enabled.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.DISABLE_SYMLINKS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_PRINCIPAL_TO_LOCAL_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_PRINCIPAL_TO_LOCAL_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_PRINCIPAL_TO_LOCAL_PLUGIN</pre>
<div class="block"><p>The plugin that will convert a principal to a local user.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_PRINCIPAL_TO_LOCAL_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_GROUP_MAPPING_SERVICE_PROVIDER_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_GROUP_MAPPING_SERVICE_PROVIDER_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_GROUP_MAPPING_SERVICE_PROVIDER_PLUGIN</pre>
<div class="block"><p>The plugin that will provide user groups service</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_GROUP_MAPPING_SERVICE_PROVIDER_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_CREDENTIAL_RENEWERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_CREDENTIAL_RENEWERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_CREDENTIAL_RENEWERS</pre>
<div class="block"><p>A list of credential renewers that nimbus should load.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_CREDENTIAL_RENEWERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_AUTO_CRED_PLUGINS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_AUTO_CRED_PLUGINS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_AUTO_CRED_PLUGINS</pre>
<div class="block"><p>A list of plugins that nimbus should load during submit topology to populate credentials on user&rsquo;s behalf.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_AUTO_CRED_PLUGINS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_SUPERVISOR_USERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_SUPERVISOR_USERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_SUPERVISOR_USERS</pre>
<div class="block"><p>A list of users that run the supervisors and should be authorized to interact with nimbus as a supervisor would. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_SUPERVISOR_USERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_DAEMON_USERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_DAEMON_USERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_DAEMON_USERS</pre>
<div class="block"><p>A list of users that nimbus runs as and should be authorized to interact with the supervisor as nimbus would. To use this set supervisor.authorizer to org.apache.storm.security.auth.authorizer.SupervisorSimpleACLAuthorizer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_DAEMON_USERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_ADMINS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_ADMINS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_ADMINS</pre>
<div class="block"><p>A list of users that are cluster admins and can run any command. To use this set nimbus.authorizer to org.apache.storm.security.auth.authorizer.SimpleACLAuthorizer</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_ADMINS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_ADMINS_GROUPS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_ADMINS_GROUPS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_ADMINS_GROUPS</pre>
<div class="block"><p>A list of groups that are cluster admins and can run any command.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_ADMINS_GROUPS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_BLOBSTORE_ACL_VALIDATION_ENABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_BLOBSTORE_ACL_VALIDATION_ENABLED</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_BLOBSTORE_ACL_VALIDATION_ENABLED</pre>
<div class="block"><p>For secure mode we would want to turn on this config By default this is turned off assuming the default is insecure</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_BLOBSTORE_ACL_VALIDATION_ENABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_BLOBSTORE_INPUTSTREAM_BUFFER_SIZE_BYTES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_BLOBSTORE_INPUTSTREAM_BUFFER_SIZE_BYTES</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_BLOBSTORE_INPUTSTREAM_BUFFER_SIZE_BYTES</pre>
<div class="block"><p>What buffer size to use for the blobstore uploads.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_BLOBSTORE_INPUTSTREAM_BUFFER_SIZE_BYTES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_TOPOLOGY_SUBMISSION_NOTIFIER_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_TOPOLOGY_SUBMISSION_NOTIFIER_PLUGIN</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_TOPOLOGY_SUBMISSION_NOTIFIER_PLUGIN</pre>
<div class="block"><p>FQCN of a class that implements <code>ISubmitterHook</code> @see ISubmitterHook for details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_TOPOLOGY_SUBMISSION_NOTIFIER_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_IMPERSONATION_ACL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_IMPERSONATION_ACL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_IMPERSONATION_ACL</pre>
<div class="block"><p>Impersonation user ACL config entries.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_IMPERSONATION_ACL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_SCHEDULER_STRATEGY_CLASS_WHITELIST">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_SCHEDULER_STRATEGY_CLASS_WHITELIST</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NIMBUS_SCHEDULER_STRATEGY_CLASS_WHITELIST</pre>
<div class="block"><p>A whitelist of the RAS scheduler strategies allowed by nimbus. Should be a list of fully-qualified class names or null to allow all.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NIMBUS_SCHEDULER_STRATEGY_CLASS_WHITELIST">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_LAUNCHER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_LAUNCHER</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_LAUNCHER</pre>
<div class="block"><p>Full path to the worker-laucher executable that will be used to lauch workers when SUPERVISOR_RUN_WORKER_AS_USER is set to true.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_LAUNCHER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP</pre>
<div class="block"><p>Map a version of storm to a worker classpath that can be used to run it. This allows the supervisor to select an available version of storm that is compatible with what a topology was launched with.</p><p>Only the major and minor version numbers are used, although this may change in the future. The code will first try to find a version that is the same or higher than the requested version, but with the same major version number. If it cannot it will fall back to using one with a lower minor version, but in some cases this might fail as some features may be missing.</p><p>Because of how this selection process works please don&rsquo;t include two releases with the same major and minor versions as it is undefined which will be selected. Also it is good practice to just include one release for each major version you want to support unless the minor versions are truly not compatible with each other. This is to avoid maintenance and testing overhead.</p><p>This config needs to be set on all supervisors and on nimbus. In general this can be the output of calling storm classpath on the version you want and adding in an entry for the config directory for that release. You should modify the storm.yaml of each of these versions to match the features and settings you want on the main version.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_VERSION_MAIN_MAP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_VERSION_MAIN_MAP</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_VERSION_MAIN_MAP</pre>
<div class="block"><p>Map a version of storm to a worker&rsquo;s main class. In most cases storm should have correct defaults and just setting SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP is enough.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_VERSION_MAIN_MAP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_VERSION_LOGWRITER_MAP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_VERSION_LOGWRITER_MAP</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_VERSION_LOGWRITER_MAP</pre>
<div class="block"><p>Map a version of storm to a worker&rsquo;s logwriter class. In most cases storm should have correct defaults and just setting SUPERVISOR_WORKER_VERSION_CLASSPATH_MAP is enough.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_VERSION_LOGWRITER_MAP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_DEFAULT_VERSION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_DEFAULT_VERSION</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> SUPERVISOR_WORKER_DEFAULT_VERSION</pre>
<div class="block"><p>The version of storm to assume a topology should run as if not version is given by the client when submitting the topology.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.SUPERVISOR_WORKER_DEFAULT_VERSION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_LOCAL_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_LOCAL_DIR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_LOCAL_DIR</pre>
<div class="block"><p>A directory on the local filesystem used by Storm for any local filesystem usage it needs. The directory must exist and the Storm daemons must have permission to read/write from this location. It could be either absolute or relative. If the setting is a relative directory, it is relative to root directory of Storm installation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_LOCAL_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_WORKERS_ARTIFACTS_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_WORKERS_ARTIFACTS_DIR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_WORKERS_ARTIFACTS_DIR</pre>
<div class="block"><p>The workers-artifacts directory (where we place all workers&rsquo; logs), can be either absolute or relative. By default, ${storm.log.dir}/workers-artifacts is where worker logs go. If the setting is a relative directory, it is relative to storm.log.dir.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_WORKERS_ARTIFACTS_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_EXHIBITOR_SERVERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_EXHIBITOR_SERVERS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_EXHIBITOR_SERVERS</pre>
<div class="block"><p>A list of hosts of Exhibitor servers used to discover/maintain connection to ZooKeeper cluster. Any configured ZooKeeper servers will be used for the curator/exhibitor backup connection string.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_EXHIBITOR_SERVERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_EXHIBITOR_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_EXHIBITOR_PORT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_EXHIBITOR_PORT</pre>
<div class="block"><p>The port Storm will use to connect to each of the exhibitor servers.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_EXHIBITOR_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_EXHIBITOR_URIPATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_EXHIBITOR_URIPATH</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_EXHIBITOR_URIPATH</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_EXHIBITOR_URIPATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_EXHIBITOR_POLL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_EXHIBITOR_POLL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_EXHIBITOR_POLL</pre>
<div class="block"><p>How often to poll Exhibitor cluster in millis.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_EXHIBITOR_POLL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_EXHIBITOR_RETRY_TIMES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_EXHIBITOR_RETRY_TIMES</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_EXHIBITOR_RETRY_TIMES</pre>
<div class="block"><p>The number of times to retry an Exhibitor operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_EXHIBITOR_RETRY_TIMES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_EXHIBITOR_RETRY_INTERVAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_EXHIBITOR_RETRY_INTERVAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_EXHIBITOR_RETRY_INTERVAL</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_EXHIBITOR_RETRY_INTERVAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_EXHIBITOR_RETRY_INTERVAL_CEILING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_EXHIBITOR_RETRY_INTERVAL_CEILING</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_EXHIBITOR_RETRY_INTERVAL_CEILING</pre>
<div class="block"><p>The ceiling of the interval between retries of an Exhibitor operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_EXHIBITOR_RETRY_INTERVAL_CEILING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_CONNECTION_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_CONNECTION_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_CONNECTION_TIMEOUT</pre>
<div class="block"><p>The connection timeout for clients to ZooKeeper.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_CONNECTION_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_SESSION_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_SESSION_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_SESSION_TIMEOUT</pre>
<div class="block"><p>The session timeout for clients to ZooKeeper.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_SESSION_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_RETRY_INTERVAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_RETRY_INTERVAL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_RETRY_INTERVAL</pre>
<div class="block"><p>The interval between retries of a Zookeeper operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_RETRY_INTERVAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_RETRY_INTERVAL_CEILING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_RETRY_INTERVAL_CEILING</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_RETRY_INTERVAL_CEILING</pre>
<div class="block"><p>The ceiling of the interval between retries of a Zookeeper operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_RETRY_INTERVAL_CEILING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ZOOKEEPER_RETRY_TIMES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ZOOKEEPER_RETRY_TIMES</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_ZOOKEEPER_RETRY_TIMES</pre>
<div class="block"><p>The number of times to retry a Zookeeper operation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_ZOOKEEPER_RETRY_TIMES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_CLUSTER_STATE_STORE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CLUSTER_STATE_STORE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_CLUSTER_STATE_STORE</pre>
<div class="block"><p>The ClusterState factory that worker will use to create a ClusterState to store state in. Defaults to ZooKeeper.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_CLUSTER_STATE_STORE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_HEARTBEAT_FREQUENCY_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_HEARTBEAT_FREQUENCY_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> WORKER_HEARTBEAT_FREQUENCY_SECS</pre>
<div class="block"><p>How often this worker should heartbeat to the supervisor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.WORKER_HEARTBEAT_FREQUENCY_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EXECUTOR_METRICS_FREQUENCY_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>EXECUTOR_METRICS_FREQUENCY_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> EXECUTOR_METRICS_FREQUENCY_SECS</pre>
<div class="block"><p>How often executor metrics should report to master, used for RPC heartbeat mode.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.EXECUTOR_METRICS_FREQUENCY_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TASK_HEARTBEAT_FREQUENCY_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TASK_HEARTBEAT_FREQUENCY_SECS</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TASK_HEARTBEAT_FREQUENCY_SECS</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;</div>
<div class="block"><p>How often a task should heartbeat its status to the master, deprecated for 2.0 RPC heartbeat reporting, see <code>EXECUTOR_METRICS_FREQUENCY_SECS </code>.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TASK_HEARTBEAT_FREQUENCY_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TASK_REFRESH_POLL_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TASK_REFRESH_POLL_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> TASK_REFRESH_POLL_SECS</pre>
<div class="block"><p>How often a task should sync its connections with other tasks (if a task is reassigned, the other tasks sending messages to it need to refresh their connections). In general though, when a reassignment happens other tasks will be notified almost immediately. This configuration is here just in case that notification doesn&rsquo;t come through.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.TASK_REFRESH_POLL_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_AUTHORIZER_ACL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_AUTHORIZER_ACL</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_AUTHORIZER_ACL</pre>
<div class="block"><p>The Access Control List for the DRPC Authorizer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../org/apache/storm/security/auth/authorizer/DRPCSimpleACLAuthorizer.html" title="class in org.apache.storm.security.auth.authorizer"><code>DRPCSimpleACLAuthorizer</code></a>, 
<a href="../../../constant-values.html#org.apache.storm.Config.DRPC_AUTHORIZER_ACL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_AUTHORIZER_ACL_FILENAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_AUTHORIZER_ACL_FILENAME</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_AUTHORIZER_ACL_FILENAME</pre>
<div class="block"><p>File name of the DRPC Authorizer ACL.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../org/apache/storm/security/auth/authorizer/DRPCSimpleACLAuthorizer.html" title="class in org.apache.storm.security.auth.authorizer"><code>DRPCSimpleACLAuthorizer</code></a>, 
<a href="../../../constant-values.html#org.apache.storm.Config.DRPC_AUTHORIZER_ACL_FILENAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_AUTHORIZER_ACL_STRICT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_AUTHORIZER_ACL_STRICT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> DRPC_AUTHORIZER_ACL_STRICT</pre>
<div class="block"><p>Whether the DRPCSimpleAclAuthorizer should deny requests for operations involving functions that have no explicit ACL entry. When set to false (the default) DRPC functions that have no entry in the ACL will be permitted, which is appropriate for a development environment. When set to true, explicit ACL entries are required for every DRPC function, and any request for functions will be denied.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../org/apache/storm/security/auth/authorizer/DRPCSimpleACLAuthorizer.html" title="class in org.apache.storm.security.auth.authorizer"><code>DRPCSimpleACLAuthorizer</code></a>, 
<a href="../../../constant-values.html#org.apache.storm.Config.DRPC_AUTHORIZER_ACL_STRICT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_CGROUP_HIERARCHY_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CGROUP_HIERARCHY_DIR</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_CGROUP_HIERARCHY_DIR</pre>
<div class="block"><p>root directory of the storm cgroup hierarchy</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_CGROUP_HIERARCHY_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NUM_STAT_BUCKETS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NUM_STAT_BUCKETS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> NUM_STAT_BUCKETS</pre>
<div class="block"><p>The number of Buckets</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.NUM_STAT_BUCKETS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_BLOB_UPDATE_POLL_INTERVAL_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_BLOB_UPDATE_POLL_INTERVAL_SECS</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> WORKER_BLOB_UPDATE_POLL_INTERVAL_SECS</pre>
<div class="block"><p>Interval to check for the worker to check for updated blobs and refresh worker state accordingly. The default is 10 seconds</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.WORKER_BLOB_UPDATE_POLL_INTERVAL_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_DAEMON_METRICS_REPORTER_PLUGIN_LOCALE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_DAEMON_METRICS_REPORTER_PLUGIN_LOCALE</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_DAEMON_METRICS_REPORTER_PLUGIN_LOCALE</pre>
<div class="block"><p>A specify Locale for daemon metrics reporter plugin. Use the specified IETF BCP 47 language tag string for a Locale.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_DAEMON_METRICS_REPORTER_PLUGIN_LOCALE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_DAEMON_METRICS_REPORTER_PLUGIN_RATE_UNIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_DAEMON_METRICS_REPORTER_PLUGIN_RATE_UNIT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_DAEMON_METRICS_REPORTER_PLUGIN_RATE_UNIT</pre>
<div class="block"><p>A specify rate-unit in TimeUnit to specify reporting frequency for daemon metrics reporter plugin.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_DAEMON_METRICS_REPORTER_PLUGIN_RATE_UNIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_DAEMON_METRICS_REPORTER_PLUGIN_DURATION_UNIT">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>STORM_DAEMON_METRICS_REPORTER_PLUGIN_DURATION_UNIT</h4>
<pre>public static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> STORM_DAEMON_METRICS_REPORTER_PLUGIN_DURATION_UNIT</pre>
<div class="block"><p>A specify duration-unit in TimeUnit to specify reporting window for daemon metrics reporter plugin.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.Config.STORM_DAEMON_METRICS_REPORTER_PLUGIN_DURATION_UNIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="Config--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>Config</h4>
<pre>public&nbsp;Config()</pre>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="setClasspath-java.util.Map-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setClasspath</h4>
<pre>public static&nbsp;void&nbsp;setClasspath(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cp)</pre>
</li>
</ul>
<a name="setEnvironment-java.util.Map-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEnvironment</h4>
<pre>public static&nbsp;void&nbsp;setEnvironment(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                  <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;env)</pre>
</li>
</ul>
<a name="setDebug-java.util.Map-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDebug</h4>
<pre>public static&nbsp;void&nbsp;setDebug(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                            boolean&nbsp;isOn)</pre>
</li>
</ul>
<a name="setTopologyVersion-java.util.Map-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTopologyVersion</h4>
<pre>public static&nbsp;void&nbsp;setTopologyVersion(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;version)</pre>
</li>
</ul>
<a name="setNumWorkers-java.util.Map-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNumWorkers</h4>
<pre>public static&nbsp;void&nbsp;setNumWorkers(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                 int&nbsp;workers)</pre>
</li>
</ul>
<a name="setNumAckers-java.util.Map-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNumAckers</h4>
<pre>public static&nbsp;void&nbsp;setNumAckers(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                int&nbsp;numExecutors)</pre>
</li>
</ul>
<a name="setNumEventLoggers-java.util.Map-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNumEventLoggers</h4>
<pre>public static&nbsp;void&nbsp;setNumEventLoggers(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                      int&nbsp;numExecutors)</pre>
</li>
</ul>
<a name="setMessageTimeoutSecs-java.util.Map-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMessageTimeoutSecs</h4>
<pre>public static&nbsp;void&nbsp;setMessageTimeoutSecs(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                         int&nbsp;secs)</pre>
</li>
</ul>
<a name="registerSerialization-java.util.Map-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerSerialization</h4>
<pre>public static&nbsp;void&nbsp;registerSerialization(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</pre>
</li>
</ul>
<a name="registerSerialization-java.util.Map-java.lang.Class-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerSerialization</h4>
<pre>public static&nbsp;void&nbsp;registerSerialization(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends com.esotericsoftware.kryo.Serializer&gt;&nbsp;serializerClass)</pre>
</li>
</ul>
<a name="registerEventLogger-java.util.Map-java.lang.Class-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerEventLogger</h4>
<pre>public static&nbsp;void&nbsp;registerEventLogger(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass,
                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;argument)</pre>
</li>
</ul>
<a name="registerEventLogger-java.util.Map-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerEventLogger</h4>
<pre>public static&nbsp;void&nbsp;registerEventLogger(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass)</pre>
</li>
</ul>
<a name="registerMetricsConsumer-java.util.Map-java.lang.Class-java.lang.Object-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerMetricsConsumer</h4>
<pre>public static&nbsp;void&nbsp;registerMetricsConsumer(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;argument,
                                           long&nbsp;parallelismHint)</pre>
</li>
</ul>
<a name="registerMetricsConsumer-java.util.Map-java.lang.Class-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerMetricsConsumer</h4>
<pre>public static&nbsp;void&nbsp;registerMetricsConsumer(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                                           long&nbsp;parallelismHint)</pre>
</li>
</ul>
<a name="registerMetricsConsumer-java.util.Map-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerMetricsConsumer</h4>
<pre>public static&nbsp;void&nbsp;registerMetricsConsumer(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</pre>
</li>
</ul>
<a name="registerDecorator-java.util.Map-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerDecorator</h4>
<pre>public static&nbsp;void&nbsp;registerDecorator(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoDecorator.html" title="interface in org.apache.storm.serialization">IKryoDecorator</a>&gt;&nbsp;klass)</pre>
</li>
</ul>
<a name="setKryoFactory-java.util.Map-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setKryoFactory</h4>
<pre>public static&nbsp;void&nbsp;setKryoFactory(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoFactory.html" title="interface in org.apache.storm.serialization">IKryoFactory</a>&gt;&nbsp;klass)</pre>
</li>
</ul>
<a name="setSkipMissingKryoRegistrations-java.util.Map-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSkipMissingKryoRegistrations</h4>
<pre>public static&nbsp;void&nbsp;setSkipMissingKryoRegistrations(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                                   boolean&nbsp;skip)</pre>
</li>
</ul>
<a name="setMaxTaskParallelism-java.util.Map-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMaxTaskParallelism</h4>
<pre>public static&nbsp;void&nbsp;setMaxTaskParallelism(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                         int&nbsp;max)</pre>
</li>
</ul>
<a name="setMaxSpoutPending-java.util.Map-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMaxSpoutPending</h4>
<pre>public static&nbsp;void&nbsp;setMaxSpoutPending(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                      int&nbsp;max)</pre>
</li>
</ul>
<a name="setStatsSampleRate-java.util.Map-double-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setStatsSampleRate</h4>
<pre>public static&nbsp;void&nbsp;setStatsSampleRate(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                      double&nbsp;rate)</pre>
</li>
</ul>
<a name="setFallBackOnJavaSerialization-java.util.Map-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setFallBackOnJavaSerialization</h4>
<pre>public static&nbsp;void&nbsp;setFallBackOnJavaSerialization(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;conf,
                                                  boolean&nbsp;fallback)</pre>
</li>
</ul>
<a name="setClasspath-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setClasspath</h4>
<pre>public&nbsp;void&nbsp;setClasspath(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;cp)</pre>
</li>
</ul>
<a name="setEnvironment-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setEnvironment</h4>
<pre>public&nbsp;void&nbsp;setEnvironment(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;env)</pre>
</li>
</ul>
<a name="setDebug-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setDebug</h4>
<pre>public&nbsp;void&nbsp;setDebug(boolean&nbsp;isOn)</pre>
</li>
</ul>
<a name="setTopologyVersion-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTopologyVersion</h4>
<pre>public&nbsp;void&nbsp;setTopologyVersion(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;version)</pre>
</li>
</ul>
<a name="setNumWorkers-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNumWorkers</h4>
<pre>public&nbsp;void&nbsp;setNumWorkers(int&nbsp;workers)</pre>
</li>
</ul>
<a name="setNumAckers-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNumAckers</h4>
<pre>public&nbsp;void&nbsp;setNumAckers(int&nbsp;numExecutors)</pre>
</li>
</ul>
<a name="setNumEventLoggers-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNumEventLoggers</h4>
<pre>public&nbsp;void&nbsp;setNumEventLoggers(int&nbsp;numExecutors)</pre>
</li>
</ul>
<a name="setMessageTimeoutSecs-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMessageTimeoutSecs</h4>
<pre>public&nbsp;void&nbsp;setMessageTimeoutSecs(int&nbsp;secs)</pre>
</li>
</ul>
<a name="registerSerialization-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerSerialization</h4>
<pre>public&nbsp;void&nbsp;registerSerialization(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</pre>
</li>
</ul>
<a name="registerSerialization-java.lang.Class-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerSerialization</h4>
<pre>public&nbsp;void&nbsp;registerSerialization(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends com.esotericsoftware.kryo.Serializer&gt;&nbsp;serializerClass)</pre>
</li>
</ul>
<a name="registerEventLogger-java.lang.Class-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerEventLogger</h4>
<pre>public&nbsp;void&nbsp;registerEventLogger(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass,
                                <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;argument)</pre>
</li>
</ul>
<a name="registerEventLogger-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerEventLogger</h4>
<pre>public&nbsp;void&nbsp;registerEventLogger(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/metric/IEventLogger.html" title="interface in org.apache.storm.metric">IEventLogger</a>&gt;&nbsp;klass)</pre>
</li>
</ul>
<a name="registerMetricsConsumer-java.lang.Class-java.lang.Object-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerMetricsConsumer</h4>
<pre>public&nbsp;void&nbsp;registerMetricsConsumer(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;argument,
                                    long&nbsp;parallelismHint)</pre>
</li>
</ul>
<a name="registerMetricsConsumer-java.lang.Class-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerMetricsConsumer</h4>
<pre>public&nbsp;void&nbsp;registerMetricsConsumer(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass,
                                    long&nbsp;parallelismHint)</pre>
</li>
</ul>
<a name="registerMetricsConsumer-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerMetricsConsumer</h4>
<pre>public&nbsp;void&nbsp;registerMetricsConsumer(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;klass)</pre>
</li>
</ul>
<a name="registerDecorator-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>registerDecorator</h4>
<pre>public&nbsp;void&nbsp;registerDecorator(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoDecorator.html" title="interface in org.apache.storm.serialization">IKryoDecorator</a>&gt;&nbsp;klass)</pre>
</li>
</ul>
<a name="setKryoFactory-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setKryoFactory</h4>
<pre>public&nbsp;void&nbsp;setKryoFactory(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;? extends <a href="../../../org/apache/storm/serialization/IKryoFactory.html" title="interface in org.apache.storm.serialization">IKryoFactory</a>&gt;&nbsp;klass)</pre>
</li>
</ul>
<a name="setSkipMissingKryoRegistrations-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setSkipMissingKryoRegistrations</h4>
<pre>public&nbsp;void&nbsp;setSkipMissingKryoRegistrations(boolean&nbsp;skip)</pre>
</li>
</ul>
<a name="setMaxTaskParallelism-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMaxTaskParallelism</h4>
<pre>public&nbsp;void&nbsp;setMaxTaskParallelism(int&nbsp;max)</pre>
</li>
</ul>
<a name="setMaxSpoutPending-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setMaxSpoutPending</h4>
<pre>public&nbsp;void&nbsp;setMaxSpoutPending(int&nbsp;max)</pre>
</li>
</ul>
<a name="setStatsSampleRate-double-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setStatsSampleRate</h4>
<pre>public&nbsp;void&nbsp;setStatsSampleRate(double&nbsp;rate)</pre>
</li>
</ul>
<a name="setFallBackOnJavaSerialization-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setFallBackOnJavaSerialization</h4>
<pre>public&nbsp;void&nbsp;setFallBackOnJavaSerialization(boolean&nbsp;fallback)</pre>
</li>
</ul>
<a name="setTopologyWorkerMaxHeapSize-java.lang.Number-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTopologyWorkerMaxHeapSize</h4>
<pre>public&nbsp;void&nbsp;setTopologyWorkerMaxHeapSize(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang">Number</a>&nbsp;size)</pre>
<div class="block"><p>Set the max heap size allow per worker for this topology.</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>size</code> - the maximum heap size for a worker.</dd>
</dl>
</li>
</ul>
<a name="setTopologyComponentWorkerConstraints-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTopologyComponentWorkerConstraints</h4>
<pre>public&nbsp;void&nbsp;setTopologyComponentWorkerConstraints(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;component1,
                                                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;component2)</pre>
<div class="block"><p>Declares executors of component1 cannot be on the same worker as executors of component2. This function is additive. Thus a user can setTopologyComponentWorkerConstraints(&ldquo;A&rdquo;, &ldquo;B&rdquo;) and then setTopologyComponentWorkerConstraints(&ldquo;B&rdquo;, &ldquo;C&rdquo;) Which means executors form component A cannot be on the same worker with executors of component B and executors of Component B cannot be on workers with executors of component C</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>component1</code> - a component that should not coexist with component2</dd>
<dd><code>component2</code> - a component that should not coexist with component1</dd>
</dl>
</li>
</ul>
<a name="setTopologyConstraintsMaxStateSearch-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTopologyConstraintsMaxStateSearch</h4>
<pre>public&nbsp;void&nbsp;setTopologyConstraintsMaxStateSearch(int&nbsp;numStates)</pre>
<div class="block"><p>Sets the maximum number of states that will be searched in the constraint solver strategy.</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>numStates</code> - maximum number of stats to search.</dd>
</dl>
</li>
</ul>
<a name="setTopologyPriority-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTopologyPriority</h4>
<pre>public&nbsp;void&nbsp;setTopologyPriority(int&nbsp;priority)</pre>
<div class="block"><p>Set the priority for a topology.</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>priority</code> - </dd>
</dl>
</li>
</ul>
<a name="setTopologyStrategy-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTopologyStrategy</h4>
<pre>public&nbsp;void&nbsp;setTopologyStrategy(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;strategy)</pre>
</li>
</ul>
<a name="getBlobstoreHDFSPrincipal-java.util.Map-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>getBlobstoreHDFSPrincipal</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getBlobstoreHDFSPrincipal(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&nbsp;conf)
                                        throws <a href="https://docs.oracle.com/javase/8/docs/api/java/net/UnknownHostException.html?is-external=true" title="class or interface in java.net">UnknownHostException</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/net/UnknownHostException.html?is-external=true" title="class or interface in java.net">UnknownHostException</a></code></dd>
</dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Config.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">Help</a></li>
</ul>
<div class="aboutLanguage"><script type="text/javascript" src="../../../highlight.pack.js"></script>
<script type="text/javascript"><!--
hljs.initHighlightingOnLoad();
//--></script></div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev&nbsp;Class</li>
<li><a href="../../../org/apache/storm/Constants.html" title="class in org.apache.storm"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?org/apache/storm/Config.html" target="_top">Frames</a></li>
<li><a href="Config.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested.classes.inherited.from.class.java.util.AbstractMap">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2019 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</body>
</html>
