deltacloud-core 1.1.0 → 1.1.1

data/lib/cimi/models.rb

@@ -13,8 +13,26 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 #
+
 module CIMI
-  module Model; end
+  module Model
+    def self.register_as_root_entity!(klass, opts = {})
+      @root_entities ||= [CIMI::Model::CloudEntryPoint]
+      @root_entities << klass
+      name = klass.name.split("::").last.pluralize
+      unless CIMI::Model::CloudEntryPoint.href_defined?(name)
+        params = {}
+        if opts[:as]
+          params[:xml_name] = params[:json_name] = opts[:as]
+        end
+        CIMI::Model::CloudEntryPoint.send(:href, name.underscore, params)
+      end
+    end
+
+    def self.root_entities
+      @root_entities || []
+    end
+  end
 end
 
 require 'require_relative' if RUBY_VERSION < '1.9'
@@ -31,8 +49,9 @@ unless Deltacloud.test_environment?
 end
 
 require_relative './models/schema'
-require_relative './models/base'
+require_relative './models/resource'
 require_relative './models/collection'
+require_relative './models/base'
 require_relative './models/errors'
 require_relative './models/action'
 require_relative './models/machine_volume'

data/lib/cimi/models/address.rb

@@ -65,23 +65,26 @@ class CIMI::Model::Address < CIMI::Model::Base
     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)
     address = context.driver.create_address(context.credentials, params)
-    store_attributes_for(address, input)
-    from_address(address, context)
+    result = from_address(address, 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!(id, context)
     context.driver.delete_address(context.credentials, id)
-    delete_attributes_for(::Address.new(:id => id))
+    new(:id => id).destroy
   end
 
   private
 
   def self.from_address(address, context)
-    stored_attributes = load_attributes_for(address)
     self.new(
-      :name => stored_attributes[:name] || address.id,
+      :name => address.id,
       :id => context.address_url(address.id),
-      :description => stored_attributes[:description] || "Address #{address.id}",
+      :description => "Address #{address.id}",
       :ip => address.id,
       :allocation => "dynamic", #or "static"
       :default_gateway => "unknown", #wtf
@@ -89,7 +92,6 @@ class CIMI::Model::Address < CIMI::Model::Base
       :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

@@ -42,7 +42,7 @@ class CIMI::Model::AddressTemplate < CIMI::Model::Base
       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) }
+        current_db.address_templates.map { |t| from_db(t, context) }
       end
     else
       if context.driver.respond_to? :address_template
@@ -67,7 +67,7 @@ class CIMI::Model::AddressTemplate < CIMI::Model::Base
       :dns => json['dns'],
       :protocol => json['protocol'],
       :mask => json['mask'],
-      :ent_properties => json['properties'].to_json
+      :ent_properties => json['properties'] ? json['properties'].to_json : {}
     )
     from_db(new_template, context)
   end
@@ -85,7 +85,7 @@ class CIMI::Model::AddressTemplate < CIMI::Model::Base
       :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 })
+      :ent_properties => xml['property'] ? JSON::dump(xml['property'].inject({}) { |r, p| r[p['key']]=p['content']; r }) : {}
     )
     from_db(new_template, context)
   end
@@ -108,7 +108,7 @@ class CIMI::Model::AddressTemplate < CIMI::Model::Base
       :dns => model.dns,
       :protocol => model.protocol,
       :mask => model.mask,
-      :property => JSON::parse(model.ent_properties),
+      :property => (model.ent_properties ? JSON::parse(model.ent_properties) :  nil),
       :operations => [
         { :href => context.destroy_address_template_url(model.id), :rel => 'http://schemas.dmtf.org/cimi/1/action/delete' }
       ]

data/lib/cimi/models/base.rb

@@ -15,6 +15,8 @@
 
 require 'xmlsimple'
 
+require_relative '../helpers/database_helper'
+
 # 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
 # JSON into a common form.
@@ -61,7 +63,7 @@ require 'xmlsimple'
 #   [struct(name, opts, &block)]
 #     A structured subobject; the block defines the schema of the
 #     subobject. The +:content+ option can be used to specify the attribute
-#     that should receive the content of hte corresponding XML element
+#     that should receive the content of the corresponding XML element
 #   [array(name, opts, &block)]
 #     An array of structured subobjects; the block defines the schema of
 #     the subobjects.
@@ -71,221 +73,84 @@ require 'xmlsimple'
 
 module CIMI::Model
 
-  def self.register_as_root_entity!(klass, opts = {})
-    @root_entities ||= [CIMI::Model::CloudEntryPoint]
-    @root_entities << klass
-    name = klass.name.split("::").last.pluralize
-    unless CIMI::Model::CloudEntryPoint.href_defined?(name)
-      params = {}
-      if opts[:as]
-        params[:xml_name] = params[:json_name] = opts[:as]
-      end
-      CIMI::Model::CloudEntryPoint.send(:href, name.underscore, params)
-    end
-  end
-
-  def self.root_entities
-    @root_entities || []
-  end
-
-end
-
-class CIMI::Model::Resource
+  class Base < Resource
 
-  #
-  # We keep the values of the attributes in a hash
-  #
-  attr_reader :attribute_values
+    # Extend the base model with database methods
+    extend Deltacloud::Helpers::Database
 
-  CMWG_NAMESPACE = "http://schemas.dmtf.org/cimi/1"
+    # Extend the base model with the collection handling methods
+    extend CIMI::Model::CollectionMethods
 
-  # Keep the list of all attributes in an array +attributes+; for each
-  # attribute, we also define a getter and a setter to access/change the
-  # value for that attribute
-  class << self
+    # Include methods needed to handle the $select query parameter
+    include CIMI::Helpers::SelectBaseMethods
+    #
+    # Common attributes for all resources
+    #
+    text :id, :name, :description, :created, :updated
+    hash :property
 
-    def <<(model)
-      clone_base_schema unless base_schema_cloned?
-      member_name = model.name.split("::").last
-      if ::Struct.const_defined?("CIMI_#{member_name}")
-        ::Struct.send(:remove_const, "CIMI_#{member_name}")
-      end
-      member_symbol = member_name.underscore.pluralize.to_sym
-      members = CIMI::Model::Schema::Array.new(member_symbol)
-      members.struct.schema.attributes = model.schema.attributes
-      base_schema.attributes << members
+    def initialize(values = {})
+      super(values)
+      retrieve_entity
     end
 
-    def base_schema
-      @schema ||= CIMI::Model::Schema.new
+    def []=(a, v)
+      v = super
+      retrieve_entity if a == :id
+      v
     end
 
-    def clone_base_schema
-      @schema_duped = true
-      @schema = Marshal::load(Marshal.dump(superclass.base_schema))
+    # Save the common attributes name, description, and properties to the
+    # database
+    def save
+      if @entity
+        @entity.name = name
+        @entity.description = description
+        @entity.properties = property
+        @entity.save
+      end
+      self
     end
 
-    def base_schema_cloned?
-      @schema_duped
+    # Destroy the database attributes for this model
+    def destroy
+      @entity.destroy
+      self
     end
 
-    private :clone_base_schema, :base_schema_cloned?
-
-    def inherited(child)
-      child.instance_eval do
-        def schema
-          base_schema_cloned? ? @schema : clone_base_schema
+    # FIXME: Kludge around the fact that we do not have proper *Create
+    # objects that deserialize properties by themselves
+    def extract_properties!(data)
+      h = {}
+      if data['property']
+        # Data came from XML
+        h = data['property'].inject({}) do |r,v|
+          r[v['key']] = v['content']
+          r
         end
+      elsif data['properties']
+        h = data['properties']
       end
+      property ||= {}
+      property.merge!(h)
     end
 
-    def add_attributes!(names, attr_klass, &block)
-      if self.respond_to? :schema
-        schema.add_attributes!(names, attr_klass, &block)
+    private
+
+    # Load an existing database entity for this object, or create a new one
+    def retrieve_entity
+      if self.id
+        @entity = Deltacloud::Database::Entity::retrieve(self)
+        if @entity.exists?
+          self.name = @entity.name
+          self.description = @entity.description
+          self.property ||= {}
+          self.property.merge!(@entity.properties)
+        end
       else
-        base_schema.add_attributes!(names, attr_klass, &block)
+        @entity = nil
       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
-  end
-
-  extend CIMI::Model::Schema::DSL
-
-  def [](a)
-    @attribute_values[a]
-  end
-
-  def []=(a, v)
-    @attribute_values[a] = self.class.schema.convert(a, v)
-  end
-
-  # Prepare to serialize
-  def prepare
-    self.class.schema.collections.map { |coll| coll.name }.each do |n|
-      self[n].href = "#{self.id}/#{n}" unless self[n].href
-      self[n].id = "#{self.id}/#{n}" if !self[n].entries.empty?
-    end
-  end
-
-  #
-  # Factory methods
-  #
-  def initialize(values = {})
-    names = self.class.schema.attribute_names
-    @attribute_values = names.inject(OrderedHash.new) do |hash, name|
-      hash[name] = self.class.schema.convert(name, values[name])
-      hash
     end
-  end
-
-  # Construct a new object from the XML representation +xml+
-  def self.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 self.from_json(text)
-    json = JSON::parse(text)
-    model = self.new
-    @schema.from_json(json, model)
-    model
   end
-
-  def self.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 self.xml_tag_name
-    self.name.split("::").last
-  end
-
-  def self.resource_uri
-    CMWG_NAMESPACE + "/" + self.name.split("::").last
-  end
-
-  def self.to_json(model)
-    json = @schema.to_json(model)
-    json[:resourceURI] = resource_uri
-    JSON::unparse(json)
-  end
-
-  def self.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
-
-  def to_json
-    self.class.to_json(self)
-  end
-
-  def to_xml
-    self.class.to_xml(self)
-  end
-
-  def filter_by(filter_opts)
-    return self if filter_opts.nil?
-    return filter_attributes(filter_opts.split(',').map{ |a| a.intern }) if filter_opts.include? ','
-    case filter_opts
-      when /^([\w\_]+)$/ then filter_attributes([$1.intern])
-      when /^([\w\_]+)\[(\d+\-\d+)\]$/ then filter_by_arr_range($1.intern, $2)
-      when /^([\w\_]+)\[(\d+)\]$/ then filter_by_arr_index($1.intern, $2)
-      else self
-    end
-  end
-
-  def filter_by_arr_index(attr, filter)
-    return self unless self.respond_to?(attr)
-    self.class.new(attr => [self.send(attr)[filter.to_i]])
-  end
-
-  def filter_by_arr_range(attr, filter)
-    return self unless self.respond_to?(attr)
-    filter = filter.split('-').inject { |s,e| s.to_i..e.to_i }
-    self.class.new(attr => self.send(attr)[filter])
-  end
-end
-
-require_relative '../helpers/database_helper'
-
-class CIMI::Model::Base < CIMI::Model::Resource
-  extend Deltacloud::Helpers::Database
-  #
-  # Common attributes for all resources
-  #
-  text :id, :name, :description, :created
-
-  hash :property
-
-  def filter_attributes(attr_list)
-    attrs = attr_list.inject({}) do |result, 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/collection.rb

@@ -13,22 +13,56 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+
 module CIMI::Model
   class Collection < Resource
 
     class << self
       attr_accessor :entry_name, :embedded
+
+      def xml_tag_name
+        'Collection'
+      end
+
+      def generate(model_class, opts = {})
+        model_name = model_class.name.split("::").last
+        scope = opts[:scope] || CIMI::Model
+        coll_class = Class.new(CIMI::Model::Collection)
+        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
+          end
+        end
+        coll_class
+      end
+
     end
 
     # Make sure the base schema gets cloned
-    self.schema
+    schema
 
+    # You can initialize collection by passing the Hash representation of the
+    # collection or passing another Collection object.
+    #
     def initialize(values = {})
-      if values[:entries]
-        values[self.class.entry_name] = values.delete(:entries)
+      if values.kind_of?(Hash)
+        if values[:entries]
+          values[self.class.entry_name] = values.delete(:entries)
+        end
+        values[self.class.entry_name] ||= []
+        super(values)
+      else
+        super
       end
-      values[self.class.entry_name] ||= []
-      super(values)
     end
 
     def entries
@@ -53,91 +87,65 @@ module CIMI::Model
     end
 
     def [](a)
-      a = entry_name if a == :entries
+      a = self.class.entry_name if a == :entries
       super(a)
     end
 
     def []=(a, v)
-      a = entry_name if a == :entries
+      a = self.class.entry_name if a == :entries
       super(a, v)
     end
 
-    def filter_attributes(attr_list)
+    def select_attributes(attr_list)
       self[self.class.entry_name] = entries.map do |e|
-        e.filter_attributes(attr_list)
+        e.select_attributes(attr_list)
       end
       self
     end
-
-    def self.xml_tag_name
-      "Collection"
-    end
-
-    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)
-      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
-        end
-      end
-      coll_class
-    end
   end
 
-  #
-  # We need to reopen Base and add some stuff to avoid circular dependencies
-  #
-  class Base
-    #
-    # Toplevel collections
-    #
+  module CollectionMethods
 
-    class << self
+    def collection_class=(klass)
+      @collection_class = klass
+    end
 
-      attr_accessor :collection_class
+    def collection_class
+      @collection_class
+    end
 
-      def acts_as_root_entity(opts = {})
-        self.collection_class = Collection.generate(self)
-        CIMI::Model.register_as_root_entity! self, opts
-      end
+    def acts_as_root_entity(opts = {})
+      self.collection_class = Collection.generate(self)
+      CIMI::Model.register_as_root_entity! self, opts
+    end
 
-      # Return a collection of entities
-      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 = []
-        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,
-                             :count => entries.size,
-                             :entries => entries,
-                             :operations => ops,
-                             :description => desc)
+    # Return a collection of entities
+    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 = []
+      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,
+                           :count => entries.size,
+                           :entries => entries,
+                           :operations => ops,
+                           :description => desc)
     end
 
-    def self.all(context)
-      find(:all, context)
+    def all(context)
+      find :all, context
     end
+
   end
+
 end