public static List createTopologyAwareCacheNodes(
      int numberOfNodes,
      CacheMode cacheMode,
      boolean transactional,
      boolean indexLocalOnly,
      boolean isRamDirectoryProvider) {
    List caches = new ArrayList();

    ConfigurationBuilder builder =
        AbstractCacheTest.getDefaultClusteredCacheConfig(cacheMode, transactional);

    builder.indexing().enable().indexLocalOnly(indexLocalOnly);

    if (isRamDirectoryProvider) {
      builder
          .indexing()
          .addProperty("default.directory_provider", "ram")
          .addProperty("lucene_version", "LUCENE_CURRENT");
    } else {
      builder
          .indexing()
          .addProperty(
              "hibernate.search.default.indexmanager",
              "org.infinispan.query.indexmanager.InfinispanIndexManager")
          .addProperty("default.directory_provider", "infinispan")
          .addProperty("hibernate.search.default.exclusive_index_use", "false")
          .addProperty("lucene_version", "LUCENE_36");
      if (cacheMode.isClustered()) {
        builder.clustering().stateTransfer().fetchInMemoryState(true);
      }
    }

    for (int i = 0; i < numberOfNodes; i++) {
      GlobalConfigurationBuilder globalConfigurationBuilder =
          GlobalConfigurationBuilder.defaultClusteredBuilder();
      globalConfigurationBuilder.transport().machineId("a" + i).rackId("b" + i).siteId("test" + i);

      EmbeddedCacheManager cm1 =
          TestCacheManagerFactory.createClusteredCacheManager(globalConfigurationBuilder, builder);

      caches.add(cm1.getCache());
    }

    return caches;
  }
예제 #2
0
 public static synchronized Configuration getDefaultConfiguration(CacheMode cacheMode) {
   if (defaults == null) {
     ConfigurationBuilderHolder holder = load(DEFAULTS);
     Configuration defaultConfig = holder.getDefaultConfigurationBuilder().build();
     Map<CacheMode, Configuration> map = new EnumMap<CacheMode, Configuration>(CacheMode.class);
     map.put(defaultConfig.clustering().cacheMode(), defaultConfig);
     for (ConfigurationBuilder builder : holder.getNamedConfigurationBuilders().values()) {
       Configuration config = builder.build();
       map.put(config.clustering().cacheMode(), config);
     }
     for (CacheMode mode : CacheMode.values()) {
       if (!map.containsKey(mode)) {
         map.put(
             mode,
             new ConfigurationBuilder().read(defaultConfig).clustering().cacheMode(mode).build());
       }
     }
     defaults = map;
   }
   return defaults.get(cacheMode);
 }
    @Override
    public Map<String, Number> call() throws Exception {

      Map<String, Number> map = new HashMap<>();
      Stats stats = remoteCache.getStats();
      map.put(AVERAGE_READ_TIME, stats.getAverageReadTime());
      map.put(AVERAGE_WRITE_TIME, stats.getAverageWriteTime());
      map.put(AVERAGE_REMOVE_TIME, stats.getAverageRemoveTime());
      map.put(EVICTIONS, stats.getEvictions());
      map.put(HITS, stats.getHits());
      map.put(MISSES, stats.getMisses());
      final CacheMode cacheMode = getCacheMode(remoteCache);
      // for replicated caches, we don't need to send the number of entries since it is the same in
      // all the nodes.
      if (cacheMode.isDistributed()) {
        map.put(NUMBER_OF_ENTRIES, stats.getCurrentNumberOfEntries() / numOwners());
      } else if (!cacheMode.isReplicated()) {
        map.put(NUMBER_OF_ENTRIES, stats.getCurrentNumberOfEntries());
      }
      map.put(STORES, stats.getStores());
      map.put(REMOVE_HITS, stats.getRemoveHits());
      map.put(REMOVE_MISSES, stats.getRemoveMisses());
      map.put(TIME_SINCE_START, stats.getTimeSinceStart());

      LockManager lockManager = remoteCache.getLockManager();
      map.put(NUMBER_OF_LOCKS_HELD, lockManager.getNumberOfLocksHeld());

      // number of locks available is not exposed through the LockManager interface
      map.put(NUMBER_OF_LOCKS_AVAILABLE, 0);

      // invalidations
      InvalidationInterceptor invalidationInterceptor =
          getFirstInterceptorWhichExtends(remoteCache, InvalidationInterceptor.class);
      if (invalidationInterceptor != null) {
        map.put(INVALIDATIONS, invalidationInterceptor.getInvalidations());
      } else {
        map.put(INVALIDATIONS, 0);
      }

      // passivations
      PassivationManager pManager =
          remoteCache.getComponentRegistry().getComponent(PassivationManager.class);
      if (pManager != null) {
        map.put(PASSIVATIONS, pManager.getPassivations());
      } else {
        map.put(PASSIVATIONS, 0);
      }

      // activations
      ActivationManager aManager =
          remoteCache.getComponentRegistry().getComponent(ActivationManager.class);
      if (pManager != null) {
        map.put(ACTIVATIONS, aManager.getActivationCount());
      } else {
        map.put(ACTIVATIONS, 0);
      }

      // cache loaders
      ActivationInterceptor aInterceptor =
          getFirstInterceptorWhichExtends(remoteCache, ActivationInterceptor.class);
      if (aInterceptor != null) {
        map.put(CACHE_LOADER_LOADS, aInterceptor.getCacheLoaderLoads());
        map.put(CACHE_LOADER_MISSES, aInterceptor.getCacheLoaderMisses());
      } else {
        map.put(CACHE_LOADER_LOADS, 0);
        map.put(CACHE_LOADER_MISSES, 0);
      }
      // cache store
      CacheWriterInterceptor interceptor =
          getFirstInterceptorWhichExtends(remoteCache, CacheWriterInterceptor.class);
      if (interceptor != null) {
        map.put(CACHE_WRITER_STORES, interceptor.getWritesToTheStores());
      } else {
        map.put(CACHE_WRITER_STORES, 0);
      }
      return map;
    }
예제 #4
0
  /**
   * Adds the listener using the provided filter converter and class loader. The provided builder is
   * used to add additional configuration including (clustered, onlyPrimary & identifier) which can
   * be used after this method is completed to see what values were used in the addition of this
   * listener
   *
   * @param listener
   * @param filter
   * @param converter
   * @param classLoader
   * @param <C>
   * @return
   */
  public <C> void addListener(
      Object listener,
      CacheEventFilter<? super K, ? super V> filter,
      CacheEventConverter<? super K, ? super V, C> converter,
      ClassLoader classLoader) {
    Listener l = testListenerClassValidity(listener.getClass());
    UUID generatedId = UUID.randomUUID();
    CacheMode cacheMode = config.clustering().cacheMode();
    CacheInvocationBuilder builder = new CacheInvocationBuilder();
    builder
        .setIncludeCurrentState(l.includeCurrentState())
        .setClustered(l.clustered())
        .setOnlyPrimary(
            l.clustered() ? (cacheMode.isDistributed() ? true : false) : l.primaryOnly())
        .setFilter(filter)
        .setConverter(converter)
        .setIdentifier(generatedId)
        .setClassLoader(classLoader);
    boolean foundMethods = validateAndAddListenerInvocation(listener, builder);

    if (foundMethods && l.clustered()) {
      if (cacheMode.isInvalidation()) {
        throw new UnsupportedOperationException(
            "Cluster listeners cannot be used with Invalidation Caches!");
      } else if (cacheMode.isDistributed()) {
        clusterListenerIDs.put(listener, generatedId);
        EmbeddedCacheManager manager = cache.getCacheManager();
        Address ourAddress = manager.getAddress();

        List<Address> members = manager.getMembers();
        // If we are the only member don't even worry about sending listeners
        if (members != null && members.size() > 1) {
          DistributedExecutionCompletionService decs =
              new DistributedExecutionCompletionService(distExecutorService);

          if (log.isTraceEnabled()) {
            log.tracef(
                "Replicating cluster listener to other nodes %s for cluster listener with id %s",
                members, generatedId);
          }
          Callable callable =
              new ClusterListenerReplicateCallable(
                  generatedId, ourAddress, filter, converter, l.sync());
          for (Address member : members) {
            if (!member.equals(ourAddress)) {
              decs.submit(member, callable);
            }
          }

          for (int i = 0; i < members.size() - 1; ++i) {
            try {
              decs.take().get();
            } catch (InterruptedException e) {
              throw new CacheListenerException(e);
            } catch (ExecutionException e) {
              throw new CacheListenerException(e);
            }
          }

          int extraCount = 0;
          // If anyone else joined since we sent these we have to send the listeners again, since
          // they may have queried
          // before the other nodes got the new listener
          List<Address> membersAfter = manager.getMembers();
          for (Address member : membersAfter) {
            if (!members.contains(member) && !member.equals(ourAddress)) {
              if (log.isTraceEnabled()) {
                log.tracef(
                    "Found additional node %s that joined during replication of cluster listener with id %s",
                    member, generatedId);
              }
              extraCount++;
              decs.submit(member, callable);
            }
          }

          for (int i = 0; i < extraCount; ++i) {
            try {
              decs.take().get();
            } catch (InterruptedException e) {
              throw new CacheListenerException(e);
            } catch (ExecutionException e) {
              throw new CacheListenerException(e);
            }
          }
        }
      }
    }

    // If we have a segment listener handler, it means we have to do initial state
    QueueingSegmentListener handler = segmentHandler.remove(generatedId);
    if (handler != null) {
      if (log.isTraceEnabled()) {
        log.tracef("Listener %s requests initial state for cache", generatedId);
      }
      try (CloseableIterator<CacheEntry<K, C>> iterator =
          entryRetriever.retrieveEntries(
              filter == null ? null : new CacheEventFilterAsKeyValueFilter(filter),
              converter == null ? null : new CacheEventConverterAsConverter(converter),
              null,
              handler)) {
        while (iterator.hasNext()) {
          CacheEntry<K, C> entry = iterator.next();
          // Mark the key as processed and see if we had a concurrent update
          Object value = handler.markKeyAsProcessing(entry.getKey());
          if (value == BaseQueueingSegmentListener.REMOVED) {
            // Don't process this value if we had a concurrent remove
            continue;
          }
          raiseEventForInitialTransfer(generatedId, entry, builder.isClustered());

          handler.notifiedKey(entry.getKey());
        }
      }

      Set<CacheEntry> entries = handler.findCreatedEntries();

      for (CacheEntry entry : entries) {
        raiseEventForInitialTransfer(generatedId, entry, builder.isClustered());
      }

      if (log.isTraceEnabled()) {
        log.tracef("Listener %s initial state for cache completed", generatedId);
      }

      handler.transferComplete();
    }
  }
예제 #5
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);
    }
  }