cloudfiles 1.4.10 → 1.4.11

data/lib/cloudfiles/storage_object.rb

@@ -1,83 +1,97 @@
 module CloudFiles
   class StorageObject
     # See COPYING for license information.
-    # Copyright (c) 2009, Rackspace US, Inc.
-    
+    # Copyright (c) 2011, Rackspace US, Inc.
+
     # Name of the object corresponding to the instantiated object
     attr_reader :name
-
-    # Size of the object (in bytes)
-    attr_reader :bytes
     
     # The parent CloudFiles::Container object
     attr_reader :container
 
-    # Date of the object's last modification
-    attr_reader :last_modified
-
-    # ETag of the object data
-    attr_reader :etag
-
-    # Content type of the object data
-    attr_reader :content_type
-
     # Builds a new CloudFiles::StorageObject in the current container.  If force_exist is set, the object must exist or a
-    # NoSuchObjectException will be raised.  If not, an "empty" CloudFiles::StorageObject will be returned, ready for data
+    # CloudFiles::Exception::NoSuchObject Exception will be raised.  If not, an "empty" CloudFiles::StorageObject will be returned, ready for data
     # via CloudFiles::StorageObject.write
-    def initialize(container,objectname,force_exists=false,make_path=false) 
+    def initialize(container, objectname, force_exists = false, make_path = false)
       if objectname.match(/\?/)
-        raise SyntaxException, "Object #{objectname} contains an invalid character in the name (? not allowed)"
+        raise CloudFiles::Exception::Syntax, "Object #{objectname} contains an invalid character in the name (? not allowed)"
       end
       @container = container
       @containername = container.name
       @name = objectname
       @make_path = make_path
       @storagehost = self.container.connection.storagehost
-      @storagepath = self.container.connection.storagepath+"/#{URI.encode(@containername).gsub(/&/,'%26')}/#{URI.encode(@name).gsub(/&/,'%26')}"
+      @storagepath = self.container.connection.storagepath + "/#{CloudFiles.escape @containername}/#{CloudFiles.escape @name}"
       @storageport = self.container.connection.storageport
       @storagescheme = self.container.connection.storagescheme
-      if container.object_exists?(objectname)
-        populate
-      else
-        raise NoSuchObjectException, "Object #{@name} does not exist" if force_exists
+      if force_exists
+        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless container.object_exists?(objectname)
       end
     end
-    
-    # Caches data about the CloudFiles::StorageObject for fast retrieval.  This method is automatically called when the 
-    # class is initialized, but it can be called again if the data needs to be updated.
-    def populate
-      response = self.container.connection.cfreq("HEAD",@storagehost,@storagepath,@storageport,@storagescheme)
-      raise NoSuchObjectException, "Object #{@name} does not exist" unless (response.code =~ /^20/)
-      @bytes = response["content-length"]
-      @last_modified = Time.parse(response["last-modified"])
-      @etag = response["etag"]
-      @content_type = response["content-type"]
-      resphash = {}
-      response.to_hash.select { |k,v| k.match(/^x-object-meta/) }.each { |x| resphash[x[0]] = x[1].to_s }
-      @metadata = resphash
+
+    # Refreshes the object metadata
+    def refresh
+      @object_metadata = nil
       true
     end
-    alias :refresh :populate
+    alias :populate :refresh
+
+    # Retrieves Metadata for the object
+    def object_metadata
+      @object_metadata ||= (
+        response = self.container.connection.cfreq("HEAD", @storagehost, @storagepath, @storageport, @storagescheme)
+        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (response.code =~ /^20/)
+        resphash = {}
+        response.to_hash.select { |k,v| k.match(/^x-object-meta/) }.each { |x| resphash[x[0]] = x[1].to_s }
+        {
+          :bytes => response["content-length"],
+          :last_modified => Time.parse(response["last-modified"]),
+          :etag => response["etag"],
+          :content_type => response["content-type"],
+          :metadata => resphash
+        }
+      )
+    end
+
+    # Size of the object (in bytes)
+    def bytes
+      self.object_metadata[:bytes]
+    end
+
+    # Date of the object's last modification
+    def last_modified
+      self.object_metadata[:last_modified]
+    end
+
+    # ETag of the object data
+    def etag
+      self.object_metadata[:etag]
+    end
+
+    # Content type of the object data
+    def content_type
+      self.object_metadata[:content_type]
+    end
 
     # Retrieves the data from an object and stores the data in memory.  The data is returned as a string.
     # Throws a NoSuchObjectException if the object doesn't exist.
     #
     # If the optional size and range arguments are provided, the call will return the number of bytes provided by
     # size, starting from the offset provided in offset.
-    # 
+    #
     #   object.data
     #   => "This is the text stored in the file"
-    def data(size=-1,offset=0,headers = {})
+    def data(size = -1, offset = 0, headers = {})
       if size.to_i > 0
         range = sprintf("bytes=%d-%d", offset.to_i, (offset.to_i + size.to_i) - 1)
         headers['Range'] = range
       end
-      response = self.container.connection.cfreq("GET",@storagehost,@storagepath,@storageport,@storagescheme,headers)
-      raise NoSuchObjectException, "Object #{@name} does not exist" unless (response.code =~ /^20/)
+      response = self.container.connection.cfreq("GET", @storagehost, @storagepath, @storageport, @storagescheme, headers)
+      raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (response.code =~ /^20/)
       response.body
     end
 
-    # Retrieves the data from an object and returns a stream that must be passed to a block.  Throws a 
+    # Retrieves the data from an object and returns a stream that must be passed to a block.  Throws a
     # NoSuchObjectException if the object doesn't exist.
     #
     # If the optional size and range arguments are provided, the call will return the number of bytes provided by
@@ -87,16 +101,16 @@ module CloudFiles
     #   object.data_stream do |chunk|
     #     data += chunk
     #   end
-    #  
+    #
     #   data
     #   => "This is the text stored in the file"
-    def data_stream(size=-1,offset=0,headers = {},&block)
+    def data_stream(size = -1, offset = 0, headers = {}, &block)
       if size.to_i > 0
         range = sprintf("bytes=%d-%d", offset.to_i, (offset.to_i + size.to_i) - 1)
         headers['Range'] = range
       end
-      self.container.connection.cfreq("GET",@storagehost,@storagepath,@storageport,@storagescheme,headers,nil) do |response|
-        raise NoSuchObjectException, "Object #{@name} does not exist" unless (response.code == "200")
+      self.container.connection.cfreq("GET", @storagehost, @storagepath, @storageport, @storagescheme, headers, nil) do |response|
+        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (response.code == "200")
         response.read_body(&block)
       end
     end
@@ -108,32 +122,32 @@ module CloudFiles
     #    => {"ruby"=>"cool", "foo"=>"bar"}
     def metadata
       metahash = {}
-      @metadata.each{|key, value| metahash[key.gsub(/x-object-meta-/,'').gsub(/\+\-/, ' ')] = URI.decode(value).gsub(/\+\-/, ' ')}
+      self.object_metadata[:metadata].each{ |key, value| metahash[key.gsub(/x-object-meta-/, '').gsub(/\+\-/, ' ')] = URI.decode(value).gsub(/\+\-/, ' ') }
       metahash
     end
-    
+
     # Sets the metadata for an object.  By passing a hash as an argument, you can set the metadata for an object.
     # However, setting metadata will overwrite any existing metadata for the object.
-    # 
+    #
     # Throws NoSuchObjectException if the object doesn't exist.  Throws InvalidResponseException if the request
     # fails.
     def set_metadata(metadatahash)
       headers = {}
-      metadatahash.each{|key, value| headers['X-Object-Meta-' + key.to_s.capitalize] = value.to_s}
-      response = self.container.connection.cfreq("POST",@storagehost,@storagepath,@storageport,@storagescheme,headers)
-      raise NoSuchObjectException, "Object #{@name} does not exist" if (response.code == "404")
-      raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "202")
+      metadatahash.each{ |key, value| headers['X-Object-Meta-' + key.to_s.capitalize] = value.to_s }
+      response = self.container.connection.cfreq("POST", @storagehost, @storagepath, @storageport, @storagescheme, headers)
+      raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" if (response.code == "404")
+      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "202")
       true
     end
-    
+
     # Takes supplied data and writes it to the object, saving it.  You can supply an optional hash of headers, including
     # Content-Type and ETag, that will be applied to the object.
     #
-    # If you would rather stream the data in chunks, instead of reading it all into memory at once, you can pass an 
+    # If you would rather stream the data in chunks, instead of reading it all into memory at once, you can pass an
     # IO object for the data, such as: object.write(open('/path/to/file.mp3'))
     #
     # You can compute your own MD5 sum and send it in the "ETag" header.  If you provide yours, it will be compared to
-    # the MD5 sum on the server side.  If they do not match, the server will return a 422 status code and a MisMatchedChecksumException
+    # the MD5 sum on the server side.  If they do not match, the server will return a 422 status code and a CloudFiles::Exception::MisMatchedChecksum Exception
     # will be raised.  If you do not provide an MD5 sum as the ETag, one will be computed on the server side.
     #
     # Updates the container cache and returns true on success, raises exceptions if stuff breaks.
@@ -153,9 +167,9 @@ module CloudFiles
     # with no data (or, if you need to pass headers)
     #
     #  object.write(nil,{'header' => 'value})
-    
-    def write(data=nil,headers={})
-      raise SyntaxException, "No data or header updates supplied" if ((data.nil? && $stdin.tty?) and headers.empty?)
+
+    def write(data = nil, headers = {})
+      raise CloudFiles::Exception::Syntax, "No data or header updates supplied" if ((data.nil? && $stdin.tty?) and headers.empty?)
       if headers['Content-Type'].nil?
         type = MIME::Types.type_for(self.name).first.to_s
         if type.empty?
@@ -166,18 +180,20 @@ module CloudFiles
       end
       # If we're taking data from standard input, send that IO object to cfreq
       data = $stdin if (data.nil? && $stdin.tty? == false)
-      response = self.container.connection.cfreq("PUT",@storagehost,"#{@storagepath}",@storageport,@storagescheme,headers,data)
+      response = self.container.connection.cfreq("PUT", @storagehost, "#{@storagepath}", @storageport, @storagescheme, headers, data)
       code = response.code
-      raise InvalidResponseException, "Invalid content-length header sent" if (code == "412")
-      raise MisMatchedChecksumException, "Mismatched etag" if (code == "422")
-      raise InvalidResponseException, "Invalid response code #{code}" unless (code == "201")
+      raise CloudFiles::Exception::InvalidResponse, "Invalid content-length header sent" if (code == "412")
+      raise CloudFiles::Exception::MisMatchedChecksum, "Mismatched etag" if (code == "422")
+      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{code}" unless (code =~ /^20./)
       make_path(File.dirname(self.name)) if @make_path == true
-      self.populate
+      self.refresh
       true
     end
-    
+
     # A convenience method to stream data into an object from a local file (or anything that can be loaded by Ruby's open method)
     #
+    # You can provide an optional hash of headers, in case you want to do something like set the Content-Type manually.
+    #
     # Throws an Errno::ENOENT if the file cannot be read.
     #
     #   object.data
@@ -186,21 +202,23 @@ module CloudFiles
     #   object.load_from_filename("/tmp/file.txt")
     #   => true
     #
+    #   object.load_from_filename("/home/rackspace/myfile.tmp", 'Content-Type' => 'text/plain')
+    #
     #   object.data
     #   => "This data was in the file /tmp/file.txt"
     #
     #   object.load_from_filename("/tmp/nonexistent.txt")
     #   => Errno::ENOENT: No such file or directory - /tmp/nonexistent.txt
-    def load_from_filename(filename)
+    def load_from_filename(filename, headers = {})
       f = open(filename)
-      self.write(f)
+      self.write(f, headers)
       f.close
       true
     end
 
     # A convenience method to stream data from an object into a local file
     #
-    # Throws an Errno::ENOENT if the file cannot be opened for writing due to a path error, 
+    # Throws an Errno::ENOENT if the file cannot be opened for writing due to a path error,
     # and Errno::EACCES if the file cannot be opened for writing due to permissions.
     #
     #   object.data
@@ -222,7 +240,7 @@ module CloudFiles
       end
       true
     end
-    
+
     # If the parent container is public (CDN-enabled), returns the CDN URL to this object.  Otherwise, return nil
     #
     #   public_object.public_url
@@ -231,26 +249,68 @@ module CloudFiles
     #   private_object.public_url
     #   => nil
     def public_url
-      self.container.public? ? self.container.cdn_url + "/#{URI.encode(@name).gsub(/&/,'%26')}" : nil
+      self.container.public? ? self.container.cdn_url + "/#{CloudFiles.escape @name}" : nil
     end
     
+    # Copy this object to a new location (optionally in a new container)
+    #
+    # You must supply either a name for the new object or a container name, or both. If a :name is supplied without a :container, 
+    # the object is copied within the current container. If the :container is specified with no :name, then the object is copied
+    # to the new container with its current name.
+    #
+    #    object.copy(:name => "images/funny/lolcat.jpg", :container => "pictures")
+    #
+    # You may also supply a hash of headers in the :headers option. From there, you can set things like Content-Type, or other
+    # headers as available in the API document.
+    #
+    #    object.copy(:name => 'newfile.tmp', :headers => {'Content-Type' => 'text/plain'})
+    #
+    # Returns the new CloudFiles::StorageObject for the copied item.
+    def copy(options = {})
+      raise CloudFiles::Exception::Syntax, "You must either provide the :container or the :name for this operation" unless (options[:container] || options[:name])
+      new_container = options[:container] || self.container.name
+      new_name = options[:name] || self.name
+      new_headers = options[:headers] || {}
+      raise CloudFiles::Exception::Syntax, "The :headers option must be a hash" unless new_headers.is_a?(Hash)
+      new_name.sub!(/^\//,'')
+      headers = {'X-Copy-From' => "#{self.container.name}/#{self.name}", 'Content-Type' => self.content_type.sub(/;.+/, '')}.merge(new_headers)
+      # , 'Content-Type' => self.content_type
+      new_path = self.container.connection.storagepath + "/#{CloudFiles.escape new_container}/#{CloudFiles.escape new_name}"
+      response = self.container.connection.cfreq("PUT", @storagehost, new_path, @storageport, @storagescheme, headers)
+      code = response.code
+      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
+      return CloudFiles::Container.new(self.container.connection, new_container).object(new_name)
+    end
+    
+    # Takes the same options as the copy method, only it does a copy followed by a delete on the original object.
+    #
+    # Returns the new CloudFiles::StorageObject for the moved item. You should not attempt to use the old object after doing
+    # a move.
+    def move(options = {})
+      new_object = self.copy(options)
+      self.container.delete_object(self.name)
+      self.freeze
+      return new_object
+    end
+      
+
     def to_s # :nodoc:
       @name
     end
-    
+
     private
-    
-    def make_path(path) # :nodoc:
-      if path == "." || path == "/"
-        return
-      else
-        unless self.container.object_exists?(path)
-          o = self.container.create_object(path)
-          o.write(nil,{'Content-Type' => 'application/directory'})
+
+      def make_path(path) # :nodoc:
+        if path == "." || path == "/"
+          return
+        else
+          unless self.container.object_exists?(path)
+            o = self.container.create_object(path)
+            o.write(nil, {'Content-Type' => 'application/directory'})
+          end
+          make_path(File.dirname(path))
         end
-        make_path(File.dirname(path))
       end
-    end
 
   end
 

data/test/cloudfiles_authentication_test.rb

@@ -10,7 +10,7 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
     server.stubs(:get).returns(response)
     CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => false, :authurl => 'https://auth.api.rackspacecloud.com/v1.0')
+    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => false, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
     result = CloudFiles::Authentication.new(@connection)
     assert_equal result.class, CloudFiles::Authentication
   end
@@ -21,7 +21,7 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
     server.stubs(:get).returns(response)
     CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => true, :authurl => 'https://auth.api.rackspacecloud.com/v1.0')
+    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
     result = CloudFiles::Authentication.new(@connection)
     assert_equal result.class, CloudFiles::Authentication
   end
@@ -32,16 +32,16 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     server = mock(:use_ssl= => true, :verify_mode= => true, :start => true)
     server.stubs(:get).returns(response)
     CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true,  :authurl => 'https://auth.api.rackspacecloud.com/v1.0')
-    assert_raises(AuthenticationException) do
+    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true,  :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
+    assert_raises(CloudFiles::Exception::Authentication) do
       result = CloudFiles::Authentication.new(@connection)
     end
   end
     
   def test_bad_hostname
-    Net::HTTP.stubs(:new).raises(ConnectionException)
-    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :authurl => 'https://auth.api.rackspacecloud.com/v1.0')
-    assert_raises(ConnectionException) do
+    Net::HTTP.stubs(:new).raises(CloudFiles::Exception::Connection)
+    @connection = stub(:proxy_host => nil, :proxy_port => nil, :authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
+    assert_raises(CloudFiles::Exception::Connection) do
       result = CloudFiles::Authentication.new(@connection)
     end
   end

data/test/cloudfiles_connection_test.rb

@@ -83,8 +83,8 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   end
   
   def test_net_http_raises_connection_exception
-    Net::HTTP.expects(:new).raises(ConnectionException)
-    assert_raises(ConnectionException) do
+    Net::HTTP.expects(:new).raises(CloudFiles::Exception::Connection)
+    assert_raises(CloudFiles::Exception::Connection) do
       response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
     end
   end
@@ -118,8 +118,9 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
     server = stub(:use_ssl= => true, :verify_mode= => true, :start => true)
     server.stubs(:finish).returns(true)
     server.stubs(:request).raises(EOFError)
+    CloudFiles::Connection.any_instance.stubs(:get_info).returns({:bytes => @bytes, :count => @count})
     Net::HTTP.stubs(:new).returns(server)
-    assert_raises(ConnectionException) do
+    assert_raises(CloudFiles::Exception::Connection) do
       response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
     end
   end
@@ -133,7 +134,7 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   
   def test_get_info_fails
     build_net_http_object(:response => {'x-account-bytes-used' => '9999', 'x-account-container-count' => '5'}, :code => '999')
-    assert_raises(InvalidResponseException) do
+    assert_raises(CloudFiles::Exception::InvalidResponse) do
       @connection.get_info
     end
   end
@@ -154,7 +155,7 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   
   def test_public_containers_exception
     build_net_http_object(:code => '999')
-    assert_raises(InvalidResponseException) do
+    assert_raises(CloudFiles::Exception::InvalidResponse) do
       public_containers = @connection.public_containers
     end
   end
@@ -167,14 +168,14 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   
   def test_delete_nonempty_container
     build_net_http_object(:code => '409')
-    assert_raises(NonEmptyContainerException) do
+    assert_raises(CloudFiles::Exception::NonEmptyContainer) do
       response = @connection.delete_container("not_empty")
     end
   end
   
   def test_delete_unknown_container
     build_net_http_object(:code => '999')
-    assert_raises(NoSuchContainerException) do
+    assert_raises(CloudFiles::Exception::NoSuchContainer) do
       response = @connection.delete_container("not_empty")
     end
   end
@@ -188,7 +189,7 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   
   def test_create_container_with_invalid_name
     CloudFiles::Container.stubs(:new)
-    assert_raise(SyntaxException) do
+    assert_raise(CloudFiles::Exception::Syntax) do
       container = @connection.create_container('a'*300)
     end
   end
@@ -196,7 +197,7 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   def test_create_container_name_filter
     CloudFiles::Container.any_instance.stubs(:populate)
     build_net_http_object(:code => '201')
-    assert_raises(SyntaxException) do 
+    assert_raises(CloudFiles::Exception::Syntax) do 
       container = @connection.create_container('this/has/bad?characters')
     end
   end
@@ -219,9 +220,9 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   end
   
   def test_fetch_nonexistent_container
-    CloudFiles::Container.any_instance.stubs(:populate).raises(NoSuchContainerException)
+    CloudFiles::Container.any_instance.stubs(:metadata).raises(CloudFiles::Exception::NoSuchContainer)
     build_net_http_object
-    assert_raise(NoSuchContainerException) do
+    assert_raise(CloudFiles::Exception::NoSuchContainer) do
       container = @connection.container('bad_container')
     end
   end
@@ -258,7 +259,7 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   
   def test_containers_bad_result
     build_net_http_object(:code => '999')
-    assert_raises(InvalidResponseException) do
+    assert_raises(CloudFiles::Exception::InvalidResponse) do
       containers = @connection.containers
     end
   end
@@ -280,7 +281,7 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   
   def test_containers_detail_bad_response
     build_net_http_object(:code => '999')
-    assert_raises(InvalidResponseException) do
+    assert_raises(CloudFiles::Exception::InvalidResponse) do
       details = @connection.containers_detail
     end
   end