opennebula 6.6.1 → 6.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af7eaa43ec35cbc81be2215013a235e6be0ed5b73f4ff4f4b55a21f4d85df635
-  data.tar.gz: 19a6fd052192ac9d266caea0718a8abb29c1bc1a86624b7162ad6a1dbea5fe0d
+  metadata.gz: 885bbb7b22fbe7f2652e00b846dbf5881960a9cd041282d789a669d671a5835f
+  data.tar.gz: e7575d6535512ae13e139249ecfb05cac655cd34013176184bf98ce6fc5215dd
 SHA512:
-  metadata.gz: af9f1f08ed1e6e43b3d69c1092d45909f8d5b423d801db6efad379d12137d3a36b119db9c7a0da7f7b6d96e9e6e5598043b3d22c5827a3d1b62fdaf082aba010
-  data.tar.gz: f73c345fd3f1ed0fe33f70cb58d409618c8e875260416457eb8a01d93d2d869b3fd9d8171026be1600fa7b01c440f1c5f0d6aeda7de6b0bc1cda65babfac3917
+  metadata.gz: 138d7785b0d1c4dc84df1a862f6a14de05a4156ee44b1bff15752dcb99daab62e9590a776d4bc3d5dcd8c45924c574b0b1a8da1aa16e37626609780811b2e47a
+  data.tar.gz: b3ff5aa1bf6ef4ed40f37e77beb6a8e4e11aaa7bbeed6c5643c316cb95f795d0c4792b026478c92298d8e00b584955a9c2970f14eb03257c8316ef9bb886d198

data/lib/DriverExecHelper.rb

@@ -189,7 +189,7 @@ module DriverExecHelper
                 cfg=file.read
             end
 
-            cfg.split(/\n/).each do |line|
+            cfg.split("\n").each do |line|
                 m=line.match(/^([^=]+)=(.*)$/)
 
                 next unless m

data/lib/HostSyncManager.rb

@@ -0,0 +1,111 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2023, 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.                                             #
+# -------------------------------------------------------------------------- #
+
+# rubocop:disable Lint/MissingCopEnableDirective
+# rubocop:disable Layout/FirstArgumentIndentation
+# rubocop:disable Layout/FirstHashElementIndentation
+# rubocop:disable Layout/HashAlignment
+# rubocop:disable Layout/HeredocIndentation
+# rubocop:disable Layout/IndentationWidth
+# rubocop:disable Style/HashSyntax
+# rubocop:disable Style/ParallelAssignment
+
+require 'CommandManager'
+
+# This helper module introduces a common routine that synchronizes
+# the "remotes".
+class HostSyncManager
+
+    def initialize(one_config = nil)
+        one_location = ENV['ONE_LOCATION']&.delete("'")
+        if one_location.nil?
+            @one_config_path         = '/var/lib/one/config'
+            @local_scripts_base_path = '/var/lib/one/remotes'
+        else
+            @one_config_path         = one_location + '/var/config'
+            @local_scripts_base_path = one_location + '/var/remotes'
+        end
+
+        # Do a simple parsing of the config file unless the values
+        # are already provided. NOTE: We don't care about "arrays" here..
+        one_config ||= File.read(@one_config_path).lines.each_with_object({}) \
+        do |line, object|
+            key, value = line.split('=').map(&:strip)
+            object[key.upcase] = value
+        end
+
+        @remote_scripts_base_path = one_config['SCRIPTS_REMOTE_DIR']
+        @remote_scripts_base_path&.delete!("'")
+    end
+
+    def update_remotes(hostname, logger = nil, copy_method = :rsync, subset = nil)
+        sources = '.'
+
+        if subset && copy_method == :rsync
+            # Make sure all files in the subset exist (and are relative).
+            subset.each do |path|
+                File.realpath path, @local_scripts_base_path
+            end
+
+            sources = subset.join(' ')
+        end
+
+        assemble_cmd = lambda do |steps|
+            "exec 2>/dev/null; #{steps.join(' && ')}"
+        end
+
+        case copy_method
+        when :ssh
+            mkdir_cmd = assemble_cmd.call [
+                "rm -rf '#{@remote_scripts_base_path}'/",
+                "mkdir -p '#{@remote_scripts_base_path}'/"
+            ]
+
+            sync_cmd = assemble_cmd.call [
+                "cd '#{@local_scripts_base_path}'/",
+                "scp -rp #{sources} " \
+                    "'#{hostname}':'#{@remote_scripts_base_path}'/"
+            ]
+        when :rsync
+            mkdir_cmd = assemble_cmd.call [
+                "mkdir -p '#{@remote_scripts_base_path}'/"
+            ]
+
+            sync_cmd = assemble_cmd.call [
+                "cd '#{@local_scripts_base_path}'/",
+                "rsync -LRaz --delete #{sources} " \
+                    "'#{hostname}':'#{@remote_scripts_base_path}'/"
+            ]
+        end
+
+        cmd = SSHCommand.run(mkdir_cmd, hostname, logger)
+        return cmd.code if error?(cmd)
+
+        cmd = LocalCommand.run(sync_cmd, logger)
+        return cmd.code if error?(cmd)
+
+        0
+    end
+
+    def error?(cmd)
+        return false if cmd.code == 0
+
+        STDERR.puts cmd.stderr
+        STDOUT.puts cmd.stdout
+        true
+    end
+
+end

data/lib/VirtualMachineDriver.rb

@@ -55,7 +55,8 @@ class VirtualMachineDriver < OpenNebulaDriver
         :update_conf => "UPDATECONF",
         :resize      => "RESIZE",
         :backup      => "BACKUP",
-        :update_nic   => "UPDATENIC"
+        :update_nic   => "UPDATENIC",
+        :backup_cancel=> "BACKUPCANCEL"
     }
 
     POLL_ATTRIBUTE = OpenNebula::VirtualMachine::Driver::POLL_ATTRIBUTE
@@ -104,6 +105,7 @@ class VirtualMachineDriver < OpenNebulaDriver
         register_action(ACTION[:resize].to_sym, method("resize"))
         register_action(ACTION[:backup].to_sym, method("backup"))
         register_action(ACTION[:update_nic].to_sym, method("update_nic"))
+        register_action(ACTION[:backup_cancel].to_sym, method("backup_cancel"))
     end
 
     # Decodes the encoded XML driver message received from the core
@@ -248,6 +250,11 @@ class VirtualMachineDriver < OpenNebulaDriver
         send_message(ACTION[:update_nic],RESULT[:failure],id,error)
     end
 
+    def backup_cancel(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:backup_cancel],RESULT[:failure],id,error)
+    end
+
 private
 
     # Interface to handle the pending events from the ActionManager Interface

data/lib/cloud/CloudClient.rb

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

data/lib/host.rb

@@ -352,7 +352,7 @@ module VCenterDriver
             str_info << 'USEDMEMORY='  << (total_mem - free_mem).to_s << "\n"
 
             # DRS enabled
-            str_info << 'VCENTER_DRS='  << drs_enabled.to_s << "\n"
+            str_info << 'VCENTER_DRS=' << drs_enabled.to_s << "\n"
 
             # HA enabled
             str_info << 'VCENTER_HA=' << ha_enabled.to_s << "\n"

data/lib/models/service.rb

@@ -323,6 +323,9 @@ module OpenNebula
 
             template['start_time'] = Integer(Time.now)
 
+            # Replace $attibute by the corresponding value
+            resolve_attributes(template)
+
             super(template.to_json, template['name'])
         end
 
@@ -660,7 +663,7 @@ module OpenNebula
             end if deploy
 
             # Replace $attibute by the corresponding value
-            resolve_attributes(body)
+            resolve_networks(body)
 
             # @body = template.to_hash
 
@@ -784,31 +787,49 @@ module OpenNebula
         end
 
         # rubocop:disable Layout/LineLength
+        def resolve_networks(template)
+            template['roles'].each do |role|
+                next unless role['vm_template_contents']
+
+                # $CUSTOM1_VAR Any word character
+                # (letter, number, underscore)
+                role['vm_template_contents'].scan(/\$(\w+)/).each do |key|
+                    net = template['networks_values'].find {|att| att.key? key[0] }
+
+                    next if net.nil?
+
+                    role['vm_template_contents'].gsub!(
+                        '$'+key[0],
+                        net[net.keys[0]]['id'].to_s
+                    )
+                end
+            end
+        end
+
         def resolve_attributes(template)
             template['roles'].each do |role|
                 if role['vm_template_contents']
                     # $CUSTOM1_VAR Any word character
                     # (letter, number, underscore)
                     role['vm_template_contents'].scan(/\$(\w+)/).each do |key|
-                        # Check if $ var value is in custom_attrs_values
-                        if !template['custom_attrs_values'].nil? &&
-                           template['custom_attrs_values'].key?(key[0])
+                        # Check if $ var value is in custom_attrs_values within the role
+                        if !role['custom_attrs_values'].nil? && \
+                            role['custom_attrs_values'].key?(key[0])
                             role['vm_template_contents'].gsub!(
                                 '$'+key[0],
-                                template['custom_attrs_values'][key[0]]
+                                role['custom_attrs_values'][key[0]]
                             )
                             next
                         end
 
-                        # Check if $ var value is in networks
-                        net = template['networks_values']
-                              .find {|att| att.key? key[0] }
+                        # Check if $ var value is in custom_attrs_values
 
-                        next if net.nil?
+                        next unless !template['custom_attrs_values'].nil? && \
+                                     template['custom_attrs_values'].key?(key[0])
 
                         role['vm_template_contents'].gsub!(
                             '$'+key[0],
-                            net[net.keys[0]]['id'].to_s
+                            template['custom_attrs_values'][key[0]]
                         )
                     end
                 end

data/lib/opennebula/flow/service_template.rb

@@ -42,6 +42,16 @@ module OpenNebula
                     :type => :string,
                     :required => false
                 },
+                'custom_attrs' => {
+                    :type => :object,
+                    :properties => {},
+                    :required => false
+                },
+                'custom_attrs_values' => {
+                    :type => :object,
+                    :properties => {},
+                    :required => false
+                },
                 'parents' => {
                     :type => :array,
                     :items => {
@@ -487,7 +497,7 @@ module OpenNebula
                 instantiate_template = JSON.parse(@body.to_json)
             else
                 instantiate_template = JSON.parse(@body.to_json)
-                                           .merge(merge_template)
+                                           .deep_merge(merge_template)
             end
 
             begin

data/lib/opennebula/pool_element.rb

@@ -17,11 +17,13 @@
 require 'opennebula/pool'
 
 module OpenNebula
+
     # The PoolElement Class represents a generic element of a Pool in
     # XML format
     class PoolElement < XMLElement
 
-    protected
+        protected
+
         # node:: _XML_is a XML element that represents the Pool element
         # client:: _Client_ represents a XML-RPC connection
         def initialize(node, client)
@@ -49,12 +51,12 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def call(xml_method, *args)
-            return Error.new('ID not defined') if !@pe_id
+            return Error.new('ID not defined') unless @pe_id
 
             rc = @client.call(xml_method, *args)
-            rc = nil if !OpenNebula.is_error?(rc)
+            rc = nil unless OpenNebula.is_error?(rc)
 
-            return rc
+            rc
         end
 
         # Calls to the corresponding info method to retreive the element
@@ -66,19 +68,19 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def info(xml_method, root_element, decrypt = false)
-            return Error.new('ID not defined') if !@pe_id
+            return Error.new('ID not defined') unless @pe_id
 
             rc = @client.call(xml_method, @pe_id, decrypt)
 
             if !OpenNebula.is_error?(rc)
                 initialize_xml(rc, root_element)
-                rc   = nil
+                rc = nil
 
                 @pe_id = self['ID'].to_i if self['ID']
                 @name  = self['NAME'] if self['NAME']
             end
 
-            return rc
+            rc
         end
 
         # Calls to the corresponding allocate method to create a new element
@@ -97,7 +99,7 @@ module OpenNebula
                 rc     = nil
             end
 
-            return rc
+            rc
         end
 
         # Calls to the corresponding update method to modify
@@ -111,10 +113,10 @@ module OpenNebula
         #   otherwise
         def update(xml_method, new_template, *args)
             if new_template.nil?
-                return Error.new("Wrong argument", Error::EXML_RPC_CALL)
+                return Error.new('Wrong argument', Error::EXML_RPC_CALL)
             end
 
-            return call(xml_method, @pe_id, new_template, *args)
+            call(xml_method, @pe_id, new_template, *args)
         end
 
         # Calls to the corresponding delete method to remove this element
@@ -125,7 +127,7 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def delete(xml_method)
-            return call(xml_method,@pe_id)
+            call(xml_method, @pe_id)
         end
 
         # Calls to the corresponding chown method to modify
@@ -138,7 +140,7 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def chown(xml_method, uid, gid)
-            return call(xml_method, @pe_id, uid, gid)
+            call(xml_method, @pe_id, uid, gid)
         end
 
         # Calls to the corresponding chmod method to modify
@@ -149,7 +151,7 @@ module OpenNebula
         #
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
-        def chmod_octet(xml_method, octet)
+        def chmod_octet(_xml_method, octet)
             owner_u = octet[0..0].to_i & 4 != 0 ? 1 : 0
             owner_m = octet[0..0].to_i & 2 != 0 ? 1 : 0
             owner_a = octet[0..0].to_i & 1 != 0 ? 1 : 0
@@ -161,7 +163,7 @@ module OpenNebula
             other_a = octet[2..2].to_i & 1 != 0 ? 1 : 0
 
             chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
-                other_m, other_a)
+                  other_m, other_a)
         end
 
         # Calls to the corresponding chmod method to modify
@@ -173,13 +175,12 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def chmod(xml_method, owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
-                other_m, other_a)
-            return call(xml_method, @pe_id, owner_u, owner_m,
-                            owner_a, group_u, group_m, group_a, other_u,
-                            other_m, other_a)
+                  other_m, other_a)
+            call(xml_method, @pe_id, owner_u, owner_m,
+                 owner_a, group_u, group_m, group_a, other_u,
+                 other_m, other_a)
         end
 
-
         # Retrieves this Element's monitoring data from OpenNebula
         #
         # @param [String] xml_method the name of the XML-RPC method
@@ -189,28 +190,27 @@ module OpenNebula
         # @return [Hash<String, Array<Array<int>>, OpenNebula::Error] Hash with
         #   the requested xpath expressions, and an Array of [timestamp, value].
         def monitoring(xml_method, xpaths)
-            return Error.new('ID not defined') if !@pe_id
+            return Error.new('ID not defined') unless @pe_id
 
             rc = @client.call(xml_method, @pe_id)
 
-            if ( OpenNebula.is_error?(rc) )
+            if OpenNebula.is_error?(rc)
                 return rc
             end
 
             xmldoc = XMLElement.new
             xmldoc.initialize_xml(rc, 'MONITORING_DATA')
 
-
-            return OpenNebula.process_monitoring(xmldoc, @pe_id, xpaths)
+            OpenNebula.process_monitoring(xmldoc, @pe_id, xpaths)
         end
 
-    public
+        public
 
         # Creates new element specifying its id
         # id:: identifyier of the element
         # client:: initialized OpenNebula::Client object
-        def self.new_with_id(id, client=nil)
-            self.new(self.build_xml(id), client)
+        def self.new_with_id(id, client = nil)
+            new(build_xml(id), client)
         end
 
         # Returns element identifier
@@ -221,16 +221,14 @@ module OpenNebula
 
         # Gets element name
         # [return] _String_ the PoolElement name
-        def name
-            @name
-        end
+        attr_reader :name
 
         # DO NOT USE - ONLY REXML BACKEND
         def to_str
-            str = ""
-            REXML::Formatters::Pretty.new(1).write(@xml,str)
+            str = ''
+            REXML::Formatters::Pretty.new(1).write(@xml, str)
 
-            return str
+            str
         end
 
         # Replace the xml pointed by xpath using  a Hash object
@@ -240,18 +238,19 @@ module OpenNebula
         # @param [Hash] options object containing pair key-value
         #
         # @returns the new xml representation
-        def replace(opts, xpath = "TEMPLATE")
-            if self[xpath]
-                opts.each do |att, value|
-                    xpath_u = xpath+"/#{att}"
-                    docs = retrieve_xmlelements(xpath_u)
-                    if docs.size == 1
-                        docs[0].set_content(value)
-                    end
+        def replace(opts, xpath = 'TEMPLATE')
+            return unless self[xpath]
+
+            opts.each do |att, value|
+                xpath_u = xpath+"/#{att}"
+                docs = retrieve_xmlelements(xpath_u)
+                if docs.size == 1
+                    docs[0].set_content(value)
                 end
-                update(template_like_str(xpath))
             end
+            update(template_like_str(xpath))
         end
+
     end
 
     # Processes the monitoring data in XML returned by OpenNebula
@@ -266,20 +265,22 @@ module OpenNebula
     def self.process_monitoring(xmldoc, oid, xpath_expressions)
         hash = {}
         timestamps = xmldoc.retrieve_elements(
-            "/MONITORING_DATA/MONITORING[ID=#{oid}]/TIMESTAMP")
+            "/MONITORING_DATA/MONITORING[ID=#{oid}]/TIMESTAMP"
+        )
 
-        xpath_expressions.each { |xpath|
+        xpath_expressions.each do |xpath|
             xpath_values = xmldoc.retrieve_elements(
-                "/MONITORING_DATA/MONITORING[ID=#{oid}]/#{xpath}")
+                "/MONITORING_DATA/MONITORING[ID=#{oid}]/#{xpath}"
+            )
 
-            if ( xpath_values.nil? )
+            if xpath_values.nil?
                 hash[xpath] = []
             else
                 hash[xpath] = timestamps.zip(xpath_values)
             end
-        }
+        end
 
-        return hash
+        hash
     end
 
 end