/* ------------------------------------------------------------------------ */ /* Copyright 2002-2020, 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. */ /* -------------------------------------------------------------------------*/ #ifndef HOST_H_ #define HOST_H_ #include "PoolObjectSQL.h" #include "HostTemplate.h" #include "HostMonitoringTemplate.h" #include "HostShare.h" #include "ClusterableSingle.h" #include "ObjectCollection.h" #include "NebulaLog.h" #include "NebulaUtil.h" /** * The Host class. */ class Host : public PoolObjectSQL, public ClusterableSingle { public: // HOST STATES +----------------+ // | VM DEPLOYMENT | // +----------------+------------+--------+-------+ // | STATE | MONITORING | MANUAL | SCHED | // +----------------+------------+--------+-------+ // | INIT/MONITORED | Yes | Yes | // +----------------+------------+--------+-------+ // | DISABLED | Yes | Yes | No | // +----------------+------------+----------------+ // | OFFLINE | No | No | // +----------------+-----------------------------+ enum HostState { INIT = 0, /**< Initial state for enabled hosts. */ //MONITORING_MONITORED = 1, /**< Monitoring the host (from monitored). */ MONITORED = 2, /**< The host has been monitored. */ ERROR = 3, /**< An error ocurrer in host monitoring. */ DISABLED = 4, /**< The host is disabled see above. */ //MONITORING_ERROR = 5, /**< Monitoring the host (from error). */ //MONITORING_INIT = 6, /**< Monitoring the host (from init). */ //MONITORING_DISABLED = 7, /**< Monitoring the host (from disabled). */ OFFLINE = 8 /**< The host is set offline, see above */ }; /** * Functions to convert to/from string the Host states */ static int str_to_state(std::string& st, HostState& state) { one_util::toupper(st); state = INIT; if ( st == "INIT" ) { state = INIT; } else if ( st == "MONITORED" ) { state = MONITORED; } else if ( st == "ERROR" ) { state = ERROR; } else if ( st == "DISABLED" ) { state = DISABLED; } else if ( st == "OFFLINE" ) { state = OFFLINE; } else { return -1; } return 0; } static std::string state_to_str(HostState state) { std::string st = ""; switch (state) { case INIT: st = "INIT"; break; case MONITORED: st = "MONITORED"; break; case ERROR: st = "ERROR"; break; case DISABLED: st = "DISABLED"; break; case OFFLINE: st = "OFFLINE"; break; } return st; } virtual ~Host() = default; /** * Function to print the Host object into a string in XML format * @param xml the resulting XML string * @return a reference to the generated string */ std::string& to_xml(std::string& xml) const override; /** * Rebuilds the object from an xml formatted string * @param xml_str The xml-formatted string * * @return 0 on success, -1 otherwise */ int from_xml(const std::string &xml_str) override; /** * Checks if the host is a remote public cloud * @return true if the host is a remote public cloud */ bool is_public_cloud() const; /** * Sets the current host offline, it will not be monitored nor used by the * scheduler, manual VM deployment is also restricted */ void offline(); /** * Sets the current host disable, it will receive monitor updates, manual * deployment of VMs is allowed and the scheduler will not consider this * host. */ void disable(); /** * Enables the current host, it will be monitored and could be used by * the scheduler */ void enable(); /** * Sets the host in error state (if not disabled/offline) and update * template with the associated error message * @param message associated error message */ void error(const std::string& message); /** * Test if the Host has changed state since last time prev state was set * @return true if Host changed state */ bool has_changed_state() { return prev_state != state; } /** * Sets the previous state to the current one */ void set_prev_state() { prev_state = state; }; /** * Update host after a successful monitor. It modifies counters, state * and template attributes * @param parse_str string with values to be parsed * @return 0 on success **/ int update_info(Template &tmpl); /** * Retrieves host state * @return HostState code number */ HostState get_state() const { return state; }; /** * Retrieves host state * @return HostState code number */ void set_state(HostState new_state) { state = new_state; }; /** * Retrieves VMM mad name * @return string vmm mad name */ const std::string& get_vmm_mad() const { return vmm_mad_name; }; /** * Retrieves IM mad name * @return string im mad name */ const std::string& get_im_mad() const { return im_mad_name; }; // ------------------------------------------------------------------------- // Share functions. // ------------------------------------------------------------------------- long long get_share_running_vms() const { return host_share.get_running_vms(); } /** * Adds a new VM to the host share by incrementing usage counters * @param sr the capacity request of the VM * @return 0 on success */ void add_capacity(HostShareCapacity &sr) { if ( vm_collection.add(sr.vmid) == 0 ) { host_share.add(sr); } else { std::ostringstream oss; oss << "VM " << sr.vmid << " is already in host " << oid << "."; NebulaLog::log("ONE", Log::ERROR, oss); } }; /** * Deletes a new VM to the host share by incrementing usage counters * @param sr the capacity request of the VM * @return 0 on success */ void del_capacity(HostShareCapacity& sr) { if ( vm_collection.del(sr.vmid) == 0 ) { host_share.del(sr); } else { std::ostringstream oss; oss << "VM " << sr.vmid << " is not in host " << oid << "."; NebulaLog::log("ONE", Log::ERROR, oss); } }; /** * Tests whether a VM device capacity can be allocated in the host * @param sr capacity requested by the VM * @param error returns the error reason, if any * * @return true if the share can host the VM */ bool test_capacity(HostShareCapacity &sr, std::string& error) { return host_share.test(sr, error); } /** * Update reserved capacity according to cluster reservations * @param ccpu cluster reserved cpu * @param cmem cluster reserved mem * * @return true capacity was updated, * false if host has its own reservations */ bool update_reserved_capacity(const std::string& ccpu, const std::string& cmem); /** * Returns a copy of the VM IDs set */ const std::set& get_vm_ids() const { return vm_collection.get_collection(); } /** * Factory method for host templates */ Template * get_new_template() const override { return new HostTemplate; } /** * Executed after an update operation to process the new template * - encrypt secret attributes. */ int post_update_template(std::string& error) override; /** * Read monitoring from DB */ void load_monitoring(); void update_zombies(const std::set& ids); private: friend class HostPool; /** * The state of the Host */ HostState state; HostState prev_state; /** * Name of the IM and VMM drivers */ std::string im_mad_name; std::string vmm_mad_name; /** * The Share represents the logical capacity associated with the host */ HostShare host_share; /** * Stores a collection with the VMs running in the host */ ObjectCollection vm_collection; /** * Stores monitor information for the host */ HostMonitoringTemplate monitoring; // ************************************************************************* // Constructor // ************************************************************************* Host(int id, const std::string& hostname, const std::string& im_mad, const std::string& vmm_mad, int clusterid, const std::string& cluster); // ************************************************************************* // Helper functions // ************************************************************************* /** * Gets the reserved capacity of this host, if not defined it will be used * the cluster one (if any) * @param rcpu reserved cpu * @param rmem reserved mem */ void reserved_capacity(std::string& rcpu, std::string& rmem) const; void update_wilds(); // ************************************************************************* // DataBase implementation (Private) // ************************************************************************* /** * Execute an INSERT or REPLACE Sql query. * @param db The SQL DB * @param replace Execute an INSERT or a REPLACE * @param error_str Returns the error reason, if any * @return 0 one success */ int insert_replace(SqlDB *db, bool replace, std::string& error_str); /** * Writes the Host and its associated HostShares in the database. * @param db pointer to the db * @return 0 on success */ int insert(SqlDB *db, std::string& error_str) override { return insert_replace(db, false, error_str); }; /** * Writes/updates the Hosts data fields in the database. * @param db pointer to the db * @return 0 on success */ int update(SqlDB *db) override { std::string error_str; return insert_replace(db, true, error_str); }; }; #endif /*HOST_H_*/