LogMultiFileCache (ACS-2016.6)

java.lang.Object
- com.cosylab.logging.client.cache.LogMultiFileCache

All Implemented Interfaces:

ILogMap

Direct Known Subclasses:

LogCache
```
public class LogMultiFileCache
extends java.lang.Object
implements ILogMap
```
This class manages a set of LogBufferedFileCache objects allowing the storing of logs in different files, though from the user point of view the logs are stored or retrieved from single data store. This is due to the fact that files can grow up to a given size and hence setting a limit on the number of logs that can be collected. Logs are added to a file until it reaches a given size, then a new file is created. Logs have different length and therefore the number of logs in each File Buffered Cache will be different (see example below). Logs are accessible by the user through a keyword (logKey) which is implemented as an increased running number. On the other hand, within each File Buffered Cache they have their own numbering system which starts from 0 to the maximum number of logs. Example : logKey logCounter Buffered File Range Cache Range -------------------------------------------------------- 0 - 10 11 0 - 10 file1 11 - 25 15 0 - 14 file2 26 - 32 7 0 - 6 file3 33 - 50 18 0 - 18 file4 When logs are deleted they are no longer accessible : when all logs stored in a single file are marked as deleted the corresponding logCounter = 0 and as consequence the file itself is removed. Using the example let's assume we delete the logs with the following keyword : 26,27,28,31,32, from now on these logs will not be accessible for the user. logKey logCounter Buffered File Range Cache Range -------------------------------------------------------- 0 - 10 11 0 - 10 file1 11 - 25 15 0 - 14 file2 26 - 32 2 0 - 6 file3 33 - 50 18 0 - 18 file4 If we delete also logs with keywords 29 and 30 the logCounter will be zero and file3 will be deleted. logKey Mapping When retrieving the log we need to re-map the global log keyword into the keyword used to add the log to the specific Buffered File Cache. This is done by simply subtracting the minimum key value from the logKey. Example : Retrieve logKey 20. logKey 20 is stored in the second Buffered File Cache and it is accessible with the local key = (20 - 11) = 9

Author:

mcomin

Field Summary

Fields
Modifier and Type	Field and Description
`static long`	`DEFAULT_FILEMAXSIZE` The default max size of each file of the cache
`static java.lang.String`	`FILEMAXSIZE_PROPERTY_NAME` The name of the property defining the max size of each fileof the cache

Constructor Summary

Constructors
Constructor and Description
`LogMultiFileCache()` Constructor The maximum size of the files is read from the system properties.
`LogMultiFileCache(long fileSize)` Builds a LogMultiFileCache objects setting the maximum size of the cache files

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`add(ILogEntry log)` Add a log to the cache
`void`	`clear()` Clear the Map i.e.
`void`	`deleteLog(java.lang.Integer logKey)` Delete a log with the given key.
`void`	`deleteLogs(java.util.Collection<java.lang.Integer> keys)` Delete a set of logs
`long`	`getFilesSize()` Return the disk space used by all the files of the cache.
`java.lang.Integer`	`getFirstLog()` Return the key of the first valid log (FIFO).
`int`	`getFirstLogs(int n, java.util.Collection<java.lang.Integer> keys)` Append at most n keys from the first valid logs to the collection.
`java.lang.Integer`	`getLastLog()` Return the key of the last valid log (FIFO) The key of the last log is the key of the last inserted log but it can change if such log has been deleted
`ILogEntry`	`getLog(java.lang.Integer logKey)` Retrieves a log by means of its keyword.
`long`	`getLogFileSize()` Return the size of the last log file used by the cache (it is here for testing purposes)
`long`	`getMaxFileSize()` Return the current maximum size of the log file
`int`	`getNumberOfCacheFiles()`
`int`	`getSize()`
`java.util.Iterator<ILogEntry>`	`iterator()` Return an Iterator to browse the logs in the map.
`java.util.Set<java.lang.Integer>`	`keySet()` The keys in the map
`void`	`printFileTableInfo()` Return the current maximum size of the log file
`void`	`replaceLog(java.lang.Integer key, ILogEntry log)` Replace the log in the given position with the new one
`void`	`setDebugTrace(boolean flag)` Return the current maximum size of the log file

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - FILEMAXSIZE_PROPERTY_NAME
```
public static final java.lang.String FILEMAXSIZE_PROPERTY_NAME
```
    The name of the property defining the max size of each fileof the cache
    
    See Also:
    
    Constant Field Values
  - DEFAULT_FILEMAXSIZE
```
public static final long DEFAULT_FILEMAXSIZE
```
    The default max size of each file of the cache
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - LogMultiFileCache
```
public LogMultiFileCache(long fileSize)
                  throws LogCacheException
```
    Builds a LogMultiFileCache objects setting the maximum size of the cache files
    
    Parameters:
    
    fileSize - The maximum size of cache files
    
    Throws:
    
    LogCacheException
  - LogMultiFileCache
```
public LogMultiFileCache()
                  throws LogCacheException
```
    Constructor The maximum size of the files is read from the system properties. If the property is not found a default value is used.
    
    Throws:
    
    LogCacheException
- Method Detail
  - getLog
```
public ILogEntry getLog(java.lang.Integer logKey)
                 throws LogCacheException
```
    Retrieves a log by means of its keyword.
    
    Specified by:
    
    getLog in interface ILogMap
    
    Parameters:
    
    pos - The key of the log to retrieve
    
    Returns:
    
    The log with the given key
    
    Throws:
    
    LogCacheException
  - add
```
public int add(ILogEntry log)
        throws LogCacheException
```
    Add a log to the cache
    
    Specified by:
    
    add in interface ILogMap
    
    Parameters:
    
    log - The log to add to the cache
    
    Returns:
    
    The key of the added log
    
    Throws:
    
    LogCacheException
  - deleteLog
```
public void deleteLog(java.lang.Integer logKey)
               throws LogCacheException
```
    Delete a log with the given key.
    
    Specified by:
    
    deleteLog in interface ILogMap
    
    Parameters:
    
    pos - The key of the log to delete
    
    Throws:
    
    LogCacheException
  - getSize
```
public int getSize()
```
    Specified by:
    
    getSize in interface ILogMap
    
    Returns:
    
    The number of logs in the map
    
    See Also:
    
    ILogMap
  - getLastLog
```
public java.lang.Integer getLastLog()
```
    Return the key of the last valid log (FIFO) The key of the last log is the key of the last inserted log but it can change if such log has been deleted
    
    Specified by:
    
    getLastLog in interface ILogMap
    
    Returns:
    
    The key of the last inserted log null if the cache is empty
    
    See Also:
    
    ILogMap
  - getFirstLog
```
public java.lang.Integer getFirstLog()
```
    Return the key of the first valid log (FIFO). The key of the first log is 0 but it can change if the log 0 has been deleted.
    
    Specified by:
    
    getFirstLog in interface ILogMap
    
    Returns:
    
    The key of the first log null if the cache is empty
    
    Throws:
    
    In - case of error getting the first log
    
    See Also:
    
    ILogMap
  - deleteLogs
```
public void deleteLogs(java.util.Collection<java.lang.Integer> keys)
                throws LogCacheException
```
    Delete a set of logs
    
    Specified by:
    
    deleteLogs in interface ILogMap
    
    Parameters:
    
    keys - The keys of logs to delete
    
    Throws:
    
    LogCacheException
    
    See Also:
    
    ILogMap
  - clear
```
public void clear()
           throws LogCacheException
```
    Clear the Map i.e. remove all the logs and keys from the map
    
    Specified by:
    
    clear in interface ILogMap
    
    Throws:
    
    LogCacheException
    
    See Also:
    
    ILogMap
  - replaceLog
```
public void replaceLog(java.lang.Integer key,
                       ILogEntry log)
                throws LogCacheException
```
    Replace the log in the given position with the new one
    
    Specified by:
    
    replaceLog in interface ILogMap
    
    Parameters:
    
    position - The position of the log to replace
    
    log - The key (identifier) of the log
    
    Throws:
    
    LogCacheException
    
    See Also:
    
    ILogMap
  - iterator
```
public java.util.Iterator<ILogEntry> iterator()
```
    Return an Iterator to browse the logs in the map. The order the iterator returns the logs is that of the keys.
    
    Specified by:
    
    iterator in interface ILogMap
    
    Returns:
    
    an Iterator over the elements in this map
    
    See Also:
    
    ILogMap
  - keySet
```
public java.util.Set<java.lang.Integer> keySet()
```
    The keys in the map
    
    Specified by:
    
    keySet in interface ILogMap
    
    Returns:
    
    The key in the map
    
    See Also:
    
    ILogMap
  - getFirstLogs
```
public int getFirstLogs(int n,
                        java.util.Collection<java.lang.Integer> keys)
```
    Append at most n keys from the first valid logs to the collection. First here means first in the FIFO policy. The number of added keys can be less then n if the cache doesn't contain enough logs.
    
    Specified by:
    
    getFirstLogs in interface ILogMap
    
    Parameters:
    
    n - The desired number of keys of first logs
    
    keys - The collection to add they keys to
    
    Returns:
    
    The number of keys effectively added
    
    See Also:
    
    ILogMap
  - getLogFileSize
```
public long getLogFileSize()
                    throws LogCacheException
```
    Return the size of the last log file used by the cache (it is here for testing purposes)
    
    Throws:
    
    LogCacheException
  - getFilesSize
```
public long getFilesSize()
                  throws java.io.IOException
```
    Return the disk space used by all the files of the cache.
    
    Returns:
    
    The disk space used by all the files of the cache
    
    Throws:
    
    java.io.IOException - In case of error getting the size of one of the files
  - getMaxFileSize
```
public long getMaxFileSize()
                    throws LogCacheException
```
    Return the current maximum size of the log file
    
    Throws:
    
    LogCacheException
  - setDebugTrace
```
public void setDebugTrace(boolean flag)
                   throws LogCacheException
```
    Return the current maximum size of the log file
    
    Throws:
    
    LogCacheException
  - printFileTableInfo
```
public void printFileTableInfo()
                        throws LogCacheException
```
    Return the current maximum size of the log file
    
    Throws:
    
    LogCacheException
  - getNumberOfCacheFiles
```
public int getNumberOfCacheFiles()
```
    Returns:
    
    the number of the files used by the cache

Class LogMultiFileCache

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FILEMAXSIZE_PROPERTY_NAME

DEFAULT_FILEMAXSIZE

Constructor Detail

LogMultiFileCache

LogMultiFileCache

Method Detail

getLog

add

deleteLog

getSize

getLastLog

getFirstLog

deleteLogs

clear

replaceLog

iterator

keySet

getFirstLogs

getLogFileSize

getFilesSize

getMaxFileSize

setDebugTrace

printFileTableInfo

getNumberOfCacheFiles