All Superinterfaces:

ActiveMQComponent, RefCountMessageListener

All Known Implementing Classes:

PagingStoreImpl
```
public interface PagingStore
extends ActiveMQComponent, RefCountMessageListener
```
The implementation will take care of details such as PageSize.
The producers will write directly to PagingStore, and the store will decide what Page file should be used based on configured size.

See Also:

PagingManager

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`default void`	`addSize(int size)`
`void`	`addSize(int size, boolean sizeOnly)`
`void`	`applySetting(AddressSettings addressSettings)`
`void`	`block()`
`boolean`	`checkMemory(boolean runOnFailure, Runnable runnable, Runnable runWhenBlocking)`
`boolean`	`checkMemory(Runnable runnable)`
`boolean`	`checkPageFileExists(long page)`
`void`	`checkPageLimit(long numberOfMessages)`
`boolean`	`checkReleasedMemory()`	It will return true if the destination is leaving blocking.
`void`	`counterSnapshot()`	it will save snapshots on the counters
`Page`	`depage()`	Remove the first page from the Writing Queue.
`void`	`destroy()`
`void`	`disableCleanup()`	This method will disable cleanup of pages.
`void`	`enableCleanup()`	This method will re-enable cleanup of pages.
`void`	`execute(Runnable runnable)`
`void`	`flushExecutors()`	This is used mostly by tests.
`void`	`forceAnotherPage()`
`SimpleString`	`getAddress()`
`AddressFullMessagePolicy`	`getAddressFullMessagePolicy()`
`int`	`getAddressLimitPercent()`
`long`	`getAddressSize()`
`Collection<Integer>`	`getCurrentIds()`	Files to synchronize with a remote backup.
`Page`	`getCurrentPage()`
`long`	`getCurrentWritingPage()`	Returns the page id of the current page in which the system is writing files.
`PageCursorProvider`	`getCursorProvider()`
`ArtemisExecutor`	`getExecutor()`
`long`	`getFirstPage()`
`File`	`getFolder()`
`int`	`getMaxPageReadBytes()`
`int`	`getMaxPageReadMessages()`
`long`	`getMaxSize()`
`long`	`getNumberOfPages()`
`PageFullMessagePolicy`	`getPageFullMessagePolicy()`
`Long`	`getPageLimitBytes()`
`Long`	`getPageLimitMessages()`
`int`	`getPageSizeBytes()`
`PagingManager`	`getPagingManager()`
`default StorageManager`	`getStorageManager()`
`SimpleString`	`getStoreName()`
`void`	`ioSync()`	Performs a real sync on the current IO file.
`boolean`	`isFull()`
`boolean`	`isPageFull()`
`boolean`	`isPaging()`	This method will look if the current state of paging is not paging, without using a lock.
`boolean`	`isRejectingMessages()`
`boolean`	`lock(long timeout)`	Write lock the PagingStore.
`Page`	`newPageObject(long page)`
`boolean`	`page(Message message, Transaction tx, RouteContextList listCtx)`	Write message to page if we are paging.
`void`	`pageFull(PageSubscription subscription)`	Callback to be used by a counter when the Page is full for that counter
`void`	`processReload()`
`Page`	`removePage(int pageId)`
`void`	`sendPages(ReplicationManager replicator, Collection<Integer> pageIds)`	Sends the pages with given IDs to the `ReplicationManager`.
`boolean`	`startPaging()`
`void`	`stopPaging()`
`void`	`sync()`	Schedules sync to the file storage.
`void`	`unblock()`
`void`	`unlock()`	Releases locks acquired with `lock(long)`.
`Page`	`usePage(long page)`
`Page`	`usePage(long page, boolean create)`	Use this method when you want to use the cache of used pages.

Methods inherited from interface org.apache.activemq.artemis.core.server.ActiveMQComponent
asyncStop, isStarted, start, stop

Methods inherited from interface org.apache.activemq.artemis.api.core.RefCountMessageListener
durableDown, durableUp, refDown, refUp, usageDown, usageUp

- Method Detail
  - getAddress
```
SimpleString getAddress()
```
  - getNumberOfPages
```
long getNumberOfPages()
```
  - getCurrentWritingPage
```
long getCurrentWritingPage()
```
    Returns the page id of the current page in which the system is writing files.
  - getStoreName
```
SimpleString getStoreName()
```
  - getFolder
```
File getFolder()
```
  - getAddressFullMessagePolicy
```
AddressFullMessagePolicy getAddressFullMessagePolicy()
```
  - getPageFullMessagePolicy
```
PageFullMessagePolicy getPageFullMessagePolicy()
```
  - getPageLimitMessages
```
Long getPageLimitMessages()
```
  - getPageLimitBytes
```
Long getPageLimitBytes()
```
  - pageFull
```
void pageFull(PageSubscription subscription)
```
    Callback to be used by a counter when the Page is full for that counter
  - isPageFull
```
boolean isPageFull()
```
  - checkPageLimit
```
void checkPageLimit(long numberOfMessages)
```
  - getFirstPage
```
long getFirstPage()
```
  - getPageSizeBytes
```
int getPageSizeBytes()
```
  - getAddressSize
```
long getAddressSize()
```
  - getMaxSize
```
long getMaxSize()
```
  - getMaxPageReadBytes
```
int getMaxPageReadBytes()
```
  - getMaxPageReadMessages
```
int getMaxPageReadMessages()
```
  - applySetting
```
void applySetting(AddressSettings addressSettings)
```
  - isPaging
```
boolean isPaging()
```
    This method will look if the current state of paging is not paging, without using a lock. For cases where you need absolutely atomic results, check it directly on the internal variables while requiring a readLock. It's ok to look for this with an estimate on starting a task or not, but you will need to recheck on actual paging operations.
  - sync
```
void sync()
   throws Exception
```
    Schedules sync to the file storage.
    
    Throws:
    
    Exception
  - ioSync
```
void ioSync()
     throws Exception
```
    Performs a real sync on the current IO file.
    
    Throws:
    
    Exception
  - page
```
boolean page(Message message,
             Transaction tx,
             RouteContextList listCtx)
      throws Exception
```
    Write message to page if we are paging.
    
    Returns:
    
    true if we are paging and have handled the data, false if the data needs to be sent to the journal
    
    Throws:
    
    NullPointerException - if readLock is null
    
    Exception
  - usePage
```
Page usePage(long page)
```
  - usePage
```
Page usePage(long page,
             boolean create)
```
    Use this method when you want to use the cache of used pages. If you are just using offline (e.g. print-data), use the newPageObject method.
  - newPageObject
```
Page newPageObject(long page)
            throws Exception
```
    Throws:
    
    Exception
  - checkPageFileExists
```
boolean checkPageFileExists(long page)
                     throws Exception
```
    Throws:
    
    Exception
  - getPagingManager
```
PagingManager getPagingManager()
```
  - getCursorProvider
```
PageCursorProvider getCursorProvider()
```
  - processReload
```
void processReload()
            throws Exception
```
    Throws:
    
    Exception
  - depage
```
Page depage()
     throws Exception
```
    Remove the first page from the Writing Queue. The file will still exist until Page.delete is called, So, case the system is reloaded the same Page will be loaded back if delete is not called.
    
    Throws:
    
    Exception - Note: This should still be part of the interface, even though ActiveMQ Artemis only uses through the
  - removePage
```
Page removePage(int pageId)
```
  - forceAnotherPage
```
void forceAnotherPage()
               throws Exception
```
    Throws:
    
    Exception
  - getCurrentPage
```
Page getCurrentPage()
```
  - counterSnapshot
```
void counterSnapshot()
```
    it will save snapshots on the counters
  - startPaging
```
boolean startPaging()
             throws Exception
```
    Returns:
    
    true if paging was started, or false if paging was already started before this call
    
    Throws:
    
    Exception
  - stopPaging
```
void stopPaging()
         throws Exception
```
    Throws:
    
    Exception
  - addSize
```
void addSize(int size,
             boolean sizeOnly)
```
    Parameters:
    
    size -
    
    sizeOnly - if false we won't increment the number of messages. (add references for example)
  - addSize
```
default void addSize(int size)
```
  - checkMemory
```
boolean checkMemory(Runnable runnable)
```
  - checkMemory
```
boolean checkMemory(boolean runOnFailure,
                    Runnable runnable,
                    Runnable runWhenBlocking)
```
  - isFull
```
boolean isFull()
```
  - isRejectingMessages
```
boolean isRejectingMessages()
```
  - checkReleasedMemory
```
boolean checkReleasedMemory()
```
    It will return true if the destination is leaving blocking.
  - lock
```
boolean lock(long timeout)
```
    Write lock the PagingStore.
    
    Parameters:
    
    timeout - milliseconds to wait for the lock. If value is -1 then wait indefinitely.
    
    Returns:
    
    true if the lock was obtained, false otherwise
  - unlock
```
void unlock()
```
    Releases locks acquired with lock(long).
  - flushExecutors
```
void flushExecutors()
```
    This is used mostly by tests. We will wait any pending runnable to finish its execution
  - execute
```
void execute(Runnable runnable)
```
  - getExecutor
```
ArtemisExecutor getExecutor()
```
  - getCurrentIds
```
Collection<Integer> getCurrentIds()
                           throws Exception
```
    Files to synchronize with a remote backup.
    
    Returns:
    
    a collection of page IDs which must be synchronized with a replicating backup
    
    Throws:
    
    Exception
  - sendPages
```
void sendPages(ReplicationManager replicator,
               Collection<Integer> pageIds)
        throws Exception
```
    Sends the pages with given IDs to the ReplicationManager.
    Sending is done here to avoid exposing the internal SequentialFiles.
    
    Parameters:
    
    replicator -
    
    pageIds -
    
    Throws:
    
    Exception
  - disableCleanup
```
void disableCleanup()
```
    This method will disable cleanup of pages. No page will be deleted after this call.
  - enableCleanup
```
void enableCleanup()
```
    This method will re-enable cleanup of pages. Notice that it will also start cleanup threads.
  - destroy
```
void destroy()
      throws Exception
```
    Throws:
    
    Exception
  - getAddressLimitPercent
```
int getAddressLimitPercent()
```
  - block
```
void block()
```
  - unblock
```
void unblock()
```
  - getStorageManager
```
default StorageManager getStorageManager()
```

Interface PagingStore

Method Summary

Methods inherited from interface org.apache.activemq.artemis.core.server.ActiveMQComponent

Methods inherited from interface org.apache.activemq.artemis.api.core.RefCountMessageListener

Method Detail

getAddress

getNumberOfPages

getCurrentWritingPage

getStoreName

getFolder

getAddressFullMessagePolicy

getPageFullMessagePolicy

getPageLimitMessages

getPageLimitBytes

pageFull

isPageFull

checkPageLimit

getFirstPage

getPageSizeBytes

getAddressSize

getMaxSize

getMaxPageReadBytes

getMaxPageReadMessages

applySetting

isPaging

sync

ioSync

page

usePage

usePage

newPageObject

checkPageFileExists

getPagingManager

getCursorProvider

processReload

depage

removePage

forceAnotherPage

getCurrentPage

counterSnapshot

startPaging

stopPaging

addSize

addSize

checkMemory

checkMemory

isFull

isRejectingMessages

checkReleasedMemory

lock

unlock

flushExecutors

execute

getExecutor

getCurrentIds

sendPages

disableCleanup

enableCleanup

destroy

getAddressLimitPercent

block

unblock

getStorageManager