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(@NotNull com.google.common.cache.Cache<CacheValue,NodeDocument> nodeDocumentsCache, @NotNull CacheStats nodeDocumentsCacheStats, @NotNull com.google.common.cache.Cache<StringValue,NodeDocument> prevDocumentsCache, @NotNull CacheStats prevDocumentsCacheStats, @NotNull NodeDocumentLocks locks)

Method Summary

Modifier and Type	Method and Description
void	close()
@NotNull NodeDocument	get(@NotNull String key, @NotNull Callable<NodeDocument> valueLoader) Return the document matching given key, optionally loading it from an external source.
Iterable<CacheStats>	getCacheStats()
@Nullable NodeDocument	getIfPresent(@NotNull String key) Return the cached value or null.
void	invalidate(@NotNull String key) Invalidate document with given key.
int	invalidateOutdated(@NotNull 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(@NotNull String key) Mark that the document with the given key is being changed.
void	put(@NotNull NodeDocument doc) Puts document into cache.
@NotNull NodeDocument	putIfAbsent(@NotNull NodeDocument doc) Puts document into cache iff no entry with the given key is cached already.
@NotNull NodeDocument	putIfNewer(@NotNull 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(@NotNull NodeDocument doc) Puts a document into the cache without acquiring a lock.
protected void	putInternal(@NotNull NodeDocument doc, @Nullable 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(@NotNull NodeDocument oldDoc, @NotNull 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(@NotNull
                         @NotNull com.google.common.cache.Cache<CacheValue,NodeDocument> nodeDocumentsCache,
                         @NotNull
                         @NotNull CacheStats nodeDocumentsCacheStats,
                         @NotNull
                         @NotNull com.google.common.cache.Cache<StringValue,NodeDocument> prevDocumentsCache,
                         @NotNull
                         @NotNull CacheStats prevDocumentsCacheStats,
                         @NotNull
                         @NotNull NodeDocumentLocks locks)

Method Detail

invalidate

public void invalidate(@NotNull
                       @NotNull String key)

Invalidate document with given key.

Parameters:

key - to invalidate

markChanged

public void markChanged(@NotNull
                        @NotNull String key)

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

Parameters:

key - to mark

invalidateOutdated

public int invalidateOutdated(@NotNull
                              @NotNull 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

@Nullable
public @Nullable NodeDocument getIfPresent(@NotNull
                                                     @NotNull 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

@NotNull
public @NotNull NodeDocument get(@NotNull
                                          @NotNull String key,
                                          @NotNull
                                          @NotNull 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(@NotNull
                @NotNull NodeDocument doc)

Puts document into cache.

Parameters:

doc - document to put

putIfNewer

@NotNull
public @NotNull NodeDocument putIfNewer(@NotNull
                                                 @NotNull 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

@NotNull
public @NotNull NodeDocument putIfAbsent(@NotNull
                                                  @NotNull 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(@NotNull
                                  @NotNull NodeDocument oldDoc,
                                  @NotNull
                                  @NotNull 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(@NotNull
                                 @NotNull 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(@NotNull
                                 @NotNull NodeDocument doc,
                                 @Nullable
                                 @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.