2012-02-09 20:56:47 +04:00
/* ------------------------------------------------------------------------ */
2020-04-30 16:00:02 +03:00
/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems */
2012-02-09 20:56:47 +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. */
/* -------------------------------------------------------------------------*/
# ifndef DATASTORE_H_
# define DATASTORE_H_
2019-12-10 13:45:15 +03:00
# include "PoolObjectSQL.h"
2012-02-09 20:56:47 +04:00
# include "ObjectCollection.h"
2012-02-16 22:37:08 +04:00
# include "DatastoreTemplate.h"
2012-02-28 15:17:33 +04:00
# include "Clusterable.h"
2012-04-19 13:44:19 +04:00
# include "Image.h"
2012-02-09 20:56:47 +04:00
2016-12-11 23:05:07 +03:00
class VirtualMachineDisk ;
2012-02-09 20:56:47 +04:00
/**
* The Datastore class .
*/
2016-03-02 01:31:31 +03:00
class Datastore : public PoolObjectSQL , public Clusterable
2012-02-09 20:56:47 +04:00
{
public :
2012-11-16 05:18:43 +04:00
/**
* Type of Datastore
*/
enum DatastoreType
{
IMAGE_DS = 0 , /** < Standard datastore for disk images */
SYSTEM_DS = 1 , /** < System datastore for disks of running VMs */
FILE_DS = 2 /** < File datastore for context, kernel, initrd files */
} ;
/**
2012-12-05 19:48:56 +04:00
* Return the string representation of a DatastoreType
2012-11-16 05:18:43 +04:00
* @ param ob the type
* @ return the string
*/
2020-07-02 23:42:10 +03:00
static std : : string type_to_str ( DatastoreType ob )
2012-11-16 05:18:43 +04:00
{
switch ( ob )
{
case IMAGE_DS : return " IMAGE_DS " ; break ;
case SYSTEM_DS : return " SYSTEM_DS " ; break ;
case FILE_DS : return " FILE_DS " ; break ;
default : return " " ;
}
} ;
/**
2012-12-05 19:48:56 +04:00
* Return the string representation of a DatastoreType
2012-11-16 05:18:43 +04:00
* @ param str_type string representing the DatastoreTypr
2012-12-05 19:48:56 +04:00
* @ return the DatastoreType ( defaults to IMAGE_DS )
2012-11-16 05:18:43 +04:00
*/
2020-07-02 23:42:10 +03:00
static DatastoreType str_to_type ( std : : string & str_type ) ;
2012-02-09 20:56:47 +04:00
2015-02-13 18:37:24 +03:00
/**
* Datastore State
*/
enum DatastoreState
{
READY = 0 , /** < Datastore ready to use */
DISABLED = 1 /** < System Datastore can not be used */
} ;
/**
* Returns the string representation of a DatastoreState
* @ param state The state
* @ return the string representation
*/
2020-07-02 23:42:10 +03:00
static std : : string state_to_str ( DatastoreState state )
2015-02-13 18:37:24 +03:00
{
2019-09-03 17:31:51 +03:00
switch ( state )
2015-02-13 18:37:24 +03:00
{
case READY : return " READY " ; break ;
case DISABLED : return " DISABLED " ; break ;
default : return " " ;
}
} ;
2012-02-09 20:56:47 +04:00
/**
* Function to print the Datastore object into a string in XML format
* @ param xml the resulting XML string
* @ return a reference to the generated string
*/
2020-07-02 23:42:10 +03:00
std : : string & to_xml ( std : : string & xml ) const override ;
2012-02-09 20:56:47 +04:00
/**
* Rebuilds the object from an xml formatted string
* @ param xml_str The xml - formatted string
*
* @ return 0 on success , - 1 otherwise
*/
2020-07-02 23:42:10 +03:00
int from_xml ( const std : : string & xml_str ) override ;
2012-02-09 20:56:47 +04:00
/**
* Adds this image ' s ID to the set .
* @ param id of the image to be added to the Datastore
* @ return 0 on success
*/
int add_image ( int id )
{
2016-03-02 01:31:31 +03:00
return images . add ( id ) ;
2012-02-22 21:22:41 +04:00
} ;
2012-02-09 20:56:47 +04:00
/**
* Deletes this image ' s ID from the set .
* @ param id of the image to be deleted from the Datastore
* @ return 0 on success
*/
int del_image ( int id )
{
2016-03-02 01:31:31 +03:00
return images . del ( id ) ;
2012-02-22 21:22:41 +04:00
} ;
2013-09-02 14:53:54 +04:00
/**
* Returns a copy of the Image IDs set
*/
2020-07-05 23:01:32 +03:00
const std : : set < int > & get_image_ids ( ) const
2013-09-02 14:53:54 +04:00
{
2020-07-05 23:01:32 +03:00
return images . get_collection ( ) ;
2016-03-02 01:31:31 +03:00
}
/**
* Returns the number of images
*/
int images_size ( )
{
return images . size ( ) ;
2013-09-02 14:53:54 +04:00
}
2012-02-22 21:22:41 +04:00
/**
* Retrieves TM mad name
* @ return string tm mad name
*/
2020-07-02 23:42:10 +03:00
const std : : string & get_tm_mad ( ) const
2012-02-22 21:22:41 +04:00
{
return tm_mad ;
} ;
2014-06-26 04:13:34 +04:00
/**
* Retrieves DS mad name
* @ return string ds mad name
*/
2020-07-02 23:42:10 +03:00
const std : : string & get_ds_mad ( ) const
2014-06-26 04:13:34 +04:00
{
return ds_mad ;
} ;
2012-02-25 02:13:22 +04:00
/**
* Retrieves the base path
* @ return base path string
*/
2020-07-02 23:42:10 +03:00
const std : : string & get_base_path ( ) const
2012-02-25 02:13:22 +04:00
{
return base_path ;
} ;
2012-04-19 13:44:19 +04:00
/**
* Retrieves the disk type
* @ return disk type
*/
Image : : DiskType get_disk_type ( ) const
{
return disk_type ;
} ;
2012-06-29 17:09:25 +04:00
/**
2012-11-16 05:18:43 +04:00
* Returns the datastore type
* @ return datastore type
2012-06-29 17:09:25 +04:00
*/
2012-11-16 05:18:43 +04:00
DatastoreType get_type ( ) const
2012-06-29 17:09:25 +04:00
{
2012-11-16 05:18:43 +04:00
return type ;
2012-06-29 17:09:25 +04:00
} ;
2012-02-22 21:22:41 +04:00
/**
* Modifies the given VM disk attribute adding the relevant datastore
* attributes
*
* @ param disk
2013-11-14 14:49:53 +04:00
* @ param inherit_attrs Attributes to be inherited from the DS template
* into the disk
2012-02-22 21:22:41 +04:00
*/
2015-07-22 18:20:37 +03:00
void disk_attribute (
2020-07-02 23:42:10 +03:00
VirtualMachineDisk * disk ,
const std : : vector < std : : string > & inherit_attrs ) ;
2013-11-14 14:49:53 +04:00
2013-06-27 20:06:17 +04:00
/**
* Set monitor information for the Datastore
* @ param total_mb
* @ param free_mb
* @ param used_mb
*/
2013-10-17 14:35:19 +04:00
void update_monitor ( long long total , long long free , long long used )
2013-06-27 20:06:17 +04:00
{
total_mb = total ;
free_mb = free ;
used_mb = used ;
}
2013-07-10 19:48:39 +04:00
/**
* Returns the available capacity in the datastore .
2013-07-12 18:51:36 +04:00
* @ params avail the total available size in the datastore ( MB )
2013-07-10 19:48:39 +04:00
* @ return true if the datastore is configured to enforce capacity
* checkings
*/
2020-07-05 23:01:32 +03:00
bool get_avail_mb ( long long & avail ) const ;
2013-07-05 23:14:34 +04:00
2013-10-21 17:39:58 +04:00
/**
* Returns true if the DS contains the SHARED = YES attribute
* @ return true if the DS is shared
*/
2013-10-17 19:01:43 +04:00
bool is_shared ( )
{
2013-10-21 17:39:58 +04:00
bool shared ;
if ( ! get_template_attribute ( " SHARED " , shared ) )
{
shared = true ;
}
return shared ;
} ;
2013-10-17 19:01:43 +04:00
2015-12-22 16:06:12 +03:00
/**
* Returns true if the DS_MAD_CONF has PERSISTENT_ONLY = " YES " flag
* @ return true if persistent only
*/
2020-07-05 23:01:32 +03:00
bool is_persistent_only ( ) const ;
2015-12-22 16:06:12 +03:00
2015-02-13 18:37:24 +03:00
/**
* Enable or disable the DS . Only for System DS .
* @ param enable true to enable
* @ param error_str Returns the error reason , if any
*
* @ return 0 on success
*/
2020-07-02 23:42:10 +03:00
int enable ( bool enable , std : : string & error_str ) ;
2015-02-13 18:37:24 +03:00
2018-09-14 22:15:58 +03:00
/**
* Return a set with compatible system ds for an image ds
*/
2020-07-05 23:01:32 +03:00
void get_compatible_system_ds ( std : : set < int > & compatible_sys_ds ) const
2018-09-14 22:15:58 +03:00
{
2020-07-02 23:42:10 +03:00
std : : string compatible_sys_ds_str ;
2018-09-14 22:15:58 +03:00
get_template_attribute ( " COMPATIBLE_SYS_DS " , compatible_sys_ds_str ) ;
one_util : : split_unique ( compatible_sys_ds_str , ' , ' , compatible_sys_ds ) ;
}
2018-11-05 18:46:23 +03:00
/**
* Verify the proper definition of the TM_MAD by checking the attributes
* related to the TM defined in TM_MAD_CONF
*/
2020-07-02 23:42:10 +03:00
int get_tm_mad_targets ( const std : : string & tm_mad ,
std : : string & ln_target ,
std : : string & clone_target ,
2020-07-05 23:01:32 +03:00
std : : string & disk_type ) const ;
2018-11-05 18:46:23 +03:00
2012-02-09 20:56:47 +04:00
private :
// -------------------------------------------------------------------------
// Friends
// -------------------------------------------------------------------------
friend class DatastorePool ;
2012-02-16 22:37:08 +04:00
// *************************************************************************
// Datastore Private Attributes
// *************************************************************************
/**
2012-03-06 18:13:55 +04:00
* Name of the datastore driver used to register new images
2012-02-16 22:37:08 +04:00
*/
2020-07-02 23:42:10 +03:00
std : : string ds_mad ;
2012-02-16 22:37:08 +04:00
2012-02-22 21:22:41 +04:00
/**
* Name of the TM driver used to transfer file to and from the hosts
*/
2020-07-02 23:42:10 +03:00
std : : string tm_mad ;
2012-02-22 21:22:41 +04:00
2012-02-16 22:37:08 +04:00
/**
* Base path for the storage
*/
2020-07-02 23:42:10 +03:00
std : : string base_path ;
2012-02-16 22:37:08 +04:00
2012-06-29 14:44:04 +04:00
/**
2012-11-16 05:18:43 +04:00
* The datastore type
2012-06-29 14:44:04 +04:00
*/
2012-11-16 05:18:43 +04:00
DatastoreType type ;
2012-06-29 14:44:04 +04:00
2012-04-19 13:44:19 +04:00
/**
* Disk types for the Images created in this datastore
*/
Image : : DiskType disk_type ;
2013-06-27 20:06:17 +04:00
/**
* Total datastore capacity in MB
*/
2013-10-17 14:35:19 +04:00
long long total_mb ;
2013-06-27 20:06:17 +04:00
/**
* Available datastore capacity in MB
*/
2013-10-17 14:35:19 +04:00
long long free_mb ;
2013-06-27 20:06:17 +04:00
/**
* Used datastore capacity in MB
*/
2013-10-17 14:35:19 +04:00
long long used_mb ;
2013-06-27 20:06:17 +04:00
2015-02-13 18:37:24 +03:00
/**
* Datastore state
*/
DatastoreState state ;
2016-03-02 01:31:31 +03:00
/**
* Collection of image ids in this datastore
*/
ObjectCollection images ;
2012-02-09 20:56:47 +04:00
// *************************************************************************
// Constructor
// *************************************************************************
2012-02-28 15:17:33 +04:00
Datastore (
2012-03-01 21:50:17 +04:00
int uid ,
int gid ,
2020-07-02 23:42:10 +03:00
const std : : string & uname ,
const std : : string & gname ,
2013-01-18 21:34:51 +04:00
int umask ,
2012-02-28 15:17:33 +04:00
DatastoreTemplate * ds_template ,
2020-07-02 23:42:10 +03:00
const std : : set < int > & cluster_ids ) ;
2012-02-09 20:56:47 +04:00
2019-09-03 17:31:51 +03:00
virtual ~ Datastore ( ) = default ;
2012-02-09 20:56:47 +04:00
2015-10-29 18:55:53 +03:00
/**
* Sets the DISK_TYPE attribute for the datastore . This function will
* check the type against the supported DiskTypes for each datastore type
* ( SYSTEM , IMAGE and FILE ) .
* @ param s_dt DISK_TYPE in string form . If empty Image : : FILE will be used
* @ param error description if any . The string is upcased
*
* @ return - 1 if an inconsistent assigment is found
*
*/
2020-07-02 23:42:10 +03:00
int set_ds_disk_type ( std : : string & s_dt , std : : string & error ) ;
2015-10-29 18:55:53 +03:00
2012-02-09 20:56:47 +04:00
// *************************************************************************
// 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
*/
2020-07-02 23:42:10 +03:00
int insert_replace ( SqlDB * db , bool replace , std : : string & error_str ) ;
2012-02-09 20:56:47 +04:00
/**
* Bootstraps the database table ( s ) associated to the Datastore
* @ return 0 on success
*/
2020-06-29 13:14:00 +03:00
static int bootstrap ( SqlDB * db ) ;
2012-02-09 20:56:47 +04:00
/**
* Writes the Datastore in the database .
* @ param db pointer to the db
* @ return 0 on success
*/
2020-07-02 23:42:10 +03:00
int insert ( SqlDB * db , std : : string & error_str ) override ;
2012-02-09 20:56:47 +04:00
/**
* Writes / updates the Datastore ' s data fields in the database .
* @ param db pointer to the db
* @ return 0 on success
*/
2019-09-03 17:31:51 +03:00
int update ( SqlDB * db ) override
2012-02-09 20:56:47 +04:00
{
2020-07-02 23:42:10 +03:00
std : : string error_str ;
2012-02-09 20:56:47 +04:00
return insert_replace ( db , true , error_str ) ;
}
2012-03-02 20:25:42 +04:00
/**
2012-06-28 19:51:21 +04:00
* Factory method for datastore templates
2012-03-02 20:25:42 +04:00
*/
2019-09-03 17:31:51 +03:00
Template * get_new_template ( ) const override
2012-03-02 20:25:42 +04:00
{
return new DatastoreTemplate ;
}
2013-10-23 18:15:18 +04:00
2015-12-21 21:27:26 +03:00
/**
* Verify the proper definition of the DS_MAD by checking the attributes
* related to the DS defined in DS_MAD_CONF specified in the Datastore
* template
*/
2020-07-02 23:42:10 +03:00
int set_ds_mad ( std : : string & ds_mad , std : : string & error_str ) ;
2015-12-21 21:27:26 +03:00
/**
* Verify the proper definition of the TM_MAD by checking the attributes
* related to the TM defined in TM_MAD_CONF
*/
2020-07-02 23:42:10 +03:00
int set_tm_mad ( std : : string & tm_mad , std : : string & error_str ) ;
2014-10-20 18:05:44 +04:00
/**
* Child classes can process the new template set with replace_template or
* append_template with this method
* @ param error string describing the error if any
* @ return 0 on success
2019-09-03 17:31:51 +03:00
* - encrypt secret attributes .
2014-10-20 18:05:44 +04:00
*/
2020-07-02 23:42:10 +03:00
int post_update_template ( std : : string & error ) override ;
2012-02-09 20:56:47 +04:00
} ;
# endif /*DATASTORE_H_*/