Example #1
0
def test_incremental_backup_with_backup_mode(tmp_dirs):
    vm = FakeVm()
    dom = FakeDomainAdapter()
    fake_disks = create_fake_disks(vm, backup_mode=backup.MODE_FULL)

    # start full backup
    config = {
        'backup_id': BACKUP_1_ID,
        'disks': fake_disks,
        'to_checkpoint_id': CHECKPOINT_1_ID
    }

    backup.start_backup(vm, dom, config)
    backup.stop_backup(vm, dom, BACKUP_1_ID)

    # start incremental backup

    socket = backup.socket_path(BACKUP_2_ID)
    scratch1 = scratch_disk_path(vm, BACKUP_2_ID, "sda")
    scratch2 = scratch_disk_path(vm, BACKUP_2_ID, "vda")

    dom.output_checkpoints = [CHECKPOINT_1]

    # Set vda disk backup_mode to 'incremental'
    for disk in fake_disks:
        if disk["imageID"] == IMAGE_2_UUID:
            disk["backup_mode"] = backup.MODE_INCREMENTAL

    config = {
        'backup_id': BACKUP_2_ID,
        'disks': fake_disks,
        'from_checkpoint_id': CHECKPOINT_1_ID,
        'to_checkpoint_id': CHECKPOINT_2_ID,
    }

    backup.start_backup(vm, dom, config)

    backup_xml = f"""
        <domainbackup mode='pull'>
          <incremental>{CHECKPOINT_1_ID}</incremental>
          <server transport='unix' socket='{socket}'/>
          <disks>
            <disk name='sda' backup='yes' type='file' backupmode='full'
                exportname='sda' index='9'>
              <driver type='qcow2'/>
              <scratch file='{scratch1}'>
                <seclabel model='dac' relabel='no'/>
              </scratch>
            </disk>
            <disk name='vda' backup='yes' type='file' backupmode='incremental'
                incremental='{CHECKPOINT_1_ID}' exportname='vda' index='10'>
              <driver type='qcow2'/>
              <scratch file='{scratch2}'>
                <seclabel model="dac" relabel="no"/>
              </scratch>
            </disk>
          </disks>
        </domainbackup>
        """
    assert normalized(dom.backupGetXMLDesc()) == normalized(backup_xml)
Example #2
0
def test_failed_delete_checkpoint():
    error_msg = "Internal delete error"

    dom = FakeDomainAdapter()

    checkpoint_2 = FakeCheckpoint(CHECKPOINT_2_XML, CHECKPOINT_2_ID, dom=dom)
    # simulating an error that raised when calling the delete method
    # of a specific checkpoint
    checkpoint_2.errors["delete"] = fake.libvirt_error(
        [libvirt.VIR_ERR_INTERNAL_ERROR, '', error_msg], "Fake libvirt error")

    dom.output_checkpoints = [
        FakeCheckpoint(CHECKPOINT_1_XML, CHECKPOINT_1_ID, dom=dom),
        checkpoint_2
    ]

    vm = FakeVm()
    res = backup.delete_checkpoints(vm, dom,
                                    [CHECKPOINT_1_ID, CHECKPOINT_2_ID])

    expected_result = {
        'checkpoint_ids': [CHECKPOINT_1_ID],
        'error': {
            'code': 1,
            'message': error_msg
        }
    }
    assert res["result"] == expected_result

    res = backup.list_checkpoints(vm, dom)
    assert res["result"] == [CHECKPOINT_2_ID]
Example #3
0
def test_dump_missing_checkpoint():
    dom = FakeDomainAdapter()
    dom.output_checkpoints = [
        FakeCheckpoint(CHECKPOINT_1_XML, CHECKPOINT_1_ID),
    ]

    with pytest.raises(exception.NoSuchCheckpointError):
        backup.dump_checkpoint(dom, CHECKPOINT_2_ID)
Example #4
0
def test_incremental_backup_with_backup_mode(tmp_backupdir, tmp_basedir):
    vm = FakeVm()
    dom = FakeDomainAdapter()
    fake_disks = create_fake_disks(backup_mode=backup.MODE_FULL)

    # start full backup
    config = {
        'backup_id': BACKUP_1_ID,
        'disks': fake_disks,
        'to_checkpoint_id': CHECKPOINT_1_ID
    }

    backup.start_backup(vm, dom, config)
    backup.stop_backup(vm, dom, BACKUP_1_ID)

    # start incremental backup
    socket_path = backup.socket_path(BACKUP_2_ID)
    scratch_disk_paths = _get_scratch_disks_path(BACKUP_2_ID)

    expected_xml = """
        <domainbackup mode='pull'>
            <incremental>{}</incremental>
            <server transport='unix' socket='{}'/>
            <disks>
                <disk backupmode="full" name='sda' type='file'>
                    <scratch file='{}'>
                        <seclabel model="dac" relabel="no"/>
                    </scratch>
                </disk>
                <disk backupmode="incremental" incremental='{}'
                 name='vda' type='file'>
                    <scratch file='{}'>
                        <seclabel model="dac" relabel="no"/>
                    </scratch>
                </disk>
            </disks>
        </domainbackup>
        """.format(CHECKPOINT_1_ID, socket_path, scratch_disk_paths[0],
                   CHECKPOINT_1_ID, scratch_disk_paths[1])

    dom.output_checkpoints = [CHECKPOINT_1]

    # Set vda disk backup_mode to 'incremental'
    for disk in fake_disks:
        if disk["imageID"] == IMAGE_2_UUID:
            disk["backup_mode"] = backup.MODE_INCREMENTAL

    config = {
        'backup_id': BACKUP_2_ID,
        'disks': fake_disks,
        'from_checkpoint_id': CHECKPOINT_1_ID,
        'to_checkpoint_id': CHECKPOINT_2_ID,
        'parent_checkpoint_id': CHECKPOINT_1_ID
    }

    backup.start_backup(vm, dom, config)
    assert indented(expected_xml) == indented(dom.input_backup_xml)
Example #5
0
def test_dump_checkpoint_lookup_failed():
    dom = FakeDomainAdapter()
    dom.errors["checkpointLookupByName"] = fake.libvirt_error(
        [libvirt.VIR_ERR_INTERNAL_ERROR], "Fake libvirt error")
    dom.output_checkpoints = [
        FakeCheckpoint(CHECKPOINT_1_XML, CHECKPOINT_1_ID),
        FakeCheckpoint(CHECKPOINT_2_XML, CHECKPOINT_2_ID)
    ]

    with pytest.raises(libvirt.libvirtError) as e:
        backup.dump_checkpoint(dom, CHECKPOINT_1_ID)
    assert e.value.get_error_code() == libvirt.VIR_ERR_INTERNAL_ERROR
Example #6
0
def test_dump_checkpoint():
    dom = FakeDomainAdapter()
    dom.output_checkpoints = [
        FakeCheckpoint(CHECKPOINT_1_XML, CHECKPOINT_1_ID),
        FakeCheckpoint(CHECKPOINT_2_XML, CHECKPOINT_2_ID)
    ]

    for checkpoint_cfg in FAKE_CHECKPOINT_CFG:
        res = backup.dump_checkpoint(dom, checkpoint_cfg['id'])

        expected_result = {'checkpoint': checkpoint_cfg['xml']}
        assert res["result"] == expected_result
Example #7
0
def test_delete_one_checkpoint():
    dom = FakeDomainAdapter()
    dom.output_checkpoints = [
        FakeCheckpoint(CHECKPOINT_1_XML, CHECKPOINT_1_ID, dom=dom),
        FakeCheckpoint(CHECKPOINT_2_XML, CHECKPOINT_2_ID, dom=dom)
    ]

    vm = FakeVm()
    res = backup.delete_checkpoints(vm, dom, [CHECKPOINT_1_ID])

    expected_result = {'checkpoint_ids': [CHECKPOINT_1_ID]}
    assert res["result"] == expected_result

    res = backup.list_checkpoints(vm, dom)
    assert res["result"] == [CHECKPOINT_2_ID]
Example #8
0
def test_dump_checkpoint_get_xml_failed():
    checkpoint_2 = FakeCheckpoint(CHECKPOINT_2_XML, CHECKPOINT_2_ID)
    # simulating an error that raised when calling the getXMLDesc method
    # of a specific checkpoint
    checkpoint_2.errors["getXMLDesc"] = fake.libvirt_error(
        [libvirt.VIR_ERR_INTERNAL_ERROR, '', 'Internal get XML error'],
        "Fake libvirt error")

    dom = FakeDomainAdapter()
    dom.output_checkpoints = [
        FakeCheckpoint(CHECKPOINT_1_XML, CHECKPOINT_1_ID), checkpoint_2
    ]

    with pytest.raises(libvirt.libvirtError) as e:
        backup.dump_checkpoint(dom, CHECKPOINT_2_ID)
    assert e.value.get_error_code() == libvirt.VIR_ERR_INTERNAL_ERROR
Example #9
0
def test_delete_missing_checkpoint():
    dom = FakeDomainAdapter()
    dom.output_checkpoints = [
        FakeCheckpoint(CHECKPOINT_2_XML, CHECKPOINT_2_ID, dom=dom)
    ]

    vm = FakeVm()
    res = backup.delete_checkpoints(vm, dom,
                                    [CHECKPOINT_1_ID, CHECKPOINT_2_ID])

    expected_result = {'checkpoint_ids': [CHECKPOINT_1_ID, CHECKPOINT_2_ID]}
    # validate that the missing checkpoint reported as
    # successfully removed
    assert res["result"] == expected_result

    res = backup.list_checkpoints(vm, dom)
    assert res["result"] == []
Example #10
0
def test_incremental_backup(tmp_backupdir, tmp_basedir):
    vm = FakeVm()
    dom = FakeDomainAdapter()
    fake_disks = create_fake_disks()

    # start full backup
    config = {
        'backup_id': BACKUP_1_ID,
        'disks': fake_disks,
        'to_checkpoint_id': CHECKPOINT_1_ID
    }

    res = backup.start_backup(vm, dom, config)
    assert dom.backing_up

    result_disks = res['result']['disks']
    verify_backup_urls(BACKUP_1_ID, result_disks)

    backup.stop_backup(vm, dom, BACKUP_1_ID)
    assert not dom.backing_up

    verify_scratch_disks_removed(vm)

    # start incremental backup
    socket_path = backup.socket_path(BACKUP_2_ID)
    scratch_disk_paths = _get_scratch_disks_path(BACKUP_2_ID)

    expected_xml = """
        <domainbackup mode='pull'>
            <incremental>{}</incremental>
            <server transport='unix' socket='{}'/>
            <disks>
                <disk name='sda' type='file'>
                    <scratch file='{}'>
                        <seclabel model="dac" relabel="no"/>
                    </scratch>
                </disk>
                <disk name='vda' type='file'>
                    <scratch file='{}'>
                        <seclabel model="dac" relabel="no"/>
                    </scratch>
                </disk>
            </disks>
        </domainbackup>
        """.format(CHECKPOINT_1_ID, socket_path, scratch_disk_paths[0],
                   scratch_disk_paths[1])

    dom.output_checkpoints = [CHECKPOINT_1]

    config = {
        'backup_id': BACKUP_2_ID,
        'disks': fake_disks,
        'from_checkpoint_id': CHECKPOINT_1_ID,
        'to_checkpoint_id': CHECKPOINT_2_ID,
        'parent_checkpoint_id': CHECKPOINT_1_ID
    }

    res = backup.start_backup(vm, dom, config)
    assert dom.backing_up
    assert indented(expected_xml) == indented(dom.input_backup_xml)
    assert indented(CHECKPOINT_2_XML) == (indented(dom.input_checkpoint_xml))

    verify_scratch_disks_exists(vm, BACKUP_2_ID)

    # verify that the vm froze and thawed during the backup
    assert vm.froze
    assert vm.thawed

    result_disks = res['result']['disks']
    verify_backup_urls(BACKUP_2_ID, result_disks)

    backup.stop_backup(vm, dom, BACKUP_2_ID)
    verify_scratch_disks_removed(vm)
Example #11
0
def test_incremental_backup(tmp_dirs):
    vm = FakeVm()
    dom = FakeDomainAdapter()
    fake_disks = create_fake_disks(vm)

    # start full backup
    config = {
        'backup_id': BACKUP_1_ID,
        'disks': fake_disks,
        'to_checkpoint_id': CHECKPOINT_1_ID
    }

    res = backup.start_backup(vm, dom, config)
    assert dom.backing_up

    result_disks = res['result']['disks']
    verify_backup_urls(vm, BACKUP_1_ID, result_disks)

    backup.stop_backup(vm, dom, BACKUP_1_ID)
    assert not dom.backing_up

    verify_scratch_disks_removed(vm)

    # start incremental backup

    socket = backup.socket_path(BACKUP_2_ID)
    scratch1 = scratch_disk_path(vm, BACKUP_2_ID, "sda")
    scratch2 = scratch_disk_path(vm, BACKUP_2_ID, "vda")

    dom.output_checkpoints = [CHECKPOINT_1]

    config = {
        'backup_id': BACKUP_2_ID,
        'disks': fake_disks,
        'from_checkpoint_id': CHECKPOINT_1_ID,
        'to_checkpoint_id': CHECKPOINT_2_ID,
    }

    res = backup.start_backup(vm, dom, config)
    assert dom.backing_up

    backup_xml = f"""
        <domainbackup mode='pull'>
          <incremental>{CHECKPOINT_1_ID}</incremental>
          <server transport='unix' socket='{socket}'/>
          <disks>
            <disk name='sda' backup='yes' type='file' backupmode='incremental'
                incremental='{CHECKPOINT_1_ID}' exportname='sda' index='9'>
                <driver type="qcow2"/>
                <scratch file='{scratch1}'>
                  <seclabel model="dac" relabel="no"/>
                </scratch>
            </disk>
            <disk name='vda' backup='yes' type='file' backupmode='incremental'
                incremental='{CHECKPOINT_1_ID}' exportname='vda' index='10'>
              <driver type="qcow2"/>
              <scratch file='{scratch2}'>
                <seclabel model="dac" relabel="no"/>
              </scratch>
            </disk>
          </disks>
        </domainbackup>
        """
    assert normalized(dom.backupGetXMLDesc()) == normalized(backup_xml)

    assert normalized(CHECKPOINT_2_XML) == (normalized(
        dom.input_checkpoint_xml))

    verify_scratch_disks_exists(vm, BACKUP_2_ID)

    # verify that the vm froze and thawed during the backup
    assert vm.froze
    assert vm.thawed

    result_disks = res['result']['disks']
    verify_backup_urls(vm, BACKUP_2_ID, result_disks)

    backup.stop_backup(vm, dom, BACKUP_2_ID)
    verify_scratch_disks_removed(vm)