ceph/src/ceph-volume/ceph_volume/tests/devices/lvm/strategies/test_bluestore.py

   1 import pytest
   2 from ceph_volume.devices.lvm.strategies import bluestore
   3 from ceph_volume.api import lvm
   4
   5
   6 class TestSingleType(object):
   7
   8     def test_hdd_device_is_large_enough(self, fakedevice, factory):
   9         args = factory(filtered_devices=[], osds_per_device=1,
  10                        block_db_size=None, osd_ids=[])
  11         devices = [
  12             fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
  13         ]
  14         computed_osd = bluestore.SingleType.with_auto_devices(args, devices).computed['osds'][0]
  15         assert computed_osd['data']['percentage'] == 100
  16         assert computed_osd['data']['parts'] == 1
  17         assert computed_osd['data']['human_readable_size'] == '5.00 GB'
  18         assert computed_osd['data']['path'] == '/dev/sda'
  19
  20     def test_sdd_device_is_large_enough(self, fakedevice, factory):
  21         args = factory(filtered_devices=[], osds_per_device=1,
  22                        block_db_size=None, osd_ids=[])
  23         devices = [
  24             fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
  25         ]
  26         computed_osd = bluestore.SingleType.with_auto_devices(args, devices).computed['osds'][0]
  27         assert computed_osd['data']['percentage'] == 100
  28         assert computed_osd['data']['parts'] == 1
  29         assert computed_osd['data']['human_readable_size'] == '5.00 GB'
  30         assert computed_osd['data']['path'] == '/dev/sda'
  31
  32     def test_device_cannot_have_many_osds_per_device(self, fakedevice, factory):
  33         args = factory(filtered_devices=[], osds_per_device=3,
  34                        block_db_size=None, osd_ids=[])
  35         devices = [
  36             fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
  37         ]
  38         with pytest.raises(RuntimeError) as error:
  39             bluestore.SingleType.with_auto_devices(args, devices)
  40         assert 'Unable to use device 5.66 GB /dev/sda' in str(error.value)
  41
  42     def test_device_is_lvm_member_fails(self, fakedevice, factory):
  43         args = factory(filtered_devices=[], osds_per_device=1,
  44                        block_db_size=None, osd_ids=[])
  45         devices = [
  46             fakedevice(used_by_ceph=False, is_lvm_member=True, rotational=True, sys_api=dict(size=6073740000))
  47         ]
  48         with pytest.raises(RuntimeError) as error:
  49             bluestore.SingleType.with_auto_devices(args, devices)
  50         assert 'Unable to use device, already a member of LVM' in str(error.value)
  51
  52
  53 class TestMixedType(object):
  54
  55     def test_filter_all_data_devs(self, fakedevice, factory, monkeypatch):
  56         # in this scenario the user passed a already used device to be used for
  57         # data and an unused device to be used as db device.
  58         db_dev = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
  59         data_dev = fakedevice(used_by_ceph=True, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
  60         args = factory(filtered_devices=[data_dev], osds_per_device=1,
  61                        block_db_size=None, block_wal_size=None,
  62                        osd_ids=[])
  63         monkeypatch.setattr(lvm, 'VolumeGroup', lambda x, **kw: [])
  64         bluestore.MixedType(args, [], [db_dev], [])
  65
  66
  67 class TestMixedTypeConfiguredSize(object):
  68     # uses a block.db size that has been configured via ceph.conf, instead of
  69     # defaulting to 'as large as possible'
  70
  71     def test_hdd_device_is_large_enough(self, fakedevice, factory, conf_ceph):
  72         # 3GB block.db in ceph.conf
  73         conf_ceph(get_safe=lambda *a: 3147483640)
  74         args = factory(filtered_devices=[], osds_per_device=1,
  75                        block_db_size=None, block_wal_size=None,
  76                        osd_ids=[])
  77         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
  78         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
  79         devices = [ssd, hdd]
  80
  81         osd = bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
  82         assert osd['data']['percentage'] == 100
  83         assert osd['data']['human_readable_size'] == '5.66 GB'
  84         assert osd['data']['path'] == '/dev/sda'
  85         # a new vg will be created
  86         assert osd['block.db']['path'] == 'vg: vg/lv'
  87         assert osd['block.db']['percentage'] == 100
  88
  89     def test_ssd_device_is_not_large_enough(self, fakedevice, factory, conf_ceph):
  90         # 7GB block.db in ceph.conf
  91         conf_ceph(get_safe=lambda *a: 7747483640)
  92         args = factory(filtered_devices=[], osds_per_device=1,
  93                        block_db_size=None, block_wal_size=None,
  94                        osd_ids=[])
  95         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
  96         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
  97         devices = [ssd, hdd]
  98
  99         with pytest.raises(RuntimeError) as error:
 100             bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
 101         expected = 'Not enough space in fast devices (5.66 GB) to create 1 x 7.22 GB block.db LV'
 102         assert expected in str(error.value)
 103
 104     def test_multi_hdd_device_is_not_large_enough(self, fakedevice, factory, conf_ceph):
 105         # 3GB block.db in ceph.conf
 106         conf_ceph(get_safe=lambda *a: 3147483640)
 107         args = factory(filtered_devices=[], osds_per_device=2,
 108                        block_db_size=None, block_wal_size=None,
 109                        osd_ids=[])
 110         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60737400000))
 111         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
 112         devices = [ssd, hdd]
 113
 114         with pytest.raises(RuntimeError) as error:
 115             bluestore.MixedType.with_auto_devices(args, devices)
 116         expected = 'Unable to use device 5.66 GB /dev/sda, LVs would be smaller than 5GB'
 117         assert expected in str(error.value)
 118
 119
 120 class TestMixedTypeLargeAsPossible(object):
 121
 122     def test_hdd_device_is_large_enough(self, fakedevice, factory, conf_ceph):
 123         conf_ceph(get_safe=lambda *a: None)
 124         args = factory(filtered_devices=[], osds_per_device=1,
 125                        block_db_size=None, block_wal_size=None,
 126                        osd_ids=[])
 127         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
 128         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
 129         devices = [ssd, hdd]
 130
 131         osd = bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
 132         assert osd['data']['percentage'] == 100
 133         assert osd['data']['human_readable_size'] == '5.66 GB'
 134         assert osd['data']['path'] == '/dev/sda'
 135         # a new vg will be created
 136         assert osd['block.db']['path'] == 'vg: vg/lv'
 137         # as large as possible
 138         assert osd['block.db']['percentage'] == 100
 139
 140     def test_multi_hdd_device_is_large_enough(self, fakedevice, factory, conf_ceph):
 141         conf_ceph(get_safe=lambda *a: None)
 142         args = factory(filtered_devices=[], osds_per_device=2,
 143                        block_db_size=None, block_wal_size=None,
 144                        osd_ids=[])
 145         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60073740000))
 146         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=60073740000))
 147         devices = [ssd, hdd]
 148
 149         osd = bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
 150         assert osd['data']['percentage'] == 50
 151         assert osd['data']['human_readable_size'] == '27.97 GB'
 152         assert osd['data']['path'] == '/dev/sda'
 153         # a new vg will be created
 154         assert osd['block.db']['path'] == 'vg: vg/lv'
 155         # as large as possible
 156         assert osd['block.db']['percentage'] == 50
 157
 158     def test_multi_hdd_device_is_not_large_enough(self, fakedevice, factory, conf_ceph):
 159         conf_ceph(get_safe=lambda *a: None)
 160         args = factory(filtered_devices=[], osds_per_device=2,
 161                        block_db_size=None, block_wal_size=None,
 162                        osd_ids=[])
 163         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60737400000))
 164         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
 165         devices = [ssd, hdd]
 166
 167         with pytest.raises(RuntimeError) as error:
 168             bluestore.MixedType.with_auto_devices(args, devices)
 169         expected = 'Unable to use device 5.66 GB /dev/sda, LVs would be smaller than 5GB'
 170         assert expected in str(error.value)
 171
 172
 173 class TestMixedTypeWithExplicitDevices(object):
 174
 175     def test_multi_hdd_device_is_large_enough(self, fakedevice, factory, conf_ceph):
 176         conf_ceph(get_safe=lambda *a: None)
 177         args = factory(filtered_devices=[], osds_per_device=2,
 178                        block_db_size=None, block_wal_size=None,
 179                        osd_ids=[])
 180         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60073740000))
 181         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=60073740000))
 182
 183         osd = bluestore.MixedType(args, [hdd], [], [ssd]).computed['osds'][0]
 184         assert osd['data']['percentage'] == 50
 185         assert osd['data']['human_readable_size'] == '27.97 GB'
 186         assert osd['data']['path'] == '/dev/sda'
 187         # a new vg will be created
 188         assert osd['block.wal']['path'] == 'vg: vg/lv'
 189         # as large as possible
 190         assert osd['block.wal']['percentage'] == 50
 191
 192     def test_wal_device_is_not_large_enough(self, fakedevice, factory, conf_ceph):
 193         conf_ceph(get_safe=lambda *a: None)
 194         args = factory(filtered_devices=[], osds_per_device=2,
 195                        block_db_size=None, block_wal_size=None,
 196                        osd_ids=[])
 197         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=1610612736))
 198         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=60073740000))
 199
 200         with pytest.raises(RuntimeError) as error:
 201             bluestore.MixedType(args, [hdd], [], [ssd]).computed['osds'][0]
 202         expected = 'Unable to use device 1.50 GB /dev/sda, LVs would be smaller than 1GB'
 203         assert expected in str(error.value), str(error)