deltacloud-core 1.0.5 → 1.1.0

data/lib/cimi/models/machine_image.rb

@@ -17,8 +17,10 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
 
   acts_as_root_entity
 
-  href :image_location
-  text :image_data
+  text :state
+  text :type
+  text :image_location
+  href :related_image
 
   array :operations do
     scalar :rel, :href
@@ -36,13 +38,46 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
   end
 
   def self.from_image(image, context)
+    stored_attributes = load_attributes_for(image)
     self.new(
-      :name => image.id,
       :id => context.machine_image_url(image.id),
-      :description => image.description,
-      :created => Time.now.xmlschema,
-      :image_location => { :href => "#{context.driver.name}://#{image.id}" } # FIXME
+      :name => stored_attributes[:name] || image.id,
+      :description => stored_attributes[:description] || image.description,
+      :state => image.state || 'UNKNOWN',
+      :type => "IMAGE",
+      :created => image.creation_time.nil? ? Time.now.xmlschema : Time.parse(image.creation_time.to_s).xmlschema,
+      :image_location => (stored_attributes[:property] && stored_attributes[:property]['image_location']) ?
+        stored_attributes[:property].delete('image_location') : 'unknown',
+      :property => stored_attributes[:property]
     )
   end
 
+  def self.create(request_body, context)
+    # The 'imageLocation' attribute is mandatory in CIMI, however in Deltacloud
+    # there is no way how to figure out from what Machine the MachineImage was
+    # created from. For that we need to store this attribute in properties.
+    #
+    if context.grab_content_type(context.request.content_type, request_body) == :xml
+      input = XmlSimple.xml_in(request_body.read, {"ForceArray"=>false,"NormaliseSpace"=>2})
+      raise 'imageLocation attribute is mandatory' unless input['imageLocation']
+      input['property'] ||= {}
+      input['property'].kind_of?(Array) ?
+        input['property'] << { 'image_location' => input['imageLocation'] } : input['property'].merge!('image_location' => input['imageLocation'])
+    else
+      input = JSON.parse(request_body.read)
+      raise 'imageLocation attribute is mandatory' unless input['imageLocation']
+      input['properties'] ||= []
+      input['properties'] << { 'image_location' => input['imageLocation'] }
+    end
+    params = {:id => context.href_id(input["imageLocation"], :machines), :name=>input["name"], :description=>input["description"]}
+    image = context.driver.create_image(context.credentials, params)
+    store_attributes_for(image, input)
+    from_image(image, context)
+  end
+
+  def self.delete!(image_id, context)
+    context.driver.destroy_image(context.credentials, image_id)
+    delete_attributes_for(::Image.new(:id => image_id))
+  end
+
 end

data/lib/cimi/models/machine_template.rb

@@ -40,4 +40,62 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
   array :operations do
     scalar :rel, :href
   end
+
+  class << self
+    def find(id, context)
+      if id == :all
+        current_db.machine_templates.map { |t| from_db(t, context) }
+      else
+        template = current_db.machine_templates_dataset.first(:id => id)
+        raise CIMI::Model::NotFound unless template
+        from_db(template, context)
+      end
+    end
+
+    def create_from_json(body, context)
+      json = JSON.parse(body)
+      new_template = current_db.add_machine_template(
+        :name => json['name'],
+        :description => json['description'],
+        :machine_config => json['machineConfig']['href'],
+        :machine_image => json['machineImage']['href'],
+        :ent_properties => json['properties'].to_json
+      )
+      from_db(new_template, context)
+    end
+
+    def create_from_xml(body, context)
+      xml = XmlSimple.xml_in(body)
+      new_template = current_db.add_machine_template(
+        :name => xml['name'].first,
+        :description => xml['description'].first,
+        :machine_config => xml['machineConfig'].first['href'],
+        :machine_image => xml['machineImage'].first['href'],
+        :ent_properties => JSON::dump(xml['property'].inject({}) { |r, p| r[p['key']]=p['content']; r })
+      )
+      from_db(new_template, context)
+    end
+
+    def delete!(id, context)
+      current_db.machine_templates.first(:id => id).destroy
+    end
+
+    private
+
+    def from_db(model, context)
+      self.new(
+        :id => context.machine_template_url(model.id),
+        :name => model.name,
+        :description => model.description,
+        :machine_config => { :href => model.machine_config },
+        :machine_image => { :href => model.machine_image },
+        :property => JSON::parse(model.ent_properties),
+        :created => Time.parse(model.created_at.to_s).xmlschema,
+        :operations => [
+          { :href => context.destroy_machine_template_url(model.id), :rel => 'http://schemas.dmtf.org/cimi/1/action/delete' }
+        ]
+      )
+    end
+  end
+
 end

data/lib/cimi/models/machine_volume.rb

@@ -26,17 +26,65 @@ class CIMI::Model::MachineVolume < CIMI::Model::Base
     if id == :all
       volumes = context.driver.storage_volumes(context.credentials)
       volumes.inject([]) do |attached, vol|
+        id = context.machine_url(instance_id)+"/volumes/#{vol.id}"
         attached <<  self.new(
-          :id => context.machine_url(instance_id)+"/volumes/#{vol.id}",
+          :id => id,
           :name => vol.id,
           :description => "MachineVolume #{vol.id} for Machine #{instance_id}",
-          :created => Time.parse(vol.created).xmlschema,
+          :created => vol.created.nil? ? nil : Time.parse(vol.created).xmlschema,
           :initial_location => vol.device,
-          :volume => {:href=>context.volume_url(vol.id)}
+          :volume => {:href=>context.volume_url(vol.id)},
+          :operations => [{:href=>id, :rel => "delete" }]
           ) if vol.instance_id == instance_id
         attached
       end
     else
+      vol = context.driver.storage_volume(context.credentials, {:id=>id})
+      id = context.machine_url(instance_id)+"/volumes/#{vol.id}"
+      raise CIMI::Model::NotFound unless vol.instance_id == instance_id
+      self.new(
+        :id => id,
+        :name => vol.id,
+        :description => "MachineVolume #{vol.id} for Machine #{instance_id}",
+        :created => vol.created.nil? ? nil : Time.parse(vol.created).xmlschema,
+        :initial_location => vol.device,
+        :volume => {:href=>context.volume_url(vol.id)},
+        :operations => [{:href=>id, :rel => "delete" }]
+        )
     end
   end
+
+  def self.find_to_attach_from_xml(xml_in, context)
+    xml = XmlSimple.xml_in(xml_in)
+    vol_id = xml["volume"].first["href"].split("/").last
+    location = xml["initialLocation"].first.strip
+    [vol_id, location]
+  end
+
+  def self.find_to_attach_from_json(json_in, context)
+    json = JSON.parse(json_in)
+    vol_id = json["volume"]["href"].split("/").last
+    location = json["initialLocation"]
+    [vol_id, location]
+  end
+
+
+  def self.collection_for_instance(instance_id, context)
+    machine_volumes = self.find(instance_id, context)
+    volumes_url = context.url("/machines/#{instance_id}/volumes")
+    unless CIMI::Model.const_defined?('MachineVolumeCollection')
+      collection_class = CIMI::Model::Collection.generate(self)
+    else
+      collection_class = CIMI::Model::MachineVolumeCollection
+    end
+    collection_class.new(
+      :id => volumes_url,
+      :name => 'default',
+      :count => machine_volumes.size,
+      :description => "Volume collection for Machine #{instance_id}",
+      :entries => machine_volumes,
+      :operations => [{ :href => volumes_url.singularize+"_attach", :rel => "add" }]
+    )
+  end
+
 end

data/lib/cimi/models/resource_metadata.rb

@@ -16,7 +16,7 @@
 
 class CIMI::Model::ResourceMetadata < CIMI::Model::Base
 
-  acts_as_root_entity
+  text :name
 
   text :type_uri
 
@@ -25,10 +25,20 @@ class CIMI::Model::ResourceMetadata < CIMI::Model::Base
     scalar :namespace
     scalar :type
     scalar :required
-    scalar :constraints
+    array :constraints do
+      text :value
+    end
   end
 
-  array :operations do
+  array :capabilities do
+    scalar :name
+    scalar :uri
+    scalar :description
+    scalar :value, :text => :direct
+  end
+
+
+  array :actions do
     scalar :name
     scalar :uri
     scalar :description
@@ -37,49 +47,102 @@ class CIMI::Model::ResourceMetadata < CIMI::Model::Base
     scalar :output_message
   end
 
+  array :operations do
+    scalar :rel, :href
+  end
+
   def self.find(id, context)
-    resource_metadata = []
     if id == :all
+      resource_metadata = []
       CIMI::Model.root_entities.each do |resource_class|
-        resource_metadata << resource_class.create_resource_metadata(context) if resource_class.respond_to?(:create_resource_metadata)
+        meta = resource_metadata_for(resource_class, context)
+        resource_metadata << meta unless none_defined(meta)
       end
       return resource_metadata
     else
       resource_class = CIMI::Model.const_get("#{id.camelize}")
-      if resource_class.respond_to?(:create_resource_metadata)
-        resource_class.create_resource_metadata(context)
-      end
+      resource_metadata_for(resource_class, context)
     end
   end
 
-  def self.metadata_from_deltacloud_features(cimi_resource, dcloud_resource, context)
-    deltacloud_features = context.driver.class.features[dcloud_resource]
-    metadata_attributes = deltacloud_features.map{|f| attributes_from_feature(f)}
-    from_feature(cimi_resource, context, metadata_attributes.flatten!)
+  def self.resource_metadata_for(resource_class, context)
+    attributes = rm_attributes_for(resource_class, context)
+    capabilities = rm_capabilities_for(resource_class, context)
+    actions = rm_actions_for(resource_class, context)
+    cimi_resource = resource_class.name.split("::").last
+    self.new({ :id => context.resource_metadata_url(cimi_resource.underscore),
+              :name => cimi_resource,
+              :type_uri => resource_class.resource_uri,
+              :attributes => attributes,
+              :capabilities => capabilities,
+              :actions => actions
+    })
   end
 
-  def includes_attribute?(attribute)
-    self.attributes.any?{|attr| attr[:name] == attribute}
+  def self.resource_attributes
+    @resource_attributes ||= {}
+  end
+
+  def self.add_resource_attribute!(klass, name, opts={})
+    resource_attributes[klass.name] ||= {}
+    resource_attributes[klass.name][name] = opts
   end
 
   private
 
-  def self.attributes_from_feature(feature)
-    feature = CIMI::FakeCollection.feature(feature)
-    feature.operations.first.params_array.map do |p|
+  def self.rm_attributes_for(resource_class, context)
+    return [] if resource_attributes[resource_class.name].nil?
+    resource_attributes[resource_class.name].map do |attr_name, attr_def|
+      if attr_def.has_key? :constraints
+        constraints = attr_def[:constraints].call(context)
+      else
+        constraints = []
+      end
       {
-        :name=> p.name,
-        :type=> "xs:string",
-        :required=> p.required? ? "true" : "false",
-        :constraints=> (feature.constraints.empty? ? (feature.description.nil? ? "" : feature.description): feature.constraints)
+        :name => attr_name.to_s,
+        # TODO: We need to make this URI return description of this 'non-CIMI'
+        # attribute
+        :namespace => "http://deltacloud.org/cimi/#{resource_class.name.split('::').last}/#{attr_name}",
+        :type => translate_attr_type(attr_def[:type]),
+        :required => attr_def[:required] ? 'true' : 'false',
+        :constraints => constraints.map { |v| { :value => v }}
       }
     end
   end
 
-  def self.from_feature(cimi_resource, context, metadata_attributes)
-    self.new(:name => cimi_resource, :uri=>"#{context.resource_metadata_url}/#{cimi_resource.underscore}",
-             :type_uri=> context.send("#{cimi_resource.pluralize.underscore}_url"),
-             :attributes => metadata_attributes)
+  def self.rm_capabilities_for(resource_class,context)
+    cimi_object = resource_class.name.split("::").last.underscore.pluralize.to_sym
+    capabilities = (context.driver.class.features[cimi_object] || []).inject([]) do |res, cur|
+      feat = CIMI::FakeCollection.feature(cur)
+      values = (context.driver.class.constraints[cimi_object][feat.name][:values] || []).inject([]) do |vals, val|
+        vals <<  val
+        vals
+      end
+      res << {:name => feat.name.to_s.camelize,
+       :uri => CMWG_NAMESPACE+"/capability/#{cimi_object.to_s.camelize.singularize}/#{feat.name.to_s.camelize}",
+       :description => feat.description,
+       :value => values.join(",") }
+      res
+    end
+#cimi_resource.underscore.pluralize.to_sym
+  end
+
+  def self.rm_actions_for(resource_class, context)
+    []
+  end
+
+  def self.translate_attr_type(type)
+    case type
+      when :href then 'URI'
+      when :text then 'string'
+      when :boolean then 'boolean'
+      else 'text'
+    end
+  end
+
+  def self.none_defined(metadata)
+    return true if metadata.capabilities.empty? && metadata.capabilities.empty? && metadata.attributes.empty?
+    return false
   end
 
 end

data/lib/cimi/models/schema.rb

@@ -136,7 +136,7 @@ class CIMI::Model::Schema
     end
 
     def convert_to_xml(model)
-      xml = {}
+      xml = OrderedHash.new
       @schema.to_xml(model, xml)
       xml
     end
@@ -195,7 +195,7 @@ class CIMI::Model::Schema
 
     def from_xml(xml, model)
       model[name] = (xml[xml_name] || []).inject({}) do |result, item|
-        result[item["name"]] = item["content"]
+        result[item["key"]] = item["content"]
         result
       end
     end
@@ -205,7 +205,7 @@ class CIMI::Model::Schema
     end
 
     def to_xml(model, xml)
-      ary = (model[name] || {}).map { |k, v| { "name" => k, "content" => v } }
+      ary = (model[name] || {}).map { |k, v| { "key" => k, "content" => v } }
       xml[xml_name] = ary unless ary.empty?
     end
 
@@ -229,11 +229,15 @@ class CIMI::Model::Schema
     end
 
     def from_xml(xml, model)
-      model[name] = @collection_class.schema.from_xml(xml[xml_name].first, {})
+      if xml[xml_name]
+        model[name] = @collection_class.schema.from_xml(xml[xml_name].first, {})
+      end
     end
 
     def from_json(json, model)
-      model[name] = @collection_class.schema.from_json(json[json_name], {})
+      if json[json_name]
+        model[name] = @collection_class.schema.from_json(json[json_name], {})
+      end
     end
 
     def to_xml(model, xml)
@@ -330,6 +334,16 @@ class CIMI::Model::Schema
   # Requires that the class into which this is included has a
   # +add_attributes!+ method
   module DSL
+
+    def resource_attr(name, opts={})
+      CIMI::Model::ResourceMetadata.add_resource_attribute!(self, name, opts)
+      if opts[:type]
+        send(opts[:type], name)
+      else
+        text name
+      end
+    end
+
     def href(*args)
       opts = args.extract_opts!
       args.each { |arg| struct(arg, opts) { scalar :href } }

data/lib/cimi/models/volume.rb

@@ -38,34 +38,40 @@ class CIMI::Model::Volume < CIMI::Model::Base
   end
 
   def self.find(id, context)
-    volumes = []
-    opts = ( id == :all ) ? {} : { :id => id }
-    volumes = context.driver.storage_volumes(context.credentials, opts)
-    volumes.collect!{ |volume| from_storage_volume(volume, context) }
-    return volumes.first unless volumes.length > 1 || volumes.length == 0
-    return volumes
+    creds = context.credentials
+    if id == :all
+      volumes = context.driver.storage_volumes(creds)
+      volumes.collect{ |volume| from_storage_volume(volume, context) }
+    else
+      volume = context.driver.storage_volumes(creds, :id => id).first
+      raise CIMI::Model::NotFound unless volume
+      from_storage_volume(volume, context)
+    end
   end
 
   def self.all(context); find(:all, context); end
 
-  def self.create_from_json(json_in, context)
-    json = JSON.parse(json_in)
-    volume_config_id = json["volumeTemplate"]["volumeConfig"]["href"].split("/").last
-    volume_image_id = (json["volumeTemplate"].has_key?("volumeImage") ?
-                json["volumeTemplate"]["volumeImage"]["href"].split("/").last  : nil)
-    create_volume({:volume_config_id=>volume_config_id, :volume_image_id=>volume_image_id}, context)
-  end
-
-  def self.create_from_xml(xml_in, context)
-    xml = XmlSimple.xml_in(xml_in)
-    volume_config_id = xml["volumeTemplate"][0]["volumeConfig"][0]["href"].split("/").last
-    volume_image_id = (xml["volumeTemplate"][0].has_key?("volumeImage") ?
-             xml["volumeTemplate"][0]["volumeImage"][0]["href"].split("/").last  : nil)
-    create_volume({:volume_config_id=>volume_config_id, :volume_image_id=>volume_image_id}, context)
+  def self.create(request_body, context, type)
+    #json = JSON.parse(json_in)
+    input = (type == :xml)? XmlSimple.xml_in(request_body, {"ForceArray"=>false,"NormaliseSpace"=>2}) : JSON.parse(request_body)
+    if input["volumeTemplate"]["href"]  #template by reference
+      #FIXME - don't have volumeTemplates yet - datamapper   volume_config =
+    else #template by value
+      volume_image_id = (input["volumeTemplate"].has_key?("volumeImage") ?
+                input["volumeTemplate"]["volumeImage"]["href"].split("/").last  : nil)
+      if input["volumeTemplate"]["volumeConfig"]["href"] #with config by reference
+        volume_config_id = input["volumeTemplate"]["volumeConfig"]["href"].split("/").last
+        create_volume({:volume_config_id=>volume_config_id, :volume_image_id=>volume_image_id}, input, context)
+      else #with config by value
+        capacity = input["volumeTemplate"]["volumeConfig"]["capacity"]
+        create_volume({:capacity=>capacity, :volume_image_id=>volume_image_id}, input, context)
+      end
+    end
   end
 
   def self.delete!(id, context)
     context.driver.destroy_storage_volume(context.credentials, {:id=>id} )
+    delete_attributes_for(StorageVolume.new(:id => id))
   end
 
   def self.find_to_attach_from_json(json_in, context)
@@ -80,27 +86,57 @@ class CIMI::Model::Volume < CIMI::Model::Base
                            :attachment_point=>v["attachmentPoint"] }}
   end
 
+  def to_entity
+    'volume'
+  end
+
   private
 
-  def self.create_volume(params, context)
-    volume_config = CIMI::Model::VolumeConfiguration.find(params[:volume_config_id], context)
-    opts = {:capacity=>volume_config.capacity[:quantity], :snapshot_id=>params[:volume_image_id] }
+  def self.create_volume(params, data, context)
+    if params[:volume_config_id]
+      volume_config = CIMI::Model::VolumeConfiguration.find(params[:volume_config_id], context)
+      opts = {:capacity=>context.from_kibibyte(volume_config.capacity, "GB"),
+              :snapshot_id=>params[:volume_image_id],
+              :name=>data["name"]}
+    elsif params[:capacity]
+      opts = {:capacity=>context.from_kibibyte(params[:capacity], "GB"),
+              :snapshot_id=>params[:volume_image_id],
+              :name=>data["name"]}
+    end
     storage_volume = context.driver.create_storage_volume(context.credentials, opts)
-    from_storage_volume(storage_volume, context)
+    entity = store_attributes_for(storage_volume, data)
+    from_storage_volume(storage_volume, context, entity.to_hash)
   end
 
-  def self.from_storage_volume(volume, context)
-    self.new( { :name => volume.id,
-                :description => volume.id,
-                :created => Time.parse(volume.created).xmlschema,
+  def self.from_storage_volume(volume, context, stored_attributes=nil)
+    stored_attributes ||= load_attributes_for(volume)
+    self.new( { :name => stored_attributes[:name] || volume.id,
+                :description => stored_attributes[:description] || 'Description of Volume',
+                :property => stored_attributes[:property],
+                :created => volume.created.nil? ? nil : Time.parse(volume.created).xmlschema,
                 :id => context.volume_url(volume.id),
-                :capacity => { :quantity=>volume.capacity, :units=>"gibibyte"  }, #FIXME... units will vary
+                :capacity => context.to_kibibyte(volume.capacity, 'GB'),
                 :bootable => "false", #fixme ... will vary... ec2 doesn't expose this
                 :snapshots => [], #fixme...
                 :type => 'http://schemas.dmtf.org/cimi/1/mapped',
                 :state => volume.state,
-                :meters => []
+                :meters => [],
+                :operations => [{:href=> context.volume_url(volume.id), :rel => "delete"}]
             } )
   end
 
+  def self.collection_for_instance(instance_id, context)
+    instance = context.driver.instance(context.credentials, :id => instance_id)
+    volumes = instance.storage_volumes.map do |mappings|
+      mappings.keys.map { |volume_id| from_storage_volume(context.driver.storage_volume(context.credentials, :id => volume_id), context) }
+    end.flatten
+    CIMI::Model::VolumeCollection.new(
+      :id => context.url("/machines/#{instance_id}/volumes"),
+      :name => 'default',
+      :count => volumes.size,
+      :description => "Volume collection for Machine #{instance_id}",
+      :entries => volumes
+    )
+  end
+
 end