ggoodale-rackspace_cloud 0.3.0 → 0.4.0

data/README

@@ -7,7 +7,7 @@ Example:
 => nil
 >> cloud.servers
 => []
->> new_server = cloud.create_server('development', 1, 8) # create a 256MB Ubunty 9.04 instance)
+>> 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 ...

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/rackspace_cloud.rb

@@ -26,29 +26,6 @@ module RackspaceCloud
     #This should eventually check the versions and raise an APIVersionError if there's a mismatch.
   end
 
-  # storage for the lists of flavors and images we request at auth time
-  FLAVORS = {}
-  def RackspaceCloud.populate_flavors
-    request("/flavors/detail")['flavors'].each do |flavor|
-      FLAVORS[flavor['id']] = RackspaceCloud::Flavor.new(flavor)
-    end
-    nil
-  end
-  
-  IMAGES = {}
-  def RackspaceCloud.populate_images
-    request("/images/detail")['images'].each do |image|
-      IMAGES[image['id']] = RackspaceCloud::Image.new(image)
-    end
-    nil
-  end
-  
-  LIMITS = {}
-  def RackspaceCloud.get_limits
-    LIMITS.merge!(request("/limits")['limits'])
-    nil
-  end
-
   def RackspaceCloud.request_authorization(user, access_key)
     session = Patron::Session.new
     session.base_url = BASE_AUTH_URI
@@ -59,48 +36,9 @@ module RackspaceCloud
     
     case response.status
     when 204 # "No Content", which means success
-      @server_management_url = response.headers['X-Server-Management-Url']
-      @storage_url = response.headers['X-Storage-Url']
-      @storage_token = response.headers['X-Storage-Token']
-      @cdn_management_url = response.headers['X-CDN-Management-Url'] 
-      @auth_token = response.headers['X-Auth-Token']
-      @@authorized = true
+      response.headers
     else 
       raise AuthorizationError, "Error during authorization: #{response.status}"
     end
-    nil
-  end
-
-  def RackspaceCloud.request(path, options={})
-    raise RuntimeError, "Please authorize before using by calling connect()" unless defined?(@@authorized) && @@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, 202, 204
-      JSON.parse(response.body) unless response.body.empty?
-    else
-      puts response.body
-      raise RuntimeError, "Error fetching #{path}: #{response.status}"
-    end
   end
 end

data/lib/rackspace_cloud/base.rb

@@ -6,22 +6,54 @@ module RackspaceCloud
       validate_config(config)
       @user = config[:user]
       @access_key = config[:access_key]
+      @authorized = false
     end
 
     def connect
-      RackspaceCloud.request_authorization(@user, @access_key)
+      configure_service_urls(RackspaceCloud.request_authorization(@user, @access_key))
       RackspaceCloud.check_version_compatibility
-      RackspaceCloud.populate_flavors
-      RackspaceCloud.populate_images
-      RackspaceCloud.get_limits
+      @authorized = true
+      populate_flavors
+      populate_images
+      get_limits
+    end
+    
+    def authorized?
+      @authorized
     end
 
-    def servers(force_refresh=false)
-      RackspaceCloud.request("/servers/detail")["servers"].collect {|server_json|
-        RackspaceCloud::Server.new(server_json)
-      }
+    # 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,
@@ -31,7 +63,53 @@ module RackspaceCloud
         'personality' => personality
       }}
       
-      RackspaceCloud::Server.new(RackspaceCloud.request("/servers", :method => :post, :data => new_server_data)['server'])
+      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
@@ -46,5 +124,13 @@ module RackspaceCloud
       (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

@@ -2,12 +2,6 @@ module RackspaceCloud
   class Flavor
     attr_reader :name, :disk, :ram, :rackspace_id
 
-    class << self
-      def lookup_by_id(id)
-        RackspaceCloud::FLAVORS[id]
-      end
-    end
-    
     def initialize(flavor_json)
       @rackspace_id = flavor_json['id']
       @name         = flavor_json['name']

data/lib/rackspace_cloud/image.rb

@@ -3,21 +3,26 @@ module RackspaceCloud
 
     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
+    attr_reader :name, :created, :updated, :status, :progress, :rackspace_id, :base
     
     class << self
-      def lookup_by_id(id)
-        RackspaceCloud::IMAGES[id]
+      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(image_json)
+    def initialize(base, image_json)
+      @base = base
       populate(image_json)
     end
 
     def delete
-      raise RuntimeError, "Can't delete Rackspace standar images" if @rackspace_id <= MAX_RACKSPACE_IMAGE_ID
-      RackspaceCloud.request("/images/#{@rackspace_id}", :method => :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
@@ -25,8 +30,8 @@ module RackspaceCloud
     end
     
     def refresh
-      populate(RackspaceCloud.request("/images/#{@rackspace_id}")['image'])
-      RackspaceCloud::IMAGES[@rackspace_id] = self
+      populate(@base.request("/images/#{@rackspace_id}")['image'])
+      self
     end
 
     protected
@@ -39,5 +44,9 @@ module RackspaceCloud
       @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

@@ -1,17 +1,18 @@
 module RackspaceCloud
   class Server
-    attr_reader :name, :status, :flavor, :image
+    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(server_json)
+    def initialize(base, server_json)
+      @base = base
       populate(server_json)
     end
     
     def ready?
-      @status == 'ACTIVE'
+      self.refresh.status == 'ACTIVE'
     end
     
     def reboot
@@ -38,42 +39,44 @@ module RackspaceCloud
       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
-      RackspaceCloud.request("/servers/#{@rackspace_id}", :method => :delete)
+      @base.request("/servers/#{@rackspace_id}", :method => :delete)
     end
 
     def update_server_name(new_name)
-      RackspaceCloud.request("/servers/#{@rackspace_id}", :method => :put, :data => {"server" => {"name" => new_name}})
+      @base.request("/servers/#{@rackspace_id}", :method => :put, :data => {"server" => {"name" => new_name}})
     end
 
     def update_admin_password(new_password)
-      RackspaceCloud.request("/servers/#{@rackspace_id}", :method => :put, :data => {"server" => {"adminPass" => new_password}})
-    end
-
-    def save_as_image(name)
-      image_json = RackspaceCloud.request("/images", :method => :post, :data => {'image' => {'name' => name, 'serverId' => @rackspace_id}})['image']
-      new_image = RackspaceCloud::Image.new(image_json)
-      RackspaceCloud::IMAGES[new_image.rackspace_id] = new_image
-      new_image
+      @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(RackspaceCloud.request("/servers/#{@rackspace_id}")['server'])
+      populate(@base.request("/servers/#{@rackspace_id}")['server'])
       self
     end
     
     protected
     
     def action_request(data)
-      RackspaceCloud.request("/servers/#{@rackspace_id}/action", :method => :post, :data => 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 = RackspaceCloud::Flavor.lookup_by_id(server_json['flavorId'])
-      @image = RackspaceCloud::Image.lookup_by_id(server_json['imageId'])
+      @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']

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

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rackspace_cloud}
-  s.version = "0.3.0"
+  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-07-22}
+  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 = [
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
      "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",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ggoodale-rackspace_cloud
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Grant Goodale
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-22 00:00:00 -07:00
+date: 2009-08-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,12 +42,14 @@ files:
 - 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: false
 homepage: http://github.com/ggoodale/rackspace_cloud
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -68,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Gem enabling the management of Rackspace Cloud Server instances