deltacloud-core 0.4.1 → 0.5.0

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -33,6 +33,10 @@ module Deltacloud
 
 class RHEVMDriver < Deltacloud::BaseDriver
 
+  def supported_collections
+    DEFAULT_COLLECTIONS - [:storage_snapshots]
+  end
+
   feature :instances, :user_name do
     constraint :max_length, 50
   end
@@ -64,25 +68,29 @@ class RHEVMDriver < Deltacloud::BaseDriver
 
   define_instance_states do
     start.to( :pending )          .automatically
-    pending.to( :running )        .on( :start )
     pending.to( :stopped )        .automatically
     stopped.to( :running )        .on( :start )
     running.to( :stopping )       .on( :stop )
     stopped.to( :finish )         .on( :destroy )
   end
 
+  def providers(credentials)
+    client = new_client(credentials)
+    safely do
+      client.datacenters.collect { |dc| convert_provider(dc) }
+    end
+  end
+
   #
   # Realms
   #
 
-  def realms(credentials, opts=nil)
+  def realms(credentials, opts={})
     client = new_client(credentials)
     realm_arr = []
     safely do
-      clusters = client.clusters
-      clusters.each do |r|
-        d = client.datacenters(:id => r.datacenter.id).first
-        realm_arr << convert_realm(r, d)
+      realm_arr = client.clusters.collect do |r|
+        convert_realm(r, client.datacenter(r.datacenter.id))
       end
     end
     realm_arr = filter_on( realm_arr, :id, opts )
@@ -93,12 +101,10 @@ class RHEVMDriver < Deltacloud::BaseDriver
     client = new_client(credentials)
     img_arr = []
     safely do
-      templates = client.templates
       if (!opts.nil? && opts[:id])
-        templates = templates.select{|t| opts[:id] == t.id}
-      end
-      templates.each do |t|
-        img_arr << convert_image(client, t)
+        img_arr << convert_image(client, client.template(opts[:id]))
+      else
+        img_arr = client.templates.collect { |t| convert_image(client, t) }
       end
     end
     img_arr = filter_on( img_arr, :architecture, opts )
@@ -214,12 +220,20 @@ class RHEVMDriver < Deltacloud::BaseDriver
   private
 
   def new_client(credentials)
-    url = api_provider
+    url, datacenter = api_provider.split(';')
     safely do
-      ::RHEVM::Client.new(credentials.user, credentials.password, url)
+      ::RHEVM::Client.new(credentials.user, credentials.password, url, datacenter)
     end
   end
 
+  def convert_provider(dc)
+    Provider.new(
+      :id => dc.id,
+      :name => dc.name,
+      :url => [api_provider.split(';').first, dc.id].join(';')
+    )
+  end
+
   def confserver_ip(uuid)
     client = RestClient::Resource::new(ENV['CONFIG_SERVER_ADDRESS'])
     client["/ip/%s/%s" % [ (ENV['CONFIG_SERVER_VERSION'] || '0.0.1'), uuid]].get(:accept => 'text/plain').body.strip rescue nil
@@ -234,15 +248,21 @@ class RHEVMDriver < Deltacloud::BaseDriver
                                    :hwp_storage => "#{storage_size}"
     )
     public_addresses = []
-    # First check if RHEV-M guest tools are installed and IP address is offered by them
-    public_addresses << inst.ip if inst.ip
-    # Second check if ConfServer broker is running, then ask for an IP there
-    public_addresses << confserver_ip(inst.id) if ENV['CONFIG_SERVER_ADDRESS'] and public_addresses.empty?
-    public_addresses.compact!
-    # If everything fails fallback to report MAC address
-    public_addresses = inst.macs if public_addresses.empty?
-    public_addresses.flatten!
-    public_addresses << inst.vnc if inst.vnc
+    # First try to get IP address from RHEV-M. This require rhev-agent package
+    # installed on guest
+    public_addresses << InstanceAddress.new(inst.ip) if inst.ip
+    # ConfServer will overide the IP address returned by RHEV-M guest agent
+    if ENV['CONFIG_SERVER_ADDRESS']
+      ip = confserver_ip(inst.id)
+      public_addresses = [ InstanceAddress.new(ip) ]
+    end
+    # If IP retrieval failed, fallback to VNC and MAC address
+    if public_addresses.empty?
+      public_addresses = inst.macs.collect { |mac_address| InstanceAddress.new(mac_address, :type => :mac) }
+    end
+    if inst.vnc
+      public_addresses << InstanceAddress.new(inst.vnc[:address], :port => inst.vnc[:port], :type => :vnc)
+    end
     Instance.new(
       :id => inst.id,
       :name => inst.name,

data/lib/deltacloud/drivers/rimuhosting/rimuhosting_driver.rb

@@ -131,7 +131,7 @@ class RimuHostingDriver < Deltacloud::BaseDriver
             :owner_id => "root",
             :instance_profile => InstanceProfile.new("none"),
             :actions => instance_actions_for("RUNNING"),
-            :public_addresses => inst["allocated_ips"]["primary_ip"],
+            :public_addresses => [ InstanceAddress.new(inst["allocated_ips"]["primary_ip"] ),
             :launch_time => inst["billing_info"]["order_date"]["iso_format"]
     })
   end

data/lib/deltacloud/drivers/sbc/sbc_driver.rb

@@ -51,7 +51,8 @@ class SBCDriver < Deltacloud::BaseDriver
   def realms(credentials, opts={})
     sbc_client = new_client(credentials)
     doc = sbc_client.list_locations
-    doc.xpath('ns2:DescribeLocationsResponse/Location').map { |loc| convert_location(loc) }
+    realms = doc.xpath('ns2:DescribeLocationsResponse/Location').map { |loc| convert_location(loc) }
+    realms = filter_on(realms, :id, opts)
   end
 
   #
@@ -206,7 +207,7 @@ class SBCDriver < Deltacloud::BaseDriver
       :realm_id => instance["location"],
       :state => state,
       :actions => instance_actions_for(state),
-      :public_addresses => [instance["primaryIP"]["ip"]],
+      :public_addresses => [ InstanceAddress.new(instance["primaryIP"]["ip"]) ],
       :private_addresses => [],
       :instance_profile => InstanceProfile.new(instance["instanceType"].gsub('/', '-')),
       :launch_time => instance["launchTime"],

data/lib/deltacloud/drivers/terremark/terremark_driver.rb

@@ -262,8 +262,8 @@ end
                     :realm_id => "US-Miami",
                     :state => current_state,
                     :actions => instance_actions_for(current_state),
-                    :public_addresses => vapp_public_ip,
-                    :private_addresses => vapp_private_ip,
+                    :public_addresses => [ InstanceAddress.new(vapp_public_ip) ],
+                    :private_addresses => [ InstanceAddress.new(vapp_private_ip) ],
                     :instance_profile => profile
                     } )
   end

data/lib/deltacloud/drivers/vsphere/vsphere_client.rb

@@ -32,7 +32,8 @@ module Deltacloud::Drivers::VSphere
         rootFolder = vsphere.serviceInstance.content.rootFolder
         vm = {}
         rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).each do |dc|
-          dc.datastoreFolder.childEntity.collect do |datastore|
+          dslist = list_datastores(dc.datastoreFolder)
+          dslist.each do |datastore|
             vm[:instance] = datastore.vm.find { |x| x.name == name }
             if vm[:instance]
               vm[:datastore] = datastore.name
@@ -63,6 +64,7 @@ module Deltacloud::Drivers::VSphere
         dc = rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).select do |dc|
           dc.datastoreFolder.childEntity.find { |d| d.name == name }.nil? == false
         end.flatten.compact.first
+        dc = rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).first
         dc.hostFolder.childEntity.collect.first.resourcePool
       end
     end
@@ -77,8 +79,12 @@ module Deltacloud::Drivers::VSphere
       safely do
         rootFolder = vsphere.serviceInstance.content.rootFolder
         rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).collect do |dc|
-          dc.datastoreFolder.childEntity.find { |d| d.name == name }
-        end.flatten.compact.first
+          list_datastores(dc.datastoreFolder).each do |d|
+            if d.name == name
+              return d
+            end
+          end
+        end
       end
     end
 
@@ -90,7 +96,7 @@ module Deltacloud::Drivers::VSphere
       vms = []
       rootFolder = vsphere.serviceInstance.content.rootFolder
       rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).each do |dc|
-        dc.datastoreFolder.childEntity.each do |datastore|
+        list_datastores(dc.datastoreFolder).each do  |datastore|
           vms += datastore.vm.collect { |vm| { :instance => vm, :datastore => datastore.name } unless vm.nil? }
           stored_tasks(datastore, vsphere) do |task|
             if task.info.entity.class == RbVmomi::VIM::VirtualMachine
@@ -102,6 +108,21 @@ module Deltacloud::Drivers::VSphere
       vms.flatten.compact
     end
 
+    # This helper will traverse across all datacenters and folders and gather
+    # all datastores available on vSphere
+    #
+    def list_datastores(df)
+      datastores = []
+      df.childEntity.each do |object|
+        if object.class.to_s == 'Folder'
+          datastores += list_datastores(object)
+        else
+          datastores << object
+        end
+      end
+      datastores
+    end
+
     # Map given instance to task. Task name is used as a filename.
     #
     def map_task_to_instance(datastore, task_key, new_instance)

data/lib/deltacloud/drivers/vsphere/vsphere_driver.rb

@@ -42,13 +42,17 @@ module Deltacloud::Drivers::VSphere
       safely do
         service = vsphere.serviceInstance.content
         max_memory, max_cpu_cores = [], []
+        #
+        # Note: Memory is being hardcoded now to range 512MB to 2GB
+        #       JIRA: DTACLOUD-123
+        #
         service.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).each do |dc|
-          max_memory << dc.hostFolder.childEntity.first.summary.effectiveMemory
+          # max_memory << dc.hostFolder.childEntity.first.summary.effectiveMemory
           max_cpu_cores << dc.hostFolder.childEntity.first.summary.numCpuCores
         end
         [Deltacloud::HardwareProfile::new('default') do
           cpu (1..max_cpu_cores.min)
-          memory (128..max_memory.min)
+          memory (512..2048)
           architecture ['x86_64', 'i386']
         end]
       end
@@ -171,11 +175,15 @@ module Deltacloud::Drivers::VSphere
                                                   :hwp_cpu => properties[:cpus],
                                                   :hwp_memory => properties[:memory],
                                                   :hwp_storage => properties[:storage])
-
           # We're getting IP address from 'vmware guest tools'.
           # If guest tools are not installed, we return list of MAC addresses
           # assigned to this instance.
-          instance_address = vm.guest[:net].empty? ? vm.macs.values.first : vm.guest[:net].first[:ipAddress].first
+          public_addresses = []
+          if vm.guest[:net].empty?
+            public_addresses = vm.macs.values.collect { |mac_address| InstanceAddress.new(mac_address, :type => :mac) }
+          else
+            public_addresses = [InstanceAddress.new(vm.guest[:net].first[:ipAddress].first)]
+          end
           Instance.new(
             :id => properties[:name],
             :name => properties[:name],
@@ -184,7 +192,7 @@ module Deltacloud::Drivers::VSphere
             :description => properties[:full_name],
             :realm_id => realm_id,
             :state => instance_state,
-            :public_addresses => instance_address,
+            :public_addresses => public_addresses,
             :private_addresses => [],
             :instance_profile => instance_profile,
             :actions => instance_actions_for( instance_state ),
@@ -205,6 +213,9 @@ module Deltacloud::Drivers::VSphere
     def create_instance(credentials, image_id, opts)
       vsphere = new_client(credentials)
       safely do
+        if opts[:hwp_cpu]
+          raise "Invalid CPU value. Must be in integer format" unless valid_cpu_value?(opts[:hwp_cpu])
+        end
         rootFolder = vsphere.serviceInstance.content.rootFolder
         vm = find_vm(credentials, opts[:image_id])
         raise "ERROR: Could not find the image in given datacenter" unless vm[:instance]
@@ -306,7 +317,7 @@ module Deltacloud::Drivers::VSphere
 
     # Reboot an instance, given its id.
     def reboot_instance(credentials, id)
-      find_vm(credentials, id)[:instance].ResetVM_Task
+      find_vm(credentials, id)[:instance].RebootGuest
     end
 
     # Start an instance, given its id.
@@ -351,6 +362,10 @@ module Deltacloud::Drivers::VSphere
         status 502
       end
 
+      on /Invalid/ do
+        status 400
+      end
+
     end
 
     def valid_credentials?(credentials)
@@ -378,12 +393,16 @@ module Deltacloud::Drivers::VSphere
     end
 
     def convert_realm(datastore)
-      Realm::new(
-        :id => datastore.name,
-        :name => datastore.name,
-        :limit => datastore.summary.freeSpace,
-        :state => datastore.summary.accessible ? 'AVAILABLE' : 'UNAVAILABLE'
-      )
+      if datastore.class.to_s == 'Folder'
+        datastore.childEntity.collect { |datastorenew| convert_realm(datastorenew) }
+      else
+        Realm::new(
+          :id => datastore.name,
+          :name => datastore.name,
+          :limit => datastore.summary.freeSpace,
+          :state => datastore.summary.accessible ? 'AVAILABLE' : 'UNAVAILABLE'
+        )
+      end
     end
 
     def convert_state(object, state)
@@ -404,6 +423,10 @@ module Deltacloud::Drivers::VSphere
       new_state
     end
 
+    def valid_cpu_value?(val)
+      true if val =~ /^(\d+)$/
+    end
+
     def valid_memory_value?(val)
       true if (val.to_i%4) == 0
     end

data/lib/deltacloud/hardware_profile.rb

@@ -68,26 +68,50 @@ module Deltacloud
         kind == :fixed
       end
 
-      def to_param
-        return nil if kind == :fixed
-        if kind == :range
-          # FIXME: We can't validate ranges currently
-          args = [param, :string, :optional]
-        else
-          args = [param, :string, :optional, values.collect { |v| v.to_s} ]
+      def valid?(v)
+        v = convert_property_value_type(v)
+        case kind
+          # NOTE:
+          # Currently we cannot validate fixed values because of UI
+          # limitation. In UI we have multiple hwp_* properties which overide
+          # each other.
+          # Then provider have one 'static' hardware profile and one
+          # 'customizable' when user select the static one the UI also send
+          # values from the customizable one (which will lead to a validation
+          # error because validation algorith will think that client want to
+          # overide fixed values.
+          #
+          # when :fixed then (v == @default.to_s)
+          when :fixed then true
+          when :range then match_type?(first, v) and (first..last).include?(v)
+          when :enum then match_type?(values.first, v) and values.include?(v)
+          else false
         end
-        Validation::Param.new(args)
+      end
+
+      def to_param
+        Validation::Param.new([param, :string, :optional, []])
       end
 
       def include?(v)
         if kind == :fixed
           return v == value
-        elsif kind == :range
-          return v >= first && v <= last
         else
           return values.include?(v)
         end
       end
+
+      private
+
+      def match_type?(reference, value)
+        true if reference.class == value.class
+      end
+
+      def convert_property_value_type(v)
+        return v.to_f if v =~ /(\d+)\.(\d+)/
+        return v.to_i if v =~ /(\d+)/
+        v.to_s
+      end
     end
 
     class << self

data/lib/deltacloud/helpers/application_helper.rb

@@ -22,12 +22,12 @@ module ApplicationHelper
   include Deltacloud
 
   def bread_crumb
-    s = "<ul class='breadcrumb'><li class='first'><a href='#{root_url}'>&#948</a></li>"
+    s = "<ul class='breadcrumb'><li class='first'><a href='#{settings.root_url}'>&#948</a></li>"
     url = request.path_info.split('?')  #remove extra query string parameters
     levels = url[0].split('/') #break up url into different levels
     levels.each_with_index do |level, index|
       unless level.blank?
-        next if "/#{level}" == Sinatra::UrlForHelper::DEFAULT_URI_PREFIX
+        next if "/#{level}" == settings.root_url
         if index == levels.size-1 || (level == levels[levels.size-2] && levels[levels.size-1].to_i > 0)
           s += "<li class='subsequent'>#{level.gsub(/_/, ' ')}</li>\n" unless level.to_i > 0
         else
@@ -177,7 +177,7 @@ module ApplicationHelper
   def link_to_documentation
     return '' unless request.env['REQUEST_URI']
     uri = request.env['REQUEST_URI'].dup
-    uri.gsub!(Sinatra::UrlForHelper::DEFAULT_URI_PREFIX,
+    uri.gsub!(settings.root_url,
               api_url_for(:docs)) unless uri.include?("docs") #i.e. if already serving under /api/docs, leave it be
     '<a href="%s">[ Documentation ]</a>' % uri
   end
@@ -248,31 +248,6 @@ module ApplicationHelper
     end
   end
 
-  # FIXME: It would be cleaner if we stored the type of address explicitly in
-  # public_addresses instead of guessing it; especially since now a RHEV-M
-  # vnc address in theory could look like type ipv4.
-  #
-  # Instead of pushing just the address onto public_addresses, we should
-  # just push a pair [type, address], i.e. [:vnc, "172.16.0.1"] or a hash
-  # { :vnc => "172.16.0.1" }
-  #
-  def address_type(address)
-    case address
-      when /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/; :ipv4
-      when /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:[\-\d]+)$/; :vnc
-      when /^(\S{1,2}:\S{1,2}:\S{1,2}:\S{1,2}:\S{1,2}:\S{1,2})?$/; :mac
-      else :hostname
-    end
-  end
-
-  def format_address(address, opts={})
-    capture_haml do
-      haml_tag :address, { :type => address_type(address) }.merge(opts) do
-        haml_concat address
-      end
-    end
-  end
-
   def translate_error_code(code)
     case code
       when 400; { :message => "Bad Request" }

data/lib/deltacloud/helpers/blob_stream.rb

@@ -104,6 +104,7 @@ module Thin
 end
 
 require 'net/http'
+require 'net/https'
 #monkey patch for Net:HTTP
 module Net
   class HTTP
@@ -186,7 +187,7 @@ class BlobStreamIO
   def self.is_put_blob(request = nil)
     path = request.env['PATH_INFO']
     method = request.env['REQUEST_METHOD']
-    if ( path =~ /^#{Regexp.escape(Sinatra::UrlForHelper::DEFAULT_URI_PREFIX)}\/buckets/ && method == 'PUT' )
+    if ( path =~ /^#{Regexp.escape(settings.root_url)}\/buckets/ && method == 'PUT' )
       return true
     else
       return false