k3nny
737f9bea38
All checks were successful
lint / docker (push) Successful in 9m14s
fix code passing ruff linter pre-commit ruff pre-commit ruff format
301 lines
13 KiB
Python
Executable File
301 lines
13 KiB
Python
Executable File
#!/usr/bin/python3
|
|
# -*- coding: utf-8 -*-
|
|
# -----------------------------------------------------------------------
|
|
# This file is part of TISBackup
|
|
#
|
|
# TISBackup is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# TISBackup is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with TISBackup. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# -----------------------------------------------------------------------
|
|
|
|
import datetime
|
|
import hashlib
|
|
import logging
|
|
import os
|
|
import re
|
|
import socket
|
|
import ssl
|
|
import tarfile
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
from stat import *
|
|
|
|
import requests
|
|
|
|
from . import XenAPI
|
|
from .common import *
|
|
|
|
if hasattr(ssl, "_create_unverified_context"):
|
|
ssl._create_default_https_context = ssl._create_unverified_context
|
|
|
|
|
|
class backup_xva(backup_generic):
|
|
"""Backup a VM running on a XCP server as a XVA file (requires xe tools and XenAPI)"""
|
|
|
|
type = "xen-xva"
|
|
|
|
required_params = backup_generic.required_params + ["xcphost", "password_file", "server_name"]
|
|
optional_params = backup_generic.optional_params + [
|
|
"enable_https",
|
|
"halt_vm",
|
|
"verify_export",
|
|
"reuse_snapshot",
|
|
"ignore_proxies",
|
|
"use_compression",
|
|
]
|
|
|
|
enable_https = "no"
|
|
halt_vm = "no"
|
|
verify_export = "no"
|
|
reuse_snapshot = "no"
|
|
ignore_proxies = "yes"
|
|
use_compression = "true"
|
|
|
|
if str2bool(ignore_proxies):
|
|
os.environ["http_proxy"] = ""
|
|
os.environ["https_proxy"] = ""
|
|
|
|
def verify_export_xva(self, filename):
|
|
self.logger.debug("[%s] Verify xva export integrity", self.server_name)
|
|
tar = tarfile.open(filename)
|
|
members = tar.getmembers()
|
|
for tarinfo in members:
|
|
if re.search("^[0-9]*$", os.path.basename(tarinfo.name)):
|
|
sha1sum = hashlib.sha1(tar.extractfile(tarinfo).read()).hexdigest()
|
|
sha1sum2 = tar.extractfile(tarinfo.name + ".checksum").read()
|
|
if not sha1sum == sha1sum2:
|
|
raise Exception("File corrupt")
|
|
tar.close()
|
|
|
|
def export_xva(self, vdi_name, filename, halt_vm, dry_run, enable_https=True, reuse_snapshot="no"):
|
|
user_xen, password_xen, null = open(self.password_file).read().split("\n")
|
|
session = XenAPI.Session("https://" + self.xcphost)
|
|
try:
|
|
session.login_with_password(user_xen, password_xen)
|
|
except XenAPI.Failure as error:
|
|
msg, ip = error.details
|
|
|
|
if msg == "HOST_IS_SLAVE":
|
|
xcphost = ip
|
|
session = XenAPI.Session("https://" + xcphost)
|
|
session.login_with_password(user_xen, password_xen)
|
|
|
|
if not session.xenapi.VM.get_by_name_label(vdi_name):
|
|
return "bad VM name: %s" % vdi_name
|
|
|
|
vm = session.xenapi.VM.get_by_name_label(vdi_name)[0]
|
|
status_vm = session.xenapi.VM.get_power_state(vm)
|
|
|
|
self.logger.debug("[%s] Check if previous fail backups exist", vdi_name)
|
|
backups_fail = [f for f in os.listdir(self.backup_dir) if f.startswith(vdi_name) and f.endswith(".tmp")]
|
|
for backup_fail in backups_fail:
|
|
self.logger.debug('[%s] Delete backup "%s"', vdi_name, backup_fail)
|
|
os.unlink(os.path.join(self.backup_dir, backup_fail))
|
|
|
|
# add snapshot option
|
|
if not str2bool(halt_vm):
|
|
self.logger.debug("[%s] Check if previous tisbackups snapshots exist", vdi_name)
|
|
old_snapshots = session.xenapi.VM.get_by_name_label("tisbackup-%s" % (vdi_name))
|
|
self.logger.debug("[%s] Old snaps count %s", vdi_name, len(old_snapshots))
|
|
|
|
if len(old_snapshots) == 1 and str2bool(reuse_snapshot):
|
|
snapshot = old_snapshots[0]
|
|
self.logger.debug('[%s] Reusing snap "%s"', vdi_name, session.xenapi.VM.get_name_description(snapshot))
|
|
vm = snapshot # vm = session.xenapi.VM.get_by_name_label("tisbackup-%s"%(vdi_name))[0]
|
|
else:
|
|
self.logger.debug("[%s] Deleting %s old snaps", vdi_name, len(old_snapshots))
|
|
for old_snapshot in old_snapshots:
|
|
self.logger.debug("[%s] Destroy snapshot %s", vdi_name, session.xenapi.VM.get_name_description(old_snapshot))
|
|
try:
|
|
for vbd in session.xenapi.VM.get_VBDs(old_snapshot):
|
|
if session.xenapi.VBD.get_type(vbd) == "CD" and not session.xenapi.VBD.get_record(vbd)["empty"]:
|
|
session.xenapi.VBD.eject(vbd)
|
|
else:
|
|
vdi = session.xenapi.VBD.get_VDI(vbd)
|
|
if "NULL" not in vdi:
|
|
session.xenapi.VDI.destroy(vdi)
|
|
session.xenapi.VM.destroy(old_snapshot)
|
|
except XenAPI.Failure as error:
|
|
return "error when destroy snapshot %s" % (error)
|
|
|
|
now = datetime.datetime.now()
|
|
self.logger.debug("[%s] Snapshot in progress", vdi_name)
|
|
try:
|
|
snapshot = session.xenapi.VM.snapshot(vm, "tisbackup-%s" % (vdi_name))
|
|
self.logger.debug("[%s] got snapshot %s", vdi_name, snapshot)
|
|
except XenAPI.Failure as error:
|
|
return "error when snapshot %s" % (error)
|
|
# get snapshot opaqueRef
|
|
vm = session.xenapi.VM.get_by_name_label("tisbackup-%s" % (vdi_name))[0]
|
|
session.xenapi.VM.set_name_description(snapshot, "snapshot created by tisbackup on: %s" % (now.strftime("%Y-%m-%d %H:%M")))
|
|
else:
|
|
self.logger.debug("[%s] Status of VM: %s", self.backup_name, status_vm)
|
|
if status_vm == "Running":
|
|
self.logger.debug("[%s] Shudown in progress", self.backup_name)
|
|
if dry_run:
|
|
print("session.xenapi.VM.clean_shutdown(vm)")
|
|
else:
|
|
session.xenapi.VM.clean_shutdown(vm)
|
|
try:
|
|
try:
|
|
filename_temp = filename + ".tmp"
|
|
self.logger.debug("[%s] Copy in progress", self.backup_name)
|
|
if not str2bool(self.use_compression):
|
|
socket.setdefaulttimeout(120)
|
|
|
|
scheme = "http://"
|
|
if str2bool(enable_https):
|
|
scheme = "https://"
|
|
|
|
# url = scheme+user_xen+":"+password_xen+"@"+self.xcphost+"/export?use_compression="+self.use_compression+"&uuid="+session.xenapi.VM.get_uuid(vm)
|
|
top_level_url = (
|
|
scheme + self.xcphost + "/export?use_compression=" + self.use_compression + "&uuid=" + session.xenapi.VM.get_uuid(vm)
|
|
)
|
|
r = requests.get(top_level_url, auth=(user_xen, password_xen))
|
|
open(filename_temp, "wb").write(r.content)
|
|
|
|
except Exception as e:
|
|
self.logger.error("[%s] error when fetching snap: %s", "tisbackup-%s" % (vdi_name), e)
|
|
if os.path.exists(filename_temp):
|
|
os.unlink(filename_temp)
|
|
raise
|
|
|
|
finally:
|
|
if not str2bool(halt_vm):
|
|
self.logger.debug("[%s] Destroy snapshot", "tisbackup-%s" % (vdi_name))
|
|
try:
|
|
for vbd in session.xenapi.VM.get_VBDs(snapshot):
|
|
if session.xenapi.VBD.get_type(vbd) == "CD" and not session.xenapi.VBD.get_record(vbd)["empty"]:
|
|
session.xenapi.VBD.eject(vbd)
|
|
else:
|
|
vdi = session.xenapi.VBD.get_VDI(vbd)
|
|
if "NULL" not in vdi:
|
|
session.xenapi.VDI.destroy(vdi)
|
|
session.xenapi.VM.destroy(snapshot)
|
|
except XenAPI.Failure as error:
|
|
return "error when destroy snapshot %s" % (error)
|
|
|
|
elif status_vm == "Running":
|
|
self.logger.debug("[%s] Starting in progress", self.backup_name)
|
|
if dry_run:
|
|
print("session.xenapi.Async.VM.start(vm,False,True)")
|
|
else:
|
|
session.xenapi.Async.VM.start(vm, False, True)
|
|
|
|
session.logout()
|
|
|
|
if os.path.exists(filename_temp):
|
|
tar = os.system('tar tf "%s" > /dev/null' % filename_temp)
|
|
if not tar == 0:
|
|
os.unlink(filename_temp)
|
|
return "Tar error"
|
|
if str2bool(self.verify_export):
|
|
self.verify_export_xva(filename_temp)
|
|
os.rename(filename_temp, filename)
|
|
|
|
return 0
|
|
|
|
def do_backup(self, stats):
|
|
try:
|
|
dest_filename = os.path.join(self.backup_dir, "%s-%s.%s" % (self.backup_name, self.backup_start_date, "xva"))
|
|
|
|
# options = []
|
|
# options_params = " ".join(options)
|
|
cmd = self.export_xva(
|
|
vdi_name=self.server_name,
|
|
filename=dest_filename,
|
|
halt_vm=self.halt_vm,
|
|
enable_https=self.enable_https,
|
|
dry_run=self.dry_run,
|
|
reuse_snapshot=self.reuse_snapshot,
|
|
)
|
|
if os.path.exists(dest_filename):
|
|
stats["written_bytes"] = os.stat(dest_filename)[ST_SIZE]
|
|
stats["total_files_count"] = 1
|
|
stats["written_files_count"] = 1
|
|
stats["total_bytes"] = stats["written_bytes"]
|
|
else:
|
|
stats["written_bytes"] = 0
|
|
|
|
stats["backup_location"] = dest_filename
|
|
if cmd == 0:
|
|
stats["log"] = "XVA backup from %s OK, %d bytes written" % (self.server_name, stats["written_bytes"])
|
|
stats["status"] = "OK"
|
|
else:
|
|
raise Exception(cmd)
|
|
|
|
except BaseException as e:
|
|
stats["status"] = "ERROR"
|
|
stats["log"] = str(e)
|
|
raise
|
|
|
|
def register_existingbackups(self):
|
|
"""scan backup dir and insert stats in database"""
|
|
|
|
registered = [
|
|
b["backup_location"]
|
|
for b in self.dbstat.query("select distinct backup_location from stats where backup_name=?", (self.backup_name,))
|
|
]
|
|
|
|
filelist = os.listdir(self.backup_dir)
|
|
filelist.sort()
|
|
for item in filelist:
|
|
if item.endswith(".xva"):
|
|
dir_name = os.path.join(self.backup_dir, item)
|
|
if dir_name not in registered:
|
|
start = (
|
|
datetime.datetime.strptime(item, self.backup_name + "-%Y%m%d-%Hh%Mm%S.xva") + datetime.timedelta(0, 30 * 60)
|
|
).isoformat()
|
|
if fileisodate(dir_name) > start:
|
|
stop = fileisodate(dir_name)
|
|
else:
|
|
stop = start
|
|
self.logger.info("Registering %s started on %s", dir_name, start)
|
|
self.logger.debug(" Disk usage %s", 'du -sb "%s"' % dir_name)
|
|
if not self.dry_run:
|
|
size_bytes = int(os.popen('du -sb "%s"' % dir_name).read().split("\t")[0])
|
|
else:
|
|
size_bytes = 0
|
|
self.logger.debug(" Size in bytes : %i", size_bytes)
|
|
if not self.dry_run:
|
|
self.dbstat.add(
|
|
self.backup_name,
|
|
self.server_name,
|
|
"",
|
|
backup_start=start,
|
|
backup_end=stop,
|
|
status="OK",
|
|
total_bytes=size_bytes,
|
|
backup_location=dir_name,
|
|
TYPE="BACKUP",
|
|
)
|
|
else:
|
|
self.logger.info("Skipping %s, already registered", dir_name)
|
|
|
|
|
|
register_driver(backup_xva)
|
|
|
|
if __name__ == "__main__":
|
|
logger = logging.getLogger("tisbackup")
|
|
logger.setLevel(logging.DEBUG)
|
|
formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
|
|
handler = logging.StreamHandler()
|
|
handler.setFormatter(formatter)
|
|
logger.addHandler(handler)
|
|
|
|
cp = ConfigParser()
|
|
cp.read("/opt/tisbackup/configtest.ini")
|
|
b = backup_xva()
|
|
b.read_config(cp)
|