cloudfiles 1.4.17 → 1.4.18

data/CHANGELOG

@@ -1,3 +1,8 @@
+================================================================================
+1.4.18 (2011/09/07)
+================================================================================
+ o Added Streaming URL support
+
 ================================================================================
 1.4.17 (2011/05/27)
 ================================================================================

data/Gemfile

@@ -1,3 +1,7 @@
 source :gemcutter
 
 gemspec
+
+group :development do
+  gem 'rake'
+end

data/cloudfiles.gemspec

@@ -1,4 +1,4 @@
-require 'lib/cloudfiles/version'
+require File.expand_path('../lib/cloudfiles/version', __FILE__)
 
 Gem::Specification.new do |s|
   s.name = %q{cloudfiles}

data/lib/cloudfiles/authentication.rb

@@ -14,29 +14,33 @@ module CloudFiles
       path = parsed_auth_url.path
       hdrhash = { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey }
       begin
-        server             = get_server(connection, parsed_auth_url)
+        server = get_server(connection, parsed_auth_url)
 
         if parsed_auth_url.scheme == "https"
           server.use_ssl     = true
           server.verify_mode = OpenSSL::SSL::VERIFY_NONE
         end
         server.start
-      rescue
-        raise CloudFiles::Exception::Connection, "Unable to connect to #{server.address}"
+      rescue Exception => e
+        # uncomment if you suspect a problem with this branch of code
+#         $stderr.puts "got error #{e.class}: #{e.message.inspect}\n" << e.traceback.map{|n| "\t#{n}"}.join("\n")
+        raise CloudFiles::Exception::Connection, "Unable to connect to #{server.address}", caller
       end
       response = server.get(path, hdrhash)
       if (response.code =~ /^20./)
         if response["x-cdn-management-url"]
           connection.cdn_available = true
-          connection.cdnmgmthost   = URI.parse(response["x-cdn-management-url"]).host
-          connection.cdnmgmtpath   = URI.parse(response["x-cdn-management-url"]).path
-          connection.cdnmgmtport   = URI.parse(response["x-cdn-management-url"]).port
-          connection.cdnmgmtscheme = URI.parse(response["x-cdn-management-url"]).scheme
+          parsed_cdn_url = URI.parse(response["x-cdn-management-url"])
+          connection.cdnmgmthost   = parsed_cdn_url.host
+          connection.cdnmgmtpath   = parsed_cdn_url.path
+          connection.cdnmgmtport   = parsed_cdn_url.port
+          connection.cdnmgmtscheme = parsed_cdn_url.scheme
         end
-        connection.storagehost   = set_snet(connection, URI.parse(response["x-storage-url"]).host)
-        connection.storagepath   = URI.parse(response["x-storage-url"]).path
-        connection.storageport   = URI.parse(response["x-storage-url"]).port
-        connection.storagescheme = URI.parse(response["x-storage-url"]).scheme
+        parsed_storage_url = URI.parse(response["x-storage-url"])
+        connection.storagehost   = set_snet(connection, parsed_storage_url.host)
+        connection.storagepath   = parsed_storage_url.path
+        connection.storageport   = parsed_storage_url.port
+        connection.storagescheme = parsed_storage_url.scheme
         connection.authtoken     = response["x-auth-token"]
         connection.authok        = true
       else

data/lib/cloudfiles/connection.rb

@@ -133,7 +133,7 @@ module CloudFiles
     #   cf.bytes
     #   => 42438527
     def get_info
-      response = cfreq("HEAD", @storagehost, @storagepath, @storageport, @storagescheme)
+      response = storage_request("HEAD")
       raise CloudFiles::Exception::InvalidResponse, "Unable to obtain account size" unless (response.code == "204")
       @bytes = response["x-account-bytes-used"].to_i
       @count = response["x-account-container-count"].to_i
@@ -166,7 +166,7 @@ module CloudFiles
       query = []
       query << "limit=#{CloudFiles.escape limit.to_s}" if limit.to_i > 0
       query << "marker=#{CloudFiles.escape marker.to_s}" unless marker.to_s.empty?
-      response = cfreq("GET", @storagehost, "#{@storagepath}?#{query.join '&'}", @storageport, @storagescheme)
+      response = storage_request("GET", "?#{query.join('&')}")
       return [] if (response.code == "204")
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "200")
       CloudFiles.lines(response.body)
@@ -187,7 +187,7 @@ module CloudFiles
       query = ['format=xml']
       query << "limit=#{CloudFiles.escape limit.to_s}" if limit.to_i > 0
       query << "marker=#{CloudFiles.escape marker.to_s}" unless marker.to_s.empty?
-      response = cfreq("GET", @storagehost, "#{@storagepath}?#{query.join '&'}", @storageport, @storagescheme)
+      response = storage_request("GET", "?#{query.join('&')}")
       return {} if (response.code == "204")
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "200")
       doc = REXML::Document.new(response.body)
@@ -208,7 +208,7 @@ module CloudFiles
     #   cf.container_exists?('bad_container')
     #   => false
     def container_exists?(containername)
-      response = cfreq("HEAD", @storagehost, "#{@storagepath}/#{CloudFiles.escape containername}", @storageport, @storagescheme)
+      response = storage_request("HEAD", CloudFiles.escape(containername))
       return (response.code == "204")? true : false ;
     end
 
@@ -227,7 +227,7 @@ module CloudFiles
     def create_container(containername)
       raise CloudFiles::Exception::Syntax, "Container name cannot contain the characters '/' or '?'" if containername.match(/[\/\?]/)
       raise CloudFiles::Exception::Syntax, "Container name is limited to 256 characters" if containername.length > 256
-      response = cfreq("PUT", @storagehost, "#{@storagepath}/#{CloudFiles.escape containername}", @storageport, @storagescheme)
+      response = storage_request("PUT", CloudFiles.escape(containername))
       raise CloudFiles::Exception::InvalidResponse, "Unable to create container #{containername}" unless (response.code == "201" || response.code == "202")
       CloudFiles::Container.new(self, containername)
     end
@@ -244,7 +244,7 @@ module CloudFiles
     #   cf.delete_container('nonexistent')
     #   => NoSuchContainerException: Container nonexistent does not exist
     def delete_container(containername)
-      response = cfreq("DELETE", @storagehost, "#{@storagepath}/#{CloudFiles.escape containername}", @storageport, @storagescheme)
+      response = storage_request("DELETE", CloudFiles.escape(containername))
       raise CloudFiles::Exception::NonEmptyContainer, "Container #{containername} is not empty" if (response.code == "409")
       raise CloudFiles::Exception::NoSuchContainer, "Container #{containername} does not exist" unless (response.code == "204")
       true
@@ -261,12 +261,22 @@ module CloudFiles
     #   => ["video", "webpics"]
     def public_containers(enabled_only = false)
       paramstr = enabled_only == true ? "enabled_only=true" : ""
-      response = cfreq("GET", @cdnmgmthost, "#{@cdnmgmtpath}?#{paramstr}", @cdnmgmtport, @cdnmgmtscheme)
+      response = cdn_request("GET", "?#{paramstr}")
       return [] if (response.code == "204")
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "200")
       CloudFiles.lines(response.body)
     end
 
+    def storage_request(method, path = "", headers = {}, data = nil, attempts = 0, &block)
+      path = "#{@storagepath}/#{path}" unless (path[0,1] == '/')
+      cfreq(method, @storagehost, path, @storageport, @storagescheme, headers, data, attempts, &block)
+    end
+
+    def cdn_request(method, path = "", headers = {}, data = nil, attempts = 0, &block)
+      path = "#{@cdnmgmtpath}/#{path}" unless (path[0,1] == '/')
+      cfreq(method, @cdnmgmthost, path, @cdnmgmtport, @cdnmgmtscheme, headers, data, attempts, &block)
+    end
+
     # This method actually makes the HTTP calls out to the server
     def cfreq(method, server, path, port, scheme, headers = {}, data = nil, attempts = 0, &block) # :nodoc:
       start = Time.now
@@ -292,7 +302,11 @@ module CloudFiles
       response
     rescue Errno::EPIPE, Timeout::Error, Errno::EINVAL, EOFError, IOError
       # Server closed the connection, retry
-      raise CloudFiles::Exception::Connection, "Unable to reconnect to #{server.address} after #{attempts} attempts" if attempts >= 5
+      if attempts >= 5
+        host_str = server.respond_to?(:address) ? server.address : server
+        raise CloudFiles::Exception::Connection, "Unable to reconnect to #{host_str} after #{attempts} attempts", caller
+      end
+
       attempts += 1
       begin
         @http[server].finish
@@ -302,7 +316,7 @@ module CloudFiles
       start_http(server, path, port, scheme, headers)
       retry
     rescue ExpiredAuthTokenException
-      raise CloudFiles::Exception::Connection, "Authentication token expired and you have requested not to retry" if @retry_auth == false
+      raise CloudFiles::Exception::Connection, "Authentication token expired and you have requested not to retry", caller if @retry_auth == false
       CloudFiles::Authentication.new(self)
       retry
     end
@@ -329,8 +343,8 @@ module CloudFiles
             @http[server].verify_mode = OpenSSL::SSL::VERIFY_NONE
           end
           @http[server].start
-        rescue
-          raise CloudFiles::Exception::Connection, "Unable to connect to #{server.address}"
+        rescue Exception
+          raise CloudFiles::Exception::Connection, "Unable to connect to #{server.address}", caller
         end
       end
     end

data/lib/cloudfiles/container.rb

@@ -16,16 +16,6 @@ module CloudFiles
     def initialize(connection, name)
       @connection = connection
       @name = name
-      @storagehost = self.connection.storagehost
-      @storagepath = self.connection.storagepath + "/" + CloudFiles.escape(@name)
-      @storageport = self.connection.storageport
-      @storagescheme = self.connection.storagescheme
-      if self.connection.cdn_available?
-        @cdnmgmthost = self.connection.cdnmgmthost
-        @cdnmgmtpath = self.connection.cdnmgmtpath + "/" + CloudFiles.escape(@name) if self.connection.cdnmgmtpath
-        @cdnmgmtport = self.connection.cdnmgmtport
-        @cdnmgmtscheme = self.connection.cdnmgmtscheme
-      end
       # Load the metadata now, so we'll get a CloudFiles::Exception::NoSuchContainer exception should the container
       # not exist.
       self.container_metadata
@@ -51,11 +41,11 @@ module CloudFiles
     # Retrieves Metadata for the container
     def container_metadata
       @metadata ||= (
-        response = self.connection.cfreq("HEAD", @storagehost, @storagepath + "/", @storageport, @storagescheme)
+        response = self.connection.storage_request("HEAD", "#{escaped_name}/")
         raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code =~ /^20/)
         resphash = {}
         response.to_hash.select { |k,v| k.match(/^x-container-meta/) }.each { |x| resphash[x[0]] = x[1].to_s }
-        {:bytes => response["x-container-bytes-used"].to_i, :count => response["x-container-object-count"].to_i, :metadata => resphash}
+        {:bytes => response["x-container-bytes-used"].to_i, :count => response["x-container-object-count"].to_i, :metadata => resphash, :container_read => response["x-container-read"], :container_write => response["x-container-write"]}
       )
     end
 
@@ -64,13 +54,14 @@ module CloudFiles
       return @cdn_metadata if @cdn_metadata
       if cdn_available?
         @cdn_metadata = (
-          response = self.connection.cfreq("HEAD", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
+          response = self.connection.cdn_request("HEAD", escaped_name)
           cdn_enabled = ((response["x-cdn-enabled"] || "").downcase == "true") ? true : false
           {
             :cdn_enabled => cdn_enabled,
             :cdn_ttl => cdn_enabled ? response["x-ttl"].to_i : nil,
             :cdn_url => cdn_enabled ? response["x-cdn-uri"] : nil,
             :cdn_ssl_url => cdn_enabled ? response["x-cdn-ssl-uri"] : nil,
+            :cdn_streaming_url => cdn_enabled ? response["x-cdn-streaming-uri"] : nil,
             :user_agent_acl => response["x-user-agent-acl"],
             :referrer_acl => response["x-referrer-acl"],
             :cdn_log => (cdn_enabled and response["x-log-retention"] == "True") ? true : false
@@ -100,7 +91,7 @@ module CloudFiles
     def set_metadata(metadatahash)
       headers = {}
       metadatahash.each{ |key, value| headers['X-Container-Meta-' + CloudFiles.escape(key.to_s.capitalize)] = value.to_s }
-      response = self.connection.cfreq("POST", @storagehost, @storagepath, @storageport, @storagescheme, headers)
+      response = self.connection.storage_request("POST", escaped_name, headers)
       raise CloudFiles::Exception::NoSuchObject, "Container #{@name} does not exist" if (response.code == "404")
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
       true
@@ -108,12 +99,12 @@ module CloudFiles
     
     # Size of the container (in bytes)
     def bytes
-      self.metadata[:bytes]
+      self.container_metadata[:bytes]
     end
 
     # Number of objects in the container
     def count
-      self.metadata[:count]
+      self.container_metadata[:count]
     end
 
     # Returns true if the container is public and CDN-enabled.  Returns false otherwise.
@@ -145,6 +136,10 @@ module CloudFiles
     def cdn_ssl_url
       self.cdn_metadata[:cdn_ssl_url]
     end
+    # CDN Streaming container URL (if container is public)
+    def cdn_ssl_url
+      self.cdn_metadata[:cdn_streaming_url]
+    end
 
     # The container ACL on the User Agent
     def user_agent_acl
@@ -156,6 +151,16 @@ module CloudFiles
       self.cdn_metadata[:referrer_acl]
     end
 
+    #used by openstack swift
+    def read_acl
+      self.container_metadata[:container_read]
+    end
+
+    #used by openstack swift
+    def write_acl
+      self.container_metadata[:container_write]
+    end
+
     # Returns true if log retention is enabled on this container, false otherwise
     def cdn_log
       self.cdn_metadata[:cdn_log]
@@ -166,10 +171,10 @@ module CloudFiles
     # Change the log retention status for this container.  Values are true or false.
     #
     # These logs will be periodically (at unpredictable intervals) compressed and uploaded
-    # to a “.CDN_ACCESS_LOGS” container in the form of “container_name.YYYYMMDDHH-XXXX.gz”.
+    # to a ".CDN_ACCESS_LOGS" container in the form of "container_name.YYYYMMDDHH-XXXX.gz".
     def log_retention=(value)
       raise Exception::CDNNotAvailable unless cdn_available?
-      response = self.connection.cfreq("POST", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, {"x-log-retention" => value.to_s.capitalize})
+      response = self.connection.cdn_request("POST", escaped_name, {"x-log-retention" => value.to_s.capitalize})
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "201" or response.code == "202")
       return true
     end
@@ -216,7 +221,7 @@ module CloudFiles
           query << "#{param}=#{CloudFiles.escape(value.to_s)}"
         end
       end
-      response = self.connection.cfreq("GET", @storagehost, "#{@storagepath}?#{query.join '&'}", @storageport, @storagescheme)
+      response = self.connection.storage_request("GET", "#{escaped_name}?#{query.join '&'}")
       return [] if (response.code == "204")
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "200")
       return CloudFiles.lines(response.body)
@@ -249,7 +254,7 @@ module CloudFiles
           query << "#{param}=#{CloudFiles.escape(value.to_s)}"
         end
       end
-      response = self.connection.cfreq("GET", @storagehost, "#{@storagepath}?#{query.join '&'}", @storageport, @storagescheme)
+      response = self.connection.storage_request("GET", "#{escaped_name}?#{query.join '&'}")
       return {} if (response.code == "204")
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "200")
       doc = REXML::Document.new(response.body)
@@ -281,7 +286,7 @@ module CloudFiles
     #   container.object_exists?('badfile.txt')
     #   => false
     def object_exists?(objectname)
-      response = self.connection.cfreq("HEAD", @storagehost, "#{@storagepath}/#{CloudFiles.escape objectname}", @storageport, @storagescheme)
+      response = self.connection.storage_request("HEAD", "#{escaped_name}/#{CloudFiles.escape objectname}")
       return (response.code =~ /^20/)? true : false
     end
 
@@ -306,7 +311,7 @@ module CloudFiles
     #   container.delete_object('nonexistent_file.txt')
     #   => NoSuchObjectException: Object nonexistent_file.txt does not exist
     def delete_object(objectname)
-      response = self.connection.cfreq("DELETE", @storagehost, "#{@storagepath}/#{CloudFiles.escape objectname}", @storageport, @storagescheme)
+      response = self.connection.storage_request("DELETE", "#{escaped_name}/#{CloudFiles.escape objectname}")
       raise CloudFiles::Exception::NoSuchObject, "Object #{objectname} does not exist" if (response.code == "404")
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
       true
@@ -333,17 +338,43 @@ module CloudFiles
         options = {:ttl => ttl}
       end
 
-      response = self.connection.cfreq("PUT", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
+      response = self.connection.cdn_request("PUT", escaped_name)
       raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
 
       headers = { "X-TTL" => options[:ttl].to_s , "X-CDN-Enabled" => "True" }
       headers["X-User-Agent-ACL"] = options[:user_agent_acl] if options[:user_agent_acl]
       headers["X-Referrer-ACL"] = options[:referrer_acl] if options[:referrer_acl]
-      response = self.connection.cfreq("POST", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
+      response = post_with_headers(headers)
       raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
       refresh
       true
     end
+
+    # Only to be used with openstack swift
+    def set_write_acl(write_string)
+      refresh
+      headers = {"X-Container-Write" => write_string}
+      post_with_headers(headers)
+      true
+    end
+
+    # Only to be used with openstack swift
+    def set_read_acl(read_string)
+      refresh
+      headers = {"X-Container-Read" => read_string}
+      post_with_headers(headers)
+      true
+    end
+
+    def post_with_headers(headers = {})
+      if cdn_enabled?
+        response = self.connection.cdn_request("POST", escaped_name, headers)
+      else
+        response = self.connection.storage_request("POST", escaped_name, headers)
+      end
+      raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist (response code: #{response.code})" unless (response.code =~ /^20/)
+      response
+    end
    
     # Makes a container private and returns true upon success.  Throws NoSuchContainerException
     # if the container doesn't exist or if the request fails.
@@ -355,7 +386,7 @@ module CloudFiles
     def make_private
       raise Exception::CDNNotAvailable unless cdn_available?
       headers = { "X-CDN-Enabled" => "False" }
-      response = self.connection.cfreq("POST", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
+      response = self.connection.cdn_request("POST", escaped_name, headers)
       raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
       refresh
       true
@@ -380,15 +411,11 @@ module CloudFiles
     #   => true
     def purge_from_cdn(email=nil)
       raise Exception::CDNNotAvailable unless cdn_available?
-      if email
-          headers = {"X-Purge-Email" => email}
-          response = self.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
-          raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (response.code > "200" && response.code < "299")
-      else
-          response = self.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
-          raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (response.code > "200" && response.code < "299")
+      headers = {}
+      headers = {"X-Purge-Email" => email} if email
+      response = self.connection.cdn_request("DELETE", escaped_name, headers)
+      raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (response.code > "200" && response.code < "299")
       true
-      end
     end
 
     def to_s # :nodoc:
@@ -398,6 +425,10 @@ module CloudFiles
     def cdn_available?
       self.connection.cdn_available?
     end
+    
+    def escaped_name
+      CloudFiles.escape(@name)
+    end
 
   end
 

data/lib/cloudfiles/storage_object.rb

@@ -17,16 +17,8 @@ module CloudFiles
       @containername = container.name
       @name = objectname
       @make_path = make_path
-      @storagehost = self.container.connection.storagehost
-      @storagepath = self.container.connection.storagepath + "/#{CloudFiles.escape @containername}/#{CloudFiles.escape @name, '/'}"
-      @storageport = self.container.connection.storageport
-      @storagescheme = self.container.connection.storagescheme
-      if self.container.connection.cdn_available?
-        @cdnmgmthost = self.container.connection.cdnmgmthost
-        @cdnmgmtpath = self.container.connection.cdnmgmtpath + "/#{CloudFiles.escape @containername}/#{CloudFiles.escape @name, '/'}"
-        @cdnmgmtport = self.container.connection.cdnmgmtport
-        @cdnmgmtscheme = self.container.connection.cdnmgmtscheme
-      end
+      @storagepath = "#{CloudFiles.escape @containername}/#{CloudFiles.escape @name, '/'}"
+
       if force_exists
         raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless container.object_exists?(objectname)
       end
@@ -42,10 +34,15 @@ module CloudFiles
     # Retrieves Metadata for the object
     def object_metadata
       @object_metadata ||= (
-        response = self.container.connection.cfreq("HEAD", @storagehost, @storagepath, @storageport, @storagescheme)
+        response = self.container.connection.storage_request("HEAD", @storagepath)
         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 }
+        metas = response.to_hash.select { |k,v| k.match(/^x-object-meta/) }
+
+        metas.each do |x,y|
+          resphash[x] = (y.respond_to?(:join) ? y.join('') : y.to_s)
+        end
+
         {
           :manifest => response["x-object-manifest"],
           :bytes => response["content-length"],
@@ -76,6 +73,10 @@ module CloudFiles
     def content_type
       self.object_metadata[:content_type]
     end
+
+    def content_type=(type)
+      self.copy(:headers => {'Content-Type' => 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.
@@ -90,7 +91,7 @@ module CloudFiles
         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)
+      response = self.container.connection.storage_request("GET", @storagepath, headers)
       raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (response.code =~ /^20/)
       response.body
     end
@@ -114,7 +115,7 @@ module CloudFiles
         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|
+      self.container.connection.storage_request("GET", @storagepath, headers, nil) do |response|
         raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist. Response code #{response.code}" unless (response.code =~ /^20./)
         response.read_body(&block)
       end
@@ -139,11 +140,12 @@ module CloudFiles
     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)
+      response = self.container.connection.storage_request("POST", @storagepath, 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")
+      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
       true
     end
+    alias :metadata= :set_metadata
     
 
     # Returns the object's manifest.
@@ -162,7 +164,7 @@ module CloudFiles
     # fails.
     def set_manifest(manifest)
       headers = {'X-Object-Manifest' => manifest}
-      response = self.container.connection.cfreq("PUT", @storagehost, @storagepath, @storageport, @storagescheme, headers)
+      response = self.container.connection.storage_request("PUT", @storagepath, 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 =~ /^20/)
       true
@@ -209,7 +211,7 @@ 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.storage_request("PUT", @storagepath, headers, data)
       code = response.code
       raise CloudFiles::Exception::InvalidResponse, "Invalid content-length header sent" if (code == "412")
       raise CloudFiles::Exception::MisMatchedChecksum, "Mismatched etag" if (code == "422")
@@ -237,14 +239,10 @@ module CloudFiles
     #   => true
     def purge_from_cdn(email=nil)
       raise Exception::CDNNotAvailable unless cdn_available?
-      if email
-          headers = {"X-Purge-Email" => email}
-          response = self.container.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
-          raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
-      else
-          response = self.container.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
-          raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
-      end
+      headers = {}
+      headers = {"X-Purge-Email" => email} if email
+      response = self.container.connection.cdn_request("DELETE", @storagepath, headers)
+      raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
       true
     end
 
@@ -296,7 +294,7 @@ module CloudFiles
     #   object.save_to_filename("/tmp/owned_by_root.txt")
     #   => Errno::EACCES: Permission denied - /tmp/owned_by_root.txt
     def save_to_filename(filename)
-      File.open(filename, 'w+') do |f|
+      File.open(filename, 'wb+') do |f|
         self.data_stream do |chunk|
           f.write chunk
         end
@@ -315,7 +313,7 @@ module CloudFiles
       self.container.public? ? self.container.cdn_url + "/#{CloudFiles.escape @name, '/'}" : nil
     end
 
-        # If the parent container is public (CDN-enabled), returns the SSL CDN URL to this object.  Otherwise, return nil
+    # If the parent container is public (CDN-enabled), returns the SSL CDN URL to this object.  Otherwise, return nil
     #
     #   public_object.public_ssl_url
     #   => "https://c61.ssl.cf0.rackcdn.com/myfile.jpg"
@@ -326,6 +324,16 @@ module CloudFiles
       self.container.public? ? self.container.cdn_ssl_url + "/#{CloudFiles.escape @name, '/'}" : nil
     end
 
+    # If the parent container is public (CDN-enabled), returns the SSL CDN URL to this object.  Otherwise, return nil
+    #
+    #   public_object.public_streaming_url
+    #   => "https://c61.stream.rackcdn.com/myfile.jpg"
+    #
+    #   private_object.public_streaming_url
+    #   => nil
+    def public_streaming_url
+      self.container.public? ? self.container.cdn_streaming_url + "/#{CloudFiles.escape @name, '/'}" : nil
+    end
     
     # Copy this object to a new location (optionally in a new container)
     #
@@ -342,7 +350,7 @@ module CloudFiles
     #
     # 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])
+      raise CloudFiles::Exception::Syntax, "You must provide the :container, :name, or :headers for this operation" unless (options[:container] || options[:name] || options[:headers])
       new_container = options[:container] || self.container.name
       new_name = options[:name] || self.name
       new_headers = options[:headers] || {}
@@ -350,8 +358,8 @@ module CloudFiles
       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)
+      new_path = "#{CloudFiles.escape new_container}/#{CloudFiles.escape new_name, '/'}"
+      response = self.container.connection.storage_request("PUT", new_path, 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)

data/lib/cloudfiles/version.rb

@@ -1,3 +1,3 @@
 module CloudFiles
-  VERSION = '1.4.17'
+  VERSION = '1.4.18'
 end

data/test/cloudfiles_connection_test.rb

@@ -81,7 +81,49 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
       response = @connection.cfreq("HEAD", "test.server.example", "/dummypath", "80", "http")
     end
   end
-  
+
+  def test_storage_request
+    build_net_http_object
+    assert_nothing_raised do
+      response = @connection.storage_request("HEAD", "dummypath")
+    end
+  end
+
+  def test_storage_request_adds_path
+    build_net_http_object({}, {:method => "HEAD", :path => "#{@connection.storagepath}/dummypath"})
+    assert_nothing_raised do
+      response = @connection.storage_request("HEAD", "dummypath")
+    end
+  end
+
+  def test_storage_path_does_not_add_path_when_absolute
+    build_net_http_object({}, {:method => "HEAD", :path => "/dummypath"})
+    assert_nothing_raised do
+      response = @connection.storage_request("HEAD", "/dummypath")
+    end
+  end
+
+  def test_cdn_request
+    build_net_http_object
+    assert_nothing_raised do
+      response = @connection.cdn_request("HEAD", "dummypath")
+    end
+  end
+
+  def test_cdn_request_adds_path
+    build_net_http_object({}, {:method => "HEAD", :path => "#{@connection.cdnmgmtpath}/dummypath"})
+    assert_nothing_raised do
+      response = @connection.cdn_request("HEAD", "dummypath")
+    end
+  end
+
+  def test_cdn_path_does_not_add_path_when_absolute
+    build_net_http_object({}, {:method => "HEAD", :path => "/dummypath"})
+    assert_nothing_raised do
+      response = @connection.cdn_request("HEAD", "/dummypath")
+    end
+  end
+ 
   def test_net_http_raises_connection_exception
     Net::HTTP.expects(:new).raises(CloudFiles::Exception::Connection)
     assert_raises(CloudFiles::Exception::Connection) do
@@ -288,7 +330,8 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
     
   private
   
-  def build_net_http_object(args={:code => '204' }, cfreq_expectations={})
+  def build_net_http_object(args={}, cfreq_expectations={})
+    args.merge!(:code => '204') unless args[:code]
     args[:response] = {} unless args[:response]
     response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}.merge(args[:response])
     response.stubs(:code).returns(args[:code])

data/test/cloudfiles_container_test.rb

@@ -7,7 +7,8 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
+    connection.stubs(:cdn_request => response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.name, 'test_container'
     assert_equal @container.class, CloudFiles::Container
@@ -20,7 +21,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => false)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal 'test_container', @container.name
     assert_equal CloudFiles::Container, @container.class
@@ -31,7 +32,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('999')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     assert_raise(CloudFiles::Exception::NoSuchContainer) do
       @container = CloudFiles::Container.new(connection, 'test_container')
     end
@@ -41,7 +42,8 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'x-cdn-enabled' => 'True', 'x-cdn-uri' => 'http://cdn.test.example/container', 'x-ttl' => '86400'}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
+    connection.stubs(:cdn_request => response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.name, 'test_container'
     assert_equal @container.cdn_enabled, true
@@ -56,28 +58,28 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_make_private_succeeds
-    build_net_http_object(:code => '201')
+    build_net_http_object(:code => '201', :cdn_request => true)
     assert_nothing_raised do
       @container.make_private
     end
   end
   
   def test_make_private_fails
-    build_net_http_object(:code => '999')
+    build_net_http_object(:code => '999', :cdn_request => true)
     assert_raises(CloudFiles::Exception::NoSuchContainer) do
       @container.make_private
     end
   end
   
   def test_make_public_succeeds
-    build_net_http_object(:code => '201')
+    build_net_http_object(:code => '201', :cdn_request => true)
     assert_nothing_raised do
       @container.make_public
     end
   end
   
   def test_make_public_fails
-    build_net_http_object(:code => '999')
+    build_net_http_object(:code => '999', :cdn_request => true)
     assert_raises(CloudFiles::Exception::NoSuchContainer) do
       @container.make_public
     end
@@ -87,7 +89,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.empty?, false
   end
@@ -96,16 +98,80 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '0', 'x-container-object-count' => '0'}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.empty?, true
   end
+
+  def build_acl_test_state(opts={})
+    @connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdn_available? => false)
+
+    @response = {
+      'x-container-bytes-used' => '0',
+      'x-container-object-count' => '0',
+    }.merge(opts.fetch(:response, {}))
+
+    @response.stubs(:code).returns(opts.fetch(:code, '204'))
+    @connection.stubs(:storage_request => @response)
+    @container = CloudFiles::Container.new(@connection, 'test_container')
+  end
   
+  def test_read_acl_is_set_from_headers
+    build_acl_test_state :response => { 'x-container-read' => '.r:*' }, :code => '204'
+    assert_equal @response["x-container-read"], @container.read_acl
+  end
+
+  def test_set_read_acl_fails
+    build_acl_test_state
+
+    response = stub(:code => '999')
+
+    @connection.stubs(:storage_request => response)
+
+    assert_raises(CloudFiles::Exception::NoSuchContainer) do
+      @container.set_read_acl('.r:*')
+    end
+  end
+
+  def test_set_read_acl_succeeds
+    build_acl_test_state
+
+    @connection.stubs(:storage_request => stub(:code => '204'))
+
+    assert_equal @container.set_read_acl('.r:*'), true
+  end
+
+  def test_write_acl_is_set_from_headers
+    build_acl_test_state :response => { 'x-container-write' => '.r:*' }, :code => '204'
+    assert_equal @response["x-container-write"], @container.write_acl
+  end
+
+  def test_set_write_acl_fails
+    build_acl_test_state
+
+    response = stub(:code => '999')
+
+    @connection.stubs(:storage_request => response)
+
+    assert_raises(CloudFiles::Exception::NoSuchContainer) do
+      @container.set_write_acl('.r:*')
+    end
+  end
+
+  def test_set_write_acl_succeeds
+    build_acl_test_state
+
+    @connection.stubs(:storage_request => stub(:code => '204'))
+
+    assert_equal @container.set_write_acl('.r:*'), true
+  end
+
   def test_log_retention_is_true
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '0', 'x-container-object-count' => '0', 'x-cdn-enabled' => 'True', 'x-log-retention' => 'True'}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:cdn_request => response)
+    connection.stubs(:storage_request => response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.log_retention?, true
   end
@@ -247,12 +313,12 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_setting_log_retention
-    build_net_http_object(:code => '201')
+    build_net_http_object(:code => '201', :cdn_request => true)
     assert(@container.log_retention='false')
   end
   
   def test_purge_from_cdn_succeeds
-    build_net_http_object
+    build_net_http_object(:cdn_request => true)
     assert_nothing_raised do
       @container.purge_from_cdn
       @container.purge_from_cdn("small.fox@hole.org")
@@ -261,7 +327,8 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   
   private
   
-  def build_net_http_object(args={:code => '204' }, cfreq_expectations={})
+  def build_net_http_object(args={}, cfreq_expectations={})
+    args.merge!(:code => '204') unless args[:code]
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
     CloudFiles::Container.any_instance.stubs(:metadata).returns()
     CloudFiles::Container.any_instance.stubs(:container_metadata).returns({:bytes => 99, :count => 2})
@@ -274,20 +341,22 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     if !cfreq_expectations.empty?
       #cfreq(method,server,path,port,scheme,headers = {},data = nil,attempts = 0,&block)
       
-      parameter_expectations = [anything(), anything(), anything(), anything(), anything(), anything(), anything(), anything()]
+      parameter_expectations = [anything(), anything(), anything(), anything(), anything(), anything()]
       parameter_expectations[0] = cfreq_expectations[:method] if cfreq_expectations[:method]
-      parameter_expectations[2] = cfreq_expectations[:path] if cfreq_expectations[:path]
+      parameter_expectations[1] = cfreq_expectations[:path] if cfreq_expectations[:path]
       
-      connection.expects(:cfreq).with(*parameter_expectations).returns(response)
+      connection.expects(:cdn_request).with(*parameter_expectations).returns(response) if args[:cdn_request]
+      connection.expects(:storage_request).with(*parameter_expectations).returns(response)
     else  
-      connection.stubs(:cfreq => response)
+      connection.stubs(:cdn_request => response) if args[:cdn_request]
+      connection.stubs(:storage_request => response)
     end
     
     @container = CloudFiles::Container.new(connection, 'test_container')
     @container.stubs(:connection).returns(connection)
   end
   
-  def build_net_http_object_with_cfreq_expectations(args={:code => '204'}, cfreq_expectations={})
+  def build_net_http_object_with_cfreq_expectations(args={}, cfreq_expectations={})
     build_net_http_object(args, cfreq_expectations)
   end
 end

data/test/cloudfiles_storage_object_test.rb

@@ -7,7 +7,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     container = CloudFiles::Container.new(connection, 'test_container')
     @object = CloudFiles::StorageObject.new(container, 'test_object')
     assert_equal @object.name, 'test_object'
@@ -19,7 +19,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => false)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     container = CloudFiles::Container.new(connection, 'test_container')
     @object = CloudFiles::StorageObject.new(container, 'test_object')
     assert_equal @object.name, 'test_object'
@@ -28,7 +28,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   end
   
   def test_public_url_exists
-    build_net_http_object(:public => true, :name => 'test object')
+    build_net_http_object(:public => true, :name => 'test object', :cdn_request => true)
     assert_equal @object.public_url, "http://cdn.test.example/test%20object"
   end
   
@@ -109,12 +109,12 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   
   def test_read_metadata_succeeds
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
-    response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'x-object-meta-foo' => 'Bar', 'last-modified' => Time.now.to_s}
+    response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'x-object-meta-foo' => 'Bar', 'x-object-meta-spam' => ['peanut', 'butter'], 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     container = CloudFiles::Container.new(connection, 'test_container')
     @object = CloudFiles::StorageObject.new(container, 'test_object')
-    assert_equal @object.metadata, {'foo' => 'Bar'}
+    assert_equal @object.metadata, {'foo' => 'Bar', 'spam' => 'peanutbutter'}
   end
   
   def test_write_succeeds
@@ -130,7 +130,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204').then.returns('204').then.returns('201').then.returns('204')
-    connection.stubs(:cfreq => response)
+    connection.stubs(:storage_request => response)
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
     container = CloudFiles::Container.new(connection, 'test_container')
     @object = CloudFiles::StorageObject.new(container, 'path/to/my/test_object', false, true)
@@ -162,7 +162,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   end
   
   def test_purge_from_cdn_succeeds
-    build_net_http_object
+    build_net_http_object(:cdn_request => true)
     assert_nothing_raised do
       @object.purge_from_cdn
       @object.purge_from_cdn("small.fox@hole.org")
@@ -198,8 +198,9 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   end
   
   private
-  
-  def build_net_http_object(args={:code => '204' })
+
+  def build_net_http_object(args={})
+    args.merge!(:code => '204' ) unless args[:code]
     CloudFiles::Container.any_instance.stubs(:metadata).returns({})
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
     CloudFiles::Container.any_instance.stubs(:container_metadata).returns({:bytes => 99, :count => 2})
@@ -208,7 +209,11 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token', 'last-modified' => Time.now.to_s}.merge(args[:response])
     response.stubs(:code).returns(args[:code])
     response.stubs(:body).returns args[:body] || nil
-    connection.stubs(:cfreq => response)
+
+    connection.stubs(:cdn_request => response) if args[:cdn_request]
+
+    connection.stubs(:storage_request => response)
+
     container = CloudFiles::Container.new(connection, 'test_container')
     container.stubs(:connection).returns(connection)
     container.stubs(:public?).returns(args[:public] || false)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cloudfiles
 version: !ruby/object:Gem::Version 
-  hash: 37
+  hash: 35
   prerelease: 
   segments: 
   - 1
   - 4
-  - 17
-  version: 1.4.17
+  - 18
+  version: 1.4.18
 platform: ruby
 authors: 
 - H. Wade Minter
@@ -16,7 +16,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-27 00:00:00 Z
+date: 2011-09-28 00:00:00 -04:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: mime-types
@@ -81,6 +82,7 @@ files:
 - test/cloudfiles_container_test.rb
 - test/cloudfiles_storage_object_test.rb
 - test/test_helper.rb
+has_rdoc: true
 homepage: http://www.rackspacecloud.com/cloud_hosting_products/files
 licenses: []
 
@@ -110,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.6.0
 signing_key: 
 specification_version: 3
 summary: A Ruby API into Rackspace Cloud Files