org.apache.jackrabbit.oak.plugins.document.cache

Class NodeDocumentCache

java.lang.Object

org.apache.jackrabbit.oak.plugins.document.cache.NodeDocumentCache

All Implemented Interfaces:

Closeable, AutoCloseable

public class NodeDocumentCache
extends Object
implements Closeable

Cache for the NodeDocuments. This class is thread-safe and uses the provided NodeDocumentLock.

Constructor Summary

Constructors

Constructor and Description
NodeDocumentCache(Cache<CacheValue,NodeDocument> nodeDocumentsCache, CacheStats nodeDocumentsCacheStats, Cache<StringValue,NodeDocument> prevDocumentsCache, CacheStats prevDocumentsCacheStats, NodeDocumentLocks locks)

Method Summary

Modifier and Type	Method and Description
void	close()
NodeDocument	get(String key, Callable<NodeDocument> valueLoader) Return the document matching given key, optionally loading it from an external source.
Iterable<CacheStats>	getCacheStats()
NodeDocument	getIfPresent(String key) Return the cached value or null.
void	invalidate(String key) Invalidate document with given key.
int	invalidateOutdated(Map<String,ModificationStamp> modStamps) Invalidate document with given keys iff their modification stamps are different as passed in the map.
Iterable<CacheValue>	keys()
void	markChanged(String key) Mark that the document with the given key is being changed.
void	put(NodeDocument doc) Puts document into cache.
NodeDocument	putIfAbsent(NodeDocument doc) Puts document into cache iff no entry with the given key is cached already.
NodeDocument	putIfNewer(NodeDocument doc) Puts document into cache iff no entry with the given key is cached already or the cached document is older (has smaller Document.MOD_COUNT).
protected void	putInternal(NodeDocument doc) Puts a document into the cache without acquiring a lock.
protected void	putInternal(NodeDocument doc, CacheChangesTracker trackerToSkip) Puts a document into the cache without acquiring a lock.
void	putNonConflictingDocs(CacheChangesTracker tracker, Iterable<NodeDocument> docs) Updates the cache with all the documents that: (1) currently have their older versions in the cache or (2) have been neither put nor invalidated during the tracker lifetime.
CacheChangesTracker	registerTracker(Set<String> keys) Registers a new CacheChangesTracker that records all puts and invalidations related to the given documents
CacheChangesTracker	registerTracker(String fromKey, String toKey) Registers a new CacheChangesTracker that records all puts and invalidations related to children of the given parent.
void	replaceCachedDocument(NodeDocument oldDoc, NodeDocument newDoc) Replaces the cached value if the old document is currently present in the cache.
Iterable<NodeDocument>	values()

Methods inherited from class java.lang.Object

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

Constructor Detail

NodeDocumentCache

public NodeDocumentCache(@Nonnull
                         Cache<CacheValue,NodeDocument> nodeDocumentsCache,
                         @Nonnull
                         CacheStats nodeDocumentsCacheStats,
                         @Nonnull
                         Cache<StringValue,NodeDocument> prevDocumentsCache,
                         @Nonnull
                         CacheStats prevDocumentsCacheStats,
                         @Nonnull
                         NodeDocumentLocks locks)

Method Detail

invalidate

public void invalidate(@Nonnull
                       String key)

Invalidate document with given key.

Parameters:

key - to invalidate

markChanged

public void markChanged(@Nonnull
                        String key)

Mark that the document with the given key is being changed.

Parameters:

key - to mark

invalidateOutdated

@Nonnegative
public int invalidateOutdated(@Nonnull
                                            Map<String,ModificationStamp> modStamps)

Invalidate document with given keys iff their modification stamps are different as passed in the map.

Parameters:

modStamps - map where key is the document id and the value is the modification stamps.

Returns:

number of invalidated entries

getIfPresent

@CheckForNull
public NodeDocument getIfPresent(@Nonnull
                                                String key)

Return the cached value or null.

Parameters:

key - document key

Returns:

cached value of null if there's no document with given key cached

get

@Nonnull
public NodeDocument get(@Nonnull
                                  String key,
                                  @Nonnull
                                  Callable<NodeDocument> valueLoader)
                           throws ExecutionException

Return the document matching given key, optionally loading it from an external source.

This method can modify the cache, so it's synchronized. The getIfPresent(String) is not synchronized and will be faster if you need to get the cached value outside the critical section.

Parameters:

key - document key

valueLoader - object used to retrieve the document

Returns:

document matching given key

Throws:

ExecutionException

See Also:

Cache.get(Object, Callable)

put

public void put(@Nonnull
                NodeDocument doc)

Puts document into cache.

Parameters:

doc - document to put

putIfNewer

@Nonnull
public NodeDocument putIfNewer(@Nonnull
                                         NodeDocument doc)

Puts document into cache iff no entry with the given key is cached already or the cached document is older (has smaller Document.MOD_COUNT).

Parameters:

doc - the document to add to the cache

Returns:

either the given doc or the document already present in the cache if it's newer

putIfAbsent

@Nonnull
public NodeDocument putIfAbsent(@Nonnull
                                          NodeDocument doc)

Puts document into cache iff no entry with the given key is cached already. This operation is atomic.

Parameters:

doc - the document to add to the cache.

Returns:

either the given doc or the document already present in the cache.

replaceCachedDocument

public void replaceCachedDocument(@Nonnull
                                  NodeDocument oldDoc,
                                  @Nonnull
                                  NodeDocument newDoc)

Replaces the cached value if the old document is currently present in the cache. If the oldDoc is not cached, nothing will happen. If oldDoc does not match the document currently in the cache, then the cached document is invalidated.

Parameters:

oldDoc - the old document

newDoc - the replacement

keys

public Iterable<CacheValue> keys()

Returns:

keys stored in cache

values

public Iterable<NodeDocument> values()

Returns:

values stored in cache

getCacheStats

public Iterable<CacheStats> getCacheStats()

close

public void close()
           throws IOException

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Throws:

IOException

registerTracker

public CacheChangesTracker registerTracker(String fromKey,
                                           String toKey)

Registers a new CacheChangesTracker that records all puts and invalidations related to children of the given parent.

Parameters:

fromKey - only keys larger than this key will be tracked

toKey - only keys smaller than this key will be tracked

Returns:

new tracker

registerTracker

public CacheChangesTracker registerTracker(Set<String> keys)

Registers a new CacheChangesTracker that records all puts and invalidations related to the given documents

Parameters:

keys - these documents will be tracked

Returns:

new tracker

putNonConflictingDocs

public void putNonConflictingDocs(CacheChangesTracker tracker,
                                  Iterable<NodeDocument> docs)

Updates the cache with all the documents that: (1) currently have their older versions in the cache or (2) have been neither put nor invalidated during the tracker lifetime. We can't cache documents that has been invalidated during the tracker lifetime, as it's possible that the invalidated version was newer than the one passed in the docs parameter. If the document has been added during the tracker lifetime, but it is not present in the cache anymore, it means it may have been evicted, so we can't re-add it for the same reason as above.

Parameters:

tracker - used to decide whether the docs should be put into cache

docs - to put into cache

putInternal

protected final void putInternal(@Nonnull
                                 NodeDocument doc)

Puts a document into the cache without acquiring a lock. All trackers will be updated.

Parameters:

doc - the document to put into the cache.

putInternal

protected final void putInternal(@Nonnull
                                 NodeDocument doc,
                                 @Nullable
                                 CacheChangesTracker trackerToSkip)

Puts a document into the cache without acquiring a lock. All trackers will be updated, apart from the trackerToSkip.

Parameters:

doc - the document to put into the cache.

trackerToSkip - this tracker won't be updated. pass null to update all trackers.