elasticsearch-api 7.17.11 → 9.0.2

data/lib/elasticsearch/api/response.rb

@@ -0,0 +1,48 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Elasticsearch
+  module API
+    # Elasticsearch client API Response object. Receives an Elastic::Transport::Transport::Response in
+    # the initializer and behaves like a Hash, except when status or headers are called upon it, in
+    # which case it returns the original object's status and headers.
+    class Response
+      RESPONSE_METHODS = [:status, :body, :headers]
+
+      def initialize(response)
+        @response = response
+      end
+
+      def method_missing(method, *args, &block)
+        if RESPONSE_METHODS.include? method
+          @response.send method.to_sym
+        else
+          @response.body.send(method.to_sym, *args, &block)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @response.body.respond_to?(method_name, include_private) ||
+          RESPONSE_METHODS.include?(method_name)
+      end
+
+      def to_s
+        @response.body.to_s
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/utils.rb

@@ -24,60 +24,62 @@ module Elasticsearch
       # URL-escape a string
       #
       # @example
-      #     __escape('foo/bar') # => 'foo%2Fbar'
-      #     __escape('bar^bam') # => 'bar%5Ebam'
+      #     escape('foo/bar') # => 'foo%2Fbar'
+      #     escape('bar^bam') # => 'bar%5Ebam'
       #
       # @api private
-      def __escape(string)
+      def escape(string)
         return string if string == '*'
+
         ERB::Util.url_encode(string.to_s)
       end
 
       # Create a "list" of values from arguments, ignoring nil values and encoding special characters.
       #
       # @example Create a list from array
-      #     __listify(['A','B']) # => 'A,B'
+      #     listify(['A','B']) # => 'A,B'
       #
       # @example Create a list from arguments
-      #     __listify('A','B') # => 'A,B'
+      #     listify('A','B') # => 'A,B'
       #
       # @example Escape values
-      #     __listify('foo','bar^bam') # => 'foo,bar%5Ebam'
+      #     listify('foo','bar^bam') # => 'foo,bar%5Ebam'
       #
       # @example Do not escape the values
-      #     __listify('foo','bar^bam', escape: false) # => 'foo,bar^bam'
+      #     listify('foo','bar^bam', escape: false) # => 'foo,bar^bam'
       #
       # @api private
-      def __listify(*list)
+      def listify(*list)
         options = list.last.is_a?(Hash) ? list.pop : {}
 
         escape = options[:escape]
-        Array(list).
-          flat_map { |e| e.respond_to?(:split) ? e.split(',') : e }.
-          flatten.
-          compact.
-          map { |e| escape == false ? e : __escape(e) }.
-          join(',')
+        Array(list)
+          .flat_map { |e| e.respond_to?(:split) ? e.split(',') : e }
+          .flatten
+          .compact
+          .map { |e| escape == false ? e : escape(e) }
+          .join(',')
       end
 
       # Create a path (URL part) from arguments, ignoring nil values and empty strings.
       #
       # @example Create a path from array
-      #     __pathify(['foo', '', nil, 'bar']) # => 'foo/bar'
+      #     pathify(['foo', '', nil, 'bar']) # => 'foo/bar'
       #
       # @example Create a path from arguments
-      #     __pathify('foo', '', nil, 'bar') # => 'foo/bar'
+      #     pathify('foo', '', nil, 'bar') # => 'foo/bar'
       #
       # # @example Encode special characters
-      #     __pathify(['foo', 'bar^bam']) # => 'foo/bar%5Ebam'
+      #     pathify(['foo', 'bar^bam']) # => 'foo/bar%5Ebam'
       #
       # @api private
-      def __pathify(*segments)
-        Array(segments).flatten.
-          compact.
-          reject { |s| s.to_s.strip.empty? }.
-          join('/').
-          squeeze('/')
+      def pathify(*segments)
+        Array(segments)
+          .flatten
+          .compact
+          .reject { |s| s.to_s.strip.empty? }
+          .join('/')
+          .squeeze('/')
       end
 
       # Convert an array of payloads into Elasticsearch `header\ndata` format
@@ -86,7 +88,7 @@ module Elasticsearch
       # or the conveniency "combined" format where data is passed along with the header
       # in a single item.
       #
-      #     Elasticsearch::API::Utils.__bulkify [
+      #     Elasticsearch::API::Utils.bulkify [
       #       { :index =>  { :_index => 'myindexA', :_type => 'mytype', :_id => '1', :data => { :title => 'Test' } } },
       #       { :update => { :_index => 'myindexB', :_type => 'mytype', :_id => '2', :data => { :doc => { :title => 'Update' } } } }
       #     ]
@@ -96,7 +98,7 @@ module Elasticsearch
       #     # => {"update":{"_index":"myindexB","_type":"mytype","_id":"2"}}
       #     # => {"doc":{"title":"Update"}}
       #
-      def __bulkify(payload)
+      def bulkify(payload)
         operations = %w[index create delete update]
 
         case
@@ -129,54 +131,9 @@ module Elasticsearch
         payload = payload.join("\n")
       end
 
-      # Validates the argument Hash against common and valid API parameters
-      #
-      # @param arguments    [Hash]          Hash of arguments to verify and extract, **with symbolized keys**
-      # @param valid_params [Array<Symbol>] An array of symbols with valid keys
-      #
-      # @return [Hash]         Return whitelisted Hash
-      # @raise [ArgumentError] If the arguments Hash contains invalid keys
-      #
-      # @example Extract parameters
-      #   __validate_and_extract_params( { :foo => 'qux' }, [:foo, :bar] )
-      #   # => { :foo => 'qux' }
-      #
-      # @example Raise an exception for invalid parameters
-      #   __validate_and_extract_params( { :foo => 'qux', :bam => 'mux' }, [:foo, :bar] )
-      #   # ArgumentError: "URL parameter 'bam' is not supported"
-      #
-      # @example Skip validating parameters
-      #   __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar], { skip_parameter_validation: true } )
-      #   # => { :foo => "q", :bam => "m" }
-      #
-      # @example Skip validating parameters when the module setting is set
-      #   Elasticsearch::API.settings[:skip_parameter_validation] = true
-      #   __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar] )
-      #   # => { :foo => "q", :bam => "m" }
-      #
-      # @api private
-      #
-      def __validate_and_extract_params(arguments, params=[], options={})
-        if options[:skip_parameter_validation] || Elasticsearch::API.settings[:skip_parameter_validation]
-          arguments
-        else
-          __validate_params(arguments, params)
-          __extract_params(arguments, params, options.merge(:escape => false))
-        end
-      end
-
-      def __validate_params(arguments, valid_params=[])
-        arguments.each do |k,v|
-          raise ArgumentError, "URL parameter '#{k}' is not supported" \
-            unless COMMON_PARAMS.include?(k) || COMMON_QUERY_PARAMS.include?(k) || valid_params.include?(k)
-        end
-      end
-
-      def __extract_params(arguments, params=[], options={})
-        result = arguments.select { |k,v| COMMON_QUERY_PARAMS.include?(k) || params.include?(k) }
-        result = Hash[result] unless result.is_a?(Hash) # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
-        result = Hash[result.map { |k,v| v.is_a?(Array) ? [k, __listify(v, options)] : [k,v]  }] # Listify Arrays
-        result
+      def process_params(arguments)
+        arguments = Hash[arguments] unless arguments.is_a?(Hash)
+        Hash[arguments.map { |k, v| v.is_a?(Array) ? [k, listify(v, { escape: false })] : [k, v] }] # Listify Arrays
       end
 
       # Extracts the valid parts of the URL from the arguments
@@ -189,18 +146,14 @@ module Elasticsearch
       # @return [Array<String>]            Valid parts of the URL as an array of strings
       #
       # @example Extract parts
-      #   __extract_parts { :foo => true }, [:foo, :bar]
+      #   extract_parts { :foo => true }, [:foo, :bar]
       #   # => [:foo]
       #
       #
       # @api private
       #
-      def __extract_parts(arguments, valid_parts=[])
-        parts = Hash[arguments.select { |k,v| valid_parts.include?(k) }]
-        parts = parts.reduce([]) { |sum, item| k, v = item; v.is_a?(TrueClass) ? sum << k.to_s : sum << v  }
-
-        arguments.delete_if { |k,v| valid_parts.include? k }
-        return parts
+      def extract_parts(arguments, _valid_parts = [])
+        Hash[arguments].reduce([]) { |sum, item| k, v = item; v.is_a?(TrueClass) ? sum << k.to_s : sum << v }
       end
 
       # Calls the given block, rescuing from `StandardError`.
@@ -214,7 +167,7 @@ module Elasticsearch
       #
       # @api private
       #
-      def __rescue_from_not_found(&block)
+      def rescue_from_not_found(&block)
         yield
       rescue StandardError => e
         if e.class.to_s =~ /NotFound/ || e.message =~ /Not\s*Found/i
@@ -224,68 +177,6 @@ module Elasticsearch
         end
       end
 
-      def __report_unsupported_parameters(arguments, params=[])
-        messages = []
-        unsupported_params = params.select {|d| d.is_a?(Hash) ? arguments.include?(d.keys.first) : arguments.include?(d) }
-
-        unsupported_params.each do |param|
-          name = case param
-          when Symbol
-            param
-          when Hash
-            param.keys.first
-          else
-            raise ArgumentError, "The param must be a Symbol or a Hash"
-          end
-
-          explanation = if param.is_a?(Hash)
-            ". #{param.values.first[:explanation]}."
-          else
-            ". This parameter is not supported in the version you're using: #{Elasticsearch::API::VERSION}, and will be removed in the next release."
-          end
-
-          message = "[!] You are using unsupported parameter [:#{name}]"
-
-          if source = caller && caller.last
-            message += " in `#{source}`"
-          end
-
-          message += explanation
-
-          messages << message
-        end
-
-        unless messages.empty?
-          messages << "Suppress this warning by the `-WO` command line flag."
-
-          if STDERR.tty?
-            Kernel.warn messages.map { |m| "\e[31;1m#{m}\e[0m" }.join("\n")
-          else
-            Kernel.warn messages.join("\n")
-          end
-        end
-      end
-
-      def __report_unsupported_method(name)
-        message = "[!] You are using unsupported method [#{name}]"
-        if source = caller && caller.last
-          message += " in `#{source}`"
-        end
-
-        message += ". This method is not supported in the version you're using: #{Elasticsearch::API::VERSION}, and will be removed in the next release. Suppress this warning by the `-WO` command line flag."
-
-        if STDERR.tty?
-          Kernel.warn "\e[31;1m#{message}\e[0m"
-        else
-          Kernel.warn message
-        end
-      end
-
-      def ndjson_headers(headers)
-        headers.merge!('Content-Type' => 'application/x-ndjson') unless ['1', 'true'].include?(ENV['ELASTIC_CLIENT_APIVERSIONING'])
-        headers
-      end
-
       extend self
     end
   end

data/lib/elasticsearch/api/version.rb

@@ -17,6 +17,7 @@
 
 module Elasticsearch
   module API
-    VERSION = '7.17.11'.freeze
+    VERSION = '9.0.2'.freeze
+    ES_SPECIFICATION_COMMIT = '52c473efb1fb5320a5bac12572d0b285882862fb'.freeze
   end
 end

data/lib/elasticsearch/api.rb

@@ -15,68 +15,102 @@
 # specific language governing permissions and limitations
 # under the License.
 
-require "cgi"
-require "multi_json"
+require 'cgi'
+require 'multi_json'
+require 'elasticsearch/api/version'
+require 'elasticsearch/api/utils'
+require 'elasticsearch/api/response'
 
-require "elasticsearch/api/version"
-require "elasticsearch/api/namespace/common"
-require "elasticsearch/api/utils"
-require "elasticsearch/api/actions/params_registry"
-
-Dir[ File.expand_path('../api/actions/**/params_registry.rb', __FILE__) ].each   { |f| require f }
-Dir[ File.expand_path('../api/actions/**/*.rb', __FILE__) ].each   { |f| require f }
-Dir[ File.expand_path('../api/namespace/**/*.rb', __FILE__) ].each { |f| require f }
+Dir[File.expand_path('api/actions/**/*.rb', __dir__)].each { |f| require f }
 
 module Elasticsearch
+  # This is the main module for including all API endpoint functions
+  # It includes the namespace modules from ./api/actions
   module API
+    include Elasticsearch::API::Actions
     DEFAULT_SERIALIZER = MultiJson
 
-    COMMON_PARAMS = [
-      :ignore,                        # Client specific parameters
-      :index, :type, :id,             # :index/:type/:id
-      :body,                          # Request body
-      :node_id,                       # Cluster
-      :name,                          # Alias, template, settings, warmer, ...
-      :field                          # Get field mapping
-    ]
-
-    COMMON_QUERY_PARAMS = [
-      :ignore,                        # Client specific parameters
-      :format,                        # Search, Cat, ...
-      :pretty,                        # Pretty-print the response
-      :human,                         # Return numeric values in human readable format
-      :filter_path,                   # Filter the JSON response
-      :opaque_id                      # Use X-Opaque-Id
-    ]
-
     HTTP_GET          = 'GET'.freeze
     HTTP_HEAD         = 'HEAD'.freeze
     HTTP_POST         = 'POST'.freeze
     HTTP_PUT          = 'PUT'.freeze
     HTTP_DELETE       = 'DELETE'.freeze
-    UNDERSCORE_SEARCH = '_search'.freeze
-    UNDERSCORE_ALL    = '_all'.freeze
-    DEFAULT_DOC       = '_doc'.freeze
 
-    # Auto-include all namespaces in the receiver
+    module CommonClient
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      def perform_request(method, path, params = {}, body = nil, headers = nil, request_opts = {})
+        client.perform_request(method, path, params, body, headers, request_opts)
+      end
+    end
+
+    # Add new namespaces to this constant
     #
-    def self.included(base)
-      base.send :include,
-                Elasticsearch::API::Common,
-                Elasticsearch::API::Actions,
-                Elasticsearch::API::Cluster,
-                Elasticsearch::API::Nodes,
-                Elasticsearch::API::Indices,
-                Elasticsearch::API::Ingest,
-                Elasticsearch::API::Snapshot,
-                Elasticsearch::API::Tasks,
-                Elasticsearch::API::Cat,
-                Elasticsearch::API::Remote,
-                Elasticsearch::API::DanglingIndices,
-                Elasticsearch::API::Features,
-                Elasticsearch::API::Shutdown
+    API_NAMESPACES = [:async_search,
+                      :cat,
+                      :cross_cluster_replication,
+                      :cluster,
+                      :connector,
+                      :dangling_indices,
+                      :enrich,
+                      :eql,
+                      :esql,
+                      :features,
+                      :fleet,
+                      :graph,
+                      :index_lifecycle_management,
+                      :indices,
+                      :inference,
+                      :ingest,
+                      :license,
+                      :logstash,
+                      :migration,
+                      :machine_learning,
+                      :nodes,
+                      :query_rules,
+                      :search_application,
+                      :searchable_snapshots,
+                      :security,
+                      :simulate,
+                      :snapshot_lifecycle_management,
+                      :snapshot,
+                      :sql,
+                      :ssl,
+                      :synonyms,
+                      :tasks,
+                      :text_structure,
+                      :transform,
+                      :watcher,
+                      :xpack].freeze
+
+    UPPERCASE_APIS = ['sql', 'ssl'].freeze
+    API_NAMESPACES.each do |namespace|
+      name = namespace.to_s
+      module_name = if UPPERCASE_APIS.include?(name)
+                      name.upcase
+                    elsif name == 'xpack'
+                      'XPack'
+                    else
+                      name.split('_').map(&:capitalize).join
+                    end
+      class_name = "#{module_name}Client"
+
+      klass = Class.new(Object) do
+        include CommonClient, Object.const_get("Elasticsearch::API::#{module_name}::Actions")
+      end
+      Object.const_set(class_name, klass)
+      define_method(name) do
+        instance_variable_set("@#{name}", klass.new(self))
+      end
     end
 
+    alias ml machine_learning
+    alias ilm index_lifecycle_management
+
     # The serializer class
     #
     def self.serializer