Package com.datastax.driver.core.policies

Class RackAwareRoundRobinPolicy

  • All Implemented Interfaces:
    LoadBalancingPolicy
    public class RackAwareRoundRobinPolicy
extends Object
implements LoadBalancingPolicy
    A rack aware Round-robin load balancing policy.

    This policy provides round-robin queries over the node of the local rack. After that, the query plan includes round-robin list of nodes in the local DC (but not in local rack). It also includes in the query plans returned a configurable number of hosts in the remote data centers, but those are always tried after the local nodes. In other words, this policy guarantees that no host in a remote data center will be queried unless no host in the local data center can be reached.

    For LWT (Lightweight Transaction) queries (where Statement.isLWT() returns true), the policy skips local rack prioritization and treats all hosts in the local datacenter equally, distributing queries in round-robin fashion across the entire local DC. Remote datacenters are still only used as fallback after all local DC hosts have been tried.

    • Constructor Detail

      • RackAwareRoundRobinPolicy

        public RackAwareRoundRobinPolicy​(String localDc,
                                 String localRack,
                                 int usedHostsPerRemoteDc,
                                 boolean allowRemoteDCsForLocalConsistencyLevel,
                                 boolean allowEmptyLocalDc,
                                 boolean allowEmptyLocalRack)

    • Method Detail

      • getLocalDc

        @Beta
public String getLocalDc()
        The datacenter this policy considers local, or null if it has neither been configured explicitly nor inferred yet. When isLocalDcExplicit() is false, this is the datacenter inferred from the first contacted node, which is only available once the policy has been initialized.
        Returns:
        the local datacenter name, or null.

      • getLocalRack

        @Beta
public String getLocalRack()
        The rack this policy considers local, or null if it has neither been configured explicitly nor inferred yet.
        Returns:
        the local rack name, or null.

      • isLocalDcExplicit

        @Beta
public boolean isLocalDcExplicit()
        Whether the local datacenter was configured explicitly (as opposed to being inferred from the first contacted node).
        Returns:
        true if the local datacenter was set explicitly.

      • isLocalRackExplicit

        @Beta
public boolean isLocalRackExplicit()
        Whether the local rack was configured explicitly (as opposed to being inferred from the first contacted node).
        Returns:
        true if the local rack was set explicitly.

      • init

        public void init​(Cluster cluster,
                 Collection<Host> hosts)
        Description copied from interface: LoadBalancingPolicy
        Initialize this load balancing policy.

        Note that the driver guarantees that it will call this method exactly once per policy object and will do so before any call to another of the methods of the policy.

        Specified by:
        init in interface LoadBalancingPolicy
        Parameters:
        cluster - the Cluster instance for which the policy is created.
        hosts - the initial hosts to use.

      • distance

        public HostDistance distance​(Host host)
        Return the HostDistance for the provided host.

        This policy consider nodes in the local datacenter as LOCAL. For each remote datacenter, it considers a configurable number of hosts as REMOTE and the rest is IGNORED.

        To configure how many hosts in each remote datacenter should be considered, see RackAwareRoundRobinPolicy.Builder.withUsedHostsPerRemoteDc(int).

        Specified by:
        distance in interface LoadBalancingPolicy
        Parameters:
        host - the host of which to return the distance of.
        Returns:
        the HostDistance to host.

      • newQueryPlan

        public Iterator<Host> newQueryPlan​(String loggedKeyspace,
                                   Statement statement)
        Returns the hosts to use for a new query.

        The returned plan will always try each known host in the local rack first, and then, if none of the host in local rack are reachable, will try hosts in remote racks of the local datacenter. Finally, it will try up to a configurable number of other host per remote datacenter. The order of the local node in the returned query plan will follow a Round-robin algorithm.

        Specified by:
        newQueryPlan in interface LoadBalancingPolicy
        Parameters:
        loggedKeyspace - the keyspace currently logged in on for this query.
        statement - the query for which to build the plan.
        Returns:
        a new query plan, i.e. an iterator indicating which host to try first for querying, which one to use as failover, etc...

      • onUp

        public void onUp​(Host host)
        Description copied from interface: LoadBalancingPolicy
        Called when a node is determined to be up.
        Specified by:
        onUp in interface LoadBalancingPolicy
        Parameters:
        host - the host that has been detected up.

      • onDown

        public void onDown​(Host host)
        Description copied from interface: LoadBalancingPolicy
        Called when a node is determined to be down.
        Specified by:
        onDown in interface LoadBalancingPolicy
        Parameters:
        host - the host that has been detected down.

      • onAdd

        public void onAdd​(Host host)
        Description copied from interface: LoadBalancingPolicy
        Called when a new node is added to the cluster.

        The newly added node should be considered up.

        Specified by:
        onAdd in interface LoadBalancingPolicy
        Parameters:
        host - the host that has been newly added.

      • close

        public void close()
        Description copied from interface: LoadBalancingPolicy
        Gets invoked at cluster shutdown.

        This gives the policy the opportunity to perform some cleanup, for instance stop threads that it might have started.

        Specified by:
        close in interface LoadBalancingPolicy