Examples with ConsistentHash org.infinispan.distribution.ch.ConsistentHash used on opensource projects

Example 1 with ConsistentHash

use of org.infinispan.distribution.ch.ConsistentHash in project wildfly by wildfly.

the class CacheRegistry method topologyChanged.

@TopologyChanged
public void topologyChanged(TopologyChangedEvent<Node, Map.Entry<K, V>> event) {
    if (event.isPre())
        return;
    ConsistentHash previousHash = event.getConsistentHashAtStart();
    List<Address> previousMembers = previousHash.getMembers();
    ConsistentHash hash = event.getConsistentHashAtEnd();
    List<Address> members = hash.getMembers();
    Address localAddress = event.getCache().getCacheManager().getAddress();
    // Determine which nodes have left the cache view
    Set<Address> addresses = new HashSet<>(previousMembers);
    addresses.removeAll(members);
    try {
        this.topologyChangeExecutor.submit(() -> {
            if (!addresses.isEmpty()) {
                // We're only interested in the entries for which we are the primary owner
                List<Node> nodes = addresses.stream().filter(address -> hash.locatePrimaryOwner(address).equals(localAddress)).map(address -> this.factory.createNode(address)).collect(Collectors.toList());
                if (!nodes.isEmpty()) {
                    Cache<Node, Map.Entry<K, V>> cache = this.cache.getAdvancedCache().withFlags(Flag.FORCE_SYNCHRONOUS);
                    Map<K, V> removed = new HashMap<>();
                    try (Batch batch = this.batcher.createBatch()) {
                        for (Node node : nodes) {
                            Map.Entry<K, V> old = cache.remove(node);
                            if (old != null) {
                                removed.put(old.getKey(), old.getValue());
                            }
                        }
                    } catch (CacheException e) {
                        ClusteringServerLogger.ROOT_LOGGER.registryPurgeFailed(e, this.cache.getCacheManager().toString(), this.cache.getName(), nodes);
                    }
                    // Invoke listeners outside above tx context
                    if (!removed.isEmpty()) {
                        this.notifyListeners(Event.Type.CACHE_ENTRY_REMOVED, removed);
                    }
                }
            } else {
                // This is a merge after cluster split: re-populate the cache registry with lost registry entries
                if (!previousMembers.contains(localAddress)) {
                    // If this node is not a member at merge start, its mapping is lost and needs to be recreated and listeners notified
                    try {
                        this.populateRegistry();
                        // Local cache events do not trigger notifications
                        this.notifyListeners(Event.Type.CACHE_ENTRY_CREATED, this.entry);
                    } catch (CacheException e) {
                        ClusteringServerLogger.ROOT_LOGGER.failedToRestoreLocalRegistryEntry(e, this.cache.getCacheManager().toString(), this.cache.getName());
                    }
                }
            }
        });
    } catch (RejectedExecutionException e) {
    // Executor was shutdown
    }
}

Example 2 with ConsistentHash

use of org.infinispan.distribution.ch.ConsistentHash in project hibernate-orm by hibernate.

the class UnorderedDistributionInterceptor method visitPutKeyValueCommand.

@Override
public Object visitPutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand command) throws Throwable {
    if (command.hasFlag(Flag.CACHE_MODE_LOCAL)) {
        // for state-transfer related writes
        return invokeNextInterceptor(ctx, command);
    }
    int commandTopologyId = command.getTopologyId();
    int currentTopologyId = stateTransferManager.getCacheTopology().getTopologyId();
    if (commandTopologyId != -1 && currentTopologyId != commandTopologyId) {
        throw new OutdatedTopologyException("Cache topology changed while the command was executing: expected " + commandTopologyId + ", got " + currentTopologyId);
    }
    ConsistentHash writeCH = distributionManager.getWriteConsistentHash();
    List<Address> owners = null;
    if (writeCH.isReplicated()) {
        // local result is always ignored
        invokeNextInterceptor(ctx, command);
    } else {
        owners = writeCH.locateOwners(command.getKey());
        if (owners.contains(rpcManager.getAddress())) {
            invokeNextInterceptor(ctx, command);
        } else {
            log.tracef("Not invoking %s on %s since it is not an owner", command, rpcManager.getAddress());
        }
    }
    if (ctx.isOriginLocal() && command.isSuccessful()) {
        // unlocking (and committing) the entry.
        return rpcManager.invokeRemotelyAsync(owners, command, isSynchronous(command) ? syncRpcOptions : asyncRpcOptions);
    }
    return null;
}