All Classes and Interfaces

Base implementation of a AggregationBuilder.
Abstract base class for allocating an unassigned shard to a node
Works around ObjectParser not supporting constructor arguments.
An abstract class for representing various types of allocation decisions.
A base class for tasks that need to repeat.
Base implementation that throws an IOException for the DocIdSetIterator APIs.
Bind a value or constant.
A base abstract blob container that implements higher level container methods.
Abstract diffable object with simple diffs implementation that sends the entire object if object has changed or nothing if object remained the same.
Abstract base for scripts to execute to build scripted fields.
Base field mapper class for all spatial field types
Interface representing parser in geometry indexing pipeline.
Base QueryBuilder that builds a Geometry Query
local class that encapsulates xcontent parsed shape parameters
This abstract class holds parameters shared by HighlightBuilder and HighlightBuilder.Field and provides the common setters, equality, hashCode calculation and common serialization
Base class for functionality shared between aggregators for this histogram aggregation.
Hyperloglog counter, implemented based on pseudo code from and its appendix Trying to understand what this class does without having read the paper is considered adventurous.
Iterator over a HyperLogLog register
Base class for HLL++ algorithms.
AbstractIndexAnalyzerProvider<T extends org.apache.lucene.analysis.Analyzer>
A PerValueEstimator is a sub-class that can be used to estimate the memory overhead for loading the data.
Base class for terms and multi_terms aggregation that handles common reduce logic
AbstractLifecycleRunnable is a service-lifecycle aware AbstractRunnable.
Linear counter, implemented based on pseudo code from and its appendix Trying to understand what this class does without having read the paper is considered adventurous.
Iterator over the hash values
Common base class for script field scripts that return long values.
Implements and() and or().
A support class for Modules which reduces repetition and results in a more readable configuration.
Abstract diffable object with simple diffs implementation that sends the entire object if object has changed or nothing is object remained the same.
Base implementation that throws an IOException for the DocIdSetIterator APIs.
This provides a base class for aggregations that are building percentiles or percentiles-like functionality (e.g.
Base implementation of a PipelineAggregationBuilder.
Base class for for spatial fields that only support indexing points
A base parser implementation for point formats
An Abstract Processor that holds tag and description information about the processor.
A record of timings for the various operations that may happen during query execution.
Base class for all classes producing lucene queries.
Abstract resource watcher framework, which handles adding and removing listeners and calling resource observer.
An extension to runnable.
A basic setting service that can be used for per-index and per-cluster settings.
Transactional interface to update settings.
Abstract base class for building queries based on script fields.
Base class for GeoShapeFieldMapper
Base implementation that throws an IOException for the DocIdSetIterator APIs.
Base implementation that throws an IOException for the DocIdSetIterator APIs.
Base implementation that throws an IOException for the DocIdSetIterator APIs.
Base implementation that throws an IOException for the DocIdSetIterator APIs.
Allows to wait for all nodes to reply to the publish of a new cluster state and notifies the ClusterStatePublisher.AckListener so that the cluster state update can be acknowledged
An extension interface to ClusterStateUpdateTask that allows to be notified when all the nodes have acknowledged a cluster state update request
Identifies a cluster state update request with acknowledgement support
Abstract class that allows to mark action requests that support acknowledgements.
Base request builder for master node operations that support acknowledgements
A response that indicates that a request has been acknowledged
Base class for the common case of a TransportMasterNodeAction that responds with an AcknowledgedResponse.
A filter allowing to filter transport actions
A simple base class for injectable action filters that spares the implementation from handling the filter chain.
A filter chain allowing to continue and process the transport action request
Holds the action filters injected through plugins, properly sorted by ActionFilter.order()
An extension to Future allowing for simplified "get" operations.
A listener for action responses or failures.
A simple base class for action response listeners, defaulting to using the SAME executor (as its very common on response handlers).
Builds and binds the generic action map, all TransportActions, and ActionFilters.
An exception indicating that a transport action was not found.
An additional extension point for Plugins that extends Elasticsearch's scripting functionality.
Base class for responses to action requests.
Base class for Runnables that need to call ActionListener.onFailure(Exception) in case an uncaught exception or error is thrown while the actual action is run.
An action invocation failure.
A generic action.
A class whose instances represent a value for counting the number of active shard copies for a given shard in an index.
This class provides primitives for waiting for a configured number of shards to become active before sending a response on an ActionListener.
An Aggregator that delegates collection to another Aggregator and then translates its results into the results you'd expect from another aggregation.
Class representing statistics about adaptive replica selection.
Cluster state update request that allows to add a block to one or more indices
A request to add a block to an index.
Builder for add index block request
A request to add voting config exclusions for certain master-eligible nodes, and wait for these nodes to be removed from the voting configuration.
A multi bucket aggregation where the buckets are defined by a set of filters (a bucket is produced per filter plus a bucket for each non-empty filter intersection so A, B and A&B).
A bucket associated with a specific filter or pair (identified by its key)
Aggregation for adjacency matrices.
Administrative actions/operations against the cluster or the indices.
An aggregation.
Common xcontent fields that are shared among addAggregation
A factory that knows how to create an Aggregator of a specific type.
A rough count of the number of buckets that Aggregators built by this builder will contain per parent bucket used to validate sorts and pipeline aggregations.
Common xcontent fields shared among aggregator builders
Utility class to create aggregations.
Everything used to build and execute aggregations and the data sources that power them.
Implementation of AggregationContext for production usage that wraps our ubiquitous SearchExecutionContext and anything else specific to aggregations.
Thrown when failing to execute an aggregation
Thrown when failing to execute an aggregation
Provides a set of static helpers to determine if a particular type of InternalAggregation "has a value" or not.
A path that can be used to sort/order buckets (in some multi-bucket aggregations, e.g.
Aggregation phase of a search request, used to collect aggregations
AbstractProfileBreakdown customized to work with aggregations.
A container class to hold the profile results for a single shard in the request.
Represents a set of Aggregations
A factory to construct stateful AggregationScript factories for a specific index.
A factory to construct AggregationScript instances.
An Aggregator.
Compare two buckets by their ordinal.
Parses the aggregation request and creates the appropriate aggregator factory for it.
Aggregation mode for sub aggregations.
Base implementation for concrete aggregators.
An immutable collection of AggregatorFactories.
A mutable collection of AggregationBuilders and PipelineAggregationBuilders.
Represents an alias, to be associated with an index
Individual operation to perform on the cluster state as part of an IndicesAliasesRequest.
Operation to add an alias to an index.
Validate a new alias.
Operation to remove an alias from an index.
Operation to remove an index.
Needs to be implemented by all ActionRequest subclasses that relate to one or more indices and one or more aliases.
Represents a QueryBuilder and a list of alias names that filters the builder is composed of.
Validator for an alias, to be used before adding an alias to the index metadata and make sure the alias is valid
Stats class encapsulating all of the different circuit breaker stats
Noop mapper that ensures that mappings created in 6x that explicitly disable the _all field can be restored in this version.
Represents a executor node operation that corresponds to a persistent task
Allocates an unassigned empty primary shard to a specific node.
Allocates an unassigned replica shard to a specific node.
Allocates an unassigned stale primary shard to a specific node.
Represents the allocation decision by an allocator for an unassigned shard.
A command to move shards in some way.
A simple AllocationCommand composite managing several AllocationCommand implementations
AllocationDecider is an abstract base class that allows to make dynamic cluster- or index-wide shard allocation decisions on a per-node basis.
A composite AllocationDecider combining the "decision" of multiple AllocationDecider implementations into a single allocation decision.
An enum which represents the various decision types that can be taken by the allocators and deciders for allocating a shard to a node.
Uniquely identifies an allocation.
This service manages the node allocation of a cluster.
this class is used to describe results of applying a set of AllocationCommand
Enum representing the mode in which token filters and analyzers are allowed to operate.
The basic factory interface for analysis components.
An additional extension point for Plugins that extends Elasticsearch's analysis functionality.
An internal registry for tokenizer, token filter, char filter and analyzer.
Statistics about analysis usage.
A request to analyze a text associated with a specific index.
A class that groups analysis components necessary to produce a custom analyzer.
Analyzers that provide access to their token filters should implement this
AnalyzerProvider<T extends org.apache.lucene.analysis.Analyzer>
See the EDSL examples at Binder.
See the EDSL examples at Binder.
See the EDSL examples at Binder.
Annotation utilities.
A master node sends this request to its peers to inform them that it could commit the cluster state with the given term and version.
An implementation of ValueFetcher that knows how to extract values from the document source.
Provides a static final field that can be used to check if assertions are enabled.
AssignmentDecision represents the decision made during the process of assigning a persistent task to a node of the cluster.
Annotates an injected parameter or field whose value comes from an argument to a factory method.
FactoryProvider now works better with the standard @Inject annotation.
An "associated index" is an index that is related to or derived from a system index, but should not be considered a system index, usually because it is meant to be visible to users.
A BiFunction-like interface designed to be used with asynchronous executions.
This async IO processor allows to batch IO operations and have a single writer processing the write operations.
Allows to asynchronously fetch shard related data from other nodes for allocation, without blocking the cluster update thread.
The result of a fetch operation.
An action that lists the relevant shard data that needs to be fetched.
A list backed by an AtomicReferenceArray with potential null values, easily allowing to get the concrete values as a list using AtomicArray.asList().
Api that auto creates an index or data stream that originate from requests that write into an index that doesn't yet exist.
Encapsulates the logic of whether a new index should be automatically created when a write operation is about to happen in a non existing index.
This class acts as a functional wrapper around the index.auto_expand_replicas setting.
Helper functions for creating various forms of AutomatonQuery
A builder for executors that automatically adjust the queue length as needed, depending on Little's Law.
An aggregation that computes the average of the values in the current bucket.
This AllocationDecider controls shard allocation based on awareness key-value pairs defined in the node configuration.
Provides a backoff policy for bulk requests.
The BalancedShardsAllocator re-balances the nodes allocations within an cluster based on a BalancedShardsAllocator.WeightFunction.
Interface shared by AggregationBuilder and PipelineAggregationBuilder so they can conveniently share the same namespace for XContentParser.namedObject(Class, String, Object).
An abstract class that implements basic functionality for allocating shards to nodes based on shard copies that already exist in the cluster.
A base class for node level operations.
Abstract base class for allocating an unassigned primary shard to a node
Base handler for REST requests.
REST requests are handled by preparing a channel consumer that represents the execution of the request against a channel.
A base class for task requests
Base class for responses of task-related operations
A base class for all classes that allows reading ops from translog files
A replication request that has no more information than ReplicationRequest.
A BatchedRerouteService is a RerouteService that batches together reroute requests to avoid unnecessary extra reroutes.
A specialization of DeferringBucketCollector that collects all matches and then is able to replay a given subset of buckets which represent the survivors from a pruning process performed by the aggregator that owns this collector.
A specialization of DeferringBucketCollector that collects all matches and then replays only the top scoring documents to child aggregations.
Base abstraction of an array.
Utility class to work with arrays.
LeafFieldData impl on top of Lucene's binary doc values.
A range field for binary encoded ranges
A range aggregator for values that are stored in SORTED_SET doc values.
Performs binary search on an arbitrary data structure.
Collects configuration information (primarily bindings) which will be used to create an Injector.
A mapping from a key (type and optional annotation) to the strategy for getting instances of the type.
Annotates annotations which are used for binding.
Bind a non-constant key.
Visits each of the strategies used to scope an injection.
Visits each of the strategies used to find an instance to satisfy an injection.
A bit array that is implemented using a growing LongArray created from BigArrays.
This is a cache for BitDocIdSet based filters and is unbounded by size or time.
A listener interface that is executed for each onCache / onRemoval event
BlendedTermQuery can be used to unify term statistics across one or more fields in the index.
An interface for managing a repository of blob entries, where each blob entry is just a named group of bytes.
An interface for providing basic metadata about a blob.
The list of paths where a blob can reside.
An interface for storing blobs.
Shard snapshot metadata
Information about snapshotted file
Contains information about all snapshots for the given shard in repository
BlobStore - based implementation of Snapshot Repository
Handles responses obtained when publishing a new cluster state from master to all non master nodes.
A field mapper for boolean fields.
A Query that matches documents matching boolean combinations of other queries.
The BoostingQuery class can be used to effectively demote results that match a given query.
Encapsulates a bootstrap check.
Encapsulate the result of a bootstrap check.
Context that is passed to every bootstrap check to make decisions on.
Exposes system startup information
A custom break iterator that is used to find break-delimited passages bounded by a provided maximum length in the UnifiedHighlighter context.
A bounded transport address is a tuple of TransportAddress, one array that represents the addresses the transport is bound to, and the other is the published one that represents the address clients should communicate on.
Settings for a CircuitBreaker
Base class for all broadcast operation based responses.
An exception indicating that a failure occurred performing an operation on the shard.
A script used in bucket aggregations that returns a double value.
A script used in bucket aggregations that returns a boolean value.
A Collector that can collect data in separate buckets.
Type specialized sort implementations designed for use in aggregations.
Callbacks for storing extra data along with competitive sorts.
Superclass for implementations of BucketedSort for double keys.
Superclass for implementations of BucketedSort for float keys.
Superclass for implementations of BucketedSort for long keys.
Used with BucketedSort.getValues(long, ResultBuilder) to build results from the sorting operation.
A set of static helpers to simplify working with aggregation buckets, in particular providing utilities that help pipeline aggregations.
A gap policy determines how "holes" in a set of buckets should be handled.
A parser for parsing requests for a BucketMetricsPipelineAggregator
A class of sibling pipeline aggregations which calculate metrics across the buckets of a sibling aggregation
Builds a pipeline aggregation that allows sorting the buckets of its parent aggregation.
Helper functions for common Bucketing functions
Similar to Lucene's BufferedChecksumIndexInput, however this wraps a StreamInput so anything read will update the checksum
Similar to Lucene's BufferedChecksumIndexOutput, however this wraps a StreamOutput so anything written will update the checksum
Information about a build of Elasticsearch.
Response used for actions that index many documents using a scroll request.
Task storing information about a currently running BulkByScroll request.
Status of the reindex, update by query, or delete by query.
This class acts as a builder for BulkByScrollTask.Status.
The status of a slice of the request.
Represents a single item response for an action executed as part of the bulk API.
Represents a failure.
A bulk processor is a thread safe bulk processing class, allowing to easily set when to "flush" a new bulk request (either based on number of actions, based on the size, or time), and to easily control the number of concurrent bulk requests allowed to be executed in parallel.
A builder used to create a build an instance of a bulk processor.
A listener for the execution.
A bulk request holds an ordered IndexRequests, DeleteRequests and UpdateRequests and allows to executes it in a single batch.
A bulk request holds an ordered IndexRequests and DeleteRequests and allows to executes it in a single batch.
Implements the low-level details of bulk request handling
Helper to parse bulk requests.
A response of a bulk execution.
Abstraction of an array of byte values.
Wraps array of bytes into IndexInput
Resettable StreamInput that wraps a byte array.
A SizeUnit represents size at a given unit of granularity and provides utility methods to convert across units.
Maps BytesRef bucket keys to bucket ordinals.
An iterator for buckets inside a particular owningBucketOrd.
A reference to bytes.
Comparator source for string/binary values.
Specialized hash table implementation similar to Lucene's BytesRefHash that maps BytesRef values to ids.
A @link StreamOutput that uses BigArrays to acquire pages of bytes, which avoids frequent reallocation & copying of the internal data.
A specialized, bytes only request, that can potentially be optimized on the network layer, specifically for the same large buffer send to several nodes.
Utility methods to do byte-level encoding.
A simple concurrent cache.
A Supplier that caches its return value.
A command that cancels relocation, or recovery of a given shard on a node.
A cache of a single object whose refresh process can be cancelled.
A task that can be cancelled
This interface is implemented by any class that needs to react to the cancellation of this task.
Tracks items that are associated with cancellable tasks, supporting efficient lookup by task ID and by parent task ID
A utility class for multi threaded operation that needs to be cancellable via interrupts.
ActionType for cancelling running tasks
A request to cancel tasks
Builder for the request to cancel tasks running on the specified nodes
Returns the list of tasks that were cancelled
Node-level request used during can-match phase
Shard-level response for can-match requests
An aggregation that computes approximate numbers of unique terms.
An aggregator that computes approximate counts of unique values.
Upper bound of how many owningBucketOrds that an Aggregator will have to collect into.
A ContextMapping that uses a simple string as a criteria The suggestions are boosted and/or filtered by their associated category (string) value.
Defines the query context for CategoryContextMapping
only for testing until we have a disk-full FileSystem
A BiConsumer-like interface which allows throwing checked exceptions.
A BiFunction-like interface which allows throwing checked exceptions.
A Supplier-like interface which allows throwing checked exceptions.
Snapshot metadata file format used in v2.0 and above
Breaker that will check a parent's when incrementing
Base class for doing chunked writes to a blob store.
Interface for an object that can be incremented, breaking after some configured limit has been reached.
An extension point for Plugin implementations to add custom circuit breakers
Interface for Circuit Breaker services, which provide breakers to classes that load field data.
Class encapsulating stats about the circuit breaker
Exception thrown when the circuit breaker trips
Checked by scripting engines to allow loading a java class.
The response of a clear cache action.
A request to clear the voting config exclusions from the cluster state, optionally waiting for these nodes to be removed from the cluster first.
A client provides a one stop interface for performing actions/operations against the cluster.
A scrollable source of hits from a Client instance.
Abstract Transport.Connection that provides common close logic.
Cluster state update request that allows to close one or more indices
A request to close an index.
Builder for close index request
Administrative actions/operations against indices.
ActionType for explaining shard allocation for a shard in the cluster
A request to explain the allocation of a shard in the cluster
Builder for requests to explain the allocation of a shard in the cluster
Explanation response for a shard in the cluster
A ClusterAllocationExplanation is an explanation of why a shard is unassigned, or if it is not unassigned, then which nodes it could possibly be relocated to.
Represents current cluster level blocks to block dirty operations done against the cluster.
An event received by the local node, signaling that the cluster state has changed.
This class manages node connections within a cluster.
This request is specific to the REST client.
This response is specific to the REST client.
Pattern converter to format the cluster_id variable into JSON fields
ClusterInfo is an object representing a map of nodes to DiskUsage and a map of shard ids to shard sizes, see InternalClusterInfoService.shardIdentifierFromRouting(String) for the key used in the shardSizes map
Represents a data path on a node
Represents the total amount of "reserved" space on a particular data path, together with the set of shards considered.
Interface for a class used to gather information about a cluster periodically.
Configures classes and services that affect the entire cluster.
Resolves cluster names from an expression.
An extension point for Plugin implementations to customer behavior of cluster management.
This AllocationDecider controls re-balancing operations based on the cluster wide active shard state.
An enum representation for the configured re-balance type.
Request to submit cluster reroute allocation commands
Builder for a cluster reroute request
Response returned after a cluster reroute request
Encapsulates all valid cluster level settings.
Represents the current state of the cluster.
An interface that implementors use when a class requires a client to maybe have a feature.
A component that is in charge of applying an incoming cluster state to the node internal data structures.
A listener to be notified when a cluster state changes.
A utility class which simplifies interacting with the cluster state in cases where one tries to take action based on the current state but may want to wait for a new state and retry upon failure.
Represents a cluster state update computed by the MasterService for publication to the cluster.
The response for getting the cluster state.
Cluster state update task configuration for timeout and priority
Represents the result of a batched execution of cluster state update tasks
Base class to be used when needing to update the cluster state Contains the basic fields that are always needed
Various statistics (timing information etc) about cluster state updates coordinated by this node.
A task that can update the cluster state.
A request to get cluster level stats.
Request for an update cluster settings action
Builder for a cluster update settings request
A response for a cluster update settings action.
Since Lucene 4.0 low level index segments are read and written through a codec layer that allows to use use-case specific file formats & data-structures per field.
A builder that enables field collapsing on search request.
Context used for field collapsing
Represents hits returned by CollapsingTopDocsCollector.getTopDocs().
A collector that groups documents based on field values and returns CollapseTopFieldDocs output.
Collections-related utility methods.
Public interface and serialization container for profiled timings of the Collectors used in the search.
A BitSet implementation that combines two instances of BitSet and Bits to provide a single merged view.
An IndexDeletionPolicy that coordinates between Lucene's commits and the retention of translog generation files, making sure that all translog files that are needed to recover from the Lucene commit are not deleted.
A query that matches on multiple text fields, as if the field contents had been indexed into a single combined field.
A rate limiter designed for multiple concurrent users.
Holder class for method to configure logging without Elasticsearch configuration files for use in CLI tools that will not read such files.
a class the returns dynamic information with respect to the last commit point of this shard
Since max_optimization optimization landed in 7.0, normal MatchQuery will achieve the same result without any configuration.
Comparator-related utility methods.
Used to calculate sums using the Kahan summation algorithm.
Mapper for completion field.
ActionType that is used by executor node to indicate that the persistent action finished or failed on the node and needs to be removed from the cluster state in case of successful completion or restarted on some other node in case of failure.
Suggestion response for CompletionSuggester results Response format for each entry: { "text" : STRING "score" : FLOAT "contexts" : CONTEXTS } CONTEXTS : { "CONTEXT_NAME" : ARRAY, ..
Defines a suggest command based on a prefix, typically to provide "auto-complete" functionality for users as they type search terms.
A component template is a re-usable Template as well as metadata about the template.
ComponentTemplateMetadata is a custom Metadata implementation for storing a map of component templates and their names.
An index template is comprised of a set of index patterns, an optional template, and a list of ids corresponding to component templates that should be composed in order when creating a new index.
The ComposableIndexTemplateMetadata class is a custom Metadata.Custom implementation that stores a map of ids to ComposableIndexTemplate templates.
A composite BytesReference that allows joining multiple bytes references into one without copying.
A script that emits a map of multiple values, that can then be accessed by child runtime fields.
Marker interface that needs to be implemented by all ActionRequest subclasses that are composed of multiple sub-requests which relate to one or more indices.
A runtime field of type object.
A Processor that executes a list of other "processors".
Similar class to the String class except that it internally stores data using a compressed representation in order to require less permanent memory.
A Recycler implementation based on a concurrent Deque.
Similar to the ClusterRebalanceAllocationDecider this AllocationDecider controls the number of currently in-progress re-balance (relocation) operations and restricts node allocations if the configured threshold is reached.
Thrown when a user tries to multiple conflicting snapshot/restore operations at the same time.
Base class for rollover request conditions
Holder for evaluated condition result
Holder for index stats used to evaluate conditions
Thrown when a programming error such as a misplaced annotation, illegal binding, or unsupported scope is found.
A connection profile describes how many connection are established to specific node for each of the available request types.
A builder to build a new ConnectionProfile
Used to publish secure setting hashes in the cluster state and to validate those hashes against the local values of those same settings.
Binds to a constant value.
Bind a constant.
A MappedFieldType that has the same value for all documents.
A query that wraps a filter and simply returns a constant score equal to the query boost for every document in the filter.
Context of a dependency construction.
A binding to the constructor of a concrete clss.
Builder for ContextMapping
Context-aware extension of IndexSearcher.
A ContextMapping defines criteria that can be used to filter and/or boost suggestions at query time for CompletionFieldMapper.
ContextMappings indexes context-enabled suggestion fields and creates context queries for defined ContextMappings for a CompletionFieldMapper
Restores the given ThreadContext.StoredContext once the listener is invoked
A binding created from converting a bound instance to a new type.
A collection of persistent node ids, denoting the voting configuration for cluster state changes.
The core class of the cluster state coordination algorithm, directly implementing the formal model
Pluggable persistence layer for CoordinationState.
A collection of votes, used to calculate quorums.
This exception is thrown when rejecting state transitions on the CoordinationState object, for example when receiving a publish request with the wrong term or version.
Context object used to rewrite QueryBuilder instances into simplified version in the coordinator.
An immutable map whose writes result in a new copy of the map to be created.
CoreValuesSourceType holds the ValuesSourceType implementations for the core aggregations package.
This exception is thrown when Elasticsearch detects an inconsistency in one of it's persistent states.
This file is forked from the project.
A simple thread safe count-down class that in contrast to a CountDownLatch never blocks.
A CountedBitSet wraps a FixedBitSet but automatically releases the internal bitset when all bits are set to reduce memory usage.
A CounterMetric is used to track the number of completed and outstanding items, for example, the number of executed refreshes, the currently used memory by indexing, the current pending search requests.
Cluster state update request that allows to create an index
A request to create an index.
Builder for a create index request
A response for a create index action.
Create snapshot action
Create snapshot request
Create snapshot request builder
Create snapshot response
Thrown when errors occur while creating a Injector.
An approximate set membership datastructure CuckooFilters are similar to Bloom Filters in usage; values are inserted, and the Cuckoo can be asked if it has seen a particular value before.
A custom analyzer that is built out of a single Tokenizer and a list of TokenFilters.
A field visitor that allows to load a selection of the stored fields by exact name or by pattern.
A custom normalizer that is built out of a char and token filters.
Custom passage formatter that allows us to: 1) extract different snippets (instead of a single big string) together with their scores (Snippet) 2) use the Encoder implementations that are already used with the other highlighters
Custom field that allows storing an integer value as a term frequency in lucene.
Subclass of the UnifiedHighlighter that works for a single field in a single document.
Contains information about a dangling index, i.e.
The dangling indices state is responsible for finding new dangling indices (indices that have their state written on disk, but don't exists in the metadata of the cluster), and importing them into the cluster.
Operations on data streams.
Custom Metadata implementation for storing a map of DataStreams and their names.
FieldMapper for the data-stream's timestamp meta-field.
The DataTier class encapsulates the formalization of the "content", "hot", "warm", and "cold" tiers as node roles.
This setting provider injects the setting allocating all newly created indices with index.routing.allocation.include._tier: "data_hot" unless the user overrides the setting while the index is being created (in a create index request for instance)
A FieldMapper for dates.
Temporary parse method that takes into account the date format.
A builder for histograms on date fields.
The interval the date histogram is based on.
A SingleDimensionValuesSource for date histogram values.
A CompositeValuesSourceBuilder that builds a RoundingValuesSource from a Script or a field name using the provided interval.
A shared interface for aggregations that parse and use "interval" parameters.
A class that handles all the parsing, bwc and deprecations surrounding date histogram intervals.
An abstraction over date math parsing to allow different implementation for joda and java time.
A simple wrapper class that indicates that the wrapped query has made use of NOW when parsing its datemath.
Implement this interface to provide a decay function that is executed on a distance.
This is the base class for scoring a single field.
Parser used for all decay functions, one instance each.
This abstract class defining basic Decision used during shard allocation process.
Simple class representing a list of decisions
Simple class representing a single decision
This enumeration defines the possible types of decisions
Inspects token streams for duplicate sequences of tokens.
No-op visitor for subclassing.
No-op visitor for subclassing.
No-op visitor for subclassing.
The default rest channel for incoming requests.
A BucketCollector that records collected doc IDs and buckets and allows to replay a subset of the collected buckets.
Compressor implementation based on the DEFLATE compression algorithm.
A holder for Writeables that delays reading the underlying object on the receiving end.
A Writeable stored in serialized form backed by a ReleasableBytesReference.
The DelayedAllocationService listens to cluster state changes and checks if there are unassigned shards with delayed allocation (unassigned shards that have the delay marker).
A wrapper around reducing buckets with the same key that can delay that reduction as long as possible.
An exception marking that this recovery attempt should be ignored (since probably, we already recovered).
Creates a new DeleteByQueryRequest that uses scrolling and bulk requests to delete all documents matching the query.
This action causes a dangling index to be considered as deleted by the cluster.
Represents a request to delete a particular dangling index, specified by its UUID.
Cluster state update request that allows to close one or more indices
A request to delete an index.
A request to delete an index template.
Unregister repository action
Unregister repository request.
Builder for unregister repository request
A request to delete a document from an index based on its type and id.
A delete document action request builder.
The response of the delete action.
Builder class for DeleteResponse.
The result of deleting multiple blobs from a BlobStore.
Delete snapshot action
Delete snapshot request
Delete snapshot request builder
A variable that can be resolved by an injector.
A logger message used by DeprecationLogger.
Deprecation log messages are categorised so that consumers of the logs can easily aggregate them.
A logger that logs deprecation notices.
DeprecationRestHandler provides a proxy for any existing RestHandler so that usage of the handler can be logged using the DeprecationLogger.
A Recycler implementation based on a Deque.
Helper for dealing with destructive operations and wildcard usage.
Dfs phase of a search request, used to make scoring 100% accurate by collecting additional info from each shard before the query phase.
Represents difference between states of cluster state parts
Cluster state part, changes in which can be serialized
This is a Map<String, String> that implements AbstractDiffable so it can be used for cluster state purposes
Represents differences between two DiffableStringMaps.
Implementation of the ValueSerializer that wraps value and diff readers.
Serializer for Diffable map values.
Represents differences between two ImmutableOpenMap of (possibly diffable) objects
Provides read and write operations to serialize keys of map
Represents differences between two maps of objects and is used as base class for different map implementations.
Serializer for non-diffable map values
Implementation of ValueSerializer that serializes immutable sets
Provides read and write operations to serialize map values.
This attribute can be used to indicate that the PositionLengthAttribute should not be taken in account in this TokenStream.
Default implementation of DisableGraphAttribute.
A pluggable module allowing to implement discovery of other nodes, publishing of the cluster state to all nodes, electing a master of the cluster that raises cluster state change events.
A module for loading classes for node discovery.
A discovery node represents a node that is part of the cluster.
Represents a node role.
This class holds all DiscoveryNode in the cluster and provides convenience methods to access, modify merge / diff discovery nodes.
An additional extension point for Plugins that extends Elasticsearch's discovery functionality.
Exposes common discovery settings that may be supported by all the different discovery implementations
Deals with rolling upgrades of the cluster coordination layer.
The DiskThresholdDecider checks that the node a shard is potentially being allocated to has enough disk space.
Listens for a node to go over the high watermark and kicks off an empty reroute if it does.
A container to keep settings for disk thresholds up to date with cluster setting changes.
Encapsulation class used to represent the amount of disk used on a node.
A query that generates the union of documents produced by its sub-queries, and that scores each document with the maximum score for that document as produced by any sub-query, plus a tie breaking increment for any additional matching sub-queries.
Response listener for REST requests which dispatches the serialization of the response off of the thread on which the response was received, since that thread is often a transport thread and XContent serialization might be expensive.
A query to boost scores based on their proximity to the given origin for date, date_nanos and geo_point field types
The DistanceUnit enumerates several units for measuring distances.
This class implements a value+unit tuple.
Alternative, faster implementation for converting String keys to longs but with the potential for hash collisions.
Mapper for the doc_count field.
An implementation of a doc_count provider that reads the value of the _doc_count field in the document.
A SliceQuery that partitions documents based on their Lucene ID.
Access the document in a script, provides both old-style, doc['fieldname'], and new style field('fieldname') access to the fields.
A single field name and values part of SearchHit and GetResult.
A parser for documents
Context used when parsing incoming documents.
Value fetcher that loads from doc values.
A formatter for values as returned by the fielddata/doc-values APIs.
Singleton, stateless formatter, for representing bytes as base64 strings
Stateless, Singleton formatter for boolean values.
Singleton, stateless formatter for geo hash values
Stateless, singleton formatter for IP address data
Singleton, stateless formatter for "Raw" values, generally taken to mean keywords and other strings.
DocValues format for unsigned 64 bit long values, that are stored as shifted signed 64 bit long values.
Provide access to DocValues for script field api and doc API.
A SliceQuery that uses the numeric doc values of a field to do the slicing.
Generic interface to group ActionRequest, which perform writes to a single document Action requests implementing this can be part of BulkRequest
Requested operation type to perform on the document
A base class for the response of a write operation that involves a single doc
Base class of all DocWriteResponse builders.
An enum that represents the results of CRUD operations, primarily used to communicate the type of operation that occurred.
Abstraction of an array of double values.
Represent hard_bounds and extended_bounds in histogram aggregations.
Result of the TermsAggregator when the field is some kind of decimal number like a float, double, or distance.
Comparator source for double values.
Drop processor only returns null for the execution result to indicate that any document executed by it should not be indexed.
A Trie structure for analysing byte streams for duplicate sequences.
Provides statistics useful for detecting duplicate sections of text
Defines a MappedFieldType that exposes dynamic child field types If the field is named 'my_field', then a user is able to search on the field in both of the following ways: - Using the field name 'my_field', which will delegate to the field type as usual.
DynamicMap is used to wrap a Map for a script parameter.
The type of a field as detected while parsing a json document.
A Collector that early terminates collection after maxCountHits docs have been collected.
This exception is thrown when Elasticsearch detects an inconsistency in one of it's persistent files.
A FilterDirectoryReader that exposes Elasticsearch internal per shard / index information like the shard ID.
A base class for all elasticsearch exceptions.
A generic exception indicating failure to generate.
A FilterLeafReader that exposes Elasticsearch internal per shard / index information like the shard ID.
A MergePolicy that upgrades segments and can upgrade merges.
Unchecked exception that is translated into a 400 BAD REQUEST error when it bubbles out over HTTP.
Generic security exception
Exception who's RestStatus is arbitrary rather than derived.
The same as TimeoutException simply a runtime one.
An exception that is meant to be "unwrapped" when sent back to the user as an error because its is cause, if non-null is always more useful to the user than the exception itself.
It's provably impossible to guarantee that any leader election algorithm ever elects a leader, but they generally work (with probability that approaches 1 over time) as long as elections occur sufficiently infrequently, compared to the time it takes to send a message to another node and receive a response back.
Allows plugging in a custom election strategy, restricting the notion of an election quorum.
a class to encapsulate all the information about a candidate in a master election that is needed to decided which of the candidates should win
A core component of a module or injector.
Exposes elements of a module so they can be inspected, validated or rewritten.
Visit elements.
ClusterInfoService that provides empty maps for disk usage and shard sizes
Script field with no mapping, always returns defaultValue.
Allocation values or rather their string representation to be used used with EnableAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ENABLE_SETTING / EnableAllocationDecider.INDEX_ROUTING_ALLOCATION_ENABLE_SETTING via cluster / index settings.
Rebalance values or rather their string representation to be used used with EnableAllocationDecider.CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING / EnableAllocationDecider.INDEX_ROUTING_REBALANCE_ENABLE_SETTING via cluster / index settings.
EnableAssignmentDecider is used to allow/disallow the persistent tasks to be assigned to cluster nodes.
Allocation values or rather their string representation to be used used with EnableAssignmentDecider.CLUSTER_TASKS_ALLOCATION_ENABLE_SETTING via cluster settings.
Whether we should read history operations from translog or Lucene index
A throttling class that can be activated, causing the acquireThrottle method to block on a lock when throttling is enabled
A Lock implementation that always allows the lock to be acquired
type of operation (index, delete), subclasses use static types
Base class for index and delete operation results Holds result meta data (e.g.
Called for each new opened engine reader to warm new segments
An exception indicating that an Engine creation failed.
Simple Engine Factory
A plugin that provides alternative engine implementations.
The environment of where things exists.
A cli command which requires an Environment to use current paths and settings.
Handles errors in the Injector.
A collection of error messages.
Indicates that a result could not be returned while preparing or resolving a binding.
Cache helper that allows swapping in implementations that are different to Lucene's IndexReader.CacheHelper which ties its lifecycle to that of the underlying reader.
Implementation of ESCacheHelper that wraps an IndexReader.CacheHelper.
Formats log events as strings in a json format.
A base class for custom log4j logger messages.
Pattern converter to populate ESMessageField in a pattern.
An extension to thread pool executor, allowing (in the future) to add specific additional stats to it.
A ToParentBlockJoinQuery that allows to retrieve its nested path.
An EvictingQueue is a non-blocking queue which is limited to a maximum size; when new elements are added to a full queue, elements are evicted from the head of the queue to accommodate the new elements.
Calculate a exponentially weighted moving average
ExecutorBuilder<U extends org.elasticsearch.threadpool.ExecutorBuilder.ExecutorSettings>
Base class for executor builders.
A class that gathers the names of thread pool executors that should be used for a particular system index or system data stream.
Some operations need to use different executors for different index patterns.
Searches for, and allocates, shards for which there is an existing on-disk copy somewhere in the cluster.
Constructs a query that only match on documents that the field has a value in them.
To be implemented by ScoreScript which can provided an Explanation of the score This is currently not used inside elasticsearch but it is used, see for example here:
Entry point for the explain feature.
Explains the scoring calculations for the top hits.
Explain request encapsulating the explain query and document identifier to get an explanation for.
A builder for ExplainRequest.
Response containing the score explanation.
Holds a value that is either: a) set implicitly e.g.
Implements exponentially weighted moving averages (commonly abbreviated EWMA) for a single value.
Accompanies a @Provides method annotation in a private module to indicate that the provided binding is exposed.
A binding to a key exposed from an enclosed private environment.
For private binder's expose() method.
Since max_optimization optimization landed in 7.0, normal MatchQuery will achieve the same result without any configuration.
Statistics over a set of values (either aggregated over field data or scripts)
Extended Statistics over a set of buckets
An extension point for Plugin implementations to be themselves extensible.
Provides a factory that combines the caller's arguments with injector-supplied values to construct objects.
Lazily creates (and caches) values for keys.
A class representing a failed shard.
Thrown when failing to publish a cluster state.
A base class for MasterFaultDetection & NodesFaultDetection, making sure both use the same setting.
Holds the results of the most recent attempt to migrate system indices.
Encapsulates state required to execute fetch phases
All the required context to pull a field from the doc values.
Fetch sub phase which pulls data from doc values.
The context needed to retrieve fields.
A fetch sub-phase for high-level field retrieval.
Fetch phase of a search request, used to fetch the actual top matching documents to be returned to the client, identified after reducing all of the matches returned by the query phase
Context used to fetch the _source.
Sub phase within the fetch phase used to fetch things *about* the documents like highlighting or matched queries.
Executes the logic for a FetchSubPhase against a particular leaf reader and hit
A field in a document accessible via scripting.
A mapper for field aliases.
Wrapper around a field name and the format that should be used to display values of this field.
Describes the capabilities of a field optionally merged across multiple indices.
Response for FieldCapabilitiesRequest requests.
Used by all field data based aggregators.
Utility methods, similar to Lucene's DocValues.
A helper class to FetchFieldsPhase that's initialized with a list of field patterns to fetch.
A Builder for a ParametrizedFieldMapper
Represents a list of fields with optional boost factor where the current field should be copied to
A configurable parameter for a field mapper
Serializes a parameter
Check on whether or not a parameter should be serialized
TypeParser implementation that automatically handles parsing
A reusable class to encode field -&gt; memory size mappings
A mapper that indexes the field names of a document under _field_names.
Stored fields visitor which provides information about the field names that will be requested
A script to produce dynamic values for return fields.
A factory to construct FieldScript instances.
Holds stats about the content of a script
A sort builder to sort based on a document field.
Holds stats about a mapped field.
Base StoredFieldVisitor that retrieves all non-redundant metadata.
Wraps a DirectoryReader and tracks all access to fields, notifying a FieldUsageTrackingDirectoryReader.FieldUsageNotifier upon access.
A function_score function that multiplies the score with the value of a field from the document, optionally multiplying the field by a factor first, and applying a modification (log, ln, sqrt, square, etc) afterwards.
The Type class encapsulates the modification types that can be applied to the score/value product.
Builder to construct field_value_factor functions for a function score query.
Represents values for a given document
An implementation of SeedHostsProvider that reads hosts/ports from FileBasedSeedHostsProvider.UNICAST_HOSTS_FILE.
Callback interface that file changes File Watcher is using to notify listeners about changes.
This context will execute a file restore of the lucene files.
This class provides utility methods for calling some native methods related to filesystems.
Elasticsearch utils to work with Path
File resources watcher The file watcher checks directory and all its subdirectories for file changes and notifies its listeners accordingly
A filter aggregation.
A frequency TermsEnum that returns frequencies derived from a collection of cached leaf termEnums.
Aggregate all docs that match a filter.
This AllocationDecider control shard allocation by include and exclude filters via dynamic cluster and index routing settings.
Collects results by running each filter against the searcher and doesn't build any LeafBucketCollectors which is generally faster than FiltersAggregator.Compatible but doesn't support when there is a parent aggregator or any child aggregators.
Builds FilterByFilterAggregator when the filters are valid and it would be faster than a "native" aggregation implementation.
A Client that contains another Client which it uses as its basic source, possibly transforming the requests / responses along the way or providing additional functionality.
IndexOutput that delegates all calls to another IndexOutput
A multi bucket aggregation where the buckets are defined by a set of filters (a bucket per filter).
A bucket associated with a specific filter (identified by its key)
Aggregator for filters.
A script implementation of a query filter.
A factory to construct stateful FilterScript factories for a specific index.
A factory to construct FilterScript instances.
Wraps a StreamInput and delegates to it.
Context for finalizing a snapshot.
Represents a request to find a particular dangling index by UUID.
Models a response to a FindDanglingIndexRequest.
A builder for fixed executors.
A field mapper that accepts a JSON object and flattens it into a single field.
A field data implementation that gives access to the values associated with a particular JSON key.
A field type that represents the values under a particular JSON key, used when searching under a specific key as in 'my_flattened.key: some_value'.
A field type that represents all 'root' values.
Abstraction of an array of double values.
Comparator source for float values.
A flush request to flush one or more indices.
A response to flush action.
The FollowersChecker is responsible for allowing a leader to check that its followers are still connected and healthy.
A request to force merging the segments of one or more indices.
A request to force merge one or more indices.
A response for force merge action.
Simple helper class for FastVectorHighlighter FragmentsBuilder implementations.
A frequency terms enum that maintains a cache of docFreq, totalTermFreq, or both for repeated term lookup.
A file system based implementation of BlobContainer.
Runs periodically and attempts to create a temp file to see if the filesystem is writable.
Shared file system implementation of the BlobStoreRepository
A query that allows for a pluggable boost function / filter.
A query that uses a filters with a script associated with them to compute the score.
Function to be associated with an optional filter, meaning it will be executed only for the documents that match the given filter.
A response handler to be used when all interaction will be done through the TransportFuture.
A unit class that encapsulates all in-exact search parsing and conversion from similarities to edit distances etc.
Fuzzy options for completion suggester
Options for fuzzy queries
A Query that does fuzzy matching for a specific value.
Loads (and maybe upgrades) cluster metadata at startup, and persistently stores cluster metadata for future restarts.
Use ScriptException for exceptions from the scripting engine, otherwise use a more appropriate exception (e.g.
A class representing a Geo-Bounding-Box for use by Geo queries and aggregations that deal with extents/rectangles representing rectangular areas of interest.
Creates a Lucene query that will filter for all documents that lie within the specified bounding box.
An aggregation that computes a bounding box in which all documents of the current bucket are.
Interface for GeoCentroidAggregator
A ContextMapping that uses a geo location/area as a criteria.
Geo distance calculation.
Filter results of a query to include only those within a specific distance to some geo point.
A geo distance based sorting on a geo point like field.
Specifies how a geo query should be run.
Output formatters for geo fields support extensions such as vector tiles.
Defines an extension point for geometry formatter
A geo-grid aggregation.
A bucket that is associated with a geo-grid cell.
Aggregates data expressed as longs (for efficiency's sake) but formats results as aggregation-specific strings.
Class to help convert MultiGeoPointValues to GeoHash bucketing.
Aggregates data expressed as GeoHash longs (for efficiency's sake) but formats results as Geohash strings.
Utility class for converting libs/geo shapes to and from GeoJson
Splits lines by datelines.
Output formatters supported by geometry fields.
Utility class for binary serializtion/deserialization of libs/geo classes
An utility class with to read geometries from a XContentParser or generic object.
Supported formats to read/write JSON geometries.
Field Mapper for geo_point types.
Script producing geo points.
Per-document geo-point values.
Splits polygons by datelines.
Defines the query context for GeoContextMapping
FieldMapper for indexing LatLonShapes.
Utility class that converts geometries into Lucene-compatible form for indexing in a geo_shape field.
Implemented by MappedFieldType that support GeoShape queries.
Derived AbstractGeometryQueryBuilder that builds a lat, lon GeoShape Query.
Utility class that transforms Elasticsearch geometry objects to the Lucene representation
Class to help convert MultiGeoPointValues to GeoTile bucketing.
Aggregates data expressed as geotile longs (for efficiency's sake) but formats results as geotile strings.
Implements geotile key hashing, same as used by many map tile implementations.
Represents the point of the geohash cell that should be used as the value of geohash
This enum is used to determine how to deal with invalid geo coordinates in geo related queries: On STRICT validation invalid coordinates cause an exception to be thrown.
Action to retrieve one or more component templates
Request that to retrieve one or more component templates
Request that to retrieve one or more index templates
Action for getting a feature upgrade status.
Request for whether system features need to be upgraded
A response showing whether system features need to be upgraded and, feature by feature, which indices need to be upgraded.
A class for a particular feature, showing whether it needs to be upgraded and the earliest Elasticsearch version used to create one of this feature's system indices.
A data class that holds an index name and the version of Elasticsearch with which that index was created
Request the mappings of specific fields Note: there is a new class with the same name for the Java HLRC that uses a typeless format.
A helper class to build GetFieldMappingsRequest objects
Response object for GetFieldMappingsRequest API Note: there is a new class with the same name for the Java HLRC that uses a typeless format.
A request to retrieve information about an index.
A response for a get index action.
Request that allows to retrieve index templates
Get repositories action
Get repository request
Get repository request builder
Get repositories response
A request to get a document (its source) from an index based on its id.
A get document action request builder.
The response of a get action.
Describes the context of fetching one or more SnapshotInfo via Repository.getSnapshotInfo(GetSnapshotInfoContext).
Get snapshots action
Get snapshot request
Get snapshots request builder
Get snapshots response
ActionType for retrieving a list of currently running tasks
A request to get node tasks
Builder for the request to retrieve the list of tasks running on the specified nodes
Returns the list of tasks currently running on the nodes
A global aggregation.
Represents a collection of global checkpoint listeners.
A global checkpoint listener consisting of a callback that is notified when the global checkpoint is updated or the shard is closed.
Background global checkpoint sync action initiated when a shard goes inactive.
An aggregator that computes approximate counts of unique values using global ords.
Utility class to build global ordinals.
Concrete implementation of IndexOrdinalsFieldData for global ordinals.
An aggregator of string values that relies on global ordinals in order to build buckets.
An action listener that delegates its results to another listener once it has received N results (either successes or failures).
This class implements a compilation of ShardIterators.
The entry point to the Guice framework.
A TransportAction that self registers a handler into the transport service
Implemented by bindings, providers and instances that expose their dependencies explicitly.
This is a simplistic logger that adds warning messages to HTTP headers.
CircuitBreakerService that attempts to redistribute space between breakers if tripped
A builder for search highlighting.
Highlights a search result.
A field highlighted with its highlighted fragments.
A histogram aggregation.
A bucket in the histogram where documents fall in
A builder for histograms on numeric fields.
Constructs the per-shard aggregator instance for histogram aggregation.
Implemented by histogram aggregations and used by pipeline aggregations to insert buckets.
Per-document histogram value.
Per-segment histogram values.
A CompositeValuesSourceBuilder that builds a HistogramValuesSource from another numeric values source using the provided interval.
Calculate a doubly exponential weighted moving average
Calculate a triple exponential weighted moving average
Tracks a collection of HttpStats.ClientStats for current and recently-closed HTTP connections.
A basic http request abstraction.
A basic http response abstraction.
Dispatches HTTP requests.
Serves as a node level registry for hunspell dictionaries.
Hyperloglog++ counter, implemented based on pseudo code from and its appendix This implementation is different from the original implementation in that it uses a hash table instead of a sorted list for linear counting.
A mapper for the _id field.
A query that will return only documents matching specific ids (and a type).
Simple class to log ifconfig-style output at DEBUG logging.
A field mapper that records fields that have been ignored because they were malformed.
This exception defines illegal states of shard routing
Exception thrown if trying to mutate files in an immutable directory.
An immutable map implementation based on open hash map.
An immutable map implementation based on open hash map.
A pointer to the default implementation of a type.
Represents a request to import a particular dangling index.
Represents a request to import a particular dangling index, specified by its UUID.
Handles inbound messages by first deserializing a TransportMessage from an InboundMessage and then passing it to the appropriate handler.
Defines the include/exclude regular expression filtering for string terms aggregation.
Thrown by Diff.apply(T) method
Tracks the metadata written to disk, allowing updated metadata to be written incrementally (i.e.
A value class representing the basic required properties of an Elasticsearch index.
An index abstraction is a reference to one or more concrete indices.
Represents an alias and groups all IndexMetadata instances sharing the same alias name together.
Represents an concrete index and encapsulates its IndexMetadata
An index abstraction type.
IndexAnalyzers contains a name to analyzer mapping for a specific index.
Exception indicating that one or more requested indices are closed.
The result of analyzing disk usage of each field in a shard/index
Disk usage stats for a single field
An index event listener is the primary extension point for plugins and build-in services to react / listen to per-index and per-shard events.
Statistics about an index feature.
Describes the capabilities of a field in a single index.
Thread-safe utility class that allows to get per-segment values via the IndexFieldData.load(LeafReaderContext) method.
Simple wrapper class around a filter that matches parent documents and a filter that matches child documents.
A simple field data cache abstraction on the *index* level.
Specialization of IndexFieldData for geo points.
A collection of tombstones for explicitly marking indices as deleted in the cluster state.
A class to build an IndexGraveyard.
A class representing a diff of two IndexGraveyard objects.
An individual tombstone entry for representing a deleted index.
Specialization of IndexFieldData for histograms.
Represents a single snapshotted index in the repository.
An indexing listener for indexing, delete, events.
A Composite listener that multiplexes calls to each of the listeners methods.
Class representing an (inclusive) range of long values in a field in an index which may comprise multiple shards.
Tracks the blob uuids of blobs containing IndexMetadata for snapshots as well an identifier for each of these blobs.
Observer that tracks changes made to RoutingNodes in order to update the primary terms and in-sync allocation ids in IndexMetadata once the allocation round has completed.
This service is responsible for verifying index metadata when an index is introduced to the cluster, for example when restarting nodes, importing dangling indices, or restoring an index from a snapshot repository.
IndexModule represents the central extension point for index level custom implementations like: Similarity - New Similarity implementations can be registered through IndexModule.addSimilarity(String, TriFunction) while existing Providers can be referenced through Settings under the IndexModule.SIMILARITY_SETTINGS_PREFIX prefix along with the "type" value.
This is a context for the DateMathExpressionResolver which does not require IndicesOptions or ClusterState since it uses only the start time to resolve expressions.
Base class for numeric field data.
The type of number.
Specialization of IndexFieldData for data that is indexed with ordinals.
OutputStream that writes into underlying IndexOutput
An IndexPatternMatcher holds an index pattern in a string and, given a Metadata object, can return a list of index names matching that pattern.
Thrown when some action cannot be performed because the primary shard of some shard group in an index has not been allocated post api action.
The index-level query cache.
Index request to index a typed JSON document into a specific index and make it searchable.
An index document action request builder.
A response of an index operation,
Builder class for IndexResponse.
Generates the shard id for (id, routing) pairs.
The IndexRoutingTable represents routing information for a single index.
Encapsulates all valid index level settings.
An IndexSettingProvider is a provider for index level settings that can be set explicitly as a default value (so they show up as "set" for newly created indices)
This class encapsulates all index level settings and handles settings updates.
Simple struct encapsulating a shard failure
Generic shard restore exception
Thrown when restore of a shard fails
IndexShardRoutingTable encapsulates all instances of a single shard.
Generic shard snapshot exception
Thrown when snapshot process is failed on a shard level
Represent shard snapshot status
Returns an immutable state of IndexShardSnapshotStatus at a given point in time.
Snapshot stage
Holds all the information that is used to build the sort order of an index.
A plugin that provides alternative directory implementations.
An interface that describes how to create a new directory instance per shard.
IndexStorePlugin.IndexFoldersDeletionListener are invoked before the folders of a shard or an index are deleted from disk.
An interface that allows to create a new RecoveryState per shard.
An interface that allows plugins to override the IndexCommit of which a snapshot is taken.
A handle on the execution of warm-up action.
Administrative actions/operations against indices.
Cluster state update request that allows to add or remove aliases
A request to add/remove aliases for one or more indices.
Request to take one or more actions on one or more indexes and alias combinations.
Builder for request to modify many aliases at once.
Base cluster state update request that allows to execute update against multiple indices
Configures classes and services that are shared by indices on each node.
Controls how to deal with unavailable concrete indices (closed or missing), how wildcard expressions are expanded to actual indices (all, closed or open indices) and how to deal with wildcard expressions that resolve to no indices.
Needs to be implemented by all ActionRequest subclasses that relate to one or more indices.
The indices request cache allows to cache a shard level request stage responses, helping with improving similar requests that are potentially expensive (because of aggs for example).
Request builder for IndicesShardStoresRequest
ActionType for TransportIndicesShardStoresAction Exposes shard store information for requested indices.
Response for IndicesShardStoresAction Consists of IndicesShardStoresResponse.StoreStatuss for requested indices grouped by indices and shard ids and a list of encountered node IndicesShardStoresResponse.Failures
Single node failure while retrieving shard store information
Shard store information from a node
The status of the shard store with respect to the cluster
A request to get indices level stats.
A request to get indices level stats.
Holds information about currently in-flight shard level snapshot or clone operations on a per-shard level.
A utility for forwarding ingest requests to ingest nodes in a round-robin fashion.
A script used by ConditionalProcessor.
Represents a single document being captured before indexing and holds the source and metadata (like id, type and index).
Holds the ingest pipelines that are available in the cluster
An extension point for Plugin implementations to add custom ingest processors
A dedicated wrapper for exceptions encountered executing an ingest processor.
A script used by the Ingest Script Processor.
Holder class for several ingest related services.
Container for pipeline stats.
Container for processor stats.
Annotates members of your implementation class (constructors, methods and fields) into which the Injector should inject values.
Listens for injections into instances of type I.
A constructor, field or method that can receive injections.
A request to inject the instance fields and methods of an instance.
Builds the graphs of objects that make up your application.
Context used for inner hits retrieval
A SubSearchContext that associates TopDocs to each SearchHit in the parent search context
A binding to a single instance.
Abstraction of an array of integer values.
An internal implementation of Aggregation.
An internal implementation of Aggregations.
Implementation of Histogram.
A range aggregation for data that is encoded in doc values using a binary representation.
InternalClusterInfoService provides the ClusterInfoService interface, routinely updated on a timer.
Internal context.
Implementation of Histogram.
Creates objects which will be injected.
ES: An factory that returns a pre created instance.
Serialization and merge logic for GeoCentroidAggregator.
Represents a grid of cells where each cell's location is determined by a specific geo hashing algorithm.
Represents a grid of cells where each cell's location is determined by a geohash.
Represents a grid of cells where each cell's location is determined by a geohash.
A global scope get (the document set on which we aggregate is all documents in the search context (ie.
Implementation of Histogram.
Common superclass for results of the terms aggregation on mapped fields.
Result of the NestedAggregator.
Implementations for MultiBucketsAggregation.Bucket ordering strategies.
MultiBucketsAggregation.Bucket ordering strategy to sort by a sub-aggregation.
MultiBucketsAggregation.Bucket ordering strategy to sort by multiple criteria.
Contains logic for parsing a BucketOrder from a XContentParser.
Contains logic for reading/writing BucketOrder from/to streams.
This class wraps a Lucene Collector and times the execution of: - setScorer() - collect() - doSetNextReader() - needsScores() InternalProfiler facilitates the linking of the Collector graph
Reads a bucket.
SearchResponseSections subclass that can be serialized over the wire.
Result of the significant terms aggregation.
Reads a bucket.
A base class for all the single bucket aggregations.
Reads a bucket.
Results of the TopHitsAggregator.
An internal implementation of ValueCount.
Constructs an IntervalsSource based on analyzed text
Base class for scripts used as interval filters, see IntervalsSourceProvider.IntervalFilter
Builder for IntervalQuery
Factory class for IntervalsSource Built-in sources include IntervalsSourceProvider.Match, which analyzes a text string and converts it to a proximity source (phrase, ordered or unordered depending on how strict the matching should be); IntervalsSourceProvider.Combine, which allows proximity queries between different sub-sources; and IntervalsSourceProvider.Disjunction.
Thrown on the attempt to create a snapshot with invalid name
A FieldMapper for ip addresses.
Script producing IP addresses.
Doc values implementation for ips.
This class is loaded by JVM SPI mechanism in order to provide ISO compatible behaviour for week calculations using java.time.
A class encapsulating the usage of a particular "thing" by something else
A parser for date/time formatted text with optional date math.
A wrapper around ZonedDateTime that exposes joda methods for backcompat.
A parser for date/time formatted text with optional date math.
Triggered by a StartJoinRequest, instances of this class represent join votes, and have a source and target node.
Outputs the Throwable portion of the LoggingEvent as a Json formatted field with array "exception": [ "stacktrace", "lines", "as", "array", "elements" ] Reusing @link org.apache.logging.log4j.core.pattern.ExtendedThrowablePatternConverter which already converts a Throwable from LoggingEvent into a multiline string
Binding key consisting of an injection type and an optional annotation.
Defines behavior for comparing bucket keys to imposes a total ordering of buckets of the same type.
The atomic field data implementation for FlattenedFieldMapper.KeyedFlattenedFieldType.
This class manages locks.
An EnvironmentAwareCommand that needs to access the elasticsearch keystore, possibly decrypting it if it is password protected.
A disk based container for sensitive settings in Elasticsearch.
A field mapper for keywords.
A publication can succeed and complete before all nodes have applied the published state and acknowledged it; however we need every node eventually either to apply the published state (or a later state) or be removed from the cluster.
An action listener that allows passing in a CountDownLatch that will be counted down after onResponse or onFailure is called
Encapsulates a CheckedSupplier which is lazily invoked once on the first call to #getOrCompute().
This is a modified version of SoftDeletesDirectoryReaderWrapper that materializes the liveDocs bitset lazily.
Tracks the state of sliced subtasks and provides unified status information for a sliced BulkByScrollRequest.
The LeaderChecker is responsible for allowing followers to check that the currently elected leader is still connected and healthy.
Collects results for a particular segment.
A LeafBucketCollector that delegates all calls to the sub leaf aggregator and sets the scorer on its source of values if it implements ScorerAware.
Specialization of LeafNumericFieldData for floating-point numerics.
The thread safe LeafReader level cache of the data.
LeafFieldData specialization for geo points.
LeafFieldData specialization for histogram data.
Specialization of LeafNumericFieldData for integers.
Manages loading information about nested documents for a single index segment
Specialization of LeafFieldData for numeric data.
Specialization of LeafFieldData for data that is indexed with ordinals.
Provides direct access to a LeafReaderContext
RuntimeField base class for leaf fields that will only ever return a single MappedFieldType from RuntimeField.asMappedFieldTypes().
Per-leaf ScoreFunction.
Per-segment version of SearchLookup.
Lifecycle state.
This analyzer limits the highlighting once it sees a token with a start offset <= the configured limit, which won't pass and will end the stream.
Linear interpolation smoothing model.
Calculate a linearly weighted moving average, such that older values are linearly less important.
See the EDSL examples at Binder.
A binding to a linked key.
Represents a request to list all dangling indices known to the cluster.
Models a response to a ListDanglingIndicesRequest.
A Future and ActionListener against which which other ActionListeners can be registered later, to support fanning-out a result to a dynamic collection of listeners.
A future implementation that allows for the result to be passed to listeners waiting for notification.
ActionType for retrieving a list of currently running tasks
A request to get node tasks
Builder for the request to retrieve the list of tasks running on the specified nodes
Returns the list of tasks currently running on the nodes
Transport level private response for the transport handler registered under "cluster:monitor/nodes/liveness"
Transport level private response for the transport handler registered under "cluster:monitor/nodes/liveness"
This class generates sequences numbers and keeps track of the so-called "local checkpoint" which is the highest number for which all previous sequence numbers have been processed (inclusive).
Used to apply state updates on nodes that are not necessarily master
Utilities for for dealing with Locale objects
Enables listening to master changes events of the local node (when the local node becomes the master, and when the local node cease being a master).
Converts utc into local time and back again.
How to get instances of LocalTimeOffset.
An InfoStream (for Lucene's IndexWriter) that redirects messages to "lucene.iw.ifd" and "lucene.iw" Logger.trace.
Format string for Elasticsearch log messages.
A set of utilities around Logging.
A command that is aware of logging.
A multi-command that is aware of logging.
Logs deprecations to the DeprecationLogger.
A TaskListener that just logs the response at the info level.
Abstraction of an array of long values.
Represent hard_bounds and extended_bounds in date-histogram aggregations.
Specialized hash table implementation similar to BytesRefHash that maps long values to ids.
Maps owning bucket ordinals and long bucket keys to bucket ordinals.
An iterator for buckets inside a particular owningBucketOrd.
Implementation that works properly when collecting from many buckets.
Implementation that packs the owningbucketOrd into the top bits of a long and uses the bottom bits for the value.
Implementation that only works if it is collecting from a single bucket.
Specialized hash table implementation similar to BytesRefHash that maps two long values to ids.
A hash table from native longs to objects.
Result of the RareTerms aggregation when the field is some kind of whole number like a integer, long, or a date.
An aggregator that finds "rare" string values (e.g.
Result of the TermsAggregator when the field is some kind of whole number like a integer, long, or a date.
Comparator source for long values.
Normalizer used to lowercase values
Builds an analyzer for normalization that lowercases terms.
Fork of Document with additional functionality.
This file is forked from the project.
This class represents the manifest file, which is the entry point for reading meta data from disk.
An API to bind multiple map entries separately, only to later inject them as a complete map.
The actual mapbinder plays several roles:
This defines the core properties and functions to operate on a field.
An enum used to describe the relation between the range of terms in a shard when compared with a query range
Holds context for building Mapper objects from their Builders
An extension point for Plugin implementations to add custom mappers
A registry for all field mappers.
The reason why a mapping is being merged.
Wrapper around everything that defines a mapping, without references to utility classes like MapperService, ...
A (mostly) immutable snapshot of the current mapping of an index with access to everything we need for the search phase.
Key for the lookup to be used in caches.
Mapping configuration for a type.
Parser for Mapping provided in CompressedXContent format
Holds everything that is needed to parse mappings.
Usage statistics about mappings usage.
Called by shards in the cluster when their mapping was dynamically updated and it needs to be updated in the cluster state meta data (and broadcast to all members).
An aggregator of string values that hashes the strings on the fly rather than up front like the GlobalOrdinalsStringTermsAggregator.
Abstraction on top of building collectors to fetch values so terms, significant_terms, and significant_text can share a bunch of aggregation code.
Fetch values from a ValuesSource.
A fault detection that pings the master periodically to see if its alive.
Thrown when a ping reaches the wrong node
Base request builder for master node operations
Base request builder for master node read operations that can be executed on the local node as well
Base request for master based read operations that allows to read the cluster state from the local node if needed
A based request for master based operation.
A query that matches on all documents.
The boolean prefix query analyzes the input text and creates a boolean query containing a Term query for each term, except for the last term, which is used to create a prefix query
Returns true or false for a given input.
Matcher implementations.
A query that matches no document.
Match query is a query that analyzes the text and constructs a phrase prefix query as the result of the analysis.
Match query is a query that analyzes the text and constructs a phrase query as the result of the analysis.
Match query is a query that analyzes the text and constructs a query as the result of the analysis.
An aggregation that computes the maximum of the values in the current bucket.
Condition for index maximum age.
Condition for maximum index docs.
A size-based condition for the primary shards within an index.
An allocation decider that prevents shards from being allocated on any node if the shards allocation has been retried N times without success.
A collector that computes the maximum score.
A size-based condition for an index size.
An aggregation that approximates the median absolute deviation of a numeric field
Injects dependencies into the fields and methods on instances of type T.
A lookup of the members injector for a type.
Utility methods to get memory sizes.
Interface to allow merging Metadata.Custom.
Query merging two point in range queries.
A shard in elasticsearch is a Lucene index, and a Lucene index is broken down into segments.
The merge scheduler (ConcurrentMergeScheduler) controls the execution of merge operations once they are needed (according to the merge policy).
An error message and the context in which it occurred.
This MessageDigests class provides convenience methods for obtaining thread local MessageDigest instances for MD5, SHA-1, SHA-256 and SHA-512 message digests.
Metadata is the part of the ClusterState which persists across restarts.
Custom metadata that persists (via XContent) across restarts.
Service responsible for submitting create index requests
Handles data stream modification requests.
Deletes indices.
A mapper for a builtin field containing metadata about a document.
A type parser for an unconfigurable metadata field.
Service responsible for submitting add and remove aliases requests
Service responsible for submitting open/close index requests as well as for adding index blocks
Service responsible for submitting index templates updates
Service responsible for submitting mapping changes
Service responsible for handling rollover requests for write aliases and data streams
MetadataStateFormat is a base class to write checksummed XContent based files to one or more directories in a standardized directory structure.
Service responsible for submitting update index settings requests
Upgrades Metadata on startup on behalf of installed Plugins
Handles writing and loading Manifest, Metadata and IndexMetadata
Counterpart to AggregationInspectionHelper, providing helpers for some aggs that have package-private getters.
Handles updating the FeatureMigrationResults in the cluster state.
An aggregation that computes the minimum of the values in the current bucket.
MinAndMax<T extends Comparable<? super T>>
A class that encapsulates a minimum and a maximum, that are of the same type and Comparable.
A Query that only matches documents that are greater than or equal to a configured doc ID.
A missing aggregation.
Exception indicating that not all requested operations from LuceneChangesSnapshot are available.
Utility class that allows to return views of ValuesSources that replace the missing value with a configured value.
A module contributes configuration information, typically interface bindings, which will be used to create an Injector.
Static utility methods for creating and working with instances of Module.
See the EDSL example at override().
A more like this query that finds documents that are "like" the provided set of document(s).
A single item to be used for a MoreLikeThisQueryBuilder.
Static methods for working with types that we aren't publishing in the public Types API.
We cannot serialize the built-in Java member classes, which prevents us from using Members in our exception types.
The WildcardType interface supports multiple upper bounds and multiple lower bounds.
Abstract class which also provides some concrete parsing functionality.
Represents the common interface that all moving average models share.
A command that moves a shard from a specific node to another node.
Note: The shard needs to be in the state ShardRoutingState.STARTED in order to be moved.
Represents a decision to move a started shard, either because it is no longer allowed to remain on its current node or because moving it to another node will form a better cluster balance.
This pipeline aggregation gives the user the ability to script functions that "move" across a window of data, instead of single data points.
Provides a collection of static utility methods that can be referenced from MovingFunction script contexts
This class provides a custom script context for the Moving Function pipeline aggregation, so that we can expose a number of pre-baked moving functions like min, max, movavg, etc
An API to bind multiple values separately, only to later inject them as a complete collection.
The actual multibinder plays several roles:
A BucketCollector which allows running a bucket collection with several BucketCollectors.
An aggregation service that creates instances of MultiBucketConsumerService.MultiBucketConsumer.
An IntConsumer that throws a MultiBucketConsumerService.TooManyBucketsException when the sum of the provided values is above the limit (`search.max_buckets`).
An aggregation that returns multiple buckets
A bucket represents a criteria to which all documents that fall in it adhere to.
File chunks are sent/requested sequentially by at most one thread at any time.
A stateful lightweight per document set of GeoPoint values.
A single multi get response.
A single get item.
A multi get document action request builder.
Represents a failure.
Same as MatchQueryBuilder but supports multiple fields.
Ordinals implementation which is efficient at storing field data ordinals for multi-valued or sparse fields.
A multi search API request.
A request builder for multiple search requests.
A multi search response.
A search response item, holding the actual search response, or an error message if it failed.
A single multi get response.
Represents a failure.
Defines what values to pick in the case a document contains multiple values for a particular field.
Class to encapsulate a set of ValuesSource objects labeled by field name
Similar to ValuesSourceAggregationBuilder, except it references multiple ValuesSources (e.g.
Wraps MurmurHash3 to provide an interface similar to MessageDigest that allows hashing of byte arrays passed through multiple calls to Murmur3Hasher.update(byte[]).
Hash function based on the Murmur3 algorithm, which is the default as of Elasticsearch 2.0.
MurmurHash3 hashing functions.
A 128-bits hash.
Annotates named things.
Named analyzer is an analyzer wrapper around an actual analyzer (NamedAnalyzer.analyzer that is associated with a name (
NamedDiff<T extends Diffable<T>>
Diff that also support NamedWriteable interface
Diff that also support VersionedNamedWriteable interface
Value Serializer for named diffables
A registry from String to some class implementation.
A Writeable object identified by its name.
Wraps a StreamInput and associates it with a NamedWriteableRegistry
A registry for Writeable.Reader readers of NamedWriteable.
An entry in the registry, made up of a category class and name, and a reader for that category class.
Provides named XContent parsers.
Utility methods for use with @Named.
A nested aggregation.
Manages loading information about nested documents
Utility class to filter parent and children clauses when building nested queries.
A Mapper for nested objects
During query parsing this keeps track of the current nested level.
Utility functions for presentation of network addresses.
Represents a transport message sent over the network.
A module to handle registering and binding all network related classes.
Plugin for extending network and transport related classes
A custom name resolver can support custom lookup keys (my_net_key:ipv4) and also change the default inet address used in case no settings is provided.
Utilities for network interfaces / addresses binding and publishing.
A specific type of SettingsException indicating failure to load a class based on a settings value.
A node represent a node within a cluster (
This class represents the shard allocation decision and its explanation for a single node.
A class that captures metadata about a shard store on a node.
Pattern converter to format the node_and_cluster_id variable into JSON fields and cluster.uuid.
The NodeAndClusterIdStateListener listens to cluster state changes and ONLY when receives the first update it sets the clusterUUID and nodeID in log4j pattern converter NodeAndClusterIdConverter.
Client that executes actions on the local node.
An exception indicating that node is closed.
This component is responsible for maintaining connections from this node to all the nodes listed in the cluster state, and for disconnecting from nodes once they are removed from the cluster state.
A component that holds all data paths for a single node.
A functional interface that people can use to reference NodeEnvironment.shardLock(ShardId, String, long)