deltacloud-client 0.0.2

data/lib/dcloud/storage_volume.rb

@@ -0,0 +1,53 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'dcloud/base_model'
+
+module DCloud
+    class StorageVolume < BaseModel
+
+      xml_tag_name :storage_volume
+
+      attribute :created
+      attribute :state
+      attribute :capacity
+      attribute :device
+      attribute :instance
+
+      def initialize(client, uri, xml=nil)
+        super( client, uri, xml )
+      end
+
+      def load_payload(xml=nil)
+        super(xml)
+        unless xml.nil?
+          @created = xml.text( 'created' )
+          @state = xml.text( 'state' )
+          @capacity = xml.text( 'capacity' ).to_f
+          @device = xml.text( 'device' )
+          instances = xml.get_elements( 'instance' )
+          if ( ! instances.empty? )
+            instance = instances.first
+            instance_href = instance.attributes['href']
+            if ( instance_href )
+              @instance = Instance.new( @client, instance_href )
+            end
+          end
+        end
+      end
+    end
+end

data/lib/dcloud/transition.rb

@@ -0,0 +1,35 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+module DCloud
+    class Transition
+
+      attr_accessor :to
+      attr_accessor :action
+
+      def initialize(to, action)
+        @to = to
+        @action = action
+      end
+
+      def auto?()
+        @action.nil?
+      end
+
+    end
+end

data/lib/deltacloud.rb

@@ -0,0 +1,356 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'rest_client'
+require 'rexml/document'
+require 'logger'
+require 'dcloud/flavor'
+require 'dcloud/realm'
+require 'dcloud/image'
+require 'dcloud/instance'
+require 'dcloud/storage_volume'
+require 'dcloud/storage_snapshot'
+require 'dcloud/state'
+require 'dcloud/transition'
+require 'base64'
+
+module RestClient
+  class Response
+    def body
+      self.to_s
+    end
+  end
+end
+
+class DeltaCloud
+
+  attr_accessor :logger
+  attr_reader   :api_uri
+  attr_reader   :entry_points
+  attr_reader   :driver_name
+
+  def self.driver_name(url)
+    DeltaCloud.new( nil, nil, url) do |client|
+      return client.driver_name
+    end
+  end
+
+  def initialize(name, password, api_uri, &block)
+    @logger       = Logger.new( STDERR )
+    @name         = name
+    @password     = password
+    @api_uri      = URI.parse( api_uri )
+    @entry_points = {}
+    discover_entry_points
+    connect( &block )
+    self
+  end
+
+
+  def connect(&block)
+    @http = RestClient::Resource.new( api_uri.to_s , :accept => 'application/xml' )
+    discover_entry_points
+    block.call( self ) if block
+    self
+  end
+
+  def api_host
+    @api_uri.host
+  end
+
+  def api_port
+    @api_uri.port
+  end
+
+  def api_path
+    @api_uri.path
+  end
+
+  def flavors(opts={})
+    flavors = []
+    request(entry_points[:flavors], :get, opts) do |response|
+      doc = REXML::Document.new( response )
+      doc.get_elements( 'flavors/flavor' ).each do |flavor|
+        uri = flavor.attributes['href']
+        flavors << DCloud::Flavor.new( self, uri, flavor )
+      end
+    end
+    flavors
+  end
+
+  def flavor(id)
+    request( entry_points[:flavors], :get, {:id=>id } ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( '/flavor' ).each do |flavor|
+        uri = flavor.attributes['href']
+        return DCloud::Flavor.new( self, uri, flavor )
+      end
+    end
+  end
+
+  def fetch_flavor(uri)
+    xml = fetch_resource( :flavor, uri )
+    return DCloud::Flavor.new( self, uri, xml ) if xml
+    nil
+  end
+
+  def fetch_resource(type, uri)
+    request( uri ) do |response|
+      doc = REXML::Document.new( response.body )
+      if ( doc.root && ( doc.root.name == type.to_s.gsub( /_/, '-' ) ) )
+        return doc.root
+      end
+    end
+    nil
+  end
+
+  def instance_states
+    states = []
+    request( entry_points[:instance_states] ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'states/state' ).each do |state_elem|
+        state = DCloud::State.new( state_elem.attributes['name'] )
+        state_elem.get_elements( 'transition' ).each do |transition_elem|
+          state.transitions << DCloud::Transition.new(
+                                 transition_elem.attributes['to'],
+                                 transition_elem.attributes['action']
+                               )
+        end
+        states << state
+      end
+    end
+    states
+  end
+
+  def instance_state(name)
+    found = instance_states.find{|e| e.name.to_s == name.to_s}
+    found
+  end
+
+  def realms(opts={})
+    realms = []
+    request( entry_points[:realms], :get, opts ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'realms/realm' ).each do |realm|
+        uri = realm.attributes['href']
+        realms << DCloud::Realm.new( self, uri, realm )
+      end
+    end
+    realms
+  end
+
+  def realm(id)
+    request( entry_points[:realms], :get, {:id=>id } ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'realm' ).each do |realm|
+        uri = realm.attributes['href']
+        return DCloud::Realm.new( self, uri, realm )
+      end
+    end
+    nil
+  end
+
+  def fetch_realm(uri)
+    xml = fetch_resource( :realm, uri )
+    return DCloud::Realm.new( self, uri, xml ) if xml
+    nil
+  end
+
+  def images(opts={})
+    images = []
+    request_path = entry_points[:images]
+    request( request_path, :get, opts ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'images/image' ).each do |image|
+        uri = image.attributes['href']
+        images << DCloud::Image.new( self, uri, image )
+      end
+    end
+    images
+  end
+
+  def image(id)
+    request( entry_points[:images], :get, {:id=>id } ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'image' ).each do |instance|
+        uri = instance.attributes['href']
+        return DCloud::Image.new( self, uri, instance )
+      end
+    end
+    nil
+  end
+
+  def instances
+    instances = []
+    request( entry_points[:instances] ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'instances/instance' ).each do |instance|
+        uri = instance.attributes['href']
+        instances << DCloud::Instance.new( self, uri, instance )
+      end
+    end
+    instances
+  end
+
+  def instance(id)
+    request( entry_points[:instances], :get, {:id=>id } ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'instance' ).each do |instance|
+        uri = instance.attributes['href']
+        return DCloud::Instance.new( self, uri, instance )
+      end
+    end
+    nil
+  end
+
+  def post_instance(uri)
+    request( uri, :post ) do |response|
+      return true
+    end
+    return false
+  end
+
+  def fetch_instance(uri)
+    xml = fetch_resource( :instance, uri )
+    return DCloud::Instance.new( self, uri, xml ) if xml
+    nil
+  end
+
+  def create_instance(image_id, opts={})
+    name = opts[:name]
+    realm_id = opts[:realm]
+    flavor_id = opts[:flavor]
+
+    params = {}
+    ( params[:realm_id] = realm_id ) if realm_id
+    ( params[:flavor_id] = flavor_id ) if flavor_id
+    ( params[:name] = name ) if name
+
+    params[:image_id] = image_id
+    request( entry_points[:instances], :post, {}, params ) do |response|
+      doc = REXML::Document.new( response.body )
+      instance = doc.root
+      uri = instance.attributes['href']
+      return DCloud::Instance.new( self, uri, instance )
+    end
+  end
+
+  def storage_volumes
+    storage_volumes = []
+    request( entry_points[:storage_volumes] ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'storage-volumes/storage-volume' ).each do |instance|
+        uri = instance.attributes['href']
+        storage_volumes << DCloud::StorageVolume.new( self, uri, instance )
+      end
+    end
+    storage_volumes
+  end
+
+  def storage_volume(id)
+    request( entry_points[:storage_volumes], :get, {:id=>id } ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'storage-volume' ).each do |storage_volume|
+        uri = storage_volume.attributes['href']
+        return DCloud::StorageVolume.new( self, uri, storage_volume )
+      end
+    end
+    nil
+  end
+
+  def fetch_storage_volume(uri)
+    xml = fetch_resource( :storage_volume, uri )
+    return DCloud::StorageVolume.new( self, uri, xml ) if xml
+    nil
+  end
+
+  def storage_snapshots()
+    storage_snapshots = []
+    request( entry_points[:storage_snapshots] ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'storage-snapshots/storage-snapshot' ).each do |instance|
+        uri = instance.attributes['href']
+        storage_snapshots << DCloud::StorageSnapshot.new( self, uri, instance )
+      end
+    end
+    storage_snapshots
+  end
+
+  def storage_snapshot(id)
+    request( entry_points[:storage_snapshots], :get, {:id=>id } ) do |response|
+      doc = REXML::Document.new( response.body )
+      doc.get_elements( 'storage-snapshot' ).each do |storage_snapshot|
+        uri = storage_snapshot.attributes['href']
+        return DCloud::StorageSnapshot.new( self, uri, storage_snapshot )
+      end
+    end
+    nil
+  end
+
+  def fetch_storage_snapshot(uri)
+    xml = fetch_resource( :storage_snapshot, uri )
+    return DCloud::StorageSnapshot.new( self, uri, xml ) if xml
+    nil
+  end
+
+  def fetch_image(uri)
+    xml = fetch_resource( :image, uri )
+    return DCloud::Image.new( self, uri, xml ) if xml
+    nil
+  end
+
+  private
+
+  attr_reader :http
+
+  def discover_entry_points
+    request(api_uri.to_s) do |response|
+      doc = REXML::Document.new( response.body )
+      @driver_name = doc.root.attributes['driver']
+      doc.get_elements( 'api/link' ).each do |link|
+        rel = link.attributes['rel']
+        uri = link.attributes['href']
+        @entry_points[rel.to_sym] = uri
+      end
+    end
+  end
+
+  def request(path='', method=:get, query_args={}, form_data={}, &block)
+    if ( path =~ /^http/ )
+      request_path = path
+    else
+      request_path = "#{api_uri.to_s}#{path}"
+    end
+    if query_args[:id]
+      request_path += "/#{query_args[:id]}"
+      query_args.delete(:id)
+    end
+    query_string = URI.escape(query_args.collect{|k,v| "#{k}=#{v}"}.join('&'))
+    request_path += "?#{query_string}" unless query_string==''
+    headers = {
+      :authorization => "Basic "+Base64.encode64("#{@name}:#{@password}"),
+      :accept => "application/xml"
+    }
+    logger << "Request [#{method.to_s.upcase}] #{request_path}]\n"
+    if method.eql?(:get)
+      RestClient.send(method, request_path, headers, &block)
+    else
+      RestClient.send(method, request_path, form_data, headers, &block)
+    end
+  end
+
+end

data/specs/data/images/img1.yml

@@ -0,0 +1,3 @@
+:description: Fedora 10
+:owner_id: fedoraproject
+:architecture: x86_64