Package org.infinispan.distribution.ch.impl

Class DefaultConsistentHashFactory

java.lang.Object
org.infinispan.distribution.ch.impl.AbstractConsistentHashFactory<DefaultConsistentHash>
org.infinispan.distribution.ch.impl.DefaultConsistentHashFactory
All Implemented Interfaces:
ConsistentHashFactory<DefaultConsistentHash>
Direct Known Subclasses:
TopologyAwareConsistentHashFactory
public class DefaultConsistentHashFactory extends AbstractConsistentHashFactory<DefaultConsistentHash>
Default implementation of ConsistentHashFactory. All methods except union(DefaultConsistentHash, DefaultConsistentHash) return a consistent hash with floor(numOwners*numSegments/numNodes) <= segments per owner <= ceil(numOwners*numSegments/numNodes).
Since:
5.2
Author:
Dan Berindei, anistor@redhat.com

  • Constructor Details

    • DefaultConsistentHashFactory

      public DefaultConsistentHashFactory()

  • Method Details

    • create

      public DefaultConsistentHash create(int numOwners, int numSegments, List<Address> members, Map<Address,Float> capacityFactors)
      Description copied from interface: ConsistentHashFactory
      Create a new consistent hash instance. The consistent hash will be balanced.
      Parameters:
      numOwners - The ideal number of owners for each key. The created consistent hash can have more or less owners, but each key will have at least one owner.
      numSegments - Number of hash-space segments. The implementation may round up the number of segments for performance, or may ignore the parameter altogether.
      members - A list of addresses representing the new cache members.
      capacityFactors - The capacity factor of each member. Determines the relative capacity of each node compared to the others. The implementation may ignore this parameter. If null, all the members are assumed to have a capacity factor of 1.

    • fromPersistentState

      public DefaultConsistentHash fromPersistentState(ScopedPersistentState state)
      Description copied from interface: ConsistentHashFactory
      Recreates a ConsistentHash from a previously stored persistent state. The returned ConsistentHash will not have proper addresses, but PersistentUUIDs instead so they will need to be replaced
      Parameters:
      state - the state to restore

    • updateMembers

      public DefaultConsistentHash updateMembers(DefaultConsistentHash baseCH, List<Address> actualMembers, Map<Address,Float> actualCapacityFactors)
      Leavers are removed and segments without owners are assigned new owners. Joiners might get some of the un-owned segments but otherwise they are not taken into account (that should happen during a rebalance).
      Parameters:
      baseCH - An existing consistent hash instance, should not be null
      actualMembers - A list of addresses representing the new cache members.
      actualCapacityFactors - The capacity factor of each member. Determines the relative capacity of each node compared to the others. The implementation may ignore this parameter. If null, all the members are assumed to have a capacity factor of 1.
      Returns:

    • rebalance

      public DefaultConsistentHash rebalance(DefaultConsistentHash baseCH)
      Description copied from interface: ConsistentHashFactory
      Create a new consistent hash instance, based on an existing instance, but balanced according to the implementation's rules.
      Parameters:
      baseCH - An existing consistent hash instance, should not be null
      Returns:
      A new ConsistentHash instance, or baseCH if the existing instance does not need any changes.

    • union

      public DefaultConsistentHash union(DefaultConsistentHash dch1, DefaultConsistentHash dch2)
      Merges two consistent hash objects that have the same number of segments, numOwners and hash function. For each segment, the primary owner of the first CH has priority, the other primary owners become backups.

    • rebalanceBuilder

      protected void rebalanceBuilder(DefaultConsistentHashFactory.Builder builder)

    • addPrimaryOwners

      protected void addPrimaryOwners(DefaultConsistentHashFactory.Builder builder)

    • replacePrimaryOwners

      protected void replacePrimaryOwners(DefaultConsistentHashFactory.Builder builder, int maxOwners)

    • swapPrimaryOwnersWithBackups

      protected void swapPrimaryOwnersWithBackups(DefaultConsistentHashFactory.Builder builder)

    • addBackupOwners

      protected void addBackupOwners(DefaultConsistentHashFactory.Builder builder)

    • removeExtraBackupOwners

      protected void removeExtraBackupOwners(DefaultConsistentHashFactory.Builder builder)

    • doAddBackupOwners

      protected void doAddBackupOwners(DefaultConsistentHashFactory.Builder builder)

    • replaceBackupOwners

      protected void replaceBackupOwners(DefaultConsistentHashFactory.Builder builder)

    • findNewBackupOwner

      protected Address findNewBackupOwner(DefaultConsistentHashFactory.Builder builder, Collection<Address> excludes, Address owner)
      Returns:
      The member with the worst owned segments/capacity ratio that is also not in the excludes list.

    • equals

      public boolean equals(Object other)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object