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

feature #457: Check LCM state in DM callback actions

Browse Source
This commit is contained in:
Ruben S. Montero 2010-12-30 01:10:24 +01:00
parent 4d56271c7f
commit 50815ee928
2 changed files with 75 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/dm/DispatchManagerStates.cc
View File

@ -28,7 +28,8 @@ void DispatchManager::suspend_success_action(int vid)
return;
}
if (vm->get_state() == VirtualMachine::ACTIVE )
if ((vm->get_state() == VirtualMachine::ACTIVE) &&
(vm->get_lcm_state() == VirtualMachine::SAVE_SUSPEND))
{
vm->set_state(VirtualMachine::SUSPENDED);
@ -66,7 +67,8 @@ void DispatchManager::stop_success_action(int vid)
return;
}
if (vm->get_state() == VirtualMachine::ACTIVE )
if ((vm->get_state() == VirtualMachine::ACTIVE) &&
(vm->get_lcm_state() == VirtualMachine::EPILOG_STOP))
{
vm->set_state(VirtualMachine::STOPPED);
@ -95,7 +97,10 @@ void DispatchManager::stop_success_action(int vid)
void DispatchManager::done_action(int vid)
{
VirtualMachine * vm;
VirtualMachine * vm;
VirtualMachine::LcmState lcm_state;
VirtualMachine::VmState dm_state;
vm = vmpool->get(vid,true);
@ -104,7 +109,13 @@ void DispatchManager::done_action(int vid)
return;
}
if ( vm->get_state() == VirtualMachine::ACTIVE )
lcm_state = vm->get_lcm_state();
dm_state = vm->get_state();
if ((dm_state == VirtualMachine::ACTIVE) &&
(lcm_state == VirtualMachine::EPILOG ||
lcm_state == VirtualMachine::CANCEL ||
lcm_state == VirtualMachine::DELETE ))
{
vm->set_state(VirtualMachine::DONE);
@ -147,21 +158,24 @@ void DispatchManager::failed_action(int vid)
return;
}
vm->set_state(VirtualMachine::LCM_INIT);
if (vm->get_lcm_state() == VirtualMachine::FAILURE)
{
vm->set_state(VirtualMachine::FAILED);
vm->set_state(VirtualMachine::LCM_INIT);
vm->set_exit_time(time(0));
vm->set_state(VirtualMachine::FAILED);
vmpool->update(vm);
vm->set_exit_time(time(0));
vm->log("DiM", Log::INFO, "New VM state is FAILED");
vmpool->update(vm);
vm->unlock();
vm->log("DiM", Log::INFO, "New VM state is FAILED");
vm->unlock();
}
return;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

94
src/lcm/LifeCycleStates.cc
View File

@ -36,7 +36,7 @@ void LifeCycleManager::save_success_action(int vid)
{
Nebula& nd = Nebula::instance();
TransferManager * tm = nd.get_tm();
int cpu,mem,disk;
int cpu,mem,disk;
time_t the_time = time(0);
//----------------------------------------------------
@ -69,11 +69,11 @@ void LifeCycleManager::save_success_action(int vid)
tm->trigger(TransferManager::PROLOG_MIGR,vid);
}
else if ( vm->get_lcm_state() == VirtualMachine::SAVE_SUSPEND)
else if (vm->get_lcm_state() == VirtualMachine::SAVE_SUSPEND)
{
Nebula& nd = Nebula::instance();
DispatchManager * dm = nd.get_dm();
int cpu,mem,disk;
int cpu,mem,disk;
time_t the_time = time(0);
//----------------------------------------------------
@ -100,7 +100,7 @@ void LifeCycleManager::save_success_action(int vid)
{
Nebula& nd = Nebula::instance();
TransferManager * tm = nd.get_tm();
time_t the_time = time(0);
time_t the_time = time(0);
//----------------------------------------------------
// EPILOG_STOP STATE
@ -148,11 +148,11 @@ void LifeCycleManager::save_failure_action(int vid)
if ( vm->get_lcm_state() == VirtualMachine::SAVE_MIGRATE )
{
int cpu,mem,disk;
time_t the_time = time(0);
int cpu,mem,disk;
time_t the_time = time(0);
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
//----------------------------------------------------
// RUNNING STATE FROM SAVE_MIGRATE
@ -191,17 +191,17 @@ void LifeCycleManager::save_failure_action(int vid)
vmpool->update_history(vm);
vm->log("LCM", Log::INFO, "Fail to save VM state while migrating."
" Assuming that the VM is still RUNNING (will poll VM).");
" Assuming that the VM is still RUNNING (will poll VM).");
//----------------------------------------------------
vmm->trigger(VirtualMachineManager::POLL,vid);
}
else if ( vm->get_lcm_state() == VirtualMachine::SAVE_SUSPEND ||
vm->get_lcm_state() == VirtualMachine::SAVE_STOP )
vm->get_lcm_state() == VirtualMachine::SAVE_STOP )
{
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
//----------------------------------------------------
// RUNNING STATE FROM SAVE_SUSPEND OR SAVE_STOP
@ -212,7 +212,7 @@ void LifeCycleManager::save_failure_action(int vid)
vmpool->update(vm);
vm->log("LCM", Log::INFO, "Fail to save VM state."
" Assuming that the VM is still RUNNING (will poll VM).");
" Assuming that the VM is still RUNNING (will poll VM).");
//----------------------------------------------------
@ -242,8 +242,8 @@ void LifeCycleManager::deploy_success_action(int vid)
if ( vm->get_lcm_state() == VirtualMachine::MIGRATE )
{
int cpu,mem,disk;
time_t the_time = time(0);
int cpu,mem,disk;
time_t the_time = time(0);
vm->set_running_stime(the_time);
@ -288,10 +288,10 @@ void LifeCycleManager::deploy_failure_action(int vid)
if ( vm->get_lcm_state() == VirtualMachine::MIGRATE )
{
int cpu,mem,disk;
time_t the_time = time(0);
int cpu,mem,disk;
time_t the_time = time(0);
Nebula& nd = Nebula::instance();
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
//----------------------------------------------------
@ -339,7 +339,7 @@ void LifeCycleManager::deploy_failure_action(int vid)
}
else if (vm->get_lcm_state() == VirtualMachine::BOOT)
{
time_t the_time = time(0);
time_t the_time = time(0);
vm->set_running_etime(the_time);
@ -394,10 +394,10 @@ void LifeCycleManager::shutdown_success_action(int vid)
void LifeCycleManager::shutdown_failure_action(int vid)
{
VirtualMachine * vm;
VirtualMachine * vm;
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
vm = vmpool->get(vid,true);
@ -415,7 +415,7 @@ void LifeCycleManager::shutdown_failure_action(int vid)
vmpool->update(vm);
vm->log("LCM", Log::INFO, "Fail to shutdown VM."
" Assuming that the VM is still RUNNING (will poll VM).");
" Assuming that the VM is still RUNNING (will poll VM).");
//----------------------------------------------------
@ -452,7 +452,7 @@ void LifeCycleManager::prolog_success_action(int vid)
action = VirtualMachineManager::DEPLOY;
}
else if ( lcm_state == VirtualMachine::PROLOG_MIGRATE ||
lcm_state == VirtualMachine::PROLOG_RESUME )
lcm_state == VirtualMachine::PROLOG_RESUME )
{
action = VirtualMachineManager::RESTORE;
}
@ -495,7 +495,7 @@ void LifeCycleManager::prolog_success_action(int vid)
void LifeCycleManager::prolog_failure_action(int vid)
{
VirtualMachine * vm;
time_t the_time = time(0);
time_t the_time = time(0);
vm = vmpool->get(vid,true);
@ -523,7 +523,7 @@ void LifeCycleManager::epilog_success_action(int vid)
VirtualMachine * vm;
time_t the_time = time(0);
int cpu,mem,disk;
int cpu,mem,disk;
DispatchManager::Actions action;
@ -534,11 +534,11 @@ void LifeCycleManager::epilog_success_action(int vid)
return;
}
if ( vm->get_lcm_state() == VirtualMachine::EPILOG_STOP )
if (vm->get_lcm_state() == VirtualMachine::EPILOG_STOP)
{
action = DispatchManager::STOP_SUCCESS;
}
else if ( vm->get_lcm_state() == VirtualMachine::EPILOG)
else if (vm->get_lcm_state() == VirtualMachine::EPILOG)
{
action = DispatchManager::DONE;
}
@ -599,8 +599,8 @@ void LifeCycleManager::epilog_failure_action(int vid)
void LifeCycleManager::cancel_success_action(int vid)
{
VirtualMachine * vm;
time_t the_time = time(0);
int cpu,mem,disk;
time_t the_time = time(0);
int cpu,mem,disk;
Nebula& nd = Nebula::instance();
DispatchManager * dm = nd.get_dm();
@ -637,8 +637,8 @@ void LifeCycleManager::cancel_failure_action(int vid)
{
VirtualMachine * vm;
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
Nebula& nd = Nebula::instance();
VirtualMachineManager * vmm = nd.get_vmm();
vm = vmpool->get(vid,true);
@ -656,7 +656,7 @@ void LifeCycleManager::cancel_failure_action(int vid)
vmpool->update(vm);
vm->log("LCM", Log::INFO, "Fail to cancel VM."
" Assuming that the VM is still RUNNING (will poll VM).");
" Assuming that the VM is still RUNNING (will poll VM).");
//----------------------------------------------------
@ -672,7 +672,7 @@ void LifeCycleManager::monitor_failure_action(int vid)
{
VirtualMachine * vm;
time_t the_time = time(0);
time_t the_time = time(0);
vm = vmpool->get(vid,true);
@ -695,10 +695,10 @@ void LifeCycleManager::monitor_suspend_action(int vid)
{
VirtualMachine * vm;
int cpu,mem,disk;
time_t the_time = time(0);
int cpu,mem,disk;
time_t the_time = time(0);
Nebula& nd = Nebula::instance();
Nebula& nd = Nebula::instance();
DispatchManager * dm = nd.get_dm();
vm = vmpool->get(vid,true);
@ -708,6 +708,14 @@ void LifeCycleManager::monitor_suspend_action(int vid)
return;
}
//----------------------------------------------------
// SAVE_SUSPEND STATE
//----------------------------------------------------
vm->set_state(VirtualMachine::SAVE_SUSPEND);
vmpool->update(vm);
vm->set_running_etime(the_time);
vm->set_etime(the_time);
@ -726,7 +734,6 @@ void LifeCycleManager::monitor_suspend_action(int vid)
dm->trigger(DispatchManager::SUSPEND_SUCCESS,vid);
vm->unlock();
}
@ -745,7 +752,7 @@ void LifeCycleManager::monitor_done_action(int vid)
}
//----------------------------------------------------
// EPILOG STATE
// UNKNWON STATE
//----------------------------------------------------
vm->set_state(VirtualMachine::UNKNOWN);
@ -765,12 +772,12 @@ void LifeCycleManager::monitor_done_action(int vid)
void LifeCycleManager::failure_action(VirtualMachine * vm)
{
Nebula& nd = Nebula::instance();
TransferManager * tm = nd.get_tm();
Nebula& nd = Nebula::instance();
TransferManager * tm = nd.get_tm();
DispatchManager * dm = nd.get_dm();
time_t the_time = time(0);
int cpu,mem,disk;
time_t the_time = time(0);
int cpu,mem,disk;
//----------------------------------------------------
// LCM FAILURE STATE
@ -799,4 +806,3 @@ void LifeCycleManager::failure_action(VirtualMachine * vm)
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */