<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<link rel="canonical" href="https://ignite.apache.org/releases/2.4.0/javadoc/org/apache/ignite/IgniteSystemProperties.html" />
<META NAME="ROBOTS" CONTENT="NOINDEX">

<!-- Generated by javadoc (1.8.0_77) on Mon Mar 05 10:43:13 UTC 2018 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>IgniteSystemProperties (Ignite 2.4.0)</title>
<meta name="date" content="2018-03-05">
<link rel="stylesheet" type="text/css" href="../../../javadoc.css" title="Style">
<script type="text/javascript" src="../../../script.js"></script>

<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-61232409-1', 'auto');
  ga('send', 'pageview');

</script></head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="IgniteSystemProperties (Ignite 2.4.0)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":9,"i1":9,"i2":9,"i3":9,"i4":9,"i5":9,"i6":9,"i7":9,"i8":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/IgniteSystemProperties.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">Ignite - In-Memory Data Fabric</div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../org/apache/ignite/IgniteState.html" title="enum in org.apache.ignite"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../org/apache/ignite/IgniteTransactions.html" title="interface in org.apache.ignite"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?org/apache/ignite/IgniteSystemProperties.html" target="_top">Frames</a></li>
<li><a href="IgniteSystemProperties.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>Constr&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>Constr&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.ignite</div>
<h2 title="Class IgniteSystemProperties" class="title">Class IgniteSystemProperties</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="http://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.ignite.IgniteSystemProperties</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public final class <span class="typeNameLabel">IgniteSystemProperties</span>
extends <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></pre>
<div class="block">Contains constants for all system properties and environmental variables in Ignite.
 These properties and variables can be used to affect the behavior of Ignite.</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="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_AFFINITY_HISTORY_SIZE">IGNITE_AFFINITY_HISTORY_SIZE</a></span></code>
<div class="block">Maximum size for affinity assignment history.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_ATOMIC_CACHE_DELETE_HISTORY_SIZE">IGNITE_ATOMIC_CACHE_DELETE_HISTORY_SIZE</a></span></code>
<div class="block">Maximum size for atomic cache queue delete history (default is 200 000 entries per partition).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_ATOMIC_CACHE_QUEUE_RETRY_TIMEOUT">IGNITE_ATOMIC_CACHE_QUEUE_RETRY_TIMEOUT</a></span></code>
<div class="block">Atomic cache deferred update timeout.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_ATOMIC_DEFERRED_ACK_BUFFER_SIZE">IGNITE_ATOMIC_DEFERRED_ACK_BUFFER_SIZE</a></span></code>
<div class="block">Atomic cache deferred update response buffer size.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_ATOMIC_DEFERRED_ACK_TIMEOUT">IGNITE_ATOMIC_DEFERRED_ACK_TIMEOUT</a></span></code>
<div class="block">Atomic cache deferred update timeout.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_BINARY_DONT_WRAP_TREE_STRUCTURES">IGNITE_BINARY_DONT_WRAP_TREE_STRUCTURES</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">Should be removed in Apache Ignite 2.0.</span></div>
</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_BINARY_MARSHALLER_USE_STRING_SERIALIZATION_VER_2">IGNITE_BINARY_MARSHALLER_USE_STRING_SERIALIZATION_VER_2</a></span></code>
<div class="block">Manages type of serialization mechanism for <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang"><code>String</code></a> that is marshalled/unmarshalled by BinaryMarshaller.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_BINARY_SORT_OBJECT_FIELDS">IGNITE_BINARY_SORT_OBJECT_FIELDS</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">Should be removed in Apache Ignite 2.0.</span></div>
</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CACHE_CLIENT">IGNITE_CACHE_CLIENT</a></span></code>
<div class="block">Property controlling default behavior of cache client flag.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CACHE_KEY_VALIDATION_DISABLED">IGNITE_CACHE_KEY_VALIDATION_DISABLED</a></span></code>
<div class="block">Flag indicating whether validation of keys put to cache should be disabled.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CACHE_REMOVED_ENTRIES_TTL">IGNITE_CACHE_REMOVED_ENTRIES_TTL</a></span></code>
<div class="block">Ttl of removed cache entries (ms).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CACHE_RETRIES_COUNT">IGNITE_CACHE_RETRIES_COUNT</a></span></code>
<div class="block">Number of cache operation retries in case of topology exceptions.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CACHE_START_SIZE">IGNITE_CACHE_START_SIZE</a></span></code>
<div class="block">Cache start size for on-heap maps.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CLIENT_CACHE_CHANGE_MESSAGE_TIMEOUT">IGNITE_CLIENT_CACHE_CHANGE_MESSAGE_TIMEOUT</a></span></code>
<div class="block">When client cache is started or closed special discovery message is sent to notify cluster (for example this is
 needed for <a href="../../../org/apache/ignite/cluster/ClusterGroup.html#forCacheNodes-java.lang.String-"><code>ClusterGroup.forCacheNodes(String)</code></a> API.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CLUSTER_NAME">IGNITE_CLUSTER_NAME</a></span></code>
<div class="block">Ignite cluster name.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CONFIG_URL">IGNITE_CONFIG_URL</a></span></code>
<div class="block">System property to hold optional configuration URL.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CONSISTENT_ID_BY_HOST_WITHOUT_PORT">IGNITE_CONSISTENT_ID_BY_HOST_WITHOUT_PORT</a></span></code>
<div class="block">When set to <code>true</code>, for consistent id will calculate by host name, without port, and you can use
 only one node for host in cluster.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_CONSOLE_APPENDER">IGNITE_CONSOLE_APPENDER</a></span></code>
<div class="block">If this property is set to <code>true</code> (default) and Ignite is launched
 in verbose mode (see <a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_QUIET"><code>IGNITE_QUIET</code></a>) and no console appenders can be found
 in configuration, then default console appender will be added.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DAEMON">IGNITE_DAEMON</a></span></code>
<div class="block">Presence of this system property with value <code>true</code> will make the grid
 node start as a daemon node.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DATA_STORAGE_FOLDER_BY_CONSISTENT_ID">IGNITE_DATA_STORAGE_FOLDER_BY_CONSISTENT_ID</a></span></code>
<div class="block">When set to <code>true</code>, Data store folders are generated only by consistent id, and no consistent ID will be
 set based on existing data store folders.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD">IGNITE_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD</a></span></code>
<div class="block">Tasks stealing will be started if tasks queue size per data-streamer thread exceeds this threshold.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_BUFFER_SIZE">IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_BUFFER_SIZE</a></span></code>
<div class="block">One phase commit deferred ack request buffer size.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_TIMEOUT">IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_TIMEOUT</a></span></code>
<div class="block">One phase commit deferred ack request timeout.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DEP_MODE_OVERRIDE">IGNITE_DEP_MODE_OVERRIDE</a></span></code>
<div class="block">System property to override deployment mode configuration parameter.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DIAGNOSTIC_ENABLED">IGNITE_DIAGNOSTIC_ENABLED</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DIRECT_IO_ENABLED">IGNITE_DIRECT_IO_ENABLED</a></span></code>
<div class="block">When set to <code>true</code>, direct IO may be enabled.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DISABLE_HOSTNAME_VERIFIER">IGNITE_DISABLE_HOSTNAME_VERIFIER</a></span></code>
<div class="block">System property to disable <a href="http://docs.oracle.com/javase/8/docs/api/javax/net/ssl/HostnameVerifier.html?is-external=true" title="class or interface in javax.net.ssl"><code>HostnameVerifier</code></a> for SSL connections.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DISCO_FAILED_CLIENT_RECONNECT_DELAY">IGNITE_DISCO_FAILED_CLIENT_RECONNECT_DELAY</a></span></code>
<div class="block">Defines reconnect delay in milliseconds for client node that was failed forcible.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DISCOVERY_CLIENT_RECONNECT_HISTORY_SIZE">IGNITE_DISCOVERY_CLIENT_RECONNECT_HISTORY_SIZE</a></span></code>
<div class="block">Maximum number of discovery message history used to support client reconnect.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_DISCOVERY_HISTORY_SIZE">IGNITE_DISCOVERY_HISTORY_SIZE</a></span></code>
<div class="block">Maximum size for discovery messages history.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_ENABLE_FORCIBLE_NODE_KILL">IGNITE_ENABLE_FORCIBLE_NODE_KILL</a></span></code>
<div class="block">If this property is set, a node will forcible fail a remote node when it fails to establish a communication
 connection.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_EXCEPTION_REGISTRY_MAX_SIZE">IGNITE_EXCEPTION_REGISTRY_MAX_SIZE</a></span></code>
<div class="block">Property controlling size of buffer holding last exception.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_EXCHANGE_HISTORY_SIZE">IGNITE_EXCHANGE_HISTORY_SIZE</a></span></code>
<div class="block">Maximum size for exchange history.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_EXCHANGE_MERGE_DELAY">IGNITE_EXCHANGE_MERGE_DELAY</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_FORCE_START_JAVA7">IGNITE_FORCE_START_JAVA7</a></span></code>
<div class="block">Start Ignite on versions of JRE 7 older than 1.7.0_71.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_GRID_CLIENT_LOG_ENABLED">IGNITE_GRID_CLIENT_LOG_ENABLED</a></span></code>
<div class="block">If this property is set to <code>true</code> enable logging in <code>GridClient</code>.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_H2_DEBUG_CONSOLE">IGNITE_H2_DEBUG_CONSOLE</a></span></code>
<div class="block">If this property set then debug console will be opened for H2 indexing SPI.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_H2_DEBUG_CONSOLE_PORT">IGNITE_H2_DEBUG_CONSOLE_PORT</a></span></code>
<div class="block">This property allows to specify user defined port which H2 indexing SPI will use
 to start H2 debug console on.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_H2_INDEXING_CACHE_CLEANUP_PERIOD">IGNITE_H2_INDEXING_CACHE_CLEANUP_PERIOD</a></span></code>
<div class="block">System property to specify period in milliseconds between calls of the SQL statements cache cleanup task.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT">IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT</a></span></code>
<div class="block">System property to specify timeout in milliseconds after which thread's SQL statements cache is cleared by
 cleanup task if the thread does not perform any query.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_HOME">IGNITE_HOME</a></span></code>
<div class="block">Defines Ignite installation folder.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_INDEXING_DISCOVERY_HISTORY_SIZE">IGNITE_INDEXING_DISCOVERY_HISTORY_SIZE</a></span></code>
<div class="block">Indexing discovery history size.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_IO_BALANCE_PERIOD">IGNITE_IO_BALANCE_PERIOD</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_IO_DUMP_ON_TIMEOUT">IGNITE_IO_DUMP_ON_TIMEOUT</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_IPC_SHMEM_SPACE_DEBUG">IGNITE_IPC_SHMEM_SPACE_DEBUG</a></span></code>
<div class="block">If this property is set to <code>true</code> then shared memory space native debug will be enabled.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_JCACHE_DEFAULT_ISOLATED">IGNITE_JCACHE_DEFAULT_ISOLATED</a></span></code>
<div class="block">Property controlling whether CacheManager will start grid with isolated IP finder when default URL
 is passed in.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_JDBC_DRIVER_CURSOR_REMOVE_DELAY">IGNITE_JDBC_DRIVER_CURSOR_REMOVE_DELAY</a></span></code>
<div class="block">JDBC driver cursor remove delay.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_JETTY_HOST">IGNITE_JETTY_HOST</a></span></code>
<div class="block">This property allows to override Jetty host for REST processor.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_JETTY_LOG_NO_OVERRIDE">IGNITE_JETTY_LOG_NO_OVERRIDE</a></span></code>
<div class="block">This property does not allow Ignite to override Jetty log configuration for REST processor.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_JETTY_PORT">IGNITE_JETTY_PORT</a></span></code>
<div class="block">This property allows to override Jetty local port for REST processor.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_JOBS_HISTORY_SIZE">IGNITE_JOBS_HISTORY_SIZE</a></span></code>
<div class="block">System property to override default job processor maps sizes for finished jobs and
 cancellation requests.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_JOBS_METRICS_CONCURRENCY_LEVEL">IGNITE_JOBS_METRICS_CONCURRENCY_LEVEL</a></span></code>
<div class="block">System property to override default job metrics processor property defining
 concurrency level for structure holding job metrics snapshots.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LOCAL_HOST">IGNITE_LOCAL_HOST</a></span></code>
<div class="block">Name of system property to set system-wide local IP address or host.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LOCAL_STORE_KEEPS_PRIMARY_ONLY">IGNITE_LOCAL_STORE_KEEPS_PRIMARY_ONLY</a></span></code>
<div class="block">Indicating whether local store keeps primary only.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LOG_DIR">IGNITE_LOG_DIR</a></span></code>
<div class="block">Environment variable to override logging directory that has been set in logger configuration.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LOG_GRID_NAME">IGNITE_LOG_GRID_NAME</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">Use <a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LOG_INSTANCE_NAME"><code>IGNITE_LOG_INSTANCE_NAME</code></a>.</span></div>
</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LOG_INSTANCE_NAME">IGNITE_LOG_INSTANCE_NAME</a></span></code>
<div class="block">If this system property is present the Ignite will include instance name into verbose log.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LONG_LONG_HASH_MAP_LOAD_FACTOR">IGNITE_LONG_LONG_HASH_MAP_LOAD_FACTOR</a></span></code>
<div class="block">Long-long offheap map load factor.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT">IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT</a></span></code>
<div class="block">Cache operations that take more time than value of this property will be output to log.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT_LIMIT">IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT_LIMIT</a></span></code>
<div class="block">Upper time limit between long running/hanging operations debug dumps.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MARSHAL_BUFFERS_RECHECK">IGNITE_MARSHAL_BUFFERS_RECHECK</a></span></code>
<div class="block">System property to specify how often in milliseconds marshal buffers
 should be rechecked and potentially trimmed.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MARSHALLER_BLACKLIST">IGNITE_MARSHALLER_BLACKLIST</a></span></code>
<div class="block">Defines path to the file that contains list of classes disallowed to safe deserialization.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MARSHALLER_WHITELIST">IGNITE_MARSHALLER_WHITELIST</a></span></code>
<div class="block">Defines path to the file that contains list of classes allowed to safe deserialization.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MAX_COMPLETED_TX_COUNT">IGNITE_MAX_COMPLETED_TX_COUNT</a></span></code>
<div class="block">Property controlling size of buffer holding completed transaction versions.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MAX_INDEX_PAYLOAD_SIZE">IGNITE_MAX_INDEX_PAYLOAD_SIZE</a></span></code>
<div class="block">System property to specify maximum payload size in bytes for <code>H2TreeIndex</code>.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MAX_NESTED_LISTENER_CALLS">IGNITE_MAX_NESTED_LISTENER_CALLS</a></span></code>
<div class="block">Maximum number of nested listener calls before listener notification becomes asynchronous.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MBEAN_APPEND_CLASS_LOADER_ID">IGNITE_MBEAN_APPEND_CLASS_LOADER_ID</a></span></code>
<div class="block">If this property is set to <code>true</code> then Ignite will append
 hash code of class loader to MXBean name.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MBEAN_APPEND_JVM_ID">IGNITE_MBEAN_APPEND_JVM_ID</a></span></code>
<div class="block">If this property is set to <code>true</code> then Ignite will append
 hash code of <a href="../../../org/apache/ignite/Ignite.html" title="interface in org.apache.ignite"><code>Ignite</code></a> class as hex string and append
 JVM name returned by <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/management/RuntimeMXBean.html?is-external=true#getName--" title="class or interface in java.lang.management"><code>RuntimeMXBean.getName()</code></a>.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MBEANS_DISABLED">IGNITE_MBEANS_DISABLED</a></span></code>
<div class="block">If property is set to <code>true</code>, then Ignite will disable MBeans registration.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MEMORY_PER_BYTE_COPY_THRESHOLD">IGNITE_MEMORY_PER_BYTE_COPY_THRESHOLD</a></span></code>
<div class="block">When unsafe memory copy if performed below this threshold, Ignite will do it on per-byte basis instead of
 calling to Unsafe.copyMemory().</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MEMORY_UNALIGNED_ACCESS">IGNITE_MEMORY_UNALIGNED_ACCESS</a></span></code>
<div class="block">Whether Ignite can access unaligned memory addresses.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_MIN_BUFFERED_COMMUNICATION_MSG_CNT">IGNITE_MIN_BUFFERED_COMMUNICATION_MSG_CNT</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">Not used anymore.</span></div>
</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_NEAR_GET_MAX_REMAPS">IGNITE_NEAR_GET_MAX_REMAPS</a></span></code>
<div class="block">This property defines the maximum number of attempts to remap near get to the same
 primary node.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_NO_ASCII">IGNITE_NO_ASCII</a></span></code>
<div class="block">If this system property is present (any value) - no ASCII logo will
 be printed.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_NO_DISCO_ORDER">IGNITE_NO_DISCO_ORDER</a></span></code>
<div class="block">Name of the system property to disable requirement for proper node ordering
 by discovery SPI.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_NO_SELECTOR_OPTS">IGNITE_NO_SELECTOR_OPTS</a></span></code>
<div class="block">If set to <code>true</code>, then default selected keys set is used inside
 <code>GridNioServer</code> which lead to some extra garbage generation when
 processing selected keys.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_NO_SHUTDOWN_HOOK">IGNITE_NO_SHUTDOWN_HOOK</a></span></code>
<div class="block">If this system property is set to <code>false</code> - no shutdown hook will be set.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_OFFHEAP_LOCK_CONCURRENCY_LEVEL">IGNITE_OFFHEAP_LOCK_CONCURRENCY_LEVEL</a></span></code>
<div class="block">Ignite page memory concurrency level.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_OFFHEAP_SAFE_RELEASE">IGNITE_OFFHEAP_SAFE_RELEASE</a></span></code>
<div class="block">Flag that will force Ignite to fill memory block with some recognisable pattern right before
 this memory block is released.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_OPTIMIZED_MARSHALLER_USE_DEFAULT_SUID">IGNITE_OPTIMIZED_MARSHALLER_USE_DEFAULT_SUID</a></span></code>
<div class="block">Manages <code>OptimizedMarshaller</code> behavior of <code>serialVersionUID</code> computation for
 <a href="http://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io"><code>Serializable</code></a> classes.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_OVERRIDE_MCAST_GRP">IGNITE_OVERRIDE_MCAST_GRP</a></span></code>
<div class="block">System property to override multicast group taken from configuration.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_OVERRIDE_WRITE_THROTTLING_ENABLED">IGNITE_OVERRIDE_WRITE_THROTTLING_ENABLED</a></span></code>
<div class="block">If this property is set, <a href="../../../org/apache/ignite/configuration/DataStorageConfiguration.html#writeThrottlingEnabled"><code>DataStorageConfiguration.writeThrottlingEnabled</code></a> will be overridden to true
 independent of initial value in configuration.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PARTITION_RELEASE_FUTURE_DUMP_THRESHOLD">IGNITE_PARTITION_RELEASE_FUTURE_DUMP_THRESHOLD</a></span></code>
<div class="block">If a partition release future completion time during an exchange exceeds this threshold, the contents of
 the future will be dumped to the log on exchange.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PDS_MAX_CHECKPOINT_MEMORY_HISTORY_SIZE">IGNITE_PDS_MAX_CHECKPOINT_MEMORY_HISTORY_SIZE</a></span></code>
<div class="block">Number of checkpoint history entries held in memory.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PDS_PARTITION_DESTROY_CHECKPOINT_DELAY">IGNITE_PDS_PARTITION_DESTROY_CHECKPOINT_DELAY</a></span></code>
<div class="block">WAL rebalance threshold.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PDS_SKIP_CRC">IGNITE_PDS_SKIP_CRC</a></span></code>
<div class="block">Skip CRC calculation flag.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PDS_WAL_REBALANCE_THRESHOLD">IGNITE_PDS_WAL_REBALANCE_THRESHOLD</a></span></code>
<div class="block">WAL rebalance threshold.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PERFORMANCE_SUGGESTIONS_DISABLED">IGNITE_PERFORMANCE_SUGGESTIONS_DISABLED</a></span></code>
<div class="block">Flag indicating whether performance suggestions output on start should be disabled.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PRELOAD_RESEND_TIMEOUT">IGNITE_PRELOAD_RESEND_TIMEOUT</a></span></code>
<div class="block">System property to hold preload resend timeout for evicted partitions.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_PROG_NAME">IGNITE_PROG_NAME</a></span></code>
<div class="block">Name of the system property defining name of command line program.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_QUIET">IGNITE_QUIET</a></span></code>
<div class="block">Set to either <code>true</code> or <code>false</code> to enable or disable quiet mode
 of Ignite.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_REBALANCE_STATISTICS_TIME_INTERVAL">IGNITE_REBALANCE_STATISTICS_TIME_INTERVAL</a></span></code>
<div class="block">Time interval for calculating rebalance rate statistics, in milliseconds.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_REFLECTION_CACHE_SIZE">IGNITE_REFLECTION_CACHE_SIZE</a></span></code>
<div class="block">System property to override default reflection cache size.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_REST_MAX_TASK_RESULTS">IGNITE_REST_MAX_TASK_RESULTS</a></span></code>
<div class="block">This property allows to override maximum count of task results stored on one node
 in REST processor.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_REST_SESSION_TIMEOUT">IGNITE_REST_SESSION_TIMEOUT</a></span></code>
<div class="block">This property allow rewriting default (<code>30</code>) rest session expire time (in seconds).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_REST_START_ON_CLIENT">IGNITE_REST_START_ON_CLIENT</a></span></code>
<div class="block">This property allows to override default behavior that rest processor
 doesn't start on client node.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_RESTART_CODE">IGNITE_RESTART_CODE</a></span></code>
<div class="block">This property is used internally to pass an exit code to loader when
 Ignite instance is being restarted.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SECURITY_COMPATIBILITY_MODE">IGNITE_SECURITY_COMPATIBILITY_MODE</a></span></code>
<div class="block">When set to <code>true</code>, Ignite switches to compatibility mode with versions that don't
 support service security permissions.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SERVICES_COMPATIBILITY_MODE">IGNITE_SERVICES_COMPATIBILITY_MODE</a></span></code>
<div class="block">Manages backward compatibility of <a href="../../../org/apache/ignite/IgniteServices.html" title="interface in org.apache.ignite"><code>IgniteServices</code></a>.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SKIP_CONFIGURATION_CONSISTENCY_CHECK">IGNITE_SKIP_CONFIGURATION_CONSISTENCY_CHECK</a></span></code>
<div class="block">Property allowing to skip configuration consistency checks.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SLOW_TX_WARN_TIMEOUT">IGNITE_SLOW_TX_WARN_TIMEOUT</a></span></code>
<div class="block">Transactions that take more time, than value of this property, will be output to log
 with warning level.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SQL_MERGE_TABLE_MAX_SIZE">IGNITE_SQL_MERGE_TABLE_MAX_SIZE</a></span></code>
<div class="block">Property controlling maximum number of SQL result rows which can be fetched into a merge table.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SQL_MERGE_TABLE_PREFETCH_SIZE">IGNITE_SQL_MERGE_TABLE_PREFETCH_SIZE</a></span></code>
<div class="block">Property controlling number of SQL result rows that will be fetched into a merge table at once before
 applying binary search for the bounds.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SQL_PARSER_DISABLE_H2_FALLBACK">IGNITE_SQL_PARSER_DISABLE_H2_FALLBACK</a></span></code>
<div class="block">Disable fallback to H2 SQL parser if the internal SQL parser fails to parse the statement.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SSH_HOST">IGNITE_SSH_HOST</a></span></code>
<div class="block">System property to hold SSH host for visor-started nodes.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SSH_USER_NAME">IGNITE_SSH_USER_NAME</a></span></code>
<div class="block">System property to hold SSH user name for visor-started nodes.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_START_CACHES_ON_JOIN">IGNITE_START_CACHES_ON_JOIN</a></span></code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_STARVATION_CHECK_INTERVAL">IGNITE_STARVATION_CHECK_INTERVAL</a></span></code>
<div class="block">This system property defines interval in milliseconds in which Ignite will check
 thread pool state for starvation.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_STREAM_TRANSFORMER_COMPATIBILITY_MODE">IGNITE_STREAM_TRANSFORMER_COMPATIBILITY_MODE</a></span></code>
<div class="block">Manages backward compatibility of <a href="../../../org/apache/ignite/stream/StreamTransformer.html#from-org.apache.ignite.cache.CacheEntryProcessor-"><code>StreamTransformer.from(CacheEntryProcessor)</code></a> method.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_SUCCESS_FILE">IGNITE_SUCCESS_FILE</a></span></code>
<div class="block">Name of the system property defining success file name.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TCP_DISCOVERY_ADDRESSES">IGNITE_TCP_DISCOVERY_ADDRESSES</a></span></code>
<div class="block">Comma separated list of addresses in format "10.100.22.100:45000,10.100.22.101:45000".</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_THREAD_DUMP_ON_EXCHANGE_TIMEOUT">IGNITE_THREAD_DUMP_ON_EXCHANGE_TIMEOUT</a></span></code>
<div class="block">If this property is set to <code>true</code> then Ignite will log thread dump in case of partition exchange timeout.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TO_STRING_COLLECTION_LIMIT">IGNITE_TO_STRING_COLLECTION_LIMIT</a></span></code>
<div class="block">Limit collection (map, array) elements number to output.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TO_STRING_INCLUDE_SENSITIVE">IGNITE_TO_STRING_INCLUDE_SENSITIVE</a></span></code>
<div class="block">Setting to <code>true</code> enables writing sensitive information in <code>toString()</code> output.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TO_STRING_MAX_LENGTH">IGNITE_TO_STRING_MAX_LENGTH</a></span></code>
<div class="block">Maximum length for <code>toString()</code> result.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TROUBLESHOOTING_LOGGER">IGNITE_TROUBLESHOOTING_LOGGER</a></span></code>
<div class="block">Setting this option to <code>true</code> will enable troubleshooting logger.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TTL_EXPIRE_BATCH_SIZE">IGNITE_TTL_EXPIRE_BATCH_SIZE</a></span></code>
<div class="block">When cache has entries with expired TTL, each user operation will also remove this amount of expired entries.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TX_DEADLOCK_DETECTION_MAX_ITERS">IGNITE_TX_DEADLOCK_DETECTION_MAX_ITERS</a></span></code>
<div class="block">Specifies maximum number of iterations for deadlock detection procedure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TX_DEADLOCK_DETECTION_TIMEOUT">IGNITE_TX_DEADLOCK_DETECTION_TIMEOUT</a></span></code>
<div class="block">Specifies timeout for deadlock detection procedure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_TX_SALVAGE_TIMEOUT">IGNITE_TX_SALVAGE_TIMEOUT</a></span></code>
<div class="block">Timeout after which all uncompleted transactions originated by left node will be
 salvaged (i.e. invalidated and committed).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_UNWRAP_BINARY_FOR_INDEXING_SPI">IGNITE_UNWRAP_BINARY_FOR_INDEXING_SPI</a></span></code>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;
<div class="block"><span class="deprecationComment">Should be removed in Apache Ignite 2.0.</span></div>
</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_UPDATE_NOTIFIER">IGNITE_UPDATE_NOTIFIER</a></span></code>
<div class="block">If this system property is set to <code>false</code> - no checks for new versions will
 be performed by Ignite.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_USE_ASYNC_FILE_IO_FACTORY">IGNITE_USE_ASYNC_FILE_IO_FACTORY</a></span></code>
<div class="block">If this property is set, then Ignite will use Async File IO factory by default.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_USE_LEGACY_NODE_COMPARATOR">IGNITE_USE_LEGACY_NODE_COMPARATOR</a></span></code>
<div class="block">If the property is set Ignite will use legacy node comparator (based on node order) inste

 Default value is <code>false</code>.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_WAL_DEBUG_LOG_ON_RECOVERY">IGNITE_WAL_DEBUG_LOG_ON_RECOVERY</a></span></code>
<div class="block">Default value is <code>false</code>.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_WAL_FSYNC_WITH_DEDICATED_WORKER">IGNITE_WAL_FSYNC_WITH_DEDICATED_WORKER</a></span></code>
<div class="block">When set to <code>true</code>, WAL implementation with dedicated worker will be used even in FSYNC mode.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_WAL_LOG_TX_RECORDS">IGNITE_WAL_LOG_TX_RECORDS</a></span></code>
<div class="block">If the property is set <code>TxRecord</code> records
 will be logged to WAL.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_WAL_MMAP">IGNITE_WAL_MMAP</a></span></code>
<div class="block">Property that indicates should be mapped byte buffer used or not.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_WAL_SERIALIZER_VERSION">IGNITE_WAL_SERIALIZER_VERSION</a></span></code>
<div class="block">Property for setup WAL serializer version.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_WORK_DIR">IGNITE_WORK_DIR</a></span></code>
<div class="block">Environment variable to set work directory.</div>
</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 boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getBoolean-java.lang.String-">getBoolean</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getBoolean-java.lang.String-boolean-">getBoolean</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
          boolean&nbsp;dflt)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getDouble-java.lang.String-double-">getDouble</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
         double&nbsp;dflt)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>static float</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getFloat-java.lang.String-float-">getFloat</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
        float&nbsp;dflt)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getInteger-java.lang.String-int-">getInteger</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
          int&nbsp;dflt)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>static long</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getLong-java.lang.String-long-">getLong</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
       long&nbsp;dflt)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getString-java.lang.String-">getString</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#getString-java.lang.String-java.lang.String-">getString</a></span>(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
         <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;dflt)</code>
<div class="block">Gets either system property or environment variable with given name.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../org/apache/ignite/IgniteSystemProperties.html#snapshot--">snapshot</a></span>()</code>
<div class="block">Gets snapshot of system properties.</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="http://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="http://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="http://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="http://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="http://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="http://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="http://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="http://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="http://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="http://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="http://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="http://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="IGNITE_LOG_GRID_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LOG_GRID_NAME</h4>
<pre><a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LOG_GRID_NAME</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Use <a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_LOG_INSTANCE_NAME"><code>IGNITE_LOG_INSTANCE_NAME</code></a>.</span></div>
<div class="block">If this system property is present the Ignite will include grid name into verbose log.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LOG_GRID_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_LOG_INSTANCE_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LOG_INSTANCE_NAME</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LOG_INSTANCE_NAME</pre>
<div class="block">If this system property is present the Ignite will include instance name into verbose log.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LOG_INSTANCE_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_RESTART_CODE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_RESTART_CODE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_RESTART_CODE</pre>
<div class="block">This property is used internally to pass an exit code to loader when
 Ignite instance is being restarted.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_RESTART_CODE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DAEMON">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DAEMON</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DAEMON</pre>
<div class="block">Presence of this system property with value <code>true</code> will make the grid
 node start as a daemon node. Node that this system property will override
 <a href="../../../org/apache/ignite/configuration/IgniteConfiguration.html#isDaemon--"><code>IgniteConfiguration.isDaemon()</code></a> configuration.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DAEMON">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_HOME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_HOME</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_HOME</pre>
<div class="block">Defines Ignite installation folder.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_HOME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_NO_SHUTDOWN_HOOK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_NO_SHUTDOWN_HOOK</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_NO_SHUTDOWN_HOOK</pre>
<div class="block">If this system property is set to <code>false</code> - no shutdown hook will be set.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_NO_SHUTDOWN_HOOK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_NO_DISCO_ORDER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_NO_DISCO_ORDER</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_NO_DISCO_ORDER</pre>
<div class="block">Name of the system property to disable requirement for proper node ordering
 by discovery SPI. Use with care, as proper node ordering is required for
 cache consistency. If set to <code>true</code>, then any discovery SPI can be used
 with distributed cache, otherwise, only discovery SPIs that have annotation
 <a href="../../../org/apache/ignite/spi/discovery/DiscoverySpiOrderSupport.html" title="annotation in org.apache.ignite.spi.discovery"><code>@GridDiscoverySpiOrderSupport(true)</code></a> will
 be allowed.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_NO_DISCO_ORDER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DISCO_FAILED_CLIENT_RECONNECT_DELAY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DISCO_FAILED_CLIENT_RECONNECT_DELAY</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DISCO_FAILED_CLIENT_RECONNECT_DELAY</pre>
<div class="block">Defines reconnect delay in milliseconds for client node that was failed forcible.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DISCO_FAILED_CLIENT_RECONNECT_DELAY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_UPDATE_NOTIFIER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_UPDATE_NOTIFIER</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_UPDATE_NOTIFIER</pre>
<div class="block">If this system property is set to <code>false</code> - no checks for new versions will
 be performed by Ignite. By default, Ignite periodically checks for the new
 version and prints out the message into the log if new version of Ignite is
 available for download.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_UPDATE_NOTIFIER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_STARVATION_CHECK_INTERVAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_STARVATION_CHECK_INTERVAL</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_STARVATION_CHECK_INTERVAL</pre>
<div class="block">This system property defines interval in milliseconds in which Ignite will check
 thread pool state for starvation. Zero value will disable this checker.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_STARVATION_CHECK_INTERVAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_NO_ASCII">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_NO_ASCII</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_NO_ASCII</pre>
<div class="block">If this system property is present (any value) - no ASCII logo will
 be printed.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_NO_ASCII">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_JETTY_HOST">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_JETTY_HOST</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_JETTY_HOST</pre>
<div class="block">This property allows to override Jetty host for REST processor.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_JETTY_HOST">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_JETTY_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_JETTY_PORT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_JETTY_PORT</pre>
<div class="block">This property allows to override Jetty local port for REST processor.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_JETTY_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_JETTY_LOG_NO_OVERRIDE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_JETTY_LOG_NO_OVERRIDE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_JETTY_LOG_NO_OVERRIDE</pre>
<div class="block">This property does not allow Ignite to override Jetty log configuration for REST processor.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_JETTY_LOG_NO_OVERRIDE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_REST_SESSION_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_REST_SESSION_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_REST_SESSION_TIMEOUT</pre>
<div class="block">This property allow rewriting default (<code>30</code>) rest session expire time (in seconds).</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_REST_SESSION_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_REST_MAX_TASK_RESULTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_REST_MAX_TASK_RESULTS</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_REST_MAX_TASK_RESULTS</pre>
<div class="block">This property allows to override maximum count of task results stored on one node
 in REST processor.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_REST_MAX_TASK_RESULTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_REST_START_ON_CLIENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_REST_START_ON_CLIENT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_REST_START_ON_CLIENT</pre>
<div class="block">This property allows to override default behavior that rest processor
 doesn't start on client node. If set <code>true</code> than rest processor will be started on client node.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_REST_START_ON_CLIENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_NEAR_GET_MAX_REMAPS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_NEAR_GET_MAX_REMAPS</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_NEAR_GET_MAX_REMAPS</pre>
<div class="block">This property defines the maximum number of attempts to remap near get to the same
 primary node. Remapping may be needed when topology is changed concurrently with
 get operation.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_NEAR_GET_MAX_REMAPS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_QUIET">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_QUIET</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_QUIET</pre>
<div class="block">Set to either <code>true</code> or <code>false</code> to enable or disable quiet mode
 of Ignite. In quiet mode, only warning and errors are printed into the log
 additionally to a shortened version of standard output on the start.
 <p>
 Note that if you use <tt>ignite.{sh|bat}</tt> scripts to start Ignite they
 start by default in quiet mode. You can supply <tt>-v</tt> flag to override it.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_QUIET">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TROUBLESHOOTING_LOGGER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TROUBLESHOOTING_LOGGER</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TROUBLESHOOTING_LOGGER</pre>
<div class="block">Setting this option to <code>true</code> will enable troubleshooting logger.
 Troubleshooting logger makes logging more verbose without enabling debug mode
 to provide more detailed logs without performance penalty.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TROUBLESHOOTING_LOGGER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TO_STRING_INCLUDE_SENSITIVE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TO_STRING_INCLUDE_SENSITIVE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TO_STRING_INCLUDE_SENSITIVE</pre>
<div class="block">Setting to <code>true</code> enables writing sensitive information in <code>toString()</code> output.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TO_STRING_INCLUDE_SENSITIVE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TO_STRING_MAX_LENGTH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TO_STRING_MAX_LENGTH</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TO_STRING_MAX_LENGTH</pre>
<div class="block">Maximum length for <code>toString()</code> result.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TO_STRING_MAX_LENGTH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TO_STRING_COLLECTION_LIMIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TO_STRING_COLLECTION_LIMIT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TO_STRING_COLLECTION_LIMIT</pre>
<div class="block">Limit collection (map, array) elements number to output.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TO_STRING_COLLECTION_LIMIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CONSOLE_APPENDER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CONSOLE_APPENDER</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CONSOLE_APPENDER</pre>
<div class="block">If this property is set to <code>true</code> (default) and Ignite is launched
 in verbose mode (see <a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_QUIET"><code>IGNITE_QUIET</code></a>) and no console appenders can be found
 in configuration, then default console appender will be added.
 Set this property to <code>false</code> if no appenders should be added.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CONSOLE_APPENDER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_EXCHANGE_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_EXCHANGE_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_EXCHANGE_HISTORY_SIZE</pre>
<div class="block">Maximum size for exchange history. Default value is <code>1000</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_EXCHANGE_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_EXCHANGE_MERGE_DELAY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_EXCHANGE_MERGE_DELAY</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_EXCHANGE_MERGE_DELAY</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_EXCHANGE_MERGE_DELAY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PROG_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PROG_NAME</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PROG_NAME</pre>
<div class="block">Name of the system property defining name of command line program.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PROG_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SUCCESS_FILE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SUCCESS_FILE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SUCCESS_FILE</pre>
<div class="block">Name of the system property defining success file name. This file
 is used with auto-restarting functionality when Ignite is started
 by supplied <tt>ignite.{bat|sh}</tt> scripts.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SUCCESS_FILE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_LOCAL_HOST">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LOCAL_HOST</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LOCAL_HOST</pre>
<div class="block">Name of system property to set system-wide local IP address or host. If provided it will
 override all default local bind settings within Ignite or any of its SPIs.
 <p>
 Note that system-wide local bind address can also be set via <a href="../../../org/apache/ignite/configuration/IgniteConfiguration.html#getLocalHost--"><code>IgniteConfiguration.getLocalHost()</code></a>
 method. However, system properties have priority over configuration properties specified in
 <a href="../../../org/apache/ignite/configuration/IgniteConfiguration.html" title="class in org.apache.ignite.configuration"><code>IgniteConfiguration</code></a>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LOCAL_HOST">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DEP_MODE_OVERRIDE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DEP_MODE_OVERRIDE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DEP_MODE_OVERRIDE</pre>
<div class="block">System property to override deployment mode configuration parameter.
 Valid values for property are: PRIVATE, ISOLATED, SHARED or CONTINUOUS.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../org/apache/ignite/configuration/DeploymentMode.html" title="enum in org.apache.ignite.configuration"><code>DeploymentMode</code></a>, 
<a href="../../../org/apache/ignite/configuration/IgniteConfiguration.html#getDeploymentMode--"><code>IgniteConfiguration.getDeploymentMode()</code></a>, 
<a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DEP_MODE_OVERRIDE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MAX_COMPLETED_TX_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MAX_COMPLETED_TX_COUNT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MAX_COMPLETED_TX_COUNT</pre>
<div class="block">Property controlling size of buffer holding completed transaction versions. Such buffer
 is used to detect duplicate transaction and has a default value of <code>102400</code>. In
 most cases this value is large enough and does not need to be changed.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MAX_COMPLETED_TX_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SLOW_TX_WARN_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SLOW_TX_WARN_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SLOW_TX_WARN_TIMEOUT</pre>
<div class="block">Transactions that take more time, than value of this property, will be output to log
 with warning level. <code>0</code> (default value) disables warning on slow transactions.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SLOW_TX_WARN_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TX_SALVAGE_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TX_SALVAGE_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TX_SALVAGE_TIMEOUT</pre>
<div class="block">Timeout after which all uncompleted transactions originated by left node will be
 salvaged (i.e. invalidated and committed).</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TX_SALVAGE_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TX_DEADLOCK_DETECTION_MAX_ITERS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TX_DEADLOCK_DETECTION_MAX_ITERS</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TX_DEADLOCK_DETECTION_MAX_ITERS</pre>
<div class="block">Specifies maximum number of iterations for deadlock detection procedure.
 If value of this property is less then or equal to zero then deadlock detection will be disabled.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TX_DEADLOCK_DETECTION_MAX_ITERS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TX_DEADLOCK_DETECTION_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TX_DEADLOCK_DETECTION_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TX_DEADLOCK_DETECTION_TIMEOUT</pre>
<div class="block">Specifies timeout for deadlock detection procedure.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TX_DEADLOCK_DETECTION_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_OVERRIDE_MCAST_GRP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_OVERRIDE_MCAST_GRP</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_OVERRIDE_MCAST_GRP</pre>
<div class="block">System property to override multicast group taken from configuration.
 Used for testing purposes.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_OVERRIDE_MCAST_GRP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_REFLECTION_CACHE_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_REFLECTION_CACHE_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_REFLECTION_CACHE_SIZE</pre>
<div class="block">System property to override default reflection cache size. Default value is <code>128</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_REFLECTION_CACHE_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_JOBS_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_JOBS_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_JOBS_HISTORY_SIZE</pre>
<div class="block">System property to override default job processor maps sizes for finished jobs and
 cancellation requests. Default value is <code>10240</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_JOBS_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_JOBS_METRICS_CONCURRENCY_LEVEL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_JOBS_METRICS_CONCURRENCY_LEVEL</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_JOBS_METRICS_CONCURRENCY_LEVEL</pre>
<div class="block">System property to override default job metrics processor property defining
 concurrency level for structure holding job metrics snapshots.
 Default value is <code>64</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_JOBS_METRICS_CONCURRENCY_LEVEL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CONFIG_URL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CONFIG_URL</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CONFIG_URL</pre>
<div class="block">System property to hold optional configuration URL.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CONFIG_URL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SSH_HOST">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SSH_HOST</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SSH_HOST</pre>
<div class="block">System property to hold SSH host for visor-started nodes.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SSH_HOST">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SSH_USER_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SSH_USER_NAME</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SSH_USER_NAME</pre>
<div class="block">System property to hold SSH user name for visor-started nodes.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SSH_USER_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PRELOAD_RESEND_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PRELOAD_RESEND_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PRELOAD_RESEND_TIMEOUT</pre>
<div class="block">System property to hold preload resend timeout for evicted partitions.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PRELOAD_RESEND_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MARSHAL_BUFFERS_RECHECK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MARSHAL_BUFFERS_RECHECK</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MARSHAL_BUFFERS_RECHECK</pre>
<div class="block">System property to specify how often in milliseconds marshal buffers
 should be rechecked and potentially trimmed. Default value is <code>10,000ms</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MARSHAL_BUFFERS_RECHECK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DISABLE_HOSTNAME_VERIFIER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DISABLE_HOSTNAME_VERIFIER</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DISABLE_HOSTNAME_VERIFIER</pre>
<div class="block">System property to disable <a href="http://docs.oracle.com/javase/8/docs/api/javax/net/ssl/HostnameVerifier.html?is-external=true" title="class or interface in javax.net.ssl"><code>HostnameVerifier</code></a> for SSL connections.
 Can be used for development with self-signed certificates. Default value is <code>false</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DISABLE_HOSTNAME_VERIFIER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MIN_BUFFERED_COMMUNICATION_MSG_CNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MIN_BUFFERED_COMMUNICATION_MSG_CNT</h4>
<pre><a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MIN_BUFFERED_COMMUNICATION_MSG_CNT</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Not used anymore.</span></div>
<div class="block">System property to disable buffered communication if node sends less messages count than
 specified by this property. Default value is <code>512</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MIN_BUFFERED_COMMUNICATION_MSG_CNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_OFFHEAP_SAFE_RELEASE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_OFFHEAP_SAFE_RELEASE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_OFFHEAP_SAFE_RELEASE</pre>
<div class="block">Flag that will force Ignite to fill memory block with some recognisable pattern right before
 this memory block is released. This will help to recognize cases when already released memory is accessed.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_OFFHEAP_SAFE_RELEASE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_ATOMIC_CACHE_DELETE_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_ATOMIC_CACHE_DELETE_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_ATOMIC_CACHE_DELETE_HISTORY_SIZE</pre>
<div class="block">Maximum size for atomic cache queue delete history (default is 200 000 entries per partition).</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_ATOMIC_CACHE_DELETE_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CACHE_REMOVED_ENTRIES_TTL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CACHE_REMOVED_ENTRIES_TTL</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CACHE_REMOVED_ENTRIES_TTL</pre>
<div class="block">Ttl of removed cache entries (ms).</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CACHE_REMOVED_ENTRIES_TTL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TCP_DISCOVERY_ADDRESSES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TCP_DISCOVERY_ADDRESSES</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TCP_DISCOVERY_ADDRESSES</pre>
<div class="block">Comma separated list of addresses in format "10.100.22.100:45000,10.100.22.101:45000".
 Makes sense only for <a href="../../../org/apache/ignite/spi/discovery/tcp/ipfinder/vm/TcpDiscoveryVmIpFinder.html" title="class in org.apache.ignite.spi.discovery.tcp.ipfinder.vm"><code>TcpDiscoveryVmIpFinder</code></a>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TCP_DISCOVERY_ADDRESSES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PERFORMANCE_SUGGESTIONS_DISABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PERFORMANCE_SUGGESTIONS_DISABLED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PERFORMANCE_SUGGESTIONS_DISABLED</pre>
<div class="block">Flag indicating whether performance suggestions output on start should be disabled.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PERFORMANCE_SUGGESTIONS_DISABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_ATOMIC_DEFERRED_ACK_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_ATOMIC_DEFERRED_ACK_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_ATOMIC_DEFERRED_ACK_BUFFER_SIZE</pre>
<div class="block">Atomic cache deferred update response buffer size.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_ATOMIC_DEFERRED_ACK_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_ATOMIC_DEFERRED_ACK_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_ATOMIC_DEFERRED_ACK_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_ATOMIC_DEFERRED_ACK_TIMEOUT</pre>
<div class="block">Atomic cache deferred update timeout.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_ATOMIC_DEFERRED_ACK_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_ATOMIC_CACHE_QUEUE_RETRY_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_ATOMIC_CACHE_QUEUE_RETRY_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_ATOMIC_CACHE_QUEUE_RETRY_TIMEOUT</pre>
<div class="block">Atomic cache deferred update timeout.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_ATOMIC_CACHE_QUEUE_RETRY_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_TIMEOUT</pre>
<div class="block">One phase commit deferred ack request timeout.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_BUFFER_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_BUFFER_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_BUFFER_SIZE</pre>
<div class="block">One phase commit deferred ack request buffer size.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DEFERRED_ONE_PHASE_COMMIT_ACK_REQUEST_BUFFER_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_H2_DEBUG_CONSOLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_H2_DEBUG_CONSOLE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_H2_DEBUG_CONSOLE</pre>
<div class="block">If this property set then debug console will be opened for H2 indexing SPI.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_H2_DEBUG_CONSOLE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_H2_DEBUG_CONSOLE_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_H2_DEBUG_CONSOLE_PORT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_H2_DEBUG_CONSOLE_PORT</pre>
<div class="block">This property allows to specify user defined port which H2 indexing SPI will use
 to start H2 debug console on. If this property is not set or set to 0, H2 debug
 console will use system-provided dynamic port.
 This property is only relevant when <a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_H2_DEBUG_CONSOLE"><code>IGNITE_H2_DEBUG_CONSOLE</code></a> property is set.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_H2_DEBUG_CONSOLE_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_IPC_SHMEM_SPACE_DEBUG">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_IPC_SHMEM_SPACE_DEBUG</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_IPC_SHMEM_SPACE_DEBUG</pre>
<div class="block">If this property is set to <code>true</code> then shared memory space native debug will be enabled.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_IPC_SHMEM_SPACE_DEBUG">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SKIP_CONFIGURATION_CONSISTENCY_CHECK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SKIP_CONFIGURATION_CONSISTENCY_CHECK</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SKIP_CONFIGURATION_CONSISTENCY_CHECK</pre>
<div class="block">Property allowing to skip configuration consistency checks.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SKIP_CONFIGURATION_CONSISTENCY_CHECK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CACHE_KEY_VALIDATION_DISABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CACHE_KEY_VALIDATION_DISABLED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CACHE_KEY_VALIDATION_DISABLED</pre>
<div class="block">Flag indicating whether validation of keys put to cache should be disabled.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CACHE_KEY_VALIDATION_DISABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_LOG_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LOG_DIR</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LOG_DIR</pre>
<div class="block">Environment variable to override logging directory that has been set in logger configuration.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LOG_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_WORK_DIR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_WORK_DIR</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_WORK_DIR</pre>
<div class="block">Environment variable to set work directory. The property <a href="../../../org/apache/ignite/configuration/IgniteConfiguration.html#setWorkDirectory-java.lang.String-"><code>IgniteConfiguration.setWorkDirectory(java.lang.String)</code></a> has higher
 priority.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_WORK_DIR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MBEAN_APPEND_JVM_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MBEAN_APPEND_JVM_ID</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MBEAN_APPEND_JVM_ID</pre>
<div class="block">If this property is set to <code>true</code> then Ignite will append
 hash code of <a href="../../../org/apache/ignite/Ignite.html" title="interface in org.apache.ignite"><code>Ignite</code></a> class as hex string and append
 JVM name returned by <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/management/RuntimeMXBean.html?is-external=true#getName--" title="class or interface in java.lang.management"><code>RuntimeMXBean.getName()</code></a>.
 <p>
 This may be helpful when running Ignite in some application server
 clusters or similar environments to avoid MBean name collisions.
 <p>
 Default is <code>false</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MBEAN_APPEND_JVM_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MBEAN_APPEND_CLASS_LOADER_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MBEAN_APPEND_CLASS_LOADER_ID</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MBEAN_APPEND_CLASS_LOADER_ID</pre>
<div class="block">If this property is set to <code>true</code> then Ignite will append
 hash code of class loader to MXBean name.
 <p>
 Default is <code>true</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MBEAN_APPEND_CLASS_LOADER_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MBEANS_DISABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MBEANS_DISABLED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MBEANS_DISABLED</pre>
<div class="block">If property is set to <code>true</code>, then Ignite will disable MBeans registration.
 This may be helpful if MBeans are not allowed e.g. for security reasons.

 Default is <code>false</code></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MBEANS_DISABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_EXCEPTION_REGISTRY_MAX_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_EXCEPTION_REGISTRY_MAX_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_EXCEPTION_REGISTRY_MAX_SIZE</pre>
<div class="block">Property controlling size of buffer holding last exception. Default value of <code>1000</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_EXCEPTION_REGISTRY_MAX_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CACHE_CLIENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CACHE_CLIENT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CACHE_CLIENT</pre>
<div class="block">Property controlling default behavior of cache client flag.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CACHE_CLIENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_JCACHE_DEFAULT_ISOLATED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_JCACHE_DEFAULT_ISOLATED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_JCACHE_DEFAULT_ISOLATED</pre>
<div class="block">Property controlling whether CacheManager will start grid with isolated IP finder when default URL
 is passed in. This is needed to pass TCK tests which use default URL and assume isolated cache managers
 for different class loaders.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_JCACHE_DEFAULT_ISOLATED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SQL_MERGE_TABLE_MAX_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SQL_MERGE_TABLE_MAX_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SQL_MERGE_TABLE_MAX_SIZE</pre>
<div class="block">Property controlling maximum number of SQL result rows which can be fetched into a merge table.
 If there are less rows than this threshold then multiple passes throw a table will be possible,
 otherwise only one pass (e.g. only result streaming is possible).</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SQL_MERGE_TABLE_MAX_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SQL_MERGE_TABLE_PREFETCH_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SQL_MERGE_TABLE_PREFETCH_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SQL_MERGE_TABLE_PREFETCH_SIZE</pre>
<div class="block">Property controlling number of SQL result rows that will be fetched into a merge table at once before
 applying binary search for the bounds.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SQL_MERGE_TABLE_PREFETCH_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SQL_PARSER_DISABLE_H2_FALLBACK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SQL_PARSER_DISABLE_H2_FALLBACK</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SQL_PARSER_DISABLE_H2_FALLBACK</pre>
<div class="block">Disable fallback to H2 SQL parser if the internal SQL parser fails to parse the statement.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SQL_PARSER_DISABLE_H2_FALLBACK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_AFFINITY_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_AFFINITY_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_AFFINITY_HISTORY_SIZE</pre>
<div class="block">Maximum size for affinity assignment history.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_AFFINITY_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DISCOVERY_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DISCOVERY_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DISCOVERY_HISTORY_SIZE</pre>
<div class="block">Maximum size for discovery messages history.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DISCOVERY_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DISCOVERY_CLIENT_RECONNECT_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DISCOVERY_CLIENT_RECONNECT_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DISCOVERY_CLIENT_RECONNECT_HISTORY_SIZE</pre>
<div class="block">Maximum number of discovery message history used to support client reconnect.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DISCOVERY_CLIENT_RECONNECT_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CACHE_RETRIES_COUNT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CACHE_RETRIES_COUNT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CACHE_RETRIES_COUNT</pre>
<div class="block">Number of cache operation retries in case of topology exceptions.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CACHE_RETRIES_COUNT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_THREAD_DUMP_ON_EXCHANGE_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_THREAD_DUMP_ON_EXCHANGE_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_THREAD_DUMP_ON_EXCHANGE_TIMEOUT</pre>
<div class="block">If this property is set to <code>true</code> then Ignite will log thread dump in case of partition exchange timeout.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_THREAD_DUMP_ON_EXCHANGE_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_IO_DUMP_ON_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_IO_DUMP_ON_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_IO_DUMP_ON_TIMEOUT</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_IO_DUMP_ON_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DIAGNOSTIC_ENABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DIAGNOSTIC_ENABLED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DIAGNOSTIC_ENABLED</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DIAGNOSTIC_ENABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT</pre>
<div class="block">Cache operations that take more time than value of this property will be output to log. Set to <code>0</code> to disable.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT_LIMIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT_LIMIT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT_LIMIT</pre>
<div class="block">Upper time limit between long running/hanging operations debug dumps.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LONG_OPERATIONS_DUMP_TIMEOUT_LIMIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_JDBC_DRIVER_CURSOR_REMOVE_DELAY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_JDBC_DRIVER_CURSOR_REMOVE_DELAY</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_JDBC_DRIVER_CURSOR_REMOVE_DELAY</pre>
<div class="block">JDBC driver cursor remove delay.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_JDBC_DRIVER_CURSOR_REMOVE_DELAY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_LONG_LONG_HASH_MAP_LOAD_FACTOR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LONG_LONG_HASH_MAP_LOAD_FACTOR</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LONG_LONG_HASH_MAP_LOAD_FACTOR</pre>
<div class="block">Long-long offheap map load factor.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LONG_LONG_HASH_MAP_LOAD_FACTOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MAX_NESTED_LISTENER_CALLS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MAX_NESTED_LISTENER_CALLS</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MAX_NESTED_LISTENER_CALLS</pre>
<div class="block">Maximum number of nested listener calls before listener notification becomes asynchronous.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MAX_NESTED_LISTENER_CALLS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_LOCAL_STORE_KEEPS_PRIMARY_ONLY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_LOCAL_STORE_KEEPS_PRIMARY_ONLY</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_LOCAL_STORE_KEEPS_PRIMARY_ONLY</pre>
<div class="block">Indicating whether local store keeps primary only. Backward compatibility flag.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_LOCAL_STORE_KEEPS_PRIMARY_ONLY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_OPTIMIZED_MARSHALLER_USE_DEFAULT_SUID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_OPTIMIZED_MARSHALLER_USE_DEFAULT_SUID</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_OPTIMIZED_MARSHALLER_USE_DEFAULT_SUID</pre>
<div class="block">Manages <code>OptimizedMarshaller</code> behavior of <code>serialVersionUID</code> computation for
 <a href="http://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io"><code>Serializable</code></a> classes.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_OPTIMIZED_MARSHALLER_USE_DEFAULT_SUID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_BINARY_MARSHALLER_USE_STRING_SERIALIZATION_VER_2">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_BINARY_MARSHALLER_USE_STRING_SERIALIZATION_VER_2</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_BINARY_MARSHALLER_USE_STRING_SERIALIZATION_VER_2</pre>
<div class="block">Manages type of serialization mechanism for <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang"><code>String</code></a> that is marshalled/unmarshalled by BinaryMarshaller.
 Should be used for cases when a String contains a surrogate symbol without its pair one. This is frequently used
 in algorithms that encrypts data in String format.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_BINARY_MARSHALLER_USE_STRING_SERIALIZATION_VER_2">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MARSHALLER_WHITELIST">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MARSHALLER_WHITELIST</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MARSHALLER_WHITELIST</pre>
<div class="block">Defines path to the file that contains list of classes allowed to safe deserialization.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MARSHALLER_WHITELIST">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MARSHALLER_BLACKLIST">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MARSHALLER_BLACKLIST</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MARSHALLER_BLACKLIST</pre>
<div class="block">Defines path to the file that contains list of classes disallowed to safe deserialization.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MARSHALLER_BLACKLIST">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_NO_SELECTOR_OPTS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_NO_SELECTOR_OPTS</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_NO_SELECTOR_OPTS</pre>
<div class="block">If set to <code>true</code>, then default selected keys set is used inside
 <code>GridNioServer</code> which lead to some extra garbage generation when
 processing selected keys.
 <p>
 Default value is <code>false</code>. Should be switched to <code>true</code> if there are
 any problems in communication layer.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_NO_SELECTOR_OPTS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_H2_INDEXING_CACHE_CLEANUP_PERIOD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_H2_INDEXING_CACHE_CLEANUP_PERIOD</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_H2_INDEXING_CACHE_CLEANUP_PERIOD</pre>
<div class="block">System property to specify period in milliseconds between calls of the SQL statements cache cleanup task.
 <p>
 Cleanup tasks clears cache for terminated threads and for threads which did not perform SQL queries within
 timeout configured via <a href="../../../org/apache/ignite/IgniteSystemProperties.html#IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT"><code>IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT</code></a> property.
 <p>
 Default value is <code>10,000ms</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_H2_INDEXING_CACHE_CLEANUP_PERIOD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT</pre>
<div class="block">System property to specify timeout in milliseconds after which thread's SQL statements cache is cleared by
 cleanup task if the thread does not perform any query.
 <p>
 Default value is <code>600,000ms</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_H2_INDEXING_CACHE_THREAD_USAGE_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SERVICES_COMPATIBILITY_MODE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SERVICES_COMPATIBILITY_MODE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SERVICES_COMPATIBILITY_MODE</pre>
<div class="block">Manages backward compatibility of <a href="../../../org/apache/ignite/IgniteServices.html" title="interface in org.apache.ignite"><code>IgniteServices</code></a>. All nodes in cluster must have identical value
 of this property.
 <p>
 If property is <code>false</code> then node is not required to have service implementation class if service is not
 deployed on this node.
 <p>
 If the property is <code>true</code> then service implementation class is required on node even if service
 is not deployed on this node.
 <p>
 If the property is not set (<code>null</code>) then Ignite will automatically detect which compatibility mode
 should be used.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SERVICES_COMPATIBILITY_MODE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_STREAM_TRANSFORMER_COMPATIBILITY_MODE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_STREAM_TRANSFORMER_COMPATIBILITY_MODE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_STREAM_TRANSFORMER_COMPATIBILITY_MODE</pre>
<div class="block">Manages backward compatibility of <a href="../../../org/apache/ignite/stream/StreamTransformer.html#from-org.apache.ignite.cache.CacheEntryProcessor-"><code>StreamTransformer.from(CacheEntryProcessor)</code></a> method.
 <p>
 If the property is <code>true</code>, then the wrapped <a href="../../../org/apache/ignite/cache/CacheEntryProcessor.html" title="interface in org.apache.ignite.cache"><code>CacheEntryProcessor</code></a> won't be able to be loaded over
 P2P class loading.
 <p>
 If the property is <code>false</code>, then another implementation of <a href="../../../org/apache/ignite/stream/StreamTransformer.html" title="class in org.apache.ignite.stream"><code>StreamTransformer</code></a> will be returned,
 that fixes P2P class loading for <a href="../../../org/apache/ignite/cache/CacheEntryProcessor.html" title="interface in org.apache.ignite.cache"><code>CacheEntryProcessor</code></a>, but it will be incompatible with old versions
 of Ignite.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_STREAM_TRANSFORMER_COMPATIBILITY_MODE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_BINARY_DONT_WRAP_TREE_STRUCTURES">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_BINARY_DONT_WRAP_TREE_STRUCTURES</h4>
<pre><a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_BINARY_DONT_WRAP_TREE_STRUCTURES</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Should be removed in Apache Ignite 2.0.</span></div>
<div class="block">When set to <code>true</code> tree-based data structures - <code>TreeMap</code> and <code>TreeSet</code> - will not be
 wrapped into special holders introduced to overcome serialization issue caused by missing <code>Comparable</code>
 interface on <code>BinaryObject</code>.
 <p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_BINARY_DONT_WRAP_TREE_STRUCTURES">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CONSISTENT_ID_BY_HOST_WITHOUT_PORT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CONSISTENT_ID_BY_HOST_WITHOUT_PORT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CONSISTENT_ID_BY_HOST_WITHOUT_PORT</pre>
<div class="block">When set to <code>true</code>, for consistent id will calculate by host name, without port, and you can use
 only one node for host in cluster.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CONSISTENT_ID_BY_HOST_WITHOUT_PORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_IO_BALANCE_PERIOD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_IO_BALANCE_PERIOD</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_IO_BALANCE_PERIOD</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_IO_BALANCE_PERIOD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_BINARY_SORT_OBJECT_FIELDS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_BINARY_SORT_OBJECT_FIELDS</h4>
<pre><a href="http://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_BINARY_SORT_OBJECT_FIELDS</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Should be removed in Apache Ignite 2.0.</span></div>
<div class="block">When set to <code>true</code> fields are written by BinaryMarshaller in sorted order. Otherwise
 the natural order is used.
 <p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_BINARY_SORT_OBJECT_FIELDS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MEMORY_UNALIGNED_ACCESS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MEMORY_UNALIGNED_ACCESS</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MEMORY_UNALIGNED_ACCESS</pre>
<div class="block">Whether Ignite can access unaligned memory addresses.
 <p>
 Defaults to <code>false</code>, meaning that unaligned access will be performed only on x86 architecture.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MEMORY_UNALIGNED_ACCESS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MEMORY_PER_BYTE_COPY_THRESHOLD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MEMORY_PER_BYTE_COPY_THRESHOLD</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MEMORY_PER_BYTE_COPY_THRESHOLD</pre>
<div class="block">When unsafe memory copy if performed below this threshold, Ignite will do it on per-byte basis instead of
 calling to Unsafe.copyMemory().
 <p>
 Defaults to 0, meaning that threshold is disabled.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MEMORY_PER_BYTE_COPY_THRESHOLD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_UNWRAP_BINARY_FOR_INDEXING_SPI">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_UNWRAP_BINARY_FOR_INDEXING_SPI</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_UNWRAP_BINARY_FOR_INDEXING_SPI</pre>
<div class="block"><span class="deprecatedLabel">Deprecated.</span>&nbsp;<span class="deprecationComment">Should be removed in Apache Ignite 2.0.</span></div>
<div class="block">When set to <code>true</code> BinaryObject will be unwrapped before passing to IndexingSpi to preserve
 old behavior query processor with IndexingSpi.
 <p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_UNWRAP_BINARY_FOR_INDEXING_SPI">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_MAX_INDEX_PAYLOAD_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_MAX_INDEX_PAYLOAD_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_MAX_INDEX_PAYLOAD_SIZE</pre>
<div class="block">System property to specify maximum payload size in bytes for <code>H2TreeIndex</code>.
 <p>
 Defaults to <code>0</code>, meaning that inline index store is disabled.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_MAX_INDEX_PAYLOAD_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_REBALANCE_STATISTICS_TIME_INTERVAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_REBALANCE_STATISTICS_TIME_INTERVAL</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_REBALANCE_STATISTICS_TIME_INTERVAL</pre>
<div class="block">Time interval for calculating rebalance rate statistics, in milliseconds. Defaults to 60000.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_REBALANCE_STATISTICS_TIME_INTERVAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_TTL_EXPIRE_BATCH_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_TTL_EXPIRE_BATCH_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_TTL_EXPIRE_BATCH_SIZE</pre>
<div class="block">When cache has entries with expired TTL, each user operation will also remove this amount of expired entries.
 Defaults to <code>5</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_TTL_EXPIRE_BATCH_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_INDEXING_DISCOVERY_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_INDEXING_DISCOVERY_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_INDEXING_DISCOVERY_HISTORY_SIZE</pre>
<div class="block">Indexing discovery history size. Protects from duplicate messages maintaining the list of IDs of recently
 arrived discovery messages.
 <p>
 Defaults to <code>1000</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_INDEXING_DISCOVERY_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CACHE_START_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CACHE_START_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CACHE_START_SIZE</pre>
<div class="block">Cache start size for on-heap maps. Defaults to 4096.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CACHE_START_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_START_CACHES_ON_JOIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_START_CACHES_ON_JOIN</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_START_CACHES_ON_JOIN</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_START_CACHES_ON_JOIN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PDS_SKIP_CRC">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PDS_SKIP_CRC</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PDS_SKIP_CRC</pre>
<div class="block">Skip CRC calculation flag.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PDS_SKIP_CRC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PDS_PARTITION_DESTROY_CHECKPOINT_DELAY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PDS_PARTITION_DESTROY_CHECKPOINT_DELAY</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PDS_PARTITION_DESTROY_CHECKPOINT_DELAY</pre>
<div class="block">WAL rebalance threshold.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PDS_PARTITION_DESTROY_CHECKPOINT_DELAY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PDS_WAL_REBALANCE_THRESHOLD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PDS_WAL_REBALANCE_THRESHOLD</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PDS_WAL_REBALANCE_THRESHOLD</pre>
<div class="block">WAL rebalance threshold.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PDS_WAL_REBALANCE_THRESHOLD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_OFFHEAP_LOCK_CONCURRENCY_LEVEL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_OFFHEAP_LOCK_CONCURRENCY_LEVEL</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_OFFHEAP_LOCK_CONCURRENCY_LEVEL</pre>
<div class="block">Ignite page memory concurrency level.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_OFFHEAP_LOCK_CONCURRENCY_LEVEL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_FORCE_START_JAVA7">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_FORCE_START_JAVA7</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_FORCE_START_JAVA7</pre>
<div class="block">Start Ignite on versions of JRE 7 older than 1.7.0_71. For proper work it may require
 disabling JIT in some places.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_FORCE_START_JAVA7">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_SECURITY_COMPATIBILITY_MODE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_SECURITY_COMPATIBILITY_MODE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_SECURITY_COMPATIBILITY_MODE</pre>
<div class="block">When set to <code>true</code>, Ignite switches to compatibility mode with versions that don't
 support service security permissions. In this case security permissions will be ignored
 (if they set).
 <p>
     Default is <code>false</code>, which means that service security permissions will be respected.
 </p></div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_SECURITY_COMPATIBILITY_MODE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CLUSTER_NAME">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CLUSTER_NAME</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CLUSTER_NAME</pre>
<div class="block">Ignite cluster name.
 <p>
 Defaults to utility cache deployment ID..</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CLUSTER_NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_CLIENT_CACHE_CHANGE_MESSAGE_TIMEOUT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_CLIENT_CACHE_CHANGE_MESSAGE_TIMEOUT</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_CLIENT_CACHE_CHANGE_MESSAGE_TIMEOUT</pre>
<div class="block">When client cache is started or closed special discovery message is sent to notify cluster (for example this is
 needed for <a href="../../../org/apache/ignite/cluster/ClusterGroup.html#forCacheNodes-java.lang.String-"><code>ClusterGroup.forCacheNodes(String)</code></a> API. This timeout specifies how long to wait
 after client cache start/close before sending this message. If during this timeout another client
 cache changed, these events are combined into single message.
 <p>
 Default is 10 seconds.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_CLIENT_CACHE_CHANGE_MESSAGE_TIMEOUT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PARTITION_RELEASE_FUTURE_DUMP_THRESHOLD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PARTITION_RELEASE_FUTURE_DUMP_THRESHOLD</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PARTITION_RELEASE_FUTURE_DUMP_THRESHOLD</pre>
<div class="block">If a partition release future completion time during an exchange exceeds this threshold, the contents of
 the future will be dumped to the log on exchange. Default is <code>0</code> (disabled).</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PARTITION_RELEASE_FUTURE_DUMP_THRESHOLD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_ENABLE_FORCIBLE_NODE_KILL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_ENABLE_FORCIBLE_NODE_KILL</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_ENABLE_FORCIBLE_NODE_KILL</pre>
<div class="block">If this property is set, a node will forcible fail a remote node when it fails to establish a communication
 connection.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_ENABLE_FORCIBLE_NODE_KILL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD</pre>
<div class="block">Tasks stealing will be started if tasks queue size per data-streamer thread exceeds this threshold.
 <p>
 Default value is <code>4</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_USE_ASYNC_FILE_IO_FACTORY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_USE_ASYNC_FILE_IO_FACTORY</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_USE_ASYNC_FILE_IO_FACTORY</pre>
<div class="block">If this property is set, then Ignite will use Async File IO factory by default.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_USE_ASYNC_FILE_IO_FACTORY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_WAL_LOG_TX_RECORDS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_WAL_LOG_TX_RECORDS</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_WAL_LOG_TX_RECORDS</pre>
<div class="block">If the property is set <code>TxRecord</code> records
 will be logged to WAL.

 Default value is <code>false</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_WAL_LOG_TX_RECORDS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_OVERRIDE_WRITE_THROTTLING_ENABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_OVERRIDE_WRITE_THROTTLING_ENABLED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_OVERRIDE_WRITE_THROTTLING_ENABLED</pre>
<div class="block">If this property is set, <a href="../../../org/apache/ignite/configuration/DataStorageConfiguration.html#writeThrottlingEnabled"><code>DataStorageConfiguration.writeThrottlingEnabled</code></a> will be overridden to true
 independent of initial value in configuration.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_OVERRIDE_WRITE_THROTTLING_ENABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_WAL_SERIALIZER_VERSION">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_WAL_SERIALIZER_VERSION</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_WAL_SERIALIZER_VERSION</pre>
<div class="block">Property for setup WAL serializer version.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_WAL_SERIALIZER_VERSION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_USE_LEGACY_NODE_COMPARATOR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_USE_LEGACY_NODE_COMPARATOR</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_USE_LEGACY_NODE_COMPARATOR</pre>
<div class="block">If the property is set Ignite will use legacy node comparator (based on node order) inste

 Default value is <code>false</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_USE_LEGACY_NODE_COMPARATOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_WAL_MMAP">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_WAL_MMAP</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_WAL_MMAP</pre>
<div class="block">Property that indicates should be mapped byte buffer used or not.
 Possible values: <code>true</code> and <code>false</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_WAL_MMAP">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DATA_STORAGE_FOLDER_BY_CONSISTENT_ID">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DATA_STORAGE_FOLDER_BY_CONSISTENT_ID</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DATA_STORAGE_FOLDER_BY_CONSISTENT_ID</pre>
<div class="block">When set to <code>true</code>, Data store folders are generated only by consistent id, and no consistent ID will be
 set based on existing data store folders. This option also enables compatible folder generation mode as it was
 before 2.3.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DATA_STORAGE_FOLDER_BY_CONSISTENT_ID">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_WAL_DEBUG_LOG_ON_RECOVERY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_WAL_DEBUG_LOG_ON_RECOVERY</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_WAL_DEBUG_LOG_ON_RECOVERY</pre>
<div class="block">Default value is <code>false</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_WAL_DEBUG_LOG_ON_RECOVERY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_PDS_MAX_CHECKPOINT_MEMORY_HISTORY_SIZE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_PDS_MAX_CHECKPOINT_MEMORY_HISTORY_SIZE</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_PDS_MAX_CHECKPOINT_MEMORY_HISTORY_SIZE</pre>
<div class="block">Number of checkpoint history entries held in memory.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_PDS_MAX_CHECKPOINT_MEMORY_HISTORY_SIZE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_GRID_CLIENT_LOG_ENABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_GRID_CLIENT_LOG_ENABLED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_GRID_CLIENT_LOG_ENABLED</pre>
<div class="block">If this property is set to <code>true</code> enable logging in <code>GridClient</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_GRID_CLIENT_LOG_ENABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_DIRECT_IO_ENABLED">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>IGNITE_DIRECT_IO_ENABLED</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_DIRECT_IO_ENABLED</pre>
<div class="block">When set to <code>true</code>, direct IO may be enabled. Direct IO enabled only if JAR file with corresponding
 feature is available in classpath and OS and filesystem settings allows to enable this mode.
 Default is <code>true</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_DIRECT_IO_ENABLED">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IGNITE_WAL_FSYNC_WITH_DEDICATED_WORKER">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>IGNITE_WAL_FSYNC_WITH_DEDICATED_WORKER</h4>
<pre>public static final&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> IGNITE_WAL_FSYNC_WITH_DEDICATED_WORKER</pre>
<div class="block">When set to <code>true</code>, WAL implementation with dedicated worker will be used even in FSYNC mode.
 Default is <code>false</code>.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../constant-values.html#org.apache.ignite.IgniteSystemProperties.IGNITE_WAL_FSYNC_WITH_DEDICATED_WORKER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="getString-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>@Nullable
public static&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Gets either system property or environment variable with given name.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Value of the system property or environment variable.
         Returns <code>null</code> if neither can be found for given name.</dd>
</dl>
</li>
</ul>
<a name="getString-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getString</h4>
<pre>@Nullable
public static&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;getString(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                                         <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;dflt)</pre>
<div class="block">Gets either system property or environment variable with given name.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dd><code>dflt</code> - Default value.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Value of the system property or environment variable.
         Returns <code>null</code> if neither can be found for given name.</dd>
</dl>
</li>
</ul>
<a name="getBoolean-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getBoolean</h4>
<pre>public static&nbsp;boolean&nbsp;getBoolean(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Gets either system property or environment variable with given name.
 The result is transformed to <code>boolean</code> using <code>Boolean.valueOf()</code> method.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Boolean value of the system property or environment variable.
         Returns <code>False</code> in case neither system property
         nor environment variable with given name is found.</dd>
</dl>
</li>
</ul>
<a name="getBoolean-java.lang.String-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getBoolean</h4>
<pre>public static&nbsp;boolean&nbsp;getBoolean(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                                 boolean&nbsp;dflt)</pre>
<div class="block">Gets either system property or environment variable with given name.
 The result is transformed to <code>boolean</code> using <code>Boolean.valueOf()</code> method.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dd><code>dflt</code> - Default value.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Boolean value of the system property or environment variable.
         Returns default value in case neither system property
         nor environment variable with given name is found.</dd>
</dl>
</li>
</ul>
<a name="getInteger-java.lang.String-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getInteger</h4>
<pre>public static&nbsp;int&nbsp;getInteger(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                             int&nbsp;dflt)</pre>
<div class="block">Gets either system property or environment variable with given name.
 The result is transformed to <code>int</code> using <code>Integer.parseInt()</code> method.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dd><code>dflt</code> - Default value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Integer value of the system property or environment variable.
         Returns default value in case neither system property
         nor environment variable with given name is found.</dd>
</dl>
</li>
</ul>
<a name="getFloat-java.lang.String-float-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFloat</h4>
<pre>public static&nbsp;float&nbsp;getFloat(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                             float&nbsp;dflt)</pre>
<div class="block">Gets either system property or environment variable with given name.
 The result is transformed to <code>float</code> using <code>Float.parseFloat()</code> method.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dd><code>dflt</code> - Default value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Float value of the system property or environment variable.
         Returns default value in case neither system property
         nor environment variable with given name is found.</dd>
</dl>
</li>
</ul>
<a name="getLong-java.lang.String-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLong</h4>
<pre>public static&nbsp;long&nbsp;getLong(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                           long&nbsp;dflt)</pre>
<div class="block">Gets either system property or environment variable with given name.
 The result is transformed to <code>long</code> using <code>Long.parseLong()</code> method.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dd><code>dflt</code> - Default value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Integer value of the system property or environment variable.
         Returns default value in case neither system property
         nor environment variable with given name is found.</dd>
</dl>
</li>
</ul>
<a name="getDouble-java.lang.String-double-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getDouble</h4>
<pre>public static&nbsp;double&nbsp;getDouble(<a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                               double&nbsp;dflt)</pre>
<div class="block">Gets either system property or environment variable with given name.
 The result is transformed to <code>double</code> using <code>Double.parseDouble()</code> method.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the system property or environment variable.</dd>
<dd><code>dflt</code> - Default value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Integer value of the system property or environment variable.
         Returns default value in case neither system property
         nor environment variable with given name is found.</dd>
</dl>
</li>
</ul>
<a name="snapshot--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>snapshot</h4>
<pre>public static&nbsp;<a href="http://docs.oracle.com/javase/8/docs/api/java/util/Properties.html?is-external=true" title="class or interface in java.util">Properties</a>&nbsp;snapshot()</pre>
<div class="block">Gets snapshot of system properties.
 Snapshot could be used for thread safe iteration over system properties.
 Non-string properties are removed before return.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Snapshot of system properties.</dd>
</dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/IgniteSystemProperties.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">Ignite - In-Memory Data Fabric</div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../org/apache/ignite/IgniteState.html" title="enum in org.apache.ignite"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../org/apache/ignite/IgniteTransactions.html" title="interface in org.apache.ignite"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?org/apache/ignite/IgniteSystemProperties.html" target="_top">Frames</a></li>
<li><a href="IgniteSystemProperties.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>Constr&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>Constr&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><table width="100%" border="0" cellspacing=0 cellpadding=0 style="padding: 5px">                                     <tr>                                         <td>                                             <table style="padding-left: 0; margin: 0">                                                 <tbody style="padding: 0; margin: 0">                                                     <tr style="padding: 0; margin: 0">                                                         <td>                                                             <a target=_blank href="https://ignite.apache.org"><nobr>2018 Copyright &#169; Apache Software Foundation</nobr></a>                                                         </td>                                                     </tr>                                                 </tbody>                                             </table>                                         </td>                                         <td width="100%" align="right" valign="center">                                             <a href="https://twitter.com/ApacheIgnite" class="twitter-follow-button" data-show-count="false" data-size="large">Follow @ApacheIgnite</a>                                         </td>                                     </tr>                                     <tr>                                         <td colspan="2" valign="top" align="left">                                             <table style="padding-left: 0; margin: 0">                                                 <tbody style="padding: 0; margin: 0">                                                     <tr style="padding: 0; margin: 0">                                                         <td>                                                             <b>Ignite Fabric</b>                                                         </td>                                                         <td>:&nbsp;&nbsp;                                                             ver. <strong>2.4.0</strong>                                                         </td>                                                     </tr>                                                     <tr style="padding: 0; margin: 0">                                                         <td>                                                             <b>Release Date</b>                                                         </td>                                                         <td>:&nbsp;&nbsp;                                                             March 5 2018                                                         </td>                                                     </tr>                                                 </tbody>                                             </table>                                         </td>                                     </tr>                                     </table></small></p>
</body>
</html>
