com.cosylab.logging.client.cache

Class LogFileCache

java.lang.Object

com.cosylab.logging.client.cache.LogFileCache

All Implemented Interfaces:

ILogMap

Direct Known Subclasses:

LogBufferedFileCache

public class LogFileCache
extends java.lang.Object
implements ILogMap

This class implements the cache in order to be able to manage long log files. It is implemented by a file of logs and a data structure to associate the position in a file (LogCacheInfo) to each log. Such data structure is realized by a TreeMap whith the key given by the (progressive, unique) number of a log. Actually it is not possible to remove a log from the file. To effectively delete logs from disk we need some kind of garbage collector that removes the logs marked as delete from the file. This garbage collector is needed to avoid the file on disk grows indefinitely. Another potential problem is given by the integer identifier of the logs that grows indefinitely. A temporary solution could be that of using long instad of integers.

Author:

acaproni

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	LogFileCache.LogCacheInfo An entry in the cache on disk.

Field Summary

Fields

Modifier and Type	Field and Description
protected java.io.RandomAccessFile	file The file of logs is accessed in a random way (the positions are stored in the index)
protected java.util.TreeMap<java.lang.Integer,LogFileCache.LogCacheInfo>	index The index of the log is a SortedMap having the number identifying a log as key.
protected int	logID Each log is identified by a unique integer used as key to get the log from the file (throw the index data structure) logID is incremented whenever a new log is added NOTE: in this implementation this value is incremented without taking care of the logs deleted.
protected java.util.HashMap<java.lang.Integer,ILogEntry>	replacedLogs The logs replaced (for example the logs with some info added) They are usually a few so we keep them in memory

Constructor Summary

Constructors

Constructor and Description
LogFileCache()

Method Summary

Modifier and Type	Method and Description
int	add(ILogEntry log) Append a log to the end of the cache
void	clear() Empty the cache.
void	deleteLog(java.lang.Integer key) Delete a log The log is marked as deleted and moved from the index to the deleteLogIndex.
void	deleteLogs(java.util.Collection<java.lang.Integer> keys) Delete a set of logs
long	getFileSize() Return the length of the file on disk
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 cheang if such log has been deleted
ILogEntry	getLog(java.lang.Integer key) Return the log in the given position
int	getSize()
protected void	initCache() Init the file where the cache stores the logs If the file already exists it is truncated to 0 length this situation might happen whenever the cache is cleared
java.util.Iterator<ILogEntry>	iterator() Return an iterator over the logs in cache
java.util.Set<java.lang.Integer>	keySet() Return a set with all the keys of the logs in cache
void	replaceLog(java.lang.Integer key, ILogEntry log) Replace the log in the given position with the new one NOTE: the new log is kept in memory
protected java.lang.String	toCacheString(ILogEntry log)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

file

protected java.io.RandomAccessFile file

The file of logs is accessed in a random way (the positions are stored in the index)

logID

protected int logID

Each log is identified by a unique integer used as key to get the log from the file (throw the index data structure) logID is incremented whenever a new log is added NOTE: in this implementation this value is incremented without taking care of the logs deleted.

index

protected java.util.TreeMap<java.lang.Integer,LogFileCache.LogCacheInfo> index

The index of the log is a SortedMap having the number identifying a log as key. Each entry is a LogCacheInfo containing the starting and ending position of the log in the file

replacedLogs

protected java.util.HashMap<java.lang.Integer,ILogEntry> replacedLogs

The logs replaced (for example the logs with some info added) They are usually a few so we keep them in memory

Constructor Detail

LogFileCache

public LogFileCache()

Method Detail

getSize

public int getSize()

Specified by:

getSize in interface ILogMap

Returns:

The number of logs in cache

getFileSize

public long getFileSize()
                 throws java.io.IOException

Return the length of the file on disk

Returns:

The size of the file cache

Throws:

java.io.IOException - in case of I/O error

See Also:

RandomAccessFile

initCache

protected void initCache()
                  throws java.io.IOException

Init the file where the cache stores the logs If the file already exists it is truncated to 0 length this situation might happen whenever the cache is cleared

Throws:

java.io.IOException

clear

public void clear()
           throws LogCacheException

Empty the cache.

Specified by:

clear in interface ILogMap

Throws:

java.io.IOException

LogCacheException

getLog

public ILogEntry getLog(java.lang.Integer key)
                 throws LogCacheException

Return the log in the given position

Specified by:

getLog in interface ILogMap

Parameters:

pos - The position of the log

Returns:

The LogEntryXML or null in case of error

Throws:

LogCacheException

add

public int add(ILogEntry log)
        throws LogCacheException

Append a log to the end of the cache

Specified by:

add in interface ILogMap

Parameters:

log - The log to append in the cache

Returns:

The key in the cache of the added log

Throws:

LogCacheException

replaceLog

public void replaceLog(java.lang.Integer key,
                       ILogEntry log)
                throws LogCacheException

Replace the log in the given position with the new one NOTE: the new log is kept in memory

Specified by:

replaceLog in interface ILogMap

Parameters:

position - The position of the log to replace

log - The key (identifier) ot the log

Throws:

LogCacheException

toCacheString

protected java.lang.String toCacheString(ILogEntry log)

deleteLog

public void deleteLog(java.lang.Integer key)
               throws LogCacheException

Delete a log The log is marked as deleted and moved from the index to the deleteLogIndex. The log still exists in the file but is not accessible.

Specified by:

deleteLog in interface ILogMap

Parameters:

pos - The key of the log to remove

Throws:

LogCacheException

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

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

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

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 cheang if such log has been deleted

Specified by:

getLastLog in interface ILogMap

Returns:

The key of the last inserted log null if th cache is empty

keySet

public java.util.Set<java.lang.Integer> keySet()

Return a set with all the keys of the logs in cache

Specified by:

keySet in interface ILogMap

Returns:

The keys of the logs in cache

iterator

public java.util.Iterator<ILogEntry> iterator()

Return an iterator over the logs in cache

Specified by:

iterator in interface ILogMap

Returns:

an Iterator over the elements in this map