# Copyright 2010-2011 Josh Durgin # Copyright 2020 Red Hat, Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Storage backend for RBD (RADOS (Reliable Autonomic Distributed Object Store) Block Device)""" import contextlib import logging import math import urllib from eventlet import tpool from oslo_config import cfg from oslo_utils import encodeutils from oslo_utils import eventletutils from oslo_utils import units from glance_store import capabilities from glance_store.common import utils from glance_store import driver from glance_store import exceptions from glance_store.i18n import _, _LE, _LI, _LW from glance_store import location try: import rados import rbd except ImportError: rados = None rbd = None DEFAULT_POOL = 'images' DEFAULT_USER = None # let librados decide based on the Ceph conf file DEFAULT_CHUNKSIZE = 8 # in MiB DEFAULT_SNAPNAME = 'snap' LOG = logging.getLogger(__name__) _RBD_OPTS = [ cfg.IntOpt('rbd_store_chunk_size', default=DEFAULT_CHUNKSIZE, min=1, help=""" Size, in megabytes, to chunk RADOS images into. Provide an integer value representing the size in megabytes to chunk Glance images into. The default chunk size is 8 megabytes. For optimal performance, the value should be a power of two. When Ceph's RBD object storage system is used as the storage backend for storing Glance images, the images are chunked into objects of the size set using this option. These chunked objects are then stored across the distributed block data store to use for Glance. Possible Values: * Any positive integer value Related options: * None """), cfg.StrOpt('rbd_store_pool', default=DEFAULT_POOL, help=""" RADOS pool in which images are stored. When RBD is used as the storage backend for storing Glance images, the images are stored by means of logical grouping of the objects (chunks of images) into a ``pool``. Each pool is defined with the number of placement groups it can contain. The default pool that is used is 'images'. More information on the RBD storage backend can be found here: http://ceph.com/planet/how-data-is-stored-in-ceph-cluster/ Possible Values: * A valid pool name Related options: * None """), cfg.StrOpt('rbd_store_user', default=DEFAULT_USER, help=""" RADOS user to authenticate as. This configuration option takes in the RADOS user to authenticate as. This is only needed when RADOS authentication is enabled and is applicable only if the user is using Cephx authentication. If the value for this option is not set by the user or is set to None, a default value will be chosen, which will be based on the client. section in rbd_store_ceph_conf. Possible Values: * A valid RADOS user Related options: * rbd_store_ceph_conf """), cfg.StrOpt('rbd_store_ceph_conf', default='', help=""" Ceph configuration file path. This configuration option specifies the path to the Ceph configuration file to be used. If the value for this option is not set by the user or is set to the empty string, librados will read the standard ceph.conf file by searching the default Ceph configuration file locations in sequential order. See the Ceph documentation for details. NOTE: If using Cephx authentication, this file should include a reference to the right keyring in a client. section NOTE 2: If you leave this option empty (the default), the actual Ceph configuration file used may change depending on what version of librados is being used. If it is important for you to know exactly which configuration file is in effect, you may specify that file here using this option. Possible Values: * A valid path to a configuration file Related options: * rbd_store_user """), cfg.IntOpt('rados_connect_timeout', default=-1, help=""" Timeout value for connecting to Ceph cluster. This configuration option takes in the timeout value in seconds used when connecting to the Ceph cluster i.e. it sets the time to wait for glance-api before closing the connection. This prevents glance-api hangups during the connection to RBD. If the value for this option is set to less than 0, no timeout is set and the default librados value is used. Possible Values: * Any integer value Related options: * None """), cfg.BoolOpt('rbd_thin_provisioning', default=False, help=""" Enable or not thin provisioning in this backend. This configuration option enable the feature of not really write null byte sequences on the RBD backend, the holes who can appear will automatically be interpreted by Ceph as null bytes, and do not really consume your storage. Enabling this feature will also speed up image upload and save network traffic in addition to save space in the backend, as null bytes sequences are not sent over the network. Possible Values: * True * False Related options: * None """), ] class StoreLocation(location.StoreLocation): """ Class describing a RBD URI. This is of the form: rbd://image or rbd://fsid/pool/image/snapshot """ def process_specs(self): # convert to ascii since librbd doesn't handle unicode for key, value in self.specs.items(): self.specs[key] = str(value) self.fsid = self.specs.get('fsid') self.pool = self.specs.get('pool') self.image = self.specs.get('image') self.snapshot = self.specs.get('snapshot') def get_uri(self): if self.fsid and self.pool and self.snapshot: # ensure nothing contains / or any other url-unsafe character safe_fsid = urllib.parse.quote(self.fsid, '') safe_pool = urllib.parse.quote(self.pool, '') safe_image = urllib.parse.quote(self.image, '') safe_snapshot = urllib.parse.quote(self.snapshot, '') return "rbd://%s/%s/%s/%s" % (safe_fsid, safe_pool, safe_image, safe_snapshot) else: return "rbd://%s" % self.image def parse_uri(self, uri): prefix = 'rbd://' self.validate_schemas(uri, valid_schemas=(prefix,)) # convert to ascii since librbd doesn't handle unicode try: ascii_uri = str(uri) except UnicodeError: reason = _('URI contains non-ascii characters') msg = _LI("Invalid URI: %s") % reason LOG.info(msg) raise exceptions.BadStoreUri(message=reason) pieces = ascii_uri[len(prefix):].split('/') if len(pieces) == 1: self.fsid, self.pool, self.image, self.snapshot = \ (None, None, pieces[0], None) elif len(pieces) == 4: self.fsid, self.pool, self.image, self.snapshot = \ map(urllib.parse.unquote, pieces) else: reason = _('URI must have exactly 1 or 4 components') msg = _LI("Invalid URI: %s") % reason LOG.info(msg) raise exceptions.BadStoreUri(message=reason) if any(map(lambda p: p == '', pieces)): reason = _('URI cannot contain empty components') msg = _LI("Invalid URI: %s") % reason LOG.info(msg) raise exceptions.BadStoreUri(message=reason) class ImageIterator(object): """ Reads data from an RBD image, one chunk at a time. """ def __init__(self, pool, name, snapshot, store, chunk_size=None): self.pool = pool or store.pool self.name = name self.snapshot = snapshot self.user = store.user self.conf_file = store.conf_file self.chunk_size = chunk_size or store.READ_CHUNKSIZE self.store = store def __iter__(self): try: with self.store.get_connection(conffile=self.conf_file, rados_id=self.user) as conn: with conn.open_ioctx(self.pool) as ioctx: with rbd.Image(ioctx, self.name, snapshot=self.snapshot) as image: size = image.size() bytes_left = size while bytes_left > 0: length = min(self.chunk_size, bytes_left) data = image.read(size - bytes_left, length) bytes_left -= len(data) yield data return except rbd.ImageNotFound: raise exceptions.NotFound( _('RBD image %s does not exist') % self.name) class Store(driver.Store): """An implementation of the RBD backend adapter.""" _CAPABILITIES = capabilities.BitMasks.RW_ACCESS OPTIONS = _RBD_OPTS EXAMPLE_URL = "rbd://///" def __init__(self, *args, **kargs): super(Store, self).__init__(*args, **kargs) if self.backend_group: self.store_conf = driver.BackendGroupConfiguration( self.OPTIONS, self.backend_group, conf=self.conf) else: self.store_conf = self.conf.glance_store def get_schemes(self): return ('rbd',) def RBDProxy(self): if eventletutils.is_monkey_patched('thread'): return tpool.Proxy(rbd.RBD()) else: return rbd.RBD() @contextlib.contextmanager def get_connection(self, conffile, rados_id): client = rados.Rados(conffile=conffile, rados_id=rados_id) timeout = self.store_conf.rados_connect_timeout if timeout >= 0: t = str(timeout) client.conf_set('rados_osd_op_timeout', t) client.conf_set('rados_mon_op_timeout', t) client.conf_set('client_mount_timeout', t) try: client.connect() except (rados.Error, rados.ObjectNotFound) as e: if self.backend_group and len(self.conf.enabled_backends) > 1: reason = _("Error in store configuration: %s") % e LOG.debug(reason) raise exceptions.BadStoreConfiguration( store_name=self.backend_group, reason=reason) else: msg = _LE("Error connecting to ceph cluster.") LOG.exception(msg) raise exceptions.BackendException() try: yield client finally: client.shutdown() def configure_add(self): """ Configure the Store to use the stored configuration options Any store that needs special configuration should implement this method. If the store was not able to successfully configure itself, it should raise `exceptions.BadStoreConfiguration` """ if rbd is None or rados is None: reason = _("The required libraries(rbd and rados) are not " "available") LOG.error(reason) raise exceptions.BadStoreConfiguration(store_name='rbd', reason=reason) try: chunk = self.store_conf.rbd_store_chunk_size pool = self.store_conf.rbd_store_pool user = self.store_conf.rbd_store_user conf_file = self.store_conf.rbd_store_ceph_conf thin_provisioning = self.store_conf.rbd_thin_provisioning self.thin_provisioning = thin_provisioning self.chunk_size = chunk * units.Mi self.READ_CHUNKSIZE = self.chunk_size self.WRITE_CHUNKSIZE = self.READ_CHUNKSIZE # these must not be unicode since they will be passed to a # non-unicode-aware C library self.pool = str(pool) self.user = str(user) self.conf_file = str(conf_file) except cfg.ConfigFileValueError as e: reason = _("Error in store configuration: %s") % e LOG.error(reason) raise exceptions.BadStoreConfiguration(store_name='rbd', reason=reason) if self.backend_group: self._set_url_prefix() self.size = 0 self.resize_amount = self.WRITE_CHUNKSIZE def _set_url_prefix(self): fsid = None with self.get_connection(conffile=self.conf_file, rados_id=self.user) as conn: if hasattr(conn, 'get_fsid'): fsid = encodeutils.safe_decode(conn.get_fsid()) if fsid and self.pool: # ensure nothing contains / or any other url-unsafe character safe_fsid = urllib.parse.quote(fsid, '') safe_pool = urllib.parse.quote(self.pool, '') self._url_prefix = "rbd://%s/%s/" % (safe_fsid, safe_pool) else: self._url_prefix = "rbd://" @capabilities.check def get(self, location, offset=0, chunk_size=None, context=None): """ Takes a `glance_store.location.Location` object that indicates where to find the image file, and returns a tuple of generator (for reading the image file) and image_size :param location: `glance_store.location.Location` object, supplied from glance_store.location.get_location_from_uri() :raises: `glance_store.exceptions.NotFound` if image does not exist """ loc = location.store_location return (ImageIterator(loc.pool, loc.image, loc.snapshot, self), self.get_size(location)) def get_size(self, location, context=None): """ Takes a `glance_store.location.Location` object that indicates where to find the image file, and returns the size :param location: `glance_store.location.Location` object, supplied from glance_store.location.get_location_from_uri() :raises: `glance_store.exceptions.NotFound` if image does not exist """ loc = location.store_location # if there is a pool specific in the location, use it; otherwise # we fall back to the default pool specified in the config target_pool = loc.pool or self.pool with self.get_connection(conffile=self.conf_file, rados_id=self.user) as conn: with conn.open_ioctx(target_pool) as ioctx: try: with rbd.Image(ioctx, loc.image, snapshot=loc.snapshot) as image: img_info = image.stat() return img_info['size'] except rbd.ImageNotFound: msg = _('RBD image %s does not exist') % loc.get_uri() LOG.debug(msg) raise exceptions.NotFound(msg) def _create_image(self, fsid, conn, ioctx, image_name, size, order, context=None): """ Create an rbd image. If librbd supports it, make it a cloneable snapshot, so that copy-on-write volumes can be created from it. :param image_name: Image's name :returns: `glance_store.rbd.StoreLocation` object """ features = conn.conf_get('rbd_default_features') if ((features is None) or (int(features) == 0)): features = rbd.RBD_FEATURE_LAYERING self.RBDProxy().create(ioctx, image_name, size, order, old_format=False, features=int(features)) return StoreLocation({ 'fsid': fsid, 'pool': self.pool, 'image': image_name, 'snapshot': DEFAULT_SNAPNAME, }, self.conf) def _delete_image(self, target_pool, image_name, snapshot_name=None, context=None): """ Delete RBD image and snapshot. :param image_name: Image's name :param snapshot_name: Image snapshot's name :raises: NotFound if image does not exist; InUseByStore if image is in use or snapshot unprotect failed """ with self.get_connection(conffile=self.conf_file, rados_id=self.user) as conn: with conn.open_ioctx(target_pool) as ioctx: try: # First remove snapshot. if snapshot_name is not None: with rbd.Image(ioctx, image_name) as image: try: self._unprotect_snapshot(image, snapshot_name) image.remove_snap(snapshot_name) except rbd.ImageNotFound as exc: msg = (_("Snap Operating Exception " "%(snap_exc)s " "Snapshot does not exist.") % {'snap_exc': exc}) LOG.debug(msg) except rbd.ImageBusy as exc: log_msg = (_LW("Snap Operating Exception " "%(snap_exc)s " "Snapshot is in use.") % {'snap_exc': exc}) LOG.warning(log_msg) raise exceptions.InUseByStore() # Then delete image. self.RBDProxy().remove(ioctx, image_name) except rbd.ImageHasSnapshots: log_msg = (_LW("Unable to remove image %(img_name)s: it " "has snapshot(s) left; trashing instead") % {'img_name': image_name}) LOG.warning(log_msg) with rbd.Image(ioctx, image_name) as image: try: rbd.RBD().trash_move(ioctx, image_name) LOG.debug('Moved %s to trash', image_name) except rbd.ImageBusy: LOG.warning(_('Unable to move in-use image to ' 'trash')) raise exceptions.InUseByStore() return raise exceptions.HasSnapshot() except rbd.ImageBusy: log_msg = (_LW("Remove image %(img_name)s failed. " "It is in use.") % {'img_name': image_name}) LOG.warning(log_msg) raise exceptions.InUseByStore() except rbd.ImageNotFound: msg = _("RBD image %s does not exist") % image_name raise exceptions.NotFound(message=msg) def _unprotect_snapshot(self, image, snap_name): try: image.unprotect_snap(snap_name) except rbd.InvalidArgument: # NOTE(slaweq): if snapshot was unprotected already, rbd library # raises InvalidArgument exception without any "clear" message. # Such exception is not dangerous for us so it will be just logged LOG.debug("Snapshot %s is unprotected already" % snap_name) def _resize_on_write(self, image, image_size, bytes_written, chunk_length): """Handle the rbd resize when needed.""" if image_size != 0 or self.size >= bytes_written + chunk_length: return self.size # Note(jokke): We double how much we grow the image each time # up to 8gigs to avoid resizing for each write on bigger images self.resize_amount = min(self.resize_amount * 2, 8 * units.Gi) new_size = self.size + self.resize_amount LOG.debug("resizing image to %s KiB" % (new_size / units.Ki)) image.resize(new_size) return new_size @driver.back_compat_add @capabilities.check def add(self, image_id, image_file, image_size, hashing_algo, context=None, verifier=None): """ Stores an image file with supplied identifier to the backend storage system and returns a tuple containing information about the stored image. :param image_id: The opaque image identifier :param image_file: The image data to write, as a file-like object :param image_size: The size of the image data to write, in bytes :param hashing_algo: A hashlib algorithm identifier (string) :param context: A context object :param verifier: An object used to verify signatures for images :returns: tuple of: (1) URL in backing store, (2) bytes written, (3) checksum, (4) multihash value, and (5) a dictionary with storage system specific information :raises: `glance_store.exceptions.Duplicate` if the image already exists """ os_hash_value = utils.get_hasher(hashing_algo, False) checksum = utils.get_hasher('md5', False) image_name = str(image_id) with self.get_connection(conffile=self.conf_file, rados_id=self.user) as conn: fsid = None if hasattr(conn, 'get_fsid'): # Librados's get_fsid is represented as binary # in py3 instead of str as it is in py2. # This is causing problems with ceph. # Decode binary to str fixes these issues. # Fix with encodeutils.safe_decode CAN BE REMOVED # after librados's fix will be stable. # # More information: # https://bugs.launchpad.net/glance-store/+bug/1816721 # https://bugs.launchpad.net/cinder/+bug/1816468 # https://tracker.ceph.com/issues/38381 fsid = encodeutils.safe_decode(conn.get_fsid()) with conn.open_ioctx(self.pool) as ioctx: order = int(math.log(self.WRITE_CHUNKSIZE, 2)) LOG.debug('creating image %s with order %d and size %d', image_name, order, image_size) if image_size == 0: LOG.warning(_LW("Since image size is zero we will be " "doing resize-before-write which will be " "slower than normal")) try: loc = self._create_image(fsid, conn, ioctx, image_name, image_size, order) except rbd.ImageExists: msg = _('RBD image %s already exists') % image_id raise exceptions.Duplicate(message=msg) try: with rbd.Image(ioctx, image_name) as image: bytes_written = 0 offset = 0 chunks = utils.chunkreadable(image_file, self.WRITE_CHUNKSIZE) for chunk in chunks: # NOTE(jokke): If we don't know image size we need # to resize it on write. The resize amount will # ramp up to 8 gigs. chunk_length = len(chunk) self.size = self._resize_on_write(image, image_size, bytes_written, chunk_length) bytes_written += chunk_length # Check if writing this chunk exceeds the # image_size if image_size != 0 and bytes_written > image_size: raise exceptions.Invalid( _("Size exceeds: expected %(expected)d " "bytes, got %(actual)d bytes") % {'expected': image_size, 'actual': bytes_written}) if not (self.thin_provisioning and not any(chunk)): image.write(chunk, offset) offset += chunk_length os_hash_value.update(chunk) checksum.update(chunk) if verifier: verifier.update(chunk) # Lets trim the image in case we overshoot with resize if image_size == 0: image.resize(bytes_written) if loc.snapshot: image.create_snap(loc.snapshot) image.protect_snap(loc.snapshot) except rbd.NoSpace: log_msg = (_LE("Failed to store image %(img_name)s " "insufficient space available") % {'img_name': image_name}) LOG.error(log_msg) # Delete image if one was created try: target_pool = loc.pool or self.pool self._delete_image(target_pool, loc.image, loc.snapshot) except exceptions.NotFound: pass raise exceptions.StorageFull(message=log_msg) except rbd.IncompleteWriteError as exc: log_msg = (_LE("Failed to store image %(img_name)s " "image data exceeded the expected size. " "Store Exception %(store_exc)s") % {'img_name': image_name, 'store_exc': exc}) LOG.error(log_msg) # Delete image if one was created try: target_pool = loc.pool or self.pool self._delete_image(target_pool, loc.image, loc.snapshot) except exceptions.NotFound: pass raise exceptions.Invalid(message=log_msg) except Exception as exc: log_msg = (_LE("Failed to store image %(img_name)s " "Store Exception %(store_exc)s") % {'img_name': image_name, 'store_exc': exc}) LOG.error(log_msg) # Delete image if one was created try: target_pool = loc.pool or self.pool self._delete_image(target_pool, loc.image, loc.snapshot) except exceptions.NotFound: pass raise exc # If actual bytes written are less than image_size # (when image_size != 0), update accordingly if image_size != 0 and bytes_written != image_size: # Delete image if one was created try: self._delete_image(loc.pool or self.pool, loc.image, loc.snapshot) except exceptions.NotFound: pass raise exceptions.Invalid(_( "Size mismatch: expected %(expected)d " "bytes, got %(actual)d bytes") % { 'expected': image_size, 'actual': bytes_written}) # Add store backend information to location metadata metadata = {} if self.backend_group: metadata['store'] = self.backend_group return (loc.get_uri(), bytes_written, checksum.hexdigest(), os_hash_value.hexdigest(), metadata) @capabilities.check def delete(self, location, context=None): """ Takes a `glance_store.location.Location` object that indicates where to find the image file to delete. :param location: `glance_store.location.Location` object, supplied from glance_store.location.get_location_from_uri() :raises: NotFound if image does not exist; InUseByStore if image is in use or snapshot unprotect failed """ loc = location.store_location target_pool = loc.pool or self.pool self._delete_image(target_pool, loc.image, loc.snapshot)