mirror of
https://github.com/OpenNebula/one.git
synced 2024-12-22 13:33:52 +03:00
413 lines
12 KiB
C++
413 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 BACKUP_JOB_H_
|
|
#define BACKUP_JOB_H_
|
|
|
|
#include "PoolObjectSQL.h"
|
|
#include "ObjectXML.h"
|
|
#include "ObjectCollection.h"
|
|
|
|
/**
|
|
* The BackuJob class, it organize backups of multiple VMs
|
|
*
|
|
* The schema is as follows:
|
|
* <BACKUPJOB>
|
|
*
|
|
* <!-- PoolObjectSQL attributes -->
|
|
*
|
|
* <PRIORITY> Of this backup job. BJ with higher priority are scheduled first
|
|
* <SCHED_ACTIONS> List of associated scheduled action
|
|
* <ID>
|
|
* <UPDATED_VMS> VMs with all backups up to date
|
|
* <ID>
|
|
* <OUTDATED_VMS> VMs that need a backup
|
|
* <ID>
|
|
* <BACKING_UP_VMS> VMs with an ongoing backup operation
|
|
* <ID>
|
|
* <ERROR_VMS> VMs that fail the last backup operation
|
|
* <ID>
|
|
* <LAST_BACKUP_TIME> Last time the backup job was triggered
|
|
* <LAST_BACKUP_DURATION> Time to backup all VMs int the backup job
|
|
* <TEMPLATE>
|
|
* <KEEP_LAST> Just keep the last N backups
|
|
* <BACKUP_VOLATILE> Backup volatile disks or not
|
|
* <FS_FREEZE> FS freeze operation to perform on the VM
|
|
* <MODE> Backup mode
|
|
* <BACKUP_VMS> comma separated list of VMs to backup, order is implicit
|
|
* <DATASTORE_ID> The dastore ID used to store the active backups
|
|
* <EXECUTION>
|
|
*/
|
|
class BackupJob : public PoolObjectSQL
|
|
{
|
|
public:
|
|
// *************************************************************************
|
|
// Priority Limits
|
|
// *************************************************************************
|
|
static const int MAX_PRIO;
|
|
|
|
static const int MIN_PRIO;
|
|
|
|
static const int MAX_USER_PRIO;
|
|
|
|
// *************************************************************************
|
|
// Backup modes
|
|
// *************************************************************************
|
|
enum Execution
|
|
{
|
|
SEQUENTIAL = 0, /** < Backup VMs one by one */
|
|
PARALLEL = 1, /** < Backup all VMs in parallel */
|
|
};
|
|
|
|
static std::string execution_to_str(Execution exec)
|
|
{
|
|
switch (exec)
|
|
{
|
|
case SEQUENTIAL: return "SEQUENTIAL";
|
|
case PARALLEL: return "PARALLEL";
|
|
default: return "";
|
|
}
|
|
};
|
|
|
|
static Execution str_to_execution(std::string& str_exec)
|
|
{
|
|
Execution exec = SEQUENTIAL;
|
|
|
|
one_util::toupper(str_exec);
|
|
|
|
if ( str_exec == "SEQUENTIAL" )
|
|
{
|
|
exec = SEQUENTIAL;
|
|
}
|
|
else if ( str_exec == "PARALLEL" )
|
|
{
|
|
exec = PARALLEL;
|
|
}
|
|
|
|
return exec;
|
|
};
|
|
|
|
/**
|
|
* Function to print the BackuJob 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
|
|
{
|
|
return to_xml_extended(xml, false);
|
|
}
|
|
|
|
std::string& to_xml_extended(std::string& xml, bool do_sa) const;
|
|
|
|
/**
|
|
* Starts execution of the Backup Job
|
|
* Add VMs to WAITING_VMS list, the backup of individual VMs
|
|
* is managed by Scheduled Action Manager
|
|
*/
|
|
int execute(std::string& error);
|
|
|
|
/**
|
|
* Cancel pending Backup Job action, clear the waiting and pending list
|
|
*/
|
|
void cancel();
|
|
|
|
/**
|
|
* Retry Backup Job, move VMs from error list to outdated
|
|
*/
|
|
void retry();
|
|
|
|
/**
|
|
* Returns VMs waiting for a backup, the order define the priority
|
|
*/
|
|
std::vector<int> backup_vms() const
|
|
{
|
|
std::string vms_str;
|
|
std::vector<int> vms;
|
|
get_template_attribute("BACKUP_VMS", vms_str);
|
|
|
|
one_util::split(vms_str, ',', vms);
|
|
|
|
return vms;
|
|
}
|
|
|
|
/**
|
|
* Returns VMs waiting for a backup, the order define the priority
|
|
*/
|
|
const std::set<int>& outdated() const
|
|
{
|
|
return _outdated.get_collection();
|
|
}
|
|
|
|
/**
|
|
* Returns VMs that are currently being backed up
|
|
*/
|
|
const std::set<int>& backing_up() const
|
|
{
|
|
return _backing_up.get_collection();
|
|
}
|
|
|
|
/**
|
|
* Get priority
|
|
*/
|
|
int priority() const
|
|
{
|
|
return _priority;
|
|
}
|
|
|
|
/**
|
|
* Set priority
|
|
*/
|
|
void priority(int pr)
|
|
{
|
|
if ( pr >= MIN_PRIO && pr <= MAX_PRIO )
|
|
{
|
|
_priority = pr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns execution mode: SEQUENTIAL or PARALLEL
|
|
*/
|
|
Execution exec_mode() const;
|
|
|
|
/**
|
|
* Returns Datastore ID, where to backup the VMs
|
|
*/
|
|
int ds_id() const;
|
|
|
|
/**
|
|
* Returns the 'reset' attribute for the Backup Config
|
|
*/
|
|
int reset() const;
|
|
|
|
/**
|
|
* VM backup started, move the VM from waiting to pending list
|
|
*/
|
|
void backup_started(int vm_id);
|
|
|
|
/**
|
|
* Remove Virtual Machine from outdated and VMS list
|
|
*/
|
|
void remove_vm(int vm_id);
|
|
|
|
/**
|
|
* VM backup finished, remove it from backing_up list
|
|
*/
|
|
void backup_finished(int vm_id, bool success);
|
|
|
|
/**
|
|
* Add Virtual Machine to error_vms list
|
|
*/
|
|
void add_error(int vm_id);
|
|
|
|
/**
|
|
* Return Backup Config in format for Virtual Machine
|
|
*/
|
|
void get_backup_config(Template &tmpl);
|
|
|
|
/**
|
|
* Get IDs of the associated scheduled actions
|
|
*/
|
|
ObjectCollection& sched_actions()
|
|
{
|
|
return _sched_actions;
|
|
}
|
|
|
|
const ObjectCollection& sched_actions() const
|
|
{
|
|
return _sched_actions;
|
|
}
|
|
|
|
/**
|
|
* Replace template for this object. Object should be updated
|
|
* after calling this method
|
|
* @param tmpl_str new contents
|
|
* @param keep_restricted If true, the restricted attributes of the
|
|
* current template will override the new template
|
|
* @param error string describing the error if any
|
|
* @return 0 on success
|
|
*/
|
|
int replace_template(const std::string& tmpl_str,
|
|
bool keep_restricted,
|
|
std::string& error) override;
|
|
|
|
/**
|
|
* Append new attributes to the *user template*.
|
|
* @param tmpl_str new contents
|
|
* @param keep_restricted If true, the restricted attributes of the
|
|
* current template will override the new template
|
|
* @param error string describing the error if any
|
|
* @return 0 on success
|
|
*/
|
|
int append_template(const std::string& tmpl_str, bool keep_restricted,
|
|
std::string& error) override;
|
|
|
|
friend class BackupJobPool;
|
|
friend class PoolSQL;
|
|
|
|
protected:
|
|
/**
|
|
* 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
|
|
*/
|
|
int post_update_template(std::string& error) override
|
|
{
|
|
remove_template_attribute("NAME");
|
|
remove_template_attribute("PRIORITY");
|
|
remove_template_attribute("SCHED_ACTION");
|
|
|
|
return parse(error);
|
|
}
|
|
|
|
// *************************************************************************
|
|
// Database implementation
|
|
// *************************************************************************
|
|
/**
|
|
* Bootstraps the database table(s) associated to the Backup Jobs
|
|
* @return 0 on success
|
|
*/
|
|
static int bootstrap(SqlDB * db);
|
|
|
|
/**
|
|
* Writes the BackupJob to the DB
|
|
* @param db pointer to the database.
|
|
* @return 0 on success.
|
|
*/
|
|
int insert(SqlDB * db, std::string& error_str) override;
|
|
|
|
/**
|
|
* Updates the BackupJob record
|
|
* @param db pointer to the database.
|
|
* @return 0 on success.
|
|
*/
|
|
int update(SqlDB * db) override;
|
|
|
|
/**
|
|
* Execute an INSERT or REPLACE Sql query.
|
|
* @param db The SQL DB
|
|
* @param replace Execute an INSERT or a REPLACE
|
|
* @return 0 on success
|
|
*/
|
|
int insert_replace(SqlDB *db, bool replace, std::string& error_str);
|
|
|
|
private:
|
|
/**
|
|
* Priority for this backup job [0, 99]
|
|
*/
|
|
int _priority;
|
|
|
|
/**
|
|
* Associated scheduled action for this backup job
|
|
*/
|
|
ObjectCollection _sched_actions;
|
|
|
|
/**
|
|
* These collections stores the collection of VMs in the Virtual
|
|
* Networks and manages the update process
|
|
* - updated VMs with not pending backups
|
|
* - outdated VMs that need backup
|
|
* - backing_up VMs with an ongoing backup operation
|
|
* - error VMs that fail the last backup operation
|
|
*/
|
|
ObjectCollection _updated;
|
|
|
|
ObjectCollection _outdated;
|
|
|
|
ObjectCollection _backing_up;
|
|
|
|
ObjectCollection _error;
|
|
|
|
/**
|
|
* Time stats for the last backup action (start - epoch, duration - sec)
|
|
*/
|
|
time_t _last_time;
|
|
|
|
time_t _last_duration;
|
|
|
|
/**
|
|
* @param uid
|
|
* @param id
|
|
* @param uname
|
|
* @param gname
|
|
* @param umask
|
|
* @param tmpl
|
|
*/
|
|
BackupJob(int uid,
|
|
int gid,
|
|
const std::string& uname,
|
|
const std::string& gname,
|
|
int umask,
|
|
std::unique_ptr<Template> templ);
|
|
|
|
/**
|
|
* Factory method for Hook templates
|
|
*/
|
|
std::unique_ptr<Template> get_new_template() const override
|
|
{
|
|
return std::make_unique<Template>(true);
|
|
}
|
|
|
|
/*
|
|
* Parse configuration attributes for the backup operation
|
|
* - KEEP_LAST
|
|
* - BACKUP_VOLATILE
|
|
* - FSFREEZE
|
|
* - MODE
|
|
* - BACKUP_VMS
|
|
*
|
|
* This method also updates the VMs collections removing those VMs no longer
|
|
* present in BACKUP_VMS
|
|
*/
|
|
int parse(std::string& error);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/**
|
|
* Check if the VM belongs only to one Backup Job.
|
|
* Assign Backup Job ID to added Virtual Machines, remove ID for removed VMs.
|
|
* @param vms_new_str New value of BACKUP_VMS attribute
|
|
* @param vms_old_str Old value of BACKUP_VMS attribute
|
|
* @param error string describing the error if any
|
|
* @return 0 on success, -1 otherwise
|
|
*/
|
|
int process_backup_vms(const std::string& vms_new_str,
|
|
const std::string& vms_old_str,
|
|
std::string& error);
|
|
|
|
/**
|
|
* Remove Backup Job ID from Virtual Machines listed in BACKUP_VMS attribute
|
|
*/
|
|
void remove_id_from_vms();
|
|
|
|
/**
|
|
* Remove Backup Job ID from Virtual Machines
|
|
* @param vms Virtual Machine IDs to remove the Backup Job ID
|
|
*/
|
|
void remove_id_from_vms(const std::set<unsigned int>& vms);
|
|
};
|
|
|
|
#endif /*BACKUP_JOB_H_*/
|
|
|