[ceph.git] / ceph / src / python-common / ceph / tests / test_drive_group.py

# flake8: noqa
import pytest
import yaml

from ceph.deployment import drive_selection, translate
from ceph.deployment.hostspec import HostSpec
from ceph.deployment.inventory import Device
from ceph.deployment.service_spec import PlacementSpec, ServiceSpecValidationError
from ceph.tests.utils import _mk_inventory, _mk_device
from ceph.deployment.drive_group import DriveGroupSpec, DeviceSelection, \
    DriveGroupValidationError

@pytest.mark.parametrize("test_input",
[
    (
        [  # new style json
            {
                'service_type': 'osd',
                'service_id': 'testing_drivegroup',
                'placement': {'host_pattern': 'hostname'},
                'data_devices': {'paths': ['/dev/sda']}
            }
        ]
    ),
])
def test_DriveGroup(test_input):
    dg = [DriveGroupSpec.from_json(inp) for inp in test_input][0]
    assert dg.placement.filter_matching_hostspecs([HostSpec('hostname')]) == ['hostname']
    assert dg.service_id == 'testing_drivegroup'
    assert all([isinstance(x, Device) for x in dg.data_devices.paths])
    assert dg.data_devices.paths[0].path == '/dev/sda'

@pytest.mark.parametrize("test_input",
[
    (
        {}
    ),
    (
        yaml.safe_load("""
service_type: osd
service_id: mydg
placement:
  host_pattern: '*'
data_devices:
  limit: 1
"""),

        yaml.safe_load("""
service_type: osd
service_id: mydg
placement:
  host_pattern: '*'
data_devices:
  all: True
filter_logic: XOR
""")
    )
])
def test_DriveGroup_fail(test_input):
    with pytest.raises(ServiceSpecValidationError):
        DriveGroupSpec.from_json(test_input)


def test_drivegroup_pattern():
    dg = DriveGroupSpec(PlacementSpec(host_pattern='node[1-3]'), data_devices=DeviceSelection(all=True))
    assert dg.placement.filter_matching_hostspecs([HostSpec('node{}'.format(i)) for i in range(10)]) == ['node1', 'node2', 'node3']


def test_drive_selection():
    devs = DeviceSelection(paths=['/dev/sda'])
    spec = DriveGroupSpec(PlacementSpec('node_name'), data_devices=devs)
    assert all([isinstance(x, Device) for x in spec.data_devices.paths])
    assert spec.data_devices.paths[0].path == '/dev/sda'

    with pytest.raises(DriveGroupValidationError, match='exclusive'):
        DeviceSelection(paths=['/dev/sda'], rotational=False)


def test_ceph_volume_command_0():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(all=True)
                          )
    inventory = _mk_inventory(_mk_device()*2)
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --yes --no-systemd'


def test_ceph_volume_command_1():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(rotational=True),
                          db_devices=DeviceSelection(rotational=False)
                          )
    inventory = _mk_inventory(_mk_device(rotational=True)*2 + _mk_device(rotational=False)*2)
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
                   '--db-devices /dev/sdc /dev/sdd --yes --no-systemd')


def test_ceph_volume_command_2():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
                          db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
                          wal_devices=DeviceSelection(size='10G')
                          )
    inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
                              _mk_device(rotational=False, size="300.00 GB")*2 +
                              _mk_device(size="10.0 GB", rotational=False)*2
                              )
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
                   '--db-devices /dev/sdc /dev/sdd --wal-devices /dev/sde /dev/sdf '
                   '--yes --no-systemd')


def test_ceph_volume_command_3():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
                          db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
                          wal_devices=DeviceSelection(size='10G'),
                          encrypted=True
                          )
    inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
                              _mk_device(rotational=False, size="300.00 GB")*2 +
                              _mk_device(size="10.0 GB", rotational=False)*2
                              )
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
                   '--db-devices /dev/sdc /dev/sdd '
                   '--wal-devices /dev/sde /dev/sdf --dmcrypt '
                   '--yes --no-systemd')


def test_ceph_volume_command_4():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
                          db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
                          wal_devices=DeviceSelection(size='10G'),
                          block_db_size='500M',
                          block_wal_size='500M',
                          osds_per_device=3,
                          encrypted=True
                          )
    inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
                              _mk_device(rotational=False, size="300.00 GB")*2 +
                              _mk_device(size="10.0 GB", rotational=False)*2
                              )
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
                   '--db-devices /dev/sdc /dev/sdd --wal-devices /dev/sde /dev/sdf '
                   '--block-wal-size 500M --block-db-size 500M --dmcrypt '
                   '--osds-per-device 3 --yes --no-systemd')


def test_ceph_volume_command_5():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(rotational=True),
                          objectstore='filestore'
                          )
    inventory = _mk_inventory(_mk_device(rotational=True)*2)
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --filestore --yes --no-systemd'


def test_ceph_volume_command_6():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(rotational=False),
                          journal_devices=DeviceSelection(rotational=True),
                          journal_size='500M',
                          objectstore='filestore'
                          )
    inventory = _mk_inventory(_mk_device(rotational=True)*2 + _mk_device(rotational=False)*2)
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == ('lvm batch --no-auto /dev/sdc /dev/sdd '
                   '--journal-size 500M --journal-devices /dev/sda /dev/sdb '
                   '--filestore --yes --no-systemd')


def test_ceph_volume_command_7():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(all=True),
                          osd_id_claims={'host1': ['0', '1']}
                          )
    inventory = _mk_inventory(_mk_device(rotational=True)*2)
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, ['0', '1']).run()
    assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --osd-ids 0 1 --yes --no-systemd'


def test_ceph_volume_command_8():
    spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
                          data_devices=DeviceSelection(rotational=True, model='INTEL SSDS'),
                          db_devices=DeviceSelection(model='INTEL SSDP'),
                          filter_logic='OR',
                          osd_id_claims={}
                          )
    inventory = _mk_inventory(_mk_device(rotational=True,  size='1.82 TB',  model='ST2000DM001-1ER1') +  # data
                              _mk_device(rotational=False, size="223.0 GB", model='INTEL SSDSC2KG24') +  # data
                              _mk_device(rotational=False, size="349.0 GB", model='INTEL SSDPED1K375GA')  # wal/db
                              )
    sel = drive_selection.DriveSelection(spec, inventory)
    cmd = translate.to_ceph_volume(sel, []).run()
    assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --db-devices /dev/sdc --yes --no-systemd'
Commit	Line	Data
9f95a23c TL	1	# flake8: noqa
9f95a23c TL	2	import pytest
1911f103	3	import yaml
9f95a23c TL	4
9f95a23c TL	5	from ceph.deployment import drive_selection, translate
f6b5b4d7	6	from ceph.deployment.hostspec import HostSpec
9f95a23c TL	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]
f6b5b4d7	28	assert dg.placement.filter_matching_hostspecs([HostSpec('hostname')]) == ['hostname']
9f95a23c TL	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
1911f103 TL	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
f6b5b4d7 TL	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
1911f103 TL	56	""")
	57	)
	58	])
	59	def test_DriveGroup_fail(test_input):
9f95a23c	60	with pytest.raises(ServiceSpecValidationError):
1911f103 TL	61	DriveGroupSpec.from_json(test_input)
1911f103 TL	62
9f95a23c TL	63
	64
	65	def test_drivegroup_pattern():
	66	dg = DriveGroupSpec(PlacementSpec(host_pattern='node[1-3]'), data_devices=DeviceSelection(all=True))
f6b5b4d7	67	assert dg.placement.filter_matching_hostspecs([HostSpec('node{}'.format(i)) for i in range(10)]) == ['node1', 'node2', 'node3']
9f95a23c TL	68
	69
	70	def test_drive_selection():
	71	devs = DeviceSelection(paths=['/dev/sda'])
	72	spec = DriveGroupSpec(PlacementSpec('node_name'), data_devices=devs)
	73	assert all([isinstance(x, Device) for x in spec.data_devices.paths])
	74	assert spec.data_devices.paths[0].path == '/dev/sda'
	75
	76	with pytest.raises(DriveGroupValidationError, match='exclusive'):
	77	DeviceSelection(paths=['/dev/sda'], rotational=False)
	78
	79
	80	def test_ceph_volume_command_0():
	81	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	82	data_devices=DeviceSelection(all=True)
	83	)
	84	inventory = _mk_inventory(_mk_device()*2)
	85	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	86	cmd = translate.to_ceph_volume(sel, []).run()
9f95a23c TL	87	assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --yes --no-systemd'
	88
	89
	90	def test_ceph_volume_command_1():
	91	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	92	data_devices=DeviceSelection(rotational=True),
	93	db_devices=DeviceSelection(rotational=False)
	94	)
	95	inventory = _mk_inventory(_mk_device(rotational=True)2 + _mk_device(rotational=False)2)
	96	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	97	cmd = translate.to_ceph_volume(sel, []).run()
9f95a23c TL	98	assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
	99	'--db-devices /dev/sdc /dev/sdd --yes --no-systemd')
	100
	101
	102	def test_ceph_volume_command_2():
	103	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	104	data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
	105	db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
	106	wal_devices=DeviceSelection(size='10G')
	107	)
	108	inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
	109	_mk_device(rotational=False, size="300.00 GB")*2 +
	110	_mk_device(size="10.0 GB", rotational=False)*2
	111	)
	112	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	113	cmd = translate.to_ceph_volume(sel, []).run()
9f95a23c TL	114	assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
	115	'--db-devices /dev/sdc /dev/sdd --wal-devices /dev/sde /dev/sdf '
	116	'--yes --no-systemd')
	117
	118
	119	def test_ceph_volume_command_3():
	120	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	121	data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
	122	db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
	123	wal_devices=DeviceSelection(size='10G'),
	124	encrypted=True
	125	)
	126	inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
	127	_mk_device(rotational=False, size="300.00 GB")*2 +
	128	_mk_device(size="10.0 GB", rotational=False)*2
	129	)
	130	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	131	cmd = translate.to_ceph_volume(sel, []).run()
9f95a23c TL	132	assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
	133	'--db-devices /dev/sdc /dev/sdd '
	134	'--wal-devices /dev/sde /dev/sdf --dmcrypt '
	135	'--yes --no-systemd')
	136
	137
	138	def test_ceph_volume_command_4():
	139	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	140	data_devices=DeviceSelection(size='200GB:350GB', rotational=True),
	141	db_devices=DeviceSelection(size='200GB:350GB', rotational=False),
	142	wal_devices=DeviceSelection(size='10G'),
	143	block_db_size='500M',
	144	block_wal_size='500M',
	145	osds_per_device=3,
	146	encrypted=True
	147	)
	148	inventory = _mk_inventory(_mk_device(rotational=True, size="300.00 GB")*2 +
	149	_mk_device(rotational=False, size="300.00 GB")*2 +
	150	_mk_device(size="10.0 GB", rotational=False)*2
	151	)
	152	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	153	cmd = translate.to_ceph_volume(sel, []).run()
9f95a23c TL	154	assert cmd == ('lvm batch --no-auto /dev/sda /dev/sdb '
	155	'--db-devices /dev/sdc /dev/sdd --wal-devices /dev/sde /dev/sdf '
	156	'--block-wal-size 500M --block-db-size 500M --dmcrypt '
	157	'--osds-per-device 3 --yes --no-systemd')
	158
	159
	160	def test_ceph_volume_command_5():
	161	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	162	data_devices=DeviceSelection(rotational=True),
	163	objectstore='filestore'
	164	)
	165	inventory = _mk_inventory(_mk_device(rotational=True)*2)
	166	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	167	cmd = translate.to_ceph_volume(sel, []).run()
9f95a23c TL	168	assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --filestore --yes --no-systemd'
	169
	170
	171	def test_ceph_volume_command_6():
	172	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	173	data_devices=DeviceSelection(rotational=False),
	174	journal_devices=DeviceSelection(rotational=True),
	175	journal_size='500M',
	176	objectstore='filestore'
	177	)
	178	inventory = _mk_inventory(_mk_device(rotational=True)2 + _mk_device(rotational=False)2)
	179	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	180	cmd = translate.to_ceph_volume(sel, []).run()
9f95a23c TL	181	assert cmd == ('lvm batch --no-auto /dev/sdc /dev/sdd '
	182	'--journal-size 500M --journal-devices /dev/sda /dev/sdb '
	183	'--filestore --yes --no-systemd')
1911f103 TL	184
	185
	186	def test_ceph_volume_command_7():
	187	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	188	data_devices=DeviceSelection(all=True),
	189	osd_id_claims={'host1': ['0', '1']}
	190	)
	191	inventory = _mk_inventory(_mk_device(rotational=True)*2)
	192	sel = drive_selection.DriveSelection(spec, inventory)
f6b5b4d7	193	cmd = translate.to_ceph_volume(sel, ['0', '1']).run()
1911f103	194	assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --osd-ids 0 1 --yes --no-systemd'
f6b5b4d7 TL	195
	196
	197	def test_ceph_volume_command_8():
	198	spec = DriveGroupSpec(placement=PlacementSpec(host_pattern='*'),
	199	data_devices=DeviceSelection(rotational=True, model='INTEL SSDS'),
	200	db_devices=DeviceSelection(model='INTEL SSDP'),
	201	filter_logic='OR',
	202	osd_id_claims={}
	203	)
	204	inventory = _mk_inventory(_mk_device(rotational=True, size='1.82 TB', model='ST2000DM001-1ER1') + # data
	205	_mk_device(rotational=False, size="223.0 GB", model='INTEL SSDSC2KG24') + # data
	206	_mk_device(rotational=False, size="349.0 GB", model='INTEL SSDPED1K375GA') # wal/db
	207	)
	208	sel = drive_selection.DriveSelection(spec, inventory)
	209	cmd = translate.to_ceph_volume(sel, []).run()
	210	assert cmd == 'lvm batch --no-auto /dev/sda /dev/sdb --db-devices /dev/sdc --yes --no-systemd'