deltacloud-core 1.1.2 → 1.1.3

data/lib/cimi/models/credential_template.rb

@@ -19,6 +19,4 @@ class CIMI::Model::CredentialTemplate < CIMI::Model::Base
   text :password, :required => true
   text :key, :required => true
 
-  # TODO: tbd
-
 end

data/lib/cimi/models/disk.rb

@@ -22,60 +22,4 @@ class CIMI::Model::Disk < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(instance, machine_config, context, id=:all)
-    if id == :all
-      name = instance.id+"_disk_" #assuming one disk for now...
-
-      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
-          hw_profile = context.driver.hardware_profile(context.credentials, :id => instance.instance_profile.name)
-          if hw_profile.storage
-            capacity = context.to_kibibyte(hw_profile.storage.value, 'MB')
-          end
-        end
-
-        return [] unless capacity
-
-        [self.new(
-          :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
-        )]
-      end
-    else
-    end
-  end
-
-  def self.collection_for_instance(instance_id, context)
-    instance = context.driver.instance(context.credentials, :id => instance_id)
-    disks = find(instance, nil, context)
-    unless CIMI::Model.const_defined?('DiskCollection')
-      collection_class = CIMI::Model::Collection.generate(self)
-    else
-      collection_class = CIMI::Model::DiskCollection
-    end
-    collection_class.new(
-      :id => context.url("/machines/#{instance_id}/disks"),
-      :name => 'default',
-      :count => disks.size,
-      :description => "Disk collection for Machine #{instance_id}",
-      :entries => disks
-    )
-  end
-
 end

data/lib/cimi/models/forwarding_group.rb

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

data/lib/cimi/models/forwarding_group_template.rb

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

data/lib/cimi/models/machine.rb

@@ -17,10 +17,10 @@ class CIMI::Model::Machine < CIMI::Model::Base
 
   acts_as_root_entity
 
-  resource_attr :realm, :required => false,
-    :constraints => lambda { |c| c.driver.realms(c.credentials).map { |r| r.id } }
-
-  resource_attr :machine_image, :required => false, :type => :href
+  # DC-specific Extension
+  text :realm, :required => false
+  # DC-specific extension
+  href :machine_image, :required => false
 
   text :state
   text :cpu
@@ -38,129 +38,4 @@ class CIMI::Model::Machine < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    instances = []
-    if id == :all
-      instances = context.driver.instances(context.credentials)
-      instances.map { |instance| from_instance(instance, context) }.compact
-    else
-      instance = context.driver.instance(context.credentials, :id => id)
-      raise CIMI::Model::NotFound unless instance
-      from_instance(instance, context)
-    end
-  end
-
-  def perform(action, context, &block)
-    begin
-      if context.driver.send(:"#{action.name}_instance", context.credentials, self.id.split("/").last)
-        block.callback :success
-      else
-        raise "Operation failed to execute on given Machine"
-      end
-    rescue => e
-      block.callback :failure, e.message
-    end
-  end
-
-  def self.delete!(id, context)
-    context.driver.destroy_instance(context.credentials, id)
-    new(:id => id).destroy
-  end
-
-  #returns the newly attach machine_volume
-  def self.attach_volume(volume, location, context)
-    context.driver.attach_storage_volume(context.credentials,
-     {:id=>volume, :instance_id=>context.params[:id], :device=>location})
-    CIMI::Model::MachineVolume.find(context.params[:id], context, volume)
-  end
-
-  #returns the machine_volume_collection for the given machine
-  def self.detach_volume(volume, location, context)
-    context.driver.detach_storage_volume(context.credentials,
-     {:id=>volume, :instance_id=>context.params[:id], :device=>location})
-    CIMI::Model::MachineVolume.collection_for_instance(context.params[:id], context)
-  end
-
-  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)
-    machine_spec = {
-      :name => instance.name,
-      :created => instance.launch_time.nil? ? Time.now.xmlschema : Time.parse(instance.launch_time.to_s).xmlschema,
-      :description => "No description set for Machine #{instance.name}",
-      :id => context.machine_url(instance.id),
-      :state => convert_instance_state(instance.state),
-      :cpu => cpu || convert_instance_cpu(instance.instance_profile, context),
-      :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)
-    }
-    if context.expand? :disks
-      machine_spec[:disks] = CIMI::Model::Disk.find(instance, machine_conf, context, :all)
-    end
-    if context.expand? :volumes
-      machine_spec[:volumes] = CIMI::Model::MachineVolume.find(instance.id, context, :all)
-    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
-    self.new(machine_spec)
-  end
-
-  # FIXME: This will convert 'RUNNING' state to 'STARTED'
-  # which is defined in CIMI (p65)
-  #
-  def self.convert_instance_state(state)
-    case state
-      when "RUNNING" then "STARTED"
-      when "PENDING" then "CREATING" #aruba only exception... could be "STARTING" here
-      else state
-    end
-  end
-
-  def self.convert_instance_cpu(profile, context)
-    cpu_override = profile.overrides.find { |p, v| p == :cpu }
-    if cpu_override.nil?
-      CIMI::Model::MachineConfiguration.find(profile.id, context).cpu
-    else
-      cpu_override[1]
-    end
-  end
-
-  def self.convert_instance_memory(profile, context)
-    machine_conf = CIMI::Model::MachineConfiguration.find(profile.name, context)
-    memory_override = profile.overrides.find { |p, v| p == :memory }
-    memory_override.nil? ? machine_conf.memory.to_i : context.to_kibibyte(memory_override[1].to_i,"MB")
-  end
-
-  def self.convert_instance_addresses(instance)
-    (instance.public_addresses + instance.private_addresses).collect do |address|
-      {
-        :hostname => address.is_hostname? ? address : nil,
-        :mac_address => address.is_mac? ? address : nil,
-        :state => 'Active',
-        :protocol => 'IPv4',
-        :address => address.is_ipv4? ? address : nil,
-        :allocation => 'Static'
-      }
-    end
-  end
-
-  def self.convert_instance_actions(instance, context)
-    actions = instance.actions.collect do |action|
-      action = :restart if action == :reboot
-      name = action
-      name = :delete if action == :destroy # In CIMI destroy operation become delete
-      { :href => context.send(:"#{action}_machine_url", instance.id), :rel => "http://schemas.dmtf.org/cimi/1/action/#{name}" }
-    end
-    actions <<  { :href => context.send(:"machine_images_url"), :rel => "http://schemas.dmtf.org/cimi/1/action/capture" } if instance.can_create_image?
-    actions
-  end
-
-  def self.convert_storage_volumes(instance, context)
-    instance.storage_volumes ||= [] #deal with nilpointers
-    instance.storage_volumes.map{|vol| {:href=>context.volume_url(vol.keys.first),
-                                       :initial_location=>vol.values.first} }
-  end
-
 end

data/lib/cimi/models/machine_configuration.rb

@@ -30,35 +30,4 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    profiles = []
-    if id == :all
-      profiles = context.driver.hardware_profiles(context.credentials)
-      profiles.map { |profile| from_hardware_profile(profile, context) }.compact
-    else
-      profile = context.driver.hardware_profile(context.credentials, id)
-      from_hardware_profile(profile, context)
-    end
-  end
-
-  private
-  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 ? context.to_kibibyte((profile.memory.value || profile.memory.default), profile.memory.unit) : nil
-    cpu = (profile.cpu ? (profile.cpu.value || profile.cpu.default) : nil )
-    storage = profile.storage ? context.to_kibibyte((profile.storage.value || profile.storage.default), profile.storage.unit) :  nil
-    machine_hash = {
-      :name => profile.name,
-      :description => "Machine Configuration with #{memory} KiB "+
-        "of memory and #{cpu} CPU",
-      :cpu => ( cpu.to_i.to_s if cpu ) ,
-      :created => Time.now.xmlschema,  # FIXME: DC hardware_profile has no mention about created_at
-      :memory => (memory if memory),
-      :disks => (  [ { :capacity => storage, :format => (profile.storage.respond_to?(:format) ? profile.storage.format : "unknown")  } ] if storage ), #no format attr for hwp - may be added if providers support...,
-      :id => context.machine_configuration_url(profile.id)
-    }
-    self.new(machine_hash)
-  end
-
 end

data/lib/cimi/models/machine_create.rb

@@ -14,36 +14,8 @@
 # under the License.
 
 class CIMI::Model::MachineCreate < CIMI::Model::Base
+
   ref :machine_template
   text :realm
 
-  def create(ctx)
-    params = {}
-    if machine_template.href
-      template = machine_template.find(ctx)
-      params[:hwp_id] = template.machine_config.ref_id(ctx)
-      params[:initial_state] = template.initial_state
-      image_id = template.machine_image.ref_id(ctx)
-    else
-      # FIXME: What if either of these href's isn't there ? What if the user
-      # tries to override some aspect of the machine_config/machine_image ?
-      params[:hwp_id] = machine_template.machine_config.href.split('/').last
-      params[:initial_state] = machine_template.initial_state
-      image_id = machine_template.machine_image.href.split('/').last
-      if machine_template.credential.href
-        params[:keyname] = machine_template.credential.href.split('/').last
-      end
-    end
-
-    params[:name] = name if name
-    params[:realm_id] = realm if realm
-    instance = ctx.driver.create_instance(ctx.credentials, image_id, params)
-
-    result = CIMI::Model::Machine::from_instance(instance, ctx)
-    result.name = name if name
-    result.description = description if description
-    result.property = property if property
-    result.save
-    result
-  end
 end

data/lib/cimi/models/machine_image.rb

@@ -26,32 +26,4 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  def self.find(id, context)
-    images = []
-    if id == :all
-      images = context.driver.images(context.credentials)
-      images.map { |image| from_image(image, context) }
-    else
-      image = context.driver.image(context.credentials, :id => id)
-      from_image(image, context)
-    end
-  end
-
-  def self.from_image(image, context)
-    self.new(
-      :id => context.machine_image_url(image.id),
-      :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
-    )
-  end
-
-  def self.delete!(image_id, context)
-    context.driver.destroy_image(context.credentials, image_id)
-    new(:id => image_id).destroy
-  end
-
 end

data/lib/cimi/models/machine_image_create.rb

@@ -19,23 +19,4 @@ class CIMI::Model::MachineImageCreate < CIMI::Model::Base
   text :image_location, :required => true
   href :related_image
 
-  def create(context)
-    validate!
-
-    params = {
-      :id => context.href_id(image_location, :machines),
-      :name => name,
-      :description => description
-    }
-
-    img = context.driver.create_image(context.credentials, params)
-
-    result = CIMI::Model::MachineImage.from_image(img, context)
-    result.name = name if name
-    result.description = description if description
-    result.property = property if property
-    result.save
-    result
-  end
-
 end

data/lib/cimi/models/machine_template.rb

@@ -22,17 +22,18 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
   ref :machine_image
   ref :credential
 
-  resource_attr :realm, :required => false,
-    :constraints => lambda { |c| c.driver.realms(c.credentials).map { |r| r.id }}
+  text :realm, :required => false
 
   array :volumes do
     scalar :href, :initial_location
   end
 
-  array :volume_templates do
-    scalar :href, :initial_location
+  class CIMI::Model::VolumeTemplateWithLocation < CIMI::Model::VolumeTemplate
+    text :initial_location
   end
 
+  array :volume_templates, :ref => CIMI::Model::VolumeTemplateWithLocation
+
   array :network_interfaces do
     href :vsp
     text :hostname, :mac_address, :state, :protocol, :allocation
@@ -43,39 +44,4 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
     scalar :rel, :href
   end
 
-  class << self
-    def find(id, context)
-      if id == :all
-        current_db.machine_templates.map { |t| from_db(t, context) }
-      else
-        template = current_db.machine_templates_dataset.first(:id => id)
-        raise CIMI::Model::NotFound unless template
-        from_db(template, context)
-      end
-    end
-
-    def delete!(id, context)
-      current_db.machine_templates.first(:id => id).destroy
-    end
-
-    def from_db(model, context)
-      self.new(
-        :id => context.machine_template_url(model.id),
-        :name => model.name,
-        :description => model.description,
-        :machine_config => { :href => model.machine_config },
-        :machine_image => { :href => model.machine_image },
-        :realm => model.realm,
-        :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'
-          }
-        ]
-      )
-    end
-  end
-
 end

data/lib/cimi/models/machine_template_create.rb

@@ -18,16 +18,4 @@ class CIMI::Model::MachineTemplateCreate < CIMI::Model::Base
   href :machine_config, :required => true
   href :machine_image, :required => true
 
-  def create(context)
-    validate!
-    new_template = self.class.current_db.add_machine_template(
-      :name => name,
-      :description => description,
-      :machine_config => machine_config.href,
-      :machine_image => machine_image.href,
-      :ent_properties => property.to_json
-    )
-    CIMI::Model::MachineTemplate.from_db(new_template, context)
-  end
-
 end