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         monkeypatch.setattr(lvm, 'VolumeGroups', lambda: [])
  65         bluestore.MixedType(args, [], [db_dev], [])
  66
  67
  68 class TestMixedTypeConfiguredSize(object):
  69     # uses a block.db size that has been configured via ceph.conf, instead of
  70     # defaulting to 'as large as possible'
  71
  72     def test_hdd_device_is_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
  73         # 3GB block.db in ceph.conf
  74         conf_ceph(get_safe=lambda *a: 3147483640)
  75         args = factory(filtered_devices=[], osds_per_device=1,
  76                        block_db_size=None, block_wal_size=None,
  77                        osd_ids=[])
  78         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
  79         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
  80         devices = [ssd, hdd]
  81
  82         osd = bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
  83         assert osd['data']['percentage'] == 100
  84         assert osd['data']['human_readable_size'] == '5.66 GB'
  85         assert osd['data']['path'] == '/dev/sda'
  86         # a new vg will be created
  87         assert osd['block.db']['path'] == 'vg: vg/lv'
  88         assert osd['block.db']['percentage'] == 100
  89
  90     def test_ssd_device_is_not_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
  91         # 7GB block.db in ceph.conf
  92         conf_ceph(get_safe=lambda *a: 7747483640)
  93         args = factory(filtered_devices=[], osds_per_device=1,
  94                        block_db_size=None, block_wal_size=None,
  95                        osd_ids=[])
  96         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
  97         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
  98         devices = [ssd, hdd]
  99
 100         with pytest.raises(RuntimeError) as error:
 101             bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
 102         expected = 'Not enough space in fast devices (5.66 GB) to create 1 x 7.22 GB block.db LV'
 103         assert expected in str(error.value)
 104
 105     def test_multi_hdd_device_is_not_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
 106         # 3GB block.db in ceph.conf
 107         conf_ceph(get_safe=lambda *a: 3147483640)
 108         args = factory(filtered_devices=[], osds_per_device=2,
 109                        block_db_size=None, block_wal_size=None,
 110                        osd_ids=[])
 111         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60737400000))
 112         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
 113         devices = [ssd, hdd]
 114
 115         with pytest.raises(RuntimeError) as error:
 116             bluestore.MixedType.with_auto_devices(args, devices)
 117         expected = 'Unable to use device 5.66 GB /dev/sda, LVs would be smaller than 5GB'
 118         assert expected in str(error.value)
 119
 120
 121 class TestMixedTypeLargeAsPossible(object):
 122
 123     def test_hdd_device_is_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
 124         conf_ceph(get_safe=lambda *a: None)
 125         args = factory(filtered_devices=[], osds_per_device=1,
 126                        block_db_size=None, block_wal_size=None,
 127                        osd_ids=[])
 128         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=6073740000))
 129         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
 130         devices = [ssd, hdd]
 131
 132         osd = bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
 133         assert osd['data']['percentage'] == 100
 134         assert osd['data']['human_readable_size'] == '5.66 GB'
 135         assert osd['data']['path'] == '/dev/sda'
 136         # a new vg will be created
 137         assert osd['block.db']['path'] == 'vg: vg/lv'
 138         # as large as possible
 139         assert osd['block.db']['percentage'] == 100
 140
 141     def test_multi_hdd_device_is_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
 142         conf_ceph(get_safe=lambda *a: None)
 143         args = factory(filtered_devices=[], osds_per_device=2,
 144                        block_db_size=None, block_wal_size=None,
 145                        osd_ids=[])
 146         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60073740000))
 147         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=60073740000))
 148         devices = [ssd, hdd]
 149
 150         osd = bluestore.MixedType.with_auto_devices(args, devices).computed['osds'][0]
 151         assert osd['data']['percentage'] == 50
 152         assert osd['data']['human_readable_size'] == '27.97 GB'
 153         assert osd['data']['path'] == '/dev/sda'
 154         # a new vg will be created
 155         assert osd['block.db']['path'] == 'vg: vg/lv'
 156         # as large as possible
 157         assert osd['block.db']['percentage'] == 50
 158
 159     def test_multi_hdd_device_is_not_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
 160         conf_ceph(get_safe=lambda *a: None)
 161         args = factory(filtered_devices=[], osds_per_device=2,
 162                        block_db_size=None, block_wal_size=None,
 163                        osd_ids=[])
 164         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60737400000))
 165         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=6073740000))
 166         devices = [ssd, hdd]
 167
 168         with pytest.raises(RuntimeError) as error:
 169             bluestore.MixedType.with_auto_devices(args, devices)
 170         expected = 'Unable to use device 5.66 GB /dev/sda, LVs would be smaller than 5GB'
 171         assert expected in str(error.value)
 172
 173
 174 class TestMixedTypeWithExplicitDevices(object):
 175
 176     def test_multi_hdd_device_is_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
 177         conf_ceph(get_safe=lambda *a: None)
 178         args = factory(filtered_devices=[], osds_per_device=2,
 179                        block_db_size=None, block_wal_size=None,
 180                        osd_ids=[])
 181         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=60073740000))
 182         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=60073740000))
 183
 184         osd = bluestore.MixedType(args, [hdd], [], [ssd]).computed['osds'][0]
 185         assert osd['data']['percentage'] == 50
 186         assert osd['data']['human_readable_size'] == '27.97 GB'
 187         assert osd['data']['path'] == '/dev/sda'
 188         # a new vg will be created
 189         assert osd['block.wal']['path'] == 'vg: vg/lv'
 190         # as large as possible
 191         assert osd['block.wal']['percentage'] == 50
 192
 193     def test_wal_device_is_not_large_enough(self, stub_vgs, fakedevice, factory, conf_ceph):
 194         conf_ceph(get_safe=lambda *a: None)
 195         args = factory(filtered_devices=[], osds_per_device=2,
 196                        block_db_size=None, block_wal_size=None,
 197                        osd_ids=[])
 198         ssd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=False, sys_api=dict(size=1610612736))
 199         hdd = fakedevice(used_by_ceph=False, is_lvm_member=False, rotational=True, sys_api=dict(size=60073740000))
 200
 201         with pytest.raises(RuntimeError) as error:
 202             bluestore.MixedType(args, [hdd], [], [ssd]).computed['osds'][0]
 203         expected = 'Unable to use device 1.50 GB /dev/sda, LVs would be smaller than 1GB'
 204         assert expected in str(error.value), str(error)