Class: Elastomer::Client::Index

Inherits:
Object
  • Object
show all
Defined in:
lib/elastomer/client/index.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(client, name) ⇒ Index

Create a new index client for making API requests that pertain to the health and management of individual indexes.

client - Elastomer::Client used for HTTP requests to the server name - The name of the index as a String or an Array of names



25
26
27
28
 
# File 'lib/elastomer/client/index.rb', line 25

def initialize( client, name )
  @client = client
  @name   = @client.assert_param_presence(name, "index name") unless name.nil?
end

Instance Attribute Details

#client ⇒ Object (readonly)

Returns the value of attribute client.



30
31
32
 
# File 'lib/elastomer/client/index.rb', line 30

def client
  @client
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



30
31
32
 
# File 'lib/elastomer/client/index.rb', line 30

def name
  @name
end

Instance Method Details

#add_alias(name, params = {}) ⇒ Object

Add a single alias to this index.

name - Name of the alias to add to the index params - Parameters Hash

:routing - optional routing that can be associated with an alias
:filter  - optional filter that can be associated with an alias

Examples

index.add_alias("foo", routing: "foo")

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html

Returns the response body as a Hash



200
201
202
203
 
# File 'lib/elastomer/client/index.rb', line 200

def add_alias( name, params = {} )
  response = client.put "/{index}/_alias/{name}", update_params(params, name: name, action: "index.add_alias", rest_api: "indices.put_alias")
  response.body
end

#analyze(text, params = {}) ⇒ Object

Perform the analysis process on some text and return the tokens breakdown of the text.

text - The text to analyze as a String params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-analyze.html

Returns the response body as a Hash



232
233
234
235
236
 
# File 'lib/elastomer/client/index.rb', line 232

def analyze( text, params = {} )
  body = text.is_a?(Hash) ? text : {text: text.to_s}
  response = client.get "{/index}/_analyze", update_params(params, body: body, action: "index.analyze", rest_api: "indices.analyze")
  response.body
end

#app_delete_by_query(query, params = nil) ⇒ Object

DEPRECATED: Delete documents from one or more indices and one or more types based on a query using application-level logic.

See Client#app_delete_by_query for more information.

Returns a Hash of statistics about the delete operations simulating the Elasticsearch 2.x delete by query plugin’s output.



546
547
548
 
# File 'lib/elastomer/client/index.rb', line 546

def app_delete_by_query(query, params = nil)
  docs.app_delete_by_query(query, params)
end

#bulk(params = {}, &block) ⇒ Object

Perform bulk indexing and/or delete operations. The current index name will be passed to the bulk API call as part of the request parameters.

params - Parameters Hash that will be passed to the bulk API call. block - Required block that is used to accumulate bulk API operations.

All the operations will be passed to the search cluster via a
single API request.

Yields a Bulk instance for building bulk API call bodies.

Examples

index.bulk do |b|
  b.index( document1 )
  b.index( document2 )
  b.delete( document3 )
  ...
end

See www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html

Returns the response body as a Hash



387
388
389
390
391
392
 
# File 'lib/elastomer/client/index.rb', line 387

def bulk( params = {}, &block )
  raise "a block is required" if block.nil?

  params = {index: self.name}.merge params
  client.bulk params, &block
end

#clear_cache(params = {}) ⇒ Object

Clear caches for one or more indices. Individual caches can be specified with parameters.

params - Parameters Hash

:index - set to "_all" to clear all index caches

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-clearcache.html

Returns the response body as a Hash



303
304
305
306
 
# File 'lib/elastomer/client/index.rb', line 303

def clear_cache( params = {} )
  response = client.post "{/index}/_cache/clear", update_params(params, action: "index.clear_cache", rest_api: "indices.clear_cache")
  response.body
end

#close(params = {}) ⇒ Object

Close the index.

params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-open-close.html

Returns the response body as a Hash



92
93
94
95
 
# File 'lib/elastomer/client/index.rb', line 92

def close( params = {} )
  response = client.post "/{index}/_close", update_params(params, action: "index.close", rest_api: "indices.close")
  response.body
end

#create(body, params = {}) ⇒ Object

Create the index.

body - The index settings and mappings as a Hash or a JSON encoded String params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-create-index.html

Returns the response body as a Hash



56
57
58
59
 
# File 'lib/elastomer/client/index.rb', line 56

def create( body, params = {} )
  response = client.put "/{index}", update_params(params, body: body, action: "index.create", rest_api: "indices.create")
  response.body
end

#defaults ⇒ Object

Internal: Returns a Hash containing default parameters.



589
590
591
 
# File 'lib/elastomer/client/index.rb', line 589

def defaults
  { index: name }
end

#delete(params = {}) ⇒ Object

Delete the index.

params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-delete-index.html

Returns the response body as a Hash



68
69
70
71
 
# File 'lib/elastomer/client/index.rb', line 68

def delete( params = {} )
  response = client.delete "/{index}", update_params(params, action: "index.delete", rest_api: "indices.delete")
  response.body
end

#delete_alias(name, params = {}) ⇒ Object

Delete an alias from this index.

name - Name of the alias to delete from the index params - Parameters Hash

Examples

index.delete_alias("foo")
index.delete_alias(["foo", "bar"])

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html

Returns the response body as a Hash



218
219
220
221
 
# File 'lib/elastomer/client/index.rb', line 218

def delete_alias( name, params = {} )
  response = client.delete "/{index}/_alias/{name}", update_params(params, name: name, action: "index.delete_alias", rest_api: "indices.delete_alias")
  response.body
end

#delete_by_query(query, params = nil) ⇒ Object

Delete documents by query following either the native or application-level delete by query method.

NOTE: The parameters and response format varies by version. To have more control over this, use app_delete_by_query or native_delete_by_query directly.



535
536
537
 
# File 'lib/elastomer/client/index.rb', line 535

def delete_by_query(query, params = nil)
  docs.send(client.version_support.delete_by_query_method, query, params)
end

#docs(type = nil) ⇒ Object

Provides access to document-level API commands. These commands will be scoped to this index and the give ‘type`, if any.

type - The document type as a String

See www.elastic.co/guide/en/elasticsearch/reference/current/docs.html

Returns a Docs instance.



348
349
350
 
# File 'lib/elastomer/client/index.rb', line 348

def docs( type = nil )
  client.docs name, type
end

#exists?(params = {}) ⇒ Boolean Also known as: exist?

Check for the existence of the index. If a ‘:type` option is given, then we will check for the existence of the document type in the index.

params - Parameters Hash

:type - optional type mapping as a String

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-exists.html and www.elastic.co/guide/en/elasticsearch/reference/current/indices-types-exists.html

Returns true if the index (or type) exists

Returns:

  • (Boolean) 


42
43
44
45
 
# File 'lib/elastomer/client/index.rb', line 42

def exists?( params = {} )
  response = client.head "/{index}{/type}", update_params(params, action: "index.exists", rest_api: "indices.exists")
  response.success?
end

#flush(params = {}) ⇒ Object

Flush one or more indices to the index storage.

params - Parameters Hash

:index - set to "_all" to flush all indices

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-flush.html

Returns the response body as a Hash



260
261
262
263
 
# File 'lib/elastomer/client/index.rb', line 260

def flush( params = {} )
  response = client.post "{/index}/_flush", update_params(params, action: "index.flush", rest_api: "indices.flush")
  response.body
end

#forcemerge(params = {}) ⇒ Object Also known as: optimize

Force merge one or more indices. Force merging an index allows to reduce the number of segments but can be resource intensive.

params - Parameters Hash

:index - set to "_all" to force merge all indices

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-forcemerge.html

Returns the response body as a Hash



274
275
276
277
 
# File 'lib/elastomer/client/index.rb', line 274

def forcemerge( params = {} )
  response = client.post "{/index}/_forcemerge", update_params(params, action: "index.forcemerge", rest_api: "indices.forcemerge")
  response.body
end

#get_alias(name, params = {}) ⇒ Object

Return the named aliases associated with this index.

name - Name of the alias to look up params - Parameters Hash

:ignore_unavailable - What to do if a specified index name doesn’t
                      exist. If set to `true` then those indices are ignored.

Examples

index.get_alias("*")       # returns all aliases for the current index
index.get_alias("issue*")  # returns all aliases starting with "issue"

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html

Returns the response body as a Hash



181
182
183
184
 
# File 'lib/elastomer/client/index.rb', line 181

def get_alias( name, params = {} )
  response = client.get "/{index}/_alias/{name}", update_params(params, name: name, action: "index.get_alias", rest_api: "indices.get_alias")
  response.body
end

#get_aliases(params = {}) ⇒ Object Also known as: aliases

Return the aliases associated with this index.

params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html

Returns the response body as a Hash



160
161
162
163
 
# File 'lib/elastomer/client/index.rb', line 160

def get_aliases( params = {} )
  response = client.get "/{index}/_alias", update_params(action: "index.get_aliases", rest_api: "indices.get_alias")
  response.body
end

#get_mapping(params = {}) ⇒ Object Also known as: mapping

Retrieve one or more mappings from the index. To retrieve a specific mapping provide the name as the ‘:type` parameter.

params - Parameters Hash

:type - specific document type as a String or Array of Strings

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-get-mapping.html

Returns the response body as a Hash



132
133
134
135
 
# File 'lib/elastomer/client/index.rb', line 132

def get_mapping( params = {} )
  response = client.get "/{index}/_mapping{/type}", update_params(params, action: "index.get_mapping", rest_api: "indices.get_mapping")
  response.body
end

#get_settings(params = {}) ⇒ Object Also known as: settings

Retrieve the settings for the index.

params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-get-settings.html

Returns the response body as a Hash



104
105
106
107
 
# File 'lib/elastomer/client/index.rb', line 104

def get_settings( params = {} )
  response = client.get "{/index}/_settings", update_params(params, action: "index.get_settings", rest_api: "indices.get_settings")
  response.body
end

#multi_percolate(params = {}, &block) ⇒ Object

Execute an array of percolate actions in bulk. Results are returned in an array in the order the actions were sent. The current index name will be passed to the API call as part of the request parameters.

See www.elastic.co/guide/en/elasticsearch/reference/current/search-percolate.html#_multi_percolate_api

params - Optional request parameters as a Hash block - Passed to a MultiPercolate instance which assembles the

percolate actions into a single request.

Examples

# block form
multi_percolate do |m|
  m.percolate({ author: "pea53" }, { type: 'default-type' })
  m.count({ author: "pea53" }, { type: 'type2' })
  ...
end

Returns the response body as a Hash



502
503
504
505
 
# File 'lib/elastomer/client/index.rb', line 502

def multi_percolate(params = {}, &block)
  params = defaults.merge params
  client.multi_percolate(params, &block)
end

#multi_search(params = {}, &block) ⇒ Object

Execute an array of searches in bulk. Results are returned in an array in the order the queries were sent. The current index name will be passed to the multi_search API call as part of the request parameters.

See www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html

params - Parameters Hash that will be passed to the API call. block - Required block that is used to accumulate searches.

All the operations will be passed to the search cluster
via a single API request.

Yields a MultiSearch instance for building multi_search API call bodies.

Examples

index.multi_search do |m|
  m.search({query: {match_all: {}}, size: 0)
  m.search({query: {field: {"author" => "grantr"}}}, type: 'tweet')
  ...
end

See www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html

Returns the response body as a Hash



475
476
477
478
479
480
 
# File 'lib/elastomer/client/index.rb', line 475

def multi_search( params = {}, &block )
  raise "a block is required" if block.nil?

  params = {index: self.name}.merge params
  client.multi_search params, &block
end

#native_delete_by_query(query, params = nil) ⇒ Object

Delete documents from one or more indices and one or more types based on a query using Elasticsearch’s _delete_by_query API.

See Client#native_delete_by_query for more information.

Returns a Hash of statistics about the delete operations as returned by _delete_by_query.

Raises Elastomer::Client::IncompatibleVersionException if this version of Elasticsearch does not support _delete_by_query.



560
561
562
 
# File 'lib/elastomer/client/index.rb', line 560

def native_delete_by_query(query, params = nil)
  docs.native_delete_by_query(query, params)
end

#open(params = {}) ⇒ Object

Open the index.

params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-open-close.html

Returns the response body as a Hash



80
81
82
83
 
# File 'lib/elastomer/client/index.rb', line 80

def open( params = {} )
  response = client.post "/{index}/_open", update_params(params, action: "index.open", rest_api: "indices.open")
  response.body
end

#percolator(id) ⇒ Object

Constructs a Percolator with the given id on this index.

Examples

index.percolator "1"

Returns a Percolator



571
572
573
 
# File 'lib/elastomer/client/index.rb', line 571

def percolator(id)
  Percolator.new(client, name, id)
end

#recovery(params = {}) ⇒ Object

Provides insight into ongoing index shard recoveries. Recovery status may be reported for specific indices, or cluster-wide.

params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-recovery.html

Returns the response body as a Hash



289
290
291
292
 
# File 'lib/elastomer/client/index.rb', line 289

def recovery( params = {} )
  response = client.get "{/index}/_recovery", update_params(params, action: "index.recovery", rest_api: "indices.recovery")
  response.body
end

#refresh(params = {}) ⇒ Object

Explicitly refresh one or more index, making all operations performed since the last refresh available for search.

params - Parameters Hash

:index - set to "_all" to refresh all indices

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-refresh.html

Returns the response body as a Hash



247
248
249
250
 
# File 'lib/elastomer/client/index.rb', line 247

def refresh( params = {} )
  response = client.post "{/index}/_refresh", update_params(params, action: "index.refresh", rest_api: "indices.refresh")
  response.body
end

#scan(query, opts = {}) ⇒ Object

Create a new Scroller instance for scanning all results from a ‘query`. The Scroller will be scoped to the current index. The Scroller is configured to use `scan` semantics which are more efficient than a standard scroll query; the caveat is that the returned documents cannot be sorted.

query - The query to scan as a Hash or a JSON encoded String opts - Options Hash

:index  - the name of the index to search
:type   - the document type to search
:scroll - the keep alive time of the scrolling request (5 minutes by default)
:size   - the number of documents per shard to fetch per scroll

Examples

scan = index.scan('{"query":{"match_all":{}}}')
scan.each_document do |document|
  document['_id']
  document['_source']
end

See www.elastic.co/guide/en/elasticsearch/reference/current/search-request-scroll.html

Returns a new Scroller instance



444
445
446
447
 
# File 'lib/elastomer/client/index.rb', line 444

def scan( query, opts = {} )
  opts = {index: name}.merge opts
  client.scan query, opts
end

#scroll(query, opts = {}) ⇒ Object

Create a new Scroller instance for scrolling all results from a ‘query`. The Scroller will be scoped to the current index.

query - The query to scroll as a Hash or a JSON encoded String opts - Options Hash

:index  - the name of the index to search
:type   - the document type to search
:scroll - the keep alive time of the scrolling request (5 minutes by default)
:size   - the number of documents per shard to fetch per scroll

Examples

scroll = index.scroll('{"query":{"match_all":{}},"sort":{"date":"desc"}}')
scroll.each_document do |document|
  document['_id']
  document['_source']
end

See www.elastic.co/guide/en/elasticsearch/reference/current/search-request-scroll.html

Returns a new Scroller instance



415
416
417
418
 
# File 'lib/elastomer/client/index.rb', line 415

def scroll( query, opts = {} )
  opts = {index: name}.merge opts
  client.scroll query, opts
end

#segments(params = {}) ⇒ Object

Retrieve low level Lucene segments information for shards of one or more indices.

params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-segments.html

Returns the response body as a Hash



335
336
337
338
 
# File 'lib/elastomer/client/index.rb', line 335

def segments( params = {} )
  response = client.get "{/index}/_segments", update_params(params, action: "index.segments", rest_api: "indices.segments")
  response.body
end

#stats(params = {}) ⇒ Object

Retrieve statistics about one or more indices. Specific statistics can be retrieved with parameters.

params - Parameters Hash

:stats - a single stats value or an Array of stats values

Examples

stats(stats: "docs")
stats(stats: %w[flush merge])

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-stats.html

Returns the response body as a Hash



322
323
324
325
 
# File 'lib/elastomer/client/index.rb', line 322

def stats( params = {} )
  response = client.get "{/index}/_stats{/stats}", update_params(params, action: "index.stats", rest_api: "indices.stats")
  response.body
end

#suggest(query, params = {}) ⇒ Object

Exposes the ‘/_suggest` endpoint of the Elasticsearch API.

query - The query body as a Hash params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters.html

Returns the response body as a Hash



360
361
362
363
 
# File 'lib/elastomer/client/index.rb', line 360

def suggest(query, params = {})
  response = client.post "{/index}/_suggest", update_params(params, body: query, action: "index.suggest", rest_api: "suggest")
  response.body
end

#update_mapping(type, body, params = {}) ⇒ Object Also known as: put_mapping

Register specific mapping definition for a specific type.

type - Name of the mapping to update as a String body - The mapping values to update as a Hash or a JSON encoded String params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-put-mapping.html

Returns the response body as a Hash



147
148
149
150
 
# File 'lib/elastomer/client/index.rb', line 147

def update_mapping( type, body, params = {} )
  response = client.put "/{index}/_mapping/{type}", update_params(params, body: body, type: type, action: "index.update_mapping", rest_api: "indices.put_mapping")
  response.body
end

#update_params(params, overrides = nil) ⇒ Object

Internal: Add default parameters to the ‘params` Hash and then apply `overrides` to the params if any are given.

params - Parameters Hash overrides - Optional parameter overrides as a Hash

Returns a new params Hash.



582
583
584
585
586
 
# File 'lib/elastomer/client/index.rb', line 582

def update_params( params, overrides = nil )
  h = defaults.update params
  h.update overrides unless overrides.nil?
  h
end

#update_settings(body, params = {}) ⇒ Object

Change specific index level settings in real time.

body - The index settings as a Hash or a JSON encoded String params - Parameters Hash

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html

Returns the response body as a Hash



118
119
120
121
 
# File 'lib/elastomer/client/index.rb', line 118

def update_settings( body, params = {} )
  response = client.put "{/index}/_settings", update_params(params, body: body, action: "index.update_settings", rest_api: "indices.put_settings")
  response.body
end

#warmer(warmer_name) ⇒ Object

Provides access to warmer API commands. Index warmers run search requests to warm up the index before it is available for searching. Warmers are useful for searches that require heavy data loading, such as faceting or sorting.

The warmer api allows creating, deleting, and retrieving registered warmers.

warmer_name - The name of the warmer to operate on.

Examples

index.warmer('warmer1').create(query: {match_all: {}})
index.warmer('warmer1').get
index.warmer('warmer1').delete

See www.elastic.co/guide/en/elasticsearch/reference/current/indices-warmers.html

Returns a new Warmer instance



525
526
527
 
# File 'lib/elastomer/client/index.rb', line 525

def warmer(warmer_name)
  Warmer.new(client, name, warmer_name)
end