def _validate_db_devs(self):
# do not allow non-common VG to continue
validators.has_common_vg(self.db_or_journal_devs)
# find the common VG to calculate how much is available
self.common_vg = self.get_common_vg(self.db_or_journal_devs)
# find how many block.db LVs are possible from the common VG
if self.common_vg:
common_vg_size = disk.Size(gb=self.common_vg.free)
else:
common_vg_size = disk.Size(gb=0)
# non-VG SSDs
vg_members = set([d for d in self.db_or_journal_devs if d.is_lvm_member])
self.blank_db_devs = set(self.db_or_journal_devs).difference(vg_members)
self.total_blank_db_dev_size = disk.Size(b=0)
for blank_db_dev in self.blank_db_devs:
self.total_blank_db_dev_size += disk.Size(b=blank_db_dev.lvm_size.b)
self.total_available_db_space = self.total_blank_db_dev_size + common_vg_size
# If not configured, we default to 0, which is really "use as much as
# possible" captured by the `else` condition
if self.block_db_size.gb > 0:
try:
self.vg_extents = lvm.sizing(
self.total_available_db_space.b, size=self.block_db_size.b * self.osds_per_device
)
except SizeAllocationError:
msg = "Not enough space in fast devices (%s) to create %s x %s block.db LV"
raise RuntimeError(
msg % (self.total_available_db_space, self.osds_per_device, self.block_db_size)
)
else:
self.vg_extents = lvm.sizing(
self.total_available_db_space.b, parts=self.dbs_needed
)
# validate that number of block.db LVs possible are enough for number of
# OSDs proposed
if self.total_available_db_space.b == 0:
msg = "No space left in fast devices to create block.db LVs"
raise RuntimeError(msg)
# bluestore_block_db_size was unset, so we must set this to whatever
# size we get by dividing the total available space for block.db LVs
# into the number of block.db LVs needed (i.e. "as large as possible")
if self.block_db_size.b == 0:
self.block_db_size = self.total_available_db_space / self.dbs_needed
self.use_large_block_db = True
total_dbs_possible = self.total_available_db_space / self.block_db_size
if self.dbs_needed > total_dbs_possible:
msg = "Not enough space (%s) to create %s x %s block.db LVs" % (
self.total_available_db_space, self.dbs_needed, self.block_db_size,
)
raise RuntimeError(msg)
def compute(self):
"""
Go through the rules needed to properly size the lvs, return
a dictionary with the result
"""
osds = self.computed['osds']
vgs = self.computed['vgs']
for device in self.hdds:
vgs.append({'devices': [device['path']], 'parts': 1})
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device['path']
osd['data']['size'] = device['size']
osd['data']['parts'] = 1
osd['data']['percentage'] = 100
osd['data']['human_readable_size'] = str(disk.Size(b=device['size']))
osds.append(osd)
for device in self.ssds:
# TODO: creates 2 OSDs per device, make this configurable (env var?)
extents = lvm.sizing(device['size'], parts=2)
vgs.append({'devices': [device['path']], 'parts': 2})
for ssd in range(2):
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device['path']
osd['data']['size'] = extents['sizes']
osd['data']['parts'] = extents['parts']
osd['data']['percentage'] = 50
osd['data']['human_readable_size'] = str(disk.Size(b=extents['sizes']))
osds.append(osd)
def report_pretty(self):
vg_extents = lvm.sizing(self.total_ssd_size.b, parts=self.db_lvs)
db_size = str(disk.Size(b=(vg_extents['sizes'])))
string = ""
string += templates.total_osds.format(total_osds=len(self.hdds))
string += templates.ssd_volume_group.format(
target='block.db',
total_lv_size=str(self.total_ssd_size),
total_lvs=vg_extents['parts'],
block_lv_size=db_size,
block_db_devices=', '.join([ssd.abspath for ssd in self.ssds]),
lv_size=str(disk.Size(b=(vg_extents['sizes']))),
total_osds=len(self.hdds))
string += templates.osd_component_titles
for osd in self.computed['osds']:
string += templates.osd_header
string += templates.osd_component.format(
_type='[data]',
path=osd['data']['path'],
size=osd['data']['human_readable_size'],
percent=osd['data']['percentage'])
string += templates.osd_component.format(
_type='[block.db]',
path='(volume-group/lv)',
size=osd['block.db']['human_readable_size'],
percent=osd['block.db']['percentage'])
print(string)
def compute(self):
"""
Go through the rules needed to properly size the lvs, return
a dictionary with the result
"""
osds = self.computed['osds']
for device in self.hdds:
for hdd in range(self.osds_per_device):
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device.abspath
osd['data']['size'] = device.sys_api['size'] / self.osds_per_device
osd['data']['parts'] = self.osds_per_device
osd['data']['percentage'] = 100 / self.osds_per_device
osd['data']['human_readable_size'] = str(
disk.Size(b=device.sys_api['size']) / self.osds_per_device
)
osds.append(osd)
for device in self.ssds:
extents = lvm.sizing(device.sys_api['size'], parts=self.osds_per_device)
for ssd in range(self.osds_per_device):
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device.abspath
osd['data']['size'] = extents['sizes']
osd['data']['parts'] = extents['parts']
osd['data']['percentage'] = 100 / self.osds_per_device
osd['data']['human_readable_size'] = str(disk.Size(b=extents['sizes']))
osds.append(osd)
self.computed['changed'] = len(osds) > 0
def report_pretty(self):
vg_extents = lvm.sizing(self.total_ssd_size.b, parts=self.db_lvs)
db_size = str(disk.Size(b=(vg_extents['sizes'])))
string = ""
string += templates.total_osds.format(
total_osds=len(self.hdds)
)
string += templates.ssd_volume_group.format(
target='block.db',
total_lv_size=str(self.total_ssd_size),
total_lvs=vg_extents['parts'],
block_lv_size=db_size,
block_db_devices=', '.join([ssd['path'] for ssd in self.ssds]),
lv_size=str(disk.Size(b=(vg_extents['sizes']))),
total_osds=len(self.hdds)
)
string += templates.osd_component_titles
for osd in self.computed['osds']:
string += templates.osd_header
string += templates.osd_component.format(
_type='[data]',
path=osd['data']['path'],
size=osd['data']['human_readable_size'],
percent=osd['data']['percentage'])
string += templates.osd_component.format(
_type='[block.db]',
path='(volume-group/lv)',
size=osd['block.db']['human_readable_size'],
percent=osd['block.db']['percentage'])
print(string)
def compute(self):
"""
Go through the rules needed to properly size the lvs, return
a dictionary with the result
"""
osds = self.computed['osds']
for device in self.hdds:
for hdd in range(self.osds_per_device):
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device.abspath
osd['data']['size'] = device.lvm_size.b / self.osds_per_device
osd['data']['parts'] = self.osds_per_device
osd['data']['percentage'] = 100 / self.osds_per_device
osd['data']['human_readable_size'] = str(
disk.Size(b=device.lvm_size.b) / self.osds_per_device
)
osds.append(osd)
for device in self.ssds:
extents = lvm.sizing(device.lvm_size.b, parts=self.osds_per_device)
for ssd in range(self.osds_per_device):
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device.abspath
osd['data']['size'] = extents['sizes']
osd['data']['parts'] = extents['parts']
osd['data']['percentage'] = 100 / self.osds_per_device
osd['data']['human_readable_size'] = str(disk.Size(b=extents['sizes']))
osds.append(osd)
self.computed['changed'] = len(osds) > 0
def compute(self):
"""
Go through the rules needed to properly size the lvs, return
a dictionary with the result
"""
osds = self.computed['osds']
vgs = self.computed['vgs']
for device in self.hdds:
vgs.append({'devices': [device['path']], 'parts': 1})
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device['path']
osd['data']['size'] = device['size']
osd['data']['parts'] = 1
osd['data']['percentage'] = 100
osd['data']['human_readable_size'] = str(
disk.Size(b=device['size']))
osds.append(osd)
for device in self.ssds:
# TODO: creates 2 OSDs per device, make this configurable (env var?)
extents = lvm.sizing(device['size'], parts=2)
vgs.append({'devices': [device['path']], 'parts': 2})
for ssd in range(2):
osd = {'data': {}, 'block.db': {}}
osd['data']['path'] = device['path']
osd['data']['size'] = extents['sizes']
osd['data']['parts'] = extents['parts']
osd['data']['percentage'] = 50
osd['data']['human_readable_size'] = str(
disk.Size(b=extents['sizes']))
osds.append(osd)
def validate(self):
"""
Ensure that the minimum requirements for this type of scenario is
met, raise an error if the provided devices would not work
"""
# validate minimum size for all devices
validators.minimum_device_size(self.devices,
osds_per_device=self.osds_per_device)
# make sure that data devices do not have any LVs
validators.no_lvm_membership(self.data_devs)
# do not allow non-common VG to continue
validators.has_common_vg(self.db_or_journal_devs)
# find the common VG to calculate how much is available
self.common_vg = self.get_common_vg(self.db_or_journal_devs)
# find how many journals are possible from the common VG
if self.common_vg:
common_vg_size = disk.Size(b=self.common_vg.free)
else:
common_vg_size = disk.Size(gb=0)
# non-VG SSDs
vg_ssds = set([d for d in self.db_or_journal_devs if d.is_lvm_member])
self.blank_journal_devs = set(
self.db_or_journal_devs).difference(vg_ssds)
self.total_blank_journal_dev_size = disk.Size(b=0)
for blank_journal_dev in self.blank_journal_devs:
self.total_blank_journal_dev_size += disk.Size(
b=blank_journal_dev.lvm_size.b)
self.total_available_journal_space = self.total_blank_journal_dev_size + common_vg_size
try:
self.vg_extents = lvm.sizing(self.total_available_journal_space.b,
size=self.journal_size.b *
self.osds_per_device)
except SizeAllocationError:
msg = "Not enough space in fast devices (%s) to create %s x %s journal LV"
raise RuntimeError(msg % (self.total_available_journal_space,
self.osds_per_device, self.journal_size))
# validate that number of journals possible are enough for number of
# OSDs proposed
total_journals_possible = self.total_available_journal_space / self.journal_size
if self.osds_per_device > total_journals_possible:
msg = "Not enough space (%s) to create %s x %s journal LVs" % (
self.total_available_journal_space, self.journals_needed,
self.journal_size)
raise RuntimeError(msg)
if self.osd_ids:
self._validate_osd_ids()
def validate(self):
"""
Ensure that the minimum requirements for this type of scenario is
met, raise an error if the provided devices would not work
"""
# validate minimum size for all devices
validators.minimum_device_size(self.devices, osds_per_device=self.osds_per_device)
# make sure that data devices do not have any LVs
validators.no_lvm_membership(self.data_devs)
# do not allow non-common VG to continue
validators.has_common_vg(self.db_or_journal_devs)
# find the common VG to calculate how much is available
self.common_vg = self.get_common_vg(self.db_or_journal_devs)
# find how many journals are possible from the common VG
if self.common_vg:
common_vg_size = disk.Size(gb=self.common_vg.free)
else:
common_vg_size = disk.Size(gb=0)
# non-VG SSDs
vg_ssds = set([d for d in self.db_or_journal_devs if d.is_lvm_member])
self.blank_journal_devs = set(self.db_or_journal_devs).difference(vg_ssds)
self.total_blank_journal_dev_size = disk.Size(b=0)
for blank_journal_dev in self.blank_journal_devs:
self.total_blank_journal_dev_size += disk.Size(b=blank_journal_dev.lvm_size.b)
self.total_available_journal_space = self.total_blank_journal_dev_size + common_vg_size
try:
self.vg_extents = lvm.sizing(
self.total_available_journal_space.b, size=self.journal_size.b * self.osds_per_device
)
except SizeAllocationError:
msg = "Not enough space in fast devices (%s) to create %s x %s journal LV"
raise RuntimeError(
msg % (self.total_available_journal_space, self.osds_per_device, self.journal_size)
)
# validate that number of journals possible are enough for number of
# OSDs proposed
total_journals_possible = self.total_available_journal_space / self.journal_size
if self.osds_per_device > total_journals_possible:
msg = "Not enough space (%s) to create %s x %s journal LVs" % (
self.total_available_journal_space, self.journals_needed, self.journal_size
)
raise RuntimeError(msg)
if self.osd_ids:
self._validate_osd_ids()
def validate(self):
"""
Ensure that the minimum requirements for this type of scenario is
met, raise an error if the provided devices would not work
"""
# validate minimum size for all devices
validators.minimum_device_size(self.devices)
# make sure that data devices do not have any LVs
validators.no_lvm_membership(self.hdds)
# do not allow non-common VG to continue
validators.has_common_vg(self.ssds)
# find the common VG to calculate how much is available
self.common_vg = self.get_common_vg()
# find how many journals are possible from the common VG
if self.common_vg:
common_vg_size = disk.Size(gb=self.common_vg.free)
else:
common_vg_size = disk.Size(gb=0)
# non-VG SSDs
self.vg_ssds = set([d for d in self.ssds if d.is_lvm_member])
self.blank_ssds = set(self.ssds).difference(self.vg_ssds)
self.total_blank_ssd_size = disk.Size(b=0)
for blank_ssd in self.blank_ssds:
self.total_blank_ssd_size += disk.Size(b=blank_ssd.sys_api['size'])
self.total_available_journal_space = self.total_blank_ssd_size + common_vg_size
try:
self.vg_extents = lvm.sizing(self.total_available_journal_space.b,
size=self.journal_size.b)
# FIXME with real exception catching from sizing that happens when the
# journal space is not enough
except Exception:
self.vg_extents = {'parts': 0, 'percentages': 0, 'sizes': 0}
# validate that number of journals possible are enough for number of
# OSDs proposed
total_journals_possible = self.total_available_journal_space / self.journal_size
if len(self.hdds) > total_journals_possible:
msg = "Not enough %s journals (%s) can be created for %s OSDs" % (
self.journal_size, total_journals_possible, len(self.hdds))
raise RuntimeError(msg)
def report_pretty(self):
vg_extents = lvm.sizing(self.total_available_db_space.b, parts=self.dbs_needed)
db_size = str(disk.Size(b=(vg_extents['sizes'])))
string = ""
if self.args.filtered_devices:
string += templates.filtered_devices(self.args.filtered_devices)
string += templates.total_osds.format(
total_osds=len(self.hdds) * self.osds_per_device
)
string += templates.ssd_volume_group.format(
target='block.db',
total_lv_size=str(self.total_available_db_space),
total_lvs=vg_extents['parts'] * self.osds_per_device,
block_lv_size=db_size,
block_db_devices=', '.join([ssd.abspath for ssd in self.ssds]),
lv_size=self.block_db_size or str(disk.Size(b=(vg_extents['sizes']))),
total_osds=len(self.hdds)
)
string += templates.osd_component_titles
for osd in self.computed['osds']:
string += templates.osd_header
string += templates.osd_component.format(
_type='[data]',
path=osd['data']['path'],
size=osd['data']['human_readable_size'],
percent=osd['data']['percentage'])
string += templates.osd_component.format(
_type='[block.db]',
path=osd['block.db']['path'],
size=osd['block.db']['human_readable_size'],
percent=osd['block.db']['percentage'])
print(string)
def validate(self):
"""
HDDs represent data devices, and solid state devices are for block.db,
make sure that the number of data devices would have enough LVs and
those LVs would be large enough to accommodate a block.db
"""
# validate minimum size for all devices
validators.minimum_device_size(self.devices)
# add all the size available in solid drives and divide it by the
# expected number of osds, the expected output should be larger than
# the minimum alllowed for block.db
self.total_ssd_size = disk.Size(b=0)
for ssd in self.ssds:
self.total_ssd_size + disk.Size(b=ssd['size'])
self.block_db_size = self.total_ssd_size / self.db_lvs
self.vg_extents = lvm.sizing(self.total_ssd_size.b, parts=self.db_lvs)
# min 2GB of block.db is allowed
msg = 'Total solid size (%s) is not enough for block.db LVs larger than 2 GB'
if self.block_db_size < disk.Size(gb=2):
# use ad-hoc exception here
raise RuntimeError(msg % self.total_ssd_size)
def validate(self):
"""
HDDs represent data devices, and solid state devices are for block.db,
make sure that the number of data devices would have enough LVs and
those LVs would be large enough to accommodate a block.db
"""
# validate minimum size for all devices
validators.minimum_device_size(self.devices)
# add all the size available in solid drives and divide it by the
# expected number of osds, the expected output should be larger than
# the minimum alllowed for block.db
self.total_ssd_size = disk.Size(b=0)
for ssd in self.ssds:
self.total_ssd_size + disk.Size(b=ssd['size'])
self.block_db_size = self.total_ssd_size / self.db_lvs
self.vg_extents = lvm.sizing(self.total_ssd_size.b, parts=self.db_lvs)
# min 2GB of block.db is allowed
msg = 'Total solid size (%s) is not enough for block.db LVs larger than 2 GB'
if self.block_db_size < disk.Size(gb=2):
# use ad-hoc exception here
raise RuntimeError(msg % self.total_ssd_size)
def report_pretty(self, filtered_devices):
string = ""
if filtered_devices:
string += templates.filtered_devices(filtered_devices)
string += templates.total_osds.format(total_osds=len(self.data_devs) *
self.osds_per_device)
if self.db_or_journal_devs:
vg_extents = lvm.sizing(self.total_available_db_space.b,
parts=self.dbs_needed)
db_size = str(disk.Size(b=(vg_extents['sizes'])))
string += templates.ssd_volume_group.format(
target='block.db',
total_lv_size=str(self.total_available_db_space),
total_lvs=vg_extents['parts'] * self.osds_per_device,
block_lv_size=db_size,
block_db_devices=', '.join(
[ssd.abspath for ssd in self.db_or_journal_devs]),
lv_size=self.block_db_size
or str(disk.Size(b=(vg_extents['sizes']))),
total_osds=len(self.data_devs))
if self.wal_devs:
wal_vg_extents = lvm.sizing(self.total_available_wal_space.b,
parts=self.wals_needed)
wal_size = str(disk.Size(b=(wal_vg_extents['sizes'])))
string += templates.ssd_volume_group.format(
target='block.wal',
total_lv_size=str(self.total_available_wal_space),
total_lvs=wal_vg_extents['parts'] * self.osds_per_device,
block_lv_size=wal_size,
block_db_devices=', '.join(
[dev.abspath for dev in self.wal_devs]),
lv_size=self.block_wal_size
or str(disk.Size(b=(wal_vg_extents['sizes']))),
total_osds=len(self.data_devs))
string += templates.osd_component_titles
for osd in self.computed['osds']:
string += templates.osd_header
if 'osd_id' in osd:
string += templates.osd_reused_id.format(id_=osd['osd_id'])
string += templates.osd_component.format(
_type='[data]',
path=osd['data']['path'],
size=osd['data']['human_readable_size'],
percent=osd['data']['percentage'])
if 'block.db' in osd:
string += templates.osd_component.format(
_type='[block.db]',
path=osd['block.db']['path'],
size=osd['block.db']['human_readable_size'],
percent=osd['block.db']['percentage'])
if 'block.wal' in osd:
string += templates.osd_component.format(
_type='[block.wal]',
path=osd['block.wal']['path'],
size=osd['block.wal']['human_readable_size'],
percent=osd['block.wal']['percentage'])
print(string)
def validate(self):
"""
HDDs represent data devices, and solid state devices are for block.db,
make sure that the number of data devices would have enough LVs and
those LVs would be large enough to accommodate a block.db
"""
# validate minimum size for all devices
validators.minimum_device_size(self.devices, osds_per_device=self.osds_per_device)
# make sure that data devices do not have any LVs
validators.no_lvm_membership(self.hdds)
# do not allow non-common VG to continue
validators.has_common_vg(self.ssds)
# find the common VG to calculate how much is available
self.common_vg = self.get_common_vg()
# find how many block.db LVs are possible from the common VG
if self.common_vg:
common_vg_size = disk.Size(gb=self.common_vg.free)
else:
common_vg_size = disk.Size(gb=0)
# non-VG SSDs
self.vg_ssds = set([d for d in self.ssds if d.is_lvm_member])
self.blank_ssds = set(self.ssds).difference(self.vg_ssds)
self.total_blank_ssd_size = disk.Size(b=0)
for blank_ssd in self.blank_ssds:
self.total_blank_ssd_size += disk.Size(b=blank_ssd.sys_api['size'])
self.total_available_db_space = self.total_blank_ssd_size + common_vg_size
# If not configured, we default to 0, which is really "use as much as
# possible" captured by the `else` condition
if self.block_db_size.gb > 0:
try:
self.vg_extents = lvm.sizing(
self.total_available_db_space.b, size=self.block_db_size.b * self.osds_per_device
)
except SizeAllocationError:
msg = "Not enough space in fast devices (%s) to create %s x %s block.db LV"
raise RuntimeError(
msg % (self.total_available_db_space, self.osds_per_device, self.block_db_size)
)
else:
self.vg_extents = lvm.sizing(
self.total_available_db_space.b, parts=self.dbs_needed
)
# validate that number of block.db LVs possible are enough for number of
# OSDs proposed
if self.total_available_db_space.b == 0:
msg = "No space left in fast devices to create block.db LVs"
raise RuntimeError(msg)
# bluestore_block_db_size was unset, so we must set this to whatever
# size we get by dividing the total available space for block.db LVs
# into the number of block.db LVs needed (i.e. "as large as possible")
if self.block_db_size.b == 0:
self.block_db_size = self.total_available_db_space / self.dbs_needed
total_dbs_possible = self.total_available_db_space / self.block_db_size
if self.dbs_needed > total_dbs_possible:
msg = "Not enough space (%s) to create %s x %s block.db LVs" % (
self.total_available_db_space, self.dbs_needed, self.block_db_size,
)
raise RuntimeError(msg)
def validate(self):
"""
HDDs represent data devices, and solid state devices are for block.db,
make sure that the number of data devices would have enough LVs and
those LVs would be large enough to accommodate a block.db
"""
# validate minimum size for all devices
validators.minimum_device_size(self.devices, osds_per_device=self.osds_per_device)
# make sure that data devices do not have any LVs
validators.no_lvm_membership(self.hdds)
# do not allow non-common VG to continue
validators.has_common_vg(self.ssds)
# find the common VG to calculate how much is available
self.common_vg = self.get_common_vg()
# find how many block.db LVs are possible from the common VG
if self.common_vg:
common_vg_size = disk.Size(gb=self.common_vg.free)
else:
common_vg_size = disk.Size(gb=0)
# non-VG SSDs
self.vg_ssds = set([d for d in self.ssds if d.is_lvm_member])
self.blank_ssds = set(self.ssds).difference(self.vg_ssds)
self.total_blank_ssd_size = disk.Size(b=0)
for blank_ssd in self.blank_ssds:
self.total_blank_ssd_size += disk.Size(b=blank_ssd.lvm_size.b)
self.total_available_db_space = self.total_blank_ssd_size + common_vg_size
# If not configured, we default to 0, which is really "use as much as
# possible" captured by the `else` condition
if self.block_db_size.gb > 0:
try:
self.vg_extents = lvm.sizing(
self.total_available_db_space.b, size=self.block_db_size.b * self.osds_per_device
)
except SizeAllocationError:
msg = "Not enough space in fast devices (%s) to create %s x %s block.db LV"
raise RuntimeError(
msg % (self.total_available_db_space, self.osds_per_device, self.block_db_size)
)
else:
self.vg_extents = lvm.sizing(
self.total_available_db_space.b, parts=self.dbs_needed
)
# validate that number of block.db LVs possible are enough for number of
# OSDs proposed
if self.total_available_db_space.b == 0:
msg = "No space left in fast devices to create block.db LVs"
raise RuntimeError(msg)
# bluestore_block_db_size was unset, so we must set this to whatever
# size we get by dividing the total available space for block.db LVs
# into the number of block.db LVs needed (i.e. "as large as possible")
if self.block_db_size.b == 0:
self.block_db_size = self.total_available_db_space / self.dbs_needed
self.use_large_block_db = True
total_dbs_possible = self.total_available_db_space / self.block_db_size
if self.dbs_needed > total_dbs_possible:
msg = "Not enough space (%s) to create %s x %s block.db LVs" % (
self.total_available_db_space, self.dbs_needed, self.block_db_size,
)
raise RuntimeError(msg)
def _validate_wal_devs(self):
# do not allow non-common VG to continue
validators.has_common_vg(self.wal_devs)
# find the common VG to calculate how much is available
self.common_wal_vg = self.get_common_vg(self.wal_devs)
# find how many block.wal LVs are possible from the common VG
if self.common_wal_vg:
common_vg_size = disk.Size(gb=self.common_wal_vg.free)
else:
common_vg_size = disk.Size(gb=0)
# non-VG SSDs
vg_members = set([d for d in self.wal_devs if d.is_lvm_member])
self.blank_wal_devs = set(self.wal_devs).difference(vg_members)
self.total_blank_wal_dev_size = disk.Size(b=0)
for blank_wal_dev in self.blank_wal_devs:
self.total_blank_wal_dev_size += disk.Size(
b=blank_wal_dev.lvm_size.b)
self.total_available_wal_space = self.total_blank_wal_dev_size + common_vg_size
# If not configured, we default to 0, which is really "use as much as
# possible" captured by the `else` condition
if self.block_wal_size.gb > 0:
try:
self.vg_extents = lvm.sizing(self.total_available_wal_space.b,
size=self.block_wal_size.b *
self.osds_per_device)
except SizeAllocationError:
msg = "Not enough space in fast devices (%s) to create %s x %s block.wal LV"
raise RuntimeError(msg %
(self.total_available_wal_space,
self.osds_per_device, self.block_wal_size))
else:
self.wal_vg_extents = lvm.sizing(self.total_available_wal_space.b,
parts=self.wals_needed)
# validate that number of block.wal LVs possible are enough for number of
# OSDs proposed
if self.total_available_wal_space.b == 0:
msg = "No space left in fast devices to create block.wal LVs"
raise RuntimeError(msg)
# bluestore_block_wal_size was unset, so we must set this to whatever
# size we get by dividing the total available space for block.wal LVs
# into the number of block.wal LVs needed (i.e. "as large as possible")
if self.block_wal_size.b == 0:
self.block_wal_size = self.total_available_wal_space / self.wals_needed
self.use_large_block_wal = True
total_wals_possible = self.total_available_wal_space / self.block_wal_size
if self.wals_needed > total_wals_possible:
msg = "Not enough space (%s) to create %s x %s block.wal LVs" % (
self.total_available_wal_space,
self.wals_needed,
self.block_wal_size,
)
raise RuntimeError(msg)
def report_pretty(self, filtered_devices):
string = ""
if filtered_devices:
string += templates.filtered_devices(filtered_devices)
string += templates.total_osds.format(
total_osds=len(self.data_devs) * self.osds_per_device
)
if self.db_or_journal_devs:
vg_extents = lvm.sizing(self.total_available_db_space.b, parts=self.dbs_needed)
db_size = str(disk.Size(b=(vg_extents['sizes'])))
string += templates.ssd_volume_group.format(
target='block.db',
total_lv_size=str(self.total_available_db_space),
total_lvs=vg_extents['parts'] * self.osds_per_device,
block_lv_size=db_size,
block_db_devices=', '.join([ssd.abspath for ssd in
self.db_or_journal_devs]),
lv_size=self.block_db_size or str(disk.Size(b=(vg_extents['sizes']))),
total_osds=len(self.data_devs)
)
if self.wal_devs:
wal_vg_extents = lvm.sizing(self.total_available_wal_space.b,
parts=self.wals_needed)
wal_size = str(disk.Size(b=(wal_vg_extents['sizes'])))
string += templates.ssd_volume_group.format(
target='block.wal',
total_lv_size=str(self.total_available_wal_space),
total_lvs=wal_vg_extents['parts'] * self.osds_per_device,
block_lv_size=wal_size,
block_db_devices=', '.join([dev.abspath for dev in
self.wal_devs]),
lv_size=self.block_wal_size or str(disk.Size(b=(wal_vg_extents['sizes']))),
total_osds=len(self.data_devs)
)
string += templates.osd_component_titles
for osd in self.computed['osds']:
string += templates.osd_header
if 'osd_id' in osd:
string += templates.osd_reused_id.format(
id_=osd['osd_id'])
string += templates.osd_component.format(
_type='[data]',
path=osd['data']['path'],
size=osd['data']['human_readable_size'],
percent=osd['data']['percentage'])
if 'block.db' in osd:
string += templates.osd_component.format(
_type='[block.db]',
path=osd['block.db']['path'],
size=osd['block.db']['human_readable_size'],
percent=osd['block.db']['percentage'])
if 'block.wal' in osd:
string += templates.osd_component.format(
_type='[block.wal]',
path=osd['block.wal']['path'],
size=osd['block.wal']['human_readable_size'],
percent=osd['block.wal']['percentage'])
print(string)
