private void parseLocking(XMLExtendedStreamReader reader, ModelNode locking)
     throws XMLStreamException {
   for (int i = 0; i < reader.getAttributeCount(); i++) {
     String value = reader.getAttributeValue(i);
     Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
     switch (attribute) {
       case ISOLATION:
         {
           try {
             IsolationLevel level = IsolationLevel.valueOf(value);
             locking.get(ModelKeys.ISOLATION).set(level.name());
           } catch (IllegalArgumentException e) {
             throw ParseUtils.invalidAttributeValue(reader, i);
           }
           break;
         }
       case STRIPING:
         {
           locking.get(ModelKeys.STRIPING).set(Boolean.parseBoolean(value));
           break;
         }
       case ACQUIRE_TIMEOUT:
         {
           locking.get(ModelKeys.ACQUIRE_TIMEOUT).set(Long.parseLong(value));
           break;
         }
       case CONCURRENCY_LEVEL:
         {
           locking.get(ModelKeys.CONCURRENCY_LEVEL).set(Integer.parseInt(value));
           break;
         }
       default:
         {
           throw ParseUtils.unexpectedAttribute(reader, i);
         }
     }
   }
   ParseUtils.requireNoContent(reader);
 }
Exemple #2
0
  /**
   * Create a Configuration object initialized from the operation ModelNode
   *
   * @param containerName the name of the cache container
   * @param cache ModelNode representing cache configuration
   * @param builder ConfigurationBuilder object to add data to
   * @return initialised Configuration object
   */
  void processModelNode(
      OperationContext context,
      String containerName,
      ModelNode cache,
      ConfigurationBuilder builder,
      List<Dependency<?>> dependencies)
      throws OperationFailedException {

    final Indexing indexing =
        Indexing.valueOf(
            CommonAttributes.INDEXING.resolveModelAttribute(context, cache).asString());
    final boolean batching =
        CommonAttributes.BATCHING.resolveModelAttribute(context, cache).asBoolean();

    // set the cache mode (may be modified when setting up clustering attributes)
    builder.clustering().cacheMode(this.mode);
    final ModelNode indexingPropertiesModel =
        CommonAttributes.INDEXING_PROPERTIES.resolveModelAttribute(context, cache);
    Properties indexingProperties = new Properties();
    if (indexing.isEnabled() && indexingPropertiesModel.isDefined()) {
      for (Property p : indexingPropertiesModel.asPropertyList()) {
        String value = p.getValue().asString();
        indexingProperties.put(p.getName(), value);
      }
    }
    builder
        .indexing()
        .enabled(indexing.isEnabled())
        .indexLocalOnly(indexing.isLocalOnly())
        .withProperties(indexingProperties);

    // locking is a child resource
    if (cache.hasDefined(ModelKeys.LOCKING)
        && cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME).isDefined()) {
      ModelNode locking = cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME);

      final IsolationLevel isolationLevel =
          IsolationLevel.valueOf(
              CommonAttributes.ISOLATION.resolveModelAttribute(context, locking).asString());
      final boolean striping =
          CommonAttributes.STRIPING.resolveModelAttribute(context, locking).asBoolean();
      final long acquireTimeout =
          CommonAttributes.ACQUIRE_TIMEOUT.resolveModelAttribute(context, locking).asLong();
      final int concurrencyLevel =
          CommonAttributes.CONCURRENCY_LEVEL.resolveModelAttribute(context, locking).asInt();

      builder
          .locking()
          .isolationLevel(isolationLevel)
          .useLockStriping(striping)
          .lockAcquisitionTimeout(acquireTimeout)
          .concurrencyLevel(concurrencyLevel);
    }

    TransactionMode txMode = TransactionMode.NONE;
    LockingMode lockingMode = LockingMode.OPTIMISTIC;
    // locking is a child resource
    if (cache.hasDefined(ModelKeys.TRANSACTION)
        && cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME).isDefined()) {
      ModelNode transaction = cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME);

      final long stopTimeout =
          CommonAttributes.STOP_TIMEOUT.resolveModelAttribute(context, transaction).asLong();
      txMode =
          TransactionMode.valueOf(
              CommonAttributes.MODE.resolveModelAttribute(context, transaction).asString());
      lockingMode =
          LockingMode.valueOf(
              CommonAttributes.LOCKING.resolveModelAttribute(context, transaction).asString());

      builder.transaction().cacheStopTimeout(stopTimeout);
    }
    builder
        .transaction()
        .transactionMode(txMode.getMode())
        .lockingMode(lockingMode)
        .useSynchronization(!txMode.isXAEnabled())
        .recovery()
        .enabled(txMode.isRecoveryEnabled());
    if (txMode.isRecoveryEnabled()) {
      builder.transaction().syncCommitPhase(true).syncRollbackPhase(true);
    }

    if (batching) {
      builder
          .transaction()
          .transactionMode(org.infinispan.transaction.TransactionMode.TRANSACTIONAL)
          .invocationBatching()
          .enable();
    } else {
      builder.transaction().invocationBatching().disable();
    }

    // eviction is a child resource
    if (cache.hasDefined(ModelKeys.EVICTION)
        && cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME).isDefined()) {
      ModelNode eviction = cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME);

      final EvictionStrategy strategy =
          EvictionStrategy.valueOf(
              CommonAttributes.EVICTION_STRATEGY
                  .resolveModelAttribute(context, eviction)
                  .asString());
      builder.eviction().strategy(strategy);

      if (strategy.isEnabled()) {
        final int maxEntries =
            CommonAttributes.MAX_ENTRIES.resolveModelAttribute(context, eviction).asInt();
        builder.eviction().maxEntries(maxEntries);
      }
    }
    // expiration is a child resource
    if (cache.hasDefined(ModelKeys.EXPIRATION)
        && cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME).isDefined()) {

      ModelNode expiration = cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME);

      final long maxIdle =
          CommonAttributes.MAX_IDLE.resolveModelAttribute(context, expiration).asLong();
      final long lifespan =
          CommonAttributes.LIFESPAN.resolveModelAttribute(context, expiration).asLong();
      final long interval =
          CommonAttributes.INTERVAL.resolveModelAttribute(context, expiration).asLong();

      builder.expiration().maxIdle(maxIdle).lifespan(lifespan).wakeUpInterval(interval);
      // Only enable the reaper thread if we need it
      if ((maxIdle > 0) || (lifespan > 0)) {
        builder.expiration().enableReaper();
      } else {
        builder.expiration().disableReaper();
      }
    }

    // stores are a child resource
    String storeKey = this.findStoreKey(cache);
    if (storeKey != null) {
      ModelNode store = this.getStoreModelNode(cache);

      final boolean shared =
          CommonAttributes.SHARED.resolveModelAttribute(context, store).asBoolean();
      final boolean preload =
          CommonAttributes.PRELOAD.resolveModelAttribute(context, store).asBoolean();
      final boolean passivation =
          CommonAttributes.PASSIVATION.resolveModelAttribute(context, store).asBoolean();
      final boolean fetchState =
          CommonAttributes.FETCH_STATE.resolveModelAttribute(context, store).asBoolean();
      final boolean purge =
          CommonAttributes.PURGE.resolveModelAttribute(context, store).asBoolean();
      final boolean singleton =
          CommonAttributes.SINGLETON.resolveModelAttribute(context, store).asBoolean();
      final boolean async =
          store.hasDefined(ModelKeys.WRITE_BEHIND)
              && store.get(ModelKeys.WRITE_BEHIND, ModelKeys.WRITE_BEHIND_NAME).isDefined();

      builder.loaders().shared(shared).preload(preload).passivation(passivation);
      LoaderConfigurationBuilder storeBuilder =
          builder
              .loaders()
              .addCacheLoader()
              .fetchPersistentState(fetchState)
              .purgeOnStartup(purge)
              .purgeSynchronously(true);
      storeBuilder.singletonStore().enabled(singleton);

      if (async) {
        ModelNode writeBehind = store.get(ModelKeys.WRITE_BEHIND, ModelKeys.WRITE_BEHIND_NAME);
        storeBuilder
            .async()
            .enable()
            .flushLockTimeout(
                CommonAttributes.FLUSH_LOCK_TIMEOUT
                    .resolveModelAttribute(context, writeBehind)
                    .asLong())
            .modificationQueueSize(
                CommonAttributes.MODIFICATION_QUEUE_SIZE
                    .resolveModelAttribute(context, writeBehind)
                    .asInt())
            .shutdownTimeout(
                CommonAttributes.SHUTDOWN_TIMEOUT
                    .resolveModelAttribute(context, writeBehind)
                    .asLong())
            .threadPoolSize(
                CommonAttributes.THREAD_POOL_SIZE
                    .resolveModelAttribute(context, writeBehind)
                    .asInt());
      }

      this.buildCacheStore(context, storeBuilder, containerName, store, storeKey, dependencies);
    }
  }
Exemple #3
0
  /**
   * Create a Configuration object initialized from the operation ModelNode
   *
   * @param cache ModelNode representing cache configuration
   * @param builder ConfigurationBuilder object to add data to
   * @return initialised Configuration object
   */
  void processModelNode(
      ModelNode cache, ConfigurationBuilder builder, List<Dependency<?>> dependencies) {

    String cacheName = cache.require(ModelKeys.NAME).asString();

    builder.classLoader(this.getClass().getClassLoader());
    builder
        .clustering()
        .cacheMode(CacheMode.valueOf(cache.require(ModelKeys.CACHE_MODE).asString()));

    if (cache.hasDefined(ModelKeys.INDEXING)) {
      Indexing indexing = Indexing.valueOf(cache.get(ModelKeys.INDEXING).asString());
      builder.indexing().enabled(indexing.isEnabled()).indexLocalOnly(indexing.isLocalOnly());
    }
    if (cache.hasDefined(ModelKeys.QUEUE_SIZE)) {
      int size = cache.get(ModelKeys.QUEUE_SIZE).asInt();
      builder.clustering().async().replQueueMaxElements(size).useReplQueue(size > 0);
    }
    if (cache.hasDefined(ModelKeys.QUEUE_FLUSH_INTERVAL)) {
      builder
          .clustering()
          .async()
          .replQueueInterval(cache.get(ModelKeys.QUEUE_FLUSH_INTERVAL).asLong());
    }
    if (cache.hasDefined(ModelKeys.REMOTE_TIMEOUT)) {
      builder.clustering().sync().replTimeout(cache.get(ModelKeys.REMOTE_TIMEOUT).asLong());
    }
    if (cache.hasDefined(ModelKeys.OWNERS)) {
      builder.clustering().hash().numOwners(cache.get(ModelKeys.OWNERS).asInt());
    }
    if (cache.hasDefined(ModelKeys.VIRTUAL_NODES)) {
      builder.clustering().hash().numVirtualNodes(cache.get(ModelKeys.VIRTUAL_NODES).asInt());
    }
    if (cache.hasDefined(ModelKeys.L1_LIFESPAN)) {
      long lifespan = cache.get(ModelKeys.L1_LIFESPAN).asLong();
      if (lifespan > 0) {
        builder.clustering().l1().enable().lifespan(lifespan);
      } else {
        builder.clustering().l1().disable();
      }
    }

    // locking is a child resource
    if (cache.hasDefined(ModelKeys.LOCKING)
        && cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME).isDefined()) {
      ModelNode locking = cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME);
      if (locking.hasDefined(ModelKeys.ISOLATION)) {
        builder
            .locking()
            .isolationLevel(IsolationLevel.valueOf(locking.get(ModelKeys.ISOLATION).asString()));
      }
      if (locking.hasDefined(ModelKeys.STRIPING)) {
        builder.locking().useLockStriping(locking.get(ModelKeys.STRIPING).asBoolean());
      }
      if (locking.hasDefined(ModelKeys.ACQUIRE_TIMEOUT)) {
        builder.locking().lockAcquisitionTimeout(locking.get(ModelKeys.ACQUIRE_TIMEOUT).asLong());
      }
      if (locking.hasDefined(ModelKeys.CONCURRENCY_LEVEL)) {
        builder.locking().concurrencyLevel(locking.get(ModelKeys.CONCURRENCY_LEVEL).asInt());
      }
    }

    TransactionMode txMode = TransactionMode.NONE;
    LockingMode lockingMode = LockingMode.OPTIMISTIC;
    // locking is a child resource
    if (cache.hasDefined(ModelKeys.TRANSACTION)
        && cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME).isDefined()) {
      ModelNode transaction = cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME);
      if (transaction.hasDefined(ModelKeys.STOP_TIMEOUT)) {
        builder.transaction().cacheStopTimeout(transaction.get(ModelKeys.STOP_TIMEOUT).asLong());
      }
      if (transaction.hasDefined(ModelKeys.MODE)) {
        txMode = TransactionMode.valueOf(transaction.get(ModelKeys.MODE).asString());
      }
      if (transaction.hasDefined(ModelKeys.LOCKING)) {
        lockingMode = LockingMode.valueOf(transaction.get(ModelKeys.LOCKING).asString());
      }
    }
    builder
        .transaction()
        .transactionMode(txMode.getMode())
        .lockingMode(lockingMode)
        .useSynchronization(!txMode.isXAEnabled())
        .recovery()
        .enabled(txMode.isRecoveryEnabled());
    if (txMode.isRecoveryEnabled()) {
      builder.transaction().syncCommitPhase(true).syncRollbackPhase(true);
    }
    if (cache.hasDefined(ModelKeys.BATCHING)) {
      InvocationBatchingConfigurationBuilder batchingBuilder =
          builder
              .transaction()
              .transactionMode(org.infinispan.transaction.TransactionMode.TRANSACTIONAL)
              .invocationBatching();
      if (cache.get(ModelKeys.BATCHING).asBoolean()) {
        batchingBuilder.enable();
      } else {
        batchingBuilder.disable();
      }
    }
    // eviction is a child resource
    if (cache.hasDefined(ModelKeys.EVICTION)
        && cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME).isDefined()) {
      ModelNode eviction = cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME);

      if (eviction.hasDefined(ModelKeys.STRATEGY)) {
        builder
            .eviction()
            .strategy(EvictionStrategy.valueOf(eviction.get(ModelKeys.STRATEGY).asString()));
      }
      if (eviction.hasDefined(ModelKeys.MAX_ENTRIES)) {
        builder.eviction().maxEntries(eviction.get(ModelKeys.MAX_ENTRIES).asInt());
      }
    }
    // expiration is a child resource
    if (cache.hasDefined(ModelKeys.EXPIRATION)
        && cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME).isDefined()) {
      ModelNode expiration = cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME);
      if (expiration.hasDefined(ModelKeys.MAX_IDLE)) {
        builder.expiration().maxIdle(expiration.get(ModelKeys.MAX_IDLE).asLong());
      }
      if (expiration.hasDefined(ModelKeys.LIFESPAN)) {
        builder.expiration().lifespan(expiration.get(ModelKeys.LIFESPAN).asLong());
      }
      if (expiration.hasDefined(ModelKeys.INTERVAL)) {
        builder.expiration().wakeUpInterval(expiration.get(ModelKeys.INTERVAL).asLong());
      }
    }

    String storeKey = this.findStoreKey(cache);
    if (storeKey != null) {
      ModelNode store = this.getStoreModelNode(cache);
      builder
          .loaders()
          .shared(
              store.hasDefined(ModelKeys.SHARED) ? store.get(ModelKeys.SHARED).asBoolean() : false)
          .preload(
              store.hasDefined(ModelKeys.PRELOAD)
                  ? store.get(ModelKeys.PRELOAD).asBoolean()
                  : false)
          .passivation(
              store.hasDefined(ModelKeys.PASSIVATION)
                  ? store.get(ModelKeys.PASSIVATION).asBoolean()
                  : true);
      LoaderConfigurationBuilder storeBuilder =
          builder
              .loaders()
              .addCacheLoader()
              .fetchPersistentState(
                  store.hasDefined(ModelKeys.FETCH_STATE)
                      ? store.get(ModelKeys.FETCH_STATE).asBoolean()
                      : true)
              .purgeOnStartup(
                  store.hasDefined(ModelKeys.PURGE) ? store.get(ModelKeys.PURGE).asBoolean() : true)
              .purgeSynchronously(true);
      storeBuilder
          .singletonStore()
          .enabled(
              store.hasDefined(ModelKeys.SINGLETON)
                  ? store.get(ModelKeys.SINGLETON).asBoolean()
                  : false);
      this.buildCacheStore(storeBuilder, cacheName, store, storeKey, dependencies);
    }
  }