opennebula 6.6.3 → 6.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 885bbb7b22fbe7f2652e00b846dbf5881960a9cd041282d789a669d671a5835f
-  data.tar.gz: e7575d6535512ae13e139249ecfb05cac655cd34013176184bf98ce6fc5215dd
+  metadata.gz: eedefbb85b95ea6fab4348f1a05bb71ef05532659c49a388cecf0ba3662afb75
+  data.tar.gz: 10a3856b4e5794727d67687446ef420c8b0eb05b9f15ada412467d8e3da8b15a
 SHA512:
-  metadata.gz: 138d7785b0d1c4dc84df1a862f6a14de05a4156ee44b1bff15752dcb99daab62e9590a776d4bc3d5dcd8c45924c574b0b1a8da1aa16e37626609780811b2e47a
-  data.tar.gz: b3ff5aa1bf6ef4ed40f37e77beb6a8e4e11aaa7bbeed6c5643c316cb95f795d0c4792b026478c92298d8e00b584955a9c2970f14eb03257c8316ef9bb886d198
+  metadata.gz: ce540f42a07049fd4088692b31b3651dce29db28cee3bd199a3c67f17998aad1677a8aceb4d29a75deb93e9c5d7d985b9246cc7fa6c55721f9e3411e5779dd85
+  data.tar.gz: c751b6ad361a43f7d87ef93734f881715b95c1b2c8c385b565c10ae7ce62b8d3d69db42d4ed2365cb4449d1ed1e2ea8a1958a38ab5705e4c755a6ef135e7249c

data/lib/cloud/CloudClient.rb

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

data/lib/opennebula/acl.rb

@@ -73,7 +73,8 @@ module OpenNebula
             "MARKETPLACE"   =>  0x8000000000000,
             "MARKETPLACEAPP"=> 0x10000000000000,
             "VMGROUP"       => 0x20000000000000,
-            "VNTEMPLATE"    => 0x40000000000000
+            "VNTEMPLATE"    => 0x40000000000000,
+            "BACKUPJOB"     =>0x100000000000000
         }
 
         RIGHTS =

data/lib/opennebula/backupjob.rb

@@ -0,0 +1,250 @@
+# -------------------------------------------------------------------------- #
+# 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.                                             #
+#--------------------------------------------------------------------------- #
+
+require 'opennebula/lockable_ext'
+require 'opennebula/pool_element'
+
+module OpenNebula
+
+    # Class for representing a Backup Job object
+    class BackupJob < PoolElement
+
+        #######################################################################
+        # Constants and Class Methods
+        #######################################################################
+
+        BACKUPJOB_METHODS = {
+            :allocate    => 'backupjob.allocate',
+            :info        => 'backupjob.info',
+            :update      => 'backupjob.update',
+            :delete      => 'backupjob.delete',
+            :chown       => 'backupjob.chown',
+            :chmod       => 'backupjob.chmod',
+            :clone       => 'backupjob.clone',
+            :rename      => 'backupjob.rename',
+            :lock        => 'backupjob.lock',
+            :unlock      => 'backupjob.unlock',
+            :backup      => 'backupjob.backup',
+            :cancel      => 'backupjob.cancel',
+            :retry       => 'backupjob.retry',
+            :priority    => 'backupjob.priority',
+            :schedadd    => 'backupjob.schedadd',
+            :scheddelete => 'backupjob.scheddelete',
+            :schedupdate => 'backupjob.schedupdate'
+        }
+
+        # Creates a BackupJob description with just its identifier
+        # this method should be used to create plain BackupJob objects.
+        # +id+ the id of the user
+        #
+        # Example:
+        #   bj = BackupJob.new(BackupJob.build_xml(3),rpc_client)
+        #
+        def self.build_xml(pe_id = nil)
+            if pe_id
+                obj_xml = "<BACKUPJOB><ID>#{pe_id}</ID></BACKUPJOB>"
+            else
+                obj_xml = '<BACKUPJOB></BACKUPJOB>'
+            end
+
+            XMLElement.build_xml(obj_xml, 'BACKUPJOB')
+        end
+
+        # Class constructor
+        def initialize(xml, client)
+            LockableExt.make_lockable(self, BACKUPJOB_METHODS)
+
+            super(xml, client)
+
+            @client = client
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Backup Job Object
+        #######################################################################
+
+        # Retrieves the information of the given Backup Job.
+        def info
+            return Error.new('ID not defined') unless @pe_id
+
+            rc = @client.call(BACKUPJOB_METHODS[:info], @pe_id)
+
+            if !OpenNebula.is_error?(rc)
+                initialize_xml(rc, 'BACKUPJOB')
+                rc = nil
+
+                @pe_id = self['ID'].to_i if self['ID']
+                @name  = self['NAME'] if self['NAME']
+            end
+
+            rc
+        end
+
+        alias info! info
+
+        # Allocates a new Backup Job in OpenNebula
+        #
+        # @param description [String] The contents of the BackupJob.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def allocate(description)
+            super(BACKUPJOB_METHODS[:allocate], description)
+        end
+
+        # Deletes the BackupJob
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def delete
+            call(BACKUPJOB_METHODS[:delete], @pe_id)
+        end
+
+        # Replaces the Backup Job contents
+        #
+        # @param new_template [String] New template contents
+        # @param append [true, false] True to append new attributes instead of
+        #   replace the whole template
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def update(new_template, append = false)
+            super(BACKUPJOB_METHODS[:update], new_template, append ? 1 : 0)
+        end
+
+        # Changes the owner/group
+        # uid:: _Integer_ the new owner id. Set to -1 to leave the current one
+        # gid:: _Integer_ the new group id. Set to -1 to leave the current one
+        # [return] nil in case of success or an Error object
+        def chown(uid, gid)
+            super(BACKUPJOB_METHODS[:chown], uid, gid)
+        end
+
+        # Changes the Backup Job permissions.
+        #
+        # @param octet [String] Permissions octed , e.g. 640
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def chmod_octet(octet)
+            super(BACKUPJOB_METHODS[:chmod], octet)
+        end
+
+        # Changes the Backup Job permissions.
+        # Each [Integer] argument must be 1 to allow, 0 deny, -1 do not change
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        # rubocop:disable Metrics/ParameterLists
+        def chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
+                  other_m, other_a)
+            call(BACKUPJOB_METHODS[:chmod], @pe_id, owner_u, owner_m, owner_a, group_u,
+                 group_m, group_a, other_u, other_m, other_a)
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        # Renames this Backup Job
+        #
+        # @param name [String] New name for the Backup Job.
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def rename(name)
+            call(BACKUPJOB_METHODS[:rename], @pe_id, name)
+        end
+
+        # Starts the Backup Job
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def backup
+            call(BACKUPJOB_METHODS[:backup], @pe_id)
+        end
+
+        # Cancel pending Backup Job, removing VMs from waiting list
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def cancel
+            call(BACKUPJOB_METHODS[:cancel], @pe_id)
+        end
+
+        # Retry backup for VMs in error list
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def retry
+            call(BACKUPJOB_METHODS[:retry], @pe_id)
+        end
+
+        # Change priority of Backup Job
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def priority(pr)
+            call(BACKUPJOB_METHODS[:priority], @pe_id, pr)
+        end
+
+        # Add Scheduled action
+        #
+        # @param sched_template [String] Template with SCHED_ACTIONs
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def sched_action_add(sched_template)
+            call(BACKUPJOB_METHODS[:schedadd], @pe_id, sched_template)
+        end
+
+        # Delete Scheduled Action
+        #
+        # @param sched_id [Int] id of the SCHED_ACTION
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def sched_action_delete(sched_id)
+            call(BACKUPJOB_METHODS[:scheddelete], @pe_id, sched_id.to_i)
+        end
+
+        # Update Scheduled Action
+        #
+        # @param sched_id [Int] id of the SCHED_ACTION
+        # @param sched_template [String] Template containing a SCHED_ACTION
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def sched_action_update(sched_id, sched_template)
+            call(BACKUPJOB_METHODS[:schedupdate], @pe_id,
+                 sched_id.to_i, sched_template)
+        end
+
+        #######################################################################
+        # Helpers to get Template information
+        #######################################################################
+
+        # Returns the group identifier
+        # [return] _Integer_ the element's group ID
+        def gid
+            self['GID'].to_i
+        end
+
+        def owner_id
+            self['UID'].to_i
+        end
+
+        def public?
+            self['PERMISSIONS/GROUP_U'] == '1' || self['PERMISSIONS/OTHER_U'] == '1'
+        end
+
+    end
+
+end

data/lib/opennebula/backupjob_pool.rb

@@ -0,0 +1,82 @@
+# -------------------------------------------------------------------------- #
+# 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.                                             #
+#--------------------------------------------------------------------------- #
+
+require 'opennebula/pool'
+
+module OpenNebula
+
+    # Class representing a Backup Job pool
+    class BackupJobPool < Pool
+
+        #######################################################################
+        # Constants and Class attribute accessors
+        #######################################################################
+
+        BACKUPJOB_POOL_METHODS = {
+            :info => 'backupjobpool.info'
+        }
+
+        #######################################################################
+        # Class constructor & Pool Methods
+        #######################################################################
+
+        # +client+ a Client object that represents an XML-RPC connection
+        # +user_id+ used to refer to a Pool with Templates from that user
+        def initialize(client, user_id = -1)
+            super('BACKUPJOB_POOL', 'BACKUPJOB', client)
+
+            @user_id = user_id
+        end
+
+        # Factory method to create Backup Job objects
+        def factory(element_xml)
+            OpenNebula::BackupJob.new(element_xml, @client)
+        end
+
+        #######################################################################
+        # XML-RPC Methods for the Template Object
+        #######################################################################
+
+        # Retrieves all or part of the Templates in the pool.
+        def info(*args)
+            case args.size
+            when 0
+                info_filter(BACKUPJOB_POOL_METHODS[:info], @user_id, -1, -1)
+            when 3
+                info_filter(BACKUPJOB_POOL_METHODS[:info], args[0], args[1], args[2])
+            end
+        end
+
+        def info_all
+            super(BACKUPJOB_POOL_METHODS[:info])
+        end
+
+        def info_mine
+            super(BACKUPJOB_POOL_METHODS[:info])
+        end
+
+        def info_group
+            super(BACKUPJOB_POOL_METHODS[:info])
+        end
+
+        alias info! info
+        alias info_all! info_all
+        alias info_mine! info_mine
+        alias info_group! info_group
+
+    end
+
+end

data/lib/opennebula/client.rb

@@ -140,9 +140,9 @@ module OpenNebula
                 @one_endpoint = endpoint
             elsif ENV["ONE_XMLRPC"]
                 @one_endpoint = ENV["ONE_XMLRPC"]
-            elsif ENV['HOME'] and File.exists?(ENV['HOME']+"/.one/one_endpoint")
+            elsif ENV['HOME'] and File.exist?(ENV['HOME']+"/.one/one_endpoint")
                 @one_endpoint = File.read(ENV['HOME']+"/.one/one_endpoint")
-            elsif File.exists?("/var/lib/one/.one/one_endpoint")
+            elsif File.exist?("/var/lib/one/.one/one_endpoint")
                 @one_endpoint = File.read("/var/lib/one/.one/one_endpoint")
             else
                 @one_endpoint = "http://localhost:2633/RPC2"

data/lib/opennebula/group.rb

@@ -37,7 +37,7 @@ module OpenNebula
         SELF = -1
 
         # Default resource ACL's for group users (create)
-        GROUP_DEFAULT_ACLS = "VM+IMAGE+TEMPLATE+DOCUMENT+SECGROUP+VROUTER+VMGROUP"
+        GROUP_DEFAULT_ACLS = "VM+IMAGE+TEMPLATE+DOCUMENT+SECGROUP+VROUTER+VMGROUP+BACKUPJOB"
 
         # The default view for group and group admins, must be defined in
         # sunstone_views.yaml

data/lib/opennebula/ldap_auth.rb

@@ -89,7 +89,7 @@ class OpenNebula::LdapAuth
         file=@options[:mapping_file_path]
         generate = false
 
-        if File.exists?(file)
+        if File.exist?(file)
             stat = File.stat(file)
             age = Time.now.to_i - stat.mtime.to_i
             generate = true if age > @options[:mapping_timeout]
@@ -124,7 +124,7 @@ class OpenNebula::LdapAuth
 
         @mapping = {}
 
-        if File.exists?(file)
+        if File.exist?(file)
             @mapping = YAML.load(File.read(file))
         end
 

data/lib/opennebula/lockable_ext.rb

@@ -125,6 +125,7 @@ module OpenNebula::LockableExt
     def self.lockable?(obj)
         # Lockable classes
         lockable = [
+            OpenNebula::BackupJob,
             OpenNebula::Document,
             OpenNebula::Hook,
             OpenNebula::Image,

data/lib/opennebula/oneflow_client.rb

@@ -21,6 +21,7 @@ require 'cloud/CloudClient'
 include CloudCLI
 
 module Role
+
     # Actions that can be performed on the VMs of a given Role
     SCHEDULE_ACTIONS = [
         'terminate',
@@ -78,8 +79,9 @@ module Role
     # @param [String] state String number representing the state
     # @return the state string
     def self.state_str(state_number)
-        return STATE_STR[state_number.to_i]
+        STATE_STR[state_number.to_i]
     end
+
 end
 
 module Service
@@ -126,19 +128,19 @@ module Service
     # @param [String] state String number representing the state
     # @return the state string
     def self.state_str(state_number)
-        return STATE_STR[state_number.to_i]
+        STATE_STR[state_number.to_i]
     end
 
     # Build a json specifying an action
     # @param [String] perform action to be performed (e.g.: shutdown)
     # @param [Hash, nil] params contains the params for the action
     # @return [String] json representing the action
-    def self.build_json_action(perform, params=nil)
-        body = Hash.new
+    def self.build_json_action(perform, params = nil)
+        body = {}
         body['perform'] = perform
         body['params']  = params if params
 
-        action = Hash.new
+        action = {}
         action['action'] = body
 
         JSON.pretty_generate action
@@ -148,83 +150,83 @@ module Service
 
     DEFAULT_OPTIONS = [
         ENDPOINT = {
-            :name => "server",
-            :short => "-s url",
-            :large => "--server url",
+            :name => 'server',
+            :short => '-s url',
+            :large => '--server url',
             :format => String,
-            :description => "Service endpoint"
+            :description => 'Service endpoint'
         },
         USERNAME={
-            :name => "username",
-            :short => "-u name",
-            :large => "--username name",
+            :name => 'username',
+            :short => '-u name',
+            :large => '--username name',
             :format => String,
-            :description => "User name"
+            :description => 'User name'
         },
         PASSWORD={
-            :name => "password",
-            :short => "-p pass",
-            :large => "--password pass",
+            :name => 'password',
+            :short => '-p pass',
+            :large => '--password pass',
             :format => String,
-            :description => "User password"
+            :description => 'User password'
         }
     ]
 
     JSON_FORMAT = {
-        :name => "json",
-        :short => "-j",
-        :large => "--json",
-        :description => "Print the resource in JSON"
+        :name => 'json',
+        :short => '-j',
+        :large => '--json',
+        :description => 'Print the resource in JSON'
     }
 
     TOP = {
-        :name => "top",
-        :short => "-t",
-        :large => "--top",
-        :description => "Top for the command"
+        :name => 'top',
+        :short => '-t',
+        :large => '--top',
+        :description => 'Top for the command'
     }
 
     PERIOD = {
-        :name => "period",
-        :short => "-p x",
-        :large => "--period x",
+        :name => 'period',
+        :short => '-p x',
+        :large => '--period x',
         :format => Integer,
-        :description => "Seconds between each group of actions"
+        :description => 'Seconds between each group of actions'
     }
 
     NUMBER = {
-        :name => "number",
-        :short => "-n x",
-        :large => "--number x",
+        :name => 'number',
+        :short => '-n x',
+        :large => '--number x',
         :format => Integer,
-        :description => "Number of VMs to apply the action to each period"
+        :description => 'Number of VMs to apply the action to each period'
     }
 
     FORCE = {
-        :name => "force",
-        :short => "-f",
-        :large => "--force",
-        :description => "Force the new cardinality even if it is outside the limits"
+        :name => 'force',
+        :short => '-f',
+        :large => '--force',
+        :description => 'Force the new cardinality even if it is outside the limits'
     }
 
     # Format helpers
 
-#    def self.rname_to_id(name, poolname, options)
+    #    def self.rname_to_id(name, poolname, options)
     def self.rname_to_id(name, poolname)
         return 0, name.to_i if name.match(/^[0123456789]+$/)
 
-        client = Service::Client.new()
+        client = Service::Client.new
 
         resource_path = case poolname
-        when "SERVICE"          then "/service"
-        when "SERVICE TEMPLATE" then "/service_template"
-        end
+                        when 'SERVICE'          then '/service'
+                        when 'SERVICE TEMPLATE' then '/service_template'
+                        end
 
         response = client.get(resource_path)
 
-        if CloudClient::is_error?(response)
+        if CloudClient.is_error?(response)
             return -1, "OpenNebula #{poolname} name not found," <<
-                       " use the ID instead"
+                       ' use the ID instead'
         end
 
         pool = JSON.parse(response.body)
@@ -242,38 +244,32 @@ module Service
 
         objects = pool['DOCUMENT_POOL']['DOCUMENT'].select {|object| object['NAME'] == name }
 
-        if objects.length>0
-            if objects.length>1
-                return -1, "There are multiple #{ename}s with name #{name}."
-            else
-                result = objects.first['ID']
-            end
-        else
-            return -1, "#{ename} named #{name} not found."
-        end
+        return -1, "#{ename} named #{name} not found." unless objects.length>0
+        return -1, "There are multiple #{ename}s with name #{name}." if objects.length>1
+
+        result = objects.first['ID']
 
-        return 0, result
+        [0, result]
     end
 
     def self.list_to_id(names, poolname)
-
-        client = Service::Client.new()
+        client = Service::Client.new
 
         resource_path = case poolname
-        when "SERVICE"          then "/service"
-        when "SERVICE TEMPLATE" then "/service_template"
-        end
+                        when 'SERVICE'          then '/service'
+                        when 'SERVICE TEMPLATE' then '/service_template'
+                        end
 
         response = client.get(resource_path)
 
-        if CloudClient::is_error?(response)
+        if CloudClient.is_error?(response)
             return -1, "OpenNebula #{poolname} name not found," <<
-                       " use the ID instead"
+                       ' use the ID instead'
         end
 
         pool = JSON.parse(response.body)
 
-        result = names.split(',').collect { |name|
+        result = names.split(',').collect do |name|
             if name.match(/^[0123456789]+$/)
                 name.to_i
             else
@@ -285,9 +281,9 @@ module Service
 
                 rc[1]
             end
-        }
+        end
 
-        return 0, result
+        [0, result]
     end
 
     def self.list_to_id_desc(poolname)
@@ -304,8 +300,8 @@ module Service
         ids.each do |id|
             response = block.call(id) if block_given?
 
-            if CloudClient::is_error?(response)
-                puts response.to_s
+            if CloudClient.is_error?(response)
+                puts response
                 exit_code = response.code.to_i
             end
         end
@@ -321,16 +317,29 @@ module Service
         exit_code = 0
         response  = block.call(id) if block_given?
 
-        if CloudClient::is_error?(response)
-            puts response.to_s
+        if CloudClient.is_error?(response)
+            puts response
             exit_code = response.code.to_i
         end
 
         exit_code
     end
 
+    #
+    # Interface to OneFlow REST API through a Ruby client
+    #
     class Client
-        def initialize(opts={})
+
+        #
+        # The options are read from ENV and FS if not passed
+        #
+        # @param [Hash] opts Required configuration to interact with OneFlow
+        # @option opts [String] :url Endpoint where OneFlow is running. Defaults to 'http://localhost:2474'
+        # @option opts [String] :username OpenNebula user
+        # @option opts [String] :password OpenNebula user password
+        # @option opts [String] :user_agent Defaults to Ruby. Oneflow will behave accordingly.
+        #
+        def initialize(opts = {})
             endpoint  = '/.one/oneflow_endpoint'
             @username = opts[:username] || ENV['ONEFLOW_USER']
             @password = opts[:password] || ENV['ONEFLOW_PASSWORD']
@@ -339,23 +348,23 @@ module Service
                 url = opts[:url]
             elsif ENV['ONEFLOW_URL']
                 url = ENV['ONEFLOW_URL']
-            elsif ENV['HOME'] && File.exists?(ENV['HOME'] + endpoint)
+            elsif ENV['HOME'] && File.exist?(ENV['HOME'] + endpoint)
                 url = File.read(ENV['HOME'] + endpoint).strip
-            elsif File.exists?('/var/lib/one/.one/oneflow_endpoint')
+            elsif File.exist?('/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"])
-                    one_auth = File.read(ENV["ONE_AUTH"])
-                elsif ENV["HOME"] and File.file?(ENV["HOME"]+"/.one/one_auth")
-                    one_auth = File.read(ENV["HOME"]+"/.one/one_auth")
-                elsif File.file?("/var/lib/one/.one/one_auth")
-                    one_auth = File.read("/var/lib/one/.one/one_auth")
+                if ENV['ONE_AUTH'] and !ENV['ONE_AUTH'].empty? and File.file?(ENV['ONE_AUTH'])
+                    one_auth = File.read(ENV['ONE_AUTH'])
+                elsif ENV['HOME'] and File.file?(ENV['HOME']+'/.one/one_auth')
+                    one_auth = File.read(ENV['HOME']+'/.one/one_auth')
+                elsif File.file?('/var/lib/one/.one/one_auth')
+                    one_auth = File.read('/var/lib/one/.one/one_auth')
                 else
-                    raise "ONE_AUTH file not present"
+                    raise 'ONE_AUTH file not present'
                 end
 
                 one_auth = one_auth.rstrip
@@ -366,37 +375,37 @@ module Service
             @uri = URI.parse(url)
 
             @user_agent = "OpenNebula #{CloudClient::VERSION} " <<
-                "(#{opts[:user_agent]||"Ruby"})"
+                "(#{opts[:user_agent]||'Ruby'})"
 
             @host = nil
             @port = nil
 
-            if ENV['http_proxy']
-                uri_proxy  = URI.parse(ENV['http_proxy'])
-                flag = false
-
-                # Check if we need to bypass the proxy
-                if ENV['no_proxy']
-                    ENV['no_proxy'].split(',').each do |item|
-                        item = item.rstrip.lstrip
-
-                        unless (IPAddress @uri.host rescue nil).nil?
-                            unless (IPAddress item rescue nil).nil?
-                                flag |= IPAddress(item).include? IPAddress(@uri.host)
-                            end
-                        else
-                            if (IPAddress(item) rescue nil).nil?
-                                flag |= (item == @uri.host)
-                            end
+            return unless ENV['http_proxy']
+
+            uri_proxy = URI.parse(ENV['http_proxy'])
+            flag = false
+
+            #  Check if we need to bypass the proxy
+            if ENV['no_proxy']
+                ENV['no_proxy'].split(',').each do |item|
+                    item = item.strip
+
+                    if (IPAddress @uri.host rescue nil).nil?
+                        if (IPAddress(item) rescue nil).nil?
+                            flag |= (item == @uri.host)
+                        end
+                    else
+                        unless (IPAddress item rescue nil).nil?
+                            flag |= IPAddress(item).include? IPAddress(@uri.host)
                         end
                     end
                 end
-
-                unless flag
-                    @host = uri_proxy.host
-                    @port = uri_proxy.port
-                end
             end
+
+            return if flag
+
+            @host = uri_proxy.host
+            @port = uri_proxy.port
         end
 
         def set_content_type(content_type)
@@ -420,10 +429,8 @@ module Service
             req = Net::HTTP::Proxy(@host, @port)::Post.new(path)
             req.body = body
 
-            if path.start_with?('/service_template')
-                unless @content_type.nil?
-                    req.content_type = @content_type
-                end
+            if path.start_with?('/service_template') && !@content_type.nil?
+                req.content_type = @content_type
             end
             do_request(req)
         end
@@ -454,11 +461,11 @@ module Service
 
             req['User-Agent'] = @user_agent
 
-            res = CloudClient::http_start(@uri, @timeout) do |http|
+            CloudClient.http_start(@uri, @timeout) do |http|
                 http.request(req)
             end
-
-            res
         end
+
     end
+
 end

data/lib/opennebula/ssh_auth.rb

@@ -14,104 +14,127 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
-
-require 'pp'
 require 'openssl'
 require 'base64'
 require 'fileutils'
+require 'open3'
+require 'tempfile'
+
+module OpenNebula
+
+    # SSH key authentication class. It can be used as a driver for auth_mad
+    # as auth method is defined. It also holds some helper methods to be used
+    # by oneauth command
+    class SshAuth
+
+        # Initialize SshAuth object
+        #
+        # @param [Hash] default options for path
+        # @option options [String] :public_key public key for the user
+        # @option options [String] :private_key key private key for the user.
+        def initialize(options = {})
+            @private_key = nil
+            @public_key  = nil
+
+            # Initialize the private key
+            if options[:private_key]
+                begin
+                    @private_key = File.read(options[:private_key])
+                rescue StandardError => e
+                    raise "Cannot read #{options[:private_key]}\n #{e}"
+                end
 
-module OpenNebula; end
-
-# SSH key authentication class. It can be used as a driver for auth_mad
-# as auth method is defined. It also holds some helper methods to be used
-# by oneauth command
-class OpenNebula::SshAuth
-    # Initialize SshAuth object
-    #
-    # @param [Hash] default options for path
-    # @option options [String] :public_key public key for the user
-    # @option options [String] :private_key key private key for the user.
-    def initialize(options={})
-        @private_key = nil
-        @public_key  = nil
-
-        # Initialize the private key
-        if options[:private_key]
-            begin
-                @private_key = File.read(options[:private_key])
-            rescue Exception => e
-                raise "Cannot read #{options[:private_key]}"
+                begin
+                    @private_key_rsa = OpenSSL::PKey::RSA.new(@private_key)
+                rescue OpenSSL::PKey::RSAError
+                    private_key_pem = openssh_to_pem(@private_key)
+                    @private_key_rsa = OpenSSL::PKey::RSA.new(private_key_pem)
+                end
+            end
+
+            # Initialize the public key
+            if options[:public_key]
+                @public_key = options[:public_key]
+            elsif !@private_key.nil?
+                # Init ssh keys using private key. public key is extracted in a
+                # format compatible with openssl. The public key does not contain
+                # "---- BEGIN/END PUBLIC KEY ----" and is in a single line
+                @public_key = @private_key_rsa.public_key.to_pem.split("\n")
+                @public_key = @public_key.reject {|l| l.match(/PUBLIC KEY/) }.join('')
+            end
+
+            if @private_key.nil? && @public_key.nil?
+                raise 'You have to define at least one of the keys'
             end
 
-            @private_key_rsa = OpenSSL::PKey::RSA.new(@private_key)
+            @public_key_rsa = OpenSSL::PKey::RSA.new(Base64.decode64(@public_key))
         end
 
-        # Initialize the public key
-        if options[:public_key]
-            @public_key = options[:public_key]
-        elsif @private_key != nil
-            # Init ssh keys using private key. public key is extracted in a
-            # format compatible with openssl. The public key does not contain
-            # "---- BEGIN/END PUBLIC KEY ----" and is in a single line
-            @public_key = @private_key_rsa.public_key.to_pem.split("\n")
-            @public_key = @public_key.reject {|l| l.match(/PUBLIC KEY/) }.join('')
+        # Creates a login token for ssh authentication.
+        # By default it is valid for 1 hour but it can be changed to any number
+        # of seconds with expire parameter (in seconds)
+        def login_token(user, expire = 3600)
+            expire ||= 3600
+
+            return encrypt("#{user}:#{Time.now.to_i + expire.to_i}")
         end
 
-        if @private_key.nil? && @public_key.nil?
-            raise "You have to define at least one of the keys"
+        # Returns a valid password string to create a user using this auth driver.
+        # In this case the ssh public key.
+        def password
+            @public_key
         end
 
-        @public_key_rsa = OpenSSL::PKey::RSA.new(Base64::decode64(@public_key))
-    end
+        # Checks the proxy created with the login method
+        def authenticate(user, token)
+            begin
+                token_plain = decrypt(token)
+                t_user, time = token_plain.split(':')
 
-    # Creates a login token for ssh authentication.
-    # By default it is valid for 1 hour but it can be changed to any number
-    # of seconds with expire parameter (in seconds)
-    def login_token(user, expire=3600)
-        expire ||= 3600
+                return 'invalid credentials' unless user == t_user
+                return 'ssh proxy expired, login again to renew it' if Time.now.to_i >= time.to_i
 
-        return encrypt("#{user}:#{Time.now.to_i + expire.to_i}")
-    end
+                return true
+            rescue StandardError
+                return 'error'
+            end
+        end
 
-    # Returns a valid password string to create a user using this auth driver.
-    # In this case the ssh public key.
-    def password
-        @public_key
-    end
+        private
 
-    # Checks the proxy created with the login method
-    def authenticate(user, token)
-        begin
-            token_plain = decrypt(token)
-            _user, time = token_plain.split(':')
-
-            if user == _user
-                if Time.now.to_i >= time.to_i
-                    return "ssh proxy expired, login again to renew it"
-                else
-                    return true
-                end
-            else
-                return "invalid credentials"
-            end
-        rescue
-            return "error"
+        def openssh_to_pem(private_key)
+            temp_file = Tempfile.new('private_key')
+
+            File.write(temp_file.path, private_key)
+
+            # Use ssh-keygen to convert the key
+            command = "ssh-keygen -p -N '' -m PEM -f #{temp_file.path}"
+
+            _out, err, status = Open3.capture3(command)
+
+            raise "Failed to convert key: #{err}" unless status.success?
+
+            pem_key = File.read(temp_file.path)
+            return pem_key
+        ensure
+            temp_file.close
+            temp_file.unlink if temp_file
+        end
+
+        ###########################################################################
+        #                       Methods to handle ssh keys
+        ###########################################################################
+        # Encrypts data with the private key of the user and returns
+        # base 64 encoded output in a single line
+        def encrypt(data)
+            Base64.encode64(@private_key_rsa.private_encrypt(data)).gsub!("\n", '').strip
         end
-    end
 
-    private
+        # Decrypts base 64 encoded data with pub_key (public key)
+        def decrypt(data)
+            @public_key_rsa.public_decrypt(Base64.decode64(data))
+        end
 
-    ###########################################################################
-    #                       Methods to handle ssh keys
-    ###########################################################################
-    # Encrypts data with the private key of the user and returns
-    # base 64 encoded output in a single line
-    def encrypt(data)
-        Base64::encode64(@private_key_rsa.private_encrypt(data)).gsub!(/\n/, '').strip
     end
 
-    # Decrypts base 64 encoded data with pub_key (public key)
-    def decrypt(data)
-        @public_key_rsa.public_decrypt(Base64::decode64(data))
-    end
 end

data/lib/opennebula/virtual_machine.rb

@@ -756,7 +756,8 @@ module OpenNebula
         #  can be updated are: INPUT/{TYPE, BUS}; RAW/{TYPE, DATA, DATA_VMX},
         #  OS/{BOOT, BOOTLOADER, ARCH, MACHINE, KERNEL, INITRD},
         #  FEATURES/{ACPI, APIC, PAE, LOCALTIME, HYPERV, GUEST_AGENT},
-        #  and GRAPHICS/{TYPE, LISTEN, PASSWD, KEYMAP}
+        #  GRAPHICS/{TYPE, LISTEN, PASSWD, KEYMAP},
+        #  and VIDEO/{TYPE, IOMMU, ATS, VRAM, RESOLUTION}
         # @param append, append template, do not delete empty attributes
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise

data/lib/opennebula/vm_group.rb

@@ -31,7 +31,10 @@ module OpenNebula
             :chmod       => "vmgroup.chmod",
             :rename      => "vmgroup.rename",
             :lock        => "vmgroup.lock",
-            :unlock        => "vmgroup.unlock"
+            :unlock      => "vmgroup.unlock",
+            :roleadd     => "vmgroup.roleadd",
+            :roledelete  => "vmgroup.roledelete",
+            :roleupdate  => "vmgroup.roleupdate"
         }
 
         # Creates a VMGroup description with just its identifier
@@ -134,6 +137,37 @@ module OpenNebula
             return call(VMGROUP_METHODS[:rename], @pe_id, name)
         end
 
+        # Add role to VM Group
+        #
+        # @param template [String] String template for the new role
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def role_add(template)
+            return call(VMGROUP_METHODS[:roleadd], @pe_id, template)
+        end
+
+        # Delete role from VM Group
+        #
+        # @param roleid [Integer] ID of the role to remove
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def role_delete(roleid)
+            return call(VMGROUP_METHODS[:roledelete], @pe_id, roleid)
+        end
+
+        # Update VM Group role
+        #
+        # @param roleid [Integer] ID of the role to remove
+        # @param template [String] String template with updated values
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def role_update(roleid, template)
+            return call(VMGROUP_METHODS[:roleupdate], @pe_id, roleid, template)
+        end
+
         #######################################################################
         # Helpers to get VMGroup information
         #######################################################################

data/lib/opennebula.rb

@@ -73,9 +73,11 @@ require 'opennebula/hook'
 require 'opennebula/hook_pool'
 require 'opennebula/hook_log'
 require 'opennebula/flow'
+require 'opennebula/backupjob'
+require 'opennebula/backupjob_pool'
 
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '6.6.3'
+    VERSION = '6.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opennebula
 version: !ruby/object:Gem::Version
-  version: 6.6.3
+  version: 6.8.0
 platform: ruby
 authors:
 - OpenNebula
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-25 00:00:00.000000000 Z
+date: 2023-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -155,6 +155,8 @@ files:
 - lib/opennebula.rb
 - lib/opennebula/acl.rb
 - lib/opennebula/acl_pool.rb
+- lib/opennebula/backupjob.rb
+- lib/opennebula/backupjob_pool.rb
 - lib/opennebula/client.rb
 - lib/opennebula/cluster.rb
 - lib/opennebula/cluster_pool.rb