elasticshell 0.0.5 → 0.0.6

data/README.rdoc

@@ -74,7 +74,7 @@ you can connect to servers by issuing the +connect+ command:
 === Understanding Scope
 
 Scopes are defined by the Elasticsearch REST API.  Some scopes like
-<tt>/_cluster</tt> or <tt>/nodes</tt> are static and present for all
+<tt>/_cluster</tt> or <tt>/_nodes</tt> are static and present for all
 Elasticsearch clusters.  Other scopes like <tt>/my_index/my_type</tt>
 depend upon the particular cluster.
 
@@ -239,10 +239,10 @@ Or you can try sending it to Ruby itself:
 
   GET /my_index$ _search /tmp/query_that_needs_filtering.json | puts response["hits"]["hits"].first["body"]
 
-Everything to the right of the +|+ is executing within a Ruby process
-that has the +response+ and +request+ variables in scope.  You can be
-even more free by just piping without any Ruby code, which will leave
-you in a Ruby (Pry) shell with the same binding.
+Everything to the right of the <tt>|</tt> is executing within a Ruby
+process that has the +response+ and +request+ variables in scope.  You
+can be even more free by just piping without any Ruby code, which will
+leave you in a Ruby (Pry) shell with the same binding.
 
   GET /my_index$ _search /tmp/query_that_needs_interaction.json | 
   >> response

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/elasticshell/client.rb

@@ -9,29 +9,20 @@ module Elasticshell
       @options = options
     end
 
-    def connect options={}
-      servers = (@options.merge(options)[:servers] || Settings[:servers].to_s.split(","))
+    def safely_connect options={}
+      servers = @options.merge(options)[:servers]
       raise ClientError.new("Must provide at least one server to connect to.") if servers.empty?
-      begin
-        Elasticshell.debug("Connecting to Elasticsearch servers: #{servers.join(', ')}")
-        begin
-          timeout(5) do
-            @client = ElasticSearch::Client.new(servers)
-          end
-        rescue Timeout::Error => e
-          Elasticshell.error("Could not connect to Elasticsearch servers: #{servers.join(', ')}")
-          return
-        end
-        Elasticshell.info("Connected to Elasticsearch servers: #{servers.join(', ')}")
-      rescue ElasticSearch::ConnectionFailed => e
-        raise ClientError.new("Could not connect to Elasticsearch server: #{servers.join(', ')}")
-      end
+      connect(servers.dup, first_attempt=true)
     end
 
     def connected?
       @client
     end
 
+    def safely verb, params={}, options={}, body=''
+      request(verb, params, options.merge(:safely => true))
+    end
+
     def request verb, params={}, options={}, body=''
       raise ClientError.new("Not connected to any Elasticsearch servers.") unless connected?
       safe        = options.delete(:safely)
@@ -50,8 +41,33 @@ module Elasticshell
         end
       end
     end
+    
+    private
+
+    def connect servers, first_attempt=false
+      string  = servers.join(' ')
+      Elasticshell.debug("Attempting to connect to #{string} ...")         if first_attempt
+      raise ClientError.new("Timed out or failed to connect to #{string}") if servers.empty?
+      begin
+        server = servers.shift
+        timeout(5) do
+          @client = ElasticSearch::Client.new(server)
+          Elasticshell.info("Connected to #{server}")
+        end
+      rescue Timeout::Error => e
+        Elasticshell.debug("Timed out connecting to #{server}")
+        connect(servers)
+      rescue ElasticSearch::ConnectionFailed => e
+        Elasticshell.debug("Failure connecting to #{server}")
+        connect(servers)
+      rescue => e
+        Elasticshell.error("#{e.class} -- #{e.message}")
+        connect(servers)
+      end
+    end
 
     def perform_request verb, params, options, body
+      # p [verb, params, options, body]
       @client.execute(:standard_request, verb.downcase.to_sym, params, options, body)
     end
 
@@ -68,10 +84,6 @@ module Elasticshell
       # end
     end
 
-    def safely verb, params={}, options={}, body=''
-      request(verb, params, options.merge(:safely => true))
-    end
-  
   end
 
 end

data/lib/elasticshell/commands/connect.rb

@@ -11,7 +11,7 @@ module Elasticshell
       def evaluate!
         servers = (input.split(/\s+/, 2)[1] || '').split(/\s+/)
         if servers.empty?
-          shell.client.connect()
+          shell.client.safely_connect()
         else
           uris = servers.map do |raw|
             has_port = raw =~ /:\d+/
@@ -31,7 +31,7 @@ module Elasticshell
               nil
             end
           end.compact
-          shell.client.connect(:servers => uris)
+          shell.client.safely_connect(:servers => uris)
         end
       end
 

data/lib/elasticshell/commands/request.rb

@@ -15,7 +15,7 @@ module Elasticshell
       end
 
       def perform_request!
-        self.response = shell.client.request(request[:verb], {:op => request[:path] }, request[:query_options].merge(:log => shell.log_requests?), request[:body])
+        self.response = shell.client.safely(request[:verb], {:op => request[:path].gsub(/^\//,'') }, request[:query_options].merge(:log => shell.log_requests?), request[:body])
       end
 
       def pipe?

data/lib/elasticshell/shell.rb

@@ -108,15 +108,11 @@ module Elasticshell
     end
 
     def prompt
-      verb_string  = self.class.formatted_verb(verb)
+      verb_string  = Elasticshell.format((verb.to_s =~ /^(?:G|H)/i ? :passive_http_verb_format : :active_http_verb_format), "%v", verb.to_s.upcase)
       scope_string = Elasticshell.format((scope.exists? ? :existing_scope_format : :missing_scope_format), "%s", scope.path)
       Elasticshell.format((pretty? ? :pretty_prompt_format : :prompt_format), ["%s", "%v"], [scope_string, verb_string])
     end
 
-    def self.formatted_verb verb
-      Elasticshell.format((verb.to_s =~ /^(?:G|H)/i ? :passive_http_verb_format : :active_http_verb_format), "%v", verb.to_s.upcase)
-    end
-    
     def pretty?
       @pretty
     end

data/lib/elasticshell/utils/log.rb

@@ -61,7 +61,7 @@ module Elasticshell
   end
 
   def self.request verb, host, path
-    log.info(format(:http_request_format, ["%v", "%h", "%p"], [Shell.formatted_verb(verb), host, path]))
+    log.info(format(:http_request_format, ["%v", "%h", "%p"], [verb.to_s.upcase, host, path]))
   end
   
   def self.debug msg

data/spec/elasticshell/client_spec.rb

@@ -24,7 +24,7 @@ describe Client do
       @client.stub!(:log_request)
       @client.stub!(:perform_request)
       @verb   = "GET"
-      @params = {:op => "/foobar"}
+      @params = {:op => "foobar"}
     end
 
     it "should log all requests by default" do

data/spec/elasticshell/commands/connect_spec.rb

@@ -8,12 +8,12 @@ describe Commands::Connect do
   end
 
   it "should start a connection to the default servers" do
-    @shell.client.should_receive(:connect).with()
+    @shell.client.should_receive(:safely_connect).with()
     expect(@shell.eval_line("connect"))
   end
 
   it "should start a connection to the given comma-separated servers" do
-    @shell.client.should_receive(:connect).with(:servers => %w[http://123.123.123.123:9200/ http://321.321.321.321:9200/])
+    @shell.client.should_receive(:safely_connect).with(:servers => %w[http://123.123.123.123:9200/ http://321.321.321.321:9200/])
     expect(@shell.eval_line("connect http://123.123.123.123:9200 http://321.321.321.321:9200"))
   end
   

data/spec/elasticshell/commands/request_spec.rb

@@ -8,50 +8,50 @@ describe Commands::Request do
   end
 
   it "should recognize a simple request" do
-    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    @shell.client.should_receive(:safely).with("GET", { :op => "_simple" }, kind_of(Hash), "").and_return('{}')
     @shell.eval_line("_simple")
   end
 
   it "should recognize a simple request with a different verb" do
-    @shell.client.should_receive(:request).with("POST", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    @shell.client.should_receive(:safely).with("POST", { :op => "_simple" }, kind_of(Hash), "").and_return('{}')
     @shell.eval_line("POST _simple")
   end
 
   it "should recognize a request with an absolute path" do
-    @shell.client.should_receive(:request).with("GET", { :op => "/some/thing" }, kind_of(Hash), "").and_return('{}')
+    @shell.client.should_receive(:safely).with("GET", { :op => "some/thing" }, kind_of(Hash), "").and_return('{}')
     @shell.eval_line("/some/thing")
   end
 
   it "should recognize a request with a query string" do
-    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, {"foo" => "bar", "baz" => "booz what", :log => true}, "").and_return('{}')
+    @shell.client.should_receive(:safely).with("GET", { :op => "_simple" }, {"foo" => "bar", "baz" => "booz what", :log => true}, "").and_return('{}')
     @shell.eval_line("_simple?foo=bar&baz=booz+what")
   end
 
   it "should recognize a request with an inline body" do
-    @shell.client.should_receive(:request).with("POST", { :op => "/_simple" }, kind_of(Hash), "{}").and_return('{}')
+    @shell.client.should_receive(:safely).with("POST", { :op => "_simple" }, kind_of(Hash), "{}").and_return('{}')
     @shell.eval_line("POST _simple {}")
   end
 
   it "should recognize a request with a body read from a local file" do
     File.should_receive(:exist?).with("/some/file.json").and_return(true)
     File.should_receive(:read).with("/some/file.json").and_return("{}")
-    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "{}").and_return('{}')
+    @shell.client.should_receive(:safely).with("GET", { :op => "_simple" }, kind_of(Hash), "{}").and_return('{}')
     @shell.eval_line("_simple /some/file.json")
   end
 
   it "should recognize a request with a body read from STDIN" do
     @shell.input_stream.stub!(:gets).and_return("{}")
-    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "{}").and_return('{}')
+    @shell.client.should_receive(:safely).with("GET", { :op => "_simple" }, kind_of(Hash), "{}").and_return('{}')
     @shell.eval_line("_simple -")
   end
 
   it "should be able to pipe the output of a request to Ruby inline" do
-    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    @shell.client.should_receive(:safely).with("GET", { :op => "_simple" }, kind_of(Hash), "").and_return('{}')
     @shell.eval_line("_simple | response")
   end
 
   it "should be able to pipe the output of a request to a RIPL session" do
-    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    @shell.client.should_receive(:safely).with("GET", { :op => "_simple" }, kind_of(Hash), "").and_return('{}')
     require 'ripl'
     Ripl.should_receive(:start)
     @shell.eval_line("_simple |")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticshell
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-27 00:00:00.000000000 Z
+date: 2012-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -187,7 +187,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4595416963629376856
+      hash: 3786860425467706238
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: