rubberband-pure 0.1.6

data/lib/elasticsearch/client/admin_index.rb

@@ -0,0 +1,149 @@
+module ElasticSearch
+  module Api
+    module Admin
+      module Index
+        PSEUDO_INDICES = [:all]
+
+        def index_status(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          indices = args.empty? ? [(default_index || :all)] : args.flatten
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:index_status, indices, options)
+        end
+
+        def index_mapping(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          indices = args.empty? ? [(default_index || :all)] : args.flatten
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:index_mapping, indices, options)
+        end
+
+        # options: number_of_shards, number_of_replicas
+        def create_index(index, create_options={}, options={})
+          unless create_options[:index]
+            create_options = { :index => create_options }
+          end
+          execute(:create_index, index, create_options, options)
+        end
+
+        def delete_index(index, options={})
+          execute(:delete_index, index, options)
+        end
+
+        # :add => { "index" => "alias" }
+        # :add => [{"index" => "alias"}, {"index2" => "alias2"}]
+        # :add => { "index" => "alias", "index2" => "alias2" }
+        # :remove => { "index" => "alias" }
+        # :remove => [{"index" => "alias", {"index2" => "alias2"}]
+        # :remove => { "index" => "alias", "index2" => "alias2" }
+        # :actions => [{:add => {:index => "index", :alias => "alias"}}]
+        def alias_index(operations, options={})
+          if operations[:actions]
+            alias_ops = operations
+          else
+            alias_ops = { :actions => [] }
+            [:add, :remove].each do |op|
+              next unless operations.has_key?(op)
+              op_actions = operations[op].is_a?(Array) ? operations[op] : [operations[op]]
+              op_actions.each do |action_hash|
+                action_hash.each do |index, index_alias|
+                  alias_ops[:actions] << { op => { :index => index, :alias => index_alias }}
+                end
+              end
+            end
+          end
+          execute(:alias_index, alias_ops, options)
+        end
+
+        def get_aliases(index=default_index, options={})
+          index, type, options = extract_scope(options)
+          execute(:get_aliases, index, options)
+        end
+
+        # options: ignore_conflicts
+        def update_mapping(mapping, options={})
+          index, type, options = extract_required_scope(options)
+
+          options = options.dup
+          indices = Array(index)
+          unless mapping[type]
+            mapping = { type => mapping }
+          end
+
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:update_mapping, indices, type, mapping, options)
+        end
+
+        def delete_mapping(options={})
+          index, type, options = extract_required_scope(options)
+          execute(:delete_mapping, index, type, options)
+        end
+
+        def update_settings(settings, options={})
+          index, type, options = extract_scope(options)
+          execute(:update_settings, index, settings, options)
+        end
+
+        def get_settings(index=default_index, options={})
+          execute(:get_settings, index, options)
+        end
+
+        # list of indices, or :all
+        # options: refresh
+        # default: default_index if defined, otherwise :all
+        def flush(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          indices = args.empty? ? [(default_index || :all)] : args.flatten
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:flush, indices, options)
+        end
+
+        # list of indices, or :all
+        # no options
+        # default: default_index if defined, otherwise all
+        def refresh(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          indices = args.empty? ? [(default_index || :all)] : args.flatten
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:refresh, indices, options)
+        end
+
+        # list of indices, or :all
+        # no options
+        # default: default_index if defined, otherwise all
+        def snapshot(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          indices = args.empty? ? [(default_index || :all)] : args.flatten
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:snapshot, indices, options)
+        end
+
+        # list of indices, or :all
+        # options: max_num_segments, only_expunge_deletes, refresh, flush
+        # default: default_index if defined, otherwise all
+        def optimize(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          indices = args.empty? ? [(default_index || :all)] : args.flatten
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:optimize, indices, options)
+        end
+
+        def create_river(type, create_options, options={})
+          execute(:create_river, type, create_options, options)
+        end
+
+        def get_river(type, options={})
+          execute(:get_river, type, options)
+        end
+
+        def river_status(type, options={})
+          execute(:river_status, type, options)
+        end
+
+        def delete_river(type=nil, options={})
+          execute(:delete_river, type, options)
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/client/auto_discovering_client.rb

@@ -0,0 +1,21 @@
+module ElasticSearch
+  module AutoDiscoveringClient
+
+    AUTO_DISCOVERING_DEFAULTS = {
+      :auto_discovery => true
+    }.freeze
+
+    def initialize(servers, options={})
+      super
+      @options = AUTO_DISCOVERING_DEFAULTS.merge(@options)
+      if @options[:auto_discovery]
+        auto_discover_nodes!
+      end
+    end
+
+    #TODO how to autodiscover on reconnect? don't want to overwrite methods of RetryingClient
+    def auto_discover_nodes!
+      @server_list = execute(:all_nodes)
+    end
+  end
+end

data/lib/elasticsearch/client/default_scope.rb

@@ -0,0 +1,36 @@
+module ElasticSearch
+  module Api
+    module DefaultScope
+      def default_index
+        @default_index ||= @options[:index]
+      end
+
+      def default_index=(index)
+        @default_index = index
+      end
+
+      def default_type
+        @default_type ||= @options[:type]
+      end
+
+      def default_type=(type)
+        @default_type = type
+      end
+
+      private
+
+      def extract_scope(options)
+        options = options.dup
+        index = options.delete(:index) || default_index
+        type = options.delete(:type) || default_type
+        [index, type, options]
+      end
+
+      def extract_required_scope(options)
+        scope = extract_scope(options)
+        raise "index and type or defaults required" unless scope[0] && scope[1]
+        scope
+      end
+    end
+  end
+end

data/lib/elasticsearch/client/hits.rb

@@ -0,0 +1,82 @@
+require 'ostruct'
+
+module ElasticSearch
+  module Api
+    class Hit < OpenStruct
+      undef_method :id if method_defined?(:id)
+
+      def initialize(hit)
+        hit = hit.dup
+        hit.merge!(hit["_source"]) if hit["_source"]
+        hit["id"] ||= hit["_id"]
+        super(hit)
+      end
+
+      def attributes
+        @table
+      end
+    end
+
+    module Pagination
+      def current_page
+        (@options[:page].respond_to?(:empty?) ? @options[:page].empty? : !@options[:page]) ? 1 : @options[:page].to_i
+      end
+
+      def next_page
+        current_page >= total_pages ? nil : current_page + 1
+      end
+
+      def previous_page
+        current_page == 1 ? nil : current_page - 1
+      end
+
+      def per_page
+        @options[:per_page] || 10
+      end
+
+      def total_pages
+        (total_entries / per_page.to_f).ceil
+      end
+      alias_method :page_count, :total_pages
+    end
+
+
+    class Hits
+      include Pagination
+      attr_reader :hits, :total_entries, :_shards, :response, :facets, :scroll_id
+
+      def initialize(response, options={})
+        @response = response
+        @options = options
+        @total_entries = response["hits"]["total"]
+        @_shards = response["_shards"]
+        @facets = response["facets"]
+        @scroll_id = response["_scroll_id"] || response["_scrollId"]
+        populate(@options[:ids_only])
+      end
+
+      def to_a
+        @hits
+      end
+
+      def freeze
+        @hits.freeze
+        super
+      end
+
+      def method_missing(method, *args, &block)
+        @hits.send(method, *args, &block)
+      end
+
+      def respond_to?(method, include_private = false)
+        super || @hits.respond_to?(method, include_private)
+      end
+
+      private
+
+      def populate(ids_only=false)
+        @hits = @response["hits"]["hits"].collect { |h| ids_only ? h["_id"] : Hit.new(h) }
+      end
+    end
+  end
+end

data/lib/elasticsearch/client/index.rb

@@ -0,0 +1,143 @@
+require 'client/hits'
+
+module ElasticSearch
+  module Api
+    module Index
+      def index(document, options={})
+        index, type, options = extract_required_scope(options)
+        # type
+        # index
+        # id (optional)
+        # op_type (optional)
+        # timeout (optional)
+        # document (optional)
+
+        id = options.delete(:id)
+        if @batch
+          #TODO add routing, parent
+          @batch << { :index => { :_index => index, :_type => type, :_id => id }.merge(options)}
+          @batch << document
+        else
+          result = execute(:index, index, type, id, document, options)
+          if result["ok"]
+            result["_id"]
+          else
+            false
+          end
+        end
+      end
+
+      def get(id, options={})
+        index, type, options = extract_required_scope(options)
+        # index
+        # type
+        # id
+        # fields
+        
+        hit = execute(:get, index, type, id, options)
+        if hit
+          Hit.new(hit)
+        end
+      end
+
+      def delete(id, options={})
+        index, type, options = extract_required_scope(options)
+
+        if @batch
+          #TODO add routing, parent
+          @batch << { :delete => { :_index => index, :_type => type, :_id => id }}
+        else
+          result = execute(:delete, index, type, id, options)
+          result["ok"]
+        end
+      end
+      
+      def delete_by_query(query, options = {})
+        index, type, options = extract_required_scope(options)
+        execute(:delete_by_query, index, type, query, options)
+      end
+
+      #df	 The default field to use when no field prefix is defined within the query.
+      #analyzer	 The analyzer name to be used when analyzing the query string.
+      #default_operator	 The default operator to be used, can be AND or OR. Defaults to OR.
+      #explain	 For each hit, contain an explanation of how to scoring of the hits was computed.
+      #fields	 The selective fields of the document to return for each hit (fields must be stored), comma delimited. Defaults to the internal _source field.
+      #field	 Same as fields above, but each parameter contains a single field name to load. There can be several field parameters.
+      #sort	 Sorting to perform. Can either be in the form of fieldName, or fieldName:desc (for reverse sorting). The fieldName can either be an actual field within the document, or the special score name to indicate sorting based on scores. There can be several sort parameters (order is important).
+      #from	 The starting from index of the hits to return. Defaults to 0.
+      #size	 The number of hits to return. Defaults to 10.
+      #search_type	 The type of the search operation to perform. Can be dfs_query_then_fetch, dfs_query_and_fetch, query_then_fetch, query_and_fetch. Defaults to query_then_fetch.
+      #scroll Get a scroll id to continue paging through the search results. Value is the time to keep a scroll request around, e.g. 5m
+      #ids_only Return ids instead of hits
+      def search(query, options={})
+        index, type, options = extract_scope(options)
+
+        options[:size] ||= (options[:per_page] || options[:limit] || 10)
+        options[:from] ||= options[:size] * (options[:page].to_i-1) if options[:page] && options[:page].to_i > 1
+        options[:from] ||= options[:offset] if options[:offset]
+
+        options[:fields] = "_id" if options[:ids_only]
+
+        # options that elasticsearch doesn't recognize: page, per_page, ids_only, limit, offset
+        search_options = options.reject { |k, v| [:page, :per_page, :ids_only, :limit, :offset].include?(k) }
+
+        response = execute(:search, index, type, query, search_options)
+
+        Hits.new(response, {:per_page => options[:per_page], :page => options[:page], :ids_only => options[:ids_only]}) #ids_only returns array of ids instead of hits
+      end
+
+      #ids_only Return ids instead of hits
+      #pass a block to execute the block for each batch of hits
+      def scroll(scroll_id, options={}, &block)
+        begin
+          search_options = options.reject { |k, v| [:page, :per_page, :ids_only, :limit, :offset].include?(k) }
+          response = execute(:scroll, scroll_id, options)
+          hits = Hits.new(response, { :ids_only => options[:ids_only] })
+          if block_given? && !hits.empty?
+            yield hits 
+            scroll_id = hits.scroll_id
+          end
+        end until !block_given? || hits.empty?
+        hits
+      end 
+
+      #df	 The default field to use when no field prefix is defined within the query.
+      #analyzer	 The analyzer name to be used when analyzing the query string.
+      #default_operator	 The default operator to be used, can be AND or OR. Defaults to OR.
+      def count(query, options={})
+        index, type, options = extract_scope(options)
+
+        response = execute(:count, index, type, query, options)
+        response["count"].to_i #TODO check if count is nil
+      end
+
+      # Starts a bulk operation batch and yields self. Index and delete requests will be 
+      # queued until the block closes, then sent as a single _bulk call.
+      def bulk(options={})
+        # allow nested bulk calls
+        if @batch
+          yield(self)
+        else
+          begin
+            @batch = []
+            yield(self)
+            response = execute(:bulk, @batch, options)
+          ensure
+            @batch = nil
+          end
+        end
+      end
+      
+      # minor multi get support
+      def multi_get(ids, options={})
+        index, type, options = extract_required_scope(options)
+        results = execute(:multi_get, index, type, ids, options)
+        if(results)
+          hits = []
+          results.each { |hit| hits << Hit.new(hit) }
+          hits
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/client/retrying_client.rb

@@ -0,0 +1,81 @@
+# mostly ripped from thrift_client
+
+module ElasticSearch
+  class NoServersAvailable < StandardError; end
+
+  module RetryingClient
+
+    RETRYING_DEFAULTS = {
+      :randomize_server_list => true,
+      :retries => nil,
+      :server_retry_period => 1,
+      :server_max_requests => nil,
+      :retry_overrides => {}
+    }.freeze
+
+    # use cluster status to get server list
+    def initialize(servers, options={})
+      super
+      @options = RETRYING_DEFAULTS.merge(@options)
+      @retries = options[:retries] || @server_list.size
+      @request_count = 0
+      @max_requests = @options[:server_max_requests]
+      @retry_period = @options[:server_retry_period]
+      rebuild_live_server_list!
+    end
+
+    def connect!
+      @current_server = next_server
+      super
+    rescue ElasticSearch::RetryableError
+      retry
+    end
+
+    def disconnect!
+      # Keep live servers in the list if we have a retry period. Otherwise,
+      # always eject, because we will always re-add them.
+      if @retry_period && @current_server
+        @live_server_list.unshift(@current_server)
+      end
+
+      super
+      @request_count = 0
+    end
+
+    #TODO this can spin indefinitely if timeout > retry_period
+    def next_server
+      if @retry_period
+        rebuild_live_server_list! if Time.now > @last_rebuild + @retry_period
+        raise NoServersAvailable, "No live servers in #{@server_list.inspect} since #{@last_rebuild.inspect}." if @live_server_list.empty?
+      elsif @live_server_list.empty?
+        rebuild_live_server_list!
+      end
+      @live_server_list.pop
+    end
+
+    def rebuild_live_server_list!
+      @last_rebuild = Time.now
+      if @options[:randomize_server_list]
+        @live_server_list = @server_list.sort_by { rand }
+      else
+        @live_server_list = @server_list.dup
+      end
+    end
+
+    def execute(method_name, *args)
+      disconnect_on_max! if @max_requests and @request_count >= @max_requests
+      @request_count += 1
+      begin
+        super
+      rescue ElasticSearch::RetryableError
+        disconnect!
+        retry
+      end
+    end
+
+    def disconnect_on_max!
+      @live_server_list.push(@current_server)
+      disconnect!
+    end
+  end
+end