def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
# create the single vg for all block.db lv's first
vg_info = self.computed['vgs'][0]
vg = lvm.create_vg(vg_info['devices'])
# now produce all the block.db lvs needed from that single vg
db_lvs = lvm.create_lvs(vg,
parts=vg_info['parts'],
name_prefix='osd-block-db')
# create the data lvs, and create the OSD with the matching block.db lvs from before
for osd in self.computed['osds']:
vg = lvm.create_vg(osd['data']['path'])
from uuid import uuid4
data_lv = lvm.create_lv('osd-data-%s' % str(uuid4()), vg.name)
db_lv = db_lvs.pop()
# FIXME: no support for dmcrypt, crush class, etc...
Create([
'--bluestore', '--data',
"%s/%s" % (data_lv.vg_name, data_lv.name), '--block.db',
'%s/%s' % (db_lv.vg_name, db_lv.name)
]).main()
def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
osd_vgs = dict([(osd['data']['path'], None)
for osd in self.computed['osds']])
# create the vgs first, mapping them to the device path
for osd in self.computed['osds']:
vg = osd_vgs.get(osd['data']['path'])
if not vg:
vg = lvm.create_vg(osd['data']['path'])
osd_vgs[osd['data']['path']] = {
'vg': vg,
'parts': osd['data']['parts']
}
# create the lvs from the vgs captured in the beginning
for create in osd_vgs.values():
lvs = lvm.create_lvs(create['vg'],
parts=create['parts'],
name_prefix='osd-data')
vg_name = create['vg'].name
for lv in lvs:
# FIXME: no support for dmcrypt, crush class, etc...
Create([
'--bluestore',
'--data',
"%s/%s" % (vg_name, lv.name),
]).main()
def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
# create the single vg for all block.db lv's first
vg_info = self.computed['vgs'][0]
vg = lvm.create_vg(vg_info['devices'])
# now produce all the block.db lvs needed from that single vg
db_lvs = lvm.create_lvs(vg,
parts=vg_info['parts'],
name_prefix='osd-block-db')
# create the data lvs, and create the OSD with the matching block.db lvs from before
for osd in self.computed['osds']:
vg = lvm.create_vg(osd['data']['path'])
data_lv = lvm.create_lv('osd-data-%s' % str(uuid4()), vg.name)
db_lv = db_lvs.pop()
command = [
'--bluestore', '--data',
"%s/%s" % (data_lv.vg_name, data_lv.name), '--block.db',
'%s/%s' % (db_lv.vg_name, db_lv.name)
]
if self.args.dmcrypt:
command.append('--dmcrypt')
if self.args.no_systemd:
command.append('--no-systemd')
if self.args.crush_device_class:
command.extend(
['--crush-device-class', self.args.crush_device_class])
Create(command).main()
def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
# create the single vg for all block.db lv's first
vg_info = self.computed['vgs'][0]
vg = lvm.create_vg(vg_info['devices'])
# now produce all the block.db lvs needed from that single vg
db_lvs = lvm.create_lvs(vg, parts=vg_info['parts'], name_prefix='osd-block-db')
# create the data lvs, and create the OSD with the matching block.db lvs from before
for osd in self.computed['osds']:
vg = lvm.create_vg(osd['data']['path'])
data_lv = lvm.create_lv('osd-data-%s' % str(uuid4()), vg.name)
db_lv = db_lvs.pop()
command = [
'--bluestore',
'--data', "%s/%s" % (data_lv.vg_name, data_lv.name),
'--block.db', '%s/%s' % (db_lv.vg_name, db_lv.name)
]
if self.args.dmcrypt:
command.append('--dmcrypt')
if self.args.no_systemd:
command.append('--no-systemd')
if self.args.crush_device_class:
command.extend(['--crush-device-class', self.args.crush_device_class])
Create(command).main()
def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
osd_vgs = dict([(osd['data']['path'], None) for osd in self.computed['osds']])
# create the vgs first, mapping them to the device path
for osd in self.computed['osds']:
vg = osd_vgs.get(osd['data']['path'])
if not vg:
vg = lvm.create_vg(osd['data']['path'])
osd_vgs[osd['data']['path']] = {'vg': vg, 'parts': osd['data']['parts']}
# create the lvs from the vgs captured in the beginning
for create in osd_vgs.values():
lvs = lvm.create_lvs(create['vg'], parts=create['parts'], name_prefix='osd-data')
vg_name = create['vg'].name
for lv in lvs:
# FIXME: no support for dmcrypt, crush class, etc...
Create([
'--bluestore',
'--data', "%s/%s" % (vg_name, lv.name),
]).main()
def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
osd_vgs = dict([(osd['data']['path'], None) for osd in self.computed['osds']])
# create the vgs first, mapping them to the device path
for osd in self.computed['osds']:
vg = osd_vgs.get(osd['data']['path'])
if not vg:
vg = lvm.create_vg(osd['data']['path'])
osd_vgs[osd['data']['path']] = {'vg': vg, 'parts': osd['data']['parts']}
# create the lvs from the vgs captured in the beginning
for create in osd_vgs.values():
lvs = lvm.create_lvs(create['vg'], parts=create['parts'], name_prefix='osd-data')
vg_name = create['vg'].name
for lv in lvs:
command = ['--bluestore', '--data']
command.append('%s/%s' % (vg_name, lv.name))
if self.args.dmcrypt:
command.append('--dmcrypt')
if self.args.no_systemd:
command.append('--no-systemd')
if self.args.crush_device_class:
command.extend(['--crush-device-class', self.args.crush_device_class])
if self.args.prepare:
Prepare(command).main()
else:
Create(command).main()
def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
# create the single vg for all block.db lv's first
vg_info = self.computed['vgs'][0]
vg = lvm.create_vg(vg_info['devices'])
# now produce all the block.db lvs needed from that single vg
db_lvs = lvm.create_lvs(vg, parts=vg_info['parts'], name_prefix='osd-block-db')
# create the data lvs, and create the OSD with the matching block.db lvs from before
for osd in self.computed['osds']:
vg = lvm.create_vg(osd['data']['path'])
from uuid import uuid4
data_lv = lvm.create_lv('osd-data-%s' % str(uuid4()), vg.name)
db_lv = db_lvs.pop()
# FIXME: no support for dmcrypt, crush class, etc...
Create([
'--bluestore',
'--data', "%s/%s" % (data_lv.vg_name, data_lv.name),
'--block.db', '%s/%s' % (db_lv.vg_name, db_lv.name)
]).main()
def execute(self):
"""
Create vgs/lvs from the incoming set of devices, assign their roles
(block, block.db, block.wal, etc..) and offload the OSD creation to
``lvm create``
"""
osd_vgs = dict([(osd['data']['path'], None) for osd in self.computed['osds']])
# create the vgs first, mapping them to the device path
for osd in self.computed['osds']:
vg = osd_vgs.get(osd['data']['path'])
if not vg:
vg = lvm.create_vg(osd['data']['path'])
osd_vgs[osd['data']['path']] = {'vg': vg, 'parts': osd['data']['parts']}
# create the lvs from the vgs captured in the beginning
for create in osd_vgs.values():
lvs = lvm.create_lvs(create['vg'], parts=create['parts'], name_prefix='osd-data')
vg_name = create['vg'].name
for lv in lvs:
command = ['--bluestore', '--data']
command.append('%s/%s' % (vg_name, lv.name))
if self.args.dmcrypt:
command.append('--dmcrypt')
if self.args.no_systemd:
command.append('--no-systemd')
if self.args.crush_device_class:
command.extend(['--crush-device-class', self.args.crush_device_class])
if self.args.prepare:
Prepare(command).main()
else:
Create(command).main()
def test_fallback_to_one_part(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='999'
)
lvs = api.create_lvs(vg)
assert len(lvs) == 1
def test_null_tags_are_set_by_default(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='999'
)
kwargs = api.create_lvs(vg, parts=4)[0][1]
assert list(kwargs['tags'].values()) == ['null', 'null', 'null', 'null']
def test_only_uses_free_size(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='1000'
)
lvs = api.create_lvs(vg, parts=4)
assert lvs[0][1]['extents'] == 250
def test_creates_correct_lv_number_from_parts(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='999'
)
lvs = api.create_lvs(vg, parts=4)
assert len(lvs) == 4
def test_creates_correct_lv_number_from_parts(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='999'
)
lvs = api.create_lvs(vg, parts=4)
assert len(lvs) == 4
def test_fallback_to_one_part(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='999'
)
lvs = api.create_lvs(vg)
assert len(lvs) == 1
def test_null_tags_are_set_by_default(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='999'
)
kwargs = api.create_lvs(vg, parts=4)[0][1]
assert list(kwargs['tags'].values()) == ['null', 'null', 'null', 'null']
def test_only_uses_free_size(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(
vg_name='ceph', vg_free='1024g',
vg_size='99999999g', vg_free_count='1000'
)
lvs = api.create_lvs(vg, parts=4)
assert lvs[0][1]['extents'] == 250
def test_suffixes_the_size_arg(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw:
(a, kw))
lvs = api.create_lvs(self.vg, parts=4)
assert lvs[0][1]['extents'] == 249
def test_creates_correct_lv_number_from_parts(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw:
(a, kw))
lvs = api.create_lvs(self.vg, parts=4)
assert len(lvs) == 4
def test_suffixes_the_size_arg(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw:
(a, kw))
vg = api.VolumeGroup(vg_name='ceph', vg_free='1024g')
lvs = api.create_lvs(vg, parts=4)
assert lvs[0][1]['size'] == '256g'
def test_null_tags_are_set_by_default(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw:
(a, kw))
kwargs = api.create_lvs(self.vg, parts=4)[0][1]
assert list(
kwargs['tags'].values()) == ['null', 'null', 'null', 'null']
def test_fallback_to_one_part(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw:
(a, kw))
lvs = api.create_lvs(self.vg)
assert len(lvs) == 1
def test_suffixes_the_size_arg(self, monkeypatch):
monkeypatch.setattr('ceph_volume.api.lvm.create_lv', lambda *a, **kw: (a, kw))
vg = api.VolumeGroup(vg_name='ceph', vg_free='1024g')
lvs = api.create_lvs(vg, parts=4)
assert lvs[0][1]['size'] == '256g'
