opennebula-cli 4.12.1 → 4.13.80.beta1

data/lib/one_helper.rb

@@ -649,13 +649,13 @@ user         #{self.rname} of the user identified by the username
 EOT
         end
 
-        def self.table_conf
-            path = "#{ENV["HOME"]}/.one/cli/#{self.conf_file}"
+        def self.table_conf(conf_file=self.conf_file)
+            path = "#{ENV["HOME"]}/.one/cli/#{conf_file}"
 
             if File.exists?(path)
                 return path
             else
-                return "#{TABLE_CONF_PATH}/#{self.conf_file}"
+                return "#{TABLE_CONF_PATH}/#{conf_file}"
             end
         end
 

data/lib/one_helper/oneacct_helper.rb

@@ -114,7 +114,7 @@ class AcctHelper < OpenNebulaHelper::OneHelper
     ACCT_OPTIONS     = [START_TIME_ACCT, END_TIME_ACCT, USERFILTER, GROUP, HOST, XPATH, XML, JSON, SPLIT]
     SHOWBACK_OPTIONS = [START_TIME_SHOWBACK, END_TIME_SHOWBACK, USERFILTER, GROUP, XML, JSON]
 
-    ACCT_TABLE = CLIHelper::ShowTable.new("oneacct.yaml", nil) do
+    ACCT_TABLE = CLIHelper::ShowTable.new(self.table_conf("oneacct.yaml"), nil) do
         column :UID, "User ID", :size=>4 do |d|
             d["UID"]
         end
@@ -155,20 +155,42 @@ class AcctHelper < OpenNebulaHelper::OneHelper
             d["VM"]["TEMPLATE"]["CPU"]
         end
 
-        column :NET_RX, "Data received from the network", :size=>6 do |d|
+        column :NETRX, "Data received from the network", :size=>6 do |d|
             # NET is measured in bytes, unit_to_str expects KBytes
-            OpenNebulaHelper.unit_to_str(d["VM"]["NET_RX"].to_i / 1024.0, {})
+            OpenNebulaHelper.unit_to_str(d["VM"]["MONITORING/NETRX"].to_i / 1024.0, {})
         end
 
-        column :NET_TX, "Data sent to the network", :size=>6 do |d|
+        column :NETTX, "Data sent to the network", :size=>6 do |d|
             # NET is measured in bytes, unit_to_str expects KBytes
-            OpenNebulaHelper.unit_to_str(d["VM"]["NET_TX"].to_i / 1024.0, {})
+            OpenNebulaHelper.unit_to_str(d["VM"]["MONITORING/NETTX"].to_i / 1024.0, {})
         end
 
-        default :VID, :HOSTNAME, :ACTION, :REASON, :START_TIME, :END_TIME, :MEMORY, :CPU, :NET_RX, :NET_TX
+        column :DISK, "Total disk size used", :size=>6 do |d|
+            # DISK size is measured in mb, unit_to_str expects KBytes
+            total_disk_size = 0
+
+            vm_id = d["VM"]["ID"].to_i
+
+            disks_all = [d["VM"]["TEMPLATE"]["DISK"]].flatten.compact rescue []
+            disks_all.each do |disk|
+                total_disk_size += disk["SIZE"].to_i
+            end
+
+            snapshots_all = [d["VM"]["SNAPSHOTS"]].flatten.compact rescue []
+            snapshots_all.each do |snapshot|
+                snapshot_disk = [snapshot["SNAPSHOT"]].flatten.compact rescue []
+                snapshot_disk.each do |snapshot|
+                    total_disk_size += snapshot["SIZE"].to_i
+                end
+            end
+
+            OpenNebulaHelper.unit_to_str(total_disk_size * 1024.0, {})
+        end
+
+        default :VID, :HOSTNAME, :ACTION, :REASON, :START_TIME, :END_TIME, :MEMORY, :CPU, :NETRX, :NETTX, :DISK
     end
 
-    SHOWBACK_TABLE = CLIHelper::ShowTable.new("oneshowback.yaml", nil) do
+    SHOWBACK_TABLE = CLIHelper::ShowTable.new(self.table_conf("oneshowback.yaml"), nil) do
         column :UID, "User ID", :size=>4 do |d|
             d["UID"]
         end

data/lib/one_helper/onehost_helper.rb

@@ -167,6 +167,11 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
 
     NUM_THREADS = 15
     def sync(host_ids, options)
+        if `id -u`.to_i == 0 || `id -G`.split.collect{|e| e.to_i}.include?(0)
+            STDERR.puts("Cannot run 'onehost sync' as root")
+            exit -1
+        end
+
         begin
             current_version = File.read(REMOTES_LOCATION+'/VERSION').strip
         rescue
@@ -406,8 +411,44 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
 
         CLIHelper.print_header(str_h1 % "MONITORING INFORMATION", false)
 
+        wilds = host.wilds
+
+        host.delete_element("TEMPLATE/VM")
+        host.delete_element("TEMPLATE_WILDS")
+
         puts host.template_str
 
+        puts
+        CLIHelper.print_header("WILD VIRTUAL MACHINES", false)
+        puts
+
+        format = "%30s %36s %4s %10s"
+        CLIHelper.print_header(format % ["NAME", "IMPORT_ID", "CPU", "MEMORY"],
+                               true)
+
+        wilds.each do |wild|
+          if wild['IMPORT_TEMPLATE']
+            wild_tmplt = Base64::decode64(wild['IMPORT_TEMPLATE']).split("\n")
+            name   = wild_tmplt.select { |line|
+                      line[/^NAME/]
+                     }[0].split("=")[1].gsub("\"", " ").strip
+            import = wild_tmplt.select { |line|
+                       line[/^IMPORT_VM_ID/]
+                     }[0].split("=")[1].gsub("\"", " ").strip
+            memory = wild_tmplt.select { |line|
+                       line[/^MEMORY/]
+                     }[0].split("=")[1].gsub("\"", " ").strip
+            cpu    = wild_tmplt.select { |line|
+                        line[/^CPU/]
+                     }[0].split("=")[1].gsub("\"", " ").strip
+          else
+            name     = wild['DEPLOY_ID']
+            import   = memory = cpu = "-"
+          end
+
+          puts format % [name, import, cpu, memory]
+        end
+
         puts
         CLIHelper.print_header("VIRTUAL MACHINES", false)
         puts

data/lib/one_helper/oneimage_helper.rb

@@ -86,10 +86,10 @@ class OneImageHelper < OpenNebulaHelper::OneHelper
                     path=Dir.pwd+"/"+o
                 end
 
-                if File.exist?(path)
+                if File.readable?(path)
                     [0, path]
                 else
-                    [-1, "File '#{path}' does not exist."]
+                    [-1, "File '#{path}' does not exist or is not readable."]
                 end
             end
         },
@@ -292,6 +292,13 @@ class OneImageHelper < OpenNebulaHelper::OneHelper
 
             puts str % [e,  mask]
         }
+
+        if image.has_elements?("/IMAGE/SNAPSHOTS")
+            puts
+            CLIHelper.print_header(str_h1 % "IMAGE SNAPSHOTS",false)
+            format_snapshots(image)
+        end
+
         puts
 
         CLIHelper.print_header(str_h1 % "IMAGE TEMPLATE",false)
@@ -311,6 +318,44 @@ class OneImageHelper < OpenNebulaHelper::OneHelper
         end
     end
 
+    def format_snapshots(image)
+        table=CLIHelper::ShowTable.new(nil, self) do
+            column :AC , "Is active", :left, :size => 2 do |d|
+                if d["ACTIVE"] == "YES"
+                    "=>"
+                else
+                    ""
+                end
+            end
+            column :ID, "Snapshot ID", :size=>3 do |d|
+                d["ID"]
+            end
+
+            column :PARENT, "Snapshot Parent ID", :size=>6 do |d|
+                d["PARENT"]
+            end
+
+            column :CHILDREN, "Snapshot Children IDs", :size=>10 do |d|
+                d["CHILDREN"]
+            end
+
+            column :NAME, "Snapshot Name", :left, :size=>45 do |d|
+                d["NAME"]
+            end
+
+            column :DATE, "Snapshot creation date", :size=>15 do |d|
+                OpenNebulaHelper.time_to_str(d["DATE"])
+            end
+
+            default :AC, :ID, :PARENT, :DATE, :CHILDREN, :NAME
+        end
+
+        # Convert snapshot data to an array
+        image_hash = image.to_hash
+        image_snapshots = [image_hash['IMAGE']['SNAPSHOTS']].flatten.first
+        table.show(image_snapshots)
+    end
+
     def self.create_image_variables(options, name)
         if Array===name
             names=name

data/lib/one_helper/onequota_helper.rb

@@ -74,7 +74,7 @@ class OneQuotaHelper
 
     #  Edits the quota template of a resource
     #  @param [XMLElement] resource to get the current info from
-    #  @param [String] path to the new contents. If nil a editor will be 
+    #  @param [String] path to the new contents. If nil a editor will be
     #         used
     #  @param [True|False] is_default To change the help text
     #  @return [String] contents of the new quotas
@@ -122,7 +122,7 @@ class OneQuotaHelper
 
     #  Retrieves a clean quota template, without any existing resource
     #  information
-    #  @param path [String] path to the new contents. If nil a editor will be 
+    #  @param path [String] path to the new contents. If nil a editor will be
     #         used
     #  @return [String] contents of the new quotas
     def self.get_batch_quota(path)
@@ -159,7 +159,7 @@ class OneQuotaHelper
     #  Edits the quota template of a resource, adding the quotas set in str
     #  @param resource [PoolElement] to get the current info from
     #  @param str [String] quota template, created by get_batch_quota()
-    #  @return [String, OpenNebula::Error] merged contents of the new quotas on 
+    #  @return [String, OpenNebula::Error] merged contents of the new quotas on
     #    success, Error if the user info could not be retrieved
     def self.merge_quota(resource, str)
         rc = resource.info

data/lib/one_helper/onevm_helper.rb

@@ -14,8 +14,38 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
+if !ONE_LOCATION
+    MAD_LOCATION      = "/usr/lib/one/mads"
+    VAR_LOCATION      = "/var/lib/one"
+else
+    MAD_LOCATION      = ONE_LOCATION + "/lib/mads"
+    VAR_LOCATION      = ONE_LOCATION + "/var"
+end
+
+VMS_LOCATION = VAR_LOCATION + "/vms"
+
+$: << MAD_LOCATION
+
 require 'one_helper'
 require 'optparse/time'
+require 'one_tm'
+
+class String
+    def red
+        colorize(31)
+    end
+
+    def green
+        colorize(32)
+    end
+
+private
+
+    def colorize(color_code)
+        "\e[#{color_code}m#{self}\e[0m"
+    end
+end
+
 
 class OneVMHelper < OpenNebulaHelper::OneHelper
     MULTIPLE={
@@ -123,6 +153,45 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         return short_state_str
     end
 
+    # Return the IP or several IPs of a VM
+    def self.ip_str(vm)
+        ips = []
+
+        vm_nics = []
+
+        if !vm["TEMPLATE"]["NIC"].nil?
+            vm_nics = [vm["TEMPLATE"]['NIC']].flatten
+        end
+
+        vm_nics.each do |nic|
+            if nic.has_key?("IP")
+                ips.push(nic["IP"])
+            end
+
+            if nic.has_key?("IP6_GLOBAL")
+                ips.push(nic["IP6_GLOBAL"])
+            end
+
+            if nic.has_key?("IP6_ULA")
+                ips.push(nic["IP6_ULA"])
+            end
+        end
+
+        VirtualMachine::EXTERNAL_IP_ATTRS.each do |attr|
+            external_ip = vm["MONITORING"][attr]
+
+            if !external_ip.nil? && !ips.include?(external_ip)
+                ips.push(external_ip)
+            end
+        end
+
+        if ips.empty?
+            return "--"
+        else
+            return ips.join(",")
+        end
+    end
+
     def format_pool(options)
         config_file = self.class.table_conf
 
@@ -208,6 +277,10 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                 OpenNebulaHelper.period_to_str(dtime, false)
             end
 
+            column :IP, "VM IP addresses", :left, :donottruncate, :size=>15 do |d|
+                OneVMHelper.ip_str(d)
+            end
+
             default :ID, :USER, :GROUP, :NAME, :STAT, :UCPU, :UMEM, :HOST,
                 :TIME
         end
@@ -247,6 +320,123 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         end
     end
 
+    RECOVER_RETRY_STEPS = {
+        :PROLOG_MIGRATE_FAILURE          => :migrate,
+        :PROLOG_MIGRATE_POWEROFF_FAILURE => :migrate,
+        :PROLOG_MIGRATE_SUSPEND_FAILURE  => :migrate,
+        :PROLOG_FAILURE                  => :prolog,
+        :PROLOG_RESUME_FAILURE           => :resume,
+        :PROLOG_UNDEPLOY_FAILURE         => :resume,
+        :EPILOG_FAILURE                  => :epilog,
+        :EPILOG_STOP_FAILURE             => :stop,
+        :EPILOG_UNDEPLOY_FAILURE         => :stop
+    }
+
+    def recover_retry_interactive(vm)
+        # Disable CTRL-C in the menu
+        trap("SIGINT") { }
+
+        if !File.readable?(VAR_LOCATION+"/config")
+            STDERR.puts "Error reading #{VAR_LOCATION+'/config'}. The " <<
+                "TM Debug Interactive Environment must be executed as " <<
+                "oneadmin in the frontend."
+            exit -1
+        end
+
+        rc = vm.info
+        if OpenNebula.is_error?(rc)
+            STDERR.puts rc.message
+            exit -1
+        end
+
+        if !RECOVER_RETRY_STEPS.include?(vm.lcm_state_str.to_sym)
+            STDERR.puts "Current LCM STATE '#{vm.lcm_state_str}' not " <<
+                "compatible with RECOVER RETRY action."
+            exit -1
+        end
+
+        seq = vm['/VM/HISTORY_RECORDS/HISTORY[last()]/SEQ']
+
+        tm_action = RECOVER_RETRY_STEPS[vm.lcm_state_str.to_sym]
+
+        tm_file = "#{VMS_LOCATION}/#{vm.id}/transfer.#{seq}.#{tm_action}"
+
+        if !File.readable?(tm_file)
+            STDERR.puts "Cannot read #{tm_file}"
+            exit -1
+        end
+
+        @tm_action_list = File.read(tm_file)
+
+        puts "TM Debug Interactive Environment.".green
+        puts
+        print_tm_action_list
+
+        @tm = TransferManagerDriver.new(nil)
+        i=0
+        @tm_action_list.lines.each do |tm_command|
+            i+=1
+            success=false
+
+            while !success
+                puts "Current action (#{i}):".green
+                puts tm_command
+                puts
+
+                puts <<-EOF.gsub(/^\s+/,"")
+                Choose action:
+                (r) Run action
+                (n) Skip to next action
+                (a) Show all actions
+                (q) Quit
+                EOF
+
+                ans = ""
+                while !%w(n a r q).include?(ans)
+                    printf "> "
+                    ans = STDIN.gets.strip.downcase
+
+                    puts
+
+                    case ans
+                    when "n"
+                        success = true
+                    when "a"
+                        print_tm_action_list
+                    when "q"
+                        exit -1
+                    when "r"
+                        result, result_message = @tm.do_transfer_action(@id, tm_command.split)
+
+                        if result == "SUCCESS"
+                            success = true
+                            puts "#{result}"
+                            puts
+                        else
+                            puts
+                            puts "#{result}. Repeat command.".red
+                            puts
+                        end
+                    end
+                end
+            end
+        end
+
+        puts "If all the TM actions have been successful and you want to"
+        puts "recover the Virtual Machine to the RUNNING state execute this command:"
+        puts "$ onevm recover #{vm.id} --success"
+    end
+
+    def print_tm_action_list
+        puts "TM Action list:".green
+        i=0
+        @tm_action_list.lines.each do |line|
+            i+=1
+            puts "(#{i}) #{line}"
+        end
+        puts
+    end
+
     private
 
     def factory(id=nil)
@@ -312,22 +502,37 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         puts
 
         CLIHelper.print_header(str_h1 % "VIRTUAL MACHINE MONITORING",false)
-        poll_attrs = {
-            "USED MEMORY" => "MEMORY",
-            "USED CPU" => "CPU",
-            "NET_TX" => "NET_TX",
-            "NET_RX" => "NET_RX"
-        }
 
-        poll_attrs.each { |k,v|
-            if k == "USED CPU"
-                puts str % [k,vm[v]]
-            elsif k == "USED MEMORY"
-                puts str % [k, OpenNebulaHelper.unit_to_str(vm[v].to_i, {})]
+        vm_monitoring = vm.to_hash['VM']['MONITORING']
+
+        order_attrs  = %w(CPU MEMORY NETTX NETRX)
+
+        vm_monitoring_sort = []
+        order_attrs.each do |key|
+            if (val = vm_monitoring.delete(key))
+                vm_monitoring_sort << [key, val]
+            end
+        end
+
+        vm_monitoring_sort.sort{|a,b| a[0]<=>b[0]}
+
+        filter_attrs = %w(STATE DISK_SIZE SNAPSHOT_SIZE)
+        vm_monitoring.each do |key, val|
+            if !filter_attrs.include?(key)
+                vm_monitoring_sort << [key, val]
+            end
+        end
+
+        vm_monitoring_sort.each do |k,v|
+            if k == "MEMORY"
+                puts str % [k, OpenNebulaHelper.unit_to_str(v.to_i, {})]
+            elsif k  =~ /NET.X/
+                puts str % [k, OpenNebulaHelper.unit_to_str(v.to_i/1024, {})]
             else
-                puts str % [k, OpenNebulaHelper.unit_to_str(vm[v].to_i/1024, {})]
+                puts str % [k, v]
             end
-        }
+        end
+
         puts
 
         CLIHelper.print_header(str_h1 % "PERMISSIONS",false)
@@ -341,7 +546,33 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
             puts str % [e,  mask]
         }
 
+        vm_disks = []
+
         if vm.has_elements?("/VM/TEMPLATE/DISK")
+            vm_disks = [vm.to_hash['VM']['TEMPLATE']['DISK']].flatten
+        end
+
+        if vm.has_elements?("/VM/TEMPLATE/CONTEXT")
+            context_disk = vm.to_hash['VM']['TEMPLATE']['CONTEXT']
+
+            context_disk["IMAGE"]     = "CONTEXT"
+            context_disk["DATASTORE"] = "-"
+            context_disk["TYPE"]      = "-"
+            context_disk["READONLY"]  = "-"
+            context_disk["SAVE"]      = "-"
+            context_disk["CLONE"]     = "-"
+            context_disk["SAVE_AS"]   = "-"
+
+            vm_disks.push(context_disk)
+        end
+
+        # get monitoring data
+        vm_disks.each do |disk|
+            disk_id = disk["DISK_ID"]
+            disk["MONITOR_SIZE"] = vm["MONITORING/DISK_SIZE[ID='#{disk_id}']/SIZE"]
+        end
+
+        if !vm_disks.empty?
             puts
             CLIHelper.print_header(str_h1 % "VM DISKS",false)
             CLIHelper::ShowTable.new(nil, self) do
@@ -374,6 +605,30 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                     end
                 end
 
+                column :SIZE, "", :left, :size=>9 do |d|
+                    if d["SIZE"]
+                        size = OpenNebulaHelper.unit_to_str(
+                                    d['SIZE'].to_i,
+                                    {},
+                                    "M"
+                                )
+                    else
+                        size = "-"
+                    end
+
+                    if d["MONITOR_SIZE"]
+                        monitor_size = OpenNebulaHelper.unit_to_str(
+                                    d['MONITOR_SIZE'].to_i,
+                                    {},
+                                    "M"
+                                )
+                    else
+                        monitor_size = "-"
+                    end
+
+                    "#{monitor_size}/#{size}"
+                end
+
                 column :TYPE, "", :left, :size=>4 do |d|
                     d["TYPE"].downcase
                 end
@@ -390,20 +645,21 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                     d["CLONE"]
                 end
 
-                column :"SAVE_AS", "", :size=>7 do |d|
-                    d["SAVE_AS"] || "-"
-                end
-
-
-                default :ID, :TARGET, :IMAGE, :TYPE,
-                    :SAVE, :SAVE_AS
-            end.show([vm.to_hash['VM']['TEMPLATE']['DISK']].flatten, {})
+                default :ID, :DATASTORE, :TARGET, :IMAGE, :SIZE, :TYPE,
+                    :SAVE
+            end.show(vm_disks, {})
 
             while vm.has_elements?("/VM/TEMPLATE/DISK")
                 vm.delete_element("/VM/TEMPLATE/DISK")
             end if !options[:all]
         end
 
+        if vm.has_elements?("/VM/SNAPSHOTS")
+            puts
+            CLIHelper.print_header(str_h1 % "VM DISK SNAPSHOTS",false)
+            format_snapshots(vm)
+        end
+
         sg_nics = []
 
         if (vm.has_elements?("/VM/TEMPLATE/NIC/SECURITY_GROUPS"))
@@ -730,4 +986,91 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
 
         table.show(history)
     end
+
+    def format_snapshots(vm)
+        table=CLIHelper::ShowTable.new(nil, self) do
+            column :AC , "Is active", :left, :size => 2 do |d|
+                if d["ACTIVE"] == "YES"
+                    "=>"
+                else
+                    ""
+                end
+            end
+            column :ID, "Snapshot ID", :size=>3 do |d|
+                d["ID"]
+            end
+
+            column :DISK, "Disk ID", :size=>4 do |d|
+                d["DISK_ID"]
+            end
+
+            column :PARENT, "Snapshot Parent ID", :size=>6 do |d|
+                d["PARENT"]
+            end
+
+            column :CHILDREN, "Snapshot Children IDs", :size=>10 do |d|
+                d["CHILDREN"]
+            end
+
+            column :SIZE, "", :left, :size=>9 do |d|
+                if d["SIZE"]
+                    size = OpenNebulaHelper.unit_to_str(
+                                d['SIZE'].to_i,
+                                {},
+                                "M"
+                            )
+                else
+                    size = "-"
+                end
+
+                if d["MONITOR_SIZE"]
+                    monitor_size = OpenNebulaHelper.unit_to_str(
+                                d['MONITOR_SIZE'].to_i,
+                                {},
+                                "M"
+                            )
+                else
+                    monitor_size = "-"
+                end
+
+                "#{monitor_size}/#{size}"
+            end
+
+            column :NAME, "Snapshot Name", :left, :size=>26 do |d|
+                d["NAME"]
+            end
+
+            column :DATE, "Snapshot creation date", :size=>10 do |d|
+                OpenNebulaHelper.time_to_str(d["DATE"])
+            end
+
+            default :AC, :ID, :DISK, :PARENT, :DATE, :CHILDREN, :SIZE, :NAME
+        end
+
+        # Convert snapshot data to an array
+        vm_hash = vm.to_hash
+        vm_snapshots = [vm_hash['VM']['SNAPSHOTS']].flatten
+
+        snapshots = []
+
+        vm_snapshots.each do |disk|
+            disk_id = disk['DISK_ID']
+
+            sshots = [disk['SNAPSHOT']].flatten
+            sshots.each do |snapshot|
+                data = snapshot.merge({ 'DISK_ID' => disk_id })
+                snapshots << data
+            end
+        end
+
+        # get monitoring data
+        snapshots.each do |snapshot|
+            disk_id = snapshot["DISK_ID"]
+            snap_id = snapshot["ID"]
+            xpath = "MONITORING/SNAPSHOT_SIZE[ID='#{snap_id}' and DISK_ID='#{disk_id}']/SIZE"
+            snapshot["MONITOR_SIZE"] = vm[xpath]
+        end
+
+        table.show(snapshots)
+    end
 end