deltacloud-core 1.0.5 → 1.1.0

data/lib/deltacloud/models/firewall.rb

@@ -19,4 +19,16 @@ class Firewall < BaseModel
   attr_accessor :description
   attr_accessor :owner_id
   attr_accessor :rules
-end
+
+  def to_hash(context)
+    r = {
+      :id => self.id,
+      :name => name,
+      :description => description,
+      :owner_id => owner_id,
+      :rules => []
+    }
+    r[:rules] = rules.map { |rule| rule.to_hash(context) } if rules and !rules.empty?
+    r
+  end
+end

data/lib/deltacloud/models/firewall_rule.rb

@@ -22,4 +22,18 @@ class FirewallRule < BaseModel
   attr_accessor :direction #ingress egress
   attr_accessor :rule_action #Accept/Deny - initially added for FGCP
   attr_accessor :log_rule #log when rule triggered true/false - added for FGCP
+
+  def to_hash(context)
+    {
+      :id => self.id,
+      :allow_protocol => allow_protocol,
+      :port_from => port_from,
+      :port_to => port_to,
+      :sources => sources,
+      :direction => direction,
+      :rule_action => rule_action,
+      :log_rule => log_rule
+    }.delete_if { |k, v| v.nil? }
+  end
+
 end

data/lib/deltacloud/models/hardware_profile.rb

@@ -75,6 +75,7 @@ module Deltacloud
       return false unless p = property(prop)
       return true if p.kind == :range and (p.first..p.last).include?(v)
       return true if p.kind == :enum and p.values.include?(v)
+      return true if p.kind == :fixed and p.value == v
       false
     end
 
@@ -84,6 +85,15 @@ module Deltacloud
       }.compact
     end
 
+    def to_hash(context)
+      r = {
+        :id => self.id,
+        :name => name,
+      }
+      r.merge!({:properties => @properties}) if !@properties.empty?
+      r
+    end
+
     class Property
       attr_reader :name, :kind, :default
       # kind == :range
@@ -112,6 +122,10 @@ module Deltacloud
         @default = opts[:default] if opts[:default]
       end
 
+      def to_s
+        "#{@default}"
+      end
+
       def unit
         HardwareProfile.unit(name)
       end

data/lib/deltacloud/models/image.rb

@@ -25,4 +25,19 @@ class Image < BaseModel
   attr_accessor :hardware_profiles
   attr_accessor :creation_time
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :name => name,
+      :description => description,
+      :owner => owner_id,
+      :architecture => architecture,
+      :state => state,
+      :creation_time => creation_time,
+      :hardware_profiles => hardware_profiles.map { |p|
+        { :id => p.id, :href => context.hardware_profile_url(p.id), :rel => :hardware_profile }
+      }
+    }
+  end
+
 end

data/lib/deltacloud/models/instance.rb

@@ -38,6 +38,45 @@ class Instance < BaseModel
   attr_accessor :firewalls
   attr_accessor :storage_volumes
 
+  def to_hash(context)
+    r = {
+      :id => self.id,
+      :name => name,
+      :state => state,
+      :owner => owner_id,
+      :image => { :href => context.image_url(image_id), :id => image_id, :rel => :image },
+      :realm => { :href => context.realm_url(realm_id), :id => realm_id, :rel => :realm },
+      :actions => actions.compact.map { |a|
+        {
+          :href => context.send("#{a}_instance_url", self.id),
+          :rel => "#{a}",
+          :method => context.instance_action_method(a)
+        }
+      },
+      :instance_profile => {
+        :id => instance_profile.id,
+        :href => context.hardware_profile_url(instance_profile.id),
+        :rel => :hardware_profile,
+        :properties => instance_profile.overrides
+      },
+      :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)
+    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 => { :keyname => keyname }) if keyname
+    end
+    if context.driver.class.has_feature?(:instances, :authentication_password)
+      r.merge!(:authentication => { :user => username, :password => password }) if username
+    end
+    r
+  end
+
   def storage_volumes
     @storage_volumes || []
   end
@@ -51,7 +90,7 @@ class Instance < BaseModel
   end
 
   def hardware_profile=(profile)
-    instance_profile = profile
+    @instance_profile = profile
   end
 
   def initialize(init=nil)

data/lib/deltacloud/models/instance_address.rb

@@ -37,6 +37,15 @@ class InstanceAddress
     address
   end
 
+  def to_hash(context)
+    r = {
+      :address => address,
+      :type => address_type
+    }
+    r.merge!(:port => port) if !port.nil?
+    r
+  end
+
   def is_mac?
     address_type == :mac
   end

data/lib/deltacloud/models/key.rb

@@ -51,4 +51,19 @@ class Key < BaseModel
     "-----BEGIN RSA PRIVATE KEY-----\n"+pem_material+"-----END RSA PRIVATE KEY-----"
   end
 
+  def to_hash(context)
+    r = {
+      :id => self.id,
+      :credential_type => credential_type,
+      :username => username,
+      :password => password,
+      :state => state
+    }
+    r[:pem_rsa_key] = pem_rsa_key if pem_rsa_key
+    r[:fingerprint] = fingerprint if fingerprint
+    r[:username] = username if username
+    r[:password] = password if password
+    r
+  end
+
 end

data/lib/deltacloud/models/load_balancer.rb

@@ -27,10 +27,30 @@ class LoadBalancer < BaseModel
     @listeners << Listener.new(opts)
   end
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :realms => realms,
+      :listeners => listeners.map { |l| l.to_hash(context) },
+      :instances => instances.map { |i| i.to_hash(context) },
+      :public_addresses => public_addresses,
+      :created_at => created_at
+    }
+  end
+
   class Listener < BaseModel
     attr_accessor :protocol
     attr_accessor :load_balancer_port
     attr_accessor :instance_port
+
+    def to_hash(context)
+      {
+        :id => self.id,
+        :protocol => protocol,
+        :load_balancer_port => load_balancer_port,
+        :instance_port => instance_port
+      }
+    end
   end
 
 end

data/lib/deltacloud/models/metric.rb

@@ -29,12 +29,27 @@ class Metric < BaseModel
     self
   end
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :entity => entity,
+      :properties => properties.map { |p| p.to_hash(context) }
+    }
+  end
+
   class Property
     attr_accessor :name, :values
 
     def initialize(name, values=nil)
       @name, @values = name, values
     end
+
+    def to_hash(context)
+      {
+        :name => name,
+        :values => values
+      }
+    end
   end
 
 end

data/lib/deltacloud/models/provider.rb

@@ -24,4 +24,12 @@ class Provider < BaseModel
     super(opts)
   end
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :name => name,
+      :url => url
+    }
+  end
+
 end

data/lib/deltacloud/models/realm.rb

@@ -21,4 +21,13 @@ class Realm < BaseModel
   attr_accessor :limit
   attr_accessor :state
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :name => name,
+      :state => state,
+      :limit => limit
+    }
+  end
+
 end

data/lib/deltacloud/models/state_machine.rb

@@ -81,6 +81,14 @@ module Deltacloud
         transition
       end
 
+      def from(*states)
+        states.each do |s|
+          initial = @machine.state(s)
+          trans = initial.to self.name
+          trans.automatically
+        end
+      end
+
     end
 
     class Transition

data/lib/deltacloud/models/storage_snapshot.rb

@@ -21,9 +21,20 @@ class StorageSnapshot < BaseModel
   attr_accessor :state
   attr_accessor :storage_volume_id
   attr_accessor :created
+  attr_accessor :name
+  attr_accessor :description
 
   def is_completed?
     state == 'completed'
   end
 
+  def to_hash(context)
+    {
+      :id => self.id,
+      :state => state,
+      :storage_volume => { :id => storage_volume_id, :href => context.storage_volume_url(storage_volume_id), :rel => :storage_volume },
+      :created => created
+    }
+  end
+
 end

data/lib/deltacloud/models/storage_volume.rb

@@ -26,5 +26,29 @@ class StorageVolume < BaseModel
   attr_accessor :actions
   attr_accessor :name
   attr_accessor :kind
+  attr_accessor :description # openstack volumes have a display_description attr
+
+  def to_hash(context)
+    r = {
+      :id => self.id,
+      :name => name,
+      :description => description,
+      :state => state,
+      :created => created,
+      :realm => { :id => realm_id, :href => context.realm_url(realm_id), :rel => :realm },
+      :device => device,
+      :kind => kind,
+      :capacity => capacity,
+    }
+    r[:actions] = (actions || []).map { |a|
+      { :href => context.send("#{a}_storage_volume", self.id), :rel => a }
+    }
+    if instance_id
+      r[:instance] = { :id => instance_id, :href => context.instance_url(instance_id), :rel => :instance }
+    else
+      r[:instance] = {}
+    end
+    r
+  end
 
 end

data/lib/deltacloud/server.rb

@@ -14,8 +14,6 @@
 # under the License.
 
 require 'rubygems'
-require 'crack'
-require 'json'
 require 'yaml'
 require 'haml'
 require 'sinatra/base'
@@ -52,7 +50,7 @@ module Deltacloud
       @collections = driver.supported_collections(credentials)
       respond_to do |format|
         format.xml { haml :"api/show" }
-        format.json { xml_to_json :"api/show" }
+        format.json { collections_to_json(@collections) }
         format.html { haml :"api/show" }
       end
     end

data/lib/deltacloud/version.rb

@@ -15,5 +15,6 @@
 # under the License.
 
 module Deltacloud
-  API_VERSION = '1.0.5' unless defined?(API_VERSION)
+  API_VERSION = '1.1.0'
+  CIMI_API_VERSION = '1.0.1'
 end

data/lib/deltacloud_rack.rb

@@ -14,6 +14,7 @@
 # under the License.
 
 require 'require_relative' if RUBY_VERSION < '1.9'
+require 'json/pure'
 
 require_relative './deltacloud/core_ext'
 require_relative './sinatra/rack_logger'
@@ -71,7 +72,6 @@ module Deltacloud
       respond_to do |format|
         format.xml { haml :'index', :layout => false }
         format.html { haml :'index', :layout => false }
-        format.json { xml_to_json "index" }
       end
     end
   end

data/tests/cimi/db/database_helper_test.rb

@@ -0,0 +1,190 @@
+require 'rubygems'
+require 'require_relative' if RUBY_VERSION < '1.9'
+require 'minitest/autorun'
+
+require_relative 'db_helper.rb'
+require_relative '../spec_helper.rb'
+require_relative './../collections/common.rb'
+
+class DatabaseHelper
+  include Deltacloud::Helpers::Database
+end
+
+describe Deltacloud::Helpers::Database do
+  include Deltacloud::DatabaseTestHelper
+
+  before do
+    ENV['RACK_ENV'] = 'development'
+    @db = DatabaseHelper.new
+  end
+
+  it 'report if application is running under test environment' do
+    ENV['RACK_ENV'] = 'test'
+    @db.test_environment?.must_equal true
+    ENV['RACK_ENV'] = 'development'
+    @db.test_environment?.must_equal false
+  end
+
+  it 'report if given entity is provided by database' do
+    @db.provides?('machine_template').must_equal true
+    @db.provides?('machine').must_equal false
+  end
+
+  it 'reports the current provider' do
+    @db.current_provider.must_equal 'default'
+  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')
+  end
+
+  it 'must return entity for given model' do
+    provider = Deltacloud::Database::Provider
+    entity = Deltacloud::Database::Entity
+    @db.current_db.wont_be_nil
+
+    new_entity = @db.current_db.add_entity(
+      :name => 'testMachine1',
+      :description => 'testMachine1 description',
+      :ent_properties => JSON::dump(:key => 'value'),
+      :be_kind => 'instance',
+      :be_id => 'inst1'
+    )
+
+    check_entity_base_attrs new_entity, entity, @db.current_db
+
+    result = @db.get_entity(Instance.new(:id => 'inst1'))
+    result.must_equal new_entity
+
+    new_entity.destroy.wont_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
+
+    new_entity = @db.current_db.add_entity(
+      :name => 'testMachine1',
+      :description => 'testMachine1 description',
+      :ent_properties => JSON::dump(:key => 'value'),
+      :be_kind => 'instance',
+      :be_id => 'inst1'
+    )
+
+    check_entity_base_attrs new_entity, entity, @db.current_db
+
+    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)
+
+    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
+
+    new_entity = @db.current_db.add_entity(
+      :name => 'testMachine1',
+      :description => 'testMachine1 description',
+      :ent_properties => JSON::dump(:key => 'value'),
+      :be_kind => 'instance',
+      :be_id => 'inst1'
+    )
+
+    check_entity_base_attrs new_entity, entity, @db.current_db
+
+    result = @db.delete_attributes_for(Instance.new(:id => 'inst1'))
+    result.wont_equal false
+    result.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
+
+    mock_instance = Instance.new(:id => 'inst1')
+    mock_json = '
+{
+  "resourceURI": "http://schemas.dmtf.org/cimi/1/MachineCreate",
+  "name": "myDatabaseMachine",
+  "description": "This is a demo machine",
+  "properties": {
+    "foo": "bar",
+    "life": "is life"
+  },
+  "machineTemplate": {
+    "machineConfig": { "href": "http://localhost:3001/cimi/machine_configurations/m1-small" },
+    "machineImage": { "href": "http://localhost:3001/cimi/machine_images/img1" }
+  }
+}
+    '
+    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
+  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