rackspace_cloud 0.4.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Cosmin Radoi
+
+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

@@ -0,0 +1,21 @@
+Example:
+
+>> require 'rackspace_cloud'
+>> cloud = RackspaceCloud::Base.new(:user => "gomer", :access_key => "aabbccddaabbccddaabbccdd")
+=> #<RackspaceCloud::Base:0x1065f44 @access_key="aabbccddaabbccddaabbccdd", @user="gomer">
+>> cloud.connect
+=> nil
+>> cloud.servers
+=> []
+>> new_server = cloud.create_server('development', 1, 8) # create a 256MB Ubuntu 9.04 instance)
+=> #<RackspaceCloud::Server:0x1054a78 @image=#<RackspaceCloud::Image:0x10598e8 @name="Ubuntu 9.04 (jaunty)", @updated="2009-07-20T09:14:37-05:00", @created="2009-07-20T09:14:37-05:00", @status="ACTIVE", @rackspace_id=8>, @public_ips=["174.xxx.xxx.xxx"], @flavor=#<RackspaceCloud::Flavor:0x105d40c @name="256 slice", @ram=256, @disk=10, @rackspace_id=1>, @name="development", @progress=80, @adminPass="developmentU5fG3", @host_id="a7765fde333eead221", @private_ips=["10.xxx.xxx.xxx"], @rackspace_id=1, @status="BUILD">
+
+... wait a while ...
+
+>> new_server.refresh.status
+=> "ACTIVE"
+>> new_server.hard_reboot
+=> nil
+>> new_server.refresh.status
+=> "HARD_REBOOT"
+

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+ 
+task :default => :test
+ 
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "rackspace_cloud"
+    gemspec.summary = "Gem enabling the management of Rackspace Cloud Server instances"
+    gemspec.description = "Gem enabling the management of Rackspace Cloud Server instances."
+    gemspec.email = "grant@moreblinktag.com"
+    gemspec.homepage = "http://github.com/ggoodale/rackspace_cloud"
+    gemspec.authors = ["Grant Goodale"]
+    gemspec.files.exclude("**/.gitignore")
+    gemspec.add_dependency('patron', '>= 0.4.0')
+    gemspec.add_development_dependency('shoulda', '>= 2.10')
+    gemspec.add_development_dependency('mocha', '>= 0.9.4')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+ 
+ 

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/lib/rackspace_cloud.rb

@@ -0,0 +1,44 @@
+require "patron"
+require "json"
+require "uri"
+require "digest/sha1"
+require "base64"
+
+# Bring in all of our submodules
+Dir[File.join(File.dirname(__FILE__), 'rackspace_cloud/**/*.rb')].sort.each { |lib| require lib }
+
+module RackspaceCloud
+  
+  class APIVersionError    < StandardError; end
+  class ConfigurationError < StandardError; end
+  class AuthorizationError < StandardError; end
+  
+  API_VERSION = "1.0"
+  BASE_AUTH_URI = "https://auth.api.rackspacecloud.com"
+        
+  def RackspaceCloud.auth_url
+    @@auth_uri ||= URI.parse("#{BASE_AUTH_URI}/v#{API_VERSION}")
+  end
+   
+  protected
+
+  def RackspaceCloud.check_version_compatibility
+    #This should eventually check the versions and raise an APIVersionError if there's a mismatch.
+  end
+
+  def RackspaceCloud.request_authorization(user, access_key)
+    session = Patron::Session.new
+    session.base_url = BASE_AUTH_URI
+    session.headers["X-Auth-User"] = user
+    session.headers["X-Auth-Key"] = access_key
+    session.headers["User-Agent"] = "rackspacecloud_ruby_gem"
+    response = session.get("/v#{API_VERSION}")
+    
+    case response.status
+    when 204 # "No Content", which means success
+      response.headers
+    else 
+      raise AuthorizationError, "Error during authorization: #{response.status}"
+    end
+  end
+end

data/lib/rackspace_cloud/base.rb

@@ -0,0 +1,136 @@
+module RackspaceCloud
+  class Base
+    attr_reader :user, :access_key, :auth_token
+
+    def initialize(config={})
+      validate_config(config)
+      @user = config[:user]
+      @access_key = config[:access_key]
+      @authorized = false
+    end
+
+    def connect
+      configure_service_urls(RackspaceCloud.request_authorization(@user, @access_key))
+      RackspaceCloud.check_version_compatibility
+      @authorized = true
+      populate_flavors
+      populate_images
+      get_limits
+    end
+    
+    def authorized?
+      @authorized
+    end
+
+    # storage for the lists of flavors and images we request at auth time
+    attr_reader :flavors
+    def populate_flavors
+      @flavors ||= {}
+      request("/flavors/detail")['flavors'].each do |flavor|
+        @flavors[flavor['id']] = RackspaceCloud::Flavor.new(flavor)
+      end
+      nil
+    end
+
+    attr_reader :images
+    def populate_images
+      @images ||= {}
+      request("/images/detail")['images'].each do |image|
+        @images[image['id']] = RackspaceCloud::Image.new(self, image)
+      end
+      nil
+    end
+
+    attr_reader :limits
+    def get_limits
+      @limits ||= {}
+      @limits.merge!(request("/limits")['limits'])
+      nil
+    end
+    
+    def servers
+      request("/servers/detail")["servers"].collect {|server_json|
+        RackspaceCloud::Server.new(self, server_json)
+      }
+    end
+    
+    def create_server(name, flavor, image, metadata={}, personality=[])
+      new_server_data = {'server' => {
+        'name' => name,
+        'flavorId' => flavor.to_i,
+        'imageId'  => image.to_i,
+        'metadata' => metadata,
+        'personality' => personality
+      }}
+      
+      RackspaceCloud::Server.new(self, request("/servers", :method => :post, :data => new_server_data)['server'])
+    end
+    
+    def shared_ip_groups
+      request("/shared_ip_groups/detail")['sharedIpGroups'].collect {|group_json|
+        RackspaceCloud::SharedIPGroup.new(self, group_json)
+      }
+    end
+    
+    # Yes, you can only specify at most a single server to initially populate a shared IP group.  Odd, that.
+    def create_shared_ip_group(name, server=nil)
+      new_group_data = {'sharedIpGroup' => {'name' => name, 'server' => server}}
+      new_group_data['sharedIpGroup']['server'] = server.to_i unless server.nil?
+      RackspaceCloud::SharedIPGroup.new(self, request("/shared_ip_groups", :method => :post, :data => new_group_data))
+    end
+
+    def request(path, options={})
+      raise RuntimeError, "Please authorize before using by calling connect()" unless authorized?
+      @session ||= begin
+        s = Patron::Session.new
+        s.base_url = @server_management_url
+        s.headers['X-Auth-Token'] = @auth_token
+        s.headers["User-Agent"] = "rackspacecloud_ruby_gem"
+        s.timeout = 10
+        s
+      end
+      response = case options[:method]
+      when :post
+        @session.headers['Accept'] = "application/json"
+        @session.headers['Content-Type'] = "application/json"
+        @session.post("#{path}", options[:data].to_json)
+      when :put
+        @session.headers['Content-Type'] = "application/json"
+        @session.put("#{path}", options[:data].to_json)      
+      when :delete
+        @session.delete("#{path}")
+      else      
+        @session.get("#{path}.json")
+      end
+
+      case response.status
+      when 200, 201, 202, 204
+        JSON.parse(response.body) unless response.body.empty?
+      else
+        puts response.body
+        raise RuntimeError, "Error fetching #{path}: #{response.status}"
+      end
+    end
+
+    def api_version
+      RackspaceCloud::API_VERSION
+    end
+
+    protected
+
+    def validate_config(config)
+      errors = []
+      (config[:user] && config[:user].length) || errors << "missing username"
+      (config[:access_key] && config[:access_key].length) || errors << "missing access_key"
+      raise(ArgumentError, "Error: invalid configuration: #{errors.join(';')}") unless errors.empty?
+    end
+    
+    def configure_service_urls(url_hash = {})
+      @server_management_url = url_hash['X-Server-Management-Url']
+      @storage_url = url_hash['X-Storage-Url']
+      @storage_token = url_hash['X-Storage-Token']
+      @cdn_management_url = url_hash['X-CDN-Management-Url'] 
+      @auth_token = url_hash['X-Auth-Token']
+    end
+  end
+end

data/lib/rackspace_cloud/flavor.rb

@@ -0,0 +1,17 @@
+module RackspaceCloud
+  class Flavor
+    attr_reader :name, :disk, :ram, :rackspace_id
+
+    def initialize(flavor_json)
+      @rackspace_id = flavor_json['id']
+      @name         = flavor_json['name']
+      @disk         = flavor_json['disk']
+      @ram          = flavor_json['ram']
+    end
+    
+    def to_i
+      @rackspace_id
+    end
+  end
+end
+

data/lib/rackspace_cloud/image.rb

@@ -0,0 +1,52 @@
+module RackspaceCloud
+  class Image
+
+    MAX_RACKSPACE_IMAGE_ID = 10 # the highest id in use by a standard rackspace image (vs. a user backup)
+
+    attr_reader :name, :created, :updated, :status, :progress, :rackspace_id, :base
+    
+    class << self
+      def create_from_server(server, name=nil)
+        name ||= generate_timestamped_name(server)
+        image_json = server.base.request("/images", :method => :post, :data => {'image' => {'name' => name, 'serverId' => @rackspace_id}})['image']
+        new_image = RackspaceCloud::Image.new(image_json)
+        @images[new_image.rackspace_id] = new_image
+        new_image
+      end
+    end
+    
+    def initialize(base, image_json)
+      @base = base
+      populate(image_json)
+    end
+
+    def delete
+      raise RuntimeError, "Can't delete Rackspace standard images" if @rackspace_id <= MAX_RACKSPACE_IMAGE_ID
+      @base.request("/images/#{@rackspace_id}", :method => :delete)
+    end
+    
+    def to_i
+      @rackspace_id
+    end
+    
+    def refresh
+      populate(@base.request("/images/#{@rackspace_id}")['image'])
+      self
+    end
+
+    protected
+
+    def populate(image_json)
+      @rackspace_id = image_json['id']
+      @name         = image_json['name']
+      @created      = DateTime.parse(image_json['created'])
+      @updated      = DateTime.parse(image_json['updated'])
+      @status       = image_json['status']
+      @progress     = image_json['progress']
+    end
+    
+    def generate_timestamped_name(server)
+      "#{server.downcase.gsub!(/\W/, "-")}-#{Time.nowTime.now.strftime('%Y%m%d%H%M%S%z')}"
+    end
+  end
+end

data/lib/rackspace_cloud/server.rb

@@ -0,0 +1,88 @@
+module RackspaceCloud
+  class Server
+    attr_reader :name, :status, :flavor, :image, :base
+    attr_reader :rackspace_id, :host_id, :progress
+    attr_reader :public_ips, :private_ips, :adminPass
+
+    STATUS_VALUES = %w{ACTIVE BUILD REBUILD SUSPENDED QUEUE_RESIZE PREP_RESIZE VERIFY_RESIZE PASSWORD RESCUE REBOOT HARD_REBOOT SHARE_IP SHARE_IP_NO_CONFIG DELETE_IP UNKNOWN}
+
+    def initialize(base, server_json)
+      @base = base
+      populate(server_json)
+    end
+    
+    def ready?
+      self.refresh.status == 'ACTIVE'
+    end
+    
+    def reboot
+      action_request('reboot' => {'type' => 'SOFT'})
+    end
+    
+    def hard_reboot
+      action_request('reboot' => {'type' => 'HARD'})      
+    end
+    
+    def rebuild(new_image=nil)
+      action_request('rebuild' => {'imageId' => new_image ? new_image.to_i : image.to_i})      
+    end
+
+    def resize(new_flavor)
+      action_request('resize' => {'flavorId' => new_flavor.to_i})
+    end
+
+    def confirm_resize
+      action_request('confirmResize' => nil)
+    end
+    
+    def revert_resize
+      action_request('revertResize' => nil)
+    end
+
+    def share_ip_address(ip_address, shared_ip_address_group, configure_server = true)
+      @base.request("/servers/#{@rackspace_id}/ips/public/#{ip_address}", 
+      :method => :put, :data => {'shareIp' => {'sharedIpGroupId' => shared_ip_address_group.to_i, 'configureServer' => configure_server}})
+    end
+
+    def unshare_ip_address(ip_address)
+      @base.request("/servers/#{@rackspace_id}/ips/public/#{ip_address}", :method => :delete)
+    end
+
+    def delete
+      @base.request("/servers/#{@rackspace_id}", :method => :delete)
+    end
+
+    def update_server_name(new_name)
+      @base.request("/servers/#{@rackspace_id}", :method => :put, :data => {"server" => {"name" => new_name}})
+    end
+
+    def update_admin_password(new_password)
+      @base.request("/servers/#{@rackspace_id}", :method => :put, :data => {"server" => {"adminPass" => new_password}})
+    end
+
+    # update this server's status and progress by calling /servers/<id>
+    def refresh
+      populate(@base.request("/servers/#{@rackspace_id}")['server'])
+      self
+    end
+    
+    protected
+    
+    def action_request(data)
+      @base.request("/servers/#{@rackspace_id}/action", :method => :post, :data => data)      
+    end
+    
+    def populate(server_json)
+      @name = server_json['name']
+      @status = server_json['status']
+      @flavor = @base.flavors[server_json['flavorId']]
+      @image = @base.images[server_json['imageId']]
+      @rackspace_id = server_json['id']
+      @host_id = server_json['hostId']
+      @progress = server_json['progress']
+      @public_ips = server_json['addresses']['public']
+      @private_ips = server_json['addresses']['private']
+      @adminPass = server_json['adminPass']
+    end
+  end
+end

data/lib/rackspace_cloud/shared_ip_group.rb

@@ -0,0 +1,33 @@
+module RackspaceCloud
+  class SharedIPGroup
+    attr_reader :rackspace_id, :name, :servers
+
+    def initialize(base, group_json)
+      @base = base
+      populate(group_json)
+    end
+
+    def delete
+      @base.request("/shared_ip_groups/#{@rackspace_id}", :method => :delete)
+    end
+
+    def refresh
+      populate(@base.request("/shared_ip_groups/detail")['sharedIpGroup'])
+    end
+
+    def to_i
+      @rackspace_id
+    end
+
+    protected
+
+    def populate(group_json)
+      puts group_json.inspect
+      @rackspace_id = group_json['id']
+      @name = group_json['name']
+      unless group_json['servers'].nil?
+        @servers = @base.servers.select{|server| group_json['servers'].include? server.rackspace_id}
+      end
+    end
+  end
+end

data/rackspace_cloud.gemspec

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rackspace_cloud}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Grant Goodale"]
+  s.date = %q{2009-08-03}
+  s.description = %q{Gem enabling the management of Rackspace Cloud Server instances.}
+  s.email = %q{grant@moreblinktag.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "install.rb",
+     "lib/rackspace_cloud.rb",
+     "lib/rackspace_cloud/base.rb",
+     "lib/rackspace_cloud/flavor.rb",
+     "lib/rackspace_cloud/image.rb",
+     "lib/rackspace_cloud/server.rb",
+     "lib/rackspace_cloud/shared_ip_group.rb",
+     "rackspace_cloud.gemspec",
+     "test/authentication_test.rb",
+     "test/configuration_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ggoodale/rackspace_cloud}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Gem enabling the management of Rackspace Cloud Server instances}
+  s.test_files = [
+    "test/authentication_test.rb",
+     "test/configuration_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<patron>, [">= 0.4.0"])
+    else
+      s.add_dependency(%q<patron>, [">= 0.4.0"])
+    end
+  else
+    s.add_dependency(%q<patron>, [">= 0.4.0"])
+  end
+end

data/test/authentication_test.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class AuthenticationTest < Test::Unit::TestCase
+  context "A valid configuration" do 
+    should "be able to authenticate successfully" do
+      true
+    end
+  end
+  
+end

data/test/configuration_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class ConfigurationTest < Test::Unit::TestCase
+  context "A RackspaceCloud configuration" do
+    setup do
+      @config = {:user => "foo", :access_key => "aabbccdd"}
+    end
+
+    should "contain a username" do
+      @config[:user] = nil
+      assert_raise(ArgumentError) {
+        RackspaceCloud::Base.new(@config)
+      }
+    end
+
+    should "contain an authorization token" do
+      @config[:access_key] = nil
+      assert_raise(ArgumentError) {
+        RackspaceCloud::Base.new(@config)
+      }      
+    end
+    
+    should "should be valid if all required parameters are specified" do
+      assert_nothing_raised  { RackspaceCloud::Base.new(@config) }
+    end
+  end    
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'test/unit'
+gem 'thoughtbot-shoulda'
+
+begin 
+  require 'shoulda'
+rescue LoadError
+  abort "Unable to find thoughtbot-shoulda gem - please check that Shoulda is installed"
+end
+ 
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rackspace_cloud')

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: rackspace_cloud
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Grant Goodale
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: patron
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+description: Gem enabling the management of Rackspace Cloud Server instances.
+email: grant@moreblinktag.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- init.rb
+- install.rb
+- lib/rackspace_cloud.rb
+- lib/rackspace_cloud/base.rb
+- lib/rackspace_cloud/flavor.rb
+- lib/rackspace_cloud/image.rb
+- lib/rackspace_cloud/server.rb
+- lib/rackspace_cloud/shared_ip_group.rb
+- rackspace_cloud.gemspec
+- test/authentication_test.rb
+- test/configuration_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/ggoodale/rackspace_cloud
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 3
+summary: Gem enabling the management of Rackspace Cloud Server instances
+test_files: 
+- test/authentication_test.rb
+- test/configuration_test.rb
+- test/test_helper.rb