<!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>DaemonConfig (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="DaemonConfig (Storm 2.0.0 API)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":9,"i1":9,"i2":9,"i3":9};
var tabs = {65535:["t0","All Methods"],1:["t1","Static 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/DaemonConfig.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><a href="../../../org/apache/storm/Constants.html" title="class in org.apache.storm"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../org/apache/storm/ExclamationTopology.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/DaemonConfig.html" target="_top">Frames</a></li>
<li><a href="DaemonConfig.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>Nested&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 DaemonConfig" class="title">Class DaemonConfig</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>org.apache.storm.DaemonConfig</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><a href="../../../org/apache/storm/validation/Validated.html" title="interface in org.apache.storm.validation">Validated</a></dd>
</dl>
<hr>
<br>
<pre>public class <span class="typeNameLabel">DaemonConfig</span>
extends <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>
implements <a href="../../../org/apache/storm/validation/Validated.html" title="interface in org.apache.storm.validation">Validated</a></pre>
<div class="block"><p>Storm configs are specified as a plain old map. This class provides constants for all the configurations possible on a Storm cluster. 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>This class extends <a href="../../../org/apache/storm/Config.html" title="class in org.apache.storm"><code>Config</code></a> for supporting Storm Daemons.</p></div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== 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/DaemonConfig.html#BLACKLIST_SCHEDULER_REPORTER">BLACKLIST_SCHEDULER_REPORTER</a></span></code>
<div class="block">The class that the blacklist scheduler will report the blacklist.</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/DaemonConfig.html#BLACKLIST_SCHEDULER_RESUME_TIME">BLACKLIST_SCHEDULER_RESUME_TIME</a></span></code>
<div class="block">The number of seconds that the blacklisted slots or supervisor will be resumed.</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/DaemonConfig.html#BLACKLIST_SCHEDULER_STRATEGY">BLACKLIST_SCHEDULER_STRATEGY</a></span></code>
<div class="block">The class that specifies the eviction strategy to use in blacklist 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/DaemonConfig.html#BLACKLIST_SCHEDULER_TOLERANCE_COUNT">BLACKLIST_SCHEDULER_TOLERANCE_COUNT</a></span></code>
<div class="block">The number of hit count that will trigger blacklist in tolerance 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/DaemonConfig.html#BLACKLIST_SCHEDULER_TOLERANCE_TIME">BLACKLIST_SCHEDULER_TOLERANCE_TIME</a></span></code>
<div class="block">The number of seconds that the blacklist scheduler will concern of bad slots or supervisors.</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/DaemonConfig.html#DEV_ZOOKEEPER_PATH">DEV_ZOOKEEPER_PATH</a></span></code>
<div class="block">The path to use as the zookeeper dir when running a zookeeper server via &ldquo;storm dev-zookeeper&rdquo;.</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/DaemonConfig.html#DRPC_AUTHORIZER">DRPC_AUTHORIZER</a></span></code>
<div class="block">Class name for authorization plugin for DRPC 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/DaemonConfig.html#DRPC_CHILDOPTS">DRPC_CHILDOPTS</a></span></code>
<div class="block">Childopts for Storm DRPC Java 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/DaemonConfig.html#DRPC_DISABLE_HTTP_BINDING">DRPC_DISABLE_HTTP_BINDING</a></span></code>
<div class="block">This controls wheather Storm DRPC should bind to http port even if drpc.http.port is &gt; 0.</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/DaemonConfig.html#DRPC_HTTP_CREDS_PLUGIN">DRPC_HTTP_CREDS_PLUGIN</a></span></code>
<div class="block">Class name of the HTTP credentials plugin for DRPC.</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/DaemonConfig.html#DRPC_HTTP_FILTER">DRPC_HTTP_FILTER</a></span></code>
<div class="block">A class implementing javax.servlet.Filter for DRPC HTTP requests.</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/DaemonConfig.html#DRPC_HTTP_FILTER_PARAMS">DRPC_HTTP_FILTER_PARAMS</a></span></code>
<div class="block">Initialization parameters for the javax.servlet.Filter of the DRPC HTTP 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/DaemonConfig.html#DRPC_HTTP_PORT">DRPC_HTTP_PORT</a></span></code>
<div class="block">This port is used by Storm DRPC for receiving HTTP DPRC requests from clients.</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/DaemonConfig.html#DRPC_HTTPS_KEY_PASSWORD">DRPC_HTTPS_KEY_PASSWORD</a></span></code>
<div class="block">Password to the private key in the keystore for setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_HTTPS_KEYSTORE_PASSWORD">DRPC_HTTPS_KEYSTORE_PASSWORD</a></span></code>
<div class="block">Password to the keystore used by Storm DRPC for setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_HTTPS_KEYSTORE_PATH">DRPC_HTTPS_KEYSTORE_PATH</a></span></code>
<div class="block">Path to the keystore used by Storm DRPC for setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_HTTPS_KEYSTORE_TYPE">DRPC_HTTPS_KEYSTORE_TYPE</a></span></code>
<div class="block">Type of keystore used by Storm DRPC for setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_HTTPS_NEED_CLIENT_AUTH">DRPC_HTTPS_NEED_CLIENT_AUTH</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/DaemonConfig.html#DRPC_HTTPS_PORT">DRPC_HTTPS_PORT</a></span></code>
<div class="block">This port is used by Storm DRPC for receiving HTTPS (SSL) DPRC requests from clients.</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/DaemonConfig.html#DRPC_HTTPS_TRUSTSTORE_PASSWORD">DRPC_HTTPS_TRUSTSTORE_PASSWORD</a></span></code>
<div class="block">Password to the truststore used by Storm DRPC setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_HTTPS_TRUSTSTORE_PATH">DRPC_HTTPS_TRUSTSTORE_PATH</a></span></code>
<div class="block">Path to the truststore used by Storm DRPC setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_HTTPS_TRUSTSTORE_TYPE">DRPC_HTTPS_TRUSTSTORE_TYPE</a></span></code>
<div class="block">Type of truststore used by Storm DRPC for setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_HTTPS_WANT_CLIENT_AUTH">DRPC_HTTPS_WANT_CLIENT_AUTH</a></span></code>
<div class="block">Password to the truststore used by Storm DRPC setting up HTTPS (SSL).</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/DaemonConfig.html#DRPC_REQUEST_TIMEOUT_SECS">DRPC_REQUEST_TIMEOUT_SECS</a></span></code>
<div class="block">The timeout on DRPC requests within the DRPC 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/DaemonConfig.html#ISOLATION_SCHEDULER_MACHINES">ISOLATION_SCHEDULER_MACHINES</a></span></code>
<div class="block">A map from topology name to the number of machines that should be dedicated for that 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/DaemonConfig.html#JAVA_LIBRARY_PATH">JAVA_LIBRARY_PATH</a></span></code>
<div class="block">This value is passed to spawned JVMs (e.g., Nimbus, Supervisor, and Workers) for the java.library.path value.</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/DaemonConfig.html#LOGS_GROUPS">LOGS_GROUPS</a></span></code>
<div class="block">A list of groups allowed to view logs via the Log Viewer.</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/DaemonConfig.html#LOGS_USERS">LOGS_USERS</a></span></code>
<div class="block">A list of users allowed to view logs via the Log Viewer.</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/DaemonConfig.html#LOGVIEWER_APPENDER_NAME">LOGVIEWER_APPENDER_NAME</a></span></code>
<div class="block">Appender name used by log viewer to determine log directory.</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/DaemonConfig.html#LOGVIEWER_CHILDOPTS">LOGVIEWER_CHILDOPTS</a></span></code>
<div class="block">Childopts for log viewer java 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/DaemonConfig.html#LOGVIEWER_CLEANUP_AGE_MINS">LOGVIEWER_CLEANUP_AGE_MINS</a></span></code>
<div class="block">How many minutes since a log was last modified for the log to be considered for clean-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/DaemonConfig.html#LOGVIEWER_CLEANUP_INTERVAL_SECS">LOGVIEWER_CLEANUP_INTERVAL_SECS</a></span></code>
<div class="block">How often to clean up old log files.</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/DaemonConfig.html#LOGVIEWER_DISABLE_HTTP_BINDING">LOGVIEWER_DISABLE_HTTP_BINDING</a></span></code>
<div class="block">This controls wheather Storm Logviewer should bind to http port even if logviewer.port is &gt; 0.</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/DaemonConfig.html#LOGVIEWER_FILTER">LOGVIEWER_FILTER</a></span></code>
<div class="block">A class implementing javax.servlet.Filter for authenticating/filtering Logviewer requests.</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/DaemonConfig.html#LOGVIEWER_FILTER_PARAMS">LOGVIEWER_FILTER_PARAMS</a></span></code>
<div class="block">Initialization parameters for the javax.servlet.Filter for Logviewer.</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/DaemonConfig.html#LOGVIEWER_HTTPS_KEY_PASSWORD">LOGVIEWER_HTTPS_KEY_PASSWORD</a></span></code>
<div class="block">Password to the private key in the keystore for setting up HTTPS (SSL).</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/DaemonConfig.html#LOGVIEWER_HTTPS_KEYSTORE_PASSWORD">LOGVIEWER_HTTPS_KEYSTORE_PASSWORD</a></span></code>
<div class="block">Password for the keystore for HTTPS for Storm Logviewer.</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/DaemonConfig.html#LOGVIEWER_HTTPS_KEYSTORE_PATH">LOGVIEWER_HTTPS_KEYSTORE_PATH</a></span></code>
<div class="block">Path to the keystore containing the certs used by Storm Logviewer for HTTPS communications.</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/DaemonConfig.html#LOGVIEWER_HTTPS_KEYSTORE_TYPE">LOGVIEWER_HTTPS_KEYSTORE_TYPE</a></span></code>
<div class="block">Type of the keystore for HTTPS for Storm Logviewer.</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/DaemonConfig.html#LOGVIEWER_HTTPS_NEED_CLIENT_AUTH">LOGVIEWER_HTTPS_NEED_CLIENT_AUTH</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/DaemonConfig.html#LOGVIEWER_HTTPS_PORT">LOGVIEWER_HTTPS_PORT</a></span></code>
<div class="block">Storm Logviewer HTTPS port.</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/DaemonConfig.html#LOGVIEWER_HTTPS_TRUSTSTORE_PASSWORD">LOGVIEWER_HTTPS_TRUSTSTORE_PASSWORD</a></span></code>
<div class="block">Password for the truststore for HTTPS for Storm Logviewer.</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/DaemonConfig.html#LOGVIEWER_HTTPS_TRUSTSTORE_PATH">LOGVIEWER_HTTPS_TRUSTSTORE_PATH</a></span></code>
<div class="block">Path to the truststore containing the certs used by Storm Logviewer for HTTPS communications.</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/DaemonConfig.html#LOGVIEWER_HTTPS_TRUSTSTORE_TYPE">LOGVIEWER_HTTPS_TRUSTSTORE_TYPE</a></span></code>
<div class="block">Type of the truststore for HTTPS for Storm Logviewer.</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/DaemonConfig.html#LOGVIEWER_HTTPS_WANT_CLIENT_AUTH">LOGVIEWER_HTTPS_WANT_CLIENT_AUTH</a></span></code>
<div class="block">Password to the truststore used by Storm Logviewer setting up HTTPS (SSL).</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/DaemonConfig.html#LOGVIEWER_MAX_PER_WORKER_LOGS_SIZE_MB">LOGVIEWER_MAX_PER_WORKER_LOGS_SIZE_MB</a></span></code>
<div class="block">The maximum number of bytes per worker&rsquo;s files can take up in MB.</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/DaemonConfig.html#LOGVIEWER_MAX_SUM_WORKER_LOGS_SIZE_MB">LOGVIEWER_MAX_SUM_WORKER_LOGS_SIZE_MB</a></span></code>
<div class="block">The maximum number of bytes all worker log files can take up in MB.</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/DaemonConfig.html#LOGVIEWER_PORT">LOGVIEWER_PORT</a></span></code>
<div class="block">HTTP UI port for log viewer.</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/DaemonConfig.html#MULTITENANT_SCHEDULER_USER_POOLS">MULTITENANT_SCHEDULER_USER_POOLS</a></span></code>
<div class="block">A map from the user name to the number of machines that should that user is allowed to 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/DaemonConfig.html#NIMBUS_ASSIGNMENTS_SERVICE_THREAD_QUEUE_SIZE">NIMBUS_ASSIGNMENTS_SERVICE_THREAD_QUEUE_SIZE</a></span></code>
<div class="block">This controls the number of working thread queue size of assignment 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/DaemonConfig.html#NIMBUS_ASSIGNMENTS_SERVICE_THREADS">NIMBUS_ASSIGNMENTS_SERVICE_THREADS</a></span></code>
<div class="block">This controls the number of working threads for distributing master assignments to supervisors.</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/DaemonConfig.html#NIMBUS_AUTHORIZER">NIMBUS_AUTHORIZER</a></span></code>
<div class="block">Class name for authorization plugin for Nimbus.</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/DaemonConfig.html#NIMBUS_BLOBSTORE">NIMBUS_BLOBSTORE</a></span></code>
<div class="block">What blobstore implementation nimbus 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/DaemonConfig.html#NIMBUS_BLOBSTORE_EXPIRATION_SECS">NIMBUS_BLOBSTORE_EXPIRATION_SECS</a></span></code>
<div class="block">During operations with the blob store, via master, how long a connection is idle before nimbus considers it dead and drops the session and any associated connections.</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/DaemonConfig.html#NIMBUS_CHILDOPTS">NIMBUS_CHILDOPTS</a></span></code>
<div class="block">This parameter is used by the storm-deploy project to configure the jvm options for the nimbus daemon.</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/DaemonConfig.html#NIMBUS_CLEANUP_INBOX_FREQ_SECS">NIMBUS_CLEANUP_INBOX_FREQ_SECS</a></span></code>
<div class="block">How often nimbus should wake the cleanup thread to clean the inbox.</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/DaemonConfig.html#NIMBUS_CODE_SYNC_FREQ_SECS">NIMBUS_CODE_SYNC_FREQ_SECS</a></span></code>
<div class="block">How often nimbus&rsquo;s background thread to sync code for missing topologies should run.</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/DaemonConfig.html#NIMBUS_CREDENTIAL_RENEW_FREQ_SECS">NIMBUS_CREDENTIAL_RENEW_FREQ_SECS</a></span></code>
<div class="block">How often nimbus should wake up to renew credentials if needed.</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/DaemonConfig.html#NIMBUS_DAEMON_USER">NIMBUS_DAEMON_USER</a></span></code>
<div class="block">This is the user that the Nimbus daemon process is running as.</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/DaemonConfig.html#NIMBUS_EXECUTORS_PER_TOPOLOGY">NIMBUS_EXECUTORS_PER_TOPOLOGY</a></span></code>
<div class="block">A number representing the maximum number of executors any single topology can acquire.</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/DaemonConfig.html#NIMBUS_FILE_COPY_EXPIRATION_SECS">NIMBUS_FILE_COPY_EXPIRATION_SECS</a></span></code>
<div class="block">During upload/download with the master, how long an upload or download connection is idle before nimbus considers it dead and drops the connection.</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/DaemonConfig.html#NIMBUS_IMPERSONATION_AUTHORIZER">NIMBUS_IMPERSONATION_AUTHORIZER</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/DaemonConfig.html#NIMBUS_INBOX_JAR_EXPIRATION_SECS">NIMBUS_INBOX_JAR_EXPIRATION_SECS</a></span></code>
<div class="block">The length of time a jar file lives in the inbox before being deleted by the cleanup thread.</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/DaemonConfig.html#NIMBUS_MONITOR_FREQ_SECS">NIMBUS_MONITOR_FREQ_SECS</a></span></code>
<div class="block">How often nimbus should wake up to check heartbeats and do reassignments.</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/DaemonConfig.html#NIMBUS_SLOTS_PER_TOPOLOGY">NIMBUS_SLOTS_PER_TOPOLOGY</a></span></code>
<div class="block">A number representing the maximum number of workers any single topology can acquire.</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/DaemonConfig.html#NIMBUS_SUPERVISOR_TIMEOUT_SECS">NIMBUS_SUPERVISOR_TIMEOUT_SECS</a></span></code>
<div class="block">How long before a supervisor can go without heartbeating before nimbus considers it dead and stops assigning new work to 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/DaemonConfig.html#NIMBUS_TASK_LAUNCH_SECS">NIMBUS_TASK_LAUNCH_SECS</a></span></code>
<div class="block">A special timeout used when a task is initially launched.</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/DaemonConfig.html#NIMBUS_TASK_TIMEOUT_SECS">NIMBUS_TASK_TIMEOUT_SECS</a></span></code>
<div class="block">How long without heartbeating a task can go before nimbus will consider the task dead and reassign it to another location.</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/DaemonConfig.html#NIMBUS_TOPOLOGY_ACTION_NOTIFIER_PLUGIN">NIMBUS_TOPOLOGY_ACTION_NOTIFIER_PLUGIN</a></span></code>
<div class="block">FQCN of a class that implements <code>I</code> @see org.apache.storm.nimbus.ITopologyActionNotifierPlugin 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/DaemonConfig.html#NIMBUS_TOPOLOGY_BLOBSTORE_DELETION_DELAY_MS">NIMBUS_TOPOLOGY_BLOBSTORE_DELETION_DELAY_MS</a></span></code>
<div class="block">This controls the number of milliseconds nimbus will wait before deleting a topology blobstore once detected it is able to delete.</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/DaemonConfig.html#NIMBUS_TOPOLOGY_VALIDATOR">NIMBUS_TOPOLOGY_VALIDATOR</a></span></code>
<div class="block">A custom class that implements ITopologyValidator that is run whenever a topology is submitted.</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/DaemonConfig.html#NIMBUS_WORKER_HEARTBEATS_RECOVERY_STRATEGY_CLASS">NIMBUS_WORKER_HEARTBEATS_RECOVERY_STRATEGY_CLASS</a></span></code>
<div class="block">class controls heartbeats recovery strategy.</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/DaemonConfig.html#PACEMAKER_CHILDOPTS">PACEMAKER_CHILDOPTS</a></span></code>
<div class="block">This parameter is used by the storm-deploy project to configure the jvm options for the pacemaker daemon.</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/DaemonConfig.html#PACEMAKER_MAX_THREADS">PACEMAKER_MAX_THREADS</a></span></code>
<div class="block">The maximum number of threads that should be used by the Pacemaker.</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/DaemonConfig.html#RESOURCE_AWARE_SCHEDULER_MAX_TOPOLOGY_SCHEDULING_ATTEMPTS">RESOURCE_AWARE_SCHEDULER_MAX_TOPOLOGY_SCHEDULING_ATTEMPTS</a></span></code>
<div class="block">The maximum number of times that the RAS will attempt to schedule 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/DaemonConfig.html#RESOURCE_AWARE_SCHEDULER_PRIORITY_STRATEGY">RESOURCE_AWARE_SCHEDULER_PRIORITY_STRATEGY</a></span></code>
<div class="block">the class that specifies the scheduling priority strategy to use in ResourceAwareScheduler.</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/DaemonConfig.html#RESOURCE_AWARE_SCHEDULER_USER_POOLS">RESOURCE_AWARE_SCHEDULER_USER_POOLS</a></span></code>
<div class="block">A map of users to another map of the resource guarantees of the user.</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/DaemonConfig.html#SCHEDULER_CONFIG_LOADER_ARTIFACTORY_BASE_DIRECTORY">SCHEDULER_CONFIG_LOADER_ARTIFACTORY_BASE_DIRECTORY</a></span></code>
<div class="block">It is the part of the uri, configurable in Artifactory, which represents the top of the directory tree.</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/DaemonConfig.html#SCHEDULER_CONFIG_LOADER_POLLTIME_SECS">SCHEDULER_CONFIG_LOADER_POLLTIME_SECS</a></span></code>
<div class="block">It is the frequency at which the plugin will call out to artifactory instead of returning the most recently cached result.</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/DaemonConfig.html#SCHEDULER_CONFIG_LOADER_TIMEOUT_SECS">SCHEDULER_CONFIG_LOADER_TIMEOUT_SECS</a></span></code>
<div class="block">It is the amount of time an http connection to the artifactory server will wait before timing out.</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/DaemonConfig.html#SCHEDULER_CONFIG_LOADER_URI">SCHEDULER_CONFIG_LOADER_URI</a></span></code>
<div class="block">For ArtifactoryConfigLoader, this can either be a reference to an individual file in Artifactory or to a directory.</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/DaemonConfig.html#SCHEDULER_DISPLAY_RESOURCE">SCHEDULER_DISPLAY_RESOURCE</a></span></code>
<div class="block">Whether we want to display all the resource capacity and scheduled usage on the UI page.</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/DaemonConfig.html#SCHEDULING_TIMEOUT_SECONDS_PER_TOPOLOGY">SCHEDULING_TIMEOUT_SECONDS_PER_TOPOLOGY</a></span></code>
<div class="block">Max time to attempt to schedule one 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/DaemonConfig.html#STORM_CGROUP_CGEXEC_CMD">STORM_CGROUP_CGEXEC_CMD</a></span></code>
<div class="block">full path to cgexec 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/DaemonConfig.html#STORM_CGROUP_HIERARCHY_NAME">STORM_CGROUP_HIERARCHY_NAME</a></span></code>
<div class="block">name for the cgroup hierarchy.</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/DaemonConfig.html#STORM_CGROUP_INHERIT_CPUSET_CONFIGS">STORM_CGROUP_INHERIT_CPUSET_CONFIGS</a></span></code>
<div class="block">To determine whether or not to cgroups should inherit cpuset.cpus and cpuset.mems config values form parent cgroup Note that cpuset.cpus and cpuset.mems configs in a cgroup must be initialized (i.e.</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/DaemonConfig.html#STORM_CGROUP_MEMORY_ENFORCEMENT_ENABLE">STORM_CGROUP_MEMORY_ENFORCEMENT_ENABLE</a></span></code>
<div class="block">Java does not always play nicely with cgroups.</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/DaemonConfig.html#STORM_CGROUP_MEMORY_LIMIT_TOLERANCE_MARGIN_MB">STORM_CGROUP_MEMORY_LIMIT_TOLERANCE_MARGIN_MB</a></span></code>
<div class="block">Please use STORM_SUPERVISOR_MEMORY_LIMIT_TOLERANCE_MARGIN_MB instead.</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/DaemonConfig.html#STORM_CGROUP_RESOURCES">STORM_CGROUP_RESOURCES</a></span></code>
<div class="block">resources to to be controlled by cgroups.</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/DaemonConfig.html#STORM_CLUSTER_METRICS_CONSUMER_PUBLISH_INTERVAL_SECS">STORM_CLUSTER_METRICS_CONSUMER_PUBLISH_INTERVAL_SECS</a></span></code>
<div class="block">How often cluster metrics data is published to metrics consumer.</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/DaemonConfig.html#STORM_CLUSTER_METRICS_CONSUMER_REGISTER">STORM_CLUSTER_METRICS_CONSUMER_REGISTER</a></span></code>
<div class="block">A list of classes implementing IClusterMetricsConsumer (See storm.yaml.example for exact config format).</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/DaemonConfig.html#STORM_DAEMON_METRICS_REPORTER_CSV_LOG_DIR">STORM_DAEMON_METRICS_REPORTER_CSV_LOG_DIR</a></span></code>
<div class="block">A specify csv reporter directory for CvsPreparableReporter daemon metrics reporter.</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/DaemonConfig.html#STORM_DAEMON_METRICS_REPORTER_PLUGIN_DOMAIN">STORM_DAEMON_METRICS_REPORTER_PLUGIN_DOMAIN</a></span></code>
<div class="block">A specify domain for daemon metrics reporter plugin to limit reporting to specific domain.</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/DaemonConfig.html#STORM_DAEMON_METRICS_REPORTER_PLUGINS">STORM_DAEMON_METRICS_REPORTER_PLUGINS</a></span></code>
<div class="block">A list of daemon metrics reporter plugin class names.</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/DaemonConfig.html#STORM_HEALTH_CHECK_DIR">STORM_HEALTH_CHECK_DIR</a></span></code>
<div class="block">The directory where storm&rsquo;s health scripts go.</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/DaemonConfig.html#STORM_HEALTH_CHECK_TIMEOUT_MS">STORM_HEALTH_CHECK_TIMEOUT_MS</a></span></code>
<div class="block">The time to allow any given healthcheck script to run before it is marked failed due to timeout.</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/DaemonConfig.html#STORM_LOG4J2_CONF_DIR">STORM_LOG4J2_CONF_DIR</a></span></code>
<div class="block">A directory that holds configuration files for log4j2.</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/DaemonConfig.html#STORM_METRIC_PROCESSOR_CLASS">STORM_METRIC_PROCESSOR_CLASS</a></span></code>
<div class="block">Class implementing WorkerMetricsProcessor.</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/DaemonConfig.html#STORM_METRIC_STORE_CLASS">STORM_METRIC_STORE_CLASS</a></span></code>
<div class="block">Class implementing MetricStore.</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/DaemonConfig.html#STORM_NETTY_FLUSH_CHECK_INTERVAL_MS">STORM_NETTY_FLUSH_CHECK_INTERVAL_MS</a></span></code>
<div class="block">We check with this interval that whether the Netty channel is writable and try to write pending 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/DaemonConfig.html#STORM_NIMBUS_ZOOKEEPER_ACLS_CHECK">STORM_NIMBUS_ZOOKEEPER_ACLS_CHECK</a></span></code>
<div class="block">In nimbus on startup check if all of the zookeeper ACLs are correct before starting.</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/DaemonConfig.html#STORM_NIMBUS_ZOOKEEPER_ACLS_FIXUP">STORM_NIMBUS_ZOOKEEPER_ACLS_FIXUP</a></span></code>
<div class="block">In nimbus on startup check if all of the zookeeper ACLs are correct before starting.</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/DaemonConfig.html#STORM_RESOURCE_ISOLATION_PLUGIN">STORM_RESOURCE_ISOLATION_PLUGIN</a></span></code>
<div class="block">The plugin to be used for resource isolation.</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/DaemonConfig.html#STORM_RESOURCE_ISOLATION_PLUGIN_ENABLE">STORM_RESOURCE_ISOLATION_PLUGIN_ENABLE</a></span></code>
<div class="block">flag to determine whether to use a resource isolation plugin Also determines whether the unit tests for cgroup runs.</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/DaemonConfig.html#STORM_ROCKSDB_CREATE_IF_MISSING">STORM_ROCKSDB_CREATE_IF_MISSING</a></span></code>
<div class="block">RocksDB create if missing flag.</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/DaemonConfig.html#STORM_ROCKSDB_LOCATION">STORM_ROCKSDB_LOCATION</a></span></code>
<div class="block">RocksDB file location.</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/DaemonConfig.html#STORM_ROCKSDB_METADATA_STRING_CACHE_CAPACITY">STORM_ROCKSDB_METADATA_STRING_CACHE_CAPACITY</a></span></code>
<div class="block">RocksDB metadata cache capacity.</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/DaemonConfig.html#STORM_ROCKSDB_METRIC_DELETION_PERIOD_HOURS">STORM_ROCKSDB_METRIC_DELETION_PERIOD_HOURS</a></span></code>
<div class="block">RocksDB setting for period of metric deletion thread.</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/DaemonConfig.html#STORM_ROCKSDB_METRIC_RETENTION_HOURS">STORM_ROCKSDB_METRIC_RETENTION_HOURS</a></span></code>
<div class="block">RocksDB setting for length of metric retention.</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/DaemonConfig.html#STORM_SCHEDULER">STORM_SCHEDULER</a></span></code>
<div class="block">A global task scheduler used to assign topologies&rsquo;s tasks to supervisors&rsquo; 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/DaemonConfig.html#STORM_SUPERVISOR_CGROUP_ROOTDIR">STORM_SUPERVISOR_CGROUP_ROOTDIR</a></span></code>
<div class="block">root directory for cgoups.</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/DaemonConfig.html#STORM_SUPERVISOR_HARD_LIMIT_MEMORY_OVERAGE_MB">STORM_SUPERVISOR_HARD_LIMIT_MEMORY_OVERAGE_MB</a></span></code>
<div class="block">If the memory usage of a worker goes over its limit by this value is it shot immediately.</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/DaemonConfig.html#STORM_SUPERVISOR_HARD_MEMORY_LIMIT_MULTIPLIER">STORM_SUPERVISOR_HARD_MEMORY_LIMIT_MULTIPLIER</a></span></code>
<div class="block">A multiplier for the memory limit of a worker that will have the supervisor shoot it immediately.</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/DaemonConfig.html#STORM_SUPERVISOR_LOW_MEMORY_THRESHOLD_MB">STORM_SUPERVISOR_LOW_MEMORY_THRESHOLD_MB</a></span></code>
<div class="block">If the amount of memory that is free in the system (either on the box or in the supervisor&rsquo;s cgroup) is below this number (in MB) consider the system to be in low memory mode and start shooting workers if they are over their limit.</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/DaemonConfig.html#STORM_SUPERVISOR_MEDIUM_MEMORY_GRACE_PERIOD_MS">STORM_SUPERVISOR_MEDIUM_MEMORY_GRACE_PERIOD_MS</a></span></code>
<div class="block">The number of milliseconds that a worker is allowed to be over their limit when there is a medium amount of memory free in the 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/DaemonConfig.html#STORM_SUPERVISOR_MEDIUM_MEMORY_THRESHOLD_MB">STORM_SUPERVISOR_MEDIUM_MEMORY_THRESHOLD_MB</a></span></code>
<div class="block">If the amount of memory that is free in the system (either on the box or in the supervisor&rsquo;s cgroup) is below this number (in MB) consider the system to be a little low on memory and start shooting workers if they are over their limit for a given grace period STORM_SUPERVISOR_MEDIUM_MEMORY_GRACE_PERIOD_MS.</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/DaemonConfig.html#STORM_SUPERVISOR_MEMORY_LIMIT_TOLERANCE_MARGIN_MB">STORM_SUPERVISOR_MEMORY_LIMIT_TOLERANCE_MARGIN_MB</a></span></code>
<div class="block">Memory given to each worker for free (because java and storm have some overhead).</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/DaemonConfig.html#STORM_TOPOLOGY_CLASSPATH_BEGINNING_ENABLED">STORM_TOPOLOGY_CLASSPATH_BEGINNING_ENABLED</a></span></code>
<div class="block">Enables user-first classpath.</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/DaemonConfig.html#STORM_WORKER_CGROUP_CPU_LIMIT">STORM_WORKER_CGROUP_CPU_LIMIT</a></span></code>
<div class="block">the manually set cpu share for each CGroup on supervisor node.</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/DaemonConfig.html#STORM_WORKER_CGROUP_MEMORY_MB_LIMIT">STORM_WORKER_CGROUP_MEMORY_MB_LIMIT</a></span></code>
<div class="block">the manually set memory limit (in MB) for each CGroup on supervisor node.</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/DaemonConfig.html#STORM_WORKER_MIN_CPU_PCORE_PERCENT">STORM_WORKER_MIN_CPU_PCORE_PERCENT</a></span></code>
<div class="block">The config indicates the minimum percentage of cpu for a core that a worker 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/DaemonConfig.html#STORM_WORKER_TOKEN_LIFE_TIME_HOURS">STORM_WORKER_TOKEN_LIFE_TIME_HOURS</a></span></code>
<div class="block">The number of hours a worker token is valid 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/DaemonConfig.html#SUPERVISOR_AUTHORIZER">SUPERVISOR_AUTHORIZER</a></span></code>
<div class="block">Class name for authorization plugin for 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/DaemonConfig.html#SUPERVISOR_BLOBSTORE">SUPERVISOR_BLOBSTORE</a></span></code>
<div class="block">What blobstore implementation the supervisor should 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/DaemonConfig.html#SUPERVISOR_BLOBSTORE_DOWNLOAD_MAX_RETRIES">SUPERVISOR_BLOBSTORE_DOWNLOAD_MAX_RETRIES</a></span></code>
<div class="block">Maximum number of retries a supervisor is allowed to make for downloading a blob.</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/DaemonConfig.html#SUPERVISOR_BLOBSTORE_DOWNLOAD_THREAD_COUNT">SUPERVISOR_BLOBSTORE_DOWNLOAD_THREAD_COUNT</a></span></code>
<div class="block">What blobstore download parallelism the supervisor should 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/DaemonConfig.html#SUPERVISOR_CHILDOPTS">SUPERVISOR_CHILDOPTS</a></span></code>
<div class="block">This parameter is used by the storm-deploy project to configure the jvm options for the supervisor daemon.</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/DaemonConfig.html#SUPERVISOR_ENABLE">SUPERVISOR_ENABLE</a></span></code>
<div class="block">Whether or not the supervisor should launch workers assigned to 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/DaemonConfig.html#SUPERVISOR_HEARTBEAT_FREQUENCY_SECS">SUPERVISOR_HEARTBEAT_FREQUENCY_SECS</a></span></code>
<div class="block">how often the supervisor sends a heartbeat to the master.</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/DaemonConfig.html#SUPERVISOR_LOCALIZER_CACHE_CLEANUP_INTERVAL_MS">SUPERVISOR_LOCALIZER_CACHE_CLEANUP_INTERVAL_MS</a></span></code>
<div class="block">The distributed cache cleanup interval.</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/DaemonConfig.html#SUPERVISOR_LOCALIZER_CACHE_TARGET_SIZE_MB">SUPERVISOR_LOCALIZER_CACHE_TARGET_SIZE_MB</a></span></code>
<div class="block">The distributed cache target size in MB.</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/DaemonConfig.html#SUPERVISOR_MONITOR_FREQUENCY_SECS">SUPERVISOR_MONITOR_FREQUENCY_SECS</a></span></code>
<div class="block">How often the supervisor checks the worker heartbeats to see if any of them need to be restarted.</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/DaemonConfig.html#SUPERVISOR_SCHEDULER_META">SUPERVISOR_SCHEDULER_META</a></span></code>
<div class="block">the metadata configured on the 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/DaemonConfig.html#SUPERVISOR_SLOTS_PORTS">SUPERVISOR_SLOTS_PORTS</a></span></code>
<div class="block">A list of ports that can run workers on this 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/DaemonConfig.html#SUPERVISOR_WORKER_START_TIMEOUT_SECS">SUPERVISOR_WORKER_START_TIMEOUT_SECS</a></span></code>
<div class="block">How long a worker can go without heartbeating during the initial launch 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/DaemonConfig.html#UI_CENTRAL_LOGGING_URL">UI_CENTRAL_LOGGING_URL</a></span></code>
<div class="block">Storm UI Central Logging URL.</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/DaemonConfig.html#UI_CHILDOPTS">UI_CHILDOPTS</a></span></code>
<div class="block">Childopts for Storm UI Java 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/DaemonConfig.html#UI_DISABLE_HTTP_BINDING">UI_DISABLE_HTTP_BINDING</a></span></code>
<div class="block">This controls wheather Storm UI should bind to http port even if ui.port is &gt; 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/DaemonConfig.html#UI_DISABLE_SPOUT_LAG_MONITORING">UI_DISABLE_SPOUT_LAG_MONITORING</a></span></code>
<div class="block">This controls whether Storm UI displays spout lag for the Kafka spout.</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/DaemonConfig.html#UI_FILTER">UI_FILTER</a></span></code>
<div class="block">A class implementing javax.servlet.Filter for authenticating/filtering UI requests.</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/DaemonConfig.html#UI_FILTER_PARAMS">UI_FILTER_PARAMS</a></span></code>
<div class="block">Initialization parameters for the javax.servlet.Filter for UI.</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/DaemonConfig.html#UI_HEADER_BUFFER_BYTES">UI_HEADER_BUFFER_BYTES</a></span></code>
<div class="block">The size of the header buffer for the UI 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/DaemonConfig.html#UI_HOST">UI_HOST</a></span></code>
<div class="block">Storm UI binds to this host/interface.</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/DaemonConfig.html#UI_HTTP_CREDS_PLUGIN">UI_HTTP_CREDS_PLUGIN</a></span></code>
<div class="block">Class name of the HTTP credentials plugin for the UI.</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/DaemonConfig.html#UI_HTTPS_KEY_PASSWORD">UI_HTTPS_KEY_PASSWORD</a></span></code>
<div class="block">Password to the private key in the keystore for setting up HTTPS (SSL).</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/DaemonConfig.html#UI_HTTPS_KEYSTORE_PASSWORD">UI_HTTPS_KEYSTORE_PASSWORD</a></span></code>
<div class="block">Password to the keystore used by Storm UI for setting up HTTPS (SSL).</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/DaemonConfig.html#UI_HTTPS_KEYSTORE_PATH">UI_HTTPS_KEYSTORE_PATH</a></span></code>
<div class="block">Path to the keystore used by Storm UI for setting up HTTPS (SSL).</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/DaemonConfig.html#UI_HTTPS_KEYSTORE_TYPE">UI_HTTPS_KEYSTORE_TYPE</a></span></code>
<div class="block">Type of keystore used by Storm UI for setting up HTTPS (SSL).</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/DaemonConfig.html#UI_HTTPS_NEED_CLIENT_AUTH">UI_HTTPS_NEED_CLIENT_AUTH</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/DaemonConfig.html#UI_HTTPS_PORT">UI_HTTPS_PORT</a></span></code>
<div class="block">This port is used by Storm UI for receiving HTTPS (SSL) 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/DaemonConfig.html#UI_HTTPS_TRUSTSTORE_PASSWORD">UI_HTTPS_TRUSTSTORE_PASSWORD</a></span></code>
<div class="block">Password to the truststore used by Storm UI setting up HTTPS (SSL).</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/DaemonConfig.html#UI_HTTPS_TRUSTSTORE_PATH">UI_HTTPS_TRUSTSTORE_PATH</a></span></code>
<div class="block">Path to the truststore used by Storm UI setting up HTTPS (SSL).</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/DaemonConfig.html#UI_HTTPS_TRUSTSTORE_TYPE">UI_HTTPS_TRUSTSTORE_TYPE</a></span></code>
<div class="block">Type of truststore used by Storm UI for setting up HTTPS (SSL).</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/DaemonConfig.html#UI_HTTPS_WANT_CLIENT_AUTH">UI_HTTPS_WANT_CLIENT_AUTH</a></span></code>
<div class="block">Password to the truststore used by Storm DRPC setting up HTTPS (SSL).</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/DaemonConfig.html#UI_PAGINATION">UI_PAGINATION</a></span></code>
<div class="block">Storm UI drop-down pagination value.</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/DaemonConfig.html#UI_PORT">UI_PORT</a></span></code>
<div class="block">Storm UI binds to this port.</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/DaemonConfig.html#UI_PROJECT_BUGTRACKER_URL">UI_PROJECT_BUGTRACKER_URL</a></span></code>
<div class="block">Storm UI Project BUGTRACKER Link for reporting issue.</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/DaemonConfig.html#VALIDATE_TOPOLOGY_SCHEDULER_STRATEGY">VALIDATE_TOPOLOGY_SCHEDULER_STRATEGY</a></span></code>
<div class="block">Server side validation that @{see Config#TOPOLOGY_SCHEDULER_STRATEGY} is set ot a subclass of IStrategy.</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/DaemonConfig.html#WORKER_PROFILER_CHILDOPTS">WORKER_PROFILER_CHILDOPTS</a></span></code>
<div class="block">The jvm profiler 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/DaemonConfig.html#WORKER_PROFILER_COMMAND">WORKER_PROFILER_COMMAND</a></span></code>
<div class="block">The command launched supervisor with worker arguments pid, action and [target_directory] Where action is - start profile, stop profile, jstack, heapdump and kill against pid.</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/DaemonConfig.html#WORKER_PROFILER_ENABLED">WORKER_PROFILER_ENABLED</a></span></code>
<div class="block">Enable profiling of worker JVMs using Oracle&rsquo;s Java Flight Recorder.</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/DaemonConfig.html#DaemonConfig--">DaemonConfig</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="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/DaemonConfig.html#getCgroupRootDir-java.util.Map-">getCgroupRootDir</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)</code>&nbsp;</td>
</tr>
<tr id="i1" 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/DaemonConfig.html#getCgroupStormHierarchyDir-java.util.Map-">getCgroupStormHierarchyDir</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)</code>&nbsp;</td>
</tr>
<tr id="i2" 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/DaemonConfig.html#getCgroupStormHierarchyName-java.util.Map-">getCgroupStormHierarchyName</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)</code>&nbsp;</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html?is-external=true" title="class or interface in java.util">ArrayList</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>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/storm/DaemonConfig.html#getCgroupStormResources-java.util.Map-">getCgroupStormResources</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)</code>
<div class="block">Get the cgroup resources from the conf.</div>
</td>
</tr>
</table>
<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#clone--" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.lang">equals</a>, <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#hashCode--" title="class or interface in java.lang">hashCode</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#toString--" title="class or interface in java.lang">toString</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>
</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="STORM_NETTY_FLUSH_CHECK_INTERVAL_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NETTY_FLUSH_CHECK_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> STORM_NETTY_FLUSH_CHECK_INTERVAL_MS</pre>
<div class="block"><p>We check with this interval that whether the Netty channel is writable and try to write pending messages.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_NETTY_FLUSH_CHECK_INTERVAL_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_DAEMON_METRICS_REPORTER_PLUGINS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_DAEMON_METRICS_REPORTER_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> STORM_DAEMON_METRICS_REPORTER_PLUGINS</pre>
<div class="block"><p>A list of daemon metrics reporter plugin class names. These plugins must implement <a href="../../../org/apache/storm/daemon/metrics/reporters/PreparableReporter.html" title="interface in org.apache.storm.daemon.metrics.reporters"><code>PreparableReporter</code></a> interface.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_DAEMON_METRICS_REPORTER_PLUGINS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_DAEMON_METRICS_REPORTER_PLUGIN_DOMAIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_DAEMON_METRICS_REPORTER_PLUGIN_DOMAIN</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_DOMAIN</pre>
<div class="block"><p>A specify domain for daemon metrics reporter plugin to limit reporting to specific domain.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_DAEMON_METRICS_REPORTER_PLUGIN_DOMAIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_DAEMON_METRICS_REPORTER_CSV_LOG_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_DAEMON_METRICS_REPORTER_CSV_LOG_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_DAEMON_METRICS_REPORTER_CSV_LOG_DIR</pre>
<div class="block"><p>A specify csv reporter directory for CvsPreparableReporter daemon metrics reporter.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_DAEMON_METRICS_REPORTER_CSV_LOG_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_LOG4J2_CONF_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_LOG4J2_CONF_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_LOG4J2_CONF_DIR</pre>
<div class="block"><p>A directory that holds configuration files for log4j2. It can be either a relative or an absolute directory. If relative, it is relative to the storm&rsquo;s home directory.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_LOG4J2_CONF_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_SCHEDULER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SCHEDULER</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_SCHEDULER</pre>
<div class="block"><p>A global task scheduler used to assign topologies&rsquo;s tasks to supervisors&rsquo; workers.</p><p>If this is not set, a default system scheduler will be used.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_SCHEDULER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SCHEDULING_TIMEOUT_SECONDS_PER_TOPOLOGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SCHEDULING_TIMEOUT_SECONDS_PER_TOPOLOGY</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> SCHEDULING_TIMEOUT_SECONDS_PER_TOPOLOGY</pre>
<div class="block"><p>Max time to attempt to schedule one topology. The default is 60 seconds</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SCHEDULING_TIMEOUT_SECONDS_PER_TOPOLOGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLACKLIST_SCHEDULER_TOLERANCE_TIME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLACKLIST_SCHEDULER_TOLERANCE_TIME</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> BLACKLIST_SCHEDULER_TOLERANCE_TIME</pre>
<div class="block"><p>The number of seconds that the blacklist scheduler will concern of bad slots or supervisors.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.BLACKLIST_SCHEDULER_TOLERANCE_TIME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLACKLIST_SCHEDULER_TOLERANCE_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLACKLIST_SCHEDULER_TOLERANCE_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> BLACKLIST_SCHEDULER_TOLERANCE_COUNT</pre>
<div class="block"><p>The number of hit count that will trigger blacklist in tolerance time.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.BLACKLIST_SCHEDULER_TOLERANCE_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLACKLIST_SCHEDULER_RESUME_TIME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLACKLIST_SCHEDULER_RESUME_TIME</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> BLACKLIST_SCHEDULER_RESUME_TIME</pre>
<div class="block"><p>The number of seconds that the blacklisted slots or supervisor will be resumed.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.BLACKLIST_SCHEDULER_RESUME_TIME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLACKLIST_SCHEDULER_REPORTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLACKLIST_SCHEDULER_REPORTER</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> BLACKLIST_SCHEDULER_REPORTER</pre>
<div class="block"><p>The class that the blacklist scheduler will report the blacklist.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.BLACKLIST_SCHEDULER_REPORTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BLACKLIST_SCHEDULER_STRATEGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BLACKLIST_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> BLACKLIST_SCHEDULER_STRATEGY</pre>
<div class="block"><p>The class that specifies the eviction strategy to use in blacklist scheduler. If you are using the RAS scheduler please set this to &ldquo;org.apache.storm.scheduler.blacklist.strategies.RasBlacklistStrategy&rdquo; or you may get odd behavior when the cluster is full and there are blacklisted nodes.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.BLACKLIST_SCHEDULER_STRATEGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SCHEDULER_DISPLAY_RESOURCE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SCHEDULER_DISPLAY_RESOURCE</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> SCHEDULER_DISPLAY_RESOURCE</pre>
<div class="block"><p>Whether we want to display all the resource capacity and scheduled usage on the UI page. You MUST have this variable set if you are using any kind of resource-related scheduler. <p/> If this is not set, we will not display resource capacity and usage on the UI.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SCHEDULER_DISPLAY_RESOURCE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_HEALTH_CHECK_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_HEALTH_CHECK_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_HEALTH_CHECK_DIR</pre>
<div class="block"><p>The directory where storm&rsquo;s health scripts go.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_HEALTH_CHECK_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_HEALTH_CHECK_TIMEOUT_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_HEALTH_CHECK_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_HEALTH_CHECK_TIMEOUT_MS</pre>
<div class="block"><p>The time to allow any given healthcheck script to run before it is marked failed due to timeout.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_HEALTH_CHECK_TIMEOUT_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_DAEMON_USER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_DAEMON_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> NIMBUS_DAEMON_USER</pre>
<div class="block"><p>This is the user that the Nimbus daemon process is running as. May be used when security is enabled to authorize actions in the cluster.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_DAEMON_USER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_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> NIMBUS_CHILDOPTS</pre>
<div class="block"><p>This parameter is used by the storm-deploy project to configure the jvm options for the nimbus daemon.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_TASK_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_TASK_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> NIMBUS_TASK_TIMEOUT_SECS</pre>
<div class="block"><p>How long without heartbeating a task can go before nimbus will consider the task dead and reassign it to another location.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_TASK_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_MONITOR_FREQ_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_MONITOR_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> NIMBUS_MONITOR_FREQ_SECS</pre>
<div class="block"><p>How often nimbus should wake up to check heartbeats and do reassignments. Note that if a machine ever goes down Nimbus will immediately wake up and take action. This parameter is for checking for failures when there&rsquo;s no explicit event like that occurring.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_MONITOR_FREQ_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_CLEANUP_INBOX_FREQ_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_CLEANUP_INBOX_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> NIMBUS_CLEANUP_INBOX_FREQ_SECS</pre>
<div class="block"><p>How often nimbus should wake the cleanup thread to clean the inbox.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../org/apache/storm/DaemonConfig.html#NIMBUS_INBOX_JAR_EXPIRATION_SECS"><code>NIMBUS_INBOX_JAR_EXPIRATION_SECS</code></a>, 
<a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_CLEANUP_INBOX_FREQ_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_INBOX_JAR_EXPIRATION_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_INBOX_JAR_EXPIRATION_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> NIMBUS_INBOX_JAR_EXPIRATION_SECS</pre>
<div class="block"><p>The length of time a jar file lives in the inbox before being deleted by the cleanup thread.</p><p>Probably keep this value greater than or equal to NIMBUS_CLEANUP_INBOX_JAR_EXPIRATION_SECS. Note that the time it takes to delete an inbox jar file is going to be somewhat more than NIMBUS_CLEANUP_INBOX_JAR_EXPIRATION_SECS (depending on how often NIMBUS_CLEANUP_FREQ_SECS is set to).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../org/apache/storm/DaemonConfig.html#NIMBUS_CLEANUP_INBOX_FREQ_SECS"><code>NIMBUS_CLEANUP_INBOX_FREQ_SECS</code></a>, 
<a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_INBOX_JAR_EXPIRATION_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_SUPERVISOR_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_SUPERVISOR_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> NIMBUS_SUPERVISOR_TIMEOUT_SECS</pre>
<div class="block"><p>How long before a supervisor can go without heartbeating before nimbus considers it dead and stops assigning new work to it.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_SUPERVISOR_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_TASK_LAUNCH_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_TASK_LAUNCH_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> NIMBUS_TASK_LAUNCH_SECS</pre>
<div class="block"><p>A special timeout used when a task is initially launched. During launch, this is the timeout used until the first heartbeat, overriding nimbus.task.timeout.secs.</p>
<p>A separate timeout exists for launch because there can be quite a bit of overhead
to launching new JVM's and configuring them.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_TASK_LAUNCH_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_FILE_COPY_EXPIRATION_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_FILE_COPY_EXPIRATION_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> NIMBUS_FILE_COPY_EXPIRATION_SECS</pre>
<div class="block"><p>During upload/download with the master, how long an upload or download connection is idle before nimbus considers it dead and drops the connection.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_FILE_COPY_EXPIRATION_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_TOPOLOGY_VALIDATOR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_TOPOLOGY_VALIDATOR</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_TOPOLOGY_VALIDATOR</pre>
<div class="block"><p>A custom class that implements ITopologyValidator that is run whenever a topology is submitted. Can be used to provide business-specific logic for whether topologies are allowed to run or not.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_TOPOLOGY_VALIDATOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_AUTHORIZER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_AUTHORIZER</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_AUTHORIZER</pre>
<div class="block"><p>Class name for authorization plugin for Nimbus.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_AUTHORIZER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_AUTHORIZER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_AUTHORIZER</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_AUTHORIZER</pre>
<div class="block"><p>Class name for authorization plugin for supervisor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_AUTHORIZER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_IMPERSONATION_AUTHORIZER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_IMPERSONATION_AUTHORIZER</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_AUTHORIZER</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.DaemonConfig.NIMBUS_IMPERSONATION_AUTHORIZER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_CREDENTIAL_RENEW_FREQ_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_CREDENTIAL_RENEW_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> NIMBUS_CREDENTIAL_RENEW_FREQ_SECS</pre>
<div class="block"><p>How often nimbus should wake up to renew credentials if needed.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_CREDENTIAL_RENEW_FREQ_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_TOPOLOGY_ACTION_NOTIFIER_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_TOPOLOGY_ACTION_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> NIMBUS_TOPOLOGY_ACTION_NOTIFIER_PLUGIN</pre>
<div class="block"><p>FQCN of a class that implements <code>I</code> @see org.apache.storm.nimbus.ITopologyActionNotifierPlugin for details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_TOPOLOGY_ACTION_NOTIFIER_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_ASSIGNMENTS_SERVICE_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_ASSIGNMENTS_SERVICE_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_ASSIGNMENTS_SERVICE_THREADS</pre>
<div class="block"><p>This controls the number of working threads for distributing master assignments to supervisors.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_ASSIGNMENTS_SERVICE_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_ASSIGNMENTS_SERVICE_THREAD_QUEUE_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_ASSIGNMENTS_SERVICE_THREAD_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_ASSIGNMENTS_SERVICE_THREAD_QUEUE_SIZE</pre>
<div class="block"><p>This controls the number of working thread queue size of assignment service.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_ASSIGNMENTS_SERVICE_THREAD_QUEUE_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_WORKER_HEARTBEATS_RECOVERY_STRATEGY_CLASS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_WORKER_HEARTBEATS_RECOVERY_STRATEGY_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_WORKER_HEARTBEATS_RECOVERY_STRATEGY_CLASS</pre>
<div class="block"><p>class controls heartbeats recovery strategy.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_WORKER_HEARTBEATS_RECOVERY_STRATEGY_CLASS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_TOPOLOGY_BLOBSTORE_DELETION_DELAY_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_TOPOLOGY_BLOBSTORE_DELETION_DELAY_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> NIMBUS_TOPOLOGY_BLOBSTORE_DELETION_DELAY_MS</pre>
<div class="block"><p>This controls the number of milliseconds nimbus will wait before deleting a topology blobstore once detected it is able to delete.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_TOPOLOGY_BLOBSTORE_DELETION_DELAY_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HOST">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HOST</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> UI_HOST</pre>
<div class="block"><p>Storm UI binds to this host/interface.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HOST">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_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> UI_PORT</pre>
<div class="block"><p>Storm UI binds to this port.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_DISABLE_HTTP_BINDING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_DISABLE_HTTP_BINDING</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> UI_DISABLE_HTTP_BINDING</pre>
<div class="block"><p>This controls wheather Storm UI should bind to http port even if ui.port is &gt; 0.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_DISABLE_HTTP_BINDING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_DISABLE_SPOUT_LAG_MONITORING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_DISABLE_SPOUT_LAG_MONITORING</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> UI_DISABLE_SPOUT_LAG_MONITORING</pre>
<div class="block"><p>This controls whether Storm UI displays spout lag for the Kafka spout.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_DISABLE_SPOUT_LAG_MONITORING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_DISABLE_HTTP_BINDING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_DISABLE_HTTP_BINDING</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> LOGVIEWER_DISABLE_HTTP_BINDING</pre>
<div class="block"><p>This controls wheather Storm Logviewer should bind to http port even if logviewer.port is &gt; 0.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_DISABLE_HTTP_BINDING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_DISABLE_HTTP_BINDING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_DISABLE_HTTP_BINDING</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_DISABLE_HTTP_BINDING</pre>
<div class="block"><p>This controls wheather Storm DRPC should bind to http port even if drpc.http.port is &gt; 0.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_DISABLE_HTTP_BINDING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_PROJECT_BUGTRACKER_URL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_PROJECT_BUGTRACKER_URL</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> UI_PROJECT_BUGTRACKER_URL</pre>
<div class="block"><p>Storm UI Project BUGTRACKER Link for reporting issue.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_PROJECT_BUGTRACKER_URL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_CENTRAL_LOGGING_URL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_CENTRAL_LOGGING_URL</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> UI_CENTRAL_LOGGING_URL</pre>
<div class="block"><p>Storm UI Central Logging URL.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_CENTRAL_LOGGING_URL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_PAGINATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_PAGINATION</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> UI_PAGINATION</pre>
<div class="block"><p>Storm UI drop-down pagination value. Set ui.pagination to be a positive integer or -1 (displays all entries). Valid values: -1, 10, 20, 25 etc.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_PAGINATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_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> LOGVIEWER_PORT</pre>
<div class="block"><p>HTTP UI port for log viewer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_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> LOGVIEWER_CHILDOPTS</pre>
<div class="block"><p>Childopts for log viewer java process.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_CLEANUP_INTERVAL_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_CLEANUP_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> LOGVIEWER_CLEANUP_INTERVAL_SECS</pre>
<div class="block"><p>How often to clean up old log files.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_CLEANUP_INTERVAL_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_CLEANUP_AGE_MINS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_CLEANUP_AGE_MINS</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> LOGVIEWER_CLEANUP_AGE_MINS</pre>
<div class="block"><p>How many minutes since a log was last modified for the log to be considered for clean-up.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_CLEANUP_AGE_MINS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_MAX_SUM_WORKER_LOGS_SIZE_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_MAX_SUM_WORKER_LOGS_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> LOGVIEWER_MAX_SUM_WORKER_LOGS_SIZE_MB</pre>
<div class="block"><p>The maximum number of bytes all worker log files can take up in MB.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_MAX_SUM_WORKER_LOGS_SIZE_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_MAX_PER_WORKER_LOGS_SIZE_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_MAX_PER_WORKER_LOGS_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> LOGVIEWER_MAX_PER_WORKER_LOGS_SIZE_MB</pre>
<div class="block"><p>The maximum number of bytes per worker&rsquo;s files can take up in MB.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_MAX_PER_WORKER_LOGS_SIZE_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_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> LOGVIEWER_HTTPS_PORT</pre>
<div class="block"><p>Storm Logviewer HTTPS port. Logviewer must use HTTPS if Storm UI is using HTTPS.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_KEYSTORE_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_KEYSTORE_PATH</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> LOGVIEWER_HTTPS_KEYSTORE_PATH</pre>
<div class="block"><p>Path to the keystore containing the certs used by Storm Logviewer for HTTPS communications.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_KEYSTORE_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_KEYSTORE_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_KEYSTORE_PASSWORD</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> LOGVIEWER_HTTPS_KEYSTORE_PASSWORD</pre>
<div class="block"><p>Password for the keystore for HTTPS for Storm Logviewer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_KEYSTORE_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_KEYSTORE_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_KEYSTORE_TYPE</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> LOGVIEWER_HTTPS_KEYSTORE_TYPE</pre>
<div class="block"><p>Type of the keystore for HTTPS for Storm Logviewer. see <a href="http://docs.oracle.com/javase/8/docs/api/java/security/KeyStore.html">http://docs.oracle.com/javase/8/docs/api/java/security/KeyStore.html</a> for more details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_KEYSTORE_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_KEY_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_KEY_PASSWORD</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> LOGVIEWER_HTTPS_KEY_PASSWORD</pre>
<div class="block"><p>Password to the private key in the keystore for setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_KEY_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_TRUSTSTORE_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_TRUSTSTORE_PATH</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> LOGVIEWER_HTTPS_TRUSTSTORE_PATH</pre>
<div class="block"><p>Path to the truststore containing the certs used by Storm Logviewer for HTTPS communications.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_TRUSTSTORE_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_TRUSTSTORE_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_TRUSTSTORE_PASSWORD</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> LOGVIEWER_HTTPS_TRUSTSTORE_PASSWORD</pre>
<div class="block"><p>Password for the truststore for HTTPS for Storm Logviewer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_TRUSTSTORE_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_TRUSTSTORE_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_TRUSTSTORE_TYPE</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> LOGVIEWER_HTTPS_TRUSTSTORE_TYPE</pre>
<div class="block"><p>Type of the truststore for HTTPS for Storm Logviewer. see <a href="http://docs.oracle.com/javase/8/docs/api/java/security/Truststore.html">http://docs.oracle.com/javase/8/docs/api/java/security/Truststore.html</a> for more details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_TRUSTSTORE_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_WANT_CLIENT_AUTH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_WANT_CLIENT_AUTH</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> LOGVIEWER_HTTPS_WANT_CLIENT_AUTH</pre>
<div class="block"><p>Password to the truststore used by Storm Logviewer setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_WANT_CLIENT_AUTH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_HTTPS_NEED_CLIENT_AUTH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_HTTPS_NEED_CLIENT_AUTH</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> LOGVIEWER_HTTPS_NEED_CLIENT_AUTH</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_HTTPS_NEED_CLIENT_AUTH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGS_USERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGS_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> LOGS_USERS</pre>
<div class="block"><p>A list of users allowed to view logs via the Log Viewer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGS_USERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGS_GROUPS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGS_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> LOGS_GROUPS</pre>
<div class="block"><p>A list of groups allowed to view logs via the Log Viewer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGS_GROUPS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_APPENDER_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_APPENDER_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> LOGVIEWER_APPENDER_NAME</pre>
<div class="block"><p>Appender name used by log viewer to determine log directory.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_APPENDER_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_FILTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_FILTER</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> LOGVIEWER_FILTER</pre>
<div class="block"><p>A class implementing javax.servlet.Filter for authenticating/filtering Logviewer requests.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_FILTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LOGVIEWER_FILTER_PARAMS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOGVIEWER_FILTER_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> LOGVIEWER_FILTER_PARAMS</pre>
<div class="block"><p>Initialization parameters for the javax.servlet.Filter for Logviewer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.LOGVIEWER_FILTER_PARAMS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_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> UI_CHILDOPTS</pre>
<div class="block"><p>Childopts for Storm UI Java process.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_FILTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_FILTER</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> UI_FILTER</pre>
<div class="block"><p>A class implementing javax.servlet.Filter for authenticating/filtering UI requests.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_FILTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_FILTER_PARAMS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_FILTER_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> UI_FILTER_PARAMS</pre>
<div class="block"><p>Initialization parameters for the javax.servlet.Filter for UI.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_FILTER_PARAMS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HEADER_BUFFER_BYTES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HEADER_BUFFER_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> UI_HEADER_BUFFER_BYTES</pre>
<div class="block"><p>The size of the header buffer for the UI in bytes.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HEADER_BUFFER_BYTES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_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> UI_HTTPS_PORT</pre>
<div class="block"><p>This port is used by Storm UI for receiving HTTPS (SSL) requests from clients.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_KEYSTORE_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_KEYSTORE_PATH</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> UI_HTTPS_KEYSTORE_PATH</pre>
<div class="block"><p>Path to the keystore used by Storm UI for setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_KEYSTORE_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_KEYSTORE_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_KEYSTORE_PASSWORD</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> UI_HTTPS_KEYSTORE_PASSWORD</pre>
<div class="block"><p>Password to the keystore used by Storm UI for setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_KEYSTORE_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_KEYSTORE_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_KEYSTORE_TYPE</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> UI_HTTPS_KEYSTORE_TYPE</pre>
<div class="block"><p>Type of keystore used by Storm UI for setting up HTTPS (SSL). see <a href="http://docs.oracle.com/javase/7/docs/api/java/security/KeyStore">http://docs.oracle.com/javase/7/docs/api/java/security/KeyStore</a> .html for more details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_KEYSTORE_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_KEY_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_KEY_PASSWORD</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> UI_HTTPS_KEY_PASSWORD</pre>
<div class="block"><p>Password to the private key in the keystore for setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_KEY_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_TRUSTSTORE_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_TRUSTSTORE_PATH</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> UI_HTTPS_TRUSTSTORE_PATH</pre>
<div class="block"><p>Path to the truststore used by Storm UI setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_TRUSTSTORE_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_TRUSTSTORE_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_TRUSTSTORE_PASSWORD</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> UI_HTTPS_TRUSTSTORE_PASSWORD</pre>
<div class="block"><p>Password to the truststore used by Storm UI setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_TRUSTSTORE_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_TRUSTSTORE_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_TRUSTSTORE_TYPE</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> UI_HTTPS_TRUSTSTORE_TYPE</pre>
<div class="block"><p>Type of truststore used by Storm UI for setting up HTTPS (SSL). see <a href="http://docs.oracle">http://docs.oracle</a> .com/javase/7/docs/api/java/security/KeyStore.html for more details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_TRUSTSTORE_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_WANT_CLIENT_AUTH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_WANT_CLIENT_AUTH</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> UI_HTTPS_WANT_CLIENT_AUTH</pre>
<div class="block"><p>Password to the truststore used by Storm DRPC setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_WANT_CLIENT_AUTH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTPS_NEED_CLIENT_AUTH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTPS_NEED_CLIENT_AUTH</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> UI_HTTPS_NEED_CLIENT_AUTH</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTPS_NEED_CLIENT_AUTH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PACEMAKER_MAX_THREADS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PACEMAKER_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_MAX_THREADS</pre>
<div class="block"><p>The maximum number of threads that should be used by the Pacemaker. 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.DaemonConfig.PACEMAKER_MAX_THREADS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PACEMAKER_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PACEMAKER_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> PACEMAKER_CHILDOPTS</pre>
<div class="block"><p>This parameter is used by the storm-deploy project to configure the jvm options for the pacemaker daemon.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.PACEMAKER_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTP_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTP_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_HTTP_PORT</pre>
<div class="block"><p>This port is used by Storm DRPC for receiving HTTP DPRC requests from clients.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTP_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_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_HTTPS_PORT</pre>
<div class="block"><p>This port is used by Storm DRPC for receiving HTTPS (SSL) DPRC requests from clients.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_KEYSTORE_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_KEYSTORE_PATH</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_HTTPS_KEYSTORE_PATH</pre>
<div class="block"><p>Path to the keystore used by Storm DRPC for setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_KEYSTORE_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_KEYSTORE_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_KEYSTORE_PASSWORD</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_HTTPS_KEYSTORE_PASSWORD</pre>
<div class="block"><p>Password to the keystore used by Storm DRPC for setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_KEYSTORE_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_KEYSTORE_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_KEYSTORE_TYPE</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_HTTPS_KEYSTORE_TYPE</pre>
<div class="block"><p>Type of keystore used by Storm DRPC for setting up HTTPS (SSL). see <a href="http://docs.oracle">http://docs.oracle</a> .com/javase/7/docs/api/java/security/KeyStore.html for more details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_KEYSTORE_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_KEY_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_KEY_PASSWORD</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_HTTPS_KEY_PASSWORD</pre>
<div class="block"><p>Password to the private key in the keystore for setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_KEY_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_TRUSTSTORE_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_TRUSTSTORE_PATH</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_HTTPS_TRUSTSTORE_PATH</pre>
<div class="block"><p>Path to the truststore used by Storm DRPC setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_TRUSTSTORE_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_TRUSTSTORE_PASSWORD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_TRUSTSTORE_PASSWORD</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_HTTPS_TRUSTSTORE_PASSWORD</pre>
<div class="block"><p>Password to the truststore used by Storm DRPC setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_TRUSTSTORE_PASSWORD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_TRUSTSTORE_TYPE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_TRUSTSTORE_TYPE</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_HTTPS_TRUSTSTORE_TYPE</pre>
<div class="block"><p>Type of truststore used by Storm DRPC for setting up HTTPS (SSL). see <a href="http://docs.oracle">http://docs.oracle</a> .com/javase/7/docs/api/java/security/KeyStore.html for more details.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_TRUSTSTORE_TYPE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_WANT_CLIENT_AUTH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_WANT_CLIENT_AUTH</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_HTTPS_WANT_CLIENT_AUTH</pre>
<div class="block"><p>Password to the truststore used by Storm DRPC setting up HTTPS (SSL).</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_WANT_CLIENT_AUTH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTPS_NEED_CLIENT_AUTH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTPS_NEED_CLIENT_AUTH</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_HTTPS_NEED_CLIENT_AUTH</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTPS_NEED_CLIENT_AUTH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_AUTHORIZER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_AUTHORIZER</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</pre>
<div class="block"><p>Class name for authorization plugin for DRPC client.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_AUTHORIZER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_REQUEST_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_REQUEST_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> DRPC_REQUEST_TIMEOUT_SECS</pre>
<div class="block"><p>The timeout on DRPC requests within the DRPC server. Defaults to 10 minutes. Note that requests can also timeout based on the socket timeout on the DRPC client, and separately based on the topology message timeout for the topology implementing the DRPC function.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_REQUEST_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_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> DRPC_CHILDOPTS</pre>
<div class="block"><p>Childopts for Storm DRPC Java process.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_SCHEDULER_META">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_SCHEDULER_META</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_SCHEDULER_META</pre>
<div class="block"><p>the metadata configured on the supervisor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_SCHEDULER_META">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_SLOTS_PORTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_SLOTS_PORTS</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_SLOTS_PORTS</pre>
<div class="block"><p>A list of ports that can run workers on this supervisor. Each worker uses one port, and the supervisor will only run one worker per port. Use this configuration to tune how many workers run on each machine.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_SLOTS_PORTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_BLOBSTORE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_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> SUPERVISOR_BLOBSTORE</pre>
<div class="block"><p>What blobstore implementation the supervisor should use.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_BLOBSTORE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_LOCALIZER_CACHE_TARGET_SIZE_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_LOCALIZER_CACHE_TARGET_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> SUPERVISOR_LOCALIZER_CACHE_TARGET_SIZE_MB</pre>
<div class="block"><p>The distributed cache target size in MB. This is a soft limit to the size of the distributed cache contents.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_LOCALIZER_CACHE_TARGET_SIZE_MB">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_LOCALIZER_CACHE_CLEANUP_INTERVAL_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_LOCALIZER_CACHE_CLEANUP_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> SUPERVISOR_LOCALIZER_CACHE_CLEANUP_INTERVAL_MS</pre>
<div class="block"><p>The distributed cache cleanup interval. Controls how often it scans to attempt to cleanup anything over the cache target size.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_LOCALIZER_CACHE_CLEANUP_INTERVAL_MS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_BLOBSTORE_DOWNLOAD_THREAD_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_BLOBSTORE_DOWNLOAD_THREAD_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> SUPERVISOR_BLOBSTORE_DOWNLOAD_THREAD_COUNT</pre>
<div class="block"><p>What blobstore download parallelism the supervisor should use.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_BLOBSTORE_DOWNLOAD_THREAD_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_BLOBSTORE_DOWNLOAD_MAX_RETRIES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_BLOBSTORE_DOWNLOAD_MAX_RETRIES</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_BLOBSTORE_DOWNLOAD_MAX_RETRIES</pre>
<div class="block"><p>Maximum number of retries a supervisor is allowed to make for downloading a blob.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_BLOBSTORE_DOWNLOAD_MAX_RETRIES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_BLOBSTORE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_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> NIMBUS_BLOBSTORE</pre>
<div class="block"><p>What blobstore implementation nimbus should use.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_BLOBSTORE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_BLOBSTORE_EXPIRATION_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_BLOBSTORE_EXPIRATION_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> NIMBUS_BLOBSTORE_EXPIRATION_SECS</pre>
<div class="block"><p>During operations with the blob store, via master, how long a connection is idle before nimbus considers it dead and drops the session and any associated connections.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_BLOBSTORE_EXPIRATION_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_SLOTS_PER_TOPOLOGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_SLOTS_PER_TOPOLOGY</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_SLOTS_PER_TOPOLOGY</pre>
<div class="block"><p>A number representing the maximum number of workers any single topology can acquire. This will be ignored if the Resource Aware Scheduler is used.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_SLOTS_PER_TOPOLOGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTP_FILTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTP_FILTER</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_HTTP_FILTER</pre>
<div class="block"><p>A class implementing javax.servlet.Filter for DRPC HTTP requests.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTP_FILTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTP_FILTER_PARAMS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTP_FILTER_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> DRPC_HTTP_FILTER_PARAMS</pre>
<div class="block"><p>Initialization parameters for the javax.servlet.Filter of the DRPC HTTP service.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTP_FILTER_PARAMS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_EXECUTORS_PER_TOPOLOGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_EXECUTORS_PER_TOPOLOGY</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_EXECUTORS_PER_TOPOLOGY</pre>
<div class="block"><p>A number representing the maximum number of executors any single topology can acquire.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_EXECUTORS_PER_TOPOLOGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_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> SUPERVISOR_CHILDOPTS</pre>
<div class="block"><p>This parameter is used by the storm-deploy project to configure the jvm options for the supervisor daemon.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_WORKER_START_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_WORKER_START_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_START_TIMEOUT_SECS</pre>
<div class="block"><p>How long a worker can go without heartbeating during the initial launch before the supervisor tries to restart the worker process. This value override supervisor.worker.timeout.secs during launch because there is additional overhead to starting and configuring the JVM on launch.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_WORKER_START_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_ENABLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_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> SUPERVISOR_ENABLE</pre>
<div class="block"><p>Whether or not the supervisor should launch workers assigned to it. Defaults to true &ndash; and you should probably never change this value. This configuration is used in the Storm unit tests.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_ENABLE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_HEARTBEAT_FREQUENCY_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_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> SUPERVISOR_HEARTBEAT_FREQUENCY_SECS</pre>
<div class="block"><p>how often the supervisor sends a heartbeat to the master.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_HEARTBEAT_FREQUENCY_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SUPERVISOR_MONITOR_FREQUENCY_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SUPERVISOR_MONITOR_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> SUPERVISOR_MONITOR_FREQUENCY_SECS</pre>
<div class="block"><p>How often the supervisor checks the worker heartbeats to see if any of them need to be restarted.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SUPERVISOR_MONITOR_FREQUENCY_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_PROFILER_CHILDOPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_PROFILER_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_PROFILER_CHILDOPTS</pre>
<div class="block"><p>The jvm profiler opts provided to workers launched by this supervisor.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.WORKER_PROFILER_CHILDOPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_PROFILER_ENABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_PROFILER_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> WORKER_PROFILER_ENABLED</pre>
<div class="block"><p>Enable profiling of worker JVMs using Oracle&rsquo;s Java Flight Recorder. Unlocking commercial features requires a special license from Oracle. See <a href="http://www.oracle.com/technetwork/java/javase/terms/products/index.html">http://www.oracle.com/technetwork/java/javase/terms/products/index.html</a></p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.WORKER_PROFILER_ENABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WORKER_PROFILER_COMMAND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WORKER_PROFILER_COMMAND</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_PROFILER_COMMAND</pre>
<div class="block"><p>The command launched supervisor with worker arguments pid, action and [target_directory] Where action is - start profile, stop profile, jstack, heapdump and kill against pid.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.WORKER_PROFILER_COMMAND">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_CLUSTER_METRICS_CONSUMER_REGISTER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CLUSTER_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> STORM_CLUSTER_METRICS_CONSUMER_REGISTER</pre>
<div class="block"><p>A list of classes implementing IClusterMetricsConsumer (See storm.yaml.example for exact config format). Each listed class will be routed cluster related metrics data. Each listed class maps 1:1 to a ClusterMetricsConsumerExecutor and they&rsquo;re executed in Nimbus. Only consumers which run in leader Nimbus receives metrics data.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_CLUSTER_METRICS_CONSUMER_REGISTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_CLUSTER_METRICS_CONSUMER_PUBLISH_INTERVAL_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CLUSTER_METRICS_CONSUMER_PUBLISH_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> STORM_CLUSTER_METRICS_CONSUMER_PUBLISH_INTERVAL_SECS</pre>
<div class="block"><p>How often cluster metrics data is published to metrics consumer.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_CLUSTER_METRICS_CONSUMER_PUBLISH_INTERVAL_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_TOPOLOGY_CLASSPATH_BEGINNING_ENABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_TOPOLOGY_CLASSPATH_BEGINNING_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_TOPOLOGY_CLASSPATH_BEGINNING_ENABLED</pre>
<div class="block"><p>Enables user-first classpath. See topology.classpath.beginning.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_TOPOLOGY_CLASSPATH_BEGINNING_ENABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="JAVA_LIBRARY_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JAVA_LIBRARY_PATH</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> JAVA_LIBRARY_PATH</pre>
<div class="block"><p>This value is passed to spawned JVMs (e.g., Nimbus, Supervisor, and Workers) for the java.library.path value. java.library.path tells the JVM where to look for native libraries. It is necessary to set this config correctly since Storm uses the ZeroMQ and JZMQ native libs.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.JAVA_LIBRARY_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DEV_ZOOKEEPER_PATH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEV_ZOOKEEPER_PATH</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> DEV_ZOOKEEPER_PATH</pre>
<div class="block"><p>The path to use as the zookeeper dir when running a zookeeper server via &ldquo;storm dev-zookeeper&rdquo;. This zookeeper instance is only intended for development; it is not a production grade zookeeper setup.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DEV_ZOOKEEPER_PATH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="ISOLATION_SCHEDULER_MACHINES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ISOLATION_SCHEDULER_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> ISOLATION_SCHEDULER_MACHINES</pre>
<div class="block"><p>A map from topology name to the number of machines that should be dedicated for that topology. Set storm.scheduler to org.apache.storm.scheduler.IsolationScheduler to make use of the isolation scheduler.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.ISOLATION_SCHEDULER_MACHINES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SCHEDULER_CONFIG_LOADER_URI">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SCHEDULER_CONFIG_LOADER_URI</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> SCHEDULER_CONFIG_LOADER_URI</pre>
<div class="block"><p>For ArtifactoryConfigLoader, this can either be a reference to an individual file in Artifactory or to a directory. If it is a directory, the file with the largest lexographic name will be returned. Users need to add &ldquo;artifactory+&rdquo; to the beginning of the real URI to use ArtifactoryConfigLoader. For FileConfigLoader, this is the URI pointing to a file.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SCHEDULER_CONFIG_LOADER_URI">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SCHEDULER_CONFIG_LOADER_POLLTIME_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SCHEDULER_CONFIG_LOADER_POLLTIME_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> SCHEDULER_CONFIG_LOADER_POLLTIME_SECS</pre>
<div class="block"><p>It is the frequency at which the plugin will call out to artifactory instead of returning the most recently cached result. Currently it&rsquo;s only used in ArtifactoryConfigLoader.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SCHEDULER_CONFIG_LOADER_POLLTIME_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SCHEDULER_CONFIG_LOADER_TIMEOUT_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SCHEDULER_CONFIG_LOADER_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> SCHEDULER_CONFIG_LOADER_TIMEOUT_SECS</pre>
<div class="block"><p>It is the amount of time an http connection to the artifactory server will wait before timing out. Currently it&rsquo;s only used in ArtifactoryConfigLoader.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SCHEDULER_CONFIG_LOADER_TIMEOUT_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SCHEDULER_CONFIG_LOADER_ARTIFACTORY_BASE_DIRECTORY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SCHEDULER_CONFIG_LOADER_ARTIFACTORY_BASE_DIRECTORY</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> SCHEDULER_CONFIG_LOADER_ARTIFACTORY_BASE_DIRECTORY</pre>
<div class="block"><p>It is the part of the uri, configurable in Artifactory, which represents the top of the directory tree. It&rsquo;s only used in ArtifactoryConfigLoader.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.SCHEDULER_CONFIG_LOADER_ARTIFACTORY_BASE_DIRECTORY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="MULTITENANT_SCHEDULER_USER_POOLS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>MULTITENANT_SCHEDULER_USER_POOLS</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> MULTITENANT_SCHEDULER_USER_POOLS</pre>
<div class="block"><p>A map from the user name to the number of machines that should that user is allowed to use. 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.DaemonConfig.MULTITENANT_SCHEDULER_USER_POOLS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RESOURCE_AWARE_SCHEDULER_USER_POOLS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>RESOURCE_AWARE_SCHEDULER_USER_POOLS</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> RESOURCE_AWARE_SCHEDULER_USER_POOLS</pre>
<div class="block"><p>A map of users to another map of the resource guarantees of the user. Used by Resource Aware Scheduler to ensure per user resource guarantees.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.RESOURCE_AWARE_SCHEDULER_USER_POOLS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RESOURCE_AWARE_SCHEDULER_PRIORITY_STRATEGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>RESOURCE_AWARE_SCHEDULER_PRIORITY_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> RESOURCE_AWARE_SCHEDULER_PRIORITY_STRATEGY</pre>
<div class="block"><p>the class that specifies the scheduling priority strategy to use in ResourceAwareScheduler.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.RESOURCE_AWARE_SCHEDULER_PRIORITY_STRATEGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RESOURCE_AWARE_SCHEDULER_MAX_TOPOLOGY_SCHEDULING_ATTEMPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>RESOURCE_AWARE_SCHEDULER_MAX_TOPOLOGY_SCHEDULING_ATTEMPTS</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> RESOURCE_AWARE_SCHEDULER_MAX_TOPOLOGY_SCHEDULING_ATTEMPTS</pre>
<div class="block"><p>The maximum number of times that the RAS will attempt to schedule a topology. The default is 5.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.RESOURCE_AWARE_SCHEDULER_MAX_TOPOLOGY_SCHEDULING_ATTEMPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NIMBUS_CODE_SYNC_FREQ_SECS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NIMBUS_CODE_SYNC_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> NIMBUS_CODE_SYNC_FREQ_SECS</pre>
<div class="block"><p>How often nimbus&rsquo;s background thread to sync code for missing topologies should run.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.NIMBUS_CODE_SYNC_FREQ_SECS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_RESOURCE_ISOLATION_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_RESOURCE_ISOLATION_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_RESOURCE_ISOLATION_PLUGIN</pre>
<div class="block"><p>The plugin to be used for resource isolation.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_RESOURCE_ISOLATION_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_CGROUP_RESOURCES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CGROUP_RESOURCES</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_RESOURCES</pre>
<div class="block"><p>resources to to be controlled by cgroups.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_CGROUP_RESOURCES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_CGROUP_HIERARCHY_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CGROUP_HIERARCHY_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> STORM_CGROUP_HIERARCHY_NAME</pre>
<div class="block"><p>name for the cgroup hierarchy.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_CGROUP_HIERARCHY_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_RESOURCE_ISOLATION_PLUGIN_ENABLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_RESOURCE_ISOLATION_PLUGIN_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> STORM_RESOURCE_ISOLATION_PLUGIN_ENABLE</pre>
<div class="block"><p>flag to determine whether to use a resource isolation plugin Also determines whether the unit tests for cgroup runs. If storm.resource.isolation.plugin.enable is set to false the unit tests for cgroups will not run</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_RESOURCE_ISOLATION_PLUGIN_ENABLE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_METRIC_STORE_CLASS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_METRIC_STORE_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> STORM_METRIC_STORE_CLASS</pre>
<div class="block"><p>Class implementing MetricStore. Runs on Nimbus.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_METRIC_STORE_CLASS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_METRIC_PROCESSOR_CLASS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_METRIC_PROCESSOR_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> STORM_METRIC_PROCESSOR_CLASS</pre>
<div class="block"><p>Class implementing WorkerMetricsProcessor. Runs on Supervisors.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_METRIC_PROCESSOR_CLASS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ROCKSDB_LOCATION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ROCKSDB_LOCATION</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_ROCKSDB_LOCATION</pre>
<div class="block"><p>RocksDB file location. This setting is specific to the org.apache.storm.metricstore.rocksdb.RocksDbStore implementation for the storm.metricstore.class.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_ROCKSDB_LOCATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ROCKSDB_CREATE_IF_MISSING">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ROCKSDB_CREATE_IF_MISSING</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_ROCKSDB_CREATE_IF_MISSING</pre>
<div class="block"><p>RocksDB create if missing flag. This setting is specific to the org.apache.storm.metricstore.rocksdb.RocksDbStore implementation for the storm.metricstore.class.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_ROCKSDB_CREATE_IF_MISSING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ROCKSDB_METADATA_STRING_CACHE_CAPACITY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ROCKSDB_METADATA_STRING_CACHE_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> STORM_ROCKSDB_METADATA_STRING_CACHE_CAPACITY</pre>
<div class="block"><p>RocksDB metadata cache capacity. This setting is specific to the org.apache.storm.metricstore.rocksdb.RocksDbStore implementation for the storm.metricstore.class.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_ROCKSDB_METADATA_STRING_CACHE_CAPACITY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ROCKSDB_METRIC_RETENTION_HOURS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ROCKSDB_METRIC_RETENTION_HOURS</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_ROCKSDB_METRIC_RETENTION_HOURS</pre>
<div class="block"><p>RocksDB setting for length of metric retention. This setting is specific to the org.apache.storm.metricstore.rocksdb.RocksDbStore implementation for the storm.metricstore.class.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_ROCKSDB_METRIC_RETENTION_HOURS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_ROCKSDB_METRIC_DELETION_PERIOD_HOURS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_ROCKSDB_METRIC_DELETION_PERIOD_HOURS</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_ROCKSDB_METRIC_DELETION_PERIOD_HOURS</pre>
<div class="block"><p>RocksDB setting for period of metric deletion thread. This setting is specific to the org.apache.storm.metricstore.rocksdb .RocksDbStore implementation for the storm.metricstore.class.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_ROCKSDB_METRIC_DELETION_PERIOD_HOURS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_NIMBUS_ZOOKEEPER_ACLS_CHECK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NIMBUS_ZOOKEEPER_ACLS_CHECK</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_ZOOKEEPER_ACLS_CHECK</pre>
<div class="block"><p>In nimbus on startup check if all of the zookeeper ACLs are correct before starting. If not don&rsquo;t start nimbus.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_NIMBUS_ZOOKEEPER_ACLS_CHECK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_NIMBUS_ZOOKEEPER_ACLS_FIXUP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_NIMBUS_ZOOKEEPER_ACLS_FIXUP</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_ZOOKEEPER_ACLS_FIXUP</pre>
<div class="block"><p>In nimbus on startup check if all of the zookeeper ACLs are correct before starting. If not do your best to fix them before nimbus starts, if it cannot fix them nimbus will not start. This overrides any value set for storm.nimbus.zookeeper.acls.check.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.STORM_NIMBUS_ZOOKEEPER_ACLS_FIXUP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="VALIDATE_TOPOLOGY_SCHEDULER_STRATEGY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>VALIDATE_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> VALIDATE_TOPOLOGY_SCHEDULER_STRATEGY</pre>
<div class="block"><p>Server side validation that @{see Config#TOPOLOGY_SCHEDULER_STRATEGY} is set ot a subclass of IStrategy.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.VALIDATE_TOPOLOGY_SCHEDULER_STRATEGY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="UI_HTTP_CREDS_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UI_HTTP_CREDS_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> UI_HTTP_CREDS_PLUGIN</pre>
<div class="block"><p>Class name of the HTTP credentials plugin for the UI.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.UI_HTTP_CREDS_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DRPC_HTTP_CREDS_PLUGIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DRPC_HTTP_CREDS_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_HTTP_CREDS_PLUGIN</pre>
<div class="block"><p>Class name of the HTTP credentials plugin for DRPC.</p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.storm.DaemonConfig.DRPC_HTTP_CREDS_PLUGIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="STORM_SUPERVISOR_CGROUP_ROOTDIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SUPERVISOR_CGROUP_ROOTDIR</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> STORM_SUPERVISOR_CGROUP_ROOTDIR</pre>
<div class="block"><p>root directory for cgoups.</p></div>
</li>
</ul>
<a name="STORM_WORKER_CGROUP_MEMORY_MB_LIMIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_WORKER_CGROUP_MEMORY_MB_LIMIT</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> STORM_WORKER_CGROUP_MEMORY_MB_LIMIT</pre>
<div class="block"><p>the manually set memory limit (in MB) for each CGroup on supervisor node.</p></div>
</li>
</ul>
<a name="STORM_WORKER_CGROUP_CPU_LIMIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_WORKER_CGROUP_CPU_LIMIT</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> STORM_WORKER_CGROUP_CPU_LIMIT</pre>
<div class="block"><p>the manually set cpu share for each CGroup on supervisor node.</p></div>
</li>
</ul>
<a name="STORM_CGROUP_CGEXEC_CMD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CGROUP_CGEXEC_CMD</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> STORM_CGROUP_CGEXEC_CMD</pre>
<div class="block"><p>full path to cgexec command.</p></div>
</li>
</ul>
<a name="STORM_CGROUP_MEMORY_LIMIT_TOLERANCE_MARGIN_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CGROUP_MEMORY_LIMIT_TOLERANCE_MARGIN_MB</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> STORM_CGROUP_MEMORY_LIMIT_TOLERANCE_MARGIN_MB</pre>
<div class="block"><p>Please use STORM_SUPERVISOR_MEMORY_LIMIT_TOLERANCE_MARGIN_MB instead. The amount of memory a worker can exceed its allocation before cgroup will kill it.</p></div>
</li>
</ul>
<a name="STORM_CGROUP_INHERIT_CPUSET_CONFIGS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CGROUP_INHERIT_CPUSET_CONFIGS</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> STORM_CGROUP_INHERIT_CPUSET_CONFIGS</pre>
<div class="block"><p>To determine whether or not to cgroups should inherit cpuset.cpus and cpuset.mems config values form parent cgroup Note that cpuset.cpus and cpuset.mems configs in a cgroup must be initialized (i.e. contain a valid value) prior to being able to launch processes in that cgroup. The common use case for this config is when the linux distribution that is used does not support the cgroup.clone_children config.</p></div>
</li>
</ul>
<a name="STORM_CGROUP_MEMORY_ENFORCEMENT_ENABLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_CGROUP_MEMORY_ENFORCEMENT_ENABLE</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> STORM_CGROUP_MEMORY_ENFORCEMENT_ENABLE</pre>
<div class="block"><p>Java does not always play nicely with cgroups. It is coming but not fully implemented and not for the way storm uses cgroups. In the short term you can disable the hard memory enforcement by cgroups and let the supervisor handle shooting workers going over their limit in a kinder way.</p></div>
</li>
</ul>
<a name="STORM_SUPERVISOR_MEMORY_LIMIT_TOLERANCE_MARGIN_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SUPERVISOR_MEMORY_LIMIT_TOLERANCE_MARGIN_MB</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> STORM_SUPERVISOR_MEMORY_LIMIT_TOLERANCE_MARGIN_MB</pre>
<div class="block"><p>Memory given to each worker for free (because java and storm have some overhead). This is memory on the box that the workers can use. This should not be included in SUPERVISOR_MEMORY_CAPACITY_MB, as nimbus does not use this memory for scheduling.</p></div>
</li>
</ul>
<a name="STORM_SUPERVISOR_HARD_MEMORY_LIMIT_MULTIPLIER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SUPERVISOR_HARD_MEMORY_LIMIT_MULTIPLIER</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> STORM_SUPERVISOR_HARD_MEMORY_LIMIT_MULTIPLIER</pre>
<div class="block"><p>A multiplier for the memory limit of a worker that will have the supervisor shoot it immediately. 1.0 means shoot the worker as soon as it goes over. 2.0 means shoot the worker if its usage is double what was requested. This value is combined with STORM_SUPERVISOR_HARD_MEMORY_LIMIT_OVERAGE and which ever is greater is used for enforcement. This allows small workers to not be shot.</p></div>
</li>
</ul>
<a name="STORM_SUPERVISOR_HARD_LIMIT_MEMORY_OVERAGE_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SUPERVISOR_HARD_LIMIT_MEMORY_OVERAGE_MB</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> STORM_SUPERVISOR_HARD_LIMIT_MEMORY_OVERAGE_MB</pre>
<div class="block"><p>If the memory usage of a worker goes over its limit by this value is it shot immediately. This value is combined with STORM_SUPERVISOR_HARD_LIMIT_MEMORY_MULTIPLIER and which ever is greater is used for enforcement. This allows small workers to not be shot.</p></div>
</li>
</ul>
<a name="STORM_SUPERVISOR_LOW_MEMORY_THRESHOLD_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SUPERVISOR_LOW_MEMORY_THRESHOLD_MB</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> STORM_SUPERVISOR_LOW_MEMORY_THRESHOLD_MB</pre>
<div class="block"><p>If the amount of memory that is free in the system (either on the box or in the supervisor&rsquo;s cgroup) is below this number (in MB) consider the system to be in low memory mode and start shooting workers if they are over their limit.</p></div>
</li>
</ul>
<a name="STORM_SUPERVISOR_MEDIUM_MEMORY_THRESHOLD_MB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SUPERVISOR_MEDIUM_MEMORY_THRESHOLD_MB</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> STORM_SUPERVISOR_MEDIUM_MEMORY_THRESHOLD_MB</pre>
<div class="block"><p>If the amount of memory that is free in the system (either on the box or in the supervisor&rsquo;s cgroup) is below this number (in MB) consider the system to be a little low on memory and start shooting workers if they are over their limit for a given grace period STORM_SUPERVISOR_MEDIUM_MEMORY_GRACE_PERIOD_MS.</p></div>
</li>
</ul>
<a name="STORM_SUPERVISOR_MEDIUM_MEMORY_GRACE_PERIOD_MS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_SUPERVISOR_MEDIUM_MEMORY_GRACE_PERIOD_MS</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> STORM_SUPERVISOR_MEDIUM_MEMORY_GRACE_PERIOD_MS</pre>
<div class="block"><p>The number of milliseconds that a worker is allowed to be over their limit when there is a medium amount of memory free in the system.</p></div>
</li>
</ul>
<a name="STORM_WORKER_MIN_CPU_PCORE_PERCENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STORM_WORKER_MIN_CPU_PCORE_PERCENT</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> STORM_WORKER_MIN_CPU_PCORE_PERCENT</pre>
<div class="block"><p>The config indicates the minimum percentage of cpu for a core that a worker 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></P> Workers in containers or cgroups may require a minimum amount of CPU in order to launch within the supervisor timeout. This setting allows configuring this to occur.</p></div>
</li>
</ul>
<a name="STORM_WORKER_TOKEN_LIFE_TIME_HOURS">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>STORM_WORKER_TOKEN_LIFE_TIME_HOURS</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> STORM_WORKER_TOKEN_LIFE_TIME_HOURS</pre>
<div class="block"><p>The number of hours a worker token is valid for. This also sets how frequently worker tokens will be renewed.</p></div>
</li>
</ul>
</li>
</ul>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="DaemonConfig--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>DaemonConfig</h4>
<pre>public&nbsp;DaemonConfig()</pre>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="getCgroupRootDir-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getCgroupRootDir</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;getCgroupRootDir(<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)</pre>
</li>
</ul>
<a name="getCgroupStormHierarchyDir-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getCgroupStormHierarchyDir</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;getCgroupStormHierarchyDir(<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)</pre>
</li>
</ul>
<a name="getCgroupStormResources-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getCgroupStormResources</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html?is-external=true" title="class or interface in java.util">ArrayList</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>&gt;&nbsp;getCgroupStormResources(<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)</pre>
<div class="block"><p>Get the cgroup resources from the conf.</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>conf</code> - the config to read</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the resources.</dd>
</dl>
</li>
</ul>
<a name="getCgroupStormHierarchyName-java.util.Map-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>getCgroupStormHierarchyName</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;getCgroupStormHierarchyName(<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)</pre>
</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/DaemonConfig.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><a href="../../../org/apache/storm/Constants.html" title="class in org.apache.storm"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../org/apache/storm/ExclamationTopology.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/DaemonConfig.html" target="_top">Frames</a></li>
<li><a href="DaemonConfig.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>Nested&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>
