opennebula 6.6.2 → 6.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0911e0ad571781c4b94ee39d8459948d92ef8eb0d95aa9e06387bf402d2abd9
-  data.tar.gz: 98c66b223bdf54a82a8d4524288067b9b41045781ff90d4828328db18066d67f
+  metadata.gz: 885bbb7b22fbe7f2652e00b846dbf5881960a9cd041282d789a669d671a5835f
+  data.tar.gz: e7575d6535512ae13e139249ecfb05cac655cd34013176184bf98ce6fc5215dd
 SHA512:
-  metadata.gz: 9fc7ce19570b9ee1c5b3047e4d0503bd7028b4cee025fd37b8c42526fbe440fb0398ca2c9ba7a803e524e4fd9415f54c971e6be8aaa16a3513df91677cb1f557
-  data.tar.gz: 6e39b6567ce933244ddcedb2700abb82e002ccf3ed6199b78cccd064330fd93e7774d44defa7d6901b6a9d08ffd0abc798cd17f1706088f24897d7efcaaaeef5
+  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/cloud/CloudClient.rb

@@ -51,7 +51,7 @@ end
 module CloudClient
 
     # OpenNebula version
-    VERSION = '6.6.2'
+    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/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