<hazelcast xsi:schemaLocation="http://www.hazelcast.com/schema/config
	http://www.hazelcast.com/schema/config/hazelcast-config-3.2.xsd"
	xmlns="http://www.hazelcast.com/schema/config"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!-- Update xsd line, when upgrading Hazelcast version. -->

  <!--
      Note: When adding some elements to this file,
      try to follow the schema defined in the xsd when possible.
  -->

  <group>
    <name>__HC_CLUSTER__</name>
  </group>

  <properties>
    <property name="hazelcast.logging.type">slf4j</property>
    <property name="hazelcast.version.check.enabled">false</property>
  </properties>

  <network>
    <port auto-increment="true">__HC_PORT__</port>
<!-- Examples to force using certain interface
    <interfaces enabled="true">
      <interface>192.168.200.*</interface>
    </interfaces>
-->
    <join>
__HC_NETWORK__
      <aws enabled="false">
      </aws>
    </join>
  </network>

    <serialization>
        <!-- IdentifiedDataSerializableFactory for HZTable.VersionedValue class -->
        <data-serializable-factories>
            <data-serializable-factory factory-id="1">net.onrc.onos.core.datastore.hazelcast.VersionedValueSerializableFactory</data-serializable-factory>
        </data-serializable-factories>
        <serializers>
          <serializer type-class="net.onrc.onos.core.util.distributed.sharedlog.internal.LogValue">net.onrc.onos.core.util.distributed.sharedlog.hazelcast.LogValueSerializer</serializer>
        </serializers>
    </serialization>

  <!-- Configuration of maps used as a data store. -->
  <map name="datastore://*">
    <!-- must use 'sync' backup to imitate other data store -->
    <backup-count>3</backup-count>
    <async-backup-count>0</async-backup-count>
    <!-- must be false for strong consistency -->
    <read-backup-data>false</read-backup-data>
    <!-- near cache must not be used -->
  </map>

  <!-- Configuration of maps used as a log store. -->
  <map name="logmap://*">
    <!-- must use 'sync' backup to imitate other data store -->
    <backup-count>3</backup-count>
    <async-backup-count>0</async-backup-count>
    <!-- can be true, since log map value is basically immutable -->
    <read-backup-data>true</read-backup-data>
    <!-- near cache can be enabled -->
    <near-cache>
      <!-- TODO revisit random params -->
      <max-size>5000</max-size>
      <time-to-live-seconds>300</time-to-live-seconds>
      <eviction-policy>LRU</eviction-policy>
    </near-cache>
  </map>

  <!-- Configuration of maps used as a snap shot store. -->
  <map name="ssmap://*">
    <!-- must use 'sync' backup to imitate other data store -->
    <backup-count>3</backup-count>
    <async-backup-count>0</async-backup-count>
    <!-- can be true, since snap shot map value is basically immutable -->
    <read-backup-data>true</read-backup-data>
    <!-- near cache can be enabled -->
    <near-cache>
      <!-- TODO revisit random params -->
      <max-size>10</max-size>
      <time-to-live-seconds>300</time-to-live-seconds>
      <eviction-policy>LRU</eviction-policy>
    </near-cache>
  </map>

  <map name="*">

    <!--
    Number of sync-backups. If 1 is set as the backup-count for example,
    then all entries of the map will be copied to another JVM for
    fail-safety. Valid numbers are 0 (no backup), 1, 2, 3.
    -->
    <backup-count>3</backup-count>

    <!--
    Number of async-backups. If 1 is set as the backup-count for example,
    then all entries of the map will be copied to another JVM for
    fail-safety. Valid numbers are 0 (no backup), 1, 2, 3.
    -->
    <async-backup-count>0</async-backup-count>

    <!--
    Can we read the local backup entries? Default value is false for
    strong consistency. Being able to read backup data will give you
    greater performance.
    -->
    <read-backup-data>true</read-backup-data>

    <near-cache>
      <!--
	  Maximum size of the near cache. When max size is reached,
	  cache is evicted based on the policy defined.
	  Any integer between 0 and Integer.MAX_VALUE. 0 means
	  Integer.MAX_VALUE. Default is 0.
      -->
      <max-size>0</max-size>
      <!--
	  Maximum number of seconds for each entry to stay in the near cache.
	  Entries that are older than <time-to-live-seconds> will get
	  automatically evicted from the near cache.
	  Any integer between 0 and Integer.MAX_VALUE. 0 means infinite.
	  Default is 0.
      -->
      <time-to-live-seconds>0</time-to-live-seconds>

      <!--
	  Maximum number of seconds each entry can stay in the near cache as
	  untouched (not-read).
	  Entries that are not read (touched) more than <max-idle-seconds>
	  value will get removed from the near cache.
	  Any integer between 0 and Integer.MAX_VALUE. 0 means
	  Integer.MAX_VALUE. Default is 0.
      -->
      <max-idle-seconds>0</max-idle-seconds>

      <!--
	  Valid values are:
	  NONE (no extra eviction, <time-to-live-seconds> may still apply),
	  LRU (Least Recently Used),
	  LFU (Least Frequently Used).
	  LRU is the default.
	  Regardless of the eviction policy used, <time-to-live-seconds> will
	  still apply.
      -->
      <eviction-policy>NONE</eviction-policy>

      <!--
	  Should the cached entries get evicted if the entries are changed
	  (updated or removed).
	  true of false. Default is true.
      -->
      <invalidate-on-change>true</invalidate-on-change>

    </near-cache>
  </map>

  <topic name="*">
    <global-ordering-enabled>false</global-ordering-enabled>
  </topic>
</hazelcast>
