elasticsearch-api 0.0.2

data/lib/elasticsearch/api/actions/cluster/health.rb

@@ -0,0 +1,50 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Returns information about cluster "health".
+        #
+        # @example
+        #
+        #     client.cluster.health
+        #
+        # @option arguments [String] :index Limit the information returned to a specific index
+        # @option arguments [String] :level Specify the level of detail for returned information
+        #                                   (options: cluster, indices, shards)
+        # @option arguments [Boolean] :local Return local information, do not retrieve the state from master node
+        #                                    (default: false)
+        # @option arguments [Time] :master_timeout Explicit operation timeout for connection to master node
+        # @option arguments [Time] :timeout Explicit operation timeout
+        # @option arguments [Number] :wait_for_active_shards Wait until the specified number of shards is active
+        # @option arguments [Number] :wait_for_nodes Wait until the specified number of nodes is available
+        # @option arguments [Number] :wait_for_relocating_shards Wait until the specified number of relocating
+        #                                                        shards is finished
+        # @option arguments [String] :wait_for_status Wait until cluster is in a specific state
+        #                                             (options: green, yellow, red)
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-health/
+        #
+        def health(arguments={})
+          method = 'GET'
+          path   = "_cluster/health"
+          params = arguments.select do |k,v|
+            [ :level,
+              :local,
+              :master_timeout,
+              :timeout,
+              :wait_for_active_shards,
+              :wait_for_nodes,
+              :wait_for_relocating_shards,
+              :wait_for_status ].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          params = Hash[params] unless params.is_a?(Hash)
+          body = nil
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/cluster/node_hot_threads.rb

@@ -0,0 +1,46 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Returns information about the hottest threads in the cluster or on a specific node as a String.
+        #
+        #
+        # The information is returned as text, and allows you to understand what are currently
+        # the most taxing operations happening in the cluster, for debugging or monitoring purposes.
+        #
+        # @example Return 10 hottest threads
+        #
+        #     client.cluster.node_hot_threads threads: 10
+        #
+        # @option arguments [List] :node_id A comma-separated list of node IDs or names to limit the returned information;
+        #                                   use `_local` to return information from the node you're connecting to,
+        #                                   leave empty to get information from all nodes
+        # @option arguments [Time] :interval The interval for the second sampling of threads
+        # @option arguments [Number] :snapshots Number of samples of thread stacktrace (default: 10)
+        # @option arguments [Number] :threads Specify the number of threads to provide information for (default: 3)
+        # @option arguments [String] :type The type to sample (default: cpu) (options: cpu, wait, block)
+        #
+        # @return [String]
+        #
+        # @see http://www.elasticsearch.org/guide/reference/api/admin-cluster-nodes-hot-threads/
+        #
+        def node_hot_threads(arguments={})
+          method = 'GET'
+          path   = "_cluster/nodes/#{arguments[:node_id]}/hot_threads".squeeze('/')
+          params = arguments.select do |k,v|
+            [ :interval,
+              :snapshots,
+              :threads,
+              :type ].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          params = Hash[params] unless params.is_a?(Hash)
+          body = nil
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/cluster/node_info.rb

@@ -0,0 +1,59 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Returns information about nodes in the cluster (cluster settings, JVM version, etc).
+        #
+        # Use the `all` option to return all available settings, or limit the information returned
+        # to a specific type (eg. `http`).
+        #
+        # Use the `node_id` option to limit information to specific node(s).
+        #
+        # @example Return information about JVM
+        #
+        #     client.cluster.node_info jvm: true
+        #
+        # @option arguments [List] :node_id A comma-separated list of node IDs or names to limit the returned information;
+        #                                   use `_local` to return information from the node you're connecting to, leave
+        #                                   empty to get information from all nodes
+        # @option arguments [Boolean] :all Return all available information
+        # @option arguments [Boolean] :clear Reset the default settings
+        # @option arguments [Boolean] :http Return information about HTTP
+        # @option arguments [Boolean] :jvm Return information about the JVM
+        # @option arguments [Boolean] :network Return information about network
+        # @option arguments [Boolean] :os Return information about the operating system
+        # @option arguments [Boolean] :plugin Return information about plugins
+        # @option arguments [Boolean] :process Return information about the Elasticsearch process
+        # @option arguments [Boolean] :settings Return information about node settings
+        # @option arguments [Boolean] :thread_pool Return information about the thread pool
+        # @option arguments [Boolean] :transport Return information about transport
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-nodes-info/
+        #
+        def node_info(arguments={})
+          method = 'GET'
+          path   = Utils.__pathify( '_cluster/nodes', Utils.__listify(arguments[:node_id]) )
+          params = arguments.select do |k,v|
+            [ :all,
+              :clear,
+              :http,
+              :jvm,
+              :network,
+              :os,
+              :plugin,
+              :process,
+              :settings,
+              :thread_pool,
+              :transport ].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          params = Hash[params] unless params.is_a?(Hash)
+          body = nil
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/cluster/node_shutdown.rb

@@ -0,0 +1,36 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Shutdown one or all nodes
+        #
+        # @example Shut down node named _Bloke_
+        #
+        #     client.cluster.node_shutdown node_id: 'Bloke'
+        #
+        # @option arguments [List] :node_id A comma-separated list of node IDs or names to perform the operation on; use
+        #                                   `_local` to shutdown the node you're connected to, leave empty to
+        #                                   shutdown all nodes
+        # @option arguments [Time] :delay Set the delay for the operation (default: 1s)
+        # @option arguments [Boolean] :exit Exit the JVM as well (default: true)
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-nodes-shutdown/
+        #
+        def node_shutdown(arguments={})
+          method = 'POST'
+          path   = Utils.__pathify( '_cluster/nodes', Utils.__listify(arguments[:node_id]), '_shutdown' )
+          params = arguments.select do |k,v|
+            [ :delay,
+              :exit ].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          params = Hash[params] unless params.is_a?(Hash)
+          body   = nil
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/cluster/node_stats.rb

@@ -0,0 +1,77 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Returns statistical information about nodes in the cluster.
+        #
+        # @example Return statistics about JVM
+        #
+        #     client.cluster.node_stats clear: true, jvm: true
+        #
+        # @option arguments [List] :metric Limit the information returned for `indices` family to a specific metric
+        #                                  (options: docs, fielddata, filter_cache, flush, get, id_cache, indexing, merges,
+        #                                  refresh, search, store, warmer)
+        # @option arguments [List] :node_id A comma-separated list of node IDs or names to limit the returned information;
+        #                                   use `_local` to return information from the node you're connecting to, leave
+        #                                   empty to get information from all nodes
+        # @option arguments [Boolean] :all Return all available information
+        # @option arguments [Boolean] :clear Reset the default level of detail
+        # @option arguments [List] :fields A comma-separated list of fields for `fielddata` metric (supports wildcards)
+        # @option arguments [Boolean] :fs Return information about the filesystem
+        # @option arguments [Boolean] :http Return information about HTTP
+        # @option arguments [Boolean] :indices Return information about indices
+        # @option arguments [Boolean] :jvm Return information about the JVM
+        # @option arguments [Boolean] :network Return information about network
+        # @option arguments [Boolean] :os Return information about the operating system
+        # @option arguments [Boolean] :process Return information about the Elasticsearch process
+        # @option arguments [Boolean] :thread_pool Return information about the thread pool
+        # @option arguments [Boolean] :transport Return information about transport
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-nodes-stats/
+        #
+        def node_stats(arguments={})
+          method = 'GET'
+
+          case
+            # Field data metric for the `indices` metric family
+            when arguments[:indices] && arguments[:metric] == 'fielddata'
+              path   = Utils.__pathify( '_nodes', Utils.__listify(arguments[:node_id]), 'stats/indices/fielddata' )
+              params = { :fields => Utils.__listify(arguments[:fields]) }
+
+            # `indices` metric family incl. a metric
+            when arguments[:indices] && arguments[:metric]
+              path   = Utils.__pathify( '_nodes', Utils.__listify(arguments[:node_id]), 'stats/indices', arguments[:metric] )
+              params = {}
+
+            else
+              path   = Utils.__pathify( '_nodes', Utils.__listify(arguments[:node_id]), 'stats' )
+
+              params = arguments.select do |k,v|
+                [ :all,
+                  :clear,
+                  :fields,
+                  :fs,
+                  :http,
+                  :indices,
+                  :jvm,
+                  :network,
+                  :os,
+                  :process,
+                  :thread_pool,
+                  :transport ].include?(k)
+              end
+              # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+              params = Hash[params] unless params.is_a?(Hash)
+
+              params[:fields] = Utils.__listify(params[:fields]) if params[:fields]
+          end
+
+          body = nil
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/cluster/put_settings.rb

@@ -0,0 +1,28 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Update cluster settings.
+        #
+        # @example Disable shard allocation in the cluster until restart
+        #
+        #     client.cluster.put_settings body: { transient: { 'cluster.routing.allocation.disable_allocation' => true } }
+        #
+        # @option arguments [Hash] :body The settings to be updated. Can be either `transient` or `persistent`
+        #                                (survives cluster restart).
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-update-settings/
+        #
+        def put_settings(arguments={})
+          method = 'PUT'
+          path   = "_cluster/settings"
+          params = {}
+          body   = arguments[:body] || {}
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/cluster/reroute.rb

@@ -0,0 +1,44 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Perform manual shard allocation in the cluster.
+        #
+        # Pass the operations you want to perform in the `:body` option. Use the `dry_run` option to
+        # evaluate the result of operations without actually performing them.
+        #
+        # @example Move shard `0` of index `myindex` from node named _Node1_ to node named _Node2_
+        #
+        #     client.cluster.reroute body: {
+        #       commands: [
+        #         { move: { index: 'myindex', shard: 0, from_node: 'Node1', to_node: 'Node2' } }
+        #       ]
+        #     }
+        #
+        # @note If you want to explicitely set the shard allocation to a certain node, you might
+        #       want to look at the `allocation.*` cluster settings.
+        #
+        # @option arguments [Hash] :body The definition of `commands` to perform (`move`, `cancel`, `allocate`)
+        # @option arguments [Boolean] :dry_run Simulate the operation only and return the resulting state
+        # @option arguments [Boolean] :filter_metadata Don't return cluster state metadata (default: false)
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-reroute/
+        #
+        def reroute(arguments={})
+          method = 'POST'
+          path   = "_cluster/reroute"
+          params = arguments.select do |k,v|
+            [ :dry_run,
+              :filter_metadata ].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          params = Hash[params] unless params.is_a?(Hash)
+          body   = arguments[:body] || {}
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/cluster/state.rb

@@ -0,0 +1,47 @@
+module Elasticsearch
+  module API
+    module Cluster
+      module Actions
+
+        # Get information about the cluster state (indices settings, allocations, etc)
+        #
+        # @example
+        #
+        #     client.cluster.state
+        #
+        # @option arguments [Boolean] :filter_blocks Do not return information about blocks
+        # @option arguments [Boolean] :filter_index_templates Do not return information about index templates
+        # @option arguments [List] :filter_indices Limit returned metadata information to specific indices
+        # @option arguments [Boolean] :filter_metadata Do not return information about indices metadata
+        # @option arguments [Boolean] :filter_nodes Do not return information about nodes
+        # @option arguments [Boolean] :filter_routing_table Do not return information about shard allocation
+        #                                                   (`routing_table` and `routing_nodes`)
+        # @option arguments [Boolean] :local Return local information, do not retrieve the state from master node
+        #                                    (default: false)
+        # @option arguments [Time] :master_timeout Specify timeout for connection to master
+        #
+        # @see http://elasticsearch.org/guide/reference/api/admin-cluster-state/
+        #
+        def state(arguments={})
+          method = 'GET'
+          path   = "_cluster/state"
+          params = arguments.select do |k,v|
+            [ :filter_blocks,
+              :filter_index_templates,
+              :filter_indices,
+              :filter_metadata,
+              :filter_nodes,
+              :filter_routing_table,
+              :local,
+              :master_timeout ].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          params = Hash[params] unless params.is_a?(Hash)
+          body = nil
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/count.rb

@@ -0,0 +1,46 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Get the number of documents for the cluster, index, type, or a query.
+      #
+      # @example Get the number of all documents in the cluster
+      #
+      #     client.count
+      #
+      # @example Get the number of documents in a specified index
+      #
+      #     client.count index: 'myindex'
+      #
+      # @option arguments [List] :index A comma-separated list of indices to restrict the results
+      # @option arguments [List] :type A comma-separated list of types to restrict the results
+      # @option arguments [Hash] :body A query to restrict the results (optional)
+      # @option arguments [String] :ignore_indices When performed on multiple indices, allows to ignore `missing` ones
+      #                                            (options: none, missing)
+      # @option arguments [Number] :min_score Include only documents with a specific `_score` value in the result
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [String] :source The URL-encoded query definition (instead of using the request body)
+      #
+      # @see http://elasticsearch.org/guide/reference/api/count/
+      #
+      def count(arguments={})
+        method = 'GET'
+        path   = Utils.__pathify( Utils.__listify(arguments[:index]), Utils.__listify(arguments[:type]), '_count' )
+        params = arguments.select do |k,v|
+          [ :ignore_indices,
+            :min_score,
+            :preference,
+            :routing,
+            :source ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end