diff --git a/watcher/applier/action_plan/default.py b/watcher/applier/action_plan/default.py index cf9ba5625..d72e0fcbd 100644 --- a/watcher/applier/action_plan/default.py +++ b/watcher/applier/action_plan/default.py @@ -22,7 +22,7 @@ from watcher.applier.action_plan import base from watcher.applier import default from watcher.applier.messaging import event_types from watcher.common.messaging.events import event -from watcher import objects +from watcher.objects import action_plan as ap_objects LOG = log.getLogger(__name__) @@ -35,7 +35,7 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler): self.applier_manager = applier_manager def notify(self, uuid, event_type, state): - action_plan = objects.ActionPlan.get_by_uuid(self.ctx, uuid) + action_plan = ap_objects.ActionPlan.get_by_uuid(self.ctx, uuid) action_plan.state = state action_plan.save() ev = event.Event() @@ -51,7 +51,7 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler): # update state self.notify(self.action_plan_uuid, event_types.EventTypes.LAUNCH_ACTION_PLAN, - objects.action_plan.Status.ONGOING) + ap_objects.State.ONGOING) applier = default.DefaultApplier(self.applier_manager, self.ctx) result = applier.execute(self.action_plan_uuid) except Exception as e: @@ -59,9 +59,9 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler): result = False finally: if result is True: - status = objects.action_plan.Status.SUCCEEDED + status = ap_objects.State.SUCCEEDED else: - status = objects.action_plan.Status.FAILED + status = ap_objects.State.FAILED # update state self.notify(self.action_plan_uuid, event_types.EventTypes.LAUNCH_ACTION_PLAN, diff --git a/watcher/applier/workflow_engine/default.py b/watcher/applier/workflow_engine/default.py index 97b3d75d3..6124ced37 100644 --- a/watcher/applier/workflow_engine/default.py +++ b/watcher/applier/workflow_engine/default.py @@ -100,13 +100,13 @@ class TaskFlowActionContainer(task.Task): def pre_execute(self): try: self.engine.notify(self._db_action, - obj_action.Status.ONGOING) + obj_action.State.ONGOING) LOG.debug("Precondition action %s", self.name) self.action.precondition() except Exception as e: LOG.exception(e) self.engine.notify(self._db_action, - obj_action.Status.FAILED) + obj_action.State.FAILED) raise def execute(self, *args, **kwargs): @@ -117,17 +117,17 @@ class TaskFlowActionContainer(task.Task): result = self.action.execute() if result is not True: self.engine.notify(self._db_action, - obj_action.Status.FAILED) + obj_action.State.FAILED) else: self.engine.notify(self._db_action, - obj_action.Status.SUCCEEDED) + obj_action.State.SUCCEEDED) except Exception as e: LOG.exception(e) LOG.error(_LE('The WorkFlow Engine has failed ' 'to execute the action %s'), self.name) self.engine.notify(self._db_action, - obj_action.Status.FAILED) + obj_action.State.FAILED) raise def post_execute(self): @@ -137,7 +137,7 @@ class TaskFlowActionContainer(task.Task): except Exception as e: LOG.exception(e) self.engine.notify(self._db_action, - obj_action.Status.FAILED) + obj_action.State.FAILED) raise def revert(self, *args, **kwargs): diff --git a/watcher/db/sqlalchemy/api.py b/watcher/db/sqlalchemy/api.py index 00332da2f..6cd5389b8 100644 --- a/watcher/db/sqlalchemy/api.py +++ b/watcher/db/sqlalchemy/api.py @@ -322,7 +322,7 @@ class Connection(api.BaseConnection): values['uuid'] = utils.generate_uuid() if values.get('state') is None: - values['state'] = audit_objects.AuditStatus.PENDING + values['state'] = audit_objects.State.PENDING audit = models.Audit() audit.update(values) diff --git a/watcher/decision_engine/audit/default.py b/watcher/decision_engine/audit/default.py index 8f6221318..10c036a88 100644 --- a/watcher/decision_engine/audit/default.py +++ b/watcher/decision_engine/audit/default.py @@ -15,26 +15,23 @@ # limitations under the License. from oslo_log import log -from watcher.common.messaging.events.event import Event -from watcher.decision_engine.audit.base import \ - BaseAuditHandler -from watcher.decision_engine.messaging.events import Events -from watcher.decision_engine.planner.manager import PlannerManager -from watcher.decision_engine.strategy.context.default import \ - DefaultStrategyContext -from watcher.objects.audit import Audit -from watcher.objects.audit import AuditStatus +from watcher.common.messaging.events import event as watcher_event +from watcher.decision_engine.audit import base +from watcher.decision_engine.messaging import events as de_events +from watcher.decision_engine.planner import manager as planner_manager +from watcher.decision_engine.strategy.context import default as default_context +from watcher.objects import audit as audit_objects LOG = log.getLogger(__name__) -class DefaultAuditHandler(BaseAuditHandler): +class DefaultAuditHandler(base.BaseAuditHandler): def __init__(self, messaging): super(DefaultAuditHandler, self).__init__() self._messaging = messaging - self._strategy_context = DefaultStrategyContext() - self._planner_manager = PlannerManager() + self._strategy_context = default_context.DefaultStrategyContext() + self._planner_manager = planner_manager.PlannerManager() self._planner = None @property @@ -52,7 +49,7 @@ class DefaultAuditHandler(BaseAuditHandler): return self._strategy_context def notify(self, audit_uuid, event_type, status): - event = Event() + event = watcher_event.Event() event.type = event_type event.data = {} payload = {'audit_uuid': audit_uuid, @@ -61,20 +58,19 @@ class DefaultAuditHandler(BaseAuditHandler): payload) def update_audit_state(self, request_context, audit_uuid, state): - LOG.debug("Update audit state:{0} ".format(state)) - audit = Audit.get_by_uuid(request_context, audit_uuid) + LOG.debug("Update audit state: %s", state) + audit = audit_objects.Audit.get_by_uuid(request_context, audit_uuid) audit.state = state audit.save() - self.notify(audit_uuid, Events.TRIGGER_AUDIT, state) + self.notify(audit_uuid, de_events.Events.TRIGGER_AUDIT, state) return audit def execute(self, audit_uuid, request_context): try: - LOG.debug("Trigger audit %s" % audit_uuid) - + LOG.debug("Trigger audit %s", audit_uuid) # change state of the audit to ONGOING audit = self.update_audit_state(request_context, audit_uuid, - AuditStatus.ONGOING) + audit_objects.State.ONGOING) # execute the strategy solution = self.strategy_context.execute_strategy(audit_uuid, @@ -84,8 +80,8 @@ class DefaultAuditHandler(BaseAuditHandler): # change state of the audit to SUCCEEDED self.update_audit_state(request_context, audit_uuid, - AuditStatus.SUCCEEDED) + audit_objects.State.SUCCEEDED) except Exception as e: LOG.exception(e) self.update_audit_state(request_context, audit_uuid, - AuditStatus.FAILED) + audit_objects.State.FAILED) diff --git a/watcher/decision_engine/planner/default.py b/watcher/decision_engine/planner/default.py index 35a2bc6b5..42fcfd14b 100644 --- a/watcher/decision_engine/planner/default.py +++ b/watcher/decision_engine/planner/default.py @@ -47,7 +47,7 @@ class DefaultPlanner(base.BasePlanner): 'action_type': action_type, 'applies_to': applies_to, 'input_parameters': input_parameters, - 'state': objects.action.Status.PENDING, + 'state': objects.action.State.PENDING, 'alarm': None, 'next': None, } @@ -99,7 +99,7 @@ class DefaultPlanner(base.BasePlanner): 'uuid': utils.generate_uuid(), 'audit_id': audit_id, 'first_action_id': None, - 'state': objects.action_plan.Status.RECOMMENDED + 'state': objects.action_plan.State.RECOMMENDED } new_action_plan = objects.ActionPlan(context, **action_plan_dict) diff --git a/watcher/objects/action.py b/watcher/objects/action.py index dbb74ec15..80a64d062 100644 --- a/watcher/objects/action.py +++ b/watcher/objects/action.py @@ -22,7 +22,7 @@ from watcher.objects import base from watcher.objects import utils as obj_utils -class Status(object): +class State(object): PENDING = 'PENDING' ONGOING = 'ONGOING' FAILED = 'FAILED' diff --git a/watcher/objects/action_plan.py b/watcher/objects/action_plan.py index b69a51fee..395fa826a 100644 --- a/watcher/objects/action_plan.py +++ b/watcher/objects/action_plan.py @@ -75,7 +75,7 @@ from watcher.objects import base from watcher.objects import utils as obj_utils -class Status(object): +class State(object): RECOMMENDED = 'RECOMMENDED' ONGOING = 'ONGOING' FAILED = 'FAILED' diff --git a/watcher/objects/audit.py b/watcher/objects/audit.py index e933395b8..8f5340ca0 100644 --- a/watcher/objects/audit.py +++ b/watcher/objects/audit.py @@ -55,7 +55,7 @@ from watcher.objects import base from watcher.objects import utils as obj_utils -class AuditStatus(object): +class State(object): ONGOING = 'ONGOING' SUCCEEDED = 'SUCCEEDED' SUBMITTED = 'SUBMITTED' diff --git a/watcher/tests/api/v1/test_audits.py b/watcher/tests/api/v1/test_audits.py index 343184dd6..e10d3869e 100644 --- a/watcher/tests/api/v1/test_audits.py +++ b/watcher/tests/api/v1/test_audits.py @@ -443,7 +443,7 @@ class TestPost(api_base.FunctionalTest): self.assertEqual(urlparse.urlparse(response.location).path, expected_location) self.assertEqual(audit_dict['uuid'], response.json['uuid']) - self.assertEqual(objects.audit.AuditStatus.PENDING, + self.assertEqual(objects.audit.State.PENDING, response.json['state']) self.assertNotIn('updated_at', response.json.keys) self.assertNotIn('deleted_at', response.json.keys) @@ -492,7 +492,7 @@ class TestPost(api_base.FunctionalTest): response = self.post_json('/audits', audit_dict) self.assertEqual('application/json', response.content_type) self.assertEqual(201, response.status_int) - self.assertEqual(objects.audit.AuditStatus.PENDING, + self.assertEqual(objects.audit.State.PENDING, response.json['state']) self.assertTrue(utils.is_uuid_like(response.json['uuid'])) diff --git a/watcher/tests/applier/action_plan/test_default_action_handler.py b/watcher/tests/applier/action_plan/test_default_action_handler.py index 2e139c838..d5aec5def 100644 --- a/watcher/tests/applier/action_plan/test_default_action_handler.py +++ b/watcher/tests/applier/action_plan/test_default_action_handler.py @@ -21,7 +21,7 @@ from mock import MagicMock from watcher.applier.action_plan.default import DefaultActionPlanHandler from watcher.applier.messaging.event_types import EventTypes -from watcher.objects.action_plan import Status +from watcher.objects import action_plan as ap_objects from watcher.objects import ActionPlan from watcher.tests.db.base import DbTestCase from watcher.tests.objects import utils as obj_utils @@ -39,7 +39,7 @@ class TestDefaultActionPlanHandler(DbTestCase): command.execute() action_plan = ActionPlan.get_by_uuid(self.context, self.action_plan.uuid) - self.assertEqual(Status.SUCCEEDED, action_plan.state) + self.assertEqual(ap_objects.State.SUCCEEDED, action_plan.state) def test_trigger_audit_send_notification(self): messaging = MagicMock() @@ -48,10 +48,10 @@ class TestDefaultActionPlanHandler(DbTestCase): command.execute() call_on_going = call(EventTypes.LAUNCH_ACTION_PLAN.name, { - 'action_plan_status': Status.ONGOING, + 'action_plan_state': ap_objects.State.ONGOING, 'action_plan__uuid': self.action_plan.uuid}) call_succeeded = call(EventTypes.LAUNCH_ACTION_PLAN.name, { - 'action_plan_status': Status.SUCCEEDED, + 'action_plan_state': ap_objects.State.SUCCEEDED, 'action_plan__uuid': self.action_plan.uuid}) calls = [call_on_going, call_succeeded] diff --git a/watcher/tests/applier/workflow_engine/test_default_workflow_engine.py b/watcher/tests/applier/workflow_engine/test_default_workflow_engine.py index ff6ff34fc..8a183095a 100644 --- a/watcher/tests/applier/workflow_engine/test_default_workflow_engine.py +++ b/watcher/tests/applier/workflow_engine/test_default_workflow_engine.py @@ -69,7 +69,7 @@ class TestDefaultWorkFlowEngine(base.DbTestCase): 'action_type': action_type, 'applies_to': applies_to, 'input_parameters': parameters, - 'state': objects.action.Status.PENDING, + 'state': objects.action.State.PENDING, 'alarm': None, 'next': next, } @@ -95,7 +95,7 @@ class TestDefaultWorkFlowEngine(base.DbTestCase): actions = [self.create_action("nop", "", {'message': 'test'}, None)] result = self.engine.execute(actions) self.assertEqual(result, True) - self.check_actions_state(actions, objects.action.Status.SUCCEEDED) + self.check_actions_state(actions, objects.action.State.SUCCEEDED) def test_execute_with_two_actions(self): actions = [] @@ -107,16 +107,16 @@ class TestDefaultWorkFlowEngine(base.DbTestCase): result = self.engine.execute(actions) self.assertEqual(result, True) - self.check_actions_state(actions, objects.action.Status.SUCCEEDED) + self.check_actions_state(actions, objects.action.State.SUCCEEDED) def test_execute_with_three_actions(self): actions = [] next2 = self.create_action("nop", "vm1", {'message': 'next'}, None) next = self.create_action("sleep", "vm1", {'duration': '0'}, next2.id) first = self.create_action("nop", "vm1", {'message': 'hello'}, next.id) - self.check_action_state(first, objects.action.Status.PENDING) - self.check_action_state(next, objects.action.Status.PENDING) - self.check_action_state(next2, objects.action.Status.PENDING) + self.check_action_state(first, objects.action.State.PENDING) + self.check_action_state(next, objects.action.State.PENDING) + self.check_action_state(next2, objects.action.State.PENDING) actions.append(first) actions.append(next) @@ -124,7 +124,7 @@ class TestDefaultWorkFlowEngine(base.DbTestCase): result = self.engine.execute(actions) self.assertEqual(result, True) - self.check_actions_state(actions, objects.action.Status.SUCCEEDED) + self.check_actions_state(actions, objects.action.State.SUCCEEDED) def test_execute_with_exception(self): actions = [] @@ -135,18 +135,18 @@ class TestDefaultWorkFlowEngine(base.DbTestCase): first = self.create_action("nop", "vm1", {'message': 'hello'}, next.id) - self.check_action_state(first, objects.action.Status.PENDING) - self.check_action_state(next, objects.action.Status.PENDING) - self.check_action_state(next2, objects.action.Status.PENDING) + self.check_action_state(first, objects.action.State.PENDING) + self.check_action_state(next, objects.action.State.PENDING) + self.check_action_state(next2, objects.action.State.PENDING) actions.append(first) actions.append(next) actions.append(next2) result = self.engine.execute(actions) self.assertEqual(result, False) - self.check_action_state(first, objects.action.Status.SUCCEEDED) - self.check_action_state(next, objects.action.Status.SUCCEEDED) - self.check_action_state(next2, objects.action.Status.FAILED) + self.check_action_state(first, objects.action.State.SUCCEEDED) + self.check_action_state(next, objects.action.State.SUCCEEDED) + self.check_action_state(next2, objects.action.State.FAILED) @mock.patch("watcher.common.loader.default.DriverManager") def test_execute_with_action_exception(self, m_driver): @@ -161,4 +161,4 @@ class TestDefaultWorkFlowEngine(base.DbTestCase): actions = [self.create_action("dontcare", "vm1", {}, None)] result = self.engine.execute(actions) self.assertEqual(result, False) - self.check_action_state(actions[0], objects.action.Status.FAILED) + self.check_action_state(actions[0], objects.action.State.FAILED) diff --git a/watcher/tests/decision_engine/audit/test_default_audit_handler.py b/watcher/tests/decision_engine/audit/test_default_audit_handler.py index 312bd6d29..c21633734 100644 --- a/watcher/tests/decision_engine/audit/test_default_audit_handler.py +++ b/watcher/tests/decision_engine/audit/test_default_audit_handler.py @@ -15,19 +15,17 @@ # limitations under the License. import mock -from watcher.decision_engine.audit.default import DefaultAuditHandler -from watcher.decision_engine.messaging.events import Events -from watcher.metrics_engine.cluster_model_collector.manager import \ - CollectorManager -from watcher.objects.audit import Audit -from watcher.objects.audit import AuditStatus -from watcher.tests.db.base import DbTestCase -from watcher.tests.decision_engine.strategy.strategies.faker_cluster_state \ - import FakerModelCollector +from watcher.decision_engine.audit import default as default +from watcher.decision_engine.messaging import events +from watcher.metrics_engine.cluster_model_collector import manager +from watcher.objects import audit as audit_objects +from watcher.tests.db import base +from watcher.tests.decision_engine.strategy.strategies import \ + faker_cluster_state as faker from watcher.tests.objects import utils as obj_utils -class TestDefaultAuditHandler(DbTestCase): +class TestDefaultAuditHandler(base.DbTestCase): def setUp(self): super(TestDefaultAuditHandler, self).setUp() self.audit_template = obj_utils.create_test_audit_template( @@ -36,32 +34,32 @@ class TestDefaultAuditHandler(DbTestCase): self.context, audit_template_id=self.audit_template.id) - @mock.patch.object(CollectorManager, "get_cluster_model_collector") + @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector") def test_trigger_audit_without_errors(self, mock_collector): - mock_collector.return_value = FakerModelCollector() - audit_handler = DefaultAuditHandler(mock.MagicMock()) + mock_collector.return_value = faker.FakerModelCollector() + audit_handler = default.DefaultAuditHandler(mock.MagicMock()) audit_handler.execute(self.audit.uuid, self.context) - @mock.patch.object(CollectorManager, "get_cluster_model_collector") + @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector") def test_trigger_audit_state_success(self, mock_collector): - mock_collector.return_value = FakerModelCollector() - audit_handler = DefaultAuditHandler(mock.MagicMock()) + mock_collector.return_value = faker.FakerModelCollector() + audit_handler = default.DefaultAuditHandler(mock.MagicMock()) audit_handler.execute(self.audit.uuid, self.context) - audit = Audit.get_by_uuid(self.context, self.audit.uuid) - self.assertEqual(AuditStatus.SUCCEEDED, audit.state) + audit = audit_objects.Audit.get_by_uuid(self.context, self.audit.uuid) + self.assertEqual(audit_objects.State.SUCCEEDED, audit.state) - @mock.patch.object(CollectorManager, "get_cluster_model_collector") + @mock.patch.object(manager.CollectorManager, "get_cluster_model_collector") def test_trigger_audit_send_notification(self, mock_collector): messaging = mock.MagicMock() - mock_collector.return_value = FakerModelCollector() - audit_handler = DefaultAuditHandler(messaging) + mock_collector.return_value = faker.FakerModelCollector() + audit_handler = default.DefaultAuditHandler(messaging) audit_handler.execute(self.audit.uuid, self.context) - call_on_going = mock.call(Events.TRIGGER_AUDIT.name, { - 'audit_status': AuditStatus.ONGOING, + call_on_going = mock.call(events.Events.TRIGGER_AUDIT.name, { + 'audit_status': audit_objects.State.ONGOING, 'audit_uuid': self.audit.uuid}) - call_succeeded = mock.call(Events.TRIGGER_AUDIT.name, { - 'audit_status': AuditStatus.SUCCEEDED, + call_succeeded = mock.call(events.Events.TRIGGER_AUDIT.name, { + 'audit_status': audit_objects.State.SUCCEEDED, 'audit_uuid': self.audit.uuid}) calls = [call_on_going, call_succeeded]