def build_app(*, use_cached=False, config_overrides=None):
from flask import Flask
global _cached_app # pylint: disable=global-statement
global _building # pylint: disable=global-statement
if use_cached and _cached_app is not None:
return _cached_app
if config_overrides is None:
config_overrides = {}
if _building:
raise RuntimeError('Attempted to create an app while an app was already being initialized!')
_building = True
try:
proj = get_project()
_logger.debug('Starting app {.name}...', proj)
_cached_app = Flask(get_project().name, static_folder=None, template_folder=None)
_cached_app.config.update(config_overrides)
proj.configure_app(_cached_app)
gossip.trigger_with_tags('cob.after_configure_app', {'app': _cached_app})
_logger.trace('URL map: {}', _cached_app.url_map)
return _cached_app
finally:
_building = False
def create(cls, system, **fields):
"""
Creates a new object of this type
"""
gossip.trigger_with_tags('infinidat.sdk.pre_creation_data_validation', {'fields': fields, 'system': system, 'cls': cls})
data = cls._get_data_for_post(system, fields)
return cls._create(system, cls.get_url_path(system), data)
def test_set_strict_with_subgroups_and_tags(hook_name):
def handler():
pass
main_group_name = hook_name.partition(".")[0]
gossip.register(handler, hook_name)
with pytest.raises(UndefinedHook):
gossip.get_or_create_group(main_group_name).set_strict()
hook = gossip.define(hook_name, tags=("some_tag", "other_tag"))
illegal_tags_hook = gossip.define(".".join([hook.group.full_name, "hook_with_illegal_tags"]))
gossip.register(handler, illegal_tags_hook.full_name, tags=("fake_tag"))
with pytest.raises(UnsupportedHookTags):
gossip.get_or_create_group(main_group_name).set_strict()
illegal_tags_hook.unregister_all()
gossip.get_or_create_group(main_group_name).set_strict()
with pytest.raises(UnsupportedHookTags):
@gossip.register(hook_name, tags=("fake_tag",))
def handler2(): # pylint: disable=unused-variable
pass
with pytest.raises(UnsupportedHookTags):
gossip.trigger_with_tags(hook_name, tags=("fake_tag",))
gossip.trigger_with_tags(hook_name, tags=("some_tag", "other_tag"))
def delete(self, retain_staging_area=False, force_if_remote_error=False, force_on_target=False, force_if_no_remote_credentials=False):
path = self.get_this_url_path()
if retain_staging_area:
path = path.add_query_param('retain_staging_area', 'true')
if force_if_remote_error:
path = path.add_query_param('force_if_remote_error', 'true')
if force_on_target:
path = path.add_query_param('force_on_target', 'true')
if force_if_no_remote_credentials:
path = path.add_query_param('force_if_no_remote_credentials', 'true')
try:
remote_replica = self.get_remote_replica()
except UnknownSystem:
remote_replica = None
with self._get_delete_context():
resp = self.system.api.delete(path)
if retain_staging_area:
local, remote = self._get_deletion_result(resp.get_result(), remote_replica)
else:
local = remote = None
for snap in local, remote:
if snap is not None:
gossip.trigger_with_tags(
'infinidat.sdk.replica_snapshot_created', {'snapshot': snap}, tags=['infinibox'])
return local, remote
def _possible_api_failure_context(tags):
try:
yield
except APICommandFailed as e:
exc_type, exc_value, exc_tb = sys.exc_info()
gossip.trigger_with_tags('infinidat.sdk.object_operation_failure', {'exception': e}, tags=tags)
reraise(exc_type, exc_value, exc_tb)
def create(cls, system, binder, **fields): # pylint: disable=arguments-differ
hook_tags = cls.get_tags_for_object_operations(system)
gossip.trigger_with_tags('infinidat.sdk.pre_creation_data_validation',
{'fields': fields, 'system': system, 'cls': cls},
tags=hook_tags)
data = get_data_for_object_creation(cls, system, fields)
url = binder.get_url_path()
return cls._create(system, url, data)
def trigger_finish_fork(self, child):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(_FINISH_FORK_HOOK, {
'obj': self._forked_obj,
'child': child
},
tags=hook_tags)
self._forked_obj = None
def _notify_pre_exposure(replica):
if replica is None or not replica.is_in_system():
return
gossip.trigger_with_tags(
'infinidat.sdk.pre_replication_snapshot_expose', {
'source': replica.get_local_entity(),
'system': replica.system
},
tags=replica._get_entity_tags()) # pylint: disable=protected-access
def create(cls, system, **fields):
"""
Creates a new object of this type
"""
hook_tags = cls.get_tags_for_object_operations(system)
gossip.trigger_with_tags('infinidat.sdk.pre_creation_data_validation',
{'fields': fields, 'system': system, 'cls': cls},
tags=hook_tags)
data = get_data_for_object_creation(cls, system, fields)
return cls._create(system, cls.get_url_path(system), data)
def _notify_exposure_failure(replica, exception):
if replica is None or not replica.is_in_system():
return
gossip.trigger_with_tags(
'infinidat.sdk.replication_snapshot_expose_failure', {
'obj': replica,
'exception': exception,
'system': replica.system
},
tags=replica._get_entity_tags()) # pylint: disable=protected-access
def trigger_after_restore(self, source):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags('infinidat.sdk.post_data_restore', {
'source': source,
'target': self
},
tags=hook_tags)
gossip.trigger_with_tags('infinidat.sdk.post_object_restore', {
'source': source,
'target': self
},
tags=hook_tags)
def expose_last_consistent_snapshot(self):
resp = self.system.api.post(self.get_this_url_path().add_path('expose_last_consistent_snapshot')).get_result()
if self.is_consistency_group():
snapshot_id = resp['_local_reclaimed_sg_id']
else:
snapshot_id = resp['entity_pairs'][0]['_local_reclaimed_snapshot_id']
if snapshot_id is None:
return None
returned = self._get_entity_collection().get_by_id_lazy(snapshot_id)
gossip.trigger_with_tags(
'infinidat.sdk.replica_snapshot_created', {'snapshot': returned}, tags=['infinibox'])
return returned
def _update_fields(self, update_dict):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(
'infinidat.sdk.pre_fields_update',
{'source': self, 'fields': update_dict}, tags=hook_tags)
for field_name, field_value in list(iteritems(update_dict)):
try:
field = self.fields[field_name]
except LookupError:
continue
translated_value = field.binding.get_api_value_from_value(
self.system, type(self), self, field_value)
update_dict[field.api_name] = translated_value
if field.api_name != field_name:
update_dict.pop(field_name)
gossip.trigger_with_tags('infinidat.sdk.pre_object_update', {'obj': self, 'data': update_dict},
tags=hook_tags)
try:
res = self.system.api.put(self.get_this_url_path(), data=update_dict)
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags('infinidat.sdk.object_update_failure',
{'obj': self, 'exception': e, 'system': self.system},
tags=hook_tags)
response_dict = res.get_result()
if len(update_dict) == 1 and not isinstance(response_dict, dict):
[key] = update_dict.keys()
response_dict = {key: response_dict}
self.update_field_cache({k: response_dict[k] for k in update_dict if k in response_dict})
gossip.trigger_with_tags('infinidat.sdk.post_object_update',
{'obj': self, 'data': update_dict, 'response_dict': response_dict}, tags=hook_tags)
return res
def trigger_restore_failure(self, source, e):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags('infinidat.sdk.data_restore_failure', {
'source': source,
'target': self,
'exc': e
},
tags=hook_tags)
gossip.trigger_with_tags('infinidat.sdk.object_restore_failure', {
'source': source,
'target': self,
'exc': e
},
tags=hook_tags)
def trigger_begin_fork(self):
assert self._forked_obj is None
if self._is_synced_remote_entity():
remote_entity = self.get_remote_entity()
if remote_entity is not None:
self._forked_obj = self.get_remote_entity()
else:
_logger.debug(
'Could not fetch remote entity for {}. Forking local entity',
self)
self._forked_obj = self
else:
self._forked_obj = self
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(_BEGIN_FORK_HOOK, {'obj': self._forked_obj},
tags=hook_tags)
def _change_type(self, new_type, params=None):
if params is None:
params = {}
old_type = self.get_replication_type().lower()
new_type = new_type.lower()
gossip.trigger_with_tags('infinidat.sdk.pre_replica_change_type', {
'replica': self,
'old_type': old_type,
'new_type': new_type
},
tags=['infinibox'])
try:
url = self.get_this_url_path().add_path('change_type_to_async') if new_type == 'async' \
else self.get_this_url_path().add_path('change_type_to_sync')
self.system.api.post(url, data=params)
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags(
'infinidat.sdk.replica_change_type_failure', {
'replica': self,
'old_type': old_type,
'new_type': new_type,
'exception': e
},
tags=['infinibox'])
gossip.trigger_with_tags('infinidat.sdk.post_replica_change_type', {
'replica': self,
'old_type': old_type,
'new_type': new_type
},
tags=['infinibox'])
self.invalidate_cache()
def _assign_unassign_operation(self, entity, operation_name):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(
'infinidat.sdk.pre_qos_policy_{}'.format(operation_name), {
'qos_policy': self,
'entity': entity
},
tags=hook_tags)
data = {'entity_id': entity.id}
try:
self.system.api.post(
self.get_this_url_path().add_path(operation_name), data=data)
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags(
'infinidat.sdk.qos_policy_{}_failure'.format(
operation_name), {
'exception': e,
'qos_policy': self,
'entity': entity
},
tags=hook_tags)
gossip.trigger_with_tags(
'infinidat.sdk.post_qos_policy_{}'.format(operation_name), {
'qos_policy': self,
'entity': entity
},
tags=['infinibox'])
def _update_fields(self, update_dict):
gossip.trigger_with_tags(
'infinidat.sdk.pre_fields_update',
{'source': self, 'fields': update_dict}, tags=['infinibox'])
for field_name, field_value in list(iteritems(update_dict)):
try:
field = self.fields[field_name]
except LookupError:
continue
translated_value = field.binding.get_api_value_from_value(self.system, type(self), self, field_value)
update_dict[field.api_name] = translated_value
if field.api_name != field_name:
update_dict.pop(field_name)
hook_tags = self._get_tags_for_object_operations(self.system)
gossip.trigger_with_tags('infinidat.sdk.pre_object_update', {'obj': self, 'data': update_dict}, tags=hook_tags)
with _possible_api_failure_context(tags=hook_tags):
res = self.system.api.put(self.get_this_url_path(), data=update_dict)
response_dict = res.get_result()
if len(update_dict) == 1 and not isinstance(response_dict, dict):
[key] = update_dict.keys()
response_dict = {key: response_dict}
self.update_field_cache(response_dict)
gossip.trigger_with_tags('infinidat.sdk.post_object_update',
{'obj': self, 'data': update_dict, 'response_dict': response_dict}, tags=hook_tags)
return res
def _trigger_stage_hooks(base_config, request, stage):
for cluster, installer_type in cluster_installers(base_config, request):
gossip.trigger_with_tags(stage, kwargs=dict(cluster=cluster, request=request), tags=[installer_type])
for host, installer_type in host_installers(base_config, request):
gossip.trigger_with_tags(stage, kwargs=dict(host=host, request=request), tags=[installer_type])
gossip.trigger_with_tags(stage, kwargs=dict(base_config=base_config, request=request), tags=['base_config'])
def expose_last_consistent_snapshot(self):
self._notify_pre_exposure(self)
try:
resp = self.system.api.post(self.get_this_url_path().add_path(
'expose_last_consistent_snapshot')).get_result()
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
self._notify_exposure_failure(self, e)
if self.is_consistency_group():
snapshot_id = resp['_local_reclaimed_sg_id']
else:
snapshot_id = resp['entity_pairs'][0][
'_local_reclaimed_snapshot_id']
if snapshot_id is None:
return None
returned = self._get_entity_collection().get_by_id_lazy(snapshot_id)
gossip.trigger_with_tags('infinidat.sdk.replica_snapshot_created',
{'snapshot': returned},
tags=['infinibox'])
self._notify_post_exposure(self, returned)
gadget.log_operation(self, "expose last consistent snapshot")
return returned
def _get_delete_context(self):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags('infinidat.sdk.pre_object_deletion', {'obj': self}, tags=hook_tags)
try:
yield
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags('infinidat.sdk.object_deletion_failure',
{'obj': self, 'exception': e, 'system': self.system},
tags=hook_tags)
gossip.trigger_with_tags('infinidat.sdk.post_object_deletion', {'obj': self}, tags=hook_tags)
def restore(self, snapshot):
"""Restores this entity from a given snapshot object
"""
snapshot_id = snapshot.id
hook_tags = self._get_tags_for_object_operations(self.system)
restore_url = self.get_this_url_path().add_path('restore')
gossip.trigger_with_tags('infinidat.sdk.pre_data_restore', {'source': snapshot, 'target': self}, tags=hook_tags)
try:
self.system.api.post(restore_url, data=snapshot_id)
except APICommandFailed as e:
gossip.trigger_with_tags('infinidat.sdk.data_restore_failure', {'source': snapshot, 'target': self, 'exc': e}, tags=hook_tags)
raise
gossip.trigger_with_tags('infinidat.sdk.post_data_restore', {'source': snapshot, 'target': self}, tags=hook_tags)
def create(self, *args, **kwargs):
hook_tags = TreeQ.get_tags_for_object_operations(self.system)
hook_data = {'fields': kwargs, 'system': self.system, 'filesystem': self._filesystem}
gossip.trigger_with_tags('infinidat.sdk.pre_treeq_creation', hook_data, tags=hook_tags)
try:
treeq = TreeQ.create(self.system, self, *args, **kwargs)
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
hook_data['exception'] = e
gossip.trigger_with_tags('infinidat.sdk.treeq_creation_failure', hook_data, tags=hook_tags)
hook_data['treeq'] = treeq
gossip.trigger_with_tags('infinidat.sdk.post_treeq_creation', hook_data, tags=hook_tags)
return treeq
def _create(cls, system, url, data, tags=None):
hook_tags = tags or cls._get_tags_for_object_operations(system)
gossip.trigger_with_tags('infinidat.sdk.pre_object_creation', {'data': data, 'system': system, 'cls': cls}, tags=hook_tags)
try:
with _possible_api_failure_context(tags=hook_tags):
returned = system.api.post(url, data=data).get_result()
obj = cls(system, returned)
except Exception as e:
gossip.trigger_with_tags('infinidat.sdk.object_creation_failure',
{'cls': cls, 'system': system, 'data': data, 'exception': e}, tags=hook_tags)
raise
gossip.trigger_with_tags('infinidat.sdk.post_object_creation',
{'obj': obj, 'data': data, 'response_dict': returned}, tags=hook_tags)
return obj
def _create_child(self, name):
self.refresh('has_children')
hook_tags = self._get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(_BEGIN_FORK_HOOK, {'obj': self}, tags=hook_tags)
if not name:
name = self.fields.name.generate_default().generate()
data = {'name': name, 'parent_id': self.get_id()}
try:
child = self._create(self.system, self.get_url_path(self.system), data=data, tags=hook_tags)
except Exception:
gossip.trigger_with_tags(_CANCEL_FORK_HOOK, {'obj': self}, tags=hook_tags)
raise
gossip.trigger_with_tags(_FINISH_FORK_HOOK, {'obj': self, 'child': child}, tags=hook_tags)
self._handle_possible_replication_snapshot(child)
return child
def _create(cls, system, url, data, tags=None):
hook_tags = tags or cls.get_tags_for_object_operations(system)
gossip.trigger_with_tags('infinidat.sdk.pre_object_creation', {'data': data, 'system': system, 'cls': cls},
tags=hook_tags)
try:
returned = system.api.post(url, data=data).get_result()
obj = cls(system, returned)
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags('infinidat.sdk.object_creation_failure',
{'cls': cls, 'system': system, 'data': data, 'exception': e},
tags=hook_tags)
gossip.trigger_with_tags('infinidat.sdk.post_object_creation',
{'obj': obj, 'data': data, 'response_dict': returned}, tags=hook_tags)
gadget.log_entity_creation(entity=obj, params=data)
return obj
def _create_child(self, name=None, write_protected=None, ssd_enabled=None):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags('infinidat.sdk.pre_entity_child_creation', {
'source': self,
'system': self.system
},
tags=hook_tags)
self.invalidate_cache('has_children')
self.trigger_begin_fork()
if not name:
name = self.fields.name.generate_default().generate()
data = {'name': name, 'parent_id': self.get_id()}
if write_protected is not None:
assert self.system.compat.has_writable_snapshots(), \
'write_protected parameter is not supported for this version'
data['write_protected'] = write_protected
if ssd_enabled is not None:
data['ssd_enabled'] = ssd_enabled
try:
child = self._create(self.system,
self.get_url_path(self.system),
data=data,
tags=self.get_tags_for_object_operations(
self.system))
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags('infinidat.sdk.entity_child_failure',
{
'obj': self,
'exception': e,
'system': self.system
},
tags=hook_tags)
self.trigger_cancel_fork()
self.trigger_finish_fork(child)
gossip.trigger_with_tags('infinidat.sdk.post_entity_child_creation', {
'source': self,
'target': child,
'system': self.system
},
tags=hook_tags)
handle_possible_replication_snapshot(child)
return child
def _lock_unlock_operation(self, operation_name):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(
'infinidat.sdk.pre_pool_{}'.format(operation_name), {'pool': self},
tags=hook_tags)
try:
self.system.api.post(
self.get_this_url_path().add_path(operation_name))
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags(
'infinidat.sdk.pool_{}_failure'.format(operation_name), {
'pool': self,
'exception': e
},
tags=hook_tags)
gossip.trigger_with_tags(
'infinidat.sdk.post_pool_{}'.format(operation_name),
{'pool': self},
tags=hook_tags)
def resume(self):
"""Resumes this replica
"""
gossip.trigger_with_tags('infinidat.sdk.pre_replica_resume',
{'replica': self},
tags=['infinibox'])
try:
self.system.api.post(self.get_this_url_path().add_path('resume'))
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags(
'infinidat.sdk.replica_resume_failure', {
'replica': self,
'exception': e
},
tags=['infinibox'])
gossip.trigger_with_tags('infinidat.sdk.post_replica_resume',
{'replica': self},
tags=['infinibox'])
self.invalidate_cache('state')
gadget.log_operation(self, "resume")
def switch_role(self):
"""Switches replica role - sync replicas only
"""
gossip.trigger_with_tags('infinidat.sdk.pre_replica_switch_role',
{'replica': self},
tags=['infinibox'])
try:
self.system.api.post(
self.get_this_url_path().add_path('switch_role'))
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags(
'infinidat.sdk.replica_switch_role_failure', {
'replica': self,
'exception': e
},
tags=['infinibox'])
gossip.trigger_with_tags('infinidat.sdk.post_replica_switch_role',
{'replica': self},
tags=['infinibox'])
self.invalidate_cache()
gadget.log_operation(self, "switch role")
def move_pool(self, target_pool, with_capacity=False):
"""Moves this entity to a new pool, optionally along with its needed capacity
"""
data = dict(pool_id=target_pool.get_id(), with_capacity=with_capacity)
hook_tags = self.get_tags_for_object_operations(self.system)
source_pool = self.get_pool()
gossip.trigger_with_tags('infinidat.sdk.pre_pool_move', {
'obj': self,
'with_capacity': with_capacity,
'system': self.system,
'target_pool': target_pool,
'source_pool': source_pool
},
tags=hook_tags)
try:
self.system.api.post(self.get_this_url_path().add_path('move'),
data=data)
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags('infinidat.sdk.pool_move_failure', {
'obj': self,
'with_capacity': with_capacity,
'system': self.system,
'exception': e,
'target_pool': target_pool,
'source_pool': source_pool
},
tags=hook_tags)
gossip.trigger_with_tags('infinidat.sdk.post_pool_move', {
'obj': self,
'with_capacity': with_capacity,
'system': self.system,
'target_pool': target_pool,
'source_pool': source_pool
},
tags=hook_tags)
def change_role(self, entity_pairs=OMIT):
"""Changes the role of this replica from source to target or vice-versa
"""
data = {
'entity_pairs': entity_pairs
} if entity_pairs is not OMIT else None
gossip.trigger_with_tags('infinidat.sdk.pre_replica_change_role',
{'replica': self},
tags=['infinibox'])
try:
self.system.api.post(
self.get_this_url_path().add_path('change_role'), data=data)
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
gossip.trigger_with_tags(
'infinidat.sdk.replica_change_role_failure', {
'replica': self,
'exception': e
},
tags=['infinibox'])
gossip.trigger_with_tags('infinidat.sdk.post_replica_change_role',
{'replica': self},
tags=['infinibox'])
self.invalidate_cache()
def test_trigger_hook_with_unsupported_tags():
gossip.define('group.some_hook', tags=("some_tag",))
gossip.trigger('group.some_hook', tags=("fake_tag",))
gossip.get_or_create_group('group').set_strict()
with pytest.raises(UnsupportedHookTags):
gossip.trigger_with_tags('group.some_hook', tags=("fake_tag",))
def _get_delete_context(self):
hook_tags = self._get_tags_for_object_operations(self.system)
gossip.trigger_with_tags('infinidat.sdk.pre_object_deletion', {'obj': self}, tags=hook_tags)
with _possible_api_failure_context(hook_tags):
yield
gossip.trigger_with_tags('infinidat.sdk.post_object_deletion', {'obj': self}, tags=hook_tags)
def trigger_begin_fork(self):
hook_tags = self._get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(_BEGIN_FORK_HOOK, {'obj': self}, tags=hook_tags)
def grain(grain_type, name, mountpoint):
_generate(f'grain-{grain_type}', name, {
'name': name,
'mountpoint': mountpoint,
})
gossip.trigger_with_tags('cob.after_generate.grain', tags=[grain_type], kwargs={'name': name})
def delete(self,
retain_staging_area=False,
force_if_remote_error=False,
force_on_target=False,
force_if_no_remote_credentials=False):
"""Deletes this replica
"""
path = self.get_this_url_path()
if retain_staging_area:
path = path.add_query_param('retain_staging_area', 'true')
if force_if_remote_error:
path = path.add_query_param('force_if_remote_error', 'true')
if force_on_target:
path = path.add_query_param('force_on_target', 'true')
if force_if_no_remote_credentials:
path = path.add_query_param('force_if_no_remote_credentials',
'true')
try:
remote_replica = self.get_remote_replica(safe=True)
if remote_replica is None:
_logger.debug(
'Failed to get remote replica during delete operation')
except UnknownSystem:
remote_replica = None
if retain_staging_area:
self._notify_pre_exposure(self)
self._notify_pre_exposure(remote_replica)
gadget.log_entity_deletion(self)
with self._get_delete_context():
try:
resp = self.system.api.delete(path)
entity_pairs = None
result = resp.get_result()
if result:
entity_pairs = result.get('entity_pairs')
gossip.trigger_with_tags('infinidat.sdk.replica_deleted', {
'replica': self,
'entity_pairs': entity_pairs
},
tags=['infinibox'])
except Exception as e: # pylint: disable=broad-except
with end_reraise_context():
if retain_staging_area:
self._notify_exposure_failure(self, e)
self._notify_exposure_failure(remote_replica, e)
if retain_staging_area:
local, remote = self._get_deletion_result(resp.get_result(),
remote_replica)
else:
local = remote = None
for replica, snap in (self, local), (remote_replica, remote):
if snap is not None:
gossip.trigger_with_tags(
'infinidat.sdk.replica_snapshot_created',
{'snapshot': snap},
tags=['infinibox'])
self._notify_post_exposure(replica, snap)
return local, remote
def test_trigger_hook(specify_tags):
if specify_tags:
gossip.trigger_with_tags(_HOOK_NAME, tags=_ACCEPTED_TAGS)
else:
gossip.trigger_with_tags(_HOOK_NAME, tags=())
def trigger_before_restore(self, source):
hook_tags = self._get_tags_for_object_operations(self.system)
gossip.trigger_with_tags('infinidat.sdk.pre_data_restore', {'source': source, 'target': self}, tags=hook_tags)
def test_trigger_hook(specify_tags):
if specify_tags:
gossip.trigger_with_tags(_HOOK_NAME, tags=_ACCEPTED_TAGS)
else:
gossip.trigger_with_tags(_HOOK_NAME, tags=())
def _notify_operation_failed(system, exception, **kwargs):
cls = kwargs.pop('cls', None) or type(kwargs.pop('obj'))
tags = cls.get_tags_for_object_operations(system)
gossip.trigger_with_tags('infinidat.sdk.object_operation_failure', {'exception': exception}, tags=tags)
def trigger_finish_fork(self, child):
hook_tags = self._get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(_FINISH_FORK_HOOK, {'obj': self, 'child': child}, tags=hook_tags)
def test_trigger_with_bad_tags(tags, is_strict):
if not is_strict:
return
with pytest.raises(gossip.exceptions.UnsupportedHookTags):
gossip.trigger_with_tags(_HOOK_NAME, tags=tags)
def trigger_cancel_fork(self):
hook_tags = self.get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(_CANCEL_FORK_HOOK, {'obj': self._forked_obj},
tags=hook_tags)
self._forked_obj = None
def change_role(self, entity_pairs=OMIT):
data = {'entity_pairs': entity_pairs} if entity_pairs is not OMIT else None
self.system.api.post(self.get_this_url_path()
.add_path('change_role'), data=data)
self.refresh()
gossip.trigger_with_tags('infinidat.sdk.replica_after_change_role', {'replica': self}, tags=['infinibox'])
def trigger_cancel_fork(self):
hook_tags = self._get_tags_for_object_operations(self.system)
gossip.trigger_with_tags(_CANCEL_FORK_HOOK, {'obj': self}, tags=hook_tags)
def _handle_possible_replication_snapshot(self, snapshot):
fields = snapshot.get_fields(from_cache=True, raw_value=True)
if fields.get('rmr_snapshot_guid', None) is not None:
gossip.trigger_with_tags('infinidat.sdk.replica_snapshot_created', {'snapshot': snapshot}, tags=['infinibox'])
def test_trigger_with_bad_tags(tags, is_strict):
if not is_strict:
return
with pytest.raises(gossip.exceptions.UnsupportedHookTags):
gossip.trigger_with_tags(_HOOK_NAME, tags=tags)
