loadbalancer

abstract class DistributorT[Node] extends AnyRef

The base type of the load balancer distributor.
The base type of the load balancer distributor. Distributors are updated nondestructively, but, as with nodes, may share some data across updates.

Attributes
protected
class HeapBalancer[Req, Rep] extends ServiceFactory[Req, Rep] with OnReady

An efficient load balancer that operates on Activity[Set[ServiceFactory[Req, Rep]]].
abstract class LoadBalancerFactory extends AnyRef

A thin interface around a Balancer's constructor that allows Finagle to pass in context from the stack to the balancers at construction time.
A thin interface around a Balancer's constructor that allows Finagle to pass in context from the stack to the balancers at construction time.

See also
The user guide for more details.
Balancers for a collection of available balancers.
trait NodeT[Req, Rep] extends ServiceFactory[Req, Rep]

The base type of nodes over which load is balanced.
The base type of nodes over which load is balanced. Nodes define the load metric that is used; distributors like P2C will use these to decide where to balance the next request.

Attributes
protected
class RoundRobinBalancer[Req, Rep] extends ServiceFactory[Req, Rep] with Balancer[Req, Rep] with Updating[Req, Rep]

A simple round robin balancer that chooses the next backend in the list for each request.

object Aperture
object Balancers

Constructor methods for various load balancers.
Constructor methods for various load balancers. The methods take balancer specific parameters and return a LoadBalancerFactory that allows you to easily inject a balancer into the Finagle stack via client configuration.

See also
The user guide for more details.
object ConcurrentLoadBalancerFactory

A load balancer that balances among multiple connections, useful for managing concurrency in pipelining protocols.
A load balancer that balances among multiple connections, useful for managing concurrency in pipelining protocols.
Each endpoint can open multiple connections. For N endpoints, each opens M connections, load balancer balances among N*M options. Thus, it increases concurrency of each endpoint.
object DefaultBalancerFactory extends LoadBalancerFactory
object HeapBalancer
object LoadBalancerFactory
object defaultBalancer extends GlobalFlag[String]

We expose the ability to configure balancers per-process via flags.
We expose the ability to configure balancers per-process via flags. 'heap', 'choice', and 'aperture' are valid choices for defaultBalancer. However, using this is generally not a good idea, as Finagle processes usually contain many clients. To configure the load balancer method on a client, use the configured method like so:
{{ val balancer = Balancers.aperture(...) Protocol.configured(LoadBalancerFactory.Param(balancer)) }}
package exp
object perHostStats extends GlobalFlag[Boolean]