From 701f33ca5f83eece0876362c9274a71cd364f09e Mon Sep 17 00:00:00 2001 From: "Ruben S. Montero" Date: Sat, 16 Feb 2013 02:55:17 +0100 Subject: [PATCH] featue #1739: Move Host and VM update functions to each class. --- include/Host.h | 66 +++++--- include/PoolObjectSQL.h | 20 ++- include/VirtualMachine.h | 35 +---- include/VirtualMachineManager.h | 5 - include/VirtualMachineManagerDriver.h | 35 +++-- src/host/Host.cc | 149 +++++++++++++++++- src/im/InformationManagerDriver.cc | 201 ++++++------------------- src/pool/PoolObjectSQL.cc | 32 ++-- src/vm/VirtualMachine.cc | 41 +++++ src/vmm/VirtualMachineManager.cc | 6 +- src/vmm/VirtualMachineManagerDriver.cc | 149 +++++++++++------- 11 files changed, 422 insertions(+), 317 deletions(-) diff --git a/include/Host.h b/include/Host.h index 712ffb35bb..3f740cf87b 100644 --- a/include/Host.h +++ b/include/Host.h @@ -80,27 +80,6 @@ public: return ((state == MONITORING_ERROR) || (state==MONITORING_MONITORED)); } - /** - * Updates the Host's last_monitored time stamp. - * @param success if the monitored action was successfully performed - */ - void touch(bool success) - { - last_monitored = time(0); - - if ( state != DISABLED) //Don't change the state is host is disabled - { - if (success == true) - { - state = MONITORED; - } - else - { - state = ERROR; - } - } - }; - /** * Disables the current host, it will not be monitored nor used by the * scheduler @@ -119,11 +98,27 @@ public: state = INIT; }; - /** Update host counters and update the whole host on the DB + /** + * Update host after a successful monitor. It modifies counters, state + * and template attributes * @param parse_str string with values to be parsed + * @param with_vm_info if monitoring contains VM information + * @param lost set of VMs that should be in the host and were not found + * @param found VMs running in the host (as expected) and info. * @return 0 on success **/ - int update_info(string &parse_str); + int update_info(string &parse_str, + bool &with_vm_info, + set &lost, + map &found); + + /** + * Update host after a failed monitor. It state + * and template attributes + * @param message from the driver + * @param vm_ids running on the host + */ + void error_info(const string& message, set &vm_ids); /** * Inserts the last monitoring, and deletes old monitoring entries. @@ -419,6 +414,31 @@ private: virtual ~Host(); + // ************************************************************************* + // Host Management + // ************************************************************************* + + /** + * Updates the Host's last_monitored time stamp. + * @param success if the monitored action was successfully performed + */ + void touch(bool success) + { + last_monitored = time(0); + + if ( state != DISABLED) //Don't change the state is host is disabled + { + if (success == true) + { + state = MONITORED; + } + else + { + state = ERROR; + } + } + }; + // ************************************************************************* // DataBase implementation (Private) // ************************************************************************* diff --git a/include/PoolObjectSQL.h b/include/PoolObjectSQL.h index f3cefd37a8..812a587157 100644 --- a/include/PoolObjectSQL.h +++ b/include/PoolObjectSQL.h @@ -408,12 +408,24 @@ public: void clear_template_error_message(); /** - * Sets a message with timestamp in the template + * Adds a string attribute * @param att_name Name for the attribute - * @param message Message string - * @return 0 on success + * @param att_val Message string */ - void set_template_message(const string& att_name, const string& message); + void add_template_attribute(const string& name, const string& value) + { + obj_template->add(name, value); + } + + /** + * Adds an int attribute + * @param att_name Name for the attribute + * @param att_val integer + */ + void add_template_attribute(const string& name, int value) + { + obj_template->add(name, value); + } /** * Factory method for templates, it should be implemented diff --git a/include/VirtualMachine.h b/include/VirtualMachine.h index e3a88b61bb..ec52350bed 100644 --- a/include/VirtualMachine.h +++ b/include/VirtualMachine.h @@ -171,7 +171,7 @@ public: }; /** - * Updates VM dynamic information (usage counters). + * Updates VM dynamic information (usage counters), and updates last_poll * @param _memory Kilobytes used by the VM (total) * @param _cpu used by the VM (rate) * @param _net_tx transmitted bytes (total) @@ -181,28 +181,8 @@ public: const int _memory, const int _cpu, const long long _net_tx, - const long long _net_rx) - { - if (_memory != -1) - { - memory = _memory; - } - - if (_cpu != -1) - { - cpu = _cpu; - } - - if (_net_tx != -1) - { - net_tx = _net_tx; - } - - if (_net_rx != -1) - { - net_rx = _net_rx; - } - }; + const long long _net_rx, + const map &custom); /** * Returns the deployment ID @@ -778,15 +758,6 @@ public: return last_poll; }; - /** - * Sets time of last information polling. - * @param poll time in epoch, normally time(0) - */ - void set_last_poll(time_t poll) - { - last_poll = poll; - }; - /** * Get the VM physical requirements for the host. * @param cpu diff --git a/include/VirtualMachineManager.h b/include/VirtualMachineManager.h index 96b9d4473a..0191a366ba 100644 --- a/include/VirtualMachineManager.h +++ b/include/VirtualMachineManager.h @@ -121,11 +121,6 @@ private: */ time_t timer_period; - /** - * Time when the VMM was started - */ - time_t timer_start; - /** * Virtual Machine polling interval */ diff --git a/include/VirtualMachineManagerDriver.h b/include/VirtualMachineManagerDriver.h index 78132a45f4..531c822134 100644 --- a/include/VirtualMachineManagerDriver.h +++ b/include/VirtualMachineManagerDriver.h @@ -84,13 +84,6 @@ public: */ static void process_poll(VirtualMachine* vm, const string &monitor_str); - /** - * Updates the VM after a failed poll driver action - * - * @param id VM id - */ - static void process_failed_poll(int id); - protected: /** * Gets a configuration attr from driver configuration file (single @@ -291,8 +284,6 @@ private: write_drv("DETACHDISK", oid, drv_msg); } -private: - void write_drv(const char * aname, const int oid, const string& msg) const { ostringstream os; @@ -301,6 +292,32 @@ private: write(os); } + + /** + * Gets VM information from the driver answer + * @param monitor_str from the driver + * @param memory Kilobytes used by the VM (total) + * @param cpu used by the VM (rate) + * @param net_tx transmitted bytes (total) + * @param net_rx received bytes (total) + * @param state of the vm + * @param custom monitor information + */ + static int parse_vm_info( + const string& monitor_str, + int &cpu, + int &memory, + long long &net_tx, + long long &net_rx, + char &state, + map &custom); + + /** + * Based on the monitoring state updates or trigger LCM actions + * @param vm virtual machine + * @param state from driver + */ + static void process_poll_state(VirtualMachine* vm, char state); }; /* -------------------------------------------------------------------------- */ diff --git a/src/host/Host.cc b/src/host/Host.cc index e8fd0c4684..c196d1b5b1 100644 --- a/src/host/Host.cc +++ b/src/host/Host.cc @@ -170,22 +170,60 @@ error_common: /* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */ -int Host::update_info(string &parse_str) +int Host::update_info(string &parse_str, + bool &with_vm_info, + set &lost, + map &found) { - char * error_msg; - int rc; - float fv; + char * error_msg; + Template* tmpl; + VectorAttribute* vatt; + vector::iterator it; + vector vm_att; + + int rc; + int vmid; + float fv; + + ostringstream zombie; + ostringstream wild; + + int num_zombies = 0; + int num_wilds = 0; + + // + // ---------------------------------------------------------------------- // + // Parse Template (twice because of repeated VM values) // + // ---------------------------------------------------------------------- // rc = obj_template->parse(parse_str, &error_msg); if ( rc != 0 ) { - NebulaLog::log("ONE", Log::ERROR, error_msg); + ostringstream ess; + + ess << "Error parsing host information: " << error_msg + << "Monitoring information: " << parse_str; + + NebulaLog::log("ONE", Log::ERROR, ess); + + touch(false); + + set_template_error_message("Error parsing monitor information." + " Check oned.log for more details."); free(error_msg); + return -1; } + tmpl = new Template(); + + tmpl->parse(parse_str, &error_msg); + + // ---------------------------------------------------------------------- // + // Extract share information // + // ---------------------------------------------------------------------- // get_template_attribute("TOTALCPU", fv); host_share.max_cpu = static_cast(fv); get_template_attribute("TOTALMEMORY", fv); @@ -201,12 +239,113 @@ int Host::update_info(string &parse_str) get_template_attribute("USEDMEMORY", fv); host_share.used_mem = static_cast(fv); + // ---------------------------------------------------------------------- // + // Remove expired information // + // ---------------------------------------------------------------------- // + clear_template_error_message(); + + remove_template_attribute("ZOMBIES"); + remove_template_attribute("TOTAL_ZOMBIES"); + + remove_template_attribute("WILDS"); + remove_template_attribute("TOTAL_WILDS"); + + remove_template_attribute("VM"); + + get_template_attribute("VM_POLL", with_vm_info); + remove_template_attribute("VM_POLL"); + + // ---------------------------------------------------------------------- // + // Correlate VM information with the list of running VMs // + // ---------------------------------------------------------------------- // + tmpl->remove("VM", vm_att); + + lost = get_running_vms(); + + for (it = vm_att.begin(); it != vm_att.end(); it++) + { + vatt = dynamic_cast(*it); + + if (vatt == 0) + { + delete *it; + continue; + } + + rc = vatt->vector_value("ID", vmid); + + if (rc == 0 && vmid != -1) + { + if (lost.erase(vmid) == 1) //Good, known + { + found.insert(make_pair(vmid, vatt->vector_value("POLL"))); + } + else //Bad, known but should not be here + { + if (num_zombies++ > 0) + { + zombie << ", "; + } + + zombie << vatt->vector_value("DEPLOY_ID"); + } + } + else if (rc == 0) //not ours + { + if (num_wilds++ > 0) + { + wild << ", "; + } + + wild << vatt->vector_value("DEPLOY_ID"); + } + + delete *it; + } + + if (num_wilds > 0) + { + add_template_attribute("TOTAL_WILDS", num_wilds); + add_template_attribute("WILDS", wild.str()); + } + + if (num_zombies > 0) + { + add_template_attribute("TOTAL_ZOMBIES", num_zombies); + add_template_attribute("ZOMBIES", zombie.str()); + } + + delete tmpl; + + // Touch the host to update its last_monitored timestamp and state + + touch(true); + return 0; } /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ +void Host::error_info(const string& message, set &vm_ids) +{ + ostringstream oss; + + vm_ids = vm_collection.get_collection_copy(); + + oss << "Error monitoring Host " << get_name() << " (" << get_oid() << ")" + << ": " << message; + + NebulaLog::log("ONE", Log::ERROR, oss); + + touch(false); + + set_template_error_message(oss.str()); +} + +/* -------------------------------------------------------------------------- */ +/* -------------------------------------------------------------------------- */ + int Host::update_monitoring(SqlDB * db) { ostringstream oss; diff --git a/src/im/InformationManagerDriver.cc b/src/im/InformationManagerDriver.cc index 3361a765d6..67d07ddf86 100644 --- a/src/im/InformationManagerDriver.cc +++ b/src/im/InformationManagerDriver.cc @@ -16,6 +16,7 @@ #include "InformationManagerDriver.h" #include "NebulaLog.h" +#include "Nebula.h" #include "Util.h" #include "VirtualMachineManagerDriver.h" #include @@ -96,6 +97,11 @@ void InformationManagerDriver::protocol( { bool vm_poll; + set lost; + map found; + + int rc; + host = hpool->get(id,true); if ( host == 0 ) @@ -103,167 +109,72 @@ void InformationManagerDriver::protocol( goto error_host; } - vm_ids = host->get_running_vms(); - getline (is, hinfo64); hinfo = one_util::base64_decode(hinfo64); if (result != "SUCCESS") { - goto error_driver_info; + set vm_ids; + + host->error_info(*hinfo, vm_ids); + + for (set::iterator it = vm_ids.begin(); it != vm_ids.end(); it++) + { + Nebula &ne = Nebula::instance(); + LifeCycleManager *lcm = ne.get_lcm(); + + lcm->trigger(LifeCycleManager::MONITOR_DONE, *it); + } + + delete hinfo; + + hpool->update(host); + host->unlock(); + + return; } - int rc; - - ostringstream oss; - - int vmid; - char * error_msg; - string monitor_str; - - VectorAttribute* vatt; - vector vm_att; - vector::iterator it; - - oss << "Host " << id << " successfully monitored."; - NebulaLog::log("InM", Log::DEBUG, oss); - - rc = host->update_info(*hinfo); + rc = host->update_info(*hinfo, vm_poll, lost, found); if (rc != 0) { - ess << "Error parsing host information: " << *hinfo; delete hinfo; - goto error_common_info; + hpool->update(host); + host->unlock(); + + return; } - host->clear_template_error_message(); - host->remove_template_attribute("INFO_MESSAGE"); - - // The hinfo string is parsed again because HostTemplate has - // replace_mode set to true, but we expect several VM vector attributes - Template* tmpl = new Template(); - tmpl->parse(*hinfo, &error_msg); - - tmpl->remove("VM", vm_att); - delete hinfo; - host->get_template_attribute("VM_POLL", vm_poll); - - host->remove_template_attribute("VM_POLL"); - host->remove_template_attribute("VM"); - - host->touch(true); - hpool->update(host); hpool->update_monitoring(host); + ess << "Host " << host->get_name() << " (" << host->get_oid() << ")" + << " successfully monitored."; + + NebulaLog::log("InM", Log::DEBUG, ess); + host->unlock(); - vector external_vms; - map rogue_vms; - - for (it=vm_att.begin(); it != vm_att.end(); it++) - { - vatt = dynamic_cast(*it); - - if (vatt == 0) - { - delete *it; - continue; - } - - rc = vatt->vector_value("ID", vmid); - - if (rc == 0 && vmid != -1) - { - if (vm_ids.erase(vmid) == 1) - { - monitor_str = vatt->vector_value("POLL"); - - VirtualMachineManagerDriver::process_poll(vmid, monitor_str); - } - else - { - rogue_vms[vmid] = vatt->vector_value("DEPLOY_ID"); - } - } - else if (rc == 0) - { - external_vms.push_back( vatt->vector_value("DEPLOY_ID") ); - } - - delete *it; - } - if (vm_poll) { - for (set::iterator it = vm_ids.begin(); it != vm_ids.end(); it++) + set::iterator its; + map::iterator itm; + + for (its = lost.begin(); its != lost.end(); its++) { - // This VM should be running on this host, but it was not reported + Nebula &ne = Nebula::instance(); + LifeCycleManager *lcm = ne.get_lcm(); - VirtualMachineManagerDriver::process_failed_poll(*it); - } - } - - bool log_error = false; - bool log_info = false; - - if (!rogue_vms.empty()) - { - log_error = true; - - map::iterator it; - - ess.str(""); - ess << "Manual intervention required, these VMs should" - << " not be running on Host " << id << ":"; - - for(it = rogue_vms.begin(); it != rogue_vms.end(); it++) - { - ess << " VM " << it->first << " (hypervisor name '" << it->second << "')"; + lcm->trigger(LifeCycleManager::MONITOR_DONE, *its); } - NebulaLog::log("InM",Log::ERROR,ess); - } - - if (!external_vms.empty()) - { - log_info = true; - - vector::iterator it; - - oss.str(""); - oss << "External VMs found:"; - - for(it = external_vms.begin(); it != external_vms.end(); it++) + for (itm = found.begin(); itm != found.end(); itm++) { - oss << " " << *it; - } - } - - if (log_error || log_info) - { - host = hpool->get(id,true); - - if ( host != 0 ) - { - if (log_error) - { - host->set_template_error_message(ess.str()); - } - - if (log_info) - { - host->set_template_message("INFO_MESSAGE", oss.str()); - } - - hpool->update(host); - - host->unlock(); + VirtualMachineManagerDriver::process_poll(itm->first, itm->second); } } } @@ -277,31 +188,6 @@ void InformationManagerDriver::protocol( return; -error_driver_info: - ess << "Error monitoring host " << id << " : " << *hinfo; - - delete hinfo; - - for (set::iterator it = vm_ids.begin(); it != vm_ids.end(); it++) - { - VirtualMachineManagerDriver::process_failed_poll(*it); - } - - goto error_common_info; - -error_common_info: - NebulaLog::log("InM",Log::ERROR,ess); - - host->set_template_error_message(ess.str()); - - host->touch(false); - - hpool->update(host); - - host->unlock(); - - return; - error_host: ess << "Could not get host " << id; NebulaLog::log("InM",Log::ERROR,ess); @@ -309,7 +195,6 @@ error_host: return; error_parse: - ess << "Error while parsing driver message: " << message; NebulaLog::log("InM",Log::ERROR,ess); diff --git a/src/pool/PoolObjectSQL.cc b/src/pool/PoolObjectSQL.cc index 2549fa140d..dcf4cc2777 100644 --- a/src/pool/PoolObjectSQL.cc +++ b/src/pool/PoolObjectSQL.cc @@ -138,7 +138,17 @@ const char * PoolObjectSQL::error_attribute_name = "ERROR"; void PoolObjectSQL::set_template_error_message(const string& message) { - set_template_message(error_attribute_name, message); + SingleAttribute * attr; + ostringstream error_value; + + error_value << one_util::log_time() << " : " << message; + + //Replace previous error message and insert the new one + + attr = new SingleAttribute(error_attribute_name, error_value.str()); + + obj_template->erase(error_attribute_name); + obj_template->set(attr); } /* -------------------------------------------------------------------------- */ @@ -152,26 +162,6 @@ void PoolObjectSQL::clear_template_error_message() /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ -void PoolObjectSQL::set_template_message( - const string& att_name, - const string& message) -{ - SingleAttribute * attr; - ostringstream error_value; - - error_value << one_util::log_time() << " : " << message; - - //Replace previous error message and insert the new one - - attr = new SingleAttribute(att_name, error_value.str()); - - obj_template->erase(att_name); - obj_template->set(attr); -} - -/* -------------------------------------------------------------------------- */ -/* -------------------------------------------------------------------------- */ - int PoolObjectSQL::replace_template(const string& tmpl_str, string& error) { Template * new_tmpl = get_new_template(); diff --git a/src/vm/VirtualMachine.cc b/src/vm/VirtualMachine.cc index 7d79d4ce53..c60f67d023 100644 --- a/src/vm/VirtualMachine.cc +++ b/src/vm/VirtualMachine.cc @@ -2465,6 +2465,47 @@ string VirtualMachine::get_system_dir() const /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ +void VirtualMachine::update_info( + const int _memory, + const int _cpu, + const long long _net_tx, + const long long _net_rx, + const map &custom) +{ + map::const_iterator it; + + last_poll = time(0); + + if (_memory != -1) + { + memory = _memory; + } + + if (_cpu != -1) + { + cpu = _cpu; + } + + if (_net_tx != -1) + { + net_tx = _net_tx; + } + + if (_net_rx != -1) + { + net_rx = _net_rx; + } + + for (it = custom.begin(); it != custom.end(); it++) + { + replace_template_attribute(it->first, it->second); + } + + set_vm_info(); + + clear_template_error_message(); +}; + /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ diff --git a/src/vmm/VirtualMachineManager.cc b/src/vmm/VirtualMachineManager.cc index 2609c5f86a..98e5324848 100644 --- a/src/vmm/VirtualMachineManager.cc +++ b/src/vmm/VirtualMachineManager.cc @@ -40,7 +40,6 @@ VirtualMachineManager::VirtualMachineManager( vmpool(_vmpool), hpool(_hpool), timer_period(_timer_period), - timer_start(0), poll_period(_poll_period), vm_limit(_vm_limit) { @@ -64,8 +63,6 @@ extern "C" void * vmm_action_loop(void *arg) NebulaLog::log("VMM",Log::INFO,"Virtual Machine Manager started."); - vmm->timer_start = time(0); - if ( vmm->poll_period == 0 ) { NebulaLog::log("VMM",Log::INFO,"VM monitoring is disabled."); @@ -1422,7 +1419,8 @@ error_common: void VirtualMachineManager::timer_action() { - static int mark = 0; + static int mark = 0; + static int timer_start = time(0); VirtualMachine * vm; vector oids; diff --git a/src/vmm/VirtualMachineManagerDriver.cc b/src/vmm/VirtualMachineManagerDriver.cc index 498c737f7b..d7b424c8c8 100644 --- a/src/vmm/VirtualMachineManagerDriver.cc +++ b/src/vmm/VirtualMachineManagerDriver.cc @@ -400,9 +400,12 @@ void VirtualMachineManagerDriver::protocol( } else { - log_error(vm,os,is,"Error monitoring VM"); + Nebula &ne = Nebula::instance(); + LifeCycleManager* lcm = ne.get_lcm(); - process_poll(vm, "STATE=d"); + log_error(vm, os, is, "Error monitoring VM"); + + lcm->trigger(LifeCycleManager::MONITOR_DONE, vm->get_oid()); } } else if (action == "LOG") @@ -419,14 +422,6 @@ void VirtualMachineManagerDriver::protocol( /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ -void VirtualMachineManagerDriver::process_failed_poll(int id) -{ - process_poll(id, "STATE=d"); -} - -/* -------------------------------------------------------------------------- */ -/* -------------------------------------------------------------------------- */ - void VirtualMachineManagerDriver::process_poll( int id, const string &monitor_str) @@ -451,24 +446,76 @@ void VirtualMachineManagerDriver::process_poll( VirtualMachine* vm, const string& monitor_str) { - size_t pos; + int rc; + + int cpu; + int memory; + long long net_tx; + long long net_rx; + char state; + + map custom; + ostringstream oss; + + VirtualMachinePool* vmpool = Nebula::instance().get_vmpool(); + + rc = parse_vm_info(monitor_str, cpu, memory, net_tx, net_rx, state, custom); + + if (rc == -1) + { + vm->set_template_error_message("Error parsing monitoring information."); + + vmpool->update(vm); + + return; + } + + oss << "VM " << vm->get_oid() << " successfully monitored: " << monitor_str; + NebulaLog::log("VMM", Log::INFO, oss); + + vm->update_info(memory, cpu, net_tx, net_rx, custom); + + vmpool->update(vm); + + vmpool->update_history(vm); + + vmpool->update_monitoring(vm); + + process_poll_state(vm, state); + +} + +/* -------------------------------------------------------------------------- */ +/* -------------------------------------------------------------------------- */ + +int VirtualMachineManagerDriver::parse_vm_info( + const string& monitor_str, + int &cpu, + int &memory, + long long &net_tx, + long long &net_rx, + char &state, + map &custom) +{ + istringstream is; + + int parse_error = 0; + size_t pos; + + string tmp; + string var; - string tmp; - string var; ostringstream os; istringstream tiss; - int cpu = -1; - int memory = -1; - long long net_tx = -1; - long long net_rx = -1; - char state = '-'; + cpu = -1; + memory = -1; + net_tx = -1; + net_rx = -1; + state = '-'; - bool parse_error = false; + custom.clear(); - VirtualMachinePool * vmpool = Nebula::instance().get_vmpool(); - - istringstream is; is.str(monitor_str); while(is.good()) @@ -479,7 +526,7 @@ void VirtualMachineManagerDriver::process_poll( if ( pos == string::npos ) { - parse_error = true; + parse_error = -1; continue; } @@ -493,7 +540,7 @@ void VirtualMachineManagerDriver::process_poll( if (!tiss.good()) { - parse_error = true; + parse_error = -1; continue; } @@ -523,61 +570,52 @@ void VirtualMachineManagerDriver::process_poll( tiss >> val; - vm->replace_template_attribute(var,val); + custom.insert(make_pair(var, val)); } } - if (parse_error) + return parse_error; +} + +/* -------------------------------------------------------------------------- */ +/* -------------------------------------------------------------------------- */ + +void VirtualMachineManagerDriver::process_poll_state( + VirtualMachine* vm, + char state) +{ + if (state == '-' || + (vm->get_lcm_state() != VirtualMachine::RUNNING && + vm->get_lcm_state() != VirtualMachine::UNKNOWN)) { - os.str(""); - os << "Error parsing monitoring str:\"" << monitor_str <<"\""; - - vm->log("VMM",Log::ERROR,os); - - vm->set_template_error_message(os.str()); - vmpool->update(vm); - return; } - vm->set_last_poll(time(0)); + Nebula &ne = Nebula::instance(); - vm->update_info(memory,cpu,net_tx,net_rx); - vm->set_vm_info(); + LifeCycleManager* lcm = ne.get_lcm(); + VirtualMachinePool* vmpool = ne.get_vmpool(); - vmpool->update(vm); - vmpool->update_history(vm); - vmpool->update_monitoring(vm); - - if (state != '-' && - (vm->get_lcm_state() == VirtualMachine::RUNNING || - vm->get_lcm_state() == VirtualMachine::UNKNOWN)) + switch (state) { - Nebula &ne = Nebula::instance(); - LifeCycleManager * lcm = ne.get_lcm(); - - switch (state) - { case 'a': // Still active, good! if ( vm->get_lcm_state() == VirtualMachine::UNKNOWN) { - vm->log("VMM",Log::INFO,"VM was now found, new state is" - " RUNNING"); + vm->log("VMM",Log::INFO,"VM found again, state is RUNNING"); + vm->set_state(VirtualMachine::RUNNING); vmpool->update(vm); } break; case 'p': // It's paused - vm->log("VMM",Log::INFO,"VM running but new state " - "from monitor is PAUSED."); + vm->log("VMM",Log::INFO,"VM running but monitor state is PAUSED."); lcm->trigger(LifeCycleManager::MONITOR_SUSPEND, vm->get_oid()); break; case 'e': //Failed - vm->log("VMM",Log::INFO,"VM running but new state " - "from monitor is ERROR."); + vm->log("VMM",Log::INFO,"VM running but monitor state is ERROR."); lcm->trigger(LifeCycleManager::MONITOR_FAILURE, vm->get_oid()); break; @@ -589,7 +627,6 @@ void VirtualMachineManagerDriver::process_poll( lcm->trigger(LifeCycleManager::MONITOR_DONE, vm->get_oid()); break; - } } }