opensearch-ruby 3.3.0 → 4.0.0.pre.beta.1

data/lib/opensearch/api.rb

@@ -3,100 +3,28 @@
 # The OpenSearch Contributors require contributions made to
 # this file be licensed under the Apache-2.0 license or a
 # compatible open source license.
-#
-# Modifications Copyright OpenSearch Contributors. See
-# GitHub history for details.
-#
-# 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.
 
-# This code was generated from OpenSearch API Spec.
-# Update the code generation logic instead of modifying this file directly.
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec.
 
 # frozen_string_literal: true
 
-require 'opensearch/api/namespace/common'
-require 'opensearch/api/utils'
-require 'opensearch/api/actions/params_registry'
-
-Dir[File.expand_path('api/actions/**/params_registry.rb', __dir__)].sort.each   { |f| require f }
-Dir[File.expand_path('api/actions/**/*.rb', __dir__)].sort.each   { |f| require f }
-Dir[File.expand_path('api/namespace/**/*.rb', __dir__)].sort.each { |f| require f }
-
 module OpenSearch
   module API
-    DEFAULT_SERIALIZER = MultiJson
+    GLOBAL_QUERY_PARAMS = Set.new([
+      'pretty',         # Whether to pretty format the returned JSON response.
+      'human',          # Whether to return human readable values for statistics.
+      'error_trace',    # Whether to include the stack trace of returned errors.
+      'source',         # The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
+      'filter_path'     # Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-".
+    ]).freeze
 
-    COMMON_PARAMS = [
-      :ignore,                        # Client specific parameters
-      :index, :id,                    # :index/: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'
-    HTTP_HEAD         = 'HEAD'
-    HTTP_PATCH        = 'PATCH'
-    HTTP_POST         = 'POST'
-    HTTP_PUT          = 'PUT'
-    HTTP_DELETE       = 'DELETE'
-
-    UNDERSCORE_SEARCH = '_search'
-    UNDERSCORE_ALL    = '_all'
-    DEFAULT_DOC       = '_doc'
-
-    # Auto-include all namespaces in the receiver
-    def self.included(base)
-      base.send :include,
-                OpenSearch::API::Common,
-                OpenSearch::API::Actions,
-                OpenSearch::API::Cat,
-                OpenSearch::API::Cluster,
-                OpenSearch::API::DanglingIndices,
-                OpenSearch::API::Features,
-                OpenSearch::API::Http,
-                OpenSearch::API::Indices,
-                OpenSearch::API::Ingest,
-                OpenSearch::API::Nodes,
-                OpenSearch::API::Remote,
-                OpenSearch::API::RemoteStore,
-                OpenSearch::API::Security,
-                OpenSearch::API::Shutdown,
-                OpenSearch::API::Snapshot,
-                OpenSearch::API::Tasks
-    end
+    DEFAULT_SERIALIZER = MultiJson
 
-    # The serializer class
     def self.serializer
       settings[:serializer] || DEFAULT_SERIALIZER
     end
 
-    # Access the module settings
     def self.settings
       @settings ||= {}
     end

data/lib/opensearch/dsl/search/queries/script_score.rb

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+module OpenSearch
+  module DSL
+    module Search
+      module Queries
+        # A query which wraps another query and returns a customized score for matching documents
+        #
+        # @example
+        #
+        #     search do
+        #       query do
+        #         script_score do
+        #           query do
+        #             match content: 'Twitter'
+        #           end
+        #
+        #           script source: "_score * params['multiplier']",
+        #                  params: { multiplier: 2.0 }
+        #         end
+        #       end
+        #     end
+        #
+        # @see https://opensearch.org/docs/latest/query-dsl/specialized/script-score/
+        #
+        class ScriptScore
+          include BaseComponent
+
+          option_method :script
+          option_method :min_score
+          option_method :boost
+
+          # DSL method for building the `query` part of the query definition
+          #
+          # @return [self]
+          #
+          def query(*args, &block)
+            @query = block ? @query = Query.new(*args, &block) : args.first
+            self
+          end
+
+          # Converts the query definition to a Hash
+          #
+          # @return [Hash]
+          #
+          def to_hash
+            hash = super
+            if @query
+              _query = @query.respond_to?(:to_hash) ? @query.to_hash : @query
+              hash[name].update(query: _query)
+            end
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/dsl/search.rb

@@ -51,8 +51,8 @@ module OpenSearch
       #     # => {:query=>{:match=>{:title=>"test"}}}
       #
       #
-      def search(*args, &block)
-        Search.new(*args, &block)
+      def search(...)
+        Search.new(...)
       end
 
       extend self

data/lib/opensearch/dsl.rb

@@ -36,9 +36,9 @@ require 'opensearch/dsl/search/sort'
 require 'opensearch/dsl/search/options'
 require 'opensearch/dsl/search/suggest'
 
-Dir[File.expand_path('dsl/search/queries/**/*.rb', __dir__)].sort.each        { |f| require f }
-Dir[File.expand_path('dsl/search/filters/**/*.rb', __dir__)].sort.each        { |f| require f }
-Dir[File.expand_path('dsl/search/aggregations/**/*.rb', __dir__)].sort.each   { |f| require f }
+Dir[File.expand_path('dsl/search/queries/**/*.rb', __dir__)].each        { |f| require f }
+Dir[File.expand_path('dsl/search/filters/**/*.rb', __dir__)].each        { |f| require f }
+Dir[File.expand_path('dsl/search/aggregations/**/*.rb', __dir__)].each   { |f| require f }
 
 require 'opensearch/dsl/search'
 

data/lib/opensearch/transport/client.rb

@@ -180,7 +180,6 @@ module OpenSearch
       end
 
       # Performs a request through delegation to {#transport}.
-      #
       def perform_request(method, path, params = {}, body = nil, headers = nil)
         method = @send_get_body_as if method == 'GET' && body
         if (opaque_id = params.delete(:opaque_id))
@@ -191,6 +190,32 @@ module OpenSearch
         transport.perform_request(method, path, params, body, headers)
       end
 
+      def perform_ping_request(*args)
+        perform_request(*args).status == 200
+      rescue StandardError => e
+        return false if e.class.to_s =~ /NotFound|ConnectionFailed/
+        return false if e.message =~ /Not *Found|404|ConnectionFailed/i
+        raise e
+      end
+
+      def perform_head_request(*args)
+        perform_request(*args).status == 200
+      rescue StandardError => e
+        return false if e.class.to_s =~ /NotFound/
+        return false if e.message =~ /Not\s*Found/i
+        raise e
+      end
+
+      def perform_delete_request(*args, ignore404)
+        perform_request(*args).body
+      rescue StandardError => e
+        if ignore404
+          return false if e.class.to_s =~ /NotFound/
+          return false if e.message =~ /Not\s*Found/i
+        end
+        raise e
+      end
+
       private
 
       def set_api_key

data/lib/opensearch/transport/transport/http/faraday.rb

@@ -24,6 +24,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'opensearch/version'
+
 module OpenSearch
   module Transport
     module Transport
@@ -91,7 +93,7 @@ module OpenSearch
                 meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
               end
               meta << client.headers[USER_AGENT_STR].to_s
-              "opensearch-ruby/#{VERSION} (#{meta.join('; ')})"
+              "opensearch-ruby/#{OpenSearch::VERSION} (#{meta.join('; ')})"
             end
           end
         end

data/lib/opensearch/version.rb

@@ -25,5 +25,5 @@
 # under the License.
 
 module OpenSearch
-  VERSION = '3.3.0'.freeze
+  VERSION = '4.0.0-beta.1'.freeze
 end

data/lib/opensearch.rb

@@ -3,99 +3,137 @@
 # The OpenSearch Contributors require contributions made to
 # this file be licensed under the Apache-2.0 license or a
 # compatible open source license.
-#
-# Modifications Copyright OpenSearch Contributors. See
-# GitHub history for details.
-#
-# 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.
-
-require 'opensearch/version'
+
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec.
+
 require 'opensearch/transport'
 require 'opensearch/api'
+Dir[File.expand_path('opensearch/api/**/*.rb', __dir__)].each { |f| require f }
 
 module OpenSearch
-  SECURITY_PRIVILEGES_VALIDATION_WARNING = 'The client is unable to verify distribution due to security privileges on the server side. Some functionality may not be compatible if the server is running an unsupported product.'.freeze
-  NOT_SUPPORTED_WARNING = 'The client is not supported for the provided version and distribution combination.'.freeze
-
   class Client
-    include OpenSearch::API
+    include OpenSearch::API::Root::Actions
     attr_accessor :transport
 
-    # See OpenSearch::Transport::Client for initializer parameters
     def initialize(arguments = {}, &block)
-      @verified = false
       @transport = OpenSearch::Transport::Client.new(arguments, &block)
     end
 
-    def method_missing(name, *args, &block)
-      return super unless name == :perform_request
-      verify_open_search unless @verified
-      @transport.perform_request(*args, &block)
+    def asynchronous_search
+      @asynchronous_search ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::AsynchronousSearch::Actions)
     end
 
-    def respond_to_missing?(method_name, include_private = false)
-      method_name == :perform_request || super
+    def cat
+      @cat ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Cat::Actions)
     end
 
-    private
+    def cluster
+      @cluster ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Cluster::Actions)
+    end
 
-    def verify_open_search
-      begin
-        response = open_search_validation_request
-      rescue OpenSearch::Transport::Transport::Errors::Unauthorized,
-             OpenSearch::Transport::Transport::Errors::Forbidden
-        @verified = true
-        warn(SECURITY_PRIVILEGES_VALIDATION_WARNING)
-        return
-      end
+    def dangling_indices
+      @dangling_indices ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::DanglingIndices::Actions)
+    end
 
-      body = if response.headers['content-type'] == 'application/yaml'
-               require 'yaml'
-               YAML.safe_load(response.body)
-             else
-               response.body
-             end
-      version = body.dig('version', 'number')
-      distribution = body.dig('version', 'distribution')
-      verify_version_and_distribution(version, distribution)
+    def flow_framework
+      @flow_framework ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::FlowFramework::Actions)
     end
 
-    def verify_version_and_distribution(version, distribution)
-      raise OpenSearch::UnsupportedProductError if version.nil?
+    def indices
+      @indices ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Indices::Actions)
+    end
 
-      # The client supports all the versions of OpenSearch
-      if distribution != 'opensearch' &&
-         (Gem::Version.new(version) < Gem::Version.new('6.0.0') ||
-           Gem::Version.new(version) >= Gem::Version.new('8.0.0'))
-        raise OpenSearch::UnsupportedProductError
-      end
+    def ingest
+      @ingest ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Ingest::Actions)
+    end
 
-      @verified = true
+    def insights
+      @insights ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Insights::Actions)
     end
 
-    def open_search_validation_request
-      @transport.perform_request('GET', '/')
+    def ism
+      @ism ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Ism::Actions)
+    end
+
+    def knn
+      @knn ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Knn::Actions)
+    end
+
+    def list
+      @list ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::List::Actions)
+    end
+
+    def ml
+      @ml ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Ml::Actions)
+    end
+
+    def nodes
+      @nodes ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Nodes::Actions)
+    end
+
+    def notifications
+      @notifications ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Notifications::Actions)
+    end
+
+    def observability
+      @observability ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Observability::Actions)
+    end
+
+    def ppl
+      @ppl ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Ppl::Actions)
+    end
+
+    def query
+      @query ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Query::Actions)
+    end
+
+    def remote_store
+      @remote_store ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::RemoteStore::Actions)
+    end
+
+    def replication
+      @replication ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Replication::Actions)
+    end
+
+    def rollups
+      @rollups ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Rollups::Actions)
+    end
+
+    def search_pipeline
+      @search_pipeline ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::SearchPipeline::Actions)
+    end
+
+    def security
+      @security ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Security::Actions)
+    end
+
+    def sm
+      @sm ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Sm::Actions)
+    end
+
+    def snapshot
+      @snapshot ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Snapshot::Actions)
+    end
+
+    def sql
+      @sql ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Sql::Actions)
+    end
+
+    def tasks
+      @tasks ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Tasks::Actions)
+    end
+
+    def transforms
+      @transforms ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Transforms::Actions)
+    end
+
+    def wlm
+      @wlm ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Wlm::Actions)
     end
-  end
 
-  class UnsupportedProductError < StandardError
-    def initialize(message = NOT_SUPPORTED_WARNING)
-      super(message)
+    def http
+      @http ||= OpenSearch::API::Namespace.new(transport, OpenSearch::API::Http::Actions)
     end
   end
 end

data/opensearch-ruby.gemspec

@@ -62,7 +62,7 @@ Gem::Specification.new do |s|
     s.cert_chain  = ['.github/opensearch-rubygems.pem']
   end
 
-  s.required_ruby_version = '>= 2.5'
+  s.required_ruby_version = '>= 3.0'
 
   s.add_dependency 'faraday', '>= 1.0', '< 3'
   s.add_dependency 'multi_json', '>= 1.0'

data/spec/spec_helper.rb

@@ -29,6 +29,7 @@ if ENV.fetch('COVERAGE', nil) && ENV['CI'].nil?
   SimpleCov.start { add_filter %r{^/test|spec/} }
 end
 
+require 'active_support'
 require 'ansi'
 require 'opensearch'
 require 'opensearch-dsl'
@@ -58,7 +59,7 @@ tracer.formatter = ->(_s, _d, _p, m) { "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(
 unless defined?(OPENSEARCH_URL)
   OPENSEARCH_URL = ENV.fetch('OPENSEARCH_URL', nil) ||
                    ENV.fetch('TEST_OPENSEARCH_SERVER', nil) ||
-                   "http://localhost:#{ENV.fetch('TEST_CLUSTER_PORT', nil) || 9200}"
+                   "https://admin:myStrongPassword123!@localhost:#{ENV.fetch('TEST_CLUSTER_PORT', nil) || 9200}"
 end
 
 DEFAULT_CLIENT = OpenSearch::Client.new(host: OPENSEARCH_URL,
@@ -83,7 +84,7 @@ end
 # The names of the connected nodes.
 # @return [ Array<String> ] The node names.
 def node_names
-  node_stats = default_client.perform_request('GET', '_nodes/stats').body
+  node_stats = default_client.transport.perform_request('GET', '_nodes/stats').body
   $node_names ||= node_stats['nodes'].collect do |name, stats|
     stats['name']
   end
@@ -99,22 +100,6 @@ class NotFound < StandardError; end
 
 module HelperModule
   def self.included(context)
-    context.let(:client_double) do
-      Class.new { include OpenSearch::API }.new.tap do |client|
-        expect(client).to receive(:perform_request).with(*expected_args).and_return(response_double)
-      end
-    end
-
-    context.let(:client) do
-      Class.new { include OpenSearch::API }.new.tap do |client|
-        expect(client).to receive(:perform_request).with(*expected_args).and_return(response_double)
-      end
-    end
-
-    context.let(:response_double) do
-      double('response', status: 200, body: {}, headers: {})
-    end
-
     context.let(:hosts) { OPENSEARCH_HOSTS }
   end
 end