FastestServerLB

LB strategy that selects the fastest server based on the latest average response time. It's aimed to handle a multi datacenter setup where some server regularly need longer to response. It shall also detect short (subsecond) pauses of a server e.g. due to garbage collection or s.th. else.

The latest average response time is determined in the following order (the first found measure is used): - currently still running requests (if they're lasting longer than previous, already completed requests) - average response time of the current or the last second - average response time of the last ten seconds - total average resonse time

The response time is measured using the given testQuery. A dedicated test query is used, because queries can have very different performance characteristics, so that it might even be hard for an application to classify this. With the testQuery you have control what is used to measure response time.

For "normal" / "fast" servers (default: with a resonse time <= the average of all servers, you can override determineFastServers) test queries are run whenever a request comes in, but between test queries at least the minDelay has to be passed. This way servers are not hammered with requests when nobody else is using your search, but if there's high traffic this load balancer get high resolution of monitoring data to detect short pauses as well.

For "slow" servers (default: response time > average) tests are run using the specified maxDelay.

Directly after creation of this LoadBalancer / AsnycSolrClient multiple test queries are run (according to the specified initialTestRuns, by default 10) to have initial stats.

Linear Supertypes

LoadBalancer, RequestInterceptor, AnyRef, Any

Instance Constructors

new FastestServerLB(solrServers: SolrServers, collectionAndTestQuery: (SolrServer) ⇒ (String, SolrQuery), minDelay: Duration = 100 millis, maxDelay: Duration = 10 seconds, initialTestRuns: Int = 10, clock: Clock = Clock.systemDefault)

solrServers
solr servers to load balance, those are regularly tested.
collectionAndTestQuery
a function that returns the collection name and a testQuery for the given server. The collection is used to partition server when classifying "fast"/"slow" servers, because for different collections response times will be different. It's somehow similar with the testQuery: it might be different per server, e.g. some server might only provide a /suggest handler while others provide /select (which can be specified via the "qt" query param in the test query).
minDelay
the minimum delay between the response of a test and the start of the next test (to limit test frequency)
maxDelay
the delay between tests for slow servers (or all servers if there are no real requests)
initialTestRuns
on start each active server is tested the given number of times to gather initial stats and determine fast/slow servers.
clock
the clock to get the current time from. The tests using the maxDelay are run using a scheduled executor, therefore this interval uses the system clock

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def determineFastServers: Map[String, Set[SolrServer]]

Determines the servers that are tested more frequently.
Determines the servers that are tested more frequently.

Attributes
protected
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
var fastServersByCollection: Map[String, Set[SolrServer]]

Attributes
protected
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def interceptQuery(f: (SolrServer, SolrQuery) ⇒ Future[QueryResponse])(solrServer: SolrServer, q: SolrQuery): Future[QueryResponse]

Intercept user queries to trigger test queries based on the current request rate.
Intercept user queries to trigger test queries based on the current request rate.
f
the function to intercept
solrServer
the SolrServer that's used to run the query
q
the query to send to solr.
returns
the query response.

Definition Classes
FastestServerLB → LoadBalancer → RequestInterceptor
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onFastServersChanged(previousFastServers: Map[String, Set[SolrServer]]): Unit

Attributes
protected
def scheduleTests(): Unit

Attributes
protected
def scheduleUpdateStats(): Unit

Attributes
protected
val serverTestTimestamp: Map[SolrServer, Millisecond]

Attributes
protected[io.ino.solrs]
def setAsyncSolrClient(client: AsyncSolrClient): Unit

On creation of AsyncSolrClient this method is invoked with the created instance.
On creation of AsyncSolrClient this method is invoked with the created instance. Subclasses can override this method to get access to the solr client.

Definition Classes
FastestServerLB → LoadBalancer
def shutdown(): Unit
def solrServer(q: SolrQuery): Option[SolrServer]

Determines the solr server to use for a new request.
Determines the solr server to use for a new request.

Definition Classes
FastestServerLB → LoadBalancer
val solrServers: SolrServers

solr servers to load balance, those are regularly tested.
solr servers to load balance, those are regularly tested.

Definition Classes
FastestServerLB → LoadBalancer
val statsByServer: TrieMap[SolrServer, PerformanceStats]

Attributes
protected[io.ino.solrs]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object FastestServerLB | package solrs

class FastestServerLB extends LoadBalancer

Instance Constructors

new FastestServerLB(solrServers: SolrServers, collectionAndTestQuery: (SolrServer) ⇒ (String, SolrQuery), minDelay: Duration = 100 millis, maxDelay: Duration = 10 seconds, initialTestRuns: Int = 10, clock: Clock = Clock.systemDefault)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def determineFastServers: Map[String, Set[SolrServer]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var fastServersByCollection: Map[String, Set[SolrServer]]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def interceptQuery(f: (SolrServer, SolrQuery) ⇒ Future[QueryResponse])(solrServer: SolrServer, q: SolrQuery): Future[QueryResponse]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onFastServersChanged(previousFastServers: Map[String, Set[SolrServer]]): Unit

def scheduleTests(): Unit

def scheduleUpdateStats(): Unit

val serverTestTimestamp: Map[SolrServer, Millisecond]

def setAsyncSolrClient(client: AsyncSolrClient): Unit

def shutdown(): Unit

def solrServer(q: SolrQuery): Option[SolrServer]

val solrServers: SolrServers

val statsByServer: TrieMap[SolrServer, PerformanceStats]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from LoadBalancer

Inherited from RequestInterceptor

Inherited from AnyRef

Inherited from Any

Ungrouped