<!-- EhCache XML configuration file used for JSecurity spring sample application -->
<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User's home directory
         user.dir - User's current working directory
         java.io.tmpdir - Default temp file path -->
    <diskStore path="java.io.tmpdir/jsecurity-spring-sample"/>


    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required:

        maxElementsInMemory            - Sets the maximum number of objects that will be created in memory
        eternal                        - Sets whether elements are eternal. If eternal,  timeouts are ignored and the
                                         element is never expired.
        overflowToDisk                 - Sets whether elements can overflow to disk when the in-memory cache
                                         has reached the maxInMemory limit.

        The following attributes are optional:
        timeToIdleSeconds              - Sets the time to idle for an element before it expires.
                                         i.e. The maximum amount of time between accesses before an element expires
                                         Is only used if the element is not eternal.
                                         Optional attribute. A value of 0 means that an Element can idle for infinity.
                                         The default value is 0.
        timeToLiveSeconds              - Sets the time to live for an element before it expires.
                                         i.e. The maximum time between creation time and when an element expires.
                                         Is only used if the element is not eternal.
                                         Optional attribute. A value of 0 means that and Element can live for infinity.
                                         The default value is 0.
        diskPersistent                 - Whether the disk store persists between restarts of the Virtual Machine.
                                         The default value is false.
        diskExpiryThreadIntervalSeconds- The number of seconds between runs of the disk expiry thread. The default value
                                         is 120 seconds.
        memoryStoreEvictionPolicy      - Policy would be enforced upon reaching the maxElementsInMemory limit. Default
                                         policy is Least Recently Used (specified as LRU). Other policies available -
                                         First In First Out (specified as FIFO) and Less Frequently Used
                                         (specified as LFU)
        -->

    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="false"
        diskPersistent="false"
        diskExpiryThreadIntervalSeconds="120"
        />

    <!-- We want eternal="true" (with no timeToIdle or timeToLive settings) because JSecurity manages session
         expirations explicitly.  If we set it to false and then set corresponding timeToIdle and timeToLive properties,
         ehcache would evict sessions without JSecurity's knowledge, which would cause many problems
         (e.g. "My JSecurity session timeout is 30 minutes - why isn't a session available after 2 minutes?"
         Answer - ehcache expired it due to the timeToIdle property set to 120 seconds.)

         diskPersistent=true since we want an enterprise session management feature - ability to use sessions after
         even after a JVM restart.  -->
    <cache  name="jsecurity-activeSessionCache"
            maxElementsInMemory="20000"
            eternal="true"
            overflowToDisk="true"
            diskPersistent="true"
            diskExpiryThreadIntervalSeconds="600"/>

    <cache name="org.jsecurity.realm.SimpleAccountRealm.authorization"
        maxElementsInMemory="100"
        eternal="false"
        timeToLiveSeconds="600"
        overflowToDisk="false"/>

</ehcache>