activerecord_reindex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3eeb09396b487cf9fbd9d02ecb4f78ff27523665
+  data.tar.gz: 5b410be8a9139992259f0d87ff0c0d0bbb7db2f4
+SHA512:
+  metadata.gz: c63d9c04a190fe046eaca49262b6b327d6cb1f5108d1a6f1a78d8dfb13ce3ee77276b6ffae21b01232077cbe65a4671c896bd286719297d40fb6f09b14f1d241
+  data.tar.gz: 7359249c0e579f8889dd3d37c41b0e6eb1533fb451e5521fcb357ee924d1a3c1cdd560ec479aeb316376c73bcc3a54e5278ac609576812cf01e27d6bf7488d83

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Health24
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/activerecord_reindex.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+require 'activerecord_reindex/version'
+
+# monkey patch active record associations
+require 'active_record'
+require 'active_job'
+
+require 'activerecord_reindex/base'
+require 'activerecord_reindex/association'
+require 'activerecord_reindex/association_reflection'
+
+# monkey patch elasticsearch/model
+require 'elasticsearch/model'
+require 'activerecord_reindex/update_document_monkey_patch'
+
+module ActiverecordReindex
+end

data/lib/activerecord_reindex/adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+# Abstract adapter class
+# New adapters should implement :call method that will perform reindexing of the given record
+# Example:
+#   def call(record)
+#     reindex_it(record)
+#   end
+module ActiverecordReindex
+  class Adapter
+
+    # check if record of this class can be reindexed
+    # check if klass inherits from elasticsearch-model base class
+    # and have method required for reindexing
+    def self._check_elasticsearch_connection(klass)
+      klass < Elasticsearch::Model
+    end
+
+  end
+
+end

data/lib/activerecord_reindex/association.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+
+# Adds reindex option to associations
+# values accepted are true, :async. Default false.
+# If true it will add syncronous elasticsearch reindex callbacks on:
+# 1. record updated
+# 2. record destroyed
+# 3. record index updated
+# if :async it will add async callbacks in same cases
+module ActiveRecord
+  module Associations
+    module Builder
+      class Association
+
+        class << self
+
+          alias original_valid_options valid_options
+
+          # This method monkey patches ActiveRecord valid_options to add one more valid option :reindex
+          # Examples:
+          #   belongs_to :tag, reindex: true
+          #   belongs_to :tagging, reindex: :async
+          #   has_many :tags, reindex: async
+          #   has_many :tags, through: :taggings, reindex: true
+          def valid_options(*args)
+            original_valid_options(*args) + [:reindex]
+          end
+
+          alias original_define_callbacks define_callbacks
+
+          # This method monkeypatches ActiveRecord define_callbacks to
+          # add reindex callbacks if corresponding option specified
+          # if reindex; true - add syncronous callback to reindex associated records
+          # if reindex: :async - add asyncronous callback to reindex associated records
+          def define_callbacks(model, reflection)
+            original_define_callbacks(model, reflection)
+            if reflection.reindex_sync?
+              add_reindex_callback(model, reflection, async: false)
+              model.sync_reindexable_reflections += [reflection]
+            elsif reflection.reindex_async?
+              add_reindex_callback(model, reflection, async: true)
+              model.async_reindexable_reflections += [reflection]
+            end
+          end
+
+          private
+
+          # manages adding of callbacks considering async option
+          def add_reindex_callback(model, reflection, async:)
+            add_destroy_reindex_callback(model, reflection, async: async)
+
+            add_update_reindex_callback(model, reflection, async: async)
+          end
+
+          # add callback to reindex associated records on destroy
+          # if association has dependent: :destroy or dependent: :delete_all
+          # we skip this callback since destroyed records should reindex themselves
+          def add_destroy_reindex_callback(model, reflection, async:)
+            return if [:destroy, :delete_all].include? reflection.options[:dependent]
+
+            model.after_commit on: :destroy, &callback(async, reflection)
+          end
+
+          # add callback to reindex associations on update
+          # if model inherited from Elasticsearch::Model it means it have own index in elasticsearch
+          # and therefore should reindex itself on update those triggering update_document hook
+          # to prevent double reindex we're not adding update callback on such models
+          def add_update_reindex_callback(model, reflection, async:)
+            return if model < Elasticsearch::Model
+
+            model.after_commit on: :update, &callback(async, reflection)
+          end
+
+          # callback methods defined in ActiveRecord::Base monkeypatch
+          def callback(async, reflection)
+            async ? -> { reindex_async(reflection) } : -> { reindex_sync(reflection) }
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/activerecord_reindex/association_reflection.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+# Add helper methods to Activerecord Reflection
+# for quick access to reindex options
+module ActiveRecord
+  module Reflection
+    class AssociationReflection
+
+      def reindex_sync?
+        @options.fetch(:reindex, false) == true
+      end
+
+      def reindex_async?
+        @options.fetch(:reindex, false) == :async
+      end
+
+    end
+
+    class ThroughReflection
+
+      def reindex_sync?
+        @delegate_reflection.options.fetch(:reindex, false) == true
+      end
+
+      def reindex_async?
+        @delegate_reflection.options.fetch(:reindex, false) == :async
+      end
+
+    end
+  end
+end

data/lib/activerecord_reindex/async_adapter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+
+# Asyncronouse reindex adapter
+# uses Jobs for reindexing records asyncronously
+# Using ActiveJob as dependency bcs activerecord is required for this so
+# in most cases it would be used with rails hence with ActiveJob
+# later can think about adding support for differnt job adapters
+require_relative 'adapter'
+module ActiverecordReindex
+  class AsyncAdapter < Adapter
+
+    # Job wrapper. Queues elastic_index queue for each reindex
+    class UpdateJob < ::ActiveJob::Base
+
+      # TODO: make queue name configurable
+      queue_as :elastic_index
+
+      def perform(klass, id, request_record_klass, request_record_id)
+        klass = klass.constantize
+        request_record = request_record_klass.constantize.find(request_record_id)
+        klass.find(id).__elasticsearch__.update_document(request_record: request_record)
+      end
+
+    end
+
+    class << self
+
+      # ***nasty-stuff***
+      #   hooking into update_document has sudden side-effect
+      #   if associations defined two-way they will trigger reindex recursively and result in StackLevelTooDeep
+      #   hence to prevent this we're passing request_record to adapter
+      #   request record is record that initted reindex for current record as association
+      #   we will skip it in associations reindex to prevent recursive reindex and StackLevelTooDeep error
+      def call(record, request_record)
+        return unless _check_elasticsearch_connection(record.class)
+        UpdateJob.perform_later(record.class, record.id, request_record.class, request_record.id)
+      end
+
+    end
+
+  end
+end

data/lib/activerecord_reindex/base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+require_relative 'async_adapter'
+require_relative 'sync_adapter'
+require_relative 'reindexer'
+
+# ActiveRecord::Base extension to provide methods for
+# reindexing callbacks
+# this methods requested in callbacks in association.rb
+module ActiveRecord
+  class Base
+
+    def self.inherited(child)
+      super
+      class << child
+
+        attr_accessor :reindexer, :async_adapter, :sync_adapter, :sync_reindexable_reflections, :async_reindexable_reflections
+
+      end
+
+      # Init default values to prevent undefined method for nilClass error
+      child.sync_reindexable_reflections = []
+      child.async_reindexable_reflections = []
+
+      child.reindexer = ActiverecordReindex::Reindexer.new
+      # TODO: provide config for changing adapters
+      # For now can set adapter through writers inside class
+      child.async_adapter = ActiverecordReindex::AsyncAdapter
+      child.sync_adapter = ActiverecordReindex::SyncAdapter
+    end
+
+    def reindex_async(reflection, skip_record: nil)
+      _reindex(reflection, strategy: self.class.async_adapter, skip_record: skip_record)
+    end
+
+    def reindex_sync(reflection, skip_record: nil)
+      _reindex(reflection, strategy: self.class.sync_adapter, skip_record: skip_record)
+    end
+
+    private
+
+    def _reindex(reflection, strategy:, skip_record:)
+      self.class.reindexer
+          .with_strategy(strategy)
+          .call(self, reflection: reflection, skip_record: skip_record)
+    end
+
+  end
+end

data/lib/activerecord_reindex/reindexer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+module ActiverecordReindex
+  class Reindexer
+
+    # chain strategy before actual executing
+    # strategy can be either sync or async
+    # corresponding to type of reindexing
+    # additional strategies can be defined and specified by user
+    def with_strategy(strategy)
+      @strategy = strategy
+      self
+    end
+
+    # reindex records associated with given record on given association
+    # if association is collection(has_many, has_many_through, has_and_belongs_to_many)
+    #   get all associated recrods and reindex them
+    # else
+    #   reindex given record associted one
+    def call(record, reflection:, skip_record:)
+      if reflection.collection?
+        _reindex_collection(reflection, record, skip_record)
+      else
+        associated_record = record.public_send(reflection.name)
+        return if associated_record == skip_record
+        _update_index(associated_record, record)
+      end
+    end
+
+    private
+
+    # TODO: add bulk reindex if need performance
+    # raise if strategy was not specified or doesn't respond to call which is required for strategy
+    # pass record to strategy and execute reindex
+    # clear strategy to not mess up future reindexing
+    def _update_index(associated_record, record)
+      _check_strategy
+
+      @strategy.call(associated_record, record)
+
+      _clear_strategy
+    end
+
+    def _check_strategy
+      raise ArgumentError, 'No strategy specified.' unless @strategy
+      raise ArgumentError, "Strategy specified incorrect. Check if #{@strategy} responds to :call." unless @strategy.respond_to? :call
+    end
+
+    def _clear_strategy
+      @strategy = nil
+    end
+
+    def _reindex_collection(reflection, record, skip_record)
+      collection = record.public_send(reflection.name)
+
+      collection -= [skip_record] if reflection.klass == skip_record.class
+
+      collection.each do |associated_record|
+        _update_index(associated_record, record)
+      end
+    end
+
+  end
+end

data/lib/activerecord_reindex/sync_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+# Reindexes records syncronously
+require_relative 'adapter'
+module ActiverecordReindex
+  class SyncAdapter < Adapter
+
+    class << self
+
+      # updates index directly in elasticsearch through
+      # Elasticsearch::Model instance method
+      # if class not inherited from Elasticsearch::Model it skips since it cannot be reindexing
+      # TODO: show error\warning about trying to reindex record that is not connection to elastic
+      # ***nasty-stuff***
+      #   hooking into update_document has sudden side-effect
+      #   if associations defined two-way they will trigger reindex recursively and result in StackLevelTooDeep
+      #   hence to prevent this we're passing request_record to adapter
+      #   request record is record that initted reindex for current record as association
+      #   we will skip it in associations reindex to prevent recursive reindex and StackLevelTooDeep error
+      def call(record, request_record)
+        return unless _check_elasticsearch_connection(record.class)
+        record.__elasticsearch__.update_document(request_record: request_record)
+      end
+
+    end
+
+  end
+
+end

data/lib/activerecord_reindex/update_document_monkey_patch.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+module Elasticsearch
+  module Model
+    module Indexing
+      module InstanceMethods
+
+        alias original_update_document update_document
+
+        # monkey patch update_document method from elasticsearch gem
+        # use +super+ and hook on reindex to reindex associations
+        # for why request_record needed here and what it is see sync_adapter.rb
+        def update_document(*args, request_record: nil)
+          if _active_record_model?(self.class)
+            _reindex_reflections(self.class, request_record)
+          end
+          original_update_document(*args)
+        end
+
+        private
+
+        def _active_record_model?(klass)
+          klass < ActiveRecord::Base
+        end
+
+        def _reindex_reflections(klass, request_record)
+          klass.sync_reindexable_reflections.each do |reflection|
+            target.reindex_sync(reflection, skip_record: request_record)
+          end
+
+          klass.async_reindexable_reflections.each do |reflection|
+            target.reindex_async(reflection, skip_record: request_record)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/activerecord_reindex/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+module ActiverecordReindex
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_reindex
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- vs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- vshaveyko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/activerecord_reindex.rb
+- lib/activerecord_reindex/adapter.rb
+- lib/activerecord_reindex/association.rb
+- lib/activerecord_reindex/association_reflection.rb
+- lib/activerecord_reindex/async_adapter.rb
+- lib/activerecord_reindex/base.rb
+- lib/activerecord_reindex/reindexer.rb
+- lib/activerecord_reindex/sync_adapter.rb
+- lib/activerecord_reindex/update_document_monkey_patch.rb
+- lib/activerecord_reindex/version.rb
+homepage: https://github.com/Health24/activerecord_reindex
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Add Elasticsearch reindex option to ActiveRecord associations
+test_files: []