opennebula 5.1.80.beta1 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bce5ec2f4c8ec1633421f1998e9a659a3b712fe2
-  data.tar.gz: 75718ab515a32acc13a5f931836a7a77a02c6ce4
+  metadata.gz: 40bbc901923acb487fd5b753dda85f8677985cdb
+  data.tar.gz: dd3421af744f7a1e25f6c940507297e80b595fe6
 SHA512:
-  metadata.gz: c69828852d920460e330c553ce20fd3f71e9450d5702576e4e800bbf12fbde0d273b8d7d03e4dd62c34971ba0c131d6e3fea21afc550de6a71794796f00d97d7
-  data.tar.gz: 23be93fa25689ce1d05d920a420cd3f766a47594a7f60d152539b3f013b953444357f8ebd01cdb8c6f0bbaa79c1186ad9beec04cea773c2ca4ee9b00b5c4a495
+  metadata.gz: 2db7146a955358e97698af1f8207623da99d1c4a9b8204380d3483bd9ffacc962b6d4c0d5d5d55dc5a0a49b2602ee2a1a05e021203a02285653aef50c1eaef51
+  data.tar.gz: b0818115d8aebc25f332cdf4585d2bbbd1d9e50f742122442d5aef6d4a61ff9d5211943600a53479e0bbc75e836db1147fd7a4b964286a297658b8ea38e4a077

data/lib/cloud/CloudClient.rb

@@ -50,12 +50,17 @@ end
 module CloudClient
 
     # OpenNebula version
-    VERSION = '5.1.80'
+    VERSION = '5.2.0'
 
     # #########################################################################
     # Default location for the authentication file
     # #########################################################################
-    DEFAULT_AUTH_FILE = ENV["HOME"]+"/.one/one_auth"
+
+    if ENV["HOME"]
+        DEFAULT_AUTH_FILE = ENV["HOME"]+"/.one/one_auth"
+    else
+        DEFAULT_AUTH_FILE = "/var/lib/one/.one/one_auth"
+    end
 
     # #########################################################################
     # Gets authorization credentials from ONE_AUTH or default
@@ -63,6 +68,7 @@ module CloudClient
     #
     # Raises an error if authorization is not found
     # #########################################################################
+
     def self.get_one_auth
         if ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and
             File.file?(ENV["ONE_AUTH"])

data/lib/opennebula.rb

@@ -66,5 +66,5 @@ require 'opennebula/marketplaceapp_pool'
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '5.1.80'
+    VERSION = '5.2.0'
 end

data/lib/opennebula/group.rb

@@ -331,9 +331,9 @@ module OpenNebula
                                                    @client)
 
                 if udriver
-                    rc = group_admin.allocate(uadmin, upasswd, udriver)
+                    rc = group_admin.allocate(uadmin, upasswd, udriver, [self.id])
                 else
-                    rc = group_admin.allocate(uadmin, upasswd)
+                    rc = group_admin.allocate(uadmin, upasswd, nil, [self.id])
                 end
 
                 if OpenNebula.is_error?(rc)
@@ -341,14 +341,6 @@ module OpenNebula
                 end
             end
 
-            # Set admin user groups to self
-            rc = group_admin.chgrp(self.id)
-
-            if OpenNebula.is_error?(rc)
-                group_admin.delete
-                return rc
-            end
-
             rc = self.add_admin(group_admin.id)
 
             if OpenNebula.is_error?(rc)

data/lib/opennebula/oneflow_client.rb

@@ -385,4 +385,4 @@ module Service
             res
         end
     end
-end
+end

data/lib/opennebula/pool.rb

@@ -62,19 +62,23 @@ module OpenNebula
         alias_method :info!, :info
 
         def info_all(xml_method, *args)
-            return xmlrpc_info(xml_method,INFO_ALL,-1,-1, *args)
+            return xmlrpc_info(xml_method, INFO_ALL, -1, -1, *args)
         end
 
         def info_mine(xml_method, *args)
-            return xmlrpc_info(xml_method,INFO_MINE,-1,-1, *args)
+            return xmlrpc_info(xml_method, INFO_MINE, -1, -1, *args)
         end
 
         def info_group(xml_method, *args)
-            return xmlrpc_info(xml_method,INFO_GROUP,-1,-1, *args)
+            return xmlrpc_info(xml_method, INFO_GROUP, -1, -1, *args)
+        end
+
+        def info_primary_group(xml_method, *args)
+            return xmlrpc_info(xml_method, INFO_PRIMARY_GROUP, -1, -1, *args)
         end
 
         def info_filter(xml_method, who, start_id, end_id, *args)
-            return xmlrpc_info(xml_method,who, start_id, end_id, *args)
+            return xmlrpc_info(xml_method, who, start_id, end_id, *args)
         end
 
         # Retrieves the monitoring data for all the Objects in the pool
@@ -144,6 +148,7 @@ module OpenNebula
         INFO_GROUP = -1
         INFO_ALL   = -2
         INFO_MINE  = -3
+        INFO_PRIMARY_GROUP = -4
 
         # Iterates over every PoolElement in the Pool and calls the block with a
         # a PoolElement obtained calling the factory method

data/lib/opennebula/user.rb

@@ -98,8 +98,17 @@ module OpenNebula
         # +username+ Name of the new user.
         #
         # +password+ Password for the new user
-        def allocate(username, password, driver=CORE_AUTH)
-            super(USER_METHODS[:allocate], username, password, driver)
+        # @param username Username for the new user.
+        # @param password Password for the new user
+        # @param driver Auth driver for the new user.
+        # @param gids Group IDs. The first ID will be used as the main group.
+        # This array can be empty, in which case the default group will be used.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(username, password, driver=nil, gids=[])
+            driver = CORE_AUTH if driver.nil?
+            super(USER_METHODS[:allocate], username, password, driver, gids)
         end
 
         # Replaces the template contents

data/lib/vcenter_driver.rb

@@ -144,6 +144,7 @@ class VIClient
                 v.propSet.each{ |dynprop|
                     obj[dynprop.name] = dynprop.val
                 }
+                obj[:ref] = k._ref
                 objects << OpenStruct.new(obj)
             end
         }
@@ -151,7 +152,7 @@ class VIClient
     end
 
     ############################################################################
-    # Initializr the VIClient, and creates an OpenNebula client. The parameters
+    # Initialize the VIClient, and creates an OpenNebula client. The parameters
     # are obtained from the associated OpenNebula host
     # @param hid [Integer] The OpenNebula host id with VCenter attributes
     ############################################################################
@@ -301,6 +302,37 @@ class VIClient
         baseEntity
     end
 
+    ########################################################################
+    # Searches the associated vmFolder of the DataCenter for the current
+    # connection. Returns a RbVmomi::VIM::VirtualMachine or nil if not found
+    #
+    # Searches by moref, name, uuid and then iterates over all VMs
+    #
+    # @param uuid [String] the UUID of the VM or VM Template
+    # @param ref [String] VMware moref
+    # @param name [String] VM name in vCenter
+    ########################################################################
+    def find_vm_fast(uuid, ref = nil, name = nil)
+        if ref
+            # It can raise ManagedObjectNotFound
+            begin
+                vm = RbVmomi::VIM::VirtualMachine.new(@dc._connection, ref)
+                return vm if vm.config && vm.config.uuid == uuid
+            rescue  => e
+            end
+        end
+
+        if name
+            begin
+                vm = @dc.vmFolder.find(name)
+                return vm if vm.config && vm.config.uuid == uuid
+            rescue
+            end
+        end
+
+        return find_vm_template(uuid)
+    end
+
     ########################################################################
     # Searches the associated vmFolder of the DataCenter for the current
     # connection. Returns a RbVmomi::VIM::VirtualMachine or nil if not found
@@ -310,11 +342,7 @@ class VIClient
         version = @vim.serviceContent.about.version
 
         found_vm = nil
-
-        if version.split(".").first.to_i >= 6
-           found_vm = @dc.vmFolder.findByUuid(uuid, RbVmomi::VIM::VirtualMachine, @dc)
-        end
-
+        found_vm = @dc.vmFolder.findByUuid(uuid, RbVmomi::VIM::VirtualMachine, @dc)
         return found_vm if found_vm
 
         vms = VIClient.get_entities(@dc.vmFolder, 'VirtualMachine')
@@ -352,6 +380,15 @@ class VIClient
     ########################################################################
     def get_datastore(ds_name)
         datastores = VIClient.get_entities(@dc.datastoreFolder, 'Datastore')
+
+        storage_pods = VIClient.get_entities(@dc.datastoreFolder, 'StoragePod')
+        storage_pods.each { |sp|
+            storage_pod_datastores = VIClient.get_entities(sp, 'Datastore')
+            if not storage_pod_datastores.empty?
+                datastores.concat(storage_pod_datastores)
+            end
+        }
+
         ds         = datastores.select{|ds| ds.name == ds_name}[0]
     end
 
@@ -430,13 +467,15 @@ class VIClient
                     ds   = ds_cache[t.datastore[0].to_s]
 
                     one_tmp << {
-                        :name       => "#{vi_tmp.vm.name} - #{host.cluster_name}",
-                        :uuid       => vi_tmp.vm.config.uuid,
-                        :host       => host.cluster_name,
-                        :one        => vi_tmp.to_one(host),
-                        :ds         => vi_tmp.to_one_ds(host, ds.name),
-                        :default_ds => ds.name,
-                        :rp         => vi_tmp.to_one_rp(host)
+                        :name           => "#{vi_tmp.vm.name} - #{host.cluster_name}",
+                        :uuid           => vi_tmp.vm.config.uuid,
+                        :host           => host.cluster_name,
+                        :one            => vi_tmp.to_one(host),
+                        :ds             => vi_tmp.to_one_ds(host, ds.name),
+                        :default_ds     => ds.name,
+                        :rp             => vi_tmp.to_one_rp(host),
+                        :vcenter_ref    => vi_tmp.vm._ref,
+                        :vcenter_name   => vi_tmp.vm.name
                     }
                 end
             }
@@ -513,7 +552,6 @@ class VIClient
                                      "VN_MAD = \"dummy\"\n" \
                                      "VCENTER_TYPE = \"Distributed Port Group\""
 
-
                      default_pc = n.config.defaultPortConfig
 
                      has_vlan = false
@@ -540,7 +578,7 @@ class VIClient
                      end
 
                      if !vlan_str.empty?
-                         vnet_template << "VLAN_ID=#{vlan_str}\n"
+                         vnet_template << "VLAN_TAGGED_ID=#{vlan_str}\n"
                      end
 
                      one_net = {:name    => net_name,
@@ -591,6 +629,15 @@ class VIClient
         datacenters.each { |dc|
             one_tmp = []
             datastores = VIClient.get_entities(dc.datastoreFolder, 'Datastore')
+
+            storage_pods = VIClient.get_entities(dc.datastoreFolder, 'StoragePod')
+            storage_pods.each { |sp|
+                storage_pod_datastores = VIClient.get_entities(sp, 'Datastore')
+                if not storage_pod_datastores.empty?
+                    datastores.concat(storage_pod_datastores)
+                end
+            }
+
             datastores.each { |ds|
                 next if !ds.is_a? RbVmomi::VIM::Datastore
                 # Find the Cluster from which to access this ds
@@ -654,6 +701,15 @@ class VIClient
 
             # Find datastore within datacenter
             datastores = VIClient.get_entities(dc.datastoreFolder, 'Datastore')
+
+            storage_pods = VIClient.get_entities(dc.datastoreFolder, 'StoragePod')
+            storage_pods.each { |sp|
+                storage_pod_datastores = VIClient.get_entities(sp, 'Datastore')
+                if not storage_pod_datastores.empty?
+                    datastores.concat(storage_pod_datastores)
+                end
+            }
+
             ds         = datastores.select{|ds| ds.name == ds_name}[0]
             next if !ds
 
@@ -981,10 +1037,20 @@ class VCenterCachedHost
             while !datacenter.is_a? RbVmomi::VIM::Datacenter
                 datacenter = datacenter.parent
             end
-            
+
             datastores=VIClient.get_entities(
                           datacenter.datastoreFolder,
                            'Datastore')
+
+            storage_pods = VIClient.get_entities(datacenter.datastoreFolder,
+                                                'StoragePod')
+            storage_pods.each { |sp|
+                storage_pod_datastores = VIClient.get_entities(sp, 'Datastore')
+                if not storage_pod_datastores.empty?
+                    datastores.concat(storage_pod_datastores)
+                end
+            }
+
             datastores.each { |ds|
                 @attributes['ds_list'] += ds.name + ","
             }
@@ -1290,7 +1356,7 @@ class VCenterHost < ::OpenNebula::Host
                                          val[:key]=="opennebula.vm.running"}
               if running_flag.size > 0 and running_flag[0]
                   running_flag = running_flag[0][:value]
-              end                                
+              end
 
               next if running_flag == "no"
 
@@ -1345,6 +1411,17 @@ class VCenterHost < ::OpenNebula::Host
 
         datastores = VIClient.get_entities(client.dc.datastoreFolder,
                                            'Datastore')
+
+        storage_pods = VIClient.get_entities(client.dc.datastoreFolder,
+                                            'StoragePod')
+
+        storage_pods.each { |sp|
+            storage_pod_datastores = VIClient.get_entities(sp, 'Datastore')
+            if not storage_pod_datastores.empty?
+                datastores.concat(storage_pod_datastores)
+            end
+        }
+
         datastores.each { |ds|
             str_info += "VCENTER_DATASTORE=\"#{ds.name}\"\n"
         }
@@ -1383,13 +1460,16 @@ class VCenterVm
     # Deploys a VM
     #  @xml_text XML representation of the VM
     ############################################################################
-    def self.deploy(xml_text, lcm_state, deploy_id, hostname, datastore = nil)
+    def self.deploy(xml_text, lcm_state, deploy_id, hostname, datastore = nil,
+                    ops = {})
         if lcm_state == "BOOT" || lcm_state == "BOOT_FAILURE"
-            return clone_vm(xml_text, hostname, datastore)
+            return clone_vm(xml_text, hostname, datastore, ops)
         else
             hid         = VIClient::translate_hostname(hostname)
             connection  = VIClient.new(hid)
-            vm          = connection.find_vm_template(deploy_id)
+            vm          = connection.find_vm_fast(deploy_id,
+                                                  ops[:ref],
+                                                  ops[:name])
             xml         = REXML::Document.new xml_text
 
             reconfigure_vm(vm, xml, false, hostname)
@@ -1428,8 +1508,8 @@ class VCenterVm
                     detach_attached_disks(vm, disks, hostname) if disks
                 end
 
-                # If the VM was instantiated to persistent, convert the VM to 
-                # vCenter VM Template and update the OpenNebula new 
+                # If the VM was instantiated to persistent, convert the VM to
+                # vCenter VM Template and update the OpenNebula new
                 # VM Template to point to the new vCenter VM Template
                 if !to_template.nil?
                     vm.MarkAsTemplate
@@ -1537,18 +1617,28 @@ class VCenterVm
         case lcm_state
             when "SHUTDOWN"
                 begin
-                    vm.ShutdownGuest.wait_for_completion
+                    vm.ShutdownGuest
+                    counter = 60*10 # 10 minutes
+                    while counter > 0
+                        break if vm.runtime.powerState == "poweredOff"
+                        counter -= 1
+                        sleep 1
+                    end
                 rescue
                 end
-                vm.PowerOffVM_Task.wait_for_completion
+
+                if vm.runtime.powerState != "poweredOff"
+                    vm.PowerOffVM_Task.wait_for_completion
+                end
+
                 if keep_disks
                     detach_all_disks(vm)
                 else
                     detach_attached_disks(vm, disks, hostname) if disks
                 end
 
-                # If the VM was instantiated to persistent, convert the VM to 
-                # vCenter VM Template and update the OpenNebula new 
+                # If the VM was instantiated to persistent, convert the VM to
+                # vCenter VM Template and update the OpenNebula new
                 # VM Template to point to the new vCenter VM Template
                 if !to_template.nil?
                     vm.MarkAsTemplate
@@ -1576,10 +1666,19 @@ class VCenterVm
 
             when "SHUTDOWN_POWEROFF", "SHUTDOWN_UNDEPLOY"
                 begin
-                    vm.ShutdownGuest.wait_for_completion
+                    vm.ShutdownGuest
+                    counter = 60*10 # 10 minutes
+                    while counter > 0
+                        break if vm.runtime.powerState == "poweredOff"
+                        counter -= 1
+                        sleep 1
+                    end
                 rescue
                 end
-                vm.PowerOffVM_Task.wait_for_completion
+
+                if vm.runtime.powerState != "poweredOff"
+                    vm.PowerOffVM_Task.wait_for_completion
+                end
         end
     end
 
@@ -1793,6 +1892,73 @@ class VCenterVm
         end if @vm.guest.net
 
         @guest_ip_addresses = guest_ip_addresses.join(',')
+
+        # Network metrics - Realtime retrieved by perfManager
+        pm = @client.vim.serviceInstance.content.perfManager
+
+        provider = pm.provider_summary [@vm].first
+        refresh_rate = provider.refreshRate
+
+        vmid = -1
+        extraconfig_vmid = @vm.config.extraConfig.select{|val|
+                                        val[:key]=="opennebula.vm.id"}
+        if extraconfig_vmid.size > 0 and extraconfig_vmid[0]
+            vmid = extraconfig_vmid[0][:value].to_i
+        end
+
+        if vmid < 0
+            @nettx = 0
+            @netrx = 0
+            id_not_found = "Could not retrieve VM ID from extra configuration for "\
+                           "vCenter's VM UUID #{@vm.config.uuid}"
+        else
+            one_vm = OpenNebula::VirtualMachine.new_with_id(vmid, OpenNebula::Client.new)
+            one_vm.info
+            stats = []
+
+            if(one_vm["LAST_POLL"] && one_vm["LAST_POLL"].to_i != 0 )
+                #Real time data stores max 1 hour. 1 minute has 3 samples
+                interval = (Time.now.to_i - one_vm["LAST_POLL"].to_i)
+
+                #If last poll was more than hour ago get 3 minutes,
+                #else calculate how many samples since last poll
+                samples =  interval > 3600 ? 9 : interval / refresh_rate
+                max_samples = samples > 0 ? samples : 1
+
+                stats = pm.retrieve_stats(
+                    [@vm],
+                    ['net.transmitted','net.bytesRx','net.bytesTx','net.received'],
+                    {interval:refresh_rate, max_samples: max_samples}
+                )
+            else
+                # First poll, get at least latest 3 minutes = 9 samples
+                stats = pm.retrieve_stats(
+                    [@vm],
+                    ['net.transmitted','net.bytesRx'],
+                    {interval:refresh_rate, max_samples: 9}
+                )
+            end
+
+            if stats.empty? || stats.first[1][:metrics].empty?
+                @nettx = 0
+                @netrx = 0
+            else
+                metrics = stats.first[1][:metrics]
+
+                nettx_kbpersec = 0
+                metrics['net.transmitted'].each { |sample|
+                    nettx_kbpersec += sample
+                }
+
+                netrx_kbpersec = 0
+                metrics['net.bytesRx'].each { |sample|
+                    netrx_kbpersec += sample
+                }
+
+                @nettx = (nettx_kbpersec * 1024 * refresh_rate).to_i
+                @netrx = (netrx_kbpersec * 1024 * refresh_rate).to_i
+            end
+        end
     end
 
     ########################################################################
@@ -1835,6 +2001,8 @@ class VCenterVm
               "PUBLIC_CLOUD = [\n"\
               "  TYPE        =\"vcenter\",\n"\
               "  VM_TEMPLATE =\"#{@vm.config.uuid}\",\n"\
+              "  VCENTER_REF =\"#{@vm.ref}\",\n"\
+              "  VCENTER_NAME=\"#{@vm.name}\",\n"\
               "  HOST        =\"#{cluster_name}\"\n"\
               "]\n"\
               "GRAPHICS = [\n"\
@@ -2015,7 +2183,7 @@ private
     ########################################################################
     # Returns the spec to reconfig a VM and add a NIC
     ########################################################################
-    def self.calculate_addnic_spec(vm, mac, bridge, model)
+    def self.calculate_addnic_spec(vm, mac, bridge, model, limit=nil, rsrv=nil)
         model       = model.nil? ? nil : model.downcase
         network     = vm.runtime.host.network.select{|n| n.name==bridge}
         backing     = nil
@@ -2065,24 +2233,40 @@ private
                  :port => port)
         end
 
-        return {:operation => :add,
-                :device => nic_card.new(
-                            :key => 0,
-                            :deviceInfo => {
-                                :label => "net" + card_num.to_s,
-                                :summary => bridge
-                            },
-                            :backing => backing,
-                            :addressType => mac ? 'manual' : 'generated',
-                            :macAddress  => mac
-                           )
+        card_spec = {
+            :key => 0,
+            :deviceInfo => {
+                :label => "net" + card_num.to_s,
+                :summary => bridge
+            },
+            :backing => backing,
+            :addressType => mac ? 'manual' : 'generated',
+            :macAddress  => mac
+        }
+
+        if (limit or rsrv) and (limit > 0)
+            ra_spec = Hash.new
+            rsrv = limit if rsrv > limit
+            ra_spec[:limit] = limit if limit
+            ra_spec[:reservation] = rsrv if rsrv
+            ra_spec[:share] =  RbVmomi::VIM.SharesInfo({
+                    :level => RbVmomi::VIM.SharesLevel("normal"),
+                    :shares => 0
+                })
+            card_spec[:resourceAllocation] =
+               RbVmomi::VIM.VirtualEthernetCardResourceAllocation(ra_spec)
+        end
+
+        return {
+                :operation => :add,
+                :device => nic_card.new(card_spec)
                }
     end
 
     ########################################################################
     #  Clone a vCenter VM Template and leaves it powered on
     ########################################################################
-    def self.clone_vm(xml_text, hostname, datastore)
+    def self.clone_vm(xml_text, hostname, datastore, ops = {})
 
         host_id = VCenterDriver::VIClient.translate_hostname(hostname)
 
@@ -2144,7 +2328,7 @@ private
         raise "Cannot find host id in deployment file history." if hid.nil?
 
         connection  = VIClient.new(hid)
-        vc_template = connection.find_vm_template(uuid)
+        vc_template = connection.find_vm_fast(uuid, ops[:ref], ops[:name])
 
         # Find out requested and available resource pool
 
@@ -2179,6 +2363,16 @@ private
         if datastore
             datastores = VIClient.get_entities(connection.dc.datastoreFolder,
                                              'Datastore')
+
+            storage_pods = VIClient.get_entities(connection.dc.datastoreFolder,
+                                                'StoragePod')
+            storage_pods.each { |sp|
+                storage_pod_datastores = VIClient.get_entities(sp, 'Datastore')
+                if not storage_pod_datastores.empty?
+                    datastores.concat(storage_pod_datastores)
+                end
+            }
+
             ds         = datastores.select{|ds| ds.name == datastore}[0]
             raise "Cannot find datastore #{datastore}" if !ds
         end
@@ -2410,7 +2604,24 @@ private
                mac    = nic.elements["MAC"].text
                bridge = nic.elements["BRIDGE"].text
                model  = nic.elements["MODEL"] ? nic.elements["MODEL"].text : nil
-               nic_array << calculate_addnic_spec(vm, mac, bridge, model)
+               limit_in  = nic.elements["INBOUND_PEAK_BW"] ? nic.elements["INBOUND_PEAK_BW"].text : ""
+               limit_out = nic.elements["OUTBOUND_PEAK_BW"] ? nic.elements["OUTBOUND_PEAK_BW"].text : ""
+               limit     = nil
+               if !limit_in.empty? or !limit_out.empty?
+                  limit=([limit_in.to_i, limit_out.to_i].min / 1024) * 8
+               end
+               rsrv_in  = nic.elements["INBOUND_AVG_BW"] ? nic.elements["INBOUND_AVG_BW"].text : ""
+               rsrv_out = nic.elements["OUTBOUND_AVG_BW"] ? nic.elements["OUTBOUND_AVG_BW"].text : ""
+               rsrv     = nil
+               if !rsrv_in.empty? or !rsrv_out.empty?
+                  rsrv=([rsrv_in.to_i, rsrv_out.to_i].min / 1024) * 8
+               end
+               nic_array << calculate_addnic_spec(vm,
+                                                  mac,
+                                                  bridge,
+                                                  model,
+                                                  limit,
+                                                  rsrv)
             }
 
             device_change += nic_array
@@ -2421,7 +2632,7 @@ private
         disks     = xml.root.get_elements("/VM/TEMPLATE/DISK")
         disk_spec = {}
 
-        # If the VM is not new, avoid readding DISKS
+        # If the VM is not new, avoid reading DISKS
         if !newvm
             vm.config.hardware.device.select { |d|
                 if is_disk?(d)
@@ -2490,6 +2701,16 @@ private
         # Find datastore within datacenter
         datastores = VIClient.get_entities(connection.dc.datastoreFolder,
                                            'Datastore')
+
+        storage_pods = VIClient.get_entities(connection.dc.datastoreFolder,
+                                            'StoragePod')
+        storage_pods.each { |sp|
+            storage_pod_datastores = VIClient.get_entities(sp, 'Datastore')
+            if not storage_pod_datastores.empty?
+                datastores.concat(storage_pod_datastores)
+            end
+        }
+
         ds         = datastores.select{|ds| ds.name == ds_name}[0]
 
         controller, new_number = find_free_controller(vm)
@@ -2500,22 +2721,48 @@ private
                   :fileName  => "[#{ds_name}] #{img_name}"
             )
 
-            cd = vm.config.hardware.device.select {|hw| 
+            cd = vm.config.hardware.device.select {|hw|
                                  hw.class == RbVmomi::VIM::VirtualCdrom}.first
-            device = RbVmomi::VIM::VirtualCdrom(
-                     backing: vmdk_backing,
-                     key: cd.key,
-                     controllerKey: cd.controllerKey,
-                     connectable: RbVmomi::VIM::VirtualDeviceConnectInfo(
-                       startConnected: false,
-                       connected: false,
-                       allowGuestControl: false
-                     )
-                    )
-            device_config_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(
-               :device    => device,
-               :operation => RbVmomi::VIM::VirtualDeviceConfigSpecOperation('edit')
-            )
+
+            # If no CDROM drive present, we need to add it
+            if !cd
+                controller, new_unit_number = find_free_controller(vm)
+                cdrom_drive_spec = RbVmomi::VIM.VirtualMachineConfigSpec(
+                  :deviceChange => [{
+                    :operation => :add,
+                    :device => RbVmomi::VIM::VirtualCdrom(
+                      :backing => vmdk_backing,
+                      :key => -1,
+                      :controllerKey => 15000,
+                      :unitNumber => 0,
+                      :connectable => RbVmomi::VIM::VirtualDeviceConnectInfo(
+                        :startConnected => true,
+                        :connected => true,
+                        :allowGuestControl => true
+                      )
+                   )}]
+                )
+
+                vm.ReconfigVM_Task(:spec =>
+                                       cdrom_drive_spec).wait_for_completion
+
+                return
+            else
+                device = RbVmomi::VIM::VirtualCdrom(
+                         backing: vmdk_backing,
+                         key: cd.key,
+                         controllerKey: cd.controllerKey,
+                         connectable: RbVmomi::VIM::VirtualDeviceConnectInfo(
+                           startConnected: true,
+                           connected: true,
+                           allowGuestControl: true
+                         )
+                        )
+                device_config_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(
+                   :device    => device,
+                   :operation => RbVmomi::VIM::VirtualDeviceConfigSpecOperation('edit')
+                )
+            end
         else
             vmdk_backing = RbVmomi::VIM::VirtualDiskFlatVer2BackingInfo(
                   :datastore => ds,
@@ -2639,7 +2886,6 @@ private
 
     ############################################################################
     # Detach a specific disk from a VM
-    # Attach disk to a VM
     # @params hostname[String] vcenter cluster name in opennebula as host
     # @params deploy_id[String] deploy id of the vm
     # @params ds_name[String] name of the datastore

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opennebula
 version: !ruby/object:Gem::Version
-  version: 5.1.80.beta1
+  version: 5.2.0
 platform: ruby
 authors:
 - OpenNebula
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-16 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -134,9 +134,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1