# Copyright 2018 RedHat 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. import hashlib import logging from oslo_config import cfg from oslo_utils import encodeutils import six from stevedore import driver from stevedore import extension from glance_store import capabilities from glance_store import exceptions from glance_store.i18n import _ from glance_store import location CONF = cfg.CONF LOG = logging.getLogger(__name__) _STORE_OPTS = [ cfg.StrOpt('default_backend', help=_(""" The default scheme to use for storing images. Provide a string value representing the default scheme to use for storing images. If not set, Glance API service will fail to start. Related Options: * enabled_backends """)), cfg.IntOpt('store_capabilities_update_min_interval', default=0, min=0, deprecated_for_removal=True, deprecated_since='Rocky', deprecated_reason=_(""" This option configures a stub method that has not been implemented for any existing store drivers. Hence it is non-operational, and giving it a value does absolutely nothing. This option is scheduled for removal early in the Stein development cycle. """), help=_(""" Minimum interval in seconds to execute updating dynamic storage capabilities based on current backend status. Provide an integer value representing time in seconds to set the minimum interval before an update of dynamic storage capabilities for a storage backend can be attempted. Setting ``store_capabilities_update_min_interval`` does not mean updates occur periodically based on the set interval. Rather, the update is performed at the elapse of this interval set, if an operation of the store is triggered. By default, this option is set to zero and is disabled. Provide an integer value greater than zero to enable this option. NOTE 1: For more information on store capabilities and their updates, please visit: https://specs.openstack.org/openstack/glance-specs/\ specs/kilo/store-capabilities.html For more information on setting up a particular store in your deployment and help with the usage of this feature, please contact the storage driver maintainers listed here: https://docs.openstack.org/glance_store/latest/user/drivers.html NOTE 2: The dynamic store update capability described above is not implemented by any current store drivers. Thus, this option DOES NOT DO ANYTHING (and it never has). It is DEPRECATED and scheduled for removal early in the Stein development cycle. Possible values: * Zero * Positive integer Related Options: * None """)), ] _STORE_CFG_GROUP = 'glance_store' def _list_config_opts(): # NOTE(abhishekk): This separated approach could list # store options before all driver ones, which easier # to generate sampe config file. driver_opts = _list_driver_opts() sample_opts = [(_STORE_CFG_GROUP, _STORE_OPTS)] for store_entry in driver_opts: # NOTE(abhishekk): Do not include no_conf store if store_entry == "no_conf": continue sample_opts.append((store_entry, driver_opts[store_entry])) return sample_opts def _list_driver_opts(): driver_opts = {} mgr = extension.ExtensionManager('glance_store.drivers') # NOTE(zhiyan): Handle available drivers entry_points provided # NOTE(nikhil): Return a sorted list of drivers to ensure that the sample # configuration files generated by oslo config generator retain the order # in which the config opts appear across different runs. If this order of # config opts is not preserved, some downstream packagers may see a long # diff of the changes though not relevant as only order has changed. See # some more details at bug 1619487. drivers = sorted([ext.name for ext in mgr]) handled_drivers = [] # Used to handle backwards-compatible entries for store_entry in drivers: driver_cls = _load_multi_store(None, store_entry, False) if driver_cls and driver_cls not in handled_drivers: if getattr(driver_cls, 'OPTIONS', None) is not None: driver_opts[store_entry] = driver_cls.OPTIONS handled_drivers.append(driver_cls) # NOTE(zhiyan): This separated approach could list # store options before all driver ones, which easier # to read and configure by operator. return driver_opts def register_store_opts(conf): LOG.debug("Registering options for group %s", _STORE_CFG_GROUP) conf.register_opts(_STORE_OPTS, group=_STORE_CFG_GROUP) driver_opts = _list_driver_opts() enabled_backends = conf.enabled_backends for backend in enabled_backends: for opt_list in driver_opts: if enabled_backends[backend] not in opt_list: continue LOG.debug("Registering options for group %s", backend) conf.register_opts(driver_opts[opt_list], group=backend) def _load_multi_store(conf, store_entry, invoke_load=True, backend=None): if backend: invoke_args = [conf, backend] else: invoke_args = [conf] try: LOG.debug("Attempting to import store %s", store_entry) mgr = driver.DriverManager('glance_store.drivers', store_entry, invoke_args=invoke_args, invoke_on_load=invoke_load) return mgr.driver except RuntimeError as e: LOG.warning("Failed to load driver %(driver)s. The " "driver will be disabled", dict(driver=str([driver, e]))) def _load_multi_stores(conf): enabled_backends = conf.enabled_backends for backend, store_entry in enabled_backends.items(): try: # FIXME(flaper87): Don't hide BadStoreConfiguration # exceptions. These exceptions should be propagated # to the user of the library. store_instance = _load_multi_store(conf, store_entry, backend=backend) if not store_instance: continue yield (store_entry, store_instance, backend) except exceptions.BadStoreConfiguration: continue def create_multi_stores(conf=CONF): """Registers all store modules and all schemes from the given config.""" store_count = 0 scheme_map = {} for (store_entry, store_instance, store_identifier) in _load_multi_stores(conf): try: schemes = store_instance.get_schemes() store_instance.configure(re_raise_bsc=False) except NotImplementedError: continue if not schemes: raise exceptions.BackendException( _('Unable to register store %s. No schemes associated ' 'with it.') % store_entry) else: LOG.debug("Registering store %s with schemes %s", store_entry, schemes) loc_cls = store_instance.get_store_location_class() for scheme in schemes: if scheme not in scheme_map: scheme_map[scheme] = {} scheme_map[scheme][store_identifier] = { 'store': store_instance, 'location_class': loc_cls, 'store_entry': store_entry } location.register_scheme_backend_map(scheme_map) store_count += 1 return store_count def verify_store(): store_id = CONF.glance_store.default_backend if not store_id: msg = _("'default_backend' config option is not set.") raise RuntimeError(msg) try: get_store_from_store_identifier(store_id) except exceptions.UnknownScheme: msg = _("Store for identifier %s not found") % store_id raise RuntimeError(msg) def get_store_from_store_identifier(store_identifier): """Determine backing store from identifier. Given a store identifier, return the appropriate store object for handling that scheme. """ scheme_map = {} enabled_backends = CONF.enabled_backends try: scheme = enabled_backends[store_identifier] except KeyError: msg = _("Store for identifier %s not found") % store_identifier raise exceptions.UnknownScheme(msg) if scheme not in location.SCHEME_TO_CLS_BACKEND_MAP: raise exceptions.UnknownScheme(scheme=scheme) scheme_info = location.SCHEME_TO_CLS_BACKEND_MAP[scheme][store_identifier] store = scheme_info['store'] if not store.is_capable(capabilities.BitMasks.DRIVER_REUSABLE): # Driver instance isn't stateless so it can't # be reused safely and need recreation. store_entry = scheme_info['store_entry'] store = _load_multi_store(store.conf, store_entry, invoke_load=True, backend=store_identifier) store.configure() try: loc_cls = store.get_store_location_class() for new_scheme in store.get_schemes(): if new_scheme not in scheme_map: scheme_map[new_scheme] = {} scheme_map[new_scheme][store_identifier] = { 'store': store, 'location_class': loc_cls, 'store_entry': store_entry } location.register_scheme_backend_map(scheme_map) except NotImplementedError: scheme_info['store'] = store return store def add(conf, image_id, data, size, backend, context=None, verifier=None): if not backend: backend = conf.glance_store.default_backend store = get_store_from_store_identifier(backend) return store_add_to_backend(image_id, data, size, store, context, verifier) def add_with_multihash(conf, image_id, data, size, backend, hashing_algo, scheme=None, context=None, verifier=None): if not backend: backend = conf.glance_store.default_backend store = get_store_from_store_identifier(backend) return store_add_to_backend_with_multihash( image_id, data, size, hashing_algo, store, context, verifier) def _check_metadata(store, metadata): if not isinstance(metadata, dict): msg = (_("The storage driver %(driver)s returned invalid " " metadata %(metadata)s. This must be a dictionary type") % dict(driver=str(store), metadata=str(metadata))) LOG.error(msg) raise exceptions.BackendException(msg) try: check_location_metadata(metadata) except exceptions.BackendException as e: e_msg = (_("A bad metadata structure was returned from the " "%(driver)s storage driver: %(metadata)s. %(e)s.") % dict(driver=encodeutils.exception_to_unicode(store), metadata=encodeutils.exception_to_unicode(metadata), e=encodeutils.exception_to_unicode(e))) LOG.error(e_msg) raise exceptions.BackendException(e_msg) def store_add_to_backend(image_id, data, size, store, context=None, verifier=None): """A wrapper around a call to each stores add() method. This gives glance a common place to check the output. :param image_id: The image add to which data is added :param data: The data to be stored :param size: The length of the data in bytes :param store: The store to which the data is being added :param context: The request context :param verifier: An object used to verify signatures for images :param backend: Name of the backend to store the image :return: The url location of the file, the size amount of data, the checksum of the data the storage systems metadata dictionary for the location """ (location, size, checksum, metadata) = store.add(image_id, data, size, context=context, verifier=verifier) if metadata is not None: _check_metadata(store, metadata) return (location, size, checksum, metadata) def store_add_to_backend_with_multihash( image_id, data, size, hashing_algo, store, context=None, verifier=None): """ A wrapper around a call to each store's add() method that requires a hashing_algo identifier and returns a 5-tuple including the "multihash" computed using the specified hashing_algo. (This is an enhanced version of store_add_to_backend(), which is left as-is for backward compatibility.) :param image_id: The image add to which data is added :param data: The data to be stored :param size: The length of the data in bytes :param store: The store to which the data is being added :param hashing_algo: A hashlib algorithm identifier (string) :param context: The request context :param verifier: An object used to verify signatures for images :return: The url location of the file, the size amount of data, the checksum of the data, the multihash of the data, the storage system's metadata dictionary for the location :raises: ``glance_store.exceptions.BackendException`` ``glance_store.exceptions.UnknownHashingAlgo`` """ if hashing_algo not in hashlib.algorithms_available: raise exceptions.UnknownHashingAlgo(algo=hashing_algo) (location, size, checksum, multihash, metadata) = store.add( image_id, data, size, hashing_algo, context=context, verifier=verifier) if metadata is not None: _check_metadata(store, metadata) return (location, size, checksum, multihash, metadata) def check_location_metadata(val, key=''): if isinstance(val, dict): for key in val: check_location_metadata(val[key], key=key) elif isinstance(val, list): ndx = 0 for v in val: check_location_metadata(v, key='%s[%d]' % (key, ndx)) ndx = ndx + 1 elif not isinstance(val, six.text_type): raise exceptions.BackendException(_("The image metadata key %(key)s " "has an invalid type of %(type)s. " "Only dict, list, and unicode are " "supported.") % dict(key=key, type=type(val))) def delete(uri, backend, context=None): """Removes chunks of data from backend specified by uri.""" if backend: loc = location.get_location_from_uri_and_backend( uri, backend, conf=CONF) store = get_store_from_store_identifier(backend) return store.delete(loc, context=context) LOG.warning('Backend is not set to image, searching all backends based on ' 'location URI.') backends = CONF.enabled_backends for backend in backends: try: if not uri.startswith(backends[backend]): continue loc = location.get_location_from_uri_and_backend( uri, backend, conf=CONF) store = get_store_from_store_identifier(backend) return store.delete(loc, context=context) except (exceptions.NotFound, exceptions.UnknownScheme): continue raise exceptions.NotFound(_("Image not found in any configured backend")) def set_acls_for_multi_store(location_uri, backend, public=False, read_tenants=[], write_tenants=None, context=None): if write_tenants is None: write_tenants = [] loc = location.get_location_from_uri_and_backend( location_uri, backend, conf=CONF) store = get_store_from_store_identifier(backend) try: store.set_acls(loc, public=public, read_tenants=read_tenants, write_tenants=write_tenants, context=context) except NotImplementedError: LOG.debug("Skipping store.set_acls... not implemented") def get(uri, backend, offset=0, chunk_size=None, context=None): """Yields chunks of data from backend specified by uri.""" if backend: loc = location.get_location_from_uri_and_backend(uri, backend, conf=CONF) store = get_store_from_store_identifier(backend) return store.get(loc, offset=offset, chunk_size=chunk_size, context=context) LOG.warning('Backend is not set to image, searching all backends based on ' 'location URI.') backends = CONF.enabled_backends for backend in backends: try: if not uri.startswith(backends[backend]): continue loc = location.get_location_from_uri_and_backend( uri, backend, conf=CONF) store = get_store_from_store_identifier(backend) data, size = store.get(loc, offset=offset, chunk_size=chunk_size, context=context) if data: return data, size except (exceptions.NotFound, exceptions.UnknownScheme): continue raise exceptions.NotFound(_("Image not found in any configured backend")) def get_known_schemes_for_multi_store(): """Returns list of known schemes.""" return location.SCHEME_TO_CLS_BACKEND_MAP.keys() def get_size_from_uri_and_backend(uri, backend, context=None): """Retrieves image size from backend specified by uri.""" loc = location.get_location_from_uri_and_backend( uri, backend, conf=CONF) store = get_store_from_store_identifier(backend) return store.get_size(loc, context=context)