elastics 0.1.1 → 0.2.0

data/lib/elastics/tasks/mappings.rb

@@ -7,11 +7,17 @@ module Elastics
         @mappings_paths ||= base_paths.map { |x| File.join x, 'mappings' }
       end
 
-      def put_mappings
-        mappings.each do |type, mapping|
+      # Mappings to put can be filtered with `:indices` & `:types` arrays.
+      def put_mappings(options = {})
+        version = options.fetch :version, :current
+        filter = options[:indices].try!(:map, &:to_s)
+        each_filtered(types, options[:types]) do |type|
           index = index_for_type(type)
-          log "Put mapping #{index}/#{type}"
-          client.put_mapping index: index, type: type, data: mapping
+          next if filter && !filter.include?(index)
+          versioned_index = versioned_index_name(index, version)
+          log "Putting mapping #{index}/#{type} (#{versioned_index}/#{type})"
+          client.put_mapping index: versioned_index, type: type,
+            data: mappings[type]
         end
       end
 
@@ -33,7 +39,7 @@ module Elastics
       end
 
       def index_for_type(type)
-        config[:index] || "#{config[:index_prefix]}#{type}"
+        config[:index] || type
       end
     end
   end

data/lib/elastics/tasks/migrations.rb

@@ -0,0 +1,42 @@
+module Elastics
+  module Tasks
+    module Migrations
+      def migrate(options = {})
+        create_indices(options)
+        put_mappings(options)
+      end
+
+      def migrate!(options = {})
+        options_next = options.merge version: :next
+        drop_indices(options_next)
+        create_indices(options_next)
+        put_mappings(options_next)
+        reindex(options_next) if options.fetch(:reindex, true)
+        forward_aliases(options)
+      end
+
+      def reindex(options = {})
+        version = options.fetch(:version, :current)
+        Rails.application.eager_load! if defined?(Rails)
+        VersionManager.use_version version do
+          models_to_reindex(options).each do |model|
+            log "Reindexing #{model.elastics_index_base} into " \
+              "#{model.elastics_index_name}/#{model.elastics_type_name}"
+            model.reindex_elastics
+          end
+        end
+      end
+
+      def models_to_reindex(options = {})
+        indices = options[:indices].try!(:map, &:to_s)
+        types = options[:types].try!(:map, &:to_s)
+        models = Elastics.models.select do |model|
+          next if indices && !indices.include?(model.elastics_index_base)
+          next if types && !types.include?(model.elastics_type_name)
+          true
+        end
+        models.reject { |model| models.find { |other| model < other } }
+      end
+    end
+  end
+end

data/lib/elastics/version.rb

@@ -1,5 +1,5 @@
 module Elastics
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/elastics/version_manager.rb

@@ -0,0 +1,86 @@
+module Elastics
+  class VersionManager
+    class << self
+      def default_version
+        @default_version = ENV['ELASTICS_MAPPING_VERSION'] unless defined?(@default_version)
+        @default_version
+      end
+
+      def default_version=(version)
+        @default_version = version
+        Elastics.models.each &:reset_elastics_index_name
+      end
+
+      def use_version(version)
+        old_version = default_version
+        self.default_version = version
+        yield
+      ensure
+        self.default_version = old_version
+      end
+    end
+
+    attr_reader :service_index
+
+    def initialize(client, options = {})
+      @service_index = options[:service_index] || '.elastics'
+      @index_prefix = options[:index_prefix]
+      @client = client
+    end
+
+    def reset
+      @versions = nil
+      self
+    end
+
+    def update(index, data)
+      set index, versions[index].merge(data)
+    end
+
+    def set(index, data)
+      @client.post index: @service_index, type: :mapping_versions,
+        id: prefixed_index(index), data: data
+      @versions[index] = data.with_indifferent_access
+    end
+
+    def versions
+      @versions ||= Hash.new do |hash, index|
+        result = @client.get index: @service_index, type: :mapping_versions,
+          id: prefixed_index(index)
+        if result
+          hash[index] = result['_source'].with_indifferent_access
+        else
+          set index, current: 0
+        end
+      end
+    end
+
+    def current_version(index)
+      versions[index][:current]
+    end
+
+    def next_version(index)
+      current_version(index) + 1
+    end
+
+    def version_number(index, version)
+      case version.to_s
+      when 'current'  then current_version(index)
+      when 'next'     then next_version(index)
+      else raise NameError, "Invalid version alias: #{version}"
+      end
+    end
+
+    def prefixed_index(index)
+      "#{@index_prefix}#{index}"
+    end
+
+    def index_name(index, version = self.class.default_version)
+      if version && version != :alias
+        "#{prefixed_index(index)}-v#{version_number index, version}"
+      else
+        prefixed_index(index)
+      end
+    end
+  end
+end

data/lib/tasks/elastics.rake

@@ -1,20 +1,43 @@
 namespace 'elastics' do
-  task load_config: [:environment, 'db:load_config'] do
+  task :load_config do |task, args|
+    [:environment, 'db:load_config'].each do |dep|
+      Rake::Task[dep].invoke if Rake::Task.task_defined?(dep)
+    end
+    @elastics_options = {
+      version:  ENV['version'] || :current,
+      reindex:  !ENV.key?('no_reindex'),
+      drop:     !ENV.key?('no_drop'),
+      types:    ENV['types'] && ENV['types'].split(',').map(&:strip),
+      indices:  args.extras.empty? ? nil : args.extras
+    }
   end
 
-  desc 'Creates indices and applies mappings (Use NOFLUSH to prevent old indices from deletion)'
-  task migrate: :load_config do
-    flush = !ENV.key?('NOFLUSH')
-    Elastics::Tasks.migrate(flush: flush)
+  desc 'Drop administrative index'
+  task :purge, [:keep_data] => :load_config do |task, args|
+    Elastics::Tasks.purge args[:keep_data]
   end
 
   desc 'Creates indices'
   task create: :load_config do
-    Elastics::Tasks.create_indices
+    Elastics::Tasks.create_indices @elastics_options
   end
 
   desc 'Drops indices'
-  task delete: :load_config do
-    Elastics::Tasks.delete_indices
+  task drop: :load_config do
+    Elastics::Tasks.drop_indices @elastics_options
+  end
+
+  desc 'Creates indices and applies mappings. Full migration when param is present'
+  task migrate: :load_config do
+    if ENV['full']
+      Elastics::Tasks.migrate! @elastics_options
+    else
+      Elastics::Tasks.migrate @elastics_options
+    end
+  end
+
+  desc 'Reindex'
+  task reindex: :load_config do
+    Elastics::Tasks.reindex @elastics_options
   end
 end

data/spec/lib/elastics/client/cluster_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Elastics::Client do
+  let(:client) { described_class.new(config) }
+  let(:config) { {
+    host: hosts,
+    resurrect_timeout: resurrect_timeout,
+  } }
+  let(:hosts) { [:one, :two, :three] }
+  let(:resurrect_timeout) { 5 }
+
+  describe '#next_cluster_host' do
+    subject { -> { client.send(:next_cluster_host) } }
+    context 'when @hosts contains one element' do
+      let(:hosts) { [:one] }
+
+      it 'returns this host on each call' do
+        expect(6.times.map { subject.call }).to eq([:one] * 6)
+      end
+    end
+
+    context 'when @hosts contains multiple elements' do
+      it 'returns host using round-robbin' do
+        expect(6.times.map { subject.call }).to eq(hosts.cycle.take(6))
+      end
+
+      context 'and one host is dead' do
+        before { client.send(:add_dead_host, :one, resurrect_at) }
+        let(:resurrect_at) {}
+
+        it 'returns other hosts using round-robbin' do
+          expect(6.times.map { subject.call }).to eq((hosts - [:one]).cycle.take(6))
+        end
+
+        context 'but should be resurrected' do
+          let(:resurrect_at) { 0 }
+
+          it 'resurrects this host' do
+            expect(6.times.map { subject.call }).to eq(hosts.cycle.take(7).drop(1))
+          end
+        end
+      end
+
+      context 'and all hosts are dead' do
+        before { hosts.each { |host| client.send(:add_dead_host, host) } }
+        it { should raise_error(Elastics::Client::Cluster::NoAliveHosts) }
+      end
+    end
+  end
+
+  describe '#resurrect_cluster' do
+    subject { -> { client.send(:resurrect_cluster) } }
+    context 'when multiple hosts are blocked' do
+      before { hosts.each { |host| client.send(:add_dead_host, host) } }
+
+      it { should_not change { client.instance_variable_get(:@hosts) }.from([]) }
+
+      context 'and can be resurrected' do
+        before { expect(Time).to receive(:now).and_return(resurrect_timeout.seconds.from_now) }
+        it { should change { client.instance_variable_get(:@hosts) }.from([]).to(hosts) }
+      end
+    end
+  end
+
+  describe '#http_request' do
+    subject { -> { client.send :http_request, :method, '/path', :query, :body } }
+
+    context 'when all hosts are alive' do
+      it 'uses hosts using round-robbin' do
+        hosts.cycle.take(6).each do |host|
+          expect(client.client).to receive(:request).
+            with(:method, "http://#{host}/path", :query, :body, Elastics::Client::HEADERS)
+          subject.call
+        end
+      end
+    end
+
+    context 'when one host is unreachable' do
+      before do
+        expect(client.client).to receive(:request).
+          with(:method, "http://one/path", :query, :body, Elastics::Client::HEADERS) do
+          raise Timeout::Error
+        end
+      end
+
+      it 'uses hosts using round-robbin' do
+        (hosts - [:one]).cycle.take(6).each do |host|
+          expect(client.client).to receive(:request).
+            with(:method, "http://#{host}/path", :query, :body, Elastics::Client::HEADERS)
+        end
+        6.times { subject.call }
+      end
+    end
+
+    context 'when all hosts are unreachable' do
+      before do
+        hosts.each do |host|
+          expect(client.client).to receive(:request).
+            with(:method, "http://#{host}/path", :query, :body, Elastics::Client::HEADERS) do
+            raise Timeout::Error
+          end
+        end
+      end
+
+      it { should raise_error(Elastics::Client::Cluster::NoAliveHosts) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'elastics'
+require 'active_support/all'
+
+RSpec.configure do |config|
+  #
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastics
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Max Melentiev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-30 00:00:00.000000000 Z
+date: 2014-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -44,14 +44,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.6
 description: Lightweight and extensible elasticsearch client
 email:
 - melentievm@gmail.com
@@ -60,6 +102,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
@@ -68,16 +112,24 @@ files:
 - lib/elastics/active_record.rb
 - lib/elastics/active_record/helper_methods.rb
 - lib/elastics/active_record/instrumentation.rb
-- lib/elastics/active_record/log_subscriber.rb
 - lib/elastics/active_record/model_schema.rb
+- lib/elastics/active_record/search_result.rb
+- lib/elastics/active_record/tasks_config.rb
+- lib/elastics/capistrano.rb
 - lib/elastics/client.rb
+- lib/elastics/client/cluster.rb
 - lib/elastics/query_helper.rb
 - lib/elastics/railtie.rb
 - lib/elastics/tasks.rb
+- lib/elastics/tasks/config.rb
 - lib/elastics/tasks/indices.rb
 - lib/elastics/tasks/mappings.rb
+- lib/elastics/tasks/migrations.rb
 - lib/elastics/version.rb
+- lib/elastics/version_manager.rb
 - lib/tasks/elastics.rake
+- spec/lib/elastics/client/cluster_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/printercu/elastics-rb
 licenses:
 - MIT
@@ -98,8 +150,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: ElasticSearch client with ActiveRecord integration
-test_files: []
+test_files:
+- spec/lib/elastics/client/cluster_spec.rb
+- spec/spec_helper.rb
+has_rdoc: