RubyGems - elasticsearch-extensions - Versions diffs - 0.0.21 → 0.0.22 - Mend

elasticsearch-extensions 0.0.21 → 0.0.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml +4 -4
data/Rakefile +1 -1
data/lib/elasticsearch/extensions/test/cluster.rb +492 -233
data/lib/elasticsearch/extensions/version.rb +1 -1
data/test/test/cluster/integration/cluster_test.rb +29 -0
data/test/test/cluster/unit/cluster_test.rb +280 -0
data/test/test_helper.rb +1 -1
metadata +6 -2

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d1007e770ea632d144aed7e8d7d74f8eb4e9527
-  data.tar.gz: 1a98abf5d303f796b5b96c40bd306085d4cde8e2
+  metadata.gz: 33490d5d862da6d64e26435f1a77291e2a0a82d5
+  data.tar.gz: 7b57c8185dde5a4278c142c1de61605e3107ff39
 SHA512:
-  metadata.gz: cbbf6b9033cee7d278c8ef22df5996b6503e485c6fd493620967c0a8c4b2d1fc8acca3b54331f165167435716e4f445c51ea435e4cd7e51370dbc990f4c86fcd
-  data.tar.gz: aa3855bede2446ac3784afa8d9080beb19370cdba44e22899ecd439e83ac022ad2fc8de0bbdc0a2e0db907495ae8f9bc813f0c815617e62ab6c45cdfead731a3
+  metadata.gz: 36cee1857c1fbea9d28821cb54d425df5a38f28c9d23a2a3ebd827ad29cb9f7ec004405e8b0e85176a199355ddb0ae9650980988b036f209581197f9af71d58a
+  data.tar.gz: 4a8a001059bd6982c26a21663fceb8298711cc0b73ddefd17e7be26aa97cf0e540ca7f2a5327a274f1d3c700662ecd89c58eaa8ed954eda62975ec6f97b0771c

data/Rakefile CHANGED

@@ -36,7 +36,7 @@ namespace :test do
   Rake::TestTask.new(:all) do |test|
     Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
-    test.test_files = FileList["test/**/unit/**/*_test.rb", "test/**/unit/**/*_test.rb"]
+    test.test_files = FileList["test/**/unit/**/*_test.rb", "test/**/integration/**/*_test.rb"]
   end
   Rake::TestTask.new(:profile) do |test|

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

@@ -21,110 +21,93 @@ module Elasticsearch
   module Extensions
     module Test
-      # A convenience Ruby class for starting and stopping a separate testing in-memory cluster,
-      # to not depend on -- and not mess up -- <localhost:9200>.
+      # A convenience Ruby class for starting and stopping an Elasticsearch cluster,
+      # eg. for integration tests
       #
       # @example Start a cluster with default configuration
       #      require 'elasticsearch/extensions/test/cluster'
-      #      Elasticsearch::Extensions::Test::Cluster.start
+      #      Elasticsearch::Extensions::Test::Cluster::Cluster.new.start
       #
-      # @see Cluster#start Cluster.start
-      # @see Cluster#stop Cluster.stop
+      # @see Cluster#initialize
       #
       module Cluster
-        @@network_host    = ENV.fetch('TEST_CLUSTER_NETWORK_HOST', 'localhost')
-        @@number_of_nodes = (ENV['TEST_CLUSTER_NODES'] || 2).to_i
-        @@default_cluster_name = "elasticsearch-test-#{Socket.gethostname.downcase}"
         # Starts a cluster
         #
-        # Launches the specified number of nodes in test-suitable configuration by default
-        # and prints information about the cluster -- unless this specific cluster is running already.
+        # @see Cluster#start
         #
-        # Use the {Cluster#stop Cluster.stop} command with the same arguments to stop this cluster.
-        #
-        # @option arguments [String]  :cluster_name Cluster name (default: `elasticsearch_test`)
-        # @option arguments [Integer] :nodes        Number of desired nodes (default: 2)
-        # @option arguments [String]  :command      Elasticsearch command (default: `elasticsearch`)
-        # @option arguments [String]  :port         Starting port number; will be auto-incremented (default: 9250)
-        # @option arguments [String]  :node_name    The node name (will be appended with a number)
-        # @option arguments [String]  :path_data    Path to the directory to store data in
-        # @option arguments [String]  :path_work    Path to the directory with auxiliary files
-        # @option arguments [String]  :path_logs    Path to the directory with log files
-        # @option arguments [Boolean] :multicast_enabled Whether multicast is enabled (default: true)
-        # @option arguments [Integer] :timeout      Timeout when starting the cluster (default: 30)
-        # @option arguments [String]  :network_host The host that nodes will bind on and publish to
-        # @option arguments [Boolean] :clear_cluster Wipe out cluster content on startup (default: true)
+        def start(arguments={})
+          Cluster.new(arguments).start
+        end
+        # Stops a cluster
         #
-        # You can also use environment variables to set these options.
+        # @see Cluster#stop
         #
-        # @example Start a cluster with default configuration (2 nodes, in-memory, etc)
-        #      Elasticsearch::Extensions::Test::Cluster.start
+        def stop(arguments={})
+          Cluster.new(arguments).stop
+        end
+        # Returns true when a specific test node is running within the cluster
         #
-        # @example Start a cluster with a custom configuration
-        #      Elasticsearch::Extensions::Test::Cluster.start \
-        #        cluster_name: 'my-cluster',
-        #        nodes: 3,
-        #        node_name: 'my-node',
-        #        port: 9350
+        # @see Cluster#running?
         #
-        # @example Start a cluster with a different Elasticsearch version
-        #      Elasticsearch::Extensions::Test::Cluster.start \
-        #        command: "/usr/local/Cellar/elasticsearch/1.0.0.Beta2/bin/elasticsearch"
+        def running?(arguments={})
+          Cluster.new(arguments).running?
+        end
+        # Waits until the cluster is green and prints information
         #
-        # @return Boolean
-        # @see Cluster#stop Cluster.stop
+        # @see Cluster#wait_for_green
         #
-        def start(arguments={})
-          @@number_of_nodes = ( ENV.fetch('TEST_CLUSTER_NODES', arguments[:nodes] || 2) ).to_i
-          arguments[:command]           ||= ENV.fetch('TEST_CLUSTER_COMMAND',   'elasticsearch')
-          arguments[:port]              ||= (ENV.fetch('TEST_CLUSTER_PORT',     9250).to_i)
-          arguments[:cluster_name]      ||= (ENV.fetch('TEST_CLUSTER_NAME',     @@default_cluster_name).chomp)
-          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',      '/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)
-          arguments[:network_host]      ||= @@network_host
-          clear_cluster = !!arguments[:clear_cluster] || (ENV.fetch('TEST_CLUSTER_CLEAR', 'true') != 'false')
-          # Make sure `cluster_name` is not dangerous
-          if arguments[:cluster_name] =~ /^[\/\\]?$/
-            raise ArgumentError, "The `cluster_name` parameter cannot be empty string or a slash"
-          end
-          if running? :on => arguments[:port], :as => arguments[:cluster_name]
-            print "[!] Elasticsearch cluster already running".ansi(:red)
-            wait_for_green(arguments[:port], arguments[:timeout])
-            return false
-          end
+        def wait_for_green(arguments={})
+          Cluster.new(arguments).wait_for_green
+        end
-          # Wipe out data on disk for this cluster name by default
-          FileUtils.rm_rf "#{arguments[:path_data]}/#{arguments[:cluster_name]}" if clear_cluster
+        module_function :start, :stop, :running?, :wait_for_green
-          print "Starting ".ansi(:faint) +
-                @@number_of_nodes.to_s.ansi(:bold, :faint) +
-                " Elasticsearch nodes..".ansi(:faint)
+        class Cluster
+          attr_reader :arguments
-          pids = []
+          COMMANDS = {
+            '0.90' => lambda { |arguments, node_number|
+              <<-COMMAND.gsub(/                /, '')
+                #{arguments[:command]} \
+                -f \
+                -D es.cluster.name=#{arguments[:cluster_name]} \
+                -D es.node.name=#{arguments[:node_name]}-#{node_number} \
+                -D es.http.port=#{arguments[:port].to_i + (node_number-1)} \
+                -D es.path.data=#{arguments[:path_data]} \
+                -D es.path.work=#{arguments[:path_work]} \
+                -D es.path.logs=#{arguments[:path_logs]} \
+                -D es.cluster.routing.allocation.disk.threshold_enabled=false \
+                -D es.network.host=#{arguments[:network_host]} \
+                -D es.discovery.zen.ping.multicast.enabled=#{arguments[:multicast_enabled]} \
+                -D es.script.inline=true \
+                -D es.script.indexed=true \
+                -D es.node.test=true \
+                -D es.node.testattr=test \
+                -D es.node.bench=true \
+                -D es.path.repo=/tmp \
+                -D es.repositories.url.allowed_urls=http://snapshot.test* \
+                -D es.logger.level=DEBUG \
+                #{arguments[:es_params]} \
+                > /dev/null
+              COMMAND
+              },
-          @@number_of_nodes.times do |n|
-            n += 1
-            command = <<-COMMAND
-              #{arguments[:command]} \
+            '1.0' => lambda { |arguments, node_number|
+              <<-COMMAND.gsub(/                /, '')
+                #{arguments[:command]} \
                 -D es.foreground=yes \
                 -D es.cluster.name=#{arguments[:cluster_name]} \
-                -D es.node.name=#{arguments[:node_name]}-#{n} \
-                -D es.http.port=#{arguments[:port].to_i + (n-1)} \
+                -D es.node.name=#{arguments[:node_name]}-#{node_number} \
+                -D es.http.port=#{arguments[:port].to_i + (node_number-1)} \
                 -D es.path.data=#{arguments[:path_data]} \
                 -D es.path.work=#{arguments[:path_work]} \
                 -D es.path.logs=#{arguments[:path_logs]} \
                 -D es.cluster.routing.allocation.disk.threshold_enabled=false \
-                -D es.network.host=#{@@network_host} \
+                -D es.network.host=#{arguments[:network_host]} \
                 -D es.discovery.zen.ping.multicast.enabled=#{arguments[:multicast_enabled]} \
                 -D es.script.inline=on \
                 -D es.script.indexed=on \
@@ -133,196 +116,472 @@ module Elasticsearch
                 -D es.node.bench=true \
                 -D es.path.repo=/tmp \
                 -D es.repositories.url.allowed_urls=http://snapshot.test* \
-                -D es.logger.level=DEBUG \
+                -D es.logger.level=#{ENV['DEBUG'] ? 'DEBUG' : 'INFO'} \
                 #{arguments[:es_params]} \
                 > /dev/null
-            COMMAND
-            STDERR.puts command.gsub(/ {1,}/, ' ') if ENV['DEBUG']
+              COMMAND
+              },
-            pid = Process.spawn(command)
-            Process.detach pid
-            pids << pid
+            '2.0' => lambda { |arguments, node_number|
+              <<-COMMAND.gsub(/                /, '')
+                #{arguments[:command]} \
+                -D es.foreground=yes \
+                -D es.cluster.name=#{arguments[:cluster_name]} \
+                -D es.node.name=#{arguments[:node_name]}-#{node_number} \
+                -D es.http.port=#{arguments[:port].to_i + (node_number-1)} \
+                -D es.path.data=#{arguments[:path_data]} \
+                -D es.path.work=#{arguments[:path_work]} \
+                -D es.path.logs=#{arguments[:path_logs]} \
+                -D es.cluster.routing.allocation.disk.threshold_enabled=false \
+                -D es.network.host=#{arguments[:network_host]} \
+                -D es.script.inline=true \
+                -D es.script.stored=true \
+                -D es.node.attr.testattr=test \
+                -D es.path.repo=/tmp \
+                -D es.repositories.url.allowed_urls=http://snapshot.test* \
+                -D es.logger.level=DEBUG \
+                #{arguments[:es_params]} \
+                > /dev/null
+              COMMAND
+              },
+            '5.0' => lambda { |arguments, node_number|
+              <<-COMMAND.gsub(/                /, '')
+                #{arguments[:command]} \
+                -E cluster.name=#{arguments[:cluster_name]} \
+                -E node.name=#{arguments[:node_name]}-#{node_number} \
+                -E http.port=#{arguments[:port].to_i + (node_number-1)} \
+                -E path.data=#{arguments[:path_data]} \
+                -E path.logs=#{arguments[:path_logs]} \
+                -E cluster.routing.allocation.disk.threshold_enabled=false \
+                -E network.host=#{arguments[:network_host]} \
+                -E script.inline=true \
+                -E script.stored=true \
+                -E node.attr.testattr=test \
+                -E path.repo=/tmp \
+                -E repositories.url.allowed_urls=http://snapshot.test* \
+                -E discovery.zen.minimum_master_nodes=#{arguments[:number_of_nodes]-1} \
+                -E logger.level=DEBUG \
+                #{arguments[:es_params]} \
+                > /dev/null
+              COMMAND
+            }
+          }
+          # Create a new instance of the Cluster class
+          #
+          # @option arguments [String]  :cluster_name Cluster name (default: `elasticsearch_test`)
+          # @option arguments [Integer] :nodes        Number of desired nodes (default: 2)
+          # @option arguments [String]  :command      Elasticsearch command (default: `elasticsearch`)
+          # @option arguments [String]  :port         Starting port number; will be auto-incremented (default: 9250)
+          # @option arguments [String]  :node_name    The node name (will be appended with a number)
+          # @option arguments [String]  :path_data    Path to the directory to store data in
+          # @option arguments [String]  :path_work    Path to the directory with auxiliary files
+          # @option arguments [String]  :path_logs    Path to the directory with log files
+          # @option arguments [Boolean] :multicast_enabled Whether multicast is enabled (default: true)
+          # @option arguments [Integer] :timeout      Timeout when starting the cluster (default: 30)
+          # @option arguments [String]  :network_host The host that nodes will bind on and publish to
+          # @option arguments [Boolean] :clear_cluster Wipe out cluster content on startup (default: true)
+          #
+          # You can also use environment variables to set the constructor options (see source).
+          #
+          # @see Cluster#start
+          #
+          def initialize(arguments={})
+            @arguments = arguments
+            @arguments[:command]           ||= ENV.fetch('TEST_CLUSTER_COMMAND',   'elasticsearch')
+            @arguments[:port]              ||= ENV.fetch('TEST_CLUSTER_PORT',      9250).to_i
+            @arguments[:cluster_name]      ||= ENV.fetch('TEST_CLUSTER_NAME',      __default_cluster_name).chomp
+            @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',      '/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
+            @arguments[:number_of_nodes]   ||= ENV.fetch('TEST_CLUSTER_NODES',     2).to_i
+            @arguments[:network_host]      ||= ENV.fetch('TEST_CLUSTER_NETWORK_HOST', __default_network_host)
+            @clear_cluster = !!@arguments[:clear_cluster] || (ENV.fetch('TEST_CLUSTER_CLEAR', 'true') != 'false')
+            # Make sure `cluster_name` is not dangerous
+            raise ArgumentError, "The `cluster_name` argument cannot be empty string or a slash" \
+              if @arguments[:cluster_name] =~ /^[\/\\]?$/
           end
-          # Check for proceses running
-          if `ps -p #{pids.join(' ')}`.split("\n").size < @@number_of_nodes+1
-            STDERR.puts "", "[!!!] Process failed to start (see output above)".ansi(:red)
-            exit(1)
-          end
+          # Starts a cluster
+          #
+          # Launches the specified number of nodes in a test-suitable configuration and prints
+          # information about the cluster -- unless this specific cluster is already running.
+          #
+          # @example Start a cluster with the default configuration (2 nodes, installed version, etc)
+          #      Elasticsearch::Extensions::Test::Cluster::Cluster.new.start
+          #
+          # @example Start a cluster with a custom configuration
+          #      Elasticsearch::Extensions::Test::Cluster::Cluster.new(
+          #        cluster_name: 'my-cluster',
+          #        nodes: 3,
+          #        node_name: 'my-node',
+          #        port: 9350
+          #      ).start
+          #
+          # @example Start a cluster with a different Elasticsearch version
+          #      Elasticsearch::Extensions::Test::Cluster::Cluster.new(
+          #        command: "/usr/local/Cellar/elasticsearch/1.0.0.Beta2/bin/elasticsearch"
+          #      ).start
+          #
+          # @return Boolean,Array
+          # @see Cluster#stop
+          #
+          def start
+            if self.running?
+              STDOUT.print "[!] Elasticsearch cluster already running".ansi(:red)
+              return false
+            end
-          wait_for_green(arguments[:port], arguments[:timeout])
-          return true
-        end
+            __remove_cluster_data
-        # Stop the cluster.
-        #
-        # Fetches the PID numbers from "Nodes Info" API and terminates matching nodes.
-        #
-        # @example Stop the default cluster
-        #      Elasticsearch::Extensions::Test::Cluster.stop
-        #
-        # @example Stop the cluster reachable on specific port
-        #      Elasticsearch::Extensions::Test::Cluster.stop port: 9350
-        #
-        # @return Boolean
-        # @see Cluster#start Cluster.start
-        #
-        def stop(arguments={})
-          arguments[:port] ||= (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
-          arguments[:network_host] ||= ENV.fetch('TEST_CLUSTER_NETWORK_HOST', @@network_host)
-          nodes = begin
-            JSON.parse(Net::HTTP.get(URI("http://#{arguments[:network_host]}:#{arguments[:port]}/_nodes/?process")))
-          rescue Exception => e
-            STDERR.puts "[!] Exception raised when stopping the cluster: #{e.inspect}".ansi(:red)
-            nil
-          end
+            STDOUT.print "Starting ".ansi(:faint) + arguments[:number_of_nodes].to_s.ansi(:bold, :faint) +
+                         " Elasticsearch nodes..".ansi(:faint)
+            pids = []
-          return false if nodes.nil? or nodes.empty?
+            STDERR.puts "Using Elasticsearch version [#{version}]" if ENV['DEBUG']
-          pids  = nodes['nodes'].map { |id, info| info['process']['id'] }
+            arguments[:number_of_nodes].times do |n|
+              n += 1
+              command =  __command(version, arguments, n)
+              STDERR.puts command.gsub(/ {1,}/, ' ') if ENV['DEBUG']
-          unless pids.empty?
-            print "\nStopping Elasticsearch nodes... ".ansi(:faint)
-            pids.each_with_index do |pid, i|
-              ['INT','KILL'].each do |signal|
-                begin
-                  Process.kill signal, pid
-                rescue Exception => e
-                  print "[#{e.class}] PID #{pid} not found. ".ansi(:red)
-                end
+              pid = Process.spawn(command)
+              Process.detach pid
+              pids << pid
+            end
-                # Give the system some breathing space to finish...
-                sleep 1
+            __check_for_running_processes(pids)
+            wait_for_green
+            __print_cluster_info
+            return true
+          end
-                # Check that pid really is dead
-                begin
-                  Process.getpgid( pid )
-                  # `getpgid` will raise error if pid is dead, so if we get here, try next signal.
-                  next
-                rescue Errno::ESRCH
-                  print "stopped PID #{pid} with #{signal} signal. ".ansi(:green)
-                  break # pid is dead
+          # Stops the cluster
+          #
+          # Fetches the PID numbers from "Nodes Info" API and terminates matching nodes.
+          #
+          # @example Stop the default cluster
+          #      Elasticsearch::Extensions::Test::Cluster::Cluster.new.stop
+          #
+          # @example Stop the cluster reachable on specific port
+          #      Elasticsearch::Extensions::Test::Cluster::Cluster.new(port: 9350).stop
+          #
+          # @return Boolean,Array
+          # @see Cluster#start
+          #
+          def stop
+            begin
+              nodes = __get_nodes
+            rescue Exception => e
+              STDERR.puts "[!] Exception raised when stopping the cluster: #{e.inspect}".ansi(:red)
+              nil
+            end
+            return false if nodes.nil? or nodes.empty?
+            pids  = nodes['nodes'].map { |id, info| info['process']['id'] }
+            unless pids.empty?
+              STDOUT.print "\nStopping Elasticsearch nodes... ".ansi(:faint)
+              pids.each_with_index do |pid, i|
+                ['INT','KILL'].each do |signal|
+                  begin
+                    Process.kill signal, pid
+                  rescue Exception => e
+                    STDOUT.print "[#{e.class}] PID #{pid} not found. ".ansi(:red)
+                  end
+                  # Give the system some breathing space to finish...
+                  Kernel.sleep 1
+                  # Check that pid really is dead
+                  begin
+                    Process.getpgid pid
+                    # `getpgid` will raise error if pid is dead, so if we get here, try next signal
+                    next
+                  rescue Errno::ESRCH
+                    STDOUT.print "Stopped PID #{pid}".ansi(:green) +
+                    (ENV['DEBUG'] ? " with #{signal} signal".ansi(:green) : '') +
+                    ". ".ansi(:green)
+                    break # pid is dead
+                  end
                 end
               end
+              STDOUT.puts
+            else
+              return false
             end
-            puts
-          else
-            false
+            return pids
           end
-          return pids
-        end
+          # Returns true when a specific test node is running within the cluster
+          #
+          # @return Boolean
+          #
+          def running?
+            if cluster_health = Timeout::timeout(0.25) { __get_cluster_health } rescue nil
+              return cluster_health['cluster_name']    == arguments[:cluster_name] && \
+                     cluster_health['number_of_nodes'] == arguments[:number_of_nodes]
+            end
+            return false
+          end
-        # Returns true when a specific test node is running within the cluster.
-        #
-        # @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)
-          number_of_nodes = arguments[:num] || (ENV.fetch('TEST_CLUSTER_NODES', @@number_of_nodes)).to_i
+          # Waits until the cluster is green and prints information about it
+          #
+          # @return Boolean
+          #
+          def wait_for_green
+            __wait_for_status('green', 60)
+          end
-          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
+          # Returns the major version of Elasticsearch
+          #
+          # @return String
+          # @see __determine_version
+          #
+          def version
+            @version ||= __determine_version
           end
-          return false
-        end
-        # Waits until the cluster is green and prints information
-        #
-        # @example Print the information about the default cluster
-        #     Elasticsearch::Extensions::Test::Cluster.wait_for_green
-        #
-        # @param (see #__wait_for_status)
-        #
-        # @return Boolean
-        #
-        def wait_for_green(port=9250, timeout=60)
-          __wait_for_status('green', port, timeout)
-        end
-        # Blocks the process and waits for the cluster to be in a "green" state.
-        #
-        # Prints information about the cluster on STDOUT if the cluster is available.
-        #
-        # @param status  [String]  The status to wait for (yellow, green)
-        # @param port    [Integer] The port on which the cluster is reachable
-        # @param timeout [Integer] The explicit timeout for the operation
-        #
-        # @api private
-        #
-        # @return Boolean
-        #
-        def __wait_for_status(status='green', port=9250, timeout=30)
-          uri = URI("http://#{@@network_host}:#{port}/_cluster/health?wait_for_status=#{status}")
-          Timeout::timeout(timeout) do
-            loop do
-              response = begin
-                JSON.parse(Net::HTTP.get(uri))
-              rescue Exception => e
-                STDERR.puts e.inspect if ENV['DEBUG']
-                nil
+          # Returns default `:network_host` setting based on the version
+          #
+          # @api private
+          #
+          # @return String
+          #
+          def __default_network_host
+            case version
+              when /^0|^1/
+                '0.0.0.0'
+              when /^2/
+                '0.0.0.0'
+              when /^5/
+                '_local_'
+              else
+                raise RuntimeError, "Cannot determine default network host from version [#{version}]"
+            end
+          end
+          # Returns a reasonably unique cluster name
+          #
+          # @api private
+          #
+          # @return String
+          #
+          def __default_cluster_name
+            "elasticsearch-test-#{Socket.gethostname.downcase}"
+          end
+          # Returns the HTTP URL for the cluster based on `:network_host` setting
+          #
+          # @api private
+          #
+          # @return String
+          #
+          def __cluster_url
+            if '_local_' == arguments[:network_host]
+              "http://localhost:#{arguments[:port]}"
+            else
+              "http://#{arguments[:network_host]}:#{arguments[:port]}"
+            end
+          end
+          # Determine Elasticsearch version to be launched
+          #
+          # Tries to parse the version number from the `lib/elasticsearch-X.Y.Z.jar` file,
+          # it not available, uses `elasticsearch --version` or `elasticsearch -v`
+          #
+          # @api private
+          #
+          # @return String
+          #
+          def __determine_version
+            path_to_lib = File.dirname(arguments[:command]) + '/../lib/'
+            jar = Dir.entries(path_to_lib).select { |f| f.start_with? 'elasticsearch' }.first if File.exist? path_to_lib
+            version = if jar
+              if m = jar.match(/elasticsearch\-(\d+\.\d+.\d+).*/)
+                m[1]
+              else
+                raise RuntimeError, "Cannot determine Elasticsearch version from jar [#{jar}]"
+              end
+            else
+              STDERR.puts "[!] Cannot find Elasticsearch .jar from path to command [#{arguments[:command]}], using `elasticsearch --version`" if ENV['DEBUG']
+              output = ''
+              begin
+                # First, try the new `--version` syntax...
+                STDERR.puts "Running [#{arguments[:command]} --version] to determine version" if ENV['DEBUG']
+                Timeout::timeout(10) { output = `#{arguments[:command]} --version` }
+              rescue Timeout::Error
+                # ...else, the new `-v` syntax
+                STDERR.puts "Running [#{arguments[:command]} -v] to determine version" if ENV['DEBUG']
+                output = `#{arguments[:command]} -v`
+              end
+              STDERR.puts "> #{output}" if ENV['DEBUG']
+              if output.empty?
+                raise RuntimeError, "Cannot determine Elasticsearch version from [#{arguments[:command]} --version] or [#{arguments[:command]} -v]"
+              end
+              if m = output.match(/Version: (\d\.\d.\d).*,/)
+                m[1]
+              else
+                raise RuntimeError, "Cannot determine Elasticsearch version from elasticsearch --version output [#{output}]"
               end
+            end
+            case version
+              when /^0\.90.*/
+                '0.90'
+              when /^1\..*/
+                '1.0'
+              when /^2\..*/
+                '2.0'
+              when /^5\..*/
+                '5.0'
+              else
+                raise RuntimeError, "Cannot determine major version from [#{version}]"
+            end
+          end
-              STDERR.puts response.inspect if response && ENV['DEBUG']
+          # Returns the launch command for a specific version
+          #
+          # @api private
+          #
+          # @return String
+          #
+          def __command(version, arguments, node_number)
+            if command = COMMANDS[version]
+              command.call(arguments, node_number)
+            else
+              raise ArgumentError, "Cannot find command for version [#{version}]"
+            end
+          end
+          # Blocks the process and waits for the cluster to be in a "green" state
+          #
+          # Prints information about the cluster on STDOUT if the cluster is available.
+          #
+          # @param status  [String]  The status to wait for (yellow, green)
+          # @param timeout [Integer] The explicit timeout for the operation
+          #
+          # @api private
+          #
+          # @return Boolean
+          #
+          def __wait_for_status(status='green', timeout=30)
+            Timeout::timeout(timeout) do
+              loop do
+                response = __get_cluster_health(status)
+                if response && response['status'] == status && ( arguments[:number_of_nodes].nil? || arguments[:number_of_nodes].to_i == response['number_of_nodes'].to_i  )
+                  break
+                end
-              if response && response['status'] == status && ( @@number_of_nodes.nil? || @@number_of_nodes == response['number_of_nodes'].to_i  )
-                __print_cluster_info(port) and break
+                STDOUT.print '.'.ansi(:faint)
+                sleep 1
               end
+            end
+            return true
+          end
-              print '.'.ansi(:faint)
-              sleep 1
+          # Print information about the cluster on STDOUT
+          #
+          # @api private
+          #
+          # @return Nil
+          #
+          def __print_cluster_info
+            health = JSON.parse(Net::HTTP.get(URI("#{__cluster_url}/_cluster/health")))
+            nodes  = if version == '0.90'
+              JSON.parse(Net::HTTP.get(URI("#{__cluster_url}/_nodes/?process&http")))
+            else
+              JSON.parse(Net::HTTP.get(URI("#{__cluster_url}/_nodes/process,http")))
+            end
+            master = JSON.parse(Net::HTTP.get(URI("#{__cluster_url}/_cluster/state")))['master_node']
+            puts "\n",
+                  ('-'*80).ansi(:faint),
+                 'Cluster: '.ljust(20).ansi(:faint) + health['cluster_name'].to_s.ansi(:faint),
+                 'Status:  '.ljust(20).ansi(:faint) + health['status'].to_s.ansi(:faint),
+                 'Nodes:   '.ljust(20).ansi(:faint) + health['number_of_nodes'].to_s.ansi(:faint)
+            nodes['nodes'].each do |id, info|
+              m = id == master ? '*' : '+'
+              puts ''.ljust(20) +
+                   "#{m} ".ansi(:faint) +
+                   "#{info['name'].ansi(:bold)} ".ansi(:faint) +
+                   "| version: #{info['version'] rescue 'N/A'}, ".ansi(:faint) +
+                   "pid: #{info['process']['id'] rescue 'N/A'}, ".ansi(:faint) +
+                   "address: #{info['http']['bound_address'] rescue 'N/A'}".ansi(:faint)
             end
           end
-          return true
-        end
+          # Tries to load cluster health information
+          #
+          # @api private
+          #
+          # @return Hash,Nil
+          #
+          def __get_cluster_health(status=nil)
+            uri = URI("#{__cluster_url}/_cluster/health")
+            uri.query = "wait_for_status=#{status}" if status
+            begin
+              response = Net::HTTP.get(uri)
+            rescue Exception => e
+              STDERR.puts e.inspect if ENV['DEBUG']
+              return nil
+            end
-        # Print information about the cluster on STDOUT
-        #
-        # @api private
-        #
-        def __print_cluster_info(port)
-          health = JSON.parse(Net::HTTP.get(URI("http://#{@@network_host}:#{port}/_cluster/health")))
-          nodes  = JSON.parse(Net::HTTP.get(URI("http://#{@@network_host}:#{port}/_nodes/process,http")))
-          master = JSON.parse(Net::HTTP.get(URI("http://#{@@network_host}:#{port}/_cluster/state")))['master_node']
-          puts "\n",
-                ('-'*80).ansi(:faint),
-               'Cluster: '.ljust(20).ansi(:faint) + health['cluster_name'].to_s.ansi(:faint),
-               'Status:  '.ljust(20).ansi(:faint) + health['status'].to_s.ansi(:faint),
-               'Nodes:   '.ljust(20).ansi(:faint) + health['number_of_nodes'].to_s.ansi(:faint)
-          nodes['nodes'].each do |id, info|
-            m = id == master ? '*' : '+'
-            puts ''.ljust(20) +
-                 "#{m} ".ansi(:faint) +
-                 "#{info['name'].ansi(:bold)} ".ansi(:faint) +
-                 "| version: #{info['version'] rescue 'N/A'}, ".ansi(:faint) +
-                 "pid: #{info['process']['id'] rescue 'N/A'}, ".ansi(:faint) +
-                 "address: #{info['http']['bound_address'] rescue 'N/A'}".ansi(:faint)
+            JSON.parse(response)
           end
-        end
-        # Tries to load cluster health information
-        #
-        # @api private
-        #
-        def __get_cluster_health(port=9250)
-          uri = URI("http://#{@@network_host}:#{port}/_cluster/health")
-          if response = Net::HTTP.get(uri) rescue nil
-            return JSON.parse(response)
+          # Remove the data directory (unless it has been disabled by arguments)
+          #
+          # @api private
+          #
+          def __remove_cluster_data
+            # Wipe out data on disk for this cluster name by default
+            FileUtils.rm_rf "#{arguments[:path_data]}/#{arguments[:cluster_name]}" if @clear_cluster
           end
-        end
-        extend self
+          # Check whether process for PIDs are running
+          #
+          # @api private
+          #
+          def __check_for_running_processes(pids)
+            if `ps -p #{pids.join(' ')}`.split("\n").size < arguments[:number_of_nodes]+1
+              STDERR.puts "", "[!!!] Process failed to start (see output above)".ansi(:red)
+              exit(1)
+            end
+          end
+          # Get the information about nodes
+          #
+          # @api private
+          #
+          def __get_nodes
+            JSON.parse(Net::HTTP.get(URI("#{__cluster_url}/_nodes/process")))
+          end
+        end
       end
     end
   end

data/lib/elasticsearch/extensions/version.rb CHANGED

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

data/test/test/cluster/integration/cluster_test.rb ADDED

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'pathname'
+require 'elasticsearch/extensions/test/cluster'
+class Elasticsearch::Extensions::TestClusterIntegrationTest < Test::Unit::TestCase
+  context "The Test::Cluster" do
+    PATH_TO_BUILDS = Pathname(File.expand_path('../../../../../../tmp/builds', __FILE__))
+    unless PATH_TO_BUILDS.exist?
+      puts "Path to builds doesn't exist, skipping TestClusterIntegrationTest"
+      exit(0)
+    end
+    @builds = begin
+      PATH_TO_BUILDS.entries.reject { |f| f.to_s =~ /^\./ }
+    rescue Errno::ENOENT
+      []
+    end
+    @builds.each do |build|
+      should "start and stop #{build.to_s}" do
+        puts ("----- #{build.to_s} " + "-"*(80-7-build.to_s.size)).to_s.ansi(:bold)
+        Elasticsearch::Extensions::Test::Cluster.start command: PATH_TO_BUILDS.join(build.join('bin/elasticsearch')).to_s
+        Elasticsearch::Extensions::Test::Cluster.stop command: PATH_TO_BUILDS.join(build.join('bin/elasticsearch')).to_s
+      end
+    end
+  end
+end

data/test/test/cluster/unit/cluster_test.rb ADDED

@@ -0,0 +1,280 @@
+require 'test_helper'
+require 'elasticsearch/extensions/test/cluster'
+class Elasticsearch::Extensions::TestClusterTest < Test::Unit::TestCase
+  include Elasticsearch::Extensions::Test
+  context "The Test::Cluster" do
+    context "module" do
+      should "delegate the methods to the class" do
+        Cluster::Cluster
+          .expects(:new)
+          .with({foo: 'bar'})
+          .returns(mock start: true, stop: true, running?: true, wait_for_green: true)
+          .times(4)
+        Elasticsearch::Extensions::Test::Cluster.start foo: 'bar'
+        Elasticsearch::Extensions::Test::Cluster.stop foo: 'bar'
+        Elasticsearch::Extensions::Test::Cluster.running? foo: 'bar'
+        Elasticsearch::Extensions::Test::Cluster.wait_for_green foo: 'bar'
+      end
+    end
+    context "class" do
+      setup do
+        Elasticsearch::Extensions::Test::Cluster::Cluster.any_instance.stubs(:__default_network_host).returns('_local_')
+        @subject = Elasticsearch::Extensions::Test::Cluster::Cluster.new
+        @subject.stubs(:__remove_cluster_data).returns(true)
+      end
+      teardown do
+        ENV.delete('TEST_CLUSTER_PORT')
+      end
+      should "be initialized with parameters" do
+        c = Cluster::Cluster.new port: 9400
+        assert_equal 9400, c.arguments[:port]
+      end
+      should "take parameters from environment variables" do
+        ENV['TEST_CLUSTER_PORT'] = '9400'
+        c = Cluster::Cluster.new
+        assert_equal 9400, c.arguments[:port]
+      end
+      should "raise exception for dangerous cluster name" do
+        assert_raise(ArgumentError) { Cluster::Cluster.new cluster_name: '' }
+        assert_raise(ArgumentError) { Cluster::Cluster.new cluster_name: '/' }
+      end
+      should "have a version" do
+        @subject.unstub(:version)
+        @subject.expects(:__determine_version).returns('2.0')
+        assert_equal '2.0', @subject.version
+      end
+      should "have a default network host" do
+        Cluster::Cluster.any_instance.unstub(:__default_network_host)
+        Cluster::Cluster.any_instance.stubs(:version).returns('5.0')
+        assert_equal '_local_', Cluster::Cluster.new.__default_network_host
+      end
+      should "have a default cluster name" do
+        Socket.stubs(:gethostname).returns('FOOBAR')
+        assert_equal 'elasticsearch-test-foobar', Cluster::Cluster.new.__default_cluster_name
+      end
+      should "have a cluster URL for new versions" do
+        assert_equal  'http://localhost:9250', Cluster::Cluster.new(network_host: '_local_').__cluster_url
+      end
+      should "have a cluster URL for old versions" do
+        assert_equal  'http://192.168.1.1:9250', Cluster::Cluster.new(network_host: '192.168.1.1').__cluster_url
+      end
+      should "return corresponding command to a version" do
+        assert_match /\-D es\.foreground=yes/, @subject.__command('2.0', @subject.arguments, 1)
+      end
+      should "raise an error when a corresponding command cannot be found" do
+        assert_raise ArgumentError do
+          @subject.__command('FOOBAR', @subject.arguments, 1)
+        end
+      end
+      context "when starting a cluster, " do
+        should "return false when it's already running" do
+          Process.expects(:spawn).never
+          c = Cluster::Cluster.new
+          c.expects(:running?).returns(true)
+          assert_equal false, c.start
+        end
+        should "start the specified number of nodes" do
+          Process.expects(:spawn).times(3)
+          Process.expects(:detach).times(3)
+          c = Cluster::Cluster.new number_of_nodes: 3
+          c.expects(:running?).returns(false)
+          c.unstub(:__remove_cluster_data)
+          c.expects(:__remove_cluster_data).returns(true)
+          c.expects(:wait_for_green).returns(true)
+          c.expects(:__check_for_running_processes).returns(true)
+          c.expects(:__determine_version).returns('5.0')
+          c.expects(:__print_cluster_info).returns(true)
+          assert_equal true, c.start
+        end
+      end
+      context "when stopping a cluster" do
+        setup do
+          @subject = Elasticsearch::Extensions::Test::Cluster::Cluster.new
+        end
+        should "print information about an exception" do
+          @subject.expects(:__get_nodes).raises(Errno::ECONNREFUSED)
+          assert_nothing_raised do
+            assert_equal false, @subject.stop
+          end
+        end
+        should "return false when the nodes are empty" do
+          @subject.expects(:__get_nodes).returns({})
+          assert_equal false, @subject.stop
+        end
+        should "kill each node" do
+          @subject.expects(:__get_nodes).returns({'nodes' => { 'n1' => { 'process' => { 'id' => 1 }},
+                                                               'n2' => { 'process' => { 'id' => 2 }} }})
+          Kernel.stubs(:sleep)
+          Process.expects(:kill).with('INT', 1)
+          Process.expects(:kill).with('INT', 2)
+          Process.expects(:getpgid).with(1).raises(Errno::ESRCH)
+          Process.expects(:getpgid).with(2).raises(Errno::ESRCH)
+          assert_equal [1, 2], @subject.stop
+        end
+      end
+      context "when checking if the cluster is running" do
+        setup do
+          @subject = Elasticsearch::Extensions::Test::Cluster::Cluster.new \
+                       cluster_name: 'test',
+                       number_of_nodes: 2
+        end
+        should "return true" do
+          @subject.expects(:__get_cluster_health).returns({'cluster_name' => 'test', 'number_of_nodes' => 2})
+          assert_equal true, @subject.running?
+        end
+        should "return false" do
+          @subject.expects(:__get_cluster_health).returns({'cluster_name' => 'test', 'number_of_nodes' => 1})
+          assert_equal false, @subject.running?
+        end
+      end
+      context "when waiting for the green state" do
+        should "return true" do
+          @subject.expects(:__wait_for_status).returns(true)
+          assert_equal true, @subject.wait_for_green
+        end
+      end
+      context "when waiting for cluster state" do
+        setup do
+          @subject = Elasticsearch::Extensions::Test::Cluster::Cluster.new \
+                       cluster_name: 'test',
+                       number_of_nodes: 1
+        end
+        should "return true" do
+          @subject.stubs(:__print_cluster_info)
+          @subject
+            .expects(:__get_cluster_health)
+            .with('yellow')
+            .returns({'status' => 'yellow', 'cluster_name' => 'test', 'number_of_nodes' => 1})
+          @subject.__wait_for_status('yellow')
+        end
+      end
+      context "when getting the cluster health" do
+        should "return the response" do
+          Net::HTTP
+            .expects(:get)
+            .with(URI('http://localhost:9250/_cluster/health'))
+            .returns(JSON.dump({'status' => 'yellow', 'cluster_name' => 'test', 'number_of_nodes' => 1}))
+          @subject.__get_cluster_health
+        end
+        should "wait for status" do
+          Net::HTTP
+            .expects(:get)
+            .with(URI('http://localhost:9250/_cluster/health?wait_for_status=green'))
+            .returns(JSON.dump({'status' => 'yellow', 'cluster_name' => 'test', 'number_of_nodes' => 1}))
+          @subject.__get_cluster_health('green')
+        end
+      end
+      context "when getting the list of nodes" do
+        should "return the response" do
+          Net::HTTP
+            .expects(:get)
+            .with(URI('http://localhost:9250/_nodes/process'))
+            .returns(JSON.dump({'nodes' => { 'n1' => {}, 'n2' => {} } }))
+          assert_equal 'n1', @subject.__get_nodes['nodes'].keys.first
+        end
+      end
+      context "when determining a version" do
+        setup do
+          @subject = Elasticsearch::Extensions::Test::Cluster::Cluster.new command: '/foo/bar/bin/elasticsearch'
+        end
+        should "return version from lib/elasticsearch.X.Y.Z.jar" do
+          File.expects(:exist?).with('/foo/bar/bin/../lib/').returns(true)
+          Dir.expects(:entries).with('/foo/bar/bin/../lib/').returns(['foo.jar', 'elasticsearch-2.3.0.jar'])
+          assert_equal '2.0', @subject.__determine_version
+        end
+        should "return version from `elasticsearch -v`" do
+          File.expects(:exist?).with('/foo/bar/bin/../lib/').returns(false)
+          @subject.expects(:`)
+            .with("/foo/bar/bin/elasticsearch --version")
+            .returns('Version: 2.3.0-SNAPSHOT, Build: d1c86b0/2016-03-30T10:43:20Z, JVM: 1.8.0_60')
+          assert_equal '2.0', @subject.__determine_version
+        end
+        should "raise an exception when the version cannot be parsed from .jar" do
+          # Incorrect jar version
+          File.expects(:exist?).with('/foo/bar/bin/../lib/').returns(true)
+          Dir.expects(:entries).with('/foo/bar/bin/../lib/').returns(['elasticsearch-100.jar'])
+          assert_raise(RuntimeError) { @subject.__determine_version }
+        end
+        should "raise an exception when the version cannot be parsed from command output" do
+          File.expects(:exist?).with('/foo/bar/bin/../lib/').returns(false)
+          @subject.expects(:`)
+            .with("/foo/bar/bin/elasticsearch --version")
+            .returns('Version: FOOBAR')
+          assert_raise(RuntimeError) { @subject.__determine_version }
+        end
+        should "raise an exception when the version cannot be converted to short version" do
+          # There's no Elasticsearch version 3...
+          File.expects(:exist?).with('/foo/bar/bin/../lib/').returns(true)
+          Dir.expects(:entries).with('/foo/bar/bin/../lib/').returns(['elasticsearch-3.2.1.jar'])
+          assert_raise(RuntimeError) { @subject.__determine_version }
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb CHANGED

@@ -8,7 +8,7 @@ end
 if ENV['COVERAGE'] && ENV['CI'].nil? && !RUBY_1_8
   require 'simplecov'
-  SimpleCov.start { add_filter "/test|test_/" }
+  SimpleCov.start { add_filter "test_" }
 end
 if ENV['CI'] && !RUBY_1_8

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.22
 platform: ruby
 authors:
 - Karel Minarik
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-30 00:00:00.000000000 Z
+date: 2016-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ansi
@@ -278,6 +278,8 @@ files:
 - test/backup/unit/backup_test.rb
 - test/reindex/integration/reindex_test.rb
 - test/reindex/unit/reindex_test.rb
+- test/test/cluster/integration/cluster_test.rb
+- test/test/cluster/unit/cluster_test.rb
 - test/test_helper.rb
 homepage: ''
 licenses:
@@ -308,5 +310,7 @@ test_files:
 - test/backup/unit/backup_test.rb
 - test/reindex/integration/reindex_test.rb
 - test/reindex/unit/reindex_test.rb
+- test/test/cluster/integration/cluster_test.rb
+- test/test/cluster/unit/cluster_test.rb
 - test/test_helper.rb
 has_rdoc: