elasticsearch-api 6.3.0 → 6.3.1

data/lib/elasticsearch/api/actions/indices/status.rb

@@ -0,0 +1,63 @@
+module Elasticsearch
+  module API
+    module Indices
+      module Actions
+
+        # Return information about one or more indices
+        #
+        # @example Get information about all indices
+        #
+        #     client.indices.status
+        #
+        # @example Get information about a specific index
+        #
+        #     client.indices.status index: 'foo'
+        #
+        # @example Get information about shard recovery for a specific index
+        #
+        #     client.indices.status index: 'foo', recovery: true
+        #
+        # @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] :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)
+        # @option arguments [String] :ignore_indices When performed on multiple indices, allows to ignore
+        #                                            `missing` ones (options: none, missing) @until 1.0
+        # @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when
+        #                                                 unavailable (missing, closed, etc)
+        # @option arguments [Boolean] :recovery Return information about shard recovery (progress, size, etc)
+        # @option arguments [Boolean] :snapshot Return information about snapshots (when shared gateway is used)
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-indices-status/
+        #
+        def status(arguments={})
+          method = HTTP_GET
+          path   = Utils.__pathify Utils.__listify(arguments[:index]), '_status'
+
+          params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+          body   = nil
+
+          if Array(arguments[:ignore]).include?(404)
+            Utils.__rescue_from_not_found { perform_request(method, path, params, body).body }
+          else
+            perform_request(method, path, params, body).body
+          end
+        end
+
+        # Register this action with its valid params when the module is loaded.
+        #
+        # @since 6.2.0
+        ParamsRegistry.register(:status, [
+            :ignore_indices,
+            :ignore_unavailable,
+            :allow_no_indices,
+            :expand_wildcards,
+            :recovery,
+            :snapshot ].freeze)
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/list_benchmarks.rb

@@ -0,0 +1,27 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return a list of running benchmarks
+      #
+      # @example
+      #
+      #     client.list_benchmarks
+      #
+      # @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 [String] :type The name of the document type
+      #
+      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-benchmark.html
+      #
+      def list_benchmarks(arguments={})
+        method = HTTP_GET
+        path   = "_bench"
+        params = {}
+        body   = nil
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/mlt.rb

@@ -0,0 +1,130 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return documents similar to the specified one.
+      #
+      # Performs a `more_like_this` query with the specified document as the input.
+      #
+      # @example Search for similar documents using the `title` property of document `myindex/mytype/1`
+      #
+      #     # First, let's setup a synonym-aware analyzer ("quick" <=> "fast")
+      #     client.indices.create index: 'myindex', body: {
+      #       settings: {
+      #         analysis: {
+      #           filter: {
+      #             synonyms: {
+      #               type: 'synonym',
+      #               synonyms: [ "quick,fast" ]
+      #             }
+      #           },
+      #           analyzer: {
+      #             title_synonym: {
+      #               type: 'custom',
+      #               tokenizer: 'whitespace',
+      #               filter: ['lowercase', 'stop', 'snowball', 'synonyms']
+      #             }
+      #           }
+      #         }
+      #       },
+      #       mappings: {
+      #         mytype: {
+      #           properties: {
+      #             title: {
+      #               type: 'string',
+      #               analyzer: 'title_synonym'
+      #             }
+      #           }
+      #         }
+      #       }
+      #     }
+      #
+      #     # Index three documents
+      #     client.index index: 'myindex', type: 'mytype', id: 1, body: { title: 'Quick Brown Fox'   }
+      #     client.index index: 'myindex', type: 'mytype', id: 2, body: { title: 'Slow Black Dog'    }
+      #     client.index index: 'myindex', type: 'mytype', id: 3, body: { title: 'Fast White Rabbit' }
+      #     client.indices.refresh index: 'myindex'
+      #
+      #     client.mlt index: 'myindex', type: 'mytype', id: 1, mlt_fields: 'title', min_doc_freq: 1, min_term_freq: 1
+      #     # => { ... {"title"=>"Fast White Rabbit"}}]}}
+      #
+      # @option arguments [String] :id The document ID (*Required*)
+      # @option arguments [String] :index The name of the index (*Required*)
+      # @option arguments [String] :type The type of the document (use `_all` to fetch
+      #                                  the first document matching the ID across all types) (*Required*)
+      # @option arguments [Hash] :body A specific search request definition
+      # @option arguments [Number] :boost_terms The boost factor
+      # @option arguments [Number] :max_doc_freq The word occurrence frequency as count: words with higher occurrence
+      #                                          in the corpus will be ignored
+      # @option arguments [Number] :max_query_terms The maximum query terms to be included in the generated query
+      # @option arguments [Number] :max_word_len The minimum length of the word: longer words will be ignored
+      # @option arguments [Number] :min_doc_freq The word occurrence frequency as count: words with lower occurrence
+      #                                          in the corpus will be ignored
+      # @option arguments [Number] :min_term_freq The term frequency as percent: terms with lower occurence
+      #                                           in the source document will be ignored
+      # @option arguments [Number] :min_word_len The minimum length of the word: shorter words will be ignored
+      # @option arguments [List] :mlt_fields Specific fields to perform the query against
+      # @option arguments [Number] :percent_terms_to_match How many terms have to match in order to consider
+      #                                                    the document a match (default: 0.3)
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [Number] :search_from The offset from which to return results
+      # @option arguments [List] :search_indices A comma-separated list of indices to perform the query against
+      #                                          (default: the index containing the document)
+      # @option arguments [String] :search_query_hint The search query hint
+      # @option arguments [String] :search_scroll A scroll search request definition
+      # @option arguments [Number] :search_size The number of documents to return (default: 10)
+      # @option arguments [String] :search_source A specific search request definition (instead of using the request body)
+      # @option arguments [String] :search_type Specific search type (eg. `dfs_then_fetch`, `count`, etc)
+      # @option arguments [List] :search_types A comma-separated list of types to perform the query against
+      #                                        (default: the same type as the document)
+      # @option arguments [List] :stop_words A list of stop words to be ignored
+      #
+      # @see http://elasticsearch.org/guide/reference/api/more-like-this/
+      #
+      def mlt(arguments={})
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
+        raise ArgumentError, "Required argument 'id' missing"    unless arguments[:id]
+        method = HTTP_GET
+        path   = Utils.__pathify Utils.__escape(arguments[:index]),
+                                 Utils.__escape(arguments[:type]),
+                                 Utils.__escape(arguments[:id]),
+                                 '_mlt'
+
+        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+
+        [:mlt_fields, :search_indices, :search_types, :stop_words].each do |name|
+          params[name] = Utils.__listify(params[name]) if params[name]
+        end
+
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+
+      # Register this action with its valid params when the module is loaded.
+      #
+      # @since 6.2.0
+      ParamsRegistry.register(:mlt, [
+          :boost_terms,
+          :max_doc_freq,
+          :max_query_terms,
+          :max_word_len,
+          :min_doc_freq,
+          :min_term_freq,
+          :min_word_len,
+          :mlt_fields,
+          :percent_terms_to_match,
+          :routing,
+          :search_from,
+          :search_indices,
+          :search_query_hint,
+          :search_scroll,
+          :search_size,
+          :search_source,
+          :search_type,
+          :search_types,
+          :stop_words ].freeze)
+    end
+  end
+end

data/lib/elasticsearch/api/actions/mpercolate.rb

@@ -0,0 +1,62 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Perform multiple percolate operations in a single request, similar to the {#msearch} API
+      #
+      # Pass the percolate definitions as header-body pairs in the `:body` argument, as an Array of Hashes.
+      #
+      # @example Perform two different percolations in a single request
+      #
+      #     client.mpercolate \
+      #         body: [
+      #           { percolate: { index: "my-index", type: "my-type" } },
+      #           { doc: { message: "foo bar" } },
+      #           { percolate: { index: "my-other-index", type: "my-other-type", id: "1" } },
+      #           { }
+      #         ]
+      #
+      # @option arguments [String] :index The index of the document being count percolated to use as default
+      # @option arguments [String] :type The type of the document being percolated to use as default.
+      # @option arguments [Array<Hash>]  The percolate request definitions (header & body pairs) (*Required*)
+      # @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)
+      #
+      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-percolate.html
+      #
+      def mpercolate(arguments={})
+        raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
+        method = HTTP_GET
+        path   = "_mpercolate"
+
+        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+        body   = arguments[:body]
+
+        case
+        when body.is_a?(Array)
+          payload = body.map { |d| d.is_a?(String) ? d : Elasticsearch::API.serializer.dump(d) }
+          payload << "" unless payload.empty?
+          payload = payload.join("\n")
+        else
+          payload = body
+        end
+
+        perform_request(method, path, params, payload).body
+      end
+
+      # Register this action with its valid params when the module is loaded.
+      #
+      # @since 6.2.0
+      ParamsRegistry.register(:mpercolate, [
+          :ignore_unavailable,
+          :allow_no_indices,
+          :expand_wildcards,
+          :percolate_format ].freeze)
+    end
+  end
+end

data/lib/elasticsearch/api/actions/nodes/shutdown.rb

@@ -0,0 +1,39 @@
+module Elasticsearch
+  module API
+    module Nodes
+      module Actions
+
+        # Shutdown one or all nodes
+        #
+        # @example Shut down node named _Bloke_
+        #
+        #     client.nodes.shutdown node_id: 'Bloke'
+        #
+        # @option arguments [List] :node_id A comma-separated list of node IDs or names to perform the operation on; use
+        #                                   `_local` to shutdown the node you're connected to, leave empty to
+        #                                   shutdown all nodes
+        # @option arguments [Time] :delay Set the delay for the operation (default: 1s)
+        # @option arguments [Boolean] :exit Exit the JVM as well (default: true)
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-nodes-shutdown/
+        #
+        def shutdown(arguments={})
+          method = HTTP_POST
+          path   = Utils.__pathify '_cluster/nodes', Utils.__listify(arguments[:node_id]), '_shutdown'
+
+          params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+          body   = nil
+
+          perform_request(method, path, params, body).body
+        end
+
+        # Register this action with its valid params when the module is loaded.
+        #
+        # @since 6.2.0
+        ParamsRegistry.register(:shutdown, [
+            :delay,
+            :exit ].freeze)
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/percolate.rb

@@ -0,0 +1,73 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return names of queries matching a document.
+      #
+      # Percolator allows you to register queries and then evaluate a document against them:
+      # the IDs of matching queries are returned in the response.
+      #
+      # @deprecated The `_percolate` API has been deprecated in favour of a special field mapping and the
+      #             `percolate` query;
+      #             see https://www.elastic.co/guide/en/elasticsearch/reference/5.5/breaking_50_percolator.html
+      #
+      # See full example for Elasticsearch 5.x and higher in <https://github.com/elastic/elasticsearch-ruby/blob/master/examples/percolator/percolator_alerts.rb>
+      #
+      # @option arguments [String] :index The index of the document being percolated. (*Required*)
+      # @option arguments [String] :type The type of the document being percolated. (*Required*)
+      # @option arguments [String] :id Fetch the document specified by index/type/id and
+      #                                use it instead of the passed `doc`
+      # @option arguments [Hash] :body The percolator request definition using the percolate DSL
+      # @option arguments [List] :routing A comma-separated list of specific routing values
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @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)
+      # @option arguments [String] :percolate_index The index to percolate the document into. Defaults to passed `index`.
+      # @option arguments [String] :percolate_format Return an array of matching query IDs instead of objects.
+      #                                              (options: ids)
+      # @option arguments [String] :percolate_type The type to percolate document into. Defaults to passed `type`.
+      # @option arguments [Number] :version Explicit version number for concurrency control
+      # @option arguments [String] :version_type Specific version type (options: internal, external, external_gte, force)
+      #
+      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-percolate.html
+      #
+      def percolate(arguments={})
+        Utils.__report_unsupported_method :percolate
+
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
+        method = HTTP_GET
+        path   = Utils.__pathify Utils.__escape(arguments[:index]),
+                                 Utils.__escape(arguments[:type]),
+                                 Utils.__escape(arguments[:id]),
+                                 '_percolate'
+
+        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+
+      # Register this action with its valid params when the module is loaded.
+      #
+      # @since 6.2.0
+      ParamsRegistry.register(:percolate, [
+          :routing,
+          :preference,
+          :ignore_unavailable,
+          :allow_no_indices,
+          :expand_wildcards,
+          :percolate_index,
+          :percolate_type,
+          :percolate_format,
+          :version,
+          :version_type ].freeze)
+    end
+  end
+end

data/lib/elasticsearch/api/actions/put_template.rb

@@ -0,0 +1,25 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Store a template for the search definition in Elasticsearch,
+      # to be later used with the `search_template` method
+      #
+      # @option arguments [String] :id Template ID (*Required*)
+      # @option arguments [Hash] :body The document (*Required*)
+      #
+      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+      #
+      def put_template(arguments={})
+        raise ArgumentError, "Required argument 'id' missing"   unless arguments[:id]
+        raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
+        method = HTTP_POST
+        path   = "_scripts/#{arguments[:id]}"
+        params = {}
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/remote/info.rb

@@ -0,0 +1,21 @@
+module Elasticsearch
+  module API
+    module Remote
+      module Actions
+
+        # Returns all of the configured remote cluster information
+        #
+        # @see http://www.elastic.co/guide/en/elasticsearch/reference/master/remote-info.html
+        #
+        def info(arguments={})
+          method = HTTP_GET
+          path   = "_remote/info"
+          params = {}
+          body   = nil
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end