module Elasticsearch::API::Indices::Actions
Public Instance Methods
Adds a block to an index.
@option arguments [List] :index A comma separated list of indices to add a block to @option arguments [String] :block The block to add (one of read, write, read_only or metadata) @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/index-modules-blocks.html
# File lib/elasticsearch/api/actions/indices/add_block.rb, line 38 def add_block(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.add_block' } defined_params = %i[index block].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] raise ArgumentError, "Required argument 'block' missing" unless arguments[:block] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) _block = arguments.delete(:block) method = Elasticsearch::API::HTTP_PUT path = "#{Utils.__listify(_index)}/_block/#{Utils.__listify(_block)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Performs the analysis process on a text and return the tokens breakdown of the text.
@option arguments [String] :index The name of the index to scope the operation @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body Define analyzer/tokenizer parameters and the text on which the analysis should be performed
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-analyze.html
# File lib/elasticsearch/api/actions/indices/analyze.rb, line 33 def analyze(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.analyze' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) method = if body Elasticsearch::API::HTTP_POST else Elasticsearch::API::HTTP_GET end path = if _index "#{Utils.__listify(_index)}/_analyze" else '_analyze' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Clears all or specific caches for one or more indices.
@option arguments [List] :index A comma-separated list of index name to limit the operation @option arguments [Boolean] :fielddata Clear field data @option arguments [List] :fields A comma-separated list of fields to clear when using the ‘fielddata` parameter (default: all) @option arguments [Boolean] :query Clear query caches @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :request Clear request cache @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-clearcache.html
# File lib/elasticsearch/api/actions/indices/clear_cache.rb, line 39 def clear_cache(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.clear_cache' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = if _index "#{Utils.__listify(_index)}/_cache/clear" else '_cache/clear' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Clones an index
@option arguments [String] :index The name of the source index to clone @option arguments [String] :target The name of the target index to clone into @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [String] :wait_for_active_shards Set the number of active shards to wait for on the cloned index before the operation returns. @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The configuration for the target index (‘settings` and `aliases`)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-clone-index.html
# File lib/elasticsearch/api/actions/indices/clone.rb, line 37 def clone(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.clone' } defined_params = %i[index target].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] raise ArgumentError, "Required argument 'target' missing" unless arguments[:target] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) _target = arguments.delete(:target) method = Elasticsearch::API::HTTP_PUT path = "#{Utils.__listify(_index)}/_clone/#{Utils.__listify(_target)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Closes an index.
@option arguments [List] :index A comma separated list of indices to close @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [String] :wait_for_active_shards Sets the number of active shards to wait for before the operation returns. @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-open-close.html
# File lib/elasticsearch/api/actions/indices/close.rb, line 38 def close(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.close' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = "#{Utils.__listify(_index)}/_close" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Creates an index with optional settings and mappings.
@option arguments [String] :index The name of the index @option arguments [String] :wait_for_active_shards Set the number of active shards to wait for before the operation returns. @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The configuration for the index (‘settings` and `mappings`)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-create-index.html
# File lib/elasticsearch/api/actions/indices/create.rb, line 36 def create(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.create' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_PUT path = "#{Utils.__listify(_index)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Creates a data stream
@option arguments [String] :name The name of the data stream @option arguments [Time] :timeout Specify timeout for acknowledging the cluster state update @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams.html
# File lib/elasticsearch/api/actions/indices/create_data_stream.rb, line 34 def create_data_stream(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.create_data_stream' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_PUT path = "_data_stream/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Provides statistics on operations happening in a data stream.
@option arguments [List] :name A comma-separated list of data stream names; use ‘_all` or empty string to perform the operation on all data streams @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams.html
# File lib/elasticsearch/api/actions/indices/data_streams_stats.rb, line 32 def data_streams_stats(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.data_streams_stats' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = if _name "_data_stream/#{Utils.__listify(_name)}/_stats" else '_data_stream/_stats' end params = {} Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Deletes an index.
@option arguments [List] :index A comma-separated list of indices to delete; use ‘_all` or `*` string to delete all indices @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :ignore_unavailable Ignore unavailable indexes (default: false) @option arguments [Boolean] :allow_no_indices Ignore if a wildcard expression resolves to no concrete indices (default: false) @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open, closed, or hidden indices (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-delete-index.html
# File lib/elasticsearch/api/actions/indices/delete.rb, line 37 def delete(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.delete' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_DELETE path = "#{Utils.__listify(_index)}" params = Utils.process_params(arguments) if Array(arguments[:ignore]).include?(404) Utils.__rescue_from_not_found do Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end else Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end end
Deletes an alias.
@option arguments [List] :index A comma-separated list of index names (supports wildcards); use ‘_all` for all indices @option arguments [List] :name A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices. @option arguments [Time] :timeout Explicit timestamp for the document @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-aliases.html
# File lib/elasticsearch/api/actions/indices/delete_alias.rb, line 35 def delete_alias(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.delete_alias' } defined_params = %i[index name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_DELETE path = ("#{Utils.__listify(_index)}/_aliases/#{Utils.__listify(_name)}" if _index && _name) params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Deletes the data stream lifecycle of the selected data streams.
@option arguments [List] :name A comma-separated list of data streams of which the data stream lifecycle will be deleted; use ‘*` to get all data streams @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Time] :timeout Explicit timestamp for the document @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams-delete-lifecycle.html
# File lib/elasticsearch/api/actions/indices/delete_data_lifecycle.rb, line 35 def delete_data_lifecycle(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.delete_data_lifecycle' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_DELETE path = "_data_stream/#{Utils.__listify(_name)}/_lifecycle" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Deletes a data stream.
@option arguments [List] :name A comma-separated list of data streams to delete; use ‘*` to delete all data streams @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams.html
# File lib/elasticsearch/api/actions/indices/delete_data_stream.rb, line 34 def delete_data_stream(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.delete_data_stream' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_DELETE path = "_data_stream/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Deletes an index template.
@option arguments [String] :name The name of the template @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-delete-template.html
# File lib/elasticsearch/api/actions/indices/delete_index_template.rb, line 34 def delete_index_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.delete_index_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_DELETE path = "_index_template/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Deletes an index template.
@option arguments [String] :name The name of the template @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-delete-template-v1.html
# File lib/elasticsearch/api/actions/indices/delete_template.rb, line 34 def delete_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.delete_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_DELETE path = "_template/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) if Array(arguments[:ignore]).include?(404) Utils.__rescue_from_not_found do Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end else Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end end
Analyzes the disk usage of each field of an index or data stream This functionality is Experimental and may be changed or removed completely in a future release. Elastic will take a best effort approach to fix any issues, but experimental features are not subject to the support SLA of official GA features.
@option arguments [String] :index Comma-separated list of indices or data streams to analyze the disk usage @option arguments [Boolean] :run_expensive_tasks Must be set to [true] in order for the task to be performed. Defaults to false. @option arguments [Boolean] :flush Whether flush or not before analyzing the index disk usage. Defaults to true @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-disk-usage.html
# File lib/elasticsearch/api/actions/indices/disk_usage.rb, line 41 def disk_usage(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.disk_usage' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = "#{Utils.__listify(_index)}/_disk_usage" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Downsample an index This functionality is Experimental and may be changed or removed completely in a future release. Elastic will take a best effort approach to fix any issues, but experimental features are not subject to the support SLA of official GA features.
@option arguments [String] :index The index to downsample (Required) @option arguments [String] :target_index The name of the target index to store downsampled data (Required) @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The downsampling configuration (Required)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/xpack-rollup.html
# File lib/elasticsearch/api/actions/indices/downsample.rb, line 38 def downsample(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.downsample' } defined_params = %i[index target_index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'body' missing" unless arguments[:body] raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] raise ArgumentError, "Required argument 'target_index' missing" unless arguments[:target_index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) _target_index = arguments.delete(:target_index) method = Elasticsearch::API::HTTP_POST path = "#{Utils.__listify(_index)}/_downsample/#{Utils.__listify(_target_index)}" params = {} Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns information about whether a particular index exists.
@option arguments [List] :index A comma-separated list of index names @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Boolean] :ignore_unavailable Ignore unavailable indexes (default: false) @option arguments [Boolean] :allow_no_indices Ignore if a wildcard expression resolves to no concrete indices (default: false) @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Boolean] :include_defaults Whether to return all default setting for each of the indices. @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-exists.html
# File lib/elasticsearch/api/actions/indices/exists.rb, line 38 def exists(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.exists' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_HEAD path = "#{Utils.__listify(_index)}" params = Utils.process_params(arguments) Utils.__rescue_from_not_found do perform_request(method, path, params, body, headers, request_opts).status == 200 end end
Returns information about whether a particular alias exists.
@option arguments [List] :name A comma-separated list of alias names to return @option arguments [List] :index A comma-separated list of index names to filter aliases @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-aliases.html
# File lib/elasticsearch/api/actions/indices/exists_alias.rb, line 37 def exists_alias(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.exists_alias' } defined_params = %i[name index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_HEAD path = if _index && _name "#{Utils.__listify(_index)}/_alias/#{Utils.__listify(_name)}" else "_alias/#{Utils.__listify(_name)}" end params = Utils.process_params(arguments) Utils.__rescue_from_not_found do perform_request(method, path, params, body, headers, request_opts).status == 200 end end
Returns information about whether a particular index template exists.
@option arguments [String] :name The name of the template @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Time] :master_timeout Explicit operation timeout for connection to master node @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/index-templates.html
# File lib/elasticsearch/api/actions/indices/exists_index_template.rb, line 35 def exists_index_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.exists_index_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_HEAD path = "_index_template/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns information about whether a particular index template exists.
@option arguments [List] :name The comma separated names of the index templates @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Time] :master_timeout Explicit operation timeout for connection to master node @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-template-exists-v1.html
# File lib/elasticsearch/api/actions/indices/exists_template.rb, line 35 def exists_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.exists_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_HEAD path = "_template/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Utils.__rescue_from_not_found do perform_request(method, path, params, body, headers, request_opts).status == 200 end end
Retrieves information about the index’s current data stream lifecycle, such as any potential encountered error, time since creation etc.
@option arguments [String] :index The name of the index to explain @option arguments [Boolean] :include_defaults indicates if the API
should return the default values the system uses for the index’s lifecycle @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams-explain-lifecycle.html
# File lib/elasticsearch/api/actions/indices/explain_data_lifecycle.rb, line 34 def explain_data_lifecycle(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.explain_data_lifecycle' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = "#{Utils.__listify(_index)}/_lifecycle/explain" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns the field usage stats for each field of an index This functionality is Experimental and may be changed or removed completely in a future release. Elastic will take a best effort approach to fix any issues, but experimental features are not subject to the support SLA of official GA features.
@option arguments [String] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [List] :fields A comma-separated list of fields to include in the stats if only a subset of fields should be returned (supports wildcards) @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/field-usage-stats.html
# File lib/elasticsearch/api/actions/indices/field_usage_stats.rb, line 40 def field_usage_stats(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.field_usage_stats' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = "#{Utils.__listify(_index)}/_field_usage_stats" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Performs the flush operation on one or more indices.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string for all indices @option arguments [Boolean] :force Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal) @option arguments [Boolean] :wait_if_ongoing If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running. @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-flush.html
# File lib/elasticsearch/api/actions/indices/flush.rb, line 37 def flush(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.flush' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = if _index "#{Utils.__listify(_index)}/_flush" else '_flush' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Performs the force merge operation on one or more indices.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [Boolean] :flush Specify whether the index should be flushed after performing the operation (default: true) @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Number] :max_num_segments The number of segments the index should be merged into (default: dynamic) @option arguments [Boolean] :only_expunge_deletes Specify whether the operation should only expunge deleted documents @option arguments [Boolean] :wait_for_completion Should the request wait until the force merge is completed. @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-forcemerge.html
# File lib/elasticsearch/api/actions/indices/forcemerge.rb, line 39 def forcemerge(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.forcemerge' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = if _index "#{Utils.__listify(_index)}/_forcemerge" else '_forcemerge' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns information about one or more indices.
@option arguments [List] :index A comma-separated list of index names @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Boolean] :ignore_unavailable Ignore unavailable indexes (default: false) @option arguments [Boolean] :allow_no_indices Ignore if a wildcard expression resolves to no concrete indices (default: false) @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [String] :features Return only information on specified index features (options: aliases, mappings, settings) @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Boolean] :include_defaults Whether to return all default setting for each of the indices. @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-get-index.html
# File lib/elasticsearch/api/actions/indices/get.rb, line 40 def get(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = "#{Utils.__listify(_index)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns an alias.
@option arguments [List] :name A comma-separated list of alias names to return @option arguments [List] :index A comma-separated list of index names to filter aliases @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-aliases.html
# File lib/elasticsearch/api/actions/indices/get_alias.rb, line 37 def get_alias(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_alias' } defined_params = %i[name index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = if _index && _name "#{Utils.__listify(_index)}/_alias/#{Utils.__listify(_name)}" elsif _index "#{Utils.__listify(_index)}/_alias" elsif _name "_alias/#{Utils.__listify(_name)}" else '_alias' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns the data stream lifecycle of the selected data streams.
@option arguments [List] :name A comma-separated list of data streams to get; use ‘*` to get all data streams @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Boolean] :include_defaults Return all relevant default configurations for the data stream (default: false) @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams-get-lifecycle.html
# File lib/elasticsearch/api/actions/indices/get_data_lifecycle.rb, line 35 def get_data_lifecycle(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_data_lifecycle' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = "_data_stream/#{Utils.__listify(_name)}/_lifecycle" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns data streams.
@option arguments [List] :name A comma-separated list of data streams to get; use ‘*` to get all data streams @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Boolean] :include_defaults Return all relevant default configurations for the data stream (default: false) @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :verbose Whether the maximum timestamp for each data stream should be calculated and returned (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams.html
# File lib/elasticsearch/api/actions/indices/get_data_stream.rb, line 36 def get_data_stream(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_data_stream' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = if _name "_data_stream/#{Utils.__listify(_name)}" else '_data_stream' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns mapping for one or more fields.
@option arguments [List] :fields A comma-separated list of fields @option arguments [List] :index A comma-separated list of index names @option arguments [Boolean] :include_defaults Whether the default mapping values should be returned as well @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-get-field-mapping.html
# File lib/elasticsearch/api/actions/indices/get_field_mapping.rb, line 38 def get_field_mapping(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_field_mapping' } defined_params = %i[fields index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone _fields = arguments.delete(:field) || arguments.delete(:fields) raise ArgumentError, "Required argument 'field' missing" unless _fields headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = if _index && _fields "#{Utils.__listify(_index)}/_mapping/field/#{Utils.__listify(_fields)}" else "_mapping/field/#{Utils.__listify(_fields)}" end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns an index template.
@option arguments [String] :name A pattern that returned template names must match @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Time] :master_timeout Explicit operation timeout for connection to master node @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Boolean] :include_defaults Return all relevant default configurations for the index template (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-get-template.html
# File lib/elasticsearch/api/actions/indices/get_index_template.rb, line 36 def get_index_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_index_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = if _name "_index_template/#{Utils.__listify(_name)}" else '_index_template' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns mappings for one or more indices.
@option arguments [List] :index A comma-separated list of index names @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) Deprecated @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-get-mapping.html
# File lib/elasticsearch/api/actions/indices/get_mapping.rb, line 37 def get_mapping(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_mapping' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = if _index "#{Utils.__listify(_index)}/_mapping" else '_mapping' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns settings for one or more indices.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [List] :name The name of the settings that should be included @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Boolean] :include_defaults Whether to return all default setting for each of the indices. @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-get-settings.html
# File lib/elasticsearch/api/actions/indices/get_settings.rb, line 40 def get_settings(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_settings' } defined_params = %i[index name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = if _index && _name "#{Utils.__listify(_index)}/_settings/#{Utils.__listify(_name)}" elsif _index "#{Utils.__listify(_index)}/_settings" elsif _name "_settings/#{Utils.__listify(_name)}" else '_settings' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns an index template.
@option arguments [List] :name The comma separated names of the index templates @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Time] :master_timeout Explicit operation timeout for connection to master node @option arguments [Boolean] :local Return local information, do not retrieve the state from master node (default: false) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-get-template-v1.html
# File lib/elasticsearch/api/actions/indices/get_template.rb, line 35 def get_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.get_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = if _name "_template/#{Utils.__listify(_name)}" else '_template' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Migrates an alias to a data stream
@option arguments [String] :name The name of the alias to migrate @option arguments [Time] :timeout Specify timeout for acknowledging the cluster state update @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams.html
# File lib/elasticsearch/api/actions/indices/migrate_to_data_stream.rb, line 34 def migrate_to_data_stream(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.migrate_to_data_stream' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_POST path = "_data_stream/_migrate/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Modifies a data stream
@option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The data stream modifications (Required)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams.html
# File lib/elasticsearch/api/actions/indices/modify_data_stream.rb, line 32 def modify_data_stream(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.modify_data_stream' } raise ArgumentError, "Required argument 'body' missing" unless arguments[:body] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) method = Elasticsearch::API::HTTP_POST path = '_data_stream/_modify' params = {} Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Opens an index.
@option arguments [List] :index A comma separated list of indices to open @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [String] :wait_for_active_shards Sets the number of active shards to wait for before the operation returns. @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-open-close.html
# File lib/elasticsearch/api/actions/indices/open.rb, line 38 def open(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.open' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = "#{Utils.__listify(_index)}/_open" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Promotes a data stream from a replicated data stream managed by CCR to a regular data stream
@option arguments [String] :name The name of the data stream @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams.html
# File lib/elasticsearch/api/actions/indices/promote_data_stream.rb, line 33 def promote_data_stream(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.promote_data_stream' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_POST path = "_data_stream/_promote/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Creates or updates an alias.
@option arguments [List] :index A comma-separated list of index names the alias should point to (supports wildcards); use ‘_all` to perform the operation on all indices. @option arguments [String] :name The name of the alias to be created or updated @option arguments [Time] :timeout Explicit timestamp for the document @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The settings for the alias, such as `routing` or `filter`
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-aliases.html
# File lib/elasticsearch/api/actions/indices/put_alias.rb, line 36 def put_alias(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.put_alias' } defined_params = %i[index name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_PUT path = ("#{Utils.__listify(_index)}/_aliases/#{Utils.__listify(_name)}" if _index && _name) params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Updates the data stream lifecycle of the selected data streams.
@option arguments [List] :name A comma-separated list of data streams whose lifecycle will be updated; use ‘*` to set the lifecycle to all data streams @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Time] :timeout Explicit timestamp for the document @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The data stream lifecycle configuration that consist of the data retention
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/data-streams-put-lifecycle.html
# File lib/elasticsearch/api/actions/indices/put_data_lifecycle.rb, line 36 def put_data_lifecycle(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.put_data_lifecycle' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_PUT path = "_data_stream/#{Utils.__listify(_name)}/_lifecycle" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Creates or updates an index template.
@option arguments [String] :name The name of the template @option arguments [Boolean] :create Whether the index template should only be added if new or can also replace an existing one @option arguments [String] :cause User defined reason for creating/updating the index template @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The template definition (Required)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-put-template.html
# File lib/elasticsearch/api/actions/indices/put_index_template.rb, line 36 def put_index_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.put_index_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'body' missing" unless arguments[:body] raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_PUT path = "_index_template/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Updates the index mappings.
@option arguments [List] :index A comma-separated list of index names the mapping should be added to (supports wildcards); use ‘_all` or omit to add the mapping on all indices. @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :write_index_only When true, applies mappings only to the write index of an alias or data stream @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The mapping definition (Required)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-put-mapping.html
# File lib/elasticsearch/api/actions/indices/put_mapping.rb, line 39 def put_mapping(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.put_mapping' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'body' missing" unless arguments[:body] raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_PUT path = "#{Utils.__listify(_index)}/_mapping" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Updates the index settings.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Time] :timeout Explicit operation timeout @option arguments [Boolean] :preserve_existing Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false` @option arguments [Boolean] :reopen Whether to close and reopen the index to apply non-dynamic settings. If set to `true` the indices to which the settings are being applied will be closed temporarily and then reopened in order to apply the changes. The default is `false` @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :flat_settings Return settings in flat format (default: false) @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The index settings to be updated (Required)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-update-settings.html
# File lib/elasticsearch/api/actions/indices/put_settings.rb, line 41 def put_settings(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.put_settings' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'body' missing" unless arguments[:body] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_PUT path = if _index "#{Utils.__listify(_index)}/_settings" else '_settings' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Creates or updates an index template.
@option arguments [String] :name The name of the template @option arguments [Number] :order The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers) @option arguments [Boolean] :create Whether the index template should only be added if new or can also replace an existing one @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The template definition (Required)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-templates-v1.html
# File lib/elasticsearch/api/actions/indices/put_template.rb, line 36 def put_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.put_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'body' missing" unless arguments[:body] raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_PUT path = "_template/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns information about ongoing index shard recoveries.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [Boolean] :detailed Whether to display detailed information about shard recovery @option arguments [Boolean] :active_only Display only those recoveries that are currently on-going @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-recovery.html
# File lib/elasticsearch/api/actions/indices/recovery.rb, line 34 def recovery(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.recovery' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = if _index "#{Utils.__listify(_index)}/_recovery" else '_recovery' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Performs the refresh operation in one or more indices.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-refresh.html
# File lib/elasticsearch/api/actions/indices/refresh.rb, line 35 def refresh(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.refresh' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = if _index "#{Utils.__listify(_index)}/_refresh" else '_refresh' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Reloads an index’s search analyzers and their resources.
@option arguments [List] :index A comma-separated list of index names to reload analyzers for @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [String] :resource changed resource to reload analyzers from if applicable @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-reload-analyzers.html
# File lib/elasticsearch/api/actions/indices/reload_search_analyzers.rb, line 36 def reload_search_analyzers(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.reload_search_analyzers' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = "#{Utils.__listify(_index)}/_reload_search_analyzers" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Resolves the specified index expressions to return information about each cluster, including the local cluster, if included.
@option arguments [List] :name A comma-separated list of cluster:index names or wildcard expressions @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :ignore_throttled Whether specified concrete, expanded or aliased indices should be ignored when throttled @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-resolve-cluster-api.html
# File lib/elasticsearch/api/actions/indices/resolve_cluster.rb, line 36 def resolve_cluster(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.resolve_cluster' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = "_resolve/cluster/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Returns information about any matching indices, aliases, and data streams
@option arguments [List] :name A comma-separated list of names or wildcard expressions @option arguments [String] :expand_wildcards Whether wildcard expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all) @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-resolve-index-api.html
# File lib/elasticsearch/api/actions/indices/resolve_index.rb, line 35 def resolve_index(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.resolve_index' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_GET path = "_resolve/index/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Updates an alias to point to a new index when the existing index is considered to be too large or too old.
@option arguments [String] :alias The name of the alias to rollover @option arguments [String] :new_index The name of the rollover index @option arguments [Time] :timeout Explicit operation timeout @option arguments [Boolean] :dry_run If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [String] :wait_for_active_shards Set the number of active shards to wait for on the newly created rollover index before the operation returns. @option arguments [Boolean] :lazy If set to true, the rollover action will only mark a data stream to signal that it needs to be rolled over at the next write. Only allowed on data streams. @option arguments [Boolean] :target_failure_store If set to true, the rollover action will be applied on the failure store of the data stream. @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The conditions that needs to be met for executing rollover
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-rollover-index.html
# File lib/elasticsearch/api/actions/indices/rollover.rb, line 41 def rollover(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.rollover' } defined_params = %i[alias new_index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'alias' missing" unless arguments[:alias] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _alias = arguments.delete(:alias) _new_index = arguments.delete(:new_index) method = Elasticsearch::API::HTTP_POST path = if _alias && _new_index "#{Utils.__listify(_alias)}/_rollover/#{Utils.__listify(_new_index)}" else "#{Utils.__listify(_alias)}/_rollover" end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Provides low-level information about segments in a Lucene index.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :verbose Includes detailed memory usage by Lucene. Deprecated @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-segments.html
# File lib/elasticsearch/api/actions/indices/segments.rb, line 36 def segments(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.segments' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = if _index "#{Utils.__listify(_index)}/_segments" else '_segments' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Provides store information for shard copies of indices.
@option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [List] :status A comma-separated list of statuses used to filter on shards to get store information for (options: green, yellow, red, all) @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-shards-stores.html
# File lib/elasticsearch/api/actions/indices/shard_stores.rb, line 36 def shard_stores(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.shard_stores' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = if _index "#{Utils.__listify(_index)}/_shard_stores" else '_shard_stores' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Allow to shrink an existing index into a new index with fewer primary shards.
@option arguments [String] :index The name of the source index to shrink @option arguments [String] :target The name of the target index to shrink into @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [String] :wait_for_active_shards Set the number of active shards to wait for on the shrunken index before the operation returns. @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The configuration for the target index (‘settings` and `aliases`)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-shrink-index.html
# File lib/elasticsearch/api/actions/indices/shrink.rb, line 37 def shrink(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.shrink' } defined_params = %i[index target].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] raise ArgumentError, "Required argument 'target' missing" unless arguments[:target] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) _target = arguments.delete(:target) method = Elasticsearch::API::HTTP_PUT path = "#{Utils.__listify(_index)}/_shrink/#{Utils.__listify(_target)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Simulate
matching the given index name against the index templates in the system
@option arguments [String] :name The name of the index (it must be a concrete index name) @option arguments [Boolean] :create Whether the index template we optionally defined in the body should only be dry-run added if new or can also replace an existing one @option arguments [String] :cause User defined reason for dry-run creating the new template for simulation purposes @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :include_defaults Return all relevant default configurations for this index template simulation (default: false) @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body New index template definition, which will be included in the simulation, as if it already exists in the system
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-simulate-index.html
# File lib/elasticsearch/api/actions/indices/simulate_index_template.rb, line 37 def simulate_index_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.simulate_index_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'name' missing" unless arguments[:name] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_POST path = "_index_template/_simulate_index/#{Utils.__listify(_name)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Simulate
resolving the given template name or body
@option arguments [String] :name The name of the index template @option arguments [Boolean] :create Whether the index template we optionally defined in the body should only be dry-run added if new or can also replace an existing one @option arguments [String] :cause User defined reason for dry-run creating the new template for simulation purposes @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :include_defaults Return all relevant default configurations for this template simulation (default: false) @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body New index template definition to be simulated, if no index template name is specified
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-simulate-template.html
# File lib/elasticsearch/api/actions/indices/simulate_template.rb, line 37 def simulate_template(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.simulate_template' } defined_params = [:name].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _name = arguments.delete(:name) method = Elasticsearch::API::HTTP_POST path = if _name "_index_template/_simulate/#{Utils.__listify(_name)}" else '_index_template/_simulate' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Allows you to split an existing index into a new index with more primary shards.
@option arguments [String] :index The name of the source index to split @option arguments [String] :target The name of the target index to split into @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [String] :wait_for_active_shards Set the number of active shards to wait for on the shrunken index before the operation returns. @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The configuration for the target index (‘settings` and `aliases`)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-split-index.html
# File lib/elasticsearch/api/actions/indices/split.rb, line 37 def split(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.split' } defined_params = %i[index target].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] raise ArgumentError, "Required argument 'target' missing" unless arguments[:target] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) _target = arguments.delete(:target) method = Elasticsearch::API::HTTP_PUT path = "#{Utils.__listify(_index)}/_split/#{Utils.__listify(_target)}" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Provides statistics on operations happening in an index.
@option arguments [List] :metric Limit the information returned the specific metrics. (options: _all, completion, docs, fielddata, query_cache, flush, get, indexing, merge, request_cache, refresh, search, segments, store, warmer, bulk) @option arguments [List] :index A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices @option arguments [List] :completion_fields A comma-separated list of fields for the `completion` index metric (supports wildcards) @option arguments [List] :fielddata_fields A comma-separated list of fields for the `fielddata` index metric (supports wildcards) @option arguments [List] :fields A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards) @option arguments [List] :groups A comma-separated list of search groups for `search` index metric @option arguments [String] :level Return stats aggregated at cluster, index or shard level (options: cluster, indices, shards) @option arguments [Boolean] :include_segment_file_sizes Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested) @option arguments [Boolean] :include_unloaded_segments If set to true segment stats will include stats for segments that are not currently loaded into memory @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [Boolean] :forbid_closed_indices If set to false stats will also collected from closed indices if explicitly specified or if expand_wildcards expands to closed indices @option arguments [Hash] :headers Custom HTTP headers
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-stats.html
# File lib/elasticsearch/api/actions/indices/stats.rb, line 42 def stats(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.stats' } defined_params = %i[metric index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _metric = arguments.delete(:metric) _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_GET path = if _index && _metric "#{Utils.__listify(_index)}/_stats/#{Utils.__listify(_metric)}" elsif _metric "_stats/#{Utils.__listify(_metric)}" elsif _index "#{Utils.__listify(_index)}/_stats" else '_stats' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Unfreezes an index. When a frozen index is unfrozen, the index goes through the normal recovery process and becomes writeable again.
@option arguments [String] :index The name of the index to unfreeze @option arguments [Time] :timeout Explicit operation timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [String] :wait_for_active_shards Sets the number of active shards to wait for before the operation returns. @option arguments [Hash] :headers Custom HTTP headers
*Deprecation notice*: Frozen indices are deprecated because they provide no benefit given improvements in heap memory utilization. They will be removed in a future release. Deprecated since version 7.14.0
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/unfreeze-index-api.html
# File lib/elasticsearch/api/actions/indices/unfreeze.rb, line 43 def unfreeze(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.unfreeze' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? raise ArgumentError, "Required argument 'index' missing" unless arguments[:index] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = nil _index = arguments.delete(:index) method = Elasticsearch::API::HTTP_POST path = "#{Utils.__listify(_index)}/_unfreeze" params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Updates index aliases.
@option arguments [Time] :timeout Request timeout @option arguments [Time] :master_timeout Specify timeout for connection to master @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The definition of ‘actions` to perform (Required)
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/indices-aliases.html
# File lib/elasticsearch/api/actions/indices/update_aliases.rb, line 34 def update_aliases(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.update_aliases' } raise ArgumentError, "Required argument 'body' missing" unless arguments[:body] arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) method = Elasticsearch::API::HTTP_POST path = '_aliases' params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end
Allows a user to validate a potentially expensive query without executing it.
@option arguments [List] :index A comma-separated list of index names to restrict the operation; use ‘_all` or empty string to perform the operation on all indices @option arguments [Boolean] :explain Return detailed information about the error @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when unavailable (missing or closed) @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all) @option arguments [String] :q Query in the Lucene query string syntax @option arguments [String] :analyzer The analyzer to use for the query string @option arguments [Boolean] :analyze_wildcard Specify whether wildcard and prefix queries should be analyzed (default: false) @option arguments [String] :default_operator The default operator for query string query (AND or OR) (options: AND, OR) @option arguments [String] :df The field to use as default where no field prefix is given in the query string @option arguments [Boolean] :lenient Specify whether format-based query failures (such as providing text to a numeric field) should be ignored @option arguments [Boolean] :rewrite Provide a more detailed explanation showing the actual Lucene query that will be executed. @option arguments [Boolean] :all_shards Execute validation on all shards instead of one random shard per index @option arguments [Hash] :headers Custom HTTP headers @option arguments [Hash] :body The query definition specified with the Query DSL
@see www.elastic.co/guide/en/elasticsearch/reference/8.16/search-validate.html
# File lib/elasticsearch/api/actions/indices/validate_query.rb, line 45 def validate_query(arguments = {}) request_opts = { endpoint: arguments[:endpoint] || 'indices.validate_query' } defined_params = [:index].each_with_object({}) do |variable, set_variables| set_variables[variable] = arguments[variable] if arguments.key?(variable) end request_opts[:defined_params] = defined_params unless defined_params.empty? arguments = arguments.clone headers = arguments.delete(:headers) || {} body = arguments.delete(:body) _index = arguments.delete(:index) method = if body Elasticsearch::API::HTTP_POST else Elasticsearch::API::HTTP_GET end path = if _index "#{Utils.__listify(_index)}/_validate/query" else '_validate/query' end params = Utils.process_params(arguments) Elasticsearch::API::Response.new( perform_request(method, path, params, body, headers, request_opts) ) end