ceph/src/python-common/ceph/tests/test_drive_group.py

   1 # flake8: noqa
   2 import pytest
   3 import yaml
   4
   5 from ceph.deployment import drive_selection, translate
   6 from ceph.deployment.hostspec import HostSpec
   7 from ceph.deployment.inventory import Device
   8 from ceph.deployment.service_spec import PlacementSpec, ServiceSpecValidationError
   9 from ceph.tests.utils import _mk_inventory, _mk_device
  10 from ceph.deployment.drive_group import DriveGroupSpec, DeviceSelection, \
  11     DriveGroupValidationError
  12
  13 @pytest.mark.parametrize("test_input",
  14 [
  15     (
  16         [  # new style json
  17             {
  18                 'service_type': 'osd',
  19                 'service_id': 'testing_drivegroup',
  20                 'placement': {'host_pattern': 'hostname'},
  21                 'data_devices': {'paths': ['/dev/sda']}
  22             }
  23         ]
  24     ),
  25 ])
  26 def test_DriveGroup(test_input):
  27     dg = [DriveGroupSpec.from_json(inp) for inp in test_input][0]
  28     assert dg.placement.filter_matching_hostspecs([HostSpec('hostname')]) == ['hostname']
  29     assert dg.service_id == 'testing_drivegroup'
  30     assert all([isinstance(x, Device) for x in dg.data_devices.paths])
  31     assert dg.data_devices.paths[0].path == '/dev/sda'
  32
  33 @pytest.mark.parametrize("test_input",
  34 [
  35     (
  36         {}
  37     ),
  38     (
  39         yaml.safe_load("""
  40 service_type: osd
  41 service_id: mydg
  42 placement:
  43   host_pattern: '*'
  44 data_devices:
  45   limit: 1
  46 """),
  47
  48         yaml.safe_load("""
  49 service_type: osd
  50 service_id: mydg
  51 placement:
  52   host_pattern: '*'
  53 data_devices:
  54   all: True
  55 filter_logic: XOR
  56 """)
  57     )
  58 ])
  59 def test_DriveGroup_fail(test_input):
  60     with pytest.raises(ServiceSpecValidationError):
  61         DriveGroupSpec.from_json(test_input)
  62
  63
  64
  65 def test_drivegroup_pattern():
  66     dg = DriveGroupSpec(
  67         PlacementSpec(host_pattern='node[1-3]'),
  68         service_id='foobar',
  69         data_devices=DeviceSelection(all=True))
  70     assert dg.placement.filter_matching_hostspecs([HostSpec('node{}'.format(i)) for i in range(10)]) == ['node1', 'node2', 'node3']
  71
  72
  73 def test_drive_selection():
  74     devs = DeviceSelection(paths=['/dev/sda'])
  75     spec = DriveGroupSpec(
  76         PlacementSpec('node_name'),
  77         service_id='foobar',
  78         data_devices=devs)
  79     assert all([isinstance(x, Device) for x in spec.data_devices.paths])
  80     assert spec.data_devices.paths[0].path == '/dev/sda'
  81
  82     with pytest.raises(DriveGroupValidationError, match='exclusive'):
  83         DeviceSelection(paths=['/dev/sda'], rotational=False)
  84
  85
  86 def test_ceph_volume_command_0():
  87     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
  88                           service_id='foobar',
  89                           data_devices=DeviceSelection(all=True)
  90                           )
  91     spec.validate()
  92     inventory = _mk_inventory(_mk_device()*2)
  93     sel = drive_selection.DriveSelection(spec, inventory)
  94     cmd = translate.to_ceph_volume(sel, []).run()
  95     assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --yes --no-systemd'
  96
  97
  98 def test_ceph_volume_command_1():
  99     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 100                           service_id='foobar',
 101                           data_devices=DeviceSelection(rotational=True),
 102                           db_devices=DeviceSelection(rotational=False)
 103                           )
 104     spec.validate()
 105     inventory = _mk_inventory(_mk_device(rotational=True)*2 + _mk_device(rotational=False)*2)
 106     sel = drive_selection.DriveSelection(spec, inventory)
 107     cmd = translate.to_ceph_volume(sel, []).run()
 108     assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
 109                    '--db-devices /dev/sdc /dev/sdd --yes --no-systemd')
 110
 111
 112 def test_ceph_volume_command_2():
 113     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 114                           service_id='foobar',
 115                           data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
 116                           db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
 117                           wal_devices=DeviceSelection(size='10G')
 118                           )
 119     spec.validate()
 120     inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
 121                               _mk_device(rotational=False, size="300.00 GB")*2 +
 122                               _mk_device(size="10.0 GB", rotational=False)*2
 123                               )
 124     sel = drive_selection.DriveSelection(spec, inventory)
 125     cmd = translate.to_ceph_volume(sel, []).run()
 126     assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
 127                    '--db-devices /dev/sdc /dev/sdd --wal-devices /dev/sde /dev/sdf '
 128                    '--yes --no-systemd')
 129
 130
 131 def test_ceph_volume_command_3():
 132     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 133                           service_id='foobar',
 134                           data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
 135                           db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
 136                           wal_devices=DeviceSelection(size='10G'),
 137                           encrypted=True
 138                           )
 139     spec.validate()
 140     inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
 141                               _mk_device(rotational=False, size="300.00 GB")*2 +
 142                               _mk_device(size="10.0 GB", rotational=False)*2
 143                               )
 144     sel = drive_selection.DriveSelection(spec, inventory)
 145     cmd = translate.to_ceph_volume(sel, []).run()
 146     assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
 147                    '--db-devices /dev/sdc /dev/sdd '
 148                    '--wal-devices /dev/sde /dev/sdf --dmcrypt '
 149                    '--yes --no-systemd')
 150
 151
 152 def test_ceph_volume_command_4():
 153     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 154                           service_id='foobar',
 155                           data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
 156                           db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
 157                           wal_devices=DeviceSelection(size='10G'),
 158                           block_db_size='500M',
 159                           block_wal_size='500M',
 160                           osds_per_device=3,
 161                           encrypted=True
 162                           )
 163     spec.validate()
 164     inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
 165                               _mk_device(rotational=False, size="300.00 GB")*2 +
 166                               _mk_device(size="10.0 GB", rotational=False)*2
 167                               )
 168     sel = drive_selection.DriveSelection(spec, inventory)
 169     cmd = translate.to_ceph_volume(sel, []).run()
 170     assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
 171                    '--db-devices /dev/sdc /dev/sdd --wal-devices /dev/sde /dev/sdf '
 172                    '--block-wal-size 500M --block-db-size 500M --dmcrypt '
 173                    '--osds-per-device 3 --yes --no-systemd')
 174
 175
 176 def test_ceph_volume_command_5():
 177     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 178                           service_id='foobar',
 179                           data_devices=DeviceSelection(rotational=True),
 180                           objectstore='filestore'
 181                           )
 182     with pytest.raises(DriveGroupValidationError):
 183         spec.validate()
 184     inventory = _mk_inventory(_mk_device(rotational=True)*2)
 185     sel = drive_selection.DriveSelection(spec, inventory)
 186     cmd = translate.to_ceph_volume(sel, []).run()
 187     assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --filestore --yes --no-systemd'
 188
 189
 190 def test_ceph_volume_command_6():
 191     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 192                           service_id='foobar',
 193                           data_devices=DeviceSelection(rotational=False),
 194                           journal_devices=DeviceSelection(rotational=True),
 195                           journal_size='500M',
 196                           objectstore='filestore'
 197                           )
 198     with pytest.raises(DriveGroupValidationError):
 199         spec.validate()
 200     inventory = _mk_inventory(_mk_device(rotational=True)*2 + _mk_device(rotational=False)*2)
 201     sel = drive_selection.DriveSelection(spec, inventory)
 202     cmd = translate.to_ceph_volume(sel, []).run()
 203     assert cmd == ('lvm batch --no-auto /dev/sdc /dev/sdd '
 204                    '--journal-size 500M --journal-devices /dev/sda /dev/sdb '
 205                    '--filestore --yes --no-systemd')
 206
 207
 208 def test_ceph_volume_command_7():
 209     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 210                           service_id='foobar',
 211                           data_devices=DeviceSelection(all=True),
 212                           osd_id_claims={'host1': ['0', '1']}
 213                           )
 214     spec.validate()
 215     inventory = _mk_inventory(_mk_device(rotational=True)*2)
 216     sel = drive_selection.DriveSelection(spec, inventory)
 217     cmd = translate.to_ceph_volume(sel, ['0', '1']).run()
 218     assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --osd-ids 0 1 --yes --no-systemd'
 219
 220
 221 def test_ceph_volume_command_8():
 222     spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
 223                           service_id='foobar',
 224                           data_devices=DeviceSelection(rotational=True, model='INTEL SSDS'),
 225                           db_devices=DeviceSelection(model='INTEL SSDP'),
 226                           filter_logic='OR',
 227                           osd_id_claims={}
 228                           )
 229     spec.validate()
 230     inventory = _mk_inventory(_mk_device(rotational=True,  size='1.82 TB',  model='ST2000DM001-1ER1') +  # data
 231                               _mk_device(rotational=False, size="223.0 GB", model='INTEL SSDSC2KG24') +  # data
 232                               _mk_device(rotational=False, size="349.0 GB", model='INTEL SSDPED1K375GA')  # wal/db
 233                               )
 234     sel = drive_selection.DriveSelection(spec, inventory)
 235     cmd = translate.to_ceph_volume(sel, []).run()
 236     assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --db-devices /dev/sdc --yes --no-systemd'