]>
git.proxmox.com Git - ceph.git/blob - ceph/src/ceph-volume/ceph_volume/devices/lvm/prepare.py
4db8532806a999f59bc617e432d1981e6773efc4
1 from __future__
import print_function
4 from textwrap
import dedent
5 from ceph_volume
.util
import prepare
as prepare_utils
6 from ceph_volume
.util
import encryption
as encryption_utils
7 from ceph_volume
.util
import system
, disk
8 from ceph_volume
.util
.arg_validators
import exclude_group_options
9 from ceph_volume
import conf
, decorators
, terminal
10 from ceph_volume
.api
import lvm
as api
11 from .common
import prepare_parser
, rollback_osd
14 logger
= logging
.getLogger(__name__
)
17 def prepare_dmcrypt(key
, device
, device_type
, tags
):
19 Helper for devices that are encrypted. The operations needed for
20 block, db, wal, or data/journal devices are all the same
24 tag_name
= 'ceph.%s_uuid' % device_type
27 encryption_utils
.luks_format(
31 encryption_utils
.luks_open(
37 return '/dev/mapper/%s' % uuid
40 def prepare_filestore(device
, journal
, secrets
, tags
, osd_id
, fsid
):
42 :param device: The name of the logical volume to work with
43 :param journal: similar to device but can also be a regular/plain disk
44 :param secrets: A dict with the secrets needed to create the osd (e.g. cephx)
45 :param id_: The OSD id
46 :param fsid: The OSD fsid, also known as the OSD UUID
48 cephx_secret
= secrets
.get('cephx_secret', prepare_utils
.create_key())
50 # encryption-only operations
51 if secrets
.get('dmcrypt_key'):
52 # format and open ('decrypt' devices) and re-assign the device and journal
53 # variables so that the rest of the process can use the mapper paths
54 key
= secrets
['dmcrypt_key']
55 device
= prepare_dmcrypt(key
, device
, 'data', tags
)
56 journal
= prepare_dmcrypt(key
, journal
, 'journal', tags
)
59 is_vdo
= api
.is_vdo(device
)
60 # create the directory
61 prepare_utils
.create_osd_path(osd_id
)
63 prepare_utils
.format_device(device
)
64 # mount the data device
65 prepare_utils
.mount_osd(device
, osd_id
, is_vdo
=is_vdo
)
67 prepare_utils
.link_journal(journal
, osd_id
)
68 # get the latest monmap
69 prepare_utils
.get_monmap(osd_id
)
70 # prepare the osd filesystem
71 prepare_utils
.osd_mkfs_filestore(osd_id
, fsid
, cephx_secret
)
72 # write the OSD keyring if it doesn't exist already
73 prepare_utils
.write_keyring(osd_id
, cephx_secret
)
74 if secrets
.get('dmcrypt_key'):
75 # if the device is going to get activated right away, this can be done
76 # here, otherwise it will be recreated
77 encryption_utils
.write_lockbox_keyring(
80 tags
['ceph.cephx_lockbox_secret']
84 def prepare_bluestore(block
, wal
, db
, secrets
, tags
, osd_id
, fsid
):
86 :param block: The name of the logical volume for the bluestore data
87 :param wal: a regular/plain disk or logical volume, to be used for block.wal
88 :param db: a regular/plain disk or logical volume, to be used for block.db
89 :param secrets: A dict with the secrets needed to create the osd (e.g. cephx)
90 :param id_: The OSD id
91 :param fsid: The OSD fsid, also known as the OSD UUID
93 cephx_secret
= secrets
.get('cephx_secret', prepare_utils
.create_key())
94 # encryption-only operations
95 if secrets
.get('dmcrypt_key'):
96 # If encrypted, there is no need to create the lockbox keyring file because
97 # bluestore re-creates the files and does not have support for other files
98 # like the custom lockbox one. This will need to be done on activation.
99 # format and open ('decrypt' devices) and re-assign the device and journal
100 # variables so that the rest of the process can use the mapper paths
101 key
= secrets
['dmcrypt_key']
102 block
= prepare_dmcrypt(key
, block
, 'block', tags
)
103 wal
= prepare_dmcrypt(key
, wal
, 'wal', tags
)
104 db
= prepare_dmcrypt(key
, db
, 'db', tags
)
106 # create the directory
107 prepare_utils
.create_osd_path(osd_id
, tmpfs
=True)
109 prepare_utils
.link_block(block
, osd_id
)
110 # get the latest monmap
111 prepare_utils
.get_monmap(osd_id
)
112 # write the OSD keyring if it doesn't exist already
113 prepare_utils
.write_keyring(osd_id
, cephx_secret
)
114 # prepare the osd filesystem
115 prepare_utils
.osd_mkfs_bluestore(
117 keyring
=cephx_secret
,
123 class Prepare(object):
125 help = 'Format an LVM device and associate it with an OSD'
127 def __init__(self
, argv
):
131 def get_ptuuid(self
, argument
):
132 uuid
= disk
.get_partuuid(argument
)
134 terminal
.error('blkid could not detect a PARTUUID for device: %s' % argument
)
135 raise RuntimeError('unable to use device')
138 def get_lv(self
, argument
):
140 Perform some parsing of the command-line value so that the process
141 can determine correctly if it got a device path or an lv.
143 :param argument: The command-line value that will need to be split to
144 retrieve the actual lv
146 #TODO is this efficient?
148 vg_name
, lv_name
= argument
.split('/')
149 except (ValueError, AttributeError):
151 return api
.get_lv(lv_name
=lv_name
, vg_name
=vg_name
)
153 def setup_device(self
, device_type
, device_name
, tags
, size
):
155 Check if ``device`` is an lv, if so, set the tags, making sure to
156 update the tags with the lv_uuid and lv_path which the incoming tags
159 If the device is not a logical volume, then retrieve the partition UUID
160 by querying ``blkid``
162 if device_name
is None:
164 tags
['ceph.type'] = device_type
165 tags
['ceph.vdo'] = api
.is_vdo(device_name
)
166 lv
= self
.get_lv(device_name
)
170 tags
['ceph.%s_uuid' % device_type
] = uuid
171 tags
['ceph.%s_device' % device_type
] = path
173 elif disk
.is_device(device_name
):
174 # We got a disk, create an lv
175 lv_type
= "osd-{}".format(device_type
)
176 uuid
= system
.generate_uuid()
177 tags
['ceph.{}_uuid'.format(device_type
)] = uuid
179 'device': device_name
,
183 kwargs
['size'] = disk
.Size
.parse(size
)
189 tags
['ceph.{}_device'.format(device_type
)] = path
192 # otherwise assume this is a regular disk partition
193 uuid
= self
.get_ptuuid(device_name
)
195 tags
['ceph.%s_uuid' % device_type
] = uuid
196 tags
['ceph.%s_device' % device_type
] = path
197 return path
, uuid
, tags
199 def prepare_data_device(self
, device_type
, osd_uuid
):
201 Check if ``arg`` is a device or partition to create an LV out of it
202 with a distinct volume group name, assigning LV tags on it and
203 ultimately, returning the logical volume object. Failing to detect
204 a device or partition will result in error.
206 :param arg: The value of ``--data`` when parsing args
207 :param device_type: Usually, either ``data`` or ``block`` (filestore vs. bluestore)
208 :param osd_uuid: The OSD uuid
210 device
= self
.args
.data
211 if disk
.is_partition(device
) or disk
.is_device(device
):
212 # we must create a vg, and then a single lv
213 lv_name_prefix
= "osd-{}".format(device_type
)
214 kwargs
= {'device': device
,
215 'tags': {'ceph.type': device_type
},
217 logger
.debug('data device size: {}'.format(self
.args
.data_size
))
218 if self
.args
.data_size
!= 0:
219 kwargs
['size'] = disk
.Size
.parse(self
.args
.data_size
)
220 return api
.create_lv(
226 'Cannot use device ({}).'.format(device
),
227 'A vg/lv path or an existing device is needed']
228 raise RuntimeError(' '.join(error
))
230 raise RuntimeError('no data logical volume found with: {}'.format(device
))
232 def safe_prepare(self
, args
=None):
234 An intermediate step between `main()` and `prepare()` so that we can
235 capture the `self.osd_id` in case we need to rollback
237 :param args: Injected args, usually from `lvm create` which compounds
238 both `prepare` and `create`
242 if api
.is_ceph_device(self
.get_lv(self
.args
.data
)):
243 logger
.info("device {} is already used".format(self
.args
.data
))
244 raise RuntimeError("skipping {}, it is already prepared".format(self
.args
.data
))
248 logger
.exception('lvm prepare was unable to complete')
249 logger
.info('will rollback OSD ID creation')
250 rollback_osd(self
.args
, self
.osd_id
)
252 terminal
.success("ceph-volume lvm prepare successful for: %s" % self
.args
.data
)
254 def get_cluster_fsid(self
):
256 Allows using --cluster-fsid as an argument, but can fallback to reading
257 from ceph.conf if that is unset (the default behavior).
259 if self
.args
.cluster_fsid
:
260 return self
.args
.cluster_fsid
262 return conf
.ceph
.get('global', 'fsid')
264 @decorators.needs_root
266 # FIXME we don't allow re-using a keyring, we always generate one for the
267 # OSD, this needs to be fixed. This could either be a file (!) or a string
268 # (!!) or some flags that we would need to compound into a dict so that we
269 # can convert to JSON (!!!)
270 secrets
= {'cephx_secret': prepare_utils
.create_key()}
271 cephx_lockbox_secret
= ''
272 encrypted
= 1 if self
.args
.dmcrypt
else 0
273 cephx_lockbox_secret
= '' if not encrypted
else prepare_utils
.create_key()
276 secrets
['dmcrypt_key'] = encryption_utils
.create_dmcrypt_key()
277 secrets
['cephx_lockbox_secret'] = cephx_lockbox_secret
279 cluster_fsid
= self
.get_cluster_fsid()
281 osd_fsid
= self
.args
.osd_fsid
or system
.generate_uuid()
282 crush_device_class
= self
.args
.crush_device_class
283 if crush_device_class
:
284 secrets
['crush_device_class'] = crush_device_class
285 # reuse a given ID if it exists, otherwise create a new ID
286 self
.osd_id
= prepare_utils
.create_id(osd_fsid
, json
.dumps(secrets
), osd_id
=self
.args
.osd_id
)
288 'ceph.osd_fsid': osd_fsid
,
289 'ceph.osd_id': self
.osd_id
,
290 'ceph.cluster_fsid': cluster_fsid
,
291 'ceph.cluster_name': conf
.cluster
,
292 'ceph.crush_device_class': crush_device_class
,
293 'ceph.osdspec_affinity': prepare_utils
.get_osdspec_affinity()
295 if self
.args
.filestore
:
296 #TODO: allow auto creation of journal on passed device, only works
297 # when physical device is passed, not LV
298 if not self
.args
.journal
:
299 raise RuntimeError('--journal is required when using --filestore')
301 data_lv
= self
.get_lv(self
.args
.data
)
303 data_lv
= self
.prepare_data_device('data', osd_fsid
)
305 tags
['ceph.data_device'] = data_lv
.lv_path
306 tags
['ceph.data_uuid'] = data_lv
.lv_uuid
307 tags
['ceph.cephx_lockbox_secret'] = cephx_lockbox_secret
308 tags
['ceph.encrypted'] = encrypted
309 tags
['ceph.vdo'] = api
.is_vdo(data_lv
.lv_path
)
311 journal_device
, journal_uuid
, tags
= self
.setup_device(
312 'journal', self
.args
.journal
, tags
, self
.args
.journal_size
)
314 tags
['ceph.type'] = 'data'
315 data_lv
.set_tags(tags
)
325 elif self
.args
.bluestore
:
326 block_lv
= self
.get_lv(self
.args
.data
)
328 block_lv
= self
.prepare_data_device('block', osd_fsid
)
330 tags
['ceph.block_device'] = block_lv
.lv_path
331 tags
['ceph.block_uuid'] = block_lv
.lv_uuid
332 tags
['ceph.cephx_lockbox_secret'] = cephx_lockbox_secret
333 tags
['ceph.encrypted'] = encrypted
334 tags
['ceph.vdo'] = api
.is_vdo(block_lv
.lv_path
)
336 wal_device
, wal_uuid
, tags
= self
.setup_device(
337 'wal', self
.args
.block_wal
, tags
, self
.args
.block_wal_size
)
338 db_device
, db_uuid
, tags
= self
.setup_device(
339 'db', self
.args
.block_db
, tags
, self
.args
.block_db_size
)
341 tags
['ceph.type'] = 'block'
342 block_lv
.set_tags(tags
)
355 sub_command_help
= dedent("""
356 Prepare an OSD by assigning an ID and FSID, registering them with the
357 cluster with an ID and FSID, formatting and mounting the volume, and
358 finally by adding all the metadata to the logical volumes using LVM
359 tags, so that it can later be discovered.
361 Once the OSD is ready, an ad-hoc systemd unit will be enabled so that
362 it can later get activated and the OSD daemon can get started.
364 Encryption is supported via dmcrypt and the --dmcrypt flag.
366 Existing logical volume (lv):
368 ceph-volume lvm prepare --data {vg/lv}
370 Existing block device (a logical volume will be created):
372 ceph-volume lvm prepare --data /path/to/device
374 Optionally, can consume db and wal devices, partitions or logical
375 volumes. A device will get a logical volume, partitions and existing
376 logical volumes will be used as is:
378 ceph-volume lvm prepare --data {vg/lv} --block.wal {partition} --block.db {/path/to/device}
380 parser
= prepare_parser(
381 prog
='ceph-volume lvm prepare',
382 description
=sub_command_help
,
384 if len(self
.argv
) == 0:
385 print(sub_command_help
)
387 exclude_group_options(parser
, argv
=self
.argv
, groups
=['filestore', 'bluestore'])
388 self
.args
= parser
.parse_args(self
.argv
)
389 # the unfortunate mix of one superset for both filestore and bluestore
390 # makes this validation cumbersome
391 if self
.args
.filestore
:
392 if not self
.args
.journal
:
393 raise SystemExit('--journal is required when using --filestore')
394 # Default to bluestore here since defaulting it in add_argument may
395 # cause both to be True
396 if not self
.args
.bluestore
and not self
.args
.filestore
:
397 self
.args
.bluestore
= True