deltacloud-core 1.0.1 → 1.0.2

data/lib/cimi/collections/cloud_entry_point.rb

@@ -22,7 +22,7 @@ module CIMI::Collections
         description "list all resources of the cloud"
         control do
           if params[:force_auth]
-            return [401, 'Authentication failed'] unless driver.valid_credentials?(credentials)
+            halt 401 unless driver.valid_credentials?(credentials)
           end
           entry_point = CIMI::Model::CloudEntryPoint.create(self)
           respond_to do |format|

data/lib/cimi/models.rb

@@ -17,13 +17,7 @@ module CIMI
   module Model; end
 end
 
-unless Kernel.respond_to?(:require_relative)
-  module Kernel
-    def require_relative(path)
-      require File.join(File.dirname(caller[0]), path.to_str)
-    end
-  end
-end
+require 'require_relative' if RUBY_VERSION < '1.9'
 
 require_relative './models/schema'
 require_relative './models/base'

data/lib/cimi/models/base.rb

@@ -199,10 +199,7 @@ class CIMI::Model::Base
   #
   text :id, :name, :description, :created
 
-  # FIXME: this doesn't match with JSON
-  hash :property, :content => :value do
-    scalar :name
-  end
+  hash :property
 
   def self.act_as_root_entity(name=nil)
     if name

data/lib/cimi/models/cloud_entry_point.rb

@@ -15,15 +15,26 @@
 
 class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
 
+  text  :base_uri, :xml_name => "baseURI", :json_name => "baseURI"
   array :entity_metadata do
     scalar :href
   end
 
+  DELTACLOUD_MAPPINGS = { "MachineImages" => "images",
+                          "MachineConfigurations" => "hardware_profiles",
+                          "Machines" => "instances",
+                          "Volumes" => "storage_volumes",
+                          "MachineAdmins" => "keys",
+                          "VolumeImages" => "storage_snapshots",
+                        }
+
+
   def self.create(context)
     self.new(entities(context).merge({
       :name => context.driver.name,
       :description => "Cloud Entry Point for the Deltacloud #{context.driver.name} driver",
       :id => context.cloudEntryPoint_url,
+      :base_uri => context.root_url,
       :created => Time.now,
       :entity_metadata => CIMI::Model::EntityMetadata.all_uri(context)
     }))
@@ -32,6 +43,9 @@ class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
   # Return an Hash of the CIMI root entities used in CloudEntryPoint
   def self.entities(context)
     CIMI::Model.root_entities.inject({}) do |result, entity|
+      if DELTACLOUD_MAPPINGS[entity]
+        next result unless context.driver.respond_to?(DELTACLOUD_MAPPINGS[entity])
+      end
       result[entity.underscore] = { :href => context.send(:"#{entity.underscore}_url") }
       result
     end

data/lib/cimi/models/machine.rb

@@ -132,7 +132,6 @@ class CIMI::Model::Machine < CIMI::Model::Base
   end
 
   private
-
   def self.from_instance(instance, context)
     cpu =  memory = disks = (instance.instance_profile.id == "opaque")? "n/a" : nil
     self.new(
@@ -159,10 +158,10 @@ class CIMI::Model::Machine < CIMI::Model::Base
   end
 
   def self.convert_instance_properties(instance, context)
-    properties = []
-    properties << { :name => :machine_image, :value => context.machine_image_url(instance.image_id) }
+    properties = {}
+    properties["machine_image"] = context.machine_image_url(instance.image_id)
     if instance.respond_to? :keyname
-      properties << { :name => :machine_admin, :value => context.machine_admin_url(instance.keyname) }
+      properties["machine_admin"] = context.machine_admin_url(instance.keyname)
     end
     properties
   end
@@ -187,6 +186,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   def self.convert_instance_storage(profile, context)
     machine_conf = CIMI::Model::MachineConfiguration.find(profile.name, context)
+    return nil unless machine_conf.disks
     storage_override = profile.overrides.find { |p, v| p == :storage }
     [
       { :capacity => {

data/lib/cimi/models/machine_admin.rb

@@ -25,6 +25,7 @@ class CIMI::Model::MachineAdmin < CIMI::Model::Base
 
   def self.find(id, context)
     if id == :all
+      return [] unless context.driver.respond_to?(:keys)
       keys = context.driver.keys(context.credentials)
       keys.map { |key| from_key(key, context) }
     else

data/lib/cimi/models/machine_configuration.rb

@@ -52,16 +52,16 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
     # We accept just profiles with all properties set
     return unless profile.memory or profile.cpu or profile.storage
     memory = profile.memory.value || profile.memory.default
-    cpu = profile.cpu.value || profile.cpu.default
-    storage = profile.storage.value || profile.storage.default
+    cpu = (profile.cpu ? (profile.cpu.value || profile.cpu.default) : nil )
+    storage = (profile.storage ? (profile.storage.value || profile.storage.default) :  nil )
     machine_hash = {
       :name => profile.name,
       :description => "Machine Configuration with #{memory} #{profile.memory.unit} "+
         "of memory and #{cpu} CPU",
-      :cpu => cpu,
+      :cpu => ( cpu if cpu ) ,
       :created => Time.now.to_s,  # FIXME: DC hardware_profile has no mention about created_at
       :memory => { :quantity => profile.memory.value || profile.memory.default, :units => profile.memory.unit },
-      :disks => [ { :capacity => { :quantity => profile.storage.value || profile.storage.default, :units => profile.storage.unit } } ],
+      :disks => (  [ { :capacity => { :quantity => profile.storage.value || profile.storage.default, :units => profile.storage.unit } } ] if storage ),
       :id => context.machine_configuration_url(profile.name)
     }
     self.new(machine_hash)

data/lib/cimi/models/schema.rb

@@ -25,8 +25,8 @@ class CIMI::Model::Schema
 
     def initialize(name, opts = {})
       @name = name
-      @xml_name = (opts[:xml_name] || name).to_s.camelize(true)
-      @json_name = (opts[:json_name] || name).to_s.camelize(true)
+      @xml_name = opts[:xml_name] || name.to_s.camelize(true)
+      @json_name = opts[:json_name] || name.to_s.camelize(true)
     end
 
     def from_xml(xml, model)
@@ -144,10 +144,12 @@ class CIMI::Model::Schema
   end
 
   class Array < Attribute
-    # For an array :things, we collect all <thing/> elements (XmlSimple
+    # For an array :funThings, we collect all <funThing/> elements (XmlSimple
     # actually does the collecting)
     def initialize(name, opts = {}, &block)
-      opts[:xml_name] = name.to_s.singularize unless opts[:xml_name]
+      unless opts[:xml_name]
+        opts[:xml_name] = name.to_s.singularize.camelize.uncapitalize
+      end
       super(name, opts)
       @struct = Struct.new(name, opts, &block)
     end
@@ -176,27 +178,28 @@ class CIMI::Model::Schema
     def initialize(name, opts = {}, &block)
       opts[:json_name] = name.to_s.pluralize unless opts[:json_name]
       super(name, opts)
-      @struct = Struct.new(name, opts, &block)
     end
 
     def from_xml(xml, model)
-      model[name] = (xml[xml_name] || []).map { |elt| @struct.convert_from_xml(elt) }
+      model[name] = (xml[xml_name] || []).inject({}) do |result, item|
+        result[item["name"]] = item["content"]
+        result
+      end
     end
 
     def from_json(json, model)
-      model[name] = (json[json_name] || {}).inject([]) do |result,item|
-        result << @struct.convert_from_json({ 'name' => item[0], 'value' => item[1] })
-      end
+      model[name] = json[json_name] || {}
     end
 
     def to_xml(model, xml)
-      ary = (model[name] || []).map { |elt| @struct.convert_to_xml(elt) }
+      ary = (model[name] || {}).map { |k, v| { "name" => k, "content" => v } }
       xml[xml_name] = ary unless ary.empty?
     end
 
     def to_json(model, json)
-      ary = (model[name] || []).map { |elt| @struct.convert_to_json(elt) }
-      json[json_name] = ary.inject({}) { |result, item| result[item['name']] = item['value']; result } unless ary.empty?
+      if model[name] && ! model[name].empty?
+        json[json_name] = model[name]
+      end
     end
   end
 
@@ -262,8 +265,8 @@ class CIMI::Model::Schema
       add_attributes!([name, opts], Struct, &block)
     end
 
-    def hash(name, opts={}, &block)
-      add_attributes!([name, opts], Hash, &block)
+    def hash(name)
+      add_attributes!([name, {}], Hash)
     end
   end
 

data/lib/cimi/models/volume_image.rb

@@ -25,7 +25,7 @@ class CIMI::Model::VolumeImage < CIMI::Model::Base
   def self.find(id, context)
     storage_snapshots = []
     opts = ( id==:all  ) ? {}  : { :id=>id }
-    storage_snapshots = self.driver.storage_snapshots(context.credentials, opts)
+    storage_snapshots = context.driver.storage_snapshots(context.credentials, opts)
     storage_snapshots.collect!{ |snapshot| from_storage_snapshot(snapshot, context) }
     return storage_snapshots.first unless storage_snapshots.length > 1
     return storage_snapshots

data/lib/cimi/server.rb

@@ -31,7 +31,7 @@ module CIMI
   class API < Collections::Base
 
     # Enable logging
-    use Rack::CommonLogger
+    use Deltacloud[:cimi].logger
     use Rack::Date
     use Rack::ETag
     use Rack::MatrixParams

data/lib/deltacloud/api.rb

@@ -16,14 +16,58 @@
 require 'rubygems'
 require 'ostruct'
 
-load File.join(File.dirname(__FILE__), 'core_ext.rb')
+require 'require_relative' if RUBY_VERSION < '1.9'
+
+require_relative 'core_ext'
 require_relative 'models'
 require_relative 'drivers'
 require_relative 'helpers/driver_helper'
 
+module TestPoller
+  # This method will pool the resource until condition is true
+  # Will raise 'Timeout' when it reach retry count
+  #
+  # default opts[:retries] => 10
+  # default opts[:time_between_retry] => 10 (seconds)
+  # default opts[:timeout] => 60 (seconds) -> single request timeout
+  #
+  # opts[:before] => Proc -> executed 'before' making each request
+  # opts[:after] => Proc -> executed 'after' making each request
+  #
+  def wait_for!(driver, opts={}, &block)
+    opts[:retries] ||= 10
+    opts[:time_between_retry] ||= 10
+    opts[:timeout] ||= 60
+    opts[:method] ||= self.class.name.downcase.to_sym
+    opts[:retries].downto(0) do |r|
+      result = begin
+        timeout(opts[:timeout]) do
+          if opts[:before]
+            new_instance = opts[:before].call(r) { driver.send(opts[:method], :id => self.id) }
+          else
+            new_instance = driver.send(opts[:method], :id => self.id)
+          end
+          ((yield new_instance) == true) ? new_instance : false
+        end
+      rescue Timeout::Error
+        false
+      ensure
+        opts[:after].call(r) if opts[:after]
+      end
+      return result unless result == false
+      sleep(opts[:time_between_retry])
+    end
+    raise Timeout::Error
+  end
+end
+
+class Instance; include TestPoller; end
+class Image; include TestPoller; end
+class StorageSnapshot; include TestPoller; end
+
 module Deltacloud
 
-  API_VERSION = '1.0.0'
+  API_VERSION = '1.0.2'
 
   def self.drivers
     Drivers.driver_config
@@ -57,7 +101,15 @@ module Deltacloud
     end
 
     def providers
-      Deltacloud.drivers[current_driver.to_sym]
+      if backend.respond_to? :providers
+        backend.providers(@credentials)
+      else
+        Deltacloud.drivers[current_driver.to_sym]
+      end
+    end
+
+    def provider(opts={})
+      providers.find { |p| p.id == opts[:id] }
     end
 
     def method_missing(name, *args)

data/lib/deltacloud/collections/addresses.rb

@@ -16,7 +16,7 @@
 module Deltacloud::Collections
   class Addresses < Base
 
-    check_capability :for => lambda { |m| driver.respond_to? m }
+    set :capability, lambda { |m| driver.respond_to? m }
 
     get route_for('/addresses/:id/associate') do
       @address = driver.address(credentials, params )

data/lib/deltacloud/collections/buckets.rb

@@ -18,7 +18,8 @@ module Deltacloud::Collections
 
     include Deltacloud::Features
 
-    check_capability :for => lambda { |m| driver.respond_to? m }
+    set :capability, lambda { |m| driver.respond_to? m }
+
     check_features :for => lambda { |c, f| driver.class.has_feature?(c, f) }
 
     new_route_for :buckets
@@ -48,7 +49,7 @@ module Deltacloud::Collections
       end
     end
 
-    put route_for ("/buckets/:bucket/:blob") do
+    put route_for("/buckets/:bucket/:blob") do
       if(env["BLOB_SUCCESS"]) #ie got a 200ok after putting blob
         content_type = env["CONTENT_TYPE"]
         content_type ||=  ""
@@ -57,7 +58,7 @@ module Deltacloud::Collections
         respond_to do |format|
           format.xml { haml :"blobs/show" }
           format.html { haml :"blobs/show" }
-          format.json { convert_to_json(:blob, @blob) }
+          format.json { xml_to_json 'blobs/show' }
         end
       elsif(env["BLOB_FAIL"])
         report_error(500) #OK?
@@ -76,7 +77,7 @@ module Deltacloud::Collections
         respond_to do |format|
           format.xml { haml :"blobs/show" }
           format.html { haml :"blobs/show" }
-          format.json { convert_to_json(:blob, @blob) }
+          format.json { xml_to_json 'blobs/show' }
         end
       end
     end
@@ -95,7 +96,7 @@ module Deltacloud::Collections
           response['Location'] = bucket_url(@bucket.id)
           respond_to do |format|
             format.xml  { haml :"buckets/show" }
-            format.json { convert_to_json(:bucket, @bucket) }
+            format.json { xml_to_json('buckets/show') }
             format.html do
               redirect bucket_url(@bucket.id) if @bucket and @bucket.id
               redirect buckets_url
@@ -125,7 +126,7 @@ module Deltacloud::Collections
               respond_to do |format|
                 format.xml { haml :"blobs/show" }
                 format.html { haml :"blobs/show" }
-                format.json { convert_to_json(:blob, @blob) }
+                format.json { xml_to_json 'blobs/show' }
               end
             else
               report_error(404)
@@ -154,10 +155,11 @@ module Deltacloud::Collections
               end
             end
             @blob = driver.create_blob(credentials, bucket_id, blob_id, blob_data, user_meta)
+            status 201
             respond_to do |format|
               format.xml { haml :"blobs/show" }
               format.html { haml :"blobs/show"}
-              format.json {convert_to_json(:blob, @blob)}
+              format.json { xml_to_json 'blobs/show' }
             end
           end
         end
@@ -187,7 +189,7 @@ module Deltacloud::Collections
               respond_to do |format|
                 format.xml { haml :"blobs/show" }
                 format.html { haml :"blobs/show" }
-                format.json { convert_to_json(:blob, @blob) }
+                format.json { xml_to_json 'blobs/show' }
               end
             elsif(env["BLOB_FAIL"])
               report_error(500) #OK?
@@ -206,7 +208,7 @@ module Deltacloud::Collections
               respond_to do |format|
                 format.xml { haml :"blobs/show" }
                 format.html { haml :"blobs/show" }
-                format.json { convert_to_json(:blob, @blob) }
+                format.json { xml_to_json 'blobs/show' }
               end
             end
           end
@@ -256,7 +258,7 @@ module Deltacloud::Collections
             @blob = driver.blob(credentials, { :id => params[:blob_id], 'bucket' => params[:id]})
             if @blob
               params['content_length'] = @blob.content_length
-              params['content_type'] = @blob.content_type
+              params['content_type'] = (@blob.content_type.nil? || @blob.content_type == "")? "application/octet-stream" : @blob.content_type
               params['content_disposition'] = "attachment; filename=#{@blob.id}"
               BlobStream.call(self, credentials, params)
             else

data/lib/deltacloud/collections/firewalls.rb

@@ -16,7 +16,8 @@
 module Deltacloud::Collections
   class Firewalls < Base
 
-    check_capability :for => lambda { |m| driver.respond_to? m }
+    set :capability, lambda { |m| driver.respond_to? m }
+
     check_features :for => lambda { |c, f| driver.class.has_feature?(c, f) }
 
     get route_for('/firewalls/:id/new_rule') do

data/lib/deltacloud/collections/hardware_profiles.rb

@@ -16,7 +16,7 @@
 module Deltacloud::Collections
   class HardwareProfiles < Base
 
-    check_capability :for => lambda { |m| !driver.class.send(m).empty? }
+    set :capability, lambda { |m| !driver.class.send(m).empty? }
 
     collection :hardware_profiles do
 

data/lib/deltacloud/collections/images.rb

@@ -18,12 +18,12 @@ module Deltacloud::Collections
 
     include Deltacloud::Features
 
-    check_capability :for => lambda { |m| driver.respond_to? m }
     check_features :for => lambda { |c, f| driver.class.has_feature?(c, f) }
+    set :capability, lambda { |m| driver.respond_to? m }
 
     new_route_for :images do
+      halt 404 unless params[:instance_id]
       @instance = Instance.new( :id => params[:instance_id] )
-      status 404 unless @instance
     end
 
     collection :images do