mirror of
https://github.com/OpenNebula/one.git
synced 2024-12-23 17:33:56 +03:00
e433ccb85b
co-authored-by: Frederick Borges <fborges@opennebula.io> co-authored-by: Neal Hansen <nhansen@opennebula.io> co-authored-by: Daniel Clavijo Coca <dclavijo@opennebula.io> co-authored-by: Pavel Czerný <pczerny@opennebula.systems> BACKUP INTERFACE ================= * Backups are exposed through a a special Datastore (BACKUP_DS) and Image (BACKUP) types. These new types can only be used for backup'ing up VMs. This approach allows to: - Implement tier based backup policies (backups made on different locations). - Leverage access control and quota systems - Support differnt storage and backup technologies * Backup interface for the VMs: - VM configures backups with BACKUP_CONFIG. This attribute can be set in the VM template or updated with updateconf API call. It can include: + BACKUP_VOLATILE: To backup or not volatile disks + FS_FREEZE: How the FS is freeze for running VMs (qemu-agent, suspend or none). When possible backups are crash consistent. + KEEP_LAST: keep only a given number of backups. - Backups are initiated by the one.vm.backup API call that requires the target Datastore to perform the backup (one-shot). This is exposed by the onevm backup command. - Backups can be periodic through scheduled actions. - Backup configuration is updated with one.vm.updateconf API call. * Restore interface: - Restores are initiated by the one.image.restore API call. This is exposed by oneimage restore command. - Restore include configurable options for the VM template + NO_IP: to not preserve IP addresses (but keep the NICs and network mapping) + NO_NIC: to not preserve network mappings - Other template attributes: + Clean PCI devices, including network configuration in case of TYPE=NIC attributes. By default it removes SHORT_ADDRESS and leave the "auto" selection attributes. + Clean NUMA_NODE, removes node id and cpu sets. It keeps the NUMA node - It is possible to restore single files stored in the repository by using the backup specific URL. * Sunstone (Ruby version) has been updated to expose this feautres. BACKUP DRIVERS & IMPLEMENTATION =============================== * Backup operation is implemented by a combination of 3 driver operations: - VMM. New (internal oned <-> one_vmm_exec.rb) to orchestrate backups for RUNNING VMs. - TM. This commit introduces 2 new operations (and their corresponding _live variants): + pre_backup(_live): Prepares the disks to be back'ed up in the repository. It is specific to the driver: (i) ceph uses the export operation; (ii) qcow2/raw uses snapshot-create-as and fs_freeze as needed. + post_backup(_live): Performs cleanning operations, i.e. KVM snapshots or tmp dirs. - DATASTORE. Each backup technology is represented by its corresponfing driver, that needs to implement: + backup: it takes the VM disks in file (qcow2) format and stores it the backup repository. + restore: it takes a backup image and restores the associated disks and VM template. + monitor: to gather available space in the repository + rm: to remove existing backups + stat: to return the "restored" size of a disk stored in a backup + downloader pseudo-URL handler: in the form <backup_proto>://<driver_snapshot_id>/<disk filename> BACKUP MANAGEMENT ================= Backup actions may potentially take some time, leaving some vmm_exec threads in use for a long time, stucking other vmm operations. Backups are planned by the scheduler through the sched action interface. Two attributes has been added to sched.conf: * MAX_BACKUPS max active backup operations in the cloud. No more backups will be started beyond this limit. * MAX_BACKUPS_HOST max number of backups per host * Fix onevm CLI to properly show and manage schedule actions. --schedule supports now, as well as relative times +<seconds_from_stime> onvm backup --schedule now -d 100 63 * Backup is added as VM_ADMIN_ACTIONS in oned.conf. Regular users needs to use the batch interface or request specific permissions Internal restructure of Scheduler: - All sched_actions interface is now in SchedActionsXML class and files. This class uses references to VM XML, and MUST be used in the same lifetime scope. - XMLRPC API calls for sched actions has been moved to ScheduledActionXML.cc as static functions. - VirtualMachineActionPool includes counters for active backups (total and per host). SUPPORTED PLATFORMS ==================== * hypervisor: KVM * TM: qcow2/shared/ssh, ceph * backup: restic, rsync Notes on Ceph * Ceph backups are performed in the following steps: 1. A snapshot of each disk is taken (group snapshots cannot be used as it seems we cannot export the disks afterwards) 2. Disks are export to a file 3. File is converted to qcow2 format 4. Disk files are upload to the backup repo TODO: * Confirm crash consistent snapshots cannot be used in Ceph TODO: * Check if using VM dir instead of full path is better to accomodate DS migrations i.e.: - Current path: /var/lib/one/datastores/100/53/backup/disk.0 - Proposal: 53/backup/disk.0 RESTIC DRIVER ============= Developed together with this feature is part of the EE edtion. * It supports the SFTP protocol, the following attributes are supported: - RESTIC_SFTP_SERVER - RESTIC_SFTP_USER: only if different from oneadmin - RESTIC_PASSWORD - RESTIC_IONICE: Run restic under a given ionice priority (class 2) - RESTIC_NICE: Run restic under a given nice - RESTIC_BWLIMIT: Limit restic upload/download BW - RESTIC_COMPRESSION: Restic 0.14 implements compression (three modes: off, auto, max). This requires repositories version 2. By default, auto is used (average compression without to much CPU usage) - RESTIC_CONNECTIONS: Sets the number of concurrent connections to a backend (5 by default). For high-latency backends this number can be increased. * downloader URL: restic://<datastore_id>/<snapshot_id>/<file_name> snapshot_id is the restic snapshot hash. To recover single disk images from a backup. This URLs support: - RESTIC_CONNECTIONS - RESTIC_BWLIMIT - RESTIC_IONICE - RESTIC_NICE These options needs to be defined in the associated datastore. RSYNC DRIVER ============= A rsync driver is included as part of the CE distribution. It uses the rsync tool to store backups in a remote server through SSH: * The following attributes are supported to configure the backup datastore: - RSYNC_HOST - RSYNC_USER - RSYNC_ARGS: Arguments to perform the rsync operatin (-aS by default) * downloader URL: rsync://<ds_id>/<vmid>/<hash>/<file> can be used to recover single files from an existing backup. (RSYNC_HOST and RSYN_USER needs to be set in ds_id EMULATOR_CPUS ============= This commit includes a non related backup feature: * Add EMULATOR_CPUS (KVM). This host (or cluster attribute) defines the CPU IDs where the emulator threads will be pinned. If this value is not defined the allocated CPU wll be used when using a PIN policy. (cherry picked from commit a9e6a8e000e9a5a2f56f80ce622ad9ffc9fa032b) F OpenNebula/one#5516: adding rsync backup driver (cherry picked from commit fb52edf5d009dc02b071063afb97c6519b9e8305) F OpenNebula/one#5516: update install.sh, add vmid to source, some polish Signed-off-by: Neal Hansen <nhansen@opennebula.io> (cherry picked from commit 6fc6f8a67e435f7f92d5c40fdc3d1c825ab5581d) F OpenNebula/one#5516: cleanup Signed-off-by: Neal Hansen <nhansen@opennebula.io> (cherry picked from commit 12f4333b833f23098142cd4762eb9e6c505e1340) F OpenNebula/one#5516: update downloader, default args, size check Signed-off-by: Neal Hansen <nhansen@opennebula.io> (cherry picked from commit 510124ef2780a4e2e8c3d128c9a42945be38a305) LL (cherry picked from commit d4fcd134dc293f2b862086936db4d552792539fa)
444 lines
12 KiB
C++
444 lines
12 KiB
C++
/* ------------------------------------------------------------------------ */
|
|
/* Copyright 2002-2022, 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 DATASTORE_H_
|
|
#define DATASTORE_H_
|
|
|
|
#include "PoolObjectSQL.h"
|
|
#include "ObjectCollection.h"
|
|
#include "DatastoreTemplate.h"
|
|
#include "Clusterable.h"
|
|
#include "Image.h"
|
|
|
|
class VirtualMachineDisk;
|
|
|
|
/**
|
|
* The Datastore class.
|
|
*/
|
|
class Datastore : public PoolObjectSQL, public Clusterable
|
|
{
|
|
public:
|
|
/**
|
|
* 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 */
|
|
BACKUP_DS = 3 /** < Backup datastore for VMs */
|
|
};
|
|
|
|
/**
|
|
* Return the string representation of a DatastoreType
|
|
* @param ob the type
|
|
* @return the string
|
|
*/
|
|
static std::string type_to_str(DatastoreType ob)
|
|
{
|
|
switch (ob)
|
|
{
|
|
case IMAGE_DS: return "IMAGE_DS" ; break;
|
|
case SYSTEM_DS: return "SYSTEM_DS" ; break;
|
|
case FILE_DS: return "FILE_DS" ; break;
|
|
case BACKUP_DS: return "BACKUP_DS" ; break;
|
|
default: return "";
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Return the string representation of a DatastoreType
|
|
* @param str_type string representing the DatastoreTypr
|
|
* @return the DatastoreType (defaults to IMAGE_DS)
|
|
*/
|
|
static DatastoreType str_to_type(std::string& str_type);
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
static std::string state_to_str(DatastoreState state)
|
|
{
|
|
switch (state)
|
|
{
|
|
case READY: return "READY"; break;
|
|
case DISABLED: return "DISABLED"; break;
|
|
default: return "";
|
|
}
|
|
};
|
|
|
|
virtual ~Datastore() = default;
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
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;
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
return images.add(id);
|
|
};
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
return images.del(id);
|
|
};
|
|
|
|
/**
|
|
* Returns a copy of the Image IDs set
|
|
*/
|
|
const std::set<int>& get_image_ids() const
|
|
{
|
|
return images.get_collection();
|
|
}
|
|
|
|
/**
|
|
* Returns the number of images
|
|
*/
|
|
int images_size()
|
|
{
|
|
return images.size();
|
|
}
|
|
|
|
/**
|
|
* Retrieves TM mad name
|
|
* @return string tm mad name
|
|
*/
|
|
const std::string& get_tm_mad() const
|
|
{
|
|
return tm_mad;
|
|
};
|
|
|
|
/**
|
|
* Retrieves DS mad name
|
|
* @return string ds mad name
|
|
*/
|
|
const std::string& get_ds_mad() const
|
|
{
|
|
return ds_mad;
|
|
};
|
|
|
|
/**
|
|
* Retrieves the base path
|
|
* @return base path string
|
|
*/
|
|
const std::string& get_base_path() const
|
|
{
|
|
return base_path;
|
|
};
|
|
|
|
/**
|
|
* Retrieves the disk type
|
|
* @return disk type
|
|
*/
|
|
Image::DiskType get_disk_type() const
|
|
{
|
|
return disk_type;
|
|
};
|
|
|
|
/**
|
|
* Returns the datastore type
|
|
* @return datastore type
|
|
*/
|
|
DatastoreType get_type() const
|
|
{
|
|
return type;
|
|
};
|
|
|
|
/**
|
|
* Modifies the given VM disk attribute adding the relevant datastore
|
|
* attributes
|
|
*
|
|
* @param disk
|
|
* @param inherit_attrs Attributes to be inherited from the DS template
|
|
* into the disk
|
|
*/
|
|
void disk_attribute(
|
|
VirtualMachineDisk * disk,
|
|
const std::vector<std::string>& inherit_attrs);
|
|
|
|
/**
|
|
* Set monitor information for the Datastore
|
|
* @param total_mb
|
|
* @param free_mb
|
|
* @param used_mb
|
|
*/
|
|
void update_monitor(long long total, long long free, long long used)
|
|
{
|
|
total_mb = total;
|
|
free_mb = free;
|
|
used_mb = used;
|
|
}
|
|
|
|
/**
|
|
* Returns the available capacity in the datastore.
|
|
* @params avail the total available size in the datastore (MB)
|
|
* @return true if the datastore is configured to enforce capacity
|
|
* checkings
|
|
*/
|
|
bool get_avail_mb(long long &avail) const;
|
|
|
|
/**
|
|
* Returns true if the DS contains the SHARED = YES attribute
|
|
* @return true if the DS is shared
|
|
*/
|
|
bool is_shared()
|
|
{
|
|
bool shared;
|
|
|
|
if (!get_template_attribute("SHARED", shared))
|
|
{
|
|
shared = true;
|
|
}
|
|
|
|
return shared;
|
|
};
|
|
|
|
/**
|
|
* Returns true if the DS_MAD_CONF has PERSISTENT_ONLY = "YES" flag
|
|
* @return true if persistent only
|
|
*/
|
|
bool is_persistent_only() const;
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
int enable(bool enable, std::string& error_str);
|
|
|
|
/**
|
|
* Return a set with compatible system ds for an image ds
|
|
*/
|
|
void get_compatible_system_ds(std::set<int> &compatible_sys_ds) const
|
|
{
|
|
std::string compatible_sys_ds_str;
|
|
|
|
get_template_attribute("COMPATIBLE_SYS_DS", compatible_sys_ds_str);
|
|
|
|
one_util::split_unique(compatible_sys_ds_str, ',', compatible_sys_ds);
|
|
}
|
|
|
|
/**
|
|
* Verify the proper definition of the TM_MAD by checking the attributes
|
|
* related to the TM defined in TM_MAD_CONF
|
|
*/
|
|
int get_tm_mad_targets(const std::string &tm_mad,
|
|
std::string& ln_target,
|
|
std::string& clone_target,
|
|
std::string& disk_type) const;
|
|
/**
|
|
* Returns the default DRIVER to use with images and disks in this DS. The
|
|
* precedence is:
|
|
* 1. TM_MAD_CONF/DRIVER in oned.conf
|
|
* 2. DRIVER in the DS template
|
|
*
|
|
* @param dsid of the datastore
|
|
*
|
|
* @return driver name or "" if not set or missing DS
|
|
*/
|
|
|
|
std::string get_ds_driver();
|
|
|
|
private:
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Friends
|
|
// -------------------------------------------------------------------------
|
|
|
|
friend class DatastorePool;
|
|
|
|
// *************************************************************************
|
|
// Datastore Private Attributes
|
|
// *************************************************************************
|
|
|
|
/**
|
|
* Name of the datastore driver used to register new images
|
|
*/
|
|
std::string ds_mad;
|
|
|
|
/**
|
|
* Name of the TM driver used to transfer file to and from the hosts
|
|
*/
|
|
std::string tm_mad;
|
|
|
|
/**
|
|
* Base path for the storage
|
|
*/
|
|
std::string base_path;
|
|
|
|
/**
|
|
* The datastore type
|
|
*/
|
|
DatastoreType type;
|
|
|
|
/**
|
|
* Disk types for the Images created in this datastore
|
|
*/
|
|
Image::DiskType disk_type;
|
|
|
|
/**
|
|
* Total datastore capacity in MB
|
|
*/
|
|
long long total_mb;
|
|
|
|
/**
|
|
* Available datastore capacity in MB
|
|
*/
|
|
long long free_mb;
|
|
|
|
/**
|
|
* Used datastore capacity in MB
|
|
*/
|
|
long long used_mb;
|
|
|
|
/**
|
|
* Datastore state
|
|
*/
|
|
DatastoreState state;
|
|
|
|
/**
|
|
* Collection of image ids in this datastore
|
|
*/
|
|
ObjectCollection images;
|
|
|
|
// *************************************************************************
|
|
// Constructor
|
|
// *************************************************************************
|
|
|
|
Datastore(
|
|
int uid,
|
|
int gid,
|
|
const std::string& uname,
|
|
const std::string& gname,
|
|
int umask,
|
|
std::unique_ptr<DatastoreTemplate> ds_template,
|
|
const std::set<int> &cluster_ids);
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
*/
|
|
int set_ds_disk_type(std::string& s_dt, std::string& error);
|
|
|
|
// *************************************************************************
|
|
// 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);
|
|
|
|
/**
|
|
* Bootstraps the database table(s) associated to the Datastore
|
|
* @return 0 on success
|
|
*/
|
|
static int bootstrap(SqlDB * db);
|
|
|
|
/**
|
|
* Writes the Datastore in the database.
|
|
* @param db pointer to the db
|
|
* @return 0 on success
|
|
*/
|
|
int insert(SqlDB *db, std::string& error_str) override;
|
|
|
|
/**
|
|
* Writes/updates the Datastore's 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);
|
|
}
|
|
|
|
/**
|
|
* Factory method for datastore templates
|
|
*/
|
|
std::unique_ptr<Template> get_new_template() const override
|
|
{
|
|
return std::make_unique<DatastoreTemplate>();
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
int set_ds_mad(std::string &ds_mad, std::string &error_str);
|
|
|
|
/**
|
|
* Verify the proper definition of the TM_MAD by checking the attributes
|
|
* related to the TM defined in TM_MAD_CONF
|
|
*/
|
|
int set_tm_mad(std::string &tm_mad, std::string &error_str);
|
|
|
|
/**
|
|
* 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
|
|
* - encrypt secret attributes.
|
|
*/
|
|
int post_update_template(std::string& error) override;
|
|
};
|
|
|
|
#endif /*DATASTORE_H_*/
|