cloudfiles 1.4.18 → 1.5.0

data/lib/cloudfiles.rb

@@ -30,7 +30,6 @@ module CloudFiles
   require 'digest/md5'
   require 'time'
   require 'rubygems'
-  require 'mime/types'
 
   unless "".respond_to? :each_char
     require "jcode"
@@ -38,6 +37,7 @@ module CloudFiles
   end
 
   $:.unshift(File.dirname(__FILE__))
+  require 'client'
   require 'cloudfiles/version'
   require 'cloudfiles/exception'
   require 'cloudfiles/authentication'

data/lib/cloudfiles/authentication.rb

@@ -8,54 +8,39 @@ module CloudFiles
     # cdmmgmtpath, storagehost, storagepath, authtoken, and authok variables on the connection.  If it fails, it raises
     # an CloudFiles::Exception::Authentication exception.
     #
-    # Should probably never be called directly.
+    # Should never be called directly.
     def initialize(connection)
-      parsed_auth_url = URI.parse(connection.auth_url)
-      path = parsed_auth_url.path
-      hdrhash = { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey }
       begin
-        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 Exception => e
+        storage_url, auth_token, headers = SwiftClient.get_auth(connection.auth_url, connection.authuser, connection.authkey, connection.snet?)
+      rescue => 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
+        # $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 #{connection.auth_url}", caller
       end
-      response = server.get(path, hdrhash)
-      if (response.code =~ /^20./)
-        if response["x-cdn-management-url"]
+      if auth_token 
+        if headers["x-cdn-management-url"]
           connection.cdn_available = true
-          parsed_cdn_url = URI.parse(response["x-cdn-management-url"])
+          parsed_cdn_url = URI.parse(headers["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
-        parsed_storage_url = URI.parse(response["x-storage-url"])
+        parsed_storage_url = URI.parse(headers["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.authtoken     = headers["x-auth-token"]
         connection.authok        = true
       else
         connection.authtoken = false
         raise CloudFiles::Exception::Authentication, "Authentication failed"
       end
-      server.finish
     end
 
     private
 
-      def get_server(connection, parsed_auth_url)
-        Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new(parsed_auth_url.host, parsed_auth_url.port)
-      end
-
       def set_snet(connection, hostname)
         if connection.snet?
           "snet-#{hostname}"

data/lib/cloudfiles/connection.rb

@@ -132,12 +132,18 @@ module CloudFiles
     #   => {:count=>8, :bytes=>42438527}
     #   cf.bytes
     #   => 42438527
+    # Hostname of the storage server
+
     def get_info
-      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
-      {:bytes => @bytes, :count => @count}
+      begin
+        raise CloudFiles::Exception::AuthenticationException, "Not authenticated" unless self.authok?
+        response = SwiftClient.head_account(storageurl, self.authtoken)
+        @bytes = response["x-account-bytes-used"].to_i
+        @count = response["x-account-container-count"].to_i
+        {:bytes => @bytes, :count => @count}
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Unable to obtain account size" unless (e.status.to_s == "204")
+      end
     end
     
     # The total size in bytes under this connection
@@ -162,14 +168,13 @@ module CloudFiles
     #
     #   cf.containers(2,'cftest')
     #   => ["test", "video"]
-    def containers(limit = 0, marker = "")
-      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 = 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)
+    def containers(limit = nil, marker = nil)
+      begin
+        response = SwiftClient.get_account(storageurl, self.authtoken, marker, limit)
+        response[1].collect{|c| c['name']}
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status.to_s}" unless (e.status.to_s == "200")
+      end
     end
     alias :list_containers :containers
 
@@ -183,20 +188,13 @@ module CloudFiles
     #   cf.containers_detail
     #   => { "container1" => { :bytes => "36543", :count => "146" },
     #        "container2" => { :bytes => "105943", :count => "25" } }
-    def containers_detail(limit = 0, marker = "")
-      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 = 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)
-      detailhash = {}
-      doc.elements.each("account/container/") { |c|
-        detailhash[c.elements["name"].text] = { :bytes => c.elements["bytes"].text, :count => c.elements["count"].text  }
-      }
-      doc = nil
-      return detailhash
+    def containers_detail(limit = nil, marker = nil)
+      begin
+        response = SwiftClient.get_account(storageurl, self.authtoken, marker, limit)
+        Hash[*response[1].collect{|c| [c['name'], {:bytes => c['bytes'], :count => c['count']}]}.flatten]
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status.to_s}" unless (e.status.to_s == "200")
+      end
     end
     alias :list_containers_info :containers_detail
 
@@ -208,14 +206,18 @@ module CloudFiles
     #   cf.container_exists?('bad_container')
     #   => false
     def container_exists?(containername)
-      response = storage_request("HEAD", CloudFiles.escape(containername))
-      return (response.code == "204")? true : false ;
+      begin
+        response = SwiftClient.head_container(storageurl, self.authtoken, containername)
+        true
+      rescue ClientException => e
+        false
+      end
     end
 
     # Creates a new container and returns the CloudFiles::Container object.  Throws an InvalidResponseException if the
     # request fails.
     #
-    # Slash (/) and question mark (?) are invalid characters, and will be stripped out.  The container name is limited to
+    # "/" is not valid in a container name.  The container name is limited to
     # 256 characters or less.
     #
     #   container = cf.create_container('new_container')
@@ -223,13 +225,16 @@ module CloudFiles
     #   => "new_container"
     #
     #   container = cf.create_container('bad/name')
-    #   => SyntaxException: Container name cannot contain the characters '/' or '?'
+    #   => SyntaxException: Container name cannot contain '/'
     def create_container(containername)
-      raise CloudFiles::Exception::Syntax, "Container name cannot contain the characters '/' or '?'" if containername.match(/[\/\?]/)
+      raise CloudFiles::Exception::Syntax, "Container name cannot contain '/'" if containername.match("/")
       raise CloudFiles::Exception::Syntax, "Container name is limited to 256 characters" if containername.length > 256
-      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)
+      begin
+        SwiftClient.put_container(storageurl, self.authtoken, containername)
+        CloudFiles::Container.new(self, containername)
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Unable to create container #{containername}" unless (e.status.to_s == "201" || e.status.to_s == "202")
+      end
     end
 
     # Deletes a container from the account.  Throws a NonEmptyContainerException if the container still contains
@@ -244,9 +249,12 @@ module CloudFiles
     #   cf.delete_container('nonexistent')
     #   => NoSuchContainerException: Container nonexistent does not exist
     def delete_container(containername)
-      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")
+      begin
+        SwiftClient.delete_container(storageurl, self.authtoken, containername)
+      rescue ClientException => e
+        raise CloudFiles::Exception::NonEmptyContainer, "Container #{containername} is not empty" if (e.status.to_s == "409")
+        raise CloudFiles::Exception::NoSuchContainer, "Container #{containername} does not exist" unless (e.status.to_s == "204")
+      end
       true
     end
 
@@ -260,95 +268,19 @@ module CloudFiles
     #   cf.public_containers
     #   => ["video", "webpics"]
     def public_containers(enabled_only = false)
-      paramstr = enabled_only == true ? "enabled_only=true" : ""
-      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
-      headers['Transfer-Encoding'] = "chunked" if data.respond_to?(:read)
-      hdrhash = headerprep(headers)
-      start_http(server, path, port, scheme, hdrhash)
-      request = Net::HTTP.const_get(method.to_s.capitalize).new(path, hdrhash)
-      data.rewind if data.respond_to?(:rewind)
-      if data
-        if data.respond_to?(:read)
-          request.body_stream = data
-        else
-          request.body = data
-        end
-        unless data.is_a?(IO)
-          request.content_length = data.respond_to?(:lstat) ? data.stat.size : data.size
-        end
-      else
-        request.content_length = 0
-      end
-      response = @http[server].request(request, &block)
-      raise CloudFiles::Exception::ExpiredAuthToken if response.code == "401"
-      response
-    rescue Errno::EPIPE, Timeout::Error, Errno::EINVAL, EOFError, IOError
-      # Server closed the connection, retry
-      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
-      rescue
-        nil
+        response = SwiftClient.get_account(cdnurl, self.authtoken)
+        response[1].collect{|c| c['name']}
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status.to_s}" unless (e.status.to_s == "200")
       end
-      start_http(server, path, port, scheme, headers)
-      retry
-    rescue ExpiredAuthTokenException
-      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
-
-    private
-
-    # Sets up standard HTTP headers
-    def headerprep(headers = {}) # :nodoc:
-      default_headers = {}
-      default_headers["X-Auth-Token"] = @authtoken if (authok? && @account.nil?)
-      default_headers["X-Storage-Token"] = @authtoken if (authok? && !@account.nil?)
-      default_headers["Connection"] = "Keep-Alive"
-      default_headers["User-Agent"] = "CloudFiles Ruby API #{VERSION}"
-      default_headers.merge(headers)
+    
+    def storageurl
+      "#{self.storagescheme}://#{self.storagehost}:#{self.storageport.to_s}#{self.storagepath}"
     end
-
-    # Starts (or restarts) the HTTP connection
-    def start_http(server, path, port, scheme, headers) # :nodoc:
-      if (@http[server].nil?)
-        begin
-          @http[server] = Net::HTTP::Proxy(self.proxy_host, self.proxy_port).new(server, port)
-          if scheme == "https"
-            @http[server].use_ssl = true
-            @http[server].verify_mode = OpenSSL::SSL::VERIFY_NONE
-          end
-          @http[server].start
-        rescue Exception
-          raise CloudFiles::Exception::Connection, "Unable to connect to #{server.address}", caller
-        end
-      end
+    def cdnurl
+      "#{self.cdnmgmtscheme}://#{self.cdnmgmthost}:#{self.cdnmgmtport.to_s}#{self.cdnmgmtpath}"
     end
-
   end
-
 end

data/lib/cloudfiles/container.rb

@@ -41,11 +41,14 @@ module CloudFiles
     # Retrieves Metadata for the container
     def container_metadata
       @metadata ||= (
-        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, :container_read => response["x-container-read"], :container_write => response["x-container-write"]}
+        begin
+          response = SwiftClient.head_container(self.connection.storageurl, self.connection.authtoken, escaped_name)
+          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, :container_read => response["x-container-read"], :container_write => response["x-container-write"]}
+        rescue ClientException => e
+          raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (e.status.to_s =~ /^20/)
+        end
       )
     end
 
@@ -54,18 +57,20 @@ module CloudFiles
       return @cdn_metadata if @cdn_metadata
       if cdn_available?
         @cdn_metadata = (
-          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
-          }
+          begin
+            response = SwiftClient.head_container(self.connection.cdnurl, self.connection.authtoken, 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,
+              :cdn_log => (cdn_enabled and response["x-log-retention"] == "True") ? true : false
+            }
+          rescue ClientException => e
+            raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (e.status.to_s =~ /^20/)
+          end
         )
       else
         @cdn_metadata = {}
@@ -91,10 +96,14 @@ 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.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
+      begin
+        SwiftClient.post_container(self.connection.storageurl, self.connection.authtoken, escaped_name, headers)
+        self.refresh
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchObject, "Container #{@name} does not exist" if (e.status.to_s == "404")
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status}" unless (e.status.to_s =~ /^20/)
+      end
     end
     
     # Size of the container (in bytes)
@@ -136,21 +145,12 @@ 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
+    def cdn_streaming_url
       self.cdn_metadata[:cdn_streaming_url]
     end
 
-    # The container ACL on the User Agent
-    def user_agent_acl
-      self.cdn_metadata[:user_agent_acl]
-    end
-
-    # The container ACL on the site Referrer
-    def referrer_acl
-      self.cdn_metadata[:referrer_acl]
-    end
-
     #used by openstack swift
     def read_acl
       self.container_metadata[:container_read]
@@ -168,15 +168,19 @@ module CloudFiles
     alias :log_retention? :cdn_log
     alias :cdn_log? :cdn_log
 
+
     # 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)
       raise Exception::CDNNotAvailable unless cdn_available?
-      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
+      begin
+        SwiftClient.post_container(self.connection.cdnurl, self.connection.authtoken, escaped_name, {"x-log-retention" => value.to_s.capitalize})
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status}" unless (e.status.to_s == "201" or e.status.to_s == "202")
+      end
     end
 
 
@@ -221,10 +225,12 @@ module CloudFiles
           query << "#{param}=#{CloudFiles.escape(value.to_s)}"
         end
       end
-      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)
+      begin
+        response = SwiftClient.get_container(self.connection.storageurl, self.connection.authtoken, escaped_name, params[:marker], params[:limit], params[:prefix], params[:delimiter])
+        return response[1].collect{|o| o['name']}
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status}" unless (e.status.to_s == "200")
+      end
     end
     alias :list_objects :objects
 
@@ -254,16 +260,12 @@ module CloudFiles
           query << "#{param}=#{CloudFiles.escape(value.to_s)}"
         end
       end
-      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)
-      detailhash = {}
-      doc.elements.each("container/object") { |o|
-        detailhash[o.elements["name"].text] = { :bytes => o.elements["bytes"].text, :hash => o.elements["hash"].text, :content_type => o.elements["content_type"].text, :last_modified => DateTime.parse(o.elements["last_modified"].text) }
-      }
-      doc = nil
-      return detailhash
+      begin 
+        response = SwiftClient.get_container(self.connection.storageurl, self.connection.authtoken, escaped_name, params[:marker], params[:limit], params[:prefix], params[:delimiter])
+        return Hash[*response[1].collect{|o| [o['name'],{ :bytes => o["bytes"], :hash => o["hash"], :content_type => o["content_type"], :last_modified => DateTime.parse(o["last_modified"])}] }.flatten]
+      rescue ClientException => e
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status}" unless (e.status.to_s == "200")
+      end
     end
     alias :list_objects_info :objects_detail
 
@@ -286,8 +288,12 @@ module CloudFiles
     #   container.object_exists?('badfile.txt')
     #   => false
     def object_exists?(objectname)
-      response = self.connection.storage_request("HEAD", "#{escaped_name}/#{CloudFiles.escape objectname}")
-      return (response.code =~ /^20/)? true : false
+      begin
+        response = SwiftClient.head_object(self.connection.storageurl, self.connection.authtoken, escaped_name, objectname)
+        true
+      rescue ClientException => e
+        false
+      end
     end
 
     # Creates a new CloudFiles::StorageObject in the current container.
@@ -311,10 +317,13 @@ module CloudFiles
     #   container.delete_object('nonexistent_file.txt')
     #   => NoSuchObjectException: Object nonexistent_file.txt does not exist
     def delete_object(objectname)
-      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
+      begin
+        SwiftClient.delete_object(self.connection.storageurl, self.connection.authtoken, escaped_name, objectname)
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchObject, "Object #{objectname} does not exist" if (e.status.to_s == "404")
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status}" unless (e.status.to_s =~ /^20/)
+      end
     end
 
     # Makes a container publicly available via the Cloud Files CDN and returns true upon success.  Throws NoSuchContainerException
@@ -338,14 +347,17 @@ module CloudFiles
         options = {:ttl => ttl}
       end
 
-      response = self.connection.cdn_request("PUT", escaped_name)
-      raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
-
+      begin
+        SwiftClient.put_container(self.connection.cdnurl, self.connection.authtoken, escaped_name)
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (e.status.to_s == "201" || e.status.to_s == "202")
+      end
       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 = post_with_headers(headers)
-      raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
+
+      post_with_headers(headers)
+      # raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
       refresh
       true
     end
@@ -367,13 +379,11 @@ module CloudFiles
     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)
+      begin
+        SwiftClient.post_container(cdn_enabled? ? self.connection.cdnurl : self.connection.storageurl, self.connection.authtoken, escaped_name, headers)
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist (response code: #{e.status.to_s})" unless (e.status.to_s =~ /^20/)
       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
@@ -386,10 +396,13 @@ module CloudFiles
     def make_private
       raise Exception::CDNNotAvailable unless cdn_available?
       headers = { "X-CDN-Enabled" => "False" }
-      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
+      begin
+        SwiftClient.post_container(self.connection.cdnurl, self.connection.authtoken, escaped_name, headers)
+        refresh
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (e.status.to_s == "201" || e.status.to_s == "202")
+      end
     end
 
     # Purges CDN Edge Cache for all objects inside of this container
@@ -413,9 +426,12 @@ module CloudFiles
       raise Exception::CDNNotAvailable unless cdn_available?
       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
+      begin
+        SwiftClient.delete_container(self.connection.cdnurl, self.connection.authtoken, escaped_name, headers)
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (e.status.to_s > "200" && e.status.to_s < "299")
+      end
     end
 
     def to_s # :nodoc: