Exemple #1
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;
 }
  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;
  }
Exemple #3
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);
  }
Exemple #4
0
  /**
   * 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);
    }
  }