elastic-enterprise-search 0.2.1 → 7.12.0

data/lib/elastic/enterprise-search/api/version.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# 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 Elastic
+  module EnterpriseSearch
+    module Actions
+      # Version - Get version information for this server
+      # Get version information for this server
+      #
+      # @option arguments [Hash] :headers optional HTTP headers to send with the request
+      #
+      # @see https://www.elastic.co/guide/en/enterprise-search/current/management-apis.html
+      #
+      def version(arguments = {})
+        headers = arguments.delete(:headers) || {}
+
+        request(
+          :get,
+          'api/ent/v1/internal/version/',
+          arguments,
+          {},
+          headers
+        )
+      end
+    end
+  end
+end

data/lib/elastic/enterprise-search/client.rb

@@ -1,34 +1,93 @@
-require 'set'
-require 'elastic/enterprise-search/configuration'
+# 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.
+
+# frozen_string_literal: true
+
 require 'elastic/enterprise-search/request'
 require 'elastic/enterprise-search/utils'
+require 'elasticsearch-transport'
 
 module Elastic
+  # If the version is X.X.X.pre/alpha/beta, use X.X.Xp for the meta-header:
+  def self.client_meta_version
+    regexp = /^([0-9]+\.[0-9]+\.[0-9]+)\.?([a-z0-9.-]+)?$/
+    match = Elastic::EnterpriseSearch::VERSION.match(regexp)
+    return "#{match[1]}p" if match[2]
+
+    Elastic::EnterpriseSearch::VERSION
+  end
+
+  META_HEADER_SERVICE_VERSION = [:ent, client_meta_version].freeze
+
   module EnterpriseSearch
-    # API client for the {Elastic Enterprise Search API}[https://swiftype.com/enterprise-search].
+    # API client for the {Elastic Enterprise Search API}[https://www.elastic.co/enterprise-search].
+    # This is the main client from which the Workplace Search and App Search clients inherit.
     class Client
       DEFAULT_TIMEOUT = 15
 
       include Elastic::EnterpriseSearch::Request
+      include Elastic::EnterpriseSearch::Actions
+      include Elastic::EnterpriseSearch::Utils
+
+      def workplace_search(options = {})
+        @workplace_search ||= Elastic::EnterpriseSearch::WorkplaceSearch::Client.new(
+          host: host,
+          http_auth: options[:http_auth],
+          transport: @transport
+        )
+      end
 
-      def self.configure(&block)
-        Elastic::EnterpriseSearch.configure &block
+      def app_search(options = {})
+        @app_search ||= Elastic::EnterpriseSearch::AppSearch::Client.new(
+          host: host,
+          http_auth: options[:http_auth],
+          transport: @transport
+        )
       end
 
       # Create a new Elastic::EnterpriseSearch::Client client
       #
       # @param options [Hash] a hash of configuration options that will override what is set on the Elastic::EnterpriseSearch class.
-      # @option options [String] :access_token an Access Token to use for this client
+      # @option options [String] :host Enterprise Search host
+      # @option options [Hash] :basic_auth a username and password for Basic Authentication
       # @option options [Numeric] :overall_timeout overall timeout for requests in seconds (default: 15s)
-      # @option options [Numeric] :open_timeout the number of seconds Net::HTTP (default: 15s)
-      #   will wait while opening a connection before raising a Timeout::Error
+      # @option options [Numeric] :open_timeout the number of seconds Net::HTTP (default: 15s) will wait while opening a connection before raising a Timeout::Error
       # @option options [String] :proxy url of proxy to use, ex: "http://localhost:8888"
+      # @option options [Boolean] :log Use the default logger (disabled by default)
+      # @option arguments [Object] :logger An instance of a Logger-compatible object
+      # @option enable_meta_header [Boolean] :enable_meta_header Enable sending the meta data header to Cloud.
+      #                                                          (Default: true)
       def initialize(options = {})
         @options = options
+        @transport = transport
       end
 
-      def access_token
-        @options[:access_token] || Elastic::EnterpriseSearch.access_token
+      def transport
+        @options[:transport] ||
+          Elasticsearch::Client.new(
+            host: host,
+            log: log,
+            logger: logger,
+            request_timeout: overall_timeout,
+            transport_options: {
+              request: { open_timeout: open_timeout }
+            },
+            enable_meta_header: @options[:enable_meta_header] || true
+          )
       end
 
       def open_timeout
@@ -43,50 +102,29 @@ module Elastic
         (@options[:overall_timeout] || DEFAULT_TIMEOUT).to_f
       end
 
-      # Documents have fields that can be searched or filtered.
-      #
-      # For more information on indexing documents, see the {Content Source documentation}[https://swiftype.com/documentation/enterprise-search/guides/content-sources].
-      module ContentSourceDocuments
-
-        # Index a batch of documents using the {Content Source API}[https://swiftype.com/documentation/enterprise-search/api/custom-sources].
-        #
-        # @param [String] content_source_key the unique Content Source key as found in your Content Sources dashboard
-        # @param [Array] documents an Array of Document Hashes
-        #
-        # @return [Array<Hash>] an Array of Document indexing Results
-        #
-        # @raise [Elastic::EnterpriseSearch::InvalidDocument] when a single document is missing required fields or contains unsupported fields
-        # @raise [Timeout::Error] when timeout expires waiting for results
-        def index_documents(content_source_key, documents)
-          documents = Array(documents).map! { |document| normalize_document(document) }
-
-          async_create_or_update_documents(content_source_key, documents)
-        end
-
-        # Destroy a batch of documents given a list of external IDs
-        #
-        # @param [Array<String>] document_ids an Array of Document External IDs
-        #
-        # @return [Array<Hash>] an Array of Document destroy result hashes
-        #
-        # @raise [Timeout::Error] when timeout expires waiting for results
-        def destroy_documents(content_source_key, document_ids)
-          document_ids = Array(document_ids)
-          post("ent/sources/#{content_source_key}/documents/bulk_destroy.json", document_ids)
-        end
-
-        private
-
-        def async_create_or_update_documents(content_source_key, documents)
-          post("ent/sources/#{content_source_key}/documents/bulk_create.json", documents)
-        end
-
-        def normalize_document(document)
-          Utils.stringify_keys(document)
-        end
+      def http_auth
+        @options[:http_auth] || { user: 'elastic', password: 'changeme' }
+      end
+
+      def http_auth=(http_auth)
+        @options[:http_auth] = http_auth
+      end
+
+      def log
+        @options[:log] || false
+      end
+
+      def logger
+        @options[:logger]
       end
 
-      include Elastic::EnterpriseSearch::Client::ContentSourceDocuments
+      def host
+        return DEFAULT_HOST unless @options[:host]
+
+        raise URI::InvalidURIError unless @options[:host] =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+
+        @options[:host]
+      end
     end
   end
 end

data/lib/elastic/enterprise-search/configuration.rb

@@ -1,18 +1,35 @@
+# 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.
+
+# frozen_string_literal: true
+
 require 'uri'
-require 'elastic/enterprise-search/version'
+require 'elastic/workplace-search/version'
 
 module Elastic
   module EnterpriseSearch
+    # Configuratin module
     module Configuration
-      DEFAULT_ENDPOINT = "http://localhost:3002/api/v1/"
+      # TODO: Endpoint for EE
+      # DEFAULT_ENDPOINT = 'http://localhost:3002/api/ws/v1/'
 
-      VALID_OPTIONS_KEYS = [
-        :access_token,
-        :user_agent,
-        :endpoint
-      ].freeze
+      VALID_OPTIONS_KEYS = [:access_token, :endpoint].freeze
 
-      attr_accessor *VALID_OPTIONS_KEYS
+      attr_accessor(*VALID_OPTIONS_KEYS)
 
       def self.extended(base)
         base.reset
@@ -22,11 +39,10 @@ module Elastic
       def reset
         self.access_token = nil
         self.endpoint = DEFAULT_ENDPOINT
-        self.user_agent = nil
         self
       end
 
-      # Yields the Elastic::EnterpriseSearch::Configuration module which can be used to set configuration options.
+      # Yields the Elastic::WorkplaceSearch::Configuration module which can be used to set configuration options.
       #
       # @return self
       def configure
@@ -37,17 +53,17 @@ module Elastic
       # Return a hash of the configured options.
       def options
         options = {}
-        VALID_OPTIONS_KEYS.each{ |k| options[k] = send(k) }
+        VALID_OPTIONS_KEYS.each { |k| options[k] = send(k) }
         options
       end
 
       # setter for endpoint that ensures it always ends in '/'
       def endpoint=(endpoint)
-        if endpoint.end_with?('/')
-          @endpoint = endpoint
-        else
-          @endpoint = "#{endpoint}/"
-        end
+        @endpoint = if endpoint.end_with?('/')
+                      endpoint
+                    else
+                      "#{endpoint}/"
+                    end
       end
     end
   end

data/lib/elastic/enterprise-search/exceptions.rb

@@ -1,3 +1,22 @@
+# 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.
+
+# frozen_string_literal: true
+
 module Elastic
   module EnterpriseSearch
     class ClientException < StandardError; end

data/lib/elastic/enterprise-search/request.rb

@@ -1,112 +1,90 @@
+# 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.
+
+# frozen_string_literal: true
+
 require 'net/https'
 require 'json'
 require 'elastic/enterprise-search/exceptions'
-require 'openssl'
+require 'base64'
 
 module Elastic
   module EnterpriseSearch
-    CLIENT_NAME = 'elastic-enterprise-search-ruby'
+    CLIENT_NAME = 'elastic-enteprise-search-ruby'
     CLIENT_VERSION = Elastic::EnterpriseSearch::VERSION
 
+    # Module included in Elastic::Enterprise::Client for http requests.
     module Request
-      def get(path, params={})
-        request(:get, path, params)
+      def get(path, params = {}, headers = {})
+        request(:get, path, params, headers)
       end
 
-      def post(path, params={})
-        request(:post, path, params)
+      def post(path, params = {}, body = {}, headers = {})
+        request(:post, path, params, body, headers)
       end
 
-      def put(path, params={})
-        request(:put, path, params)
+      def put(path, params = {}, body = {}, headers = {})
+        request(:put, path, params, body, headers)
       end
 
-      def delete(path, params={})
-        request(:delete, path, params)
+      def delete(path, params = {}, headers = {})
+        request(:delete, path, params, headers)
       end
 
       # Construct and send a request to the API.
       #
       # @raise [Timeout::Error] when the timeout expires
-      def request(method, path, params = {})
-        Timeout.timeout(overall_timeout) do
-          uri = URI.parse("#{Elastic::EnterpriseSearch.endpoint}#{path}")
-
-          request = build_request(method, uri, params)
-
-          if proxy
-            proxy_parts = URI.parse(proxy)
-            http = Net::HTTP.new(uri.host, uri.port, proxy_parts.host, proxy_parts.port, proxy_parts.user, proxy_parts.password)
-          else
-            http = Net::HTTP.new(uri.host, uri.port)
-          end
-
-          http.open_timeout = open_timeout
-          http.read_timeout = overall_timeout
-
-          if uri.scheme == 'https'
-            http.use_ssl = true
-            # st_ssl_verify_none provides a means to disable SSL verification for debugging purposes. An example
-            # is Charles, which uses a self-signed certificate in order to inspect https traffic. This will
-            # not be part of this client's public API, this is more of a development enablement option
-            http.verify_mode = ENV['st_ssl_verify_none'] == 'true' ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
-            http.ca_file = File.realpath(File.join(File.dirname(__FILE__), '..', '..', 'data', 'ca-bundle.crt'))
-            http.ssl_timeout = open_timeout
-          end
+      def request(method, path, params = {}, body = {}, headers = {})
+        meta_headers = { authorization: decide_authorization(params), user_agent: request_user_agent }
+        headers = if headers.nil? || !headers.is_a?(Hash)
+                    meta_headers
+                  else
+                    headers.merge(meta_headers)
+                  end
+
+        @transport.perform_request(method.to_s.upcase, path, params, body, headers)
+      end
 
-          response = http.request(request)
-          handle_errors(response)
-          JSON.parse(response.body) if response.body && response.body.strip != ''
-        end
+      def setup_authentication_header
+        credentials = Base64.strict_encode64("#{http_auth[:user]}:#{http_auth[:password]}")
+        "Basic #{credentials}"
       end
 
       private
-      def handle_errors(response)
-        case response
-        when Net::HTTPSuccess
-          response
-        when Net::HTTPUnauthorized
-          raise Elastic::EnterpriseSearch::InvalidCredentials
-        when Net::HTTPNotFound
-          raise Elastic::EnterpriseSearch::NonExistentRecord
-        when Net::HTTPBadRequest
-          raise Elastic::EnterpriseSearch::BadRequest
-        when Net::HTTPForbidden
-          raise Elastic::EnterpriseSearch::Forbidden
-        else
-          raise Elastic::EnterpriseSearch::UnexpectedHTTPException, "#{response.code} #{response.body}"
+
+      def request_user_agent
+        ua = "#{CLIENT_NAME}/#{CLIENT_VERSION}"
+        meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+        if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+          meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} " \
+                  "#{RbConfig::CONFIG['target_cpu']}"
         end
+        meta << "elasticsearch-transport: #{Elasticsearch::Transport::VERSION}"
+        "#{ua} (#{meta.join('; ')})"
       end
 
-      def build_request(method, uri, params)
-        klass = case method
-                when :get
-                  Net::HTTP::Get
-                when :post
-                  Net::HTTP::Post
-                when :put
-                  Net::HTTP::Put
-                when :delete
-                  Net::HTTP::Delete
-                end
-
-        case method
-        when :get, :delete
-          uri.query = URI.encode_www_form(params) if params && !params.empty?
-          req = klass.new(uri.request_uri)
-        when :post, :put
-          req = klass.new(uri.request_uri)
-          req.body = JSON.generate(params) unless params.length == 0
+      def decide_authorization(params)
+        if params[:grant_type] == 'authorization_code'
+          "Bearer #{params[:code]}"
+        elsif params[:access_token]
+          "Bearer #{params.delete(:access_token)}"
+        else
+          setup_authentication_header
         end
-
-        req['User-Agent'] = Elastic::EnterpriseSearch.user_agent if Elastic::EnterpriseSearch.user_agent
-        req['Content-Type'] = 'application/json'
-        req['X-Swiftype-Client'] = CLIENT_NAME
-        req['X-Swiftype-Client-Version'] = CLIENT_VERSION
-        req['Authorization'] = "Bearer #{access_token}"
-        puts req
-
-        req
       end
     end
   end