shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2025-04-01 06:50:25 +03:00
Code Releases Wiki Activity

Feature : Refactor VM state change log

Browse Source 
(cherry picked from commit 329f0ef0fd099c46b2c5b30c61093c421d961e2b)
This commit is contained in:
Carlos Martín 2015-03-30 11:17:36 +02:00 committed by Ruben S. Montero
parent 7f13981543
commit e95bde2a73
5 changed files with 36 additions and 127 deletions

20
include/VirtualMachine.h

@ -297,6 +297,18 @@ public:
}
};
/**
* writes a log message in vm.log. The class lock should be locked and
* the VM MUST BE obtained through the VirtualMachinePool get() method.
*/
void log(
const char * module,
const Log::MessageType type,
const string& message) const
{
log(module, type, message.c_str());
};
/**
* Function to print the VirtualMachine object into a string in
* XML format
@ -1021,7 +1033,11 @@ public:
*/
void set_state(VmState s)
{
string st;
state = s;
log("VM", Log::INFO, "New state is " + vm_state_to_str(st, s));
};
/**
@ -1030,7 +1046,11 @@ public:
*/
void set_state(LcmState s)
{
string st;
lcm_state = s;
log("VM", Log::INFO, "New LCM state is " + lcm_state_to_str(st, s));
};
/**

18
src/dm/DispatchManagerActions.cc

@ -50,8 +50,6 @@ int DispatchManager::deploy (
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is ACTIVE.");
lcm->trigger(LifeCycleManager::DEPLOY,vid);
}
else
@ -119,8 +117,6 @@ int DispatchManager::import (
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is RUNNING");
vm->unlock();
return 0;
@ -402,8 +398,6 @@ int DispatchManager::hold(
vm->set_state(VirtualMachine::HOLD);
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is HOLD.");
}
else
{
@ -448,8 +442,6 @@ int DispatchManager::release(
vm->set_state(VirtualMachine::PENDING);
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is PENDING.");
}
else
{
@ -633,16 +625,12 @@ int DispatchManager::resume(
vm->set_state(VirtualMachine::PENDING);
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is PENDING.");
}
else if (vm->get_state() == VirtualMachine::SUSPENDED)
{
Nebula& nd = Nebula::instance();
LifeCycleManager * lcm = nd.get_lcm();
vm->log("DiM", Log::INFO, "New VM state is ACTIVE.");
lcm->trigger(LifeCycleManager::RESTORE,vid);
}
else if (vm->get_state() == VirtualMachine::POWEROFF)
@ -650,8 +638,6 @@ int DispatchManager::resume(
Nebula& nd = Nebula::instance();
LifeCycleManager * lcm = nd.get_lcm();
vm->log("DiM", Log::INFO, "New VM state is ACTIVE.");
lcm->trigger(LifeCycleManager::RESTART,vid);
}
else
@ -885,8 +871,6 @@ void DispatchManager::finalize_cleanup(VirtualMachine * vm)
vm->set_state(VirtualMachine::DONE);
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is DONE.");
uid = vm->get_uid();
gid = vm->get_gid();
tmpl = vm->clone_template();
@ -1007,8 +991,6 @@ int DispatchManager::resubmit(int vid)
vm->set_state(VirtualMachine::PENDING);
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is PENDING.");
break;
case VirtualMachine::ACTIVE: //Cleanup VM resources before PENDING

12
src/dm/DispatchManagerStates.cc

@ -40,8 +40,6 @@ void DispatchManager::suspend_success_action(int vid)
vm->set_state(VirtualMachine::LCM_INIT);
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is SUSPENDED");
}
else
{
@ -88,8 +86,6 @@ void DispatchManager::stop_success_action(int vid)
}
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is STOPPED");
}
else
{
@ -136,8 +132,6 @@ void DispatchManager::undeploy_success_action(int vid)
}
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is UNDEPLOYED");
}
else
{
@ -179,8 +173,6 @@ void DispatchManager::poweroff_success_action(int vid)
vm->set_state(VirtualMachine::LCM_INIT);
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is POWEROFF");
}
else
{
@ -237,8 +229,6 @@ void DispatchManager::done_action(int vid)
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is DONE");
uid = vm->get_uid();
gid = vm->get_gid();
tmpl = vm->clone_template();
@ -285,8 +275,6 @@ void DispatchManager::resubmit_action(int vid)
vmpool->update(vm);
vm->log("DiM", Log::INFO, "New VM state is PENDING");
vm->unlock();
}

55
src/lcm/LifeCycleActions.cc

@ -74,8 +74,6 @@ void LifeCycleManager::deploy_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is PROLOG.");
//----------------------------------------------------
if (hpool->add_capacity(vm->get_hid(),vm->get_oid(),cpu,mem,disk) == -1)
@ -132,8 +130,6 @@ void LifeCycleManager::suspend_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is SAVE_SUSPEND");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::SAVE,vid);
@ -180,8 +176,6 @@ void LifeCycleManager::stop_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is SAVE_STOP");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::SAVE,vid);
@ -205,8 +199,6 @@ void LifeCycleManager::stop_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_STOP");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG_STOP,vid);
@ -265,8 +257,6 @@ void LifeCycleManager::migrate_action(int vid)
hpool->add_capacity(vm->get_hid(), vm->get_oid(), cpu, mem, disk);
vm->log("LCM", Log::INFO, "New VM state is SAVE_MIGRATE");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::SAVE,vid);
@ -280,12 +270,10 @@ void LifeCycleManager::migrate_action(int vid)
if (vm->get_state() == VirtualMachine::POWEROFF)
{
vm->set_state(VirtualMachine::PROLOG_MIGRATE_POWEROFF);
vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_POWEROFF");
}
else //if (vm->get_state() == VirtualMachine::SUSPENDED)
else // VirtualMachine::SUSPENDED
{
vm->set_state(VirtualMachine::PROLOG_MIGRATE_SUSPEND);
vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_SUSPEND");
}
vm->set_state(VirtualMachine::ACTIVE);
@ -355,8 +343,6 @@ void LifeCycleManager::migrate_action(int vid)
hpool->del_capacity(vm->get_previous_hid(), vm->get_oid(), cpu, mem, disk);
vm->log("LCM", Log::INFO, "New VM state is BOOT");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::DEPLOY, vid);
@ -413,8 +399,6 @@ void LifeCycleManager::live_migrate_action(int vid)
hpool->add_capacity(vm->get_hid(), vm->get_oid(), cpu, mem, disk);
vm->log("LCM",Log::INFO,"New VM state is MIGRATE");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::MIGRATE,vid);
@ -462,8 +446,6 @@ void LifeCycleManager::shutdown_action(int vid)
vmpool->update_history(vm);
vm->log("LCM",Log::INFO,"New VM state is SHUTDOWN");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::SHUTDOWN,vid);
@ -489,8 +471,6 @@ void LifeCycleManager::shutdown_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG,vid);
@ -534,8 +514,6 @@ void LifeCycleManager::undeploy_action(int vid, bool hard)
vmpool->update(vm);
vm->log("LCM",Log::INFO,"New VM state is SHUTDOWN_UNDEPLOY");
//----------------------------------------------------
if (hard)
@ -573,8 +551,6 @@ void LifeCycleManager::undeploy_action(int vid, bool hard)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_UNDEPLOY");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG_STOP,vid);
@ -637,8 +613,6 @@ void LifeCycleManager::poweroff_action(int vid, bool hard)
vmpool->update(vm);
vm->log("LCM",Log::INFO,"New VM state is SHUTDOWN_POWEROFF");
//----------------------------------------------------
if (hard)
@ -708,8 +682,6 @@ void LifeCycleManager::restore_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New state is BOOT_SUSPENDED");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::RESTORE,vid);
@ -757,8 +729,6 @@ void LifeCycleManager::cancel_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New state is CANCEL");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::CANCEL,vid);
@ -784,8 +754,6 @@ void LifeCycleManager::cancel_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG,vid);
@ -841,7 +809,6 @@ void LifeCycleManager::restart_action(int vid)
case VirtualMachine::BOOT_UNKNOWN:
case VirtualMachine::BOOT_POWEROFF:
action = VirtualMachineManager::DEPLOY;
vm->log("LCM", Log::INFO, "Sending BOOT command to VM again");
break;
@ -850,18 +817,28 @@ void LifeCycleManager::restart_action(int vid)
case VirtualMachine::BOOT_UNDEPLOY:
case VirtualMachine::BOOT_MIGRATE:
action = VirtualMachineManager::RESTORE;
vm->log("LCM", Log::INFO, "Sending RESTORE command to VM again");
break;
case VirtualMachine::UNKNOWN:
action = VirtualMachineManager::DEPLOY;
vm->set_state(VirtualMachine::BOOT_UNKNOWN);
vmpool->update(vm);
break;
vm->log("LCM", Log::INFO, "New VM state is BOOT_UNKNOWN");
case VirtualMachine::BOOT_FAILURE:
action = VirtualMachineManager::DEPLOY;
vm->set_state(VirtualMachine::BOOT);
vmpool->update(vm);
break;
case VirtualMachine::BOOT_MIGRATE_FAILURE:
action = VirtualMachineManager::RESTORE;
vm->set_state(VirtualMachine::BOOT_MIGRATE);
vmpool->update(vm);
break;
default:
@ -890,8 +867,6 @@ void LifeCycleManager::restart_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is BOOT_POWEROFF");
vmm->trigger(VirtualMachineManager::DEPLOY, vid);
}
}
@ -1043,8 +1018,6 @@ void LifeCycleManager::clean_up_vm(VirtualMachine * vm, bool dispose, int& imag
VirtualMachine::LcmState state = vm->get_lcm_state();
int vid = vm->get_oid();
vm->log("LCM", Log::INFO, "New VM state is CLEANUP.");
if (dispose)
{
vm->set_state(VirtualMachine::CLEANUP_DELETE);

58
src/lcm/LifeCycleStates.cc

@ -70,8 +70,6 @@ void LifeCycleManager::save_success_action(int vid)
hpool->del_capacity(vm->get_previous_hid(), vm->get_oid(), cpu, mem, disk);
vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE");
//----------------------------------------------------
tm->trigger(TransferManager::PROLOG_MIGR,vid);
@ -134,8 +132,6 @@ void LifeCycleManager::save_success_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_STOP");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG_STOP,vid);
@ -300,8 +296,6 @@ void LifeCycleManager::deploy_success_action(int vid)
vm->delete_snapshots();
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is RUNNING");
}
else if ( vm->get_lcm_state() == VirtualMachine::BOOT ||
vm->get_lcm_state() == VirtualMachine::BOOT_POWEROFF ||
@ -316,8 +310,6 @@ void LifeCycleManager::deploy_success_action(int vid)
vm->set_state(VirtualMachine::RUNNING);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is RUNNING");
}
else
{
@ -408,24 +400,18 @@ void LifeCycleManager::deploy_failure_action(int vid)
vm->set_state(VirtualMachine::BOOT_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "Fail to boot VM. New VM state is BOOT_FAILURE");
}
else if (vm->get_lcm_state() == VirtualMachine::BOOT_MIGRATE)
{
vm->set_state(VirtualMachine::BOOT_MIGRATE_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "Fail to boot VM. New VM state is BOOT_MIGRATE_FAILURE");
}
else if (vm->get_lcm_state() == VirtualMachine::BOOT_UNKNOWN)
{
vm->set_state(VirtualMachine::UNKNOWN);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "Fail to boot VM. New VM state is UNKNOWN");
}
else if (vm->get_lcm_state() == VirtualMachine::BOOT_POWEROFF)
{
@ -440,8 +426,6 @@ void LifeCycleManager::deploy_failure_action(int vid)
vmpool->update(vm);
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "Fail to boot VM. New VM state is POWEROFF");
}
else if (vm->get_lcm_state() == VirtualMachine::BOOT_SUSPENDED)
{
@ -456,8 +440,6 @@ void LifeCycleManager::deploy_failure_action(int vid)
vmpool->update(vm);
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "Fail to boot VM. New VM state is SUSPENDED");
}
else if (vm->get_lcm_state() == VirtualMachine::BOOT_STOPPED)
{
@ -481,8 +463,6 @@ void LifeCycleManager::deploy_failure_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "Fail to boot VM. New VM state is EPILOG_STOP");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG_STOP,vid);
@ -509,8 +489,6 @@ void LifeCycleManager::deploy_failure_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "Fail to boot VM. New VM state is EPILOG_UNDEPLOY");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG_STOP,vid);
@ -566,8 +544,6 @@ void LifeCycleManager::shutdown_success_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG,vid);
@ -622,8 +598,6 @@ void LifeCycleManager::shutdown_success_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_UNDEPLOY");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG_STOP,vid);
@ -832,30 +806,22 @@ void LifeCycleManager::prolog_failure_action(int vid)
{
vm->set_state(VirtualMachine::PROLOG_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is PROLOG_FAILURE");
}
else if ( state == VirtualMachine::PROLOG_MIGRATE )
{
vm->set_state(VirtualMachine::PROLOG_MIGRATE_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_FAILURE");
}
else if ( state == VirtualMachine::PROLOG_MIGRATE_POWEROFF )
{
vm->set_state(VirtualMachine::PROLOG_MIGRATE_POWEROFF_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_POWEROFF_FAILURE");
}
else if ( state == VirtualMachine::PROLOG_MIGRATE_SUSPEND )
{
vm->set_state(VirtualMachine::PROLOG_MIGRATE_SUSPEND_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_SUSPEND_FAILURE");
}
else if ( state == VirtualMachine::PROLOG_RESUME )
{
@ -966,22 +932,16 @@ void LifeCycleManager::epilog_success_action(int vid)
{
vm->set_state(VirtualMachine::EPILOG_STOP);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_STOP");
}
else if ( state == VirtualMachine::EPILOG_UNDEPLOY_FAILURE )
{
vm->set_state(VirtualMachine::EPILOG_UNDEPLOY);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_UNDEPLOY");
}
else if ( state == VirtualMachine::EPILOG_FAILURE )
{
vm->set_state(VirtualMachine::EPILOG);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG");
}
state = vm->get_lcm_state();
@ -1100,22 +1060,16 @@ void LifeCycleManager::epilog_failure_action(int vid)
{
vm->set_state(VirtualMachine::EPILOG_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_FAILURE");
}
else if ( state == VirtualMachine::EPILOG_STOP )
{
vm->set_state(VirtualMachine::EPILOG_STOP_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_STOP_FAILURE");
}
else if ( state == VirtualMachine::EPILOG_UNDEPLOY )
{
vm->set_state(VirtualMachine::EPILOG_UNDEPLOY_FAILURE);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_UNDEPLOY_FAILURE");
}
//wrong state + recover failure from failure state
else if ( state != VirtualMachine::EPILOG_FAILURE &&
@ -1171,8 +1125,6 @@ void LifeCycleManager::cancel_success_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG,vid);
@ -1200,8 +1152,6 @@ void LifeCycleManager::cancel_success_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is EPILOG_UNDEPLOY");
//----------------------------------------------------
tm->trigger(TransferManager::EPILOG_STOP,vid);
@ -1315,6 +1265,8 @@ void LifeCycleManager::monitor_suspend_action(int vid)
// SAVE_SUSPEND STATE
//----------------------------------------------------
vm->log("LCM", Log::INFO, "Polling reports that the VM is suspended.");
vm->set_state(VirtualMachine::SAVE_SUSPEND);
vm->set_resched(false);
@ -1336,8 +1288,6 @@ void LifeCycleManager::monitor_suspend_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "VM is suspended.");
//----------------------------------------------------
dm->trigger(DispatchManager::SUSPEND_SUCCESS,vid);
@ -1375,8 +1325,6 @@ void LifeCycleManager::monitor_done_action(int vid)
vm->set_resched(false);
vmpool->update(vm);
vm->log("LCM", Log::INFO, "New VM state is UNKNOWN");
}
// This event can be received when the VM is in PROLOG, BOOT...
// and other transient states (through host monitor probe).
@ -1473,8 +1421,6 @@ void LifeCycleManager::monitor_poweron_action(int vid)
vm->set_last_poll(the_time);
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "New VM state is RUNNING");
}
vm->unlock();