public Backend(Configuration storageConfig) {
this.storageConfig = storageConfig;
storeManager = getStorageManager(storageConfig);
indexes = getIndexes(storageConfig);
storeFeatures = storeManager.getFeatures();
basicMetrics = storageConfig.getBoolean(BASIC_METRICS, BASIC_METRICS_DEFAULT);
mergeBasicMetrics =
storageConfig.getBoolean(MERGE_BASIC_METRICS_KEY, MERGE_BASIC_METRICS_DEFAULT);
int bufferSizeTmp = storageConfig.getInt(BUFFER_SIZE_KEY, BUFFER_SIZE_DEFAULT);
Preconditions.checkArgument(
bufferSizeTmp >= 0, "Buffer size must be non-negative (use 0 to disable)");
if (!storeFeatures.supportsBatchMutation()) {
bufferSize = 0;
log.debug("Buffering disabled because backend does not support batch mutations");
} else bufferSize = bufferSizeTmp;
writeAttempts = storageConfig.getInt(WRITE_ATTEMPTS_KEY, WRITE_ATTEMPTS_DEFAULT);
Preconditions.checkArgument(writeAttempts > 0, "Write attempts must be positive");
readAttempts = storageConfig.getInt(READ_ATTEMPTS_KEY, READ_ATTEMPTS_DEFAULT);
Preconditions.checkArgument(readAttempts > 0, "Read attempts must be positive");
persistAttemptWaittime =
storageConfig.getInt(STORAGE_ATTEMPT_WAITTIME_KEY, STORAGE_ATTEMPT_WAITTIME_DEFAULT);
Preconditions.checkArgument(
persistAttemptWaittime > 0, "Persistence attempt retry wait time must be non-negative");
// If lock prefix is unspecified, specify it now
storageConfig.setProperty(
ExpectedValueCheckingStore.LOCAL_LOCK_MEDIATOR_PREFIX_KEY,
storageConfig.getString(
ExpectedValueCheckingStore.LOCAL_LOCK_MEDIATOR_PREFIX_KEY, storeManager.getName()));
final String lockBackendName =
storageConfig.getString(
GraphDatabaseConfiguration.LOCK_BACKEND,
GraphDatabaseConfiguration.LOCK_BACKEND_DEFAULT);
if (REGISTERED_LOCKERS.containsKey(lockBackendName)) {
lockerCreator = REGISTERED_LOCKERS.get(lockBackendName);
} else {
throw new TitanConfigurationException(
"Unknown lock backend \""
+ lockBackendName
+ "\". Known lock backends: "
+ Joiner.on(", ").join(REGISTERED_LOCKERS.keySet())
+ ".");
}
// Never used for backends that have innate transaction support, but we
// want to maintain the non-null invariant regardless; it will default
// to connsistentkey impl if none is specified
Preconditions.checkNotNull(lockerCreator);
if (storeFeatures.isDistributed() && storeFeatures.isKeyOrdered()) {
log.debug("Wrapping index store with HashPrefix");
hashPrefixIndex = true;
} else {
hashPrefixIndex = false;
}
}
public BackendTransaction beginTransaction() throws StorageException {
StoreTransaction tx = storeManager.beginTransaction(ConsistencyLevel.DEFAULT);
if (bufferSize > 1) {
assert storeManager.getFeatures().supportsBatchMutation();
if (isKeyColumnValueStore) {
assert storeManager instanceof KeyColumnValueStoreManager;
tx =
new BufferTransaction(
tx,
(KeyColumnValueStoreManager) storeManager,
bufferSize,
writeAttempts,
persistAttemptWaittime);
} else {
assert storeManager instanceof KeyValueStoreManager;
// TODO: support buffer mutations
}
}
if (!storeFeatures.supportsLocking()) {
if (storeFeatures.isTransactional()) {
// No transaction wrapping needed
} else if (storeFeatures.supportsConsistentKeyOperations()) {
tx =
new ConsistentKeyLockTransaction(
tx, storeManager.beginTransaction(ConsistencyLevel.KEY_CONSISTENT));
}
}
return new BackendTransaction(tx);
}
private KeyColumnValueStore getLockStore(KeyColumnValueStore store) throws StorageException {
if (!storeFeatures.supportsLocking()) {
if (storeFeatures.isTransactional()) {
store = new TransactionalLockStore(store);
} else if (storeFeatures.supportsConsistentKeyOperations()) {
store =
new ConsistentKeyLockStore(
store, getStore(store.getName() + LOCK_STORE_SUFFIX), lockConfiguration);
} else throw new IllegalArgumentException("Store needs to support some form of locking");
}
return store;
}
private KeyColumnValueStore getLockStore(KeyColumnValueStore store, boolean lockEnabled)
throws StorageException {
if (!storeFeatures.supportsLocking()) {
if (storeFeatures.supportsTransactions()) {
store = new TransactionalLockStore(store);
} else if (storeFeatures.supportsConsistentKeyOperations()) {
if (lockEnabled) {
final String lockerName = store.getName() + LOCK_STORE_SUFFIX;
store = new ExpectedValueCheckingStore(store, getLocker(lockerName));
} else {
store = new ExpectedValueCheckingStore(store, null);
}
} else throw new IllegalArgumentException("Store needs to support some form of locking");
}
return store;
}
/**
* Opens a new transaction against all registered backend system wrapped in one {@link
* BackendTransaction}.
*
* @return
* @throws StorageException
*/
public BackendTransaction beginTransaction(TransactionConfiguration configuration)
throws StorageException {
StoreTxConfig txConfig = new StoreTxConfig(configuration.getMetricsPrefix());
if (configuration.hasTimestamp()) txConfig.setTimestamp(configuration.getTimestamp());
StoreTransaction tx = storeManager.beginTransaction(txConfig);
if (bufferSize > 1) {
Preconditions.checkArgument(storeManager.getFeatures().supportsBatchMutation());
tx =
new BufferTransaction(
tx, storeManager, bufferSize, writeAttempts, persistAttemptWaittime);
}
if (!storeFeatures.supportsLocking()) {
if (storeFeatures.supportsTransactions()) {
// No transaction wrapping needed
} else if (storeFeatures.supportsConsistentKeyOperations()) {
txConfig =
new StoreTxConfig(ConsistencyLevel.KEY_CONSISTENT, configuration.getMetricsPrefix());
if (configuration.hasTimestamp()) txConfig.setTimestamp(configuration.getTimestamp());
tx =
new ExpectedValueCheckingTransaction(
tx, storeManager.beginTransaction(txConfig), readAttempts);
}
}
// Index transactions
Map<String, IndexTransaction> indexTx = new HashMap<String, IndexTransaction>(indexes.size());
for (Map.Entry<String, IndexProvider> entry : indexes.entrySet()) {
indexTx.put(entry.getKey(), new IndexTransaction(entry.getValue()));
}
return new BackendTransaction(
tx,
storeManager.getFeatures(),
edgeStore,
vertexIndexStore,
edgeIndexStore,
readAttempts,
persistAttemptWaittime,
indexTx);
}
public void initialize(Configuration config) {
try {
// EdgeStore & VertexIndexStore
KeyColumnValueStore idStore = getStore(ID_STORE_NAME);
idAuthority = null;
if (storeFeatures.isTransactional()) {
idAuthority = new TransactionalIDManager(idStore, storeManager, config);
} else if (storeFeatures.supportsConsistentKeyOperations()) {
idAuthority = new ConsistentKeyIDManager(idStore, storeManager, config);
} else {
idAuthority = new TransactionalIDManager(idStore, storeManager, config);
log.error(
"Store needs to support consistent key or transactional operations for ID manager to guarantee proper id allocations");
}
edgeStore = getLockStore(getBufferStore(EDGESTORE_NAME));
vertexIndexStore = getLockStore(getBufferStore(VERTEXINDEX_STORE_NAME));
if (hashPrefixIndex)
vertexIndexStore = new HashPrefixKeyColumnValueStore(vertexIndexStore, 4);
} catch (StorageException e) {
throw new TitanException("Could not initialize backend", e);
}
}
public Backend(Configuration storageConfig) {
storeManager = getStorageManager(storageConfig);
isKeyColumnValueStore = storeManager instanceof KeyColumnValueStoreManager;
storeFeatures = storeManager.getFeatures();
int bufferSizeTmp = storageConfig.getInt(BUFFER_SIZE_KEY, BUFFER_SIZE_DEFAULT);
Preconditions.checkArgument(
bufferSizeTmp >= 0, "Buffer size must be non-negative (use 0 to disable)");
if (!storeFeatures.supportsBatchMutation()) {
bufferSize = 0;
log.debug("Buffering disabled because backend does not support batch mutations");
} else bufferSize = bufferSizeTmp;
if (!storeFeatures.supportsLocking() && storeFeatures.supportsConsistentKeyOperations()) {
lockConfiguration =
new ConsistentKeyLockConfiguration(storageConfig, storeManager.toString());
} else {
lockConfiguration = null;
}
writeAttempts = storageConfig.getInt(WRITE_ATTEMPTS_KEY, WRITE_ATTEMPTS_DEFAULT);
Preconditions.checkArgument(writeAttempts > 0, "Write attempts must be positive");
readAttempts = storageConfig.getInt(READ_ATTEMPTS_KEY, READ_ATTEMPTS_DEFAULT);
Preconditions.checkArgument(readAttempts > 0, "Read attempts must be positive");
persistAttemptWaittime =
storageConfig.getInt(STORAGE_ATTEMPT_WAITTIME_KEY, STORAGE_ATTEMPT_WAITTIME_DEFAULT);
Preconditions.checkArgument(
persistAttemptWaittime > 0, "Persistence attempt retry wait time must be non-negative");
if (storeFeatures.isDistributed() && storeFeatures.isKeyOrdered()) {
log.debug("Wrapping index store with HashPrefix");
hashPrefixIndex = true;
} else {
hashPrefixIndex = false;
}
}
/**
* Initializes this backend with the given configuration. Must be called before this Backend can
* be used
*
* @param config
*/
public void initialize(Configuration config) {
try {
// EdgeStore & VertexIndexStore
KeyColumnValueStore idStore = getStore(ID_STORE_NAME);
if (basicMetrics) {
idStore = new MetricInstrumentedStore(idStore, getMetricsStoreName("idStore"));
}
idAuthority = null;
if (storeFeatures.supportsTransactions()) {
idAuthority = new TransactionalIDManager(idStore, storeManager, config);
} else if (storeFeatures.supportsConsistentKeyOperations()) {
idAuthority = new ConsistentKeyIDManager(idStore, storeManager, config);
} else {
throw new IllegalStateException(
"Store needs to support consistent key or transactional operations for ID manager to guarantee proper id allocations");
}
edgeStore = getLockStore(getBufferStore(EDGESTORE_NAME));
vertexIndexStore = getLockStore(getBufferStore(VERTEXINDEX_STORE_NAME));
edgeIndexStore = getLockStore(getBufferStore(EDGEINDEX_STORE_NAME), false);
if (hashPrefixIndex) {
vertexIndexStore = new HashPrefixKeyColumnValueStore(vertexIndexStore, 4);
edgeIndexStore = new HashPrefixKeyColumnValueStore(edgeIndexStore, 4);
}
if (basicMetrics) {
edgeStore = new MetricInstrumentedStore(edgeStore, getMetricsStoreName("edgeStore"));
vertexIndexStore =
new MetricInstrumentedStore(vertexIndexStore, getMetricsStoreName("vertexIndexStore"));
edgeIndexStore =
new MetricInstrumentedStore(edgeIndexStore, getMetricsStoreName("edgeIndexStore"));
}
String version =
BackendOperation.execute(
new Callable<String>() {
@Override
public String call() throws Exception {
String version = storeManager.getConfigurationProperty(TITAN_BACKEND_VERSION);
if (version == null) {
storeManager.setConfigurationProperty(
TITAN_BACKEND_VERSION, TitanConstants.VERSION);
version = TitanConstants.VERSION;
}
return version;
}
@Override
public String toString() {
return "ConfigurationRead";
}
},
config.getLong(SETUP_WAITTIME_KEY, SETUP_WAITTIME_DEFAULT));
Preconditions.checkState(version != null, "Could not read version from storage backend");
if (!TitanConstants.VERSION.equals(version)
&& !TitanConstants.COMPATIBLE_VERSIONS.contains(version)) {
throw new TitanException(
"StorageBackend version is incompatible with current Titan version: "
+ version
+ " vs. "
+ TitanConstants.VERSION);
}
} catch (StorageException e) {
throw new TitanException("Could not initialize backend", e);
}
}