opennebula-cli 5.6.2 → 5.7.80.pre

data/bin/onevm

@@ -16,22 +16,22 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
-ONE_LOCATION=ENV["ONE_LOCATION"]
+ONE_LOCATION = ENV['ONE_LOCATION']
 
 if !ONE_LOCATION
-    RUBY_LIB_LOCATION="/usr/lib/one/ruby"
+    RUBY_LIB_LOCATION = '/usr/lib/one/ruby'
 else
-    RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby"
+    RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby'
 end
 
-$: << RUBY_LIB_LOCATION
-$: << RUBY_LIB_LOCATION+"/cli"
+$LOAD_PATH << RUBY_LIB_LOCATION
+$LOAD_PATH << RUBY_LIB_LOCATION + '/cli'
 
 require 'command_parser'
 require 'one_helper/onevm_helper'
 
-cmd=CommandParser::CmdParser.new(ARGV) do
-    usage "`onevm` <command> [<args>] [<options>]"
+CommandParser::CmdParser.new(ARGV) do
+    usage '`onevm` <command> [<args>] [<options>]'
     version OpenNebulaHelper::ONE_VERSION
 
     helper = OneVMHelper.new
@@ -40,149 +40,158 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         helper.set_client(options)
     end
 
-    TYPE={
-        :name => "type",
-        :short => "-t type",
-        :large => "--type type",
+    TYPE = {
+        :name => 'type',
+        :short => '-t type',
+        :large => '--type type',
         :format => String,
-        :description => "Type of the new Image"
+        :description => 'Type of the new Image'
     }
 
-    TARGET={
-        :name => "target",
-        :short => "-t target",
-        :large => "--target target",
+    TARGET = {
+        :name => 'target',
+        :short => '-t target',
+        :large => '--target target',
         :format => String,
-        :description => "Device where the image will be attached"
+        :description => 'Device where the image will be attached'
     }
 
-    PREFIX={
-        :name => "prefix",
-        :large => "--prefix prefix",
+    PREFIX = {
+        :name => 'prefix',
+        :large => '--prefix prefix',
         :format => String,
-        :description => "Overrides the DEV_PREFIX of the image"
+        :description => 'Overrides the DEV_PREFIX of the image'
     }
 
-    CACHE={
-        :name => "cache",
-        :large => "--cache cache_mode",
+    CACHE = {
+        :name => 'cache',
+        :large => '--cache cache_mode',
         :format => String,
-        :description => "Hypervisor cache mode: default, none, writethrough,"<<
-            " writeback, directsync or unsafe. (Only KVM driver)"
+        :description => 'Hypervisor cache mode: default, none, writethrough,'\
+                        ' writeback, directsync or unsafe. (Only KVM driver)'
     }
 
-    DISCARD={
-        :name => "discard",
-        :large => "--discard discard_mode",
+    DISCARD = {
+        :name => 'discard',
+        :large => '--discard discard_mode',
         :format => String,
-        :description => "Hypervisor discard mode: ignore or unmap."<<
-            " (Only KVM driver)"
+        :description => 'Hypervisor discard mode: ignore or unmap.'\
+                        ' (Only KVM driver)'
     }
 
-    ENFORCE={
-        :name  => "enforce",
-        :short => "-e",
-        :large => "--enforce",
-        :description => "Enforce that the host capacity is not exceeded"
+    ENFORCE = {
+        :name => 'enforce',
+        :short => '-e',
+        :large => '--enforce',
+        :description => 'Enforce that the host capacity is not exceeded'
     }
 
-    SUCCESS={
-        :name  => "success",
-        :large => "--success",
-        :description => "Recover a VM by succeeding the pending action"
+    SUCCESS = {
+        :name => 'success',
+        :large => '--success',
+        :description => 'Recover a VM by succeeding the pending action'
     }
 
-    FAILURE={
-        :name  => "failure",
-        :large => "--failure",
-        :description => "Recover a VM by failing the pending action"
+    FAILURE = {
+        :name => 'failure',
+        :large => '--failure',
+        :description => 'Recover a VM by failing the pending action'
     }
 
-    RETRY={
-        :name  => "retry",
-        :large => "--retry",
-        :description => "Recover a VM by retrying the last failed action"
+    RETRY = {
+        :name => 'retry',
+        :large => '--retry',
+        :description => 'Recover a VM by retrying the last failed action'
     }
 
-    DELETE={
-        :name  => "delete",
-        :large => "--delete",
-        :description => "No recover action possible, delete the VM"
+    DELETE = {
+        :name => 'delete',
+        :large => '--delete',
+        :description => 'No recover action possible, delete the VM'
     }
 
-    RECREATE={
-        :name  => "recreate",
-        :large => "--recreate",
-        :description => "No recover action possible, delete and recreate the VM"
+    RECREATE = {
+        :name => 'recreate',
+        :large => '--recreate',
+        :description => 'No recover action possible, delete and recreate the VM'
     }
 
-    INTERACTIVE={
-        :name  => "interactive",
-        :large => "--interactive",
-        :description => "Enables interactive recovery. Only works alongside "<<
-            " the --retry option."
+    DELETE_DB = {
+        :name => 'deletedb',
+        :large => '--delete-db',
+        :description => 'No recover action possible, delete the VM from the '\
+                        'DB. It does not trigger any action on the hypervisor'
     }
 
-    SNAP={
-        :name  => "snapshot",
-        :short => "-s snapshot",
-        :large => "--snapshot snapshot",
+    INTERACTIVE = {
+        :name => 'interactive',
+        :large => '--interactive',
+        :description => 'Enables interactive recovery. Only works alongside '\
+                        ' the --retry option.'
+    }
+
+    SNAP = {
+        :name => 'snapshot',
+        :short => '-s snapshot',
+        :large => '--snapshot snapshot',
         :format => String,
-        :description => "ID of the Snapshot to save."
+        :description => 'ID of the Snapshot to save.'
     }
 
-    PERSISTENT={
-        :name  => "persistent",
-        :large => "--persistent",
-        :description => "Make the new images persistent"
+    PERSISTENT = {
+        :name => 'persistent',
+        :large => '--persistent',
+        :description => 'Make the new images persistent'
     }
 
-    USE={
-        :name  => "use",
-        :large => "--use",
-        :description => "lock use actions"
+    USE = {
+        :name => 'use',
+        :large => '--use',
+        :description => 'lock use actions'
     }
 
-    MANAGE={
-        :name  => "manage",
-        :large => "--manage",
-        :description => "lock manage actions"
+    MANAGE = {
+        :name => 'manage',
+        :large => '--manage',
+        :description => 'lock manage actions'
     }
 
-    ADMIN={
-        :name  => "admin",
-        :large => "--admin",
-        :description => "lock admin actions"
+    ADMIN = {
+        :name => 'admin',
+        :large => '--admin',
+        :description => 'lock admin actions'
     }
 
-    ALL={
-        :name  => "all",
-        :large => "--all",
-        :description => "lock all actions"
+    ALL = {
+        :name => 'all',
+        :large => '--all',
+        :description => 'lock all actions'
     }
 
     ########################################################################
     # Global Options
     ########################################################################
-    set :option, CommandParser::OPTIONS+OpenNebulaHelper::CLIENT_OPTIONS
+    set :option, CommandParser::OPTIONS + OpenNebulaHelper::CLIENT_OPTIONS
 
     ########################################################################
     # Formatters for arguments
     ########################################################################
-    set :format, :hostid, OpenNebulaHelper.rname_to_id_desc("HOST") do |arg|
-        OpenNebulaHelper.rname_to_id(arg, "HOST")
+    set :format, :hostid, OpenNebulaHelper.rname_to_id_desc('HOST') do |arg|
+        OpenNebulaHelper.rname_to_id(arg, 'HOST')
     end
 
-    set :format, :groupid, OpenNebulaHelper.rname_to_id_desc("GROUP") do |arg|
-        OpenNebulaHelper.rname_to_id(arg, "GROUP")
+    set :format, :groupid, OpenNebulaHelper.rname_to_id_desc('GROUP') do |arg|
+        OpenNebulaHelper.rname_to_id(arg, 'GROUP')
     end
 
-    set :format, :userid, OpenNebulaHelper.rname_to_id_desc("USER") do |arg|
-        OpenNebulaHelper.rname_to_id(arg, "USER")
+    set :format, :userid, OpenNebulaHelper.rname_to_id_desc('USER') do |arg|
+        OpenNebulaHelper.rname_to_id(arg, 'USER')
     end
 
-    set :format, :datastoreid, OpenNebulaHelper.rname_to_id_desc("DATASTORE") do |arg|
-        OpenNebulaHelper.rname_to_id(arg, "DATASTORE")
+    set :format,
+        :datastoreid,
+        OpenNebulaHelper.rname_to_id_desc('DATASTORE') do |arg|
+        OpenNebulaHelper.rname_to_id(arg, 'DATASTORE')
     end
 
     set :format, :vmid, OneVMHelper.to_id_desc do |arg|
@@ -199,15 +208,15 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         helper.filterflag_to_i(arg)
     end
 
-    set :format, :diskid, "Integer" do |arg|
+    set :format, :diskid, 'Integer' do |arg|
         format_int(arg)
     end
 
-    set :format, :size, "Disk size in MiB" do |arg|
+    set :format, :size, 'Disk size in MiB' do |arg|
         OpenNebulaHelper.size_in_mb(arg)
     end
 
-    format :snapshot_id, "Snapshot identifier" do |arg|
+    format :snapshot_id, 'Snapshot identifier' do |arg|
         helper.retrieve_snapshot_id(@current_vm, arg)
     end
 
@@ -238,34 +247,33 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :create, create_desc, [:file, nil], :options =>
-            [OneVMHelper::MULTIPLE, OneVMHelper::HOLD]+
+            [OneVMHelper::MULTIPLE, OneVMHelper::HOLD] +
             OpenNebulaHelper::TEMPLATE_OPTIONS_VM do
 
         number    = options[:multiple] || 1
         exit_code = nil
 
         if args[0] && OpenNebulaHelper.create_template_options_used?(options)
-            STDERR.puts "You can not use both template file and template"<<
-                " creation options."
-            next -1
+            STDERR.puts 'You can not use both template file and template'\
+                        ' creation options.'
+            exit(-1)
         end
 
         begin
             if args[0]
-                template=File.read(args[0])
+                template = File.read(args[0])
             else
                 res = OpenNebulaHelper.create_template(options)
 
                 if res.first != 0
                     STDERR.puts res.last
-                    next -1
+                    exit(-1)
                 end
 
                 template = res.last
             end
-
-        rescue Exception => e
-            STDERR.puts "Error reading template."
+        rescue StandardError
+            STDERR.puts 'Error reading template.'
             next -1
         end
 
@@ -274,11 +282,11 @@ cmd=CommandParser::CmdParser.new(ARGV) do
             exit 0
         end
 
-        on_hold = options[:hold] != nil
+        on_hold = !options[:hold].nil?
 
         number.times do
             exit_code = helper.create_resource(options) do |vm|
-                error = vm.allocate(template, on_hold)
+                vm.allocate(template, on_hold)
             end
 
             break if exit_code == -1
@@ -293,12 +301,14 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :update, update_desc, :vmid, [:file, nil],
-    :options=>OpenNebulaHelper::APPEND do
-        helper.perform_action(args[0],options,"modified") do |obj|
+            :options => OpenNebulaHelper::APPEND do
+        helper.perform_action(args[0], options, 'modified') do |obj|
             if options[:append]
-                str = OpenNebulaHelper.append_template(args[0], obj, args[1], 'USER_TEMPLATE')
+                str = OpenNebulaHelper
+                      .append_template(args[0], obj, args[1], 'USER_TEMPLATE')
             else
-                str = OpenNebulaHelper.update_template(args[0], obj, args[1], 'USER_TEMPLATE')
+                str = OpenNebulaHelper
+                      .update_template(args[0], obj, args[1], 'USER_TEMPLATE')
             end
 
             helper.set_client(options)
@@ -315,12 +325,17 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: PENDING
     EOT
 
-    command :hold, hold_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME] do
-        if (!options[:schedule].nil?)
+    command :hold, hold_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME] do
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, @comm_name)
         else
-            helper.perform_actions(args[0],options,"put on hold") do |vm|
+            helper.perform_actions(args[0], options, 'put on hold') do |vm|
                 vm.hold
             end
         end
@@ -332,12 +347,17 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: HOLD
     EOT
 
-    command :release, release_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME] do
-        if (!options[:schedule].nil?)
+    command :release, release_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME] do
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, @comm_name)
         else
-            helper.perform_actions(args[0],options,"released") do |vm|
+            helper.perform_actions(args[0], options, 'released') do |vm|
                 vm.release
             end
         end
@@ -352,26 +372,26 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :"disk-saveas", disk_saveas_desc, :vmid, :diskid, :img_name,
-            :options=>[TYPE, SNAP] do
+            :options => [TYPE, SNAP] do
 
         disk_id     = args[1].to_i
         image_name  = args[2]
-        image_type  = options[:type] || ""
+        image_type  = options[:type] || ''
         snapshot_id = options[:snapshot]
 
         if snapshot_id.nil? || snapshot_id.empty?
             snapshot_id = -1
 
-            verbose = "disk #{disk_id} prepared to be saved in " <<
+            verbose = "disk #{disk_id} prepared to be saved in " \
                       "the image #{image_name}"
         else
             snapshot_id = snapshot_id.to_i
 
-            verbose = "disk #{disk_id} snapshot #{snapshot_id} prepared to " <<
+            verbose = "disk #{disk_id} snapshot #{snapshot_id} prepared to " \
                       "be saved in the image #{image_name}"
         end
 
-        helper.perform_action(args[0],options,verbose) do |vm|
+        helper.perform_action(args[0], options, verbose) do |vm|
             res = vm.disk_saveas(disk_id, image_name, image_type, snapshot_id)
 
             if !OpenNebula.is_error?(res)
@@ -390,17 +410,23 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: valid if no operation is being performed on the VM
     EOT
 
-    command :terminate, terminate_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME, OneVMHelper::HARD] do
+    command :terminate, terminate_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME,
+                         OneVMHelper::HARD] do
 
-        command_name='terminate'
-        command_name<<'-hard' if options[:hard]
+        command_name = 'terminate'
+        command_name << '-hard' if options[:hard]
 
-        if (!options[:schedule].nil?)
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, command_name)
         else
-            helper.perform_actions(args[0],options,"terminated") do |vm|
-                vm.terminate(options[:hard]==true)
+            helper.perform_actions(args[0], options, 'terminated') do |vm|
+                vm.terminate(options[:hard] == true)
             end
         end
     end
@@ -413,17 +439,23 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :undeploy, undeploy_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME, OneVMHelper::HARD] do
+    command :undeploy, undeploy_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME,
+                         OneVMHelper::HARD] do
 
-        command_name='undeploy'
-        command_name<<'-hard' if options[:hard]
+        command_name = 'undeploy'
+        command_name << '-hard' if options[:hard]
 
-        if (!options[:schedule].nil?)
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, command_name)
         else
-            helper.perform_actions(args[0],options,"shutting down") do |vm|
-                vm.undeploy(options[:hard]==true)
+            helper.perform_actions(args[0], options, 'shutting down') do |vm|
+                vm.undeploy(options[:hard] == true)
             end
         end
     end
@@ -435,17 +467,23 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :poweroff, poweroff_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME, OneVMHelper::HARD] do
+    command :poweroff, poweroff_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME,
+                         OneVMHelper::HARD] do
 
-        command_name='poweroff'
-        command_name<<'-hard' if options[:hard]
+        command_name = 'poweroff'
+        command_name << '-hard' if options[:hard]
 
-        if (!options[:schedule].nil?)
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, @comm_name)
         else
-            helper.perform_actions(args[0],options,"shutting down") do |vm|
-                vm.poweroff(options[:hard]==true)
+            helper.perform_actions(args[0], options, 'shutting down') do |vm|
+                vm.poweroff(options[:hard] == true)
             end
         end
     end
@@ -459,16 +497,22 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :reboot, reboot_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME, OneVMHelper::HARD] do
+    command :reboot, reboot_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME,
+                         OneVMHelper::HARD] do
 
-        command_name='reboot'
-        command_name<<'-hard' if options[:hard]
+        command_name = 'reboot'
+        command_name << '-hard' if options[:hard]
 
-        if (!options[:schedule].nil?)
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, command_name)
         else
-            helper.perform_actions(args[0],options,"rebooting") do |vm|
+            helper.perform_actions(args[0], options, 'rebooting') do |vm|
                 vm.reboot(options[:hard])
             end
         end
@@ -482,16 +526,26 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: PENDING, HOLD, STOPPED, UNDEPLOYED
     EOT
 
-    command :deploy, deploy_desc, [:range,:vmid_list], :hostid, [:datastoreid,nil],
-            :options=>[ENFORCE] do
+    command :deploy,
+            deploy_desc,
+            [:range, :vmid_list],
+            :hostid,
+            [:datastoreid, nil],
+            :options => [ENFORCE, OneVMHelper::FILE] do
         host_id = args[1]
         verbose = "deploying in host #{host_id}"
 
-        enforce = options[:enforce].nil? ? false : options[:enforce]
-        ds_id = args[2].nil? ? -1 : args[2]
+        options[:enforce].nil? ? enforce = false : enforce = options[:enforce]
+        args[2].nil? ? ds_id = -1 : ds_id = args[2]
+
+        extra_template = nil
+
+        if options[:file]
+            extra_template = File.read(options[:file])
+        end
 
-        helper.perform_actions(args[0],options,verbose) do |vm|
-            vm.deploy(host_id, enforce, ds_id)
+        helper.perform_actions(args[0], options, verbose) do |vm|
+            vm.deploy(host_id, enforce, ds_id, extra_template)
         end
     end
 
@@ -502,18 +556,20 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :migrate, migrate_desc, [:range,:vmid_list], :hostid, [:datastoreid,nil],
-            :options=>[ENFORCE, OneVMHelper::LIVE] do
+    command :migrate, migrate_desc, [:range, :vmid_list], :hostid,
+            [:datastoreid, nil], :options => [ENFORCE, OneVMHelper::LIVE,
+        OneVMHelper::POFF, OneVMHelper::POFFHARD] do
         host_id = args[1]
         verbose = "migrating to #{host_id}"
 
-        ds_id = args[2].nil? ? -1 : args[2]
+        args[2].nil? ? ds_id = -1 : ds_id = args[2]
 
-        helper.perform_actions(args[0],options,verbose) do |vm|
-            vm.migrate( host_id,
-                        options[:live]==true,
-                        options[:enforce]==true,
-                        ds_id)
+        helper.perform_actions(args[0], options, verbose) do |vm|
+            vm.migrate(host_id,
+                       options[:live] == true,
+                       options[:enforce] == true,
+                       ds_id,
+                       helper.get_migration_type(options))
         end
     end
 
@@ -524,12 +580,17 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :stop, stop_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME] do
-        if (!options[:schedule].nil?)
+    command :stop, stop_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME] do
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, @comm_name)
         else
-            helper.perform_actions(args[0],options,"stopping") do |vm|
+            helper.perform_actions(args[0], options, 'stopping') do |vm|
                 vm.stop
             end
         end
@@ -544,12 +605,17 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :suspend, suspend_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME] do
-        if (!options[:schedule].nil?)
+    command :suspend, suspend_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME] do
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, @comm_name)
         else
-            helper.perform_actions(args[0],options,"suspending") do |vm|
+            helper.perform_actions(args[0], options, 'suspending') do |vm|
                 vm.suspend
             end
         end
@@ -561,12 +627,17 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: STOPPED, SUSPENDED, UNDEPLOYED, POWEROFF, UNKNOWN
     EOT
 
-    command :resume, resume_desc, [:range,:vmid_list],
-        :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME] do
-        if (!options[:schedule].nil?)
+    command :resume, resume_desc, [:range, :vmid_list],
+            :options => [OneVMHelper::SCHEDULE,
+                         OneVMHelper::WEEKLY,
+                         OneVMHelper::MONTHLY,
+                         OneVMHelper::YEARLY,
+                         OneVMHelper::HOURLY,
+                         OneVMHelper::END_TIME] do
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, @comm_name)
         else
-            helper.perform_actions(args[0],options,"resuming") do |vm|
+            helper.perform_actions(args[0], options, 'resuming') do |vm|
                 vm.resume
             end
         end
@@ -586,10 +657,12 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States for a retry recover: Any *FAILURE state
         States for delete: Any
         States for delete-recreate: Any but STOP/UNDEPLOYED
+        States for delete-db: Any
     EOT
 
-    command :recover, recover_desc, [:range,:vmid_list],
-        :options => [SUCCESS, FAILURE, RETRY, INTERACTIVE, DELETE, RECREATE] do
+    command :recover, recover_desc, [:range, :vmid_list],
+            :options => [SUCCESS, FAILURE, RETRY, INTERACTIVE,
+                         DELETE, RECREATE, DELETE_DB] do
         if !options[:success].nil?
             result = 1
         elsif !options[:failure].nil?
@@ -600,17 +673,24 @@ cmd=CommandParser::CmdParser.new(ARGV) do
             result = 3
         elsif !options[:recreate].nil?
             result = 4
+        elsif !options[:deletedb].nil?
+            result = 5
         else
-            STDERR.puts "Need to specify the result of the pending action."
-            STDERR.puts "\t--success recover the VM by succeeding the missing action."
-            STDERR.puts "\t--failure recover the VM by failing the missing action."
-            STDERR.puts "\t--retry recover the VM by retrying the last failed action."
-            STDERR.puts "\t--delete no recover possible, delete the VM."
-            STDERR.puts "\t--recreate no recover possible, delete and recreate the VM."
-            exit -1
+            error_message = <<-EOT.unindent
+            Need to specify the result of the pending action.
+            \t--success recover the VM by succeeding the missing action.
+            \t--failure recover the VM by failing the missing action.
+            \t--retry recover the VM by retrying the last failed action.
+            \t--delete no recover possible, delete the VM.
+            \t--recreate no recover possible, delete and recreate the VM.
+            \t--delete-db no recover possible, delete the VM from the DB. No action performed on the hypervisor
+            EOT
+
+            STDERR.puts error_message
+            exit(-1)
         end
 
-        helper.perform_actions(args[0], options, "recovering") do |vm|
+        helper.perform_actions(args[0], options, 'recovering') do |vm|
             if options[:retry] && options[:interactive]
                 helper.recover_retry_interactive(vm)
             else
@@ -630,11 +710,11 @@ cmd=CommandParser::CmdParser.new(ARGV) do
             :options => [OneVMHelper::FILE, OneVMHelper::IMAGE,
                          TARGET, CACHE, DISCARD, PREFIX] do
 
-        if options[:file].nil? and options[:image].nil?
-            STDERR.puts "Provide a template file or an image:"
-            STDERR.puts "\t--file  <file>"
-            STDERR.puts "\t--image <image>"
-            exit -1
+        if options[:file].nil? && options[:image].nil?
+            STDERR.puts 'Provide a template file or an image:'
+            STDERR.puts '\t--file  <file>'
+            STDERR.puts '\t--image <image>'
+            exit(-1)
         end
 
         if options[:file]
@@ -653,17 +733,17 @@ cmd=CommandParser::CmdParser.new(ARGV) do
             end
 
             if options[:cache]
-                template<<", CACHE = \"#{options[:cache]}\""
+                template << ", CACHE = \"#{options[:cache]}\""
             end
 
             if options[:discard]
-                template<<", DISCARD = \"#{options[:discard]}\""
+                template << ", DISCARD = \"#{options[:discard]}\""
             end
 
-            template << " ]"
+            template << ' ]'
         end
 
-        helper.perform_action(args[0],options,"Attach disk") do |vm|
+        helper.perform_action(args[0], options, 'Attach disk') do |vm|
             vm.disk_attach(template)
         end
     end
@@ -677,7 +757,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     command :"disk-detach", disk_detach_desc, :vmid, :diskid do
         diskid = args[1].to_i
 
-        helper.perform_action(args[0],options,"Detach disk") do |vm|
+        helper.perform_action(args[0], options, 'Detach disk') do |vm|
             vm.disk_detach(diskid)
         end
     end
@@ -686,17 +766,23 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         Attaches a NIC to a running VM. When using --file add only one
         NIC instance.
 
+        To attach a nic alias, use --file or --alias option.
+
         States: RUNNING, POWEROFF
     EOT
 
     command :"nic-attach", nic_attach_desc, :vmid,
-            :options => [OneVMHelper::FILE, OneVMHelper::NETWORK, OneVMHelper::IP] do
-
-        if options[:file].nil? and options[:network].nil?
-            STDERR.puts "Provide a template file or a network:"
+            :options => [OneVMHelper::FILE,
+                         OneVMHelper::NETWORK,
+                         OneVMHelper::IP,
+                         OneVMHelper::ALIAS,
+                         OneVMHelper::NIC_NAME] do
+
+        if options[:file].nil? && options[:network].nil?
+            STDERR.puts 'Provide a template file or a network:'
             STDERR.puts "\t--file    <file>"
             STDERR.puts "\t--network <network>"
-            exit -1
+            exit(-1)
         end
 
         if options[:file]
@@ -704,14 +790,37 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         else
             network_id = options[:network]
             ip = options[:ip]
+            nic_alias = options[:alias]
+            nic_name = options[:nic_name]
+
             if ip
-                template = "NIC = [ NETWORK_ID = #{network_id}, IP = #{ip} ]"
+                if !nic_alias && !nic_name
+                    template = "NIC = [ NETWORK_ID = #{network_id}, IP = #{ip} ]"
+                elsif !nic_alias && nic_name
+                    template = "NIC = [ NETWORK_ID = #{network_id},
+                                        IP = #{ip},
+                                        NAME = #{nic_name} ]"
+                else
+                    template = "NIC_ALIAS = \
+                                [ NETWORK_ID = #{network_id},\
+                                  IP = #{ip},\
+                                  PARENT = #{nic_alias} ]"
+                end
             else
-                template = "NIC = [ NETWORK_ID = #{network_id} ]"
+                if !nic_alias && !nic_name
+                    template = "NIC = [ NETWORK_ID = #{network_id} ]"
+                elsif !nic_alias && nic_name
+                    template = "NIC = [ NETWORK_ID = #{network_id},
+                                        NAME = #{nic_name} ]"
+                else
+                    template = "NIC_ALIAS = \
+                                [ NETWORK_ID = #{network_id},\
+                                  PARENT = #{nic_alias} ]"
+                end
             end
         end
 
-        helper.perform_action(args[0],options,"Attach NIC") do |vm|
+        helper.perform_action(args[0], options, 'Attach NIC') do |vm|
             vm.nic_attach(template)
         end
     end
@@ -725,7 +834,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     command :"nic-detach", nic_detach_desc, :vmid, :nicid do
         nicid = args[1].to_i
 
-        helper.perform_action(args[0],options,"Detach NIC") do |vm|
+        helper.perform_action(args[0], options, 'Detach NIC') do |vm|
             vm.nic_detach(nicid)
         end
     end
@@ -734,8 +843,8 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         Changes the VM group
     EOT
 
-    command :chgrp, chgrp_desc,[:range, :vmid_list], :groupid do
-        helper.perform_actions(args[0],options,"Group changed") do |vm|
+    command :chgrp, chgrp_desc, [:range, :vmid_list], :groupid do
+        helper.perform_actions(args[0], options, 'Group changed') do |vm|
             vm.chown(-1, args[1].to_i)
         end
     end
@@ -745,9 +854,9 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :chown, chown_desc, [:range, :vmid_list], :userid,
-            [:groupid,nil] do
-        gid = args[2].nil? ? -1 : args[2].to_i
-        helper.perform_actions(args[0],options,"Owner/Group changed") do |vm|
+            [:groupid, nil] do
+        args[2].nil? ? gid = -1 : gid = args[2].to_i
+        helper.perform_actions(args[0], options, 'Owner/Group changed') do |vm|
             vm.chown(args[1].to_i, gid)
         end
     end
@@ -757,7 +866,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :chmod, chmod_desc, [:range, :vmid_list], :octet do
-        helper.perform_actions(args[0],options, "Permissions changed") do |vm|
+        helper.perform_actions(args[0], options, 'Permissions changed') do |vm|
             vm.chmod_octet(args[1])
         end
     end
@@ -768,8 +877,8 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :resched, resched_desc, [:range,:vmid_list] do
-        helper.perform_actions(args[0],options,"Setting resched flag") do |vm|
+    command :resched, resched_desc, [:range, :vmid_list] do
+        helper.perform_actions(args[0], options, 'Setting resched flag') do |vm|
             vm.resched
         end
     end
@@ -780,8 +889,10 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: RUNNING
     EOT
 
-    command :unresched, unresched_desc, [:range,:vmid_list] do
-        helper.perform_actions(args[0],options,"Clearing resched flag") do |vm|
+    command :unresched, unresched_desc, [:range, :vmid_list] do
+        helper.perform_actions(args[0],
+                               options,
+                               'Clearing resched flag') do |vm|
             vm.unresched
         end
     end
@@ -791,7 +902,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :rename, rename_desc, :vmid, :name do
-        helper.perform_action(args[0],options,"renamed") do |o|
+        helper.perform_action(args[0], options, 'renamed') do |o|
             o.rename(args[1])
         end
     end
@@ -803,13 +914,18 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         Creates a new VM snapshot
     EOT
 
-    command :"snapshot-create", snapshot_create_desc, [:range,:vmid_list],
-        [:name, nil], :options => [OneVMHelper::SCHEDULE, OneVMHelper::WEEKLY, OneVMHelper::MONTHLY, OneVMHelper::YEARLY, OneVMHelper::HOURLY, OneVMHelper::END_TIME] do
+    command :"snapshot-create", snapshot_create_desc, [:range, :vmid_list],
+            [:name, nil], :options => [OneVMHelper::SCHEDULE,
+                                       OneVMHelper::WEEKLY,
+                                       OneVMHelper::MONTHLY,
+                                       OneVMHelper::YEARLY,
+                                       OneVMHelper::HOURLY,
+                                       OneVMHelper::END_TIME] do
 
-        if (!options[:schedule].nil?)
+        if !options[:schedule].nil?
             helper.schedule_actions(args[0], options, @comm_name)
         else
-            helper.perform_actions(args[0],options,"snapshot created") do |o|
+            helper.perform_actions(args[0], options, 'snapshot created') do |o|
                 o.snapshot_create(args[1])
             end
         end
@@ -821,8 +937,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :"snapshot-revert", snapshot_revert_desc, :vmid, :snapshot_id do
-
-        helper.perform_action(args[0],options,"snapshot reverted") do |o|
+        helper.perform_action(args[0], options, 'snapshot reverted') do |o|
             o.snapshot_revert(args[1].to_i)
         end
     end
@@ -833,7 +948,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :"snapshot-delete", snapshot_delete_desc, :vmid, :snapshot_id do
-        helper.perform_action(args[0],options,"snapshot deleted") do |o|
+        helper.perform_action(args[0], options, 'snapshot deleted') do |o|
             o.snapshot_delete(args[1])
         end
     end
@@ -846,9 +961,9 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :"disk-snapshot-create", disk_snapshot_create_desc,
-      :vmid, :diskid, :name do
-        helper.perform_action(args[0],options,"disk snapshot created") do |o|
-          o.disk_snapshot_create(args[1].to_i, args[2])
+            :vmid, :diskid, :name do
+        helper.perform_action(args[0], options, 'disk snapshot created') do |o|
+            o.disk_snapshot_create(args[1].to_i, args[2])
         end
     end
 
@@ -859,9 +974,9 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :"disk-snapshot-revert", disk_snapshot_revert_desc,
-      :vmid, :diskid, :disk_snapshot_id do
-        helper.perform_action(args[0],options,"disk snapshot reverted") do |o|
-          o.disk_snapshot_revert(args[1].to_i, args[2].to_i)
+            :vmid, :diskid, :disk_snapshot_id do
+        helper.perform_action(args[0], options, 'disk snapshot reverted') do |o|
+            o.disk_snapshot_revert(args[1].to_i, args[2].to_i)
         end
     end
 
@@ -870,10 +985,28 @@ cmd=CommandParser::CmdParser.new(ARGV) do
 
         States: RUNNING, POWEROFF, SUSPENDED
     EOT
+
     command :"disk-snapshot-delete", disk_snapshot_delete_desc,
-      :vmid, :diskid, :disk_snapshot_id do
-        helper.perform_action(args[0],options,"disk snapshot deleted") do |o|
-          o.disk_snapshot_delete(args[1].to_i, args[2].to_i)
+            :vmid, :diskid, :disk_snapshot_id do
+        helper.perform_action(args[0], options, 'disk snapshot deleted') do |o|
+            o.disk_snapshot_delete(args[1].to_i, args[2].to_i)
+        end
+    end
+
+    disk_snapshot_rename_desc = <<-EOT.unindent
+        Renames a disk snapshot.
+    EOT
+
+    command :"disk-snapshot-rename", disk_snapshot_rename_desc,
+            :vmid, :diskid, :disk_snapshot_id, :new_snapshot_name do
+        helper.perform_action(args[0], options, 'disk snapshot rename') do |o|
+            is_num = true if Integer(args[2]) rescue false
+
+            if !is_num
+                OpenNebula::Error.new('The disk snapshot ID must be an integer')
+            else
+                o.disk_snapshot_rename(args[1].to_i, args[2].to_i, args[3].to_s)
+            end
         end
     end
 
@@ -889,8 +1022,8 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :"disk-resize", disk_resize_desc,
-      :vmid, :diskid, :size do
-        helper.perform_action(args[0],options,"disk resized") do |o|
+            :vmid, :diskid, :size do
+        helper.perform_action(args[0], options, 'disk resized') do |o|
             o.info
             size = o["/VM/TEMPLATE/DISK[DISK_ID='#{args[1]}']/SIZE"].to_i
 
@@ -910,8 +1043,8 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :list, list_desc, [:filterflag, nil],
-            :options=>CLIHelper::OPTIONS+OpenNebulaHelper::OPTIONS+
-            [OpenNebulaHelper::DESCRIBE] do
+            :options => CLIHelper::OPTIONS + OpenNebulaHelper::OPTIONS +
+                        [OpenNebulaHelper::DESCRIBE] do
         helper.list_pool(options, false, args[0])
     end
 
@@ -920,8 +1053,8 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :show, show_desc, :vmid,
-            :options=>[OpenNebulaHelper::XML, OneVMHelper::ALL_TEMPLATE] do
-        helper.show_resource(args[0],options)
+            :options => [OpenNebulaHelper::XML, OneVMHelper::ALL_TEMPLATE] do
+        helper.show_resource(args[0], options)
     end
 
     top_desc = <<-EOT.unindent
@@ -929,7 +1062,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :top, top_desc, [:filterflag, nil],
-            :options=>CLIHelper::OPTIONS+OpenNebulaHelper::OPTIONS do
+            :options => CLIHelper::OPTIONS + OpenNebulaHelper::OPTIONS do
         helper.list_pool(options, true, args[0])
     end
 
@@ -939,13 +1072,14 @@ cmd=CommandParser::CmdParser.new(ARGV) do
 
     EOT
 
-    command :resize, resize_desc, :vmid, :options =>
-            OpenNebulaHelper::CAPACITY_OPTIONS_VM + [ENFORCE, OneVMHelper::FILE] do
+    command :resize, resize_desc, :vmid,
+            :options => OpenNebulaHelper::CAPACITY_OPTIONS_VM +
+                        [ENFORCE, OneVMHelper::FILE] do
 
         if options[:file]
             template = File.read(options[:file])
         else
-            template = ""
+            template = ''
 
             if !options[:cpu].nil?
                 template << "CPU = #{options[:cpu]}\n"
@@ -962,7 +1096,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
 
         enforce = options[:enforce] || false
 
-        helper.perform_action(args[0], options, "Resizing VM") do |vm|
+        helper.perform_action(args[0], options, 'Resizing VM') do |vm|
             vm.resize(template, enforce)
         end
     end
@@ -974,9 +1108,9 @@ cmd=CommandParser::CmdParser.new(ARGV) do
         States: POWEROFF
     EOT
 
-    command :save, save_desc, :vmid, :name, :options=>[PERSISTENT] do
-        helper.perform_action(args[0],options,"Saving VM") do |vm|
-            res = vm.save_as_template(args[1], options[:persistent] )
+    command :save, save_desc, :vmid, :name, :options => [PERSISTENT] do
+        helper.perform_action(args[0], options, 'Saving VM') do |vm|
+            res = vm.save_as_template(args[1], options[:persistent])
 
             if !OpenNebula.is_error?(res)
                 puts "Template ID: #{res}"
@@ -1003,22 +1137,24 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :updateconf, updateconf_desc, :vmid, [:file, nil] do
-        template = ""
+        template = ''
 
         begin
-            template=File.read(args[1]) if args[1]
-        rescue Exception => e
-            STDERR.puts "Error reading template."
-            exit -1
+            template = File.read(args[1]) if args[1]
+        rescue StandardError => e
+            STDERR.puts "Error reading template: #{e.message}."
+            exit(-1)
         end
 
-        helper.perform_action(args[0], options, "Updating VM configuration") do |vm|
+        helper.perform_action(args[0], options,
+                              'Updating VM configuration') do |vm|
             if template.empty?
                 vm.info
 
                 template = vm.template_like_str('TEMPLATE', true,
-                           'OS | FEATURES | INPUT | GRAPHICS | RAW | CONTEXT')
-                template = OpenNebulaHelper::editor_input(template)
+                                                'OS | FEATURES | INPUT | '\
+                                                'GRAPHICS | RAW | CONTEXT')
+                template = OpenNebulaHelper.editor_input(template)
             end
 
             vm.updateconf(template)
@@ -1032,8 +1168,8 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :lock, lock_desc, :vmid,
-        :options => [USE, MANAGE, ADMIN, ALL] do
-        helper.perform_action(args[0],options,"VM locked") do |vm|
+            :options => [USE, MANAGE, ADMIN, ALL] do
+        helper.perform_action(args[0], options, 'VM locked') do |vm|
             if !options[:use].nil?
                 level = 1
             elsif !options[:manage].nil?
@@ -1055,7 +1191,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
     EOT
 
     command :unlock, unlock_desc, :vmid do
-        helper.perform_action(args[0],options,"VM unlocked") do |vm|
+        helper.perform_action(args[0], options, 'VM unlocked') do |vm|
             vm.unlock
         end
     end