def _catch_up_logs(self, added, updated, removed):
# Create new session and populate the hashtrees
session = api.get_session(autocommit=True, expire_on_commit=True,
use_slave=False)
store = aim_store.SqlAlchemyStore(session)
ht_db_l.HashTreeDbListener(
aim_manager.AimManager()).catch_up_with_action_log(store)
def _initialize_hooks(self):
self.register_before_session_flush_callback(
'hashtree_db_listener_on_commit',
ht_db_l.HashTreeDbListener(aim_manager.AimManager()).on_commit)
self.register_after_transaction_ends_callback(
'tree_creation_postcommit',
rpc.AIDEventRpcApi().tree_creation_postcommit)
def _initialize_hooks(self):
self._hashtree_db_listener = ht_db_l.HashTreeDbListener(
aim_manager.AimManager())
self.register_update_listener('hashtree_db_listener_on_commit',
self._hashtree_db_listener.on_commit)
self.register_postcommit_listener(
'tree_creation_postcommit',
rpc.AIDEventRpcApi().tree_creation_postcommit)
def observe(self):
# TODO(ivar): move this to a separate thread and add scheduled reset
# mechanism
hashtree_db_listener.HashTreeDbListener(
self.manager).catch_up_with_action_log(self.context.store,
self._served_tenants)
# REVISIT(ivar): what if a root is marked as needs_reset? we could
# avoid syncing it altogether
self._state.update(self.get_optimized_state(self.state))
def observe(self, context):
# TODO(ivar): move this to a separate thread and add scheduled reset
# mechanism
served_tenants = copy.deepcopy(self._served_tenants)
# TODO(ivar): object based reset scheduling would be more correct
# to prevent objects from being re-tried too soon.
# This will require working with the DB timestamp and proper range
# query design.
htdbl = hashtree_db_listener.HashTreeDbListener(self.manager)
if utils.get_time() > self._scheduled_recovery:
for root in served_tenants:
self.manager.recover_root_errors(context, root)
htdbl.cleanup_zombie_status_objects(context, served_tenants)
self.schedule_next_recovery()
htdbl.catch_up_with_action_log(context.store, served_tenants)
# REVISIT(ivar): what if a root is marked as needs_reset? we could
# avoid syncing it altogether
self._state.update(self.get_optimized_state(context, self.state))
def upgrade(ctx, version):
"""Used for upgrading database."""
version = version or 'head'
ctx.obj['manager'].upgrade(version)
# create common tenant
aim_ctx = context.AimContext(store=api.get_store(expire_on_commit=True))
aim_mgr = aim_manager.AimManager()
common_tenant = resource.Tenant(name='common', monitored=True)
if not aim_mgr.get(aim_ctx, common_tenant):
aim_mgr.create(aim_ctx, common_tenant)
fix_no_nat_l3out_ownership(aim_ctx)
click.echo('Rebuilding hash-trees')
# reset hash-trees to account for schema/converter changes
listener = hashtree_db_listener.HashTreeDbListener(aim_mgr)
listener.reset(aim_ctx.store)
def setUp(self):
super(TestHashTreeDbListenerNoMockStore, self).setUp(mock_store=False)
self.tt_mgr = tree_manager.HashTreeManager()
self.mgr = aim_manager.AimManager()
self.db_l = ht_db_l.HashTreeDbListener(aim_manager.AimManager())
def setUp(self):
super(TestHashTreeDbListener, self).setUp()
self.tt_mgr = tree_manager.HashTreeManager()
self.mgr = aim_manager.AimManager()
self.db_l = ht_db_l.HashTreeDbListener(aim_manager.AimManager())
def reset(self, context, tenants):
LOG.warn('Reset called for roots %s' % tenants)
for root in tenants:
hashtree_db_listener.HashTreeDbListener(
self.manager).tt_mgr.set_needs_reset_by_root_rn(context, root)
def _reset(ctx, tenant):
mgr = ctx.obj['manager']
aim_ctx = ctx.obj['aim_ctx']
listener = hashtree_db_listener.HashTreeDbListener(mgr)
listener.reset(aim_ctx.store, tenant)
def _reset(aim_mgr):
aim_ctx = context.AimContext(store=api.get_store(expire_on_commit=True))
# reset hash-trees to account for schema/converter changes
listener = hashtree_db_listener.HashTreeDbListener(aim_mgr)
aim_ctx.store.db_session.expunge_all()
listener.reset(aim_ctx.store)
