lowang-rubberband 0.0.3

data/lib/elasticsearch/client/admin_index.rb

@@ -0,0 +1,109 @@
+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
+
+        # 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
+
+        # options: ignore_conflicts
+        def update_mapping(mapping, options={})
+          set_default_scope!(options)
+          raise "index and type or defaults required" unless options[:index] && options[:type]
+
+          options = options.dup
+          indices = Array(options.delete(:index))
+          type = options.delete(:type)
+          unless mapping[type]
+            mapping = { type => mapping }
+          end
+
+          indices.collect! { |i| PSEUDO_INDICES.include?(i) ? "_#{i}" : i }
+          execute(:update_mapping, indices, type, mapping, 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
+      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,29 @@
+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 set_default_scope!(options)
+        options[:index] ||= default_index
+        options[:type] ||= default_type
+        nil
+      end
+    end
+  end
+end

data/lib/elasticsearch/client/hits.rb

@@ -0,0 +1,83 @@
+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)
+        @table.freeze
+      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["_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).freeze }
+      end
+    end
+  end
+end

data/lib/elasticsearch/client/index.rb

@@ -0,0 +1,102 @@
+require 'client/hits'
+
+module ElasticSearch
+  module Api
+    module Index
+      def index(document, options={})
+        set_default_scope!(options)
+        raise "index and type or defaults required" unless options[:index] && options[:type]
+        # type
+        # index
+        # id (optional)
+        # op_type (optional)
+        # timeout (optional)
+        # document (optional)
+
+        result = execute(:index, options[:index], options[:type], options[:id], document, options)
+        if result["ok"]
+          result["_id"]
+        else
+          false
+        end
+      end
+
+      def get(id, options={})
+        set_default_scope!(options)
+        raise "index and type or defaults required" unless options[:index] && options[:type]
+        # index
+        # type
+        # id
+        # fields
+        
+        hit = execute(:get, options[:index], options[:type], id, options)
+        if hit
+          Hit.new(hit).freeze
+        end
+      end
+
+      def delete(id, options={})
+        set_default_scope!(options)
+        raise "index and type or defaults required" unless options[:index] && options[:type]
+        result = execute(:delete, options[:index], options[:type], id, options)
+        result["ok"]
+      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:reverse (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={})
+        set_default_scope!(options)
+
+        #TODO this doesn't work for facets, because they have a valid query key as element. need a list of valid toplevel keys in the search dsl
+        #query = {:query => query} if query.is_a?(Hash) && !query[:query] # if there is no query element, wrap query in one
+
+        search_options = slice_hash(options, :df, :analyzer, :default_operator, :explain, :fields, :field, :sort, :from, :size, :search_type, :limit, :per_page, :page, :offset, :scroll)
+
+        search_options[:size] ||= (search_options[:per_page] || search_options[:limit] || 10)
+        search_options[:from] ||= search_options[:size] * (search_options[:page].to_i-1) if search_options[:page] && search_options[:page].to_i > 1
+        search_options[:from] ||= search_options[:offset] if search_options[:offset]
+
+        search_options[:fields] = "_id" if options[:ids_only]
+
+        response = execute(:search, options[:index], options[:type], query, search_options)
+        Hits.new(response, slice_hash(options, :per_page, :page, :ids_only)).freeze #ids_only returns array of ids instead of hits
+      end
+
+      #ids_only Return ids instead of hits
+      def scroll(scroll_id, options={})
+        response = execute(:scroll, scroll_id)
+        Hits.new(response, slice_hash(options, :ids_only)).freeze
+      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={})
+        set_default_scope!(options)
+
+        count_options = slice_hash(options, :df, :analyzer, :default_operator)
+        response = execute(:count, options[:index], options[:type], query, count_options)
+        response["count"].to_i #TODO check if count is nil
+      end
+
+      private
+
+      def slice_hash(hash, *keys)
+        h = {}
+        keys.each { |k| h[k] = hash[k] if hash.has_key?(k) }
+        h
+      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

data/lib/elasticsearch/encoding.rb

@@ -0,0 +1,7 @@
+require 'encoding/base'
+
+module ElasticSearch
+  module Encoding
+    autoload :JSON, 'encoding/json'
+  end
+end

data/lib/elasticsearch/encoding/base.rb

@@ -0,0 +1,17 @@
+module ElasticSearch
+  module Encoding
+    class Base
+      def encode(object)
+        raise "not implemented"
+      end
+
+      def decode(string)
+        raise "not implemented"
+      end
+
+      def is_encoded?(object)
+        raise "not implemented"
+      end
+    end
+  end
+end