opennebula 6.1.90.pre → 6.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2297734850551fc2c89b8d6bbccd43408724e330
-  data.tar.gz: e7bc524512feaa2dd9215214aa2b273dd6a9f8d5
+SHA256:
+  metadata.gz: 9492453d246b5d413a5902766bda7526160e953c1e6072d242509ebff8df73bc
+  data.tar.gz: eb349b7f7f2a87b29cbbae06ec35db4131db8baf96e5cbf4cf9875f3815e2db3
 SHA512:
-  metadata.gz: 6df4eefbb624baa5f43f4959d188f43ef1ad36cb25814f76b829480bd26b60946489029d0623727d96881eff87efe9755a823884a7988fe68206d43fe86442af
-  data.tar.gz: 547a06b4424a0f2dfaeec1a2c4c9ac4a5fa8854665338fe34e7ebc9b6cbd0de3682c6ade82b9360fb7e68a9c9bbb2d4fb3a89c05757652e8e98c732951e52447
+  metadata.gz: 546bd3075e73b2e73be4abe53dad5af5d27956dbb896182fd828a2794b510b5df71ea615915b82abbba506ff824f31091fb54afee8d8e67b3b50092714a15ffb
+  data.tar.gz: 6476073b7b334c8e746350760a0de9082770f45df57ee3c9db318b72ee9f1c72c86f8626d892e313c4d92387920e367a063878ac24237b017b66fecb7dc3d7fb

data/lib/cloud/CloudClient.rb

@@ -51,7 +51,7 @@ end
 module CloudClient
 
     # OpenNebula version
-    VERSION = '6.1.90'
+    VERSION = '6.2.2'
 
     # #########################################################################
     # Default location for the authentication file

data/lib/datacenter.rb

@@ -131,7 +131,10 @@ module VCenterDriver
 
                     # Setting host import name and
                     # replace spaces and weird characters
-                    cluster_name = (ccr['name']).to_s.tr(' ', '_')
+                    cluster_name = ccr['name'].to_s.tr(' ', '_')
+                    cluster_name = VCenterDriver::VcImporter.sanitize(
+                        cluster_name
+                    )
                     cluster_name =
                         VCenterDriver::VIHelper
                         .one_name(
@@ -159,11 +162,28 @@ module VCenterDriver
             host_objects
         end
 
-        def get_unimported_datastores(dpool, vcenter_instance_name, hpool)
+        # rubocop:disable Style/GlobalVars
+        def get_unimported_datastores(dpool, vcenter_instance_name, hpool, args)
             import_id = 0
             ds_objects = {}
             vcenter_uuid = vcenter_instance_uuid
 
+            # Selected host in OpenNebula
+            if $conf.nil?
+                one_client = OpenNebula::Client.new
+            else
+                one_client = OpenNebula::Client.new(
+                    nil,
+                    $conf[:one_xmlrpc]
+                )
+            end
+            one_host = OpenNebula::Host.new_with_id(args[:host], one_client)
+
+            rc = one_host.info
+            raise rc.message if OpenNebula.is_error? rc
+
+            cluster_id = one_host['CLUSTER_ID'].to_i
+
             # Get datacenters
             fetch! if @items.empty?
 
@@ -185,7 +205,10 @@ module VCenterDriver
                             'summary.freeSpace'
                         )
 
-                    ds_name     = name.to_s
+                    ds_name = VCenterDriver::VcImporter.sanitize(
+                        name.to_s
+                    )
+
                     ds_total_mb = ((capacity.to_i / 1024) / 1024)
                     ds_free_mb  = ((free_space.to_i / 1024) / 1024)
                     ds_ref      = ds['_ref']
@@ -363,8 +386,15 @@ module VCenterDriver
                 end
             end
 
+            ds_objects.keys.each do |key|
+                unless ds_objects[key][:cluster].include? cluster_id
+                    ds_objects.delete key
+                end
+            end
+
             { vcenter_instance_name => ds_objects }
         end
+        # rubocop:enable Style/GlobalVars
 
         def get_unimported_templates(vi_client, tpool)
             template_objects = {}

data/lib/datastore.rb

@@ -881,7 +881,7 @@ module VCenterDriver
             @one_class = OpenNebula::Datastore
         end
 
-        def get_list(_args = {})
+        def get_list(args = {})
             dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)
 
             # one pool creation
@@ -908,7 +908,8 @@ module VCenterDriver
                  .get_unimported_datastores(
                      dpool,
                      @vi_client.vc_name,
-                     hpool
+                     hpool,
+                     args
                  )
             @list = rs
         end
@@ -948,7 +949,11 @@ module VCenterDriver
                 clusters = opts['selected_clusters'].each.map(&:to_i)
             end
 
-            res = { :id => [], :name => selected[:simple_name] }
+            name = VCenterDriver::VcImporter.sanitize(
+                selected[:simple_name]
+            )
+
+            res = { :id => [], :name => name }
             @info[:rollback] = []
             pair.each do |ds|
                 create(ds[:one]) do |one_object, id|
@@ -1011,7 +1016,9 @@ module VCenterDriver
             message = 'Error creating the OpenNebula resource'
             info = selected[:one]
             dsid = selected[:dsid].to_i
-            name = selected[:name]
+            name = VCenterDriver::VcImporter.sanitize(
+                selected[:name]
+            )
 
             rc = resource.allocate(info, dsid, false)
             VCenterDriver::VIHelper.check_error(rc, message)

data/lib/host.rb

@@ -712,7 +712,7 @@ module VCenterDriver
 
                 # Only take care of VMs, not templates
                 if !hashed_properties['config.template']
-                    vms[r.obj._ref] = hashed_properties
+                    vms[r.obj._ref + '_' + vc_uuid] = hashed_properties
                     vm_objects << r.obj
                 end
             end
@@ -802,7 +802,8 @@ module VCenterDriver
                     found_vm =
                         host_vms
                         .select do |vm|
-                            vm['DEPLOY_ID'].eql? vm_ref
+                            vm['DEPLOY_ID'] == vm_ref ||
+                            vm['DEPLOY_ID'] == VIHelper.get_deploy_id(vm_ref)
                         end.first
                     id = found_vm['ID'] if found_vm
 

data/lib/opennebula/flow/service_pool.rb

@@ -55,8 +55,12 @@ module OpenNebula
             @one_pool   = nil
 
             if @client
-                info     = Nokogiri::XML(@client.call('user.info', -1))
-                @user_id = Integer(info.xpath('/USER/ID').text)
+                rc = @client.call('user.info', -1)
+
+                unless OpenNebula.is_error?(rc)
+                    info     = Nokogiri::XML(rc)
+                    @user_id = Integer(info.xpath('/USER/ID').text)
+                end
             end
 
             super('DOCUMENT_POOL', 'DOCUMENT', @client)

data/lib/opennebula/flow/service_template.rb

@@ -315,6 +315,12 @@ module OpenNebula
                 end
             else
                 IMMUTABLE_ATTRS.each do |attr|
+                    # Allows updating the template without
+                    # specifying the immutable attributes
+                    if template[attr].nil?
+                        template[attr] = @body[attr]
+                    end
+
                     next if template[attr] == @body[attr]
 
                     return [false, "service_template/#{attr}"]

data/lib/opennebula/host.rb

@@ -14,7 +14,6 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
-
 require 'opennebula/pool_element'
 require 'base64'
 require 'yaml'
@@ -217,10 +216,12 @@ module OpenNebula
         # Imports a wild VM from the host and puts it in running state
         #
         # @param name [String] Name of the VM to import
+        # @param ipv4 [Array]  Array with IP4s to set
+        # @param ipv6 [Array]  Array with IP6s to set
         #
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
-        def import_wild(name)
+        def import_wild(name, ipv4 = nil, ipv6 = nil)
             vms = importable_wilds.select {|vm| vm['VM_NAME'] == name }
 
             if vms.length == 0
@@ -247,8 +248,15 @@ module OpenNebula
                 vi_client = VCenterDriver::VIClient.new_from_host(self["ID"])
                 importer  = VCenterDriver::VmmImporter.new(@client, vi_client)
 
-                return importer.import({wild: wild, template: template,
-                                        one_item: vm, host: self['ID']})
+                return importer.import(
+                    { :wild     => wild,
+                      :template => template,
+                      :one_item => vm,
+                      :host     => self['ID'],
+                      :ipv4     => ipv4,
+                      :ipv6     => ipv6
+                    }
+                )
             else
                 rc = vm.allocate(template)
 

data/lib/opennebula/ldap_auth.rb

@@ -15,7 +15,9 @@
 # ---------------------------------------------------------------------------- #
 
 require 'rubygems'
-require 'opennebula'
+require 'opennebula/xml_utils'
+require 'opennebula/client'
+require 'opennebula/group_pool'
 require 'net/ldap'
 require 'yaml'
 

data/lib/opennebula/marketplaceapp_ext.rb

@@ -185,9 +185,22 @@ module OpenNebula::MarketPlaceAppExt
                 #---------------------------------------------------------------
                 # Created an associated VMTemplate if needed
                 #---------------------------------------------------------------
-                if (self['TEMPLATE/VMTEMPLATE64'].nil? && !is_vcenter) ||
-                    options[:notemplate] ||
-                    options[:template] == -1
+                if is_vcenter &&
+                    (!options[:template] || options[:template] == -1)
+                    tmpl = create_vcenter_template(ds, options, image)
+
+                    if OpenNebula.is_error?(tmpl)
+                        rc_info[:vmtemplate] = [tmpl]
+                    else
+                        rc_info[:vmtemplate] = [tmpl.id]
+                    end
+
+                    return rc_info
+                end
+
+                if self['TEMPLATE/VMTEMPLATE64'].nil? ||
+                   options[:notemplate] ||
+                   options[:template] == -1
                     return rc_info
                 end
 
@@ -286,33 +299,128 @@ module OpenNebula::MarketPlaceAppExt
                 rc
             end
 
-            def update_options_with_template(options, _validate = false)
-                vcenterrc_path =
-                    "#{VAR_LOCATION}/remotes/etc/vmm/vcenter/vcenterrc"
+            # Create a VM template in vCenter in order to use it when
+            # deploying an app from the marketplace
+            #
+            # @param ds      [OpenNebula::Datastore] Datastore information
+            # @param options [Hash]                  Export options
+            # @param image   [OpenNebula::Image]     Image information
+            def create_vcenter_template(ds, options, image = nil)
+                ret  = {}
+                keys = %w[VCENTER_TEMPLATE_REF
+                          VCENTER_CCR_REF
+                          VCENTER_INSTANCE_ID]
+
+                if ds['//VCENTER_TEMPLATE_REF']
+                    keys.each do |key|
+                        ret[key] = ds["//#{key}"]
+                    end
+                else
+                    require 'vcenter_driver'
 
-                if File.file?(vcenterrc_path)
-                    config_vcenter = YAML.load_file(vcenterrc_path)
+                    # Get vi client for current datastore
+                    vi_client = VCenterDriver::VIClient.new_from_datastore(
+                        ds.id
+                    )
 
-                    if config_vcenter.key?(:default_template)
-                        options[:template] =
-                            config_vcenter[:default_template]
+                    # Get datastore object
+                    ds_ref    = ds['//VCENTER_DS_REF']
+                    datastore = VCenterDriver::Datastore.new_from_ref(
+                        ds_ref,
+                        vi_client
+                    )
 
-                        options
-                    else
-                        raise "Couldn't find default_template " \
-                              'configuration in vcenterrc conf ' \
-                              'file. Please use the --template ' \
-                              'file to define a VM Template ID if ' \
-                              'needed or add default_template to' \
-                              ' vcenterrc conf file'
+                    # Get resource pool
+                    host_ref          = datastore['host'].first.key.parent._ref
+                    vi_client.ccr_ref = host_ref
+
+                    host = VCenterDriver::ClusterComputeResource.new_from_ref(
+                        host_ref,
+                        vi_client
+                    )
+
+                    rp = host.resource_pools.first
+
+                    # Get vCentrer instance ID
+                    uuid = vi_client.vim.serviceContent.about.instanceUuid
+
+                    # Create VM folder it not exists
+                    dc        = datastore.obtain_dc.item
+                    vm_folder = dc.find_folder('one_default_template')
+
+                    if vm_folder.nil?
+                        dc.vmFolder.CreateFolder(
+                            :name => 'one_default_template'
+                        )
+                        vm_folder = dc.find_folder('one_default_template')
+                    end
+
+                    # Define default VM config
+                    vm_cfg = { :name     => "one_app_template-#{ds.id}",
+                            :guestId  => 'otherGuest',
+                            :numCPUs  => 1,
+                            :memoryMB => 128,
+                            :files    => {
+                                :vmPathName => "[#{datastore.item.name}]"
+                            } }
+
+                    # Create the VM
+                    vm = vm_folder.CreateVM_Task(
+                        :config => vm_cfg,
+                        :pool   => rp
+                    ).wait_for_completion
+
+                    # Create the VM template
+                    vm.MarkAsTemplate
+
+                    ret['VCENTER_TEMPLATE_REF'] = vm._ref
+                    ret['VCENTER_CCR_REF']      = host_ref
+                    ret['VCENTER_INSTANCE_ID']  = uuid
+
+                    ret.each do |key, value|
+                        ds.update("#{key}=\"#{value}\"", true)
                     end
+                end
+
+                tmpl = <<-EOT
+                NAME   = "#{options[:vmtemplate_name] || options[:name]}"
+                CPU    = "1"
+                VCPU   = "1"
+                MEMORY = "128"
+                HYPERVISOR = "vcenter"
+                EOT
+
+                tmpl << "DISK = [ IMAGE_ID = \"#{image.id}\" ]" if image
+
+                ret.each do |key, value|
+                    tmpl << "#{key}=\"#{value}\"\n"
+                end
+
+                vmtpl = Template.new(Template.build_xml, @client)
+
+                rc = vmtpl.allocate(tmpl)
+
+                if OpenNebula.is_error?(rc)
+                    rc
                 else
-                    raise "Couldn't find vcenterrc conf file. " \
-                          ' Please use the --template file to define' \
-                          ' a VM Template ID if needed.'
+                    Template.new_with_id(vmtpl.id, @client)
                 end
             end
 
+            def update_options_with_template(options)
+                path = "#{VAR_LOCATION}/remotes/etc/vmm/vcenter/vcenterrc"
+
+                return options unless File.file?(path)
+
+                config = YAML.load_file(path)
+
+                return options unless config.key?(:default_template)
+
+                options[:template] = config[:default_template]
+
+                options
+            end
+
             # Creates a VM template based on the APPTEMPLATE64 attribute
             #    @param [Hash] options
             #       :export_name [String] name of the vm template
@@ -334,19 +442,19 @@ module OpenNebula::MarketPlaceAppExt
                         options = update_options_with_template(options)
                     end
 
-                    template_id = options[:template]
-
-                    if template_id < 0
-                        return
-                    end
+                    if !options[:template] || options[:template] == -1
+                        vmtpl = create_vcenter_template(ds, options)
+                    else
+                        template_id = options[:template]
+                        template    = Template.new_with_id(template_id, @client)
 
-                    template = Template.new_with_id(template_id, @client)
+                        vmtpl_id = template.clone(
+                            options[:vmtemplate_name] || options[:name]
+                        )
 
-                    vmtpl_id = template.clone(
-                        options[:vmtemplate_name] || options[:name]
-                    )
+                        vmtpl = Template.new_with_id(vmtpl_id, @client)
+                    end
 
-                    vmtpl = Template.new_with_id(vmtpl_id, @client)
                     rc = vmtpl.info
                 else
                     # ----------------------------------------------------------
@@ -461,7 +569,7 @@ module OpenNebula::MarketPlaceAppExt
             def export_recursive(xpath, options)
                 # Get marketplace apps pool to find roles apps
                 pool = OpenNebula::MarketPlaceAppPool.new(@client)
-                rc   = pool.info
+                rc   = pool.info_all
 
                 return rc if OpenNebula.is_error?(rc)
 

data/lib/opennebula/oneflow_client.rb

@@ -319,10 +319,21 @@ module Service
 
     class Client
         def initialize(opts={})
+            endpoint  = '/.one/oneflow_endpoint'
             @username = opts[:username] || ENV['ONEFLOW_USER']
             @password = opts[:password] || ENV['ONEFLOW_PASSWORD']
 
-            url = opts[:url] || ENV['ONEFLOW_URL'] || 'http://localhost:2474'
+            if opts[:url]
+                url = opts[:url]
+            elsif ENV['ONEFLOW_URL']
+                url = ENV['ONEFLOW_URL']
+            elsif ENV['HOME'] && File.exists?(ENV['HOME'] + endpoint)
+                url = File.read(ENV['HOME'] + endpoint).strip
+            elsif File.exists?('/var/lib/one/.one/oneflow_endpoint')
+                url = File.read('/var/lib/one/.one/oneflow_endpoint').strip
+            else
+                url = 'http://localhost:2474'
+            end
 
             if @username.nil? && @password.nil?
                 if ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and File.file?(ENV["ONE_AUTH"])

data/lib/opennebula/user.rb

@@ -89,8 +89,8 @@ module OpenNebula
         #######################################################################
 
         # Retrieves the information of the given User.
-        def info()
-            super(USER_METHODS[:info], 'USER')
+        def info(decrypt = false)
+            super(USER_METHODS[:info], 'USER', decrypt)
         end
 
         alias_method :info!, :info

data/lib/opennebula/virtual_machine_ext.rb

@@ -94,6 +94,35 @@ module OpenNebula::VirtualMachineExt
                     raise rc.message if OpenNebula.is_error?(rc)
                 end
 
+                # --------------------------------------------------------------
+                # Ask if source VM is linked clone
+                # --------------------------------------------------------------
+                use_linked_clones = self['USER_TEMPLATE/VCENTER_LINKED_CLONES']
+
+                if use_linked_clones && use_linked_clones.downcase == 'yes'
+                    # Delay the require until it is strictly needed
+                    # This way we can avoid the vcenter driver dependency
+                    # in no vCenter deployments
+                    require 'vcenter_driver'
+
+                    deploy_id = self['DEPLOY_ID']
+                    vm_id = self['ID']
+                    host_id = self['HISTORY_RECORDS/HISTORY[last()]/HID']
+                    vi_client = VCenterDriver::VIClient.new_from_host(host_id)
+
+                    vm = VCenterDriver::VirtualMachine.new(
+                        vi_client,
+                        deploy_id,
+                        vm_id
+                    )
+
+                    error, vm_template_ref = vm.save_as_linked_clones(name)
+
+                    raise error unless error.nil?
+
+                    return vm_template_ref
+                end
+
                 # --------------------------------------------------------------
                 # Clone the source template
                 # --------------------------------------------------------------
@@ -271,7 +300,7 @@ module OpenNebula::VirtualMachineExt
 
                 raise rc.message if OpenNebula.is_error?(rc)
 
-                binfo.merge!(backup_info) do |key, old_val, new_val|
+                binfo.merge!(backup_info) do |_key, old_val, new_val|
                     new_val.nil? ? old_val : new_val
                 end
 
@@ -472,7 +501,7 @@ module OpenNebula::VirtualMachineExt
                 end
 
                 binfo[:apps].each do |id|
-                    logger.info "Deleting applicance #{id}" if logger
+                    logger.info "Deleting appliance #{id}" if logger
 
                     papp = OpenNebula::MarketPlaceApp.new_with_id(id, @client)
 

data/lib/opennebula/virtual_machine_pool.rb

@@ -450,6 +450,10 @@ module OpenNebula
         private
 
         def build_accounting(filter_flag, options, &block)
+
+            options[:start_time] = -1 if options[:start_time].nil?
+            options[:end_time]   = -1 if options[:end_time].nil?
+
             xml_str = @client.call(VM_POOL_METHODS[:accounting],
                         filter_flag,
                         options[:start_time],

data/lib/opennebula.rb

@@ -77,5 +77,5 @@ require 'opennebula/flow'
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '6.1.90'
+    VERSION = '6.2.2'
 end

data/lib/scripts_common.rb

@@ -28,6 +28,11 @@ module OpenNebula
         log_function("INFO", message)
     end
 
+    # Logs an info message
+    def self.log_warning(message)
+        log_function('WARNING', message)
+    end
+
     # Logs an error message
     def self.log_error(message)
         log_function("ERROR", message)

data/lib/vcenter_importer.rb

@@ -202,7 +202,7 @@ module VCenterDriver
         # index associated to his own resource opt
         #
         # Example:
-        # {"vm-343" => {linked: '0', copy: '0'...}
+        # {"vm-343" => {:linked_clone: '0', :copy: '0'...}
         #
         # @ return [Hash] the list of unimported resources
         #
@@ -263,7 +263,10 @@ module VCenterDriver
 
                 cluster_list = {}
                 cpool.each do |c|
-                    cluster_list[c['ID']] = c['NAME'] if c['ID'].to_i != 0
+                    name = VCenterDriver::VcImporter.sanitize(
+                        c['NAME']
+                    )
+                    cluster_list[c['ID']] = name if c['ID'].to_i != 0
                 end
 
                 # Get OpenNebula's host pool
@@ -276,6 +279,15 @@ module VCenterDriver
                 rs = dc_folder.get_unimported_hosts(hpool,
                                                     vcenter_instance_name)
 
+                # Select just cluster with this reference
+                if options[:cluster_ref]
+                    rs.each do |_, clusters|
+                        clusters.select! do |c|
+                            c[:cluster_ref] == options[:cluster_ref]
+                        end
+                    end
+                end
+
                 STDOUT.print "done!\n\n"
 
                 rs.each do |dc, clusters|
@@ -312,10 +324,13 @@ module VCenterDriver
 
                                 cluster_list_str = "\n"
                                 cluster_list.each do |key, value|
+                                    name = VCenterDriver::VcImporter.sanitize(
+                                        value
+                                    )
                                     cluster_list_str << "      - \e[94mID: " \
                                                      << key \
                                                      << "\e[39m - NAME: " \
-                                                     << value << "\n"
+                                                     << name << "\n"
                                 end
 
                                 STDOUT.print "\n    #{cluster_list_str}"
@@ -330,15 +345,19 @@ module VCenterDriver
                             end
                         end
 
+                        cluster_name = VCenterDriver::VcImporter.sanitize(
+                            cluster[:cluster_name]
+                        )
+
                         # Check if the OpenNebula Cluster exists, and reuse it
                         one_cluster_id ||= cluster_list
-                                           .key(cluster[:cluster_name])
+                                           .key(cluster_name)
 
                         if !one_cluster_id
                             one_cluster = VCenterDriver::VIHelper
                                           .new_one_item(OpenNebula::Cluster)
                             rc = one_cluster
-                                 .allocate((cluster[:cluster_name]).to_s)
+                                 .allocate(cluster_name.to_s)
                             if ::OpenNebula.is_error?(rc)
                                 # rubocop:disable Layout/LineLength
                                 STDOUT.puts "    Error creating OpenNebula cluster: #{rc.message}\n"
@@ -355,7 +374,7 @@ module VCenterDriver
                                            rpool,
                                            one_cluster_id)
                         # rubocop:disable Layout/LineLength
-                        STDOUT.puts "\n    OpenNebula host \e[92m#{cluster[:cluster_name]}\e[39m with"\
+                        STDOUT.puts "\n    OpenNebula host \e[92m#{cluster_name}\e[39m with"\
                                     " ID \e[94m#{one_host.id}\e[39m successfully created."
                         STDOUT.puts
                         # rubocop:enable Layout/LineLength