chewy 0.8.4 → 5.1.0

data/lib/chewy/index/actions.rb

@@ -9,7 +9,7 @@ module Chewy
       module ClassMethods
         # Checks index existance. Returns true or false
         #
-        #   UsersIndex.exist? #=> true
+        #   UsersIndex.exists? #=> true
         #
         def exists?
           client.indices.exists(index: index_name)
@@ -30,8 +30,8 @@ module Chewy
         # Suffixed index names might be used for zero-downtime mapping change, for example.
         # Description: (http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/).
         #
-        def create *args
-          create! *args
+        def create(*args)
+          create!(*args)
         rescue Elasticsearch::Transport::Transport::Errors::BadRequest
           false
         end
@@ -52,18 +52,14 @@ module Chewy
         # Suffixed index names might be used for zero-downtime mapping change, for example.
         # Description: (http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/).
         #
-        def create! *args
-          options = args.extract_options!.reverse_merge!(alias: true)
-          name = build_index_name(suffix: args.first)
+        def create!(suffix = nil, **options)
+          options.reverse_merge!(alias: true)
+          general_name = index_name
+          suffixed_name = index_name(suffix: suffix)
 
-          if Chewy::Runtime.version >= 1.1
-            body = index_params
-            body.merge!(aliases: {index_name => {}}) if options[:alias] && name != index_name
-            result = client.indices.create(index: name, body: body)
-          else
-            result = client.indices.create(index: name, body: index_params)
-            result &&= client.indices.put_alias(index: name, name: index_name) if options[:alias] && name != index_name
-          end
+          body = specification_hash
+          body[:aliases] = {general_name => {}} if options[:alias] && suffixed_name != general_name
+          result = client.indices.create(index: suffixed_name, body: body)
 
           Chewy.wait_for_status if result
           result
@@ -77,8 +73,8 @@ module Chewy
         #
         #   UsersIndex.delete '01-2014' # deletes `users_01-2014` index
         #
-        def delete suffix = nil
-          result = client.indices.delete index: build_index_name(suffix: suffix)
+        def delete(suffix = nil)
+          result = client.indices.delete index: index_name(suffix: suffix)
           Chewy.wait_for_status if result
           result
           # es-ruby >= 1.0.10 handles Elasticsearch::Transport::Transport::Errors::NotFound
@@ -96,7 +92,7 @@ module Chewy
         #
         #   UsersIndex.delete '01-2014' # deletes `users_01-2014` index
         #
-        def delete! suffix = nil
+        def delete!(suffix = nil)
           # es-ruby >= 1.0.10 handles Elasticsearch::Transport::Transport::Errors::NotFound
           # by itself, so it is raised here
           delete(suffix) or raise Elasticsearch::Transport::Transport::Errors::NotFound
@@ -108,7 +104,7 @@ module Chewy
         #   UsersIndex.purge # deletes and creates `users` index
         #   UsersIndex.purge '01-2014' # deletes `users` and `users_01-2014` indexes, creates `users_01-2014`
         #
-        def purge suffix = nil
+        def purge(suffix = nil)
           delete if suffix.present?
           delete suffix
           create suffix
@@ -121,7 +117,7 @@ module Chewy
         #   UsersIndex.purge! # deletes and creates `users` index
         #   UsersIndex.purge! '01-2014' # deletes `users` and `users_01-2014` indexes, creates `users_01-2014`
         #
-        def purge! suffix = nil
+        def purge!(suffix = nil)
           delete if suffix.present? && exists?
           delete suffix
           create! suffix
@@ -137,10 +133,17 @@ module Chewy
         #
         # See [import.rb](lib/chewy/type/import.rb) for more details.
         #
-        [:import, :import!].each do |method|
+        %i[import import!].each do |method|
           class_eval <<-METHOD, __FILE__, __LINE__ + 1
-            def #{method} options = {}
-              objects = options.reject { |k, v| !type_names.map(&:to_sym).include?(k) }
+            def #{method}(*args)
+              options = args.extract_options!
+              if args.one? && type_names.one?
+                objects = {type_names.first.to_sym => args.first}
+              elsif args.one?
+                fail ArgumentError, "Please pass objects for `#{method}` as a hash with type names"
+              else
+                objects = options.reject { |k, v| !type_names.map(&:to_sym).include?(k) }
+              end
               types.map do |type|
                 args = [objects[type.type_name.to_sym], options.dup].reject(&:blank?)
                 type.#{method} *args
@@ -149,33 +152,89 @@ module Chewy
           METHOD
         end
 
-        # Deletes, creates and imports data to the index.
-        # Returns import result
-        #
-        #   UsersIndex.reset!
+        # Deletes, creates and imports data to the index. Returns the
+        # import result. If index name suffix is passed as the first
+        # argument - performs zero-downtime index resetting.
         #
-        # If index name suffix passed as the first argument - performs
-        # zero-downtime index resetting (described here:
-        # http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/).
+        # It also applies journal if anything was journaled during the
+        # reset.
         #
+        # @example
+        #   UsersIndex.reset!
         #   UsersIndex.reset! Time.now.to_i
         #
-        def reset! suffix = nil
-          if suffix.present? && (indexes = self.indexes).present?
+        # @see http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime
+        # @param suffix [String] a suffix for the newly created index
+        # @param apply_journal [true, false] if true, journal is applied after the import is completed
+        # @param journal [true, false] journaling is switched off for import during reset by default
+        # @param import_options [Hash] options, passed to the import call
+        # @return [true, false] false in case of errors
+        def reset!(suffix = nil, apply_journal: true, journal: false, **import_options)
+          result = if suffix.present?
+            start_time = Time.now
+            indexes = self.indexes
             create! suffix, alias: false
-            result = import suffix: suffix
+
+            general_name = index_name
+            suffixed_name = index_name(suffix: suffix)
+
+            optimize_index_settings suffixed_name
+            result = import import_options.merge(suffix: suffix, journal: journal, refresh: !Chewy.reset_disable_refresh_interval)
+            original_index_settings suffixed_name
+
+            delete if indexes.blank?
             client.indices.update_aliases body: {actions: [
               *indexes.map do |index|
-                {remove: {index: index, alias: index_name}}
+                {remove: {index: index, alias: general_name}}
               end,
-              {add: {index: build_index_name(suffix: suffix), alias: index_name}}
+              {add: {index: suffixed_name, alias: general_name}}
             ]}
             client.indices.delete index: indexes if indexes.present?
+
+            self.journal.apply(start_time, **import_options) if apply_journal
             result
           else
-            purge! suffix
-            import
+            purge!
+            import import_options.merge(journal: journal)
+          end
+
+          specification.lock!
+          result
+        end
+
+        # A {Chewy::Journal} instance for the particular index
+        #
+        # @return [Chewy::Journal] journal instance
+        def journal
+          @journal ||= Chewy::Journal.new(self)
+        end
+
+      private
+
+        def optimize_index_settings(index_name)
+          settings = {}
+          settings[:refresh_interval] = -1 if Chewy.reset_disable_refresh_interval
+          settings[:number_of_replicas] = 0 if Chewy.reset_no_replicas
+          update_settings index_name, settings: settings if settings.any?
+        end
+
+        def original_index_settings(index_name)
+          settings = {}
+          if Chewy.reset_disable_refresh_interval
+            settings.merge! index_settings(:refresh_interval)
+            settings[:refresh_interval] = '1s' if settings.empty?
           end
+          settings.merge! index_settings(:number_of_replicas) if Chewy.reset_no_replicas
+          update_settings index_name, settings: settings if settings.any?
+        end
+
+        def update_settings(index_name, **options)
+          client.indices.put_settings index: index_name, body: {index: options[:settings]}
+        end
+
+        def index_settings(setting_name)
+          return {} unless settings_hash.key?(:settings) && settings_hash[:settings].key?(:index)
+          settings_hash[:settings][:index].slice(setting_name)
         end
       end
     end

data/lib/chewy/index/aliases.rb

@@ -11,7 +11,8 @@ module Chewy
         end
 
         def aliases
-          client.indices.get_alias(index: index_name, name: '*')[index_name].try(:[], 'aliases').try(:keys) || []
+          name = index_name
+          client.indices.get_alias(index: name, name: '*')[name].try(:[], 'aliases').try(:keys) || []
         rescue Elasticsearch::Transport::Transport::Errors::NotFound
           []
         end

data/lib/chewy/index/settings.rb

@@ -1,16 +1,17 @@
 module Chewy
   class Index
-
     # Stores ElasticSearch index settings and resolves `analysis`
     # hash. At first, you need to store some analyzers or other
     # analysis options to the corresponding repository:
     #
+    # @example
     #   Chewy.analyzer :title_analyzer, type: 'custom', filter: %w(lowercase icu_folding title_nysiis)
     #   Chewy.filter :title_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
     #
     # `title_nysiis` filter here will be expanded automatically when
     # `title_analyzer` analyser will be used in index settings:
     #
+    # @example
     #   class ProductsIndex < Chewy::Index
     #     settings analysis: {
     #       analyzer: [
@@ -24,14 +25,17 @@ module Chewy
     # might be used as well.
     #
     class Settings
-      def initialize(params = {})
+      def initialize(params = {}, &block)
         @params = params
+        @proc_params = block
       end
 
       def to_hash
         settings = @params.deep_symbolize_keys
+        settings.merge!((@proc_params.call || {}).deep_symbolize_keys) if @proc_params
 
         settings[:analysis] = resolve_analysis(settings[:analysis]) if settings[:analysis]
+
         if settings[:index] || Chewy.configuration[:index]
           settings[:index] = (Chewy.configuration[:index] || {})
             .deep_merge((settings[:index] || {}).deep_symbolize_keys)
@@ -45,14 +49,15 @@ module Chewy
       def resolve_analysis(analysis)
         analyzer = resolve(analysis[:analyzer], Chewy.analyzers)
 
-        options = [:tokenizer, :filter, :char_filter].each.with_object({}) do |type, result|
+        options = %i[tokenizer filter char_filter].each.with_object({}) do |type, result|
           dependencies = collect_dependencies(type, analyzer)
           resolved = resolve(dependencies.push(analysis[type]), Chewy.send(type.to_s.pluralize))
           result.merge!(type => resolved) if resolved.present?
         end
 
-        options.merge!(analyzer: analyzer) if analyzer.present?
-        options
+        options[:analyzer] = analyzer if analyzer.present?
+        analysis = analysis.except(:analyzer, :tokenizer, :filter, :char_filter)
+        analysis.merge(options)
       end
 
       def collect_dependencies(type, analyzer)

data/lib/chewy/index/specification.rb

@@ -0,0 +1,60 @@
+module Chewy
+  class Index
+    # Index specification is a combination of index settings and
+    # mappings. The idea behind this class is that specification
+    # can be locked in the `Chewy::Stash::Specification` between
+    # resets, so it is possible to track changes. In the future
+    # it is planned to be way smarter but right now `rake chewy:deploy`
+    # checks if there were changes and resets the index only if
+    # anything was changed. Otherwise, the index reset is skipped.
+    #
+    # @see Chewy::Stash::Specification
+    class Specification
+      # @see Chewy::Index::Specification
+      # @param index [Chewy::Index] Just a chewy index
+      def initialize(index)
+        @index = index
+      end
+
+      # Stores the current index specification to the `Chewy::Stash::Specification`
+      # as json.
+      #
+      # @raise [Chewy::ImportFailed] if something went wrong
+      # @return [true] if everything is fine
+      def lock!
+        Chewy::Stash::Specification.import!([
+          id: @index.derivable_name,
+          specification: Base64.encode64(current.to_json)
+        ], journal: false)
+      end
+
+      # Returns the last locked specification as ruby hash. Returns
+      # empty hash if nothing is stored yet.
+      #
+      # @return [Hash] hash produced with JSON parser
+      def locked
+        filter = {ids: {values: [@index.derivable_name]}}
+        document = Chewy::Stash::Specification.filter(filter).first
+        return {} unless document
+        JSON.load(Base64.decode64(document.specification)) # rubocop:disable Security/JSONLoad
+      end
+
+      # Simply returns `Chewy::Index.specification_hash`, but
+      # prepared for JSON with `as_json` method. This means all the
+      # keys are strings and there are only values of types handled in JSON.
+      #
+      # @see Chewy::Index.specification_hash
+      # @return [Hash] a JSON-ready hash
+      def current
+        @index.specification_hash.as_json
+      end
+
+      # Compares previously locked and current specifications.
+      #
+      # @return [true, false] the result of comparison
+      def changed?
+        current != locked
+      end
+    end
+  end
+end