load_balanced_tire 0.1

data/lib/tire/logger.rb

@@ -0,0 +1,60 @@
+module Tire
+  class Logger
+
+    def initialize(device, options={})
+      @device = if device.respond_to?(:write)
+        device
+      else
+        File.open(device, 'a')
+      end
+      @device.sync = true if @device.respond_to?(:sync)
+      @options = options
+      # at_exit { @device.close unless @device.closed? } if @device.respond_to?(:closed?) && @device.respond_to?(:close)
+    end
+
+    def level
+      @options[:level] || 'info'
+    end
+
+    def write(message)
+      @device.write message
+    end
+
+    def log_request(endpoint, params=nil, curl='')
+      # 2001-02-12 18:20:42:32 [_search] (articles,users)
+      #
+      # curl -X POST ....
+      #
+      content  = "# #{time}"
+      content += " [#{endpoint}]"
+      content += " (#{params.inspect})" if params
+      content += "\n#\n"
+      content += curl
+      content += "\n\n"
+      write content
+    end
+
+    def log_response(status, took=nil, json='')
+      # 2001-02-12 18:20:42:32 [200] (4 msec)
+      #
+      # {
+      #   "took" : 4,
+      #   "hits" : [...]
+      #   ...
+      # }
+      #
+      content  = "# #{time}"
+      content += " [#{status}]"
+      content += " (#{took} msec)" if took
+      content += "\n#\n" unless json.to_s !~ /\S/
+      json.to_s.each_line { |line| content += "# #{line}" } unless json.to_s !~ /\S/
+      content += "\n\n"
+      write content
+    end
+
+    def time
+      Time.now.strftime('%Y-%m-%d %H:%M:%S:%L')
+    end
+
+  end
+end

data/lib/tire/model/callbacks.rb

@@ -0,0 +1,40 @@
+module Tire
+  module Model
+
+    # Main module containing the infrastructure for automatic updating
+    # of the _ElasticSearch_ index on model instance create, update or delete.
+    #
+    # Include it in your model: `include Tire::Model::Callbacks`
+    #
+    # The model must respond to `after_save` and `after_destroy` callbacks
+    # (ActiveModel and ActiveRecord models do so, by default).
+    #
+    module Callbacks
+
+      # A hook triggered by the `include Tire::Model::Callbacks` statement in the model.
+      #
+      def self.included(base)
+
+        # Update index on model instance change or destroy.
+        #
+        if base.respond_to?(:after_save) && base.respond_to?(:after_destroy)
+          base.send :after_save,    lambda { tire.update_index }
+          base.send :after_destroy, lambda { tire.update_index }
+        end
+
+        # Add neccessary infrastructure for the model, when missing in
+        # some half-baked ActiveModel implementations.
+        #
+        if base.respond_to?(:before_destroy) && !base.instance_methods.map(&:to_sym).include?(:destroyed?)
+          base.class_eval do
+            before_destroy  { @destroyed = true }
+            def destroyed?; !!@destroyed; end
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/import.rb

@@ -0,0 +1,26 @@
+
+module Tire
+  module Model
+
+    # Provides support for easy importing of large ActiveRecord- and ActiveModel-bound
+    # recordsets into model index.
+    #
+    # Relies on pagination support in your model, namely the `paginate` class method.
+    #
+    # Please refer to the relevant of the README for more information.
+    #
+    module Import
+
+      module ClassMethods
+
+        def import options={}, &block
+          options = { :method => 'paginate' }.update options
+          index.import klass, options, &block
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/indexing.rb

@@ -0,0 +1,128 @@
+module Tire
+  module Model
+
+    # Contains logic for definition of index settings and mappings.
+    #
+    module Indexing
+
+      module ClassMethods
+
+        # Define [_settings_](http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index.html)
+        # for the corresponding index, such as number of shards and replicas, custom analyzers, etc.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       settings :number_of_shards => 1 do
+        #         mapping do
+        #           # ...
+        #         end
+        #       end
+        #     end
+        #
+        def settings(*args)
+          @settings ||= {}
+          args.empty?  ? (return @settings) : @settings = args.pop
+          yield if block_given?
+        end
+
+        # Define the [_mapping_](http://www.elasticsearch.org/guide/reference/mapping/index.html)
+        # for the corresponding index, telling _ElasticSearch_ how to understand your documents:
+        # what type is which property, whether it is analyzed or no, which analyzer to use, etc.
+        #
+        # You may pass the top level mapping properties (such as `_source` or `_all`) as a Hash.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       mapping :_source => { :compress => true } do
+        #         indexes :id,    :index    => :not_analyzed
+        #         indexes :title, :analyzer => 'snowball', :boost => 100
+        #         indexes :words, :as       => 'content.split(/\W/).length'
+        #
+        #         indexes :comments do
+        #           indexes :body
+        #           indexes :author do
+        #             indexes :name
+        #           end
+        #         end
+        #
+        #         # ...
+        #       end
+        #     end
+        #
+        def mapping(*args)
+          @mapping ||= {}
+          if block_given?
+            @mapping_options = args.pop
+            yield
+            create_elasticsearch_index
+          else
+            @mapping
+          end
+        end
+
+        # Define mapping for the property passed as the first argument (`name`)
+        # using definition from the second argument (`options`).
+        #
+        # `:type` is optional and defaults to `'string'`.
+        #
+        # Usage:
+        #
+        # * Index property but do not analyze it: `indexes :id, :index    => :not_analyzed`
+        #
+        # * Use different analyzer for indexing a property: `indexes :title, :analyzer => 'snowball'`
+        #
+        # * Use the `:as` option to dynamically define the serialized property value, eg:
+        #
+        #       :as => 'content.split(/\W/).length'
+        #
+        # Please refer to the
+        # [_mapping_ documentation](http://www.elasticsearch.org/guide/reference/mapping/index.html)
+        # for more information.
+        #
+        def indexes(name, options = {}, &block)
+          mapping[name] = options
+
+          if block_given?
+            mapping[name][:type]       ||= 'object'
+            mapping[name][:properties] ||= {}
+
+            previous = @mapping
+            @mapping = mapping[name][:properties]
+            yield
+            @mapping = previous
+          end
+
+          mapping[name][:type] ||= 'string'
+
+          self
+        end
+
+        # Creates the corresponding index with desired settings and mappings, when it does not exists yet.
+        #
+        def create_elasticsearch_index
+          unless index.exists?
+            index.create :mappings => mapping_to_hash, :settings => settings
+          end
+        rescue Errno::ECONNREFUSED => e
+          STDERR.puts "Skipping index creation, cannot connect to ElasticSearch",
+                      "(The original exception was: #{e.inspect})"
+        end
+
+        def mapping_options
+          @mapping_options || {}
+        end
+
+        def mapping_to_hash
+          { document_type.to_sym => mapping_options.merge({ :properties => mapping }) }
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/naming.rb

@@ -0,0 +1,100 @@
+module Tire
+  module Model
+
+    # Contains logic for getting and setting the index name and document type for this model.
+    #
+    module Naming
+
+      module ClassMethods
+
+        # Get or set the index name for this model, based on arguments.
+        #
+        # By default, uses ActiveSupport inflection, so a class named `Article`
+        # will be stored in the `articles` index.
+        #
+        # To get the index name:
+        #
+        #     Article.index_name
+        #
+        # To set the index name:
+        #
+        #     Article.index_name 'my-custom-name'
+        #
+        # You can also use a block for defining the index name,
+        # which is evaluated in the class context:
+        #
+        #     Article.index_name { "articles-#{Time.now.year}" }
+        #
+        #     Article.index_name { "articles-#{Rails.env}" }
+        #
+        def index_name name=nil, &block
+          @index_name = name if name
+          @index_name = block if block_given?
+          # TODO: Try to get index_name from ancestor classes
+          @index_name || [index_prefix, klass.model_name.plural].compact.join('_')
+        end
+
+        # Set or get index prefix for all models or for a specific model.
+        #
+        # To set the prefix for all models (preferably in an initializer inside Rails):
+        #
+        #     Tire::Model::Search.index_prefix Rails.env
+        #
+        # To set the prefix for specific model:
+        #
+        #     class Article
+        #       # ...
+        #       index_prefix 'my_prefix'
+        #     end
+        #
+        # TODO: Maybe this would be more sane with ActiveSupport extensions such as `class_attribute`?
+        #
+        @@__index_prefix__ = nil
+        def index_prefix(*args)
+          # Uses class or instance variable depending on the context
+          if args.size > 0
+            value = args.pop
+            self.is_a?(Module) ? ( @@__index_prefix__ = value ) : ( @__index_prefix__ = value )
+          end
+          self.is_a?(Module) ? ( @@__index_prefix__ || nil ) : ( @__index_prefix__ || @@__index_prefix__ || nil )
+        end
+        extend self
+
+        # Get or set the document type for this model, based on arguments.
+        #
+        # By default, uses ActiveSupport inflection, so a class named `Article`
+        # will be stored as the `article` type.
+        #
+        # To get the document type:
+        #
+        #     Article.document_type
+        #
+        # To set the document type:
+        #
+        #     Article.document_type 'my-custom-type'
+        #
+        def document_type name=nil
+          @document_type = name if name
+          @document_type || klass.model_name.underscore
+        end
+      end
+
+      module InstanceMethods
+
+        # Proxy to class method `index_name`.
+        #
+        def index_name
+          instance.class.tire.index_name
+        end
+
+        # Proxy to instance method `document_type`.
+        #
+        def document_type
+          instance.class.tire.document_type
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/percolate.rb

@@ -0,0 +1,99 @@
+module Tire
+  module Model
+
+    # Contains support for the [percolation](http://www.elasticsearch.org/guide/reference/api/percolate.html)
+    # feature of _ElasticSearch_.
+    #
+    module Percolate
+
+      module ClassMethods
+
+        # Set up the percolation when documents are being added to the index.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       percolate!
+        #     end
+        #
+        # First, you have to register a percolator query:
+        #
+        #     Article.index.register_percolator_query('fail')    { |query| query.string 'fail' }
+        #
+        # Then, when you update the index, matching queries are returned in the `matches` property:
+        #
+        #     p Article.create(:title => 'This is a FAIL!').matches
+        #
+        #
+        # You may pass a pattern to filter which percolator queries will be executed.
+        #
+        # See <http://www.elasticsearch.org/guide/reference/api/index_.html> for more information.
+        #
+        def percolate!(pattern=true)
+          @@_percolator = pattern
+          self
+        end
+
+        # A callback method for intercepting percolator matches.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       on_percolate do
+        #         puts "Article title “#{title}” matches queries: #{matches.inspect}" unless matches.empty?
+        #       end
+        #     end
+        #
+        # Based on the response received in `matches`, you may choose to fire notifications,
+        # increment counters, send out e-mail alerts, etc.
+        #
+        def on_percolate(pattern=true,&block)
+          percolate!(pattern)
+          klass.after_update_elasticsearch_index(block)
+        end
+
+        # Returns the status or pattern of percolator for this class.
+        #
+        def percolator
+          defined?(@@_percolator) ? @@_percolator : nil
+        end
+      end
+
+      module InstanceMethods
+
+        # Run this document against registered percolator queries, without indexing it.
+        #
+        # First, register a percolator query:
+        #
+        #     Article.index.register_percolator_query('fail')    { |query| query.string 'fail' }
+        #
+        # Then, you may query the percolator endpoint with:
+        #
+        #     p Article.new(:title => 'This is a FAIL!').percolate
+        #
+        # Optionally, you may pass a block to filter which percolator queries will be executed.
+        #
+        # See <http://www.elasticsearch.org/guide/reference/api/percolate.html> for more information.
+        def percolate(&block)
+          index.percolate instance, block
+        end
+
+        # Mark this instance for percolation when adding it to the index.
+        #
+        def percolate=(pattern)
+          @_percolator = pattern
+        end
+
+        # Returns the status or pattern of percolator for this instance.
+        #
+        def percolator
+          @_percolator || instance.class.tire.percolator || nil
+        end
+      end
+
+    end
+
+  end
+end