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;
}
public HBaseStoreManager(org.apache.commons.configuration.Configuration config)
throws StorageException {
super(config, PORT_DEFAULT);
this.tableName = config.getString(TABLE_NAME_KEY, TABLE_NAME_DEFAULT);
this.hconf = HBaseConfiguration.create();
for (Map.Entry<String, String> confEntry : HBASE_CONFIGURATION.entrySet()) {
if (config.containsKey(confEntry.getKey())) {
hconf.set(confEntry.getValue(), config.getString(confEntry.getKey()));
}
}
// Copy a subset of our commons config into a Hadoop config
org.apache.commons.configuration.Configuration hbCommons =
config.subset(HBASE_CONFIGURATION_NAMESPACE);
@SuppressWarnings("unchecked") // I hope commons-config eventually fixes this
Iterator<String> keys = hbCommons.getKeys();
int keysLoaded = 0;
while (keys.hasNext()) {
String key = keys.next();
String value = hbCommons.getString(key);
logger.debug("HBase configuration: setting {}={}", key, value);
hconf.set(key, value);
keysLoaded++;
}
logger.debug("HBase configuration: set a total of {} configuration values", keysLoaded);
connectionPool = new HTablePool(hconf, connectionPoolSize);
openStores = new ConcurrentHashMap<String, HBaseKeyColumnValueStore>();
// TODO: allowing publicly mutate fields is bad, should be fixed
features = new StoreFeatures();
features.supportsScan = true;
features.supportsBatchMutation = true;
features.supportsTransactions = false;
features.supportsConsistentKeyOperations = true;
features.supportsLocking = false;
features.isKeyOrdered = false;
features.isDistributed = true;
features.hasLocalKeyPartition = false;
}
/**
* 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);
}
/**
* 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);
}
}
