deltacloud-core 1.0.5 → 1.1.0

data/lib/cimi/models/address.rb

@@ -51,7 +51,7 @@ class CIMI::Model::Address < CIMI::Model::Base
 
   def self.create(request_body, context, type)
     input = (type == :xml)? XmlSimple.xml_in(request_body, {"ForceArray"=>false, "NormaliseSpace"=>2}) : JSON.parse(request_body)
-    if input["addressTemplate"]["href"] #by reference
+    if input['addressTemplate'] and input["addressTemplate"]["href"] #by reference
       address_template = CIMI::Model::AddressTemplate.find(context.href_id(input["addressTemplate"]["href"], :address_templates), context)
     else
       case type
@@ -64,27 +64,32 @@ class CIMI::Model::Address < CIMI::Model::Base
     end
     params = {:name=>input["name"], :description=>input["description"], :address_template=>address_template, :env=>context }
     raise CIMI::Model::BadRequest.new("Bad request - missing required parameters. Client sent: #{request_body} which produced #{params.inspect}")  if params.has_value?(nil)
-    context.driver.create_address(context.credentials, params)
+    address = context.driver.create_address(context.credentials, params)
+    store_attributes_for(address, input)
+    from_address(address, context)
   end
 
   def self.delete!(id, context)
     context.driver.delete_address(context.credentials, id)
+    delete_attributes_for(::Address.new(:id => id))
   end
 
   private
 
   def self.from_address(address, context)
+    stored_attributes = load_attributes_for(address)
     self.new(
-      :name => address.id,
+      :name => stored_attributes[:name] || address.id,
       :id => context.address_url(address.id),
-      :description => "Address #{address.id}",
+      :description => stored_attributes[:description] || "Address #{address.id}",
       :ip => address.id,
       :allocation => "dynamic", #or "static"
-      :default_gateway => "unkown", #wtf
+      :default_gateway => "unknown", #wtf
       :dns => "unknown", #wtf
       :protocol => protocol_from_address(address.id),
       :mask => "unknown",
       :resource => (address.instance_id) ? {:href=> context.machine_url(address.instance_id)} : nil,
+      :property => stored_attributes[:property],
       :network => nil #unknown
       #optional:
       #:hostname =>

data/lib/cimi/models/address_template.rb

@@ -39,16 +39,80 @@ class CIMI::Model::AddressTemplate < CIMI::Model::Base
 
   def self.find(id, context)
     if id==:all
-      context.driver.address_templates(context.credentials, {:env=>context})
+      if context.driver.respond_to? :address_templates
+        context.driver.address_templates(context.credentials, {:env=>context})
+      else
+        current_db.address_teplates.map { |t| from_db(t, context) }
+      end
     else
-      context.driver.address_templates(context.credentials, {:id=>id, :env=>context})
+      if context.driver.respond_to? :address_template
+        context.driver.address_template(context.credentials, id, :env=>context)
+      else
+        template = current_db.address_templates_dataset.first(:id => id)
+        raise CIMI::Model::NotFound unless template
+        from_db(template, context)
+      end
     end
   end
 
-  def self.create(request_body, context, type)
+  def self.create_from_json(body, context)
+    json = JSON.parse(body)
+    new_template = current_db.add_address_template(
+      :name => json['name'],
+      :description => json['description'],
+      :hostname => json['hostname'],
+      :ip => json['ip'],
+      :allocation => json['allocation'],
+      :default_gateway => json['default_gateway'],
+      :dns => json['dns'],
+      :protocol => json['protocol'],
+      :mask => json['mask'],
+      :ent_properties => json['properties'].to_json
+    )
+    from_db(new_template, context)
+  end
+
+  def self.create_from_xml(body, context)
+    xml = XmlSimple.xml_in(body)
+    xml['property'] ||= []
+    new_template = current_db.add_address_template(
+      :name => xml['name'].first,
+      :description => xml['description'].first,
+      :ip => xml['ip'].first,
+      :hostname => xml['hostname'].first,
+      :allocation => xml['allocation'].first,
+      :default_gateway => xml['default_gateway'].first,
+      :dns => xml['dns'].first,
+      :protocol => xml['protocol'].nil? ? nil : xml['protocol'].first,
+      :mask => xml['mask'].first,
+      :ent_properties => JSON::dump(xml['property'].inject({}) { |r, p| r[p['key']]=p['content']; r })
+    )
+    from_db(new_template, context)
   end
 
   def self.delete!(id, context)
+    current_db.address_templates.first(:id => id).destroy
+  end
+
+  private
+
+  def self.from_db(model, context)
+    self.new(
+      :id => context.address_template_url(model.id),
+      :name => model.name,
+      :description => model.description,
+      :ip => model.ip,
+      :hostname => model.hostname,
+      :allocation => model.allocation,
+      :default_gateway => model.default_gateway,
+      :dns => model.dns,
+      :protocol => model.protocol,
+      :mask => model.mask,
+      :property => JSON::parse(model.ent_properties),
+      :operations => [
+        { :href => context.destroy_address_template_url(model.id), :rel => 'http://schemas.dmtf.org/cimi/1/action/delete' }
+      ]
+    )
   end
 
 end

data/lib/cimi/models/base.rb

@@ -14,7 +14,6 @@
 # under the License.
 
 require 'xmlsimple'
-require 'json'
 
 # The base class for any CIMI object that we either read from a request or
 # write as a response. This class handles serializing/deserializing XML and
@@ -73,7 +72,7 @@ require 'json'
 module CIMI::Model
 
   def self.register_as_root_entity!(klass, opts = {})
-    @root_entities ||= []
+    @root_entities ||= [CIMI::Model::CloudEntryPoint]
     @root_entities << klass
     name = klass.name.split("::").last.pluralize
     unless CIMI::Model::CloudEntryPoint.href_defined?(name)
@@ -109,7 +108,6 @@ class CIMI::Model::Resource
       clone_base_schema unless base_schema_cloned?
       member_name = model.name.split("::").last
       if ::Struct.const_defined?("CIMI_#{member_name}")
-        puts "Removing struct"
         ::Struct.send(:remove_const, "CIMI_#{member_name}")
       end
       member_symbol = member_name.underscore.pluralize.to_sym
@@ -182,7 +180,7 @@ class CIMI::Model::Resource
   #
   def initialize(values = {})
     names = self.class.schema.attribute_names
-    @attribute_values = names.inject({}) do |hash, name|
+    @attribute_values = names.inject(OrderedHash.new) do |hash, name|
       hash[name] = self.class.schema.convert(name, values[name])
       hash
     end
@@ -270,7 +268,10 @@ class CIMI::Model::Resource
   end
 end
 
+require_relative '../helpers/database_helper'
+
 class CIMI::Model::Base < CIMI::Model::Resource
+  extend Deltacloud::Helpers::Database
   #
   # Common attributes for all resources
   #
@@ -280,9 +281,11 @@ class CIMI::Model::Base < CIMI::Model::Resource
 
   def filter_attributes(attr_list)
     attrs = attr_list.inject({}) do |result, attr|
-      result[attr] = self.send(attr) if self.respond_to?(attr)
+      attr = attr.to_s.underscore
+      result[attr.to_sym] = self.send(attr) if self.respond_to?(attr)
       result
     end
     self.class.new(attrs)
   end
+
 end

data/lib/cimi/models/cloud_entry_point.rb

@@ -15,6 +15,9 @@
 
 class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
 
+  resource_attr :driver, :required => true
+  resource_attr :provider, :required => true
+
   # All possible CIMI collections, in the order in which they should appear
   # in the CEP
   COLLECTIONS = [ "resourceMetadata", "systems", "systemTemplates",
@@ -38,8 +41,10 @@ class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
     self.new(entities(context).merge({
       :name => context.driver.name,
       :description => "Cloud Entry Point for the Deltacloud #{context.driver.name} driver",
+      :driver => context.driver.name,
+      :provider => context.current_provider,
       :id => context.cloudEntryPoint_url,
-      :base_uri => context.base_uri,
+      :base_uri => context.base_uri + "/",
       :created => Time.now.xmlschema
     }))
   end

data/lib/cimi/models/collection.rb

@@ -116,14 +116,19 @@ module CIMI::Model
       def list(context)
         entries = find(:all, context)
         desc = "#{self.name.split("::").last} Collection for the #{context.driver.name.capitalize} driver"
+        acts_as_root_entity unless collection_class
         id = context.send("#{collection_class.entry_name}_url")
         ops = []
-        create = "create_#{collection_class.entry_name.to_s.singularize}_url"
-        if context.respond_to?(create)
-          url = context.send(create)
+        cimi_entity = collection_class.entry_name.to_s.singularize
+        cimi_create = "create_#{cimi_entity}_url"
+        dcloud_create = context.deltacloud_create_method_for(cimi_entity)
+        if(context.respond_to?(cimi_create) &&
+           context.driver.respond_to?(dcloud_create)) ||
+             provides?(cimi_entity)
+          url = context.send(cimi_create)
           ops << { :rel => "add", :href => url }
         end
-        collection_class.new(:id => id, :name => 'default',
+        collection_class.new(:id => id,
                              :count => entries.size,
                              :entries => entries,
                              :operations => ops,

data/lib/cimi/models/disk.rb

@@ -57,7 +57,12 @@ class CIMI::Model::Disk < CIMI::Model::Base
   def self.collection_for_instance(instance_id, context)
     instance = context.driver.instance(context.credentials, :id => instance_id)
     disks = find(instance, nil, context)
-    CIMI::Model::DiskCollection.new(
+    unless CIMI::Model.const_defined?('DiskCollection')
+      collection_class = CIMI::Model::Collection.generate(self)
+    else
+      collection_class = CIMI::Model::DiskCollection
+    end
+    collection_class.new(
       :id => context.url("/machines/#{instance_id}/disks"),
       :name => 'default',
       :count => disks.size,

data/lib/cimi/models/errors.rb

@@ -33,6 +33,14 @@ module CIMI::Model
     end
   end
 
+  class UnsupportedMediaType < StandardError
+    attr_accessor :code
+    def initialize(msg="")
+      super(msg)
+      self.code=415
+    end
+  end
+
   class NotImplemented < StandardError
     attr_accessor :code
 

data/lib/cimi/models/machine.rb

@@ -17,6 +17,11 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   acts_as_root_entity
 
+  resource_attr :realm, :required => false,
+    :constraints => lambda { |c| c.driver.realms(c.credentials).map { |r| r.id } }
+
+  resource_attr :machine_image, :required => false, :type => :href
+
   text :state
   text :cpu
 
@@ -48,38 +53,60 @@ class CIMI::Model::Machine < CIMI::Model::Base
   def self.create_from_json(body, context)
     json = JSON.parse(body)
     machine_template = json['machineTemplate']
-    hardware_profile_id = machine_template['machineConfig']["href"].split('/').last
-    image_id = machine_template['machineImage']["href"].split('/').last
+    if !machine_template['href'].nil?
+      template = current_db.machine_templates.first(:id => machine_template['href'].split('/').last)
+      raise 'Could not find the MachineTemplate' if template.nil?
+      hardware_profile_id = template.machine_config.split('/').last
+      image_id = template.machine_image.split('/').last
+    else
+      hardware_profile_id = machine_template['machineConfig']["href"].split('/').last
+      image_id = machine_template['machineImage']["href"].split('/').last
+      if machine_template.has_key? 'credential'
+        additional_params[:keyname] = machine_template['credential']["href"].split('/').last
+      end
+    end
+
     additional_params = {}
     additional_params[:name] = json['name'] if json['name']
-    if machine_template.has_key? 'credential'
-      additional_params[:keyname] = machine_template['credential']["href"].split('/').last
-    end
     instance = context.driver.create_instance(context.credentials, image_id, {
       :hwp_id => hardware_profile_id
     }.merge(additional_params))
+
+    # Store attributes that are not supported by the backend cloud to local
+    # database:
+    store_attributes_for(instance, json)
     from_instance(instance, context)
   end
 
   def self.create_from_xml(body, context)
     xml = XmlSimple.xml_in(body)
-    machine_template = xml['machineTemplate'][0]
-    hardware_profile_id = machine_template['machineConfig'][0]["href"].split('/').last
-    image_id = machine_template['machineImage'][0]["href"].split('/').last
+    if xml['machineTemplate'][0]['href']
+      template = current_db.machine_templates_dataset.first(:id => xml['machineTemplate'][0]['href'].split('/').last)
+      hardware_profile_id = template.machine_config.split('/').last
+      image_id = template.machine_image.split('/').last
+    else
+      machine_template = xml['machineTemplate'][0]
+      hardware_profile_id = machine_template['machineConfig'].first["href"].split('/').last
+      image_id = machine_template['machineImage'].first["href"].split('/').last
+      if machine_template.has_key? 'credential'
+        additional_params[:keyname] = machine_template['credential'][0]["href"].split('/').last
+      end
+    end
     additional_params = {}
     additional_params[:name] = xml['name'][0] if xml['name']
-    if machine_template.has_key? 'credential'
-      additional_params[:keyname] = machine_template['credential'][0]["href"].split('/').last
-    end
     instance = context.driver.create_instance(context.credentials, image_id, {
       :hwp_id => hardware_profile_id
     }.merge(additional_params))
-    from_instance(instance, context)
+
+    # Store attributes that are not supported by the backend cloud to local
+    # database:
+    entity = store_attributes_for(instance, xml)
+    from_instance(instance, context, entity.to_hash)
   end
 
   def perform(action, context, &block)
     begin
-      if context.driver.send(:"#{action.name}_instance", context.credentials, self.name)
+      if context.driver.send(:"#{action.name}_instance", context.credentials, self.id.split("/").last)
         block.callback :success
       else
         raise "Operation failed to execute on given Machine"
@@ -90,42 +117,38 @@ class CIMI::Model::Machine < CIMI::Model::Base
   end
 
   def self.delete!(id, context)
+    delete_attributes_for Instance.new(:id => id)
     context.driver.destroy_instance(context.credentials, id)
   end
 
-  def self.create_resource_metadata(context)
-    cimi_resource = self.name.split("::").last
-    metadata = CIMI::Model::ResourceMetadata.metadata_from_deltacloud_features(cimi_resource, :instances, context)
-    unless metadata.includes_attribute?(:name)
-      metadata.attributes << {:name=>"name", :required=>"false",
-                   :constraints=>"Determined by the cloud provider", :type=>"xs:string"}
-    end
-    metadata
-  end
-
-  def self.attach_volumes(volumes, context)
-    volumes.each do |vol|
-      context.driver.attach_storage_volume(context.credentials,
-      {:id=>vol[:volume].name, :instance_id=>context.params[:id], :device=>vol[:attachment_point]})
-    end
-    self.find(context.params[:id], context)
+  #returns the newly attach machine_volume
+  def self.attach_volume(volume, location, context)
+    context.driver.attach_storage_volume(context.credentials,
+     {:id=>volume, :instance_id=>context.params[:id], :device=>location})
+    CIMI::Model::MachineVolume.find(context.params[:id], context, volume)
   end
 
-  def self.detach_volumes(volumes, context)
-    volumes.each do |vol|
-      context.driver.detach_storage_volume(context.credentials, {:id=>vol[:volume].name, :instance_id => context.params[:id]})
-    end
-    self.find(context.params[:id], context)
+  #returns the machine_volume_collection for the given machine
+  def self.detach_volume(volume, location, context)
+    context.driver.detach_storage_volume(context.credentials,
+     {:id=>volume, :instance_id=>context.params[:id], :device=>location})
+    CIMI::Model::MachineVolume.collection_for_instance(context.params[:id], context)
   end
 
   private
-  def self.from_instance(instance, context)
+  def self.from_instance(instance, context, stored_attributes=nil)
     cpu =  memory = (instance.instance_profile.id == "opaque")? "n/a" : nil
     machine_conf = CIMI::Model::MachineConfiguration.find(instance.instance_profile.name, context)
+    stored_attributes ||= load_attributes_for(instance)
+    if stored_attributes[:property]
+      stored_attributes[:property].merge!(convert_instance_properties(instance, context))
+    else
+      stored_attributes[:property] = convert_instance_properties(instance, context)
+    end
     machine_spec = {
       :name => instance.name,
-      :description => "Instance #{instance.name}",
-      :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time).xmlschema,
+      :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time.to_s).xmlschema,
+      :description => "No description set for Machine #{instance.name}",
       :id => context.machine_url(instance.id),
       :state => convert_instance_state(instance.state),
       :cpu => cpu || convert_instance_cpu(instance.instance_profile, context),
@@ -133,14 +156,16 @@ class CIMI::Model::Machine < CIMI::Model::Base
       :disks => { :href => context.machine_url(instance.id)+"/disks"},
       :volumes => { :href=>context.machine_url(instance.id)+"/volumes"},
       :operations => convert_instance_actions(instance, context),
-      :property => convert_instance_properties(instance, context)
-    }
+      :property => stored_attributes
+    }.merge(stored_attributes)
     if context.expand? :disks
       machine_spec[:disks] = CIMI::Model::Disk.find(instance, machine_conf, context, :all)
     end
     if context.expand? :volumes
       machine_spec[:volumes] = CIMI::Model::MachineVolume.find(instance.id, context, :all)
     end
+    machine_spec[:realm] = instance.realm_id if instance.realm_id
+    machine_spec[:machine_image] = { :href => context.machine_image_url(instance.image_id) } if instance.image_id
     machine = self.new(machine_spec)
     machine
   end
@@ -195,9 +220,10 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   def self.convert_instance_actions(instance, context)
     actions = instance.actions.collect do |action|
-      action = :destroy if action == :delete # In CIMI destroy operation become delete
-      action = :restart if action == :reboot  # In CIMI reboot operation become restart
-      { :href => context.send(:"#{action}_machine_url", instance.id), :rel => "http://schemas.dmtf.org/cimi/1/action/#{action}" }
+      action = :restart if action == :reboot
+      name = action
+      name = :delete if action == :destroy # In CIMI destroy operation become delete
+      { :href => context.send(:"#{action}_machine_url", instance.id), :rel => "http://schemas.dmtf.org/cimi/1/action/#{name}" }
     end
     actions <<  { :href => context.send(:"machine_images_url"), :rel => "http://schemas.dmtf.org/cimi/1/action/capture" } if instance.can_create_image?
     actions

data/lib/cimi/models/machine_configuration.rb

@@ -52,11 +52,11 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
       :name => profile.name,
       :description => "Machine Configuration with #{memory} KiB "+
         "of memory and #{cpu} CPU",
-      :cpu => ( cpu if cpu ) ,
+      :cpu => ( cpu.to_i.to_s if cpu ) ,
       :created => Time.now.xmlschema,  # FIXME: DC hardware_profile has no mention about created_at
       :memory => (memory if memory),
       :disks => (  [ { :capacity => storage, :format => (profile.storage.respond_to?(:format) ? profile.storage.format : "unknown")  } ] if storage ), #no format attr for hwp - may be added if providers support...,
-      :id => context.machine_configuration_url(profile.name)
+      :id => context.machine_configuration_url(profile.id)
     }
     self.new(machine_hash)
   end