Improve requests for problems at start

Ref #287

alignak_app/app.py

@@ -192,13 +192,15 @@ def start(self, username=None, password=None):
             self.show_login_window()
 
         # Launch start threads
-        thread_to_launch = thread_manager.get_threads_to_launch()
-        thread_to_launch.remove('history')
-        thread_to_launch.remove('notifications')
+        thread_to_launch = [
+            'CRITICAL', 'WARNING', 'UNKNOWN', 'livesynthesis', 'realm', 'timeperiod',
+            'alignakdaemon', 'user', 'host'
+        ]
         logger.info("Filling the local database: %s", thread_to_launch)
 
         launched_threads = []
-        for thread in thread_to_launch:
+        while thread_to_launch:
+            thread = thread_to_launch.pop()
             backend_thread = BackendQThread(thread)
             backend_thread.start()
 

alignak_app/backend/backend.py

@@ -60,7 +60,6 @@ class BackendClient(object):
     }
 
     def __init__(self):
-        self.start = False
         self.backend = None
         self.connected = False
         self.user = {}
@@ -263,7 +262,7 @@ def query_realms(self):
             if realms_list:
                 data_manager.update_database('realm', realms_list)
             if 'OK' in request['_status']:
-                data_manager.databases_ready[request_data['endpoint']] = True
+                data_manager.db_is_ready[request_data['endpoint']] = True
 
     def query_timeperiods(self):
         """
@@ -294,7 +293,7 @@ def query_timeperiods(self):
             if periods_list:
                 data_manager.update_database('timeperiod', periods_list)
             if 'OK' in request['_status']:
-                data_manager.databases_ready[request_data['endpoint']] = True
+                data_manager.db_is_ready[request_data['endpoint']] = True
 
     def query_user(self):
         """
@@ -323,7 +322,7 @@ def query_user(self):
                 data_manager.update_database('user', user)
 
             if 'OK' in request['_status']:
-                data_manager.databases_ready[request_data['endpoint']] = True
+                data_manager.db_is_ready[request_data['endpoint']] = True
 
     def query_hosts(self):
         """
@@ -355,7 +354,7 @@ def query_hosts(self):
             if hosts_list:
                 data_manager.update_database('host', hosts_list)
             if 'OK' in request['_status']:
-                data_manager.databases_ready[request_data['endpoint']] = True
+                data_manager.db_is_ready[request_data['endpoint']] = True
 
     def query_services(self, host_id=None):
         """
@@ -397,89 +396,67 @@ def query_services(self, host_id=None):
                 # If not item ID, update all database
                 data_manager.update_database('service', services_list)
             if 'OK' in request['_status']:
-                data_manager.databases_ready[request_data['endpoint']] = True
+                data_manager.db_is_ready[request_data['endpoint']] = True
 
-    def query_problems(self):
+    def query_problems(self, states):
         """
         Launch requests on "service" endpoint to get items in problems and add hosts in problems:
 
         * **Hosts**: ``DOWN``, ``UNREACHABLE``
         * **Services**: ``WARNING``, ``CRITICAL``, ``UNKNOWN``
         """
 
-        def update_database(item_type, items_request):
-            """
-            Update "problems" database for an item type
-
-            :param item_type: define type of item ``Service`` | ``Host``
-            :type item_type: str
-            :param items_request: request with items
-            :type items_request: dict
-            """
-
-            for item in items_request['_items']:
-                if not item['ls_acknowledged'] and not item['ls_downtimed']:
-                    if 'service' in item_type:
-                        manager_item = Service()
-                    else:
-                        manager_item = Host()
-
-                    manager_item.create(
-                        item['_id'],
-                        item,
-                        item['name']
-                    )
-                    data_manager.database['problems'].append(manager_item)
+        # Reset if states is equal to 3 (WARNING, CRITICAL, UNKNOWN)
+        if len(states) == 3:
+            data_manager.new_database['problems'] = []
 
+        # Services
         services_projection = [
             'name', 'host', 'alias', 'ls_state', 'ls_output', 'ls_acknowledged', 'ls_downtimed'
         ]
 
-        # CRITICAL services
-        params = {'where': json.dumps({'_is_template': False, 'ls_state': 'CRITICAL'})}
-        request = self.get(
-            'service',
-            params,
-            services_projection,
-            all_items=True
-        )
-        if request:
-            update_database('service', request)
-
-        # WARNING services
-        params = {'where': json.dumps({'_is_template': False, 'ls_state': 'WARNING'})}
-        request = self.get(
-            'service',
-            params,
-            services_projection,
-            all_items=True
-        )
-        if request:
-            update_database('service', request)
-
-        # UNKNOWN services
-        params = {'where': json.dumps({'_is_template': False, 'ls_state': 'UNKNOWN'})}
-        request = self.get(
-            'service',
-            params,
-            services_projection,
-            all_items=True
-        )
-        if request:
-            update_database('service', request)
-
-        # Hosts DOWN and UNREACHABLE
-        if data_manager.database['host']:
-            for host in data_manager.database['host']:
-                if host.data['ls_state'] in ['DOWN', 'UNREACHABLE'] and \
-                        not host.data['ls_acknowledged'] and \
-                        not host.data['ls_downtimed'] and \
-                        not data_manager.get_item('problems', host.item_id):
-                    data_manager.database['problems'].append(host)
-
-        logger.info("Update database[problems]...")
-        if data_manager.database['problems']:
-            data_manager.databases_ready['problems'] = True
+        for state in states:
+            params = {'where': json.dumps({'_is_template': False, 'ls_state': state})}
+            request = self.get(
+                'service',
+                params,
+                services_projection,
+                all_items=True
+            )
+            if request:
+                for item in request['_items']:
+                    if not item['ls_acknowledged'] and not item['ls_downtimed']:
+                        service = Service()
+                        service.create(
+                            item['_id'],
+                            item,
+                            item['name']
+                        )
+                        data_manager.new_database['problems'].append(service)
+
+        # If new problems
+        if data_manager.new_database['problems']:
+            # Append states
+            data_manager.db_is_ready['problems'].append(states)
+
+            # If problems is the last, add hosts to problems
+            if len(data_manager.db_is_ready['problems']) > 2:
+                for host in data_manager.database['host']:
+                    if host.data['ls_state'] in ['DOWN', 'UNREACHABLE'] and \
+                            not host.data['ls_acknowledged'] and \
+                            not host.data['ls_downtimed'] and \
+                            not data_manager.get_item('problems', host.item_id):
+                        data_manager.new_database['problems'].append(host)
+
+                # Update "problems" database
+                data_manager.database['problems'] = []
+                while data_manager.new_database['problems']:
+                    data_manager.database['problems'].append(
+                        data_manager.new_database['problems'].pop()
+                    )
+                logger.info("Update database[problems]...")
+            if len(data_manager.db_is_ready['problems']) > 3:
+                data_manager.db_is_ready['problems'] = []
 
     def query_alignakdaemons(self):
         """
@@ -512,7 +489,7 @@ def query_alignakdaemons(self):
             if daemons_list:
                 data_manager.update_database('alignakdaemon', daemons_list)
             if 'OK' in request['_status']:
-                data_manager.databases_ready[request_data['endpoint']] = True
+                data_manager.db_is_ready[request_data['endpoint']] = True
 
     def query_livesynthesis(self):
         """
@@ -544,7 +521,7 @@ def query_livesynthesis(self):
             if livesynthesis:
                 data_manager.update_database('livesynthesis', livesynthesis)
             if 'OK' in request['_status']:
-                data_manager.databases_ready[request_data['endpoint']] = True
+                data_manager.db_is_ready[request_data['endpoint']] = True
 
     def query_history(self, hostname=None, host_id=None):
         """

alignak_app/backend/datamanager.py

@@ -52,14 +52,17 @@ def __init__(self):
             'timeperiod': [],
             'problems': [],
         }
-        self.databases_ready = {
+        self.new_database = {
+            'problems': []
+        }
+        self.db_is_ready = {
             'livesynthesis': False,
             'alignakdaemon': False,
             'host': False,
             'user': False,
             'realm': False,
             'timeperiod': False,
-            'problems': False,
+            'problems': [],
         }
         self.old_notifications = []
 
@@ -72,9 +75,12 @@ def is_ready(self):
         """
 
         cur_collected = ''
-        for db_name in self.databases_ready:
+        for db_name in self.db_is_ready:
             try:
-                assert self.databases_ready[db_name]
+                if db_name not in 'problems':
+                    assert self.db_is_ready[db_name]
+                else:
+                    assert len(self.db_is_ready[db_name]) > 2
                 cur_collected = _('READY')
             except AssertionError:
                 cur_collected = _('Collecting %s...') % db_name

alignak_app/qobjects/threads/thread.py

@@ -39,6 +39,8 @@ class BackendQThread(QThread):  # pylint: disable=too-few-public-methods
         Class who create a QThread to trigger requests
     """
 
+    problem_states = ['CRITICAL', 'WARNING', 'UNKNOWN']
+
     def __init__(self, thread, data=None):
         super(BackendQThread, self).__init__()
         self.thread_name = thread
@@ -58,8 +60,10 @@ def run(self):  # pragma: no cover
                 app_backend.query_hosts()
             elif 'service' in self.thread_name:
                 app_backend.query_services()
+            elif self.thread_name in self.problem_states:
+                app_backend.query_problems([self.thread_name])
             elif 'problems' in self.thread_name:
-                app_backend.query_problems()
+                app_backend.query_problems(self.problem_states)
             elif 'alignakdaemon' in self.thread_name:
                 app_backend.query_alignakdaemons()
             elif 'livesynthesis' in self.thread_name:

test/test_backend.py

@@ -130,7 +130,7 @@ def test_query_realms_data(self):
 
         self.assertIsNotNone(data_manager.database['realm'])
 
-        self.assertTrue(data_manager.databases_ready['realm'])
+        self.assertTrue(data_manager.db_is_ready['realm'])
 
     def test_query_period_data(self):
         """Query TimePeriod Data"""
@@ -146,7 +146,7 @@ def test_query_period_data(self):
 
         self.assertIsNotNone(data_manager.database['timeperiod'])
 
-        self.assertTrue(data_manager.databases_ready['timeperiod'])
+        self.assertTrue(data_manager.db_is_ready['timeperiod'])
 
     def test_query_user_data(self):
         """Query User Data"""
@@ -162,7 +162,7 @@ def test_query_user_data(self):
 
         self.assertIsNotNone(data_manager.database['user'])
 
-        self.assertTrue(data_manager.databases_ready['user'])
+        self.assertTrue(data_manager.db_is_ready['user'])
 
     def test_query_hosts_data(self):
         """Query Host Data"""
@@ -178,7 +178,7 @@ def test_query_hosts_data(self):
 
         self.assertIsNotNone(data_manager.database['host'])
 
-        self.assertTrue(data_manager.databases_ready['host'])
+        self.assertTrue(data_manager.db_is_ready['host'])
 
     def test_query_services_data(self):
         """Query Services Data"""
@@ -194,7 +194,7 @@ def test_query_services_data(self):
 
         self.assertIsNotNone(data_manager.database['service'])
 
-        self.assertTrue(data_manager.databases_ready['service'])
+        self.assertTrue(data_manager.db_is_ready['service'])
 
     def test_query_problems(self):
         """Query Problems Data"""
@@ -206,11 +206,11 @@ def test_query_problems(self):
         )
 
         from alignak_app.backend.datamanager import data_manager
-        under_test.query_problems()
+        under_test.query_problems(['WARNING', 'UNKNOWN'])
 
         self.assertIsNotNone(data_manager.database['problems'])
 
-        self.assertTrue(data_manager.databases_ready['problems'])
+        self.assertTrue(data_manager.db_is_ready['problems'])
 
     def test_query_daemons_data(self):
         """Query Daemons Data"""
@@ -226,7 +226,7 @@ def test_query_daemons_data(self):
 
         self.assertIsNotNone(data_manager.database['alignakdaemon'])
 
-        self.assertTrue(data_manager.databases_ready['alignakdaemon'])
+        self.assertTrue(data_manager.db_is_ready['alignakdaemon'])
 
     def test_query_livesynthesis_data(self):
         """Query Live Synthesis Data"""
@@ -242,7 +242,7 @@ def test_query_livesynthesis_data(self):
 
         self.assertIsNotNone(data_manager.database['livesynthesis'])
 
-        self.assertTrue(data_manager.databases_ready['livesynthesis'])
+        self.assertTrue(data_manager.db_is_ready['livesynthesis'])
 
     def test_query_history_data(self):
         """Query History Data"""

test/test_data_manager.py

@@ -453,25 +453,25 @@ def test_is_ready(self):
         under_test = DataManager()
 
         self.assertTrue('Collecting' in under_test.is_ready())
-        under_test.databases_ready['livesynthesis'] = True
+        under_test.db_is_ready['livesynthesis'] = True
 
         self.assertTrue('Collecting' in under_test.is_ready())
-        under_test.databases_ready['user'] = True
+        under_test.db_is_ready['user'] = True
 
         self.assertTrue('Collecting' in under_test.is_ready())
-        under_test.databases_ready['realm'] = True
+        under_test.db_is_ready['realm'] = True
 
         self.assertTrue('Collecting' in under_test.is_ready())
-        under_test.databases_ready['timeperiod'] = True
+        under_test.db_is_ready['timeperiod'] = True
 
         self.assertTrue('Collecting' in under_test.is_ready())
-        under_test.databases_ready['host'] = True
+        under_test.db_is_ready['host'] = True
 
         self.assertTrue('Collecting' in under_test.is_ready())
-        under_test.databases_ready['problems'] = True
+        under_test.db_is_ready['problems'] = [True, True, True]
 
         self.assertTrue('Collecting' in under_test.is_ready())
-        under_test.databases_ready['alignakdaemon'] = True
+        under_test.db_is_ready['alignakdaemon'] = True
 
         self.assertEqual('READY', under_test.is_ready())