elasticsearch-extensions 0.0.20 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7be8d01471cedb9edc6fef26f2d4b8494e030afe
-  data.tar.gz: 3a34292423e4f6fe30578a4c8625799bfa3f8116
+  metadata.gz: 9d1007e770ea632d144aed7e8d7d74f8eb4e9527
+  data.tar.gz: 1a98abf5d303f796b5b96c40bd306085d4cde8e2
 SHA512:
-  metadata.gz: 8b783d84286a9a4282c74d8631de4f510fdfa2e393363139a878614f814f6409767b11c0c13aba18935a51442b6003dc67eaff65cf5ccfd792b1d3d2ad7ad59a
-  data.tar.gz: c93fbdc4a33b389f4a9083a0366907fd66c5feae7dd85cf2ed97a1bc59db2fe754087bd474238786bb70b2025aac5f6a5b3a8935abdd63200d315098c696c3e8
+  metadata.gz: cbbf6b9033cee7d278c8ef22df5996b6503e485c6fd493620967c0a8c4b2d1fc8acca3b54331f165167435716e4f445c51ea435e4cd7e51370dbc990f4c86fcd
+  data.tar.gz: aa3855bede2446ac3784afa8d9080beb19370cdba44e22899ecd439e83ac022ad2fc8de0bbdc0a2e0db907495ae8f9bc813f0c815617e62ab6c45cdfead731a3

data/README.md

@@ -23,6 +23,85 @@ or install it from a source code checkout:
 
 ## Extensions
 
+### Backup
+
+Backup Elasticsearch indices as flat JSON files on the disk via integration
+with the [_Backup_](http://backup.github.io/backup/v4/) gem.
+
+Use the Backup gem's DSL to configure the backup:
+
+    require 'elasticsearch/extensions/backup'
+
+    Model.new(:elasticsearch_backup, 'Elasticsearch') do
+
+      database Elasticsearch do |db|
+        db.url     = 'http://localhost:9200'
+        db.indices = 'test'
+      end
+
+      store_with Local do |local|
+        local.path = '/tmp/backups'
+      end
+
+      compress_with Gzip
+    end
+
+Perform the backup with the Backup gem's command line utility:
+
+    $ backup perform -t elasticsearch_backup
+
+See more information in the [`Backup::Database::Elasticsearch`](lib/extensions/backup.rb)
+class documentation.
+
+### Reindex
+
+Copy documents from one index and cluster into another one, for example for purposes of changing
+the settings and mappings of the index.
+
+**NOTE:** Elasticsearch natively supports re-indexing since version 2.3. This extension is useful
+          when you need the feature on older versions.
+
+When the extension is loaded together with the
+[Ruby client for Elasticsearch](../elasticsearch/README.md),
+a `reindex` method is added to the client:
+
+    require 'elasticsearch'
+    require 'elasticsearch/extensions/reindex'
+
+    client = Elasticsearch::Client.new
+    target_client = Elasticsearch::Client.new url: 'http://localhost:9250', log: true
+
+    client.index index: 'test', type: 'd', body: { title: 'foo' }
+
+    client.reindex source: { index: 'test' },
+                   target: { index: 'test', client: target_client },
+                   transform: lambda { |doc| doc['_source']['title'].upcase! },
+                   refresh: true
+    # => { errors: 0 }
+
+    target_client.search index: 'test'
+    # => ... hits ... "title"=>"FOO"
+
+The method takes similar arguments as the core API
+[`reindex`](http://www.rubydoc.info/gems/elasticsearch-api/Elasticsearch/API/Actions#reindex-instance_method)
+method.
+
+You can also use the `Reindex` class directly:
+
+    require 'elasticsearch'
+    require 'elasticsearch/extensions/reindex'
+
+    client = Elasticsearch::Client.new
+
+    reindex = Elasticsearch::Extensions::Reindex.new \
+                source: { index: 'test', client: client },
+                target: { index: 'test-copy' }
+
+    reindex.perform
+
+See more information in the [`Elasticsearch::Extensions::Reindex::Reindex`](lib/extensions/reindex.rb)
+class documentation.
+
 ### ANSI
 
 Colorize and format selected  Elasticsearch response parts in terminal:

data/elasticsearch-extensions.gemspec

@@ -30,7 +30,12 @@ Gem::Specification.new do |s|
   end
 
   s.add_development_dependency "bundler", "> 1"
-  s.add_development_dependency "rake"
+
+  if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
+    s.add_development_dependency "rake", "~> 11.1"
+  else
+    s.add_development_dependency "rake", "< 11.0"
+  end
 
   s.add_development_dependency "awesome_print"
 

data/lib/elasticsearch/extensions.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'elasticsearch'
 require 'elasticsearch/extensions/version'
 

data/lib/elasticsearch/extensions/backup.rb

@@ -12,25 +12,25 @@ require 'patron'
 module Backup
   module Database
 
-    # Integration with the Backup gem [https://github.com/meskyanichi/backup/]
+    # Integration with the Backup gem [http://backup.github.io/backup/v4/]
     #
     # This extension allows to backup Elasticsearch indices as flat JSON files on the disk.
     #
-    # Use the Backup gem's DSL to configure the backup:
+    # @example Use the Backup gem's DSL to configure the backup
     #
     #     require 'elasticsearch/extensions/backup'
     #
     #     Model.new(:elasticsearch_backup, 'Elasticsearch') do
     #
     #       database Elasticsearch do |db|
-    #         # db.url     = 'http://localhost:9200'
-    #         # db.indices = 'articles,people'
-    #         # db.size    = 500
-    #         # db.scroll  = '10m'
+    #         db.url     = 'http://localhost:9200'
+    #         db.indices = 'articles,people'
+    #         db.size    = 500
+    #         db.scroll  = '10m'
     #       end
     #
     #       store_with Local do |local|
-    #         local.path = '/usr/local/var/backups'
+    #         local.path = '/tmp/backups'
     #         local.keep = 3
     #       end
     #
@@ -41,8 +41,33 @@ module Backup
     #
     #     $ backup perform -t elasticsearch_backup
     #
+    # The Backup gem can store your backup files on S3, Dropbox and other
+    # cloud providers, send notifications about the operation, and so on;
+    # read more in the gem documentation.
     #
-    # A simple recover script could look like this:
+    # @example Use the integration as a standalone script (eg. in a Rake task)
+    #
+    #     require 'backup'
+    #     require 'elasticsearch/extensions/backup'
+    #
+    #     Backup::Logger.configure do
+    #       logfile.enabled   = true
+    #       logfile.log_path  = '/tmp/backups/log'
+    #     end; Backup::Logger.start!
+    #
+    #     backup  = Backup::Model.new(:elasticsearch, 'Backup Elasticsearch') do
+    #       database Backup::Database::Elasticsearch do |db|
+    #         db.indices = 'test'
+    #       end
+    #
+    #       store_with Backup::Storage::Local do |local|
+    #         local.path = '/tmp/backups'
+    #       end
+    #     end
+    #
+    #     backup.perform!
+    #
+    # @example A simple recover script for the backup created in the previous examples
     #
     #     PATH = '/path/to/backup/'
     #
@@ -66,7 +91,7 @@ module Backup
     #       client.bulk body: payload
     #     end
     #
-    # @see http://meskyanichi.github.io/backup/v4/
+    # @see http://backup.github.io/backup/v4/
     #
     class Elasticsearch < Base
       class Error < ::Backup::Error; end

data/lib/elasticsearch/extensions/reindex.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+module Elasticsearch
+  module Extensions
+
+    # This module allows copying documents from one index/cluster to another one
+    #
+    # When required together with the client, it will add the `reindex` method
+    #
+    # @see Reindex::Reindex.initialize
+    # @see Reindex::Reindex#perform
+    #
+    # @see http://www.rubydoc.info/gems/elasticsearch-api/Elasticsearch/API/Actions#reindex-instance_method
+    #
+    module Reindex
+
+      # Initialize a new instance of the Reindex class (shortcut)
+      #
+      # @see Reindex::Reindex.initialize
+      #
+      def new(arguments={})
+        Reindex.new(arguments)
+      end; extend self
+
+      module API
+        # Copy documents from one index into another and refresh the target index
+        #
+        # @example
+        #     client.reindex source: { index: 'test1' }, target: { index: 'test2' }, refresh: true
+        #
+        # The method allows all the options as {Reindex::Reindex.new}.
+        #
+        # This method will be mixed into the Elasticsearch client's API, if available.
+        #
+        def reindex(arguments={})
+          arguments[:source] ||= {}
+          arguments[:source][:client] = self
+          Reindex.new(arguments).perform
+        end
+      end
+
+      # Include the `reindex` method in the API and client, if available
+      Elasticsearch::API::Actions.__send__ :include, API if defined?(Elasticsearch::API::Actions)
+      Elasticsearch::Transport::Client.__send__ :include, API if defined?(Elasticsearch::Transport::Client) && defined?(Elasticsearch::API)
+
+      # Copy documents from one index into another
+      #
+      # @example Copy documents to another index
+      #
+      #   client  = Elasticsearch::Client.new
+      #   reindex = Elasticsearch::Extensions::Reindex.new \
+      #               source: { index: 'test1', client: client },
+      #               target: { index: 'test2' }
+      #
+      #   reindex.perform
+      #
+      # @example Copy documents to a different cluster
+      #
+      #     source_client  = Elasticsearch::Client.new url: 'http://localhost:9200'
+      #     target_client  = Elasticsearch::Client.new url: 'http://localhost:9250'
+      #
+      #     reindex = Elasticsearch::Extensions::Reindex.new \
+      #                 source: { index: 'test', client: source_client },
+      #                 target: { index: 'test', client: target_client }
+      #     reindex.perform
+      #
+      # @example Transform the documents during re-indexing
+      #
+      #     reindex = Elasticsearch::Extensions::Reindex.new \
+      #                 source: { index: 'test1', client: client },
+      #                 target: { index: 'test2', transform: lambda { |doc| doc['_source']['category'].upcase! } }
+      #
+      #
+      # The reindexing process works by "scrolling" an index and sending
+      # batches via the "Bulk" API to the target index/cluster
+      #
+      # @option arguments [String] :source The source index/cluster definition (*Required*)
+      # @option arguments [String] :target The target index/cluster definition (*Required*)
+      # @option arguments [Proc] :transform A block which will be executed for each document
+      # @option arguments [Integer] :batch_size The size of the batch for scroll operation (Default: 1000)
+      # @option arguments [String] :scroll The timeout for the scroll operation (Default: 5min)
+      # @option arguments [Boolean] :refresh Whether to refresh the target index after
+      #                                      the operation is completed (Default: false)
+      #
+      # Be aware, that if you want to change the target index settings and/or mappings,
+      # you have to do so in advance by using the "Indices Create" API.
+      #
+      # Note, that there is a native "Reindex" API in Elasticsearch 2.3.x and higer versions,
+      # which will be more performant than the Ruby version.
+      #
+      # @see http://www.rubydoc.info/gems/elasticsearch-api/Elasticsearch/API/Actions#reindex-instance_method
+      #
+      class Reindex
+        attr_reader :arguments
+
+        def initialize(arguments={})
+          [
+            [:source, :index],
+            [:source, :client],
+            [:target, :index]
+          ].each do |required_option|
+            value = required_option.reduce(arguments) { |sum, o| sum = sum[o] ? sum[o] : {}  }
+
+            raise ArgumentError,
+                  "Required argument '#{Hash[*required_option]}' missing" if \
+                  value.respond_to?(:empty?) ? value.empty? : value.nil?
+          end
+
+          @arguments = {
+            batch_size: 1000,
+            scroll: '5m',
+            refresh: false
+          }.merge(arguments)
+
+          arguments[:target][:client] ||= arguments[:source][:client]
+        end
+
+        # Performs the operation
+        #
+        # @return [Hash] A Hash with the information about the operation outcome
+        #
+        def perform
+          output = { errors: 0 }
+
+          response = arguments[:source][:client].search(
+            index: arguments[:source][:index],
+            scroll: arguments[:scroll],
+            size: arguments[:batch_size],
+            search_type: 'scan',
+            fields: ['_source', '_parent', '_routing', '_timestamp']
+          )
+
+          while response = arguments[:source][:client].scroll(scroll_id: response['_scroll_id'], scroll: arguments[:scroll]) do
+            documents = response['hits']['hits']
+            break if documents.empty?
+
+            bulk = documents.map do |doc|
+              doc['_index'] = arguments[:target][:index]
+
+              arguments[:transform].call(doc) if arguments[:transform]
+
+              doc['data'] = doc['_source']
+              doc.delete('_score')
+              doc.delete('_source')
+
+              { index: doc }
+            end
+
+            bulk_response = arguments[:target][:client].bulk body: bulk
+            output[:errors] += bulk_response['items'].select { |k, v| k.values.first['error'] }.size
+          end
+
+          arguments[:target][:client].indices.refresh index: arguments[:target][:index] if arguments[:refresh]
+
+          output
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/extensions/test/cluster.rb

@@ -84,7 +84,7 @@ module Elasticsearch
           arguments[:node_name]         ||= ENV.fetch('TEST_CLUSTER_NODE_NAME', 'node')
           arguments[:path_data]         ||= ENV.fetch('TEST_CLUSTER_DATA',      '/tmp/elasticsearch_test')
           arguments[:path_work]         ||= ENV.fetch('TEST_CLUSTER_TMP',       '/tmp')
-          arguments[:path_logs]         ||= ENV.fetch('TEST_CLUSTER_LOGS',      '/var/log/elasticsearch')
+          arguments[:path_logs]         ||= ENV.fetch('TEST_CLUSTER_LOGS',      '/tmp/log/elasticsearch')
           arguments[:es_params]         ||= ENV.fetch('TEST_CLUSTER_PARAMS',    '')
           arguments[:multicast_enabled] ||= ENV.fetch('TEST_CLUSTER_MULTICAST', 'true')
           arguments[:timeout]           ||= (ENV.fetch('TEST_CLUSTER_TIMEOUT', 30).to_i)
@@ -218,16 +218,18 @@ module Elasticsearch
         #
         # @option arguments [Integer] :on The port on which the node is running.
         # @option arguments [String]  :as The cluster name.
+        # @option arguments [Integer] :num Number of nodes in the cluster.
         #
         # @return Boolean
         #
         def running?(arguments={})
-          port         = arguments[:on] || (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
-          cluster_name = arguments[:as] || (ENV.fetch('TEST_CLUSTER_NAME', @@default_cluster_name).chomp)
+          port            = arguments[:on] || (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+          cluster_name    = arguments[:as] || (ENV.fetch('TEST_CLUSTER_NAME', @@default_cluster_name).chomp)
+          number_of_nodes = arguments[:num] || (ENV.fetch('TEST_CLUSTER_NODES', @@number_of_nodes)).to_i
 
           if cluster_health = Timeout::timeout(0.25) { __get_cluster_health(port) } rescue nil
             return cluster_health['cluster_name']    == cluster_name && \
-                   cluster_health['number_of_nodes'] == @@number_of_nodes
+                   cluster_health['number_of_nodes'] == number_of_nodes
           end
           return false
         end

data/lib/elasticsearch/extensions/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Extensions
-    VERSION = "0.0.20"
+    VERSION = "0.0.21"
   end
 end

data/test/reindex/integration/reindex_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+require 'elasticsearch/extensions/reindex'
+
+class Elasticsearch::Extensions::ReindexIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+  context "The Reindex extension" do
+    setup do
+      @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+
+      @logger =  ::Logger.new(STDERR)
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        color = case severity
+          when /INFO/ then :green
+          when /ERROR|WARN|FATAL/ then :red
+          when /DEBUG/ then :cyan
+          else :white
+        end
+        ANSI.ansi(severity[0] + ' ', color, :faint) + ANSI.ansi(msg, :white, :faint) + "\n"
+      end
+
+      @client = Elasticsearch::Client.new host: "localhost:#{@port}", logger: @logger
+      @client.indices.delete index: '_all'
+
+      @client.index index: 'test1', type: 'd', id: 1, body: { title: 'TEST 1', category: 'one' }
+      @client.index index: 'test1', type: 'd', id: 2, body: { title: 'TEST 2', category: 'two' }
+      @client.index index: 'test1', type: 'd', id: 3, body: { title: 'TEST 3', category: 'three' }
+      @client.indices.refresh index: 'test1'
+
+      @client.cluster.health wait_for_status: 'yellow'
+    end
+
+    should "copy documents from one index to another" do
+      reindex = Elasticsearch::Extensions::Reindex.new \
+                  source: { index: 'test1', client: @client },
+                  target: { index: 'test2' },
+                  refresh: true
+
+      result = reindex.perform
+
+      assert_equal 0, result[:errors]
+      assert_equal 3, @client.search(index: 'test2')['hits']['total']
+    end
+
+    should "transform documents with a lambda" do
+      reindex = Elasticsearch::Extensions::Reindex.new \
+                  source: { index: 'test1', client: @client },
+                  target: { index: 'test2' },
+                  transform: lambda { |d| d['_source']['category'].upcase! },
+                  refresh: true
+
+      result = reindex.perform
+
+      assert_equal 0, result[:errors]
+      assert_equal 3, @client.search(index: 'test2')['hits']['total']
+      assert_equal 'ONE', @client.get(index: 'test2', type: 'd', id: 1)['_source']['category']
+    end
+
+    should "return the number of errors" do
+      @client.indices.create index: 'test3', body: { mappings: { d: { properties: { category: { type: 'integer' } }}}}
+      @client.cluster.health wait_for_status: 'yellow'
+
+      reindex = Elasticsearch::Extensions::Reindex.new \
+                  source: { index: 'test1', client: @client },
+                  target: { index: 'test3', transform: lambda { |d| d['_source']['category'].upcase!; d } },
+                  refresh: true
+
+      result = reindex.perform
+
+      assert_equal 3, result[:errors]
+      assert_equal 0, @client.search(index: 'test3')['hits']['total']
+    end
+
+    should "reindex via the API integration" do
+      @client.reindex source: { index: 'test1' }, target: { index: 'test4' }
+
+      @client.indices.refresh index: 'test4'
+
+      assert_equal 3, @client.search(index: 'test4')['hits']['total']
+    end
+  end
+
+end

data/test/reindex/unit/reindex_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+require 'elasticsearch/extensions/reindex'
+
+class Elasticsearch::Extensions::ReindexTest < Test::Unit::TestCase
+  context "The Reindex extension module" do
+    DEFAULT_OPTIONS = { source: { index: 'foo', client: Object.new }, target: { index: 'bar' } }
+
+    should "require options" do
+      assert_raise ArgumentError do
+        Elasticsearch::Extensions::Reindex.new
+      end
+    end
+
+    should "allow to initialize the class" do
+      assert_instance_of Elasticsearch::Extensions::Reindex::Reindex,
+                         Elasticsearch::Extensions::Reindex.new(DEFAULT_OPTIONS)
+    end
+
+    should "add the reindex to the API and client" do
+      assert_includes Elasticsearch::API::Actions.public_instance_methods.sort, :reindex
+      assert_respond_to Elasticsearch::Client.new, :reindex
+    end
+
+    should "pass the client when used in API mode" do
+      client = Elasticsearch::Client.new
+
+      Elasticsearch::Extensions::Reindex::Reindex
+        .expects(:new)
+        .with({source: { client: client }})
+        .returns(stub perform: {})
+
+      client.reindex
+    end
+
+    context "when performing the operation" do
+      setup do
+        d = { '_id' => 'foo', '_type' => 'type', '_source' => { 'foo' => 'bar' } }
+        @default_response = { 'hits' => { 'hits' => [d] } }
+        @empty_response   = { 'hits' => { 'hits' => [] } }
+        @bulk_request     = [{ index: {
+                                '_index' => 'bar',
+                                '_type'  => d['_type'],
+                                '_id'    => d['_id'],
+                                'data'   => d['_source']
+                               } }]
+        @bulk_response    = {'errors'=>false, 'items' => [{'index' => {}}]}
+        @bulk_response_error = {'errors'=>true, 'items' => [{'index' => {}},{'index' => {'error' => 'FOOBAR'}}]}
+      end
+
+      should "scroll through the index and save batches in bulk" do
+        client  = mock()
+        subject = Elasticsearch::Extensions::Reindex.new source: { index: 'foo', client: client },
+                                                         target: { index: 'bar' }
+
+        client.expects(:search).returns({ '_scroll_id' => 'scroll_id_1' })
+        client.expects(:scroll).returns(@default_response)
+              .then.returns(@empty_response)
+              .times(2)
+        client.expects(:bulk).with(body: @bulk_request).returns(@bulk_response)
+
+        result = subject.perform
+
+        assert_equal 0, result[:errors]
+      end
+
+      should "return the number of errors" do
+        client  = mock()
+        subject = Elasticsearch::Extensions::Reindex.new source: { index: 'foo', client: client },
+                                                         target: { index: 'bar' }
+
+        client.expects(:search).returns({ '_scroll_id' => 'scroll_id_1' })
+        client.expects(:scroll).returns(@default_response)
+              .then.returns(@empty_response)
+              .times(2)
+        client.expects(:bulk).with(body: @bulk_request).returns(@bulk_response_error)
+
+        result = subject.perform
+
+        assert_equal 1, result[:errors]
+      end
+
+      should "transform the documents with a lambda" do
+        client  = mock()
+        subject = Elasticsearch::Extensions::Reindex.new \
+          source: { index: 'foo', client: client },
+          target: { index: 'bar' },
+          transform: lambda { |d| d['_source']['foo'].upcase!; d }
+
+        client.expects(:search).returns({ '_scroll_id' => 'scroll_id_1' })
+        client.expects(:scroll).returns(@default_response)
+              .then.returns(@empty_response)
+              .times(2)
+        client.expects(:bulk).with do |arguments|
+                assert_equal 'BAR', arguments[:body][0][:index]['data']['foo']
+                true
+              end
+              .returns(@bulk_response)
+
+        result = subject.perform
+
+        assert_equal 0, result[:errors]
+      end
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -23,12 +23,24 @@ require 'shoulda-context'
 require 'mocha/setup'
 require 'ansi/code'
 require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || RUBY_1_8
+require 'logger'
 
 require 'elasticsearch/extensions'
+require 'elasticsearch/extensions/test/startup_shutdown'
+require 'elasticsearch/extensions/test/cluster'
 
 module Elasticsearch
   module Test
     class IntegrationTestCase < ::Test::Unit::TestCase
+      extend Elasticsearch::Extensions::Test::StartupShutdown
+
+      startup do
+        Elasticsearch::Extensions::Test::Cluster.start(nodes: 2) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
+      end
+
+      shutdown do
+        Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] and Elasticsearch::Extensions::Test::Cluster.running?
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.21
 platform: ruby
 authors:
 - Karel Minarik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-04 00:00:00.000000000 Z
+date: 2016-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ansi
@@ -70,16 +70,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.1'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
@@ -268,6 +268,7 @@ files:
 - lib/elasticsearch/extensions/ansi/helpers.rb
 - lib/elasticsearch/extensions/ansi/response.rb
 - lib/elasticsearch/extensions/backup.rb
+- lib/elasticsearch/extensions/reindex.rb
 - lib/elasticsearch/extensions/test/cluster.rb
 - lib/elasticsearch/extensions/test/cluster/tasks.rb
 - lib/elasticsearch/extensions/test/profiling.rb
@@ -275,6 +276,8 @@ files:
 - lib/elasticsearch/extensions/version.rb
 - test/ansi/unit/ansi_test.rb
 - test/backup/unit/backup_test.rb
+- test/reindex/integration/reindex_test.rb
+- test/reindex/unit/reindex_test.rb
 - test/test_helper.rb
 homepage: ''
 licenses:
@@ -303,5 +306,7 @@ summary: Extensions for the Elasticsearch Rubygem
 test_files:
 - test/ansi/unit/ansi_test.rb
 - test/backup/unit/backup_test.rb
+- test/reindex/integration/reindex_test.rb
+- test/reindex/unit/reindex_test.rb
 - test/test_helper.rb
 has_rdoc: