java.lang.Object
- io.grpc.LoadBalancer
- - io.grpc.internal.PickFirstLeafLoadBalancer

```
final class PickFirstLeafLoadBalancer
extends LoadBalancer
```
A LoadBalancer that provides no load-balancing over the addresses from the NameResolver. The channel's default behavior is used, which is walking down the address list and sticking to the first that works.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private class`	`PickFirstLeafLoadBalancer.HealthListener`
`(package private) static class`	`PickFirstLeafLoadBalancer.Index`	Index as in 'i', the pointer to an entry.
`private static class`	`PickFirstLeafLoadBalancer.Picker`	No-op picker which doesn't add any custom picking logic.
`static class`	`PickFirstLeafLoadBalancer.PickFirstLeafLoadBalancerConfig`
`private class`	`PickFirstLeafLoadBalancer.RequestConnectionPicker`	Picker that requests connection during the first pick, and returns noResult.
`private static class`	`PickFirstLeafLoadBalancer.SubchannelData`

Nested classes/interfaces inherited from class io.grpc.LoadBalancer
LoadBalancer.CreateSubchannelArgs, LoadBalancer.ErrorPicker, LoadBalancer.Factory, LoadBalancer.FixedResultPicker, LoadBalancer.Helper, LoadBalancer.PickDetailsConsumer, LoadBalancer.PickResult, LoadBalancer.PickSubchannelArgs, LoadBalancer.ResolvedAddresses, LoadBalancer.Subchannel, LoadBalancer.SubchannelPicker, LoadBalancer.SubchannelStateListener

Field Summary

Fields
Modifier and Type	Field	Description
`private PickFirstLeafLoadBalancer.Index`	`addressIndex`
`private BackoffPolicy.Provider`	`bkoffPolProvider`
`private ConnectivityState`	`concludedState`
`(package private) static int`	`CONNECTION_DELAY_INTERVAL_MS`
`private boolean`	`enableHappyEyeballs`
`private boolean`	`firstPass`
`private LoadBalancer.Helper`	`helper`
`private static java.util.logging.Logger`	`log`
`private boolean`	`notAPetiolePolicy`
`private int`	`numTf`
`private ConnectivityState`	`rawConnectivityState`
`private BackoffPolicy`	`reconnectPolicy`
`private SynchronizationContext.ScheduledHandle`	`reconnectTask`
`private SynchronizationContext.ScheduledHandle`	`scheduleConnectionTask`
`private boolean`	`serializingRetries`
`private java.util.Map<java.net.SocketAddress,PickFirstLeafLoadBalancer.SubchannelData>`	`subchannels`

Fields inherited from class io.grpc.LoadBalancer
ATTR_HEALTH_CHECKING_CONFIG, DISABLE_SUBCHANNEL_RECONNECT_KEY, EMPTY_PICKER, HAS_HEALTH_PRODUCER_LISTENER_KEY, HEALTH_CONSUMER_LISTENER_ARG_KEY, IS_PETIOLE_POLICY

Constructor Summary

Constructors
Constructor Description

PickFirstLeafLoadBalancer(LoadBalancer.Helper helper)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Status`	`acceptResolvedAddresses(LoadBalancer.ResolvedAddresses resolvedAddresses)`	Accepts newly resolved addresses from the name resolution system.
`private void`	`cancelScheduleTask()`
`private PickFirstLeafLoadBalancer.SubchannelData`	`createNewSubchannel(java.net.SocketAddress addr, Attributes attrs)`
`private static java.util.List<EquivalentAddressGroup>`	`deDupAddresses(java.util.List<EquivalentAddressGroup> groups)`
`private java.net.SocketAddress`	`getAddress(LoadBalancer.Subchannel subchannel)`
`(package private) ConnectivityState`	`getConcludedConnectivityState()`
`(package private) int`	`getGroupIndex()`
`void`	`handleNameResolutionError(Status error)`	Handles an error from the name resolution system.
`(package private) boolean`	`isIndexValid()`
`private boolean`	`isPassComplete()`
`(package private) static boolean`	`isSerializingRetries()`
`(package private) void`	`processSubchannelState(PickFirstLeafLoadBalancer.SubchannelData subchannelData, ConnectivityStateInfo stateInfo)`
`void`	`requestConnection()`	Requests a connection to the next applicable address' subchannel, creating one if necessary.
`private void`	`scheduleBackoff()`	Only called after all addresses attempted and failed (TRANSIENT_FAILURE).
`private void`	`scheduleNextConnection()`	Happy Eyeballs Schedules connection attempt to happen after a delay to the next available address.
`void`	`shutdown()`	The channel asks the load-balancer to shutdown.
`private void`	`shutdownRemaining(PickFirstLeafLoadBalancer.SubchannelData activeSubchannelData)`	Shuts down remaining subchannels.
`private void`	`updateBalancingState(ConnectivityState state, LoadBalancer.SubchannelPicker picker)`
`private void`	`updateHealthCheckedState(PickFirstLeafLoadBalancer.SubchannelData subchannelData)`

Methods inherited from class io.grpc.LoadBalancer
canHandleEmptyAddressListFromNameResolution, handleResolvedAddresses, handleSubchannelState

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - log
```
private static final java.util.logging.Logger log
```
  - CONNECTION_DELAY_INTERVAL_MS
```
static final int CONNECTION_DELAY_INTERVAL_MS
```
    See Also:
    
    Constant Field Values
  - helper
```
private final LoadBalancer.Helper helper
```
  - subchannels
```
private final java.util.Map<java.net.SocketAddress,PickFirstLeafLoadBalancer.SubchannelData> subchannels
```
  - addressIndex
```
private final PickFirstLeafLoadBalancer.Index addressIndex
```
  - numTf
```
private int numTf
```
  - firstPass
```
private boolean firstPass
```
  - scheduleConnectionTask
```
@Nullable
private SynchronizationContext.ScheduledHandle scheduleConnectionTask
```
  - rawConnectivityState
```
private ConnectivityState rawConnectivityState
```
  - concludedState
```
private ConnectivityState concludedState
```
  - enableHappyEyeballs
```
private final boolean enableHappyEyeballs
```
  - notAPetiolePolicy
```
private boolean notAPetiolePolicy
```
  - bkoffPolProvider
```
private final BackoffPolicy.Provider bkoffPolProvider
```
  - reconnectPolicy
```
private BackoffPolicy reconnectPolicy
```
  - reconnectTask
```
@Nullable
private SynchronizationContext.ScheduledHandle reconnectTask
```
  - serializingRetries
```
private final boolean serializingRetries
```
- Constructor Detail
  - PickFirstLeafLoadBalancer
```
PickFirstLeafLoadBalancer(LoadBalancer.Helper helper)
```
- Method Detail
  - isSerializingRetries
```
static boolean isSerializingRetries()
```
  - acceptResolvedAddresses
```
public Status acceptResolvedAddresses(LoadBalancer.ResolvedAddresses resolvedAddresses)
```
    Description copied from class: LoadBalancer
    
    Accepts newly resolved addresses from the name resolution system. The EquivalentAddressGroup addresses should be considered equivalent but may be flattened into a single list if needed.
    Implementations can choose to reject the given addresses by returning false.
    Implementations should not modify the given addresses.
    
    Overrides:
    
    acceptResolvedAddresses in class LoadBalancer
    
    Parameters:
    
    resolvedAddresses - the resolved server addresses, attributes, and config.
    
    Returns:
    
    true if the resolved addresses were accepted. false if rejected.
  - deDupAddresses
```
private static java.util.List<EquivalentAddressGroup> deDupAddresses(java.util.List<EquivalentAddressGroup> groups)
```
  - handleNameResolutionError
```
public void handleNameResolutionError(Status error)
```
    Description copied from class: LoadBalancer
    
    Handles an error from the name resolution system.
    
    Specified by:
    
    handleNameResolutionError in class LoadBalancer
    
    Parameters:
    
    error - a non-OK status
  - processSubchannelState
```
void processSubchannelState(PickFirstLeafLoadBalancer.SubchannelData subchannelData,
                            ConnectivityStateInfo stateInfo)
```
  - scheduleBackoff
```
private void scheduleBackoff()
```
    Only called after all addresses attempted and failed (TRANSIENT_FAILURE).
  - updateHealthCheckedState
```
private void updateHealthCheckedState(PickFirstLeafLoadBalancer.SubchannelData subchannelData)
```
  - updateBalancingState
```
private void updateBalancingState(ConnectivityState state,
                                  LoadBalancer.SubchannelPicker picker)
```
  - shutdown
```
public void shutdown()
```
    Description copied from class: LoadBalancer
    
    The channel asks the load-balancer to shutdown. No more methods on this class will be called after this method. The implementation should shutdown all Subchannels and OOB channels, and do any other cleanup as necessary.
    
    Specified by:
    
    shutdown in class LoadBalancer
  - shutdownRemaining
```
private void shutdownRemaining(PickFirstLeafLoadBalancer.SubchannelData activeSubchannelData)
```
    Shuts down remaining subchannels. Called when a subchannel becomes ready, which means that all other subchannels must be shutdown.
  - requestConnection
```
public void requestConnection()
```
    Requests a connection to the next applicable address' subchannel, creating one if necessary. Schedules a connection to next address in list as well. If the current channel has already attempted a connection, we attempt a connection to the next address/subchannel in our list. We assume that createNewSubchannel will never return null.
    
    Overrides:
    
    requestConnection in class LoadBalancer
  - scheduleNextConnection
```
private void scheduleNextConnection()
```
    Happy Eyeballs Schedules connection attempt to happen after a delay to the next available address.
  - cancelScheduleTask
```
private void cancelScheduleTask()
```
  - createNewSubchannel
```
private PickFirstLeafLoadBalancer.SubchannelData createNewSubchannel(java.net.SocketAddress addr,
                                                                     Attributes attrs)
```
  - isPassComplete
```
private boolean isPassComplete()
```
  - getAddress
```
private java.net.SocketAddress getAddress(LoadBalancer.Subchannel subchannel)
```
  - getConcludedConnectivityState
```
ConnectivityState getConcludedConnectivityState()
```
  - getGroupIndex
```
int getGroupIndex()
```
  - isIndexValid
```
boolean isIndexValid()
```

Class PickFirstLeafLoadBalancer

Nested Class Summary

Nested classes/interfaces inherited from class io.grpc.LoadBalancer

Field Summary

Fields inherited from class io.grpc.LoadBalancer

Constructor Summary

Method Summary

Methods inherited from class io.grpc.LoadBalancer

Methods inherited from class java.lang.Object

Field Detail

log

CONNECTION_DELAY_INTERVAL_MS

helper

subchannels

addressIndex

numTf

firstPass

scheduleConnectionTask

rawConnectivityState

concludedState

enableHappyEyeballs

notAPetiolePolicy

bkoffPolProvider

reconnectPolicy

reconnectTask

serializingRetries

Constructor Detail

PickFirstLeafLoadBalancer

Method Detail

isSerializingRetries

acceptResolvedAddresses

deDupAddresses

handleNameResolutionError

processSubchannelState

scheduleBackoff

updateHealthCheckedState

updateBalancingState

shutdown

shutdownRemaining

requestConnection

scheduleNextConnection

cancelScheduleTask

createNewSubchannel

isPassComplete

getAddress

getConcludedConnectivityState

getGroupIndex

isIndexValid