def load_pool_images(self, ioctx: rados.Ioctx, epoch: int,
images: Dict[str, Dict[str, Dict[str, str]]]) -> None:
pool_id = str(ioctx.get_pool_id())
pool_name = ioctx.get_pool_name()
images[pool_id] = {}
self.log.debug("load_pool_images: pool={}".format(pool_name))
try:
namespaces = [''] + rbd.RBD().namespace_list(ioctx)
for namespace in namespaces:
if not self.schedules.intersects(
LevelSpec.from_pool_spec(int(pool_id), pool_name,
namespace)):
continue
self.log.debug(
"load_pool_images: pool={}, namespace={}".format(
pool_name, namespace))
images[pool_id][namespace] = {}
ioctx.set_namespace(namespace)
updated = self.watchers.check(pool_id, namespace, epoch)
if not updated:
self.log.debug(
"load_pool_images: {}/{} not updated".format(
pool_name, namespace))
with self.lock:
images[pool_id][namespace] = \
self.images[pool_id][namespace]
continue
mirror_images = dict(rbd.RBD().mirror_image_info_list(
ioctx, rbd.RBD_MIRROR_IMAGE_MODE_SNAPSHOT))
if not mirror_images:
continue
image_names = dict([
(x['id'], x['name'])
for x in filter(lambda x: x['id'] in mirror_images,
rbd.RBD().list2(ioctx))
])
for image_id, info in mirror_images.items():
if not info['primary']:
continue
image_name = image_names.get(image_id)
if not image_name:
continue
if namespace:
name = "{}/{}/{}".format(pool_name, namespace,
image_name)
else:
name = "{}/{}".format(pool_name, image_name)
self.log.debug(
"load_pool_images: adding image {}".format(name))
images[pool_id][namespace][image_id] = name
except Exception as e:
self.log.error(
"load_pool_images: exception when scanning pool {}: {}".format(
pool_name, e))
def load_from_pool(self, ioctx: rados.Ioctx,
namespace_validator: Optional[Callable],
image_validator: Optional[Callable]) -> None:
pool_id = ioctx.get_pool_id()
pool_name = ioctx.get_pool_name()
stale_keys = []
start_after = ''
try:
while True:
with rados.ReadOpCtx() as read_op:
self.handler.log.info(
"load_schedules: {}, start_after={}".format(
pool_name, start_after))
it, ret = ioctx.get_omap_vals(read_op, start_after, "",
128)
ioctx.operate_read_op(read_op, self.handler.SCHEDULE_OID)
it = list(it)
for k, v in it:
start_after = k
v = v.decode()
self.handler.log.info("load_schedule: {} {}".format(
k, v))
try:
try:
level_spec = LevelSpec.from_id(
self.handler, k, namespace_validator,
image_validator)
except ValueError:
self.handler.log.debug(
"Stale schedule key %s in pool %s", k,
pool_name)
stale_keys.append(k)
continue
self.level_specs[level_spec.id] = level_spec
schedule = Schedule.from_json(level_spec.name, v)
self.schedules[level_spec.id] = schedule
except ValueError:
self.handler.log.error(
"Failed to decode schedule: pool={}, {} {}".
format(pool_name, k, v))
if not it:
break
except StopIteration:
pass
except rados.ObjectNotFound:
pass
if stale_keys:
with rados.WriteOpCtx() as write_op:
ioctx.remove_omap_keys(write_op, stale_keys)
ioctx.operate_write_op(write_op, self.handler.SCHEDULE_OID)
def load_pool(self, ioctx: rados.Ioctx, pools: Dict[str, Dict[str, str]]) -> None:
pool_id = str(ioctx.get_pool_id())
pool_name = ioctx.get_pool_name()
pools[pool_id] = {}
pool_namespaces = ['']
self.log.debug("load_pool: {}".format(pool_name))
try:
pool_namespaces += rbd.RBD().namespace_list(ioctx)
except rbd.OperationNotSupported:
self.log.debug("namespaces not supported")
except Exception as e:
self.log.error("exception when scanning pool {}: {}".format(
pool_name, e))
for namespace in pool_namespaces:
pools[pool_id][namespace] = pool_name
