deltacloud-core 1.1.1 → 1.1.2

data/lib/cimi/models/network_create.rb

@@ -0,0 +1,43 @@
+# 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.
+
+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

@@ -43,31 +43,31 @@ class CIMI::Model::NetworkPort < CIMI::Model::Base
 
   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["vspTemplate"]["href"] #template by reference
-      vsp_config, network = get_by_reference(input, context)
+    if input["networkPortTemplate"]["href"] #template by reference
+      network_port_config, network = get_by_reference(input, context)
     else
-      if input["vspTemplate"]["vspConfig"]["href"] # configuration by reference
-        vsp_config = CIMI::Model::VSPConfiguration.find(context.href_id(input["vspTemplate"]["vspConfig"]["href"],:vsp_configurations), context)
+      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
-        vsp_config = get_by_value(request_body, type)
+        network_port_config = get_by_value(request_body, type)
       end
-      network = CIMI::Model::Network.find(context.href_id(input["vspTemplate"]["network"]["href"], :networks), context)
+      network = CIMI::Model::Network.find(context.href_id(input["networkPortTemplate"]["network"]["href"], :networks), context)
     end
-    params = {:vsp_config => vsp_config, :network => network, :name=>input["name"], :description=>input["description"], :env=>context}
+    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_vsp(context.credentials, params)
+    context.driver.create_network_port(context.credentials, params)
   end
 
   def self.delete!(id, context)
-    context.driver.delete_vsp(context.credentials, id)
+    context.driver.delete_network_port(context.credentials, id)
   end
 
   def perform(action, context, &block)
     begin
-      if context.driver.send(:"#{action.name}_vsp", context.credentials, self.name)
+      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 VSP #{self.name} "
+        raise "Operation #{action.name} failed to execute on the NetworkPort #{self.name} "
       end
     rescue => e
       block.callback :failure, e.message
@@ -91,19 +91,19 @@ class CIMI::Model::NetworkPort < CIMI::Model::Base
   private
 
   def self.get_by_reference(input, context)
-    vsp_template = CIMI::Model::VSPTemplate.find(context.href_id(input["vspTemplate"]["href"], :vsp_templates), context)
-    vsp_config = CIMI::Model::VSPConfiguration.find(context.href_id(vsp_template.vsp_config.href, :vsp_configurations), context)
-    network = CIMI::Model::Network.find(context.href_id(vsp_template.network.href, :networks), context)
-    return vsp_config, network
+    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})
-      vsp_config = CIMI::Model::VSPConfiguration.from_xml(XmlSimple.xml_out(xml_arrays["vspTemplate"][0]["vspConfig"][0]))
+      network_port_config = CIMI::Model::NetworkPortConfiguration.from_xml(XmlSimple.xml_out(xml_arrays["networkPortTemplate"][0]["networkPortConfig"][0]))
     else
      json = JSON.parse(request_body)
-      vsp_config = CIMI::Model::VSPConfiguration.from_json(JSON.generate(json["vspTemplate"]["vspConfig"]))
+      network_port_config = CIMI::Model::NetworkPortConfiguration.from_json(JSON.generate(json["networkPortTemplate"]["networkPortConfig"]))
     end
   end
 end

data/lib/cimi/models/network_template.rb

@@ -17,9 +17,8 @@ class CIMI::Model::NetworkTemplate < CIMI::Model::Base
 
   acts_as_root_entity
 
-  href :network_config
-
-  href :forwarding_group
+  ref :network_config, :required => true
+  ref :forwarding_group, :required => true
 
   array :operations do
     scalar :rel, :href

data/lib/cimi/models/resource.rb

@@ -112,10 +112,18 @@ module CIMI
         end
 
         def parse(text, content_type)
-          if content_type == "application/xml"
-            from_xml(text)
+          if ["application/xml", "text/xml"].include? content_type
+            entity = from_xml(text)
+            entity.validate!(:xml)
+            entity
           elsif content_type == "application/json"
-            from_json(text)
+            if text.kind_of? StringIO
+              entity = from_json(text.read)
+            else
+              entity = from_json(text)
+            end
+            entity.validate!(:json)
+            entity
           else
             raise "Can not parse content type #{content_type}"
           end
@@ -145,6 +153,10 @@ module CIMI
           xml["resourceURI"] = resource_uri
           XmlSimple.xml_out(xml, :root_name => xml_tag_name)
         end
+
+        def required_attributes
+          @schema.required_attributes
+        end
       end
 
       # END of class methods
@@ -172,6 +184,13 @@ module CIMI
         end
       end
 
+      def validate!(format=:xml)
+        failed_attrs = self.class.required_attributes.map do |attr|
+          attr.send("#{format}_name") unless attr.valid?(send(attr.name))
+        end.compact
+        raise CIMI::Model::ValidationError.new(failed_attrs, format) unless failed_attrs.empty?
+      end
+
       def base_id
         self.id || @base_id
       end

data/lib/cimi/models/schema.rb

@@ -24,11 +24,13 @@ class CIMI::Model::Schema
   #
   class Attribute
     attr_reader :name, :xml_name, :json_name
+    attr_reader :required
 
     def initialize(name, opts = {})
       @name = name
       @xml_name = opts[:xml_name] || name.to_s.camelize(true)
       @json_name = opts[:json_name] || name.to_s.camelize(true)
+      @required = opts[:required] || false
     end
 
     def from_xml(xml, model)
@@ -50,6 +52,14 @@ class CIMI::Model::Schema
     def convert(value)
       value
     end
+
+    def required?
+      @required
+    end
+
+    def valid?(value)
+      !value.nil? and !value.to_s.empty?
+    end
   end
 
   class Scalar < Attribute
@@ -88,12 +98,9 @@ class CIMI::Model::Schema
 
     attr_accessor :schema
 
-    def initialize(name, opts, &block)
+    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"
@@ -102,7 +109,7 @@ class CIMI::Model::Schema
       else
         @schema = CIMI::Model::Schema.new
         @schema.instance_eval(&block) if block_given?
-        @schema.scalar(content, :text => :direct) if content
+        @schema.scalar(content, :text => :direct, :required => opts[:required]) if content
       end
     end
 
@@ -150,9 +157,69 @@ class CIMI::Model::Schema
       json
     end
 
+    def valid?(value)
+      @schema.required_attributes.all? { |a|
+        a.valid?(value.send(a.name))
+      }
+    end
+
+    def convert(value)
+      if @klass
+        @klass.new(value || {})
+      else
+        super(value)
+      end
+    end
+
     private
     def struct
-      @struct_class ||= ::Struct.new(nil, *@schema.attribute_names)
+      if @klass
+        @klass
+      else
+        @struct_class ||= ::Struct.new(nil, *@schema.attribute_names)
+      end
+    end
+  end
+
+  class Ref < CIMI::Model::Schema::Struct
+
+    def initialize(name, opts={}, &block)
+      raise 'The :class attribute must be set' unless opts[:class]
+      refname = "#{opts[:class].name.split("::").last}Ref"
+      if CIMI::Model::const_defined?(refname)
+        @klass = CIMI::Model::const_get(refname)
+      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
+      @klass.class_eval { def href?; !href.nil?; end }
+      opts[:schema] = @klass.schema
+      super(name, opts, &block)
+    end
+
+    # The 'ref' could be the reference to a CIMI entity or the full CIMI
+    # entity representation.
+    #
+    def valid?(value)
+      !value.href.nil? || @klass.schema.required_attributes.all? { |a|
+        a.valid?(value.send(a.name))
+      }
     end
   end
 
@@ -166,8 +233,15 @@ class CIMI::Model::Schema
       unless opts[:xml_name]
         opts[:xml_name] = name.to_s.singularize.camelize.uncapitalize
       end
+      if opts[:ref] && block_given?
+        raise "Provide only one of :ref or a block"
+      end
       super(name, opts)
-      @struct = Struct.new(name, opts, &block)
+      if opts[:ref]
+        @struct = Ref.new(name, :class=> opts[:ref])
+      else
+        @struct = Struct.new(name, opts, &block)
+      end
     end
 
     def from_xml(xml, model)
@@ -337,6 +411,10 @@ class CIMI::Model::Schema
     @attributes.map { |a| a.name }
   end
 
+  def required_attributes
+    @attributes.select { |a| a.required? }
+  end
+
   #
   # The DSL
   #
@@ -355,7 +433,7 @@ class CIMI::Model::Schema
 
     def href(*args)
       opts = args.extract_opts!
-      args.each { |arg| struct(arg, opts) { scalar :href } }
+      args.each { |arg| struct(arg, opts) { scalar :href, :required => opts[:required] } }
     end
 
     def text(*args)
@@ -375,6 +453,14 @@ class CIMI::Model::Schema
       add_attributes!([name, opts], Struct, &block)
     end
 
+    def ref(name, opts={})
+      unless opts[:class]
+        s = name.to_s.camelize.gsub(/Config$/, "Configuration")
+        opts[:class] = CIMI::Model::const_get(s)
+      end
+      add_attributes!([name, opts], Ref)
+    end
+
     def hash(name)
       add_attributes!([name, {}], Hash)
     end

data/lib/cimi/models/system.rb

@@ -0,0 +1,67 @@
+# 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.
+
+class CIMI::Model::System < CIMI::Model::Base
+
+  acts_as_root_entity
+
+  text :state
+
+#  collection :systems, :class => CIMI::Model::SystemSystem
+#  collection :machines, :class => CIMI::Model::SystemMachine
+#  collection :credentials, :class => CIMI::Model::SystemCredential
+#  collection :volumes, :class => CIMI::Model::SystemVolume
+#  collection :networks, :class => CIMI::Model::SystemNetwork
+#  collection :network_ports, :class => CIMI::Model::SystemNetworkPort
+#  collection :addresses, :class => CIMI::Model::SystemAddress
+#  collection :forwarding_groups, :class => CIMI::Model::SystemForwardingGroup
+
+#  array :meters do
+#    scalar :href
+#  end
+
+#  href :event_log
+
+  array :operations do
+    scalar :rel, :href
+  end
+
+  def self.find(id, context)
+    if id == :all
+      systems = context.driver.systems(context.credentials, {:env=>context})
+    else
+      systems = context.driver.systems(context.credentials, {:env=>context, :id=>id})
+      raise CIMI::Model::NotFound unless systems.first
+      systems.first
+    end
+  end
+
+  def perform(action, context, &block)
+    begin
+      if context.driver.send(:"#{action.name}_system", context.credentials, self.id.split("/").last)
+        block.callback :success
+      else
+        raise "Operation failed to execute on given System"
+      end
+    rescue => e
+      block.callback :failure, e.message
+    end
+  end
+
+  def self.delete!(id, context)
+    context.driver.destroy_system(context.credentials, id)
+  end
+
+end

data/lib/cimi/models/system_template.rb

@@ -0,0 +1,63 @@
+# 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.
+
+class CIMI::Model::SystemTemplate < CIMI::Model::Base
+
+  acts_as_root_entity
+
+  array :component_descriptors do
+    text :name, :description
+    hash :properties
+    text :type
+    #component_template, comprises:
+#    struct :machine_template, :class => CIMI::Model::MachineTemplate
+#    struct :system_template, :class => CIMI::Model::SystemTemplate
+#    struct :credential_template, :class => CIMI::Model::CredentialTemplate
+#    struct :volume_template, :class => CIMI::Model::VolumeTemplate
+#    struct :network_template, :class => CIMI::Model::NetworkTemplate
+#    struct :network_port_template, :class => CIMI::Model::NetworkPortTemplate
+#    struct :forwarding_group_template, :class => CIMI::Model::ForwardingGroupTemplate
+#    struct :address_template, :class => CIMI::Model::AddressTemplate
+    text :quantity
+  end
+
+#  array :meter_templates do
+#    scalar :href
+#  end
+
+#  href :event_log_template
+
+  array :operations do
+    scalar :rel, :href
+  end
+
+  class << self
+    def find(id, context)
+      if id == :all
+        templates = context.driver.system_templates(context.credentials, {:env=>context})
+      else
+        templates = context.driver.system_templates(context.credentials, {:env=>context, :id=>id})
+        raise CIMI::Model::NotFound unless templates.first
+        templates.first
+      end
+    end
+
+    def delete!(id, context)
+      context.driver.destroy_system_template(context.credentials, id)
+    end
+
+  end
+
+end