opennebula-cli 5.11.90.pre → 5.12.3

data/lib/one_helper/onehost_helper.rb

@@ -17,6 +17,7 @@
 require 'one_helper'
 require 'one_helper/onevm_helper'
 require 'rubygems'
+require 'time'
 
 # implements onehost command
 class OneHostHelper < OpenNebulaHelper::OneHelper
@@ -75,6 +76,15 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
 
     VERSION_XPATH = "#{TEMPLATE_XPATH}/VERSION"
 
+    MONITORING = {
+        'FREE_CPU'    => 'CAPACITY',
+        'FREE_MEMORY' => 'CAPACITY',
+        'USED_CPU'    => 'CAPACITY',
+        'USED_MEMORY' => 'CAPACITY',
+        'NETRX'       => 'SYSTEM',
+        'NETTX'       => 'SYSTEM'
+    }
+
     def self.rname
         'HOST'
     end
@@ -93,7 +103,7 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
     def format_pool(options)
         config_file = self.class.table_conf
 
-        table = CLIHelper::ShowTable.new(config_file, self) do
+        CLIHelper::ShowTable.new(config_file, self) do
             column :ID, 'ONE identifier for Host', :size => 4 do |d|
                 d['ID']
             end
@@ -223,8 +233,6 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
             default :ID, :NAME, :CLUSTER, :TVM,
                     :ALLOCATED_CPU, :ALLOCATED_MEM, :STAT
         end
-
-        table
     end
 
     def set_hybrid(type, path)
@@ -425,8 +433,7 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         rc = pool.info
         return -1, rc.message if OpenNebula.is_error?(rc)
 
-        # Assign hosts to threads
-        queue = []
+        host_errors = []
 
         pool.each do |host|
             if host_ids
@@ -435,7 +442,6 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
                 next if host['CLUSTER_ID'].to_i != cluster_id
             end
 
-            vm_mad = host['VM_MAD'].downcase
             state = host['STATE']
 
             # Skip this host from remote syncing if it's a PUBLIC_CLOUD host
@@ -444,60 +450,104 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
             # Skip this host from remote syncing if it's OFFLINE
             next if Host::HOST_STATES[state.to_i] == 'OFFLINE'
 
-            # Skip this host if it is a vCenter cluster
-            next if vm_mad == 'vcenter'
+            rc = host.forceupdate
 
-            queue << host
+            host_errors << host['NAME'] if OpenNebula.is_error?(rc)
         end
 
-        # Run the jobs in threads
-        host_errors = []
-        queue_lock = Mutex.new
-        error_lock = Mutex.new
-        total = queue.length
+        if host_errors.empty?
+            puts 'All hosts updated successfully.'
+            0
+        else
+            STDERR.puts 'Failed to update the following hosts:'
+            host_errors.each {|h| STDERR.puts "* #{h}" }
+            -1
+        end
+    end
 
-        if total.zero?
-            puts 'No hosts are going to be forced.'
-            exit(0)
+    def monitoring(host, attr, options)
+        unit    = options[:unit] || 'G'
+        start_d = options[:start]
+        end_d   = options[:end]
+        n_elems = options[:n_elems] || 8
+
+        # Different available size units
+        units = %w[K M G T]
+
+        # Attrs that need units conversion
+        attrs = %w[FREE_MEMORY USED_MEMORY]
+
+        if unit && !units.include?(unit)
+            STDERR.puts "Invalid unit `#{unit}`"
+            exit(-1)
         end
 
-        ts = (1..NUM_THREADS).map do |_t|
-            Thread.new do
-                loop do
-                    host = nil
-                    size = 0
+        attr      = attr.upcase
+        start_d   = Time.parse(start_d) if start_d
+        end_d     = Time.parse(end_d) if end_d
 
-                    queue_lock.synchronize do
-                        host = queue.shift
-                        size = queue.length
-                    end
+        # Get monitoring data from user path
+        #
+        #   0 -> timestamp
+        #   1 -> data retrieved
+        monitoring_data = host.monitoring(["#{MONITORING[attr]}/#{attr}"])
+        monitoring_data = monitoring_data["#{MONITORING[attr]}/#{attr}"]
 
-                    break unless host
+        if monitoring_data.empty?
+            STDERR.puts 'No monitoring data found'
+            return
+        end
 
-                    hn = host['NAME']
+        # Get data max and min date
+        start_d ||= Time.at(monitoring_data.min {|v| v[0].to_i }[0].to_i)
+        end_d   ||= Time.at(monitoring_data.max {|v| v[0].to_i }[0].to_i)
 
-                    system("onehost offline #{hn} && onehost enable #{hn}")
-                    if !$CHILD_STATUS.success?
-                        error_lock.synchronize do
-                            host_errors << hn
-                        end
-                    else
-                        puts "#{hn} monitoring forced"
-                    end
-                end
+        # Filter data betwen dates
+        monitoring_data.reject! do |v|
+            v[0].to_i < start_d.to_i || v[0].to_i > end_d.to_i
+        end
+
+        if monitoring_data.empty?
+            STDERR.puts "No monitoring data found between #{start_d} " \
+                        "and #{end_d}"
+            return
+        end
+
+        start_d = start_d.strftime('%d/%m/%Y %H:%M')
+        end_d   = end_d.strftime('%d/%m/%Y %H:%M')
+
+        # Parse dcollected data
+        x = monitoring_data.collect {|v| Time.at(v[0].to_i).strftime('%H:%M') }
+        y = monitoring_data.collect do |v|
+            if attrs.include?(attr)
+                # GB is the default unit
+                v = OpenNebulaHelper.bytes_to_unit(v[1].to_i, unit).round(2)
+                "#{v} #{unit}B"
+            else
+                v[1]
             end
         end
 
-        # Wait for threads to finish
-        ts.each {|t| t.join }
+        title = ''
+        title << "Host #{host.id} #{attr} "
+        title << "in #{unit}B " if unit && attrs.include?(attr)
+        title << "from #{start_d} to #{end_d}"
 
-        if host_errors.empty?
-            puts 'All hosts updated successfully.'
-            0
+        x = x.last(n_elems)
+        y = y.last(n_elems)
+
+        if options[:table]
+            print_monitoring_table(x, y, title)
+        elsif options[:csv]
+            csv = ''
+
+            csv << "TIME#{options[:csv]}VALUE\n"
+
+            x.zip(y) {|x_v, y_v| csv << "#{x_v}#{options[:csv]}#{y_v}\n" }
+
+            puts csv
         else
-            STDERR.puts 'Failed to update the following hosts:'
-            host_errors.each {|h| STDERR.puts "* #{h}" }
-            -1
+            puts OpenNebulaHelper.get_plot(x, y, attr, title)
         end
     end
 
@@ -920,4 +970,30 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         table.show(hugepages)
     end
 
+    def print_monitoring_table(x, y, title)
+        puts
+        CLIHelper.print_header(title, true)
+        puts
+
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :TIME, 'Timestamp', :size => 8, :left => false do |d|
+                d['TIME']
+            end
+
+            column :VALUE, 'Value', :size => 8, :left => false do |d|
+                d['VALUE']
+            end
+
+            default :TIME, :VALUE
+        end
+
+        data = []
+
+        x.zip(y) do |x_v, y_v|
+            data << { 'TIME' => x_v, 'VALUE' => y_v }
+        end
+
+        table.show(data)
+    end
+
 end

data/lib/one_helper/oneimage_helper.rb

@@ -192,7 +192,7 @@ class OneImageHelper < OpenNebulaHelper::OneHelper
     def format_pool(options)
         config_file = self.class.table_conf
 
-        table = CLIHelper::ShowTable.new(config_file, self) do
+        CLIHelper::ShowTable.new(config_file, self) do
             column :ID, 'ONE identifier for the Image', :size=>4 do |d|
                 d['ID']
             end
@@ -246,8 +246,6 @@ class OneImageHelper < OpenNebulaHelper::OneHelper
             default :ID, :USER, :GROUP, :NAME, :DATASTORE, :SIZE, :TYPE,
                     :PERSISTENT, :STAT, :RVMS
         end
-
-        table
     end
 
     def check_orphans

data/lib/one_helper/oneprovision_helper.rb

@@ -49,7 +49,7 @@ class OneProvisionHelper < OpenNebulaHelper::OneHelper
     def format_pool
         config_file = self.class.table_conf
 
-        table = CLIHelper::ShowTable.new(config_file, self) do
+        CLIHelper::ShowTable.new(config_file, self) do
             column :ID, 'Identifier for the Provision', :size => 36 do |p|
                 p['ID']
             end
@@ -80,8 +80,6 @@ class OneProvisionHelper < OpenNebulaHelper::OneHelper
 
             default :ID, :NAME, :CLUSTERS, :HOSTS, :NETWORKS, :DATASTORES, :STAT
         end
-
-        table
     end
 
     #######################################################################
@@ -228,11 +226,9 @@ class OneProvisionHelper < OpenNebulaHelper::OneHelper
     end
 
     def names_to_ids(objects, type)
-        objects = [objects].flatten.map do |obj|
+        [objects].flatten.map do |obj|
             OpenNebulaHelper.rname_to_id(obj.to_s, type)[1]
         end
-
-        objects
     end
 
     def get_list(provision_list)

data/lib/one_helper/onevcenter_helper.rb

@@ -237,11 +237,11 @@ class OneVcenterHelper < OpenNebulaHelper::OneHelper
                 d[:import_id]
             end
 
-            column :REF, "ref", :left, :size=>config[:REF] || 15 do |d|
+            column :REF, "ref", :left, :adjust, :size=>config[:REF] || 15 do |d|
                 d[:ref]
             end
 
-            column :NAME, "Name", :left, :size=>config[:NAME] || 20 do |d|
+            column :NAME, "Name", :left, :expand, :size=>config[:NAME] || 20 do |d|
                 d[:name] || d[:simple_name]
             end
 
@@ -250,7 +250,7 @@ class OneVcenterHelper < OpenNebulaHelper::OneHelper
                 d[:one_ids] || d[:cluster].to_s
             end
 
-            column :PATH, "PATH", :left, :size=>config[:PATH] || 10 do |d|
+            column :PATH, "PATH", :left, :expand, :size=>config[:PATH] || 10 do |d|
                 d[:path]
             end
 

data/lib/one_helper/onevm_helper.rb

@@ -354,7 +354,7 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
 
             column :MEM, 'Memory asigned to the VM', :size => 7 do |d|
                 OpenNebulaHelper.unit_to_str(d['TEMPLATE']['MEMORY'].to_i,
-                                             options)
+                                             options, 'M')
             end
 
             column :HOST, 'Host where the VM is running',
@@ -402,7 +402,7 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         table
     end
 
-    def schedule_actions(ids, options, action)
+    def schedule_actions(ids, options, action, warning = nil)
         # Verbose by default
         options[:verbose] = true
 
@@ -453,18 +453,74 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                 id = ids.max + 1
             end
 
+            sched = options[:schedule]
+
+            # If the action is set to be executed from VM start to an specific
+            # amount of time later, we should preserve the + symbol
+            if ((sched.is_a? String) && !sched.include?('+')) ||
+                !(sched.is_a? String)
+                sched = sched.to_i
+            end
+
             tmp_str = vm.user_template_str
 
             tmp_str << "\nSCHED_ACTION = "
             tmp_str << "[ID = #{id}, ACTION = #{action}, "
+            tmp_str << "WARNING = #{warning}," if warning
             tmp_str << "ARGS = \"#{options[:args]}\"," if options[:args]
-            tmp_str << "TIME = #{options[:schedule].to_i}"
+            tmp_str << "TIME = #{sched}"
             tmp_str << str_periodic << ']'
 
             vm.update(tmp_str)
         end
     end
 
+    # Update schedule action
+    #
+    # @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|
+            rc = vm.info
+
+            if OpenNebula.is_error?(rc)
+                STDERR.puts "Error #{rc.message}"
+                exit(-1)
+            end
+
+            xpath = "USER_TEMPLATE/SCHED_ACTION[ID=#{action_id}]"
+
+            unless vm.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(vm_id, vm, nil, xpath)
+            end
+
+            # Delete the current sched action
+            vm.delete_element(xpath)
+
+            # Add the modified sched action
+            tmp_str = vm.user_template_str
+            tmp_str << "\nSCHED_ACTION = ["
+            tmp_str << str.split("\n").join(',')
+            tmp_str << ']'
+
+            rc = vm.update(tmp_str)
+
+            if OpenNebula.is_error?(rc)
+                STDERR.puts "Error updating: #{rc.message}"
+                exit(-1)
+            end
+        end
+    end
+
     RECOVER_RETRY_STEPS = {
         :PROLOG_MIGRATE_FAILURE => :migrate,
         :PROLOG_MIGRATE_POWEROFF_FAILURE => :migrate,
@@ -602,6 +658,16 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         end
     end
 
+    # Get charters configuration
+    #
+    #   @return [Array]
+    #       - action
+    #           - time
+    #           - warning
+    def get_charters
+        YAML.load_file(self.class.table_conf)[:charters]
+    end
+
     private
 
     def factory(id = nil)
@@ -1144,24 +1210,24 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
             CLIHelper.print_header(str_h1 % 'SCHEDULED ACTIONS', false)
 
             CLIHelper::ShowTable.new(nil, self) do
-                column :ID, '', :size => 2 do |d|
+                column :ID, '', :adjust => true do |d|
                     d['ID'] unless d.nil?
                 end
 
-                column :ACTION, '', :left, :size => 15 do |d|
+                column :ACTION, '', :adjust => true do |d|
                     d['ACTION'] unless d.nil?
                 end
 
-                column :ARGS, '', :left, :size => 15 do |d|
+                column :ARGS, '', :adjust => true do |d|
                     d['ARGS'] ? d['ARGS'] : '-'
                 end
 
-                column :SCHEDULED, '', :size => 12 do |d|
+                column :SCHEDULED, '', :adjust => true do |d|
                     OpenNebulaHelper.time_to_str(d['TIME'], false) \
                         unless d.nil?
                 end
 
-                column :REPEAT, '', :size => 20 do |d|
+                column :REPEAT, '', :adjust => true do |d|
                     str_rep = ''
                     if !d.nil? && d.key?('REPEAT')
                         if d['REPEAT'] == '0'
@@ -1180,7 +1246,7 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                     str_rep unless d.nil?
                 end
 
-                column :END, '', :size => 20 do |d|
+                column :END, '', :adjust => true do |d|
                     str_end = ''
                     if !d.nil? && d.key?('END_TYPE')
                         if d['END_TYPE'] == '0'
@@ -1197,25 +1263,50 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                     str_end unless d.nil?
                 end
 
-                column :DONE, '', :size => 12 do |d|
+                column :DONE, '', :adjust => true do |d|
                     OpenNebulaHelper.time_to_str(d['DONE'], false) \
                         unless d.nil?
                 end
 
-                column :MESSAGE, '', :left, :adjust, :size => 35 do |d|
-                    d['MESSAGE'] unless d.nil?
+                column :MESSAGE, '', :size => 35 do |d|
+                    d['MESSAGE'] ? d['MESSAGE'] : '-'
+                end
+
+                column :CHARTER, '', :left, :adjust, :size => 15 do |d|
+                    t1 = Time.now
+                    t2 = Time.at(vm['STIME'].to_i + d['TIME'].to_i)
+
+                    days    = ((t2 - t1) / (24 * 3600)).round(2)
+                    hours   = ((t2 - t1) / 3600).round(2)
+                    minutes = ((t2 - t1) / 60).round(2)
+
+                    if days > 1
+                        show = "In #{days} days"
+                    elsif days < 1 && hours > 1
+                        show = "In #{hours} hours"
+                    elsif minutes > 0
+                        show = "In #{minutes} minutes"
+                    else
+                        show = 'Already done'
+                    end
+
+                    if (t1 - vm['STIME'].to_i).to_i > d['WARNING'].to_i
+                        "#{show} *"
+                    else
+                        show
+                    end
                 end
             end.show([vm_hash['VM']['USER_TEMPLATE']['SCHED_ACTION']].flatten,
                      {})
         end
 
+        if !options[:all]
+            vm.delete_element('/VM/USER_TEMPLATE/SCHED_ACTION')
+        end
+
         if vm.has_elements?('/VM/USER_TEMPLATE')
             puts
 
-            if !options[:all]
-                vm.delete_element('/VM/USER_TEMPLATE/SCHED_ACTION')
-            end
-
             CLIHelper.print_header(str_h1 % 'USER TEMPLATE', false)
             puts vm.template_like_str('USER_TEMPLATE')
         end