9f8fa2853a
Lets not do silly things and if the disk looks bootable, and we're not trying to do UEFI, then let us assume the proper thing will occur upon power-up. Looks at the boot sector data and if an executable is found in the first 218 bytes, then it bypasses loading a boot loader. Also adds a dependency on the "file" linux distribution package. Change-Id: I11bc26670a08ee13174a43d7cd0f1ab9c1bd35cf Story: 2006474 Task: 36410
526 lines
27 KiB
Python
526 lines
27 KiB
Python
# Copyright 2015 Red Hat, Inc.
|
|
# All Rights Reserved.
|
|
#
|
|
# 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.
|
|
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
|
|
import mock
|
|
from oslo_concurrency import processutils
|
|
|
|
from ironic_python_agent import errors
|
|
from ironic_python_agent.extensions import image
|
|
from ironic_python_agent.extensions import iscsi
|
|
from ironic_python_agent import hardware
|
|
from ironic_python_agent.tests.unit import base
|
|
from ironic_python_agent import utils
|
|
|
|
|
|
@mock.patch.object(hardware, 'dispatch_to_managers', autospec=True)
|
|
@mock.patch.object(utils, 'execute', autospec=True)
|
|
@mock.patch.object(tempfile, 'mkdtemp', lambda *_: '/tmp/fake-dir')
|
|
@mock.patch.object(shutil, 'rmtree', lambda *_: None)
|
|
class TestImageExtension(base.IronicAgentTest):
|
|
|
|
def setUp(self):
|
|
super(TestImageExtension, self).setUp()
|
|
self.agent_extension = image.ImageExtension()
|
|
self.fake_dev = '/dev/fake'
|
|
self.fake_efi_system_part = '/dev/fake1'
|
|
self.fake_root_part = '/dev/fake2'
|
|
self.fake_prep_boot_part = '/dev/fake3'
|
|
self.fake_root_uuid = '11111111-2222-3333-4444-555555555555'
|
|
self.fake_efi_system_part_uuid = '45AB-2312'
|
|
self.fake_prep_boot_part_uuid = '76937797-3253-8843-999999999999'
|
|
self.fake_dir = '/tmp/fake-dir'
|
|
|
|
@mock.patch.object(iscsi, 'clean_up', autospec=True)
|
|
@mock.patch.object(image, '_install_grub2', autospec=True)
|
|
def test_install_bootloader_bios(self, mock_grub2, mock_iscsi_clean,
|
|
mock_execute, mock_dispatch):
|
|
mock_dispatch.return_value = self.fake_dev
|
|
self.agent_extension.install_bootloader(root_uuid=self.fake_root_uuid)
|
|
mock_dispatch.assert_called_once_with('get_os_install_device')
|
|
mock_grub2.assert_called_once_with(
|
|
self.fake_dev, root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=None, prep_boot_part_uuid=None)
|
|
mock_iscsi_clean.assert_called_once_with(self.fake_dev)
|
|
|
|
@mock.patch.object(iscsi, 'clean_up', autospec=True)
|
|
@mock.patch.object(image, '_install_grub2', autospec=True)
|
|
def test_install_bootloader_uefi(self, mock_grub2, mock_iscsi_clean,
|
|
mock_execute, mock_dispatch):
|
|
mock_dispatch.return_value = self.fake_dev
|
|
self.agent_extension.install_bootloader(
|
|
root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=self.fake_efi_system_part_uuid)
|
|
mock_dispatch.assert_called_once_with('get_os_install_device')
|
|
mock_grub2.assert_called_once_with(
|
|
self.fake_dev,
|
|
root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=self.fake_efi_system_part_uuid,
|
|
prep_boot_part_uuid=None)
|
|
mock_iscsi_clean.assert_called_once_with(self.fake_dev)
|
|
|
|
@mock.patch.object(iscsi, 'clean_up', autospec=True)
|
|
@mock.patch.object(image, '_install_grub2', autospec=True)
|
|
def test_install_bootloader_prep(self, mock_grub2, mock_iscsi_clean,
|
|
mock_execute, mock_dispatch):
|
|
mock_dispatch.return_value = self.fake_dev
|
|
self.agent_extension.install_bootloader(
|
|
root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=None,
|
|
prep_boot_part_uuid=self.fake_prep_boot_part_uuid)
|
|
mock_dispatch.assert_called_once_with('get_os_install_device')
|
|
mock_grub2.assert_called_once_with(
|
|
self.fake_dev,
|
|
root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=None,
|
|
prep_boot_part_uuid=self.fake_prep_boot_part_uuid)
|
|
mock_iscsi_clean.assert_called_once_with(self.fake_dev)
|
|
|
|
@mock.patch.object(image, '_is_bootloader_loaded', lambda *_: False)
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
@mock.patch.object(hardware, 'md_get_raid_devices', autospec=True)
|
|
@mock.patch.object(os, 'environ', autospec=True)
|
|
@mock.patch.object(image, '_get_partition', autospec=True)
|
|
def test__install_grub2(self, mock_get_part_uuid, environ_mock,
|
|
mock_md_get_raid_devices, mock_is_md_device,
|
|
mock_execute, mock_dispatch):
|
|
mock_get_part_uuid.return_value = self.fake_root_part
|
|
environ_mock.get.return_value = '/sbin'
|
|
mock_is_md_device.return_value = False
|
|
mock_md_get_raid_devices.return_value = {}
|
|
image._install_grub2(self.fake_dev, self.fake_root_uuid)
|
|
|
|
expected = [mock.call('mount', '/dev/fake2', self.fake_dir),
|
|
mock.call('mount', '-o', 'bind', '/dev',
|
|
self.fake_dir + '/dev'),
|
|
mock.call('mount', '-o', 'bind', '/proc',
|
|
self.fake_dir + '/proc'),
|
|
mock.call('mount', '-o', 'bind', '/run',
|
|
self.fake_dir + '/run'),
|
|
mock.call('mount', '-t', 'sysfs', 'none',
|
|
self.fake_dir + '/sys'),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-install %s"' %
|
|
(self.fake_dir, self.fake_dev)), shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-mkconfig -o '
|
|
'/boot/grub/grub.cfg"' % self.fake_dir),
|
|
shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call('umount', self.fake_dir + '/dev',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/proc',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/run',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/sys',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir, attempts=3,
|
|
delay_on_retry=True)]
|
|
mock_execute.assert_has_calls(expected)
|
|
mock_get_part_uuid.assert_called_once_with(self.fake_dev,
|
|
uuid=self.fake_root_uuid)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
@mock.patch.object(image, '_is_bootloader_loaded', lambda *_: False)
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
@mock.patch.object(hardware, 'md_get_raid_devices', autospec=True)
|
|
@mock.patch.object(os, 'environ', autospec=True)
|
|
@mock.patch.object(image, '_get_partition', autospec=True)
|
|
def test__install_grub2_prep(self, mock_get_part_uuid, environ_mock,
|
|
mock_md_get_raid_devices, mock_is_md_device,
|
|
mock_execute, mock_dispatch):
|
|
mock_get_part_uuid.side_effect = [self.fake_root_part,
|
|
self.fake_prep_boot_part]
|
|
environ_mock.get.return_value = '/sbin'
|
|
mock_is_md_device.return_value = False
|
|
mock_md_get_raid_devices.return_value = {}
|
|
image._install_grub2(self.fake_dev, self.fake_root_uuid,
|
|
prep_boot_part_uuid=self.fake_prep_boot_part_uuid)
|
|
|
|
expected = [mock.call('mount', '/dev/fake2', self.fake_dir),
|
|
mock.call('mount', '-o', 'bind', '/dev',
|
|
self.fake_dir + '/dev'),
|
|
mock.call('mount', '-o', 'bind', '/proc',
|
|
self.fake_dir + '/proc'),
|
|
mock.call('mount', '-o', 'bind', '/run',
|
|
self.fake_dir + '/run'),
|
|
mock.call('mount', '-t', 'sysfs', 'none',
|
|
self.fake_dir + '/sys'),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-install %s"' %
|
|
(self.fake_dir, self.fake_prep_boot_part)),
|
|
shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-mkconfig -o '
|
|
'/boot/grub/grub.cfg"' % self.fake_dir),
|
|
shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call('umount', self.fake_dir + '/dev',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/proc',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/run',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/sys',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir, attempts=3,
|
|
delay_on_retry=True)]
|
|
mock_execute.assert_has_calls(expected)
|
|
mock_get_part_uuid.assert_any_call(self.fake_dev,
|
|
uuid=self.fake_root_uuid)
|
|
mock_get_part_uuid.assert_any_call(self.fake_dev,
|
|
uuid=self.fake_prep_boot_part_uuid)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
@mock.patch.object(image, '_is_bootloader_loaded', lambda *_: True)
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
@mock.patch.object(hardware, 'md_get_raid_devices', autospec=True)
|
|
@mock.patch.object(os, 'environ', autospec=True)
|
|
@mock.patch.object(os, 'makedirs', autospec=True)
|
|
@mock.patch.object(image, '_get_partition', autospec=True)
|
|
def test__install_grub2_uefi(self, mock_get_part_uuid, mkdir_mock,
|
|
environ_mock, mock_md_get_raid_devices,
|
|
mock_is_md_device, mock_execute,
|
|
mock_dispatch):
|
|
mock_get_part_uuid.side_effect = [self.fake_root_part,
|
|
self.fake_efi_system_part]
|
|
environ_mock.get.return_value = '/sbin'
|
|
mock_is_md_device.return_value = False
|
|
mock_md_get_raid_devices.return_value = {}
|
|
|
|
image._install_grub2(
|
|
self.fake_dev, root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=self.fake_efi_system_part_uuid)
|
|
|
|
expected = [mock.call('mount', '/dev/fake2', self.fake_dir),
|
|
mock.call('mount', '-o', 'bind', '/dev',
|
|
self.fake_dir + '/dev'),
|
|
mock.call('mount', '-o', 'bind', '/proc',
|
|
self.fake_dir + '/proc'),
|
|
mock.call('mount', '-o', 'bind', '/run',
|
|
self.fake_dir + '/run'),
|
|
mock.call('mount', '-t', 'sysfs', 'none',
|
|
self.fake_dir + '/sys'),
|
|
mock.call('mount', self.fake_efi_system_part,
|
|
self.fake_dir + '/boot/efi'),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-install %s"' %
|
|
(self.fake_dir, self.fake_dev)), shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-install %s --removable"' %
|
|
(self.fake_dir, self.fake_dev)), shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-mkconfig -o '
|
|
'/boot/grub/grub.cfg"' % self.fake_dir),
|
|
shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call('umount', self.fake_dir + '/boot/efi',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/dev',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/proc',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/run',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/sys',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir, attempts=3,
|
|
delay_on_retry=True)]
|
|
mkdir_mock.assert_called_once_with(self.fake_dir + '/boot/efi')
|
|
mock_execute.assert_has_calls(expected)
|
|
mock_get_part_uuid.assert_any_call(self.fake_dev,
|
|
uuid=self.fake_root_uuid)
|
|
mock_get_part_uuid.assert_any_call(self.fake_dev,
|
|
uuid=self.fake_efi_system_part_uuid)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
@mock.patch.object(image, '_is_bootloader_loaded', lambda *_: False)
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
@mock.patch.object(hardware, 'md_get_raid_devices', autospec=True)
|
|
@mock.patch.object(os, 'environ', autospec=True)
|
|
@mock.patch.object(os, 'makedirs', autospec=True)
|
|
@mock.patch.object(image, '_get_partition', autospec=True)
|
|
def test__install_grub2_uefi_umount_fails(
|
|
self, mock_get_part_uuid, mkdir_mock, environ_mock,
|
|
mock_md_get_raid_devices, mock_is_md_device, mock_execute,
|
|
mock_dispatch):
|
|
mock_get_part_uuid.side_effect = [self.fake_root_part,
|
|
self.fake_efi_system_part]
|
|
mock_is_md_device.return_value = False
|
|
mock_md_get_raid_devices.return_value = {}
|
|
|
|
def umount_raise_func(*args, **kwargs):
|
|
if args[0] == 'umount':
|
|
raise processutils.ProcessExecutionError('error')
|
|
|
|
mock_execute.side_effect = umount_raise_func
|
|
environ_mock.get.return_value = '/sbin'
|
|
self.assertRaises(errors.CommandExecutionError,
|
|
image._install_grub2,
|
|
self.fake_dev, root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=self.fake_efi_system_part_uuid)
|
|
|
|
expected = [mock.call('mount', '/dev/fake2', self.fake_dir),
|
|
mock.call('mount', '-o', 'bind', '/dev',
|
|
self.fake_dir + '/dev'),
|
|
mock.call('mount', '-o', 'bind', '/proc',
|
|
self.fake_dir + '/proc'),
|
|
mock.call('mount', '-o', 'bind', '/run',
|
|
self.fake_dir + '/run'),
|
|
mock.call('mount', '-t', 'sysfs', 'none',
|
|
self.fake_dir + '/sys'),
|
|
mock.call('mount', self.fake_efi_system_part,
|
|
self.fake_dir + '/boot/efi'),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-install %s"' %
|
|
(self.fake_dir, self.fake_dev)), shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-install %s --removable"' %
|
|
(self.fake_dir, self.fake_dev)), shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call(('chroot %s /bin/sh -c '
|
|
'"grub-mkconfig -o '
|
|
'/boot/grub/grub.cfg"' % self.fake_dir),
|
|
shell=True,
|
|
env_variables={'PATH': '/sbin:/bin:/usr/sbin'}),
|
|
mock.call('umount', self.fake_dir + '/boot/efi',
|
|
attempts=3, delay_on_retry=True)]
|
|
mock_execute.assert_has_calls(expected)
|
|
|
|
@mock.patch.object(image, '_is_bootloader_loaded', lambda *_: False)
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
@mock.patch.object(hardware, 'md_get_raid_devices', autospec=True)
|
|
@mock.patch.object(os, 'environ', autospec=True)
|
|
@mock.patch.object(os, 'makedirs', autospec=True)
|
|
@mock.patch.object(image, '_get_partition', autospec=True)
|
|
def test__install_grub2_uefi_mount_fails(
|
|
self, mock_get_part_uuid, mkdir_mock, environ_mock,
|
|
mock_is_md_device, mock_md_get_raid_devices, mock_execute,
|
|
mock_dispatch):
|
|
mock_get_part_uuid.side_effect = [self.fake_root_part,
|
|
self.fake_efi_system_part]
|
|
mock_is_md_device.side_effect = [False, False]
|
|
mock_md_get_raid_devices.return_value = {}
|
|
|
|
def mount_raise_func(*args, **kwargs):
|
|
if args[0] == 'mount':
|
|
raise processutils.ProcessExecutionError('error')
|
|
|
|
mock_execute.side_effect = mount_raise_func
|
|
self.assertRaises(errors.CommandExecutionError,
|
|
image._install_grub2,
|
|
self.fake_dev, root_uuid=self.fake_root_uuid,
|
|
efi_system_part_uuid=self.fake_efi_system_part_uuid)
|
|
|
|
expected = [mock.call('mount', '/dev/fake2', self.fake_dir),
|
|
mock.call('umount', self.fake_dir + '/dev',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/proc',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/run',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir + '/sys',
|
|
attempts=3, delay_on_retry=True),
|
|
mock.call('umount', self.fake_dir, attempts=3,
|
|
delay_on_retry=True)]
|
|
mock_execute.assert_has_calls(expected)
|
|
|
|
@mock.patch.object(image, '_is_bootloader_loaded', lambda *_: False)
|
|
@mock.patch.object(image, '_get_partition', autospec=True)
|
|
def test__install_grub2_command_fail(self, mock_get_part_uuid,
|
|
mock_execute,
|
|
mock_dispatch):
|
|
mock_get_part_uuid.return_value = self.fake_root_part
|
|
mock_execute.side_effect = processutils.ProcessExecutionError('boom')
|
|
|
|
self.assertRaises(errors.CommandExecutionError, image._install_grub2,
|
|
self.fake_dev, self.fake_root_uuid)
|
|
|
|
mock_get_part_uuid.assert_called_once_with(self.fake_dev,
|
|
uuid=self.fake_root_uuid)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
@mock.patch.object(image, '_is_bootloader_loaded', autospec=True)
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
def test__get_partition(self, mock_is_md_device, mock_is_bootloader,
|
|
mock_execute, mock_dispatch):
|
|
mock_is_md_device.side_effect = [False]
|
|
mock_is_md_device.side_effect = [False, False]
|
|
lsblk_output = ('''KNAME="test" UUID="" TYPE="disk"
|
|
KNAME="test1" UUID="256a39e3-ca3c-4fb8-9cc2-b32eec441f47" TYPE="part"
|
|
KNAME="test2" UUID="%s" TYPE="part"''' % self.fake_root_uuid)
|
|
mock_execute.side_effect = (None, None, [lsblk_output])
|
|
|
|
root_part = image._get_partition(self.fake_dev, self.fake_root_uuid)
|
|
self.assertEqual('/dev/test2', root_part)
|
|
expected = [mock.call('partx', '-u', self.fake_dev, attempts=3,
|
|
delay_on_retry=True),
|
|
mock.call('udevadm', 'settle'),
|
|
mock.call('lsblk', '-PbioKNAME,UUID,PARTUUID,TYPE',
|
|
self.fake_dev)]
|
|
mock_execute.assert_has_calls(expected)
|
|
self.assertFalse(mock_dispatch.called)
|
|
self.assertFalse(mock_is_bootloader.called)
|
|
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
def test__get_partition_no_device_found(self, mock_is_md_device,
|
|
mock_execute, mock_dispatch):
|
|
mock_is_md_device.side_effect = [False, False]
|
|
lsblk_output = ('''KNAME="test" UUID="" TYPE="disk"
|
|
KNAME="test1" UUID="256a39e3-ca3c-4fb8-9cc2-b32eec441f47" TYPE="part"
|
|
KNAME="test2" UUID="" TYPE="part"''')
|
|
mock_execute.side_effect = (
|
|
None, None, [lsblk_output],
|
|
processutils.ProcessExecutionError('boom'),
|
|
processutils.ProcessExecutionError('kaboom'))
|
|
|
|
self.assertRaises(errors.DeviceNotFound,
|
|
image._get_partition, self.fake_dev,
|
|
self.fake_root_uuid)
|
|
expected = [mock.call('partx', '-u', self.fake_dev, attempts=3,
|
|
delay_on_retry=True),
|
|
mock.call('udevadm', 'settle'),
|
|
mock.call('lsblk', '-PbioKNAME,UUID,PARTUUID,TYPE',
|
|
self.fake_dev)]
|
|
mock_execute.assert_has_calls(expected)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
def test__get_partition_fallback_partuuid(self, mock_is_md_device,
|
|
mock_execute, mock_dispatch):
|
|
mock_is_md_device.side_effect = [False]
|
|
lsblk_output = ('''KNAME="test" UUID="" TYPE="disk"
|
|
KNAME="test1" UUID="256a39e3-ca3c-4fb8-9cc2-b32eec441f47" TYPE="part"
|
|
KNAME="test2" UUID="" TYPE="part"''')
|
|
findfs_output = ('/dev/loop0\n', None)
|
|
mock_execute.side_effect = (
|
|
None, None, [lsblk_output],
|
|
processutils.ProcessExecutionError('boom'),
|
|
findfs_output)
|
|
|
|
result = image._get_partition(self.fake_dev, self.fake_root_uuid)
|
|
self.assertEqual('/dev/loop0', result)
|
|
expected = [mock.call('partx', '-u', self.fake_dev, attempts=3,
|
|
delay_on_retry=True),
|
|
mock.call('udevadm', 'settle'),
|
|
mock.call('lsblk', '-PbioKNAME,UUID,PARTUUID,TYPE',
|
|
self.fake_dev),
|
|
mock.call('findfs', 'UUID=%s' % self.fake_root_uuid),
|
|
mock.call('findfs', 'PARTUUID=%s' % self.fake_root_uuid)]
|
|
mock_execute.assert_has_calls(expected)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
def test__get_partition_command_fail(self, mock_is_md_device,
|
|
mock_execute, mock_dispatch):
|
|
mock_is_md_device.side_effect = [False, False]
|
|
mock_execute.side_effect = (None, None,
|
|
processutils.ProcessExecutionError('boom'))
|
|
self.assertRaises(errors.CommandExecutionError,
|
|
image._get_partition, self.fake_dev,
|
|
self.fake_root_uuid)
|
|
|
|
expected = [mock.call('partx', '-u', self.fake_dev, attempts=3,
|
|
delay_on_retry=True),
|
|
mock.call('udevadm', 'settle'),
|
|
mock.call('lsblk', '-PbioKNAME,UUID,PARTUUID,TYPE',
|
|
self.fake_dev)]
|
|
mock_execute.assert_has_calls(expected)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
@mock.patch.object(hardware, 'is_md_device', autospec=True)
|
|
def test__get_partition_partuuid(self, mock_is_md_device, mock_execute,
|
|
mock_dispatch):
|
|
mock_is_md_device.side_effect = [False, False]
|
|
lsblk_output = ('''KNAME="test" UUID="" TYPE="disk"
|
|
KNAME="test1" UUID="256a39e3-ca3c-4fb8-9cc2-b32eec441f47" TYPE="part"
|
|
KNAME="test2" PARTUUID="%s" TYPE="part"''' % self.fake_root_uuid)
|
|
mock_execute.side_effect = (None, None, [lsblk_output])
|
|
|
|
root_part = image._get_partition(self.fake_dev, self.fake_root_uuid)
|
|
self.assertEqual('/dev/test2', root_part)
|
|
expected = [mock.call('partx', '-u', self.fake_dev, attempts=3,
|
|
delay_on_retry=True),
|
|
mock.call('udevadm', 'settle'),
|
|
mock.call('lsblk', '-PbioKNAME,UUID,PARTUUID,TYPE',
|
|
self.fake_dev)]
|
|
mock_execute.assert_has_calls(expected)
|
|
self.assertFalse(mock_dispatch.called)
|
|
|
|
def test__is_bootloader_loaded(self, mock_execute,
|
|
mock_dispatch):
|
|
parted_output = ('BYT;\n'
|
|
'/dev/loop1:46.1MB:loopback:512:512:gpt:Loopback '
|
|
'device:;\n'
|
|
'15:1049kB:9437kB:8389kB:::boot;\n'
|
|
'1:9437kB:46.1MB:36.7MB:ext3::;\n')
|
|
disk_file_output = ('/dev/loop1: partition 1: ID=0xee, starthead 0, '
|
|
'startsector 1, 90111 sectors, extended '
|
|
'partition table (last)\011, code offset 0x48')
|
|
|
|
part_file_output = ('/dev/loop1p15: x86 boot sector, mkdosfs boot '
|
|
'message display, code offset 0x3c, OEM-ID '
|
|
'"mkfs.fat", sectors/cluster 8, root entries '
|
|
'512, sectors 16384 (volumes <=32 MB) , Media '
|
|
'descriptor 0xf8, sectors/FAT 8, heads 255, '
|
|
'serial number 0x23a08feb, unlabeled, '
|
|
'FAT (12 bit)')
|
|
|
|
# NOTE(TheJulia): File evaluates this data, so it is pointless to
|
|
# try and embed the raw bytes in the test.
|
|
dd_output = ('')
|
|
|
|
file_output = ('/dev/loop1: DOS executable (COM)\n')
|
|
|
|
mock_execute.side_effect = iter([(parted_output, ''),
|
|
(disk_file_output, ''),
|
|
(part_file_output, ''),
|
|
(dd_output, ''),
|
|
(file_output, '')])
|
|
|
|
result = image._is_bootloader_loaded(self.fake_dev)
|
|
self.assertTrue(result)
|
|
|
|
def test__is_bootloader_loaded_not_bootable(self,
|
|
mock_execute,
|
|
mock_dispatch):
|
|
parted_output = ('BYT;\n'
|
|
'/dev/loop1:46.1MB:loopback:512:512:gpt:Loopback '
|
|
'device:;\n'
|
|
'15:1049kB:9437kB:8389kB:::;\n'
|
|
'1:9437kB:46.1MB:36.7MB:ext3::;\n')
|
|
mock_execute.return_value = (parted_output, '')
|
|
result = image._is_bootloader_loaded(self.fake_dev)
|
|
self.assertFalse(result)
|
|
|
|
def test__is_bootloader_loaded_empty(self,
|
|
mock_execute,
|
|
mock_dispatch):
|
|
parted_output = ('BYT;\n'
|
|
'/dev/loop1:46.1MB:loopback:512:512:gpt:Loopback '
|
|
'device:;\n')
|
|
mock_execute.return_value = (parted_output, '')
|
|
result = image._is_bootloader_loaded(self.fake_dev)
|
|
self.assertFalse(result)
|