elastic_search_framework 2.1.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bb31cdcff7f6e3f40501c7dcadba923be7582ff8d91daec8e52d7dd8689e8da
-  data.tar.gz: b5c57937085a1719aae84d24fb10a93fbb582ec12ebe6f6b8c15f3aa987c053e
+  metadata.gz: 843e0d64a790e34d0cca88a47eb6824530b366a3f2f5732d09e8e7bae8437151
+  data.tar.gz: 914a7d0b4730df74b4cd8851d019f9cca83335951ba808b3b2a942d3398a0d8a
 SHA512:
-  metadata.gz: 214b8d927d48733fc52a98c7667621529efb9d68e331d8f4b3e4e70c76a2b72fd2e5d56f749cd5d0b2a6002316fd56bc77d9b68bf8091fe0402ea7c7f994db61
-  data.tar.gz: 8151848be2786d442eea281aa10e89338d06109b20bde72de2df87fd2f0b31a8a2279a9d560a035f66af92333657890cd5a34ed22dbb828a25e9d3003886d459
+  metadata.gz: 69b9c1c1e39841ad54cc1daf0b9895664ca4af635786dfc703c4ac8aa313af6146be873d26ca6358143f2bb1be11c453a28913a10437202524f8dbc4a75d93d9
+  data.tar.gz: e2c9a9d2ad91996c24837e2c7982b1e5a5f4a9a2d01c191e22a268f90fb9e8cbb63c2560b2cb5c105c9ac3c17dd930041bdda605512e389815e43747146f5677

data/lib/elastic_search_framework.rb

@@ -8,6 +8,8 @@ require_relative 'elastic_search_framework/logger'
 require_relative 'elastic_search_framework/exceptions'
 require_relative 'elastic_search_framework/repository'
 require_relative 'elastic_search_framework/index'
+require_relative 'elastic_search_framework/index_alias'
+require_relative 'elastic_search_framework/sharded_index'
 require_relative 'elastic_search_framework/query'
 
 module ElasticSearchFramework

data/lib/elastic_search_framework/index.rb

@@ -2,14 +2,23 @@ module ElasticSearchFramework
   module Index
     attr_accessor :index_settings
 
-    def index(name:)
+    def index(name:, version: nil)
       unless instance_variable_defined?(:@elastic_search_index_def)
-        instance_variable_set(:@elastic_search_index_def, name: "#{name}")
+        instance_variable_set(:@elastic_search_index_def, name: "#{name}#{version}")
+        instance_variable_set(:@elastic_search_index_version, version: version) unless version.nil?
       else
         raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Duplicate index description. Name: #{name}.")
       end
     end
 
+    def version
+      instance_variable_defined?(:@elastic_search_index_version) ? instance_variable_get(:@elastic_search_index_version) : 0
+    end
+
+    def routing_enabled?
+      false
+    end
+
     def id(field)
       unless instance_variable_defined?(:@elastic_search_index_id)
         instance_variable_set(:@elastic_search_index_id, field)
@@ -160,19 +169,28 @@ module ElasticSearchFramework
     end
 
     def repository
-      ElasticSearchFramework::Repository.new
+      @repository ||= ElasticSearchFramework::Repository.new
     end
 
-    def get_item(id:, type: 'default')
-      repository.get(index: self, id: id, type: type)
+    def get_item(id:, type: 'default', routing_key: nil)
+      options = { index: self, id: id, type: type }
+      options[:routing_key] = routing_key if routing_enabled? && routing_key
+
+      repository.get(options)
     end
 
-    def put_item(type: 'default', item:)
-      repository.set(entity: item, index: self, type: type)
+    def put_item(type: 'default', item:, op_type: 'index', routing_key: nil)
+      options = { entity: item, index: self, type: type, op_type: op_type }
+      options[:routing_key] = routing_key if routing_enabled? && routing_key
+
+      repository.set(options)
     end
 
-    def delete_item(id:, type: 'default')
-      repository.drop(index: self, id: id, type: type)
+    def delete_item(id:, type: 'default', routing_key: nil)
+      options = { index: self, id: id, type: type }
+      options[:routing_key] = routing_key if routing_enabled? && routing_key
+
+      repository.drop(options)
     end
 
     def query

data/lib/elastic_search_framework/index_alias.rb

@@ -0,0 +1,161 @@
+module ElasticSearchFramework
+  module IndexAlias
+    def index(klass, active:)
+      unless instance_variable_defined?(:@elastic_search_indexes)
+        instance_variable_set(:@elastic_search_indexes, [])
+      end
+      indexes = self.instance_variable_get(:@elastic_search_indexes)
+      indexes << {klass: klass, active: active}
+      instance_variable_set(:@elastic_search_indexes, indexes)
+    end
+
+    def indexes
+      self.instance_variable_get(:@elastic_search_indexes)
+    end
+
+    def name(name)
+      unless instance_variable_defined?(:@elastic_search_index_alias_name)
+        instance_variable_set(:@elastic_search_index_alias_name, "#{name}")
+      else
+        raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Duplicate index alias name: #{name}.")
+      end
+    end
+
+    def valid?
+      indexes.select { |i| i[:active] == true }.length == 1
+    end
+
+    def create
+      if !valid?
+        raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Invalid Index alias.")
+      end
+
+      uri = URI("#{host}/_aliases")
+
+      payload = {
+        actions: [],
+      }
+
+      indexes.each do |index|
+        action = nil
+        if exists?(index: index[:klass])
+          action = "remove" if !index[:active]
+        else
+          action = "add" if index[:active]
+        end
+        next if action.nil?
+
+        payload[:actions] << {action => {index: index[:klass].full_name, alias: self.full_name}}
+      end
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = JSON.dump(payload)
+      request.content_type = "application/json"
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      is_valid_response?(response.code) || Integer(response.code) == 404
+    end
+
+    def delete
+      uri = URI("#{host}/_all/_aliases/#{full_name}")
+
+      request = Net::HTTP::Delete.new(uri.request_uri)
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      is_valid_response?(response.code) || Integer(response.code) == 404
+    end
+
+    def exists?(index:)
+      uri = URI("#{host}/#{index.full_name}/_alias/#{full_name}")
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      return false if response.code == "404"
+
+      result = nil
+      if is_valid_response?(response.code)
+        result = JSON.parse(response.body)
+      end
+
+      return true if !result.nil? && result[index.full_name]["aliases"] != nil
+      return false
+    end
+
+    def is_valid_response?(code)
+      [200, 201, 202].include?(Integer(code))
+    end
+
+    def full_name
+      name = instance_variable_get(:@elastic_search_index_alias_name)
+      if ElasticSearchFramework.namespace != nil
+        "#{ElasticSearchFramework.namespace}#{ElasticSearchFramework.namespace_delimiter}#{name.downcase}"
+      else
+        name.downcase
+      end
+    end
+
+    def description
+      index = indexes.last[:klass]
+      hash = index.instance_variable_get(:@elastic_search_index_def)
+      if index.instance_variable_defined?(:@elastic_search_index_id)
+        hash[:id] = index.instance_variable_get(:@elastic_search_index_id)
+      else
+        hash[:id] = :id
+      end
+      hash
+    end
+
+    def host
+      "#{ElasticSearchFramework.host}:#{ElasticSearchFramework.port}"
+    end
+
+    def repository
+      @repository ||= ElasticSearchFramework::Repository.new
+    end
+
+    def get_item(id:, type: "default", routing_key: nil)
+      active_index = indexes.detect { |i| i[:active] == true }[:klass]
+
+      options = { index: self, id: id, type: type }
+      options[:routing_key] = routing_key if active_index.routing_enabled? && routing_key
+
+      repository.get(options)
+    end
+
+    def put_item(type: "default", item:, op_type: 'index', routing_key: nil)
+      indexes.each do |index|
+        options = { entity: item, index: index[:klass], type: type, op_type: op_type }
+        options[:routing_key] = routing_key if index[:klass].routing_enabled? && routing_key
+
+        repository.set(options)
+      end
+    end
+
+    def delete_item(id:, type: "default", routing_key: nil)
+      indexes.each do |index|
+        options = { index: index[:klass], id: id, type: type }
+        options[:routing_key] = routing_key if index[:klass].routing_enabled? && routing_key
+
+        repository.drop(options)
+      end
+    end
+
+    def query
+      ElasticSearchFramework::Query.new(index: self)
+    end
+
+    def routing_enabled?
+      indexes.find(active: true).first[:klass].routing_enabled?
+    end
+  end
+end

data/lib/elastic_search_framework/repository.rb

@@ -1,8 +1,11 @@
 module ElasticSearchFramework
   class Repository
 
-    def set(index:, entity:, type: 'default')
-      uri = URI("#{host}/#{index.full_name}/#{type.downcase}/#{get_id_value(index: index, entity: entity)}")
+    def set(index:, entity:, type: 'default', op_type: 'index', routing_key: nil)
+      uri_string = "#{host}/#{index.full_name}/#{type.downcase}/#{get_id_value(index: index, entity: entity)}?op_type=#{op_type}"
+      uri_string += "&routing=#{routing_key}" if routing_key
+
+      uri = URI(uri_string)
       hash = hash_helper.to_hash(entity)
 
       request = Net::HTTP::Put.new(uri.request_uri)
@@ -13,16 +16,22 @@ module ElasticSearchFramework
         client.request(request)
       end
 
-      unless valid_response?(response.code)
+      if valid_response?(response.code)
+        return true
+      elsif op_type == 'create' && Integer(response.code) == 409
+        return true
+      else
         raise ElasticSearchFramework::Exceptions::IndexError.new(
             "An error occurred setting an index document. Response: #{response.body} | Code: #{response.code}"
         )
       end
-      return true
     end
 
-    def get(index:, id:, type: 'default')
-      uri = URI("#{host}/#{index.full_name}/#{type.downcase}/#{id}/_source")
+    def get(index:, id:, type: 'default', routing_key: nil)
+      uri_string = "#{host}/#{index.full_name}/#{type.downcase}/#{id}/_source"
+      uri_string += "?routing=#{routing_key}" if routing_key
+
+      uri = URI(uri_string)
 
       request = Net::HTTP::Get.new(uri.request_uri)
 
@@ -43,8 +52,11 @@ module ElasticSearchFramework
       end
     end
 
-    def drop(index:, id:, type: 'default')
-      uri = URI("#{host}/#{index.full_name}/#{type.downcase}/#{id}")
+    def drop(index:, id:, type: 'default', routing_key: nil)
+      uri_string = "#{host}/#{index.full_name}/#{type.downcase}/#{id}"
+      uri_string += "?routing=#{routing_key}" if routing_key
+
+      uri = URI(uri_string)
 
       request = Net::HTTP::Delete.new(uri.request_uri)
 
@@ -61,8 +73,11 @@ module ElasticSearchFramework
       end
     end
 
-    def query(index:, expression:, type: 'default', limit: 10, count: false)
-      uri = URI("#{host}/#{index.full_name}/#{type}/_search?q=#{URI.encode(expression)}&size=#{limit}")
+    def query(index:, expression:, type: 'default', limit: 10, count: false, routing_key: nil)
+      uri_string = "#{host}/#{index.full_name}/#{type}/_search?q=#{URI.encode(expression)}&size=#{limit}"
+      uri_string += "&routing=#{routing_key}" if routing_key
+
+      uri = URI(uri_string)
 
       request = Net::HTTP::Get.new(uri.request_uri)
 
@@ -83,8 +98,11 @@ module ElasticSearchFramework
       end
     end
 
-    def json_query(index_name:, json_query:, type: 'default')
-      uri = URI("#{host}/#{index_name}/#{type}/_search")
+    def json_query(index_name:, json_query:, type: 'default', routing_key: nil)
+      uri_string = "#{host}/#{index_name}/#{type}/_search"
+      uri_string += "?routing=#{routing_key}" if routing_key
+
+      uri = URI(uri_string)
 
       request = Net::HTTP::Get.new(uri.request_uri)
       request.content_type = 'application/json'

data/lib/elastic_search_framework/sharded_index.rb

@@ -0,0 +1,200 @@
+module ElasticSearchFramework
+  module ShardedIndex
+    attr_accessor :index_settings
+
+    def index(name:, version: nil)
+      unless instance_variable_defined?(:@elastic_search_index_def)
+        instance_variable_set(:@elastic_search_index_def, name: "#{name}#{version}")
+        instance_variable_set(:@elastic_search_index_version, version: version) unless version.nil?
+      else
+        raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Duplicate index description. Name: #{name}.")
+      end
+    end
+
+    def version
+      instance_variable_defined?(:@elastic_search_index_version) ? instance_variable_get(:@elastic_search_index_version) : 0
+    end
+
+    def routing_enabled?
+      true
+    end
+
+    def id(field)
+      unless instance_variable_defined?(:@elastic_search_index_id)
+        instance_variable_set(:@elastic_search_index_id, field)
+      else
+        raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Duplicate index id. Field: #{field}.")
+      end
+    end
+
+    def mapping(name:, field:, **options)
+      unless instance_variable_defined?(:@elastic_search_index_mappings)
+        instance_variable_set(:@elastic_search_index_mappings, {})
+      end
+
+      mappings = instance_variable_get(:@elastic_search_index_mappings)
+
+      mappings[name] = {} if mappings[name].nil?
+
+      mappings[name][field] = options
+
+      instance_variable_set(:@elastic_search_index_mappings, mappings)
+    end
+
+    def create
+      if !valid?
+        raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Invalid Index description specified.")
+      end
+
+      if exists?
+        ElasticSearchFramework.logger.debug { "[#{self.class}] - Index already exists."}
+        return
+      end
+      payload = create_payload
+
+      put(payload: payload)
+    end
+
+    def put(payload:)
+      uri = URI("#{host}/#{full_name}")
+
+      request = Net::HTTP::Put.new(uri.request_uri)
+      request.body = JSON.dump(payload)
+      request.content_type = 'application/json'
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      unless is_valid_response?(response.code)
+        if JSON.parse(response.body, symbolize_names: true).dig(:error, :root_cause, 0, :type) == 'index_already_exists_exception'
+          # We get here because the `exists?` check in #create is non-atomic
+          ElasticSearchFramework.logger.warn "[#{self.class}] - Failed to create preexisting index. | Response: #{response.body}"
+        else
+          raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self}] - Failed to put index. Payload: #{payload} | Response: #{response.body}")
+        end
+      end
+      true
+    end
+
+    def get
+      uri = URI("#{host}/#{full_name}")
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      result = nil
+      if is_valid_response?(response.code)
+        result = JSON.parse(response.body)
+      end
+      result
+    end
+
+    def exists?
+      get != nil
+    end
+
+    def delete
+      uri = URI("#{host}/#{full_name}")
+
+      request = Net::HTTP::Delete.new(uri.request_uri)
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      is_valid_response?(response.code) || Integer(response.code) == 404
+    end
+
+    def settings(name:, type: nil, value:)
+      self.index_settings = {} if index_settings.nil?
+      index_settings[name] = {} if index_settings[name].nil?
+      return index_settings[name][type] = value if type
+      index_settings[name] = value
+    end
+
+    def create_payload
+      payload = { }
+      payload[:settings] = index_settings unless index_settings.nil?
+
+      unless mappings.keys.empty?
+        payload[:mappings] = {}
+
+        mappings.keys.each do |name|
+          payload[:mappings][name] = { properties: {} }
+          mappings[name].keys.each do |field|
+            payload[:mappings][name][:properties][field] = mappings[name][field]
+          end
+        end
+      end
+
+      payload
+    end
+
+    def valid?
+      self.instance_variable_get(:@elastic_search_index_def) ? true : false
+    end
+
+    def description
+      hash = self.instance_variable_get(:@elastic_search_index_def)
+      if instance_variable_defined?(:@elastic_search_index_id)
+        hash[:id] = self.instance_variable_get(:@elastic_search_index_id)
+      else
+        hash[:id] = :id
+      end
+      hash
+    end
+
+    def mappings
+      self.instance_variable_defined?(:@elastic_search_index_mappings) ? self.instance_variable_get(:@elastic_search_index_mappings) : {}
+    end
+
+    def is_valid_response?(code)
+      [200,201,202].include?(Integer(code))
+    end
+
+    def full_name
+      if ElasticSearchFramework.namespace != nil
+        "#{ElasticSearchFramework.namespace}#{ElasticSearchFramework.namespace_delimiter}#{description[:name].downcase}"
+      else
+        description[:name].downcase
+      end
+    end
+
+    def host
+      "#{ElasticSearchFramework.host}:#{ElasticSearchFramework.port}"
+    end
+
+    def repository
+      @repository ||= ElasticSearchFramework::Repository.new
+    end
+
+    def get_item(id:, type: 'default', routing_key: nil)
+      options = { index: self, id: id, type: type }
+      options[:routing_key] = routing_key if routing_enabled? && routing_key
+
+      repository.get(options)
+    end
+
+    def put_item(type: 'default', item:, op_type: 'index', routing_key: nil)
+      options = { entity: item, index: self, type: type, op_type: op_type }
+      options[:routing_key] = routing_key if routing_enabled? && routing_key
+
+      repository.set(options)
+    end
+
+    def delete_item(id:, type: 'default', routing_key: nil)
+      options = { index: self, id: id, type: type }
+      options[:routing_key] = routing_key if routing_enabled? && routing_key
+
+      repository.drop(options)
+    end
+
+    def query
+      ElasticSearchFramework::Query.new(index: self)
+    end
+  end
+end

data/lib/elastic_search_framework/version.rb

@@ -1,3 +1,3 @@
 module ElasticSearchFramework
-  VERSION = '2.1.0'
+  VERSION = '2.4.0'
 end

data/spec/elastic_search_framework/index_alias_spec.rb

@@ -0,0 +1,174 @@
+RSpec.describe ElasticSearchFramework::Index do
+  describe '#full_name' do
+    let(:namespace) { 'uat' }
+    let(:namespace_delimiter) { '.' }
+    before do
+      ElasticSearchFramework.namespace = namespace
+      ElasticSearchFramework.namespace_delimiter = namespace_delimiter
+    end
+    it 'should return the full index name including namespace and delimiter' do
+      expect(ExampleIndexAlias.full_name).to eq "#{ElasticSearchFramework.namespace}#{ElasticSearchFramework.namespace_delimiter}example"
+    end
+
+    context 'when the namespace is nil' do
+      before { ElasticSearchFramework.namespace = nil }
+
+      it 'returns the description name downcased' do
+        expect(ExampleIndexAlias.full_name).to eq 'example'
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'for a valid index definition' do
+      it 'should return true' do
+        expect(ExampleIndexAlias.valid?).to be true
+      end
+    end
+    context 'for an invalid index definition' do
+      it 'should return true' do
+        expect(InvalidIndexAlias.valid?).to be false
+      end
+    end
+  end
+
+  describe '#create' do
+    context 'when alias is valid and does not exist' do
+      before do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete if ExampleIndex.exists?
+        ExampleIndex.create
+      end
+
+      it 'creates an alias for the active index' do
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be false
+        ExampleIndexAlias.create
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be true
+      end
+
+      after do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete
+      end
+    end
+
+    context 'when alias is not valid' do
+      before { allow(ExampleIndexAlias).to receive(:valid?).and_return(false) }
+
+      it 'raises an error' do
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be false
+        expect { ExampleIndexAlias.create }.to raise_error(
+          ElasticSearchFramework::Exceptions::IndexError
+        )
+      end
+    end
+
+    context 'when alias is valid but already exists' do
+      before do
+        ExampleIndex.delete if ExampleIndex.exists?
+        ExampleIndex.create
+        ExampleIndexAlias.create
+      end
+
+      it 'does not try to create a new alias' do
+        ExampleIndexAlias.create
+      end
+
+      after do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete
+      end
+    end
+
+    context 'when alias is valid and does not exist and requires updating' do
+      before do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete if ExampleIndex.exists?
+        ExampleIndex2.delete if ExampleIndex2.exists?
+        ExampleIndex.create
+        ExampleIndex2.create
+        ExampleIndexAlias.create
+      end
+
+      it 'modifies the alias to the active index' do
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be true
+        ExampleIndexAlias2.create
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be false
+        expect(ExampleIndexAlias2.exists?(index: ExampleIndex2)).to be true
+      end
+
+      after do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete
+        ExampleIndex2.delete
+      end
+    end
+  end
+
+  describe '#get_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    context 'when active index routing_enabled false' do
+      it 'should call get on the repository' do
+        expect(ExampleIndexAlias.repository).to receive(:get).with(index: ExampleIndexAlias, id: id, type: type).once
+        ExampleIndexAlias.get_item(id: id, type: type)
+      end
+
+      it 'should call get on the repository and not pass through routing_key when supplied' do
+        expect(ExampleIndexAlias.repository).to receive(:get).with(index: ExampleIndexAlias, id: id, type: type).once
+        ExampleIndexAlias.get_item(id: id, type: type, routing_key: 5)
+      end
+    end
+
+    context 'when active index routing_enabled true' do
+      it 'should call get on the repository' do
+        expect(ExampleIndexAlias2.repository).to receive(:get).with(index: ExampleIndexAlias2, id: id, type: type, routing_key: 5).once
+        ExampleIndexAlias2.get_item(id: id, type: type, routing_key: 5)
+      end
+    end
+  end
+
+  describe '#put_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    let(:item) do
+      TestItem.new.tap do |i|
+        i.id = id
+        i.name = 'abc'
+        i.timestamp = Time.now.to_i
+        i.number = 5
+      end
+    end
+    context 'without specifying op_type' do
+      it 'should call set on the repository for each index of the alias with default op_type (index)' do
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type, op_type: 'index').once
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex2, type: type, op_type: 'index', routing_key: 5).once
+        ExampleIndexAlias.put_item(type: type, item: item, routing_key: 5)
+      end
+    end
+
+    context 'with specified op_type' do
+      it 'should call set on the repository for each index of the alias with supplied op_type (index)' do
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type, op_type: 'index').once
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex2, type: type, op_type: 'index', routing_key: 5).once
+        ExampleIndexAlias.put_item(type: type, item: item, op_type: 'index', routing_key: 5)
+      end
+
+      it 'should call set on the repository for each index of the alias with supplied op_type (create)' do
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type, op_type: 'create').once
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex2, type: type, op_type: 'create', routing_key: 5).once
+        ExampleIndexAlias.put_item(type: type, item: item, op_type: 'create', routing_key: 5)
+      end
+    end
+  end
+
+  describe '#delete_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    it 'should call drop on the repository for each index of the alias' do
+      expect(ExampleIndexAlias.repository).to receive(:drop).with(index: ExampleIndex, id: id, type: type).once
+      expect(ExampleIndexAlias.repository).to receive(:drop).with(index: ExampleIndex2, id: id, type: type, routing_key: 5).once
+      ExampleIndexAlias.delete_item(id: id, type: type, routing_key: 5)
+    end
+  end
+end

data/spec/elastic_search_framework/index_spec.rb

@@ -79,17 +79,18 @@ RSpec.describe ElasticSearchFramework::Index do
         {
           'normalizer' => {
             'custom_normalizer' => {
+              'char_filter' => [],
               'filter' => ['lowercase'],
               'type' => 'custom'
             }
           },
-          'analyzer'=>{
-              'custom_analyzer'=>{
-                'filter'=>['lowercase'],
-                'type'=>'custom',
-                'tokenizer'=>'standard'
-              }
+          'analyzer' => {
+            'custom_analyzer' => {
+              'filter' => ['lowercase'],
+              'type' => 'custom',
+              'tokenizer' => 'standard'
             }
+          }
         }
       end
 
@@ -276,8 +277,8 @@ RSpec.describe ElasticSearchFramework::Index do
     it 'should return a ElasticSearchFramework::Repository instance' do
       expect(ExampleIndex.repository).to be_a(ElasticSearchFramework::Repository)
     end
-    it 'should return a unique ElasticSearchFramework::Repository instance' do
-      expect(ExampleIndex.repository).not_to eq ExampleIndex.repository
+    it 'should return the same ElasticSearchFramework::Repository instance for multiple calls' do
+      expect(ExampleIndex.repository).to eq ExampleIndex.repository
     end
   end
 
@@ -301,9 +302,38 @@ RSpec.describe ElasticSearchFramework::Index do
         i.number = 5
       end
     end
-    it 'should call set on the repository' do
-      expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type)
-      ExampleIndex.put_item(type: type, item: item)
+
+    context 'without specifying op_type' do
+      it 'should call set on the repository with default op_type (index)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'index', type: type)
+        ExampleIndex.put_item(type: type, item: item)
+      end
+    end
+
+    context 'with specified op_type' do
+      it 'should call set on the repository with supplied op_type (index)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'index', type: type)
+        ExampleIndex.put_item(type: type, item: item, op_type: 'index')
+      end
+
+      it 'should call set on the repository with supplied op_type (create)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'create', type: type)
+        ExampleIndex.put_item(type: type, item: item, op_type: 'create')
+      end
+    end
+
+    context 'without specifying routing_key' do
+      it 'should call set on the repository without routing_key' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'index', type: type)
+        ExampleIndex.put_item(type: type, item: item, op_type: 'index')
+      end
+    end
+
+    context 'with specified routing_key' do
+      it 'should call set on the repository without routing_key' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'index', type: type)
+        ExampleIndex.put_item(type: type, item: item, op_type: 'index', routing_key: '6')
+      end
     end
   end
 

data/spec/elastic_search_framework/repository_spec.rb

@@ -63,22 +63,40 @@ RSpec.describe ElasticSearchFramework::Repository do
       ExampleIndexWithId.create
     end
 
-    it 'should create, read and delete an index document' do
-      subject.set(index: ExampleIndex, entity: item1)
-      subject.set(index: ExampleIndex, entity: item2)
-      subject.set(index: ExampleIndex, entity: item5)
-      index_item1 = subject.get(index: ExampleIndex, id: item1.id)
-      expect(index_item1[:id]).to eq item1.id
-      expect(index_item1[:name]).to eq item1.name
-      expect(index_item1[:timestamp]).to eq item1.timestamp
-      expect(index_item1[:number]).to eq item1.number
-      index_item2 = subject.get(index: ExampleIndex, id: item2.id)
-      expect(index_item2[:id]).to eq item2.id
-      expect(index_item2[:name]).to eq item2.name
-      expect(index_item2[:timestamp]).to eq item2.timestamp
-      expect(index_item2[:number]).to eq item2.number
-      subject.drop(index: ExampleIndex, id: item1.id)
-      expect(subject.get(index: ExampleIndex, id: item1.id)).to be_nil
+    context 'PUT with op_type: index' do
+      it 'should create, read and delete an index document' do
+        subject.set(index: ExampleIndex, entity: item1)
+        subject.set(index: ExampleIndex, entity: item1.tap { |i| i.timestamp += 100 })
+        subject.set(index: ExampleIndex, entity: item1.tap { |i| i.timestamp += 100 }, op_type: 'index')
+        subject.set(index: ExampleIndex, entity: item2)
+        subject.set(index: ExampleIndex, entity: item5)
+        index_item1 = subject.get(index: ExampleIndex, id: item1.id)
+        expect(index_item1[:id]).to eq item1.id
+        expect(index_item1[:name]).to eq item1.name
+        expect(index_item1[:timestamp]).to eq item1.timestamp
+        expect(index_item1[:number]).to eq item1.number
+        index_item2 = subject.get(index: ExampleIndex, id: item2.id)
+        expect(index_item2[:id]).to eq item2.id
+        expect(index_item2[:name]).to eq item2.name
+        expect(index_item2[:timestamp]).to eq item2.timestamp
+        expect(index_item2[:number]).to eq item2.number
+        subject.drop(index: ExampleIndex, id: item1.id)
+        expect(subject.get(index: ExampleIndex, id: item1.id)).to be_nil
+      end
+    end
+
+    context 'PUT with op_type: create' do
+      let!(:original_timestamp) { item1.timestamp }
+
+      it 'should not update item' do
+        subject.set(index: ExampleIndex, entity: item1)
+        subject.set(index: ExampleIndex, entity: item1.tap { |i| i.timestamp += 100 }, op_type: 'create')
+        index_item1 = subject.get(index: ExampleIndex, id: item1.id)
+        expect(index_item1[:id]).to eq item1.id
+        expect(index_item1[:name]).to eq item1.name
+        expect(index_item1[:timestamp]).to eq original_timestamp
+        expect(index_item1[:number]).to eq item1.number
+      end
     end
 
     after do

data/spec/elastic_search_framework/sharded_index_spec.rb

@@ -0,0 +1,348 @@
+RSpec.describe ElasticSearchFramework::ShardedIndex do
+  describe '#description' do
+    it 'should return the index details' do
+      expect(ExampleIndex2.description).to be_a(Hash)
+      expect(ExampleIndex2.description[:name]).to eq 'example_index2'
+      expect(ExampleIndex2.description[:id]).to eq :id
+      expect(ExampleIndexWithId2.description[:id]).to eq :number
+    end
+  end
+
+  describe '#index' do
+    before { ExampleIndex2.create unless ExampleIndex2.exists? }
+    context 'when the instance variable is not defined' do
+      before { allow(ExampleIndex2).to receive(:instance_variable_defined?).and_return(true) }
+      it 'raises an index error' do
+        expect { ExampleIndex2.index(name: 'test') }.to raise_error(
+          ElasticSearchFramework::Exceptions::IndexError,
+          '[Class] - Duplicate index description. Name: test.'
+        )
+      end
+    end
+  end
+
+  describe '#id' do
+    context 'when the instance variable is not defined' do
+      before { allow(ExampleIndex2).to receive(:instance_variable_defined?).and_return(true) }
+      it 'raises an index error' do
+        expect { ExampleIndex2.id('name') }.to raise_error(
+          ElasticSearchFramework::Exceptions::IndexError,
+          "[Class] - Duplicate index id. Field: name."
+        )
+      end
+    end
+  end
+
+  describe '#full_name' do
+    let(:namespace) { 'uat' }
+    let(:namespace_delimiter) { '.' }
+    before do
+      ElasticSearchFramework.namespace = namespace
+      ElasticSearchFramework.namespace_delimiter = namespace_delimiter
+    end
+    it 'should return the full index name including namespace and delimiter' do
+      expect(ExampleIndex2.full_name).to eq "#{ElasticSearchFramework.namespace}#{ElasticSearchFramework.namespace_delimiter}#{ExampleIndex2.description[:name]}"
+    end
+
+    context 'when the namespace is nil' do
+      before { ElasticSearchFramework.namespace = nil }
+
+      it 'returns the description name downcased' do
+        expect(ExampleIndex2.full_name).to eq 'example_index2'
+      end
+    end
+  end
+
+  describe '#mapping' do
+    it 'should add mapping details to the index definition' do
+      mappings = ExampleIndex2.mappings
+      expect(mappings).to be_a(Hash)
+      expect(mappings.length).to eq 1
+      expect(mappings['default'][:name][:type]).to eq :keyword
+      expect(mappings['default'][:name][:index]).to eq true
+    end
+  end
+
+  describe '#analysis' do
+    context 'when analysis is nil' do
+      before { ExampleIndex2.delete if ExampleIndex2.exists? }
+
+      it 'does not add analysis to the index' do
+        ExampleIndex2.create
+        expect(ExampleIndexWithSettings2.get.dig('example_index2', 'settings', 'index', 'analysis')).to be_nil
+      end
+    end
+
+    context 'when analysis is not nil' do
+      before { ExampleIndexWithSettings2.delete if ExampleIndexWithSettings2.exists? }
+      let(:expected) do
+        {
+          'normalizer' => {
+            'custom_normalizer' => {
+              'char_filter' => [],
+              'filter' => ['lowercase'],
+              'type' => 'custom'
+            }
+          },
+          'analyzer' => {
+            'custom_analyzer' => {
+              'filter' => ['lowercase'],
+              'type' => 'custom',
+              'tokenizer' => 'standard'
+            }
+          }
+        }
+      end
+
+      it 'adds analysis to the index' do
+        ExampleIndexWithSettings2.create
+        expect(ExampleIndexWithSettings2.get.dig('example_index2', 'settings', 'index', 'number_of_shards')).to eq('1')
+        expect(ExampleIndexWithSettings2.get.dig('example_index2', 'settings', 'index', 'analysis')).to eq(expected)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'for a valid index definition' do
+      it 'should return true' do
+        expect(ExampleIndex2.valid?).to be true
+      end
+    end
+    context 'for an invalid index definition' do
+      it 'should return true' do
+        expect(InvalidExampleIndex2.valid?).to be false
+      end
+    end
+  end
+
+  describe '#create' do
+    context 'when index is valid and does not exist' do
+      before { ExampleIndex2.delete if ExampleIndex2.exists? }
+
+      it 'should create an index' do
+        expect(ExampleIndex2.exists?).to be false
+        ExampleIndex2.create
+        expect(ExampleIndex2.exists?).to be true
+      end
+
+      after do
+        ExampleIndex2.delete
+      end
+    end
+
+    context 'when index is not valid' do
+      before { allow(ExampleIndex2).to receive(:valid?).and_return(false) }
+
+      it 'raises an error' do
+        expect(ExampleIndex2.exists?).to be false
+        expect { ExampleIndex2.create }.to raise_error(
+          ElasticSearchFramework::Exceptions::IndexError,
+          '[Class] - Invalid Index description specified.'
+        )
+      end
+    end
+
+    context 'when index is valid but already exists' do
+      before { ExampleIndex2.delete if ExampleIndex2.exists? }
+
+      it 'does not try to create a new index' do
+        allow(ExampleIndex2).to receive(:exists?).and_return(true)
+        expect(ExampleIndex2).not_to receive(:put)
+        ExampleIndex2.create
+      end
+    end
+  end
+
+  describe '#delete' do
+    before do
+      unless ExampleIndex2.exists?
+        ExampleIndex2.create
+      end
+    end
+    it 'should create an index' do
+      expect(ExampleIndex2.exists?).to be true
+      ExampleIndex2.delete
+      expect(ExampleIndex2.exists?).to be false
+    end
+  end
+
+  describe '#exists?' do
+    context 'when an index exists' do
+      before do
+        ExampleIndex2.delete
+        ExampleIndex2.create
+      end
+      it 'should return true' do
+        expect(ExampleIndex2.exists?).to be true
+      end
+    end
+    context 'when an index exists' do
+      before do
+        ExampleIndex2.delete
+      end
+      it 'should return false' do
+        expect(ExampleIndex2.exists?).to be false
+      end
+    end
+  end
+
+  describe '#put' do
+    let(:payload) { {} }
+    context 'when there is a valid response' do
+      before { allow(ExampleIndex2).to receive(:is_valid_response?).and_return(true) }
+
+      it 'returns true' do
+        ExampleIndex2.create
+        expect(ExampleIndex2.put(payload: payload)).to eq true
+      end
+    end
+
+    context 'when there is not a valid response' do
+      before { allow(ExampleIndex2).to receive(:is_valid_response?).and_return(false) }
+
+      context 'when the error is "index_already_exists_exception"' do
+        let(:response_body) { { error: { root_cause: [{ type: 'index_already_exists_exception' }] } } }
+        let(:request) { double }
+
+        before { ExampleIndex2.delete if ExampleIndex2.exists? }
+        it 'returns true' do
+          allow(request).to receive(:body).and_return(response_body.to_json)
+          allow(request).to receive(:code).and_return(404)
+          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(request)
+          expect(ExampleIndex2.put(payload: payload)).to eq true
+        end
+      end
+
+      context 'when the error is not "index_already_exists_exception"' do
+        let(:response_body) { { error: { root_cause: [{ type: 'foo' }] } } }
+        let(:request) { double }
+        it 'raises an IndexError' do
+          allow(request).to receive(:body).and_return(response_body.to_json)
+          allow(request).to receive(:code).and_return(404)
+          allow_any_instance_of(Net::HTTP).to receive(:request).and_return(request)
+          expect { ExampleIndex2.put(payload: payload) }.to raise_error(
+            ElasticSearchFramework::Exceptions::IndexError
+          )
+        end
+      end
+    end
+  end
+
+  describe '#is_valid_response?' do
+    let(:code) { 200 }
+    context 'when a 200 response code is returned' do
+      it 'should return true' do
+        expect(ExampleIndex2.is_valid_response?(code)).to be true
+      end
+    end
+    context 'when a 201 response code is returned' do
+      let(:code) { 201 }
+      it 'should return true' do
+        expect(ExampleIndex2.is_valid_response?(code)).to be true
+      end
+    end
+    context 'when a 202 response code is returned' do
+      let(:code) { 202 }
+      it 'should return true' do
+        expect(ExampleIndex2.is_valid_response?(code)).to be true
+      end
+    end
+    context 'when a 400 response code is returned' do
+      let(:code) { 400 }
+      it 'should return false' do
+        expect(ExampleIndex2.is_valid_response?(code)).to be false
+      end
+    end
+    context 'when a 401 response code is returned' do
+      let(:code) { 401 }
+      it 'should return false' do
+        expect(ExampleIndex2.is_valid_response?(code)).to be false
+      end
+    end
+    context 'when a 500 response code is returned' do
+      let(:code) { 500 }
+      it 'should return false' do
+        expect(ExampleIndex2.is_valid_response?(code)).to be false
+      end
+    end
+  end
+
+  describe '#host' do
+    it 'should return the expected host based on default host & port values' do
+      expect(ExampleIndex2.host).to eq "#{ElasticSearchFramework.host}:#{ElasticSearchFramework.port}"
+    end
+  end
+
+  describe '#repository' do
+    it 'should return a ElasticSearchFramework::Repository instance' do
+      expect(ExampleIndex2.repository).to be_a(ElasticSearchFramework::Repository)
+    end
+    it 'should return the same ElasticSearchFramework::Repository instance for multiple calls' do
+      expect(ExampleIndex2.repository).to eq ExampleIndex2.repository
+    end
+  end
+
+  describe '#get_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    it 'should call get on the repository' do
+      expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:get).with(index: ExampleIndex2, id: id, type: type)
+      ExampleIndex2.get_item(id: id, type: type)
+    end
+  end
+
+  describe '#put_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    let(:item) do
+      TestItem.new.tap do |i|
+        i.id = id
+        i.name = 'abc'
+        i.timestamp = Time.now.to_i
+        i.number = 5
+      end
+    end
+
+    context 'without specifying op_type' do
+      it 'should call set on the repository with default op_type (index)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex2, op_type: 'index', type: type)
+        ExampleIndex2.put_item(type: type, item: item)
+      end
+    end
+
+    context 'with specified op_type' do
+      it 'should call set on the repository with supplied op_type (index)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex2, op_type: 'index', type: type)
+        ExampleIndex2.put_item(type: type, item: item, op_type: 'index')
+      end
+
+      it 'should call set on the repository with supplied op_type (create)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex2, op_type: 'create', type: type)
+        ExampleIndex2.put_item(type: type, item: item, op_type: 'create')
+      end
+    end
+
+    context 'without specifying routing_key' do
+      it 'should call set on the repository without routing_key' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex2, op_type: 'index', type: type)
+        ExampleIndex2.put_item(type: type, item: item, op_type: 'index')
+      end
+    end
+
+    context 'with specified routing_key' do
+      it 'should call set on the repository with routing_key' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex2, op_type: 'index', type: type, routing_key: 6)
+        ExampleIndex2.put_item(type: type, item: item, op_type: 'index', routing_key: 6)
+      end
+    end
+  end
+
+  describe '#delete_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    it 'should call drop on the repository' do
+      expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:drop).with(index: ExampleIndex2, id: id, type: type)
+      ExampleIndex2.delete_item(id: id, type: type)
+    end
+  end
+end

data/spec/example_index_2.rb

@@ -0,0 +1,35 @@
+class ExampleIndex2
+  extend ElasticSearchFramework::ShardedIndex
+
+  index name: 'example_index', version: 2
+
+  mapping name: 'default', field: :name, type: :keyword, index: true
+end
+
+class ExampleIndexWithId2
+  extend ElasticSearchFramework::ShardedIndex
+
+  index name: 'example_index', version: 2
+
+  id :number
+
+  mapping name: 'default', field: :name, type: :keyword, index: true
+end
+
+class ExampleIndexWithSettings2
+  extend ElasticSearchFramework::ShardedIndex
+
+  index name: 'example_index', version: 2
+
+  normalizer_value = { custom_normalizer: { type: 'custom', char_filter: [], filter: ['lowercase'] } }
+  analyzer_value = { custom_analyzer: { type: 'custom', tokenizer: 'standard', filter: %w(lowercase) } }
+
+  settings name: :number_of_shards, value: 1
+  settings name: :analysis, type: :normalizer, value: normalizer_value
+  settings name: :analysis, type: :analyzer, value: analyzer_value
+  mapping name: 'default', field: :name, type: :keyword, index: true
+end
+
+class InvalidExampleIndex2
+  extend ElasticSearchFramework::ShardedIndex
+end

data/spec/example_index_alias.rb

@@ -0,0 +1,17 @@
+class ExampleIndexAlias
+  extend ElasticSearchFramework::IndexAlias
+
+  index ExampleIndex, active: true
+  index ExampleIndex2, active: false
+
+  name :example
+end
+
+class InvalidIndexAlias
+  extend ElasticSearchFramework::IndexAlias
+
+  index ExampleIndex, active: false
+  index ExampleIndex2, active: false
+
+  name :example
+end

data/spec/example_index_alias_2.rb

@@ -0,0 +1,8 @@
+class ExampleIndexAlias2
+  extend ElasticSearchFramework::IndexAlias
+
+  index ExampleIndex, active: false
+  index ExampleIndex2, active: true
+
+  name :example
+end

data/spec/spec_helper.rb

@@ -9,6 +9,9 @@ end
 require 'elastic_search_framework'
 require_relative '../spec/test_item.rb'
 require_relative '../spec/example_index'
+require_relative '../spec/example_index_2'
+require_relative '../spec/example_index_alias'
+require_relative '../spec/example_index_alias_2'
 require 'pry'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastic_search_framework
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.4.0
 platform: ruby
 authors:
 - vaughanbrittonsage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-17 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,14 +119,21 @@ files:
 - lib/elastic_search_framework/exceptions.rb
 - lib/elastic_search_framework/exceptions/index_error.rb
 - lib/elastic_search_framework/index.rb
+- lib/elastic_search_framework/index_alias.rb
 - lib/elastic_search_framework/logger.rb
 - lib/elastic_search_framework/query.rb
 - lib/elastic_search_framework/repository.rb
+- lib/elastic_search_framework/sharded_index.rb
 - lib/elastic_search_framework/version.rb
+- spec/elastic_search_framework/index_alias_spec.rb
 - spec/elastic_search_framework/index_spec.rb
 - spec/elastic_search_framework/query_spec.rb
 - spec/elastic_search_framework/repository_spec.rb
+- spec/elastic_search_framework/sharded_index_spec.rb
 - spec/example_index.rb
+- spec/example_index_2.rb
+- spec/example_index_alias.rb
+- spec/example_index_alias_2.rb
 - spec/spec_helper.rb
 - spec/test_item.rb
 homepage: https://github.com/sage/elastic_search_framework
@@ -148,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A lightweight framework to for working with elastic search.