def test_discard_all_pending_changes_resources_created():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = DBResource.from_dict('test2',
{'name': 'test2',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res2.inputs['a'] = '0'
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 2
change.discard_all()
staged_log = change.stage_changes()
assert len(staged_log) == 0
assert resource.load_all() == []
def test_concurrent_sequences_with_no_handler(scale, clients):
total_resources = scale * 3
timeout = scale * 2
scheduler_client = clients['scheduler']
assert len(change.staged_log()) == total_resources
ModelMeta.save_all_lazy()
plan = change.send_to_orchestration()
ModelMeta.save_all_lazy()
scheduler_client.next({}, plan.graph['uid'])
def wait_function(timeout):
try:
for summary in wait_finish(plan.graph['uid'], timeout):
assert summary[states.ERROR.name] == 0
time.sleep(0.5)
except ExecutionTimeout:
pass
return summary
waiter = gevent.spawn(wait_function, timeout)
waiter.join(timeout=timeout)
res = waiter.get(block=True)
assert res[states.SUCCESS.name] == total_resources
assert len(data.CL()) == total_resources
clear_cache()
assert len(change.staged_log()) == 0
def test_revert_create():
res = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res.inputs['a'] = '9'
res.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 1
logitem = staged_log[0]
operations.move_to_commited(logitem.log_action)
assert logitem.diff == [['add', '', [['a', '9']]]]
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(logitem.uid)
staged_log = change.stage_changes()
assert len(staged_log) == 1
for item in staged_log:
operations.move_to_commited(item.log_action)
assert resource.load_all() == []
def tagged_resources():
base_tags = ['n1=x', 'n2']
tags = base_tags + ['node=t1']
t1 = Resource.from_dict('t1', {
'name': 't1',
'tags': tags,
'base_path': 'x'
})
t1.save_lazy()
tags = base_tags + ['node=t2']
t2 = Resource.from_dict('t2', {
'name': 't2',
'tags': tags,
'base_path': 'x'
})
t2.save_lazy()
tags = base_tags + ['node=t3']
t3 = Resource.from_dict('t3', {
'name': 't3',
'tags': tags,
'base_path': 'x'
})
t3.save_lazy()
tags = ['node=t3']
t4 = Resource.from_dict('t4', {
'name': 't4',
'tags': tags,
'base_path': 'x'
})
t4.save_lazy()
ModelMeta.save_all_lazy()
return [t1, t2, t3]
def create_plan_from_graph(dg):
dg.graph['uid'] = "{0}:{1}".format(dg.graph['name'], str(uuid.uuid4()))
# FIXME change save_graph api to return new graph with Task objects
# included
save_graph(dg)
ModelMeta.save_all_lazy()
return get_graph(dg.graph['uid'])
def test_revert_create():
res = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res.inputs['a'] = '9'
res.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 1
logitem = staged_log[0]
operations.move_to_commited(logitem.log_action)
assert logitem.diff == [['add', '', [['a', '9']]]]
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(logitem.uid)
staged_log = change.stage_changes()
assert len(staged_log) == 1
for item in staged_log:
operations.move_to_commited(item.log_action)
assert resource.load_all() == []
def test_update_action_after_commit():
res = resource.load(create_resource('1').name)
res.set_operational()
res.update({'a': 10})
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert staged_log[0].action == 'update'
def test_revert_create():
res = DBResource.from_dict(
"test1",
{
"name": "test1",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res.inputs["a"] = "9"
res.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 1
logitem = staged_log[0]
operations.move_to_commited(logitem.log_action)
assert logitem.diff == [["add", "", [["a", "9"]]]]
commited = CommitedResource.get("test1")
assert commited.inputs == {"a": "9"}
change.revert(logitem.uid)
staged_log = change.stage_changes()
assert len(staged_log) == 1
for item in staged_log:
operations.move_to_commited(item.log_action)
assert resource.load_all() == []
def test_discard_connection():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = DBResource.from_dict('test2',
{'name': 'test2',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res2.inputs['a'] = '0'
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
for item in staged_log:
operations.move_to_commited(item.log_action)
res1 = resource.load('test1')
res2 = resource.load('test2')
res1.connect(res2, {'a': 'a'})
staged_log = change.stage_changes()
assert len(staged_log) == 1
assert res2.args == {'a': '9'}
change.discard_all()
assert res2.args == {'a': '0'}
assert len(change.stage_changes()) == 0
def test_discard_all_pending_changes_resources_created():
res1 = DBResource.from_dict(
"test1",
{
"name": "test1",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res1.inputs["a"] = "9"
res1.save_lazy()
res2 = DBResource.from_dict(
"test2",
{
"name": "test2",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res2.inputs["a"] = "0"
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 2
change.discard_all()
staged_log = change.stage_changes()
assert len(staged_log) == 0
assert resource.load_all() == []
def test_discard_removed():
res1 = DBResource.from_dict(
"test1",
{
"name": "test1",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res1.inputs["a"] = "9"
res1.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
for item in staged_log:
operations.move_to_commited(item.log_action)
res1 = resource.load("test1")
res1.remove()
assert len(change.stage_changes()) == 1
assert res1.to_be_removed()
change.discard_all()
assert len(change.stage_changes()) == 0
assert not resource.load("test1").to_be_removed()
def test_update_action_after_commit():
res = resource.load(create_resource('1').name)
res.set_operational()
res.update({'a': 10})
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert staged_log[0].action == 'update'
def test_discard_connection():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = DBResource.from_dict('test2',
{'name': 'test2',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res2.inputs['a'] = '0'
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
for item in staged_log:
operations.move_to_commited(item.log_action)
res1 = resource.load('test1')
res2 = resource.load('test2')
res1.connect(res2, {'a': 'a'})
staged_log = change.stage_changes()
assert len(staged_log) == 1
assert res2.args == {'a': '9'}
change.discard_all()
assert res2.args == {'a': '0'}
assert len(change.stage_changes()) == 0
def test_discard_all_pending_changes_resources_created():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = DBResource.from_dict('test2',
{'name': 'test2',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res2.inputs['a'] = '0'
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 2
change.discard_all()
staged_log = change.stage_changes()
assert len(staged_log) == 0
assert resource.load_all() == []
def set_states(uid, tasks):
plan = get_graph(uid)
for t in tasks:
if t not in plan.node:
raise Exception("No task %s in plan %s", t, uid)
plan.node[t]['task'].status = states.NOOP.name
plan.node[t]['task'].save_lazy()
ModelMeta.save_all_lazy()
def set_states(uid, tasks):
plan = get_graph(uid)
for t in tasks:
if t not in plan.node:
raise Exception("No task %s in plan %s", t, uid)
plan.node[t]['task'].status = states.NOOP.name
plan.node[t]['task'].save_lazy()
ModelMeta.save_all_lazy()
def test_discard_update():
res1 = create_resource('test1')
res1.db_obj.inputs['a'] = '9'
operations.commit_log_item(change.create_run(res1))
res1.update({'a': '11'})
ModelMeta.save_all_lazy()
assert len(change.staged_log()) == 1
assert res1.args == {'a': '11'}
change.discard_single(change.staged_log()[0])
assert res1.args == {'a': '9'}
def test_childs_added_on_stage():
res_0, res_1 = [create_resource(str(n)) for n in range(2)]
res_0.connect(res_1, {'a': 'a'})
ModelMeta.save_all_lazy()
created_log_items = stage_resources(res_0.name, 'run')
assert len(created_log_items) == 1
assert created_log_items[0].resource == res_0.name
staged_log = change.staged_log()
assert len(staged_log) == 2
child_log_item = next(li for li in staged_log if li.resource == res_1.name)
assert child_log_item.action == 'run'
def test_childs_added_on_stage():
res_0, res_1 = [create_resource(str(n)) for n in range(2)]
res_0.connect(res_1, {'a': 'a'})
ModelMeta.save_all_lazy()
created_log_items = stage_resources(res_0.name, 'run')
assert len(created_log_items) == 1
assert created_log_items[0].resource == res_0.name
staged_log = change.staged_log()
assert len(staged_log) == 2
child_log_item = next(li for li in staged_log
if li.resource == res_1.name)
assert child_log_item.action == 'run'
def test_discard_update():
res1 = create_resource('test1')
res1.inputs['a'] = '9'
res1.save_lazy()
operations.commit_log_item(change.create_run(res1.name))
res1 = resource.load('test1')
res1.update({'a': '11'})
ModelMeta.save_all_lazy()
assert len(change.staged_log()) == 1
assert res1.args == {'a': '11'}
change.discard_all()
assert res1.args == {'a': '9'}
def test_discard_update():
res1 = create_resource('test1')
res1.inputs['a'] = '9'
res1.save_lazy()
operations.commit_log_item(change.create_run(res1.name))
res1 = resource.load('test1')
res1.update({'a': '11'})
ModelMeta.save_all_lazy()
assert len(change.staged_log()) == 1
assert res1.args == {'a': '11'}
change.discard_all()
assert res1.args == {'a': '9'}
def tagged_resources():
tags = ['n1', 'n2', 'n3']
t1 = Resource.from_dict('t1',
{'name': 't1', 'tags': tags, 'base_path': 'x'})
t1.save_lazy()
t2 = Resource.from_dict('t2',
{'name': 't2', 'tags': tags, 'base_path': 'x'})
t2.save_lazy()
t3 = Resource.from_dict('t3',
{'name': 't3', 'tags': tags, 'base_path': 'x'})
t3.save_lazy()
ModelMeta.save_all_lazy()
return [t1, t2, t3]
def test_discard_removed():
res1 = create_resource('test1')
res1.db_obj.inputs['a'] = '9'
res1.db_obj.save_lazy()
res1 = resource.load('test1')
res1.remove()
ModelMeta.save_all_lazy()
assert len(change.staged_log()) == 1
assert res1.to_be_removed()
change.discard_all()
assert len(change.staged_log()) == 0
assert not resource.load('test1').to_be_removed()
def test_discard_removed():
res1 = create_resource('test1')
res1.inputs['a'] = '9'
res1.save_lazy()
res1 = resource.load('test1')
res1.remove()
ModelMeta.save_all_lazy()
assert len(change.staged_log()) == 1
assert res1.to_be_removed()
change.discard_all()
assert len(change.staged_log()) == 0
assert not resource.load('test1').to_be_removed()
def test_only_relevant_child_updated():
res1, res2, res3 = (
create_resource(
name, inputs={'a': '', 'b': ''}) for name in ('t1', 't2', 't3'))
res1.update({'a': '9', 'b': '10'})
res1.connect(res2, {'a': 'a'})
res1.connect(res3, {'b': 'b'})
ModelMeta.save_all_lazy()
# currently childs added as a side effect of staged log, thus we need
# to run it before commiting changes
assert set(s.resource for s in change.staged_log()) == {'t1', 't2', 't3'}
change.commit_all()
res1.update({'a': '12'})
ModelMeta.save_all_lazy()
# t3 not updated because "a" connected only to t2
assert set(s.resource for s in change.staged_log()) == {'t1', 't2'}
def test_revert_update_connected():
res1 = create_resource('test1')
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = create_resource('test2')
res2.inputs['a'] = ''
res2.save_lazy()
res3 = create_resource('test3')
res3.inputs['a'] = ''
res3.save_lazy()
res1 = resource.load('test1')
res2 = resource.load('test2')
res3 = resource.load('test3')
res1.connect(res2)
res2.connect(res3)
ModelMeta.save_all_lazy()
staged_log = map(lambda res: change.create_run(res.name),
(res1, res2, res3))
assert len(staged_log) == 3
for item in staged_log:
assert item.action == 'run'
operations.commit_log_item(item)
res1.disconnect(res2)
staged_log = map(lambda res: change.create_run(res.name),
(res2, res3))
to_revert = []
for item in staged_log:
assert item.action == 'run'
to_revert.append(item.uid)
operations.commit_log_item(item)
change.revert_uids(sorted(to_revert, reverse=True))
ModelMeta.save_all_lazy()
staged_log = map(lambda res: change.create_run(res.name),
(res2, res3))
for item in staged_log:
assert item.diff == [['change', 'a', ['', '9']]]
def test_revert_removal():
res = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res.inputs['a'] = '9'
res.save_lazy()
commited = CommitedResource.from_dict('test1', {'inputs': {'a': '9'},
'state': 'operational'})
commited.save_lazy()
resource_obj = resource.load(res.name)
resource_obj.remove()
ModelMeta.save_all_lazy()
changes = change.stage_changes()
assert len(changes) == 1
assert changes[0].diff == [['remove', '', [['a', '9']]]]
operations.move_to_commited(changes[0].log_action)
clear_cache()
assert DBResource._c.obj_cache == {}
# assert DBResource.bucket.get('test1').siblings == []
with mock.patch.object(repository.Repository, 'read_meta') as mread:
mread.return_value = {
'input': {'a': {'schema': 'str!'}},
'id': 'mocked'
}
with mock.patch.object(repository.Repository, 'get_path') as mpath:
mpath.return_value = 'x'
change.revert(changes[0].uid)
ModelMeta.save_all_lazy()
# assert len(DBResource.bucket.get('test1').siblings) == 1
resource_obj = resource.load('test1')
assert resource_obj.args == {
'a': '9',
'location_id': '',
'transports_id': ''
}
def test_revert_update_connected():
res1 = create_resource('test1')
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = create_resource('test2')
res2.inputs['a'] = ''
res2.save_lazy()
res3 = create_resource('test3')
res3.inputs['a'] = ''
res3.save_lazy()
res1 = resource.load('test1')
res2 = resource.load('test2')
res3 = resource.load('test3')
res1.connect(res2)
res2.connect(res3)
ModelMeta.save_all_lazy()
staged_log = map(lambda res: change.create_run(res.name),
(res1, res2, res3))
assert len(staged_log) == 3
for item in staged_log:
assert item.action == 'run'
operations.commit_log_item(item)
res1.disconnect(res2)
staged_log = map(lambda res: change.create_run(res.name), (res2, res3))
to_revert = []
for item in staged_log:
assert item.action == 'run'
to_revert.append(item.uid)
operations.commit_log_item(item)
change.revert_uids(sorted(to_revert, reverse=True))
ModelMeta.save_all_lazy()
staged_log = map(lambda res: change.create_run(res.name), (res2, res3))
for item in staged_log:
assert item.diff == [['change', 'a', ['', '9']]]
def test_revert_create():
res = create_resource('test1')
res.db_obj.inputs['a'] = '9'
logitem = change.create_run(res)
assert logitem.diff == [['add', '', [['a', '9']]]]
uid = logitem.uid
operations.commit_log_item(logitem)
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(uid)
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert len(staged_log) == 1
for item in staged_log:
operations.commit_log_item(item)
assert resource.load_all() == []
def next(self, ctxt, plan_uid):
with Lock(
plan_uid,
str(get_current_ident()),
retries=20,
waiter=Waiter(1)
):
log.debug('Received *next* event for %s', plan_uid)
plan = graph.get_graph(plan_uid)
# FIXME get_graph should raise DBNotFound if graph is not
# created
if len(plan) == 0:
raise ValueError('Plan {} is empty'.format(plan_uid))
tasks_to_schedule = self._next(plan)
for task in tasks_to_schedule:
self._do_scheduling(task)
log.debug('Scheduled tasks %r', tasks_to_schedule)
ModelMeta.save_all_lazy()
return tasks_to_schedule
def test_revert_removal():
res = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res.inputs['a'] = '9'
res.save_lazy()
commited = CommitedResource.from_dict('test1', {'inputs': {'a': '9'},
'state': 'operational'})
commited.save_lazy()
resource_obj = resource.load(res.name)
resource_obj.remove()
ModelMeta.save_all_lazy()
changes = change.stage_changes()
assert len(changes) == 1
assert changes[0].diff == [['remove', '', [['a', '9']]]]
operations.move_to_commited(changes[0].log_action)
ModelMeta.session_start()
assert DBResource._c.obj_cache == {}
assert DBResource.bucket.get('test1').siblings == []
with mock.patch.object(resource, 'read_meta') as mread:
mread.return_value = {
'input': {'a': {'schema': 'str!'}},
'id': 'mocked'
}
change.revert(changes[0].uid)
ModelMeta.save_all_lazy()
assert len(DBResource.bucket.get('test1').siblings) == 1
resource_obj = resource.load('test1')
assert resource_obj.args == {
'a': '9',
'location_id': '',
'transports_id': ''
}
def tagged_resources():
base_tags = ['n1=x', 'n2']
tags = base_tags + ['node=t1']
t1 = Resource.from_dict('t1',
{'name': 't1', 'tags': tags, 'base_path': 'x'})
t1.save_lazy()
tags = base_tags + ['node=t2']
t2 = Resource.from_dict('t2',
{'name': 't2', 'tags': tags, 'base_path': 'x'})
t2.save_lazy()
tags = base_tags + ['node=t3']
t3 = Resource.from_dict('t3',
{'name': 't3', 'tags': tags, 'base_path': 'x'})
t3.save_lazy()
tags = ['node=t3']
t4 = Resource.from_dict('t4',
{'name': 't4', 'tags': tags, 'base_path': 'x'})
t4.save_lazy()
ModelMeta.save_all_lazy()
return [t1, t2, t3]
def update_next(self, ctxt, status, errmsg):
log.debug(
'Received update for TASK %s - %s %s',
ctxt['task_id'], status, errmsg)
plan_uid, task_name = ctxt['task_id'].rsplit('~', 1)
with Lock(
plan_uid,
str(get_current_ident()),
retries=20,
waiter=Waiter(1)
):
plan = graph.get_graph(plan_uid)
task = next(t for t in plan.nodes() if t.name == task_name)
self._do_update(task, status, errmsg=errmsg)
tasks_to_schedule = self._next(plan)
for task in tasks_to_schedule:
self._do_scheduling(task)
log.debug('Scheduled tasks %r', tasks_to_schedule)
ModelMeta.save_all_lazy()
return tasks_to_schedule
def test_discard_removed_with_childs_not_affected():
res1, res2, res3 = (
create_resource(
name, inputs={'a': '', 'b': ''}) for name in ('t1', 't2', 't3'))
res1.update({'a': '9', 'b': '10'})
res1.connect(res2, {'a': 'a'})
res1.connect(res3, {'b': 'b'})
ModelMeta.save_all_lazy()
change.staged_log()
change.commit_all()
res1.remove()
ModelMeta.save_all_lazy()
staged_items = change.staged_log()
assert len(staged_items) == 1
assert staged_items[0].log_action == 't1.remove'
change.discard_all()
assert not res1.to_be_removed()
assert not res2.to_be_removed()
assert not res3.to_be_removed()
assert change.staged_log() == []
def test_revert_create():
res = create_resource('test1')
res.inputs['a'] = '9'
res.save_lazy()
logitem = change.create_run(res.name)
assert logitem.diff == [['add', '', [['a', '9']]]]
uid = logitem.uid
operations.commit_log_item(logitem)
commited = CommitedResource.get('test1')
assert commited.inputs == {'a': '9'}
change.revert(uid)
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert len(staged_log) == 1
for item in staged_log:
operations.commit_log_item(item)
assert resource.load_all() == []
def test_revert_update_connected():
res1 = create_resource('test1')
res1.update({'a': '9'})
res2 = create_resource('test2')
res2.update({'a': ''})
res3 = create_resource('test3')
res3.update({'a': ''})
res1 = resource.load('test1')
res2 = resource.load('test2')
res3 = resource.load('test3')
res1.connect(res2)
res2.connect(res3)
ModelMeta.save_all_lazy()
staged_items = change.staged_log()
assert len(staged_items) == 3
for item in staged_items:
assert item.action == 'run'
operations.commit_log_item(item)
res1.disconnect(res2)
staged_log = change.staged_log()
to_revert = []
for item in staged_log:
assert item.action == 'run'
to_revert.append(item.uid)
operations.commit_log_item(item)
change.revert_uids(sorted(to_revert, reverse=True))
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
for item in staged_log:
assert item.diff == [['change', 'a', ['', '9']]]
def test_discard_removed():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
for item in staged_log:
operations.move_to_commited(item.log_action)
res1 = resource.load('test1')
res1.remove()
assert len(change.stage_changes()) == 1
assert res1.to_be_removed()
change.discard_all()
assert len(change.stage_changes()) == 0
assert not resource.load('test1').to_be_removed()
def test_stage_and_process_partially():
a = ['a']
b = ['b']
both = a + b
range_a = range(1, 4)
range_b = range(4, 6)
with_tag_a = [create_resource(str(n), tags=a) for n in range_a]
with_tag_b = [create_resource(str(n), tags=b) for n in range_b]
ModelMeta.save_all_lazy()
created_log_items_with_a = stage_resources(a, 'restart')
assert len(created_log_items_with_a) == len(with_tag_a)
created_log_items_with_b = stage_resources(b, 'restart')
assert len(created_log_items_with_b) == len(with_tag_b)
a_graph = change.send_to_orchestration(a)
a_expected = set(['%s.restart' % n for n in range_a])
assert set(a_graph.nodes()) == a_expected
b_graph = change.send_to_orchestration(b)
b_expected = set(['%s.restart' % n for n in range_b])
assert set(b_graph.nodes()) == b_expected
both_graph = change.send_to_orchestration(both)
assert set(both_graph.nodes()) == a_expected | b_expected
def test_discard_connection():
res1 = DBResource.from_dict(
"test1",
{
"name": "test1",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res1.inputs["a"] = "9"
res1.save_lazy()
res2 = DBResource.from_dict(
"test2",
{
"name": "test2",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res2.inputs["a"] = "0"
res2.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
for item in staged_log:
operations.move_to_commited(item.log_action)
res1 = resource.load("test1")
res2 = resource.load("test2")
res1.connect(res2, {"a": "a"})
staged_log = change.stage_changes()
assert len(staged_log) == 1
assert res2.args == {"a": "9"}
change.discard_all()
assert res2.args == {"a": "0"}
assert len(change.stage_changes()) == 0
def test_discard_removed():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
for item in staged_log:
operations.move_to_commited(item.log_action)
res1 = resource.load('test1')
res1.remove()
assert len(change.stage_changes()) == 1
assert res1.to_be_removed()
change.discard_all()
assert len(change.stage_changes()) == 0
assert not resource.load('test1').to_be_removed()
def test_stage_and_process_partially():
a = ['a']
b = ['b']
both = a + b
range_a = range(1, 4)
range_b = range(4, 6)
with_tag_a = [create_resource(str(n), tags=a) for n in range_a]
with_tag_b = [create_resource(str(n), tags=b) for n in range_b]
ModelMeta.save_all_lazy()
created_log_items_with_a = stage_resources(a, 'restart')
assert len(created_log_items_with_a) == len(with_tag_a)
created_log_items_with_b = stage_resources(b, 'restart')
assert len(created_log_items_with_b) == len(with_tag_b)
a_graph = change.send_to_orchestration(a)
a_expected = set(['%s.restart' % n for n in range_a])
compare_task_to_names(set(a_graph.nodes()), a_expected)
b_graph = change.send_to_orchestration(b)
b_expected = set(['%s.restart' % n for n in range_b])
compare_task_to_names(set(b_graph.nodes()), b_expected)
both_graph = change.send_to_orchestration(both)
compare_task_to_names(set(both_graph.nodes()), a_expected | b_expected)
def test_discard_connection():
res1 = create_resource('test1')
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = create_resource('test2')
res2.inputs['a'] = '0'
res2.save_lazy()
staged_log = map(change.create_run, (res1.name, res2.name))
for item in staged_log:
operations.commit_log_item(item)
res1 = resource.load('test1')
res2 = resource.load('test2')
res1.connect(res2, {'a': 'a'})
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert len(staged_log) == 1
assert res2.args == {'a': '9'}
change.discard_all()
assert res2.args == {'a': '0'}
assert len(change.staged_log()) == 0
def test_discard_connection():
res1 = create_resource('test1')
res1.db_obj.inputs['a'] = '9'
res1.db_obj.save_lazy()
res2 = create_resource('test2')
res2.db_obj.inputs['a'] = '0'
res2.db_obj.save_lazy()
staged_log = map(change.create_run, (res1, res2))
for item in staged_log:
operations.commit_log_item(item)
res1 = resource.load('test1')
res2 = resource.load('test2')
res1.connect(res2, {'a': 'a'})
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert len(staged_log) == 1
assert res2.args == {'a': '9'}
change.discard_all()
assert res2.args == {'a': '0'}
assert len(change.staged_log()) == 0
def test_revert_removal():
res = DBResource.from_dict(
"test1",
{
"name": "test1",
"base_path": "x",
"state": RESOURCE_STATE.created.name,
"meta_inputs": {"a": {"value": None, "schema": "str"}},
},
)
res.inputs["a"] = "9"
res.save_lazy()
commited = CommitedResource.from_dict("test1", {"inputs": {"a": "9"}, "state": "operational"})
commited.save_lazy()
resource_obj = resource.load(res.name)
resource_obj.remove()
ModelMeta.save_all_lazy()
changes = change.stage_changes()
assert len(changes) == 1
assert changes[0].diff == [["remove", "", [["a", "9"]]]]
operations.move_to_commited(changes[0].log_action)
ModelMeta.session_start()
assert DBResource._c.obj_cache == {}
assert DBResource.bucket.get("test1").siblings == []
with mock.patch.object(resource, "read_meta") as mread:
mread.return_value = {"input": {"a": {"schema": "str!"}}, "id": "mocked"}
change.revert(changes[0].uid)
ModelMeta.save_all_lazy()
assert len(DBResource.bucket.get("test1").siblings) == 1
resource_obj = resource.load("test1")
assert resource_obj.args == {"a": "9", "location_id": "", "transports_id": ""}
def test_childs_added_on_stage():
res_0, res_1 = [create_resource(str(n)) for n in range(2)]
ModelMeta.save_all_lazy()
for res in (res_0, res_1):
change.create_run(res)
res_0.connect(res_1, {'a': 'a'})
change.staged_log()
ModelMeta.save_all_lazy()
change.commit_all()
res_0.update({'a': '10'})
ModelMeta.save_all_lazy()
staged_log = change.staged_log()
assert len(staged_log) == 2
child_log_item = next(li for li in staged_log
if li.resource == res_1.name)
assert child_log_item.action == 'update'
def test_revert_removal():
res = create_resource('test1')
res.inputs['a'] = '9'
res.save_lazy()
commited = CommitedResource.from_dict('test1', {
'inputs': {
'a': '9'
},
'state': 'operational'
})
commited.save_lazy()
resource_obj = resource.load(res.name)
resource_obj.remove()
ModelMeta.save_all_lazy()
log_item = change.create_remove(resource_obj.name)
log_item.save()
uid = log_item.uid
assert log_item.diff == [['remove', '', [['a', '9']]]]
operations.commit_log_item(log_item)
ModelMeta.save_all_lazy()
with mock.patch.object(repository.Repository, 'read_meta') as mread:
mread.return_value = {
'input': {
'a': {
'schema': 'str!'
}
},
'id': 'mocked'
}
with mock.patch.object(repository.Repository, 'get_path') as mpath:
mpath.return_value = 'x'
change.revert(uid)
ModelMeta.save_all_lazy()
resource_obj = resource.load('test1')
assert resource_obj.args == {
'a': '9',
'location_id': '',
'transports_id': ''
}
def test_revert_update_connected():
res1 = DBResource.from_dict('test1',
{'name': 'test1',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res1.inputs['a'] = '9'
res1.save_lazy()
res2 = DBResource.from_dict('test2',
{'name': 'test2',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res2.inputs['a'] = ''
res2.save_lazy()
res3 = DBResource.from_dict('test3',
{'name': 'test3',
'base_path': 'x',
'state': RESOURCE_STATE.created.name,
'meta_inputs': {'a': {'value': None,
'schema': 'str'}}})
res3.inputs['a'] = ''
res3.save_lazy()
res1 = resource.load('test1')
res2 = resource.load('test2')
res3 = resource.load('test3')
res1.connect(res2)
res2.connect(res3)
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 3
for item in staged_log:
assert item.action == 'run'
operations.move_to_commited(item.log_action)
assert len(change.stage_changes()) == 0
res1.disconnect(res2)
staged_log = change.stage_changes()
assert len(staged_log) == 2
to_revert = []
for item in staged_log:
assert item.action == 'update'
operations.move_to_commited(item.log_action)
to_revert.append(item.uid)
change.revert_uids(sorted(to_revert, reverse=True))
ModelMeta.save_all_lazy()
staged_log = change.stage_changes()
assert len(staged_log) == 2
for item in staged_log:
assert item.diff == [['change', 'a', ['', '9']]]
