def _check_dependency_add_dependent_list(self):
specs = [
{'name': 'A01', 'target': 'cluster_001'},
{'name': 'A02', 'target': 'node_001'},
{'name': 'A03', 'target': 'node_002'},
{'name': 'A04', 'target': 'node_003'},
]
id_of = {}
for spec in specs:
action = _create_action(self.ctx, **spec)
id_of[spec['name']] = action.id
db_api.dependency_add(self.ctx,
id_of['A01'],
[id_of['A02'], id_of['A03'], id_of['A04']])
res = db_api.dependency_get_dependents(self.ctx, id_of['A01'])
self.assertEqual(3, len(res))
self.assertIn(id_of['A02'], res)
self.assertIn(id_of['A03'], res)
self.assertIn(id_of['A04'], res)
res = db_api.dependency_get_depended(self.ctx, id_of['A01'])
self.assertEqual(0, len(res))
for aid in [id_of['A02'], id_of['A03'], id_of['A04']]:
res = db_api.dependency_get_depended(self.ctx, aid)
self.assertEqual(1, len(res))
self.assertIn(id_of['A01'], res)
res = db_api.dependency_get_dependents(self.ctx, aid)
self.assertEqual(0, len(res))
action = db_api.action_get(self.ctx, aid)
self.assertEqual(action.status, consts.ACTION_WAITING)
return id_of
def test_action_check_status(self):
specs = [
{'name': 'A01', 'target': 'cluster_001'},
{'name': 'A02', 'target': 'node_001'},
]
id_of = {}
for spec in specs:
action = _create_action(self.ctx, **spec)
id_of[spec['name']] = action.id
db_api.dependency_add(self.ctx, id_of['A02'], id_of['A01'])
action1 = db_api.action_get(self.ctx, id_of['A01'])
self.assertEqual(consts.ACTION_WAITING, action1.status)
timestamp = time.time()
status = db_api.action_check_status(self.ctx, id_of['A01'], timestamp)
self.assertEqual(consts.ACTION_WAITING, status)
status = db_api.action_check_status(self.ctx, id_of['A01'], timestamp)
self.assertEqual(consts.ACTION_WAITING, status)
timestamp = time.time()
db_api.action_mark_succeeded(self.ctx, id_of['A02'], timestamp)
status = db_api.action_check_status(self.ctx, id_of['A01'], timestamp)
self.assertEqual(consts.ACTION_READY, status)
action1 = db_api.action_get(self.ctx, id_of['A01'])
self.assertEqual('All depended actions completed.',
action1.status_reason)
self.assertEqual(timestamp, action1.end_time)
def _check_dependency_add_dependent_list(self):
specs = [
{'name': 'A01', 'target': 'cluster_001'},
{'name': 'A02', 'target': 'node_001'},
{'name': 'A03', 'target': 'node_002'},
{'name': 'A04', 'target': 'node_003'},
]
id_of = {}
for spec in specs:
action = _create_action(self.ctx, **spec)
id_of[spec['name']] = action.id
db_api.dependency_add(self.ctx,
id_of['A01'],
[id_of['A02'], id_of['A03'], id_of['A04']])
res = db_api.dependency_get_dependents(self.ctx, id_of['A01'])
self.assertEqual(3, len(res))
self.assertIn(id_of['A02'], res)
self.assertIn(id_of['A03'], res)
self.assertIn(id_of['A04'], res)
res = db_api.dependency_get_depended(self.ctx, id_of['A01'])
self.assertEqual(0, len(res))
for aid in [id_of['A02'], id_of['A03'], id_of['A04']]:
res = db_api.dependency_get_depended(self.ctx, aid)
self.assertEqual(1, len(res))
self.assertIn(id_of['A01'], res)
res = db_api.dependency_get_dependents(self.ctx, aid)
self.assertEqual(0, len(res))
action = db_api.action_get(self.ctx, aid)
self.assertEqual(action.status, consts.ACTION_WAITING)
return id_of
def test_action_check_status(self):
specs = [
{'name': 'A01', 'target': 'cluster_001'},
{'name': 'A02', 'target': 'node_001'},
]
id_of = {}
for spec in specs:
action = _create_action(self.ctx, **spec)
id_of[spec['name']] = action.id
db_api.dependency_add(self.ctx, id_of['A02'], id_of['A01'])
action1 = db_api.action_get(self.ctx, id_of['A01'])
self.assertEqual(consts.ACTION_WAITING, action1.status)
timestamp = time.time()
status = db_api.action_check_status(self.ctx, id_of['A01'], timestamp)
self.assertEqual(consts.ACTION_WAITING, status)
status = db_api.action_check_status(self.ctx, id_of['A01'], timestamp)
self.assertEqual(consts.ACTION_WAITING, status)
timestamp = time.time()
db_api.action_mark_succeeded(self.ctx, id_of['A02'], timestamp)
status = db_api.action_check_status(self.ctx, id_of['A01'], timestamp)
self.assertEqual(consts.ACTION_READY, status)
action1 = db_api.action_get(self.ctx, id_of['A01'])
self.assertEqual('All depended actions completed.',
action1.status_reason)
self.assertEqual(round(timestamp, 6), float(action1.end_time))
def _prepare_action_mark_failed_cancel(self):
specs = [
{'name': 'A01', 'status': 'INIT', 'target': 'cluster_001'},
{'name': 'A02', 'status': 'INIT', 'target': 'node_001'},
{'name': 'A03', 'status': 'INIT', 'target': 'node_002'},
{'name': 'A04', 'status': 'INIT', 'target': 'node_003'},
{'name': 'A05', 'status': 'INIT', 'target': 'cluster_002'},
{'name': 'A06', 'status': 'INIT', 'target': 'cluster_003'},
{'name': 'A07', 'status': 'INIT', 'target': 'cluster_004'},
]
id_of = {}
for spec in specs:
action = _create_action(self.ctx, **spec)
id_of[spec['name']] = action.id
db_api.dependency_add(self.ctx,
[id_of['A02'], id_of['A03'], id_of['A04']],
id_of['A01'])
db_api.dependency_add(self.ctx,
id_of['A01'],
[id_of['A05'], id_of['A06'], id_of['A07']])
res = db_api.dependency_get_depended(self.ctx, id_of['A01'])
self.assertEqual(3, len(res))
self.assertIn(id_of['A02'], res)
self.assertIn(id_of['A03'], res)
self.assertIn(id_of['A04'], res)
action = db_api.action_get(self.ctx, id_of['A01'])
self.assertEqual(consts.ACTION_WAITING, action.status)
for aid in [id_of['A02'], id_of['A03'], id_of['A04']]:
res = db_api.dependency_get_dependents(self.ctx, aid)
self.assertEqual(1, len(res))
self.assertIn(id_of['A01'], res)
res = db_api.dependency_get_depended(self.ctx, aid)
self.assertEqual(0, len(res))
res = db_api.dependency_get_dependents(self.ctx, id_of['A01'])
self.assertEqual(3, len(res))
self.assertIn(id_of['A05'], res)
self.assertIn(id_of['A06'], res)
self.assertIn(id_of['A07'], res)
for aid in [id_of['A05'], id_of['A06'], id_of['A07']]:
res = db_api.dependency_get_depended(self.ctx, aid)
self.assertEqual(1, len(res))
self.assertIn(id_of['A01'], res)
res = db_api.dependency_get_dependents(self.ctx, aid)
self.assertEqual(0, len(res))
action = db_api.action_get(self.ctx, aid)
self.assertEqual(consts.ACTION_WAITING, action.status)
return id_of
def _prepare_action_mark_failed_cancel(self):
specs = [
{'name': 'A01', 'status': 'INIT', 'target': 'cluster_001'},
{'name': 'A02', 'status': 'INIT', 'target': 'node_001'},
{'name': 'A03', 'status': 'INIT', 'target': 'node_002'},
{'name': 'A04', 'status': 'INIT', 'target': 'node_003'},
{'name': 'A05', 'status': 'INIT', 'target': 'cluster_002'},
{'name': 'A06', 'status': 'INIT', 'target': 'cluster_003'},
{'name': 'A07', 'status': 'INIT', 'target': 'cluster_004'},
]
id_of = {}
for spec in specs:
action = _create_action(self.ctx, **spec)
id_of[spec['name']] = action.id
db_api.dependency_add(self.ctx,
[id_of['A02'], id_of['A03'], id_of['A04']],
id_of['A01'])
db_api.dependency_add(self.ctx,
id_of['A01'],
[id_of['A05'], id_of['A06'], id_of['A07']])
res = db_api.dependency_get_depended(self.ctx, id_of['A01'])
self.assertEqual(3, len(res))
self.assertIn(id_of['A02'], res)
self.assertIn(id_of['A03'], res)
self.assertIn(id_of['A04'], res)
action = db_api.action_get(self.ctx, id_of['A01'])
self.assertEqual(consts.ACTION_WAITING, action.status)
for aid in [id_of['A02'], id_of['A03'], id_of['A04']]:
res = db_api.dependency_get_dependents(self.ctx, aid)
self.assertEqual(1, len(res))
self.assertIn(id_of['A01'], res)
res = db_api.dependency_get_depended(self.ctx, aid)
self.assertEqual(0, len(res))
res = db_api.dependency_get_dependents(self.ctx, id_of['A01'])
self.assertEqual(3, len(res))
self.assertIn(id_of['A05'], res)
self.assertIn(id_of['A06'], res)
self.assertIn(id_of['A07'], res)
for aid in [id_of['A05'], id_of['A06'], id_of['A07']]:
res = db_api.dependency_get_depended(self.ctx, aid)
self.assertEqual(1, len(res))
self.assertIn(id_of['A01'], res)
res = db_api.dependency_get_dependents(self.ctx, aid)
self.assertEqual(0, len(res))
action = db_api.action_get(self.ctx, aid)
self.assertEqual(consts.ACTION_WAITING, action.status)
return id_of
def test_mult_engine_keep_node_scope_lock(self):
engine1 = UUID1
engine2 = UUID2
node2 = shared.create_node(self.ctx, self.cluster, self.profile)
c_action = shared.create_action(self.ctx, target=self.cluster.id,
status='WAITING', owner=engine1,
project=self.ctx.project_id)
n_action_1 = shared.create_action(self.ctx, target=self.node.id,
status='RUNNING', owner=engine1,
project=self.ctx.project_id)
n_action_2 = shared.create_action(self.ctx, target=node2.id,
status='RUNNING', owner=engine2,
project=self.ctx.project_id)
db_api.dependency_add(self.ctx, [n_action_1.id, n_action_2.id],
c_action.id)
db_api.cluster_lock_acquire(self.cluster.id, c_action.id, -1)
db_api.cluster_lock_acquire(self.cluster.id, n_action_1.id, 1)
db_api.cluster_lock_acquire(self.cluster.id, n_action_2.id, 1)
db_api.node_lock_acquire(self.node.id, n_action_1.id)
db_api.node_lock_acquire(node2.id, n_action_2.id)
# do it
db_api.dummy_gc(engine1)
# try to acquire cluster scope lock
observed = db_api.cluster_lock_acquire(self.cluster.id, UUID3, -1)
self.assertIn(UUID3, observed)
self.assertEqual(1, len(observed))
# try to acquire node scope lock
UUID4 = uuidutils.generate_uuid()
observed = db_api.cluster_lock_acquire(self.node.id, UUID4, 1)
self.assertIn(UUID4, observed)
self.assertEqual(1, len(observed))
# node scope lock will be also released
UUID5 = uuidutils.generate_uuid()
observed = db_api.cluster_lock_acquire(node2.id, UUID5, 1)
self.assertIn(UUID5, observed)
self.assertEqual(1, len(observed))
# try to acquire node lock
UUID6 = uuidutils.generate_uuid()
observed = db_api.node_lock_acquire(self.node.id, UUID6)
self.assertEqual(UUID6, observed)
# node locks for actions owned by other engines are still there
UUID7 = uuidutils.generate_uuid()
observed = db_api.node_lock_acquire(node2.id, UUID7)
self.assertNotEqual(UUID7, observed)
self.assertEqual(n_action_2.id, observed)
# check dependency
dependents = db_api.dependency_get_depended(self.ctx, c_action.id)
self.assertEqual(0, len(dependents))
# check action status
new_c_action = db_api.action_get(self.ctx, c_action.id)
self.assertEqual('FAILED', new_c_action.status)
self.assertIsNone(new_c_action.owner)
new_n_action_1 = db_api.action_get(self.ctx, n_action_1.id)
self.assertEqual('FAILED', new_n_action_1.status)
self.assertIsNone(new_n_action_1.owner)
new_n_action_2 = db_api.action_get(self.ctx, n_action_2.id)
self.assertEqual('FAILED', new_n_action_2.status)
self.assertIsNone(new_n_action_2.owner)
