rackspace-cloud 0.5

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.5 2009-10-11
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,22 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/rackspace.rb
+lib/rackspace-cloud.rb
+lib/rackspace/connection.rb
+lib/rackspace/exceptions.rb
+lib/rackspace/cloud_servers/base.rb
+lib/rackspace/cloud_servers/server.rb
+lib/rackspace/cloud_servers/flavor.rb
+lib/rackspace/cloud_servers/image.rb
+script/console
+script/destroy
+script/generate
+test/test_base.rb
+test/test_connection.rb
+test/test_flavor.rb
+test/test_helper.rb
+test/test_image.rb
+test/test_server.rb

data/PostInstall.txt

@@ -0,0 +1,4 @@
+
+For more information on rackspace-cloud, see http://github.com/edraper/rackspace-cloud
+
+

data/README.rdoc

@@ -0,0 +1,72 @@
+= rackspace-cloud
+
+* http://github.com/edraper/rackspace-cloud
+
+== DESCRIPTION:
+
+rackspace-cloud is a Ruby gem that provides easy, simple access to the Rackspace Cloud APIs, and specifically the Cloud Servers API.
+
+== FEATURES/PROBLEMS:
+
+Currently just has support for Cloud Servers, and not Cloud Files.
+
+Server addresses, IP groups, backup schedules, and reboots/rebuilds/resizes not yet implemented for Cloud Servers.
+
+== SYNOPSIS:
+
+To initialize:
+
+Rackspace::Connection.init "user", "key"
+
+Optionally, you can specify a version of the API to use too (defaults to "v1.0"):
+
+Rackspace::Connection.init "user", "key", "v1.1"
+
+To authenticate:
+
+Rackspace::Connection.authenticate
+
+For Cloud Servers:
+
+Rackspace::CloudServers::Server.all
+
+Rackspace::CloudServers::Server.create(:name => "api-test", :imageId => 8, :flavorId => 1)
+
+Rackspace::CloudServers::Image.all
+
+Rackspace::CloudServers::Flavor.all
+
+== REQUIREMENTS:
+
+rest-client (1.0.3+)
+
+activesupport (2.3.4+)
+
+== INSTALL:
+
+gem install rackspace-cloud
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Elliott Draper <el@ejdraper.com>
+
+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/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require File.join(File.dirname(__FILE__), "lib", "rackspace-cloud")
+
+Hoe.plugin :newgem
+
+$hoe = Hoe.spec 'rackspace-cloud' do
+  self.developer 'Elliott Draper', 'el@ejdraper.com'
+  self.post_install_message = 'PostInstall.txt'
+  self.rubyforge_name       = self.name
+  self.extra_deps         = [['rest-client','>= 1.0.3'], ['activesupport','>= 2.3.4']]
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }

data/lib/rackspace-cloud.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "rackspace")

data/lib/rackspace.rb

@@ -0,0 +1,21 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "rubygems"
+gem "activesupport"
+require "active_support"
+gem "rest-client"
+require "rest_client"
+
+module Rackspace
+  VERSION = '0.5'
+  
+  module CloudServers
+  end
+end
+
+require File.join(File.dirname(__FILE__), "rackspace", "exceptions")
+require File.join(File.dirname(__FILE__), "rackspace", "connection")
+require File.join(File.dirname(__FILE__), "rackspace", "cloud_servers", "base")
+require File.join(File.dirname(__FILE__), "rackspace", "cloud_servers", "server")
+require File.join(File.dirname(__FILE__), "rackspace", "cloud_servers", "flavor")
+require File.join(File.dirname(__FILE__), "rackspace", "cloud_servers", "image")

data/lib/rackspace/cloud_servers/base.rb

@@ -0,0 +1,133 @@
+class Rackspace::CloudServers::Base
+  attr_accessor :id
+  
+  # The resource can be established with a hash of parameters
+  def initialize(attribs = {})
+    set_attributes(attribs)
+  end
+  
+  # This sets the relevant accessors using the specified attributes
+  def set_attributes(attribs)
+    attribs.each_pair do |key, value|
+      self.send("#{key}=", value) if self.respond_to?("#{key}=")
+    end
+  end
+
+  # This returns true if the record hasn't yet been persisted, false otherwise
+  def new_record?
+    self.id.nil?
+  end
+  
+  # This creates the record if it is new, otherwise it attempts to update the record
+  def save
+    self.new_record? ? create : update
+  end
+  
+  # This creates the new record using the API
+  def create
+    set_attributes(JSON.parse(Rackspace::Connection.post(self.class.resource_url, {self.class.resource.singularize => JSON.parse(self.to_json)}))[self.class.resource.singularize])
+    true
+  end
+  
+  # This updates the existing record using the API
+  def update
+    attribs = JSON.parse(self.to_json)
+    unless self.attributes_for_update.nil?
+      attribs.keys.each do |key|
+        attribs.delete(key) unless self.attributes_for_update.include?(key.to_sym)
+      end
+    end
+    Rackspace::Connection.put(self.class.resource_url(self.id), {self.class.resource.singularize => attribs})
+    true
+  end
+  
+  # This deletes the record using the API
+  def destroy
+    Rackspace::Connection.delete(self.class.resource_url(self.id))
+    true
+  end
+  
+  # These are the attributes used for the update operations
+  # Empty array means no properties will be updated, but this can be overridden with
+  # nil (all properties are updated), or an explicit array of properties that can be updated
+  def attributes_for_update
+    []
+  end
+  
+  # This reloads the current object with the latest persisted data
+  def reload
+    return false if self.new_record?
+    result = Rackspace::Connection.get(self.class.resource_url(self.id))
+    return nil if result.to_s.blank?
+    json = JSON.parse(result.to_s)
+    self.set_attributes(json[self.class.resource.singularize])
+    self
+  end
+  
+  class << self
+    # This returns the name of the resource, used for the API URLs
+    def resource
+      self.name.split("::").last.tableize
+    end
+
+    # This returns the resource URL
+    def resource_url(id = nil)
+      root = "#{Rackspace::Connection.server_management_url}/#{self.resource}"
+      id.nil? ? root : "#{root}/#{id}"
+    end
+    
+    # This returns all records for the resource
+    def all
+      self.find
+    end
+    
+    # This returns the first record for the resource
+    def first
+      self.find(:first)
+    end
+    
+    # This returns the last record for the resource
+    def last
+      self.find(:last)
+    end
+
+    # This finds all records for the resource, or a specific resource by ID
+    def find(action = :all)
+      result = case action
+      when :all
+        Rackspace::Connection.get "#{self.resource_url}/detail"
+      when :first
+        Rackspace::Connection.get "#{self.resource_url}/detail"
+      when :last
+        Rackspace::Connection.get "#{self.resource_url}/detail"
+      else
+        Rackspace::Connection.get self.resource_url(action)
+      end
+      return nil if result.to_s.blank?
+      json = JSON.parse(result.to_s)
+      case action
+      when :all
+        json[self.resource].collect { |h| self.new(h) }
+      when :first
+        json[self.resource].collect { |h| self.new(h) }.first
+      when :last
+        json[self.resource].collect { |h| self.new(h) }.last
+      else
+        self.new(json[self.resource.singularize])
+      end
+    end
+    
+    # This returns the amount of records for this resource
+    def count
+      records = self.all
+      records.nil? ? 0 : records.length
+    end
+    
+    # This creates and saves a resource with the specified attributes in one call
+    def create(attribs = {})
+      o = self.new(attribs)
+      o.save
+      o
+    end
+  end
+end

data/lib/rackspace/cloud_servers/flavor.rb

@@ -0,0 +1,13 @@
+class Rackspace::CloudServers::Flavor < Rackspace::CloudServers::Base
+  attr_accessor :name, :ram, :disk
+  
+  # Saving (create/update) isn't allowed for flavors
+  def save
+    false
+  end
+  
+  # Deletion isn't allowed for flavors
+  def destroy
+    false
+  end
+end

data/lib/rackspace/cloud_servers/image.rb

@@ -0,0 +1,8 @@
+class Rackspace::CloudServers::Image < Rackspace::CloudServers::Base
+  attr_accessor :name, :serverId, :updated, :created, :status, :progress
+  
+  # Updating isn't allowed for images
+  def update
+    false
+  end
+end

data/lib/rackspace/cloud_servers/server.rb

@@ -0,0 +1,8 @@
+class Rackspace::CloudServers::Server < Rackspace::CloudServers::Base
+  attr_accessor :name, :imageId, :flavorId, :hostId, :status, :progress, :addresses, :metadata, :personality, :adminPass
+  
+  # Overriding the update attributes so that just name and adminPass are persisted on an update
+  def attributes_for_update
+    [:name, :adminPass]
+  end
+end

data/lib/rackspace/connection.rb

@@ -0,0 +1,115 @@
+class Rackspace::Connection
+  AUTH_URL = "https://auth.api.rackspacecloud.com"
+  VERSION_URL = "https://servers.api.rackspacecloud.com"
+  
+  class << self
+    # This initializes the Rackspace environment with the data necessary to make API calls
+    def init(user, key, version = "v1.0")
+      @user = user
+      @key = key
+      @version = version
+      raise Rackspace::InvalidVersion unless self.versions.include?(version)
+      @initialized = true
+    end
+    
+    # This returns the API user being used for calls
+    def api_user
+      @user
+    end
+    
+    # This returns the API key being used for calls
+    def api_key
+      @key
+    end
+    
+    # This returns the API version being used for calls
+    def api_version
+      @version
+    end
+    
+    # This returns whether or not we've been initialized yet
+    def initialized?
+      @initialized || false
+    end
+    
+    # This authenticates with Rackspace and returns the information necessary to make subsequent authenticated calls to the API
+    def authenticate
+      raise Rackspace::NotInitialized unless self.initialized?
+      headers = RestClient::Request.execute(:method => :get, :url => "#{AUTH_URL}/#{self.api_version}", :headers => {"X-Auth-User" => self.api_user, "X-Auth-Key" => self.api_key}, :raw_response => true).headers
+      {:auth_token => headers[:x_auth_token], :storage_url => headers[:x_storage_url], :server_management_url => headers[:x_server_management_url], :cdn_management_url => headers[:x_cdn_management_url]}
+    end
+
+    # These are default headers we need to use on all requests
+    def default_headers
+      {:accept => "application/json", :content_type => "application/json"}
+    end
+    
+    # This returns the available versions of the API
+    def versions
+      JSON.parse(RestClient.get("#{VERSION_URL}/.json", self.default_headers))["versions"].collect { |v| v["id"] }.uniq
+    end
+    
+    # This caches the authentication response for subsequent usage
+    def auth_response
+      @auth_response ||= self.authenticate
+    end
+    
+    # This is the auth token provided by Rackspace after a successful authentication
+    def auth_token
+      self.auth_response[:auth_token]
+    end
+    
+    # This returns the root URL for Cloud Files API queries (not yet implemented)
+    def storage_url
+      self.auth_response[:storage_url]
+    end
+    
+    # This returns the root URL for Cloud Servers API queries
+    def server_management_url
+      self.auth_response[:server_management_url]
+    end
+    
+    # This returns the root URL for CDN Cloud Files API queries (not yet implemented)
+    def cdn_management_url
+      self.auth_response[:cdn_management_url]
+    end
+    
+    # This performs a basic GET request using the supplied URL and headers
+    def get(url, headers = {})
+      http :get, "#{url}.json", headers
+    end
+    
+    # This performs a basic POST request using the supplied URL, payload and headers
+    def post(url, payload = {}, headers = {})
+      http :post, "#{url}.json", payload.to_json, headers
+    end
+    
+    # This performs a basic PUT request using the supplied URL, payload and headers
+    def put(url, payload = {}, headers = {})
+      http :put, "#{url}.json", payload.to_json, headers
+    end
+    
+    # This performs a basic DELETE request using the supplied URL and headers
+    def delete(url, headers = {})
+      http :delete, "#{url}.json", headers
+    end
+    
+    # This will perform an HTTP call with the specified method, and arguments
+    # It will also pick up if the response is that the request was unauthorized, and will attempt
+    # the same request again after re-authenticating (in case the auth token has expired)
+    def http(method, *args)
+      args.last.merge!(self.default_headers).merge!("X-Auth-Token" => self.auth_token)
+      response = RestClient.send(method, *args)
+      @retried = false
+      response
+    rescue RestClient::Unauthorized
+      @auth_response = nil
+      if @retried
+        raise
+      else
+        @retried = true
+        retry
+      end
+    end
+  end
+end

data/lib/rackspace/exceptions.rb

@@ -0,0 +1,7 @@
+module Rackspace
+  class InvalidVersion < Exception
+  end
+
+  class NotInitialized < Exception
+  end
+end