com.aquenos.cassandra.pvarchiver.server.database

Class GenericDataStoreDAOImpl

java.lang.Object

com.aquenos.cassandra.pvarchiver.server.database.GenericDataStoreDAOImpl

All Implemented Interfaces:

GenericDataStoreDAO, Aware, SmartInitializingSingleton, ApplicationEventPublisherAware

public class GenericDataStoreDAOImpl
extends Object
implements ApplicationEventPublisherAware, GenericDataStoreDAO, SmartInitializingSingleton

Implementation of a data access object for storing generic pieces of information. This object encapsulates the logic for accessing the generic_data_store table in the Apache Cassandra database.

Author:

Sebastian Marsching

Nested Class Summary

Nested classes/interfaces inherited from interface com.aquenos.cassandra.pvarchiver.server.database.GenericDataStoreDAO

GenericDataStoreDAO.DataItem

Field Summary

Fields

Modifier and Type	Field and Description
protected org.slf4j.Logger	log Logger for this object.

Constructor Summary

Constructors

Constructor and Description
GenericDataStoreDAOImpl()

Method Summary

Modifier and Type	Method and Description
void	afterSingletonsInstantiated()
ListenableFuture<Pair<Boolean,String>>	createItem(UUID componentId, String key, String value) Create a data item for the specified component and key if no such item exists yet.
ListenableFuture<Void>	createOrUpdateItem(UUID componentId, String key, String value) Creates a data item or updates it if an item with the specified key already exists for the specified component.
ListenableFuture<Void>	deleteAllItems(UUID componentId) Removes all data items for the specified component.
ListenableFuture<Void>	deleteItem(UUID componentId, String key) Removes the item with the specified key from collection of data items for the specified component.
ListenableFuture<? extends Iterable<? extends GenericDataStoreDAO.DataItem>>	getAllItems(UUID componentId) Returns all data items for the specified component.
ListenableFuture<? extends GenericDataStoreDAO.DataItem>	getItem(UUID componentId, String key) Returns the data item with the specified key for the specified component.
boolean	isInitialized() Tells whether this DAO has finished initialization and is ready to be used.
void	onCassandraProviderInitializedEvent(CassandraProviderInitializedEvent event) Handles CassandraProviderInitializedEvents.
void	setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher)
void	setCassandraProvider(CassandraProvider cassandraProvider) Sets the Cassandra provider that provides access to the Apache Cassandra database.
ListenableFuture<Pair<Boolean,String>>	updateItem(UUID componentId, String key, String oldValue, String newValue) Updates the data item with the specified key and component.

Methods inherited from class java.lang.Object

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

Field Detail

log

protected final org.slf4j.Logger log

Logger for this object. The logger uses the actual type of this object and the base type where this field is declared.

Constructor Detail

GenericDataStoreDAOImpl

public GenericDataStoreDAOImpl()

Method Detail

onCassandraProviderInitializedEvent

@EventListener
 @Order(value=1000)
public void onCassandraProviderInitializedEvent(CassandraProviderInitializedEvent event)

Handles CassandraProviderInitializedEvents. This event is used when the CassandraProvider set using setCassandraProvider(CassandraProvider) is not ready yet when this object is initialized. In this case, some actions that usually are performed during initialization (like creating tables, initializing access objects) have to be deferred until the Apache Cassandra database becomes available.

Parameters:

event - initialization event sent by the CassandraProvider.

setCassandraProvider

@Autowired
public void setCassandraProvider(CassandraProvider cassandraProvider)

Sets the Cassandra provider that provides access to the Apache Cassandra database.

Parameters:

cassandraProvider - provider that provides a connection to the Apache Cassandra database.

afterSingletonsInstantiated

public void afterSingletonsInstantiated()

Specified by:

afterSingletonsInstantiated in interface SmartInitializingSingleton

setApplicationEventPublisher

public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher)

Specified by:

setApplicationEventPublisher in interface ApplicationEventPublisherAware

createItem

public ListenableFuture<Pair<Boolean,String>> createItem(UUID componentId,
                                                         String key,
                                                         String value)

Description copied from interface: GenericDataStoreDAO

Create a data item for the specified component and key if no such item exists yet. Typically, this is less efficient than GenericDataStoreDAO.createOrUpdateItem(UUID, String, String), so code should prefer the latter method unless it has to ensure that it does not overwrite an existing value. The operation is performed in an asynchronous way so that it will not block for network communication. The result of the operation can be checked through the returned future.

Specified by:

createItem in interface GenericDataStoreDAO

Parameters:

componentId - ID of the component for which the data item should be created.

key - key identifying the data item within the component.

value - value of the data item.

Returns:

pair of a boolean flag and a string exposed through a future. The boolean flag indicates whether the item was created. If true, the item was created, if false, an item with the specified key already existed for the specified component. In this case, the string is the value of the existing item. In case of failure, the future's get() method will throw an exception.

createOrUpdateItem

public ListenableFuture<Void> createOrUpdateItem(UUID componentId,
                                                 String key,
                                                 String value)

Description copied from interface: GenericDataStoreDAO

Creates a data item or updates it if an item with the specified key already exists for the specified component. This is the most efficient way to create or update a data item and should be preferred over GenericDataStoreDAO.createItem(UUID, String, String) and GenericDataStoreDAO.updateItem(UUID, String, String, String). The operation is performed in an asynchronous way so that it will not block for network communication. The result of the operation can be checked through the returned future.

Specified by:

createOrUpdateItem in interface GenericDataStoreDAO

Parameters:

componentId - ID of the component for which the data item should be created or updated.

key - key identifying the data item within the component.

value - value of the data item.

Returns:

future that can be used to check whether this operation finished and whether it was successful. In case of failure, the future's get() method will throw an exception.

deleteAllItems

public ListenableFuture<Void> deleteAllItems(UUID componentId)

Description copied from interface: GenericDataStoreDAO

Removes all data items for the specified component. The operation is performed in an asynchronous way so that it will not block for network communication. The result of the operation can be checked through the returned future.

Specified by:

deleteAllItems in interface GenericDataStoreDAO

Parameters:

componentId - ID of the component for which all data items should be removed.

Returns:

future that can be used to check whether this operation finished and whether it was successful. In case of failure, the future's get() method will throw an exception.

deleteItem

public ListenableFuture<Void> deleteItem(UUID componentId,
                                         String key)

Description copied from interface: GenericDataStoreDAO

Removes the item with the specified key from collection of data items for the specified component. The operation is performed in an asynchronous way so that it will not block for network communication. The result of the operation can be checked through the returned future.

Specified by:

deleteItem in interface GenericDataStoreDAO

Parameters:

componentId - ID of the component that owns the data item.

key - key identifying the data item within the component.

Returns:

future that can be used to check whether this operation finished and whether it was successful. In case of failure, the future's get() method will throw an exception.

getAllItems

public ListenableFuture<? extends Iterable<? extends GenericDataStoreDAO.DataItem>> getAllItems(UUID componentId)

Description copied from interface: GenericDataStoreDAO

Returns all data items for the specified component. The operation is performed in an asynchronous way so that it will not block for network communication. The result of the operation can be checked through the returned future.

The iterable returned by the future is only safe for iterating once. Subsequent requests to create an iterator might result in the new iterator only returning the elements that have not been returned by a previously created iterator yet. Besides, the iterator might block while iterating, waiting for additional elements to arrive from the network.

Specified by:

getAllItems in interface GenericDataStoreDAO

Parameters:

componentId - ID of the component for which all data items should be retrieved.

Returns:

all data items for the specified component exposed through a future. In case of failure, the future's get() method will throw an exception.

getItem

public ListenableFuture<? extends GenericDataStoreDAO.DataItem> getItem(UUID componentId,
                                                                        String key)

Description copied from interface: GenericDataStoreDAO

Returns the data item with the specified key for the specified component. The operation is performed in an asynchronous way so that it will not block for network communication. The result of the operation can be checked through the returned future.

Specified by:

getItem in interface GenericDataStoreDAO

Parameters:

componentId - ID of the component that owns the data item.

key - key identifying the data item within the component.

Returns:

data item with the specified key for the specified component exposed through a future. If no such data item exists, the future's get method returns null. In case of failure, the future's get() method will throw an exception.

isInitialized

public boolean isInitialized()

Description copied from interface: GenericDataStoreDAO

Tells whether this DAO has finished initialization and is ready to be used. Even if this method returns true, operations might still fail because of transient problems.

Specified by:

isInitialized in interface GenericDataStoreDAO

Returns:

true if this DAO has been initialized and is ready to be used, false if initialization has not completed yet.

updateItem

public ListenableFuture<Pair<Boolean,String>> updateItem(UUID componentId,
                                                         String key,
                                                         String oldValue,
                                                         String newValue)

Description copied from interface: GenericDataStoreDAO

Updates the data item with the specified key and component. The item is only updated if its current value matches the specified oldValue. This type of atomic operation incurs an additional overhead. Code that does not mind overwriting a different value should prefer the GenericDataStoreDAO.createOrUpdateItem(UUID, String, String) method. The operation is performed in an asynchronous way so that it will not block for network communication. The result of the operation can be checked through the returned future.

Specified by:

updateItem in interface GenericDataStoreDAO

Parameters:

componentId - ID of the component that owns the data item.

key - key identifying the data item within the component.

oldValue - old value of the data item that must be matched for the update operation to proceed.

newValue - new value that the data item shall be updated with if the old value matches.

Returns:

pair of a boolean flag and a string exposed through a future. The boolean flag indicates whether the item was updated. If true, the item was updated, if false, the item's value did not match the specified oldValue or the item did not exist. If the flag is false, the string is the current value of the existing item or null if no item with the specified component ID and key exists. In case of failure, the future's get() method will throw an exception.