Package org.infinispan.distribution.ch.impl

Class ScatteredConsistentHash

java.lang.Object
org.infinispan.distribution.ch.impl.AbstractConsistentHash
org.infinispan.distribution.ch.impl.ScatteredConsistentHash
All Implemented Interfaces:
ConsistentHash
@Immutable public class ScatteredConsistentHash extends AbstractConsistentHash
CH used by scattered caches. Allows no owners for segments (until the CH is balanced). We cannot have an owner for each segment assigned all the time, because after one node crashes, ConsistentHashFactory.updateMembers(CH, java.util.List<org.infinispan.remoting.transport.Address>, java.util.Map<org.infinispan.remoting.transport.Address, java.lang.Float>) is called and the result is sent in CH_UPDATE. Such topology is installed and later during rebalance, a diff of segments between the installed and new (rebalancing) topology is computed. If we assigned all the owners right in updateMembers, this diff would be empty.
Since:
9.1

  • Constructor Details

    • ScatteredConsistentHash

      public ScatteredConsistentHash(int numSegments, List<Address> members, Map<Address,Float> capacityFactors, Address[] segmentOwners, boolean isRebalanced)

  • Method Details

    • getNumSegments

      public int getNumSegments()
      Returns:
      The actual number of hash space segments. Note that it may not be the same as the number of segments passed in at creation time.

    • getSegmentsForOwner

      public Set<Integer> getSegmentsForOwner(Address owner)
      Description copied from interface: ConsistentHash
      Returns the segments owned by a cache member.
      Parameters:
      owner - the address of the member
      Returns:
      a non-null set of segment IDs, may or may not be unmodifiable, which shouldn't be modified by caller. The set is empty if owner is not a member of the consistent hash.

    • getPrimarySegmentsForOwner

      public Set<Integer> getPrimarySegmentsForOwner(Address owner)
      Description copied from interface: ConsistentHash
      Returns the segments that this cache member is the primary owner for.
      Parameters:
      owner - the address of the member
      Returns:
      a non-null set of segment IDs, may or may not be unmodifiable, which shouldn't be modified by caller. The set is empty if owner is not a member of the consistent hash.

    • locateOwnersForSegment

      public List<Address> locateOwnersForSegment(int segmentId)
      Returns:
      All the nodes that own a given hash space segment, first address is the primary owner. The returned list is unmodifiable.

    • locatePrimaryOwnerForSegment

      public Address locatePrimaryOwnerForSegment(int segmentId)
      Returns:
      The primary owner of a given hash space segment. This is equivalent to locateOwnersForSegment(segmentId).get(0) but is more efficient

    • isSegmentLocalToNode

      public boolean isSegmentLocalToNode(Address nodeAddress, int segmentId)
      Description copied from interface: ConsistentHash
      Check if a segment is local to a given member.

      Implementation note: normally key-based method are implemented based on segment-based methods. Here, however, we need a default implementation for the segment-based method for backwards-compatibility reasons.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

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

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • getRoutingTableAsString

      public String getRoutingTableAsString()
      Description copied from interface: ConsistentHash
      Returns a string containing all the segments and their associated addresses.

    • union

      public ScatteredConsistentHash union(ScatteredConsistentHash sch2)
      Prefers owners from the second hash -> effectively this will make pendingCH == unionCH (I think)

    • toScopedState

      public void toScopedState(ScopedPersistentState state)
      Description copied from interface: ConsistentHash
      Writes this ConsistentHash to the specified scoped state. Before invoking this method, the ConsistentHash addresses will have to be replaced with their corresponding PersistentUUIDs
      Specified by:
      toScopedState in interface ConsistentHash
      Overrides:
      toScopedState in class AbstractConsistentHash
      Parameters:
      state - the state to which this ConsistentHash will be written

    • remapAddresses

      public ConsistentHash remapAddresses(UnaryOperator<Address> remapper)
      Description copied from interface: ConsistentHash
      Returns a new ConsistentHash with the addresses remapped according to the provided UnaryOperator. If an address cannot me remapped (i.e. the remapper returns null) this method should return null.
      Parameters:
      remapper - the remapper which given an address replaces it with another one
      Returns:
      the remapped ConsistentHash or null if one of the remapped addresses is null