deltacloud-core 1.1.0 → 1.1.1

data/lib/cimi/models/disk.rb

@@ -24,11 +24,20 @@ class CIMI::Model::Disk < CIMI::Model::Base
 
   def self.find(instance, machine_config, context, id=:all)
     if id == :all
-      return machine_config.disks if machine_config
+      name = instance.id+"_disk_" #assuming one disk for now...
 
-      capacity = false
-
-      if instance
+      if machine_config
+        mach_config_disks = machine_config.disks
+        return mach_config_disks.map do |d|
+          self.new(
+            :id => context.machine_url(instance.id) + "/disks/#{name}#{d[:capacity]}",
+            :name => "#{name}#{d[:capacity]}",
+            :description => "Disk for Machine #{instance.id}",
+            :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time).xmlschema,
+            :capacity => d[:capacity]
+          )
+        end
+      else
         if instance.instance_profile.override? :storage
           capacity = context.to_kibibyte(instance.instance_profile.storage, 'MB')
         else
@@ -40,11 +49,9 @@ class CIMI::Model::Disk < CIMI::Model::Base
 
         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,
+          :id => context.machine_url(instance.id)+"/disks/#{name}#{capacity}",
+          :name => name + capacity.to_s,
           :description => "Disk for Machine #{instance.id}",
           :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time).xmlschema,
           :capacity => capacity

data/lib/cimi/models/machine.rb

@@ -52,6 +52,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   def self.create_from_json(body, context)
     json = JSON.parse(body)
+    additional_params={}
     machine_template = json['machineTemplate']
     if !machine_template['href'].nil?
       template = current_db.machine_templates.first(:id => machine_template['href'].split('/').last)
@@ -65,21 +66,28 @@ class CIMI::Model::Machine < CIMI::Model::Base
         additional_params[:keyname] = machine_template['credential']["href"].split('/').last
       end
     end
-
-    additional_params = {}
+    if machine_template.has_key? "initialState"
+      additional_params[:initial_state] = machine_template["initialState"].strip
+    end
     additional_params[:name] = json['name'] if json['name']
+    additional_params[:realm_id] = json['realm'] if json['realm']
     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)
+    machine = from_instance(instance, context)
+    machine.name = json['name'] || machine.name
+    machine.description = json['description']
+    machine.extract_properties!(json)
+    machine.save
+    machine
   end
 
   def self.create_from_xml(body, context)
     xml = XmlSimple.xml_in(body)
+    additional_params = {}
     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
@@ -92,16 +100,23 @@ class CIMI::Model::Machine < CIMI::Model::Base
         additional_params[:keyname] = machine_template['credential'][0]["href"].split('/').last
       end
     end
-    additional_params = {}
+    if xml["machineTemplate"][0].has_key? "initialState"
+      additional_params[:initial_state] = xml["machineTemplate"][0]["initialState"].first.strip
+    end
     additional_params[:name] = xml['name'][0] if xml['name']
+    additional_params[:realm_id] = xml['realm'][0] if xml['realm']
     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:
-    entity = store_attributes_for(instance, xml)
-    from_instance(instance, context, entity.to_hash)
+    machine = from_instance(instance, context)
+    machine.name = xml['name'] || machine.name
+    machine.description = xml['description']
+    machine.extract_properties!(xml)
+    machine.save
+    machine
   end
 
   def perform(action, context, &block)
@@ -117,8 +132,8 @@ 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)
+    new(:id => id).destroy
   end
 
   #returns the newly attach machine_volume
@@ -136,15 +151,9 @@ class CIMI::Model::Machine < CIMI::Model::Base
   end
 
   private
-  def self.from_instance(instance, context, stored_attributes=nil)
+  def self.from_instance(instance, context)
     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,
       :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time.to_s).xmlschema,
@@ -155,9 +164,8 @@ class CIMI::Model::Machine < CIMI::Model::Base
       :memory => memory || convert_instance_memory(instance.instance_profile, context),
       :disks => { :href => context.machine_url(instance.id)+"/disks"},
       :volumes => { :href=>context.machine_url(instance.id)+"/volumes"},
-      :operations => convert_instance_actions(instance, context),
-      :property => stored_attributes
-    }.merge(stored_attributes)
+      :operations => convert_instance_actions(instance, context)
+    }
     if context.expand? :disks
       machine_spec[:disks] = CIMI::Model::Disk.find(instance, machine_conf, context, :all)
     end
@@ -166,8 +174,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
     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
+    self.new(machine_spec)
   end
 
   # FIXME: This will convert 'RUNNING' state to 'STARTED'
@@ -181,15 +188,6 @@ class CIMI::Model::Machine < CIMI::Model::Base
     end
   end
 
-  def self.convert_instance_properties(instance, context)
-    properties = {}
-    properties["machine_image"] = context.machine_image_url(instance.image_id)
-    if instance.respond_to? :keyname
-      properties["credential"] = context.credential_url(instance.keyname)
-    end
-    properties
-  end
-
   def self.convert_instance_cpu(profile, context)
     cpu_override = profile.overrides.find { |p, v| p == :cpu }
     if cpu_override.nil?

data/lib/cimi/models/machine_image.rb

@@ -38,17 +38,13 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
   end
 
   def self.from_image(image, context)
-    stored_attributes = load_attributes_for(image)
     self.new(
       :id => context.machine_image_url(image.id),
-      :name => stored_attributes[:name] || image.id,
-      :description => stored_attributes[:description] || image.description,
+      :name => image.id,
+      :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]
+      :created => image.creation_time.nil? ? Time.now.xmlschema : Time.parse(image.creation_time.to_s).xmlschema
     )
   end
 
@@ -61,23 +57,24 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
       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)
+    result = from_image(image, context)
+    result.name = input['name'] if input['name']
+    result.description = input['description'] if input['description']
+    result.extract_properties!(input)
+    result.save
+    result
   end
 
   def self.delete!(image_id, context)
     context.driver.destroy_image(context.credentials, image_id)
-    delete_attributes_for(::Image.new(:id => image_id))
+    new(:id => image_id).destroy
   end
 
 end

data/lib/cimi/models/machine_template.rb

@@ -59,7 +59,7 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
         :description => json['description'],
         :machine_config => json['machineConfig']['href'],
         :machine_image => json['machineImage']['href'],
-        :ent_properties => json['properties'].to_json
+        :ent_properties => json['properties'] ? json['properties'].to_json : {}
       )
       from_db(new_template, context)
     end
@@ -71,7 +71,7 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
         :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 })
+        :ent_properties => xml['property'] ? JSON::dump(xml['property'].inject({}) { |r, p| r[p['key']]=p['content']; r }) : {}
       )
       from_db(new_template, context)
     end
@@ -89,7 +89,7 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
         :description => model.description,
         :machine_config => { :href => model.machine_config },
         :machine_image => { :href => model.machine_image },
-        :property => JSON::parse(model.ent_properties),
+        :property => (model.ent_properties ? JSON::parse(model.ent_properties) :  nil),
         :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' }

data/lib/cimi/models/resource.rb

@@ -0,0 +1,190 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+require_relative '../helpers/filter_helper'
+require_relative '../helpers/select_helper'
+
+module CIMI
+  module Model
+    class Resource
+
+      extend CIMI::Model::Schema::DSL
+      include CIMI::Helpers::SelectResourceMethods
+      include CIMI::Helpers::FilterResourceMethods
+
+      #
+      # We keep the values of the attributes in a hash
+      #
+      attr_reader :attribute_values
+
+      CMWG_NAMESPACE = "http://schemas.dmtf.org/cimi/1"
+
+      #
+      # Factory methods
+      #
+      def initialize(values = {})
+        names = self.class.schema.attribute_names
+        @select_attrs = values[:select_attr_list] || []
+        # Make sure we always have the :id of the entity even
+        # the $select parameter is used and :id is filtered out
+        #
+        @base_id = values[:base_id] || values[:id]
+        @attribute_values = names.inject(OrderedHash.new) do |hash, name|
+          hash[name] = self.class.schema.convert(name, values[name])
+          hash
+        end
+      end
+
+      # The CIMI::Model::Resource class methods
+      class << self
+
+        def base_schema
+          @schema ||= CIMI::Model::Schema.new
+        end
+
+        def clone_base_schema
+          @schema_duped = true
+          @schema = superclass.base_schema.deep_clone
+        end
+
+        def base_schema_cloned?
+          @schema_duped
+        end
+
+        private :clone_base_schema, :base_schema_cloned?
+
+        # If the model is inherited by another model, we want to clone
+        # the base schema instead of using the parent model schema, which
+        # might be modified
+        #
+        def inherited(child)
+          child.instance_eval do
+            def schema
+              base_schema_cloned? ? @schema : clone_base_schema
+            end
+          end
+        end
+
+        def add_attributes!(names, attr_klass, &block)
+          if self.respond_to? :schema
+            schema.add_attributes!(names, attr_klass, &block)
+          else
+            base_schema.add_attributes!(names, attr_klass, &block)
+          end
+          names.each do |name|
+            define_method(name) { self[name] }
+            define_method(:"#{name}=") { |newval| self[name] = newval }
+          end
+        end
+
+        # Return Array of links to current CIMI object
+        #
+        def all_uri(context)
+          self.all(context).map { |e| { :href => e.id } }
+        end
+
+        # Construct a new object from the XML representation +xml+
+        def from_xml(text)
+          xml = XmlSimple.xml_in(text, :force_content => true)
+          model = self.new
+          @schema.from_xml(xml, model)
+          model
+        end
+
+        # Construct a new object
+        def from_json(text)
+          json = JSON::parse(text)
+          model = self.new
+          @schema.from_json(json, model)
+          model
+        end
+
+        def parse(text, content_type)
+          if content_type == "application/xml"
+            from_xml(text)
+          elsif content_type == "application/json"
+            from_json(text)
+          else
+            raise "Can not parse content type #{content_type}"
+          end
+        end
+
+        #
+        # Serialize
+        #
+
+        def xml_tag_name
+          self.name.split("::").last
+        end
+
+        def resource_uri
+          CMWG_NAMESPACE + "/" + self.name.split("::").last
+        end
+
+        def to_json(model)
+          json = @schema.to_json(model)
+          json[:resourceURI] = resource_uri
+          JSON::unparse(json)
+        end
+
+        def to_xml(model)
+          xml = @schema.to_xml(model)
+          xml["xmlns"] = CMWG_NAMESPACE
+          xml["resourceURI"] = resource_uri
+          XmlSimple.xml_out(xml, :root_name => xml_tag_name)
+        end
+      end
+
+      # END of class methods
+
+      def [](a)
+        @attribute_values[a]
+      end
+
+      def []=(a, v)
+        return @attribute_values.delete(a) if v.nil?
+        @attribute_values[a] = self.class.schema.convert(a, v)
+      end
+
+      # Apply the $select options to all sub-collections and prepare then
+      # to serialize by setting correct :href and :id attributes.
+      #
+      def prepare
+        self.class.schema.collections.map { |coll| coll.name }.each do |n|
+          if @select_attrs.empty? or @select_attrs.include?(n)
+            self[n].href = "#{self.base_id}/#{n}" if !self[n].href
+            self[n].id = "#{self.base_id}/#{n}" if !self[n].entries.empty?
+          else
+            self[n] = nil
+          end
+        end
+      end
+
+      def base_id
+        self.id || @base_id
+      end
+
+      def to_json
+        self.class.to_json(self)
+      end
+
+      def to_xml
+        self.class.to_xml(self)
+      end
+
+    end
+
+  end
+end

data/lib/cimi/models/schema.rb

@@ -91,6 +91,9 @@ class CIMI::Model::Schema
     def initialize(name, opts, &block)
       content = opts[:content]
       super(name, opts)
+      if opts[:class]
+        opts[:schema] = opts[:class].schema
+      end
       if opts[:schema]
         if block_given?
           raise "Cannot provide :schema option and a block"
@@ -241,6 +244,7 @@ class CIMI::Model::Schema
     end
 
     def to_xml(model, xml)
+      return if model[name].nil?
       model[name].prepare
       if model[name].entries.empty?
         xml[xml_name] = { "href" => model[name].href }
@@ -250,6 +254,7 @@ class CIMI::Model::Schema
     end
 
     def to_json(model, json)
+      return if model[name].nil?
       model[name].prepare
       if model[name].entries.empty?
         json[json_name] = { "href" => model[name].href }
@@ -278,6 +283,10 @@ class CIMI::Model::Schema
     @attributes = []
   end
 
+  def deep_clone
+    Marshal::load(Marshal.dump(self))
+  end
+
   def collections
     @attributes.select { |a| a.is_a?(Collection) }
   end