opennebula 5.12.13 → 5.13.80.pre

data/lib/vi_client.rb

@@ -0,0 +1,281 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+require 'openssl'
+require 'yaml'
+
+##############################################################################
+# Module VCenterDriver
+##############################################################################
+module VCenterDriver
+
+    ##########################################################################
+    # Class VIClient
+    ##########################################################################
+    class VIClient
+
+        attr_accessor :vim
+        attr_accessor :rp
+        attr_accessor :vc_name
+        attr_accessor :ccr_ref
+
+        def initialize(opts, host_id = -1)
+            opts = { :insecure => true }.merge(opts)
+            @host_id = host_id
+            @vim = RbVmomi::VIM.connect(opts)
+            @vc_name = opts[:host] if opts[:host]
+
+            # Get ccr and get rp
+            @ccr_ref = opts.delete(:ccr)
+
+            return unless @ccr_ref
+
+            ccr = RbVmomi::VIM::ClusterComputeResource.new(@vim, @ccr_ref)
+
+            # Get ref for rp
+
+            return unless ccr
+
+            rp = opts.delete(:rp)
+
+            return unless rp
+
+            rp_list = get_resource_pools(ccr)
+            rp_ref =
+                rp_list
+                .select {|r| r[:name] == rp }.first[:ref] rescue nil
+            @rp = RbVmomi::VIM::ResourcePool(@vim, rp_ref) if rp_ref
+        end
+
+        def rp_confined?
+            !!@rp
+        end
+
+        def host_credentials(one_client)
+            raise 'no host id defined!' if @host_id == -1
+
+            host =
+                OpenNebula::Host
+                .new_with_id(
+                    @host_id,
+                    one_client
+                )
+            rc = host.info
+            if OpenNebula.is_error?(rc)
+                raise "Could not get host info \
+                for ID: #{@host_id} - #{rc.message}"
+            end
+
+            { :pass => host['TEMPLATE/VCENTER_PASSWORD'],
+             :user => host['TEMPLATE/VCENTER_USER'],
+             :host => @vc_name }
+        end
+
+        def get_resource_pools(ccr, rp = nil, parent_prefix = '', rp_array = [])
+            current_rp = ''
+
+            if !rp
+                rp = ccr.resourcePool
+            else
+                if !parent_prefix.empty?
+                    current_rp << parent_prefix
+                    current_rp << '/'
+                end
+                current_rp << rp.name
+            end
+
+            if rp.resourcePool.empty?
+                rp_info = {}
+                rp_info[:name] = current_rp
+                rp_info[:ref]  = rp._ref
+                rp_array << rp_info
+            else
+                rp.resourcePool.each do |child_rp|
+                    get_resource_pools(ccr, child_rp, current_rp, rp_array)
+                end
+                rp_info = {}
+                rp_info[:name] = current_rp
+                rp_info[:ref]  = rp._ref
+                rp_array << rp_info unless current_rp.empty?
+            end
+
+            rp_array
+        end
+
+        def close_connection
+            @vim.close
+        end
+
+        # @return RbVmomi::VIM::<type> objects
+        def self.get_entities(folder, type, entities = [])
+            if folder == []
+                # rubocop:disable Style/ReturnNil
+                return nil
+                # rubocop:enable Style/ReturnNil
+            end
+
+            folder.childEntity.each do |child|
+                the_name, _junk = child.to_s.split('(')
+                case the_name
+                when 'Folder'
+                    get_entities(child, type, entities)
+                when type
+                    entities.push(child)
+                end
+            end
+
+            entities
+        end
+
+        def self.new_from_host(host_id, client = nil)
+            begin
+                client = OpenNebula::Client.new if client.nil?
+                host = OpenNebula::Host.new_with_id(host_id, client)
+                rc = host.info(true)
+                if OpenNebula.is_error?(rc)
+                    raise "Could not get host info for \
+                    ID: #{host_id} - #{rc.message}"
+                end
+
+                connection = {
+                    :host     => host['TEMPLATE/VCENTER_HOST'],
+                    :user     => host['TEMPLATE/VCENTER_USER'],
+                    :rp       => host['TEMPLATE/VCENTER_RESOURCE_POOL'],
+                    :ccr      => host['TEMPLATE/VCENTER_CCR_REF'],
+                    :password => host['TEMPLATE/VCENTER_PASSWORD']
+                }
+
+                vc_port = host['TEMPLATE/VCENTER_PORT']
+                connection[:port] = vc_port unless vc_port.nil?
+
+                new(connection, host_id)
+            rescue StandardError => e
+                raise e
+            end
+        end
+
+        def self.new_from_datastore(datastore_id)
+            begin
+                client = OpenNebula::Client.new
+                datastore =
+                    OpenNebula::Datastore
+                    .new_with_id(
+                        datastore_id,
+                        client
+                    )
+                rc = datastore.info
+                if OpenNebula.is_error?(rc)
+                    raise "Could not get datastore info \
+                    for ID: #{datastore_id} - #{rc.message}"
+                end
+
+                vcenter_id = datastore['TEMPLATE/VCENTER_INSTANCE_ID']
+
+                host_pool = OpenNebula::HostPool.new(client)
+                rc = host_pool.info
+                if OpenNebula.is_error?(rc)
+                    raise "Could not get hosts information - #{rc.message}"
+                end
+
+                user = ''
+                password = ''
+                port = 0
+                host_pool.each do |host|
+                    vc_instance_id = host['TEMPLATE/VCENTER_INSTANCE_ID']
+                    next unless vc_instance_id == vcenter_id
+
+                    host_decrypted =
+                        OpenNebula::Host
+                        .new_with_id(
+                            host['ID'],
+                            client
+                        )
+                    host_decrypted.info(true)
+                    user = host_decrypted['TEMPLATE/VCENTER_USER']
+                    password = host_decrypted['TEMPLATE/VCENTER_PASSWORD']
+                    port = host_decrypted['TEMPLATE/VCENTER_PORT']
+                end
+                if password.empty? || user.empty?
+                    raise "Error getting \
+                    credentials for datastore #{datastore_id}"
+                end
+
+                connection = {
+                    :host     => datastore['TEMPLATE/VCENTER_HOST'],
+                    :user     => user,
+                    :password => password
+                }
+
+                connection[:port] = port unless port.nil?
+
+                new(connection)
+            rescue StandardError => e
+                raise e
+            end
+        end
+
+        def self.decrypt(msg, token)
+            begin
+                cipher = OpenSSL::Cipher.new('aes-256-cbc')
+
+                cipher.decrypt
+
+                # Truncate for Ruby 2.4 (in previous versions this was being
+                #  automatically truncated)
+                cipher.key = token[0..31]
+
+                msg =  cipher.update(Base64.decode64(msg))
+                msg << cipher.final
+            rescue StandardError
+                raise 'Error decrypting secret.'
+            end
+        end
+
+        def self.in_silence
+            begin
+                orig_stderr = $stderr.clone
+                orig_stdout = $stdout.clone
+                $stderr.reopen File.new('/dev/null', 'w')
+                $stdout.reopen File.new('/dev/null', 'w')
+                retval = yield
+            rescue StandardError => e
+                $stdout.reopen orig_stdout
+                $stderr.reopen orig_stderr
+                raise e
+            ensure
+                $stdout.reopen orig_stdout
+                $stderr.reopen orig_stderr
+            end
+            retval
+        end
+
+        def self.in_stderr_silence
+            begin
+                orig_stderr = $stderr.clone
+                $stderr.reopen File.new('/dev/null', 'w')
+                retval = yield
+            rescue StandardError => e
+                $stderr.reopen orig_stderr
+                raise e
+            ensure
+                $stderr.reopen orig_stderr
+            end
+            retval
+        end
+
+    end
+
+end
+# module VCenterDriver

data/lib/vi_helper.rb

@@ -0,0 +1,312 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+########################################################################
+# Module VCenterDriver
+########################################################################
+module VCenterDriver
+
+    ########################################################################
+    # Class VIHelper
+    ########################################################################
+    class VIHelper
+
+        ETC_LOCATION = '/etc/one/' unless defined?(ETC_LOCATION)
+        VCENTER_DRIVER_DEFAULT = "#{ETC_LOCATION}/vcenter_driver.default"
+        VM_PREFIX_DEFAULT = 'one-$i-'
+
+        # rubocop:disable Style/GlobalVars
+        # rubocop:disable Style/ClassVars
+        def self.client
+            if $conf.nil?
+                @@client ||= OpenNebula::Client.new # rubocop:disable Style/ClassVars
+            else
+                @@client ||= OpenNebula::Client.new(
+                    nil,
+                    $conf[:one_xmlrpc]
+                )
+            end
+        end
+        # rubocop:enable Style/GlobalVars
+
+        def self.set_client(options, client = nil)
+            if client.nil?
+                @@client=OpenNebulaHelper::OneHelper.get_client(options, true)
+            else
+                @@client = client
+            end
+        end
+        # rubocop:enable Style/ClassVars
+
+        def self.return_if_error(rc, item, exit_if_fail)
+            if OpenNebula.is_error?(rc)
+                raise rc.message unless exit_if_fail
+
+                STDERR.puts rc.message
+                exit 1
+            else
+                item
+            end
+        end
+
+        require 'scripts_common'
+        def self.check_error(rc, message, exit_condition = false)
+            return unless OpenNebula.is_error?(rc)
+
+            OpenNebula.error_message("\n    Error #{message}: #{rc.message}\n")
+            exit 1 if exit_condition
+
+            raise rc.message
+        end
+
+        def self.get_cluster_id(clusters)
+            clusters.each do |id|
+                return id unless id == -1
+            end
+            -1
+        end
+
+        def self.one_managed?(object)
+            if object.class.ancestors.include?(OpenNebula::XMLElement)
+                managed =
+                    object['TEMPLATE/OPENNEBULA_MANAGED'] ||
+                    object['USER_TEMPLATE/OPENNEBULA_MANAGED']
+                return managed != 'NO'
+            end
+            false
+        end
+
+        def self.check_opts(opts, att_list)
+            att_list.each do |att|
+                raise "#{att} option is mandatory" if opts[att].nil?
+            end
+        end
+
+        def self.one_item(the_class, id, exit_if_fail = true)
+            item = the_class.new_with_id(id, client)
+            rc = item.info
+            return_if_error(rc, item, exit_if_fail)
+        end
+
+        def self.new_one_item(the_class)
+            the_class.new(the_class.build_xml, client)
+        end
+
+        def self.one_pool(the_class, exit_if_fail = true)
+            item = the_class.new(client)
+
+            rc = nil
+            begin
+                rc = item.info_all
+            rescue StandardError
+                rc = item.info
+            end
+
+            return_if_error(rc, item, exit_if_fail)
+        end
+
+        def self.find_by_name(the_class, name, pool = nil, raise_if_fail = true)
+            pool = one_pool(the_class, raise_if_fail) if pool.nil?
+            element = pool.find {|e| e['NAME'] == name.to_s }
+            if element.nil? && raise_if_fail
+                raise "Could not find element '#{name}' in pool '#{the_class}'"
+            end
+
+            element
+        end
+
+        def self.generate_name(opts, nbytes)
+            return opts[:name] if nbytes <= 0
+
+            @sha256 ||= Digest::SHA256.new
+            chain = opts[:key]
+            hash  = @sha256.hexdigest(chain)[0..nbytes-1]
+
+            "#{opts[:name]}-#{hash}"
+        end
+
+        def self.one_name(the_class, name, key, pool = nil, bytes = 0)
+            # Remove \u007F character that comes from vcenter
+            name = name.tr("\u007F", '')
+            pool = one_pool(the_class) if pool.nil?
+
+            import_name = generate_name({ :name => name, :key => key }, bytes)
+
+            begin
+                find_by_name(the_class, import_name, pool)
+            rescue StandardError
+                return import_name
+            end
+
+            one_name(the_class, name, key, pool, bytes+2)
+        end
+
+        def self.get_ref_key(element, attribute, vcenter_uuid = nil)
+            key = element[attribute]
+
+            return if key.nil?
+
+            tvid = element['TEMPLATE/VCENTER_INSTANCE_ID']
+            uvid = element['USER_TEMPLATE/VCENTER_INSTANCE_ID']
+
+            if tvid
+                key += tvid
+            elsif uvid
+                key += uvid
+            elsif vcenter_uuid
+                key += vcenter_uuid
+            end
+
+            key
+        end
+
+        def self.create_ref_hash(attribute, pool, vcenter_uuid = nil)
+            hash = {}
+
+            pool.each_element(proc do |e|
+                refkey = get_ref_key(e, attribute, vcenter_uuid)
+                hash[refkey] = e
+            end)
+
+            hash
+        end
+
+        def self.clean_ref_hash
+            @ref_hash = {}
+        end
+
+        def self.add_ref_hash(attr, one_object)
+            raise 'cache is empty!' unless @ref_hash
+
+            refkey = get_ref_key(one_object, attr)
+
+            return unless @ref_hash[attr]
+
+            @ref_hash[attr][refkey] = one_object
+        end
+
+        def self.remove_ref_hash(attr, one_object)
+            raise 'cache is empty!' unless @ref_hash
+
+            refkey = get_ref_key(one_object, attr)
+
+            return unless @ref_hash[attr]
+
+            @ref_hash[attr].delete(refkey)
+        end
+
+        def self.find_by_ref(
+            the_class,
+            attribute,
+            ref,
+            vcenter_uuid,
+            pool = nil
+        )
+            pool = one_pool(the_class, false) if pool.nil?
+            @ref_hash ||= {}
+
+            if @ref_hash[attribute].nil? || @ref_hash[attribute] == {}
+                @ref_hash[attribute] = create_ref_hash(attribute,
+                                                       pool,
+                                                       vcenter_uuid)
+            end
+
+            refkey = ''
+            refkey = ref if ref
+            refkey += vcenter_uuid if vcenter_uuid
+
+            @ref_hash[attribute][refkey]
+        end
+
+        def self.find_image_by(att, the_class, path, ds_id, pool = nil)
+            pool = one_pool(the_class, false) if pool.nil?
+            pool.find do |e|
+                e[att] == path &&
+                    e['DATASTORE_ID'] == ds_id
+            end
+        end
+
+        def self.find_persistent_image_by_source(source, pool)
+            pool.find do |e|
+                e['SOURCE'] == source &&
+                    e['PERSISTENT'] == '1'
+            end
+        end
+
+        def self.find_vcenter_vm_by_name(one_vm, host, vi_client)
+            # Let's try to find the VM object only by its name
+            # Let's build the VM name
+            vm_prefix = host['TEMPLATE/VM_PREFIX']
+            vm_prefix = VM_PREFIX_DEFAULT if vm_prefix.nil? || vm_prefix.empty?
+            vm_prefix.gsub!('$i', one_vm['ID'])
+            vm_name = vm_prefix + one_vm['NAME']
+
+            # We have no DEPLOY_ID, the VM has never been deployed
+            # let's use a view to try to find the VM from the root folder
+            view = vi_client
+                   .vim
+                   .serviceContent
+                   .viewManager
+                   .CreateContainerView(
+                       {
+                           :container => vi_client.vim.rootFolder,
+                       :type => ['VirtualMachine'],
+                       :recursive => true
+                       }
+                   )
+
+            if !view.view.nil? && !view.view.empty?
+                vcenter_vm = view
+                             .view
+                             .find {|v| v.name == vm_name }
+            end
+
+            view.DestroyView # Destroy the view
+
+            vcenter_vm
+        end
+
+        def self.get_default(xpath)
+            begin
+                xml = OpenNebula::XMLElement.new
+                xml.initialize_xml(File.read(VCENTER_DRIVER_DEFAULT), 'VCENTER')
+                xml[xpath]
+            rescue StandardError
+                nil
+            end
+        end
+
+        def self.get_location(item)
+            folders = []
+            until item.instance_of? RbVmomi::VIM::Datacenter
+                item = item.parent
+                if !item.instance_of?(RbVmomi::VIM::Datacenter) &&
+                   item.name != 'host'
+                    folders << item.name
+                end
+                raise 'Could not find the location' if item.nil?
+            end
+            location   = folders.reverse.join('/')
+            location = '/' if location.empty?
+
+            location
+        end
+
+    end
+    # class VIHelper
+
+end
+# module VCenterDriver