shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2025-03-16 22:50:10 +03:00
Code Releases Wiki Activity

F #1246 Add recover --delete-db option

Browse Source 
co-authored-by: Christian González <cgonzalez@opennebula.systems>

(cherry picked from commit 1dd6cab6af088324d7aaf7d5d67775d33d7f950f)
This commit is contained in:
Ruben S. Montero 2018-10-15 15:34:40 +02:00
parent f11c050e26
commit a5e1331aec
8 changed files with 94 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/DispatchManager.h
View File

@ -296,6 +296,15 @@ public:
int delete_recreate(VirtualMachine * vm, const RequestAttributes& ra,
string& error_str);
/**
* Ends a VM life cycle inside ONE but let the VM running at the Hipervisor.
* @param vm VirtualMachine object
* @param ra information about the API call request
* @return 0 on success, the VM mutex is unlocked
*/
int delete_vm_db(VirtualMachine * vm, const RequestAttributes& ra,
string& error_str);
/**
* Recover the last operation on the VM
* @param vm VirtualMachine object
@ -541,7 +550,7 @@ private:
/**
* Frees the resources associated to a VM: disks, ip addresses and Quotas
*/
void free_vm_resources(VirtualMachine * vm);
void free_vm_resources(VirtualMachine * vm, bool check_images);
//--------------------------------------------------------------------------
// DM Actions associated with a VM state transition

3
include/VirtualMachine.h
View File

@ -1045,8 +1045,9 @@ public:
/**
* Releases all disk images taken by this Virtual Machine
* @param quotas disk space to free from image datastores
* @param check_state to update image state based on VM state
*/
void release_disk_images(vector<Template *>& quotas);
void release_disk_images(vector<Template *>& quotas, bool check_state);
/**
* @return reference to the VirtualMachine disks

13
src/cli/onevm
View File

@ -116,6 +116,13 @@ cmd=CommandParser::CmdParser.new(ARGV) do
:description => "No recover action possible, delete and recreate the VM"
}
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"
}
INTERACTIVE={
:name => "interactive",
:large => "--interactive",
@ -586,10 +593,11 @@ 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
:options => [SUCCESS, FAILURE, RETRY, INTERACTIVE, DELETE, RECREATE, DELETE_DB] do
if !options[:success].nil?
result = 1
elsif !options[:failure].nil?
@ -600,6 +608,8 @@ 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."
@ -607,6 +617,7 @@ cmd=CommandParser::CmdParser.new(ARGV) do
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."
STDERR.puts "\t--delete-db no recover possible, delete the VM from the DB. No action performed on the hypervisor"
exit -1
end

55
src/dm/DispatchManagerActions.cc
View File

@ -263,7 +263,7 @@ error:
/* ************************************************************************** */
/* ************************************************************************** */
void DispatchManager::free_vm_resources(VirtualMachine * vm)
void DispatchManager::free_vm_resources(VirtualMachine * vm, bool check_images)
{
vector<Template *> ds_quotas;
@ -298,7 +298,7 @@ void DispatchManager::free_vm_resources(VirtualMachine * vm)
vm->release_vmgroup();
vm->release_disk_images(ds_quotas);
vm->release_disk_images(ds_quotas, check_images);
vm->set_state(VirtualMachine::DONE);
@ -397,7 +397,7 @@ int DispatchManager::terminate(int vid, bool hard, const RequestAttributes& ra,
case VirtualMachine::HOLD:
case VirtualMachine::CLONING:
case VirtualMachine::CLONING_FAILURE:
free_vm_resources(vm);
free_vm_resources(vm, true);
break;
case VirtualMachine::DONE:
@ -1115,7 +1115,7 @@ int DispatchManager::delete_vm(VirtualMachine * vm, const RequestAttributes& ra,
tm->trigger(TMAction::EPILOG_DELETE, vid);
}
free_vm_resources(vm);
free_vm_resources(vm, true);
break;
case VirtualMachine::STOPPED:
@ -1129,7 +1129,7 @@ int DispatchManager::delete_vm(VirtualMachine * vm, const RequestAttributes& ra,
tm->trigger(TMAction::EPILOG_DELETE, vid);
}
free_vm_resources(vm);
free_vm_resources(vm, true);
break;
case VirtualMachine::INIT:
@ -1137,7 +1137,7 @@ int DispatchManager::delete_vm(VirtualMachine * vm, const RequestAttributes& ra,
case VirtualMachine::HOLD:
case VirtualMachine::CLONING:
case VirtualMachine::CLONING_FAILURE:
free_vm_resources(vm);
free_vm_resources(vm, true);
break;
case VirtualMachine::ACTIVE:
@ -1259,6 +1259,49 @@ int DispatchManager::delete_recreate(VirtualMachine * vm,
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int DispatchManager::delete_vm_db(VirtualMachine * vm,
const RequestAttributes& ra, string& error_str)
{
ostringstream oss;
int cpu, mem, disk;
vector<VectorAttribute *> pci;
int vid = vm->get_oid();
oss << "Deleting VM from DB " << vm->get_oid();
NebulaLog::log("DiM",Log::DEBUG,oss);
switch (vm->get_state())
{
case VirtualMachine::SUSPENDED:
case VirtualMachine::POWEROFF:
case VirtualMachine::ACTIVE:
vm->get_requirements(cpu, mem, disk, pci);
hpool->del_capacity(vm->get_hid(), vid, cpu, mem, disk, pci);
case VirtualMachine::STOPPED:
case VirtualMachine::UNDEPLOYED:
case VirtualMachine::INIT:
case VirtualMachine::PENDING:
case VirtualMachine::HOLD:
case VirtualMachine::CLONING:
case VirtualMachine::CLONING_FAILURE:
free_vm_resources(vm, false);
break;
case VirtualMachine::DONE:
vm->unlock();
break;
}
return 0;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int DispatchManager::attach(int vid, VirtualMachineTemplate * tmpl,
const RequestAttributes& ra, string & err)
{

2
src/dm/DispatchManagerStates.cc
View File

@ -277,7 +277,7 @@ void DispatchManager::done_action(int vid)
(lcm_state == VirtualMachine::EPILOG ||
lcm_state == VirtualMachine::CLEANUP_DELETE))
{
free_vm_resources(vm);
free_vm_resources(vm, true);
}
else
{

2
src/oca/ruby/opennebula/virtual_machine.rb
View File

@ -662,7 +662,7 @@ module OpenNebula
# Recovers an ACTIVE VM
#
# @param result [Integer] Recover with failure (0), success (1),
# retry (2), delete (3), delete-recreate (4)
# retry (2), delete (3), delete-recreate (4), delete-db (5)
# @param result [info] Additional information needed to recover the VM
# @return [nil, OpenNebula::Error] nil in case of success, Error
# otherwise

4
src/rm/RequestManagerVirtualMachine.cc
View File

@ -2496,6 +2496,7 @@ void VirtualMachineRecover::request_execute(
case 3: //delete
case 4: //delete-recreate set same as delete in OpenNebulaTemplate
case 5: //delete-db
aop = nd.get_vm_auth_op(History::DELETE_ACTION);
break;
@ -2540,6 +2541,9 @@ void VirtualMachineRecover::request_execute(
case 4: //delete-recreate
rc = dm->delete_recreate(vm, att, error);
break;
case 5:
rc = dm->delete_vm_db(vm, att, error);
break;
}
if ( rc == 0 )

20
src/vm/VirtualMachine.cc
View File

@ -1108,7 +1108,7 @@ error_graphics:
goto error_rollback;
error_rollback:
release_disk_images(quotas);
release_disk_images(quotas, true);
error_leases_rollback:
release_network_leases();
@ -2933,11 +2933,21 @@ int VirtualMachine::get_disk_images(string& error_str)
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void VirtualMachine::release_disk_images(vector<Template *>& quotas)
void VirtualMachine::release_disk_images(vector<Template *>& quotas,
bool set_state)
{
bool image_error = (state == ACTIVE && lcm_state != EPILOG) &&
state != PENDING && state != HOLD &&
state != CLONING && state != CLONING_FAILURE;
bool image_error;
if ( set_state )
{
image_error = (state == ACTIVE && lcm_state != EPILOG) &&
state != PENDING && state != HOLD &&
state != CLONING && state != CLONING_FAILURE;
}
else
{
image_error = false;
}
disks.release_images(oid, image_error, quotas);
}