openstack 1.0.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,189 @@
+= Ruby OpenStack
+
+== Description
+
+Ruby Openstack Compute and Object-Store bindings for the v1.0 OSAPI.
+
+Currently supports both v1.0 and v2.0 (keystone) auth.
+
+Use OpenStack::Connection.create to get a handle to an OpenStack service - set the :service_type parameter to either 'compute' or 'object-store' (defaults to 'compute')
+
+== Examples
+
+== For Compute:
+
+See the class definitions for documentation on specific methods and operations.
+
+  require 'openstack'
+
+  os = OpenStack::Connection.create(:username => USERNAME, :api_key => API_KEY, :authtenant => TENANT, :auth_url => API_URL, :service_type => "compute")
+
+  # Get a listing of all current servers
+  >> os.servers
+  => [{:name=>"Server1", :id=>110917}]
+
+  # Access a specific server
+  >> server = os.server(110917)
+  >> server.name
+  => "Server1"
+
+  # 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 = os.get_image(8)
+  => #<OpenStack::Compute::Image:0x1014a8060 ...>, status"ACTIVE"
+  >> image.name
+  => "CentOS 5.2"
+  >> flavor = os.get_flavor(2)
+  => #<OpenStack::Compute::Flavor:0x101469130 @disk=20, @name="512 server", @id=2, @ram=512>
+  >> flavor.name
+  => "512 server"
+  >> newserver = os.create_server(:name => "New Server", :imageRef => image.id, :flavorRef => 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
+
+== Examples for Object-Store:
+
+
+  os = OpenStack::Connection.create(:username => USERNAME, :api_key => API_KEY, :authtenant => TENANT, :auth_url => API_URL, :service_type => "object-store")
+
+  # Get info on container count and bytes:
+  >> os.get_info
+  => {:count=>2, :bytes=>495041}
+
+  # Get list of containers under this account:
+  >> os.containers
+  => ["another_containerfoo", "marios_test_container"]
+
+  # Get details of containers under this account:
+  >> os.containers_detail
+  =>=> {"another_containerfoo"=>{:count=>"3", :bytes=>"1994"}, "marios_test_container"=>{:count=>"2", :bytes=>"493047"}}
+
+  # Check if a container exists
+  >> os.container_exists?("no_such_thing")
+  => false
+
+  # Create new container
+  >> os.create_container("foo")
+  => => #<OpenStack::Swift::Container:0xb7275c38  ...... (rest of OpenStack::Swift::Container object)
+
+  # Delete container
+  >> os.delete_container("foo")
+  => true
+
+  # Get a container (OpenStack::Swift::Container object):
+  >> cont = os.container("foo")
+  => #<OpenStack::Swift::Container:0xb7262124 ...... (rest of OpenStack::Swift::Container object)
+
+  # Retrieve container metadata:
+  >> cont.container_metadata
+  =>{:count=>"2", :bytes=>"493047", :metadata=>{"foo"=>"bar", "author"=>"foobar", "jj"=>"foobar", "date"=>"today", "owner"=>"foo"}}
+
+  # Retrieve user defined metadata:
+  >> cont.metadata
+  => {"foo"=>"bar", "author"=>"foobar", "jj"=>"foobar", "date"=>"today", "owner"=>"foo"}
+
+  # Set user defined metadata:
+  >> cont.set_metadata({"X-Container-Meta-Author"=> "msa", "version"=>"1.2", :date=>"today"})
+  => true
+
+  # Get list of objects:
+  >> cont.objects
+  => ["fosdem2012.pdf", "moved_object"]
+
+  # Get list of objects with details:
+  >> cont.objects_detail
+  => {"fosdem2012.pdf"=>{:bytes=>"493009", :content_type=>"application/json", :hash=>"494e444f92a8082dabac80a74cdf2c3b", :last_modified=>"2012-04-26T09:22:51.611230"}, "moved_object"=>{:bytes=>"38", :content_type=>"application/json", :hash=>"a7942f97fe6bd34920a4f61fe5e604a5", :last_modified=>"2012-04-26T09:35:33.839920"}}
+
+  # Check if container is empty:
+  >> cont.empty?
+  => false
+
+  # Check if object exists:
+  >> cont.object_exists?("foo")
+  => false
+
+  # Create new object
+  >> new_obj = cont.create_object("foo", {:metadata=>{"herpy"=>"derp"}, :content_type=>"text/plain"}, "this is the data")  [can also supply File.open(/path/to/file) and the data]
+  => #<OpenStack::Swift::StorageObject:0xb72fdac0  ... etc
+
+  # Delete object
+  >> cont.delete_object("foo")
+  => true
+
+  # Get handle to an OpenStack::Swift::StorageObject Object
+  >> obj = cont.object("foo")
+  => #<OpenStack::Swift::StorageObject:0xb72fdac0  ... etc
+
+  # Get object metadata
+  >> obj.object_metadata
+  =>
+
+  # Get user defined metadata pairs
+  >> obj.metadata
+  =>
+
+  # Get data (non streaming - returned as a String)
+  >> obj.data
+  => "This is the text stored in the file"
+
+  # Get data (streaming - requires a block)
+  >> data = ""; object.data_stream do |chunk| data += chunk end
+  => #<Net::HTTPOK 200 OK readbody=true>
+  >> data
+  => "This is the text stored in the file"
+
+  # Set user defined metadata
+  >> obj.set_metadata({:foo=>"bar", "X-Object-Meta-herpa"=>"derp", "author"=>"me"})
+  => true
+
+  # (Over)Write object data
+  >> object.write("This is new data")
+  => true
+  >> object.data
+  => "This is new data"
+
+  # Copy object:
+  >>copied = obj.copy('copied_object', "destination_container", {:content_type=>"text/plain", :metadata=>{:herp=>"derp", "X-Object-Meta-foo"=>"bar} } )
+  => #<OpenStack::Swift::StorageObject:0xb728974c  ..... etc
+
+  # Move object: (copy and then delete original):
+  >> moved = obj.move('moved_object', "destination_container", {:content_type=>"text/plain", :metadata=>{:herp=>"derp", "X-Object-Meta-foo"=>"bar"} } )
+  =>  #<OpenStack::Swift::StorageObject:0xb7266bd4 ...
+  >> moved.metadata
+  => {"foo"=>"bar", "herp"=>"derp", "herpy"=>"derp"}
+  >> obj.metadata
+  => OpenStack::Exception::ItemNotFound: The resource could not be found
+
+
+== Authors
+
+By Dan Prince <dprince@redhat.com>, Naveed Massjouni <naveedm9@gmail.com>, Marios Andreou <marios@redhat.com>
+
+Initial code checkin on May 23rd 2012 - code refactored from and based on the Rackspace Cloud Servers gem
+(https://github.com/rackspace/ruby-openstack-compute) and Rackspace Cloud Files gem (https://github.com/rackspace/ruby-cloudfiles).
+
+== License
+
+See COPYING for license information.

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/openstack.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+#
+# == Ruby OpenStack API
+#
+# See COPYING for license information.
+# ----
+#
+# === Documentation & Examples
+# To begin reviewing the available methods and examples, view the README.rdoc file
+#
+# Example:
+# os = OpenStack::Connection.create({:username => "herp@derp.com", :api_key=>"password",
+#               :auth_url => "https://region-a.geo-1.identity.cloudsvc.com:35357/v2.0/",
+#               :authtenant=>"herp@derp.com-default-tenant", :service_type=>"object-store")
+#
+# will return a handle to the object-storage service swift. Alternatively, passing
+# :service_type=>"compute" will return a handle to the compute service nova.
+
+module OpenStack
+
+  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 'openstack/connection'
+  require 'openstack/compute/connection'
+  require 'openstack/compute/server'
+  require 'openstack/compute/image'
+  require 'openstack/compute/flavor'
+  require 'openstack/compute/address'
+  require 'openstack/compute/personalities'
+  require 'openstack/swift/connection'
+  require 'openstack/swift/container'
+  require 'openstack/swift/storage_object'
+
+  # Constants that set limits on server creation
+  MAX_PERSONALITY_ITEMS = 5
+  MAX_PERSONALITY_FILE_SIZE = 10240
+  MAX_SERVER_PATH_LENGTH = 255
+
+  # 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
+
+  # e.g. keys = [:limit, :marker]
+  # params = {:limit=>2, :marker="marios", :prefix=>"/"}
+  # you want url = /container_name?limit=2&marker=marios
+  def self.get_query_params(params, keys, url="")
+    set_keys = params.inject([]){|res, (k,v)| res << k if keys.include?(k) and not v.nil?; res }
+    return url if set_keys.empty?
+    url = "#{url}?#{set_keys[0]}=#{params[set_keys[0]]}"
+    set_keys.slice!(0)
+    set_keys.each do |k|
+      url = "#{url}&#{k}=#{params[set_keys[0]]}"
+    end
+    url
+  end
+
+end

data/lib/openstack/compute/address.rb

@@ -0,0 +1,39 @@
+module OpenStack
+module Compute
+
+  class AddressList < Array
+    def [](index)
+      addresses = Array.new
+      if index.class == Symbol then
+        self.each do |address|
+          if address.label == index.to_s then
+            addresses << address
+          end
+        end
+        addresses
+      else
+        super
+      end
+    end
+  end
+
+  class Address
+
+    attr_reader :address
+    attr_reader :label
+    attr_reader :version
+
+    def initialize(label, address, version = 4)
+      @label = label
+      if address.class == Hash then
+        @address = address["addr"]
+        @version = address["version"]
+      else
+        @address = address
+        @version = version
+      end
+    end
+  end
+
+end
+end

data/lib/openstack/compute/connection.rb

@@ -0,0 +1,207 @@
+module OpenStack
+module Compute
+
+  class Connection
+
+    attr_accessor   :connection
+
+    def initialize(connection)
+      @connection = connection
+      OpenStack::Authentication.init(@connection)
+    end
+
+    # Returns true if the authentication was successful and returns false otherwise.
+    #
+    #   cs.authok?
+    #   => true
+    def authok?
+      @connection.authok
+    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.paginate(options).empty? ? "#{@connection.service_path}/servers?#{anti_cache_param}" : "#{@connection.service_path}/servers?#{OpenStack.paginate(options)}&#{anti_cache_param}"
+      response = @connection.csreq("GET",@connection.service_host,path,@connection.service_port,@connection.service_scheme)
+      OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack.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"}, :imageRef=>10, :progress=>100, :hostId=>"36143b12e9e48998c2aef79b50e144d2", :flavorRef=>1, :id=>110917, :status=>"ACTIVE"}]
+    #
+    #   >> cs.list_servers_detail(:limit => 2, :offset => 3)
+    #   => [{:status=>"ACTIVE", :imageRef=>10, :progress=>100, :metadata=>{}, :addresses=>{:public=>["x.x.x.x"], :private=>["x.x.x.x"]}, :name=>"demo-standingcloud-lts", :id=>168867, :flavorRef=>1, :hostId=>"xxxxxx"},
+    #       {:status=>"ACTIVE", :imageRef=>8, :progress=>100, :metadata=>{}, :addresses=>{:public=>["x.x.x.x"], :private=>["x.x.x.x"]}, :name=>"demo-aicache1", :id=>187853, :flavorRef=>3, :hostId=>"xxxxxx"}]
+    def list_servers_detail(options = {})
+      path = OpenStack.paginate(options).empty? ? "#{@connection.service_path}/servers/detail" : "#{@connection.service_path}/servers/detail?#{OpenStack.paginate(options)}"
+      response = @connection.csreq("GET",@connection.service_host,path,@connection.service_port,@connection.service_scheme)
+      OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack.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, :flavorRef,
+    # and :imageRef are required; :metadata and :personality are optional.
+    #
+    # :flavorRef and :imageRef are href strings identifying a particular
+    # server flavor and image to use when building the server.  The :imageRef
+    # can either be a stock image, or one of your own created with the
+    # server.create_image method.
+    #
+    # The :metadata argument should be a hash of 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        => 'NewServer',
+    #        :imageRef    => '3',
+    #        :flavorRef   => '1',
+    #        :metadata    => {'Racker' => 'Fanatical'},
+    #        :personality => {'/home/bob/wedding.jpg' => '/root/wedding.jpg'})
+    #   => #<OpenStack::Compute::Server:0x101229eb0 ...>
+    #   >> server.name
+    #   => "NewServer"
+    #   >> server.status
+    #   => "BUILD"
+    #   >> server.adminPass
+    #   => "NewServerSHMGpvI"
+    def create_server(options)
+      raise OpenStack::Exception::MissingArgument, "Server name, flavorRef, and imageRef, must be supplied" unless (options[:name] && options[:flavorRef] && options[:imageRef])
+      options[:personality] = Personalities.get_personality(options[:personality])
+      data = JSON.generate(:server => options)
+      response = @connection.csreq("POST",@connection.service_host,"#{@connection.service_path}/servers",@connection.service_port,@connection.service_scheme,{'content-type' => 'application/json'},data)
+      OpenStack::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 imageRef 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.paginate(options).empty? ? "#{@connection.service_path}/images/detail" : "#{@connection.service_path}/images/detail?#{OpenStack.paginate(options)}"
+      response = @connection.csreq("GET",@connection.service_host,path,@connection.service_port,@connection.service_scheme)
+      OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack.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 flavorRef 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.paginate(options).empty? ? "#{@connection.service_path}/flavors/detail" : "#{@connection.service_path}/flavors/detail?#{OpenStack.paginate(options)}"
+      response = @connection.csreq("GET",@connection.service_host,path,@connection.service_port,@connection.service_scheme)
+      OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack.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 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 = @connection.csreq("GET",@connection.service_host,"#{@connection.service_path}/limits",@connection.service_port,@connection.service_scheme)
+      OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      OpenStack.symbolize_keys(JSON.parse(response.body)['limits'])
+    end
+
+  end
+end
+end