示例#1
0
 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);
 }
示例#2
0
 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;
 }
示例#3
0
 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;
 }
示例#4
0
  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;
  }
示例#5
0
  /**
   * 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);
  }
示例#6
0
  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;
    }
  }