--- /dev/null
+from __future__ import print_function
+import json
+import uuid
+from textwrap import dedent
+from ceph_volume.util import prepare as prepare_utils
+from ceph_volume.util import system, disk
+from ceph_volume import conf, decorators, terminal
+from ceph_volume.api import lvm as api
+from .common import prepare_parser
+
+
+def prepare_filestore(device, journal, secrets, id_=None, fsid=None):
+ """
+ :param device: The name of the logical volume to work with
+ :param journal: similar to device but can also be a regular/plain disk
+ :param secrets: A dict with the secrets needed to create the osd (e.g. cephx)
+ :param id_: The OSD id
+ :param fsid: The OSD fsid, also known as the OSD UUID
+ """
+ cephx_secret = secrets.get('cephx_secret', prepare_utils.create_key())
+ json_secrets = json.dumps(secrets)
+
+ # allow re-using an existing fsid, in case prepare failed
+ fsid = fsid or system.generate_uuid()
+ # allow re-using an id, in case a prepare failed
+ osd_id = id_ or prepare_utils.create_id(fsid, json_secrets)
+ # create the directory
+ prepare_utils.create_osd_path(osd_id)
+ # format the device
+ prepare_utils.format_device(device)
+ # mount the data device
+ prepare_utils.mount_osd(device, osd_id)
+ # symlink the journal
+ prepare_utils.link_journal(journal, osd_id)
+ # get the latest monmap
+ prepare_utils.get_monmap(osd_id)
+ # prepare the osd filesystem
+ prepare_utils.osd_mkfs_filestore(osd_id, fsid)
+ # write the OSD keyring if it doesn't exist already
+ prepare_utils.write_keyring(osd_id, cephx_secret)
+
+
+def prepare_bluestore(block, wal, db, secrets, id_=None, fsid=None):
+ """
+ :param block: The name of the logical volume for the bluestore data
+ :param wal: a regular/plain disk or logical volume, to be used for block.wal
+ :param db: a regular/plain disk or logical volume, to be used for block.db
+ :param secrets: A dict with the secrets needed to create the osd (e.g. cephx)
+ :param id_: The OSD id
+ :param fsid: The OSD fsid, also known as the OSD UUID
+ """
+ cephx_secret = secrets.get('cephx_secret', prepare_utils.create_key())
+ json_secrets = json.dumps(secrets)
+
+ # allow re-using an existing fsid, in case prepare failed
+ fsid = fsid or system.generate_uuid()
+ # allow re-using an id, in case a prepare failed
+ osd_id = id_ or prepare_utils.create_id(fsid, json_secrets)
+ # create the directory
+ prepare_utils.create_osd_path(osd_id, tmpfs=True)
+ # symlink the block
+ prepare_utils.link_block(block, osd_id)
+ # get the latest monmap
+ prepare_utils.get_monmap(osd_id)
+ # write the OSD keyring if it doesn't exist already
+ prepare_utils.write_keyring(osd_id, cephx_secret)
+ # prepare the osd filesystem
+ prepare_utils.osd_mkfs_bluestore(
+ osd_id, fsid,
+ keyring=cephx_secret,
+ wal=wal,
+ db=db
+ )
+
+
+class Prepare(object):
+
+ help = 'Format an LVM device and associate it with an OSD'
+
+ def __init__(self, argv):
+ self.argv = argv
+
+ def get_ptuuid(self, argument):
+ uuid = disk.get_partuuid(argument)
+ if not uuid:
+ terminal.error('blkid could not detect a PARTUUID for device: %s' % argument)
+ raise RuntimeError('unable to use device')
+ return uuid
+
+ def get_lv(self, argument):
+ """
+ Perform some parsing of the command-line value so that the process
+ can determine correctly if it got a device path or an lv.
+
+ :param argument: The command-line value that will need to be split to
+ retrieve the actual lv
+ """
+ try:
+ vg_name, lv_name = argument.split('/')
+ except (ValueError, AttributeError):
+ return None
+ return api.get_lv(lv_name=lv_name, vg_name=vg_name)
+
+ def setup_device(self, device_type, device_name, tags):
+ """
+ Check if ``device`` is an lv, if so, set the tags, making sure to
+ update the tags with the lv_uuid and lv_path which the incoming tags
+ will not have.
+
+ If the device is not a logical volume, then retrieve the partition UUID
+ by querying ``blkid``
+ """
+ if device_name is None:
+ return '', '', tags
+ tags['ceph.type'] = device_type
+ lv = self.get_lv(device_name)
+ if lv:
+ uuid = lv.lv_uuid
+ path = lv.lv_path
+ tags['ceph.%s_uuid' % device_type] = uuid
+ tags['ceph.%s_device' % device_type] = path
+ lv.set_tags(tags)
+ else:
+ # otherwise assume this is a regular disk partition
+ uuid = self.get_ptuuid(device_name)
+ path = device_name
+ tags['ceph.%s_uuid' % device_type] = uuid
+ tags['ceph.%s_device' % device_type] = path
+ return path, uuid, tags
+
+ def prepare_device(self, arg, device_type, cluster_fsid, osd_fsid):
+ """
+ Check if ``arg`` is a device or partition to create an LV out of it
+ with a distinct volume group name, assigning LV tags on it and
+ ultimately, returning the logical volume object. Failing to detect
+ a device or partition will result in error.
+
+ :param arg: The value of ``--data`` when parsing args
+ :param device_type: Usually, either ``data`` or ``block`` (filestore vs. bluestore)
+ :param cluster_fsid: The cluster fsid/uuid
+ :param osd_fsid: The OSD fsid/uuid
+ """
+ if disk.is_partition(arg) or disk.is_device(arg):
+ # we must create a vg, and then a single lv
+ vg_name = "ceph-%s" % cluster_fsid
+ if api.get_vg(vg_name=vg_name):
+ # means we already have a group for this, make a different one
+ # XXX this could end up being annoying for an operator, maybe?
+ vg_name = "ceph-%s" % str(uuid.uuid4())
+ api.create_vg(vg_name, arg)
+ lv_name = "osd-%s-%s" % (device_type, osd_fsid)
+ return api.create_lv(
+ lv_name,
+ vg_name, # the volume group
+ tags={'ceph.type': device_type})
+ else:
+ error = [
+ 'Cannot use device (%s).' % arg,
+ 'A vg/lv path or an existing device is needed']
+ raise RuntimeError(' '.join(error))
+
+ raise RuntimeError('no data logical volume found with: %s' % arg)
+
+ @decorators.needs_root
+ def prepare(self, args):
+ # FIXME we don't allow re-using a keyring, we always generate one for the
+ # OSD, this needs to be fixed. This could either be a file (!) or a string
+ # (!!) or some flags that we would need to compound into a dict so that we
+ # can convert to JSON (!!!)
+ secrets = {'cephx_secret': prepare_utils.create_key()}
+
+ cluster_fsid = conf.ceph.get('global', 'fsid')
+ osd_fsid = args.osd_fsid or system.generate_uuid()
+ # allow re-using an id, in case a prepare failed
+ osd_id = args.osd_id or prepare_utils.create_id(osd_fsid, json.dumps(secrets))
+ if args.filestore:
+ if not args.journal:
+ raise RuntimeError('--journal is required when using --filestore')
+
+ data_lv = self.get_lv(args.data)
+ if not data_lv:
+ data_lv = self.prepare_device(args.data, 'data', cluster_fsid, osd_fsid)
+
+ tags = {
+ 'ceph.osd_fsid': osd_fsid,
+ 'ceph.osd_id': osd_id,
+ 'ceph.cluster_fsid': cluster_fsid,
+ 'ceph.cluster_name': conf.cluster,
+ 'ceph.data_device': data_lv.lv_path,
+ 'ceph.data_uuid': data_lv.lv_uuid,
+ }
+
+ journal_device, journal_uuid, tags = self.setup_device('journal', args.journal, tags)
+
+ tags['ceph.type'] = 'data'
+ data_lv.set_tags(tags)
+
+ prepare_filestore(
+ data_lv.lv_path,
+ journal_device,
+ secrets,
+ id_=osd_id,
+ fsid=osd_fsid,
+ )
+ elif args.bluestore:
+ block_lv = self.get_lv(args.data)
+ if not block_lv:
+ block_lv = self.prepare_device(args.data, 'block', cluster_fsid, osd_fsid)
+
+ tags = {
+ 'ceph.osd_fsid': osd_fsid,
+ 'ceph.osd_id': osd_id,
+ 'ceph.cluster_fsid': cluster_fsid,
+ 'ceph.cluster_name': conf.cluster,
+ 'ceph.block_device': block_lv.lv_path,
+ 'ceph.block_uuid': block_lv.lv_uuid,
+ }
+
+ wal_device, wal_uuid, tags = self.setup_device('wal', args.block_wal, tags)
+ db_device, db_uuid, tags = self.setup_device('db', args.block_db, tags)
+
+ tags['ceph.type'] = 'block'
+ block_lv.set_tags(tags)
+
+ prepare_bluestore(
+ block_lv.lv_path,
+ wal_device,
+ db_device,
+ secrets,
+ id_=osd_id,
+ fsid=osd_fsid,
+ )
+
+ def main(self):
+ sub_command_help = dedent("""
+ Prepare an OSD by assigning an ID and FSID, registering them with the
+ cluster with an ID and FSID, formatting and mounting the volume, and
+ finally by adding all the metadata to the logical volumes using LVM
+ tags, so that it can later be discovered.
+
+ Once the OSD is ready, an ad-hoc systemd unit will be enabled so that
+ it can later get activated and the OSD daemon can get started.
+
+ Most basic Usage looks like (journal will be collocated from the same volume group):
+
+ ceph-volume lvm prepare --data {volume group name}
+
+
+ Example calls for supported scenarios:
+
+ Dedicated volume group for Journal(s)
+ -------------------------------------
+
+ Existing logical volume (lv) or device:
+
+ ceph-volume lvm prepare --filestore --data {vg/lv} --journal /path/to/device
+
+ Or:
+
+ ceph-volume lvm prepare --filestore --data {vg/lv} --journal {vg/lv}
+
+ Existing block device, that will be made a group and logical volume:
+
+ ceph-volume lvm prepare --filestore --data /path/to/device --journal {vg/lv}
+
+ Bluestore
+ ---------
+
+ Existing logical volume (lv):
+
+ ceph-volume lvm prepare --bluestore --data {vg/lv}
+
+ Existing block device, that will be made a group and logical volume:
+
+ ceph-volume lvm prepare --bluestore --data /path/to/device
+
+ Optionally, can consume db and wal devices or logical volumes:
+
+ ceph-volume lvm prepare --bluestore --data {vg/lv} --block.wal {device} --block-db {vg/lv}
+ """)
+ parser = prepare_parser(
+ prog='ceph-volume lvm prepare',
+ description=sub_command_help,
+ )
+ if len(self.argv) == 0:
+ print(sub_command_help)
+ return
+ args = parser.parse_args(self.argv)
+ # Default to bluestore here since defaulting it in add_argument may
+ # cause both to be True
+ if args.bluestore is None and args.filestore is None:
+ args.bluestore = True
+ self.prepare(args)
Code Review / stor4nfv.git / blobdiff