opennebula-cli 5.8.5 → 5.9.80.pre

data/lib/one_helper/onehost_helper.rb

@@ -636,6 +636,17 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
             print_pcis(pcis)
         end
 
+        begin
+            numa_nodes =
+                host.to_hash['HOST']['HOST_SHARE']['NUMA_NODES']['NODE']
+        rescue StandardError
+            numa_nodes = nil
+        end
+
+        if numa_nodes && !numa_nodes.empty?
+            print_numa_nodes(numa_nodes)
+        end
+
         puts
         CLIHelper.print_header('WILD VIRTUAL MACHINES', false)
         puts
@@ -718,4 +729,193 @@ class OneHostHelper < OpenNebulaHelper::OneHelper
         table.show(pcis)
     end
 
+    def print_numa_nodes(numa_nodes)
+        numa_nodes = get_numa_data(numa_nodes)
+
+        print_numa_cores(numa_nodes)
+        print_numa_memory(numa_nodes)
+        print_numa_hugepages(numa_nodes)
+    end
+
+    def get_numa_data(numa_nodes)
+        numa_nodes = [numa_nodes] if numa_nodes.class == Hash
+
+        numa_nodes.map! do |core|
+            cores = core['CORE']
+
+            free, used, cores_str = get_numa_cores(cores)
+
+            core['CORE'] = {}
+            core['CORE']['CORES'] = cores_str
+            core['CORE']['FREE']  = free
+            core['CORE']['USED']  = used
+
+            core
+        end
+
+        numa_nodes
+    end
+
+    def get_numa_cores(cores)
+        ret  = ''
+        free = 0
+        used = 0
+
+        [cores].flatten.each do |info|
+            core = info['CPUS'].split(',')
+
+            core.uniq! do |c|
+                c = c.split(':')
+                c[0]
+            end
+
+            core.each do |c|
+                c = c.split(':')
+
+                if c[1] == '-1'
+                    ret  += '-'
+                    free += 1
+                elsif c[1] == '-2'
+                    ret  += 'I'
+                    used += 1
+                elsif c[1] != '-1' && info['FREE'] == '0'
+                    ret  += 'X'
+                    used += 1
+                else
+                    ret  += 'x'
+                    used += 1
+                end
+            end
+
+            ret += ' '
+        end
+
+        [free, used, ret]
+    end
+
+    def print_numa_cores(numa_nodes)
+        puts
+        CLIHelper.print_header('NUMA NODES', false)
+        puts
+
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :ID, 'Node ID', :size => 4, :left => false do |d|
+                d['NODE_ID']
+            end
+
+            column :CORES, 'Cores usage',
+                   :left => true,
+                   :adjust => true do |d|
+                d['CORE']['CORES']
+            end
+
+            column :USED, 'Used CPUs', :size => 4, :left => true do |d|
+                d['CORE']['USED']
+            end
+
+            column :FREE, 'Free CPUs', :size => 4, :left => true do |d|
+                d['CORE']['FREE']
+            end
+
+            default :ID, :CORES, :USED, :FREE
+        end
+
+        table.show(numa_nodes)
+    end
+
+    def print_numa_memory(numa_nodes)
+        nodes = numa_nodes.clone
+
+        nodes.reject! do |node|
+            node['MEMORY'].nil? || node['MEMORY'].empty?
+        end
+
+        return if nodes.empty?
+
+        puts
+        CLIHelper.print_header('NUMA MEMORY', false)
+        puts
+
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :NODE_ID, 'Node ID', :size => 8, :left => false do |d|
+                d['NODE_ID']
+            end
+
+            column :TOTAL, 'Total memory', :size => 8, :left => true do |d|
+                OpenNebulaHelper.unit_to_str(d['MEMORY']['TOTAL'].to_i, {})
+            end
+
+            column :USED_REAL, 'Used memory', :size => 20, :left => true do |d|
+                OpenNebulaHelper.unit_to_str(d['MEMORY']['USED'].to_i, {})
+            end
+
+            column :USED_ALLOCATED, 'U memory',
+                   :size => 20, :left => true do |d|
+                OpenNebulaHelper.unit_to_str(d['MEMORY']['USAGE'].to_i, {})
+            end
+
+            column :FREE, 'Free memory', :size => 8, :left => true do |d|
+                OpenNebulaHelper.unit_to_str(d['MEMORY']['FREE'].to_i, {})
+            end
+
+            default :NODE_ID, :TOTAL, :USED_REAL, :USED_ALLOCATED, :FREE
+        end
+
+        table.show(nodes)
+    end
+
+    def print_numa_hugepages(numa_nodes)
+        nodes = numa_nodes.clone
+
+        nodes.reject! do |node|
+            node['HUGEPAGE'].nil? || node['HUGEPAGE'].empty?
+        end
+
+        return if nodes.empty?
+
+        puts
+        CLIHelper.print_header('NUMA HUGEPAGES', false)
+        puts
+
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :NODE_ID, 'Node ID', :size => 8, :left => false do |d|
+                d['NODE_ID']
+            end
+
+            column :TOTAL, 'Total pages', :size => 8, :left => true do |d|
+                d['HUGEPAGE']['PAGES']
+            end
+
+            column :SIZE, 'Pages size', :size => 8, :left => true do |d|
+                OpenNebulaHelper.unit_to_str(d['HUGEPAGE']['SIZE'].to_i / 1024,
+                                             {},
+                                             'M')
+            end
+
+            column :FREE, 'Free pages', :size => 8, :left => true do |d|
+                d['HUGEPAGE']['FREE']
+            end
+
+            column :USED, 'allocated pages', :size => 8, :left => true do |d|
+                d['HUGEPAGE']['USAGE']
+            end
+
+            default :NODE_ID, :SIZE, :TOTAL, :FREE, :USED
+        end
+
+        hugepages = []
+
+        nodes.each do |node|
+            [node['HUGEPAGE']].flatten.each do |hugepage|
+                h             = {}
+                h['NODE_ID']  = node['NODE_ID']
+                h['HUGEPAGE'] = hugepage
+
+                hugepages << h
+            end
+        end
+
+        table.show(hugepages)
+    end
+
 end

data/lib/one_helper/oneimage_helper.rb

@@ -249,6 +249,29 @@ class OneImageHelper < OpenNebulaHelper::OneHelper
         table
     end
 
+    def check_orphans
+        orphans = []
+        xpath = '/VMTEMPLATE_POOL/VMTEMPLATE/TEMPLATE/DISK'
+
+        pool = factory_pool
+        tmpl_pool = OpenNebula::TemplatePool.new(@client, -2)
+
+        pool.info
+        tmpl_pool.info
+
+        pool.each do |img|
+            attrs = { :id    => img['ID'],
+                      :name  => img['NAME'],
+                      :uname => img['UNAME'] }
+
+            orphans << img['ID'] if check_orphan(tmpl_pool,
+                                                 xpath,
+                                                 'IMAGE', attrs)
+        end
+
+        orphans
+    end
+
     private
 
     def factory(id=nil)

data/lib/one_helper/onesecgroup_helper.rb

@@ -157,7 +157,7 @@ class OneSecurityGroupHelper < OpenNebulaHelper::OneHelper
                 d["ICMPV6_TYPE"]
             end
 
-            column :NETWORK, "", :left, :donottruncate, :size=>35 do |d|
+            column :NETWORK, "", :left, :adjust, :size=>35 do |d|
                 network = ""
                 if(!d["NETWORK_ID"].nil? && d["NETWORK_ID"] != "")
                     network += "VNet " + d["NETWORK_ID"]
@@ -185,7 +185,7 @@ class OneSecurityGroupHelper < OpenNebulaHelper::OneHelper
                 network
             end
 
-            column :RANGE, "", :left, :donottruncate, :size=>16 do |d|
+            column :RANGE, "", :left, :adjust, :size=>16 do |d|
                 d["RANGE"]
             end
         end.show(rule_list, {})

data/lib/one_helper/oneuser_helper.rb

@@ -65,9 +65,9 @@ class OneUserHelper < OpenNebulaHelper::OneHelper
             password = OpenNebula::X509Auth.escape_dn(password)
         end
 
-        if options[:sha1] || options[:driver] == OpenNebula::User::CIPHER_AUTH
-            require 'digest/sha1'
-            password = Digest::SHA1.hexdigest(password)
+        if options[:sha256] || options[:driver] == OpenNebula::User::CIPHER_AUTH
+            require 'digest/sha2'
+            password = Digest::SHA256.hexdigest(password)
         end
 
         return 0, password

data/lib/one_helper/onevcenter_helper.rb

@@ -159,7 +159,8 @@ class OneVcenterHelper < OpenNebulaHelper::OneHelper
         {
            :user     => options[:vuser],
            :password => password,
-           :host     => options[:vcenter]
+           :host     => options[:vcenter],
+           :port     => options[:port]
         }
     end
 

data/lib/one_helper/onevm_helper.rb

@@ -13,23 +13,26 @@
 # See the License for the specific language governing permissions and        #
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
+# rubocop:disable Naming/UncommunicativeMethodParamName
 
 if !ONE_LOCATION
-    MAD_LOCATION      = "/usr/lib/one/mads"
-    VAR_LOCATION      = "/var/lib/one"
+    MAD_LOCATION      = '/usr/lib/one/mads'
+    VAR_LOCATION      = '/var/lib/one'
 else
-    MAD_LOCATION      = ONE_LOCATION + "/lib/mads"
-    VAR_LOCATION      = ONE_LOCATION + "/var"
+    MAD_LOCATION      = ONE_LOCATION + '/lib/mads'
+    VAR_LOCATION      = ONE_LOCATION + '/var'
 end
 
-VMS_LOCATION = VAR_LOCATION + "/vms"
+VMS_LOCATION = VAR_LOCATION + '/vms'
 
-$: << MAD_LOCATION
+$LOAD_PATH << MAD_LOCATION
 
 require 'one_helper'
 require 'optparse/time'
 
+# colored strings
 class String
+
     def red
         colorize(31)
     end
@@ -38,183 +41,185 @@ class String
         colorize(32)
     end
 
-private
+    private
 
     def colorize(color_code)
         "\e[#{color_code}m#{self}\e[0m"
     end
-end
 
+end
 
+# Helper methods for OneVM
 class OneVMHelper < OpenNebulaHelper::OneHelper
-    MULTIPLE={
-        :name  => "multiple",
-        :short => "-m x",
-        :large => "--multiple x",
+
+    MULTIPLE = {
+        :name => 'multiple',
+        :short => '-m x',
+        :large => '--multiple x',
         :format => Integer,
-        :description => "Instance multiple VMs"
+        :description => 'Instance multiple VMs'
     }
 
     IMAGE = {
-        :name   => "image",
-        :short  => "-i id|name",
-        :large  => "--image id|name" ,
-        :description => "Selects the image",
+        :name => 'image',
+        :short => '-i id|name',
+        :large => '--image id|name',
+        :description => 'Selects the image',
         :format => String,
-        :proc   => lambda { |o, options|
-            OpenNebulaHelper.rname_to_id(o, "IMAGE")
+        :proc => lambda {|o, _options|
+            OpenNebulaHelper.rname_to_id(o, 'IMAGE')
         }
     }
 
     NETWORK = {
-        :name   => "network",
-        :short  => "-n id|name",
-        :large  => "--network id|name" ,
-        :description => "Selects the virtual network",
+        :name => 'network',
+        :short => '-n id|name',
+        :large => '--network id|name',
+        :description => 'Selects the virtual network',
         :format => String,
-        :proc   => lambda { |o, options|
-            OpenNebulaHelper.rname_to_id(o, "VNET")
+        :proc => lambda {|o, _options|
+            OpenNebulaHelper.rname_to_id(o, 'VNET')
         }
     }
 
-    IP={
-        :name => "ip",
-        :short => "-i ip",
-        :large => "--ip ip",
+    IP = {
+        :name => 'ip',
+        :short => '-i ip',
+        :large => '--ip ip',
         :format => String,
-        :description => "IP address for the new NIC"
+        :description => 'IP address for the new NIC'
     }
 
     FILE = {
-        :name   => "file",
-        :short  => "-f file",
-        :large  => "--file file" ,
-        :description => "Selects the template file",
+        :name => 'file',
+        :short => '-f file',
+        :large => '--file file',
+        :description => 'Selects the template file',
         :format => String,
-        :proc   => lambda { |o, options|
+        :proc => lambda {|o, options|
             if File.file?(o)
                 options[:file] = o
             else
-                exit -1
+                exit - 1
             end
         }
     }
 
     HOLD = {
-        :name  => "hold",
-        :large => "--hold",
-        :description => "Creates the new VM on hold state instead of pending"
+        :name => 'hold',
+        :large => '--hold',
+        :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     => Time
+        :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 => Time
     }
 
     WEEKLY = {
-        :name       => "weekly",
-        :large      => "--weekly days",
-        :description => "Repeats the schedule action the days of the week specified," \
-        "it can be a number between 0,6 separated with commas." \
-        "For example: onevm resume 0 --schedule \"09/23 14:15\" --weekly 0,2,4",
-        :format     => String
+        :name => 'weekly',
+        :large => '--weekly days',
+        :description => 'Repeats the schedule action the days of the week ' \
+        'specified, it can be a number between 0,6 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 0,31 separated with commas." \
-        "For example: onevm resume 0 --schedule \"09/23 14:15\" --monthly 0,14",
-        :format     => String
+        :name => 'monthly',
+        :large => '--monthly days',
+        :description => 'Repeats the schedule action the days of the month ' \
+        'specified, it can be a number between 0,31 separated with commas.' \
+        'For example: onevm resume 0 --schedule "09/23 14:15" --monthly 0,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
+        :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
+        :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
+        :name => 'end',
+        :large => '--end number|TIME',
+        :description => '----',
+        :format => String
     }
 
     ALL_TEMPLATE = {
-        :name       => "all",
-        :large      => "--all",
-        :description => "Show all template data"
+        :name => 'all',
+        :large => '--all',
+        :description => 'Show all template data'
     }
 
     LIVE = {
-        :name        => "live",
-        :large       => "--live",
-        :description => "Do the action with the VM running"
+        :name => 'live',
+        :large => '--live',
+        :description => 'Do the action with the VM running'
     }
 
     HARD = {
-        :name       => "hard",
-        :large      => "--hard",
-        :description=> "Does not communicate with the guest OS"
+        :name => 'hard',
+        :large => '--hard',
+        :description => 'Does not communicate with the guest OS'
     }
 
     POFF = {
-        :name        => "poweroff",
-        :large       => "--poff",
-        :description => "Do the migrate by poweringoff the vm"
+        :name => 'poweroff',
+        :large => '--poff',
+        :description => 'Do the migrate by poweringoff the vm'
     }
 
     POFFHARD = {
-        :name        => "poweroff_hard",
-        :large       => "--poff-hard",
-        :description => "Do the migrate by poweringoff hard the vm"
+        :name => 'poweroff_hard',
+        :large => '--poff-hard',
+        :description => 'Do the migrate by poweringoff hard the vm'
     }
 
     ALIAS = {
-        :name       => "alias",
-        :short      => "-a alias",
-        :large      => "--alias alias",
-        :description=> "Attach the NIC as an ALIAS",
-        :format     => String
+        :name => 'alias',
+        :short => '-a alias',
+        :large => '--alias alias',
+        :description => 'Attach the NIC as an ALIAS',
+        :format => String
     }
 
     NIC_NAME = {
-        :name       => "nic_name",
-        :large      => "--nic_name name",
-        :description=> "Name of the NIC",
-        :format     => String
+        :name => 'nic_name',
+        :large => '--nic_name name',
+        :description => 'Name of the NIC',
+        :format => String
     }
 
     SEARCH = {
-        :name       => "search",
-        :large      => "--search search",
-        :description=> "query in KEY=VALUE format",
-        :format     => String
+        :name => 'search',
+        :large => '--search search',
+        :description => 'query in KEY=VALUE format',
+        :format => String
     }
 
     def self.rname
-        "VM"
+        'VM'
     end
 
     def self.conf_file
-        "onevm.yaml"
+        'onevm.yaml'
     end
 
     def self.state_to_str(id, lcm_id)
@@ -222,13 +227,13 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         state_str = VirtualMachine::VM_STATE[id]
         short_state_str = VirtualMachine::SHORT_VM_STATES[state_str]
 
-        if short_state_str=="actv"
+        if short_state_str == 'actv'
             lcm_id = lcm_id.to_i
             lcm_state_str = VirtualMachine::LCM_STATE[lcm_id]
             return VirtualMachine::SHORT_LCM_STATES[lcm_state_str]
         end
 
-        return short_state_str
+        short_state_str
     end
 
     # Return the IP or several IPs of a VM
@@ -237,48 +242,61 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
 
         vm_nics = []
 
-        if !vm["TEMPLATE"]["NIC"].nil?
-            vm_nics = [vm["TEMPLATE"]['NIC']].flatten
+        if !vm['TEMPLATE']['NIC'].nil?
+            vm_nics = [vm['TEMPLATE']['NIC']].flatten
         end
 
-        if !vm["TEMPLATE"]["PCI"].nil?
-            vm_nics = [vm_nics, vm["TEMPLATE"]['PCI']].flatten
+        if !vm['TEMPLATE']['PCI'].nil?
+            vm_nics = [vm_nics, vm['TEMPLATE']['PCI']].flatten
         end
 
         vm_nics.each do |nic|
-            ["IP", "IP6_GLOBAL", "IP6_ULA", "IP6",
-             "VROUTER_IP", "VROUTER_IP6_GLOBAL", "VROUTER_IP6_ULA"].each do |attr|
-                if nic.has_key?(attr)
+            %w[IP IP6_GLOBAL IP6_ULA IP6
+               VROUTER_IP VROUTER_IP6_GLOBAL VROUTER_IP6_ULA].each do |attr|
+                if nic.key?(attr)
                     ips.push(nic[attr])
                 end
             end
         end
 
         VirtualMachine::EXTERNAL_IP_ATTRS.each do |attr|
-            external_ip = vm["MONITORING"][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
+        return '--' if ips.empty?
+
+        ips.join(',')
     end
 
     def retrieve_snapshot_id(vm_id, id)
+        return [0, id.to_i] if id =~ /\A\d+\z/
+
         vm = retrieve_resource(vm_id)
         vm.info
 
-        if !/\A\d+\z/.match(id)
-            ids = vm.retrieve_elements("/VM/TEMPLATE/SNAPSHOT[NAME='#{id}']/SNAPSHOT_ID")
-            return [-1, "#{id} not found or duplicated"] if ids.nil? || ids.size > 1
-        else
-            return [0, id.to_i]
-        end
+        ids = vm.retrieve_elements(
+            "/VM/TEMPLATE/SNAPSHOT[NAME='#{id}']/SNAPSHOT_ID"
+        )
+
+        return [-1, "#{id} not found or duplicated"] \
+                if ids.nil? || ids.size > 1
+
+        [0, ids[0].to_i]
+    end
+
+    def retrieve_disk_snapshot_id(vm_id, id)
+        return [0, id.to_i] if id =~ /\A\d+\z/
+
+        vm = retrieve_resource(vm_id)
+        vm.info
+        ids = vm.retrieve_elements("/VM/SNAPSHOTS/SNAPSHOT[NAME='#{id}']/ID")
+
+        return [-1, "#{id} not found or duplicated"] \
+                if ids.nil? || ids.size > 1
 
         [0, ids[0].to_i]
     end
@@ -291,67 +309,69 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
         rc = cluster_pool.info
 
         cluster_names = {}
-        cluster_names["-1"] = "default"
+        cluster_names['-1'] = 'default'
 
         if !OpenNebula.is_error?(rc)
             cluster_pool.each do |c|
-                cluster_names[c["ID"]] = c["NAME"]
+                cluster_names[c['ID']] = c['NAME']
             end
         end
 
         table = CLIHelper::ShowTable.new(config_file, self) do
-            column :ID, "ONE identifier for Virtual Machine", :size=>6 do |d|
-                d["ID"]
+            column :ID, 'ONE identifier for Virtual Machine', :size => 6 do |d|
+                d['ID']
             end
 
-            column :NAME, "Name of the Virtual Machine", :left,
-                    :size=>15 do |d|
-                if d["RESCHED"] == "1"
-                    "*#{d["NAME"]}"
+            column :NAME, 'Name of the Virtual Machine', :left,
+                   :size => 15 do |d|
+                if d['RESCHED'] == '1'
+                    "*#{d['NAME']}"
                 else
-                    d["NAME"]
+                    d['NAME']
                 end
             end
 
-            column :USER, "Username of the Virtual Machine owner", :left,
-                    :size=>8 do |d|
+            column :USER, 'Username of the Virtual Machine owner', :left,
+                   :size => 8 do |d|
                 helper.user_name(d, options)
             end
 
-            column :GROUP, "Group of the Virtual Machine", :left,
-                    :size=>8 do |d|
+            column :GROUP, 'Group of the Virtual Machine', :left,
+                   :size => 8 do |d|
                 helper.group_name(d, options)
             end
 
-            column :STAT, "Actual status", :size=>4 do |d,e|
-                OneVMHelper.state_to_str(d["STATE"], d["LCM_STATE"])
+            column :STAT, 'Actual status', :size => 4 do |d, _e|
+                OneVMHelper.state_to_str(d['STATE'], d['LCM_STATE'])
             end
 
-            column :UCPU, "CPU percentage used by the VM", :size=>4 do |d|
-                cpu = d["MONITORING"]["CPU"]
-                cpu = "0" if cpu.nil?
+            column :UCPU, 'CPU percentage used by the VM', :size => 4 do |d|
+                cpu = d['MONITORING']['CPU']
+                cpu = '0' if cpu.nil?
 
                 cpu
             end
 
-            column :UMEM, "Memory used by the VM", :size=>7 do |d|
-                OpenNebulaHelper.unit_to_str(d["MONITORING"]["MEMORY"].to_i, options)
+            column :UMEM, 'Memory used by the VM', :size => 7 do |d|
+                OpenNebulaHelper.unit_to_str(d['MONITORING']['MEMORY'].to_i,
+                                             options)
             end
 
-            column :HOST, "Host where the VM is running", :left, :size=>10 do |d|
+            column :HOST, 'Host where the VM is running',
+                   :left, :size => 10 do |d|
                 if d['HISTORY_RECORDS'] && d['HISTORY_RECORDS']['HISTORY']
                     state_str = VirtualMachine::VM_STATE[d['STATE'].to_i]
-                    if %w{ACTIVE SUSPENDED POWEROFF}.include? state_str
+                    if %w[ACTIVE SUSPENDED POWEROFF].include? state_str
                         d['HISTORY_RECORDS']['HISTORY']['HOSTNAME']
                     end
                 end
             end
 
-            column :CLUSTER, "Cluster where the VM is running", :left,
-                    :size=> 10 do |d|
-                if d["HISTORY_RECORDS"]["HISTORY"]
-                    history = [d["HISTORY_RECORDS"]["HISTORY"]].flatten
-                    cluster_id = history.last["CID"]
+            column :CLUSTER, 'Cluster where the VM is running', :left,
+                   :size => 10 do |d|
+                if d['HISTORY_RECORDS']['HISTORY']
+                    history = [d['HISTORY_RECORDS']['HISTORY']].flatten
+                    cluster_id = history.last['CID']
                     cluster = cluster_names[cluster_id]
 
                     if !cluster
@@ -360,38 +380,38 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
                         cluster
                     end
                 else
-                    "NONE"
+                    'NONE'
                 end
             end
 
-            column :TIME, "Time since the VM was submitted", :size=>10 do |d|
-                stime = d["STIME"].to_i
-                etime = d["ETIME"]=="0" ? Time.now.to_i : d["ETIME"].to_i
-                dtime = etime-stime
+            column :TIME, 'Time since the VM was submitted', :size => 10 do |d|
+                stime = d['STIME'].to_i
+                etime = d['ETIME'] == '0' ? Time.now.to_i : d['ETIME'].to_i
+                dtime = etime - stime
                 OpenNebulaHelper.period_to_str(dtime, false)
             end
 
-            column :IP, "VM IP addresses", :left, :donottruncate, :size=>15 do |d|
+            column :IP, 'VM IP addresses', :left, :adjust, :size => 15 do |d|
                 OneVMHelper.ip_str(d)
             end
 
             default :ID, :USER, :GROUP, :NAME, :STAT, :UCPU, :UMEM, :HOST,
-                :TIME
+                    :TIME
         end
 
         table
     end
 
-
-    def schedule_actions(ids,options,action)
+    def schedule_actions(ids, options, action)
         # Verbose by default
         options[:verbose] = true
 
         perform_actions(
             ids, options,
-            "#{action} scheduled at #{options[:schedule]}") do |vm|
+            "#{action} scheduled at #{options[:schedule]}"
+        ) do |vm|
 
-            str_periodic = ""
+            str_periodic = ''
 
             if options.key?(:weekly)
                 str_periodic << ", REPEAT = 0, DAYS = \"#{options[:weekly]}\""
@@ -400,56 +420,61 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
             elsif options.key?(:yearly)
                 str_periodic << ", REPEAT = 2, DAYS = \"#{options[:yearly]}\""
             elsif options.key?(:hourly)
-                str_periodic << ", REPEAT = 3, DAYS = \"#{options[:hourly].to_s}\""
+                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}"
+                    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}"
+                        str_periodic << ', END_TYPE = 1, ' \
+                            "END_VALUE = #{options[:end].to_i}"
                     end
                 end
-            elsif str_periodic != ""
-                str_periodic << ", END_TYPE = 0"
+            elsif str_periodic != ''
+                str_periodic << ', END_TYPE = 0'
             end
 
             rc = vm.info
 
             if OpenNebula.is_error?(rc)
                 puts rc.message
-                exit -1
+                exit(-1)
             end
 
             ids = vm.retrieve_elements('USER_TEMPLATE/SCHED_ACTION/ID')
 
             id = 0
-            if (!ids.nil? && !ids.empty?)
+            if !ids.nil? && !ids.empty?
                 ids.map! {|e| e.to_i }
                 id = ids.max + 1
             end
 
             tmp_str = vm.user_template_str
 
-            tmp_str << "\nSCHED_ACTION = [ID = #{id}, ACTION = #{action}, TIME = #{options[:schedule].to_i}" << str_periodic << "]"
+            tmp_str << "\nSCHED_ACTION = "
+            tmp_str << "[ID = #{id}, ACTION = #{action}, "
+            tmp_str << "TIME = #{options[:schedule].to_i}"
+            tmp_str << str_periodic << ']'
 
             vm.update(tmp_str)
         end
     end
 
     RECOVER_RETRY_STEPS = {
-        :PROLOG_MIGRATE_FAILURE          => :migrate,
+        :PROLOG_MIGRATE_FAILURE => :migrate,
         :PROLOG_MIGRATE_POWEROFF_FAILURE => :migrate,
-        :PROLOG_MIGRATE_SUSPEND_FAILURE  => :migrate,
-        :PROLOG_MIGRATE_UNKNOWN_FAILURE  => :migrate,
-        :PROLOG_FAILURE                  => :prolog,
-        :PROLOG_RESUME_FAILURE           => :resume,
-        :PROLOG_UNDEPLOY_FAILURE         => :resume,
-        :EPILOG_FAILURE                  => :epilog,
-        :EPILOG_STOP_FAILURE             => :stop,
-        :EPILOG_UNDEPLOY_FAILURE         => :stop
+        :PROLOG_MIGRATE_SUSPEND_FAILURE => :migrate,
+        :PROLOG_MIGRATE_UNKNOWN_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)
@@ -457,32 +482,32 @@ class OneVMHelper < OpenNebulaHelper::OneHelper
             require 'one_tm'
         rescue LoadError
             STDERR.puts <<-EOT
-one_tm library not found. Make sure you execute recover --interactive
-in the frontend machine.
+    one_tm library not found. Make sure you execute recover --interactive
+    in the frontend machine.
             EOT
             exit(-1)
         end
 
         # Disable CTRL-C in the menu
-        trap("SIGINT") { }
+        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
+        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
+            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
+            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']
@@ -493,27 +518,27 @@ in the frontend machine.
 
         if !File.readable?(tm_file)
             STDERR.puts "Cannot read #{tm_file}"
-            exit -1
+            exit(-1)
         end
 
         @tm_action_list = File.read(tm_file)
 
-        puts "TM Debug Interactive Environment.".green
+        puts 'TM Debug Interactive Environment.'.green
         puts
         print_tm_action_list
 
         @tm = TransferManagerDriver.new(nil)
-        i=0
+        i = 0
         @tm_action_list.lines.each do |tm_command|
-            i+=1
-            success=false
+            i += 1
+            success = false
 
-            while !success
+            until success
                 puts "Current action (#{i}):".green
                 puts tm_command
                 puts
 
-                puts <<-EOF.gsub(/^\s+/,"")
+                puts <<-EOF.gsub(/^\s+/, '')
                 Choose action:
                 (r) Run action
                 (n) Skip to next action
@@ -521,47 +546,46 @@ in the frontend machine.
                 (q) Quit
                 EOF
 
-                ans = ""
-                while !%w(n a r q).include?(ans)
-                    printf "> "
+                ans = ''
+                until %w[n a r q].include?(ans)
+                    printf '> '
                     ans = STDIN.gets.strip.downcase
 
                     puts
 
                     case ans
-                    when "n"
+                    when 'n'
                         success = true
-                    when "a"
+                    when 'a'
                         print_tm_action_list
-                    when "q"
-                        exit -1
-                    when "r"
-                        result, result_message = @tm.do_transfer_action(@id, tm_command.split)
+                    when 'q'
+                        exit(-1)
+                    when 'r'
+                        result, = @tm.do_transfer_action(@id, tm_command.split)
 
-                        if result == "SUCCESS"
+                        if result == 'SUCCESS'
                             success = true
-                            puts "#{result}"
-                            puts
+                            puts result.to_s
                         else
                             puts
                             puts "#{result}. Repeat command.".red
-                            puts
                         end
+                        puts
                     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"
+        puts 'If all the TM actions have been successful and you want to'
+        puts 'recover the Virtual Machine to the RUNNING state execute this '
+        puts "command $ onevm recover #{vm.id} --success"
     end
 
     def print_tm_action_list
-        puts "TM Action list:".green
-        i=0
+        puts 'TM Action list:'.green
+        i = 0
         @tm_action_list.lines.each do |line|
-            i+=1
+            i += 1
             puts "(#{i}) #{line}"
         end
         puts
@@ -569,96 +593,102 @@ in the frontend machine.
 
     def get_migration_type(options)
         if options[:poweroff]
-            return 1
+            1
         elsif options[:poweroff_hard]
-            return 2
+            2
         else
-            return 0
+            0
         end
     end
 
     private
 
-    def factory(id=nil)
+    def factory(id = nil)
         if id
             OpenNebula::VirtualMachine.new_with_id(id, @client)
         else
-            xml=OpenNebula::VirtualMachine.build_xml
+            xml = OpenNebula::VirtualMachine.build_xml
             OpenNebula::VirtualMachine.new(xml, @client)
         end
     end
 
-    def factory_pool(user_flag=-2)
+    def factory_pool(user_flag = -2)
         OpenNebula::VirtualMachinePool.new(@client, user_flag)
     end
 
     def format_resource(vm, options = {})
-        str_h1="%-80s"
-        str="%-20s: %-20s"
+        str_h1 = '%-80s'
+        str = '%-20s: %-20s'
 
         cluster = nil
 
         vm_hash = vm.to_hash
 
-        if %w{ACTIVE SUSPENDED POWEROFF}.include? vm.state_str
+        if %w[ACTIVE SUSPENDED POWEROFF].include? vm.state_str
             cluster_id = vm['/VM/HISTORY_RECORDS/HISTORY[last()]/CID']
         else
             cluster_id = nil
         end
 
         if cluster_id
-            if cluster_id == "-1"
-                cluster = "default"
+            if cluster_id == '-1'
+                cluster = 'default'
             else
-                clu = OpenNebula::Cluster.new(OpenNebula::Cluster.build_xml(cluster_id), @client)
+                clu = OpenNebula::Cluster.new(
+                    OpenNebula::Cluster.build_xml(cluster_id), @client
+                )
                 rc = clu.info
                 if OpenNebula.is_error?(rc)
-                    cluster = "ERROR"
+                    cluster = 'ERROR'
                 else
-                    cluster = clu["NAME"]
+                    cluster = clu['NAME']
                 end
             end
         end
 
         CLIHelper.print_header(
-            str_h1 % "VIRTUAL MACHINE #{vm['ID']} INFORMATION")
-        puts str % ["ID", vm.id.to_s]
-        puts str % ["NAME", vm.name]
-        puts str % ["USER", vm['UNAME']]
-        puts str % ["GROUP", vm['GNAME']]
-        puts str % ["STATE", vm.state_str]
-        puts str % ["LCM_STATE", vm.lcm_state_str]
-        puts str % ["LOCK", OpenNebulaHelper.level_lock_to_str(vm['LOCK/LOCKED'])]
-        puts str % ["RESCHED", OpenNebulaHelper.boolean_to_str(vm['RESCHED'])]
-        puts str % ["HOST",
-            vm['/VM/HISTORY_RECORDS/HISTORY[last()]/HOSTNAME']] if
-                %w{ACTIVE SUSPENDED POWEROFF}.include? vm.state_str
-        puts str % ["CLUSTER ID", cluster_id ] if cluster_id
-        puts str % ["CLUSTER", cluster ] if cluster
-        puts str % ["START TIME",
-            OpenNebulaHelper.time_to_str(vm['/VM/STIME'])]
-        puts str % ["END TIME",
-            OpenNebulaHelper.time_to_str(vm['/VM/ETIME'])]
-        value=vm['DEPLOY_ID']
-        puts str % ["DEPLOY ID", value=="" ? "-" : value]
-        value=vm['TEMPLATE/VROUTER_ID']
-        puts str % ["VIRTUAL ROUTER ID", value] if value
+            str_h1 % "VIRTUAL MACHINE #{vm['ID']} INFORMATION"
+        )
+        puts format(str, 'ID', vm.id.to_s)
+        puts format(str, 'NAME', vm.name)
+        puts format(str, 'USER', vm['UNAME'])
+        puts format(str, 'GROUP', vm['GNAME'])
+        puts format(str, 'STATE', vm.state_str)
+        puts format(str, 'LCM_STATE', vm.lcm_state_str)
+        puts format(str, 'LOCK',
+                    OpenNebulaHelper.level_lock_to_str(vm['LOCK/LOCKED']))
+        puts format(str, 'RESCHED',
+                    OpenNebulaHelper.boolean_to_str(vm['RESCHED']))
+        if %w[ACTIVE SUSPENDED POWEROFF].include? vm.state_str
+            puts format(str, 'HOST',
+                        vm['/VM/HISTORY_RECORDS/HISTORY[last()]/HOSTNAME'])
+        end
+        puts format(str, 'CLUSTER ID', cluster_id) if cluster_id
+        puts format(str, 'CLUSTER', cluster) if cluster
+        puts format(str, 'START TIME',
+                    OpenNebulaHelper.time_to_str(vm['/VM/STIME']))
+        puts format(str, 'END TIME',
+                    OpenNebulaHelper.time_to_str(vm['/VM/ETIME']))
+        value = vm['DEPLOY_ID']
+        puts format(str, 'DEPLOY ID', value == '' ? '-' : value)
+        value = vm['TEMPLATE/VROUTER_ID']
+        puts format(str, 'VIRTUAL ROUTER ID', value) if value
 
         puts
 
-        CLIHelper.print_header(str_h1 % "VIRTUAL MACHINE MONITORING",false)
+        CLIHelper.print_header(str_h1 % 'VIRTUAL MACHINE MONITORING', false)
 
         vm_monitoring = vm_hash['VM']['MONITORING']
 
-        # Find out if it is a hybrid VM to avoid showing local IPs
-        isHybrid=false
-        vm_monitoring.each{|key, value|
+        # Find out if it is a hybrid VM to avoid showing local IPs
+        is_hybrid = false
+        vm_monitoring.each do |key, _value|
             if VirtualMachine::EXTERNAL_IP_ATTRS.include? key
-                isHybrid=true
+                is_hybrid = true
             end
-        }
+        end
 
-        order_attrs  = %w(CPU MEMORY NETTX NETRX)
+        order_attrs = %w[CPU MEMORY NETTX NETRX]
 
         vm_monitoring_sort = []
         order_attrs.each do |key|
@@ -667,156 +697,159 @@ in the frontend machine.
             end
         end
 
-        vm_monitoring_sort.sort{|a,b| a[0]<=>b[0]}
+        vm_monitoring_sort.sort_by {|a| a[0] }
 
-        filter_attrs = %w(STATE DISK_SIZE SNAPSHOT_SIZE)
+        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, {})]
+        vm_monitoring_sort.each do |k, v|
+            if k == 'MEMORY'
+                puts format(str, k, OpenNebulaHelper.unit_to_str(v.to_i, {}))
+            elsif k =~ /NET.X/
+                puts format(str, k,
+                            OpenNebulaHelper.unit_to_str(v.to_i / 1024, {}))
             else
-                puts str % [k, v]
+                puts format(str, k, v)
             end
         end
 
         puts
 
-        CLIHelper.print_header(str_h1 % "PERMISSIONS",false)
+        CLIHelper.print_header(str_h1 % 'PERMISSIONS', false)
 
-        ["OWNER", "GROUP", "OTHER"].each { |e|
-            mask = "---"
-            mask[0] = "u" if vm["PERMISSIONS/#{e}_U"] == "1"
-            mask[1] = "m" if vm["PERMISSIONS/#{e}_M"] == "1"
-            mask[2] = "a" if vm["PERMISSIONS/#{e}_A"] == "1"
+        %w[OWNER GROUP OTHER].each do |e|
+            mask = '---'
+            mask[0] = 'u' if vm["PERMISSIONS/#{e}_U"] == '1'
+            mask[1] = 'm' if vm["PERMISSIONS/#{e}_M"] == '1'
+            mask[2] = 'a' if vm["PERMISSIONS/#{e}_A"] == '1'
 
-            puts str % [e,  mask]
-        }
+            puts format(str, e, mask)
+        end
 
         vm_disks = []
 
-        if vm.has_elements?("/VM/TEMPLATE/DISK")
+        if vm.has_elements?('/VM/TEMPLATE/DISK')
             vm_disks = [vm_hash['VM']['TEMPLATE']['DISK']].flatten
         end
 
-        if vm.has_elements?("/VM/TEMPLATE/CONTEXT") && vm["/VM/HISTORY_RECORDS/HISTORY[1]/VM_MAD"] != 'vcenter'
+        if vm.has_elements?('/VM/TEMPLATE/CONTEXT') \
+                && vm['/VM/HISTORY_RECORDS/HISTORY[1]/VM_MAD'] != 'vcenter'
             context_disk = vm_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"]   = "-"
+            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"]
+            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.print_header(str_h1 % 'VM DISKS', false)
             CLIHelper::ShowTable.new(nil, self) do
-                column :ID, "", :size=>3 do |d|
-                    d["DISK_ID"]
+                column :ID, '', :size => 3 do |d|
+                    d['DISK_ID']
                 end
 
-                column :DATASTORE, "", :left, :size=>10 do |d|
-                    d["DATASTORE"]
+                column :DATASTORE, '', :left, :size => 10 do |d|
+                    d['DATASTORE']
                 end
 
-                column :TARGET, "", :left, :size=>6 do |d|
-                    d["TARGET"]
+                column :TARGET, '', :left, :size => 6 do |d|
+                    d['TARGET']
                 end
 
-                column :IMAGE, "", :left, :size=>35 do |d|
-                    if d["IMAGE"]
-                        d["IMAGE"]
-                    else
-                        case d["TYPE"].upcase
-                        when "FS"
-                            "#{d["FORMAT"]} - "<<
-                            OpenNebulaHelper.unit_to_str(d["SIZE"].to_i,
-                                                         {}, "M")
-                        when "SWAP"
-                            OpenNebulaHelper.unit_to_str(d["SIZE"].to_i,
-                                                         {}, "M")
-
-                        end
-                    end
+                # rubocop:disable Metrics/LineLength
+                column :IMAGE, '', :left, :size => 35 do |d|
+                    d['IMAGE'] || case d['TYPE'].upcase
+                                  when 'FS'
+                                      "#{d['FORMAT']} - " <<
+                                          OpenNebulaHelper.unit_to_str(d['SIZE'].to_i,
+                                                                       {}, 'M')
+                                  when 'SWAP'
+                                      OpenNebulaHelper.unit_to_str(d['SIZE'].to_i,
+                                                                   {}, 'M')
+
+                                  end
                 end
+                # rubocop:enable Metrics/LineLength
 
-                column :SIZE, "", :left, :size=>9 do |d|
-                    if d["SIZE"]
+                column :SIZE, '', :left, :size => 9 do |d|
+                    if d['SIZE']
                         size = OpenNebulaHelper.unit_to_str(
-                                    d['SIZE'].to_i,
-                                    {},
-                                    "M"
-                                )
+                            d['SIZE'].to_i,
+                            {},
+                            'M'
+                        )
                     else
-                        size = "-"
+                        size = '-'
                     end
 
-                    if d["MONITOR_SIZE"]
+                    if d['MONITOR_SIZE']
                         monitor_size = OpenNebulaHelper.unit_to_str(
-                                    d['MONITOR_SIZE'].to_i,
-                                    {},
-                                    "M"
-                                )
+                            d['MONITOR_SIZE'].to_i,
+                            {},
+                            'M'
+                        )
                     else
-                        monitor_size = "-"
+                        monitor_size = '-'
                     end
 
                     "#{monitor_size}/#{size}"
                 end
 
-                column :TYPE, "", :left, :size=>4 do |d|
-                    d["TYPE"].downcase
+                column :TYPE, '', :left, :size => 4 do |d|
+                    d['TYPE'].downcase
                 end
 
-                column :"R/O", "", :size=>3 do |d|
-                    d["READONLY"]
+                column :"R/O", '', :size => 3 do |d|
+                    d['READONLY']
                 end
 
-                column :"SAVE", "", :size=>4 do |d|
-                    d["SAVE"] || "NO"
+                column :SAVE, '', :size => 4 do |d|
+                    d['SAVE'] || 'NO'
                 end
 
-                column :"CLONE", "", :size=>5 do |d|
-                    d["CLONE"]
+                column :CLONE, '', :size => 5 do |d|
+                    d['CLONE']
                 end
 
                 default :ID, :DATASTORE, :TARGET, :IMAGE, :SIZE, :TYPE,
-                    :SAVE
+                        :SAVE
             end.show(vm_disks, {})
 
-            while vm.has_elements?("/VM/TEMPLATE/DISK")
-                vm.delete_element("/VM/TEMPLATE/DISK")
-            end if !options[:all]
+            if !options[:all]
+                while vm.has_elements?('/VM/TEMPLATE/DISK')
+                    vm.delete_element('/VM/TEMPLATE/DISK')
+                end
+            end
         end
 
-        if vm.has_elements?("/VM/SNAPSHOTS")
+        if vm.has_elements?('/VM/SNAPSHOTS')
             puts
-            CLIHelper.print_header(str_h1 % "VM DISK SNAPSHOTS",false)
+            CLIHelper.print_header(str_h1 % 'VM DISK SNAPSHOTS', false)
             format_snapshots(vm)
         end
 
         sg_nics = []
 
-        if (vm.has_elements?("/VM/TEMPLATE/NIC/SECURITY_GROUPS") ||
-            vm.has_elements?("/VM/TEMPLATE/PCI[NIC_ID>-1]/SECURITY_GROUPS"))
+        if vm.has_elements?('/VM/TEMPLATE/NIC/SECURITY_GROUPS') ||
+           vm.has_elements?('/VM/TEMPLATE/PCI[NIC_ID>-1]/SECURITY_GROUPS')
 
             sg_nics = [vm_hash['VM']['TEMPLATE']['NIC']]
 
@@ -838,465 +871,558 @@ in the frontend machine.
         # array. Duplicate IPs are not shown.
         extra_ips = []
 
-        if val=vm["/VM/MONITORING/GUEST_IP"]
+        if (val = vm['/VM/MONITORING/GUEST_IP'])
             extra_ips << val if val && !val.empty?
         end
 
-        if val=vm["/VM/MONITORING/GUEST_IP_ADDRESSES"]
+        if (val = vm['/VM/MONITORING/GUEST_IP_ADDRESSES'])
             extra_ips += val.split(',') if val && !val.empty?
         end
 
         extra_ips.uniq!
 
-        ['NIC', 'NIC_ALIAS'].each do |type|
-            if vm.has_elements?("/VM/TEMPLATE/#{type}") ||
-               vm.has_elements?("/VM/TEMPLATE/PCI[NIC_ID>-1]") || !extra_ips.empty?
+        %w[NIC NIC_ALIAS].each do |type|
+            next unless vm.has_elements?("/VM/TEMPLATE/#{type}") ||
+                        vm.has_elements?('/VM/TEMPLATE/PCI[NIC_ID>-1]') ||
+                        !extra_ips.empty?
 
-                puts
-                CLIHelper.print_header(str_h1 % "VM #{type == 'NIC' ? 'NICS' : 'ALIAS'}",false)
+            puts
+            CLIHelper.print_header(
+                str_h1 % "VM #{type == 'NIC' ? 'NICS' : 'ALIAS'}", false
+            )
 
-                nic_default = {"NETWORK" => "-",
-                               "IP" => "-",
-                               "MAC"=> "-",
-                               "BRIDGE"=>"-"}
+            nic_default = { 'NETWORK' => '-',
+                            'IP' => '-',
+                            'MAC' => '-',
+                            'BRIDGE' => '-' }
 
-                shown_ips = []
+            shown_ips = []
 
-                array_id = 0
-                vm_nics = [vm_hash['VM']['TEMPLATE'][type]]
+            array_id = 0
+            vm_nics = [vm_hash['VM']['TEMPLATE'][type]]
 
-                if type == 'NIC'
-                    vm_pcis = [vm_hash['VM']['TEMPLATE']['PCI']].flatten.compact
+            if type == 'NIC'
+                vm_pcis = [vm_hash['VM']['TEMPLATE']['PCI']].flatten.compact
 
-                    vm_pcis.each do |pci|
-                        if !pci['NIC_ID'].nil?
-                            vm_nics << pci
-                        end
+                vm_pcis.each do |pci|
+                    if !pci['NIC_ID'].nil?
+                        vm_nics << pci
                     end
                 end
+            end
 
-                vm_nics.flatten!
-                vm_nics.compact!
+            vm_nics.flatten!
+            vm_nics.compact!
 
-                vm_nics.each {|nic|
+            vm_nics.each do |nic|
+                next if nic.key?('CLI_DONE')
 
-                    next if nic.has_key?("CLI_DONE")
+                %w[IP6_LINK IP6_ULA IP6_GLOBAL IP6].each do |attr|
+                    next unless nic.key?(attr)
 
-                    ["IP6_LINK", "IP6_ULA", "IP6_GLOBAL", "IP6"].each do |attr|
-                        if nic.has_key?(attr)
-                            shown_ips << nic[attr]
+                    shown_ips << nic[attr]
 
-                            ipstr = {"IP"           => nic.delete(attr),
-                                     "CLI_DONE"     => true,
-                                     "DOUBLE_ENTRY" => true}
-                            vm_nics.insert(array_id+1,ipstr)
+                    ipstr = { 'IP' => nic.delete(attr),
+                              'CLI_DONE' => true,
+                              'DOUBLE_ENTRY' => true }
+                    vm_nics.insert(array_id + 1, ipstr)
 
-                            array_id += 1
-                        end
-                    end
+                    array_id += 1
+                end
 
-                    ["VROUTER_IP", "VROUTER_IP6_LINK",
-                     "VROUTER_IP6_ULA", "VROUTER_IP6_GLOBAL"].each do |attr|
-                        if nic.has_key?(attr)
-                            shown_ips << nic[attr]
+                %w[VROUTER_IP VROUTER_IP6_LINK
+                   VROUTER_IP6_ULA VROUTER_IP6_GLOBAL].each do |attr|
+                    next unless nic.key?(attr)
 
-                            ipstr = {"IP"           => nic.delete(attr) + " (VRouter)",
-                                     "CLI_DONE"     => true,
-                                     "DOUBLE_ENTRY" => true}
-                            vm_nics.insert(array_id+1,ipstr)
+                    shown_ips << nic[attr]
 
-                            array_id += 1
-                        end
-                    end
+                    ipstr = { 'IP' => nic.delete(attr) + ' (VRouter)',
+                              'CLI_DONE' => true,
+                              'DOUBLE_ENTRY' => true }
+                    vm_nics.insert(array_id + 1, ipstr)
 
-                    shown_ips << nic["IP"] if nic.has_key?("IP")
-
-                    nic.merge!(nic_default) {|k,v1,v2| v1}
                     array_id += 1
-                }
+                end
 
-                extra_ips -= shown_ips
+                shown_ips << nic['IP'] if nic.key?('IP')
 
-                # Add extra IPs to the VM NICS table
-                extra_ips.each do |ip|
-                    vm_nics << {
-                        "NIC_ID"        => "-",
-                        "IP"            => ip,
-                        "NETWORK"       => "Additional IP",
-                        "BRIDGE"        => "-"
-                    }
-                end
+                nic.merge!(nic_default) {|_k, v1, _v2| v1 }
+                array_id += 1
+            end
 
-                CLIHelper::ShowTable.new(nil, self) do
-                    column :ID, "", :size=>3 do |d|
-                        if d["DOUBLE_ENTRY"]
-                            ""
-                        else
-                            d["NIC_ID"]
-                        end
-                    end
+            extra_ips -= shown_ips
 
-                    column :NETWORK, "", :left, :size=>20 do |d|
-                        if d["DOUBLE_ENTRY"]
-                            ""
-                        else
-                            d["NETWORK"]
-                        end
+            # Add extra IPs to the VM NICS table
+            extra_ips.each do |ip|
+                vm_nics << {
+                    'NIC_ID' => '-',
+                    'IP' => ip,
+                    'NETWORK' => 'Additional IP',
+                    'BRIDGE' => '-'
+                }
+            end
+
+            CLIHelper::ShowTable.new(nil, self) do
+                column :ID, '', :size => 3 do |d|
+                    if d['DOUBLE_ENTRY']
+                        ''
+                    else
+                        d['NIC_ID']
                     end
+                end
 
-                    column :BRIDGE, "", :left, :size=>12 do |d|
-                        if d["DOUBLE_ENTRY"]
-                            ""
-                        else
-                            d["BRIDGE"]
-                        end
+                column :NETWORK, '', :left, :size => 20 do |d|
+                    if d['DOUBLE_ENTRY']
+                        ''
+                    else
+                        d['NETWORK']
                     end
+                end
 
-                    column :IP, "",:left, :donottruncate, :size=>15 do |d|
-                        d["IP"]
+                column :BRIDGE, '', :left, :size => 12 do |d|
+                    if d['DOUBLE_ENTRY']
+                        ''
+                    else
+                        d['BRIDGE']
                     end
+                end
 
-                    column :MAC, "", :left, :size=>17 do |d|
-                        if d["DOUBLE_ENTRY"]
-                            ""
-                        else
-                            d["MAC"]
-                        end
+                column :IP, '', :left, :adjust, :size => 15 do |d|
+                    d['IP']
+                end
+
+                column :MAC, '', :left, :size => 17 do |d|
+                    if d['DOUBLE_ENTRY']
+                        ''
+                    else
+                        d['MAC']
                     end
+                end
 
-                    if type == 'NIC'
-                        column :PCI_ID, "", :left, :size=>8 do |d|
-                            if d["DOUBLE_ENTRY"]
-                                ""
-                            else
-                                d["PCI_ID"]
-                            end
+                if type == 'NIC'
+                    column :PCI_ID, '', :left, :size => 8 do |d|
+                        if d['DOUBLE_ENTRY']
+                            ''
+                        else
+                            d['PCI_ID']
                         end
                     end
+                end
+            end.show(vm_nics, {})
 
-                end.show(vm_nics,{})
+            next if options[:all]
 
-                while vm.has_elements?("/VM/TEMPLATE/#{type}")
-                    vm.delete_element("/VM/TEMPLATE/#{type}")
-                end if !options[:all]
+            while vm.has_elements?("/VM/TEMPLATE/#{type}")
+                vm.delete_element("/VM/TEMPLATE/#{type}")
             end
         end
 
-        while vm.has_elements?("/VM/TEMPLATE/NIC")
-            vm.delete_element("/VM/TEMPLATE/NIC")
-        end if !options[:all]
+        if !options[:all]
+            while vm.has_elements?('/VM/TEMPLATE/NIC')
+                vm.delete_element('/VM/TEMPLATE/NIC')
+            end
+        end
 
-        if vm.has_elements?("/VM/TEMPLATE/SECURITY_GROUP_RULE") and !isHybrid
+        if vm.has_elements?('/VM/TEMPLATE/SECURITY_GROUP_RULE') && !is_hybrid
             puts
-            CLIHelper.print_header(str_h1 % "SECURITY",false)
+            CLIHelper.print_header(str_h1 % 'SECURITY', false)
             puts
 
             CLIHelper::ShowTable.new(nil, self) do
-                column :NIC_ID, "", :size=>6 do |d|
-                    d["NIC_ID"]
+                column :NIC_ID, '', :size => 6 do |d|
+                    d['NIC_ID']
                 end
 
-                column :NETWORK, "", :left, :size=>25 do |d|
-                    d["NETWORK"]
+                column :NETWORK, '', :left, :size => 25 do |d|
+                    d['NETWORK']
                 end
 
-                column :SECURITY_GROUPS, "", :left, :size=>47 do |d|
-                    d["SECURITY_GROUPS"]
+                column :SECURITY_GROUPS, '', :left, :size => 47 do |d|
+                    d['SECURITY_GROUPS']
                 end
-            end.show(sg_nics,{})
+            end.show(sg_nics, {})
 
             puts
 
-            CLIHelper.print_header(str_h1 % "SECURITY GROUP   TYPE     PROTOCOL NETWORK                       RANGE          ",false)
+            # rubocop:disable Metrics/LineLength
+            CLIHelper.print_header(str_h1 % 'SECURITY GROUP   TYPE     PROTOCOL NETWORK                       RANGE          ', false)
 
             CLIHelper::ShowTable.new(nil, self) do
-                column :ID, "", :size=>4 do |d|
-                    d["SECURITY_GROUP_ID"]
+                column :ID, '', :size => 4 do |d|
+                    d['SECURITY_GROUP_ID']
                 end
 
-                column :NAME, "", :left, :size=>11 do |d|
-                    d["SECURITY_GROUP_NAME"]
+                column :NAME, '', :left, :size => 11 do |d|
+                    d['SECURITY_GROUP_NAME']
                 end
 
-                column :" ", "", :left, :size=>8 do |d|
-                    d["RULE_TYPE"]
+                column :" ", '', :left, :size => 8 do |d|
+                    d['RULE_TYPE']
                 end
 
-                column :"  ", "", :left, :size=>8 do |d|
-                    protocol = d["PROTOCOL"]
+                column :"  ", '', :left, :size => 8 do |d|
+                    protocol = d['PROTOCOL']
 
-                    if(protocol.upcase == "ICMP")
-                        icmp = d["ICMP_TYPE"].nil? ? "" : "-#{d["ICMP_TYPE"]}"
+                    if protocol.casecmp('ICMP').zero?
+                        d['ICMP_TYPE'].nil? ? icmp = '' : icmp = "-#{d['ICMP_TYPE']}"
                         protocol += icmp
                     end
 
                     protocol
                 end
 
-                column :VNET, "", :size=>4 do |d|
-                    d["NETWORK_ID"]
+                column :VNET, '', :size => 4 do |d|
+                    d['NETWORK_ID']
                 end
 
-                column :START, "", :left, :donottruncate, :size=>17 do |d|
-                    network = ""
+                column :START, '', :left, :adjust, :size => 17 do |d|
+                    network = ''
 
-                    if(!d["IP"].nil? && d["IP"] != "")
-                        network = d["IP"]
-                    elsif(!d["MAC"].nil? && d["MAC"] != "")
-                        network = d["MAC"]
+                    if !d['IP'].nil? && d['IP'] != ''
+                        network = d['IP']
+                    elsif !d['MAC'].nil? && d['MAC'] != ''
+                        network = d['MAC']
                     end
 
                     network
                 end
 
-                column :SIZE, "", :left, :donottruncate, :size=>6 do |d|
-                    d["SIZE"]
+                column :SIZE, '', :left, :adjust, :size => 6 do |d|
+                    d['SIZE']
                 end
 
-                column :"   ", "", :left, :donottruncate, :size=>15 do |d|
-                    d["RANGE"]
+                column :"   ", '', :left, :adjust, :size => 15 do |d|
+                    d['RANGE']
                 end
+            end.show(
+                [vm_hash['VM']['TEMPLATE']['SECURITY_GROUP_RULE']].flatten, {}
+            )
+            # rubocop:enable Metrics/LineLength
 
-            end.show([vm_hash['VM']['TEMPLATE']['SECURITY_GROUP_RULE']].flatten, {})
-
-            while vm.has_elements?("/VM/TEMPLATE/SECURITY_GROUP_RULE")
-                vm.delete_element("/VM/TEMPLATE/SECURITY_GROUP_RULE")
-            end if !options[:all]
+            if !options[:all]
+                while vm.has_elements?('/VM/TEMPLATE/SECURITY_GROUP_RULE')
+                    vm.delete_element('/VM/TEMPLATE/SECURITY_GROUP_RULE')
+                end
+            end
         end
 
-        if vm.has_elements?("/VM/TEMPLATE/SNAPSHOT")
+        if vm.has_elements?('/VM/TEMPLATE/SNAPSHOT')
             puts
-            CLIHelper.print_header(str_h1 % "SNAPSHOTS",false)
+            CLIHelper.print_header(str_h1 % 'SNAPSHOTS', false)
 
             CLIHelper::ShowTable.new(nil, self) do
-
-                column :"ID", "", :size=>4 do |d|
-                    d["SNAPSHOT_ID"] if !d.nil?
+                column :ID, '', :size => 4 do |d|
+                    d['SNAPSHOT_ID'] unless d.nil?
                 end
 
-                column :"TIME", "", :size=>12 do |d|
-                    OpenNebulaHelper.time_to_str(d["TIME"], false) if !d.nil?
+                column :TIME, '', :size => 12 do |d|
+                    OpenNebulaHelper.time_to_str(d['TIME'], false) unless d.nil?
                 end
 
-                column :"NAME", "", :left, :size=>46 do |d|
-                    d["NAME"] if !d.nil?
+                column :NAME, '', :left, :size => 46 do |d|
+                    d['NAME'] unless d.nil?
                 end
 
-                column :"HYPERVISOR_ID", "", :left, :size=>15 do |d|
-                    d["HYPERVISOR_ID"] if !d.nil?
+                column :HYPERVISOR_ID, '', :left, :size => 15 do |d|
+                    d['HYPERVISOR_ID'] unless d.nil?
                 end
-
             end.show([vm_hash['VM']['TEMPLATE']['SNAPSHOT']].flatten, {})
 
-            vm.delete_element("/VM/TEMPLATE/SNAPSHOT")
+            vm.delete_element('/VM/TEMPLATE/SNAPSHOT')
         end
 
-        if vm.has_elements?("/VM/HISTORY_RECORDS")
+        if vm.has_elements?('/VM/HISTORY_RECORDS')
             puts
 
-            CLIHelper.print_header(str_h1 % "VIRTUAL MACHINE HISTORY",false)
+            CLIHelper.print_header(str_h1 % 'VIRTUAL MACHINE HISTORY', false)
             format_history(vm)
         end
 
-        if vm.has_elements?("/VM/USER_TEMPLATE/SCHED_ACTION")
+        if vm.has_elements?('/VM/USER_TEMPLATE/SCHED_ACTION')
             puts
-            CLIHelper.print_header(str_h1 % "SCHEDULED ACTIONS",false)
+            CLIHelper.print_header(str_h1 % 'SCHEDULED ACTIONS', false)
 
             CLIHelper::ShowTable.new(nil, self) do
-
-                column :"ID", "", :size=>2 do |d|
-                    d["ID"] if !d.nil?
+                column :ID, '', :size => 2 do |d|
+                    d['ID'] unless d.nil?
                 end
 
-                column :"ACTION", "", :left, :size=>15 do |d|
-                    d["ACTION"] if !d.nil?
+                column :ACTION, '', :left, :size => 15 do |d|
+                    d['ACTION'] unless d.nil?
                 end
 
-                column :"SCHEDULED", "", :size=>12 do |d|
-                    OpenNebulaHelper.time_to_str(d["TIME"], false) if !d.nil?
+                column :SCHEDULED, '', :size => 12 do |d|
+                    OpenNebulaHelper.time_to_str(d['TIME'], false) \
+                        unless d.nil?
                 end
 
-                column :"REPEAT", "", :size=>20 do |d|
-                    str_rep = ""
-                    if !d.nil? && d.key?("REPEAT")
-                        if d["REPEAT"] == "0"
-                            str_rep << "Weekly "
-                        elsif d["REPEAT"] == "1"
-                            str_rep << "Monthly "
-                        elsif d["REPEAT"] == "2"
-                            str_rep << "Yearly "
-                        elsif d["REPEAT"] == "3"
-                            str_rep << "Each " << d['DAYS'] << " hours"
+                column :REPEAT, '', :size => 20 do |d|
+                    str_rep = ''
+                    if !d.nil? && d.key?('REPEAT')
+                        if d['REPEAT'] == '0'
+                            str_rep << 'Weekly '
+                        elsif d['REPEAT'] == '1'
+                            str_rep << 'Monthly '
+                        elsif d['REPEAT'] == '2'
+                            str_rep << 'Yearly '
+                        elsif d['REPEAT'] == '3'
+                            str_rep << 'Each ' << d['DAYS'] << ' hours'
                         end
-                        if d["REPEAT"] != "3"
-                            str_rep << d["DAYS"]
+                        if d['REPEAT'] != '3'
+                            str_rep << d['DAYS']
                         end
                     end
-                    str_rep if !d.nil?
+                    str_rep unless d.nil?
                 end
 
-                column :"END", "", :size=>20 do |d|
-                    str_end = ""
-                    if !d.nil? && d.key?("END_TYPE")
-                        if d["END_TYPE"] == "0"
-                            str_end << "None"
-                        elsif d["END_TYPE"] == "1"
-                            str_end << "After " << d["END_VALUE"] << " times"
-                        elsif d["END_TYPE"] == "2"
-                            str_end << "On " << OpenNebulaHelper.time_to_str(d["END_VALUE"], false, false, true)
+                column :END, '', :size => 20 do |d|
+                    str_end = ''
+                    if !d.nil? && d.key?('END_TYPE')
+                        if d['END_TYPE'] == '0'
+                            str_end << 'None'
+                        elsif d['END_TYPE'] == '1'
+                            str_end << 'After ' << d['END_VALUE'] << ' times'
+                        elsif d['END_TYPE'] == '2'
+                            str_end << 'On ' << \
+                                OpenNebulaHelper.time_to_str(d['END_VALUE'],
+                                                             false, false,
+                                                             true)
                         end
                     end
-                    str_end if !d.nil?
+                    str_end unless d.nil?
                 end
 
-                column :"DONE", "", :size=>12 do |d|
-                    OpenNebulaHelper.time_to_str(d["DONE"], false) if !d.nil?
+                column :DONE, '', :size => 12 do |d|
+                    OpenNebulaHelper.time_to_str(d['DONE'], false) \
+                        unless d.nil?
                 end
 
-                column :"MESSAGE", "", :left, :donottruncate, :size=>35 do |d|
-                    d["MESSAGE"] if !d.nil?
+                column :MESSAGE, '', :left, :adjust, :size => 35 do |d|
+                    d['MESSAGE'] unless d.nil?
                 end
-            end.show([vm_hash['VM']['USER_TEMPLATE']['SCHED_ACTION']].flatten, {})
+            end.show([vm_hash['VM']['USER_TEMPLATE']['SCHED_ACTION']].flatten,
+                     {})
         end
 
-        if vm.has_elements?("/VM/USER_TEMPLATE")
+        if vm.has_elements?('/VM/USER_TEMPLATE')
             puts
 
             if !options[:all]
-                vm.delete_element("/VM/USER_TEMPLATE/SCHED_ACTION")
+                vm.delete_element('/VM/USER_TEMPLATE/SCHED_ACTION')
             end
 
-            CLIHelper.print_header(str_h1 % "USER TEMPLATE",false)
+            CLIHelper.print_header(str_h1 % 'USER TEMPLATE', false)
             puts vm.template_like_str('USER_TEMPLATE')
         end
 
+        if vm.has_elements?('/VM/TEMPLATE/NUMA_NODE')
+            print_numa_nodes([vm.to_hash['VM']['TEMPLATE']['NUMA_NODE']]
+                             .flatten)
+        end
+
+        if vm.has_elements?('/VM/TEMPLATE/TOPOLOGY')
+            print_topology([vm.to_hash['VM']['TEMPLATE']['TOPOLOGY']])
+        end
+
+        if !options[:all]
+            while vm.has_elements?('/VM/TEMPLATE/NUMA_NODE')
+                vm.delete_element('/VM/TEMPLATE/NUMA_NODE')
+            end
+        end
+
+        if !options[:all]
+            while vm.has_elements?('/VM/TEMPLATE/TOPOLOGY')
+                vm.delete_element('/VM/TEMPLATE/TOPOLOGY')
+            end
+        end
+
         puts
-        CLIHelper.print_header(str_h1 % "VIRTUAL MACHINE TEMPLATE",false)
+        CLIHelper.print_header(str_h1 % 'VIRTUAL MACHINE TEMPLATE', false)
         puts vm.template_str
     end
 
+    def print_numa_nodes(numa_nodes)
+        puts
+        CLIHelper.print_header('NUMA NODES', false)
+        puts
+
+        # rubocop:disable Metrics/LineLength
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :ID, 'Node ID', :size => 4, :left => false do |d|
+                d['NODE_ID']
+            end
+
+            column :CPUS_IDS, 'Cpus used', :adjust => true, :left => false do |d|
+                d['CPUS']
+            end
+
+            column :MEMORY, 'Memory used', :size => 10, :left => false do |d|
+                OpenNebulaHelper.unit_to_str(d['MEMORY'].to_i, {})
+            end
+
+            column :TOTAL_CPUS, 'Total CPUs', :size => 10, :left => false do |d|
+                d['TOTAL_CPUS']
+            end
+
+            default :ID, :CPUS_IDS, :MEMORY, :TOTAL_CPUS
+        end
+        # rubocop:enable Metrics/LineLength
+
+        table.show(numa_nodes)
+    end
+
+    def print_topology(topology)
+        puts
+        CLIHelper.print_header('TOPOLOGY', false)
+        puts
+
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :CORES, 'Cores', :size => 6, :left => false do |d|
+                d['CORES']
+            end
+
+            column :SOCKETS, 'Sockets', :size => 8, :left => false do |d|
+                d['SOCKETS']
+            end
+
+            column :THREADS, 'Threads', :size => 8, :left => false do |d|
+                d['THREADS']
+            end
+
+            default :CORES, :SOCKETS, :THREADS
+        end
+
+        table.show(topology)
+    end
+
     def format_history(vm)
-        table=CLIHelper::ShowTable.new(nil, self) do
-            column :SEQ, "Sequence number", :size=>3 do |d|
-                d["SEQ"]
+        table = CLIHelper::ShowTable.new(nil, self) do
+            column :SEQ, 'Sequence number', :size => 3 do |d|
+                d['SEQ']
             end
 
-            column :UID, "UID of the user that performed the action",
-                :left, :size=>4 do |d|
-                if d["UID"] != "-1"
-                    d["UID"]
+            column :UID, 'UID of the user that performed the action',
+                   :left, :size => 4 do |d|
+                if d['UID'] != '-1'
+                    d['UID']
                 else
-                    "-"
+                    '-'
                 end
             end
 
-            column :REQ, "Request ID of the action", :left, :size=>5 do |d|
-                if d["REQUEST_ID"] != "-1"
-                    d["REQUEST_ID"]
+            column :REQ, 'Request ID of the action', :left, :size => 5 do |d|
+                if d['REQUEST_ID'] != '-1'
+                    d['REQUEST_ID']
                 else
-                    "-"
+                    '-'
                 end
             end
 
-            column :HOST, "Host name of the VM container", :left, :size=>12 do |d|
-                d["HOSTNAME"]
+            column :HOST, 'Host name of the VM container',
+                   :left, :size => 12 do |d|
+                d['HOSTNAME']
             end
 
-            column :"ACTION", "VM state change action", :left, :size=>10 do |d|
-                VirtualMachine.get_history_action d["ACTION"]
+            column :ACTION, 'VM state change action', :left, :size => 10 do |d|
+                VirtualMachine.get_history_action d['ACTION']
             end
 
-            column :DS, "System Datastore", :size=>4 do |d|
-                d["DS_ID"]
+            column :DS, 'System Datastore', :size => 4 do |d|
+                d['DS_ID']
             end
 
-            column :START, "Time when the state changed", :size=>15 do |d|
+            column :START, 'Time when the state changed', :size => 15 do |d|
                 OpenNebulaHelper.time_to_str(d['STIME'])
             end
 
-            column :TIME, "Total time in this state", :size=>11 do |d|
-                stime = d["STIME"].to_i
-                etime = d["ETIME"]=="0" ? Time.now.to_i : d["ETIME"].to_i
-                dtime = etime-stime
+            column :TIME, 'Total time in this state', :size => 11 do |d|
+                stime = d['STIME'].to_i
+                etime = d['ETIME'] == '0' ? Time.now.to_i : d['ETIME'].to_i
+                dtime = etime - stime
                 OpenNebulaHelper.period_to_str(dtime, false)
             end
 
-            column :PROLOG, "Prolog time for this state", :size=>10 do |d|
-                stime = d["PSTIME"].to_i
-                if d["PSTIME"]=="0"
-                    etime=0
+            column :PROLOG, 'Prolog time for this state', :size => 10 do |d|
+                stime = d['PSTIME'].to_i
+                if d['PSTIME'] == '0'
+                    etime = 0
                 else
-                    etime = d["PETIME"]=="0" ? Time.now.to_i: d["PETIME"].to_i
+                    if d['PETIME'] == '0'
+                        etime = Time.now.to_i
+                    else
+                        etime = d['PETIME'].to_i
+                    end
                 end
-                dtime = etime-stime
+                dtime = etime - stime
                 OpenNebulaHelper.short_period_to_str(dtime)
             end
 
-            default :SEQ, :UID, :REQ, :HOST, :ACTION, :DS, :START, :TIME, :PROLOG
+            default :SEQ, :UID, :REQ, :HOST, :ACTION, \
+                    :DS, :START, :TIME, :PROLOG
         end
 
-        vm_hash=vm.to_hash
+        vm_hash = vm.to_hash
 
-        history=[vm_hash['VM']['HISTORY_RECORDS']['HISTORY']].flatten
+        history = [vm_hash['VM']['HISTORY_RECORDS']['HISTORY']].flatten
 
         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"
-                    "=>"
+        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"]
+            column :ID, 'Snapshot ID', :size => 3 do |d|
+                d['ID']
             end
 
-            column :DISK, "Disk ID", :size=>4 do |d|
-                d["DISK_ID"]
+            column :DISK, 'Disk ID', :size => 4 do |d|
+                d['DISK_ID']
             end
 
-            column :PARENT, "Snapshot Parent ID", :size=>6 do |d|
-                d["PARENT"]
+            column :PARENT, 'Snapshot Parent ID', :size => 6 do |d|
+                d['PARENT']
             end
 
-            column :CHILDREN, "Snapshot Children IDs", :size=>10 do |d|
-                d["CHILDREN"]
+            column :CHILDREN, 'Snapshot Children IDs', :size => 10 do |d|
+                d['CHILDREN']
             end
 
-            column :SIZE, "", :left, :size=>12 do |d|
-                if d["SIZE"]
+            column :SIZE, '', :left, :size => 12 do |d|
+                if d['SIZE']
                     size = OpenNebulaHelper.unit_to_str(
-                                d['SIZE'].to_i,
-                                {},
-                                "M"
-                            )
+                        d['SIZE'].to_i,
+                        {},
+                        'M'
+                    )
                 else
-                    size = "-"
+                    size = '-'
                 end
 
-                if d["MONITOR_SIZE"]
+                if d['MONITOR_SIZE']
                     monitor_size = OpenNebulaHelper.unit_to_str(
-                                d['MONITOR_SIZE'].to_i,
-                                {},
-                                "M"
-                            )
+                        d['MONITOR_SIZE'].to_i,
+                        {},
+                        'M'
+                    )
                 else
-                    monitor_size = "-"
+                    monitor_size = '-'
                 end
 
                 "#{monitor_size}/#{size}"
             end
 
-            column :NAME, "Snapshot Name", :left, :size=>32 do |d|
-                d["NAME"]
+            column :NAME, 'Snapshot Name', :left, :size => 32 do |d|
+                d['NAME']
             end
 
-            column :DATE, "Snapshot creation date", :size=>15 do |d|
-                OpenNebulaHelper.time_to_str(d["DATE"])
+            column :DATE, 'Snapshot creation date', :size => 15 do |d|
+                OpenNebulaHelper.time_to_str(d['DATE'])
             end
 
             default :AC, :ID, :DISK, :PARENT, :DATE, :SIZE, :NAME
@@ -1313,19 +1439,23 @@ in the frontend machine.
 
             sshots = [disk['SNAPSHOT']].flatten
             sshots.each do |snapshot|
-                data = snapshot.merge({ 'DISK_ID' => disk_id })
+                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]
+            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
+
+# rubocop:enable Naming/UncommunicativeMethodParamName