clouddb 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+# IDE files to ignore
+*.iml
+.idea/*

data/COPYING

@@ -0,0 +1,12 @@
+Unless otherwise noted, all files are released under the MIT license, exceptions contain licensing information in them.
+
+  Copyright (C) 2012 Rackspace US, Inc.
+
+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.
+
+Except as contained in this notice, the name of Rackspace US, Inc. shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from Rackspace US, Inc.
+

data/README.rdoc

@@ -0,0 +1,45 @@
+= Rackspace Cloud Databases
+
+== Description
+
+This is a Ruby interface into the Rackspace[http://rackspace.com/] {Cloud Databases}[http://www.rackspace.com/blog/announcing-the-rackspace-mysql-cloud-database-private-beta/] service.
+
+== Installation
+
+This source is available on Github[http://github.com/rackspace/ruby-clouddb/] and the gem is available on RubyGems[http://rubygems.org/] (coming soon..).  To install it, do
+
+  sudo gem install clouddb
+  
+To use it in Bundler, add the following statement to your Gemfile
+
+  gem "clouddb"
+  
+== RDOC Documentation
+
+Find the latest RDoc documentation for this library at http://rdoc.info/github/rackspace/ruby-clouddb/master/frames
+
+== API Documentation
+
+This binding attempts to conform to the latest API specifications. For current API documentation, visit http://docs.rackspacecloud.com/api/
+
+== Examples
+
+See the class definitions for documentation on specific methods and operations.
+
+  require 'rubygems'
+  require 'clouddb'
+
+  # Authenticate to the Rackspace Cloud, and choose to manage databases in the Dallas/Ft. Worth datacenter
+  dbaas = CloudDB::Connection.new(:username => "MY_USERNAME", :api_key => "MY_API_KEY", :region => :dfw)
+
+== Authors
+
+{Jorge Miramontes}[https://github.com/jorgem1106/] <jorge.miramontes@rackspace.com>
+{H. Wade Minter}[https://github.com/minter/] <minter@lunenburg.org>
+
+== License
+
+See COPYING for license information.
+Copyright (c) 2012, Rackspace US, Inc.
+  
+  

data/clouddb.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require File.expand_path('../lib/clouddb/version.rb', __FILE__)
+ 
+Gem::Specification.new do |s|
+  s.name        = "clouddb"
+  s.version     = CloudDB::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = %w("Jorge Miramontes", "H. Wade Minter")
+  s.email       = %w(jorge.miramontes@rackspace.com minter@lunenburg.org)
+  s.homepage    = "http://github.com/rackspace/ruby-clouddb"
+  s.summary     = "Ruby API into the Rackspace Cloud Databases product"
+  s.description = "A Ruby API to manage the Rackspace Cloud Databases product"
+ 
+  s.required_rubygems_version = ">= 1.3.6"
+ 
+  s.add_runtime_dependency "typhoeus"
+  s.add_runtime_dependency "json"
+ 
+  s.files = [
+    "COPYING",
+    ".gitignore",
+    "README.rdoc",
+    "clouddb.gemspec",
+    "lib/clouddb.rb",
+    "lib/clouddb/authentication.rb",
+    "lib/clouddb/flavor.rb",
+    "lib/clouddb/instance.rb",
+    "lib/clouddb/database.rb",
+    "lib/clouddb/user.rb",
+    "lib/clouddb/connection.rb",
+    "lib/clouddb/exception.rb",
+    "lib/clouddb/version.rb"
+  ]
+  s.require_path = 'lib'
+end

data/lib/clouddb.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+# 
+# == Cloud Databases API
+# ==== Connects Ruby Applications to Rackspace's {Cloud Databases service}[http://www.rackspace.com/cloud/cloud_hosting_products/databases/]
+# By Jorge Miramontes <jorge.miramontes@rackspace.com> and H. Wade Minter <minter@lunenburg.org>
+#
+# See COPYING for license information.
+# Copyright (c) 2012, Rackspace US, Inc.
+# ----
+# 
+# === Documentation & Examples
+# To begin reviewing the available methods and examples, peruse the README.rodc file, or begin by looking at documentation for the 
+# CloudDB::Connection class.
+#
+# The CloudDB class is the base class.  Not much of note aside from housekeeping happens here.
+# To create a new CloudDB connection, use the CloudDB::Connection.new method.
+
+module CloudDB
+  
+  AUTH_USA = "https://auth.api.rackspacecloud.com/v1.0"
+  AUTH_UK = "https://lon.auth.api.rackspacecloud.com/v1.0"
+
+  require 'uri'
+  require 'rubygems'
+  require 'json'
+  require 'date'
+  require 'typhoeus'
+
+  unless "".respond_to? :each_char
+    require "jcode"
+    $KCODE = 'u'
+  end
+
+  $:.unshift(File.dirname(__FILE__))
+  require 'clouddb/version'
+  require 'clouddb/exception'
+  require 'clouddb/authentication'
+  require 'clouddb/connection'
+  require 'clouddb/flavor'
+  require 'clouddb/instance'
+  require 'clouddb/database'
+  require 'clouddb/user'
+
+  # Helper method to recursively symbolize hash keys.
+  def self.symbolize_keys(obj)
+    case obj
+    when Array
+      obj.inject([]){|res, val|
+        res << case val
+        when Hash, Array
+          symbolize_keys(val)
+        else
+          val
+        end
+        res
+      }
+    when Hash
+      obj.inject({}){|res, (key, val)|
+        nkey = case key
+        when String
+          key.to_sym
+        else
+          key
+        end
+        nval = case val
+        when Hash, Array
+          symbolize_keys(val)
+        else
+          val
+        end
+        res[nkey] = nval
+        res
+      }
+    else
+      obj
+    end
+  end
+  
+  def self.hydra
+    @@hydra ||= Typhoeus::Hydra.new
+  end
+  
+  # CGI.escape, but without special treatment on spaces
+  def self.escape(str,extra_exclude_chars = '')
+    str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
+      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+    end
+  end
+  
+  def self.paginate(options = {})
+    path_args = []
+    path_args.push(URI.encode("limit=#{options[:limit]}")) if options[:limit]
+    path_args.push(URI.encode("offset=#{options[:offset]}")) if options[:offset]
+    path_args.join("&")
+  end
+  
+
+end

data/lib/clouddb/authentication.rb

@@ -0,0 +1,36 @@
+module CloudDB
+  class Authentication
+    
+    # Performs an authentication to the Rackspace Cloud authorization servers.  Opens a new HTTP connection to the API server,
+    # sends the credentials, and looks for a successful authentication.  If it succeeds, it sets the svrmgmthost,
+    # svrmgtpath, svrmgmtport, svrmgmtscheme, authtoken, and authok variables on the connection.  If it fails, it raises
+    # an exception.
+    #
+    # Should probably never be called directly.
+    def initialize(connection)
+      request = Typhoeus::Request.new(connection.auth_url,
+        :method                        => :get,
+        :headers                       => { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey, "User-Agent" => "Cloud Databases Ruby API #{VERSION}" },
+        :verbose                       => ENV['DATABASES_VERBOSE'] ? true : false)
+      CloudDB.hydra.queue(request)
+      CloudDB.hydra.run
+      response = request.response
+      headers = response.headers_hash
+      if (response.code.to_s == "204")
+        connection.authtoken = headers["x-auth-token"]
+        user_id = headers["x-server-management-url"].match(/.*\/(\d+)$/)[1]
+        headers["x-server-management-url"] = "https://#{connection.region}.databases.api.rackspacecloud.com/v1.0/#{user_id}"
+        connection.dbmgmthost = URI.parse(headers["x-server-management-url"]).host
+        connection.dbmgmtpath = URI.parse(headers["x-server-management-url"]).path.chomp
+        # Force the path into the v1.0 URL space
+        connection.dbmgmtpath.sub!(/\/.*?\//, '/v1.0/')
+        connection.dbmgmtport = URI.parse(headers["x-server-management-url"]).port
+        connection.dbmgmtscheme = URI.parse(headers["x-server-management-url"]).scheme
+        connection.authok = true
+      else
+        connection.authtoken = false
+        raise CloudDB::Exception::Authentication, "Authentication failed with response code #{response.code}"
+      end
+    end
+  end
+end

data/lib/clouddb/connection.rb

@@ -0,0 +1,224 @@
+module CloudDB
+  class Connection
+
+    attr_reader   :authuser
+    attr_reader   :authkey
+    attr_accessor :authtoken
+    attr_accessor :authok
+    attr_accessor :dbmgmthost
+    attr_accessor :dbmgmtpath
+    attr_accessor :dbmgmtport
+    attr_accessor :dbmgmtscheme
+    attr_reader   :auth_url
+    attr_reader   :region
+
+    # Creates a new CloudDB::Connection object.  Uses CloudDB::Authentication to perform the login for the connection.
+    #
+    # Setting the retry_auth option to false will cause an exception to be thrown if your authorization token expires.
+    # Otherwise, it will attempt to re-authenticate.
+    #
+    # This will likely be the base class for most operations.
+    #
+    # The constructor takes a hash of options, including:
+    #   :username - Your Rackspace Cloud username *required*
+    #   :api_key - Your Rackspace Cloud API key *required*
+    #   :region - The region in which to manage database instances. Current options are :dfw (Rackspace Dallas/Ft. Worth
+    #             Datacenter), :ord (Rackspace Chicago Datacenter) and :lon (Rackspace London Datacenter). *required*
+    #   :auth_url - The URL to use for authentication.  (defaults to Rackspace USA).
+    #   :retry_auth - Whether to retry if your auth token expires (defaults to true)
+    #
+    # Example:
+    #   dbaas = CloudDB::Connection.new(:username => 'YOUR_USERNAME', :api_key => 'YOUR_API_KEY', :region => :dfw)
+    def initialize(options = {:retry_auth => true})
+      @authuser = options[:username] || (raise CloudDB::Exception::Authentication, "Must supply a :username")
+      @authkey = options[:api_key] || (raise CloudDB::Exception::Authentication, "Must supply an :api_key")
+      @region = options[:region] || (raise CloudDB::Exception::Authentication, "Must supply a :region")
+      @retry_auth = options[:retry_auth]
+      @auth_url = options[:auth_url] || CloudDB::AUTH_USA
+      @snet = ENV['RACKSPACE_SERVICENET'] || options[:snet]
+      @authok = false
+      @http = {}
+      CloudDB::Authentication.new(self)
+    end
+
+    # Returns true if the authentication was successful and returns false otherwise.
+    #
+    # Example:
+    #   dbaas.authok?
+    #   => true
+    def authok?
+      @authok
+    end
+
+    # Returns the list of available database instances.
+    #
+    # Information returned includes:
+    #   :id - The numeric id of the instance.
+    #   :name - The name of the instance.
+    #   :status - The current state of the instance (BUILD, ACTIVE, BLOCKED, RESIZE, SHUTDOWN, FAILED).
+    def list_instances()
+      response = dbreq("GET", dbmgmthost, "#{dbmgmtpath}/instances", dbmgmtport, dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      instances = CloudDB.symbolize_keys(JSON.parse(response.body)["instances"])
+      return instances
+    end
+    alias :instances :list_instances
+
+    # Returns the list of available database instances with detail.
+    #
+    # Information returned includes:
+    #   :id - The numeric ID of the instance.
+    #   :name - The name of the instance.
+    #   :status - The current state of the instance (BUILD, ACTIVE, BLOCKED, RESIZE, SHUTDOWN, FAILED).
+    #   :hostname - A DNS-resolvable hostname associated with the database instance.
+    #   :flavor - The flavor of the instance.
+    #   :volume - The volume size of the instance.
+    #   :created - The time when the instance was created.
+    #   :updated - The time when the instance was last updated.
+    def list_instances_detail()
+      response = dbreq("GET", dbmgmthost, "#{dbmgmtpath}/instances/detail", dbmgmtport, dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      instances = CloudDB.symbolize_keys(JSON.parse(response.body)["instances"])
+      return instances
+    end
+    alias :instances_detail :list_instances_detail
+
+    # Returns a CloudDB::Instance object for the given instance ID number.
+    #
+    # Example:
+    #   dbaas.get_instance(692d8418-7a8f-47f1-8060-59846c6e024f)
+    def get_instance(id)
+      CloudDB::Instance.new(self,id)
+    end
+    alias :instance :get_instance
+
+    # Creates a brand new database instance under your account.
+    #
+    # Options:
+    #   :flavor_ref - reference to a flavor as specified in the response from the List Flavors API call. *required*
+    #   :name - the name of the database instance.  Limited to 128 characters or less. *required*
+    #   :size - specifies the volume size in gigabytes (GB). The value specified must be between 1 and 10. *required*
+    #   :databases - the databases to be created for the instance.
+    #   :users - the users to be created for the instance.
+    #
+    # Example:
+    #   i = dbaas.create_instance(:flavor_ref => "https://ord.databases.api.rackspacecloud.com/v1.0/1234/flavors/1",
+    #                             :name => "test_instance",
+    #                             :volume => {:size => "1"},
+    #                             :databases => [{:name => "testdb"}],
+    #                             :users => [{:name => "test",
+    #                                         :password => "test",
+    #                                         :databases => [{:name => "testdb"}]}
+    #                                       ]
+    #                            )
+    def create_instance(options = {})
+      body = Hash.new
+      body[:instance] = Hash.new
+
+      body[:instance][:flavorRef]  = options[:flavor_ref] or raise CloudDB::Exception::MissingArgument, "Must provide a flavor to create an instance"
+      body[:instance][:name]       = options[:name] or raise CloudDB::Exception::MissingArgument, "Must provide a name to create an instance"
+      body[:instance][:volume]     = options[:volume] or raise CloudDB::Exception::MissingArgument, "Must provide a size to create an instance"
+      body[:instance][:databases]  = options[:databases] if options[:databases]
+      body[:instance][:users]      = options[:users] if options[:users]
+      (raise CloudDB::Exception::Syntax, "Instance name must be 128 characters or less") if options[:name].size > 128
+
+      response = dbreq("POST", dbmgmthost, "#{dbmgmtpath}/instances", dbmgmtport, dbmgmtscheme, {}, body.to_json)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      body = JSON.parse(response.body)['instance']
+      return get_instance(body["id"])
+    end
+
+    # Returns the list of available database flavors.
+    #
+    # Information returned includes:
+    #   :id - The numeric id of this flavor
+    #   :name - The name of the flavor
+    #   :links - Useful information regarding the flavor
+    def list_flavors()
+      response = dbreq("GET", dbmgmthost, "#{dbmgmtpath}/flavors", dbmgmtport, dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      flavors = CloudDB.symbolize_keys(JSON.parse(response.body)["flavors"])
+      return flavors
+    end
+    alias :flavors :list_flavors
+
+    # Returns the list of available database flavors in detail.
+    #
+    # Information returned includes:
+    #   :id - The numeric id of this flavor
+    #   :name - The name of the flavor
+    #   :vcpus - The amount of virtual cpu power
+    #   :ram - The available memory in MB
+    #   :links - Useful information regarding the flavor
+    def list_flavors_detail()
+      response = dbreq("GET", dbmgmthost, "#{dbmgmtpath}/flavors/detail", dbmgmtport, dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      flavors = CloudDB.symbolize_keys(JSON.parse(response.body)["flavors"])
+      return flavors
+    end
+    alias :flavors_detail :list_flavors_detail
+
+    # Returns a CloudDB::Flavor object for the given flavor id number.
+    #
+    # Example:
+    #   dbaas.get_flavor(3)
+    def get_flavor(id)
+      CloudDB::Flavor.new(self,id)
+    end
+    alias :flavor :get_flavor
+
+    # This method actually makes the HTTP REST calls out to the server. Relies on the thread-safe typhoeus
+    # gem to do the heavy lifting.  Never called directly.
+    def dbreq(method, server, path, port, scheme, headers = {}, data = nil, attempts = 0) # :nodoc:
+      if data
+        unless data.is_a?(IO)
+          headers['Content-Length'] = data.respond_to?(:lstat) ? data.stat.size : data.size
+        end
+      else
+        headers['Content-Length'] = 0
+      end
+      hdrhash = headerprep(headers)
+      url = "#{scheme}://#{server}#{path}"
+      print "DEBUG: Data is #{data}\n" if (data && ENV['DATABASES_VERBOSE'])
+      request = Typhoeus::Request.new(url,
+                                      :body          => data,
+                                      :method        => method.downcase.to_sym,
+                                      :headers       => hdrhash,
+                                      :verbose       => ENV['DATABASES_VERBOSE'] ? true : false)
+      CloudDB.hydra.queue(request)
+      CloudDB.hydra.run
+
+      response = request.response
+      print "DEBUG: Body is #{response.body}\n" if ENV['DATABASES_VERBOSE']
+      raise CloudDB::Exception::ExpiredAuthToken if response.code.to_s == "401"
+      response
+    rescue Errno::EPIPE, Errno::EINVAL, EOFError
+      # Server closed the connection, retry
+      raise CloudDB::Exception::Connection, "Unable to reconnect to #{server} after #{attempts} attempts" if attempts >= 5
+      attempts += 1
+      @http[server].finish if @http[server].started?
+      start_http(server,path,port,scheme,headers)
+      retry
+    rescue CloudDB::Exception::ExpiredAuthToken
+      raise CloudDB::Exception::Connection, "Authentication token expired and you have requested not to retry" if @retry_auth == false
+      CloudDB::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["Accept"] = "application/json"
+      default_headers["Content-Type"] = "application/json"
+      default_headers["User-Agent"] = "Cloud Databases Ruby API #{CloudDB::VERSION}"
+      default_headers.merge(headers)
+    end
+
+  end
+end

data/lib/clouddb/database.rb

@@ -0,0 +1,27 @@
+module CloudDB
+  class Database
+
+    attr_reader :name
+
+    # Creates a new CloudDB::Database object representing a database.
+    def initialize(instance, name)
+      @connection     = instance.connection
+      @instance       = instance
+      @name           = name
+      @dbmgmthost     = @connection.dbmgmthost
+      @dbmgmtpath     = @connection.dbmgmtpath
+      @dbmgmtport     = @connection.dbmgmtport
+      @dbmgmtscheme   = @connection.dbmgmtscheme
+      self
+    end
+
+    # Deletes the current Database object and removes it from the instance. Returns true if successful, raises an
+    # exception if not.
+    def destroy!
+      response = @connection.dbreq("DELETE",@dbmgmthost,"#{@dbmgmtpath}/instances/#{CloudDB.escape(@instance.id.to_s)}/databases/#{CloudDB.escape(@name.to_s)}",@dbmgmtport,@dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+  end
+end

data/lib/clouddb/exception.rb

@@ -0,0 +1,73 @@
+module CloudDB
+  class Exception
+
+    class CloudDBError < StandardError
+
+      attr_reader :response_body
+      attr_reader :response_code
+
+      def initialize(message, code, response_body)
+        @response_code=code
+        @response_body=response_body
+        super(message)
+      end
+
+    end
+    
+    class ServiceFault                < CloudDBError # :nodoc:
+    end
+    class InstanceFault               < CloudDBError # :nodoc:
+    end
+    class ServiceUnavailable          < CloudDBError # :nodoc:
+    end
+    class Unauthorized                < CloudDBError # :nodoc:
+    end
+    class BadRequest                  < CloudDBError # :nodoc:
+    end
+    class ItemNotFound                < CloudDBError # :nodoc:
+    end
+    class OverLimit                   < CloudDBError # :nodoc:
+    end
+    class ImmutableEntity             < CloudDBError # :nodoc:
+    end
+    class UnprocessableEntity         < CloudDBError # :nodoc:
+    end
+    class Other                       < CloudDBError # :nodoc:
+    end
+    
+    # Plus some others that we define here
+    
+    class ExpiredAuthToken            < StandardError # :nodoc:
+    end
+    class MissingArgument             < StandardError # :nodoc:
+    end
+    class Authentication              < StandardError # :nodoc:
+    end
+    class Connection                  < StandardError # :nodoc:
+    end
+    class Syntax                      < StandardError # :nodoc:
+    end
+    
+        
+    # In the event of a non-200 HTTP status code, this method takes the HTTP response, parses
+    # the JSON from the body to get more information about the exception, then raises the
+    # proper error.  Note that all exceptions are scoped in the CloudDB::Exception namespace.
+    def self.raise_exception(response)
+      return if response.code =~ /^20.$/
+      begin
+        fault = nil
+        info = nil
+        JSON.parse(response.body).each_pair do |key, val|
+			    fault=key
+			    info=val
+			  end
+        exception_class = self.const_get(fault[0,1].capitalize+fault[1,fault.length])
+        raise exception_class.new(info["message"], response.code, response.body)
+      rescue NameError, JSON::ParserError
+        raise CloudDB::Exception::Other.new("The server returned status #{response.code} with body #{response.body}", response.code, response.body)
+      end
+    end
+    
+  end
+end
+

data/lib/clouddb/flavor.rb

@@ -0,0 +1,36 @@
+module CloudDB
+  class Flavor
+
+    attr_reader :id
+    attr_reader :name
+    attr_reader :ram
+    attr_reader :vcpus
+
+    # Creates a new CloudDB::Flavor object representing a database flavor.
+    def initialize(connection,id)
+      @connection    = connection
+      @id            = id
+      @dbmgmthost   = connection.dbmgmthost
+      @dbmgmtpath   = connection.dbmgmtpath
+      @dbmgmtport   = connection.dbmgmtport
+      @dbmgmtscheme = connection.dbmgmtscheme
+      populate
+      return self
+    end
+
+    # Updates the information about the current Flavor object by making an API call.
+    def populate
+      response = @connection.dbreq("GET",@dbmgmthost,"#{@dbmgmtpath}/flavors/#{CloudDB.escape(@id.to_s)}",@dbmgmtport,@dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      data = JSON.parse(response.body)['flavor']
+      @id     = data["id"]
+      @name   = data["name"]
+      @ram    = data["ram"]
+      @vcpus  = data["vcpus"]
+      @links  = data["links"]
+      true
+    end
+    alias :refresh :populate
+
+  end
+end

data/lib/clouddb/instance.rb

@@ -0,0 +1,244 @@
+module CloudDB
+  class Instance
+
+    attr_reader :connection
+
+    attr_reader :id
+    attr_reader :name
+    attr_reader :hostname
+    attr_reader :flavor_id
+    attr_reader :root_enabled
+    attr_reader :volume_used
+    attr_reader :volume_size
+    attr_reader :status
+    attr_reader :created
+    attr_reader :updated
+    attr_reader :links
+
+    # Creates a new CloudDB::Instance object representing a database instance.
+    def initialize(connection,id)
+      @connection    = connection
+      @id            = id
+      @dbmgmthost   = connection.dbmgmthost
+      @dbmgmtpath   = connection.dbmgmtpath
+      @dbmgmtport   = connection.dbmgmtport
+      @dbmgmtscheme = connection.dbmgmtscheme
+      populate
+      self
+    end
+
+    # Updates the information about the current instance object by making an API call.
+    def populate
+      response = @connection.dbreq("GET", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}", @dbmgmtport, @dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      data = JSON.parse(response.body)['instance']
+      @id           = data["id"]
+      @name         = data["name"]
+      @hostname     = data["hostname"]
+      @flavor_id    = data["flavor"]["id"] if data["flavor"]
+      @root_enabled = data["rootEnabled"]
+      @volume_used  = data["volume"]["used"] if data["volume"]
+      @volume_size  = data["volume"]["size"] if data["volume"]
+      @status       = data["status"]
+      @created      = data["created"]
+      @updated      = data["updated"]
+      @links        = data["links"]
+      true
+    end
+    alias :refresh :populate
+
+    # Lists the databases associated with this instance
+    #
+    # Example:
+    #   i.list_databases
+    def list_databases
+      response = @connection.dbreq("GET", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/databases", @dbmgmtport, @dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      CloudDB.symbolize_keys(JSON.parse(response.body)["databases"])
+    end
+    alias :databases :list_databases
+
+    # Returns a CloudDB::Database object for the given database name.
+    def get_database(name)
+      CloudDB::Database.new(self, name)
+    end
+    alias :database :get_database
+
+    # Creates brand new databases and associates them with the current instance. Returns true if successful.
+    #
+    # Options for each database in the array:
+    #   :name - Specifies the database name for creating the database. *required*
+    #   :character_set - Set of symbols and encodings. The default character set is utf8.
+    #   :collate - Set of rules for comparing characters in a character set. The default value for collate is
+    #              utf8_general_ci.
+    def create_databases(databases)
+      (raise CloudDB::Exception::Syntax, "Must provide at least one database in the array") if (!databases.is_a?(Array) || databases.size < 1)
+
+      body = Hash.new
+      body[:databases] = Array.new
+
+      for database in databases
+        new_database = Hash.new
+        new_database[:name]          = database[:name] or raise CloudDB::Exception::MissingArgument, "Must provide a name for each database"
+        new_database[:character_set] = database[:character_set] || 'utf8'
+        new_database[:collate]       = database[:collate] || 'utf8_general_ci'
+        (raise CloudDB::Exception::Syntax, "Database names must be 64 characters or less") if database[:name].size > 64
+
+        body[:databases] << new_database
+      end
+
+      response = @connection.dbreq("POST", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/databases", @dbmgmtport, @dbmgmtscheme, {}, body.to_json)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+    # Creates a brand new database and associates it with the current instance. Returns true if successful.
+    #
+    # Options:
+    #   :name - Specifies the database name for creating the database. *required*
+    #   :character_set - Set of symbols and encodings. The default character set is utf8.
+    #   :collate - Set of rules for comparing characters in a character set. The default value for collate is
+    #              utf8_general_ci.
+    def create_database(options={})
+      new_databases = Array.new
+      new_databases << options
+      create_databases new_databases
+    end
+
+    # Lists the users associated with the current Instance
+    #
+    # Example:
+    #   i.list_users
+    def list_users
+      response = @connection.dbreq("GET", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/users", @dbmgmtport, @dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      CloudDB.symbolize_keys(JSON.parse(response.body)["users"])
+    end
+    alias :users :list_users
+
+    # Returns a CloudDB::User object for the given user name.
+    def get_user(name)
+      CloudDB::User.new(self, name)
+    end
+    alias :user :get_user
+
+    # Creates brand new users and associates them with the current instance. Returns true if successful.
+    #
+    # Options for each user in the array:
+    #   :name - Name of the user for the database(s). *required*
+    #   :password - User password for database access. *required*
+    #   :databases - An array of databases with at least one database. *required*
+    def create_users(users)
+      (raise CloudDB::Exception::Syntax, "Must provide at least one user in the array") if (!users.is_a?(Array) || users.size < 1)
+
+      body = Hash.new
+      body[:users] = Array.new
+
+      for user in users
+        new_user = Hash.new
+        new_user[:name]      = user[:name] or raise CloudDB::Exception::MissingArgument, "Must provide a name for each user"
+        new_user[:password]  = user[:password] or raise CloudDB::Exception::MissingArgument, "Must provide a password for each user"
+        new_user[:databases] = user[:databases]
+        (raise CloudDB::Exception::Syntax, "User names must be 16 characters or less") if user[:name].size > 16
+        (raise CloudDB::Exception::Syntax, "Must provide at least one database in each user :databases array") if (!user[:databases].is_a?(Array) || user[:databases].size < 1)
+
+        body[:users] << new_user
+      end
+
+      response = @connection.dbreq("POST", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/users", @dbmgmtport, @dbmgmtscheme, {}, body.to_json)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+    # Creates a brand new user and associates it with the current instance. Returns true if successful.
+    #
+    # Options:
+    #   :name - Name of the user for the database(s). *required*
+    #   :password - User password for database access. *required*
+    #   :databases - An array of databases with at least one database. *required*
+    def create_user(options={})
+      new_users = Array.new
+      new_users << options
+      create_users new_users
+    end
+
+    # Enables the root user for the specified database instance and returns the root password.
+    #
+    # Example:
+    #   i.enable_root
+    #   => true
+    def enable_root()
+      response = @connection.dbreq("POST", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/root", @dbmgmtport, @dbmgmtscheme, {})
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      @root_enabled = true
+      body = JSON.parse(response.body)['user']
+      return body
+    end
+
+    # Returns true if root user is enabled for the specified database instance or false otherwise.
+    #
+    # Example:
+    #   i.root_enabled?
+    #   => true
+    def root_enabled?()
+      response = @connection.dbreq("GET", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/root", @dbmgmtport, @dbmgmtscheme, {})
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      @root_enabled = JSON.parse(response.body)['rootEnabled']
+      return @root_enabled
+    end
+
+    # This operation changes the memory size of the instance, assuming a valid flavorRef is provided. Restarts MySQL in
+    # the process.
+    #
+    # Options:
+    #   :flavor_ref - reference to a flavor as specified in the response from the List Flavors API call. *required*
+    def resize(options={})
+      body = Hash.new
+      body[:resize] = Hash.new
+
+      body[:resize][:flavorRef]  = options[:flavor_ref] or raise CloudDB::Exception::MissingArgument, "Must provide a flavor to create an instance"
+
+      response = @connection.dbreq("POST", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/action", @dbmgmtport, @dbmgmtscheme, {}, body.to_json)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+    # This operation supports resizing the attached volume for an instance. It supports only increasing the volume size
+    # and does not support decreasing the size. The volume size is in gigabytes (GB) and must be an integer.
+    #
+    # Options:
+    #   :size - specifies the volume size in gigabytes (GB). The value specified must be between 1 and 10. *required*
+    def resize_volume(options={})
+      body = Hash.new
+      body[:resize] = Hash.new
+      volume = Hash.new
+      body[:resize][:volume] = volume
+
+      volume[:size] = options[:size] or raise CloudDB::Exception::MissingArgument, "Must provide a volume size"
+      (raise CloudDB::Exception::Syntax, "Volume size must be a value between 1 and 10") if !options[:size].is_a?(Integer) || options[:size] < 1 || options[:size] > 10
+
+      response = @connection.dbreq("POST", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/action", @dbmgmtport, @dbmgmtscheme, {}, body.to_json)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+    # The restart operation will restart only the MySQL Instance. Restarting MySQL will erase any dynamic configuration
+    # settings that you have made within MySQL.
+    def restart()
+      body = Hash.new
+      body[:restart] = Hash.new
+
+      response = @connection.dbreq("POST", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}/action", @dbmgmtport, @dbmgmtscheme, {}, body.to_json)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+    # Deletes the current instance object.  Returns true if successful, raises an exception otherwise.
+    def destroy!
+      response = @connection.dbreq("DELETE", @dbmgmthost, "#{@dbmgmtpath}/instances/#{CloudDB.escape(@id.to_s)}", @dbmgmtport, @dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^202$/)
+      true
+    end
+
+  end
+end

data/lib/clouddb/user.rb

@@ -0,0 +1,27 @@
+module CloudDB
+  class User
+
+    attr_reader :name
+
+    # Creates a new CloudDB::User object representing a database.
+    def initialize(instance, name)
+      @connection     = instance.connection
+      @instance       = instance
+      @name           = name
+      @dbmgmthost     = @connection.dbmgmthost
+      @dbmgmtpath     = @connection.dbmgmtpath
+      @dbmgmtport     = @connection.dbmgmtport
+      @dbmgmtscheme   = @connection.dbmgmtscheme
+      self
+    end
+
+    # Deletes the current User object and removes it from the instance. Returns true if successful, raises an
+    # exception if not.
+    def destroy!
+      response = @connection.dbreq("DELETE",@dbmgmthost,"#{@dbmgmtpath}/instances/#{CloudDB.escape(@instance.id.to_s)}/users/#{CloudDB.escape(@name.to_s)}",@dbmgmtport,@dbmgmtscheme)
+      CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+  end
+end

data/lib/clouddb/version.rb

@@ -0,0 +1,3 @@
+module CloudDB
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: clouddb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ! '"Jorge'
+- Miramontes",
+- ! '"H.'
+- Wade
+- Minter"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby API to manage the Rackspace Cloud Databases product
+email:
+- jorge.miramontes@rackspace.com
+- minter@lunenburg.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- COPYING
+- .gitignore
+- README.rdoc
+- clouddb.gemspec
+- lib/clouddb.rb
+- lib/clouddb/authentication.rb
+- lib/clouddb/flavor.rb
+- lib/clouddb/instance.rb
+- lib/clouddb/database.rb
+- lib/clouddb/user.rb
+- lib/clouddb/connection.rb
+- lib/clouddb/exception.rb
+- lib/clouddb/version.rb
+homepage: http://github.com/rackspace/ruby-clouddb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: Ruby API into the Rackspace Cloud Databases product
+test_files: []