deltacloud-core 0.5.0 → 1.0.0

data/lib/cimi/models/address_collection.rb

@@ -0,0 +1,34 @@
+# 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::AddressCollection < CIMI::Model::Base
+
+  act_as_root_entity :address
+
+  array :addresses do
+    scalar :href
+  end
+
+  def self.default(context)
+    self.new(
+      :id => context.addresses_url,
+      :name => 'default',
+      :created => Time.now,
+      :description => "#{context.driver.name.capitalize} AddressCollection",
+      :addresses => CIMI::Model::Address.all(context).map { |addr| { :href => addr.id } }
+    )
+  end
+
+end

data/lib/cimi/models/address_template.rb

@@ -0,0 +1,54 @@
+# 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::AddressTemplate < CIMI::Model::Base
+
+  text :ip
+
+  text :hostname
+
+  text :allocation
+
+  text :default_gateway
+
+  text :dns
+
+  text :mac_address
+
+  text :protocol
+
+  text :mask
+
+  href :network
+
+  array :operations do
+    scalar :rel, :href
+  end
+
+  def self.find(id, context)
+    if id==:all
+      context.driver.address_templates(context.credentials, {:env=>context})
+    else
+      context.driver.address_templates(context.credentials, {:id=>id, :env=>context})
+    end
+  end
+
+  def self.create(request_body, context, type)
+  end
+
+  def self.delete!(id, context)
+  end
+
+end

data/lib/cimi/models/address_template_collection.rb

@@ -0,0 +1,34 @@
+# 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::AddressTemplateCollection < CIMI::Model::Base
+
+  act_as_root_entity :address_template
+
+  array :address_templates do
+    scalar :href
+  end
+
+  def self.default(context)
+    self.new(
+      :id => context.address_templates_url,
+      :name => 'default',
+      :created => Time.now,
+      :description => "#{context.driver.name.capitalize} AddressTemplateCollection",
+      :address_templates => CIMI::Model::AddressTemplate.all(context).map { |addr| { :href => addr.id } }
+    )
+  end
+
+end

data/lib/cimi/{model → models}/base.rb

@@ -131,7 +131,7 @@ class CIMI::Model::Base
 
     # Return Array of links to current CIMI object
     def all_uri(context)
-      self.all(context).map { |e| { :href => e.uri } }
+      self.all(context).map { |e| { :href => e.id } }
     end
   end
 
@@ -197,7 +197,7 @@ class CIMI::Model::Base
   #
   # Common attributes for all resources
   #
-  text :uri, :name, :description, :created
+  text :id, :name, :description, :created
 
   # FIXME: this doesn't match with JSON
   hash :property, :content => :value do

data/lib/cimi/{model → models}/cloud_entry_point.rb

@@ -23,18 +23,16 @@ class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
     self.new(entities(context).merge({
       :name => context.driver.name,
       :description => "Cloud Entry Point for the Deltacloud #{context.driver.name} driver",
-      :uri => context.cloudEntryPoint_url,
+      :id => context.cloudEntryPoint_url,
       :created => Time.now,
-      :entity_metadata => EntityMetadata.all_uri(context)
+      :entity_metadata => CIMI::Model::EntityMetadata.all_uri(context)
     }))
   end
 
   # Return an Hash of the CIMI root entities used in CloudEntryPoint
   def self.entities(context)
     CIMI::Model.root_entities.inject({}) do |result, entity|
-      if context.respond_to? :"#{entity.underscore}_url"
-        result[entity.underscore] = { :href => context.send(:"#{entity.underscore}_url") }
-      end
+      result[entity.underscore] = { :href => context.send(:"#{entity.underscore}_url") }
       result
     end
   end

data/lib/cimi/{model → models}/entity_metadata.rb

@@ -16,7 +16,7 @@
 
 class CIMI::Model::EntityMetadata < CIMI::Model::Base
 
-text :type_uri
+  text :type_uri
 
   array :attributes do
     scalar :name
@@ -52,7 +52,7 @@ text :type_uri
   end
 
   def self.metadata_from_deltacloud_features(cimi_entity, dcloud_entity, context)
-    deltacloud_features = context.driver.features(dcloud_entity)
+    deltacloud_features = context.driver.class.features[dcloud_entity]
     metadata_attributes = deltacloud_features.map{|f| attributes_from_feature(f)}
     from_feature(cimi_entity, context, metadata_attributes.flatten!)
   end
@@ -64,11 +64,12 @@ text :type_uri
   private
 
   def self.attributes_from_feature(feature)
-    feature.operations.first.params.inject([]) do |result, param|
-      result << {
-        :name=>(feature.name == :user_name ? :name : param[0]),
+    feature = CIMI::FakeCollection.feature(feature)
+    feature.operations.first.params_array.map do |p|
+      {
+        :name=> p.name,
         :type=> "xs:string",
-        :required=> (param[1] and param[1].optional?) ? "false" : "true",
+        :required=> p.required? ? "true" : "false",
         :constraints=> (feature.constraints.empty? ? (feature.description.nil? ? "" : feature.description): feature.constraints)
       }
     end

data/lib/cimi/{model → models}/entity_metadata_collection.rb

@@ -21,10 +21,10 @@ class CIMI::Model::EntityMetadataCollection < CIMI::Model::Base
 
   def self.default(context)
     self.new(
-      :uri => context.entity_metadata_url,
+      :id => context.entity_metadata_url,
       :name => 'default',
       :created => Time.now,
-      :entity_metadata => EntityMetadata.all_uri(context)
+      :entity_metadata => CIMI::Model::EntityMetadata.all_uri(context)
    )
   end
 

data/lib/cimi/{model → models}/errors.rb

@@ -25,6 +25,14 @@ module CIMI::Model
 
   end
 
+  class BadRequest < StandardError
+    attr_accessor :code
+    def initialize(msg="")
+      super(msg)
+      self.code=400
+    end
+  end
+
   class NotImplemented < StandardError
     attr_accessor :code
 

data/lib/cimi/{model → models}/machine.rb

@@ -13,8 +13,6 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-require 'deltacloud/models/instance_address'
-
 class CIMI::Model::Machine < CIMI::Model::Base
 
   text :state
@@ -82,6 +80,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
     hardware_profile_id = machine_template['machineConfig'][0]["href"].split('/').last
     image_id = machine_template['machineImage'][0]["href"].split('/').last
     additional_params = {}
+    additional_params[:name] =xml['name'][0] if xml['name']
     if machine_template.has_key? 'machineAdmin'
       additional_params[:keyname] = machine_template['machineAdmin'][0]["href"].split('/').last
     end
@@ -109,7 +108,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   def self.create_entity_metadata(context)
     cimi_entity = self.name.split("::").last
-    metadata = EntityMetadata.metadata_from_deltacloud_features(cimi_entity, :instances, context)
+    metadata = CIMI::Model::EntityMetadata.metadata_from_deltacloud_features(cimi_entity, :instances, context)
     unless metadata.includes_attribute?(:name)
       metadata.attributes << {:name=>"name", :required=>"false",
                    :constraints=>"Determined by the cloud provider", :type=>"xs:string"}
@@ -135,15 +134,16 @@ class CIMI::Model::Machine < CIMI::Model::Base
   private
 
   def self.from_instance(instance, context)
+    cpu =  memory = disks = (instance.instance_profile.id == "opaque")? "n/a" : nil
     self.new(
       :name => instance.id,
       :description => instance.name,
       :created => instance.launch_time,
-      :uri => context.machine_url(instance.id),
+      :id => context.machine_url(instance.id),
       :state => convert_instance_state(instance.state),
-      :cpu => convert_instance_cpu(instance.instance_profile, context),
-      :memory => convert_instance_memory(instance.instance_profile, context),
-      :disks => convert_instance_storage(instance.instance_profile, context),
+      :cpu => cpu || convert_instance_cpu(instance.instance_profile, context),
+      :memory => memory || convert_instance_memory(instance.instance_profile, context),
+      :disks => disks || convert_instance_storage(instance.instance_profile, context),
       :network_interfaces => convert_instance_addresses(instance),
       :operations => convert_instance_actions(instance, context),
       :volumes=>convert_storage_volumes(instance, context),
@@ -170,14 +170,14 @@ class CIMI::Model::Machine < CIMI::Model::Base
   def self.convert_instance_cpu(profile, context)
     cpu_override = profile.overrides.find { |p, v| p == :cpu }
     if cpu_override.nil?
-      MachineConfiguration.find(profile.id, context).cpu
+      CIMI::Model::MachineConfiguration.find(profile.id, context).cpu
     else
       cpu_override[1]
     end
   end
 
   def self.convert_instance_memory(profile, context)
-    machine_conf = MachineConfiguration.find(profile.name, context)
+    machine_conf = CIMI::Model::MachineConfiguration.find(profile.name, context)
     memory_override = profile.overrides.find { |p, v| p == :memory }
     {
       :quantity => memory_override.nil? ? machine_conf.memory[:quantity] : memory_override[1],
@@ -186,7 +186,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
   end
 
   def self.convert_instance_storage(profile, context)
-    machine_conf = MachineConfiguration.find(profile.name, context)
+    machine_conf = CIMI::Model::MachineConfiguration.find(profile.name, context)
     storage_override = profile.overrides.find { |p, v| p == :storage }
     [
       { :capacity => {

data/lib/cimi/{model → models}/machine_admin.rb

@@ -51,7 +51,7 @@ class CIMI::Model::MachineAdmin < CIMI::Model::Base
       :username => key.username,
       :password => key.is_password? ? key.password : key.fingerprint,
       :key => key.is_key? ? key.pem_rsa_key : nil,
-      :uri => context.machine_admin_url(key.id),
+      :id => context.machine_admin_url(key.id),
       :created => Time.now
     )
   end

data/lib/cimi/{model → models}/machine_admin_collection.rb

@@ -23,11 +23,11 @@ class CIMI::Model::MachineAdminCollection < CIMI::Model::Base
 
   def self.default(context)
     self.new(
-      :uri => context.machine_admins_url,
+      :id => context.machine_admins_url,
       :name => 'default',
       :created => Time.now,
       :description => "#{context.driver.name.capitalize} MachineAdminCollection",
-      :machine_admins => MachineAdmin.all_uri(context)
+      :machine_admins => CIMI::Model::MachineAdmin.all_uri(context)
     )
   end
 

data/lib/cimi/{model → models}/machine_collection.rb

@@ -23,11 +23,11 @@ class CIMI::Model::MachineCollection < CIMI::Model::Base
 
   def self.default(context)
     self.new(
-      :uri => context.machines_url,
+      :id => context.machines_url,
       :name => 'default',
       :created => Time.now,
       :description => "#{context.driver.name.capitalize} MachineCollection",
-      :machines => Machine.all_uri(context)
+      :machines => CIMI::Model::Machine.all_uri(context)
     )
   end
 

data/lib/cimi/{model → models}/machine_configuration.rb

@@ -51,15 +51,18 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
   def self.from_hardware_profile(profile, context)
     # We accept just profiles with all properties set
     return unless profile.memory or profile.cpu or profile.storage
+    memory = profile.memory.value || profile.memory.default
+    cpu = profile.cpu.value || profile.cpu.default
+    storage = profile.storage.value || profile.storage.default
     machine_hash = {
       :name => profile.name,
-      :description => "Machine Configuration with #{profile.memory.value} #{profile.memory.unit} "+
-        "of memory and #{profile.cpu.value} CPU",
-      :cpu => profile.cpu.value,
+      :description => "Machine Configuration with #{memory} #{profile.memory.unit} "+
+        "of memory and #{cpu} CPU",
+      :cpu => cpu,
       :created => Time.now.to_s,  # FIXME: DC hardware_profile has no mention about created_at
-      :memory => { :quantity => profile.memory.value, :units => profile.memory.unit },
-      :disks => [ { :capacity => { :quantity => profile.storage.value, :units => profile.storage.unit } } ],
-      :uri => context.machine_configuration_url(profile.name)
+      :memory => { :quantity => profile.memory.value || profile.memory.default, :units => profile.memory.unit },
+      :disks => [ { :capacity => { :quantity => profile.storage.value || profile.storage.default, :units => profile.storage.unit } } ],
+      :id => context.machine_configuration_url(profile.name)
     }
     self.new(machine_hash)
   end

data/lib/cimi/{model → models}/machine_configuration_collection.rb

@@ -23,11 +23,11 @@ class CIMI::Model::MachineConfigurationCollection < CIMI::Model::Base
 
   def self.default(context)
     self.new(
-      :uri => context.machine_configurations_url,
+      :id => context.machine_configurations_url,
       :name => 'default',
       :created => Time.now,
       :description => "#{context.driver.name.capitalize} MachineConfigurationCollection",
-      :machine_configurations => MachineConfiguration.all_uri(context)
+      :machine_configurations => CIMI::Model::MachineConfiguration.all_uri(context)
     )
   end
 

data/lib/cimi/{model → models}/machine_image.rb

@@ -36,7 +36,7 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
   def self.from_image(image, context)
     self.new(
       :name => image.id,
-      :uri => context.machine_image_url(image.id),
+      :id => context.machine_image_url(image.id),
       :description => image.description,
       :created => Time.now.to_s,
       :image_location => { :href => "#{context.driver.name}://#{image.id}" } # FIXME

data/lib/cimi/{model → models}/machine_image_collection.rb

@@ -23,11 +23,11 @@ class CIMI::Model::MachineImageCollection < CIMI::Model::Base
 
   def self.default(context)
     self.new(
-      :uri => context.machine_images_url,
+      :id => context.machine_images_url,
       :name => 'default',
       :created => Time.now,
       :description => "#{context.driver.name.capitalize} MachineImageCollection",
-      :machine_images => MachineImage.all_uri(context)
+      :machine_images => CIMI::Model::MachineImage.all_uri(context)
     )
   end
 

data/lib/cimi/{model → models}/machine_template_collection.rb

@@ -23,11 +23,11 @@ class CIMI::Model::MachineTemplateCollection < CIMI::Model::Base
 
   def self.default(context)
     self.new(
-      :uri => context.machine_template_url,
+      :id => context.machine_template_url,
       :name => 'default',
       :created => Time.now,
       :description => "#{context.driver.name.capitalize} MachineTemplateCollection",
-      :machine_templates => MachineTemplate.all_uri(context)
+      :machine_templates => CIMI::Model::MachineTemplate.all_uri(context)
     )
   end
 

data/lib/cimi/models/network.rb

@@ -0,0 +1,109 @@
+# 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::Network < CIMI::Model::Base
+
+  text :state
+
+  text :access
+
+  text :bandwidth_limit
+
+  text :traffic_priority
+
+  text :max_traffic_delay
+
+  text :max_traffic_loss
+
+  text :max_traffic_jitter
+
+  href :routing_group
+
+  href :event_log
+
+  array :meters do
+    scalar :href
+  end
+
+  array :operations do
+    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
+    networks
+  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["networkTemplate"]["href"] #template by reference
+      network_config, routing_group = get_by_reference(input, context)
+    else
+      if input["networkTemplate"]["networkConfig"]["href"] # configuration by reference
+        network_config = CIMI::Model::NetworkConfiguration.find(context.href_id(input["networkTemplate"]["networkConfig"]["href"],
+                                                                                :network_configurations), context)
+      else #configuration by value
+        network_config = get_by_value(request_body, type)
+      end
+      routing_group = CIMI::Model::RoutingGroup.find(context.href_id(input["networkTemplate"]["routingGroup"]["href"],
+                                                                     :routing_groups), context)
+    end
+    params = {:network_config => network_config, :routing_group => routing_group, :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(context.credentials, params)
+  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
+
+  private
+
+  def self.get_by_reference(input, context)
+    network_template = CIMI::Model::NetworkTemplate.find(context.href_id(input["networkTemplate"]["href"], :network_templates), context)
+    network_config = CIMI::Model::NetworkConfiguration.find(context.href_id(network_template.network_config.href, :network_configurations), context)
+    routing_group = CIMI::Model::RoutingGroup.find(context.href_id(network_template.routing_group.href, :routing_groups), context)
+    return network_config, routing_group
+  end
+
+  def self.get_by_value(request_body, type)
+    if type == :xml
+      xml_arrays = XmlSimple.xml_in(request_body, {"NormaliseSpace"=>2})
+      network_config = CIMI::Model::NetworkConfiguration.from_xml(XmlSimple.xml_out(xml_arrays["networkTemplate"][0]["networkConfig"][0]))
+    else
+     json = JSON.parse(request_body)
+      network_config = CIMI::Model::NetworkConfiguration.from_json(JSON.generate(json["networkTemplate"]["networkConfig"]))
+    end
+  end
+
+end