1
0
mirror of https://github.com/OpenNebula/one.git synced 2024-12-21 09:33:53 +03:00
one/include/Host.h
Tino Vázquez 05d147c524
M #-: Bump version 6.10.0
Also bump copyright year to 2024
2024-07-29 14:27:11 +02:00

440 lines
12 KiB
C++

/* ------------------------------------------------------------------------ */
/* Copyright 2002-2024, 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);
}
};
bool add_pci(HostShareCapacity &sr)
{
return host_share.add_pci(sr);
}
/**
* 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);
}
};
void del_pci(HostShareCapacity& sr)
{
host_share.del_pci(sr);
}
/**
* Revert changes in PCI Devices after migrate failure
* @param sr host share capacity info
*/
void revert_pci(HostShareCapacity& sr)
{
host_share.revert_pci(sr);
}
/**
* 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<int>& get_vm_ids() const
{
return vm_collection.get_collection();
}
/**
* Factory method for host templates
*/
std::unique_ptr<Template> get_new_template() const override
{
return std::make_unique<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<int>& 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_*/