/* -------------------------------------------------------------------------- */ /* Copyright 2002-2019, OpenNebula Project, OpenNebula Systems */ /* */ /* Licensed under the Apache License, Version 2.0 (the "License"); you may */ /* not use this file except in compliance with the License. You may obtain */ /* a copy of the License at */ /* */ /* http://www.apache.org/licenses/LICENSE-2.0 */ /* */ /* Unless required by applicable law or agreed to in writing, software */ /* distributed under the License is distributed on an "AS IS" BASIS, */ /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ /* See the License for the specific language governing permissions and */ /* limitations under the License. */ /* -------------------------------------------------------------------------- */ #include #include #include #include #include #include #include #include #include #include #include "VirtualMachine.h" #include "VirtualNetworkPool.h" #include "ImagePool.h" #include "NebulaLog.h" #include "NebulaUtil.h" #include "Snapshots.h" #include "ScheduledAction.h" #include "Nebula.h" #include "vm_file_var_syntax.h" #include "vm_var_syntax.h" /* ************************************************************************** */ /* Virtual Machine :: Constructor/Destructor */ /* ************************************************************************** */ VirtualMachine::VirtualMachine(int id, int _uid, int _gid, const string& _uname, const string& _gname, int umask, VirtualMachineTemplate * _vm_template): PoolObjectSQL(id,VM,"",_uid,_gid,_uname,_gname,table), last_poll(0), state(INIT), prev_state(INIT), lcm_state(LCM_INIT), prev_lcm_state(LCM_INIT), resched(0), stime(time(0)), etime(0), deploy_id(""), history(0), previous_history(0), disks(false), nics(false), _log(0) { if (_vm_template != 0) { // This is a VM Template, with the root TEMPLATE. _vm_template->set_xml_root("USER_TEMPLATE"); user_obj_template = _vm_template; } else { user_obj_template = new VirtualMachineTemplate(false,'=',"USER_TEMPLATE"); } obj_template = new VirtualMachineTemplate; set_umask(umask); } VirtualMachine::~VirtualMachine() { for (unsigned int i=0 ; i < history_records.size() ; i++) { delete history_records[i]; } delete _log; delete user_obj_template; } /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ int VirtualMachine::vm_state_from_str(string& st, VmState& state) { one_util::toupper(st); if ( st == "INIT" ) { state = INIT; } else if ( st == "PENDING" ) { state = PENDING; } else if ( st == "HOLD" ) { state = HOLD; } else if ( st == "ACTIVE" ) { state = ACTIVE; } else if ( st == "STOPPED" ) { state = STOPPED; } else if ( st == "SUSPENDED" ) { state = SUSPENDED; } else if ( st == "DONE" ) { state = DONE; } else if ( st == "POWEROFF" ) { state = POWEROFF; } else if ( st == "UNDEPLOYED" ) { state = UNDEPLOYED; } else if ( st == "CLONING" ) { state = CLONING; } else if ( st == "CLONING_FAILURE" ) { state = CLONING_FAILURE; } else { return -1; } return 0; } /* -------------------------------------------------------------------------- */ string& VirtualMachine::vm_state_to_str(string& st, VmState state) { switch (state) { case INIT: st = "INIT"; break; case PENDING: st = "PENDING"; break; case HOLD: st = "HOLD"; break; case ACTIVE: st = "ACTIVE"; break; case STOPPED: st = "STOPPED"; break; case SUSPENDED: st = "SUSPENDED"; break; case DONE: st = "DONE"; break; case POWEROFF: st = "POWEROFF"; break; case UNDEPLOYED: st = "UNDEPLOYED"; break; case CLONING: st = "CLONING"; break; case CLONING_FAILURE: st = "CLONING_FAILURE"; break; } return st; } /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ int VirtualMachine::lcm_state_from_str(string& st, LcmState& state) { one_util::toupper(st); if ( st == "LCM_INIT" ){ state = LCM_INIT; } else if ( st == "PROLOG" ) { state = PROLOG; } else if ( st == "BOOT" ) { state = BOOT; } else if ( st == "RUNNING" ) { state = RUNNING; } else if ( st == "MIGRATE" ) { state = MIGRATE; } else if ( st == "SAVE_STOP" ) { state = SAVE_STOP; } else if ( st == "SAVE_SUSPEND" ) { state = SAVE_SUSPEND; } else if ( st == "SAVE_MIGRATE" ) { state = SAVE_MIGRATE; } else if ( st == "PROLOG_MIGRATE" ) { state = PROLOG_MIGRATE; } else if ( st == "PROLOG_RESUME" ) { state = PROLOG_RESUME; } else if ( st == "EPILOG_STOP" ) { state = EPILOG_STOP; } else if ( st == "EPILOG" ) { state = EPILOG; } else if ( st == "SHUTDOWN" ) { state = SHUTDOWN; } else if ( st == "CLEANUP_RESUBMIT" ) { state = CLEANUP_RESUBMIT; } else if ( st == "UNKNOWN" ) { state = UNKNOWN; } else if ( st == "HOTPLUG" ) { state = HOTPLUG; } else if ( st == "SHUTDOWN_POWEROFF" ) { state = SHUTDOWN_POWEROFF; } else if ( st == "BOOT_UNKNOWN" ) { state = BOOT_UNKNOWN; } else if ( st == "BOOT_POWEROFF" ) { state = BOOT_POWEROFF; } else if ( st == "BOOT_SUSPENDED" ) { state = BOOT_SUSPENDED; } else if ( st == "BOOT_STOPPED" ) { state = BOOT_STOPPED; } else if ( st == "CLEANUP_DELETE" ) { state = CLEANUP_DELETE; } else if ( st == "HOTPLUG_SNAPSHOT" ) { state = HOTPLUG_SNAPSHOT; } else if ( st == "HOTPLUG_NIC" ) { state = HOTPLUG_NIC; } else if ( st == "HOTPLUG_SAVEAS" ) { state = HOTPLUG_SAVEAS; } else if ( st == "HOTPLUG_SAVEAS_POWEROFF" ) { state = HOTPLUG_SAVEAS_POWEROFF; } else if ( st == "HOTPLUG_SAVEAS_SUSPENDED" ) { state = HOTPLUG_SAVEAS_SUSPENDED; } else if ( st == "SHUTDOWN_UNDEPLOY" ) { state = SHUTDOWN_UNDEPLOY; } else if ( st == "EPILOG_UNDEPLOY" ) { state = EPILOG_UNDEPLOY; } else if ( st == "PROLOG_UNDEPLOY" ) { state = PROLOG_UNDEPLOY; } else if ( st == "BOOT_UNDEPLOY" ) { state = BOOT_UNDEPLOY; } else if ( st == "HOTPLUG_PROLOG_POWEROFF" ) { state = HOTPLUG_PROLOG_POWEROFF; } else if ( st == "HOTPLUG_EPILOG_POWEROFF" ) { state = HOTPLUG_EPILOG_POWEROFF; } else if ( st == "BOOT_MIGRATE" ) { state = BOOT_MIGRATE; } else if ( st == "BOOT_FAILURE" ) { state = BOOT_FAILURE; } else if ( st == "BOOT_MIGRATE_FAILURE" ) { state = BOOT_MIGRATE_FAILURE; } else if ( st == "PROLOG_MIGRATE_FAILURE" ) { state = PROLOG_MIGRATE_FAILURE; } else if ( st == "PROLOG_FAILURE" ) { state = PROLOG_FAILURE; } else if ( st == "EPILOG_FAILURE" ) { state = EPILOG_FAILURE; } else if ( st == "EPILOG_STOP_FAILURE" ) { state = EPILOG_STOP_FAILURE; } else if ( st == "EPILOG_UNDEPLOY_FAILURE" ) { state = EPILOG_UNDEPLOY_FAILURE; } else if ( st == "PROLOG_MIGRATE_POWEROFF" ) { state = PROLOG_MIGRATE_POWEROFF; } else if ( st == "PROLOG_MIGRATE_POWEROFF_FAILURE" ) { state = PROLOG_MIGRATE_POWEROFF_FAILURE; } else if ( st == "PROLOG_MIGRATE_SUSPEND" ) { state = PROLOG_MIGRATE_SUSPEND; } else if ( st == "PROLOG_MIGRATE_SUSPEND_FAILURE" ) { state = PROLOG_MIGRATE_SUSPEND_FAILURE; } else if ( st == "BOOT_STOPPED_FAILURE" ) { state = BOOT_STOPPED_FAILURE; } else if ( st == "BOOT_UNDEPLOY_FAILURE" ) { state = BOOT_UNDEPLOY_FAILURE; } else if ( st == "PROLOG_RESUME_FAILURE" ) { state = PROLOG_RESUME_FAILURE; } else if ( st == "PROLOG_UNDEPLOY_FAILURE" ) { state = PROLOG_UNDEPLOY_FAILURE; } else if ( st == "DISK_SNAPSHOT_POWEROFF" ) { state = DISK_SNAPSHOT_POWEROFF; } else if ( st == "DISK_SNAPSHOT_REVERT_POWEROFF" ) { state = DISK_SNAPSHOT_REVERT_POWEROFF; } else if ( st == "DISK_SNAPSHOT_DELETE_POWEROFF" ) { state = DISK_SNAPSHOT_DELETE_POWEROFF; } else if ( st == "DISK_SNAPSHOT_SUSPENDED" ) { state = DISK_SNAPSHOT_SUSPENDED; } else if ( st == "DISK_SNAPSHOT_REVERT_SUSPENDED" ) { state = DISK_SNAPSHOT_REVERT_SUSPENDED; } else if ( st == "DISK_SNAPSHOT_DELETE_SUSPENDED" ) { state = DISK_SNAPSHOT_DELETE_SUSPENDED; } else if ( st == "DISK_SNAPSHOT" ) { state = DISK_SNAPSHOT; } else if ( st == "DISK_SNAPSHOT_DELETE" ) { state = DISK_SNAPSHOT_DELETE; } else if ( st == "PROLOG_MIGRATE_UNKNOWN" ) { state = PROLOG_MIGRATE_UNKNOWN; } else if ( st == "PROLOG_MIGRATE_UNKNOWN_FAILURE" ) { state = PROLOG_MIGRATE_UNKNOWN_FAILURE; } else if ( st == "DISK_RESIZE" ) { state = DISK_RESIZE; } else if ( st == "DISK_RESIZE_POWEROFF" ) { state = DISK_RESIZE_POWEROFF; } else if ( st == "DISK_RESIZE_UNDEPLOYED" ) { state = DISK_RESIZE_UNDEPLOYED; } else { return -1; } return 0; } /* -------------------------------------------------------------------------- */ string& VirtualMachine::lcm_state_to_str(string& st, LcmState state) { switch (state) { case LCM_INIT: st = "LCM_INIT"; break; case PROLOG: st = "PROLOG"; break; case BOOT: st = "BOOT"; break; case RUNNING: st = "RUNNING"; break; case MIGRATE: st = "MIGRATE"; break; case SAVE_STOP: st = "SAVE_STOP"; break; case SAVE_SUSPEND: st = "SAVE_SUSPEND"; break; case SAVE_MIGRATE: st = "SAVE_MIGRATE"; break; case PROLOG_MIGRATE: st = "PROLOG_MIGRATE"; break; case PROLOG_RESUME: st = "PROLOG_RESUME"; break; case EPILOG_STOP: st = "EPILOG_STOP"; break; case EPILOG: st = "EPILOG"; break; case SHUTDOWN: st = "SHUTDOWN"; break; case CLEANUP_RESUBMIT: st = "CLEANUP_RESUBMIT"; break; case UNKNOWN: st = "UNKNOWN"; break; case HOTPLUG: st = "HOTPLUG"; break; case SHUTDOWN_POWEROFF: st = "SHUTDOWN_POWEROFF"; break; case BOOT_UNKNOWN: st = "BOOT_UNKNOWN"; break; case BOOT_POWEROFF: st = "BOOT_POWEROFF"; break; case BOOT_SUSPENDED: st = "BOOT_SUSPENDED"; break; case BOOT_STOPPED: st = "BOOT_STOPPED"; break; case CLEANUP_DELETE: st = "CLEANUP_DELETE"; break; case HOTPLUG_SNAPSHOT: st = "HOTPLUG_SNAPSHOT"; break; case HOTPLUG_NIC: st = "HOTPLUG_NIC"; break; case HOTPLUG_SAVEAS: st = "HOTPLUG_SAVEAS"; break; case HOTPLUG_SAVEAS_POWEROFF: st = "HOTPLUG_SAVEAS_POWEROFF"; break; case HOTPLUG_SAVEAS_SUSPENDED: st = "HOTPLUG_SAVEAS_SUSPENDED"; break; case SHUTDOWN_UNDEPLOY: st = "SHUTDOWN_UNDEPLOY"; break; case EPILOG_UNDEPLOY: st = "EPILOG_UNDEPLOY"; break; case PROLOG_UNDEPLOY: st = "PROLOG_UNDEPLOY"; break; case BOOT_UNDEPLOY: st = "BOOT_UNDEPLOY"; break; case HOTPLUG_PROLOG_POWEROFF: st = "HOTPLUG_PROLOG_POWEROFF"; break; case HOTPLUG_EPILOG_POWEROFF: st = "HOTPLUG_EPILOG_POWEROFF"; break; case BOOT_MIGRATE: st = "BOOT_MIGRATE"; break; case BOOT_FAILURE: st = "BOOT_FAILURE"; break; case BOOT_MIGRATE_FAILURE: st = "BOOT_MIGRATE_FAILURE"; break; case PROLOG_MIGRATE_FAILURE: st = "PROLOG_MIGRATE_FAILURE"; break; case PROLOG_FAILURE: st = "PROLOG_FAILURE"; break; case EPILOG_FAILURE: st = "EPILOG_FAILURE"; break; case EPILOG_STOP_FAILURE: st = "EPILOG_STOP_FAILURE"; break; case EPILOG_UNDEPLOY_FAILURE: st = "EPILOG_UNDEPLOY_FAILURE"; break; case PROLOG_MIGRATE_POWEROFF: st = "PROLOG_MIGRATE_POWEROFF"; break; case PROLOG_MIGRATE_POWEROFF_FAILURE: st = "PROLOG_MIGRATE_POWEROFF_FAILURE"; break; case PROLOG_MIGRATE_SUSPEND: st = "PROLOG_MIGRATE_SUSPEND"; break; case PROLOG_MIGRATE_SUSPEND_FAILURE: st = "PROLOG_MIGRATE_SUSPEND_FAILURE"; break; case BOOT_STOPPED_FAILURE: st = "BOOT_STOPPED_FAILURE"; break; case BOOT_UNDEPLOY_FAILURE: st = "BOOT_UNDEPLOY_FAILURE"; break; case PROLOG_RESUME_FAILURE: st = "PROLOG_RESUME_FAILURE"; break; case PROLOG_UNDEPLOY_FAILURE: st = "PROLOG_UNDEPLOY_FAILURE"; break; case DISK_SNAPSHOT_POWEROFF: st = "DISK_SNAPSHOT_POWEROFF"; break; case DISK_SNAPSHOT_REVERT_POWEROFF: st = "DISK_SNAPSHOT_REVERT_POWEROFF"; break; case DISK_SNAPSHOT_DELETE_POWEROFF: st = "DISK_SNAPSHOT_DELETE_POWEROFF"; break; case DISK_SNAPSHOT_SUSPENDED: st = "DISK_SNAPSHOT_SUSPENDED"; break; case DISK_SNAPSHOT_REVERT_SUSPENDED: st = "DISK_SNAPSHOT_REVERT_SUSPENDED"; break; case DISK_SNAPSHOT_DELETE_SUSPENDED: st = "DISK_SNAPSHOT_DELETE_SUSPENDED"; break; case DISK_SNAPSHOT: st = "DISK_SNAPSHOT"; break; case DISK_SNAPSHOT_DELETE: st = "DISK_SNAPSHOT_DELETE"; break; case PROLOG_MIGRATE_UNKNOWN: st = "PROLOG_MIGRATE_UNKNOWN"; break; case PROLOG_MIGRATE_UNKNOWN_FAILURE: st = "PROLOG_MIGRATE_UNKNOWN_FAILURE"; break; case DISK_RESIZE: st = "DISK_RESIZE"; break; case DISK_RESIZE_POWEROFF: st = "DISK_RESIZE_POWEROFF"; break; case DISK_RESIZE_UNDEPLOYED: st = "DISK_RESIZE_UNDEPLOYED"; break; } return st; } /* -------------------------------------------------------------------------- */ string VirtualMachine::state_str() { string st; if (state == ACTIVE) { return lcm_state_to_str(st, lcm_state); } return vm_state_to_str(st, state); } /* ************************************************************************** */ /* Virtual Machine :: Database Access Functions */ /* ************************************************************************** */ const char * VirtualMachine::table = "vm_pool"; const char * VirtualMachine::db_names = "oid, name, body, uid, gid, last_poll, state, lcm_state, " "owner_u, group_u, other_u, short_body, search_token"; const char * VirtualMachine::db_bootstrap = "CREATE TABLE IF NOT EXISTS " "vm_pool (oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, " "uid INTEGER, gid INTEGER, last_poll INTEGER, state INTEGER, " "lcm_state INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, " "short_body MEDIUMTEXT, search_token MEDIUMTEXT"; const char * VirtualMachine::monit_table = "vm_monitoring"; const char * VirtualMachine::monit_db_names = "vmid, last_poll, body"; const char * VirtualMachine::monit_db_bootstrap = "CREATE TABLE IF NOT EXISTS " "vm_monitoring (vmid INTEGER, last_poll INTEGER, body MEDIUMTEXT, " "PRIMARY KEY(vmid, last_poll))"; const char * VirtualMachine::showback_table = "vm_showback"; const char * VirtualMachine::showback_db_names = "vmid, year, month, body"; const char * VirtualMachine::showback_db_bootstrap = "CREATE TABLE IF NOT EXISTS vm_showback " "(vmid INTEGER, year INTEGER, month INTEGER, body MEDIUMTEXT, " "PRIMARY KEY(vmid, year, month))"; /* -------------------------------------------------------------------------- */ int VirtualMachine::bootstrap(SqlDB * db) { int rc; ostringstream oss_vm; oss_vm << VirtualMachine::db_bootstrap; if (db->fts_available()) { oss_vm << ", FULLTEXT ftidx(search_token))"; } else { oss_vm << ")"; } ostringstream oss_monit(VirtualMachine::monit_db_bootstrap); ostringstream oss_hist(History::db_bootstrap); ostringstream oss_showback(VirtualMachine::showback_db_bootstrap); ostringstream oss_index("CREATE INDEX state_oid_idx on vm_pool (state, oid);"); rc = db->exec_local_wr(oss_vm); rc += db->exec_local_wr(oss_index); rc += db->exec_local_wr(oss_monit); rc += db->exec_local_wr(oss_hist); rc += db->exec_local_wr(oss_showback); return rc; }; /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ int VirtualMachine::select(SqlDB * db) { ostringstream oss; ostringstream ose; string system_dir; int rc; int last_seq; Nebula& nd = Nebula::instance(); // Rebuild the VirtualMachine object rc = PoolObjectSQL::select(db); if ( rc != 0 ) { return rc; } //Get History Records. if ( hasHistory() ) { last_seq = history->seq; delete history_records[last_seq]; for (int i = last_seq; i >= 0; i--) { History * hp; hp = new History(oid, i); history_records[i] = hp; rc = hp->select(db); if ( rc != 0) { goto error_previous_history; } if ( i == last_seq ) { history = hp; } else if ( i == last_seq - 1 ) { previous_history = hp; } } } if ( state == DONE ) //Do not recreate dirs. They may be deleted { _log = 0; return 0; } //-------------------------------------------------------------------------- //Create support directories for this VM //-------------------------------------------------------------------------- oss.str(""); oss << nd.get_vms_location() << oid; mkdir(oss.str().c_str(), 0700); chmod(oss.str().c_str(), 0700); //-------------------------------------------------------------------------- //Create Log support for this VM //-------------------------------------------------------------------------- try { Log::MessageType clevel; NebulaLog::LogType log_system; log_system = nd.get_log_system(); clevel = nd.get_debug_level(); switch (log_system) { case NebulaLog::FILE_TS: case NebulaLog::FILE: _log = new FileLog(nd.get_vm_log_filename(oid), clevel); break; case NebulaLog::SYSLOG: _log = new SysLog(clevel, oid, obj_type); break; case NebulaLog::STD: _log = new StdLog(clevel, oid, obj_type); break; default: throw runtime_error("Unknown log system."); break; } } catch(exception &e) { ose << "Error creating log: " << e.what(); NebulaLog::log("ONE",Log::ERROR, ose); _log = 0; } return 0; error_previous_history: ose << "Cannot get previous history record (seq:" << history->seq << ") for VM id: " << oid; log("ONE", Log::ERROR, ose); return -1; } /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ static int set_boot_order(Template * tmpl, string& error_str) { vector disk; vector nic; ostringstream oss; int ndisk = tmpl->get("DISK", disk); int nnic = tmpl->get("NIC", nic); for (int i=0; iremove("ORDER"); } for (int i=0; iremove("ORDER"); } VectorAttribute * os = tmpl->get("OS"); if ( os == 0 ) { return 0; } string order = os->vector_value("BOOT"); if ( order.empty() ) { return 0; } vector bdevs = one_util::split(order, ','); int index = 1; for (vector::iterator i = bdevs.begin(); i != bdevs.end(); ++i) { vector * dev; int max; int disk_id; size_t pos; const char * id_name; one_util::toupper(*i); int rc = one_util::regex_match("^(DISK|NIC)[[:digit:]]+$", (*i).c_str()); if (rc != 0) { goto error_parsing; } if ((*i).compare(0,4,"DISK") == 0) { pos = 4; max = ndisk; dev = &disk; id_name = "DISK_ID"; } else if ((*i).compare(0,3,"NIC") == 0) { pos = 3; max = nnic; dev = &nic; id_name = "NIC_ID"; } else { goto error_parsing; } istringstream iss((*i).substr(pos, string::npos)); iss >> disk_id; if (iss.fail()) { goto error_parsing; } bool found = false; for (int j=0; jvector_value(id_name, j_disk_id) == 0 && j_disk_id == disk_id ) { (*dev)[j]->replace("ORDER", index++); found = true; } } if (!found) { oss << "Wrong OS/BOOT value. Device with " << id_name << " " << disk_id << " not found"; goto error_common; } } return 0; error_parsing: oss << "Wrong OS/BOOT value: \"" << order << "\" should be a comma-separated list of disk# or nic#"; error_common: error_str = oss.str(); return -1; } /* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */ int VirtualMachine::insert(SqlDB * db, string& error_str) { int rc; string name; string prefix; string value; long int ivalue; float fvalue; set cluster_ids; set datastore_ids; vector