deltacloud-core 1.1.0 → 1.1.1

data/lib/deltacloud/drivers/rackspace/rackspace_driver.rb

@@ -62,6 +62,8 @@ class RackspaceDriver < Deltacloud::BaseDriver
         )
       end
     end
+    profiles = hardware_profiles(credentials)
+    results.each { |img| img.hardware_profiles = profiles }
     filter_on( results, :id, opts )
   end
 

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -254,6 +254,7 @@ class RhevmDriver < Deltacloud::BaseDriver
       public_addresses << InstanceAddress.new(inst.vnc[:address], :port => inst.vnc[:port], :type => :vnc)
     end
 
+    can_create_image = state == 'STOPPED'
     # Remove 'destroy' operation from list of actions when RHEV-M instance
     # is suspended or paused.
     if state == 'PAUSED'
@@ -261,7 +262,6 @@ class RhevmDriver < Deltacloud::BaseDriver
       actions.delete(:destroy)
     else
       actions = instance_actions_for(state)
-      can_create_image = true
     end
 
     Instance.new(
@@ -277,7 +277,7 @@ class RhevmDriver < Deltacloud::BaseDriver
       :hardware_profile_id => profile.id,
       :public_addresses => public_addresses,
       :private_addresses => [],
-      :create_image => can_create_image || false
+      :create_image => can_create_image
     )
   end
 

data/lib/deltacloud/helpers/deltacloud_helper.rb

@@ -140,7 +140,9 @@ module Deltacloud::Helpers
     end
 
     def instance_action(name)
-      original_instance = driver.instance(credentials, :id => params[:id])
+      unless original_instance = driver.instance(credentials, :id => params[:id])
+        return report_error(403)
+      end
 
       # If original instance doesn't include called action
       # return with 405 error (Method is not Allowed)

data/lib/deltacloud/helpers/rabbit_helper.rb

@@ -64,7 +64,6 @@ module Sinatra::Rabbit
                          end
 
     helper_method_name += '_url'
-
     [Proc.new do
       define_method helper_method_name do |*args|
         if (opts = args.first).kind_of? Hash
@@ -76,7 +75,7 @@ module Sinatra::Rabbit
         else
           path = operation.full_path
         end
-        path.slice!(root_url)
+        path.slice!(root_url) if path.start_with?(root_url)
         url(path)
       end unless respond_to?(helper_method_name)
     end, helper_method_name]

data/lib/deltacloud/models/address.rb

@@ -28,6 +28,7 @@ class Address < BaseModel
   def to_hash(context)
     r = {
       :id => self.id,
+      :href => context.address_url(self.id),
       :associated => associated?
     }
     r[:instance_id] = instance_id if associated?

data/lib/deltacloud/models/blob.rb

@@ -27,6 +27,7 @@ class Blob < BaseModel
   def to_hash(context)
     {
       :id => self.id,
+      :href => context.bucket_url(bucket) + '/' + self.id,
       :bucket => { :rel => :bucket, :href => context.bucket_url(bucket), :id => bucket },
       :content_length => content_length,
       :content_type => content_type,

data/lib/deltacloud/models/bucket.rb

@@ -27,6 +27,7 @@ class Bucket < BaseModel
   def to_hash(context)
     {
       :id => self.id,
+      :href => context.bucket_url(self.id),
       :name => name,
       :size => size,
       :blob_list => blob_list.map { |b| { :rel => :blob, :href => context.url("/buckets/#{self.id}/#{b}"), :id => b }}

data/lib/deltacloud/models/firewall.rb

@@ -23,6 +23,7 @@ class Firewall < BaseModel
   def to_hash(context)
     r = {
       :id => self.id,
+      :href => context.firewall_url(self.id),
       :name => name,
       :description => description,
       :owner_id => owner_id,

data/lib/deltacloud/models/hardware_profile.rb

@@ -31,7 +31,7 @@ module Deltacloud
     class << self
       def property(prop)
         define_method(prop) do |*args|
-          values, opts, *ignored = *args
+          values, opts, _ = *args
           unless values.nil?
             @properties[prop] = Property.new(prop, values, opts || {})
           end
@@ -46,6 +46,7 @@ module Deltacloud
     property :architecture
     property :memory
     property :storage
+    property :root_type
 
     def initialize(profile_id, &block)
       @properties   = {}
@@ -88,6 +89,7 @@ module Deltacloud
     def to_hash(context)
       r = {
         :id => self.id,
+        :href => context.hardware_profile_url(self.id),
         :name => name,
       }
       r.merge!({:properties => @properties}) if !@properties.empty?

data/lib/deltacloud/models/image.rb

@@ -24,15 +24,22 @@ class Image < BaseModel
   attr_accessor :state
   attr_accessor :hardware_profiles
   attr_accessor :creation_time
+  attr_accessor :root_type
+
+  def root_type
+    @root_type || 'transient'
+  end
 
   def to_hash(context)
     {
       :id => self.id,
+      :href => context.image_url(self.id),
       :name => name,
       :description => description,
       :owner => owner_id,
       :architecture => architecture,
       :state => state,
+      :root_type => root_type,
       :creation_time => creation_time,
       :hardware_profiles => hardware_profiles.map { |p|
         { :id => p.id, :href => context.hardware_profile_url(p.id), :rel => :hardware_profile }

data/lib/deltacloud/models/instance.rb

@@ -41,6 +41,7 @@ class Instance < BaseModel
   def to_hash(context)
     r = {
       :id => self.id,
+      :href => context.instance_url(self.id),
       :name => name,
       :state => state,
       :owner => owner_id,
@@ -53,7 +54,7 @@ class Instance < BaseModel
           :method => context.instance_action_method(a)
         }
       },
-      :instance_profile => {
+      :hardware_profile => {
         :id => instance_profile.id,
         :href => context.hardware_profile_url(instance_profile.id),
         :rel => :hardware_profile,
@@ -62,17 +63,25 @@ class Instance < BaseModel
       :public_addresses => public_addresses.map { |addr| addr.to_hash(context) },
       :private_addresses => private_addresses.map { |addr| addr.to_hash(context) }
     }
-    r.merge!(:launch_time => launch_time)
+    if context.driver.respond_to? :run_on_instance
+      r[:actions] << { :href => "#{context.run_instance_url(self.id)};id=#{self.id}", :rel => 'run', :method => 'post'}
+    end
+    if can_create_image?
+      r[:actions] << { :href => "#{context.create_image_url};instance_id=#{self.id}", :rel => 'create_image', :method => 'post'}
+    end
+    r.merge!(:create_time => launch_time) if launch_time
     r.merge!(:create_image => create_image) if create_image
     r.merge!(:firewalls => firewalls.map { |f| { :id => f, :href => context.firewall_url(f), :rel => :firewall }}) if firewalls
     if storage_volumes
       r.merge!(:storage_volumes => storage_volumes.map { |v| { :id => v.keys.first, :href => context.storage_volume_url(v.keys.first), :rel => :storage_volume }})
     end
     if context.driver.class.has_feature?(:instances, :authentication_key)
+      r.merge!(:authentication_type => 'key' )
       r.merge!(:authentication => { :keyname => keyname }) if keyname
     end
     if context.driver.class.has_feature?(:instances, :authentication_password)
-      r.merge!(:authentication => { :user => username, :password => password }) if username
+      r[:authentication] && username ? r[:authentication].merge!({ :user => username, :password => password }) :
+              (username ? r.merge!(:authentication => { :user => username, :password => password }) : nil)
     end
     r
   end

data/lib/deltacloud/models/key.rb

@@ -54,6 +54,7 @@ class Key < BaseModel
   def to_hash(context)
     r = {
       :id => self.id,
+      :href => context.key_url(self.id),
       :credential_type => credential_type,
       :username => username,
       :password => password,

data/lib/deltacloud/models/load_balancer.rb

@@ -30,6 +30,7 @@ class LoadBalancer < BaseModel
   def to_hash(context)
     {
       :id => self.id,
+      :href => context.load_balancer_url(self.id),
       :realms => realms,
       :listeners => listeners.map { |l| l.to_hash(context) },
       :instances => instances.map { |i| i.to_hash(context) },

data/lib/deltacloud/models/metric.rb

@@ -32,6 +32,7 @@ class Metric < BaseModel
   def to_hash(context)
     {
       :id => self.id,
+      :href => context.matric_url(self.id),
       :entity => entity,
       :properties => properties.map { |p| p.to_hash(context) }
     }

data/lib/deltacloud/models/realm.rb

@@ -20,14 +20,23 @@ class Realm < BaseModel
   attr_accessor :name
   attr_accessor :limit
   attr_accessor :state
+  attr_accessor :resource_types
+
+  def initialize(init=nil)
+    super(init)
+    self.resource_types ||= []
+  end
 
   def to_hash(context)
-    {
+    r = {
       :id => self.id,
+      :href => context.realm_url(self.id),
       :name => name,
       :state => state,
       :limit => limit
     }
+    r.merge!({:resource_types => resource_types}) if resource_types
+    r
   end
 
 end

data/lib/deltacloud/models/storage_snapshot.rb

@@ -31,6 +31,7 @@ class StorageSnapshot < BaseModel
   def to_hash(context)
     {
       :id => self.id,
+      :href => context.storage_snapshot_url(self.id),
       :state => state,
       :storage_volume => { :id => storage_volume_id, :href => context.storage_volume_url(storage_volume_id), :rel => :storage_volume },
       :created => created

data/lib/deltacloud/models/storage_volume.rb

@@ -31,6 +31,7 @@ class StorageVolume < BaseModel
   def to_hash(context)
     r = {
       :id => self.id,
+      :href => context.storage_volume_url(self.id),
       :name => name,
       :description => description,
       :state => state,
@@ -41,7 +42,7 @@ class StorageVolume < BaseModel
       :capacity => capacity,
     }
     r[:actions] = (actions || []).map { |a|
-      { :href => context.send("#{a}_storage_volume", self.id), :rel => a }
+      { :href => context.send("#{a}_storage_volume_url", self.id), :rel => a }
     }
     if instance_id
       r[:instance] = { :id => instance_id, :href => context.instance_url(instance_id), :rel => :instance }

data/lib/deltacloud/runner.rb

@@ -69,6 +69,7 @@ module Deltacloud
       def execute(command)
         @command = command
         config = ssh_config(@network, @credentials, @key)
+        username = (@credentials[:username]) ? @credentials[:username] : 'root'
         begin
           session = nil
 	  # Default timeout for connecting to an instance.
@@ -77,7 +78,7 @@ module Deltacloud
 	  # Please keep in mind that the HTTP request timeout is set to 60
 	  # seconds, so you need to fit into this time
           Timeout::timeout(20) do
-            session = Net::SSH.start(@network.ip, 'root', config)
+            session = Net::SSH.start(@network.ip, username, config)
           end
           session.open_channel do |channel|
             channel.on_data do |ch, data|

data/lib/deltacloud/server.rb

@@ -42,6 +42,7 @@ module Deltacloud
     helpers Sinatra::Rabbit::URLFor(Deltacloud.collections)
 
     set :config, Deltacloud[:deltacloud]
+    set :haml, :format => :xhtml
 
     get '/' do
       if params[:force_auth]

data/lib/deltacloud/version.rb

@@ -15,6 +15,6 @@
 # under the License.
 
 module Deltacloud
-  API_VERSION = '1.1.0'
+  API_VERSION = '1.1.1'
   CIMI_API_VERSION = '1.0.1'
 end

data/lib/deltacloud_rack.rb

@@ -68,6 +68,10 @@ module Deltacloud
 
     set :views, File.join(File.dirname(__FILE__), '..', 'views')
 
+    get '/robots.txt' do
+      send_file File.join('public', 'robots.txt')
+    end
+
     get '/' do
       respond_to do |format|
         format.xml { haml :'index', :layout => false }

data/tests/cimi/collections/machines_test.rb

@@ -72,6 +72,86 @@ describe CIMI::Collections::Machines do
     end
   end
 
+  describe '$filter' do
+
+    it 'should filter collection by name attribute' do
+      get root_url("/machines?$filter=name='MockUserInstance'")
+      status.must_equal 200
+      (xml/'Collection/Machine').wont_be_empty
+      (xml/'Collection/Machine').size.must_equal 1
+      xml.at('Collection/count').text.must_equal '1'
+      xml.at('Collection/Machine/name').text.must_equal 'MockUserInstance'
+    end
+
+    it 'should filter collection by reverse name attribute' do
+      get root_url("/machines?$filter=name!='MockUserInstance'")
+      status.must_equal 200
+      (xml/'Collection/Machine').wont_be_empty
+      (xml/'Collection/Machine').size.must_equal 1
+      xml.at('Collection/count').text.must_equal '1'
+      xml.at('Collection/Machine/name').text.must_equal 'Mock Instance With Profile Change'
+    end
+
+  end
+
+  describe '$select' do
+
+    it 'should return only selected attribute' do
+      get root_url('/machines?$select=name')
+      status.must_equal 200
+      (xml/'Collection/Machine/name').wont_be_empty
+      (xml/'Collection/Machine/name').first.text.wont_be_empty
+      xml.xpath("/c:Collection/c:Machine/*[not(self::c:name)]", NS).must_be_empty
+    end
+
+    it 'should support multiple selected attributes' do
+      get root_url('/machines?$select=name,description')
+      status.must_equal 200
+      (xml/'Collection/Machine/name').wont_be_empty
+      (xml/'Collection/Machine/name').first.text.wont_be_empty
+      (xml/'Collection/Machine/description').wont_be_empty
+      (xml/'Collection/Machine/description').first.text.wont_be_empty
+      xml.xpath("/c:Collection/c:Machine/*[not(self::c:name) and not(self::c:description)]", NS).must_be_empty
+    end
+
+    it 'should support select on non-expanded subcollection' do
+      get root_url('/machines?$select=disks')
+      xml.xpath("/c:Collection/c:Machine/*[not(self::c:disks)]", NS).must_be_empty
+      (xml/'Collection/Machine/disks').wont_be_empty
+      (xml/'Collection/Machine/disks').each do |d|
+        d[:href].wont_be_empty
+        d[:href].must_match(/^http/)
+        d.children.must_be_empty
+      end
+    end
+
+    def disks
+      (xml/'Collection/Machine/disks').wont_be_empty
+      (xml/'Collection/Machine/disks').each do |d|
+        d[:href].wont_be_empty
+        d[:href].must_match(/^http/)
+        d.at('id').wont_be_nil
+        d.at('count').wont_be_nil
+        d.at('Disk/id').wont_be_nil
+        d.at('Disk/description').wont_be_nil
+        d.at('Disk/capacity').wont_be_nil
+        d.at('Disk/created').wont_be_nil
+      end
+    end
+
+    it 'should support select on expanded subcollection' do
+      get root_url('/machines?$select=disks&$expand=disks')
+      xml.xpath("/c:Collection/c:Machine/*[not(self::c:disks)]", NS).must_be_empty
+      disks
+    end
+
+    it 'should support select on expanded subcollection and regular attribute' do
+      get root_url('/machines?$select=name,disks&$expand=disks')
+      xml.xpath("/c:Collection/c:Machine/*[not(self::c:disks) and not(self::c:name)]", NS).must_be_empty
+      disks
+    end
+  end
+
   it 'should not return non-existing machine' do
     get root_url '/machines/unknown-machine'
     status.must_equal 404

data/tests/cimi/db/database_helper_test.rb

@@ -13,9 +13,14 @@ end
 describe Deltacloud::Helpers::Database do
   include Deltacloud::DatabaseTestHelper
 
+  Provider = Deltacloud::Database::Provider
+  Entity = Deltacloud::Database::Entity
+  BaseModel = CIMI::Model::Base
+
   before do
     ENV['RACK_ENV'] = 'development'
     @db = DatabaseHelper.new
+    @prov = Provider::lookup
   end
 
   it 'report if application is running under test environment' do
@@ -35,97 +40,84 @@ describe Deltacloud::Helpers::Database do
   end
 
   it 'create provider when it does not exists' do
-    @db.current_db.must_be_kind_of Deltacloud::Database::Provider
-    @db.current_db.driver.must_equal 'mock'
-    @db.current_db.url.must_equal @db.current_provider
-    @db.current_db.must_respond_to :entities
-    @db.current_db.must_respond_to :machine_templates
-    @db.current_db.must_respond_to :address_templates
-    @db.current_db.must_respond_to :volume_configurations
-    @db.current_db.must_respond_to :volume_templates
-  end
-
-  it 'extract attributes both from JSON and XMLSimple' do
-    xml_simple_test = { 'property' => [ { 'key' => 'template', 'content' => "value"} ] }
-    json_test = { 'properties' => { 'template' => 'value' } }
-
-    @db.extract_attribute_value('property', xml_simple_test).must_equal('template' => 'value')
-    @db.extract_attribute_value('properties', json_test).must_equal('template' => 'value')
+    @prov.must_be_kind_of Deltacloud::Database::Provider
+    @prov.driver.must_equal 'mock'
+    @prov.url.must_equal @db.current_provider
+    @prov.must_respond_to :entities
+    @prov.must_respond_to :machine_templates
+    @prov.must_respond_to :address_templates
+    @prov.must_respond_to :volume_configurations
+    @prov.must_respond_to :volume_templates
   end
 
   it 'must return entity for given model' do
-    provider = Deltacloud::Database::Provider
-    entity = Deltacloud::Database::Entity
-    @db.current_db.wont_be_nil
+    @prov.wont_be_nil
 
-    new_entity = @db.current_db.add_entity(
+    new_entity = @prov.add_entity(
       :name => 'testMachine1',
       :description => 'testMachine1 description',
       :ent_properties => JSON::dump(:key => 'value'),
-      :be_kind => 'instance',
+      :be_kind => BaseModel.name,
       :be_id => 'inst1'
     )
 
-    check_entity_base_attrs new_entity, entity, @db.current_db
+    check_entity_base_attrs new_entity, Entity, @prov
 
-    result = @db.get_entity(Instance.new(:id => 'inst1'))
+    result = Entity.retrieve(BaseModel.new(:id => 'inst1'))
     result.must_equal new_entity
 
-    new_entity.destroy.wont_equal false
+    new_entity.destroy
+    result = Entity.retrieve(BaseModel.new(:id => 'inst1'))
+    result.exists?.must_equal false
   end
 
   it 'must load attributes for entity for given model' do
-    provider = Deltacloud::Database::Provider
-    entity = Deltacloud::Database::Entity
-    @db.current_db.wont_be_nil
+    @prov.wont_be_nil
 
-    new_entity = @db.current_db.add_entity(
+    new_entity = @prov.add_entity(
       :name => 'testMachine1',
       :description => 'testMachine1 description',
       :ent_properties => JSON::dump(:key => 'value'),
-      :be_kind => 'instance',
-      :be_id => 'inst1'
+      :be_kind => BaseModel.name,
+      :be_id => 'base1'
     )
 
-    check_entity_base_attrs new_entity, entity, @db.current_db
+    check_entity_base_attrs new_entity, Entity, @prov
 
-    result = @db.load_attributes_for(Instance.new(:id => 'inst1'))
-    result.must_be_kind_of Hash
-    result[:name].must_equal new_entity.name
-    result[:description].must_equal new_entity.description
-    result[:property].must_equal JSON::parse(new_entity.ent_properties)
+    result = Entity::retrieve(BaseModel.new(:id => 'base1'))
+    result.name.must_equal new_entity.name
+    result.description.must_equal new_entity.description
+    result.properties.must_equal new_entity.properties
 
     new_entity.destroy.wont_equal false
   end
 
   it 'must delete attributes for entity for given model' do
-    provider = Deltacloud::Database::Provider
-    entity = Deltacloud::Database::Entity
-    @db.current_db.wont_be_nil
+    @prov.wont_be_nil
 
-    new_entity = @db.current_db.add_entity(
+    new_entity = @prov.add_entity(
       :name => 'testMachine1',
       :description => 'testMachine1 description',
       :ent_properties => JSON::dump(:key => 'value'),
-      :be_kind => 'instance',
-      :be_id => 'inst1'
+      :be_kind => BaseModel.name,
+      :be_id => 'base1'
     )
 
-    check_entity_base_attrs new_entity, entity, @db.current_db
+    check_entity_base_attrs new_entity, Entity, @prov
 
-    result = @db.delete_attributes_for(Instance.new(:id => 'inst1'))
-    result.wont_equal false
-    result.exists?.must_equal false
+    base = BaseModel.new(:id => 'base1')
+    base.destroy
+    entity = Entity.retrieve(base)
+    entity.wont_be_nil
+    entity.exists?.must_equal false
   end
 
-  it 'must store JSON attributes for entity for given model' do
-    provider = Deltacloud::Database::Provider
-    entity = Deltacloud::Database::Entity
-    @db.current_db.wont_be_nil
+  it 'must store attributes for a given CIMI::Model' do
+    @prov.wont_be_nil
 
-    mock_instance = Instance.new(:id => 'inst1')
-    mock_json = '
+   json = '
 {
+  "id": "http://localhost:3001/cimi/machines/42",
   "resourceURI": "http://schemas.dmtf.org/cimi/1/MachineCreate",
   "name": "myDatabaseMachine",
   "description": "This is a demo machine",
@@ -139,52 +131,15 @@ describe Deltacloud::Helpers::Database do
   }
 }
     '
-    result = @db.store_attributes_for(mock_instance, JSON::parse(mock_json))
-    result.must_be_kind_of entity
-    check_entity_base_attrs result, entity, @db.current_db
-    load_result = @db.load_attributes_for(mock_instance)
-    load_result.must_be_kind_of Hash
-    load_result.wont_be_empty
-    load_result[:name].must_equal 'myDatabaseMachine'
-    load_result[:description].must_equal 'This is a demo machine'
-    load_result[:property].must_be_kind_of Hash
-    load_result[:property].wont_be_empty
-    load_result[:property]['foo'].must_equal 'bar'
-    load_result[:property]['life'].must_equal 'is life'
-    result.destroy.wont_equal false
+    machine = CIMI::Model::Machine.from_json(json)
+    machine.save
+
+    m2 = CIMI::Model::Machine.new(:id => machine.id)
+    m2.name.must_equal 'myDatabaseMachine'
+    m2.description.must_equal 'This is a demo machine'
+    m2.property.must_be_kind_of Hash
+    m2.property.size.must_equal 2
+    m2.property['foo'].must_equal 'bar'
+    m2.property['life'].must_equal 'is life'
   end
-
-  it 'must store XML attributes for entity for given model' do
-    provider = Deltacloud::Database::Provider
-    entity = Deltacloud::Database::Entity
-    @db.current_db.wont_be_nil
-
-    mock_instance = Instance.new(:id => 'inst1')
-    mock_xml = '
-<MachineCreate>
-  <name>myMachineXML123</name>
-  <description>Description of my new Machine</description>
-  <machineTemplate>
-    <machineConfig href="http://localhost:3001/cimi/machine_configurations/m1-small"/>
-    <machineImage href="http://localhost:3001/cimi/machine_images/img1"/>
-  </machineTemplate>
-  <property key="test">value</property>
-  <property key="foo">bar</property>
-</MachineCreate>
-    '
-    result = @db.store_attributes_for(mock_instance, XmlSimple.xml_in(mock_xml))
-    result.must_be_kind_of entity
-    check_entity_base_attrs result, entity, @db.current_db
-    load_result = @db.load_attributes_for(mock_instance)
-    load_result.must_be_kind_of Hash
-    load_result.wont_be_empty
-    load_result[:name].must_equal 'myMachineXML123'
-    load_result[:description].must_equal 'Description of my new Machine'
-    load_result[:property].must_be_kind_of Hash
-    load_result[:property].wont_be_empty
-    load_result[:property]['test'].must_equal 'value'
-    result.destroy.wont_equal false
-  end
-
-
 end