openstack-compute 0.1.0

data/COPYING

@@ -0,0 +1,7 @@
+Unless otherwise noted, all files are released under the MIT license, exceptions contain licensing information in them.
+
+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.rdoc

@@ -0,0 +1,72 @@
+= Ruby OpenStack
+
+== Description
+
+Ruby Openstack Compute binding.
+
+== Examples
+
+See the class definitions for documentation on specific methods and operations.
+
+  require 'openstack/compute'
+
+  cs = OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :api_url => API_URL)	
+
+  # Get a listing of all current servers
+  >> cs.servers
+  => [{:name=>"RenamedRubyTest", :id=>110917}]
+
+  # Access a specific server
+  >> server = cs.server(110917)
+  >> server.name
+  => "RenamedRubyTest"
+
+  # or...
+  server_manager.find(110917)
+  
+
+  # See what type of server this is
+  >> server.flavor.name
+  => "256 server"
+  >> server.image.name
+  => "Ubuntu 8.04.2 LTS (hardy)"
+
+  # Soft-reboot the server
+  >> server.reboot
+  => true
+
+  # Create a new 512MB CentOS 5.2 server.  The root password is returned in the adminPass method.
+  >> image = cs.get_image(8)
+  => #<OpenStack::Compute::Image:0x1014a8060 ...>, status"ACTIVE"
+  >> image.name
+  => "CentOS 5.2"
+  >> flavor = cs.get_flavor(2)
+  => #<OpenStack::Compute::Flavor:0x101469130 @disk=20, @name="512 server", @id=2, @ram=512>
+  >> flavor.name
+  => "512 server"
+  >> newserver = cs.create_server(:name => "New Server", :imageId => image.id, :flavorId => flavor.id)
+  => #<OpenStack::Compute::Server:0x101433f08 ....
+  >> newserver.status
+  => "BUILD"
+  >> newserver.progress
+  => 0
+  >> newserver.adminPass
+  => "NewServerMbhzUnO"
+  >> newserver.refresh
+  => true
+  >> newserver.progress
+  => 12
+  
+  # Delete the new server
+  >> newserver.delete!
+  => true  
+
+== Authors
+
+By Dan Prince <dan.prince@rackspace.com>.
+
+Based on the Rackspace Cloud Servers Ruby API.
+
+== License
+
+See COPYING for license information.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/openstack/compute.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# 
+# == Ruby OpenStack Compute API
+#
+# See COPYING for license information.
+# ----
+# 
+# === Documentation & Examples
+# To begin reviewing the available methods and examples, view the README.rdoc file, or begin by looking at documentation for the OpenStack::Compute::Connection class.
+#
+# Example:
+# OpenStack::Compute::Connection.new(:username => USERNAME, :api_key => API_KEY, :api_url => API_URL) method.
+module OpenStack
+module Compute
+
+  VERSION = IO.read(File.dirname(__FILE__) + '/../../VERSION')
+  require 'net/http'
+  require 'net/https'
+  require 'uri'
+  require 'rubygems'
+  require 'json'
+  require 'date'
+
+  unless "".respond_to? :each_char
+    require "jcode"
+    $KCODE = 'u'
+  end
+
+  $:.unshift(File.dirname(__FILE__))
+  require 'compute/authentication'
+  require 'compute/connection'
+  require 'compute/server'
+  require 'compute/image'
+  require 'compute/flavor'
+  require 'compute/shared_ip_group'
+  require 'compute/exception'
+  
+  # Constants that set limits on server creation
+  MAX_PERSONALITY_ITEMS = 5
+  MAX_PERSONALITY_FILE_SIZE = 10240
+  MAX_SERVER_PATH_LENGTH = 255
+  MAX_PERSONALITY_METADATA_ITEMS = 5
+  
+  # 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.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
+end

data/lib/openstack/compute/authentication.rb

@@ -0,0 +1,42 @@
+module OpenStack
+module Compute
+  class Authentication
+    
+    # Performs an authentication to the OpenStack 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)
+      path = '/v1.0'
+      hdrhash = { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey }
+      begin
+        server = Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new(connection.api_host, connection.api_port)
+        if connection.api_scheme == "https"
+          server.use_ssl = true
+          server.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        server.start
+      rescue
+        raise OpenStack::Compute::Exception::Connection, "Unable to connect to #{server}"
+      end
+      response = server.get(path,hdrhash)
+      if (response.code == "204")
+        connection.authtoken = response["x-auth-token"]
+        connection.svrmgmthost = URI.parse(response["x-server-management-url"]).host
+        connection.svrmgmtpath = URI.parse(response["x-server-management-url"]).path
+        # Force the path into the v1.0 URL space
+        connection.svrmgmtpath.sub!(/\/.*?\//, '/v1.0/')
+        connection.svrmgmtport = URI.parse(response["x-server-management-url"]).port
+        connection.svrmgmtscheme = URI.parse(response["x-server-management-url"]).scheme
+        connection.authok = true
+      else
+        connection.authtoken = false
+        raise OpenStack::Compute::Exception::Authentication, "Authentication failed with response code #{response.code}"
+      end
+      server.finish
+    end
+  end
+end
+end

data/lib/openstack/compute/connection.rb

@@ -0,0 +1,349 @@
+module OpenStack
+module Compute
+  class Connection
+    
+    attr_reader   :authuser
+    attr_reader   :authkey
+    attr_accessor :authtoken
+    attr_accessor :authok
+    attr_accessor :svrmgmthost
+    attr_accessor :svrmgmtpath
+    attr_accessor :svrmgmtport
+    attr_accessor :svrmgmtscheme
+    attr_reader   :api_host
+    attr_reader   :api_port
+    attr_reader   :api_scheme
+    attr_reader   :proxy_host
+    attr_reader   :proxy_port
+    
+    # Creates a new OpenStack::Compute::Connection object.  Uses OpenStack::Compute::Authentication to perform the login for the connection.
+    #
+    # The constructor takes a hash of options, including:
+    #
+    #   :username - Your Openstack username *required*
+    #   :api_key - Your Openstack API key *required*
+    #   :api_url - The url of the Openstack Compute API server.
+    #   :retry_auth - Whether to retry if your auth token expires (defaults to true)
+    #   :proxy_host - If you need to connect through a proxy, supply the hostname here
+    #   :proxy_port - If you need to connect through a proxy, supply the port here
+    #
+    #   cf = OpenStack::Compute::Connection.new(:username => 'USERNAME', :api_key => 'API_KEY', :api_url => 'API_URL')
+    def initialize(options = {:retry_auth => true}) 
+      @authuser = options[:username] || (raise Exception::MissingArgument, "Must supply a :username")
+      @authkey = options[:api_key] || (raise Exception::MissingArgument, "Must supply an :api_key")
+      @api_url = options[:api_url] || (raise Exception::MissingArgument, "Must supply an :api_url")
+
+      api_uri=nil
+      begin
+        api_uri=URI.parse(@api_url)
+      rescue Exception => e
+        raise Exception::InvalidArgument, "Invalid :api_url parameter: #{e.message}"
+      end
+      raise Exception::InvalidArgument, "Invalid :api_url parameter." if api_uri.nil? or api_uri.host.nil?
+      @api_host = api_uri.host
+      @api_port = api_uri.port
+      @api_scheme = api_uri.scheme
+
+      @retry_auth = options[:retry_auth]
+      @proxy_host = options[:proxy_host]
+      @proxy_port = options[:proxy_port]
+      @authok = false
+      @http = {}
+      OpenStack::Compute::Authentication.new(self)
+    end
+    
+    # Returns true if the authentication was successful and returns false otherwise.
+    #
+    #   cs.authok?
+    #   => true
+    def authok?
+      @authok
+    end
+    
+    # This method actually makes the HTTP REST calls out to the server
+    def csreq(method,server,path,port,scheme,headers = {},data = nil,attempts = 0) # :nodoc:
+      start = Time.now
+      hdrhash = headerprep(headers)
+      start_http(server,path,port,scheme,hdrhash)
+      request = Net::HTTP.const_get(method.to_s.capitalize).new(path,hdrhash)
+      request.body = data
+      response = @http[server].request(request)
+      raise OpenStack::Compute::Exception::ExpiredAuthToken if response.code == "401"
+      response
+    rescue Errno::EPIPE, Timeout::Error, Errno::EINVAL, EOFError
+      # Server closed the connection, retry
+      raise OpenStack::Compute::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 OpenStack::Compute::Exception::ExpiredAuthToken
+      raise OpenStack::Compute::Exception::Connection, "Authentication token expired and you have requested not to retry" if @retry_auth == false
+      CloudFiles::Authentication.new(self)
+      retry
+    end
+    
+    # Returns the OpenStack::Compute::Server object identified by the given id.
+    #
+    #   >> server = cs.get_server(110917)
+    #   => #<OpenStack::Compute::Server:0x101407ae8 ...>
+    #   >> server.name
+    #   => "MyServer"
+    def get_server(id)
+      OpenStack::Compute::Server.new(self,id)
+    end
+    alias :server :get_server
+    
+    # Returns an array of hashes, one for each server that exists under this account.  The hash keys are :name and :id.
+    #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
+    #   >> cs.list_servers
+    #   => [{:name=>"MyServer", :id=>110917}]
+    #
+    #   >> cs.list_servers(:limit => 2, :offset => 3)
+    #   => [{:name=>"demo-standingcloud-lts", :id=>168867}, 
+    #       {:name=>"demo-aicache1", :id=>187853}]
+    def list_servers(options = {})
+      anti_cache_param="cacheid=#{Time.now.to_i}"
+      path = OpenStack::Compute.paginate(options).empty? ? "#{svrmgmtpath}/servers?#{anti_cache_param}" : "#{svrmgmtpath}/servers?#{OpenStack::Compute.paginate(options)}&#{anti_cache_param}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack::Compute.symbolize_keys(JSON.parse(response.body)["servers"])
+    end
+    alias :servers :list_servers
+    
+    # Returns an array of hashes with more details about each server that exists under this account.  Additional information
+    # includes public and private IP addresses, status, hostID, and more.  All hash keys are symbols except for the metadata
+    # hash, which are verbatim strings.
+    #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #   >> cs.list_servers_detail
+    #   => [{:name=>"MyServer", :addresses=>{:public=>["67.23.42.37"], :private=>["10.176.241.237"]}, :metadata=>{"MyData" => "Valid"}, :imageId=>10, :progress=>100, :hostId=>"36143b12e9e48998c2aef79b50e144d2", :flavorId=>1, :id=>110917, :status=>"ACTIVE"}]
+    #
+    #   >> cs.list_servers_detail(:limit => 2, :offset => 3)
+    #   => [{:status=>"ACTIVE", :imageId=>10, :progress=>100, :metadata=>{}, :addresses=>{:public=>["x.x.x.x"], :private=>["x.x.x.x"]}, :name=>"demo-standingcloud-lts", :id=>168867, :flavorId=>1, :hostId=>"xxxxxx"}, 
+    #       {:status=>"ACTIVE", :imageId=>8, :progress=>100, :metadata=>{}, :addresses=>{:public=>["x.x.x.x"], :private=>["x.x.x.x"]}, :name=>"demo-aicache1", :id=>187853, :flavorId=>3, :hostId=>"xxxxxx"}]
+    def list_servers_detail(options = {})
+      path = OpenStack::Compute.paginate(options).empty? ? "#{svrmgmtpath}/servers/detail" : "#{svrmgmtpath}/servers/detail?#{OpenStack::Compute.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack::Compute.symbolize_keys(JSON.parse(response.body)["servers"])
+    end
+    alias :servers_detail :list_servers_detail
+    
+    # Creates a new server instance on OpenStack Compute
+    # 
+    # The argument is a hash of options.  The keys :name, :flavorId, and :imageId are required, :metadata and :personality are optional.
+    #
+    # :flavorId and :imageId are numbers identifying a particular server flavor and image to use when building the server.  The :imageId can either
+    # be a stock image, or one of your own created with the server.create_image method.
+    #
+    # The :metadata argument will take a hash of up to five key/value pairs.  This metadata will be applied to the server at the OpenStack Compute
+    # API level.
+    #
+    # The "Personality" option allows you to include up to five files, of 10Kb or less in size, that will be placed on the created server.
+    # For :personality, pass a hash of the form {'local_path' => 'server_path'}.  The file located at local_path will be base64-encoded
+    # and placed at the location identified by server_path on the new server.
+    #
+    # Returns a OpenStack::Compute::Server object.  The root password is available in the adminPass instance method.
+    #
+    #   >> server = cs.create_server(:name => "New Server", :imageId => 2, :flavorId => 2, :metadata => {'Racker' => 'Fanatical'}, :personality => {'/Users/me/Pictures/wedding.jpg' => '/root/me.jpg'})
+    #   => #<OpenStack::Compute::Server:0x101229eb0 ...>
+    #   >> server.name
+    #   => "NewServer"
+    #   >> server.status
+    #   => "BUILD"
+    #   >> server.adminPass
+    #   => "NewServerSHMGpvI"
+    def create_server(options)
+      raise OpenStack::Compute::Exception::MissingArgument, "Server name, flavor ID, and image ID must be supplied" unless (options[:name] && options[:flavorId] && options[:imageId])
+      options[:personality] = get_personality(options[:personality])
+      raise TooManyMetadataItems, "Metadata is limited to a total of #{MAX_PERSONALITY_METADATA_ITEMS} key/value pairs" if options[:metadata].is_a?(Hash) && options[:metadata].keys.size > MAX_PERSONALITY_METADATA_ITEMS
+      data = JSON.generate(:server => options)
+      response = csreq("POST",svrmgmthost,"#{svrmgmtpath}/servers",svrmgmtport,svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      server_info = JSON.parse(response.body)['server']
+      server = OpenStack::Compute::Server.new(self,server_info['id'])
+      server.adminPass = server_info['adminPass']
+      return server
+    end
+    
+    # Returns an array of hashes listing available server images that you have access too, including stock OpenStack Compute images and 
+    # any that you have created.  The "id" key in the hash can be used where imageId is required.
+    #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
+    #   >> cs.list_images
+    #   => [{:name=>"CentOS 5.2", :id=>2, :updated=>"2009-07-20T09:16:57-05:00", :status=>"ACTIVE", :created=>"2009-07-20T09:16:57-05:00"}, 
+    #       {:name=>"Gentoo 2008.0", :id=>3, :updated=>"2009-07-20T09:16:57-05:00", :status=>"ACTIVE", :created=>"2009-07-20T09:16:57-05:00"},...
+    #
+    #   >> cs.list_images(:limit => 3, :offset => 2) 
+    #   => [{:status=>"ACTIVE", :name=>"Fedora 11 (Leonidas)", :updated=>"2009-12-08T13:50:45-06:00", :id=>13}, 
+    #       {:status=>"ACTIVE", :name=>"CentOS 5.3", :updated=>"2009-08-26T14:59:52-05:00", :id=>7}, 
+    #       {:status=>"ACTIVE", :name=>"CentOS 5.4", :updated=>"2009-12-16T01:02:17-06:00", :id=>187811}]
+    def list_images(options = {})
+      path = OpenStack::Compute.paginate(options).empty? ? "#{svrmgmtpath}/images/detail" : "#{svrmgmtpath}/images/detail?#{OpenStack::Compute.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack::Compute.symbolize_keys(JSON.parse(response.body)['images'])
+    end
+    alias :images :list_images
+    
+    # Returns a OpenStack::Compute::Image object for the image identified by the provided id.
+    #
+    #   >> image = cs.get_image(8)
+    #   => #<OpenStack::Compute::Image:0x101659698 ...>
+    def get_image(id)
+      OpenStack::Compute::Image.new(self,id)
+    end
+    alias :image :get_image
+    
+    # Returns an array of hashes listing all available server flavors.  The :id key in the hash can be used when flavorId is required.
+    #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
+    #   >> cs.list_flavors
+    #   => [{:name=>"256 server", :id=>1, :ram=>256, :disk=>10}, 
+    #       {:name=>"512 server", :id=>2, :ram=>512, :disk=>20},...
+    #
+    #   >> cs.list_flavors(:limit => 3, :offset => 2)
+    #   => [{:ram=>1024, :disk=>40, :name=>"1GB server", :id=>3}, 
+    #       {:ram=>2048, :disk=>80, :name=>"2GB server", :id=>4}, 
+    #       {:ram=>4096, :disk=>160, :name=>"4GB server", :id=>5}]       
+    def list_flavors(options = {})
+      path = OpenStack::Compute.paginate(options).empty? ? "#{svrmgmtpath}/flavors/detail" : "#{svrmgmtpath}/flavors/detail?#{OpenStack::Compute.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack::Compute.symbolize_keys(JSON.parse(response.body)['flavors'])
+    end
+    alias :flavors :list_flavors
+    
+    # Returns a OpenStack::Compute::Flavor object for the flavor identified by the provided ID.
+    #
+    #   >> flavor = cs.flavor(1)
+    #   => #<OpenStack::Compute::Flavor:0x10156dcc0 @name="256 server", @disk=10, @id=1, @ram=256>
+    def get_flavor(id)
+      OpenStack::Compute::Flavor.new(self,id)
+    end
+    alias :flavor :get_flavor
+    
+    # Returns an array of hashes for all Shared IP Groups that are available.  The :id key can be used to find that specific object.
+    #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
+    #   >> cs.list_shared_ip_groups
+    #   => [{:name=>"New Group", :id=>127}]
+    def list_shared_ip_groups(options = {})
+      path = OpenStack::Compute.paginate(options).empty? ? "#{svrmgmtpath}/shared_ip_groups/detail" : "#{svrmgmtpath}/shared_ip_groups/detail?#{OpenStack::Compute.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack::Compute.symbolize_keys(JSON.parse(response.body)['sharedIpGroups'])
+    end
+    alias :shared_ip_groups :list_shared_ip_groups
+    
+    # Returns a OpenStack::Compute::SharedIPGroup object for the IP group identified by the provided ID.
+    #
+    #   >> sig = cs.get_shared_ip_group(127)
+    #   => #<OpenStack::Compute::SharedIPGroup:0x10153ca30  ...>
+    def get_shared_ip_group(id)
+      OpenStack::Compute::SharedIPGroup.new(self,id)
+    end
+    alias :shared_ip_group :get_shared_ip_group
+    
+    # Creates a new Shared IP group.  Takes a hash as an argument.  
+    #
+    # Valid hash keys are :name (required) and :server (optional), which indicates the one server to place into this group by default.
+    #
+    #   >> sig = cs.create_shared_ip_group(:name => "Production Web", :server => 110917) 
+    #   => #<OpenStack::Compute::SharedIPGroup:0x101501d18 ...>
+    #   >> sig.name
+    #   => "Production Web"
+    #   >> sig.servers
+    #   => [110917]
+    def create_shared_ip_group(options)
+      data = JSON.generate(:sharedIpGroup => options)
+      response = csreq("POST",svrmgmthost,"#{svrmgmtpath}/shared_ip_groups",svrmgmtport,svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      ip_group = JSON.parse(response.body)['sharedIpGroup']
+      OpenStack::Compute::SharedIPGroup.new(self,ip_group['id'])
+    end
+    
+    # Returns the current state of the programatic API limits.  Each account has certain limits on the number of resources
+    # allowed in the account, and a rate of API operations.
+    #
+    # The operation returns a hash.  The :absolute hash key reveals the account resource limits, including the maxmimum 
+    # amount of total RAM that can be allocated (combined among all servers), the maximum members of an IP group, and the 
+    # maximum number of IP groups that can be created.
+    #
+    # The :rate hash key returns an array of hashes indicating the limits on the number of operations that can be performed in a 
+    # given amount of time.  An entry in this array looks like:
+    #
+    #   {:regex=>"^/servers", :value=>50, :verb=>"POST", :remaining=>50, :unit=>"DAY", :resetTime=>1272399820, :URI=>"/servers*"}
+    #
+    # This indicates that you can only run 50 POST operations against URLs in the /servers URI space per day, we have not run
+    # any operations today (50 remaining), and gives the Unix time that the limits reset.
+    #
+    # Another example is:
+    # 
+    #   {:regex=>".*", :value=>10, :verb=>"PUT", :remaining=>10, :unit=>"MINUTE", :resetTime=>1272399820, :URI=>"*"}
+    #
+    # This says that you can run 10 PUT operations on all possible URLs per minute, and also gives the number remaining and the
+    # time that the limit resets.
+    #
+    # Use this information as you're building your applications to put in relevant pauses if you approach your API limitations.
+    def limits
+      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/limits",svrmgmtport,svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack::Compute.symbolize_keys(JSON.parse(response.body)['limits'])
+    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["User-Agent"] = "OpenStack::Compute Ruby API #{VERSION}"
+      default_headers["Accept"] = "application/json"
+      default_headers.merge(headers)
+    end
+    
+    # Starts (or restarts) the HTTP connection
+    def start_http(server,path,port,scheme,headers) # :nodoc:
+      if (@http[server].nil?)
+        begin
+          @http[server] = Net::HTTP::Proxy(self.proxy_host, self.proxy_port).new(server,port)
+          if scheme == "https"
+            @http[server].use_ssl = true
+            @http[server].verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          @http[server].start
+        rescue
+          raise ConnectionException, "Unable to connect to #{server}"
+        end
+      end
+    end
+    
+    # Handles parsing the Personality hash to load it up with Base64-encoded data.
+    def get_personality(options)
+      return if options.nil?
+      require 'base64'
+      data = []
+      itemcount = 0
+      options.each do |localpath,svrpath|
+        raise OpenStack::Compute::Exception::TooManyPersonalityItems, "Personality files are limited to a total of #{MAX_PERSONALITY_ITEMS} items" if itemcount >= MAX_PERSONALITY_ITEMS
+        raise OpenStack::Compute::Exception::PersonalityFilePathTooLong, "Server-side path of #{svrpath} exceeds the maximum length of #{MAX_SERVER_PATH_LENGTH} characters" if svrpath.size > MAX_SERVER_PATH_LENGTH
+        raise OpenStack::Compute::Exception::PersonalityFileTooLarge, "Local file #{localpath} exceeds the maximum size of #{MAX_PERSONALITY_FILE_SIZE} bytes" if File.size(localpath) > MAX_PERSONALITY_FILE_SIZE
+        b64 = Base64.encode64(IO.read(localpath))
+        data.push({:path => svrpath, :contents => b64})
+        itemcount += 1
+      end
+      return data
+    end
+        
+  end
+end
+end

data/lib/openstack/compute/entity_manager.rb

@@ -0,0 +1,6 @@
+module OpenStack
+module Compute
+  class EntityManager
+  end
+end
+end

data/lib/openstack/compute/exception.rb

@@ -0,0 +1,87 @@
+module OpenStack
+module Compute
+  class Exception
+
+    class ComputeError < 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 ComputeFault           < ComputeError # :nodoc:
+    end
+    class ServiceUnavailable          < ComputeError # :nodoc:
+    end
+    class Unauthorized                < ComputeError # :nodoc:
+    end
+    class BadRequest                  < ComputeError # :nodoc:
+    end
+    class OverLimit                   < ComputeError # :nodoc:
+    end
+    class BadMediaType                < ComputeError # :nodoc:
+    end
+    class BadMethod                   < ComputeError # :nodoc:
+    end
+    class ItemNotFound                < ComputeError # :nodoc:
+    end
+    class BuildInProgress             < ComputeError # :nodoc:
+    end
+    class ServerCapacityUnavailable   < ComputeError # :nodoc:
+    end
+    class BackupOrResizeInProgress    < ComputeError # :nodoc:
+    end
+    class ResizeNotAllowed            < ComputeError # :nodoc:
+    end
+    class NotImplemented              < ComputeError # :nodoc:
+    end
+    class Other                       < ComputeError # :nodoc:
+    end
+    
+    # Plus some others that we define here
+    
+    class ExpiredAuthToken            < StandardError # :nodoc:
+    end
+    class MissingArgument             < StandardError # :nodoc:
+    end
+    class InvalidArgument             < StandardError # :nodoc:
+    end
+    class TooManyPersonalityItems     < StandardError # :nodoc:
+    end
+    class PersonalityFilePathTooLong  < StandardError # :nodoc:
+    end
+    class PersonalityFileTooLarge     < StandardError # :nodoc:
+    end
+    class Authentication              < StandardError # :nodoc:
+    end
+    class Connection                  < 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 OpenStack::Compute::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
+        raise OpenStack::Compute::Exception::Other.new("The server returned status #{response.code}", response.code, response.body)
+      end
+    end
+    
+  end
+end
+end

data/lib/openstack/compute/flavor.rb

@@ -0,0 +1,33 @@
+module OpenStack
+module Compute
+  class Flavor
+  
+    attr_reader :id
+    attr_reader :name
+    attr_reader :ram
+    attr_reader :disk
+
+    # This class provides an object for the "Flavor" of a server.  The Flavor can generally be taken as the server specification,
+    # providing information on things like memory and disk space.
+    #
+    # The disk attribute is an integer representing the disk space in GB.  The memory attribute is an integer representing the RAM in MB.
+    #
+    # This is called from the get_flavor method on a OpenStack::Compute::Connection object, returns a OpenStack::Compute::Flavor object, and will likely not be called directly.
+    #
+    #   >> flavor = cs.get_flavor(1)
+    #   => #<OpenStack::Compute::Flavor:0x1014f8bc8 @name="256 server", @disk=10, @id=1, @ram=256>
+    #   >> flavor.name
+    #   => "256 server"
+    def initialize(connection,id)
+      response = connection.csreq("GET",connection.svrmgmthost,"#{connection.svrmgmtpath}/flavors/#{URI.escape(id.to_s)}",connection.svrmgmtport,connection.svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)['flavor']
+      @id   = data['id']
+      @name = data['name']
+      @ram  = data['ram']
+      @disk = data['disk']
+    end
+    
+  end
+end
+end

data/lib/openstack/compute/image.rb

@@ -0,0 +1,62 @@
+module OpenStack
+module Compute
+  class Image
+
+    attr_reader :id
+    attr_reader :name
+    attr_reader :serverId
+    attr_reader :updated
+    attr_reader :created
+    attr_reader :status
+    attr_reader :progress
+    
+    # This class provides an object for the "Image" of a server.  The Image refers to the Operating System type and version.
+    #
+    # Returns the Image object identifed by the supplied ID number.  Called from the get_image instance method of OpenStack::Compute::Connection,
+    # it will likely not be called directly from user code.
+    #
+    #   >> cs = OpenStack::Compute::Connection.new(USERNAME,API_KEY)
+    #   >> image = cs.get_image(2)
+    #   => #<OpenStack::Compute::Image:0x1015371c0 ...>
+    #   >> image.name
+    #   => "CentOS 5.2"    
+    def initialize(connection,id)
+      @id = id
+      @connection = connection
+      populate
+    end
+    
+    # Makes the HTTP call to load information about the provided image.  Can also be called directly on the Image object to refresh data.
+    # Returns true if the refresh call succeeds.
+    #
+    #   >> image.populate
+    #   => true
+    def populate
+      response = @connection.csreq("GET",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/images/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)['image']
+      @id = data['id']
+      @name = data['name']
+      @serverId = data['serverId']
+      @updated = DateTime.parse(data['updated'])
+      @created = DateTime.parse(data['created'])
+      @status = data['status']
+      @progress = data['progress']
+      return true
+    end
+    alias :refresh :populate
+    
+    # Delete an image.  This should be returning invalid permissions when attempting to delete system images, but it's not.
+    # Returns true if the deletion succeeds.
+    #
+    #   >> image.delete!
+    #   => true
+    def delete!
+      response = @connection.csreq("DELETE",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/images/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+  end
+end
+end

data/lib/openstack/compute/server.rb

@@ -0,0 +1,287 @@
+module OpenStack
+module Compute
+  class Server
+    
+    attr_reader   :id
+    attr_reader   :name
+    attr_reader   :status
+    attr_reader   :progress
+    attr_reader   :addresses
+    attr_reader   :metadata
+    attr_reader   :hostId
+    attr_reader   :imageId
+    attr_reader   :flavorId
+    attr_reader   :metadata
+    attr_accessor :adminPass
+    
+    # This class is the representation of a single Server object.  The constructor finds the server identified by the specified
+    # ID number, accesses the API via the populate method to get information about that server, and returns the object.
+    #
+    # Will be called via the get_server or create_server methods on the OpenStack::Compute::Connection object, and will likely not be called directly.
+    #
+    #   >> server = cs.get_server(110917)
+    #   => #<OpenStack::Compute::Server:0x1014e5438 ....>
+    #   >> server.name
+    #   => "RenamedRubyTest"
+    def initialize(connection,id)
+      @connection    = connection
+      @id            = id
+      @svrmgmthost   = connection.svrmgmthost
+      @svrmgmtpath   = connection.svrmgmtpath
+      @svrmgmtport   = connection.svrmgmtport
+      @svrmgmtscheme = connection.svrmgmtscheme
+      populate
+      return self
+    end
+    
+    # Makes the actual API call to get information about the given server object.  If you are attempting to track the status or project of
+    # a server object (for example, when rebuilding, creating, or resizing a server), you will likely call this method within a loop until 
+    # the status becomes "ACTIVE" or other conditions are met.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #  >> server.refresh
+    #  => true
+    def populate
+      response = @connection.csreq("GET",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(@id.to_s)}",@svrmgmtport,@svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)["server"]
+      @id        = data["id"]
+      @name      = data["name"]
+      @status    = data["status"]
+      @progress  = data["progress"]
+      @addresses = OpenStack::Compute.symbolize_keys(data["addresses"])
+      @metadata  = data["metadata"]
+      @hostId    = data["hostId"]
+      @imageId   = data["imageId"]
+      @flavorId  = data["flavorId"]
+      @metadata  = data["metadata"]
+      true
+    end
+    alias :refresh :populate
+    
+    # Returns a new OpenStack::Compute::Flavor object for the flavor assigned to this server.
+    #
+    #   >> flavor = server.flavor
+    #   => #<OpenStack::Compute::Flavor:0x1014aac20 @name="256 server", @disk=10, @id=1, @ram=256>
+    #   >> flavor.name
+    #   => "256 server"
+    def flavor
+      OpenStack::Compute::Flavor.new(@connection,self.flavorId)
+    end
+    
+    # Returns a new OpenStack::Compute::Image object for the image assigned to this server.
+    #
+    #   >> image = server.image
+    #   => #<OpenStack::Compute::Image:0x10149a960 ...>
+    #   >> image.name
+    #   => "Ubuntu 8.04.2 LTS (hardy)"
+    def image
+      OpenStack::Compute::Image.new(@connection,self.imageId)
+    end
+    
+    # Sends an API request to reboot this server.  Takes an optional argument for the type of reboot, which can be "SOFT" (graceful shutdown)
+    # or "HARD" (power cycle).  The hard reboot is also triggered by server.reboot!, so that may be a better way to call it.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.reboot
+    #   => true
+    def reboot(type="SOFT")
+      data = JSON.generate(:reboot => {:type => type})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+    # Sends an API request to hard-reboot (power cycle) the server.  See the reboot method for more information.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.reboot!
+    #   => true
+    def reboot!
+      self.reboot("HARD")
+    end
+    
+    # Updates various parameters about the server.  Currently, the only operations supported are changing the server name (not the actual hostname
+    # on the server, but simply the label in the Servers API) and the administrator password (note: changing the admin password will trigger
+    # a reboot of the server).  Other options are ignored.  One or both key/value pairs may be provided.  Keys are case-sensitive.
+    #
+    # Input hash key values are :name and :adminPass.  Returns true if the API call succeeds.
+    #
+    #   >> server.update(:name => "MyServer", :adminPass => "12345")
+    #   => true
+    #   >> server.name
+    #   => "MyServer"
+    def update(options)
+      data = JSON.generate(:server => options)
+      response = @connection.csreq("PUT",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      # If we rename the instance, repopulate the object
+      self.populate if options[:name]
+      true
+    end
+    
+    # Deletes the server from Openstack Compute.  The server will be shut down, data deleted, and billing stopped.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.delete!
+    #   => true
+    def delete!
+      response = @connection.csreq("DELETE",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}",@svrmgmtport,@svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+    # Takes the existing server and rebuilds it with the image identified by the imageId argument.  If no imageId is provided, the current image
+    # will be used.
+    #
+    # This will wipe and rebuild the server, but keep the server ID number, name, and IP addresses the same.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.rebuild!
+    #   => true
+    def rebuild!(imageId = self.imageId)
+      data = JSON.generate(:rebuild => {:imageId => imageId})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # Takes a snapshot of the server and creates a server image from it.  That image can then be used to build new servers.  The
+    # snapshot is saved asynchronously.  Check the image status to make sure that it is ACTIVE before attempting to perform operations
+    # on it.
+    # 
+    # A name string for the saved image must be provided.  A new OpenStack::Compute::Image object for the saved image is returned.
+    #
+    # The image is saved as a backup, of which there are only three available slots.  If there are no backup slots available, 
+    # A OpenStack::Compute::Exception::OpenStackComputeFault will be raised.
+    #
+    #   >> image = server.create_image("My Rails Server")
+    #   => 
+    def create_image(name)
+      data = JSON.generate(:image => {:serverId => self.id, :name => name})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/images",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack::Compute::Image.new(@connection,JSON.parse(response.body)['image']['id'])
+    end
+    
+    # Resizes the server to the size contained in the server flavor found at ID flavorId.  The server name, ID number, and IP addresses 
+    # will remain the same.  After the resize is done, the server.status will be set to "VERIFY_RESIZE" until the resize is confirmed or reverted.
+    #
+    # Refreshes the OpenStack::Compute::Server object, and returns true if the API call succeeds.
+    # 
+    #   >> server.resize!(1)
+    #   => true
+    def resize!(flavorId)
+      data = JSON.generate(:resize => {:flavorId => flavorId})
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # After a server resize is complete, calling this method will confirm the resize with the Openstack API, and discard the fallback/original image.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.confirm_resize!
+    #   => true
+    def confirm_resize!
+      # If the resize bug gets figured out, should put a check here to make sure that it's in the proper state for this.
+      data = JSON.generate(:confirmResize => nil)
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # After a server resize is complete, calling this method will reject the resized server with the Openstack API, destroying
+    # the new image and replacing it with the pre-resize fallback image.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.confirm_resize!
+    #   => true
+    def revert_resize!
+      # If the resize bug gets figured out, should put a check here to make sure that it's in the proper state for this.
+      data = JSON.generate(:revertResize => nil)
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/action",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      self.populate
+      true
+    end
+    
+    # Provides information about the backup schedule for this server.  Returns a hash of the form 
+    # {"weekly" => state, "daily" => state, "enabled" => boolean}
+    #
+    #   >> server.backup_schedule
+    #   => {"weekly"=>"THURSDAY", "daily"=>"H_0400_0600", "enabled"=>true}
+    def backup_schedule
+      response = @connection.csreq("GET",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(@id.to_s)}/backup_schedule",@svrmgmtport,@svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      JSON.parse(response.body)['backupSchedule']
+    end
+    
+    # Updates the backup schedule for the server.  Takes a hash of the form: {:weekly => state, :daily => state, :enabled => boolean} as an argument.
+    # All three keys (:weekly, :daily, :enabled) must be provided or an exception will get raised.
+    #
+    #   >> server.backup_schedule=({:weekly=>"THURSDAY", :daily=>"H_0400_0600", :enabled=>true})
+    #   => {:weekly=>"THURSDAY", :daily=>"H_0400_0600", :enabled=>true}
+    def backup_schedule=(options)
+      data = JSON.generate('backupSchedule' => options)
+      response = @connection.csreq("POST",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/backup_schedule",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+    # Removes the existing backup schedule for the server, setting the backups to disabled.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> server.disable_backup_schedule!
+    #   => true
+    def disable_backup_schedule!
+      response = @connection.csreq("DELETE",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/backup_schedule",@svrmgmtport,@svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+
+    # Share IP between servers in Shared IP group.
+    # Takes a hash of the form: {:sharedIpGroupId => "1234", :ipAddress => "67.23.10.132", :configureServer => false} as an argument.
+    # The :sharedIpGroupId key is required.
+    # The :ipAddress key is required.
+    # The :configureServer key is optional and defaults to false.
+    #
+    #   >> server.share_ip(:sharedIpGroupId => 100, :ipAddress => "67.23.10.132")
+    #   => true
+    def share_ip(options)
+      raise OpenStack::Compute::Exception::MissingArgument, "Shared IP Group ID must be supplied" unless options[:sharedIpGroupId]
+      raise OpenStack::Compute::Exception::MissingArgument, "Ip Address must be supplied" unless options[:ipAddress]
+      options[:configureServer] = false if options[:configureServer].nil?
+      data = JSON.generate(:shareIp => {:sharedIpGroupId => options[:sharedIpGroupId], :configureServer => options[:configureServer]})
+      response = @connection.csreq("PUT",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/ips/public/#{options[:ipAddress]}",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+
+    # Unshare an IP address.
+    # Takes a hash of the form: {:ipAddress => "67.23.10.132"} as an argument.
+    # The :ipAddress key is required.
+    #
+    #   >> server.unshare_ip(:ipAddress => "67.23.10.132")
+    #   => true
+    def unshare_ip(options)
+      raise OpenStack::Compute::Exception::MissingArgument, "Ip Address must be supplied" unless options[:ipAddress]
+      response = @connection.csreq("DELETE",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/ips/public/#{options[:ipAddress]}",@svrmgmtport,@svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+ 
+  end
+end
+end

data/lib/openstack/compute/shared_ip_group.rb

@@ -0,0 +1,54 @@
+module OpenStack
+module Compute
+  class SharedIPGroup
+    
+    attr_reader :id
+    attr_reader :name
+    attr_reader :servers
+    
+    # Creates a new Shared IP Group object, with information on the group identified by the ID number.  Will most likely be called 
+    # by the get_shared_ip_group method on a OpenStack::Compute::Connection object.
+    #
+    #   >> sig = cs.get_shared_ip_group(127)
+    #   => #<OpenStack::Compute::SharedIPGroup:0x101513798 ...>
+    #   >> sig.name
+    #   => "New Group"
+    def initialize(connection,id)
+      @connection = connection
+      @id = id
+      populate
+    end
+    
+    # Makes the API call that populates the OpenStack::Compute::SharedIPGroup object with information on the group.  Can also be called directly on
+    # an existing object to update its information.
+    # 
+    # Returns true if the API call succeeds.
+    #
+    #   >> sig.populate
+    #   => true
+    def populate
+      response = @connection.csreq("GET",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/shared_ip_groups/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      data = JSON.parse(response.body)['sharedIpGroup']
+      @id = data['id']
+      @name = data['name']
+      @servers = data['servers']
+      true
+    end
+    alias :refresh :populate
+    
+    # Deletes the Shared IP Group identified by the current object.
+    #
+    # Returns true if the API call succeeds.
+    #
+    #   >> sig.delete!
+    #   => true
+    def delete!
+      response = @connection.csreq("DELETE",@connection.svrmgmthost,"#{@connection.svrmgmtpath}/shared_ip_groups/#{URI.escape(self.id.to_s)}",@connection.svrmgmtport,@connection.svrmgmtscheme)
+      OpenStack::Compute::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+    
+  end
+end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: openstack-compute
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dan Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-02 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: API Binding for OpenStack Compute
+email: dan.prince@rackspace.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- COPYING
+- README.rdoc
+- VERSION
+- lib/openstack/compute.rb
+- lib/openstack/compute/authentication.rb
+- lib/openstack/compute/connection.rb
+- lib/openstack/compute/entity_manager.rb
+- lib/openstack/compute/exception.rb
+- lib/openstack/compute/flavor.rb
+- lib/openstack/compute/image.rb
+- lib/openstack/compute/server.rb
+- lib/openstack/compute/shared_ip_group.rb
+has_rdoc: true
+homepage: https://launchpad.net/ruby-openstack-compute
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: OpenStack Compute Ruby API
+test_files: []
+