opensearch-ruby 3.4.0 → 4.0.0.pre.beta.2

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,8 +62,9 @@ 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 "logger"
   s.add_dependency 'multi_json', '>= 1.0'
 end

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

data/test/transport/unit/transport_base_test.rb

@@ -281,21 +281,6 @@ class OpenSearch::Transport::Transport::BaseTest < Minitest::Test
       end
     end
 
-    should "not raise an error when the :ignore argument has been passed" do
-      @transport.stubs(:get_connection).returns(stub_everything :failures => 1)
-
-      assert_raise OpenSearch::Transport::Transport::Errors::BadRequest do
-        @transport.perform_request 'GET', '/' do
-          OpenSearch::Transport::Transport::Response.new 400, 'CLIENT ERROR'
-        end
-      end
-
-      # No `BadRequest` error
-      @transport.perform_request 'GET', '/', :ignore => 400 do
-        OpenSearch::Transport::Transport::Response.new 400, 'CLIENT ERROR'
-      end
-    end
-
     should "mark the connection as dead on failure" do
       c = stub_everything :failures => 1
       @transport.expects(:get_connection).returns(c)
@@ -467,17 +452,6 @@ class OpenSearch::Transport::Transport::BaseTest < Minitest::Test
       end
     end
 
-    should "not log a failed OpenSearch request as fatal" do
-      @block = Proc.new { |c, u| puts "ERROR" }
-      @block.expects(:call).returns(OpenSearch::Transport::Transport::Response.new 500, 'ERROR')
-
-      @transport.expects(:__log_response).once
-      @transport.logger.expects(:fatal).never
-
-      # No `BadRequest` error
-      @transport.perform_request('POST', '_search', :ignore => 500, &@block)
-    end
-
     should "log and re-raise a Ruby exception" do
       @block = Proc.new { |c, u| puts "ERROR" }
       @block.expects(:call).raises(StandardError)