rackspace-cloudfiles 1.3.0.7 → 1.4.0.0

data/README.rdoc

@@ -1,8 +1,8 @@
-= Mosso Cloud Files
+= Rackspace Cloud Files
 
 == Description
 
-This is a Ruby interface into the Rackspace[http://rackspace.com/] {Mosso Cloud Files}[http://www.mosso.com/cloudfiles.jsp] service. Cloud Files is reliable, scalable and affordable web-based storage hosting for backing up and archiving all your static content.  Cloud Files is the first and only cloud service that leverages a tier one CDN provider to create such an easy and complete storage-to-delivery solution for media content.
+This is a Ruby interface into the Rackspace[http://rackspace.com/] {Cloud Files}[http://www.rackspacecloud.com/cloud_hosting_products/files] service. Cloud Files is reliable, scalable and affordable web-based storage hosting for backing up and archiving all your static content.  Cloud Files is the first and only cloud service that leverages a tier one CDN provider to create such an easy and complete storage-to-delivery solution for media content.
 
 == Installation
 

data/Rakefile

@@ -7,9 +7,9 @@ echoe = Echoe.new('cloudfiles') do |p|
   p.author = ["H. Wade Minter", "Rackspace Hosting"]
   p.email = 'wade.minter@rackspace.com'
   p.version = CloudFiles::VERSION
-  p.summary = "A Ruby API into Mosso Cloud Files"
-  p.description = 'A Ruby version of the Mosso Cloud Files API.'
-  p.url = "http://www.mosso.com/cloudfiles.jsp"
+  p.summary = "A Ruby API into Rackspace Cloud Files"
+  p.description = 'A Ruby version of the Rackspace Cloud Files API.'
+  p.url = "http://www.rackspacecloud.com/cloud_hosting_products/files"
   p.runtime_dependencies = ["mime-types >=1.0"]
 end
 

data/cloudfiles.gemspec

@@ -2,22 +2,22 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cloudfiles}
-  s.version = "1.3.0.7"
+  s.version = "1.4.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["H. Wade Minter, Rackspace Hosting"]
-  s.date = %q{2009-07-28}
-  s.description = %q{A Ruby version of the Mosso Cloud Files API.}
+  s.date = %q{2009-08-08}
+  s.description = %q{A Ruby version of the Rackspace Cloud Files API.}
   s.email = %q{wade.minter@rackspace.com}
   s.extra_rdoc_files = ["lib/cloudfiles/authentication.rb", "lib/cloudfiles/connection.rb", "lib/cloudfiles/container.rb", "lib/cloudfiles/storage_object.rb", "lib/cloudfiles.rb", "README.rdoc", "TODO"]
   s.files = ["cloudfiles.gemspec", "lib/cloudfiles/authentication.rb", "lib/cloudfiles/connection.rb", "lib/cloudfiles/container.rb", "lib/cloudfiles/storage_object.rb", "lib/cloudfiles.rb", "Manifest", "Rakefile", "README.rdoc", "test/cf-testunit.rb", "test/cloudfiles_authentication_test.rb", "test/cloudfiles_connection_test.rb", "test/cloudfiles_container_test.rb", "test/cloudfiles_storage_object_test.rb", "test/test_helper.rb", "TODO"]
   s.has_rdoc = true
-  s.homepage = %q{http://www.mosso.com/cloudfiles.jsp}
+  s.homepage = %q{http://www.rackspacecloud.com/cloud_hosting_products/files}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Cloudfiles", "--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{cloudfiles}
   s.rubygems_version = %q{1.3.1}
-  s.summary = %q{A Ruby API into Mosso Cloud Files}
+  s.summary = %q{A Ruby API into Rackspace Cloud Files}
   s.test_files = ["test/cloudfiles_authentication_test.rb", "test/cloudfiles_connection_test.rb", "test/cloudfiles_container_test.rb", "test/cloudfiles_storage_object_test.rb", "test/test_helper.rb"]
 
   if s.respond_to? :specification_version then

data/lib/cloudfiles.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # 
 # == Cloud Files API
-# ==== Connects Ruby Applications to Rackspace's {Mosso Cloud Files service}[http://www.mosso.com/cloudfiles.jsp]
+# ==== Connects Ruby Applications to Rackspace's {Cloud Files service}[http://www.rackspacecloud.com/cloud_hosting_products/files]
 # Initial work by Major Hayden <major.hayden@rackspace.com>
 # 
 # Subsequent work by H. Wade Minter <wade.minter@rackspace.com>
@@ -18,7 +18,7 @@
 # To create a new CloudFiles connection, use the CloudFiles::Connection.new('user_name', 'api_key') method.
 module CloudFiles
 
-  VERSION = '1.3.0.7'
+  VERSION = '1.4.0.0'
   require 'net/http'
   require 'net/https'
   require 'rexml/document'

data/lib/cloudfiles/authentication.rb

@@ -24,8 +24,12 @@ module CloudFiles
       if (response.code == "204")
         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
         connection.storagehost = 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
         connection.authtoken = response["x-auth-token"]
         connection.authok = true
       else

data/lib/cloudfiles/connection.rb

@@ -17,6 +17,12 @@ module CloudFiles
 
     # Path for managing containers on the CDN management server
     attr_accessor :cdnmgmtpath
+    
+    # Port number for the CDN server
+    attr_accessor :cdnmgmtport
+    
+    # URI scheme for the CDN server
+    attr_accessor :cdnmgmtscheme
 
     # Hostname of the storage server
     attr_accessor :storagehost
@@ -24,6 +30,12 @@ module CloudFiles
     # Path for managing containers/objects on the storage server
     attr_accessor :storagepath
     
+    # Port for managing the storage server
+    attr_accessor :storageport
+    
+    # URI scheme for the storage server
+    attr_accessor :storagescheme
+    
     # Instance variable that is set when authorization succeeds
     attr_accessor :authok
     
@@ -34,7 +46,7 @@ module CloudFiles
     attr_reader :count
 
     # Creates a new CloudFiles::Connection object.  Uses CloudFiles::Authentication to perform the login for the connection.
-    # The authuser is the Mosso username, the authkey is the Mosso API key.
+    # The authuser is the Rackspace Cloud username, the authkey is the Rackspace Cloud API key.
     #
     # Setting the optional retry_auth variable to false will cause an exception to be thrown if your authorization token expires.
     # Otherwise, it will attempt to reauthenticate.
@@ -78,7 +90,7 @@ module CloudFiles
     #   cf.bytes
     #   => 42438527    
     def get_info
-      response = cfreq("HEAD",@storagehost,@storagepath)
+      response = cfreq("HEAD",@storagehost,@storagepath,@storageport,@storagescheme)
       raise InvalidResponseException, "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
@@ -102,7 +114,7 @@ module CloudFiles
       paramarr << ["limit=#{URI.encode(limit.to_s).gsub(/&/,'%26')}"] if limit.to_i > 0
       paramarr << ["offset=#{URI.encode(marker.to_s).gsub(/&/,'%26')}"] unless marker.to_s.empty?
       paramstr = (paramarr.size > 0)? paramarr.join("&") : "" ;
-      response = cfreq("GET",@storagehost,"#{@storagepath}?#{paramstr}")
+      response = cfreq("GET",@storagehost,"#{@storagepath}?#{paramstr}",@storageport,@storagescheme)
       return [] if (response.code == "204")
       raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "200")
       CloudFiles.lines(response.body)
@@ -124,7 +136,7 @@ module CloudFiles
       paramarr << ["limit=#{URI.encode(limit.to_s).gsub(/&/,'%26')}"] if limit.to_i > 0
       paramarr << ["offset=#{URI.encode(marker.to_s).gsub(/&/,'%26')}"] unless marker.to_s.empty?
       paramstr = (paramarr.size > 0)? paramarr.join("&") : "" ;
-      response = cfreq("GET",@storagehost,"#{@storagepath}?format=xml&#{paramstr}")
+      response = cfreq("GET",@storagehost,"#{@storagepath}?format=xml&#{paramstr}",@storageport,@storagescheme)
       return {} if (response.code == "204")
       raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "200")
       doc = REXML::Document.new(response.body)
@@ -145,7 +157,7 @@ module CloudFiles
     #   cf.container_exists?('bad_container')
     #   => false
     def container_exists?(containername)
-      response = cfreq("HEAD",@storagehost,"#{@storagepath}/#{containername}")
+      response = cfreq("HEAD",@storagehost,"#{@storagepath}/#{containername}",@storageport,@storagescheme)
       return (response.code == "204")? true : false ;
     end
 
@@ -164,7 +176,7 @@ module CloudFiles
     def create_container(containername)
       raise SyntaxException, "Container name cannot contain the characters '/' or '?'" if containername.match(/[\/\?]/)
       raise SyntaxException, "Container name is limited to 256 characters" if containername.length > 256
-      response = cfreq("PUT",@storagehost,"#{@storagepath}/#{containername}")
+      response = cfreq("PUT",@storagehost,"#{@storagepath}/#{containername}",@storageport,@storagescheme)
       raise InvalidResponseException, "Unable to create container #{containername}" unless (response.code == "201" || response.code == "202")
       CloudFiles::Container.new(self,containername)
     end
@@ -181,7 +193,7 @@ module CloudFiles
     #   cf.delete_container('nonexistent')
     #   => NoSuchContainerException: Container nonexistent does not exist
     def delete_container(containername)
-      response = cfreq("DELETE",@storagehost,"#{@storagepath}/#{containername}")
+      response = cfreq("DELETE",@storagehost,"#{@storagepath}/#{containername}",@storageport,@storagescheme)
       raise NonEmptyContainerException, "Container #{containername} is not empty" if (response.code == "409")
       raise NoSuchContainerException, "Container #{containername} does not exist" unless (response.code == "204")
       true
@@ -198,18 +210,18 @@ module CloudFiles
     #   => ["video", "webpics"]
     def public_containers(enabled_only = false)
       paramstr = enabled_only == true ? "enabled_only=true" : ""
-      response = cfreq("GET",@cdnmgmthost,"#{@cdnmgmtpath}?#{paramstr}")
+      response = cfreq("GET",@cdnmgmthost,"#{@cdnmgmtpath}?#{paramstr}",@cdnmgmtport,@cdnmgmtscheme)
       return [] if (response.code == "204")
       raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "200")
       CloudFiles.lines(response.body)
     end
 
     # This method actually makes the HTTP calls out to the server
-    def cfreq(method,server,path,headers = {},data = nil,attempts = 0,&block) # :nodoc:
+    def cfreq(method,server,path,port,scheme,headers = {},data = nil,attempts = 0,&block) # :nodoc:
       start = Time.now
       headers['Transfer-Encoding'] = "chunked" if data.is_a?(IO)
       hdrhash = headerprep(headers)
-      start_http(server,path,hdrhash)
+      start_http(server,path,port,scheme,hdrhash)
       request = Net::HTTP.const_get(method.to_s.capitalize).new(path,hdrhash)
       if data
         if data.respond_to?(:read)
@@ -231,7 +243,7 @@ module CloudFiles
       raise ConnectionException, "Unable to reconnect to #{server} after #{count} attempts" if attempts >= 5
       attempts += 1
       @http[server].finish
-      start_http(server,path,headers)
+      start_http(server,path,port,scheme,headers)
       retry
     rescue ExpiredAuthTokenException
       raise ConnectionException, "Authentication token expired and you have requested not to retry" if @retry_auth == false
@@ -252,12 +264,14 @@ module CloudFiles
     end
     
     # Starts (or restarts) the HTTP connection
-    def start_http(server,path,headers) # :nodoc:
+    def start_http(server,path,port,scheme,headers) # :nodoc:
       if (@http[server].nil?)
         begin
-          @http[server] = Net::HTTP.new(server,443)
-          @http[server].use_ssl = true
-          @http[server].verify_mode = OpenSSL::SSL::VERIFY_NONE
+          @http[server] = Net::HTTP.new(server,port)
+          if scheme == "https"
+            @http[server].use_ssl = true
+            @http[server].verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
           @http[server].start
         rescue
           raise ConnectionException, "Unable to connect to #{server}"

data/lib/cloudfiles/container.rb

@@ -33,8 +33,12 @@ module CloudFiles
       @name = name
       @storagehost = self.connection.storagehost
       @storagepath = self.connection.storagepath + "/" + URI.encode(@name).gsub(/&/,'%26')
+      @storageport = self.connection.storageport
+      @storagescheme = self.connection.storagescheme
       @cdnmgmthost = self.connection.cdnmgmthost
       @cdnmgmtpath = self.connection.cdnmgmtpath + "/" + URI.encode(@name).gsub(/&/,'%26')
+      @cdnmgmtport = self.connection.cdnmgmtport
+      @cdnmgmtscheme = self.connection.cdnmgmtscheme
       populate
     end
 
@@ -52,20 +56,41 @@ module CloudFiles
     #   => 3
     def populate
       # Get the size and object count
-      response = self.connection.cfreq("HEAD",@storagehost,@storagepath+"/")
+      response = self.connection.cfreq("HEAD",@storagehost,@storagepath+"/",@storageport,@storagescheme)
       raise NoSuchContainerException, "Container #{@name} does not exist" unless (response.code == "204")
       @bytes = response["x-container-bytes-used"].to_i
       @count = response["x-container-object-count"].to_i
 
       # Get the CDN-related details
-      response = self.connection.cfreq("HEAD",@cdnmgmthost,@cdnmgmtpath)
+      response = self.connection.cfreq("HEAD",@cdnmgmthost,@cdnmgmtpath,@cdnmgmtport,@cdnmgmtscheme)
       @cdn_enabled = ((response["x-cdn-enabled"] || "").downcase == "true") ? true : false
       @cdn_ttl = @cdn_enabled ? response["x-ttl"] : false
       @cdn_url = @cdn_enabled ? response["x-cdn-uri"] : false
+      if @cdn_enabled
+        @cdn_log = response["x-log-retention"] == "False" ? false : true
+      else
+        @cdn_log = false
+      end
 
       true
     end
     alias :refresh :populate
+    
+    # Returns true if log retention is enabled on this container, false otherwise
+    def log_retention?
+      @cdn_log
+    end
+    
+    # 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”.
+    def log_retention=(value)
+      response = self.connection.cfreq("POST",@cdnmgmthost,@cdnmgmtpath,@cdnmgmtport,@cdnmgmtscheme,{"x-log-retention" => value.to_s.capitalize})
+      raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "201" or response.code == "202")
+      return true 
+    end
+      
 
     # Returns the CloudFiles::StorageObject for the named object.  Refer to the CloudFiles::StorageObject class for available
     # methods.  If the object exists, it will be returned.  If the object does not exist, a NoSuchObjectException will be thrown.
@@ -105,7 +130,7 @@ module CloudFiles
       paramarr << ["prefix=#{URI.encode(params[:prefix]).gsub(/&/,'%26')}"] if params[:prefix]
       paramarr << ["path=#{URI.encode(params[:path]).gsub(/&/,'%26')}"] if params[:path]
       paramstr = (paramarr.size > 0)? paramarr.join("&") : "" ;
-      response = self.connection.cfreq("GET",@storagehost,"#{@storagepath}?#{paramstr}")
+      response = self.connection.cfreq("GET",@storagehost,"#{@storagepath}?#{paramstr}",@storageport,@storagescheme)
       return [] if (response.code == "204")
       raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "200")
       return CloudFiles.lines(response.body)
@@ -136,7 +161,7 @@ module CloudFiles
       paramarr << ["prefix=#{URI.encode(params[:prefix]).gsub(/&/,'%26')}"] if params[:prefix]
       paramarr << ["path=#{URI.encode(params[:path]).gsub(/&/,'%26')}"] if params[:path]
       paramstr = (paramarr.size > 0)? paramarr.join("&") : "" ;
-      response = self.connection.cfreq("GET",@storagehost,"#{@storagepath}?#{paramstr}")
+      response = self.connection.cfreq("GET",@storagehost,"#{@storagepath}?#{paramstr}",@storageport,@storagescheme)
       return {} if (response.code == "204")
       raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "200")
       doc = REXML::Document.new(response.body)
@@ -179,7 +204,7 @@ module CloudFiles
     #   container.object_exists?('badfile.txt')
     #   => false
     def object_exists?(objectname)
-      response = self.connection.cfreq("HEAD",@storagehost,"#{@storagepath}/#{URI.encode(objectname).gsub(/&/,'%26')}")
+      response = self.connection.cfreq("HEAD",@storagehost,"#{@storagepath}/#{URI.encode(objectname).gsub(/&/,'%26')}",@storageport,@storagescheme)
       return (response.code == "204")? true : false
     end
 
@@ -204,7 +229,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}/#{URI.encode(objectname).gsub(/&/,'%26')}")
+      response = self.connection.cfreq("DELETE",@storagehost,"#{@storagepath}/#{URI.encode(objectname).gsub(/&/,'%26')}",@storageport,@storagescheme)
       raise NoSuchObjectException, "Object #{objectname} does not exist" if (response.code == "404")
       raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "204")
       true
@@ -218,11 +243,11 @@ module CloudFiles
     #   container.make_public(432000)
     #   => true
     def make_public(ttl = 86400)
-      response = self.connection.cfreq("PUT",@cdnmgmthost,@cdnmgmtpath)
+      response = self.connection.cfreq("PUT",@cdnmgmthost,@cdnmgmtpath,@cdnmgmtport,@cdnmgmtscheme)
       raise NoSuchContainerException, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
 
       headers = { "X-TTL" => ttl.to_s }
-      response = self.connection.cfreq("POST",@cdnmgmthost,@cdnmgmtpath,headers)
+      response = self.connection.cfreq("POST",@cdnmgmthost,@cdnmgmtpath,@cdnmgmtport,@cdnmgmtscheme,headers)
       raise NoSuchContainerException, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
       true
     end
@@ -236,7 +261,7 @@ module CloudFiles
     #   => true
     def make_private
       headers = { "X-CDN-Enabled" => "False" }
-      response = self.connection.cfreq("POST",@cdnmgmthost,@cdnmgmtpath,headers)
+      response = self.connection.cfreq("POST",@cdnmgmthost,@cdnmgmtpath,@cdnmgmtport,@cdnmgmtscheme,headers)
       raise NoSuchContainerException, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
       true
     end

data/lib/cloudfiles/storage_object.rb

@@ -34,6 +34,8 @@ module CloudFiles
       @make_path = make_path
       @storagehost = self.container.connection.storagehost
       @storagepath = self.container.connection.storagepath+"/#{URI.encode(@containername).gsub(/&/,'%26')}/#{URI.encode(@name).gsub(/&/,'%26')}"
+      @storageport = self.container.connection.storageport
+      @storagescheme = self.container.connection.storagescheme
       if container.object_exists?(objectname)
         populate
       else
@@ -44,14 +46,14 @@ module CloudFiles
     # 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)
+      response = self.container.connection.cfreq("HEAD",@storagehost,@storagepath,@storageport,@storagescheme)
       raise NoSuchObjectException, "Object #{@name} does not exist" if (response.code != "204")
       @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][0].to_s }
+      response.to_hash.select { |k,v| k.match(/^x-object-meta/) }.each { |x| resphash[x[0]] = x[1].to_s }
       @metadata = resphash
       true
     end
@@ -70,7 +72,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,headers)
+      response = self.container.connection.cfreq("GET",@storagehost,@storagepath,@storageport,@storagescheme,headers)
       raise NoSuchObjectException, "Object #{@name} does not exist" unless (response.code =~ /^20/)
       response.body.chomp
     end
@@ -93,7 +95,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,headers,nil) do |response|
+      self.container.connection.cfreq("GET",@storagehost,@storagepath,@storageport,@storagescheme,headers,nil) do |response|
         raise NoSuchObjectException, "Object #{@name} does not exist" unless (response.code == "200")
         response.read_body(&block)
       end
@@ -118,7 +120,7 @@ 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,headers)
+      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")
       true
@@ -164,10 +166,11 @@ 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}",headers,data)
-      raise InvalidResponseException, "Invalid content-length header sent" if (response.code == "412")
-      raise MisMatchedChecksumException, "Mismatched etag" if (response.code == "422")
-      raise InvalidResponseException, "Invalid response code #{response.code}" unless (response.code == "201")
+      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")
       make_path(File.dirname(self.name)) if @make_path == true
       self.populate
       true
@@ -223,7 +226,7 @@ module CloudFiles
     # If the parent container is public (CDN-enabled), returns the CDN URL to this object.  Otherwise, return nil
     #
     #   public_object.public_url
-    #   => "http://cdn.cloudfiles.mosso.com/c10181/rampage.jpg"
+    #   => "http://c0001234.cdn.cloudfiles.rackspacecloud.com/myfile.jpg"
     #
     #   private_object.public_url
     #   => nil

data/test/cloudfiles_authentication_test.rb

@@ -9,7 +9,7 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
     server.stubs(:get).returns(response)
     Net::HTTP.stubs(:new).returns(server)
-    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :storagehost= => true, :storagepath= => true, :authtoken= => true, :authok= => true)
+    @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)
     result = CloudFiles::Authentication.new(@connection)
     assert_equal result.class, CloudFiles::Authentication
   end

data/test/cloudfiles_connection_test.rb

@@ -26,35 +26,35 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   def test_cfreq_get
     build_net_http_object
     assert_nothing_raised do 
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath")
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
     end
   end
   
   def test_cfreq_post
     build_net_http_object
     assert_nothing_raised do
-      response = @connection.cfreq("POST", "test.server.example", "/dummypath")
+      response = @connection.cfreq("POST", "test.server.example", "/dummypath", "80", "http")
     end
   end
   
   def test_cfreq_put
     build_net_http_object
     assert_nothing_raised do
-      response = @connection.cfreq("PUT", "test.server.example", "/dummypath")
+      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http")
     end
   end
   
   def test_cfreq_delete
     build_net_http_object
     assert_nothing_raised do
-      response = @connection.cfreq("DELETE", "test.server.example", "/dummypath")
+      response = @connection.cfreq("DELETE", "test.server.example", "/dummypath", "80", "http")
     end
   end
   
   def test_cfreq_with_static_data
     build_net_http_object
     assert_nothing_raised do
-      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", {}, "This is string data")
+      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http", {}, "This is string data")
     end
   end
   
@@ -63,32 +63,32 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
     require 'tempfile'
     file = Tempfile.new("test")
     assert_nothing_raised do
-      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", {}, file)
+      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http", {}, file)
     end
   end
   
   def test_cfreq_head
     build_net_http_object
     assert_nothing_raised do
-      response = @connection.cfreq("HEAD", "test.server.example", "/dummypath")
+      response = @connection.cfreq("HEAD", "test.server.example", "/dummypath", "80", "http")
     end
   end
   
   def test_net_http_raises_connection_exception
     Net::HTTP.expects(:new).raises(ConnectionException)
     assert_raises(ConnectionException) do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath")
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
     end
   end
   
   def test_net_http_raises_one_eof_exception
     response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
     response.stubs(:code).returns('204')
-    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
+    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
     server.stubs(:request).raises(EOFError).then.returns(response)
     Net::HTTP.stubs(:new).returns(server)
     assert_nothing_raised do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath")
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "443", "https")
     end
   end
   
@@ -96,23 +96,23 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
     CloudFiles::Authentication.expects(:new).returns(true)
     response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
     response.stubs(:code).returns('401').then.returns('204')
-    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true)
+    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true)
     server.stubs(:request).returns(response)
     Net::HTTP.stubs(:new).returns(server)
     assert_nothing_raised do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath")
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
     end
   end
   
   def test_net_http_raises_continual_eof_exceptions
     response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
     response.stubs(:code).returns('204')
-    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true)
+    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true)
     server.stubs(:finish).returns(true)
     server.stubs(:request).raises(EOFError)
     Net::HTTP.stubs(:new).returns(server)
     assert_raises(ConnectionException) do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath")
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
     end
   end
   

data/test/cloudfiles_container_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/test_helper'
 class CloudfilesContainerTest < Test::Unit::TestCase
   
   def test_object_creation
-    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -16,7 +16,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_object_creation_no_such_container
-    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('999')
     connection.stubs(:cfreq => response)
@@ -26,7 +26,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_object_creation_with_cdn
-    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     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)
@@ -72,7 +72,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_empty_is_false
-    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -81,7 +81,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_empty_is_true
-    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     response = {'x-container-bytes-used' => '0', 'x-container-object-count' => '0'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -89,6 +89,15 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     assert_equal @container.empty?, true
   end
   
+  def test_log_retention_is_true
+    connection = mock(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    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)
+    @container = CloudFiles::Container.new(connection, 'test_container')
+    assert_equal @container.log_retention?, true
+  end
+  
   def test_object_fetch
     build_net_http_object(:code => '204', :response => {'last-modified' => 'Wed, 28 Jan 2009 16:16:26 GMT'})
     object = @container.object('good_object')
@@ -166,26 +175,21 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     end
   end
   
+  def test_setting_log_retention
+    build_net_http_object(:code => '201')
+    assert(@container.log_retention='false')
+  end
+  
   private
   
   def build_net_http_object(args={:code => '204' })
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     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', '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)
-    #server = mock()
-    #server.stubs(:verify_mode= => true)
-    #server.stubs(:start => true)
-    #server.stubs(:use_ssl=).returns(true)
-    #server.stubs(:get).returns(response)
-    #server.stubs(:post).returns(response)
-    #server.stubs(:put).returns(response)
-    #server.stubs(:head).returns(response)
-    #server.stubs(:delete).returns(response)
-    #Net::HTTP.stubs(:new).returns(server)
     @container = CloudFiles::Container.new(connection, 'test_container')
     @container.stubs(:connection).returns(connection)
   end

data/test/cloudfiles_storage_object_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/test_helper'
 class CloudfilesStorageObjectTest < Test::Unit::TestCase
   
   def test_object_creation
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     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)
@@ -15,7 +15,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   end
   
   def test_object_creation_with_invalid_name
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     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)
@@ -41,6 +41,11 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     assert_equal @object.data, 'This is good data'
   end
   
+  def test_data_with_offset_succeeds
+    build_net_http_object(:code => '200', :body => 'Thi')
+    assert_equal @object.data(3), 'Thi'
+  end
+  
   def test_data_fails
     build_net_http_object(:code => '999', :body => 'This is bad data')
     assert_raise(NoSuchObjectException) do
@@ -58,6 +63,17 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     end
   end
   
+  def test_data_stream_with_offset_succeeds
+    build_net_http_object(:code => '200', :body => 'This ')
+    data = ""
+    assert_nothing_raised do
+      @object.data_stream(5) { |chunk|
+        data += chunk
+      }
+    end
+  end
+  
+  # Need to find a way to simulate this properly
   def data_stream_fails
     build_net_http_object(:code => '999', :body => 'This is bad data')
     data = ""
@@ -90,6 +106,16 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     end
   end
   
+  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')
+    response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'x-object-meta-foo' => 'Bar', 'last-modified' => Time.now.to_s}
+    response.stubs(:code).returns('204')
+    connection.stubs(:cfreq => response)
+    container = CloudFiles::Container.new(connection, 'test_container')
+    @object = CloudFiles::StorageObject.new(container, 'test_object')
+    assert_equal @object.metadata, {'foo' => 'Bar'}
+  end
+  
   def test_write_succeeds
     CloudFiles::StorageObject.any_instance.stubs(:populate).returns(true)
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
@@ -99,6 +125,19 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     end
   end
   
+  def test_write_with_make_path
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    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)
+    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)
+    assert_nothing_raised do
+      @object.write("This is path test data")
+    end
+  end
+  
   def test_load_from_filename_succeeds
     require 'tempfile'
     out = Tempfile.new('test')
@@ -153,7 +192,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   
   def build_net_http_object(args={:code => '204' })
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
     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', 'last-modified' => Time.now.to_s}.merge(args[:response])
     response.stubs(:code).returns(args[:code])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rackspace-cloudfiles
 version: !ruby/object:Gem::Version 
-  version: 1.3.0.7
+  version: 1.4.0.0
 platform: ruby
 authors: 
 - H. Wade Minter, Rackspace Hosting
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-28 00:00:00 -07:00
+date: 2009-08-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "1.0"
     version: 
-description: A Ruby version of the Mosso Cloud Files API.
+description: A Ruby version of the Rackspace Cloud Files API.
 email: wade.minter@rackspace.com
 executables: []
 
@@ -54,7 +54,7 @@ files:
 - test/test_helper.rb
 - TODO
 has_rdoc: true
-homepage: http://www.mosso.com/cloudfiles.jsp
+homepage: http://www.rackspacecloud.com/cloud_hosting_products/files
 licenses: 
 post_install_message: 
 rdoc_options: 
@@ -84,7 +84,7 @@ rubyforge_project: cloudfiles
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
-summary: A Ruby API into Mosso Cloud Files
+summary: A Ruby API into Rackspace Cloud Files
 test_files: 
 - test/cloudfiles_authentication_test.rb
 - test/cloudfiles_connection_test.rb