org.apache.solr.client.solrj.impl

## Class BaseCloudSolrClient

- java.lang.Object
- - org.apache.solr.client.solrj.SolrClient
  - - org.apache.solr.client.solrj.impl.BaseCloudSolrClient

All Implemented Interfaces:
  Closeable, Serializable, AutoCloseable

Direct Known Subclasses:
  CloudHttp2SolrClient, CloudSolrClient

    public abstract class BaseCloudSolrClient
    extends SolrClient

See Also:
  Serialized Form

### Nested Class Summary

Nested Classes
`static class` `BaseCloudSolrClient.RouteException`
`static class` `BaseCloudSolrClient.RouteResponse<T extends LBSolrClient.Req>`

### Field Summary

Fields
`protected org.apache.solr.client.solrj.impl.BaseCloudSolrClient.StateCache` `collectionStateCache`
`static String` `STATE_VERSION`

### Constructor Summary

Constructors
`protected` `BaseCloudSolrClient(boolean updatesToLeaders, boolean parallelUpdates, boolean directUpdatesToLeadersOnly)`

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
`void` `close()`
`BaseCloudSolrClient.RouteResponse` `condenseResponse(NamedList response, int timeMillis)`
`protected <T extends BaseCloudSolrClient.RouteResponse> T` `condenseResponse(NamedList response, int timeMillis, Supplier<T> supplier)`
`void` `connect()` Connect to the zookeeper ensemble.
`void` `connect(long duration, TimeUnit timeUnit)` Connect to a cluster.
`protected Map<String,? extends LBSolrClient.Req>` `createRoutes(UpdateRequest updateRequest, ModifiableSolrParams routableParams, DocCollection col, DocRouter router, Map<String,List<String>> urlMap, String idField)`
`abstract ClusterStateProvider` `getClusterStateProvider()`
`String` `getDefaultCollection()` Gets the default collection for request
`protected DocCollection` `getDocCollection(String collection, Integer expectedVersion)`
`String` `getIdField()`
`protected abstract LBSolrClient` `getLbClient()`
`int` `getMinAchievedReplicationFactor(String collection, NamedList resp)` Useful for determining the minimum achieved replication factor across all shards involved in processing an update request, typically useful for gauging the replication factor of a batch.
`ResponseParser` `getParser()`
`RequestWriter` `getRequestWriter()`
`protected BaseCloudSolrClient.RouteException` `getRouteException(SolrException.ErrorCode serverError, NamedList<Throwable> exceptions, Map<String,? extends LBSolrClient.Req> routes)`
`Map<String,Integer>` `getShardReplicationFactor(String collection, NamedList resp)` Walks the NamedList response after performing an update request looking for the replication factor that was achieved in each shard involved in the request.
`String` `getZkHost()`
`ZkStateReader` `getZkStateReader()`
`boolean` `isDirectUpdatesToLeadersOnly()`
`boolean` `isParallelUpdates()` Gets whether direct updates are sent in parallel
`boolean` `isUpdatesToLeaders()`
`protected static ArrayList<Object>` `objectList(int n)`
`void` `registerCollectionStateWatcher(String collection, CollectionStateWatcher watcher)` Register a CollectionStateWatcher to be called when the cluster state for a collection changes Note that the watcher is unregistered after it has been called once.
`NamedList<Object>` `request(SolrRequest request, String collection)` Execute a request against a Solr server for a given collection
`protected NamedList<Object>` `requestWithRetryOnStaleState(SolrRequest request, int retryCount, List<String> inputCollections)` As this class doesn't watch external collections on the client side, there's a chance that the request will fail due to cached stale state, which means the state must be refreshed from ZK and retried.
`protected NamedList<Object>` `sendRequest(SolrRequest request, List<String> inputCollections)`
`void` `setCollectionCacheTTl(int seconds)` Sets the cache ttl for DocCollection Objects cached .
`void` `setDefaultCollection(String collection)` Sets the default collection for request
`void` `setIdField(String idField)`
`void` `setParallelCacheRefreshes(int n)` If caches are expired they are refreshed after acquiring a lock.
`void` `setParser(ResponseParser processor)` Note: This setter method is not thread-safe.
`void` `setRequestWriter(RequestWriter requestWriter)`
`void` `setRetryExpiryTime(int secs)` This is the time to wait to refetch the state after getting the same state version from ZK
`void` `setZkClientTimeout(int zkClientTimeout)` Set the timeout to the zookeeper ensemble in ms
`void` `setZkConnectTimeout(int zkConnectTimeout)` Set the connect timeout to the zookeeper ensemble in ms
`void` `waitForState(String collection, long wait, TimeUnit unit, CollectionStatePredicate predicate)` Block until a collection state matches a predicate, or a timeout Note that the predicate may be called again even after it has returned true, so implementors should avoid changing state within the predicate call itself.
`protected abstract boolean` `wasCommError(Throwable t)`

### Methods inherited from class org.apache.solr.client.solrj.SolrClient

`add, add, add, add, add, add, add, add, add, add, addBean, addBean, addBean, addBean, addBeans, addBeans, addBeans, addBeans, addBeans, addBeans, commit, commit, commit, commit, commit, commit, deleteById, deleteById, deleteById, deleteById, deleteById, deleteById, deleteById, deleteById, deleteByQuery, deleteByQuery, deleteByQuery, deleteByQuery, getBinder, getById, getById, getById, getById, getById, getById, getById, getById, optimize, optimize, optimize, optimize, optimize, optimize, ping, query, query, query, query, queryAndStreamResponse, queryAndStreamResponse, queryAndStreamResponse, request, rollback, rollback`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### STATE_VERSION

    public static final String STATE_VERSION

See Also:
  Constant Field Values

#### collectionStateCache

    protected final org.apache.solr.client.solrj.impl.BaseCloudSolrClient.StateCache collectionStateCache

### Constructor Detail

#### BaseCloudSolrClient

    protected BaseCloudSolrClient(boolean updatesToLeaders,
                                  boolean parallelUpdates,
                                  boolean directUpdatesToLeadersOnly)

### Method Detail

#### setRetryExpiryTime

    public void setRetryExpiryTime(int secs)

This is the time to wait to refetch the state after getting the same state version from ZK

secs

#### setCollectionCacheTTl

    public void setCollectionCacheTTl(int seconds)

Sets the cache ttl for DocCollection Objects cached . This is only applicable for collections which are persisted outside of clusterstate.json

Parameters:
  `seconds` - ttl value in seconds

#### getLbClient

    protected abstract LBSolrClient getLbClient()

#### getClusterStateProvider

    public abstract ClusterStateProvider getClusterStateProvider()

#### wasCommError

    protected abstract boolean wasCommError(Throwable t)

#### close

    public void close()
               throws IOException

Throws:
  `IOException`

#### getParser

    public ResponseParser getParser()

#### setParser

    public void setParser(ResponseParser processor)

Note: This setter method is not thread-safe.

Parameters:
  `processor` - Default Response Parser chosen to parse the response if the parser were not specified as part of the request.
See Also:
  `SolrRequest.getResponseParser()`

#### getRequestWriter

    public RequestWriter getRequestWriter()

#### setRequestWriter

    public void setRequestWriter(RequestWriter requestWriter)

#### getZkHost

    public String getZkHost()

Returns:
  the zkHost value used to connect to zookeeper.

#### getZkStateReader

    public ZkStateReader getZkStateReader()

#### setIdField

    public void setIdField(String idField)

Parameters:
  `idField` - the field to route documents on.

#### getIdField

    public String getIdField()

Returns:
  the field that updates are routed on.

#### setDefaultCollection

    public void setDefaultCollection(String collection)

Sets the default collection for request

#### getDefaultCollection

    public String getDefaultCollection()

Gets the default collection for request

#### setZkConnectTimeout

    public void setZkConnectTimeout(int zkConnectTimeout)

Set the connect timeout to the zookeeper ensemble in ms

#### setZkClientTimeout

    public void setZkClientTimeout(int zkClientTimeout)

Set the timeout to the zookeeper ensemble in ms

#### isParallelUpdates

    public boolean isParallelUpdates()

Gets whether direct updates are sent in parallel

#### connect

    public void connect()

Connect to the zookeeper ensemble. This is an optional method that may be used to force a connect before any other requests are sent.

#### connect

    public void connect(long duration,
                        TimeUnit timeUnit)
                 throws TimeoutException,
                        InterruptedException

Connect to a cluster. If the cluster is not ready, retry connection up to a given timeout.

Parameters:
  `duration` - the timeout
  `timeUnit` - the units of the timeout
Throws:
  `TimeoutException` - if the cluster is not ready after the timeout
  `InterruptedException` - if the wait is interrupted

#### waitForState

    public void waitForState(String collection,
                             long wait,
                             TimeUnit unit,
                             CollectionStatePredicate predicate)
                      throws InterruptedException,
                             TimeoutException

Block until a collection state matches a predicate, or a timeout Note that the predicate may be called again even after it has returned true, so implementors should avoid changing state within the predicate call itself.

Parameters:
  `collection` - the collection to watch
  `wait` - how long to wait
  `unit` - the units of the wait parameter
  `predicate` - a `CollectionStatePredicate` to check the collection state
Throws:
  `InterruptedException` - on interrupt
  `TimeoutException` - on timeout

#### registerCollectionStateWatcher

    public void registerCollectionStateWatcher(String collection,
                                               CollectionStateWatcher watcher)

Register a CollectionStateWatcher to be called when the cluster state for a collection changes Note that the watcher is unregistered after it has been called once. To make a watcher persistent, it should re-register itself in its `CollectionStateWatcher.onStateChanged(Set, DocCollection)` call

Parameters:
  `collection` - the collection to watch
  `watcher` - a watcher that will be called when the state changes

#### getRouteException

    protected BaseCloudSolrClient.RouteException getRouteException(SolrException.ErrorCode serverError,
                                                                   NamedList<Throwable> exceptions,
                                                                   Map<String,? extends LBSolrClient.Req> routes)

#### createRoutes

    protected Map<String,? extends LBSolrClient.Req> createRoutes(UpdateRequest updateRequest,
                                                                  ModifiableSolrParams routableParams,
                                                                  DocCollection col,
                                                                  DocRouter router,
                                                                  Map<String,List<String>> urlMap,
                                                                  String idField)

#### condenseResponse

    protected <T extends BaseCloudSolrClient.RouteResponse> T condenseResponse(NamedList response,
                                                                               int timeMillis,
                                                                               Supplier<T> supplier)

#### condenseResponse

    public BaseCloudSolrClient.RouteResponse condenseResponse(NamedList response,
                                                              int timeMillis)

#### request

    public NamedList<Object> request(SolrRequest request,
                                     String collection)
                              throws SolrServerException,
                                     IOException

Description copied from class: `SolrClient`
Execute a request against a Solr server for a given collection

Specified by:
  `request` in class `SolrClient`
Parameters:
  `request` - the request to execute
  `collection` - the collection to execute the request against
Returns:
  a `NamedList` containing the response from the server
Throws:
  `SolrServerException` - if there is an error on the server
  `IOException` - If there is a low-level I/O error.

#### requestWithRetryOnStaleState

    protected NamedList<Object> requestWithRetryOnStaleState(SolrRequest request,
                                                             int retryCount,
                                                             List<String> inputCollections)
                                                      throws SolrServerException,
                                                             IOException

As this class doesn't watch external collections on the client side, there's a chance that the request will fail due to cached stale state, which means the state must be refreshed from ZK and retried.

Throws:
  `SolrServerException`
  `IOException`

#### sendRequest

    protected NamedList<Object> sendRequest(SolrRequest request,
                                            List<String> inputCollections)
                                     throws SolrServerException,
                                            IOException

Throws:
  `SolrServerException`
  `IOException`

#### isUpdatesToLeaders

    public boolean isUpdatesToLeaders()

#### isDirectUpdatesToLeadersOnly

    public boolean isDirectUpdatesToLeadersOnly()

Returns:
  true if direct updates are sent to shard leaders only

#### setParallelCacheRefreshes

    public void setParallelCacheRefreshes(int n)

If caches are expired they are refreshed after acquiring a lock. use this to set the number of locks

#### objectList

    protected static ArrayList<Object> objectList(int n)

#### getDocCollection

    protected DocCollection getDocCollection(String collection,
                                             Integer expectedVersion)
                                      throws SolrException

Throws:
  `SolrException`

#### getMinAchievedReplicationFactor

    public int getMinAchievedReplicationFactor(String collection,
                                               NamedList resp)

Useful for determining the minimum achieved replication factor across all shards involved in processing an update request, typically useful for gauging the replication factor of a batch.

#### getShardReplicationFactor

    public Map<String,Integer> getShardReplicationFactor(String collection,
                                                         NamedList resp)

Walks the NamedList response after performing an update request looking for the replication factor that was achieved in each shard involved in the request. For single doc updates, there will be only one shard in the return value.