2010-04-27 19:42:37 +04:00
/* ------------------------------------------------------------------------ */
2013-01-24 19:18:30 +04:00
/* Copyright 2002-2013, OpenNebula Project (OpenNebula.org), C12G Labs */
2010-04-27 19:42:37 +04:00
/* */
/* 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. */
/* -------------------------------------------------------------------------*/
2008-06-17 20:27:32 +04:00
# ifndef HOST_H_
# define HOST_H_
# include "PoolSQL.h"
2010-08-04 17:14:53 +04:00
# include "HostTemplate.h"
2008-06-17 20:27:32 +04:00
# include "HostShare.h"
2012-02-27 21:55:15 +04:00
# include "Clusterable.h"
2012-10-25 03:32:35 +04:00
# include "ObjectCollection.h"
# include "NebulaLog.h"
2013-10-04 21:05:55 +04:00
# include "NebulaUtil.h"
2008-06-17 20:27:32 +04:00
using namespace std ;
/**
2010-04-04 03:12:52 +04:00
* The Host class .
2008-06-17 20:27:32 +04:00
*/
2012-02-27 21:55:15 +04:00
class Host : public PoolObjectSQL , public Clusterable
2008-06-17 20:27:32 +04:00
{
public :
2010-04-04 03:12:52 +04:00
2010-04-27 19:42:37 +04:00
// ----------------------------------------------------------------------
2008-06-17 20:27:32 +04:00
// Host States
2010-04-27 19:42:37 +04:00
// ----------------------------------------------------------------------
2008-06-17 20:27:32 +04:00
enum HostState
{
2012-05-18 02:14:18 +04:00
INIT = 0 , /**< Initial state for enabled hosts. */
MONITORING_MONITORED = 1 , /**< Monitoring the host (from monitored). */
MONITORED = 2 , /**< The host has been successfully monitored. */
ERROR = 3 , /**< An error ocurrer while monitoring the host. */
DISABLED = 4 , /**< The host is disabled won't be monitored. */
2013-04-24 03:12:22 +04:00
MONITORING_ERROR = 5 , /**< Monitoring the host (from error). */
MONITORING_INIT = 6 , /**< Monitoring the host (from init). */
MONITORING_DISABLED = 7 /**< Monitoring the host (from disabled). */
2008-06-17 20:27:32 +04:00
} ;
2011-02-24 20:12:26 +03:00
/**
* 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
*/
2011-02-25 01:30:39 +03:00
string & to_xml ( string & xml ) const ;
2009-07-09 18:34:34 +04:00
2008-06-17 20:27:32 +04:00
/**
2011-02-24 20:12:26 +03:00
* Rebuilds the object from an xml formatted string
* @ param xml_str The xml - formatted string
*
* @ return 0 on success , - 1 otherwise
2008-06-17 20:27:32 +04:00
*/
2011-02-25 01:30:39 +03:00
int from_xml ( const string & xml_str ) ;
2008-06-17 20:27:32 +04:00
/**
* Check if the host is enabled
* @ return true if the host is enabled
*/
bool isEnabled ( ) const
{
2013-04-24 03:12:22 +04:00
return state ! = DISABLED & & state ! = MONITORING_DISABLED ;
2008-06-17 20:27:32 +04:00
}
2010-04-04 03:12:52 +04:00
2012-05-18 02:14:18 +04:00
/**
* Check if the host is being monitored
* @ return true if the host is enabled
*/
bool isMonitoring ( ) const
{
2013-04-24 03:12:22 +04:00
return ( ( state = = MONITORING_ERROR ) | |
( state = = MONITORING_MONITORED ) | |
( state = = MONITORING_INIT ) | |
( state = = MONITORING_DISABLED ) ) ;
2012-05-18 02:14:18 +04:00
}
2013-10-04 21:05:55 +04:00
/**
* Check if host is hybrid
* @ return true if the host is enabled
*/
bool isHybrid ( ) const ;
2008-06-17 20:27:32 +04:00
/**
2010-04-04 03:12:52 +04:00
* Disables the current host , it will not be monitored nor used by the
2008-06-17 20:27:32 +04:00
* scheduler
2010-04-04 03:12:52 +04:00
*/
2013-04-24 03:12:22 +04:00
void disable ( ) ;
2008-06-17 20:27:32 +04:00
/**
2010-04-04 03:12:52 +04:00
* Enables the current host , it will be monitored and could be used by
2008-06-17 20:27:32 +04:00
* the scheduler
2010-04-04 03:12:52 +04:00
*/
2008-06-17 20:27:32 +04:00
void enable ( )
{
2010-07-11 21:45:10 +04:00
state = INIT ;
2008-06-17 20:27:32 +04:00
} ;
2010-04-04 03:12:52 +04:00
2013-04-24 03:12:22 +04:00
/**
* Sets the host in error
*/
void set_error ( )
{
state = ERROR ;
}
2013-04-25 17:10:12 +04:00
/**
* Updates the Host ' s last_monitored time stamp .
* @ param success if the monitored action was successfully performed
*/
2013-11-19 00:57:02 +04:00
void touch ( bool success )
{
last_monitored = time ( 0 ) ;
switch ( state )
{
case DISABLED :
case MONITORING_DISABLED :
state = DISABLED ;
break ;
case INIT :
case ERROR :
case MONITORED :
case MONITORING_ERROR :
case MONITORING_INIT :
case MONITORING_MONITORED :
if ( success = = true )
{
state = MONITORED ;
}
else
{
state = ERROR ;
}
break ;
default :
break ;
}
} ;
2013-04-25 17:10:12 +04:00
2013-02-16 05:55:17 +04:00
/**
* Update host after a successful monitor . It modifies counters , state
* and template attributes
2008-06-17 20:27:32 +04:00
* @ param parse_str string with values to be parsed
2013-02-16 05:55:17 +04:00
* @ 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 .
2008-06-17 20:27:32 +04:00
* @ return 0 on success
* */
2013-10-24 17:29:36 +04:00
int update_info ( Template & tmpl ,
2013-02-16 05:55:17 +04:00
bool & with_vm_info ,
set < int > & lost ,
2013-10-17 19:01:43 +04:00
map < int , string > & found ,
2013-10-21 17:39:58 +04:00
const set < int > & non_shared_ds ) ;
/**
* Extracts the DS attributes from the given template
* @ param parse_str string with values to be parsed
* @ param ds map of DS monitoring information
2013-10-24 17:29:36 +04:00
* @ param template object parsed from parse_str
2013-10-21 17:39:58 +04:00
*
* @ return 0 on success
*/
2013-10-24 17:29:36 +04:00
int extract_ds_info (
2013-10-21 17:39:58 +04:00
string & parse_str ,
2013-10-24 17:29:36 +04:00
Template & tmpl ,
map < int , const VectorAttribute * > & ds ) ;
2013-02-16 05:55:17 +04:00
2013-03-19 22:08:48 +04:00
/**
2013-02-16 05:55:17 +04:00
* 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 < int > & vm_ids ) ;
2008-06-17 20:27:32 +04:00
2012-05-16 20:00:31 +04:00
/**
* Inserts the last monitoring , and deletes old monitoring entries .
*
* @ param db pointer to the db
* @ return 0 on success
*/
int update_monitoring ( SqlDB * db ) ;
2008-06-17 20:27:32 +04:00
/**
2013-02-12 20:15:28 +04:00
* Retrieves host state
2010-04-27 19:42:37 +04:00
* @ return HostState code number
2008-06-17 20:27:32 +04:00
*/
HostState get_state ( ) const
{
return state ;
} ;
/**
2013-02-12 20:15:28 +04:00
* Retrieves VMM mad name
2010-04-27 19:42:37 +04:00
* @ return string vmm mad name
2008-06-17 20:27:32 +04:00
*/
const string & get_vmm_mad ( ) const
{
return vmm_mad_name ;
} ;
2010-04-04 03:12:52 +04:00
2011-11-10 20:28:32 +04:00
/**
2013-02-12 20:15:28 +04:00
* Retrieves VNM mad name
2011-11-10 20:28:32 +04:00
* @ return string vnm mad name
*/
const string & get_vnm_mad ( ) const
{
return vnm_mad_name ;
} ;
2008-06-17 20:27:32 +04:00
/**
2013-02-12 20:15:28 +04:00
* Retrieves IM mad name
2010-04-27 19:42:37 +04:00
* @ return string im mad name
2008-06-17 20:27:32 +04:00
*/
const string & get_im_mad ( ) const
{
return im_mad_name ;
} ;
2010-04-04 03:12:52 +04:00
2012-05-18 02:14:18 +04:00
/**
* Sets the corresponding monitoring state based on the actual host state
*/
void set_monitoring_state ( )
{
2013-04-25 18:00:03 +04:00
last_monitored = time ( 0 ) ; //Needed to expire this monitor action
2013-04-24 03:12:22 +04:00
switch ( state )
2012-05-18 02:14:18 +04:00
{
2013-04-24 03:12:22 +04:00
case ERROR :
state = MONITORING_ERROR ;
break ;
case MONITORED :
state = MONITORING_MONITORED ;
break ;
case INIT :
state = MONITORING_INIT ;
break ;
case DISABLED :
state = MONITORING_DISABLED ;
break ;
default :
break ;
2012-05-18 02:14:18 +04:00
}
} ;
2008-06-17 20:27:32 +04:00
/**
2013-02-12 20:15:28 +04:00
* Retrieves last time the host was monitored
2010-04-27 19:42:37 +04:00
* @ return time_t last monitored time
2008-06-17 20:27:32 +04:00
*/
time_t get_last_monitored ( ) const
{
return last_monitored ;
} ;
// ------------------------------------------------------------------------
2012-10-25 03:32:35 +04:00
// Share functions. Returns the value associated with each host share
2012-05-18 02:14:18 +04:00
// metric
2010-04-04 03:12:52 +04:00
// ------------------------------------------------------------------------
2013-10-02 00:34:22 +04:00
long long get_share_running_vms ( )
2010-03-08 02:11:45 +03:00
{
return host_share . running_vms ;
}
2013-10-02 00:34:22 +04:00
long long get_share_disk_usage ( )
2009-07-14 20:40:33 +04:00
{
return host_share . disk_usage ;
}
2013-10-02 00:34:22 +04:00
long long get_share_mem_usage ( )
2009-07-14 20:40:33 +04:00
{
return host_share . mem_usage ;
}
2013-10-02 00:34:22 +04:00
long long get_share_cpu_usage ( )
2009-07-14 20:40:33 +04:00
{
return host_share . cpu_usage ;
}
2013-10-02 00:34:22 +04:00
long long get_share_max_disk ( )
2009-07-14 20:40:33 +04:00
{
return host_share . max_disk ;
}
2013-10-02 00:34:22 +04:00
long long get_share_max_mem ( )
2009-07-14 20:40:33 +04:00
{
return host_share . max_mem ;
}
2013-10-02 00:34:22 +04:00
long long get_share_max_cpu ( )
2009-07-14 20:40:33 +04:00
{
return host_share . max_cpu ;
}
2013-10-02 00:34:22 +04:00
long long get_share_free_disk ( )
2009-07-14 20:40:33 +04:00
{
return host_share . free_disk ;
}
2013-10-02 00:34:22 +04:00
long long get_share_free_mem ( )
2009-07-14 20:40:33 +04:00
{
return host_share . free_mem ;
}
2013-10-02 00:34:22 +04:00
long long get_share_free_cpu ( )
2009-07-14 20:40:33 +04:00
{
return host_share . free_cpu ;
}
2013-10-02 00:34:22 +04:00
long long get_share_used_disk ( )
2009-07-14 20:40:33 +04:00
{
return host_share . used_disk ;
}
2013-10-02 00:34:22 +04:00
long long get_share_used_mem ( )
2009-07-14 20:40:33 +04:00
{
return host_share . used_mem ;
}
2013-10-02 00:34:22 +04:00
long long get_share_used_cpu ( )
2009-07-14 20:40:33 +04:00
{
return host_share . used_cpu ;
}
2008-06-17 20:27:32 +04:00
/**
2013-02-12 20:15:28 +04:00
* Adds a new VM to the given share by incrementing the cpu , mem and disk
2008-06-17 20:27:32 +04:00
* counters
2012-10-25 03:32:35 +04:00
* @ param vm_id id of the vm to add to the host
2008-06-17 20:27:32 +04:00
* @ param cpu needed by the VM ( percentage )
2012-07-12 14:48:27 +04:00
* @ param mem needed by the VM ( in KB )
2008-06-17 20:27:32 +04:00
* @ param disk needed by the VM
* @ return 0 on success
*/
2013-10-02 00:34:22 +04:00
void add_capacity ( int vm_id , long long cpu , long long mem , long long disk )
2008-06-17 20:27:32 +04:00
{
2012-10-25 03:32:35 +04:00
if ( vm_collection . add_collection_id ( vm_id ) = = 0 )
{
host_share . add ( cpu , mem , disk ) ;
}
else
{
ostringstream oss ;
oss < < " Trying to add VM " < < vm_id
< < " , that it is already associated to host " < < oid < < " . " ;
NebulaLog : : log ( " ONE " , Log : : ERROR , oss ) ;
}
2008-06-17 20:27:32 +04:00
} ;
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
/**
2010-04-04 03:12:52 +04:00
* Deletes a new VM from the given share by decrementing the cpu , mem and
2008-06-17 20:27:32 +04:00
* disk counters
2012-10-25 03:32:35 +04:00
* @ param vm_id id of the vm to delete from the host
* @ param cpu used by the VM ( percentage )
2013-02-12 20:15:28 +04:00
* @ param mem used by the VM ( in KB )
2008-06-17 20:27:32 +04:00
* @ param disk used by the VM
* @ return 0 on success
*/
2013-10-02 00:34:22 +04:00
void del_capacity ( int vm_id , long long cpu , long long mem , long long disk )
2010-04-04 03:12:52 +04:00
{
2012-10-25 03:32:35 +04:00
if ( vm_collection . del_collection_id ( vm_id ) = = 0 )
{
host_share . del ( cpu , mem , disk ) ;
}
else
{
ostringstream oss ;
oss < < " Trying to remove VM " < < vm_id
< < " , that it is not associated to host " < < oid < < " . " ;
NebulaLog : : log ( " ONE " , Log : : ERROR , oss ) ;
}
2008-06-17 20:27:32 +04:00
} ;
2013-02-23 22:49:06 +04:00
/**
* Updates the capacity used in a host when a VM is resized
* counters
* @ param cpu increment of cpu requested by the VM
* @ param mem increment of memory requested by the VM
* @ param disk not used
* @ return 0 on success
*/
void update_capacity ( int cpu , int mem , int disk )
{
host_share . update ( cpu , mem , disk ) ;
} ;
2008-06-17 20:27:32 +04:00
/**
* Tests whether a new VM can be hosted by the host or not
* @ param cpu needed by the VM ( percentage )
* @ param mem needed by the VM ( in Kb )
* @ param disk needed by the VM
* @ return true if the share can host the VM
*/
2013-10-02 00:34:22 +04:00
bool test_capacity ( long long cpu , long long mem , long long disk )
2008-06-17 20:27:32 +04:00
{
2013-02-24 03:57:55 +04:00
return host_share . test ( cpu , mem , disk ) ;
2008-06-17 20:27:32 +04:00
}
2010-04-04 03:12:52 +04:00
2013-09-02 14:53:54 +04:00
/**
* Returns a copy of the VM IDs set
*/
set < int > get_vm_ids ( )
{
return vm_collection . get_collection_copy ( ) ;
}
2011-06-02 01:53:09 +04:00
/**
* Factory method for host templates
*/
2012-03-14 18:48:06 +04:00
Template * get_new_template ( ) const
2011-06-02 01:53:09 +04:00
{
return new HostTemplate ;
}
2008-06-17 20:27:32 +04:00
private :
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
// -------------------------------------------------------------------------
// Friends
// -------------------------------------------------------------------------
2010-04-04 03:12:52 +04:00
friend class HostPool ;
2008-06-17 20:27:32 +04:00
// -------------------------------------------------------------------------
// Host Description
// -------------------------------------------------------------------------
/**
* The state of the Host
*/
HostState state ;
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
/**
* Name of the IM driver used to monitor this host
2010-04-04 03:12:52 +04:00
*/
2008-06-17 20:27:32 +04:00
string im_mad_name ;
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
/**
* Name of the VM driver used to execute VMs in this host
2010-04-04 03:12:52 +04:00
*/
2008-06-17 20:27:32 +04:00
string vmm_mad_name ;
2010-04-04 03:12:52 +04:00
2011-11-10 20:28:32 +04:00
/**
* Name of the VN driver used to manage networking in this host
*/
string vnm_mad_name ;
2008-06-17 20:27:32 +04:00
/**
2012-05-18 02:14:18 +04:00
* If Host State = MONITORED last time it got fully monitored or 1 Jan 1970
* Host State = MONITORING * last time it got a signal to be monitored
2010-04-04 03:12:52 +04:00
*/
2009-07-09 18:34:34 +04:00
time_t last_monitored ;
2008-06-17 20:27:32 +04:00
// -------------------------------------------------------------------------
// Host Attributes
// -------------------------------------------------------------------------
/**
2009-07-09 18:34:34 +04:00
* The Share represents the logical capacity associated with the host
2008-06-17 20:27:32 +04:00
*/
2009-07-09 18:34:34 +04:00
HostShare host_share ;
2008-06-17 20:27:32 +04:00
2013-11-06 15:57:57 +04:00
/**
* Tmp set of lost VM IDs . Used to give lost VMs one grace cycle , in case
* they reappear .
*/
set < int > tmp_lost_vms ;
/**
* Tmp set of zombie VM IDs . Used to give zombie VMs one grace cycle , in
* case they are cleaned .
*/
set < int > tmp_zombie_vms ;
2012-10-25 03:32:35 +04:00
// -------------------------------------------------------------------------
// VM Collection
// -------------------------------------------------------------------------
/**
* Stores a collection with the VMs running in the host
*/
ObjectCollection vm_collection ;
2013-10-04 21:05:55 +04:00
2008-06-17 20:27:32 +04:00
// *************************************************************************
// Constructor
// *************************************************************************
2012-02-24 21:53:18 +04:00
Host ( int id ,
const string & hostname ,
const string & im_mad_name ,
const string & vmm_mad_name ,
const string & vnm_mad_name ,
int cluster_id ,
const string & cluster_name ) ;
2008-06-17 20:27:32 +04:00
virtual ~ Host ( ) ;
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
// *************************************************************************
2011-02-25 01:30:39 +03:00
// DataBase implementation (Private)
2008-06-17 20:27:32 +04:00
// *************************************************************************
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
static const char * db_names ;
static const char * db_bootstrap ;
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
static const char * table ;
2012-05-16 20:00:31 +04:00
static const char * monit_db_names ;
static const char * monit_db_bootstrap ;
static const char * monit_table ;
2008-06-17 20:27:32 +04:00
/**
2011-02-25 01:30:39 +03:00
* Execute an INSERT or REPLACE Sql query .
* @ param db The SQL DB
* @ param replace Execute an INSERT or a REPLACE
2011-12-19 20:07:32 +04:00
* @ param error_str Returns the error reason , if any
2011-02-25 01:30:39 +03:00
* @ return 0 one success
2011-12-19 20:07:32 +04:00
*/
int insert_replace ( SqlDB * db , bool replace , string & error_str ) ;
2008-06-17 20:27:32 +04:00
/**
2011-02-25 01:30:39 +03:00
* Bootstraps the database table ( s ) associated to the Host
2011-10-10 17:14:46 +04:00
* @ return 0 on success
2008-06-17 20:27:32 +04:00
*/
2011-10-10 17:14:46 +04:00
static int bootstrap ( SqlDB * db )
2011-02-25 01:30:39 +03:00
{
2012-05-16 20:00:31 +04:00
int rc ;
2011-02-25 01:30:39 +03:00
ostringstream oss_host ( Host : : db_bootstrap ) ;
2012-05-16 20:00:31 +04:00
ostringstream oss_monit ( Host : : monit_db_bootstrap ) ;
rc = db - > exec ( oss_host ) ;
rc + = db - > exec ( oss_monit ) ;
2008-06-17 20:27:32 +04:00
2012-05-16 20:00:31 +04:00
return rc ;
2011-02-25 01:30:39 +03:00
} ;
2010-04-04 03:12:52 +04:00
2008-06-17 20:27:32 +04:00
/**
* Writes the Host and its associated HostShares in the database .
* @ param db pointer to the db
* @ return 0 on success
*/
2011-12-19 20:07:32 +04:00
int insert ( SqlDB * db , string & error_str )
{
return insert_replace ( db , false , error_str ) ;
} ;
2009-07-09 18:34:34 +04:00
/**
2008-06-17 20:27:32 +04:00
* Writes / updates the Hosts data fields in the database .
* @ param db pointer to the db
2009-07-09 18:34:34 +04:00
* @ return 0 on success
*/
2011-12-19 20:07:32 +04:00
int update ( SqlDB * db )
{
string error_str ;
return insert_replace ( db , true , error_str ) ;
} ;
2008-06-17 20:27:32 +04:00
} ;
# endif /*HOST_H_*/