Example #1
0
    def test_assert_handlers_called(self):
        handler_vars = {
            'create_handler_called': False,
            'update_handler_called': False,
            'delete_handler_called': False
        }

        def create_handler(sensor_db):
            handler_vars['create_handler_called'] = True

        def update_handler(sensor_db):
            handler_vars['update_handler_called'] = True

        def delete_handler(sensor_db):
            handler_vars['delete_handler_called'] = True

        sensor_watcher = SensorWatcher(create_handler, update_handler, delete_handler)

        message = Message(None, delivery_info={'routing_key': 'create'})
        sensor_watcher.process_task(MOCK_SENSOR_DB, message)
        self.assertTrue(handler_vars['create_handler_called'], 'create handler should be called.')

        message = Message(None, delivery_info={'routing_key': 'update'})
        sensor_watcher.process_task(MOCK_SENSOR_DB, message)
        self.assertTrue(handler_vars['update_handler_called'], 'update handler should be called.')

        message = Message(None, delivery_info={'routing_key': 'delete'})
        sensor_watcher.process_task(MOCK_SENSOR_DB, message)
        self.assertTrue(handler_vars['delete_handler_called'], 'delete handler should be called.')
Example #2
0
    def test_sensor_watch_queue_gets_deleted_on_stop(self):
        def create_handler(sensor_db):
            pass

        def update_handler(sensor_db):
            pass

        def delete_handler(sensor_db):
            pass

        sensor_watcher = SensorWatcher(create_handler,
                                       update_handler,
                                       delete_handler,
                                       queue_suffix='covfefe')
        sensor_watcher.start()
        sw_queues = self._get_sensor_watcher_amqp_queues(
            queue_name='st2.sensor.watch.covfefe')

        start = monotonic()
        done = False
        while not done:
            eventlet.sleep(0.01)
            sw_queues = self._get_sensor_watcher_amqp_queues(
                queue_name='st2.sensor.watch.covfefe')
            done = len(sw_queues) > 0 or ((monotonic() - start) < 5)

        sensor_watcher.stop()
        sw_queues = self._get_sensor_watcher_amqp_queues(
            queue_name='st2.sensor.watch.covfefe')
        self.assertTrue(len(sw_queues) == 0)
Example #3
0
    def test_assert_handlers_called(self):
        handler_vars = {
            "create_handler_called": False,
            "update_handler_called": False,
            "delete_handler_called": False,
        }

        def create_handler(sensor_db):
            handler_vars["create_handler_called"] = True

        def update_handler(sensor_db):
            handler_vars["update_handler_called"] = True

        def delete_handler(sensor_db):
            handler_vars["delete_handler_called"] = True

        sensor_watcher = SensorWatcher(create_handler, update_handler,
                                       delete_handler)

        message = Message(None, delivery_info={"routing_key": "create"})
        sensor_watcher.process_task(MOCK_SENSOR_DB, message)
        self.assertTrue(handler_vars["create_handler_called"],
                        "create handler should be called.")

        message = Message(None, delivery_info={"routing_key": "update"})
        sensor_watcher.process_task(MOCK_SENSOR_DB, message)
        self.assertTrue(handler_vars["update_handler_called"],
                        "update handler should be called.")

        message = Message(None, delivery_info={"routing_key": "delete"})
        sensor_watcher.process_task(MOCK_SENSOR_DB, message)
        self.assertTrue(handler_vars["delete_handler_called"],
                        "delete handler should be called.")
Example #4
0
 def __init__(self, max_containers=10):
     self._max_containers = max_containers
     self._sensor_container = None
     self._sensors_watcher = SensorWatcher(
         create_handler=self._handle_create_sensor,
         update_handler=self._handle_update_sensor,
         delete_handler=self._handle_delete_sensor,
         queue_suffix='sensor_container')
     self._container_thread = None
Example #5
0
 def __init__(self, sensors_partitioner):
     self._sensor_container = None
     self._sensors_watcher = SensorWatcher(create_handler=self._handle_create_sensor,
                                           update_handler=self._handle_update_sensor,
                                           delete_handler=self._handle_delete_sensor,
                                           queue_suffix='sensor_container')
     self._container_thread = None
     if not sensors_partitioner:
         raise ValueError('sensors_partitioner should be non-None.')
     self._sensors_partitioner = sensors_partitioner
Example #6
0
    def __init__(self, sensors_partitioner, single_sensor_mode=False):
        if not sensors_partitioner:
            raise ValueError("sensors_partitioner should be non-None.")

        self._sensors_partitioner = sensors_partitioner
        self._single_sensor_mode = single_sensor_mode

        self._sensor_container = None
        self._container_thread = None

        self._sensors_watcher = SensorWatcher(
            create_handler=self._handle_create_sensor,
            update_handler=self._handle_update_sensor,
            delete_handler=self._handle_delete_sensor,
            queue_suffix="sensor_container",
        )