elastictastic 0.5.0 → 0.10.2

data/lib/elastictastic/properties.rb

@@ -32,23 +32,23 @@ module Elastictastic
       end
 
       def all_fields
-        @all_fields ||= {}.tap do |fields|
+        @_all_fields ||= {}.tap do |fields|
           each_field { |field, properties| fields[field] = properties }
         end
       end
 
       def field_properties
-        @field_properties ||= {}
+        @_field_properties ||= {}
       end
 
       def properties
-        return @properties if defined? @properties
-        @properties = {}
-        @properties.merge!(field_properties)
+        return @_properties if defined? @_properties
+        @_properties = {}
+        @_properties.merge!(field_properties)
         embeds.each_pair do |name, embed|
-          @properties[name] = { 'properties' => embed.clazz.properties }
+          @_properties[name] = { 'properties' => embed.clazz.properties }
         end
-        @properties
+        @_properties
       end
 
       def properties_for_field(field_name)
@@ -56,7 +56,7 @@ module Elastictastic
       end
 
       def embeds
-        @embeds ||= {}
+        @_embeds ||= {}
       end
 
       def field(*field_names, &block)
@@ -66,6 +66,27 @@ module Elastictastic
         end
       end
 
+      def boost(field, options = {})
+        @_boost = { 'name' => field.to_s, 'null_value' => 1.0 }.merge(options.stringify_keys)
+      end
+
+      def route_with(field, options = {})
+        @_routing_field = field
+        @_routing_required = !!options[:required]
+      end
+
+      def routing_required?
+        !!@_routing_required
+      end
+
+      def route(instance)
+        if @_routing_field
+          @_routing_field.to_s.split('.').inject(instance) do |obj, attr|
+            Util.call_or_map(obj) { |el| el.__send__(attr) } if obj
+          end
+        end
+      end
+
       def define_field(field_name, options, &block)
         field_name = field_name.to_s
 
@@ -114,122 +135,141 @@ module Elastictastic
       end
     end
 
-    module InstanceMethods
-      def initialize(attributes = {})
-        super
-        @attributes = {}
-        @embeds = {}
-        self.attributes = attributes
-      end
+    def initialize(attributes = {})
+      super()
+      @_attributes = {}
+      @_embeds = {}
+      self.attributes = attributes
+    end
 
-      def attributes
-        @attributes.with_indifferent_access
+    def attributes
+      super.merge(@_attributes).with_indifferent_access
+    end
+
+    def attributes=(attributes)
+      attributes.each_pair do |field, value|
+        __send__(:"#{field}=", value)
       end
+    end
 
-      def attributes=(attributes)
-        attributes.each_pair do |field, value|
-          __send__(:"#{field}=", value)
-        end
+    def inspect
+      inspected = "#<#{self.class.name}"
+      if attributes.any?
+        inspected << ' ' << attributes.each_pair.map do |attr, value|
+          "#{attr}: #{value.inspect}"
+        end.join(', ')
       end
+      inspected << '>'
+    end
 
-      def elasticsearch_doc
-        {}.tap do |doc|
-          @attributes.each_pair do |field, value|
-            next if value.nil?
-            doc[field] = Util.call_or_map(value) do |item|
-              serialize_value(field, item)
-            end
+    def elasticsearch_doc
+      {}.tap do |doc|
+        @_attributes.each_pair do |field, value|
+          next if value.nil?
+          doc[field] = Util.call_or_map(value) do |item|
+            serialize_value(field, item)
           end
-          @embeds.each_pair do |field, embedded|
-            next if embedded.nil?
-            doc[field] = Util.call_or_map(embedded) do |item|
-              item.elasticsearch_doc
-            end
+        end
+        @_embeds.each_pair do |field, embedded|
+          next if embedded.nil?
+          doc[field] = Util.call_or_map(embedded) do |item|
+            item.elasticsearch_doc
           end
         end
       end
+    end
 
-      def elasticsearch_doc=(doc)
-        return if doc.nil?
-        doc.each_pair do |field_name, value|
-          if self.class.properties.has_key?(field_name)
-            embed = self.class.embeds[field_name]
-            if embed
-              embedded = Util.call_or_map(value) do |item|
-                embed.clazz.new.tap { |e| e.elasticsearch_doc = item }
-              end
-              write_embed(field_name, embedded)
-            else
-              deserialized = Util.call_or_map(value) do |item|
-                deserialize_value(field_name, item)
-              end
-              write_attribute(field_name, deserialized)
+    def elasticsearch_doc=(doc)
+      return if doc.nil?
+      doc.each_pair do |field_name, value|
+        if self.class.properties.has_key?(field_name)
+          embed = self.class.embeds[field_name]
+          if embed
+            embedded = Util.call_or_map(value) do |item|
+              embed.clazz.new.tap { |e| e.elasticsearch_doc = item }
+            end
+            write_embed(field_name, embedded)
+          else
+            deserialized = Util.call_or_map(value) do |item|
+              deserialize_value(field_name, item)
             end
+            write_attribute(field_name, deserialized)
           end
         end
       end
+    end
 
-      protected
+    def _routing
+    end
 
-      def read_attribute(field)
-        @attributes[field.to_s]
-      end
+    protected
 
-      def write_attribute(field, value)
-        if value.nil?
-          @attributes.delete(field.to_s)
-        else
-          @attributes[field.to_s] = value
-        end
-      end
+    def read_attribute(field)
+      @_attributes[field.to_s]
+    end
 
-      def read_attributes
-        @attributes
+    def write_attribute(field, value)
+      if value.nil?
+        @_attributes.delete(field.to_s)
+      else
+        @_attributes[field.to_s] = value
       end
+    end
 
-      def write_attributes(attributes)
-        @attributes = attributes
-      end
+    def read_attributes
+      @_attributes
+    end
 
-      def read_embed(field)
-        @embeds[field.to_s]
-      end
+    def read_embeds
+      @_embeds
+    end
 
-      def write_embed(field, value)
-        @embeds[field.to_s] = value
-      end
+    def write_attributes(attributes)
+      @_attributes = attributes
+    end
 
-      private
+    def write_embeds(embeds)
+      @_embeds = embeds
+    end
 
-      def serialize_value(field_name, value)
-        type = self.class.properties_for_field(field_name)['type'].to_s
-        case type
-        when 'date'
-          time = value.to_time
-          time.to_i * 1000 + time.usec / 1000
-        when 'integer', 'byte', 'short', 'long'
-          value.to_i
-        when 'float', 'double'
-          value.to_f
-        when 'boolean'
-          !!value
-        else
-          value
-        end
+    def read_embed(field)
+      @_embeds[field.to_s]
+    end
+
+    def write_embed(field, value)
+      @_embeds[field.to_s] = value
+    end
+
+    private
+
+    def serialize_value(field_name, value)
+      type = self.class.properties_for_field(field_name)['type'].to_s
+      case type
+      when 'date'
+        time = value.to_time
+        time.to_i * 1000 + time.usec / 1000
+      when 'integer', 'byte', 'short', 'long'
+        value.to_i
+      when 'float', 'double'
+        value.to_f
+      when 'boolean'
+        !!value
+      else
+        value
       end
+    end
 
-      def deserialize_value(field_name, value)
-        return nil if value.nil?
-        if self.class.properties_for_field(field_name)['type'].to_s == 'date'
-          if value.is_a? Fixnum
-            sec, usec = value / 1000, (value % 1000) * 1000
-            Time.at(sec, usec).utc
-          else
-            Time.parse(value)
-          end
+    def deserialize_value(field_name, value)
+      return nil if value.nil?
+      if self.class.properties_for_field(field_name)['type'].to_s == 'date'
+        if value.is_a? Fixnum
+          sec, usec = value / 1000, (value % 1000) * 1000
+          Time.at(sec, usec).utc
         else
-          value
+          Time.parse(value)
         end
+      else
+        value
       end
     end
   end

data/lib/elastictastic/railtie.rb

@@ -27,7 +27,7 @@ module Elastictastic
         ::Elastictastic::Observing.instantiate_observers
 
         ActionDispatch::Callbacks.to_prepare do
-          ::Elastictastic.instantiate_observers
+          ::Elastictastic::Observing.instantiate_observers
         end
       end
     end

data/lib/elastictastic/rotor.rb

@@ -0,0 +1,105 @@
+require 'elastictastic/transport_methods'
+
+module Elastictastic
+
+  class Rotor
+
+    include TransportMethods
+
+    NodeUnavailable = Class.new(StandardError)
+
+    def initialize(hosts, options)
+      node_options = {}
+      [:backoff_threshold, :backoff_start, :backoff_max].each do |key|
+        node_options[key] = options.delete(key)
+      end
+      adapter = Adapter[options.delete(:adapter)]
+      @connections = hosts.map do |host|
+        Node.new(adapter.new(host, options), node_options)
+      end
+      @head_index = 0
+    end
+
+    def request(method, path, body = nil)
+      try_rotate { |node| node.request(method, path, body) }
+    end
+
+    private
+
+    def peek
+      @connections[@head_index]
+    end
+
+    def shift
+      peek.tap { @head_index = (@head_index + 1) % @connections.length }
+    end
+
+    def try_rotate
+      last = peek
+      begin
+        yield shift
+      rescue ConnectionFailed, NodeUnavailable => e
+        raise NoServerAvailable, e if peek == last
+        retry
+      end
+    end
+
+    class Node
+      def initialize(connection, options)
+        @connection = connection
+        @failures = 0
+        @backoff_threshold = options[:backoff_threshold] || 0
+        @backoff_start = options[:backoff_start]
+        @backoff_max = options[:backoff_max]
+      end
+
+      def request(method, path, body = nil)
+        try_track { @connection.request(method, path, body).tap { succeeded! }}
+      end
+
+      private
+
+      def try_track
+        raise NodeUnavailable, "Won't retry this node until #{@back_off_until}" unless available?
+        begin
+          yield
+        rescue ConnectionFailed => e
+          failed!
+          raise e
+        end
+      end
+
+      def available?
+        !backoff_failures_reached? ||
+          !backing_off?
+      end
+
+      def backing_off?
+        @back_off_until &&
+          @back_off_until > Time.now
+      end
+
+      def backoff_failures_reached?
+        @failures >= @backoff_threshold
+      end
+
+      def succeeded!
+        @failures = 0
+        @back_off_until = nil
+      end
+
+      def failed!
+        @failures += 1
+        if @backoff_start && backoff_failures_reached?
+          backoff_count = @failures - @backoff_threshold
+          backoff_interval = @backoff_start * 2 ** backoff_count
+          backoff_interval = @backoff_max if @backoff_max &&
+            backoff_interval > @backoff_max
+          @back_off_until = Time.now + backoff_interval
+        end
+      end
+    end
+
+  end
+
+end