raca 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 41701304d4625b6d3f99be830e6b5aa1facf6875
+  data.tar.gz: eadc909441d33e2b46270ff08f1c7762d424393b
+SHA512:
+  metadata.gz: d52aca857ce76407dd7f3fc83ff1eb044627eb3054e397eee46787f467eacd1764147750847b6a5e3be635b63b4c120a7e9b6b8b4bf3d7e9f8bfeb95253a78b1
+  data.tar.gz: a46a22b4169f9a7d888633cc402b68634fae716d007a10bcca21cc9c2cd72c5ac5468289ecdb911b0d1b230596e5765ff148a937b50a23fa7a079c5f266a95a7

data/README.markdown

@@ -0,0 +1,123 @@
+# Raca
+
+A simple gem for interacting with Rackspace cloud APIs. The following APIs are
+supported:
+
+* Identity
+* Cloud Files
+* Cloud Servers
+
+Raca intentionally has no dependencies outside the ruby standard library.
+
+If loaded alongside Rails, it will utilise the rails cache to avoid repeated
+requests to the rackspace identity API.
+
+## Installation
+
+    gem install raca
+
+## Usage
+
+For full usage details check the documentation for each class, but here's
+a taste of the basics.
+
+### Regions
+
+Many of the Rackspace cloud products are available in multiple regions. When
+required, you can specify a region using a symbol with the 3-letter region code.
+
+Currently, the following regions are valid:
+
+* :ord - Chicago
+* :iad - Northern Virginia
+* :syd - Sydney
+* :dfw - Dallas-Fort Worth
+* :hkg - Hong Kong
+
+### Identity
+
+To authenticate and begin any interaction with rackspace, you must create a
+Raca::Account instance.
+
+    account = Raca::Account.new("username", "api_key")
+
+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:
+
+    puts account.public_endpoint("cloudFiles", :ord)
+    puts account.service_endpoint("cloudFiles", :ord)
+
+### Cloud Files
+
+Using an existing Raca::Account object, retrieve a collection of Cloud Files
+containers in a region like so:
+
+    ord_containers = account.containers(:ord)
+
+You can retrieve a single container from the collection:
+
+    dir = ord_containers.get("container_name")
+
+Retrieve some metadata on the collection:
+
+    put ord_containers.metadata
+
+With a single container, you can perform a range of operations on the container
+and objects inside it.
+
+    dir = ord_containers.get("container_name")
+
+Download a file:
+
+    dir.download("remote_key.txt", "/home/jh/local_file.txt")
+
+Upload a file:
+
+    dir.upload("target_path.txt", "/home/jh/local_file.txt")
+
+List keys in the container, optionally limiting the results to those
+starting with a prefix:
+
+    puts dir.list
+    puts dir.list(prefix: "subdir/")
+
+Delete an object:
+
+    dir.delete("target_path.txt")
+
+View metadata on the container:
+
+    puts dir.metadata
+    puts dir.cdn_metadata
+
+Enable access to the container contents via a public CDN. Use this with caution, it will make *all* objects public!
+
+It accepts an argument telling the CDN edge nodes how long they can cache each object for (in seconds).
+
+    dir.cdn_enable(60 * 60 * 24) # 1 day
+
+Purge an object from the CDN:
+
+    dir.purge_from_akamai("target_path.txt", "notify@example.com")
+
+Generate a public URL to an object in a private container. The second argument
+is the temp URL key that can be set using Raca::Containers#set_temp_url_key
+
+    ord_containers = account.containers(:ord)
+    ord_containers.set_temp_url_key("secret")
+    dir = ord_containers.get("container_name")
+    puts dir.expiring_url("remote_key.txt", "secret", Time.now.to_i + 60)
+
+### Cloud Servers
+
+    account = Raca::Account.new("username", "api_key")
+    server = account.servers(:ord).get("foo")
+    puts server.public_addresses
+
+## Compatibility
+
+The Raca version number is 0.0.x because it's highly unstable. Until we release
+a 1.0.0, consider the API of this gem to be unstable.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc "Run all rspec files"
+RSpec::Core::RakeTask.new("spec") do |t|
+  t.rspec_opts  = ["--color", "--format progress"]
+  t.ruby_opts = "-w"
+end

data/lib/raca.rb

@@ -0,0 +1,5 @@
+require 'raca/account'
+require 'raca/container'
+require 'raca/containers'
+require 'raca/server'
+require 'raca/servers'

data/lib/raca/account.rb

@@ -0,0 +1,129 @@
+require 'yaml'
+require 'json'
+
+module Raca
+
+  # The rackspace auth API accepts a username and API key and returns a range
+  # of settings that are used for interacting with their other APIS. Think
+  # auth tokens, hostnames, paths, etc.
+  #
+  # This class caches these settings so we don't have to continually use our
+  # username/key to retrieve them.
+  #
+  class Account
+
+    def initialize(username, key, cache = nil)
+      @username, @key, @cache = username, key, cache
+      @cache ||= if defined?(Rails)
+        Rails.cache
+      else
+        {}
+      end
+    end
+
+    def auth_token
+      extract_value(cloudfiles_data, "access", "token", "id")
+    end
+
+    def public_endpoint(service_name, region)
+      region = region.to_s.upcase
+      endpoints = service_endpoints(service_name)
+      regional_endpoint = endpoints.detect { |e| e["region"] == region } || {}
+      regional_endpoint["publicURL"]
+    end
+
+    def containers(region)
+      Raca::Containers.new(self, region)
+    end
+
+    def servers(region)
+      Raca::Servers.new(self, region)
+    end
+
+    def refresh_cache
+      Net::HTTP.new('identity.api.rackspacecloud.com', 443).tap {|http|
+        http.use_ssl = true
+      }.start {|http|
+        payload = {
+          auth: {
+            'RAX-KSKEY:apiKeyCredentials' => {
+              username: @username,
+              apiKey: @key
+            }
+          }
+        }
+        response = http.post(
+          '/v2.0/tokens',
+          JSON.dump(payload),
+          {'Content-Type' => 'application/json'},
+        )
+        if response.is_a? Net::HTTPSuccess
+          cache_write(cache_key, JSON.load(response.body))
+        end
+      }
+    end
+
+    private
+
+    # This method is opaque, but it was the best I could come up with using just
+    # the standard library. Sorry.
+    #
+    # Use this to safely extract values from nested hashes:
+    #
+    #     data = {a: {b: {c: 1}}}
+    #     extract_value(data, :a, :b, :c)
+    #     => 1
+    #
+    #     extract_value(data, :a, :b, :d)
+    #     => nil
+    #
+    #     extract_value(data, :d)
+    #     => nil
+    #
+    def extract_value(data, *keys)
+      if keys.empty?
+        data
+      elsif data.respond_to?(:[]) && data[keys.first]
+        extract_value(data[keys.first], *keys.slice(1,100))
+      else
+        nil
+      end
+    end
+
+    # An array of all the endpoints for a particular service (like cloud files,
+    # cloud servers, dns, etc)
+    #
+    def service_endpoints(service_name)
+      catalog = extract_value(cloudfiles_data, "access", "serviceCatalog") || {}
+      service = catalog.detect { |s| s["name"] == service_name } || {}
+      service["endpoints"] || []
+    end
+
+    def cache_read(key)
+      if @cache.respond_to?(:read) # rails cache
+        @cache.read(key)
+      else
+        @cache[key]
+      end
+    end
+
+    def cache_write(key, value)
+      if @cache.respond_to?(:write) # rails cache
+        @cache.write(key, value)
+      else
+        @cache[key] = value
+      end
+    end
+
+    def cloudfiles_data
+      refresh_cache unless cache_read(cache_key)
+
+      cache_read(cache_key) || {}
+    end
+
+    def cache_key
+      "raca-#{@username}"
+    end
+
+  end
+end

data/lib/raca/container.rb

@@ -0,0 +1,309 @@
+require 'net/http'
+require 'digest/md5'
+require 'openssl'
+require 'uri'
+
+module Raca
+  # Handy abstraction for interacting with a single Cloud Files container. We
+  # could use fog or similar, but this ~200 line class is simple and does
+  # everything we need.
+  class Container
+    MAX_ITEMS_PER_LIST = 10_000
+    LARGE_FILE_THRESHOLD = 5_368_709_120 # 5 Gb
+    LARGE_FILE_SEGMENT_SIZE = 104_857_600 # 100 Mb
+
+    attr_reader :container_name
+
+    def initialize(account, region, container_name, opts = {})
+      raise ArgumentError, "The container name must not contain '/'." if container_name['/']
+      @account, @region, @container_name = account, region, container_name
+      @storage_url = @account.public_endpoint("cloudFiles", region)
+      @cdn_url     = @account.public_endpoint("cloudFilesCDN", region)
+      @logger = opts[:logger]
+      @logger ||= Rails.logger if defined?(Rails)
+    end
+
+    # Upload data_or_path (which may be a filename or an IO) to the container, as key.
+    def upload(key, data_or_path)
+      case data_or_path
+      when StringIO, File
+        upload_io(key, data_or_path, data_or_path.size)
+      when String
+        File.open(data_or_path, "rb") do |io|
+          upload_io(key, io, io.stat.size)
+        end
+      else
+        raise ArgumentError, "data_or_path must be an IO with data or filename string"
+      end
+    end
+
+    # Delete +key+ from the container. If the container is on the CDN, the object will
+    # still be served from the CDN until the TTL expires.
+    def delete(key)
+      log "deleting #{key} from #{container_path}"
+      storage_request(Net::HTTP::Delete.new(File.join(container_path, key)))
+    end
+
+    # Remove +key+ from the CDN edge nodes on which it is currently cached. The object is
+    # not deleted from the container: as the URL is re-requested, the edge cache will be
+    # re-filled with the object currently in the container.
+    #
+    # This shouldn't be used except when it's really required (e.g. when a piece has to be
+    # taken down) because it's expensive: it lodges a support ticket at Akamai. (!)
+    def purge_from_akamai(key, email_address)
+      log "Requesting #{File.join(container_path, key)} to be purged from the CDN"
+      cdn_request(Net::HTTP::Delete.new(
+        File.join(container_path, key),
+        'X-Purge-Email' => email_address
+      ))
+    end
+
+    def download(key, filepath)
+      log "downloading #{key} from #{container_path}"
+      storage_request(Net::HTTP::Get.new(File.join(container_path, key))) do |response|
+        File.open(filepath, 'wb') do |io|
+          response.read_body do |chunk|
+            io.write(chunk)
+          end
+        end
+      end
+    end
+
+    # Return an array of files in the container.
+    #
+    # Supported options
+    #
+    # 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
+    def list(options = {})
+      max = options.fetch(:max, MAX_ITEMS_PER_LIST)
+      marker = options.fetch(:marker, nil)
+      prefix = options.fetch(:prefix, 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|
+        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)
+        end
+      }
+    end
+
+    def search(prefix)
+      log "retrieving container listing from #{container_path} items starting with #{prefix}"
+      list(prefix: prefix)
+    end
+
+    def metadata
+      log "retrieving container metadata from #{container_path}"
+      response = storage_request(Net::HTTP::Head.new(container_path))
+      {
+        :objects => response["X-Container-Object-Count"].to_i,
+        :bytes => response["X-Container-Bytes-Used"].to_i
+      }
+    end
+
+    def cdn_metadata
+      log "retrieving container CDN metadata from #{container_path}"
+      response = cdn_request(Net::HTTP::Head.new(container_path))
+      {
+        :cdn_enabled => response["X-CDN-Enabled"] == "True",
+        :host => response["X-CDN-URI"],
+        :ssl_host => response["X-CDN-SSL-URI"],
+        :streaming_host => response["X-CDN-STREAMING-URI"],
+        :ttl => response["X-TTL"].to_i,
+        :log_retention => response["X-Log-Retention"] == "True"
+      }
+    end
+
+    # use this with caution, it will make EVERY object in the container publicly available
+    # via the CDN. CDN enabling can be done via the web UI but only with a TTL of 72 hours.
+    # Using the API it's possible to set a TTL of 50 years.
+    #
+    def cdn_enable(ttl = 72.hours.to_i)
+      log "enabling CDN access to #{container_path} with a cache expiry of #{ttl / 60} minutes"
+
+      cdn_request Net::HTTP::Put.new(container_path, "X-TTL" => ttl.to_i.to_s)
+    end
+
+    # Generate a expiring URL for a file that is otherwise private. useful for providing temporary
+    # access to files.
+    #
+    def expiring_url(object_key, temp_url_key, expires_at = Time.now.to_i + 60)
+      digest = OpenSSL::Digest::Digest.new('sha1')
+
+      method  = 'GET'
+      expires = expires_at.to_i
+      path    = File.join(container_path, 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}"
+    end
+
+    private
+
+    def upload_io(key, io, byte_count)
+      if byte_count <= LARGE_FILE_THRESHOLD
+        upload_io_standard(key, io, byte_count)
+      else
+        upload_io_large(key, io, byte_count)
+      end
+    end
+
+    def upload_io_standard(key, io, byte_count)
+      full_path = File.join(container_path, key)
+
+      headers = {}
+      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)
+        headers['Etag']           = md5(io.path)
+      end
+      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
+      storage_request(request)
+    end
+
+    def upload_io_large(key, io, byte_count)
+      segment_count = (byte_count.to_f / LARGE_FILE_SEGMENT_SIZE).ceil
+      segments = []
+      while segments.size < segment_count
+        start_pos = 0 + (LARGE_FILE_SEGMENT_SIZE * segments.size)
+        segment_key = "%s.%03d" % [key, segments.size]
+        io.seek(start_pos)
+        segment_io = StringIO.new(io.read(LARGE_FILE_SEGMENT_SIZE))
+        result = upload_io_standard(segment_key, segment_io, segment_io.size)
+        segments << {path: "#{@container_name}/#{segment_key}", etag: result["ETag"], size_bytes: segment_io.size}
+      end
+      manifest_key = "#{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)
+    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 "Timeout from Rackspace at #{Time.now} while trying #{request.class} to #{request.path}"
+      end
+
+      unless defined?(Rails) && Rails.env.test?
+        retry_interval = 5 + (retries.to_i * 5) # Retry after 5, 10, 15 and 20 seconds
+        log "Rackspace timed out: retrying after #{retry_interval}s"
+        sleep(retry_interval)
+      end
+
+      cloud_request(request, hostname, retries + 1, &block)
+    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
+        raise "Failure: Rackspace returned #{response.inspect}" unless response.is_a?(Net::HTTPSuccess)
+        response
+      end
+    end
+
+    def log(msg)
+      if @logger.respond_to?(:debug)
+        @logger.debug msg
+      end
+    end
+
+    def storage_host
+      URI.parse(@storage_url).host
+    end
+
+    def storage_path
+      URI.parse(@storage_url).path
+    end
+
+    def cdn_host
+      URI.parse(@cdn_url).host
+    end
+
+    def cdn_path
+      URI.parse(@cdn_url).path
+    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
+    end
+
+    def extension_content_type(path)
+      {
+        ".css" => "text/css",
+        ".eot" => "application/vnd.ms-fontobject",
+        ".html" => "text/html",
+        ".js" => "application/javascript",
+        ".png" => "image/png",
+        ".jpg" => "image/jpeg",
+        ".txt" => "text/plain",
+        ".woff" => "font/woff",
+        ".zip" => "application/zip"
+      }[File.extname(path)]
+    end
+
+    # Fonts need to be served with CORS headers to work in IE and FF
+    #
+    def content_type_needs_cors(path)
+      [".eot",".ttf",".woff"].include?(File.extname(path))
+    end
+
+    def md5(path)
+      digest = Digest::MD5.new
+      File.open(path, 'rb') do |f|
+        # read in 128K chunks
+        f.each(1024 * 128) do |chunk|
+          digest << chunk
+        end
+      end
+      digest.hexdigest
+    end
+  end
+end

data/lib/raca/containers.rb

@@ -0,0 +1,79 @@
+module Raca
+  class Containers
+    def initialize(account, region, opts = {})
+      @account, @region = account, region
+      @storage_url = @account.public_endpoint("cloudFiles", region)
+      @logger = opts[:logger]
+      @logger ||= Rails.logger if defined?(Rails)
+    end
+
+    def get(container_name)
+      Raca::Container.new(@account, @region, container_name)
+    end
+
+    # Return metadata on all containers
+    #
+    def metadata
+      log "retrieving containers metadata from #{storage_path}"
+      response    = storage_request(Net::HTTP::Head.new(storage_path))
+      {
+        :containers => response["X-Account-Container-Count"].to_i,
+        :objects    => response["X-Account-Object-Count"].to_i,
+        :bytes      => response["X-Account-Bytes-Used"].to_i
+      }
+    end
+
+    # Set the secret key that will be used to generate expiring URLs for all cloud files containers on the current account. This value should be passed to the expiring_url() method.
+    #
+    # Use this with caution, this will invalidate all previously generated expiring URLS *FOR THE ENTIRE ACCOUNT*
+    #
+    def set_temp_url_key(secret)
+      log "setting Account Temp URL Key on #{storage_path}"
+
+      storage_request Net::HTTP::Post.new(storage_path, "X-Account-Meta-Temp-Url-Key" => secret.to_s)
+    end
+
+    private
+
+    def storage_host
+      URI.parse(@storage_url).host
+    end
+
+    def storage_path
+      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
+        raise "Failure: Rackspace returned #{response.inspect}" unless response.is_a?(Net::HTTPSuccess)
+        response
+      end
+    end
+
+    def log(msg)
+      if @logger.respond_to?(:debug)
+        @logger.debug msg
+      end
+    end
+  end
+end

data/lib/raca/server.rb

@@ -0,0 +1,223 @@
+require 'json'
+require 'base64'
+require 'net/http'
+
+module Raca
+  # Handy abstraction for interacting with a single rackspace Clpud Server. We
+  # could use fog or similar, but this ~200 line class is simple and does
+  # everything we need.
+  class Server
+
+    attr_reader :server_name, :server_id
+
+    def initialize(account, region, server_name)
+      @account = account
+      @region = region
+      @servers_url = @account.public_endpoint("cloudServersOpenStack", region)
+      @server_name = server_name
+      @server_id = find_server_id(server_name)
+    end
+
+    # return true if this server exists on Rackspace
+    #
+    def exists?
+      @server_id != nil
+    end
+
+    # create this server on Rackspace.
+    #
+    # flavor_name is a string that describes the amount of RAM. If you enter
+    # an invalid option a list of valid options will be raised.
+    #
+    # image_name is a string that describes the OS image to use. If you enter
+    # an invalid option a list of valid options will be raised. I suggest
+    # starting with 'Ubuntu 10.04 LTS'
+    #
+    # files is an optional Hash of path to blobs. Use it to place a file on the
+    # disk of the new server.
+    #
+    # Use it like this:
+    #
+    #     server.create(512, "Ubuntu 10.04 LTS", "/root/.ssh/authorised_keys" => File.read("/foo"))
+    #
+    def create(flavor_name, image_name, files = {})
+      raise ArgumentError, "server already exists" if exists?
+
+      request = {
+        "server" => {
+          "name" => @server_name,
+          "imageRef" => image_name_to_id(image_name),
+          "flavorRef" => flavor_name_to_id(flavor_name),
+        }
+      }
+      files.each do |path, blob|
+        request['server']['personality'] ||= []
+        request['server']['personality'] << {
+          'path' => path,
+          'contents' => Base64.encode64(blob)
+        }
+      end
+
+      data = cloud_request(Net::HTTP::Post.new(servers_path), JSON.dump(request)).body
+      data = JSON.parse(data)['server']
+      @server_id = data['id']
+    end
+
+    def delete!
+      raise ArgumentError, "server doesn't exist" unless exists?
+
+      response = cloud_request(Net::HTTP::Delete.new(server_path))
+      response.is_a? Net::HTTPSuccess
+    end
+
+    # Poll Rackspace and return once a server is in an active state. Useful after
+    # creating a new server
+    #
+    def wait_for_active
+      until details['status'] == 'ACTIVE'
+        log "Not online yet. Waiting..."
+        sleep 10
+      end
+    end
+
+    # An array of private IP addresses for the server. They can be ipv4 or ipv6
+    #
+    def private_addresses
+      details['addresses']['private'].map { |i| i["addr"] }
+    end
+
+    # An array of public IP addresses for the server. They can be ipv4 or ipv6
+    #
+    def public_addresses
+      details['addresses']['public'].map { |i| i["addr"] }
+    end
+
+    # A Hash of various matadata about the server
+    #
+    def details
+      raise ArgumentError, "server doesn't exist" unless exists?
+
+      data = cloud_request(Net::HTTP::Get.new(server_path)).body
+      JSON.parse(data)['server']
+    end
+
+    private
+
+    def list
+      json = cloud_request(Net::HTTP::Get.new(servers_path)).body
+      JSON.parse(json)['servers']
+    end
+
+    def find_server_id(server_name)
+      server = list.detect {|row|
+        row["name"] == server_name
+      }
+      server ? server["id"] : nil
+    end
+
+    def flavors_path
+      @flavors_path ||= File.join(account_path, "flavors")
+    end
+
+    def images_path
+      @images_path ||= File.join(account_path, "images")
+    end
+
+    def server_path
+      @server_path ||= File.join(account_path, "servers", @server_id.to_s)
+    end
+
+    def servers_path
+      @servers_path ||= File.join(account_path, "servers")
+    end
+
+    def servers_host
+      @servers_host ||= URI.parse(@servers_url).host
+    end
+
+    def account_path
+      @account_path ||= URI.parse(@servers_url).path
+    end
+
+    def flavors
+      @flavors ||= begin
+        data = cloud_request(Net::HTTP::Get.new(flavors_path)).body
+        JSON.parse(data)['flavors']
+      end
+    end
+
+    def flavor_names
+      flavors.map {|row| row['name'] }
+    end
+
+    def flavor_name_to_id(str)
+      flavor = flavors.detect {|row|
+        row['name'].downcase.include?(str.to_s.downcase)
+      }
+      if flavor
+        flavor['id']
+      else
+        raise ArgumentError, "valid flavors are: #{flavor_names.join(', ')}"
+      end
+    end
+
+    def images
+      @images ||= begin
+        data = cloud_request(Net::HTTP::Get.new(images_path)).body
+        JSON.parse(data)['images']
+      end
+    end
+
+    def image_names
+      images.map {|row| row['name'] }
+    end
+
+    def image_name_to_id(str)
+      image = images.detect {|row|
+        row['name'].downcase.include?(str.to_s.downcase)
+      }
+      if image
+        image['id']
+      else
+        raise ArgumentError, "valid images are: #{image_names.join(', ')}"
+      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
+        raise "Failure: Rackspace returned #{response.inspect}" unless response.is_a?(Net::HTTPSuccess)
+        response
+      end
+    rescue Timeout::Error => e
+      raise e if retries <= 0
+
+      cloud_http(hostname, retries - 1, &block)
+    end
+
+    def log(msg)
+      if defined?(Rails)
+        Rails.logger.info msg
+      else
+        puts msg
+      end
+    end
+
+  end
+end

data/lib/raca/servers.rb

@@ -0,0 +1,11 @@
+module Raca
+  class Servers
+    def initialize(account, region)
+      @account, @region = account, region
+    end
+
+    def get(server_name)
+      Raca::Server.new(@account, @region, server_name)
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: raca
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Healy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ir_b
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple wrapper for the Rackspace Cloud API with no dependencies
+email:
+- james.healy@theconversation.edu.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.markdown
+- Rakefile
+- lib/raca.rb
+- lib/raca/account.rb
+- lib/raca/container.rb
+- lib/raca/containers.rb
+- lib/raca/server.rb
+- lib/raca/servers.rb
+homepage: http://github.com/conversation/raca
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--title"
+- Raca
+- "--line-numbers"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: A simple wrapper for the Rackspace Cloud API with no dependencies
+test_files: []