restfully 0.7.1.rc3 → 0.7.1.rc4

data/bin/restfully

@@ -49,6 +49,9 @@ BANNER
     @options["logger"] = logger
   end
   opts.on("-v", "--verbose", "Run verbosely") do |v|
+    @options["logger"].level = Logger::INFO
+  end
+  opts.on("--debug", "Run in debug mode") do |v|
     @options["logger"].level = Logger::DEBUG
   end
   opts.on_tail("-h", "--help", "Show this message") do

data/lib/restfully/collection.rb

@@ -14,13 +14,13 @@ module Restfully
         super(property)
       end
     end
-    
+
     def find_by_uid(symbol)
       found = find{ |i| i.media_type.represents?(symbol) }
       found.expand unless found.nil?
       found
     end
-    
+
     def find_by_index(index)
       index = index+length if index < 0
       each_with_index{|item, i|
@@ -69,27 +69,16 @@ module Restfully
     def empty?
       total == 0
     end
-    
-    # Expand the items that 
+
+    # Expand the items that
     def expand
       each {|i| i.expand}
       self
     end
-    
+
     def inspect
       map{|item| item}.inspect
     end
-    # def (key)
-    #   p Addressable::URI.parse("./"+key.to_s)
-    #   p self.uri
-    #   uri_to_find = Addressable::URI.join(self.uri, "./"+key.to_s)
-    #   p uri_to_find
-    #   find{|resource|
-    #     resource.uri == uri_to_find
-    #   }
-    # end
-
-
   end
 
 end

data/lib/restfully/http/request.rb

@@ -2,27 +2,33 @@
 
 module Restfully
   module HTTP
-    
+
     class Request
       include Helper
-      
-      attr_reader :method, :uri, :head, :body
-      
-      def initialize(session, method, path, options)
+
+      attr_reader :session, :method, :uri, :head, :body, :attempts
+      attr_accessor :retry_on_error, :wait_before_retry
+
+      def initialize(session, method, path, options = {})
         @session = session
-        
+        @attempts = 0
+
         request = options.symbolize_keys
+
+        @retry_on_error = request[:retry_on_error] || session.config[:retry_on_error]
+        @wait_before_retry = request[:wait_before_retry] || session.config[:wait_before_retry]
+
         request[:method] = method
 
         request[:head] = sanitize_head(@session.default_headers).merge(
           build_head(request)
         )
-        
+
         request[:uri] = @session.uri_to(path)
         if request[:query]
           request[:uri].query_values = sanitize_query(request[:query])
         end
-        
+
         request[:body] = if [:post, :put].include?(request[:method])
           build_body(request)
         end
@@ -30,9 +36,10 @@ module Restfully
         @method, @uri, @head, @body = request.values_at(
           :method, :uri, :head, :body
         )
+
       end
-      
-      # Updates the request header and query parameters
+
+      # Updates the request header and query parameters.
       # Returns nil if no changes were made, otherwise self.
       def update!(options = {})
         objects_that_may_be_updated = [@uri, @head]
@@ -48,33 +55,61 @@ module Restfully
           self
         end
       end
-      
+
       def inspect
         "#{method.to_s.upcase} #{uri.to_s}, head=#{head.inspect}, body=#{body.inspect}"
       end
-      
+
       def no_cache?
         head['Cache-Control'] && head['Cache-Control'].include?('no-cache')
       end
-      
+
       def no_cache!
         @forced_cache = true
         head['Cache-Control'] = 'no-cache'
       end
-      
+
       def forced_cache?
         !!@forced_cache
       end
-      
+
+      def execute!
+        session.logger.debug self.inspect
+        resource = RestClient::Resource.new(
+          uri.to_s,
+          :headers => head
+        )
+
+        begin
+          reqcode, reqhead, reqbody = resource.send(method, body || {})
+          response = Response.new(session, reqcode, reqhead, reqbody)
+          session.logger.debug response.inspect
+          response
+        rescue Errno::ECONNREFUSED => e
+          retry! || raise(e)
+        end
+      end
+
+      def retry!
+        if @attempts < @retry_on_error
+          @attempts+=1
+          session.logger.info "Encountered connection or server error. Retrying in #{@wait_before_retry}s... [#{@attempts}/#{@retry_on_error}]"
+          sleep @wait_before_retry if @wait_before_retry > 0
+          execute!
+        else
+          false
+        end
+      end
+
       def remove_no_cache!
         @forced_cache = false
         if head['Cache-Control']
-          head['Cache-Control'] = head['Cache-Control'].split(/\s+,\s+/).reject{|v| 
+          head['Cache-Control'] = head['Cache-Control'].split(/\s+,\s+/).reject{|v|
             v =~ /no-cache/i
           }.join(",")
         end
       end
-      
+
       protected
       def build_head(options = {})
         sanitize_head(
@@ -94,7 +129,7 @@ module Restfully
           nil
         end
       end
-      
+
     end
   end
 end

data/lib/restfully/http/response.rb

@@ -50,7 +50,7 @@ module Restfully
       end
       
       def allow?(http_method)
-        http_method = http_method.to_sym
+        http_method = http_method.downcase.to_sym
         return true if http_method == :get
         (
           media_type.respond_to?(:allow?) && 

data/lib/restfully/resource.rb

@@ -25,7 +25,10 @@ module Restfully
     #   resource["uid"]
     #   => "rennes"
     def [](key)
-      expand.media_type.property(key)
+      unless collection?
+        expand
+      end
+      media_type.property(key)
     end
 
     def uri
@@ -58,7 +61,7 @@ module Restfully
     def load(options = {})
       # Send a GET request only if given a different set of options
       if @request.update!(options) || @request.no_cache?
-        @response = session.execute(@request)
+        @response = @request.execute!
         @request.remove_no_cache! if @request.forced_cache?
         if session.process(@response, @request)
           @associations.clear
@@ -121,8 +124,7 @@ module Restfully
     end
 
     def allow?(method)
-      reload
-      response.allow?(method)
+      response.allow?(method) || reload.response.allow?(method)
     end
 
     def inspect

data/lib/restfully/session.rb

@@ -16,6 +16,8 @@ module Restfully
     def initialize(options = {})
       @config = options.symbolize_keys
       @logger = @config.delete(:logger) || Logger.new(STDERR)
+      @config[:retry_on_error] ||= 5
+      @config[:wait_before_retry] ||= 5
 
       @uri = @config.delete(:uri)
       if @uri.nil? || @uri.empty?
@@ -100,29 +102,14 @@ module Restfully
       transmit :delete, path, options
     end
 
-    # Build and send the corresponding HTTP request, then process the response
+    # Build and execute the corresponding HTTP request,
+    # then process the response.
     def transmit(method, path, options)
       request = HTTP::Request.new(self, method, path, options)
-
-      response = execute(request)
-
+      response = request.execute!
       process(response, request)
     end
 
-    def execute(request)
-      resource = RestClient::Resource.new(
-        request.uri.to_s,
-        :headers => request.head
-      )
-
-      logger.debug request.inspect
-      code, head, body = resource.send(request.method, request.body || {})
-
-      response = Restfully::HTTP::Response.new(self, code, head, body)
-      logger.debug response.inspect
-      response
-    end
-
     # Process a Restfully::HTTP::Response.
     def process(response, request)
       case code=response.code
@@ -135,14 +122,15 @@ module Restfully
       when 204
         true
       when 400..499
-        msg = "Encountered error #{code} on #{request.method.upcase} #{request.uri}"
-        msg += " --- #{response.body[0..200]}" unless response.body.empty?
-        raise HTTP::ClientError, msg
-      when 500..599
-        # when 503, sleep 5, request.retry
-        msg = "Encountered error #{code} on #{request.method.upcase} #{request.uri}"
-        msg += " --- #{response.body[0..200]}" unless response.body.empty?
-        raise HTTP::ServerError, msg
+        raise HTTP::ClientError, error_message(request, response)
+      when 502..504
+        if res = request.retry!
+          process(res, request)
+        else
+         raise(HTTP::ServerError, error_message(request, response))
+       end
+      when 500, 501
+        raise HTTP::ServerError, error_message(request, response)
       else
         raise Error, "Restfully does not handle code #{code.inspect}."
       end
@@ -150,7 +138,12 @@ module Restfully
 
     protected
     def setup_cache
-      enable ::Rack::Cache, :verbose => (logger.level < Logger::INFO)
+      enable ::Rack::Cache, :verbose => (logger.level <= Logger::INFO)
+    end
+
+    def error_message(request, response)
+      msg = "Encountered error #{response.code} on #{request.method.upcase} #{request.uri}"
+      msg += " --- #{response.body[0..200]}" unless response.body.empty?
     end
 
   end

data/lib/restfully/version.rb

@@ -1,3 +1,3 @@
 module Restfully
-  VERSION = "0.7.1.rc3"
+  VERSION = "0.7.1.rc4"
 end

data/spec/restfully/http/request_spec.rb

@@ -7,6 +7,11 @@ describe Restfully::HTTP::Request do
       :default_headers => {
         'Accept' => '*/*; application/xml',
         :accept_encoding => "gzip, deflate"
+      },
+      :logger => Logger.new(STDERR),
+      :config => {
+        :retry_on_error => 5,
+        :wait_before_retry => 5
       }
     )
     
@@ -102,5 +107,33 @@ describe Restfully::HTTP::Request do
       request.body.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<network xmlns=\"http://api.bonfire-project.eu/doc/schemas/occi\">\n  <name>whatever</name>\n</network>\n"
     end
   end
+  
+  describe "execute" do
+    before do
+      @request = Restfully::HTTP::Request.new(
+        @session,
+        :get,
+        "/path"
+      )
+    end
+    it "should build the RestClient::Resource and build a response" do
+      RestClient::Resource.should_receive(:new).with(
+        @request.uri.to_s, 
+        :headers => @request.head
+      ).and_return(
+        resource = mock(RestClient::Resource)
+      )
+      resource.should_receive(:get).and_return([
+        200, 
+        {'Content-Type' => 'text/plain'},
+        ["hello"]
+      ])
+      response = @request.execute!
+      response.should be_a(Restfully::HTTP::Response)
+      response.code.should == 200
+      response.body.should == "hello"
+      response.head.should == {'Content-Type' => 'text/plain'}
+    end
+  end
 
 end

data/spec/restfully/http/response_spec.rb

@@ -36,6 +36,9 @@ describe Restfully::HTTP::Response do
     
     response.allow?(:get).should be_true
     response.allow?(:post).should be_true
+    response.allow?("POST").should be_true
+    response.allow?("GET").should be_true
+    response.allow?("PUT").should be_false
   end
   
   it "should raise an error if it cannot find a corresponding media-type" do

data/spec/restfully/resource_spec.rb

@@ -45,14 +45,23 @@ describe Restfully::Resource do
       @resource.clusters
     end
     {:update => "PUT", :submit => "POST", :delete => "DELETE"}.each do |method, http_method|
-      it "should reload the resource first, to get the Allowed HTTP methods when calling #{method.to_sym}" do
-        @resource.should_receive(:reload).once.and_return(@resource)
+      it "should get the Allowed HTTP methods when calling #{method.to_sym}" do
         @response.should_receive(:allow?).with(http_method).and_return(true)
         @session.should_receive(http_method.downcase.to_sym).
           and_return(mock(Restfully::HTTP::Response))
         @resource.send(method.to_sym)
       end
     end
+    {:update => "PUT", :submit => "POST", :delete => "DELETE"}.each do |method, http_method|
+      it "should reload itself to get the Allowed HTTP methods when calling #{method.to_sym}" do
+        @response.should_receive(:allow?).with(http_method).and_return(false)
+        @response.should_receive(:allow?).with(http_method).and_return(true)
+        @resource.should_receive(:reload).once.and_return(@resource)
+        @session.should_receive(http_method.downcase.to_sym).
+          and_return(mock(Restfully::HTTP::Response))
+        @resource.send(method.to_sym)
+      end
+    end
     it "should not allow to submit if POST not allowed on the resource" do
       @resource.should_receive(:reload).and_return(@resource)
       lambda{
@@ -125,14 +134,14 @@ describe Restfully::Resource do
     end
 
     it "should reload the resource even after having reloaded it once before" do
-      @session.should_receive(:execute).twice.with(@request).
+      @request.should_receive(:execute!).twice.
         and_return(@response)
       @resource.reload
       @resource.reload
     end
 
     it "should raise an error if it cannot reload the resource" do
-      @session.should_receive(:execute).with(@request).
+      @request.should_receive(:execute!).
         and_return(res=mock(Restfully::HTTP::Response))
       @session.should_receive(:process).with(res, @request).
         and_return(false)

data/spec/restfully/session_spec.rb

@@ -10,20 +10,20 @@ describe Restfully::Session do
       :logger => @logger
     }
   end
-  
+
   it "should initialize a session with the correct properties" do
     session = Restfully::Session.new(@config.merge("key" => "value"))
     session.logger.should == @logger
     session.uri.should == Addressable::URI.parse(@uri)
-    session.config.should == {:key => "value"}
+    session.config.should == {:wait_before_retry=>5, :key=>"value", :retry_on_error=>5}
   end
-  
+
   it "should raise an error if no URI given" do
     lambda{
       Restfully::Session.new(@config.merge(:uri => ""))
     }.should raise_error(ArgumentError)
   end
-  
+
   it "should fetch the root path [no URI path]" do
     session = Restfully::Session.new(@config)
     session.should_receive(:get).with("").
@@ -31,7 +31,7 @@ describe Restfully::Session do
     res.should_receive(:load).and_return(res)
     session.root.should == res
   end
-  
+
   it "should fetch the root path [URI path present]" do
     session = Restfully::Session.new(
       @config.merge(:uri => "https://api.grid5000.fr/resource/path")
@@ -41,21 +41,21 @@ describe Restfully::Session do
     res.should_receive(:load).and_return(res)
     session.root.should == res
   end
-  
+
   it "should add or replace additional headers to the default set" do
     session = Restfully::Session.new(
       @config.merge(:default_headers => {
-        'Accept' => 'application/xml', 
+        'Accept' => 'application/xml',
         'Cache-Control' => 'no-cache'
       })
     )
     session.default_headers.should == {
-      'Accept' => 'application/xml', 
+      'Accept' => 'application/xml',
       'Cache-Control' => 'no-cache',
       'Accept-Encoding' => 'gzip, deflate'
     }
   end
-  
+
   describe "middleware" do
     it "should only have Rack::Cache enabled by default" do
       session = Restfully::Session.new(@config)
@@ -64,7 +64,7 @@ describe Restfully::Session do
         Rack::Cache
       ]
     end
-    
+
     it "should use Restfully::Rack::BasicAuth if basic authentication is used" do
       session = Restfully::Session.new(@config.merge(
         :username => "crohr", :password => "p4ssw0rd"
@@ -76,15 +76,15 @@ describe Restfully::Session do
       ]
     end
   end
-  
+
   describe "transmitting requests" do
     before do
       @session = Restfully::Session.new(@config)
       @path = "/path"
       @default_headers = @session.default_headers
     end
-    
-    it "should make a get request" do  
+
+    it "should make a get request" do
       stub_request(:get, @uri+@path+"?k1=v1&k2=v2").with(
         :headers => @default_headers.merge({
           'Accept' => '*/*',
@@ -106,13 +106,13 @@ describe Restfully::Session do
         @response,
         instance_of(Restfully::HTTP::Request)
       )
-      
+
       @session.transmit :get, @path, {
         :query => {:k1 => "v1", :k2 => "v2"},
         :headers => {'X-Header' => 'value'}
       }
     end
-    
+
     it "should make an authenticated get request" do
       stub_request(:get, "https://crohr:p4ssw0rd@api.grid5000.fr"+@path+"?k1=v1&k2=v2").with(
         :headers => @default_headers.merge({
@@ -127,57 +127,77 @@ describe Restfully::Session do
         :headers => {'X-Header' => 'value'}
       }
     end
+
+    it "should retry for at most :max_attempts_on_connection_error if connection to the server failed" do
+
+    end
   end
-  
+
   describe "processing responses" do
     before do
       @session = Restfully::Session.new(@config)
-      @request = mock(
-        Restfully::HTTP::Request, 
-        :method => :get, 
-        :uri => @uri, 
-        :head => mock("head"),
-        :update! => nil
+      @request = Restfully::HTTP::Request.new(
+        @session,
+        :get,
+        @uri
       )
+      @request.stub!(:head).and_return({})
+      @request.stub!(:update!).and_return(nil)
+      
       @response = Restfully::HTTP::Response.new(
         @session,
         200,
-        {'X' => 'Y'},
+        {'X' => 'Y', 'Content-Type' => 'text/plain'},
         'body'
       )
     end
-    
+
     it "should return true if status=204" do
       @response.stub!(:code).and_return(204)
       @session.process(@response, @request).should be_true
     end
-    
+
     it "should raise a Restfully::HTTP::ClientError if status in 400..499" do
       @response.stub!(:code).and_return(400)
       lambda{
         @session.process(@response, @request)
       }.should raise_error(Restfully::HTTP::ClientError)
     end
-    
+
     it "should raise a Restfully::HTTP::ServerError if status in 500..599" do
       @response.stub!(:code).and_return(500)
       lambda{
         @session.process(@response, @request)
       }.should raise_error(Restfully::HTTP::ServerError)
     end
-    
+    it "should retry if the server returns one of [502,503,504], and request.retry! returns a response" do
+      @request.should_receive(:retry!).once.
+        and_return(@response)
+      @response.should_receive(:code).ordered.and_return(503)
+      @response.should_receive(:code).ordered.and_return(200)
+      @session.process(@response, @request)
+    end
+    it "should not retry if the server returns one of [502,503,504], but request.retry! returns false" do
+      @request.should_receive(:retry!).once.
+        and_return(false)
+      @response.stub!(:code).and_return(503)
+      lambda{
+        @session.process(@response, @request)
+      }.should raise_error(Restfully::HTTP::ServerError, /503/)
+    end
+
     it "should raise an error if the status is not supported" do
       @response.stub!(:code).and_return(50)
       lambda{
         @session.process(@response, @request)
       }.should raise_error(Restfully::Error)
     end
-    
+
     [201, 202].each do |status|
       it "should fetch the resource specified in the Location header if status = #{status}" do
         @response.stub!(:code).and_return(status)
         @response.head['Location'] = @uri+"/path"
-        
+
         @session.should_receive(:get).
           with(@uri+"/path", :head => @request.head).
           and_return(resource=mock("resource"))
@@ -185,7 +205,7 @@ describe Restfully::Session do
           should == resource
       end
     end
-    
+
     it "should return a Restfully::Resource if successful" do
       Restfully::MediaType.register Restfully::MediaType::ApplicationJson
       body = {
@@ -197,33 +217,33 @@ describe Restfully::Session do
         {'Content-Type' => 'application/json'},
         JSON.dump(body)
       )
-      
+
       resource = @session.process(
         @response,
         @request
       )
-      
+
       resource.should be_a(Restfully::Resource)
       resource.uri.should == @request.uri
       resource['key1'].should == body[:key1]
       resource['key2'].should == body[:key2]
     end
-    
+
     it "should raise an error if the response content-type is not supported" do
       @response = Restfully::HTTP::Response.new(
         @session, 200,
         {'Content-Type' => ''},
         'body'
       )
-      
-      lambda{ 
-        @session.process(@response,@request) 
+
+      lambda{
+        @session.process(@response,@request)
       }.should raise_error(
-        Restfully::Error, 
+        Restfully::Error,
         "Cannot find a media-type for content-type=\"\""
       )
     end
   end
-  
+
 end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: restfully
 version: !ruby/object:Gem::Version 
-  hash: 15424107
+  hash: 15424101
   prerelease: 6
   segments: 
   - 0
   - 7
   - 1
   - rc
-  - 3
-  version: 0.7.1.rc3
+  - 4
+  version: 0.7.1.rc4
 platform: ruby
 authors: 
 - Cyril Rohr