fix(node): Show accurate service status in Docker mode

Replace the broken available_on_docker flag with docker_container metadata
that maps each daemon to its companion container's host:port. In Docker
mode, use TCP health checks instead of systemctl to determine service
status. Services with containers (backup_mysql, backup_unified, update_node,
git-daemon, vsftpd) now correctly show as active. Services without
containers are marked not_available. Toggle switches are disabled in Docker
mode since services are managed by Docker Compose. Folder paths are shown
as read-only with a note about volume mounts.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ggilestro

Docker/node/docker-compose.yml

@@ -25,7 +25,6 @@ services:
     #network_mode: host                   # Comment out when running in Windows
     ports:
       - "80:80/tcp"
-      - "5353:5353/udp"
 
   ethoscope-node-backup:
     <<: *node-base

src/node/ethoscope_node/api/node_api.py

@@ -7,73 +7,77 @@
 
 import datetime
 import os
+import socket
 import subprocess
 
 import netifaces
 
 from .base import BaseAPI, error_decorator
 
 # System daemons configuration
+# docker_container: maps to the companion Docker container's hostname and port
+# on the Docker network. Used for health checks in Docker mode.
+# None means the service has no Docker container equivalent.
 SYSTEM_DAEMONS = {
     "ethoscope_backup_mysql": {
         "description": "The service that collects data from the ethoscope mariadb and syncs them with the node.",
-        "available_on_docker": True,
         "conflicts_with": [],
+        "docker_container": {"host": "ethoscope-node-backup", "port": 8090},
     },
     "ethoscope_backup_video": {
         "description": "The service that collects videos in h264 chunks from the ethoscopes and syncs them with the node",
-        "available_on_docker": True,
         "conflicts_with": ["ethoscope_backup_unified"],
+        "docker_container": None,  # Covered by ethoscope_backup_unified in Docker
     },
     "ethoscope_backup_unified": {
         "description": "The service that collects videos and SQLite dbs from the ethoscopes and syncs them with the node",
-        "available_on_docker": True,
         "conflicts_with": ["ethoscope_backup_video", "ethoscope_backup_sqlite"],
+        "docker_container": {"host": "ethoscope-node-rsync-backup", "port": 8093},
     },
     "ethoscope_backup_sqlite": {
         "description": "The service that collects SQLite db from the ethoscopes and syncs them with the node",
-        "available_on_docker": True,
         "conflicts_with": ["ethoscope_backup_unified"],
+        "docker_container": None,  # Covered by ethoscope_backup_unified in Docker
     },
     "ethoscope_update_node": {
         "description": "The service used to update the nodes and the ethoscopes.",
-        "available_on_docker": True,
         "conflicts_with": [],
+        "docker_container": {"host": "ethoscope-node-update", "port": 8888},
     },
     "git-daemon.socket": {
         "description": "The GIT server that handles git updates for the node and ethoscopes.",
-        "available_on_docker": False,
         "conflicts_with": [],
+        "docker_container": {"host": "ethoscope-git-server", "port": 9418},
     },
     "ntpd": {
         "description": "The NTPd service is syncing time with the ethoscopes.",
-        "available_on_docker": False,
         "conflicts_with": [],
+        "docker_container": None,
     },
     "sshd": {
         "description": "The SSH daemon allows power users to access the node terminal from remote.",
-        "available_on_docker": False,
         "conflicts_with": [],
+        "docker_container": None,
     },
     "vsftpd": {
         "description": "The FTP server on the node, used to access the local ethoscope data",
-        "available_on_docker": False,
         "conflicts_with": [],
+        "docker_container": {"host": "ethoscope-vsftpd", "port": 21},
     },
     "ethoscope_virtuascope": {
         "description": "A virtual ethoscope running on the node. Useful for offline tracking",
-        "available_on_docker": False,
         "conflicts_with": [],
+        "docker_container": None,
     },
     "ethoscope_tunnel": {
         "description": "Cloudflare tunnel service for remote access to this node via the internet. Requires token.",
-        "available_on_docker": False,
         "conflicts_with": [],
+        "docker_container": None,
     },
     "ethoscope_sensor_virtual": {
         "description": "A virtual sensor collecting real world data about. Requires token.",
-        "available_on_docker": False,
         "conflicts_with": [],
+        "docker_container": None,
     },
 }
 
@@ -244,30 +248,66 @@ def _get_node_system_info(self):
             "NEEDS_UPDATE": needs_update,
         }
 
+    def _check_container_health(self, host, port, timeout=2):
+        """Check if a Docker container is reachable via TCP.
+
+        Args:
+            host (str): Container hostname on the Docker network.
+            port (int): Port the container listens on.
+            timeout (int): Connection timeout in seconds.
+
+        Returns:
+            str: "active" if reachable, "inactive" otherwise.
+        """
+        try:
+            with socket.create_connection((host, port), timeout=timeout):
+                return "active"
+        except (ConnectionRefusedError, socket.timeout, OSError):
+            return "inactive"
+
     def _get_daemon_status(self):
-        """Get status of system daemons."""
+        """Get status of system daemons.
+
+        In Docker mode, uses TCP health checks against companion containers
+        instead of systemctl. Services without a docker_container mapping
+        are marked as not_available.
+        """
         daemons = SYSTEM_DAEMONS.copy()
         systemctl = self.server.systemctl
         is_dockerized = self.server.is_dockerized
 
         for daemon_name in daemons.keys():
             try:
-                with os.popen(f"{systemctl} is-active {daemon_name}") as df:
-                    is_active = df.read().strip()
-
-                is_not_available_on_docker = not daemons[daemon_name][
-                    "available_on_docker"
-                ]
+                container = daemons[daemon_name].get("docker_container")
+
+                if is_dockerized:
+                    if container:
+                        is_active = self._check_container_health(
+                            container["host"], container["port"]
+                        )
+                        not_available = False
+                    else:
+                        is_active = "inactive"
+                        not_available = True
+                else:
+                    with os.popen(f"{systemctl} is-active {daemon_name}") as df:
+                        is_active = df.read().strip()
+                    not_available = False
 
                 daemons[daemon_name].update(
                     {
                         "active": is_active,
-                        "not_available": (is_dockerized and is_not_available_on_docker),
+                        "not_available": not_available,
+                        "docker_managed": is_dockerized and container is not None,
                     }
                 )
             except Exception:
                 daemons[daemon_name].update(
-                    {"active": "unknown", "not_available": False}
+                    {
+                        "active": "unknown",
+                        "not_available": False,
+                        "docker_managed": False,
+                    }
                 )
 
         return daemons
@@ -358,6 +398,9 @@ def _execute_command(self, cmd_name):
 
     def _toggle_daemon(self, daemon_name, status):
         """Toggle system daemon on/off, enforcing service conflicts."""
+        if self.server.is_dockerized:
+            return "Service is managed by Docker Compose. Use docker compose to control it."
+
         systemctl = self.server.systemctl
         result = []
 

src/node/static/js/controllers/moreController.js

@@ -308,6 +308,10 @@ function maxLengthCheck(object) {
             $http.get('/node/daemons')
                  .then(function(response) { var data = response.data;
                     $scope.daemons = data;
+                    // Detect Docker mode from daemon metadata
+                    $scope.isDockerized = Object.keys(data).some(function(k) {
+                        return data[k].docker_managed;
+                    });
             });
 
             $http.get('/node/folders')

src/node/static/pages/more.html

@@ -383,18 +383,23 @@ <h4 class="modal-title" id="myModalLabel">Restart the node</h4>
             <div class="col-lg-8">
                 <h2>Node Administration</h2>
                 <ul class="list-group">
-                    <h3>Backup daemons and settings:</h3>
-                    <!-- <p class="log" ng-repeat="(key,entry) in daemons | toArray |orderBy: 'key'">{{key}}: {{entry}}</p></pre> -->
-
-            <li class="list-group-item" ng-repeat="(key, entry) in daemons">
-
-              <span ng-if="entry.not_available">
-                  <label>{{key}}
-                      <i class="fas fa-ban not-available-icon fa-2x" title="Currently not available in a Dockerised instance."></i>
-                  </label>
+                    <h3>Services</h3>
+                    <p ng-if="isDockerized" class="text-muted mb-2"><small><i class="fab fa-docker" style="color: #0db7ed;"></i> Services are managed by Docker Compose. Use <code>docker compose</code> to start/stop them.</small></p>
+
+            <li class="list-group-item" ng-repeat="(key, entry) in daemons" ng-if="!entry.not_available">
+
+              <span ng-if="entry.docker_managed">
+                  <div class="d-flex justify-content-between align-items-center">
+                      <div>
+                          <strong>{{key}}</strong>
+                          <span class="badge ml-2" ng-class="{'badge-success': entry.active == 'active', 'badge-danger': entry.active != 'active'}">{{entry.active}}</span>
+                          <i class="fab fa-docker ml-1" style="color: #0db7ed;" title="Managed by Docker Compose"></i>
+                      </div>
+                  </div>
+                  <small class="text-muted">{{entry.description}}</small>
               </span>
 
-              <span ng-if="!entry.not_available">
+              <span ng-if="!entry.docker_managed">
                   <label class="toggle-check" ng-class="{'text-muted': nodeManagement.isDisabledByConflict(key)}">{{key}}
                       <input type="checkbox" class="toggle-check-input"
                              ng-model="isActive"
@@ -413,18 +418,26 @@ <h3>Backup daemons and settings:</h3>
                   </p>
               </span>
             </li>
+
+            <li class="list-group-item text-muted" ng-repeat="(key, entry) in daemons" ng-if="entry.not_available" style="padding: 0.5rem 1.25rem;">
+                <i class="fas fa-ban mr-2" style="color: #ccc;"></i>
+                <span>{{key}}</span>
+                <small class="ml-2" style="color: #aaa;">not available in Docker</small>
+            </li>
         </ul>
 
         <ul class="list-group col-12">
         <h3>Folders</h3>
+            <p ng-if="isDockerized" class="text-info">
+                <small><i class="fab fa-docker"></i> These are container-internal paths. Volume mounts are configured in <code>docker-compose.yml</code>.</small>
+            </p>
             <form>
             <li class="list-group-item input" ng-repeat="(name, entry) in folders">
-<!--                <input type="file" onchange="angular.element(this).scope().nodeManagement.updateFolder(event)" name="{{name}}" id="{{name}}-btn" style="display: visible;" webkitdirectory mozdirectory msdirectory odirectory directory multiple >   -->
-                <label style="display: inline;" title={{entry.description}}>{{name}}</label><input type="text" ng-model="folders[name].path" class="w3-input" style="display: inline-block; position: relative; float: right; width: 260px; bg-color: gray;" size="40" title={{entry.description}}> <!--<button style="display: inline-block; position: relative; float: right;" ng-click="nodeManagement.browseFolder(name);"><i class="fa fa-folder-open-o" ></i></button>-->
+                <label style="display: inline;" title={{entry.description}}>{{name}}</label><input type="text" ng-model="folders[name].path" class="w3-input" style="display: inline-block; position: relative; float: right; width: 260px;" size="40" title={{entry.description}} ng-readonly="isDockerized">
                 <p>{{entry.description}}</p>
             </li>
             <br>
-            <input class="btn btn-success btn-xl" type=submit value="Save" ng-click="nodeManagement.saveFolders()">
+            <input ng-if="!isDockerized" class="btn btn-success btn-xl" type=submit value="Save" ng-click="nodeManagement.saveFolders()">
             </form>
         </ul>
         <ul class="list-group col-12">

src/node/tests/unit/api/test_node_api.py

@@ -445,7 +445,7 @@ def mock_ifaddresses(iface):
 
     @patch("os.popen")
     def test_get_daemon_status_all_active(self, mock_popen):
-        """Test getting daemon status when all active."""
+        """Test getting daemon status when all active on bare metal."""
         mock_file = Mock()
         mock_file.read.return_value = "active\n"
         mock_file.__enter__ = Mock(return_value=mock_file)
@@ -457,25 +457,57 @@ def test_get_daemon_status_all_active(self, mock_popen):
         # Check a few daemons
         self.assertEqual(result["ethoscope_backup_mysql"]["active"], "active")
         self.assertFalse(result["ethoscope_backup_mysql"]["not_available"])
+        self.assertFalse(result["ethoscope_backup_mysql"]["docker_managed"])
 
-    @patch("os.popen")
-    def test_get_daemon_status_docker_filtering(self, mock_popen):
-        """Test daemon status filters unavailable daemons in docker."""
+    @patch("ethoscope_node.api.node_api.NodeAPI._check_container_health")
+    def test_get_daemon_status_docker_with_containers(self, mock_health):
+        """Test daemon status uses TCP health checks in Docker mode."""
         self.mock_server.is_dockerized = True
-
-        mock_file = Mock()
-        mock_file.read.return_value = "inactive\n"
-        mock_file.__enter__ = Mock(return_value=mock_file)
-        mock_file.__exit__ = Mock(return_value=False)
-        mock_popen.return_value = mock_file
+        mock_health.return_value = "active"
 
         result = self.api._get_daemon_status()
 
-        # Daemons available in docker should not be marked unavailable
+        # Daemons with docker_container should be active and docker_managed
+        self.assertEqual(result["ethoscope_backup_mysql"]["active"], "active")
         self.assertFalse(result["ethoscope_backup_mysql"]["not_available"])
+        self.assertTrue(result["ethoscope_backup_mysql"]["docker_managed"])
+
+        # git-daemon.socket and vsftpd now have containers
+        self.assertEqual(result["git-daemon.socket"]["active"], "active")
+        self.assertFalse(result["git-daemon.socket"]["not_available"])
+        self.assertTrue(result["git-daemon.socket"]["docker_managed"])
+
+        self.assertEqual(result["vsftpd"]["active"], "active")
+        self.assertTrue(result["vsftpd"]["docker_managed"])
 
-        # Daemons not available in docker should be marked unavailable
+    @patch("ethoscope_node.api.node_api.NodeAPI._check_container_health")
+    def test_get_daemon_status_docker_no_container(self, mock_health):
+        """Test daemons without containers are not_available in Docker."""
+        self.mock_server.is_dockerized = True
+
+        result = self.api._get_daemon_status()
+
+        # Daemons without docker_container should be not_available
         self.assertTrue(result["sshd"]["not_available"])
+        self.assertFalse(result["sshd"]["docker_managed"])
+        self.assertTrue(result["ntpd"]["not_available"])
+        self.assertTrue(result["ethoscope_virtuascope"]["not_available"])
+
+        # backup_video/sqlite have no container (covered by unified)
+        self.assertTrue(result["ethoscope_backup_video"]["not_available"])
+        self.assertTrue(result["ethoscope_backup_sqlite"]["not_available"])
+
+    @patch("ethoscope_node.api.node_api.NodeAPI._check_container_health")
+    def test_get_daemon_status_docker_container_down(self, mock_health):
+        """Test Docker container that is unreachable shows as inactive."""
+        self.mock_server.is_dockerized = True
+        mock_health.return_value = "inactive"
+
+        result = self.api._get_daemon_status()
+
+        self.assertEqual(result["ethoscope_backup_mysql"]["active"], "inactive")
+        self.assertFalse(result["ethoscope_backup_mysql"]["not_available"])
+        self.assertTrue(result["ethoscope_backup_mysql"]["docker_managed"])
 
     @patch("os.popen")
     def test_get_daemon_status_exception(self, mock_popen):
@@ -488,6 +520,39 @@ def test_get_daemon_status_exception(self, mock_popen):
         for daemon in result.values():
             self.assertEqual(daemon["active"], "unknown")
             self.assertFalse(daemon["not_available"])
+            self.assertFalse(daemon["docker_managed"])
+
+    @patch("ethoscope_node.api.node_api.socket.create_connection")
+    def test_check_container_health_active(self, mock_conn):
+        """Test container health check returns active when reachable."""
+        mock_sock = MagicMock()
+        mock_conn.return_value.__enter__ = Mock(return_value=mock_sock)
+        mock_conn.return_value.__exit__ = Mock(return_value=False)
+
+        result = self.api._check_container_health("ethoscope-node-backup", 8090)
+
+        self.assertEqual(result, "active")
+        mock_conn.assert_called_once_with(("ethoscope-node-backup", 8090), timeout=2)
+
+    @patch("ethoscope_node.api.node_api.socket.create_connection")
+    def test_check_container_health_inactive(self, mock_conn):
+        """Test container health check returns inactive when unreachable."""
+        mock_conn.side_effect = ConnectionRefusedError()
+
+        result = self.api._check_container_health("ethoscope-node-backup", 8090)
+
+        self.assertEqual(result, "inactive")
+
+    @patch("ethoscope_node.api.node_api.socket.create_connection")
+    def test_check_container_health_timeout(self, mock_conn):
+        """Test container health check returns inactive on timeout."""
+        import socket as _socket
+
+        mock_conn.side_effect = _socket.timeout()
+
+        result = self.api._check_container_health("ethoscope-node-backup", 8090)
+
+        self.assertEqual(result, "inactive")
 
     @patch("ethoscope_node.api.node_api.BaseAPI.get_request_json")
     @patch("os.popen")
@@ -765,6 +830,14 @@ def test_toggle_daemon_stop(self, mock_popen):
             mock_log.assert_called_once()
             self.assertIn("Stopping", mock_log.call_args[0][0])
 
+    def test_toggle_daemon_blocked_in_docker(self):
+        """Test toggling daemon is blocked in Docker mode."""
+        self.mock_server.is_dockerized = True
+
+        result = self.api._toggle_daemon("ethoscope_backup_mysql", True)
+
+        self.assertIn("Docker Compose", result)
+
 
 if __name__ == "__main__":
     unittest.main()