elasticsearch-extensions 0.0.21 → 0.0.22

checksums.yaml

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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: