def test_read_execution(benchmark, fixture_file: str, compression):
with open(os.path.join(FIXTURES_DIR, fixture_file), "rb") as fp:
content = fp.read()
cfg.CONF.set_override(name="compressors",
group="database",
override=compression)
# NOTE: It's important we correctly reestablish connection before each setting change
disconnect()
connection = db_setup()
if compression is None:
assert "compressors" not in str(connection)
elif compression == "zstd":
assert "compressors=['zstd']" in str(connection)
live_action_db = LiveActionDB()
live_action_db.status = "succeeded"
live_action_db.action = "core.local"
live_action_db.result = content
inserted_live_action_db = LiveAction.add_or_update(live_action_db)
def run_benchmark():
retrieved_live_action_db = LiveAction.get_by_id(
inserted_live_action_db.id)
return retrieved_live_action_db
retrieved_live_action_db = benchmark(run_benchmark)
# Assert that result is correctly converted back to dict on retrieval
assert retrieved_live_action_db == inserted_live_action_db
def setup_action_models(cls):
action_db = ActionDB()
action_db.name = 'action-1'
action_db.description = 'awesomeness'
action_db.enabled = True
action_db.pack = 'wolfpack'
action_db.ref = ResourceReference(name=action_db.name, pack=action_db.pack).ref
action_db.entry_point = ''
action_db.runner_type = {'name': 'test-runner'}
action_db.parameters = {
'actionstr': {'type': 'string', 'position': 1, 'required': True},
'actionint': {'type': 'number', 'default': 10, 'position': 0},
'runnerdummy': {'type': 'string', 'default': 'actiondummy'}
}
ActionDBUtilsTestCase.action_db = Action.add_or_update(action_db)
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ActionDBUtilsTestCase.action_db.ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
ActionDBUtilsTestCase.liveaction_db = LiveAction.add_or_update(liveaction_db)
def test_liveaction_create_with_notify_on_success_only(self):
created = LiveActionDB()
created.action = 'core.local'
created.description = ''
created.status = 'running'
created.parameters = {}
notify_db = NotificationSchema()
notify_sub_schema = NotificationSubSchema()
notify_sub_schema.message = 'Action succeeded.'
notify_sub_schema.data = {
'foo': 'bar',
'bar': 1,
'baz': {'k1': 'v1'}
}
notify_db.on_success = notify_sub_schema
created.notify = notify_db
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
'Same triggertype was not returned.')
# Assert notify settings saved are right.
self.assertEqual(notify_sub_schema.message,
retrieved.notify.on_success.message)
self.assertDictEqual(notify_sub_schema.data, retrieved.notify.on_success.data)
self.assertListEqual(notify_sub_schema.routes, retrieved.notify.on_success.routes)
self.assertEqual(retrieved.notify.on_failure, None)
self.assertEqual(retrieved.notify.on_complete, None)
def test_update_LiveAction_status_invalid(self):
liveaction_db = LiveActionDB()
liveaction_db.status = "initializing"
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack,
).ref
params = {
"actionstr": "foo",
"some_key_that_aint_exist_in_action_or_runner": "bar",
"runnerint": 555,
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
# Update by id.
self.assertRaises(
ValueError,
action_db_utils.update_liveaction_status,
status="mea culpa",
liveaction_id=liveaction_db.id,
)
# Verify that state is not published.
self.assertFalse(LiveActionPublisher.publish_state.called)
def setup_action_models(cls):
pack = 'wolfpack'
name = 'action-1'
parameters = {
'actionint': {'type': 'number', 'default': 10, 'position': 0},
'actionfloat': {'type': 'float', 'required': False, 'position': 1},
'actionstr': {'type': 'string', 'required': True, 'position': 2},
'actionbool': {'type': 'boolean', 'required': False, 'position': 3},
'actionlist': {'type': 'list', 'required': False, 'position': 4},
'actionobject': {'type': 'object', 'required': False, 'position': 5},
'actionnull': {'type': 'null', 'required': False, 'position': 6},
'runnerdummy': {'type': 'string', 'default': 'actiondummy'}
}
action_db = ActionDB(pack=pack, name=name, description='awesomeness',
enabled=True,
ref=ResourceReference(name=name, pack=pack).ref,
entry_point='', runner_type={'name': 'test-runner'},
parameters=parameters)
ActionDBUtilsTestCase.action_db = Action.add_or_update(action_db)
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ActionDBUtilsTestCase.action_db.ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
ActionDBUtilsTestCase.liveaction_db = LiveAction.add_or_update(liveaction_db)
def test_update_same_liveaction_status(self):
liveaction_db = LiveActionDB()
liveaction_db.status = 'requested'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack).ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
# Update by id.
newliveaction_db = action_db_utils.update_liveaction_status(
status='requested', liveaction_id=liveaction_db.id)
# Verify id didn't change.
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, 'requested')
# Verify that state is not published.
self.assertFalse(LiveActionPublisher.publish_state.called)
def post(self, execution_parameters, execution_id):
"""
Re-run the provided action execution optionally specifying override parameters.
Handles requests:
POST /executions/<id>/re_run
"""
parameters = execution_parameters.parameters
# Note: We only really need parameters here
existing_execution = self._get_one(id=execution_id,
exclude_fields=self.exclude_fields)
# Merge in any parameters provided by the user
new_parameters = copy.deepcopy(existing_execution.parameters)
new_parameters.update(parameters)
# Create object for the new execution
action_ref = existing_execution.action['ref']
new_execution = LiveActionDB()
new_execution.action = action_ref
new_execution.parameters = new_parameters
result = self._handle_schedule_execution(execution=new_execution)
return result
def test_liveaction_create_with_notify_on_success_only(self):
created = LiveActionDB()
created.action = 'core.local'
created.description = ''
created.status = 'running'
created.parameters = {}
notify_db = NotificationSchema()
notify_sub_schema = NotificationSubSchema()
notify_sub_schema.message = 'Action succeeded.'
notify_sub_schema.data = {'foo': 'bar', 'bar': 1, 'baz': {'k1': 'v1'}}
notify_db.on_success = notify_sub_schema
created.notify = notify_db
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
'Same triggertype was not returned.')
# Assert notify settings saved are right.
self.assertEqual(notify_sub_schema.message,
retrieved.notify.on_success.message)
self.assertDictEqual(notify_sub_schema.data,
retrieved.notify.on_success.data)
self.assertListEqual(notify_sub_schema.routes,
retrieved.notify.on_success.routes)
self.assertEqual(retrieved.notify.on_failure, None)
self.assertEqual(retrieved.notify.on_complete, None)
def post(self, execution_parameters, execution_id):
"""
Re-run the provided action execution optionally specifying override parameters.
Handles requests:
POST /executions/<id>/re_run
"""
parameters = execution_parameters.parameters
# Note: We only really need parameters here
existing_execution = self._get_one(id=execution_id, exclude_fields=self.exclude_fields)
# Merge in any parameters provided by the user
new_parameters = copy.deepcopy(existing_execution.parameters)
new_parameters.update(parameters)
# Create object for the new execution
action_ref = existing_execution.action['ref']
new_execution = LiveActionDB()
new_execution.action = action_ref
new_execution.parameters = new_parameters
result = self._handle_schedule_execution(execution=new_execution)
return result
def test_liveaction_create_with_notify_on_success_only(self):
created = LiveActionDB()
created.action = "core.local"
created.description = ""
created.status = "running"
created.parameters = {}
notify_db = NotificationSchema()
notify_sub_schema = NotificationSubSchema()
notify_sub_schema.message = "Action succeeded."
notify_sub_schema.data = {"foo": "bar", "bar": 1, "baz": {"k1": "v1"}}
notify_db.on_success = notify_sub_schema
created.notify = notify_db
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
"Same triggertype was not returned.")
# Assert notify settings saved are right.
self.assertEqual(notify_sub_schema.message,
retrieved.notify.on_success.message)
self.assertDictEqual(notify_sub_schema.data,
retrieved.notify.on_success.data)
self.assertListEqual(notify_sub_schema.routes,
retrieved.notify.on_success.routes)
self.assertEqual(retrieved.notify.on_failure, None)
self.assertEqual(retrieved.notify.on_complete, None)
def test_update_liveaction_with_incorrect_output_schema(self):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack).ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
runner = mock.MagicMock()
runner.output_schema = {"notaparam": {"type": "boolean"}}
liveaction_db.runner = runner
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
now = get_datetime_utc_now()
status = 'succeeded'
result = 'Work is done.'
context = {'third_party_id': uuid.uuid4().hex}
newliveaction_db = action_db_utils.update_liveaction_status(
status=status,
result=result,
context=context,
end_timestamp=now,
liveaction_id=liveaction_db.id)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, status)
self.assertEqual(newliveaction_db.result, result)
self.assertDictEqual(newliveaction_db.context, context)
self.assertEqual(newliveaction_db.end_timestamp, now)
def run_benchmark():
live_action_db = LiveActionDB()
live_action_db.status = "succeeded"
live_action_db.action = "core.local"
live_action_db.result = content
inserted_live_action_db = LiveAction.add_or_update(live_action_db)
return inserted_live_action_db
def test_update_canceled_liveaction(self):
liveaction_db = LiveActionDB()
liveaction_db.status = "initializing"
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack,
).ref
params = {
"actionstr": "foo",
"some_key_that_aint_exist_in_action_or_runner": "bar",
"runnerint": 555,
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
# Update by id.
newliveaction_db = action_db_utils.update_liveaction_status(
status="running", liveaction_id=liveaction_db.id)
# Verify id didn't change.
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, "running")
# Verify that state is published.
self.assertTrue(LiveActionPublisher.publish_state.called)
LiveActionPublisher.publish_state.assert_called_once_with(
newliveaction_db, "running")
# Cancel liveaction.
now = get_datetime_utc_now()
status = "canceled"
newliveaction_db = action_db_utils.update_liveaction_status(
status=status, end_timestamp=now, liveaction_id=liveaction_db.id)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, status)
self.assertEqual(newliveaction_db.end_timestamp, now)
# Since liveaction has already been canceled, check that anymore update of
# status, result, context, and end timestamp are not processed.
now = get_datetime_utc_now()
status = "succeeded"
result = "Work is done."
context = {"third_party_id": uuid.uuid4().hex}
newliveaction_db = action_db_utils.update_liveaction_status(
status=status,
result=result,
context=context,
end_timestamp=now,
liveaction_id=liveaction_db.id,
)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, "canceled")
self.assertNotEqual(newliveaction_db.result, result)
self.assertNotEqual(newliveaction_db.context, context)
self.assertNotEqual(newliveaction_db.end_timestamp, now)
def _get_execution_db_model(self, status=action_constants.LIVEACTION_STATUS_REQUESTED):
live_action_db = LiveActionDB()
live_action_db.status = status
live_action_db.start_timestamp = date_utils.get_datetime_utc_now()
live_action_db.action = ResourceReference(
name='test_action',
pack='test_pack').ref
live_action_db.parameters = None
return action.LiveAction.add_or_update(live_action_db, publish=False)
def _get_action_exec_db_model(self, params):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = date_utils.get_datetime_utc_now()
liveaction_db.action = ResourceReference(name=ParamsUtilsTest.action_db.name,
pack=ParamsUtilsTest.action_db.pack).ref
liveaction_db.parameters = params
return liveaction_db
def _get_execution_db_model(
self, status=action_constants.LIVEACTION_STATUS_REQUESTED):
live_action_db = LiveActionDB()
live_action_db.status = status
live_action_db.start_timestamp = date_utils.get_datetime_utc_now()
live_action_db.action = ResourceReference(name='test_action',
pack='test_pack').ref
live_action_db.parameters = None
return action.LiveAction.add_or_update(live_action_db, publish=False)
def _get_action_exec_db_model(self, action_db, params):
liveaction_db = LiveActionDB()
liveaction_db.status = action_constants.LIVEACTION_STATUS_REQUESTED
liveaction_db.start_timestamp = date_utils.get_datetime_utc_now()
liveaction_db.action = ResourceReference(name=action_db.name,
pack=action_db.pack).ref
liveaction_db.parameters = params
liveaction_db.context = {'user': cfg.CONF.system_user.user}
return liveaction_db
def run_benchmark():
live_action_db = LiveActionDB()
live_action_db.status = "succeeded"
live_action_db.action = "core.local"
live_action_db.result = data
publisher.publish(
payload=live_action_db, exchange=exchange, compression=compression
)
def _create_inquiry(self, ttl, timestamp):
action_db = self.models['actions']['ask.yaml']
liveaction_db = LiveActionDB()
liveaction_db.status = action_constants.LIVEACTION_STATUS_PENDING
liveaction_db.start_timestamp = timestamp
liveaction_db.action = ResourceReference(name=action_db.name, pack=action_db.pack).ref
liveaction_db.result = {'ttl': ttl}
liveaction_db = LiveAction.add_or_update(liveaction_db)
executions.create_execution_object(liveaction_db)
def _create_inquiry(self, ttl, timestamp):
action_db = self.models['actions']['ask.yaml']
liveaction_db = LiveActionDB()
liveaction_db.status = action_constants.LIVEACTION_STATUS_PENDING
liveaction_db.start_timestamp = timestamp
liveaction_db.action = ResourceReference(name=action_db.name, pack=action_db.pack).ref
liveaction_db.result = {'ttl': ttl}
liveaction_db = LiveAction.add_or_update(liveaction_db)
executions.create_execution_object(liveaction_db)
def _get_action_exec_db_model(self, params):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = datetime.datetime.utcnow()
liveaction_db.action = ResourceReference(name=ParamsUtilsTest.action_db.name,
pack=ParamsUtilsTest.action_db.pack).ref
liveaction_db.parameters = params
return liveaction_db
def _get_failingaction_exec_db_model(self, params):
liveaction_db = LiveActionDB()
liveaction_db.status = action_constants.LIVEACTION_STATUS_REQUESTED
liveaction_db.start_timestamp = datetime.datetime.now()
liveaction_db.action = ResourceReference(
name=RunnerContainerTest.failingaction_db.name,
pack=RunnerContainerTest.failingaction_db.pack).ref
liveaction_db.parameters = params
liveaction_db.context = {'user': cfg.CONF.system_user.user}
return liveaction_db
def _get_action_exec_db_model(self, action_db, params):
liveaction_db = LiveActionDB()
liveaction_db.status = action_constants.LIVEACTION_STATUS_REQUESTED
liveaction_db.start_timestamp = date_utils.get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=action_db.name,
pack=action_db.pack).ref
liveaction_db.parameters = params
liveaction_db.context = {'user': cfg.CONF.system_user.user}
return liveaction_db
def _create_nested_executions(self, depth=2):
"""Utility function for easily creating nested LiveAction and ActionExecutions for testing
returns (childmost_liveaction_db, parentmost_liveaction_db)
"""
if depth <= 0:
raise Exception("Please provide a depth > 0")
root_liveaction_db = LiveActionDB()
root_liveaction_db.status = action_constants.LIVEACTION_STATUS_PAUSED
root_liveaction_db.action = ACTION_WORKFLOW_REF
root_liveaction_db = LiveAction.add_or_update(root_liveaction_db)
root_ex = executions.create_execution_object(root_liveaction_db)
last_id = root_ex['id']
# Create children to the specified depth
for i in range(depth):
# Childmost liveaction should use ACTION_REF, everything else
# should use ACTION_WORKFLOW_REF
if i == depth:
action = ACTION_REF
else:
action = ACTION_WORKFLOW_REF
child_liveaction_db = LiveActionDB()
child_liveaction_db.status = action_constants.LIVEACTION_STATUS_PAUSED
child_liveaction_db.action = action
child_liveaction_db.context = {
"parent": {
"execution_id": last_id
}
}
child_liveaction_db = LiveAction.add_or_update(child_liveaction_db)
parent_ex = executions.create_execution_object(child_liveaction_db)
last_id = parent_ex.id
# Return the last-created child as well as the root
return (child_liveaction_db, root_liveaction_db)
def test_update_canceled_liveaction(self):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack).ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
# Update by id.
newliveaction_db = action_db_utils.update_liveaction_status(
status='running', liveaction_id=liveaction_db.id)
# Verify id didn't change.
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, 'running')
# Verify that state is published.
self.assertTrue(LiveActionPublisher.publish_state.called)
LiveActionPublisher.publish_state.assert_called_once_with(newliveaction_db, 'running')
# Cancel liveaction.
now = get_datetime_utc_now()
status = 'canceled'
newliveaction_db = action_db_utils.update_liveaction_status(
status=status, end_timestamp=now, liveaction_id=liveaction_db.id)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, status)
self.assertEqual(newliveaction_db.end_timestamp, now)
# Since liveaction has already been canceled, check that anymore update of
# status, result, context, and end timestamp are not processed.
now = get_datetime_utc_now()
status = 'succeeded'
result = 'Work is done.'
context = {'third_party_id': uuid.uuid4().hex}
newliveaction_db = action_db_utils.update_liveaction_status(
status=status, result=result, context=context, end_timestamp=now,
liveaction_id=liveaction_db.id)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, 'canceled')
self.assertNotEqual(newliveaction_db.result, result)
self.assertNotEqual(newliveaction_db.context, context)
self.assertNotEqual(newliveaction_db.end_timestamp, now)
def run_benchmark():
live_action_db = LiveActionDB()
live_action_db.status = "succeeded"
live_action_db.action = "core.local"
live_action_db.result = data
serialized = pickle.dumps(live_action_db)
if algorithm == "zstandard":
c = zstd.ZstdCompressor()
serialized = c.compress(serialized)
return serialized
def test_update_liveaction_result_with_dotted_key(self):
liveaction_db = LiveActionDB()
liveaction_db.status = "initializing"
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack,
).ref
params = {
"actionstr": "foo",
"some_key_that_aint_exist_in_action_or_runner": "bar",
"runnerint": 555,
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
# Update by id.
newliveaction_db = action_db_utils.update_liveaction_status(
status="running", liveaction_id=liveaction_db.id)
# Verify id didn't change.
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, "running")
# Verify that state is published.
self.assertTrue(LiveActionPublisher.publish_state.called)
LiveActionPublisher.publish_state.assert_called_once_with(
newliveaction_db, "running")
now = get_datetime_utc_now()
status = "succeeded"
result = {"a": 1, "b": True, "a.b.c": "abc"}
context = {"third_party_id": uuid.uuid4().hex}
newliveaction_db = action_db_utils.update_liveaction_status(
status=status,
result=result,
context=context,
end_timestamp=now,
liveaction_id=liveaction_db.id,
)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, status)
self.assertIn("a.b.c", list(result.keys()))
self.assertDictEqual(newliveaction_db.result, result)
self.assertDictEqual(newliveaction_db.context, context)
self.assertEqual(newliveaction_db.end_timestamp, now)
def test_update_liveaction_result_with_dotted_key(self):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack).ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
# Update by id.
newliveaction_db = action_db_utils.update_liveaction_status(
status='running', liveaction_id=liveaction_db.id)
# Verify id didn't change.
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, 'running')
# Verify that state is published.
self.assertTrue(LiveActionPublisher.publish_state.called)
LiveActionPublisher.publish_state.assert_called_once_with(
newliveaction_db, 'running')
now = get_datetime_utc_now()
status = 'succeeded'
result = {'a': 1, 'b': True, 'a.b.c': 'abc'}
context = {'third_party_id': uuid.uuid4().hex}
newliveaction_db = action_db_utils.update_liveaction_status(
status=status,
result=result,
context=context,
end_timestamp=now,
liveaction_id=liveaction_db.id)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, status)
self.assertIn('a.b.c', result.keys())
self.assertDictEqual(newliveaction_db.result, result)
self.assertDictEqual(newliveaction_db.context, context)
self.assertEqual(newliveaction_db.end_timestamp, now)
def test_liveaction_create_with_notify_both_on_success_and_on_error(self):
created = LiveActionDB()
created.action = 'core.local'
created.description = ''
created.status = 'running'
created.parameters = {}
on_success = NotificationSubSchema(message='Action succeeded.')
on_failure = NotificationSubSchema(message='Action failed.')
created.notify = NotificationSchema(on_success=on_success,
on_failure=on_failure)
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
'Same triggertype was not returned.')
# Assert notify settings saved are right.
self.assertEqual(on_success.message, retrieved.notify.on_success.message)
self.assertEqual(on_failure.message, retrieved.notify.on_failure.message)
self.assertEqual(retrieved.notify.on_complete, None)
def test_liveaction_create_with_notify_both_on_success_and_on_error(self):
created = LiveActionDB()
created.action = 'core.local'
created.description = ''
created.status = 'running'
created.parameters = {}
on_success = NotificationSubSchema(message='Action succeeded.')
on_failure = NotificationSubSchema(message='Action failed.')
created.notify = NotificationSchema(on_success=on_success,
on_failure=on_failure)
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
'Same triggertype was not returned.')
# Assert notify settings saved are right.
self.assertEqual(on_success.message, retrieved.notify.on_success.message)
self.assertEqual(on_failure.message, retrieved.notify.on_failure.message)
self.assertEqual(retrieved.notify.on_complete, None)
def test_update_liveaction_result_with_dotted_key(self):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack).ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
# Update by id.
newliveaction_db = action_db_utils.update_liveaction_status(
status='running', liveaction_id=liveaction_db.id)
# Verify id didn't change.
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, 'running')
# Verify that state is published.
self.assertTrue(LiveActionPublisher.publish_state.called)
LiveActionPublisher.publish_state.assert_called_once_with(newliveaction_db, 'running')
now = get_datetime_utc_now()
status = 'succeeded'
result = {'a': 1, 'b': True, 'a.b.c': 'abc'}
context = {'third_party_id': uuid.uuid4().hex}
newliveaction_db = action_db_utils.update_liveaction_status(
status=status, result=result, context=context, end_timestamp=now,
liveaction_id=liveaction_db.id)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, status)
self.assertIn('a.b.c', list(result.keys()))
self.assertDictEqual(newliveaction_db.result, result)
self.assertDictEqual(newliveaction_db.context, context)
self.assertEqual(newliveaction_db.end_timestamp, now)
def test_update_LiveAction_status_invalid(self):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack).ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
liveaction_db = LiveAction.add_or_update(liveaction_db)
# Update by id.
self.assertRaises(ValueError, action_db_utils.update_liveaction_status,
status='mea culpa', liveaction_id=liveaction_db.id)
# Verify that state is not published.
self.assertFalse(LiveActionPublisher.publish_state.called)
def test_liveaction_crud_no_notify(self):
created = LiveActionDB()
created.action = "core.local"
created.description = ""
created.status = "running"
created.parameters = {}
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
"Same triggertype was not returned.")
self.assertEqual(retrieved.notify, None)
# Test update
self.assertIsNone(retrieved.end_timestamp)
retrieved.end_timestamp = date_utils.get_datetime_utc_now()
updated = LiveAction.add_or_update(retrieved)
self.assertTrue(updated.end_timestamp == retrieved.end_timestamp)
# Test delete
LiveActionModelTest._delete([retrieved])
try:
retrieved = LiveAction.get_by_id(saved.id)
except StackStormDBObjectNotFoundError:
retrieved = None
self.assertIsNone(retrieved, "managed to retrieve after failure.")
def test_liveaction_crud_no_notify(self):
created = LiveActionDB()
created.action = 'core.local'
created.description = ''
created.status = 'running'
created.parameters = {}
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
'Same triggertype was not returned.')
self.assertEqual(retrieved.notify, None)
# Test update
self.assertTrue(retrieved.end_timestamp is None)
retrieved.end_timestamp = date_utils.get_datetime_utc_now()
updated = LiveAction.add_or_update(retrieved)
self.assertTrue(updated.end_timestamp == retrieved.end_timestamp)
# Test delete
LiveActionModelTest._delete([retrieved])
try:
retrieved = LiveAction.get_by_id(saved.id)
except ValueError:
retrieved = None
self.assertIsNone(retrieved, 'managed to retrieve after failure.')
def test_update_liveaction_with_incorrect_output_schema(self):
liveaction_db = LiveActionDB()
liveaction_db.status = 'initializing'
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ResourceReference(
name=ActionDBUtilsTestCase.action_db.name,
pack=ActionDBUtilsTestCase.action_db.pack).ref
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555
}
liveaction_db.parameters = params
runner = mock.MagicMock()
runner.output_schema = {
"notaparam": {
"type": "boolean"
}
}
liveaction_db.runner = runner
liveaction_db = LiveAction.add_or_update(liveaction_db)
origliveaction_db = copy.copy(liveaction_db)
now = get_datetime_utc_now()
status = 'succeeded'
result = 'Work is done.'
context = {'third_party_id': uuid.uuid4().hex}
newliveaction_db = action_db_utils.update_liveaction_status(
status=status, result=result, context=context, end_timestamp=now,
liveaction_id=liveaction_db.id)
self.assertEqual(origliveaction_db.id, newliveaction_db.id)
self.assertEqual(newliveaction_db.status, status)
self.assertEqual(newliveaction_db.result, result)
self.assertDictEqual(newliveaction_db.context, context)
self.assertEqual(newliveaction_db.end_timestamp, now)
def test_liveaction_crud_no_notify(self):
created = LiveActionDB()
created.action = 'core.local'
created.description = ''
created.status = 'running'
created.parameters = {}
saved = LiveActionModelTest._save_liveaction(created)
retrieved = LiveAction.get_by_id(saved.id)
self.assertEqual(saved.action, retrieved.action,
'Same triggertype was not returned.')
self.assertEqual(retrieved.notify, None)
# Test update
self.assertTrue(retrieved.end_timestamp is None)
retrieved.end_timestamp = date_utils.get_datetime_utc_now()
updated = LiveAction.add_or_update(retrieved)
self.assertTrue(updated.end_timestamp == retrieved.end_timestamp)
# Test delete
LiveActionModelTest._delete([retrieved])
try:
retrieved = LiveAction.get_by_id(saved.id)
except StackStormDBObjectNotFoundError:
retrieved = None
self.assertIsNone(retrieved, 'managed to retrieve after failure.')
def setup_action_models(cls):
pack = "wolfpack"
name = "action-1"
parameters = {
"actionint": {
"type": "number",
"default": 10,
"position": 0
},
"actionfloat": {
"type": "float",
"required": False,
"position": 1
},
"actionstr": {
"type": "string",
"required": True,
"position": 2
},
"actionbool": {
"type": "boolean",
"required": False,
"position": 3
},
"actionarray": {
"type": "array",
"required": False,
"position": 4
},
"actionlist": {
"type": "list",
"required": False,
"position": 5
},
"actionobject": {
"type": "object",
"required": False,
"position": 6
},
"actionnull": {
"type": "null",
"required": False,
"position": 7
},
"runnerdummy": {
"type": "string",
"default": "actiondummy"
},
}
action_db = ActionDB(
pack=pack,
name=name,
description="awesomeness",
enabled=True,
ref=ResourceReference(name=name, pack=pack).ref,
entry_point="",
runner_type={"name": "test-runner"},
parameters=parameters,
)
ActionDBUtilsTestCase.action_db = Action.add_or_update(action_db)
liveaction_db = LiveActionDB()
liveaction_db.status = "initializing"
liveaction_db.start_timestamp = get_datetime_utc_now()
liveaction_db.action = ActionDBUtilsTestCase.action_db.ref
params = {
"actionstr": "foo",
"some_key_that_aint_exist_in_action_or_runner": "bar",
"runnerint": 555,
}
liveaction_db.parameters = params
ActionDBUtilsTestCase.liveaction_db = LiveAction.add_or_update(
liveaction_db)
def test_publish_compression(self):
live_action_db = LiveActionDB()
live_action_db.id = ObjectId()
live_action_db.status = "succeeded"
live_action_db.action = "core.local"
live_action_db.result = {"foo": "bar"}
exchange = Exchange("st2.execution.test", type="topic")
queue_name = "test-" + str(random.randint(1, 10000))
queue = Queue(
name=queue_name, exchange=exchange, routing_key="#", auto_delete=True
)
publisher = PoolPublisher()
with transport_utils.get_connection() as connection:
connection.connect()
watcher = QueueConsumer(connection=connection, queue=queue)
watcher_thread = eventlet.greenthread.spawn(watcher.run)
# Give it some time to start up since we are publishing on a new queue
eventlet.sleep(0.5)
self.assertEqual(len(watcher.received_messages), 0)
# 1. Verify compression is off as a default
publisher.publish(payload=live_action_db, exchange=exchange)
eventlet.sleep(0.2)
self.assertEqual(len(watcher.received_messages), 1)
self.assertEqual(
watcher.received_messages[0][1].properties["content_type"],
"application/x-python-serialize",
)
self.assertEqual(
watcher.received_messages[0][1].properties["content_encoding"], "binary"
)
self.assertEqual(
watcher.received_messages[0][1].properties["application_headers"], {}
)
self.assertEqual(watcher.received_messages[0][0].id, live_action_db.id)
# 2. Verify config level option is used
cfg.CONF.set_override(name="compression", group="messaging", override="zstd")
publisher.publish(payload=live_action_db, exchange=exchange)
eventlet.sleep(0.2)
self.assertEqual(len(watcher.received_messages), 2)
self.assertEqual(
watcher.received_messages[1][1].properties["content_type"],
"application/x-python-serialize",
)
self.assertEqual(
watcher.received_messages[1][1].properties["content_encoding"], "binary"
)
self.assertEqual(
watcher.received_messages[1][1].properties["application_headers"],
{"compression": "application/zstd"},
)
self.assertEqual(watcher.received_messages[1][0].id, live_action_db.id)
# 2. Verify argument level option is used and has precedence over config one
cfg.CONF.set_override(name="compression", group="messaging", override="zstd")
publisher.publish(payload=live_action_db, exchange=exchange, compression="gzip")
eventlet.sleep(0.2)
self.assertEqual(len(watcher.received_messages), 3)
self.assertEqual(
watcher.received_messages[2][1].properties["content_type"],
"application/x-python-serialize",
)
self.assertEqual(
watcher.received_messages[2][1].properties["content_encoding"], "binary"
)
self.assertEqual(
watcher.received_messages[2][1].properties["application_headers"],
{"compression": "application/x-gzip"},
)
self.assertEqual(watcher.received_messages[2][0].id, live_action_db.id)
watcher_thread.kill()
def test_get_all_with_filters(self):
cfg.CONF.set_override(name='heartbeat', group='stream', override=0.1)
listener = st2stream.listener.get_listener()
process_execution = listener.processor(ActionExecutionAPI)
process_liveaction = listener.processor(LiveActionAPI)
execution_api = ActionExecutionDB(**EXECUTION_1)
liveaction_api = LiveActionDB(**LIVE_ACTION_1)
liveaction_api_2 = LiveActionDB(**LIVE_ACTION_1)
liveaction_api_2.action = 'dummy.action1'
def dispatch_and_handle_mock_data(resp):
received_messages_data = ''
for index, message in enumerate(resp._app_iter):
if message.strip():
received_messages_data += message
# Dispatch some mock events
if index == 0:
meta = META('st2.execution', 'create')
process_execution(execution_api, meta)
elif index == 1:
meta = META('st2.execution', 'update')
process_execution(execution_api, meta)
elif index == 2:
meta = META('st2.execution', 'delete')
process_execution(execution_api, meta)
elif index == 3:
meta = META('st2.liveaction', 'create')
process_liveaction(liveaction_api, meta)
elif index == 4:
meta = META('st2.liveaction', 'create')
process_liveaction(liveaction_api, meta)
elif index == 5:
meta = META('st2.liveaction', 'delete')
process_liveaction(liveaction_api_2, meta)
else:
break
received_messages = received_messages_data.split('\n\n')
received_messages = [message for message in received_messages if message]
return received_messages
# 1. Default filter
resp = stream.StreamController().get_all()
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 6)
# 1. ?events= filter
# No filter provided - all messages should be received
resp = stream.StreamController().get_all()
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 6)
# Filter provided, only two messages should be received
events = ['st2.execution__create', 'st2.liveaction__delete']
events = ','.join(events)
resp = stream.StreamController().get_all(events=events)
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 2)
# Filter provided, invalid , no message should be received
events = ['invalid1', 'invalid2']
events = ','.join(events)
resp = stream.StreamController().get_all(events=events)
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 0)
# 2. ?action_refs= filter
action_refs = ['invalid1', 'invalid2']
action_refs = ','.join(action_refs)
resp = stream.StreamController().get_all(action_refs=action_refs)
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 0)
action_refs = ['dummy.action1']
action_refs = ','.join(action_refs)
resp = stream.StreamController().get_all(action_refs=action_refs)
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 1)
# 3. ?execution_ids= filter
execution_ids = ['invalid1', 'invalid2']
execution_ids = ','.join(execution_ids)
resp = stream.StreamController().get_all(execution_ids=execution_ids)
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 0)
execution_ids = [EXECUTION_1['id']]
execution_ids = ','.join(execution_ids)
resp = stream.StreamController().get_all(execution_ids=execution_ids)
received_messages = dispatch_and_handle_mock_data(resp)
self.assertEqual(len(received_messages), 3)
