Pausing device enables ConfigMode for the worker

mapadroid/data_manager/__init__.py

@@ -22,7 +22,7 @@ class DataManager(object):
     def __init__(self, dbc: DbWrapper, instance_id: int):
         self.dbc = dbc
         self.instance_id = instance_id
-        self.__paused_devices = []
+        self.__paused_devices: List[int] = []
 
     def clear_on_boot(self) -> None:
         # This function should handle any on-boot clearing.  It is not initiated by __init__ on the off-chance that
@@ -149,15 +149,15 @@ def get_valid_modes(self, section: str) -> List[str]:
             valid_modes = sorted(modules.AREA_MAPPINGS.keys())
         return valid_modes
 
-    def set_device_state(self, dev_name: str, active: int) -> None:
+    def set_device_state(self, device_id: int, active: int) -> None:
         if active == 1:
             try:
-                self.__paused_devices.remove(dev_name)
+                self.__paused_devices.remove(device_id)
             except ValueError:
                 pass
         else:
-            if dev_name not in self.__paused_devices:
-                self.__paused_devices.append(dev_name)
+            if device_id not in self.__paused_devices:
+                self.__paused_devices.append(device_id)
 
-    def is_device_active(self, dev_name: str) -> bool:
-        return dev_name not in self.__paused_devices
+    def is_device_active(self, device_id: int) -> bool:
+        return device_id not in self.__paused_devices

mapadroid/data_manager/modules/device.py

@@ -407,5 +407,5 @@ def validate_custom(self) -> Optional[dict]:
     def _load(self) -> None:
         super()._load()
         self.state = 0
-        if self._data_manager.is_device_active(self['origin']):
+        if self._data_manager.is_device_active(self.identifier):
             self.state = 1

mapadroid/madmin/api/resources/ftr_device.py

@@ -15,11 +15,9 @@ def post(self, identifier, data, resource_def, resource_info, *args, **kwargs):
                 args = self.api_req.data.get('args', {})
                 if call == 'device_state':
                     active = args.get('active', 1)
-                    origin = resource['origin']
-                    self._data_manager.set_device_state(origin, active)
-                    if active == 0:
-                        self._mapping_manager.device_set_disabled(origin)
-                        self._ws_server.force_disconnect(origin)
+                    self._data_manager.set_device_state(int(identifier), active)
+                    self._mapping_manager.device_set_disabled(resource['origin'])
+                    self._ws_server.force_disconnect(resource['origin'])
                     return (None, 200)
                 elif call == 'flush_level':
                     resource.flush_level()

mapadroid/utils/MappingManager.py

@@ -323,6 +323,9 @@ def routemanager_recalcualte(self, routemanager_name):
             logger.opt(exception=True).error('Unable to start recalculation')
         return successful
 
+    def data_manager_is_device_active(self, device_id: int):
+        return self.__data_manager.is_device_active(device_id)
+
     def __inherit_device_settings(self, devicesettings, poolsettings):
         inheritsettings = {}
         for pool_setting in poolsettings:

mapadroid/websocket/WebsocketServer.py

@@ -177,15 +177,25 @@ async def __connection_handler(self, websocket_client_connection: websockets.Web
         async with self.__current_users_mutex:
             origin_logger.debug("Checking if an entry is already present")
             entry = self.__current_users.get(origin, None)
-            if entry is None:
+            device = None
+            use_configmode = self.__enable_configmode
+            if not self.__enable_configmode:
+                for _, dev in self.__data_manager.search('device', params={'origin': origin}).items():
+                    if dev['origin'] == origin:
+                        device = dev
+                        break
+                if not self.__data_manager.is_device_active(device.identifier):
+                    origin_logger.warning('Origin is currently paused. Unpause through MADmin to begin working')
+                    use_configmode = True
+            if entry is None or use_configmode:
                 origin_logger.info("Need to start a new worker thread")
 
                 entry = WebsocketConnectedClientEntry(origin=origin,
                                                       websocket_client_connection=websocket_client_connection,
                                                       worker_instance=None,
                                                       worker_thread=None,
                                                       loop_running=self.__loop)
-                if not await self.__add_worker_and_thread_to_entry(entry, origin):
+                if not await self.__add_worker_and_thread_to_entry(entry, origin, use_configmode=use_configmode):
                     continue_register = False
             else:
                 origin_logger.info("There is a worker thread entry present, handling accordingly")
@@ -201,7 +211,7 @@ async def __connection_handler(self, websocket_client_connection: websockets.Web
                     # TODO: does this need more handling? probably update communicator or whatever?
                 elif not entry.worker_thread.is_alive():
                     origin_logger.info("Old thread is dead, trying to start a new one")
-                    if not await self.__add_worker_and_thread_to_entry(entry, origin):
+                    if not await self.__add_worker_and_thread_to_entry(entry, origin, use_configmode=use_configmode):
                         continue_register = False
                 else:
                     origin_logger.info("Old thread is about to stop. Wait a little and reconnect")
@@ -235,12 +245,12 @@ async def __connection_handler(self, websocket_client_connection: websockets.Web
             self.__worker_shutdown_queue.put(entry.worker_thread)
         origin_logger.info("Done with connection ({})", websocket_client_connection.remote_address)
 
-    async def __add_worker_and_thread_to_entry(self, entry, origin) -> bool:
+    async def __add_worker_and_thread_to_entry(self, entry, origin, use_configmode: bool = None) -> bool:
         communicator: AbstractCommunicator = Communicator(
             entry, origin, None, self.__args.websocket_command_timeout)
+        use_configmode: bool = use_configmode if use_configmode is not None else self.__enable_configmode
         worker: Optional[AbstractWorker] = await self.__worker_factory \
-            .get_worker_using_settings(origin, self.__enable_configmode,
-                                       communicator=communicator)
+            .get_worker_using_settings(origin, use_configmode, communicator=communicator)
         if worker is None:
             return False
         # to break circular dependencies, we need to set the worker ref >.<
@@ -265,9 +275,6 @@ async def __authenticate_connection(self, websocket_client_connection: websocket
                            websocket_client_connection.remote_address)
             return (None, False)
         origin_logger = get_origin_logger(logger, origin=origin)
-        if not self.__data_manager.is_device_active(origin):
-            origin_logger.warning('Origin is currently paused. Unpause through MADmin to begin working')
-            return (origin, False)
         origin_logger.info("Client registering")
         if self.__mapping_manager is None:
             origin_logger.warning("No configuration has been defined.  Please define in MADmin and click "

mapadroid/worker/WorkerConfigmode.py

@@ -55,17 +55,7 @@ def start_worker(self):
         self._db_wrapper.save_idle_status(self._dev_id, True)
         self.logger.debug("Device set to idle for routemanager")
         while self.check_walker() and not self._stop_worker_event.is_set():
-            if self._args.config_mode:
-                time.sleep(10)
-            else:
-                position_type = self._mapping_manager.routemanager_get_position_type(self._routemanager_name,
-                                                                                     self._origin)
-                if position_type is None:
-                    self.logger.warning("Mappings/Routemanagers have changed, stopping worker to be created again")
-                    self._stop_worker_event.set()
-                    time.sleep(1)
-                else:
-                    time.sleep(10)
+            time.sleep(10)
         self.set_devicesettings_value('finished', True)
         self._mapping_manager.unregister_worker_from_routemanager(self._routemanager_name, self._origin)
         try: