raca 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f887cfa6d624450eb2805122c998cc29acc0b01
-  data.tar.gz: 89109fe3d3b728239a0ab9795d24508b96bff2ae
+  metadata.gz: 264c32ae5539a36329c0b7acbbc054f1d70eb142
+  data.tar.gz: 25a6c347e4cb9e4573c993a5591426f66f0b5872
 SHA512:
-  metadata.gz: 65b7f065c88ec68907b6580fc65b1ed05187988807a450bfee8dff001d2bb0c2ac552b973bdc188567edd0bbcc1bb12ef5ca2de9e732dd9713df64220d8f8c80
-  data.tar.gz: ce61916a750f740b82b569be8913eaa806dffab65e3ad34013d49702ceaca9aa63ab7a01333a277adf51dc674427984c2fb534fc8f6cde915438ad1ce5007df8
+  metadata.gz: 932604c188aef930a67ef37950efe1de4bf2abf7ea272c2f2f2519e5d43c0e97cd7df18edda157f6b83aa1daa0f25de97ea81be613e0d477054ef833dbc6183f
+  data.tar.gz: 53fff6b33e8809a152ccf05f45259518c4a5ecc0e2c6e7d9d4fffa67814f6a7c936c76f8fa5739d3ec0581220af2fdcb21fc6e48aa8b0c686002da2d46ede8c9

data/CHANGELOG

@@ -0,0 +1,24 @@
+v0.3.0 (12th April 2014)
+* Added an optional headers param to Raca::Container#upload
+* Added the details option to Raca::Container#list
+* Fixed Raca::Container#list to return all items for containers that
+  contain more than 10,000 objects
+* Fixed Raca::Container to work with container and object names that
+  need to be escaped (spaces, some punctuation, utf8 characters, etc)
+* Refactored internal management of HTTP requests to reduce duplication
+  and improve testability. There should be no visible change to the public
+  API of raca
+
+v0.2.0 (19th March 2014)
+* Breaking API changes to Raca::Servers and Raca:Server
+  * Moved the create() method from Server to Servers
+* Added Raca::Account#service_names
+* Stop returning HTTP response objects from many methods on Raca::Container
+* Added some custom error classes for common issues (timeouts, 404s, etc) to
+  make recovering easier for the user
+
+v0.1.1 (25th February 2014)
+* Add Raca::Container#object_metadata
+
+v0.1.0 (24th February 2014)
+* Initial Release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 The Conversation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -45,10 +45,13 @@ You can view the token that will be used for subsequent requests:
 
     puts account.auth_token
 
-Or you can view the URLs for each rackspace cloud API:
+List the available APIs:
+
+    puts account.service_names
+
+... and then view the URLs for each service:
 
     puts account.public_endpoint("cloudFiles", :ord)
-    puts account.service_endpoint("cloudFiles", :ord)
 
 ### Cloud Files
 
@@ -157,3 +160,8 @@ impact on application boot times.
 
 The Raca version number is < 1.0 because it's highly unstable. Until we release
 a 1.0.0, consider the API of this gem to be unstable.
+
+## License
+
+This library is released undr the MIT License. See the included MIT-LICENSE file
+for further details

data/Rakefile

@@ -18,5 +18,5 @@ Cane::RakeTask.new(:cane) do |cane|
   cane.style_measure = 148
 
   # 0 is the goal
-  cane.max_violations = 3
+  cane.max_violations = 2
 end

data/lib/raca/account.rb

@@ -70,7 +70,7 @@ module Raca
       Raca::Containers.new(self, region)
     end
 
-    # Return a Raca::Containers object for a region. Use this to interact with the
+    # Return a Raca::Servers object for a region. Use this to interact with the
     # next gen cloud servers service.
     #
     #     account = Raca::Account.new("username", "secret")
@@ -81,9 +81,11 @@ module Raca
     end
 
     # Raca classes use this method to occasionally re-authenticate with the rackspace
-    # servers. You can probable ignore it.
+    # servers. You can probably ignore it.
     #
     def refresh_cache
+      # Raca::HttpClient depends on Raca::Account, so we intentionally don't use it here
+      # to avoid a circular dependency
       Net::HTTP.new('identity.api.rackspacecloud.com', 443).tap {|http|
         http.use_ssl = true
       }.start {|http|
@@ -108,6 +110,12 @@ module Raca
       }
     end
 
+    # Return a Raca::HttpClient suitable for making requests to hostname.
+    #
+    def http_client(hostname)
+      Raca::HttpClient.new(self, hostname)
+    end
+
     private
 
     def raise_on_error(response)

data/lib/raca/container.rb

@@ -1,4 +1,3 @@
-require 'net/http'
 require 'digest/md5'
 require 'openssl'
 require 'uri'
@@ -15,7 +14,6 @@ module Raca
     MAX_ITEMS_PER_LIST = 10_000
     LARGE_FILE_THRESHOLD = 5_368_709_120 # 5 Gb
     LARGE_FILE_SEGMENT_SIZE = 104_857_600 # 100 Mb
-    RETRY_PAUSE = 5
 
     attr_reader :container_name
 
@@ -30,13 +28,16 @@ module Raca
 
     # Upload data_or_path (which may be a filename or an IO) to the container, as key.
     #
-    def upload(key, data_or_path)
+    # If headers are provided they will be added to to upload request. Use this to
+    # manually specify content type, content disposition, CORS headers, etc.
+    #
+    def upload(key, data_or_path, headers = {})
       case data_or_path
       when StringIO, File
-        upload_io(key, data_or_path, data_or_path.size)
+        upload_io(key, data_or_path, data_or_path.size, headers)
       when String
         File.open(data_or_path, "rb") do |io|
-          upload_io(key, io, io.stat.size)
+          upload_io(key, io, io.stat.size, headers)
         end
       else
         raise ArgumentError, "data_or_path must be an IO with data or filename string"
@@ -48,7 +49,8 @@ module Raca
     #
     def delete(key)
       log "deleting #{key} from #{container_path}"
-      response = storage_request(Net::HTTP::Delete.new(File.join(container_path, key)))
+      object_path = File.join(container_path, Raca::Util.url_encode(key))
+      response = storage_client.delete(object_path)
       (200..299).cover?(response.code.to_i)
     end
 
@@ -61,20 +63,20 @@ module Raca
     #
     def purge_from_akamai(key, email_address)
       log "Requesting #{File.join(container_path, key)} to be purged from the CDN"
-      response = cdn_request(Net::HTTP::Delete.new(
-        File.join(container_path, key),
+      response = cdn_client.delete(
+        File.join(container_path, Raca::Util.url_encode(key)),
         'X-Purge-Email' => email_address
-      ))
+      )
       (200..299).cover?(response.code.to_i)
     end
 
     # Returns some metadata about a single object in this container.
     #
     def object_metadata(key)
-      object_path = File.join(container_path, key)
+      object_path = File.join(container_path, Raca::Util.url_encode(key))
       log "Requesting metadata from #{object_path}"
 
-      response = storage_request(Net::HTTP::Head.new(object_path))
+      response = storage_client.head(object_path)
       {
         :content_type => response["Content-Type"],
         :bytes => response["Content-Length"].to_i
@@ -87,7 +89,8 @@ module Raca
     #
     def download(key, filepath)
       log "downloading #{key} from #{container_path}"
-      response = storage_request(Net::HTTP::Get.new(File.join(container_path, key))) do |response|
+      object_path = File.join(container_path, Raca::Util.url_encode(key))
+      response = storage_client.get(object_path) do |response|
         File.open(filepath, 'wb') do |io|
           response.read_body do |chunk|
             io.write(chunk)
@@ -104,26 +107,31 @@ module Raca
     # max - the maximum number of items to return
     # marker - return items alphabetically after this key. Useful for pagination
     # prefix - only return items that start with this string
+    # details - return extra details for each file - size, md5, etc
     #
     def list(options = {})
-      max = options.fetch(:max, MAX_ITEMS_PER_LIST)
+      max = options.fetch(:max, 100_000_000)
       marker = options.fetch(:marker, nil)
       prefix = options.fetch(:prefix, nil)
+      details = options.fetch(:details, nil)
       limit = [max, MAX_ITEMS_PER_LIST].min
-      log "retrieving up to #{limit} of #{max} items from #{container_path}"
-      query_string = "limit=#{limit}"
-      query_string += "&marker=#{marker}" if marker
-      query_string += "&prefix=#{prefix}" if prefix
-      request = Net::HTTP::Get.new(container_path + "?#{query_string}")
-      result = storage_request(request).body || ""
-      result.split("\n").tap {|items|
+      log "retrieving up to #{max} items from #{container_path}"
+      request_path = list_request_path(marker, prefix, details, limit)
+      result = storage_client.get(request_path).body || ""
+      if details
+        result = JSON.parse(result)
+      else
+        result = result.split("\n")
+      end
+      result.tap {|items|
         if max <= limit
           log "Got #{items.length} items; we don't need any more."
         elsif items.length < limit
           log "Got #{items.length} items; there can't be any more."
         else
-          log "Got #{items.length} items; requesting #{max - limit} more."
-          items.concat list(max: max - limit, marker: items.last, prefix: prefix)
+          log "Got #{items.length} items; requesting #{limit} more."
+          details ? marker = items.last["name"] : marker = items.last
+          items.concat list(max: max-items.length, marker: marker, prefix: prefix, details: details)
         end
       }
     end
@@ -142,7 +150,7 @@ module Raca
     #
     def metadata
       log "retrieving container metadata from #{container_path}"
-      response = storage_request(Net::HTTP::Head.new(container_path))
+      response = storage_client.head(container_path)
       {
         :objects => response["X-Container-Object-Count"].to_i,
         :bytes => response["X-Container-Bytes-Used"].to_i
@@ -154,7 +162,7 @@ module Raca
     #
     def cdn_metadata
       log "retrieving container CDN metadata from #{container_path}"
-      response = cdn_request(Net::HTTP::Head.new(container_path))
+      response = cdn_client.head(container_path)
       {
         :cdn_enabled => response["X-CDN-Enabled"] == "True",
         :host => response["X-CDN-URI"],
@@ -174,7 +182,7 @@ module Raca
     def cdn_enable(ttl = 259200)
       log "enabling CDN access to #{container_path} with a cache expiry of #{ttl / 60} minutes"
 
-      response = cdn_request(Net::HTTP::Put.new(container_path, "X-TTL" => ttl.to_i.to_s))
+      response = cdn_client.put(container_path, "X-TTL" => ttl.to_i.to_s)
       (200..299).cover?(response.code.to_i)
     end
 
@@ -187,49 +195,54 @@ module Raca
       method  = 'GET'
       expires = expires_at.to_i
       path    = File.join(container_path, object_key)
+      encoded_path = File.join(container_path, Raca::Util.url_encode(object_key))
       data    = "#{method}\n#{expires}\n#{path}"
 
       hmac    = OpenSSL::HMAC.new(temp_url_key, digest)
       hmac << data
 
-      "https://#{storage_host}#{path}?temp_url_sig=#{hmac.hexdigest}&temp_url_expires=#{expires}"
+      "https://#{storage_host}#{encoded_path}?temp_url_sig=#{hmac.hexdigest}&temp_url_expires=#{expires}"
     end
 
     private
 
-    def upload_io(key, io, byte_count)
+    # build the request path for listing the contents of a container
+    #
+    def list_request_path(marker, prefix, details, limit)
+      query_string = "limit=#{limit}"
+      query_string += "&marker=#{Raca::Util.url_encode(marker)}" if marker
+      query_string += "&prefix=#{Raca::Util.url_encode(prefix)}" if prefix
+      query_string += "&format=json"      if details
+      container_path + "?#{query_string}"
+    end
+
+
+    def upload_io(key, io, byte_count, headers = {})
       if byte_count <= LARGE_FILE_THRESHOLD
-        upload_io_standard(key, io, byte_count)
+        upload_io_standard(key, io, byte_count, headers)
       else
-        upload_io_large(key, io, byte_count)
+        upload_io_large(key, io, byte_count, headers)
       end
     end
 
-    def upload_io_standard(key, io, byte_count)
-      full_path = File.join(container_path, key)
+    def upload_io_standard(key, io, byte_count, headers = {})
+      full_path = File.join(container_path, Raca::Util.url_encode(key))
 
-      headers = {}
-      headers['Content-Type']     = extension_content_type(full_path)
+      headers['Content-Type']   ||= extension_content_type(full_path)
       if io.respond_to?(:path)
         headers['Content-Type'] ||= extension_content_type(io.path)
-        headers['Content-Type'] ||= file_content_type(io.path)
       end
-        headers['Etag']           = md5_io(io)
+      headers['Etag']           = md5_io(io)
       headers['Content-Type']   ||= "application/octet-stream"
       if content_type_needs_cors(key)
         headers['Access-Control-Allow-Origin'] = "*"
       end
 
       log "uploading #{byte_count} bytes to #{full_path}"
-
-      request = Net::HTTP::Put.new(full_path, headers)
-      request.body_stream = io
-      request.content_length = byte_count
-      response = storage_request(request)
-      response['ETag']
+      put_upload(full_path, headers, byte_count, io)
     end
 
-    def upload_io_large(key, io, byte_count)
+    def upload_io_large(key, io, byte_count, headers = {})
       segment_count = (byte_count.to_f / LARGE_FILE_SEGMENT_SIZE).ceil
       segments = []
       while segments.size < segment_count
@@ -237,67 +250,25 @@ module Raca
         segment_key = "%s.%03d" % [key, segments.size]
         io.seek(start_pos)
         segment_io = StringIO.new(io.read(LARGE_FILE_SEGMENT_SIZE))
-        etag = upload_io_standard(segment_key, segment_io, segment_io.size)
+        etag = upload_io_standard(segment_key, segment_io, segment_io.size, headers)
         segments << {path: "#{@container_name}/#{segment_key}", etag: etag, size_bytes: segment_io.size}
       end
-      manifest_key = "#{key}?multipart-manifest=put"
+      full_path = File.join(container_path, Raca::Util.url_encode(key)) + "?multipart-manifest=put"
       manifest_body = StringIO.new(JSON.dump(segments))
-      upload_io_standard(manifest_key, manifest_body, manifest_body.size)
-    end
-
-    def cdn_request(request, &block)
-      cloud_request(request, cdn_host, &block)
-    end
-
-    def storage_request(request, &block)
-      cloud_request(request, storage_host, &block)
+      put_upload(full_path, {'Etag' => md5_io(manifest_body)}, manifest_body.string.bytesize, manifest_body)
     end
 
-    def cloud_request(request, hostname, retries = 0, &block)
-      cloud_http(hostname) do |http|
-        request['X-Auth-Token'] = @account.auth_token
-        http.request(request, &block)
-      end
-    rescue Timeout::Error
-      if retries >= 3
-        raise Raca::TimeoutError, "Timeout from Rackspace while trying #{request.class} to #{request.path}"
-      end
-
-      retry_interval = RETRY_PAUSE + (retries.to_i * RETRY_PAUSE) # Retry after 5, 10, 15 and 20 seconds
-      log "Rackspace timed out: retrying after #{retry_interval}s"
-      sleep(retry_interval)
-
-      cloud_request(request, hostname, retries + 1, &block)
+    def put_upload(full_path, headers, byte_count, io)
+      response = storage_client.streaming_put(full_path, io, byte_count, headers)
+      response['ETag']
     end
 
-    def cloud_http(hostname, &block)
-      Net::HTTP.new(hostname, 443).tap {|http|
-        http.use_ssl = true
-        http.read_timeout = 70
-      }.start do |http|
-        response = block.call http
-        if response.is_a?(Net::HTTPUnauthorized)
-          log "Rackspace returned HTTP 401; refreshing auth before retrying."
-          @account.refresh_cache
-          response = block.call http
-        end
-        if response.is_a?(Net::HTTPSuccess)
-          response
-        else
-          raise_on_error(response)
-        end
-      end
+    def cdn_client
+      @cdn_client ||= @account.http_client(cdn_host)
     end
 
-    def raise_on_error(response)
-      error_klass = case response.code.to_i
-      when 400 then BadRequestError
-      when 404 then NotFoundError
-      when 500 then ServerError
-      else
-        HTTPError
-      end
-      raise error_klass, "Rackspace returned HTTP status #{response.code}"
+    def storage_client
+      @storage_client ||= @account.http_client(storage_host)
     end
 
     def log(msg)
@@ -323,11 +294,7 @@ module Raca
     end
 
     def container_path
-      @container_path ||= File.join(storage_path, container_name)
-    end
-
-    def file_content_type(path)
-      `file -b --mime-type \"#{path.gsub('"', '\"')}\"`.chomp
+      @container_path ||= File.join(storage_path, Raca::Util.url_encode(container_name))
     end
 
     def extension_content_type(path)

data/lib/raca/containers.rb

@@ -23,7 +23,7 @@ module Raca
     #
     def metadata
       log "retrieving containers metadata from #{storage_path}"
-      response    = storage_request(Net::HTTP::Head.new(storage_path))
+      response    = storage_client.head(storage_path)
       {
         :containers => response["X-Account-Container-Count"].to_i,
         :objects    => response["X-Account-Object-Count"].to_i,
@@ -41,8 +41,7 @@ module Raca
     def set_temp_url_key(secret)
       log "setting Account Temp URL Key on #{storage_path}"
 
-      request = Net::HTTP::Post.new(storage_path, "X-Account-Meta-Temp-Url-Key" => secret.to_s)
-      response = storage_request(request)
+      response = storage_client.post(storage_path, nil, "X-Account-Meta-Temp-Url-Key" => secret.to_s)
       (200..299).cover?(response.code.to_i)
     end
 
@@ -56,46 +55,8 @@ module Raca
       URI.parse(@storage_url).path
     end
 
-    def storage_request(request, &block)
-      cloud_request(request, storage_host, &block)
-    end
-
-    def cloud_request(request, hostname, &block)
-      cloud_http(hostname) do |http|
-        request['X-Auth-Token'] = @account.auth_token
-        http.request(request, &block)
-      end
-    end
-
-    def cloud_http(hostname, &block)
-      Net::HTTP.new(hostname, 443).tap {|http|
-        http.use_ssl = true
-        http.read_timeout = 70
-      }.start do |http|
-        response = block.call http
-        if response.is_a?(Net::HTTPUnauthorized)
-          log "Rackspace returned HTTP 401; refreshing auth before retrying."
-          @account.refresh_cache
-          response = block.call http
-        end
-        if response.is_a?(Net::HTTPSuccess)
-          response
-        else
-          raise_on_error(response)
-        end
-        response
-      end
-    end
-
-    def raise_on_error(response)
-      error_klass = case response.code.to_i
-      when 400 then BadRequestError
-      when 404 then NotFoundError
-      when 500 then ServerError
-      else
-        HTTPError
-      end
-      raise error_klass, "Rackspace returned HTTP status #{response.code}"
+    def storage_client
+      @storage_client ||= @account.http_client(storage_host)
     end
 
     def log(msg)

data/lib/raca/http_client.rb

@@ -0,0 +1,123 @@
+require 'net/http'
+require 'openssl'
+
+module Raca
+
+  # A thin wrapper around Net::HTTP. It's aware of some common details of
+  # the rackspace APIs and has an API to match.
+  #
+  # You probably don't want to instantiate this directly,
+  # see Raca::Account#http_client
+  #
+  class HttpClient
+    RETRY_PAUSE = 5
+
+    def initialize(account, hostname, opts = {})
+      @account, @hostname = account, hostname.to_s
+      raise ArgumentError, "hostname must be plain hostname, leave the protocol out" if @hostname[/\Ahttp/]
+      @logger = opts[:logger]
+      @logger ||= Rails.logger if defined?(Rails)
+    end
+
+    def get(path, headers = {}, &block)
+      cloud_request(Net::HTTP::Get.new(path, headers), &block)
+    end
+
+    def head(path, headers = {})
+      cloud_request(Net::HTTP::Head.new(path, headers))
+    end
+
+    def delete(path, headers = {})
+      cloud_request(Net::HTTP::Delete.new(path, headers))
+    end
+
+    def put(path, headers = {})
+      cloud_request(Net::HTTP::Put.new(path, headers))
+    end
+
+    def streaming_put(path, io, byte_count, headers = {})
+      request = Net::HTTP::Put.new(path, headers)
+      request.body_stream = io
+      request.content_length = byte_count
+      cloud_request(request)
+    end
+
+    def post(path, body, headers = {})
+      request = Net::HTTP::Post.new(path, headers)
+      request.body = body if body
+      cloud_request(request)
+    end
+
+    private
+
+    # perform an HTTP request to rackpsace.
+    #
+    # request is a Net::HTTP request object.
+    # retries is an int that counts up as the request is tried after a timeout.
+    # This can be called with and without a block. Without a block, the response
+    # is returned as you'd expect
+    #
+    #     response = http_client.cloud_request(request)
+    #
+    # With the block form, the response is yielded to the block:
+    #
+    #     http_client.cloud_request(request) do |response|
+    #       puts response
+    #     end
+    #
+    def cloud_request(request, retries = 0, &block)
+      cloud_http do |http|
+        request['X-Auth-Token'] = @account.auth_token
+        http.request(request, &block)
+      end
+    rescue Timeout::Error
+      if retries >= 3
+        raise Raca::TimeoutError, "Timeout from Rackspace while trying #{request.class} to #{request.path}"
+      end
+
+      retry_interval = RETRY_PAUSE + (retries.to_i * RETRY_PAUSE) # Retry after 5, 10, 15 and 20 seconds
+      log "Rackspace timed out: retrying after #{retry_interval}s"
+      sleep(retry_interval)
+
+      cloud_request(request, retries + 1, &block)
+    end
+
+    def cloud_http(&block)
+      Net::HTTP.new(@hostname, 443).tap {|http|
+        http.use_ssl = true
+        http.read_timeout = 70
+      }.start do |http|
+        response = block.call http
+        if response.is_a?(Net::HTTPUnauthorized)
+          log "Rackspace returned HTTP 401; refreshing auth before retrying."
+          @account.refresh_cache
+          response = block.call http
+        end
+        if response.is_a?(Net::HTTPSuccess)
+          response
+        else
+          raise_on_error(response)
+        end
+      end
+    end
+
+    def raise_on_error(response)
+      error_klass = case response.code.to_i
+      when 400 then BadRequestError
+      when 404 then NotFoundError
+      when 500 then ServerError
+      else
+        HTTPError
+      end
+      raise error_klass, "Rackspace returned HTTP status #{response.code}"
+    end
+
+    def log(msg)
+      if @logger.respond_to?(:debug)
+        @logger.debug msg
+      end
+    end
+
+  end
+end
+

data/lib/raca/server.rb

@@ -1,6 +1,5 @@
 require 'json'
 require 'base64'
-require 'net/http'
 
 module Raca
   # Represents a single cloud server. Contains methods for deleting a server,
@@ -21,7 +20,7 @@ module Raca
     end
 
     def delete!
-      response = cloud_request(Net::HTTP::Delete.new(server_path))
+      response = servers_client.delete(server_path, json_headers)
       response.is_a? Net::HTTPSuccess
     end
 
@@ -50,12 +49,19 @@ module Raca
     # A Hash of various matadata about the server
     #
     def details
-      data = cloud_request(Net::HTTP::Get.new(server_path)).body
+      data = servers_client.get(server_path, json_headers).body
       JSON.parse(data)['server']
     end
 
     private
 
+    def json_headers
+      {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/json'
+      }
+    end
+
     def servers_host
       @servers_host ||= URI.parse(@servers_url).host
     end
@@ -68,49 +74,8 @@ module Raca
       @server_path ||= File.join(account_path, "servers", @server_id.to_s)
     end
 
-    def cloud_request(request, body = nil)
-      request['X-Auth-Token'] = @account.auth_token
-      request['Content-Type'] = 'application/json'
-      request['Accept']       = 'application/json'
-      cloud_http(servers_host) do |http|
-        http.request(request, body)
-      end
-    end
-
-    def cloud_http(hostname, retries = 3, &block)
-      http = Net::HTTP.new(hostname, 443)
-      http.use_ssl = true
-      http.start do |http|
-        response = block.call http
-        if response.is_a?(Net::HTTPUnauthorized)
-          log "Rackspace returned HTTP 401; refreshing auth before retrying."
-          @account.refresh_cache
-          response = block.call http
-        end
-        if response.is_a?(Net::HTTPSuccess)
-          response
-        else
-          raise_on_error(response)
-        end
-        response
-      end
-    rescue Timeout::Error
-      if retries <= 0
-        raise Raca::TimeoutError, "Timeout from Rackspace while trying #{request.class} to #{request.path}"
-      end
-
-      cloud_http(hostname, retries - 1, &block)
-    end
-
-    def raise_on_error(response)
-      error_klass = case response.code.to_i
-      when 400 then BadRequestError
-      when 404 then NotFoundError
-      when 500 then ServerError
-      else
-        HTTPError
-      end
-      raise error_klass, "Rackspace returned HTTP status #{response.code}"
+    def servers_client
+      @servers_client ||= @account.http_client(servers_host)
     end
 
     def log(msg)

data/lib/raca/servers.rb

@@ -56,13 +56,20 @@ module Raca
         }
       end
 
-      data = cloud_request(Net::HTTP::Post.new(servers_path), JSON.dump(request)).body
-      data = JSON.parse(data)['server']
+      response = servers_client.post(servers_path, JSON.dump(request), json_headers)
+      data = JSON.parse(response.body)['server']
       Raca::Server.new(@account, @region, data['id'])
     end
 
     private
 
+    def json_headers
+      {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/json'
+      }
+    end
+
     def servers_host
       @servers_host ||= URI.parse(@servers_url).host
     end
@@ -84,7 +91,7 @@ module Raca
     end
 
     def list
-      json = cloud_request(Net::HTTP::Get.new(servers_path)).body
+      json = servers_client.get(servers_path, json_headers).body
       JSON.parse(json)['servers']
     end
 
@@ -97,7 +104,7 @@ module Raca
 
     def flavors
       @flavors ||= begin
-        data = cloud_request(Net::HTTP::Get.new(flavors_path)).body
+        data = servers_client.get(flavors_path, json_headers).body
         JSON.parse(data)['flavors']
       end
     end
@@ -119,7 +126,7 @@ module Raca
 
     def images
       @images ||= begin
-        data = cloud_request(Net::HTTP::Get.new(images_path)).body
+        data = servers_client.get(images_path, json_headers).body
         JSON.parse(data)['images']
       end
     end
@@ -139,49 +146,8 @@ module Raca
       end
     end
 
-    def cloud_request(request, body = nil)
-      request['X-Auth-Token'] = @account.auth_token
-      request['Content-Type'] = 'application/json'
-      request['Accept']       = 'application/json'
-      cloud_http(servers_host) do |http|
-        http.request(request, body)
-      end
-    end
-
-    def cloud_http(hostname, retries = 3, &block)
-      http = Net::HTTP.new(hostname, 443)
-      http.use_ssl = true
-      http.start do |http|
-        response = block.call http
-        if response.is_a?(Net::HTTPUnauthorized)
-          log "Rackspace returned HTTP 401; refreshing auth before retrying."
-          @account.refresh_cache
-          response = block.call http
-        end
-        if response.is_a?(Net::HTTPSuccess)
-          response
-        else
-          raise_on_error(response)
-        end
-        response
-      end
-    rescue Timeout::Error
-      if retries <= 0
-        raise Raca::TimeoutError, "Timeout from Rackspace while trying #{request.class} to #{request.path}"
-      end
-
-      cloud_http(hostname, retries - 1, &block)
-    end
-
-    def raise_on_error(response)
-      error_klass = case response.code.to_i
-      when 400 then BadRequestError
-      when 404 then NotFoundError
-      when 500 then ServerError
-      else
-        HTTPError
-      end
-      raise error_klass, "Rackspace returned HTTP status #{response.code}"
+    def servers_client
+      @servers_client ||= @account.http_client(servers_host)
     end
 
     def log(msg)

data/lib/raca/util.rb

@@ -0,0 +1,11 @@
+module Raca
+  # Misc helper methods used across the codebase
+  class Util
+    # CGI.escape, but without special treatment on spaces
+    def self.url_encode(str)
+      str.gsub(%r{([^a-zA-Z0-9_./-]+)}) do |match|
+        '%' + match.unpack('H2*' * match.bytesize).join('%').upcase
+      end
+    end
+  end
+end

data/lib/raca.rb

@@ -3,5 +3,7 @@ require 'raca/errors'
 require 'raca/account'
 require 'raca/container'
 require 'raca/containers'
+require 'raca/http_client'
 require 'raca/server'
 require 'raca/servers'
+require 'raca/util'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raca
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - James Healy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-19 00:00:00.000000000 Z
+date: 2014-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -87,6 +87,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG
+- MIT-LICENSE
 - README.markdown
 - Rakefile
 - lib/raca.rb
@@ -94,8 +96,10 @@ files:
 - lib/raca/container.rb
 - lib/raca/containers.rb
 - lib/raca/errors.rb
+- lib/raca/http_client.rb
 - lib/raca/server.rb
 - lib/raca/servers.rb
+- lib/raca/util.rb
 homepage: http://github.com/conversation/raca
 licenses:
 - MIT