eu.fbk.knowledgestore.triplestore

Class SynchronizedTripleStore

java.lang.Object

com.google.common.collect.ForwardingObject

eu.fbk.knowledgestore.triplestore.ForwardingTripleStore

eu.fbk.knowledgestore.triplestore.SynchronizedTripleStore

All Implemented Interfaces:

Component, TripleStore, Closeable, AutoCloseable

public class SynchronizedTripleStore
extends ForwardingTripleStore

A TripleStore wrapper that synchronizes and enforces a proper access to a wrapped TripleStore.

This wrapper provides the following guarantees with respect to external access to the wrapped TripleStore:

• transaction are started and committed according to the synchronization strategy enforced by a supplied Synchronizer;
• at most one thread at a time can access the wrapped TripleStore and its TripleTransactions, with the only exception of Component.close() and TripleTransaction.end(boolean) which may be called concurrently with other active operations;
• access to the wrapped TripleStore and its TripleTransaction is enforced to occur strictly in adherence with the lifecycle defined for Components ( IllegalStateExceptions are returned to the caller otherwise);
• method reset() of wrapped TripleStore is called with no transactions active (this implies waiting for completion of pending transactions);
• before a TripleTransaction is ended, all the iterations previously returned and still open to be forcedly closed;
• before the TripleStore is closed, pending TripleTransaction are forcedly ended with a rollback.

Constructor Summary

Constructors

Constructor and Description
SynchronizedTripleStore(TripleStore delegate, String synchronizerSpec) Creates a new instance for the wrapped TripleStore and the Synchronizer specification string supplied.
SynchronizedTripleStore(TripleStore delegate, Synchronizer synchronizer) Creates a new instance for the wrapped TripleStore and Synchronizer specified.

Method Summary

Modifier and Type	Method and Description
TripleTransaction	begin(boolean readOnly) Begins a new read-only / read-write triple store transaction.
void	close() Closes this Component object.
protected TripleStore	delegate()
void	init() Initializes the Component with the supplied Runtime object.
void	reset() Resets the triple store contents, possibly recreating or reinitializing the external services / files this triple store is based on.

Methods inherited from class com.google.common.collect.ForwardingObject

toString

Methods inherited from class java.lang.Object

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

Constructor Detail

SynchronizedTripleStore

public SynchronizedTripleStore(TripleStore delegate,
                               String synchronizerSpec)

Creates a new instance for the wrapped TripleStore and the Synchronizer specification string supplied.

Parameters:

delegate - the wrapped DataStore

synchronizerSpec - the synchronizer specification string (see Synchronizer)

SynchronizedTripleStore

public SynchronizedTripleStore(TripleStore delegate,
                               Synchronizer synchronizer)

Creates a new instance for the wrapped TripleStore and Synchronizer specified.

Parameters:

delegate - the wrapped TripleStore

synchronizer - the synchronizer responsible to regulate the access to the wrapped TripleStore

Method Detail

delegate

protected TripleStore delegate()

Specified by:

delegate in class ForwardingTripleStore

init

public void init()
          throws IOException

Description copied from interface: Component

Initializes the Component with the supplied Runtime object. This method is called after the instantiation of a Component and before any other instance method is called. It provides a Runtime that can be used to access runtime services such as locking, serialization and filesystem access. The Component is allowed to perform any initialization operation that is necessary in order to become functional; on failure, these operations may result in a IOException being thrown.

Specified by:

init in interface Component

Overrides:

init in class ForwardingTripleStore

Throws:

IOException - in case initialization fails

begin

public TripleTransaction begin(boolean readOnly)
                        throws IOException

Description copied from interface: TripleStore

Begins a new read-only / read-write triple store transaction. All the accesses to a triple store must occur in the scope of a transaction, that must be ended (possibly committing the modifications done) as soon as possible to allow improving throughput.

Specified by:

begin in interface TripleStore

Overrides:

begin in class ForwardingTripleStore

Parameters:

readOnly - true if the transaction is not allowed to modify the contents of the triple store (this allows for optimizing the access to the triple store).

Returns:

the created transaction

Throws:

DataCorruptedException - in case a transaction cannot be started due to triple store files being damaged or non-existing; a TripleStore.reset() call followed by a full triple store re-population should be attempted to recover this situation

IOException - if another IO error occurs while starting the transaction, not implying a data corruption situation

reset

public void reset()
           throws IOException

Description copied from interface: TripleStore

Resets the triple store contents, possibly recreating or reinitializing the external services / files this triple store is based on. This method is expected to be called either to initialize the triple store if it does not exist, or to recover a data corruption situation. On success, the triple store is left in an empty status. It is a task of the user code to re-populate it, if necessary.

Specified by:

reset in interface TripleStore

Overrides:

reset in class ForwardingTripleStore

Throws:

IOException - if an IO error occurs while resetting the triple store (this situation is not expected to be recovered automatically via code).

close

public void close()

Description copied from interface: Component

Closes this Component object. If the component has been initialized, closing a it causes any allocated resource to be freed and any operation or transaction ongoing within the component being aborted; in case the component has not been initialized yet, or close() has already being called, calling this method has no effect. Note that the operation affects only the local Component object and not any remote service this object may rely on to implement its functionalities; in particular, such a remote service is not shutdown by the operation, so that it can be accessed by other Component instances possibly running in other (virtual) machines. Similarly, closing a Component object has no impact on stored data, that continues to be persisted and will be accessed unchanged (provided no external modification occurs) the next time a similarly configured Component is created.

Specified by:

close in interface Component

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Overrides:

close in class ForwardingTripleStore