opennebula 5.12.10 → 5.13.80.pre

data/lib/opennebula/wait_ext.rb

@@ -0,0 +1,222 @@
+# -------------------------------------------------------------------------- #
+# 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 'ffi-rzmq'
+
+require 'opennebula/host'
+require 'opennebula/image'
+require 'opennebula/virtual_machine'
+
+# Module to decorate Wait classes with the following methods:
+#   - Wait
+#
+# rubocop:disable Style/ClassAndModuleChildren
+module OpenNebula::WaitExt
+
+    # Wait classes and the name published in ZMQ
+    WAIT = {
+        OpenNebula::Host  => {
+            :event => lambda {|o, s1, _s2|
+                "EVENT STATE HOST/#{s1}//#{o['ID']}"
+            },
+
+            :in_state => lambda {|o, s1, _s2|
+                obj_s = Integer(o['STATE'])
+                inx_s = OpenNebula::Host::HOST_STATES.index(s1)
+
+                obj_s == inx_s
+            },
+
+            :in_state_e => lambda {|s1, _s2, content|
+                xml   = Nokogiri::XML(Base64.decode64(content))
+
+                obj_s = Integer(xml.xpath('//HOST/STATE').text)
+                inx_s = OpenNebula::Host::HOST_STATES.index(s1)
+
+                obj_s == inx_s
+            }
+        },
+
+        OpenNebula::Image  => {
+            :event => lambda {|o, s1, _s2|
+                "EVENT STATE IMAGE/#{s1}//#{o['ID']}"
+            },
+
+            :in_state => lambda {|o, s1, _s2|
+                obj_s = Integer(o['STATE'])
+                inx_s = OpenNebula::Image::IMAGE_STATES.index(s1)
+
+                obj_s == inx_s
+            },
+
+            :in_state_e => lambda {|s1, _s2, content|
+                xml   = Nokogiri::XML(Base64.decode64(content))
+
+                obj_s = Integer(xml.xpath('//IMAGE/STATE').text)
+                inx_s = OpenNebula::Image::IMAGE_STATES.index(s1)
+
+                obj_s == inx_s
+            }
+        },
+
+        OpenNebula::VirtualMachine => {
+            :event => lambda {|o, s1, s2|
+                "EVENT STATE VM/#{s1}/#{s2}/#{o['ID']}"
+            },
+
+            :in_state => lambda {|o, s1, s2|
+                obj_s1 = Integer(o['STATE'])
+                inx_s1 = OpenNebula::VirtualMachine::VM_STATE.index(s1)
+
+                obj_s2 = Integer(o['LCM_STATE'])
+                inx_s2 = OpenNebula::VirtualMachine::LCM_STATE.index(s2)
+
+                obj_s1 == inx_s1 && obj_s2 == inx_s2
+            },
+
+            :in_state_e => lambda {|s1, s2, content|
+                xml = Nokogiri::XML(Base64.decode64(content))
+
+                obj_s1 = Integer(xml.xpath('//VM/STATE').text)
+                inx_s1 = OpenNebula::VirtualMachine::VM_STATE.index(s1)
+
+                obj_s2 = Integer(xml.xpath('//VM/LCM_STATE').text)
+                inx_s2 = OpenNebula::VirtualMachine::LCM_STATE.index(s2)
+
+                obj_s1 == inx_s1 && obj_s2 == inx_s2
+            }
+        }
+    }
+
+    def self.extend_object(obj)
+        wait?(obj)
+
+        class << obj
+
+            # Wait until the element reaches some specific state
+            # It waits until the state can be found in ZMQ event message
+            #
+            # @param state_str [String]  State name to wait
+            # @param timeout   [Integer] Number of seconds to timeout event recv
+            # @param cycles    [Integer] Number of recv cycles. After each one
+            #                            object status is checked in OpenNebula.
+            #                            Use -1 (default) to wait forever.
+            def wait(state_str, timeout = 60, cycles = -1)
+                wait2(state_str, '', timeout, cycles)
+            end
+
+            def wait_event(ctx, event, timeout)
+                subscriber = ctx.socket(ZMQ::SUB)
+
+                # Create subscriber
+                key        = ''
+                content    = ''
+
+                subscriber.setsockopt(ZMQ::RCVTIMEO, timeout * 1000)
+                subscriber.setsockopt(ZMQ::SUBSCRIBE, event)
+                subscriber.connect('tcp://localhost:2101')
+
+                rc = subscriber.recv_string(key)
+                rc = subscriber.recv_string(content) if rc != -1
+
+                return if ZMQ::Util.errno == ZMQ::EAGAIN || rc == -1
+
+                content
+            ensure
+                subscriber.setsockopt(ZMQ::UNSUBSCRIBE, event)
+                subscriber.close
+            end
+
+            def wait2(sstr1, sstr2, timeout = 60, cycles = -1)
+                wfun = WAIT[self.class]
+
+                # Start with a timeout of 2 seconds, to wait until the first
+                # info.
+                #
+                # The timeout is increased later, to avoid multiple info calls.
+                c_timeout = 2
+                recvs     = 0
+                in_state  = false
+
+                # Subscribe with timeout seconds
+                #
+                # Subscribe string:
+                #
+                #   EVENT STATE element_name/state_str//self.ID
+                #
+                #   - element_name: is the element name to find in the message
+                #   - self.ID: returns element ID to find in the message
+                ctx = ZMQ::Context.new(1)
+
+                until in_state || (cycles != -1 && recvs >= cycles)
+                    content = wait_event(ctx,
+                                         wfun[:event].call(self, sstr1, sstr2),
+                                         c_timeout)
+
+                    if content && !content.empty?
+                        in_state = wfun[:in_state_e].call(sstr1, sstr2, content)
+
+                        break if in_state
+                    end
+
+                    c_timeout *= 10
+                    c_timeout  = timeout if c_timeout > timeout
+
+                    rco = info
+
+                    return false if OpenNebula.is_error?(rco)
+
+                    in_state = wfun[:in_state].call(self, sstr1, sstr2)
+
+                    recvs += 1
+                end
+
+                in_state
+            end
+
+        end
+
+        super
+    end
+
+    # Check if object has the method wait or not
+    #
+    # @param obj [Object or Class] Object to check class
+    def self.wait?(obj)
+        # Get obj class to find parents in wait class
+        # rubocop:disable Style/TernaryParentheses
+        (obj.is_a? Class) ? o_class = obj : o_class = obj.class
+        # rubocop:enable Style/TernaryParentheses
+
+        found   = false
+        i_class = o_class
+
+        while i_class
+            if WAIT.keys.include?(i_class)
+                found = true
+                break
+            end
+
+            i_class = i_class.superclass
+        end
+
+        return if found
+
+        raise StandardError, "Cannot extend #{o_class} with WaitExt"
+    end
+
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/lib/opennebula/x509_auth.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+# 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    #

data/lib/opennebula/xml_element.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+# 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    #

data/lib/opennebula/xml_pool.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+# 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    #

data/lib/opennebula/xml_utils.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+# 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    #

data/lib/opennebula/zone.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+# 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    #

data/lib/opennebula/zone_pool.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+# 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    #

data/lib/opennebula.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
+# 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    #
@@ -49,7 +49,9 @@ require 'opennebula/datastore_pool'
 require 'opennebula/cluster'
 require 'opennebula/cluster_pool'
 require 'opennebula/document'
+require 'opennebula/document_json'
 require 'opennebula/document_pool'
+require 'opennebula/document_pool_json'
 require 'opennebula/zone'
 require 'opennebula/zone_pool'
 require 'opennebula/security_group'
@@ -70,9 +72,10 @@ require 'opennebula/vntemplate_pool'
 require 'opennebula/hook'
 require 'opennebula/hook_pool'
 require 'opennebula/hook_log'
+require 'opennebula/flow'
 
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '5.12.10'
+    VERSION = '5.13.80'
 end

data/lib/rest_client.rb

@@ -0,0 +1,201 @@
+# -------------------------------------------------------------------------- #
+# 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'
+require 'vsphere-automation-vcenter'
+require 'vsphere-automation-cis'
+
+module VCenterDriver
+
+    ########################################################################
+    # Class RESTClient
+    ########################################################################
+    class RESTClient
+
+        attr_accessor :configuration
+
+        def initialize(opts)
+            @opts = {
+                :insecure => true,
+                :associable_types => [
+                    ClusterComputeResource,
+                    DistributedVirtualSwitch,
+                    VmwareDistributedVirtualSwitch,
+                    LibraryItem,
+                    ResourcePool,
+                    Folder,
+                    HostNetwork,
+                    DistributedVirtualPortgroup,
+                    VirtualApp,
+                    StoragePod,
+                    Datastore,
+                    Network,
+                    Datacenter,
+                    Library,
+                    HostSystem,
+                    OpaqueNetwork,
+                    VirtualMachine
+                ],
+                :category_name => 'OpenNebula',
+                :category_description => 'OpenNebula Category',
+            :cardinality =>
+                VSphereAutomation::CIS::CisTaggingCategoryModelCardinality
+                    .const_get(
+                        'multiple'.upcase
+                    )
+            }.merge(opts)
+
+            @configuration = VSphereAutomation::Configuration.new.tap do |c|
+                c.host = @opts[:hostname]
+                c.username = @opts[:username]
+                c.password = @opts[:password]
+                c.scheme = 'https'
+                c.verify_ssl = !@opts[:insecure]
+                c.verify_ssl_host = !@opts[:insecure]
+            end
+        end
+
+        def self.new_from_host(host_id)
+            begin
+                client = OpenNebula::Client.new
+                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 = {
+                    :hostname => host['TEMPLATE/VCENTER_HOST'],
+                    :username => host['TEMPLATE/VCENTER_USER'],
+                    :password => host['TEMPLATE/VCENTER_PASSWORD']
+                }
+
+                new(connection)
+            rescue StandardError => e
+                raise e
+            end
+        end
+
+        def get_or_create_tag(
+            api_client,
+            category_id,
+            tag_name,
+            tag_description
+        )
+
+            tag_api = VSphereAutomation::CIS::TaggingTagApi.new(api_client)
+            tag = tag_api.list.value.find do |id|
+                c = tag_api.get(id).value
+                break c if c.name == tag_name
+            end
+
+            if tag.nil?
+                create_spec =
+                    VSphereAutomation::CIS::CisTaggingTagCreateSpec
+                    .new(
+                        name => tag_name,
+                        description => tag_description,
+                        category_id => category_id
+                    )
+                create_model = VSphereAutomation::CIS::CisTaggingTagCreate.new(
+                    create_spec => create_spec
+                )
+
+                api_instance =
+                    VSphereAutomation::CIS::TaggingTagApi.new(api_client)
+                api_instance.create(create_model).value
+            else
+                tag.id
+            end
+        end
+
+        def get_or_create_category(api_client, category_name)
+            category_api =
+                VSphereAutomation::CIS::TaggingCategoryApi.new(api_client)
+            category = category_api.list.value.find do |id|
+                c = category_api.get(id).value
+                break c if c.name == category_name
+            end
+            if category.nil?
+                create_spec =
+                    VSphereAutomation::CIS::CisTaggingCategoryCreateSpec
+                    .new(
+                        name => category_name,
+                        description => @opts[:category_description],
+                        associable_types => @opts[:associable_types],
+                        cardinality => @opts[:cardinality]
+                    )
+                create_model =
+                    VSphereAutomation::CIS::CisTaggingCategoryCreate
+                    .new(create_spec => create_spec)
+
+                category = category_api.create(create_model)
+                category.value
+            else
+                category.id
+            end
+        end
+
+        def sync_tags(vm)
+            api_client = VSphereAutomation::ApiClient.new(@configuration)
+            VSphereAutomation::CIS::SessionApi.new(api_client).create('')
+
+            association_api =
+                VSphereAutomation::CIS::TaggingTagAssociationApi
+                .new(api_client)
+
+            vm.vcenter_tags.each do |tag|
+                category_name = @opts[:category_name]
+
+                unless tag['CATEGORY_NAME'].nil?
+                    category_name = tag['CATEGORY_NAME']
+                end
+
+                category_id = get_or_create_category(api_client, category_name)
+
+                tag_name = tag['NAME']
+                tag_description = tag['DESCRIPTION']
+
+                tag_id =
+                    get_or_create_tag(
+                        api_client,
+                        category_id,
+                        tag_name,
+                        tag_description
+                    )
+
+                request_body =
+                    VSphereAutomation::CIS::CisTaggingTagAssociationAttach.new
+
+                object_id = VSphereAutomation::CIS::VapiStdDynamicID.new
+                object_id.id = vm['_ref']
+                object_id.type = 'VirtualMachine'
+
+                request_body.object_id = object_id
+
+                begin
+                    association_api.attach(tag_id, request_body)
+                rescue VSphereAutomation::ApiError => e
+                    puts "Exception when calling \
+                         TaggingTagAssociationApi->attach: #{e}"
+                end
+            end
+        end
+
+    end
+
+end

data/lib/scripts_common.rb

@@ -0,0 +1,180 @@
+# -------------------------------------------------------------------------- #
+# 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 OpenNebula
+
+    # Generic log function
+    def self.log_function(severity, message)
+        STDERR.puts "#{severity}: #{File.basename $0}: #{message}"
+    end
+
+    # Logs an info message
+    def self.log_info(message)
+        log_function("INFO", message)
+    end
+
+    # Logs an error message
+    def self.log_error(message)
+        log_function("ERROR", message)
+    end
+
+    # Logs a debug message
+    def self.log_debug(message)
+        log_function("DEBUG", message)
+    end
+
+    # Alias log to log_info in the singleton class
+    class << self
+        alias :log :log_info
+    end
+
+    # This function is used to pass error message to the mad
+    def self.error_message(message)
+        STDERR.puts format_error_message(message)
+    end
+
+    #This function formats an error message for OpenNebula
+    def self.format_error_message(message)
+        error_str = "ERROR MESSAGE --8<------\n"
+        error_str << message
+        error_str << "\nERROR MESSAGE ------>8--"
+
+        return error_str
+    end
+
+    def self.is_disk?(arg)
+        arg.match("disk\.[0-9]+$")
+    end
+
+    # Gets the host from an argument
+    def self.arg_host(arg)
+        result = arg.match("^\([^:]*\):.*$")
+
+        return result[1] if result
+    end
+
+    def self.arg_path(arg)
+        result = arg.match('^[^:]*:(.*)$')
+
+        return result[1] if result
+    end
+
+    # Executes a command, if it fails returns error message and exits
+    # If a second parameter is present it is used as the error message when
+    # the command fails
+    def self.exec_and_log(command, message=nil, allowed_return_code=0)
+        output=`#{command} 2>&1 1>/dev/null`
+        code=$?.exitstatus
+
+        if code!=0 && code!=allowed_return_code
+            log_error "Command \"#{command}\" failed."
+            log_error output
+            if !message
+                error_message output
+            else
+                error_message message
+            end
+            exit code
+        end
+        log "Executed \"#{command}\"."
+    end
+
+    def self.send_to_monitor(msg_type, result, oid, data)
+        # Read monitord.conf
+        one_location = ENV['ONE_LOCATION']
+
+        if !one_location
+            file_dir = '/etc/one/'
+        else
+            file_dir = one_location + '/etc/'
+        end
+
+        file_name = 'monitord.conf'
+
+        begin
+            # Suppress augeas require warning message
+            $VERBOSE = nil
+
+            require 'augeas'
+
+            aug = Augeas.create(:no_modl_autoload => true,
+                :no_load          => true,
+                :root             => file_dir,
+                :loadpath         => file_name)
+
+            aug.clear_transforms
+            aug.transform(:lens => 'Oned.lns', :incl => file_name)
+            aug.context = "/files/#{file_name}"
+            aug.load
+
+            mon_address = aug.get('NETWORK/MONITOR_ADDRESS')
+            mon_port    = aug.get('NETWORK/PORT')
+            mon_key     = aug.get('NETWORK/PUBKEY').tr('"', '')
+
+            mon_address = "127.0.0.1" if mon_address.include? "auto"
+        rescue LoadError
+            mon_address = "127.0.0.1"
+            mon_port    = 4124
+        end
+
+        # Encrypt
+        if mon_key && !mon_key.empty?
+            block_size = mon_key.n.num_bytes - 11
+
+            edata = ''
+            index = 0
+
+            loop do
+                break if index >= data.length
+
+                edata << mon_key.public_encrypt(data[index, block_size])
+
+                index += block_size
+            end
+
+            data = edata
+        end
+
+        # Send data
+        begin
+            require 'base64'
+            require 'zlib'
+            require 'socket'
+
+            zdata  = Zlib::Deflate.deflate(data, Zlib::BEST_COMPRESSION)
+            data64 = Base64.strict_encode64(zdata)
+
+            if (result == "SUCCESS" || result == "0")
+                result = "SUCCESS"
+            else
+                result = "FAILURE"
+            end
+
+            if Integer(oid) == -1
+                ts = 0
+            else
+                ts = Time.now.to_i
+            end
+
+            msg = "#{msg_type} #{result} #{oid} #{ts} #{data64}"
+
+            socket_udp = UDPSocket.new()
+            socket_udp.send(msg, 0, mon_address, mon_port)
+        rescue LoadError
+            STDERR.puts('Unable to send data to Monitor Daemon')
+        end
+    end
+end