elastomer-client 0.3.1

data/lib/elastomer/client/nodes.rb

@@ -0,0 +1,87 @@
+
+module Elastomer
+  class Client
+
+    # Provides access to node-level API commands.
+    #
+    # node_id - The node ID as a String or an Array of node IDs
+    #
+    # Returns a Nodes instance.
+    def nodes( node_id = '_all' )
+      Nodes.new self, node_id
+    end
+
+
+    class Nodes
+      # Create a new nodes client for making API requests that pertain to
+      # the health and management individual nodes.
+      #
+      # client - Elastomer::Client used for HTTP requests to the server
+      # node_id - The node ID as a String or an Array of node IDs
+      #
+      def initialize( client, node_id )
+        @client  = client
+        @node_id = node_id
+      end
+
+      attr_reader :client, :node_id
+
+      # Retrieve one or more (or all) of the cluster nodes information.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-cluster-nodes-info/
+      #
+      # params - Parameters Hash
+      #
+      # Returns the response as a Hash
+      def info( params = {} )
+        response = client.get '/_nodes{/node_id}', update_params(params, :action => 'nodes.info')
+        response.body
+      end
+
+      # Retrieve one or more (or all) of the cluster nodes statistics.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-cluster-nodes-stats/
+      #
+      # params - Parameters Hash
+      #
+      # Returns the response as a Hash
+      def stats( params = {} )
+        response = client.get '/_nodes{/node_id}/stats', update_params(params, :action => 'nodes.stats')
+        response.body
+      end
+
+      # Get the current hot threads on each node in the cluster.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-cluster-nodes-hot-threads/
+      #
+      # params - Parameters Hash
+      #
+      # Returns the response as a Hash
+      def hot_threads( params = {} )
+        response = client.get '/_nodes{/node_id}/hot_threads', update_params(params, :action => 'nodes.hot_threads')
+        response.body
+      end
+
+      # Shutdown one or more nodes in the cluster.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-cluster-nodes-shutdown/
+      #
+      # params - Parameters Hash
+      #
+      # Returns the response as a Hash
+      def shutdown( params = {} )
+        response = client.post '/_cluster/nodes{/node_id}/_shutdown', update_params(params, :action => 'nodes.shutdown')
+        response.body
+      end
+
+      # Internal: Add default parameters to the `params` Hash and then apply
+      # `overrides` to the params if any are given.
+      #
+      # params    - Parameters Hash
+      # overrides - Optional parameter overrides as a Hash
+      #
+      # Returns a new params Hash.
+      def update_params( params, overrides = nil )
+        h = { :node_id => node_id }.update params
+        h.update overrides unless overrides.nil?
+        h
+      end
+    end  # Nodes
+  end  # Client
+end  # Elastomer

data/lib/elastomer/client/scan.rb

@@ -0,0 +1,161 @@
+module Elastomer
+  class Client
+
+    # Create a new Scan instance for scrolling all results from a `query`.
+    #
+    # query  - The query to scan as a Hash or a JSON encoded String
+    # opts   - Options Hash
+    #   :index  - the name of the index to search
+    #   :type   - the document type to search
+    #   :scroll - the keep alive time of the scrolling request (5 minutes by default)
+    #   :size   - the number of documents per shard to fetch per scroll
+    #
+    # Examples
+    #
+    #   scan = client.scan('{"query":{"match_all":{}}}', :index => 'test')
+    #   scan.each_document do |document|
+    #     document['_id']
+    #     document['_source']
+    #   end
+    #
+    # Returns a new Scan instance
+    def scan( query, opts = {} )
+      Scan.new self, query, opts
+    end
+
+    # Continue scrolling a scan query.
+    # See http://www.elasticsearch.org/guide/reference/api/search/scroll/
+    #
+    # scroll_id - The current scroll ID as a String
+    # scroll    - The keep alive time of the scrolling request (5 minutes by default)
+    #
+    # Examples
+    #
+    #   scroll_id = client.scan('{"query":{"match_all":{}}}', :index => 'test').scroll_id
+    #
+    #   h = client.scroll scroll_id   # scroll to get the next set of results
+    #   scroll_id = h['_scroll_id']   # and store the scroll_id to use later
+    #
+    #   h = client.scroll scroll_id   # scroll again to get the next set of results
+    #   scroll_id = h['_scroll_id']   # and store the scroll_id to use later
+    #
+    #   # repeat until the results are empty
+    #
+    # Returns the response body as a Hash.
+    def scroll( scroll_id, scroll = '5m' )
+      response = get '/_search/scroll', :body => scroll_id, :scroll => scroll, :action => 'search.scroll'
+      response.body
+    end
+
+
+    class Scan
+      # Create a new scan client that can be used to iterate over all the
+      # documents returned by the `query`.
+      #
+      # See http://www.elasticsearch.org/guide/reference/api/search/scroll/
+      # and the "Scan" section of http://www.elasticsearch.org/guide/reference/api/search/search-type/
+      #
+      # client - Elastomer::Client used for HTTP requests to the server
+      # query  - The query to scan as a Hash or a JSON encoded String
+      # opts   - Options Hash
+      #   :index  - the name of the index to search
+      #   :type   - the document type to search
+      #   :scroll - the keep alive time of the scrolling request (5 minutes by default)
+      #   :size   - the number of documents per shard to fetch per scroll
+      #
+      # Examples
+      #
+      #   scan = Scan.new(client, {:query => {:match_all => {}}}, :index => 'test-1')
+      #   scan.each_document { |doc|
+      #     doc['_id']
+      #     doc['_source']
+      #   }
+      #
+      def initialize( client, query, opts = {} )
+        @client = client
+        @query  = query
+
+        @index  = opts.fetch(:index, nil)
+        @type   = opts.fetch(:type, nil)
+        @scroll = opts.fetch(:scroll, '5m')
+        @size   = opts.fetch(:size, 50)
+
+        @offset = 0
+      end
+
+      attr_reader :client, :query, :index, :type, :scroll, :size
+
+      # Iterate over all the search results from the scan query.
+      #
+      # block  - The block will be called for each set of matching documents
+      #          returned from executing the scan query.
+      #
+      # Yields a hits Hash containing the 'total' number of hits, current
+      # 'offset' into that total, and the Array of 'hits' document Hashes.
+      #
+      # Examples
+      #
+      #   scan.each do |hits|
+      #     hits['total']
+      #     hits['offset']
+      #     hits['hits'].each { |document| ... }
+      #   end
+      #
+      # Returns this Scan instance.
+      def each
+        loop do
+          body = client.scroll scroll_id, scroll
+          @scroll_id = body['_scroll_id']
+
+          hits = body['hits']
+          break if hits['hits'].empty?
+
+          hits['offset'] = @offset
+          @offset += hits['hits'].length
+
+          yield hits
+        end
+
+        self
+      end
+
+      # Iterate over each document from the scan query. This method is just a
+      # convenience wrapper around the `each` method; it iterates the Array of
+      # documents and passes them one by one to the block.
+      #
+      # block  - The block will be called for each document returned from
+      #          executing the scan query.
+      #
+      # Yields a document Hash.
+      #
+      # Examples
+      #
+      #   scan.each_document do |document|
+      #     document['_id']
+      #     document['_source']
+      #   end
+      #
+      # Returns this Scan instance.
+      def each_document( &block )
+        each { |hits| hits['hits'].each(&block) }
+      end
+
+      # Internal: Returns the current scroll ID as a String.
+      def scroll_id
+        return @scroll_id if defined? @scroll_id
+
+        response = client.get '{/index}{/type}/_search',
+                              :action      => 'search.scan',
+                              :search_type => 'scan',
+                              :scroll      => scroll,
+                              :size        => size,
+                              :index       => index,
+                              :type        => type,
+                              :body        => query
+
+        @scroll_id = response.body['_scroll_id']
+      end
+
+    end  # Scan
+  end  # Client
+end  # Elastomer

data/lib/elastomer/client/template.rb

@@ -0,0 +1,85 @@
+
+module Elastomer
+  class Client
+
+    # Returns a Template instance.
+    def template( name )
+      Template.new self, name
+    end
+
+
+    class Template
+
+      # Create a new template client for making API requests that pertain to
+      # template management.
+      #
+      # client - Elastomer::Client used for HTTP requests to the server
+      # name   - The name of the template as a String
+      #
+      def initialize( client, name )
+        @client = client
+        @name   = name
+      end
+
+      attr_reader :client, :name
+
+      # Returns true if the template already exists on the cluster.
+      def exists?
+        client.cluster.templates.key? name
+      end
+      alias :exist? :exists?
+
+      # Get the template from the cluster.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-indices-templates/
+      #
+      # params - Parameters Hash
+      #
+      # Returns the response body as a Hash
+      def get( params = {} )
+        response = client.get '/_template/{template}', update_params(params, :action => 'template.get')
+        response.body
+      end
+
+      # Create the template on the cluster.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-indices-templates/
+      #
+      # template - The template as a Hash or a JSON encoded String
+      # params   - Parameters Hash
+      #
+      # Returns the response body as a Hash
+      def create( template, params = {} )
+        response = client.put '/_template/{template}', update_params(params, :body => template, :action => 'template.create')
+        response.body
+      end
+
+      # Delete the template from the cluster.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-indices-templates/
+      #
+      # params - Parameters Hash
+      #
+      # Returns the response body as a Hash
+      def delete( params = {} )
+        response = client.delete '/_template/{template}', update_params(params, :action => 'template.delete')
+        response.body
+      end
+
+      # Internal: Add default parameters to the `params` Hash and then apply
+      # `overrides` to the params if any are given.
+      #
+      # params    - Parameters Hash
+      # overrides - Optional parameter overrides as a Hash
+      #
+      # Returns a new params Hash.
+      def update_params( params, overrides = nil )
+        h = defaults.update params
+        h.update overrides unless overrides.nil?
+        h
+      end
+
+      # Internal: Returns a Hash containing default parameters.
+      def defaults
+        { :template => name }
+      end
+    end  # Template
+  end  # Client
+end  # Elastomer

data/lib/elastomer/client/warmer.rb

@@ -0,0 +1,96 @@
+module Elastomer
+  class Client
+
+    # Provides access to warmer API commands.
+    # See http://www.elasticsearch.org/guide/reference/api/admin-indices-warmers/
+    #
+    # index_name  - The name of the index as a String
+    # warmer_name - The name of the warmer as a String
+    #
+    # Returns a Warmer instance.
+    def warmer(index_name, warmer_name)
+      Warmer.new(self, index_name, warmer_name)
+    end
+
+    class Warmer
+
+      # Create a new Warmer helper for making warmer API requests.
+      #
+      # client     - Elastomer::Client used for HTTP requests to the server
+      # index_name - The name of the index as a String
+      # name       - The name of the warmer as a String
+      def initialize(client, index_name, name)
+        @client     = client
+        @index_name = @client.assert_param_presence(index_name, 'index name')
+        @name       = @client.assert_param_presence(name, 'warmer name')
+      end
+
+      attr_reader :client, :index_name, :name
+
+      # Create a warmer.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-indices-warmers/
+      #
+      # query  - The query the warmer should run
+      # params - Parameters Hash
+      #
+      # Examples
+      #
+      #   warmer.create(:query => {:match_all => {}})
+      #
+      # Returns the response body as a Hash
+      def create(query, params = {})
+        response = client.put '/{index}{/type}/_warmer/{warmer}', defaults.update(params.update(:body => query))
+        response.body
+      end
+
+      # Delete a warmer.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-indices-warmers/
+      #
+      # params   - Parameters Hash
+      #
+      # Returns the response body as a Hash
+      def delete(params = {})
+        response = client.delete '/{index}{/type}/_warmer/{warmer}', defaults.update(params)
+        response.body
+      end
+
+      # Get a warmer.
+      # See http://www.elasticsearch.org/guide/reference/api/admin-indices-warmers/
+      #
+      # params   - Parameters Hash
+      #
+      # Returns the response body as a Hash
+      def get(params = {})
+        response = client.get '/{index}{/type}/_warmer/{warmer}', defaults.update(params)
+        response.body
+      end
+
+      # Check whether a warmer exists. Also aliased as exist?
+      #
+      # Since there is no native warmer exists api, this method executes
+      # a get and watches for an IndexWarmerMissingException error.
+      #
+      # Returns true if the warmer exists, false if not.
+      #COMPATIBILITY warmer response differs in ES 1.0
+      # ES 1.0: missing warmer returns {} with 200 status
+      # ES 0.90: missing warmer returns IndexWarmerMissingException error
+      # See https://github.com/elasticsearch/elasticsearch/issues/5155
+      def exists?
+        response = get
+        response != {}
+      rescue Elastomer::Client::Error => exception
+        if exception.message =~ /IndexWarmerMissingException/
+          false
+        else
+          raise exception
+        end
+      end
+      alias :exist? :exists?
+
+      # Internal: Returns a Hash containing default parameters.
+      def defaults
+        {:index => index_name, :warmer => name}
+      end
+    end
+  end
+end

data/lib/elastomer/core_ext/time.rb

@@ -0,0 +1,7 @@
+require 'time'
+
+class Time
+  def to_json(ignore = nil)
+    %Q["#{self.iso8601}"]
+  end
+end

data/lib/elastomer/middleware/encode_json.rb

@@ -0,0 +1,51 @@
+module Elastomer
+  module Middleware
+    # Request middleware that encodes the body as JSON.
+    #
+    # Processes only requests with matching Content-type or those without a type.
+    # If a request doesn't have a type but has a body, it sets the Content-type
+    # to JSON MIME-type.
+    #
+    # Doesn't try to encode bodies that already are in string form.
+    class EncodeJson < Faraday::Middleware
+      CONTENT_TYPE = 'Content-Type'.freeze
+      MIME_TYPE    = 'application/json'.freeze
+
+      def call(env)
+        match_content_type(env) do |data|
+          env[:body] = encode data
+        end
+        @app.call env
+      end
+
+      def encode(data)
+        MultiJson.dump data
+      end
+
+      def match_content_type(env)
+        if process_request?(env)
+          env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+          yield env[:body] unless env[:body].respond_to?(:to_str)
+        end
+      end
+
+      def process_request?(env)
+        type = request_type(env)
+        has_body?(env) and (type.empty? or type == MIME_TYPE)
+      end
+
+      def has_body?(env)
+        body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
+      end
+
+      def request_type(env)
+        type = env[:request_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware \
+  :encode_json => ::Elastomer::Middleware::EncodeJson