opennebula-cli 6.6.3 → 6.8.0

data/lib/command_parser.rb

@@ -312,15 +312,9 @@ module CommandParser
         end
 
         def deprecated_command(name, new_command)
-            cmd = Hash.new
-            cmd[:desc] = "Deprecated, use #{new_command} instead"
-            cmd[:arity] = 0
-            cmd[:options] = []
-            cmd[:args_format] = [[:string, nil]] * 20
+            cmd = @commands[name.to_sym] || Hash.new
+            cmd[:desc] += "\nDeprecated, use #{new_command} instead"
             cmd[:deprecated] = new_command
-            cmd[:proc] = lambda do
-                print_deprecated(new_command)
-            end
 
             @commands[name.to_sym] = cmd
         end
@@ -800,7 +794,6 @@ module CommandParser
         def print_deprecated(new_command)
             puts "This command is deprecated, use instead:"
             puts "  $ #{File.basename $0} #{new_command}"
-            exit(-1)
         end
 
         def word_wrap(size, text, first_size=nil)

data/lib/one_helper/oneacl_helper.rb

@@ -34,7 +34,7 @@ class OneAclHelper < OpenNebulaHelper::OneHelper
     def self.resource_mask(str)
         resource_type=str.split('/')[0]
 
-        mask = '------------------'
+        mask = '-------------------'
 
         resource_type.split('+').each do |type|
             case type
@@ -74,6 +74,8 @@ class OneAclHelper < OpenNebulaHelper::OneHelper
                 mask[16] = 'P'
             when 'VNTEMPLATE'
                 mask[17] = 't'
+            when 'BACKUPJOB'
+                mask[18] = 'B'
             end
         end
         mask
@@ -128,9 +130,9 @@ class OneAclHelper < OpenNebulaHelper::OneHelper
                 d['STRING'].split(' ')[0]
             end
 
-            column :RES_VHNIUTGDCOZSvRMAPt,
+            column :RES_VHNIUTGDCOZSvRMAPtB,
                    'Resource to which the rule applies',
-                   :size => 22 do |d|
+                   :size => 23 do |d|
                 OneAclHelper.resource_mask d['STRING'].split(' ')[1]
             end
 
@@ -155,7 +157,7 @@ class OneAclHelper < OpenNebulaHelper::OneHelper
                 d['STRING']
             end
 
-            default :ID, :USER, :RES_VHNIUTGDCOZSvRMAPt, :RID, :OPE_UMAC, :ZONE
+            default :ID, :USER, :RES_VHNIUTGDCOZSvRMAPtB, :RID, :OPE_UMAC, :ZONE
         end
     end
     # rubocop:enable Lint/IneffectiveAccessModifier

data/lib/one_helper/onebackupjob_helper.rb

@@ -0,0 +1,284 @@
+# -------------------------------------------------------------------------- #
+# 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 'one_helper'
+
+# Helper for onebackupjob command
+class OneBackupJobHelper < OpenNebulaHelper::OneHelper
+
+    def self.rname
+        'BACKUPJOB'
+    end
+
+    def self.conf_file
+        'onebackupjob.yaml'
+    end
+
+    TEMPLATE_OPTIONS = [
+        {
+            :name => 'name',
+            :large => '--name name',
+            :format => String,
+            :description => 'Name of the new backup job'
+        },
+        {
+            :name => 'description',
+            :large => '--description description',
+            :format => String,
+            :description => 'Description for the new Image'
+        },
+        {
+            :name => 'backup_vms',
+            :large => '--vms "vm_id1,vm_id2..."',
+            :format => String,
+            :description => 'List of VM IDs to backup'
+        },
+        {
+            :name => 'keep_last',
+            :large => '--keep N',
+            :format => String,
+            :description => 'Keep N backups for the VMs in this backup job'
+        },
+        {
+            :name => 'mode',
+            :large => '--mode <increment|full>',
+            :format => String,
+            :description => 'Backup mode'
+        }
+    ]
+
+    def format_pool(options)
+        config_file = self.class.table_conf
+
+        CLIHelper::ShowTable.new(config_file, self) do
+            column :ID, 'ONE identifier for the Backup Job', :size=>4 do |d|
+                d['ID']
+            end
+
+            column :USER, 'Username of the Backup Job owner', :left,
+                   :size=>15 do |d|
+                helper.user_name(d, options)
+            end
+
+            column :GROUP, 'Group of the Backup Job', :left, :size=>15 do |d|
+                helper.group_name(d, options)
+            end
+
+            column :PRIO, 'Priority of the Backup Job', :left, :size=>4 do |d|
+                d['PRIORITY'].to_i
+            end
+
+            column :NAME, 'Date for the last backup operation', :left, :size=>15 do |d|
+                d['NAME']
+            end
+
+            column :LAST, 'Date for the last backup operation', :size => 15 do |d|
+                begin
+                    btime = d['LAST_BACKUP_TIME'].to_i
+                rescue StandardError
+                    btime = 0
+                end
+                OpenNebulaHelper.time_to_str(btime, false, true, true)
+            end
+
+            column :VMS, 'VM IDs part of this backup job', :size => 15 do |d|
+                begin
+                    vm = d['TEMPLATE']['BACKUP_VMS']
+                    vm[12..-1]='...' if vm.size > 15
+                    vm
+                rescue StandardError
+                    '-'
+                end
+            end
+
+            default :ID, :USER, :GROUP, :PRIO, :NAME, :LAST, :VMS
+        end
+    end
+
+    def schedule_actions(ids, options, warning = nil)
+        # Verbose by default
+        options[:verbose] = true
+
+        message = if options[:schedule].class == Integer
+                      "backup scheduled at #{Time.at(options[:schedule])}"
+                  else
+                      "backup scheduled after #{options[:schedule]}s"
+                  end
+
+        tmp_str = OpenNebulaHelper.schedule_action_tmpl(options, nil, warning)
+
+        perform_actions(ids, options, message) do |bj|
+            rc = bj.sched_action_add(tmp_str)
+
+            if OpenNebula.is_error?(rc)
+                STDERR.puts rc.message
+                exit(-1)
+            end
+        end
+    end
+
+    # Update schedule action
+    #
+    # @param id        [Integer] BackupJob ID
+    # @param action_id [Integer] Sched action ID
+    # @param file      [String]  File path with update content
+    # @param options
+    def update_schedule_action(id, action_id, file, options)
+        perform_action(id, options, 'Sched action updated') do |bj|
+            rc = bj.info
+
+            if OpenNebula.is_error?(rc)
+                STDERR.puts "Error #{rc.message}"
+                exit(-1)
+            end
+
+            xpath = "TEMPLATE/SCHED_ACTION[ID=#{action_id}]"
+
+            unless bj.retrieve_elements(xpath)
+                STDERR.puts "Sched action #{action_id} not found"
+                exit(-1)
+            end
+
+            # Get user information
+            if file
+                str = File.read(file)
+            else
+                str = OpenNebulaHelper.update_template(id, bj, nil, xpath)
+            end
+
+            # Add the modified sched action
+            tmp_str = "\nSCHED_ACTION = ["
+            tmp_str << str.split("\n").join(',')
+            tmp_str << ']'
+
+            rc = bj.sched_action_update(action_id, tmp_str)
+
+            if OpenNebula.is_error?(rc)
+                STDERR.puts "Error updating: #{rc.message}"
+                exit(-1)
+            end
+        end
+    end
+
+    def self.create_backupjob_template(options)
+        template_options = TEMPLATE_OPTIONS.map do |o|
+            o[:name].to_sym
+        end
+
+        template_options << :name
+
+        t = ''
+        template_options.each do |n|
+            t << "#{n.to_s.upcase}=\"#{options[n]}\"\n" if options[n]
+        end
+
+        t
+    end
+
+    private
+
+    def factory(id = nil)
+        if id
+            OpenNebula::BackupJob.new_with_id(id, @client)
+        else
+            xml=OpenNebula::BackupJob.build_xml
+            OpenNebula::BackupJob.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag = -2)
+        OpenNebula::BackupJobPool.new(@client, user_flag)
+    end
+
+    def format_resource(bj, options = {})
+        bj_hash = bj.to_hash
+
+        str='%-15s: %-20s'
+        str_h1='%-80s'
+
+        # ----------------------------------------------------------------------
+        CLIHelper.print_header(
+            str_h1 % "BACKUP JOB #{bj['ID']} INFORMATION"
+        )
+        # ----------------------------------------------------------------------
+        puts format(str, 'ID', bj.id.to_s)
+        puts format(str, 'NAME', bj.name)
+        puts format(str, 'USER', bj['UNAME'])
+        puts format(str, 'GROUP', bj['GNAME'])
+        puts format(str, 'LOCK', OpenNebulaHelper.level_lock_to_str(bj['LOCK/LOCKED']))
+
+        CLIHelper.print_header(str_h1 % 'PERMISSIONS', false)
+
+        ['OWNER', 'GROUP', 'OTHER'].each do |e|
+            mask = '---'
+            mask[0] = 'u' if bj["PERMISSIONS/#{e}_U"] == '1'
+            mask[1] = 'm' if bj["PERMISSIONS/#{e}_M"] == '1'
+            mask[2] = 'a' if bj["PERMISSIONS/#{e}_A"] == '1'
+
+            puts format(str, e, mask)
+        end
+        puts
+
+        # ----------------------------------------------------------------------
+        CLIHelper.print_header(
+            str_h1 % 'LAST BACKUP JOB EXECUTION INFORMATION'
+        )
+        # ----------------------------------------------------------------------
+        puts format(str, 'TIME', OpenNebulaHelper.time_to_str(bj['LAST_BACKUP_TIME']))
+        puts format(str, 'DURATION', OpenNebulaHelper.period_to_str(bj['LAST_BACKUP_DURATION']))
+        puts
+
+        # ----------------------------------------------------------------------
+        CLIHelper.print_header(
+            str_h1 % 'VIRTUAL MACHINE BACKUP STATUS'
+        )
+        # ----------------------------------------------------------------------
+        up  = bj.retrieve_elements('UPDATED_VMS/ID')
+        out = bj.retrieve_elements('OUTDATED_VMS/ID')
+        act = bj.retrieve_elements('BACKING_UP_VMS/ID')
+        err = bj.retrieve_elements('ERROR_VMS/ID')
+
+        up  = [] if up.nil?
+        out = [] if out.nil?
+        act = [] if act.nil?
+        err = [] if err.nil?
+
+        puts format(str, 'UPDATED', up.join(','))
+        puts format(str, 'OUTDATED', out.join(','))
+        puts format(str, 'ONGOING', act.join(','))
+        puts format(str, 'ERROR', err.join(','))
+
+        if bj.has_elements?('/BACKUPJOB/TEMPLATE/SCHED_ACTION')
+            puts
+            CLIHelper.print_header(str_h1 % 'SCHEDULED ACTIONS', false)
+
+            table = OpenNebulaHelper.scheduled_action_table(self)
+            table.show([bj_hash['BACKUPJOB']['TEMPLATE']['SCHED_ACTION']].flatten, {})
+        end
+
+        if !options[:all]
+            bj.delete_element('/BACKUPJOB/TEMPLATE/SCHED_ACTION')
+        end
+
+        puts
+
+        # ----------------------------------------------------------------------
+        CLIHelper.print_header(str_h1 % 'TEMPLATE CONTENTS', false)
+        # ----------------------------------------------------------------------
+        puts bj.template_str
+    end
+
+end

data/lib/one_helper/onevm_helper.rb

@@ -112,72 +112,6 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         :description => 'Creates the new VM on hold state instead of pending'
     }
 
-    SCHEDULE = {
-        :name => 'schedule',
-        :large => '--schedule TIME',
-        :description => 'Schedules this action to be executed after' \
-        'the given time. For example: onevm resume 0 --schedule "09/23 14:15"',
-        :format => String,
-        :proc => lambda {|o, options|
-            if o[0] == '+'
-                options[:schedule] = o
-            elsif o == 'now'
-                options[:schedule] = Time.now.to_i
-            else
-                begin
-                    options[:schedule] = Time.parse(o).to_i
-                rescue StandardError
-                    STDERR.puts "Error parsing time spec: #{o}"
-                    exit(-1)
-                end
-            end
-        }
-    }
-
-    WEEKLY = {
-        :name => 'weekly',
-        :large => '--weekly days',
-        :description => 'Repeats the schedule action the days of the week ' \
-        'specified, it can be a number between 0 (Sunday) to 6 (Saturday) ' \
-        'separated with commas. ' \
-        'For example: onevm resume 0 --schedule "09/23 14:15" --weekly 0,2,4',
-        :format => String
-    }
-
-    MONTHLY = {
-        :name => 'monthly',
-        :large => '--monthly days',
-        :description => 'Repeats the schedule action the days of the month ' \
-        'specified, it can be a number between 1,31 separated with commas. ' \
-        'For example: onevm resume 0 --schedule "09/23 14:15" --monthly 1,14',
-        :format => String
-    }
-
-    YEARLY = {
-        :name => 'yearly',
-        :large => '--yearly days',
-        :description => 'Repeats the schedule action the days of the year ' \
-        'specified, it can be a number between 0,365 separated with commas. ' \
-        'For example: onevm resume 0 --schedule "09/23 14:15" --yearly 30,60',
-        :format => String
-    }
-
-    HOURLY = {
-        :name => 'hourly',
-        :large => '--hourly hour',
-        :description => 'Repeats the schedule action each hours specified,' \
-        'it can be a number between 0,168 separated with commas. ' \
-        'For example: onevm resume 0 --schedule "09/23 14:15" --hourly 1,5',
-        :format => Numeric
-    }
-
-    END_TIME = {
-        :name => 'end',
-        :large => '--end number|TIME',
-        :description => '----',
-        :format => String
-    }
-
     ALL_TEMPLATE = {
         :name => 'all',
         :large => '--all',
@@ -426,41 +360,9 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                       "#{action} scheduled after #{options[:schedule]}s from start"
                   end
 
-        perform_actions(ids, options, message) do |vm|
-            str_periodic = ''
-
-            if options.key?(:weekly)
-                str_periodic << ", REPEAT = 0, DAYS = \"#{options[:weekly]}\""
-            elsif options.key?(:monthly)
-                str_periodic << ", REPEAT = 1, DAYS = \"#{options[:monthly]}\""
-            elsif options.key?(:yearly)
-                str_periodic << ", REPEAT = 2, DAYS = \"#{options[:yearly]}\""
-            elsif options.key?(:hourly)
-                str_periodic << ", REPEAT = 3, DAYS = \"#{options[:hourly]}\""
-            end
-
-            if options.key?(:end)
-                begin
-                    end_date = Date.parse(options[:end])
-                    str_periodic << ', END_TYPE = 2, ' \
-                            "END_VALUE = #{end_date.to_time.to_i}"
-                rescue ArgumentError
-                    if options[:end].to_i > 0
-                        str_periodic << ', END_TYPE = 1, ' \
-                            "END_VALUE = #{options[:end].to_i}"
-                    end
-                end
-            elsif str_periodic != ''
-                str_periodic << ', END_TYPE = 0'
-            end
-
-            tmp_str = 'SCHED_ACTION = ['
-            tmp_str << "ACTION = #{action}, "
-            tmp_str << "WARNING = #{warning}," if warning
-            tmp_str << "ARGS = \"#{options[:args]}\"," if options[:args]
-            tmp_str << "TIME = #{options[:schedule]}"
-            tmp_str << str_periodic << ']'
+        tmp_str = OpenNebulaHelper.schedule_action_tmpl(options, action, warning)
 
+        perform_actions(ids, options, message) do |vm|
             rc = vm.sched_action_add(tmp_str)
 
             if OpenNebula.is_error?(rc)
@@ -475,8 +377,9 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
     # @param vm_id     [Integer] Virtual Machine ID
     # @param action_id [Integer] Sched action ID
     # @param file      [String]  File path with update content
-    def update_schedule_action(vm_id, action_id, file)
-        perform_action(vm_id, {}, 'Sched action updated') do |vm|
+    # @param options
+    def update_schedule_action(vm_id, action_id, file, options)
+        perform_action(vm_id, options, 'Sched action updated') do |vm|
             rc = vm.info
 
             if OpenNebula.is_error?(rc)
@@ -1290,92 +1193,8 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
             puts
             CLIHelper.print_header(str_h1 % 'SCHEDULED ACTIONS', false)
 
-            CLIHelper::ShowTable.new(nil, self) do
-                column :ID, '', :adjust => true do |d|
-                    d['ID'] unless d.nil?
-                end
-
-                column :ACTION, '', :adjust => true do |d|
-                    d['ACTION'] unless d.nil?
-                end
-
-                column :ARGS, '', :adjust => true do |d|
-                    d['ARGS'] ? d['ARGS'] : '-'
-                end
-
-                column :SCHEDULED, '', :adjust => true do |d|
-                    t2 = d['TIME'].to_i
-                    t2 += vm['STIME'].to_i unless d['TIME'] =~ /^[0-9].*/
-
-                    OpenNebulaHelper.time_to_str(t2, false) \
-                        unless d.nil?
-                end
-
-                column :REPEAT, '', :adjust => true do |d|
-                    str_rep = ''
-                    if !d.nil? && d.key?('REPEAT')
-                        case d['REPEAT']
-                        when '0'
-                            str_rep << 'Weekly '
-                        when '1'
-                            str_rep << 'Monthly '
-                        when '2'
-                            str_rep << 'Yearly '
-                        when '3'
-                            str_rep << 'Each ' << d['DAYS'] << ' hours'
-                        end
-
-                        if d['REPEAT'] != '3'
-                            str_rep << d['DAYS']
-                        end
-                    end
-                    str_rep unless d.nil?
-                end
-
-                column :END, '', :adjust => true do |d|
-                    str_end = ''
-                    if !d.nil? && d.key?('END_TYPE')
-                        case d['END_TYPE']
-                        when '0'
-                            str_end << 'None'
-                        when '1'
-                            str_end << 'After ' << d['END_VALUE'] << ' times'
-                        when '2'
-                            str_end << 'On ' << \
-                                OpenNebulaHelper.time_to_str(d['END_VALUE'], false, false, true)
-                        end
-                    end
-                    str_end unless d.nil?
-                end
-                column :STATUS, '', :left, :size => 50 do |d|
-                    if d['DONE'] && !d['REPEAT']
-                        "Done on #{OpenNebulaHelper.time_to_str(d['DONE'], false)}"
-                    elsif d['MESSAGE']
-                        "Error! #{d['MESSAGE']}"
-                    else
-                        t1 = Time.now
-                        t2 = d['TIME'].to_i
-                        t2 += vm['STIME'].to_i unless d['TIME'] =~ /^[0-9].*/
-
-                        t2 = Time.at(t2)
-
-                        days    = ((t2 - t1) / (24 * 3600)).round(2)
-                        hours   = ((t2 - t1) / 3600).round(2)
-                        minutes = ((t2 - t1) / 60).round(2)
-
-                        if days > 1
-                            "Next in #{days} days"
-                        elsif days <= 1 && hours > 1
-                            "Next in #{hours} hours"
-                        elsif minutes > 0
-                            "Next in #{minutes} minutes"
-                        else
-                            'Overdue!'
-                        end
-                    end
-                end
-            end.show([vm_hash['VM']['TEMPLATE']['SCHED_ACTION']].flatten,
-                     {})
+            table = OpenNebulaHelper.scheduled_action_table(self)
+            table.show([vm_hash['VM']['TEMPLATE']['SCHED_ACTION']].flatten, {})
         end
 
         if !options[:all]

data/lib/one_helper/onevmgroup_helper.rb

@@ -81,6 +81,21 @@ class OneVMGroupHelper < OpenNebulaHelper::OneHelper
         table
     end
 
+    def retrieve_role_id(vmg_id, id)
+        return [0, id.to_i] if id =~ /\A\d+\z/
+
+        puts vmg_id
+        vmg = retrieve_resource(vmg_id)
+        vmg.info
+
+        ids = vmg.retrieve_elements("ROLES/ROLE[NAME='#{id}']/ID")
+
+        return [-1, "#{id} not found or duplicated"] \
+                if ids.nil? || ids.size > 1
+
+        [0, ids[0].to_i]
+    end
+
     private
 
     def factory(id=nil)