public final class SynchronizedDataStore extends ForwardingDataStore
DataStore
wrapper that synchronizes and enforces a proper access to an another
DataStore
.
This wrapper provides the following guarantees with respect to external access to the wrapped
DataStore
:
Synchronizer
;DataStore
and its
DataTransaction
s, with the only exception of Component.close()
and
DataTransaction.end(boolean)
which may be called concurrently with other active
operations;DataStore
and its DataTransaction
is enforced to
occur strictly in adherence with the lifecycle defined for Component
s (
IllegalStateException
s are thrown to the caller otherwise);DataTransaction
is ended, all the streams previously returned and still
open to be forcedly closed;DataStore
is closed, pending DataTransaction
are forcedly ended
with a rollback;SUPPORTED_TYPES
Constructor and Description |
---|
SynchronizedDataStore(DataStore delegate,
String synchronizerSpec)
Creates a new instance for the wrapped
DataStore and the Synchronizer
specification string supplied. |
SynchronizedDataStore(DataStore delegate,
Synchronizer synchronizer)
Creates a new instance for the wrapped
DataStore and Synchronizer
specified. |
Modifier and Type | Method and Description |
---|---|
DataTransaction |
begin(boolean readOnly)
Begins a new read-only / read-write
DataStore transaction. |
void |
close()
Closes this
Component object. |
protected DataStore |
delegate() |
void |
init()
Initializes the
Component with the supplied Runtime object. |
toString
public SynchronizedDataStore(DataStore delegate, String synchronizerSpec)
DataStore
and the Synchronizer
specification string supplied.delegate
- the wrapped DataStore
synchronizerSpec
- the synchronizer specification string (see Synchronizer
)public SynchronizedDataStore(DataStore delegate, Synchronizer synchronizer)
DataStore
and Synchronizer
specified.delegate
- the wrapped DataStore
synchronizer
- the synchronizer responsible to regulate the access to the wrapped
DataStore
protected DataStore delegate()
delegate
in class ForwardingDataStore
public void init() throws IOException
Component
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.init
in interface Component
init
in class ForwardingDataStore
IOException
- in case initialization failspublic DataTransaction begin(boolean readOnly) throws IOException, IllegalStateException
DataStore
DataStore
transaction. All the accesses to a
DataStore
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.begin
in interface DataStore
begin
in class ForwardingDataStore
readOnly
- true if the transaction is not allowed to modify the contents of the
DataStore
(this allows for optimizing accesses).DataCorruptedException
- in case a transaction cannot be started due to the DataStore
persistent
data being damaged or non-existing (this may trigger some external recovery
procedure)IOException
- if another IO error occurs while starting the transactionIllegalStateException
- if the DataStore
object has been already closedpublic void close()
Component
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.close
in interface Component
close
in interface Closeable
close
in interface AutoCloseable
close
in class ForwardingDataStore
Copyright © 2015–2016 FBK-irst. All rights reserved.