def test_disk_backup_name_format(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain)
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
backup_name = dombkup._disk_backup_name_format(snapdate, "vda")
expected_name = "20160815-171013_1_test_vda"
assert backup_name == expected_name
def test_add_not_existing_disk(self, build_mock_domain):
"""
Create a DomBackup and test to add vdc
"""
dombkup = DomBackup(dom=build_mock_domain)
with pytest.raises(KeyError):
dombkup.add_disks("vdc")
def test_add_disks(self, build_mock_domain):
"""
Create a DomBackup with only one disk (vda) and test to add vdb
"""
disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
}
dombkup = DomBackup(dom=build_mock_domain, _disks=disks)
expected_disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
}
assert dombkup.disks == expected_disks
dombkup.add_disks("vdb")
expected_disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
"vdb": {
"src": "/var/lib/libvirt/images/test-disk-2.qcow2",
"type": "qcow2",
}
}
assert dombkup.disks == expected_disks
def test_manually_pivot_unexistant_disk(self, build_mock_domain,
build_mock_libvirtconn):
conn = build_mock_libvirtconn
dombkup = DomBackup(dom=build_mock_domain, conn=conn)
with pytest.raises(DiskNotFoundError):
dombkup._manually_pivot_disk("sda", "/testvda")
def test_disk_backup_name_format(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain)
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
backup_name = dombkup._disk_backup_name_format(snapdate, "vda")
expected_name = "20160815-171013_1_test_vda"
assert backup_name == expected_name
def test_add_disks(self, build_mock_domain):
"""
Create a DomBackup with only one disk (vda) and test to add vdb
"""
disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
}
dombkup = DomBackup(dom=build_mock_domain, _disks=disks)
expected_disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
}
assert dombkup.disks == expected_disks
dombkup.add_disks("vdb")
expected_disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
"vdb": {
"src": "/var/lib/libvirt/images/test-disk-2.qcow2",
"type": "qcow2",
}
}
assert dombkup.disks == expected_disks
def test_add_not_existing_disk(self, build_mock_domain):
"""
Create a DomBackup and test to add vdc
"""
dombkup = DomBackup(dom=build_mock_domain)
with pytest.raises(KeyError):
dombkup.add_disks("vdc")
def build_completed_backups(backup_dir):
domain_names = ("a", "b", "vm-10", "matching", "matching2")
backup_properties = (
(arrow.get("2016-07-08 19:40:02").to("local"), None),
(arrow.get("2016-07-08 18:40:02").to("local"), None),
(arrow.get("2016-07-08 18:30:02").to("local"), None),
(arrow.get("2016-07-08 17:40:02").to("local"), None),
(arrow.get("2016-07-07 19:40:02").to("local"), None),
(arrow.get("2016-07-07 21:40:02").to("local"), None),
(arrow.get("2016-07-06 20:40:02").to("local"), None),
(arrow.get("2016-04-08 19:40:02").to("local"), None),
(arrow.get("2014-05-01 00:30:00").to("local"), "tar"),
(arrow.get("2016-03-08 14:28:13").to("local"), "xz"),
)
conn = MockConn()
for domain_id, domain_name in enumerate(domain_names):
domain_bdir = os.path.join(backup_dir, domain_name)
os.mkdir(domain_bdir)
domain = MockDomain(conn, name=domain_name, id=domain_id)
dbackup = DomBackup(
domain, domain_bdir, dev_disks=("vda", "vdb")
)
for bakdate, compression in backup_properties:
dbackup.compression = compression
definition = build_complete_backup_files_from_domainbackup(
dbackup, bakdate
)
dbackup._dump_json_definition(definition)
# create a bad json file
with open(os.path.join(domain_bdir, "badfile.json"), "w"):
pass
return (domain_names, (bp[0] for bp in backup_properties))
def build_completed_backups(backup_dir):
domain_names = ("a", "b", "vm-10", "matching", "matching2")
backup_properties = (
(arrow.get("2016-07-08 19:40:02").to("local"), None),
(arrow.get("2016-07-08 18:40:02").to("local"), None),
(arrow.get("2016-07-08 18:30:02").to("local"), None),
(arrow.get("2016-07-08 17:40:02").to("local"), None),
(arrow.get("2016-07-07 19:40:02").to("local"), None),
(arrow.get("2016-07-07 21:40:02").to("local"), None),
(arrow.get("2016-07-06 20:40:02").to("local"), None),
(arrow.get("2016-04-08 19:40:02").to("local"), None),
(arrow.get("2014-05-01 00:30:00").to("local"), "tar"),
(arrow.get("2016-03-08 14:28:13").to("local"), "xz"),
)
conn = MockConn()
for domain_id, domain_name in enumerate(domain_names):
domain_bdir = os.path.join(backup_dir, domain_name)
os.mkdir(domain_bdir)
domain = MockDomain(conn, name=domain_name, id=domain_id)
dbackup = DomBackup(domain, domain_bdir, dev_disks=("vda", "vdb"))
for bakdate, compression in backup_properties:
dbackup.compression = compression
definition = build_complete_backup_files_from_domainbackup(
dbackup, bakdate)
dbackup._dump_json_definition(definition)
# create a bad json file
with open(os.path.join(domain_bdir, "badfile.json"), "w"):
pass
return (domain_names, (bp[0] for bp in backup_properties))
def prepare_clean_aborted_dombkup(self, mock_domain, target_dir, mocker):
dombkup = DomBackup(dom=mock_domain, target_dir=str(target_dir))
dombkup.pending_info["date"] = 0
mocker.patch("virt_backup.backups.snapshot.DomExtSnapshot.clean")
return dombkup
def test_manually_pivot_disk(self, build_mock_domain,
build_mock_libvirtconn):
conn = build_mock_libvirtconn
dombkup = DomBackup(dom=build_mock_domain, conn=conn)
dombkup._manually_pivot_disk("vda", "/testvda")
dom_xml = dombkup.dom.XMLDesc()
assert self.get_src_for_disk(dom_xml, "vda") == "/testvda"
def test_add_dombackup_dedup(self, build_mock_domain):
dom = build_mock_domain
backup_group = BackupGroup(domlst=(dom, ))
backup_group.add_dombackup(DomBackup(dom, dev_disks=("vda", )))
backup_group.add_dombackup(DomBackup(dom, dev_disks=("vdb", )))
assert len(backup_group.backups) == 1
assert len(backup_group.backups[0].disks.keys()) == 2
def prepare_clean_aborted_dombkup(self, mock_domain, target_dir,
mocker):
dombkup = DomBackup(dom=mock_domain, target_dir=str(target_dir))
dombkup.pending_info["date"] = 0
mocker.patch("virt_backup.backups.snapshot.DomExtSnapshot.clean")
return dombkup
def take_snapshot_and_return_date(self, mock_domain, target_dir,
monkeypatch):
dombkup = DomBackup(dom=mock_domain,
dev_disks=("vda", ),
target_dir=target_dir)
monkeypatch.setattr(dombkup, "external_snapshot",
lambda: MockSnapshot(name="test"))
definition = dombkup.get_definition()
return dombkup._snapshot_and_save_date(definition)
def test_get_new_tar_already_exists(self, build_mock_domain, tmpdir):
dombkup = DomBackup(dom=build_mock_domain, compression="tar")
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
tar_path = tmpdir.join("{}.tar".format(
dombkup._main_backup_name_format(snapdate)))
tar_path.write("test")
with pytest.raises(FileExistsError):
dombkup.get_new_tar(str(tmpdir), snapshot_date=snapdate)
def test_get_disks_with_filter(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain)
expected_disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
}
assert dombkup._get_self_domain_disks("vda") == expected_disks
def test_get_disks_with_filter(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain)
expected_disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
}
assert dombkup._get_self_domain_disks("vda") == expected_disks
def test_get_libvirt_snapshot_xml(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain)
expected_xml = (
"<domainsnapshot>\n"
" <description>Pre-backup external snapshot</description>\n"
" <disks>\n"
" <disk name=\"vda\" snapshot=\"external\"/>\n"
" <disk name=\"vdb\" snapshot=\"external\"/>\n"
" </disks>\n"
"</domainsnapshot>\n")
assert dombkup.gen_libvirt_snapshot_xml() == expected_xml
def test_get_new_tar_already_exists(self, build_mock_domain, tmpdir):
dombkup = DomBackup(
dom=build_mock_domain, compression="tar"
)
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
tar_path = tmpdir.join(
"{}.tar".format(dombkup._main_backup_name_format(snapdate))
)
tar_path.write("test")
with pytest.raises(FileExistsError):
dombkup.get_new_tar(str(tmpdir), snapshot_date=snapdate)
def test_get_definition(self, build_mock_domain):
dombkup = DomBackup(
dom=build_mock_domain, dev_disks=("vda", ),
compression="xz", compression_lvl=4
)
expected_def = {
"compression": "xz", "compression_lvl": 4,
"domain_id": build_mock_domain.ID(),
"domain_name": build_mock_domain.name(),
"domain_xml": build_mock_domain.XMLDesc(),
"version": virt_backup.VERSION
}
assert dombkup.get_definition() == expected_def
def test_dump_json_definition(self, build_mock_domain, tmpdir):
target_dir = tmpdir.mkdir("json_dump")
dombkup = DomBackup(
dom=build_mock_domain, dev_disks=("vda", ),
compression="xz", compression_lvl=4, target_dir=str(target_dir),
)
definition = dombkup.get_definition()
datenow = datetime.datetime.now()
definition["date"] = datenow.timestamp()
dombkup._dump_json_definition(definition)
assert len(target_dir.listdir()) == 1
assert json.loads(target_dir.listdir()[0].read()) == definition
def prepare_clean_aborted_dombkup(self, mock_domain, target_dir,
monkeypatch):
def mock_post_backup_cleaning_snapshot(*args, **kwargs):
return None
dombkup = DomBackup(dom=mock_domain, target_dir=str(target_dir))
dombkup.pending_info["date"] = 0
# TODO: will have to check if pivot is triggered, and temp snapshot
# deleted
monkeypatch.setattr(dombkup, "post_backup_cleaning_snapshot",
mock_post_backup_cleaning_snapshot)
return dombkup
def test_get_new_tar(self, build_mock_domain, tmpdir, compression="tar"):
dombkup = DomBackup(dom=build_mock_domain, compression=compression)
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
target_dir = tmpdir.join("get_new_tar")
if compression == "tar":
extension = "tar"
else:
extension = "tar.{}".format(compression)
tar_path = target_dir.join("{}.{}".format(
dombkup._main_backup_name_format(snapdate), extension))
with dombkup.get_new_tar(str(target_dir), snapshot_date=snapdate):
assert tar_path.check()
def take_snapshot_and_return_date(self, mock_domain, target_dir,
monkeypatch):
dombkup = DomBackup(dom=mock_domain,
dev_disks=("vda", ),
target_dir=target_dir)
snapshot_helper = DomExtSnapshot(dombkup.dom, dombkup.disks,
dombkup.conn, dombkup.timeout)
monkeypatch.setattr(snapshot_helper, "external_snapshot",
lambda: MockSnapshot(name="test"))
dombkup._ext_snapshot_helper = snapshot_helper
definition = dombkup.get_definition()
return dombkup._snapshot_and_save_date(definition)
def test_get_definition(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain,
dev_disks=("vda", ),
compression="xz",
compression_lvl=4)
expected_def = {
"compression": "xz",
"compression_lvl": 4,
"domain_id": build_mock_domain.ID(),
"domain_name": build_mock_domain.name(),
"domain_xml": build_mock_domain.XMLDesc(),
"version": virt_backup.VERSION
}
assert dombkup.get_definition() == expected_def
def get_compressed_dombackup(build_mock_domain):
return DomBackup(
dom=build_mock_domain,
dev_disks=("vda", ),
compression="xz",
compression_lvl=4,
)
def get_uncompressed_dombackup(build_mock_domain, build_mock_libvirtconn):
callbacks_registrer = DomExtSnapshotCallbackRegistrer(
build_mock_libvirtconn)
return DomBackup(dom=build_mock_domain,
dev_disks=("vda", ),
compression=None,
callbacks_registrer=callbacks_registrer)
def test_dump_json_definition(self, build_mock_domain, tmpdir):
target_dir = tmpdir.mkdir("json_dump")
dombkup = DomBackup(
dom=build_mock_domain,
dev_disks=("vda", ),
compression="xz",
compression_lvl=4,
target_dir=str(target_dir),
)
definition = dombkup.get_definition()
datenow = datetime.datetime.now()
definition["date"] = datenow.timestamp()
dombkup._dump_json_definition(definition)
assert len(target_dir.listdir()) == 1
assert json.loads(target_dir.listdir()[0].read()) == definition
def get_uncompressed_dombackup(build_mock_domain, build_mock_libvirtconn):
callbacks_registrer = DomExtSnapshotCallbackRegistrer(build_mock_libvirtconn)
return DomBackup(
dom=build_mock_domain,
dev_disks=("vda",),
packager="directory",
callbacks_registrer=callbacks_registrer,
)
def take_snapshot_and_return_date(self, mock_domain, target_dir,
monkeypatch):
dombkup = DomBackup(
dom=mock_domain, dev_disks=("vda", ), target_dir=target_dir
)
snapshot_helper = DomExtSnapshot(
dombkup.dom, dombkup.disks, dombkup.conn, dombkup.timeout
)
monkeypatch.setattr(
snapshot_helper, "external_snapshot",
lambda: MockSnapshot(name="test")
)
dombkup._ext_snapshot_helper = snapshot_helper
definition = dombkup.get_definition()
return dombkup._snapshot_and_save_date(definition)
def get_compressed_dombackup(build_mock_domain, build_mock_libvirtconn):
callbacks_registrer = DomExtSnapshotCallbackRegistrer(build_mock_libvirtconn)
return DomBackup(
dom=build_mock_domain,
dev_disks=("vda",),
packager="tar",
packager_opts={"compression": "xz", "compression_lvl": 4},
callbacks_registrer=callbacks_registrer,
)
def test_get_new_tar(self, build_mock_domain, tmpdir, compression="tar"):
dombkup = DomBackup(
dom=build_mock_domain, compression=compression
)
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
target_dir = tmpdir.join("get_new_tar")
if compression == "tar":
extension = "tar"
else:
extension = "tar.{}".format(compression)
tar_path = target_dir.join(
"{}.{}".format(
dombkup._main_backup_name_format(snapdate), extension
)
)
with dombkup.get_new_tar(str(target_dir), snapshot_date=snapdate):
assert tar_path.check()
def test_compatible_with(self, get_uncompressed_dombackup,
build_mock_domain):
dombackup1 = get_uncompressed_dombackup
dombackup2 = DomBackup(
dom=build_mock_domain,
dev_disks=("vdb", ),
compression=None,
)
assert dombackup1.compatible_with(dombackup2)
def test_init_with_disk(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain, dev_disks=("vda", ))
expected_disks = {
"vda": {
"src": "/var/lib/libvirt/images/test-disk-1.qcow2",
"type": "qcow2",
},
}
assert dombkup.disks == expected_disks
def test_clean_pending_info(self, build_mock_domain, tmpdir):
target_dir = tmpdir.mkdir("clean_pending_info")
dombkup = DomBackup(dom=build_mock_domain, target_dir=str(target_dir))
dombkup.pending_info["date"] = 0
dombkup._dump_pending_info()
assert len(target_dir.listdir()) == 1
dombkup._clean_pending_info()
assert len(target_dir.listdir()) == 0
def test_clean_broken(self, build_backup_directory, build_mock_domain,
build_mock_libvirtconn, mocker):
build_mock_libvirtconn._domains.append(build_mock_domain)
backup_dir = build_backup_directory["backup_dir"]
group = CompleteBackupGroup(name="test",
backup_dir=str(backup_dir),
hosts=["r:.*"],
conn=build_mock_libvirtconn)
dombkup = DomBackup(dom=build_mock_domain,
target_dir=str(
backup_dir.mkdir(build_mock_domain.name())))
dombkup.pending_info["domain_name"] = build_mock_domain.name()
dombkup.pending_info["date"] = 0
dombkup._dump_pending_info()
group.scan_backup_dir()
nb_initial_backups = sum(len(b) for b in group.broken_backups.values())
assert nb_initial_backups == 1
broken_backup = group.broken_backups[build_mock_domain.name()][0]
mocker.spy(broken_backup, "clean_aborted")
group.clean_broken_backups()
assert not group.broken_backups[build_mock_domain.name()]
assert broken_backup.clean_aborted.called
def test_clean_pending_info(self, build_mock_domain, tmpdir):
target_dir = tmpdir.mkdir("clean_pending_info")
dombkup = DomBackup(dom=build_mock_domain, target_dir=str(target_dir))
dombkup.pending_info["date"] = 0
dombkup._dump_pending_info()
assert len(target_dir.listdir()) == 1
dombkup._clean_pending_info()
assert len(target_dir.listdir()) == 0
def add_domain(self, dom, disks=()):
"""
Add a domain and disks to backup in this group
If a backup already exists for the domain, will add the disks to the
first backup found
:param dom: dom to backup
:param disks: disks to backup and attached to dom
"""
try:
# if a backup of `dom` already exists, add the disks to the first
# backup found
existing_bak = next(self.search(dom))
existing_bak.add_disks(*disks)
except StopIteration:
# spawn a new DomBackup instance otherwise
self.backups.append(
DomBackup(dom=dom, dev_disks=disks, **self.default_bak_param))
def build_dombackup(dom, *dombackup_args, **dombackup_kwargs):
callbacks_registrer = DomExtSnapshotCallbackRegistrer(dom._conn)
return DomBackup(dom,
*dombackup_args,
callbacks_registrer=callbacks_registrer,
**dombackup_kwargs)
def get_uncompressed_dombackup(build_mock_domain):
return DomBackup(
dom=build_mock_domain,
dev_disks=("vda", ),
compression=None,
)
def test_main_backup_name_format(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain)
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
expected_name = "20160815-171013_1_test"
assert dombkup._main_backup_name_format(snapdate) == expected_name
def get_dombackup(build_mock_domain, build_mock_libvirtconn):
callbacks_registrer = DomExtSnapshotCallbackRegistrer(
build_mock_libvirtconn)
return DomBackup(build_mock_domain,
callbacks_registrer=callbacks_registrer)
def test_main_backup_name_format(self, build_mock_domain):
dombkup = DomBackup(dom=build_mock_domain)
snapdate = datetime.datetime(2016, 8, 15, 17, 10, 13, 0)
expected_name = "20160815-171013_1_test"
assert dombkup._main_backup_name_format(snapdate) == expected_name
