deltacloud-core 1.1.2 → 1.1.3

data/lib/cimi/models/machine_volume.rb

@@ -22,69 +22,4 @@ class CIMI::Model::MachineVolume < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(instance_id, context, id=:all)
-    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 => 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" }]
-          ) 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/network.rb

@@ -37,36 +37,4 @@ class CIMI::Model::Network < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    networks=[]
-    if id==:all
-      networks = context.driver.networks(context.credentials, {:env=>context})
-    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
-
-
-  def self.delete!(id, context)
-    context.driver.delete_network(context.credentials, id)
-  end
-
-  def perform(action, context, &block)
-    begin
-      if context.driver.send(:"#{action.name}_network", context.credentials, self.name)
-        block.callback :success
-      else
-        raise "Operation #{action.name} failed to execute on the Network #{self.name} "
-      end
-    rescue => e
-      block.callback :failure, e.message
-    end
-  end
-
 end

data/lib/cimi/models/network_configuration.rb

@@ -27,19 +27,4 @@ class CIMI::Model::NetworkConfiguration < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    network_configs = []
-    if id==:all
-      network_configs = context.driver.network_configurations(context.credentials, {:env=>context})
-    else
-      network_configs = context.driver.network_configurations(context.credentials, {:env=>context, :id=>id})
-    end
-    network_configs
-  end
-
-  def self.create_from_xml(request_body, context)
-  end
-
-  def self.create_from_json(request_body, context)
-  end
 end

data/lib/cimi/models/network_create.rb

@@ -17,27 +17,4 @@ class CIMI::Model::NetworkCreate < CIMI::Model::Base
 
   ref :network_template, :required => true
 
-  def create(context)
-    validate!
-    if network_template.href?
-      template = network_template.find(context)
-      network_config = template.network_config.find(context)
-      forwarding_group = template.forwarding_group.find(context)
-    else
-      network_config = CIMI::Model::NetworkConfiguration.find(context.href_id(network_template.network_config.href, :network_configurations), context)
-      forwarding_group = CIMI::Model::ForwardingGroup.find(context.href_id(network_template.forwarding_group.href, :forwarding_groups), context)
-    end
-    params = {
-      :network_config => network_config,
-      :forwarding_group => forwarding_group,
-      :name => name,
-      :description => description,
-      :env => context # FIXME: We should not pass the context to the driver (!)
-    }
-    network = context.driver.create_network(context.credentials, params)
-    network.property = property if property
-    network.save
-    network
-  end
-
 end

data/lib/cimi/models/network_port.rb

@@ -33,77 +33,4 @@ class CIMI::Model::NetworkPort < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    if id==:all
-      context.driver.network_ports(context.credentials, {:env=>context})
-    else
-      context.driver.network_ports(context.credentials, {:id=>id, :env=>context})
-    end
-  end
-
-  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["networkPortTemplate"]["href"] #template by reference
-      network_port_config, network = get_by_reference(input, context)
-    else
-      if input["networkPortTemplate"]["networkPortConfig"]["href"] # configuration by reference
-        network_port_config = CIMI::Model::NetworkPortConfiguration.find(context.href_id(input["networkPortTemplate"]["networkPortConfig"]["href"],:network_port_configurations), context)
-      else #configuration by value
-        network_port_config = get_by_value(request_body, type)
-      end
-      network = CIMI::Model::Network.find(context.href_id(input["networkPortTemplate"]["network"]["href"], :networks), context)
-    end
-    params = {:network_port_config => network_port_config, :network => network, :name=>input["name"], :description=>input["description"], :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_network_port(context.credentials, params)
-  end
-
-  def self.delete!(id, context)
-    context.driver.delete_network_port(context.credentials, id)
-  end
-
-  def perform(action, context, &block)
-    begin
-      if context.driver.send(:"#{action.name}_network_port", context.credentials, self.name)
-        block.callback :success
-      else
-        raise "Operation #{action.name} failed to execute on the NetworkPort #{self.name} "
-      end
-    rescue => e
-      block.callback :failure, e.message
-    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
-
-  def self.get_by_reference(input, context)
-    network_port_template = CIMI::Model::NetworkPortTemplate.find(context.href_id(input["networkPortTemplate"]["href"], :network_port_templates), context)
-    network_port_config = CIMI::Model::NetworkPortConfiguration.find(context.href_id(network_port_template.network_port_config.href, :network_port_configurations), context)
-    network = CIMI::Model::Network.find(context.href_id(network_port_template.network.href, :networks), context)
-    return network_port_config, network
-  end
-
-  def self.get_by_value(request_body, type)
-    if type == :xml
-      xml_arrays = XmlSimple.xml_in(request_body, {"NormaliseSpace"=>2})
-      network_port_config = CIMI::Model::NetworkPortConfiguration.from_xml(XmlSimple.xml_out(xml_arrays["networkPortTemplate"][0]["networkPortConfig"][0]))
-    else
-     json = JSON.parse(request_body)
-      network_port_config = CIMI::Model::NetworkPortConfiguration.from_json(JSON.generate(json["networkPortTemplate"]["networkPortConfig"]))
-    end
-  end
 end

data/lib/cimi/models/network_port_configuration.rb

@@ -25,12 +25,4 @@ class CIMI::Model::NetworkPortConfiguration < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    if id==:all
-      context.driver.network_port_configurations(context.credentials, {:env=>context})
-    else
-      context.driver.network_port_configurations(context.credentials, {:env=>context, :id=>id})
-    end
-  end
-
 end

data/lib/cimi/models/network_port_template.rb

@@ -25,12 +25,4 @@ class CIMI::Model::NetworkPortTemplate < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    if id==:all
-      context.driver.network_port_templates(context.credentials, {:env=>context})
-    else
-      context.driver.network_port_templates(context.credentials, {:env=>context, :id=>id})
-    end
-  end
-
 end

data/lib/cimi/models/network_template.rb

@@ -17,21 +17,11 @@ class CIMI::Model::NetworkTemplate < CIMI::Model::Base
 
   acts_as_root_entity
 
-  ref :network_config, :required => true
-  ref :forwarding_group, :required => true
+  ref :network_config, :class => CIMI::Model::NetworkConfiguration
+  ref :forwarding_group, :class => CIMI::Model::ForwardingGroup
 
   array :operations do
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    network_templates = []
-    if id==:all
-      network_templates = context.driver.network_templates(context.credentials, {:env=>context})
-    else
-      network_templates = context.driver.network_templates(context.credentials, {:env=>context, :id=>id})
-    end
-    network_templates
-  end
-
 end

data/lib/cimi/models/resource.rb

@@ -89,12 +89,6 @@ module CIMI
           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)

data/lib/cimi/models/resource_metadata.rb

@@ -16,6 +16,7 @@
 
 class CIMI::Model::ResourceMetadata < CIMI::Model::Base
 
+  # FIXME: Is this property really needed? (Base model include 'name'
   text :name
 
   text :type_uri
@@ -50,99 +51,4 @@ class CIMI::Model::ResourceMetadata < CIMI::Model::Base
   array :operations do
     scalar :rel, :href
   end
-
-  def self.find(id, context)
-    if id == :all
-      resource_metadata = []
-      CIMI::Model.root_entities.each do |resource_class|
-        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}")
-      resource_metadata_for(resource_class, context)
-    end
-  end
-
-  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 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.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 => 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.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

@@ -124,12 +124,12 @@ class CIMI::Model::Schema
     end
 
     def to_xml(model, xml)
-      conv = convert_to_xml(model[name])
+      conv = convert_to_xml(extract(model))
       xml[xml_name] = [conv] unless conv.empty?
     end
 
     def to_json(model, json)
-      conv = convert_to_json(model[name])
+      conv = convert_to_json(extract(model))
       json[json_name] = conv unless conv.empty?
     end
 
@@ -179,6 +179,14 @@ class CIMI::Model::Schema
         @struct_class ||= ::Struct.new(nil, *@schema.attribute_names)
       end
     end
+    def extract(model)
+      if model.respond_to?("[]")
+        model[name] || {}
+      else
+        {}
+      end
+    end
+
   end
 
   class Ref < CIMI::Model::Schema::Struct
@@ -191,20 +199,6 @@ class CIMI::Model::Schema
       else
         @klass = Class.new(opts[:class]) do |m|
           scalar :href
-
-          def ref_id(ctx)
-            # FIXME: We should use ctx's routes to split
-            # out the :id
-            href.split('/').last
-          end
-
-          def find(ctx)
-            klass.find(ref_id(ctx), ctx)
-          end
-
-          def klass
-            self.class.superclass
-          end
         end
         CIMI::Model::const_set(refname, @klass)
       end
@@ -282,13 +276,21 @@ class CIMI::Model::Schema
     end
 
     def to_xml(model, xml)
-      ary = (model[name] || {}).map { |k, v| { "key" => k, "content" => v } }
-      xml[xml_name] = ary unless ary.empty?
+      mapped = extract(model).map { |k, v| { "key" => k, "content" => v } }
+      xml[xml_name] = mapped unless mapped.empty?
     end
 
     def to_json(model, json)
-      if model[name] && ! model[name].empty?
-        json[json_name] = model[name]
+      h = extract(model)
+      json[json_name] = h unless h.empty?
+    end
+
+    private
+    def extract(model)
+      if model.respond_to?("[]")
+        model[name] || {}
+      else
+        {}
       end
     end
   end
@@ -302,7 +304,10 @@ class CIMI::Model::Schema
         raise "Specify the class of collection entries using :class"
       end
       params[:embedded] = true
-      @collection_class = CIMI::Model::Collection.generate(opts[:class], params)
+      unless opts[:class].collection_class
+        opts[:class].collection_class = CIMI::Model::Collection.generate(opts[:class], params)
+      end
+      @collection_class = opts[:class].collection_class
     end
 
     def from_xml(xml, model)
@@ -422,15 +427,6 @@ class CIMI::Model::Schema
   # +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, :required => opts[:required] } }
@@ -461,12 +457,12 @@ class CIMI::Model::Schema
       add_attributes!([name, opts], Ref)
     end
 
-    def hash(name)
+    def hash_map(name)
       add_attributes!([name, {}], Hash)
     end
 
     def collection(name, opts={})
-      opts[:scope] = self.class
+      opts[:scope] = self
       add_attributes!([name, opts], Collection)
     end
   end