deltacloud-core 1.0.4 → 1.0.5

data/lib/cimi/models/cloud_entry_point.rb

@@ -15,15 +15,32 @@
 
 class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
 
+  # All possible CIMI collections, in the order in which they should appear
+  # in the CEP
+  COLLECTIONS = [ "resourceMetadata", "systems", "systemTemplates",
+            "machines" , "machineTemplates", "machineConfigs",
+            "machineImages", "credentials", "credentialTemplates",
+            "volumes", "volumeTemplates", "volumeConfigs", "volumeImages",
+            "networks", "networkTemplates", "networkConfigs", "networkPorts",
+            "networkPortTemplates", "networkPortConfigs",
+            "addresses", "addressTemplates", "forwardingGroups",
+            "forwardingGroupTemplates",
+            "jobs", "meters", "meterTemplates", "meterConfigs",
+            "eventLogs", "eventLogTemplates" ]
+
   text  :base_uri, :xml_name => "baseURI", :json_name => "baseURI"
 
+  COLLECTIONS.each do |coll|
+    href coll.underscore
+  end
+
   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.base_uri,
-      :created => Time.now
+      :created => Time.now.xmlschema
     }))
   end
 
@@ -39,6 +56,10 @@ class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
     end
   end
 
+  def entities
+    @attribute_values.clone.delete_if { |key, value| !value.respond_to? :href }
+  end
+
   private
 
   def self.href_defined?(resource)

data/lib/cimi/models/collection.rb

@@ -14,10 +14,10 @@
 # under the License.
 
 module CIMI::Model
-  class Collection < Base
+  class Collection < Resource
 
     class << self
-      attr_accessor :entry_name
+      attr_accessor :entry_name, :embedded
     end
 
     # Make sure the base schema gets cloned
@@ -27,11 +27,29 @@ module CIMI::Model
       if values[:entries]
         values[self.class.entry_name] = values.delete(:entries)
       end
+      values[self.class.entry_name] ||= []
       super(values)
     end
 
     def entries
-      self[entry_name]
+      self[self.class.entry_name]
+    end
+
+    # Prepare to serialize
+    def prepare
+      self.count = self.entries.size
+      if self.class.embedded
+        ["id", "href"].each { |a| self[a] = nil if self[a] == "" }
+        # Handle href and id, which are really just aliases of one another
+        unless self.href || self.id
+          raise "Collection #{self.class.name} must have one of id and href set"
+        end
+        if self.href && self.id && self.href != self.id
+          raise "id and href must be identical for collection #{self.class.name}, id = #{id.inspect}, href = #{href.inspect}"
+        end
+        self.href ||= self.id
+        self.id ||= self.href
+      end
     end
 
     def [](a)
@@ -44,18 +62,30 @@ module CIMI::Model
       super(a, v)
     end
 
+    def filter_attributes(attr_list)
+      self[self.class.entry_name] = entries.map do |e|
+        e.filter_attributes(attr_list)
+      end
+      self
+    end
+
     def self.xml_tag_name
       "Collection"
     end
 
-    def self.generate(model_class)
+    def self.generate(model_class, opts = {})
       model_name = model_class.name.split("::").last
+      scope = opts[:scope] || CIMI::Model
       coll_class = Class.new(CIMI::Model::Collection)
-      CIMI::Model.const_set(:"#{model_name}Collection", coll_class)
+      scope.const_set(:"#{model_name}Collection", coll_class)
       coll_class.entry_name = model_name.underscore.pluralize.to_sym
+      coll_class.embedded = opts[:embedded]
       entry_schema = model_class.schema
       coll_class.instance_eval do
+        text :id
+        scalar :href
         text :count
+        scalar :href if opts[:embedded]
         array self.entry_name, :schema => entry_schema, :xml_name => model_name
         array :operations do
           scalar :rel, :href
@@ -87,9 +117,16 @@ module CIMI::Model
         entries = find(:all, context)
         desc = "#{self.name.split("::").last} Collection for the #{context.driver.name.capitalize} driver"
         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)
+          ops << { :rel => "add", :href => url }
+        end
         collection_class.new(:id => id, :name => 'default',
                              :count => entries.size,
                              :entries => entries,
+                             :operations => ops,
                              :description => desc)
       end
     end

data/lib/cimi/models/credential.rb

@@ -55,7 +55,7 @@ class CIMI::Model::Credential < CIMI::Model::Base
       :password => key.is_password? ? key.password : key.fingerprint,
       :key => key.is_key? ? key.pem_rsa_key : nil,
       :id => context.credential_url(key.id),
-      :created => Time.now
+      :created => Time.now.xmlschema
     )
   end
 

data/lib/cimi/models/disk.rb

@@ -24,17 +24,46 @@ class CIMI::Model::Disk < CIMI::Model::Base
 
   def self.find(instance, machine_config, context, id=:all)
     if id == :all
-      storage_override = instance.instance_profile.overrides.find { |p, v| p == :storage }
-      capacity = storage_override.nil? ? machine_config.disks[0][:capacity] : context.to_kibibyte(storage_override[1].to_i, "MB")
-      name = instance.id+"_disk_#{capacity}" #assuming one disk for now...
-     [ self.new(
-       :id => context.machine_url(instance.id)+"/disks/#{name}",
-       :name => name,
-       :description => "DiskCollection for Machine #{instance.id}",
-       :created => instance.launch_time,
-       :capacity => capacity
-      ) ]
+      return machine_config.disks if machine_config
+
+      capacity = false
+
+      if instance
+        if instance.instance_profile.override? :storage
+          capacity = context.to_kibibyte(instance.instance_profile.storage, 'MB')
+        else
+          hw_profile = context.driver.hardware_profile(context.credentials, :id => instance.instance_profile.name)
+          if hw_profile.storage
+            capacity = context.to_kibibyte(hw_profile.storage.value, 'MB')
+          end
+        end
+
+        return [] unless capacity
+
+        name = instance.id+"_disk_#{capacity}" #assuming one disk for now...
+
+        [self.new(
+          :id => context.machine_url(instance.id)+"/disks/#{name}",
+          :name => name,
+          :description => "Disk for Machine #{instance.id}",
+          :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time).xmlschema,
+          :capacity => capacity
+        )]
+      end
     else
     end
   end
+
+  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(
+      :id => context.url("/machines/#{instance_id}/disks"),
+      :name => 'default',
+      :count => disks.size,
+      :description => "Disk collection for Machine #{instance_id}",
+      :entries => disks
+    )
+  end
+
 end

data/lib/cimi/models/machine.rb

@@ -22,13 +22,8 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   text :memory
 
-  href :event_log
-
-  href :disks
-
-  href :volumes
-
-  href :network_interfaces
+  collection :disks, :class => CIMI::Model::Disk
+  collection :volumes, :class => CIMI::Model::MachineVolume
 
   array :meters do
     scalar :href
@@ -52,9 +47,17 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   def self.create_from_json(body, context)
     json = JSON.parse(body)
-    hardware_profile_id = xml['machineTemplate']['machineConfig']["href"].split('/').last
-    image_id = xml['machineTemplate']['machineImage']["href"].split('/').last
-    instance = context.create_instance(context.credentials, image_id, { :hwp_id => hardware_profile_id })
+    machine_template = json['machineTemplate']
+    hardware_profile_id = machine_template['machineConfig']["href"].split('/').last
+    image_id = machine_template['machineImage']["href"].split('/').last
+    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))
     from_instance(instance, context)
   end
 
@@ -64,7 +67,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
     hardware_profile_id = machine_template['machineConfig'][0]["href"].split('/').last
     image_id = machine_template['machineImage'][0]["href"].split('/').last
     additional_params = {}
-    additional_params[:name] =xml['name'][0] if xml['name']
+    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
@@ -118,27 +121,39 @@ class CIMI::Model::Machine < CIMI::Model::Base
   private
   def self.from_instance(instance, context)
     cpu =  memory = (instance.instance_profile.id == "opaque")? "n/a" : nil
-    self.new(
-      :name => instance.id,
-      :description => instance.name,
-      :created => instance.launch_time,
+    machine_conf = CIMI::Model::MachineConfiguration.find(instance.instance_profile.name, context)
+    machine_spec = {
+      :name => instance.name,
+      :description => "Instance #{instance.name}",
+      :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time).xmlschema,
       :id => context.machine_url(instance.id),
       :state => convert_instance_state(instance.state),
       :cpu => cpu || convert_instance_cpu(instance.instance_profile, context),
       :memory => memory || convert_instance_memory(instance.instance_profile, context),
-      :disks => {:href => context.machine_url(instance.id)+"/disks"},
-      :network_interfaces => {:href => context.machine_url(instance.id+"/network_interfaces")},
+      :disks => { :href => context.machine_url(instance.id)+"/disks"},
+      :volumes => { :href=>context.machine_url(instance.id)+"/volumes"},
       :operations => convert_instance_actions(instance, context),
-      :volumes=>{:href=>context.machine_url(instance.id)+"/volumes"},
       :property => convert_instance_properties(instance, context)
-    )
+    }
+    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 = self.new(machine_spec)
+    machine
   end
 
   # FIXME: This will convert 'RUNNING' state to 'STARTED'
   # which is defined in CIMI (p65)
   #
   def self.convert_instance_state(state)
-    ('RUNNING' == state) ? 'STARTED' : state
+    case state
+      when "RUNNING" then "STARTED"
+      when "PENDING" then "CREATING" #aruba only exception... could be "STARTING" here
+      else state
+    end
   end
 
   def self.convert_instance_properties(instance, context)
@@ -162,7 +177,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
   def self.convert_instance_memory(profile, context)
     machine_conf = CIMI::Model::MachineConfiguration.find(profile.name, context)
     memory_override = profile.overrides.find { |p, v| p == :memory }
-    memory_override.nil? ? machine_conf.memory : context.to_kibibyte(memory_override[1].to_i,"MB")
+    memory_override.nil? ? machine_conf.memory.to_i : context.to_kibibyte(memory_override[1].to_i,"MB")
   end
 
   def self.convert_instance_addresses(instance)
@@ -179,11 +194,13 @@ class CIMI::Model::Machine < CIMI::Model::Base
   end
 
   def self.convert_instance_actions(instance, context)
-    instance.actions.collect do |action|
+    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}" }
     end
+    actions <<  { :href => context.send(:"machine_images_url"), :rel => "http://schemas.dmtf.org/cimi/1/action/capture" } if instance.can_create_image?
+    actions
   end
 
   def self.convert_storage_volumes(instance, context)

data/lib/cimi/models/machine_configuration.rb

@@ -17,8 +17,8 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
 
   acts_as_root_entity :as => "machineConfigs"
 
-  text :memory
   text :cpu
+  text :memory
 
   array :disks do
     text :capacity
@@ -42,7 +42,6 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
   end
 
   private
-
   def self.from_hardware_profile(profile, context)
     # We accept just profiles with all properties set
     return unless profile.memory or profile.cpu or profile.storage
@@ -51,12 +50,12 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
     storage = profile.storage ? context.to_kibibyte((profile.storage.value || profile.storage.default), profile.storage.unit) :  nil
     machine_hash = {
       :name => profile.name,
-      :description => "Machine Configuration with #{memory} #{profile.memory.unit} "+
+      :description => "Machine Configuration with #{memory} KiB "+
         "of memory and #{cpu} CPU",
       :cpu => ( cpu if cpu ) ,
-      :created => Time.now.to_s,  # FIXME: DC hardware_profile has no mention about created_at
+      :created => Time.now.xmlschema,  # FIXME: DC hardware_profile has no mention about created_at
       :memory => (memory if memory),
-      :disks => (  [ { :capacity => storage  } ] if storage ),
+      :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)
     }
     self.new(machine_hash)

data/lib/cimi/models/machine_image.rb

@@ -40,7 +40,7 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
       :name => image.id,
       :id => context.machine_image_url(image.id),
       :description => image.description,
-      :created => Time.now.to_s,
+      :created => Time.now.xmlschema,
       :image_location => { :href => "#{context.driver.name}://#{image.id}" } # FIXME
     )
   end

data/lib/cimi/models/machine_volume.rb

@@ -30,7 +30,7 @@ class CIMI::Model::MachineVolume < CIMI::Model::Base
           :id => context.machine_url(instance_id)+"/volumes/#{vol.id}",
           :name => vol.id,
           :description => "MachineVolume #{vol.id} for Machine #{instance_id}",
-          :created => vol.created,
+          :created => Time.parse(vol.created).xmlschema,
           :initial_location => vol.device,
           :volume => {:href=>context.volume_url(vol.id)}
           ) if vol.instance_id == instance_id

data/lib/cimi/models/network.rb

@@ -25,12 +25,10 @@ class CIMI::Model::Network < CIMI::Model::Base
 
   text :class_of_service
 
-  href :network_ports
+  collection :network_ports, :class => CIMI::Model::NetworkPort
 
   href :forwarding_group
 
-  href :event_log
-
   array :meters do
     scalar :href
   end
@@ -46,6 +44,11 @@ class CIMI::Model::Network < CIMI::Model::Base
     else
       networks = context.driver.networks(context.credentials, {:id=>id, :env=>context})
     end
+    if context.expand? :networkPorts
+      networks.each do |network|
+        network.network_ports = CIMI::Model::NetworkPort.collection_for_network(network.id, context)
+      end
+    end
     networks
   end
 

data/lib/cimi/models/network_port.rb

@@ -25,8 +25,6 @@ class CIMI::Model::NetworkPort < CIMI::Model::Base
 
   text :class_of_service
 
-  href :event_log
-
   array :meters do
     scalar :href
   end
@@ -76,6 +74,19 @@ class CIMI::Model::NetworkPort < CIMI::Model::Base
     end
   end
 
+  def self.collection_for_network(network_id, context)
+    net_url = context.network_url(network_id)
+    network_ports = CIMI::Model::NetworkPort.all(context)
+    ports_collection = network_ports.inject([]){|res, current| res << current if current.network.href == net_url ; res}
+    CIMI::Model::NetworkPortCollection.new(
+      :id => net_url+"/network_ports",
+      :name => 'default',
+      :created => Time.now,
+      :description => "#{context.driver.name.capitalize} NetworkPortCollection",
+      :count => ports_collection.size,
+      :network_ports => ports_collection
+    )
+  end
 
   private
 

data/lib/cimi/models/schema.rb

@@ -46,6 +46,10 @@ class CIMI::Model::Schema
     def to_json(model, json)
       json[@json_name] = model[@name] if model and model[@name]
     end
+
+    def convert(value)
+      value
+    end
   end
 
   class Scalar < Attribute
@@ -212,6 +216,54 @@ class CIMI::Model::Schema
     end
   end
 
+  class Collection < Attribute
+    def initialize(name, opts = {})
+      params = {}
+      params[:scope] = opts.delete(:scope)
+      super(name, opts)
+      unless opts[:class]
+        raise "Specify the class of collection entries using :class"
+      end
+      params[:embedded] = true
+      @collection_class = CIMI::Model::Collection.generate(opts[:class], params)
+    end
+
+    def from_xml(xml, model)
+      model[name] = @collection_class.schema.from_xml(xml[xml_name].first, {})
+    end
+
+    def from_json(json, model)
+      model[name] = @collection_class.schema.from_json(json[json_name], {})
+    end
+
+    def to_xml(model, xml)
+      model[name].prepare
+      if model[name].entries.empty?
+        xml[xml_name] = { "href" => model[name].href }
+      else
+        xml[xml_name] = @collection_class.schema.to_xml(model[name])
+      end
+    end
+
+    def to_json(model, json)
+      model[name].prepare
+      if model[name].entries.empty?
+        json[json_name] = { "href" => model[name].href }
+      else
+        json[json_name] = @collection_class.schema.to_json(model[name])
+      end
+    end
+
+    # Convert a Hash or Array to an instance of the collection class
+    def convert(value)
+      if value.is_a?(::Array)
+        @collection_class.new(:entries => value)
+      else
+        @collection_class.new(value || {})
+      end
+    end
+  end
+
   #
   # The actual Schema class
   #
@@ -222,6 +274,16 @@ class CIMI::Model::Schema
     @attributes = []
   end
 
+  def collections
+    @attributes.select { |a| a.is_a?(Collection) }
+  end
+
+  def convert(name, value)
+    attr = @attributes.find { |a| a.name == name }
+    raise "Unknown attribute #{name}" unless attr
+    attr.convert(value)
+  end
+
   def from_xml(xml, model = {})
     @attributes.freeze
     @attributes.each { |attr| attr.from_xml(xml, model) }
@@ -237,6 +299,7 @@ class CIMI::Model::Schema
   def to_xml(model, xml = nil)
     xml ||= OrderedHash.new
     @attributes.freeze
+    model.prepare if model.respond_to?(:prepare)
     @attributes.each { |attr| attr.to_xml(model, xml) }
     xml
   end
@@ -252,6 +315,7 @@ class CIMI::Model::Schema
 
   def to_json(model, json = {})
     @attributes.freeze
+    model.prepare if model.respond_to?(:prepare)
     @attributes.each { |attr| attr.to_json(model, json) }
     json
   end
@@ -293,11 +357,8 @@ class CIMI::Model::Schema
     end
 
     def collection(name, opts={})
-      text :count
-
-      array :operations do
-        scalar :rel, :href
-      end
+      opts[:scope] = self.class
+      add_attributes!([name, opts], Collection)
     end
   end