Clean imports in code

In some part in the code we import objects.
In the Openstack style guidelines they recommand
to import only modules.
We need to fix that.

Change-Id: I4bfee2b94d101940d615f78f9bebb83310ed90ba
Partial-Bug:1543101

watcher/api/controllers/v1/audit.py

@@ -65,7 +65,7 @@ from watcher.api.controllers.v1 import types
 from watcher.api.controllers.v1 import utils as api_utils
 from watcher.common import exception
 from watcher.common import utils
-from watcher.decision_engine.rpcapi import DecisionEngineAPI
+from watcher.decision_engine import rpcapi
 from watcher import objects
 
 
@@ -369,7 +369,7 @@ class AuditsController(rest.RestController):
 
         # trigger decision-engine to run the audit
 
-        dc_client = DecisionEngineAPI()
+        dc_client = rpcapi.DecisionEngineAPI()
         dc_client.trigger_audit(context, new_audit.uuid)
 
         return Audit.convert_with_links(new_audit)

watcher/cmd/applier.py

@@ -25,7 +25,7 @@ from oslo_config import cfg
 from oslo_log import log as logging
 
 from watcher import _i18n
-from watcher.applier.manager import ApplierManager
+from watcher.applier import manager
 from watcher.common import service
 
 LOG = logging.getLogger(__name__)
@@ -40,6 +40,6 @@ def main():
     LOG.debug("Configuration:")
     cfg.CONF.log_opt_values(LOG, std_logging.DEBUG)
 
-    server = ApplierManager()
+    server = manager.ApplierManager()
     server.connect()
     server.join()

watcher/cmd/decisionengine.py

@@ -26,7 +26,7 @@ from oslo_log import log as logging
 
 from watcher import _i18n
 from watcher.common import service
-from watcher.decision_engine.manager import DecisionEngineManager
+from watcher.decision_engine import manager
 
 
 LOG = logging.getLogger(__name__)
@@ -41,6 +41,6 @@ def main():
     LOG.debug("Configuration:")
     cfg.CONF.log_opt_values(LOG, std_logging.DEBUG)
 
-    server = DecisionEngineManager()
+    server = manager.DecisionEngineManager()
     server.connect()
     server.join()

watcher/common/messaging/events/event_dispatcher.py

@@ -16,7 +16,7 @@
 
 from oslo_log import log
 
-from watcher.decision_engine.messaging.events import Events
+from watcher.decision_engine.messaging import events as messaging_events
 
 LOG = log.getLogger(__name__)
 
@@ -43,8 +43,8 @@ class EventDispatcher(object):
         """
         Dispatch an instance of Event class
         """
-        if Events.ALL in self._events.keys():
+        if messaging_events.Events.ALL in self._events.keys():
-            listeners = self._events[Events.ALL]
+            listeners = self._events[messaging_events.Events.ALL]
             for listener in listeners:
                 listener(event)
 

watcher/decision_engine/messaging/audit_endpoint.py

@@ -16,11 +16,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from concurrent.futures import ThreadPoolExecutor
+from concurrent import futures
 
 from oslo_log import log
 
-from watcher.decision_engine.audit.default import DefaultAuditHandler
+from watcher.decision_engine.audit import default
 
 LOG = log.getLogger(__name__)
 
@@ -28,7 +28,7 @@ LOG = log.getLogger(__name__)
 class AuditEndpoint(object):
     def __init__(self, messaging, max_workers):
         self._messaging = messaging
-        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+        self._executor = futures.ThreadPoolExecutor(max_workers=max_workers)
 
     @property
     def executor(self):
@@ -39,7 +39,7 @@ class AuditEndpoint(object):
         return self._messaging
 
     def do_trigger_audit(self, context, audit_uuid):
-        audit = DefaultAuditHandler(self.messaging)
+        audit = default.DefaultAuditHandler(self.messaging)
         audit.execute(audit_uuid, context)
 
     def trigger_audit(self, context, audit_uuid):

watcher/decision_engine/rpcapi.py

@@ -21,8 +21,8 @@ from oslo_config import cfg
 from oslo_log import log
 
 from watcher.common import exception
-from watcher.common.messaging.messaging_core import MessagingCore
+from watcher.common.messaging import messaging_core
-from watcher.common.messaging.notification_handler import NotificationHandler
+from watcher.common.messaging import notification_handler
 from watcher.common import utils
 from watcher.decision_engine.manager import decision_engine_opt_group
 from watcher.decision_engine.manager import WATCHER_DECISION_ENGINE_OPTS
@@ -35,7 +35,7 @@ CONF.register_group(decision_engine_opt_group)
 CONF.register_opts(WATCHER_DECISION_ENGINE_OPTS, decision_engine_opt_group)
 
 
-class DecisionEngineAPI(MessagingCore):
+class DecisionEngineAPI(messaging_core.MessagingCore):
 
     def __init__(self):
         super(DecisionEngineAPI, self).__init__(
@@ -44,7 +44,8 @@ class DecisionEngineAPI(MessagingCore):
             CONF.watcher_decision_engine.status_topic,
             api_version=self.API_VERSION,
         )
-        self.handler = NotificationHandler(self.publisher_id)
+        self.handler = notification_handler.NotificationHandler(
+            self.publisher_id)
         self.status_topic_handler.add_endpoint(self.handler)
 
     def trigger_audit(self, context, audit_uuid=None):

watcher/decision_engine/strategy/common/level.py

@@ -17,10 +17,10 @@
 # limitations under the License.
 #
 
-from enum import Enum
+import enum
 
 
-class StrategyLevel(Enum):
+class StrategyLevel(enum.Enum):
     conservative = "conservative"
     balanced = "balanced"
     growth = "growth"

watcher/decision_engine/strategy/context/default.py

@@ -16,22 +16,21 @@
 from oslo_log import log
 
 from watcher.common import clients
-from watcher.decision_engine.strategy.context.base import BaseStrategyContext
+from watcher.decision_engine.strategy.context import base
-from watcher.decision_engine.strategy.selection.default import \
+from watcher.decision_engine.strategy.selection import default
-    DefaultStrategySelector
+from watcher.metrics_engine.cluster_model_collector import manager
-from watcher.metrics_engine.cluster_model_collector.manager import \
+
-    CollectorManager
 from watcher import objects
 
 LOG = log.getLogger(__name__)
 
 
-class DefaultStrategyContext(BaseStrategyContext):
+class DefaultStrategyContext(base.BaseStrategyContext):
     def __init__(self):
         super(DefaultStrategyContext, self).__init__()
         LOG.debug("Initializing Strategy Context")
-        self._strategy_selector = DefaultStrategySelector()
+        self._strategy_selector = default.DefaultStrategySelector()
-        self._collector_manager = CollectorManager()
+        self._collector_manager = manager.CollectorManager()
 
     @property
     def collector(self):

watcher/decision_engine/strategy/loading/default.py

@@ -21,12 +21,12 @@ from __future__ import unicode_literals
 
 from oslo_log import log
 
-from watcher.common.loader.default import DefaultLoader
+from watcher.common.loader import default
 
 LOG = log.getLogger(__name__)
 
 
-class DefaultStrategyLoader(DefaultLoader):
+class DefaultStrategyLoader(default.DefaultLoader):
     def __init__(self):
         super(DefaultStrategyLoader, self).__init__(
             namespace='watcher_strategies')

watcher/decision_engine/strategy/strategies/base.py

@@ -38,8 +38,8 @@ from oslo_log import log
 import six
 
 from watcher.common import clients
-from watcher.decision_engine.solution.default import DefaultSolution
+from watcher.decision_engine.solution import default
-from watcher.decision_engine.strategy.common.level import StrategyLevel
+from watcher.decision_engine.strategy.common import level
 
 LOG = log.getLogger(__name__)
 
@@ -57,10 +57,10 @@ class BaseStrategy(object):
         self._name = name
         self.description = description
         # default strategy level
-        self._strategy_level = StrategyLevel.conservative
+        self._strategy_level = level.StrategyLevel.conservative
         self._cluster_state_collector = None
         # the solution given by the strategy
-        self._solution = DefaultSolution()
+        self._solution = default.DefaultSolution()
         self._osc = osc
 
     @abc.abstractmethod

watcher/decision_engine/strategy/strategies/basic_consolidation.py

@@ -21,17 +21,17 @@ from oslo_log import log
 
 from watcher._i18n import _LE, _LI, _LW
 from watcher.common import exception
-from watcher.decision_engine.model.hypervisor_state import HypervisorState
+from watcher.decision_engine.model import hypervisor_state as hyper_state
-from watcher.decision_engine.model.resource import ResourceType
+from watcher.decision_engine.model import resource
-from watcher.decision_engine.model.vm_state import VMState
+from watcher.decision_engine.model import vm_state
-from watcher.decision_engine.strategy.strategies.base import BaseStrategy
+from watcher.decision_engine.strategy.strategies import base
-from watcher.metrics_engine.cluster_history.ceilometer import \
+from watcher.metrics_engine.cluster_history import ceilometer as \
-    CeilometerClusterHistory
+    ceilometer_cluster_history
 
 LOG = log.getLogger(__name__)
 
 
-class BasicConsolidation(BaseStrategy):
+class BasicConsolidation(base.BaseStrategy):
     DEFAULT_NAME = "basic"
     DEFAULT_DESCRIPTION = "Basic offline consolidation"
 
@@ -104,7 +104,8 @@ class BasicConsolidation(BaseStrategy):
     @property
     def ceilometer(self):
         if self._ceilometer is None:
-            self._ceilometer = CeilometerClusterHistory(osc=self.osc)
+            self._ceilometer = (ceilometer_cluster_history.
+                                CeilometerClusterHistory(osc=self.osc))
         return self._ceilometer
 
     @ceilometer.setter
@@ -141,9 +142,9 @@ class BasicConsolidation(BaseStrategy):
         total_cores = 0
         total_disk = 0
         total_mem = 0
-        cap_cores = model.get_resource_from_id(ResourceType.cpu_cores)
+        cap_cores = model.get_resource_from_id(resource.ResourceType.cpu_cores)
-        cap_disk = model.get_resource_from_id(ResourceType.disk)
+        cap_disk = model.get_resource_from_id(resource.ResourceType.disk)
-        cap_mem = model.get_resource_from_id(ResourceType.memory)
+        cap_mem = model.get_resource_from_id(resource.ResourceType.memory)
 
         for vm_id in model.get_mapping().get_node_vms(dest_hypervisor):
             vm = model.get_vm_from_id(vm_id)
@@ -178,9 +179,9 @@ class BasicConsolidation(BaseStrategy):
         :param total_mem
         :return: True if the threshold is not exceed
         """
-        cap_cores = model.get_resource_from_id(ResourceType.cpu_cores)
+        cap_cores = model.get_resource_from_id(resource.ResourceType.cpu_cores)
-        cap_disk = model.get_resource_from_id(ResourceType.disk)
+        cap_disk = model.get_resource_from_id(resource.ResourceType.disk)
-        cap_mem = model.get_resource_from_id(ResourceType.memory)
+        cap_mem = model.get_resource_from_id(resource.ResourceType.memory)
         # available
         cores_available = cap_cores.get_capacity(dest_hypervisor)
         disk_available = cap_disk.get_capacity(dest_hypervisor)
@@ -226,13 +227,13 @@ class BasicConsolidation(BaseStrategy):
         :return:
         """
         cpu_capacity = model.get_resource_from_id(
-            ResourceType.cpu_cores).get_capacity(element)
+            resource.ResourceType.cpu_cores).get_capacity(element)
 
         disk_capacity = model.get_resource_from_id(
-            ResourceType.disk).get_capacity(element)
+            resource.ResourceType.disk).get_capacity(element)
 
         memory_capacity = model.get_resource_from_id(
-            ResourceType.memory).get_capacity(element)
+            resource.ResourceType.memory).get_capacity(element)
 
         score_cores = (1 - (float(cpu_capacity) - float(total_cores_used)) /
                        float(cpu_capacity))
@@ -274,7 +275,7 @@ class BasicConsolidation(BaseStrategy):
             cpu_avg_vm = 100
 
         cpu_capacity = model.get_resource_from_id(
-            ResourceType.cpu_cores).get_capacity(hypervisor)
+            resource.ResourceType.cpu_cores).get_capacity(hypervisor)
 
         total_cores_used = cpu_capacity * (cpu_avg_vm / 100)
 
@@ -321,7 +322,7 @@ class BasicConsolidation(BaseStrategy):
             vm_cpu_utilization = 100
 
         cpu_capacity = model.get_resource_from_id(
-            ResourceType.cpu_cores).get_capacity(vm)
+            resource.ResourceType.cpu_cores).get_capacity(vm)
 
         total_cores_used = cpu_capacity * (vm_cpu_utilization / 100.0)
 
@@ -371,7 +372,7 @@ class BasicConsolidation(BaseStrategy):
         vm_score = []
         for vm_id in vms_to_mig:
             vm = current_model.get_vm_from_id(vm_id)
-            if vm.state == VMState.ACTIVE.value:
+            if vm.state == vm_state.VMState.ACTIVE.value:
                 vm_score.append(
                     (vm_id, self.calculate_score_vm(vm, current_model)))
 
@@ -390,7 +391,7 @@ class BasicConsolidation(BaseStrategy):
                 mig_src_hypervisor)) == 0:
             self.add_change_service_state(mig_src_hypervisor.
                                           uuid,
-                                          HypervisorState.
+                                          hyper_state.HypervisorState.
                                           OFFLINE.value)
             self.number_of_released_nodes += 1
 
@@ -446,9 +447,9 @@ class BasicConsolidation(BaseStrategy):
             count = current_model.get_mapping(). \
                 get_node_vms_from_id(hypervisor_id)
             if len(count) == 0:
-                if hypervisor.state == HypervisorState.ONLINE:
+                if hypervisor.state == hyper_state.HypervisorState.ONLINE:
                     self.add_change_service_state(hypervisor_id,
-                                                  HypervisorState.
+                                                  hyper_state.HypervisorState.
                                                   OFFLINE.value)
 
         while self.get_allowed_migration_attempts() >= unsuccessful_migration:

watcher/metrics_engine/cluster_history/ceilometer.py

@@ -22,13 +22,13 @@ from oslo_config import cfg
 from oslo_log import log
 from watcher.common import ceilometer_helper
 
-from watcher.metrics_engine.cluster_history.api import BaseClusterHistory
+from watcher.metrics_engine.cluster_history import api
 
 CONF = cfg.CONF
 LOG = log.getLogger(__name__)
 
 
-class CeilometerClusterHistory(BaseClusterHistory):
+class CeilometerClusterHistory(api.BaseClusterHistory):
     def __init__(self, osc=None):
         """:param osc: an OpenStackClients instance"""
         super(CeilometerClusterHistory, self).__init__()

watcher/metrics_engine/cluster_model_collector/manager.py

@@ -21,8 +21,8 @@ from oslo_config import cfg
 from oslo_log import log
 
 from watcher.common import nova_helper
-from watcher.metrics_engine.cluster_model_collector.nova import \
+from watcher.metrics_engine.cluster_model_collector import nova as cnova
-    NovaClusterModelCollector
+
 
 LOG = log.getLogger(__name__)
 CONF = cfg.CONF
@@ -32,4 +32,4 @@ class CollectorManager(object):
     def get_cluster_model_collector(self, osc=None):
         """:param osc: an OpenStackClients instance"""
         nova = nova_helper.NovaHelper(osc=osc)
-        return NovaClusterModelCollector(nova)
+        return cnova.NovaClusterModelCollector(nova)

watcher/metrics_engine/cluster_model_collector/nova.py

@@ -25,7 +25,6 @@ from watcher.decision_engine.model import resource
 from watcher.decision_engine.model import vm as obj_vm
 from watcher.metrics_engine.cluster_model_collector import api
 
-
 LOG = log.getLogger(__name__)
 
 

watcher/tests/applier/action_plan/test_default_action_handler.py

@@ -18,38 +18,38 @@
 
 import mock
 
-from watcher.applier.action_plan.default import DefaultActionPlanHandler
+from watcher.applier.action_plan import default
-from watcher.applier.messaging.event_types import EventTypes
+from watcher.applier.messaging import event_types as ev
 from watcher.objects import action_plan as ap_objects
-from watcher.objects import ActionPlan
+from watcher.tests.db import base
-from watcher.tests.db.base import DbTestCase
 from watcher.tests.objects import utils as obj_utils
 
 
-class TestDefaultActionPlanHandler(DbTestCase):
+class TestDefaultActionPlanHandler(base.DbTestCase):
     def setUp(self):
         super(TestDefaultActionPlanHandler, self).setUp()
         self.action_plan = obj_utils.create_test_action_plan(
             self.context)
 
     def test_launch_action_plan(self):
-        command = DefaultActionPlanHandler(self.context, mock.MagicMock(),
+        command = default.DefaultActionPlanHandler(self.context,
-                                           self.action_plan.uuid)
+                                                   mock.MagicMock(),
+                                                   self.action_plan.uuid)
         command.execute()
-        action_plan = ActionPlan.get_by_uuid(self.context,
+        action_plan = ap_objects.ActionPlan.get_by_uuid(self.context,
-                                             self.action_plan.uuid)
+                                                        self.action_plan.uuid)
         self.assertEqual(ap_objects.State.SUCCEEDED, action_plan.state)
 
     def test_trigger_audit_send_notification(self):
         messaging = mock.MagicMock()
-        command = DefaultActionPlanHandler(self.context, messaging,
+        command = default.DefaultActionPlanHandler(self.context, messaging,
-                                           self.action_plan.uuid)
+                                                   self.action_plan.uuid)
         command.execute()
 
-        call_on_going = mock.call(EventTypes.LAUNCH_ACTION_PLAN.name, {
+        call_on_going = mock.call(ev.EventTypes.LAUNCH_ACTION_PLAN.name, {
             'action_plan_state': ap_objects.State.ONGOING,
             'action_plan__uuid': self.action_plan.uuid})
-        call_succeeded = mock.call(EventTypes.LAUNCH_ACTION_PLAN.name, {
+        call_succeeded = mock.call(ev.EventTypes.LAUNCH_ACTION_PLAN.name, {
             'action_plan_state': ap_objects.State.SUCCEEDED,
             'action_plan__uuid': self.action_plan.uuid})