improvement(images): drop supervisor from scylla SCT image

artifacts_test.py

@@ -171,7 +171,7 @@ def check_housekeeping_service_status(self, backend: str):
                                            severity=Severity.ERROR).publish()
             return
 
-        status = status_out.stdout.strip()
+        status = status_out.stdout.strip().lower()
         # Expected output:
         #     "scylla-housekeeping-restart.service: Succeeded" - ubuntu, centos
         #     "RUNNING" - docker
@@ -180,7 +180,7 @@ def check_housekeeping_service_status(self, backend: str):
         if "scylla-housekeeping-restart.service: Succeeded" in status or \
                 "Started Scylla Housekeeping restart mode" in status or \
                 "Started scylla-housekeeping-restart.service - Scylla Housekeeping restart mode" in status or \
-                "RUNNING" in status:
+                "running" in status:
             ScyllaHousekeepingServiceEvent(message="scylla-housekeeping-restart service running",
                                            severity=Severity.NORMAL).publish()
         else:

docker/scylla-sct/centos/Dockerfile

@@ -38,6 +38,9 @@ RUN microdnf update && \
     sudo -Hu $USER sh -c "echo 'sudo test -f /root/.cqlshrc && sudo cp /root/.cqlshrc /home/$USER/.cassandra/cqlshrc' >> ~/.ssh/rc" && \
     sudo -Hu $USER sh -c "echo 'sudo test -f /root/.cassandra/cqlshrc && sudo cp /root/.cassandra/cqlshrc /home/$USER/.cassandra/cqlshrc' >> ~/.ssh/rc"
 
+COPY docker-entrypoint.py /docker-entrypoint.py
+RUN chmod +x /docker-entrypoint.py
+
 COPY ./etc/scylla-manager.conf /etc/supervisord.conf.d/scylla-manager.conf
 COPY ./etc/sshd.conf /etc/supervisord.conf.d/sshd.conf
 COPY ./etc/sshd-service.sh /sshd-service.sh

docker/scylla-sct/docker-entrypoint.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import sys
+import signal
+import subprocess
+import scyllasetup
+import logging
+import commandlineparser
+
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format="%(message)s")
+
+# list of services, previously managed by supervisor, and their start commands
+SERVICES = {
+    'scylla': '/opt/scylladb/supervisor/scylla-server.sh',
+    'scylla-housekeeping': '/scylla-housekeeping-service.sh',
+    'scylla-node-exporter': '/opt/scylladb/supervisor/scylla-node-exporter.sh',
+    'sshd': '/sshd-service.sh',
+    'scylla-manager': '/usr/bin/scylla-manager --developer-mode'
+}
+
+processes = {}
+
+
+def signal_handler(signum, frame):
+    for name, proc in processes.items():
+        if proc.poll() is None:
+            proc.send_signal(signum)
+
+
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)
+
+try:
+    arguments, extra_arguments = commandlineparser.parse()
+    setup = scyllasetup.ScyllaSetup(arguments, extra_arguments=extra_arguments)
+    setup.developerMode()
+    setup.cpuSet()
+    setup.io()
+    setup.cqlshrc()
+    setup.arguments()
+    setup.set_housekeeping()
+
+    # instead of starting supervisord, start each service directly
+    for service_name, command in SERVICES.items():
+        if service_name in ['scylla-housekeeping', 'scylla']:
+            continue
+        processes[service_name] = subprocess.Popen(command, shell=True)
+
+    processes.get('scylla', signal.pause()).wait()
+
+except Exception:  # pylint: disable=broad-except  # noqa: BLE001
+    logging.exception('failed!')

docker/scylla-sct/ubuntu/Dockerfile

@@ -37,6 +37,9 @@ RUN apt-get update && \
     echo "autostart=false" >> /etc/supervisord.conf.d/scylla-housekeeping.conf && \
     echo "user=scylla" >> /etc/supervisord.conf.d/scylla-housekeeping.conf
 
+COPY docker-entrypoint.py /docker-entrypoint.py
+RUN chmod +x /docker-entrypoint.py
+
 COPY ./etc/scylla-manager.conf /etc/supervisord.conf.d/scylla-manager.conf
 COPY ./etc/sshd.conf /etc/supervisord.conf.d/sshd.conf
 COPY ./etc/sshd-service.sh /sshd-service.sh

sdcm/cluster_docker.py

@@ -16,11 +16,15 @@
 import os
 import re
 import logging
+import shutil
+from pathlib import Path
 from typing import Optional, Union, Dict
 from functools import cached_property
 
 from sdcm import cluster
 from sdcm.remote import LOCALRUNNER
+from sdcm.utils.docker_api_client import DockerAPIClient
+from sdcm.utils.docker_service_manager import create_service_manager, DockerServiceManager
 from sdcm.utils.docker_utils import get_docker_bridge_gateway, Container, ContainerManager, DockerException
 from sdcm.utils.health_checker import check_nodes_status
 from sdcm.utils.net import get_my_public_ip
@@ -42,6 +46,12 @@ def node_container_image_tag(self):
         return self.parent_cluster.node_container_image_tag
 
     def node_container_image_dockerfile_args(self):
+        # copy SCT-dedicated docker-entrypoint script to the context directory
+        context_path = Path(self.parent_cluster.node_container_context_path)
+        entrypoint_src = context_path.parent / 'docker-entrypoint.py'
+        entrypoint_dst = context_path / 'docker-entrypoint.py'
+        shutil.copy2(entrypoint_src, entrypoint_dst, follow_symlinks=True)
+
         return dict(path=self.parent_cluster.node_container_context_path)
 
     def node_container_image_build_args(self):
@@ -67,7 +77,50 @@ def node_container_run_args(self, seed_ip):
                     nano_cpus=smp*10**9)  # Same as `docker run --cpus=N ...' CLI command.
 
 
-class DockerNode(cluster.BaseNode, NodeContainerMixin):  # pylint: disable=abstract-method
+class ContainerServiceManagerMixin:
+    """Mixin to add Docker container specific service management capabilities to Node classes"""
+
+    _docker_api_client = None
+    _docker_cmd_executor = None
+    _docker_service_manager = None
+    _container = None
+
+    def setup_docker_management(self, container: Container | None = None):
+        if not self._docker_api_client:
+            self._docker_api_client = DockerAPIClient()
+
+            if not container and hasattr(self, '_containers') and 'node' in self._containers:
+                container = self._containers['node']
+            elif not container:
+                self._docker_api_client = DockerAPIClient()
+                container = self._docker_api_client.get_container(self.name)
+
+            self._container = container
+            if container:
+                self._docker_service_manager = create_service_manager(container, self._docker_api_client)
+
+    @cached_property
+    def docker_service_manager(self) -> DockerServiceManager | None:
+        self.setup_docker_management()
+        return self._docker_service_manager
+
+    def start_container_service(self, service_name: str, timeout: int = 60) -> bool:
+        return self.docker_service_manager.start_service(service_name, timeout)
+
+    def stop_container_service(self, service_name: str, timeout: int = 60) -> bool:
+        return self.docker_service_manager.stop_service(service_name, timeout)
+
+    def restart_container_service(self, service_name: str, timeout: int = 120) -> bool:
+        return self.docker_service_manager.restart_service(service_name, timeout)
+
+    def get_container_service_status(self, service_name: str) -> str:
+        return self.docker_service_manager.get_service_status(service_name)
+
+    def list_container_services(self) -> list[dict[str, str]]:
+        return self.docker_service_manager.list_services()
+
+
+class DockerNode(cluster.BaseNode, NodeContainerMixin, ContainerServiceManagerMixin):  # pylint: disable=abstract-method
     def __init__(self,  # pylint: disable=too-many-arguments
                  parent_cluster: "DockerCluster",
                  container: Optional[Container] = None,
@@ -139,15 +192,26 @@ def restart(self):
         ContainerManager.get_container(self, "node").restart()
 
     def get_service_status(self, service_name: str, timeout: int = 500, ignore_status=False):
+        if self._docker_service_manager:
+            status = self.get_container_service_status(service_name)
+            # format similar to supervisorctl status output for compatibility
+            return type('ServiceStatus', (), {
+                'stdout': f"{service_name} {status}",
+                'stderr': "",
+                'ok': status in ['running', 'active', 'RUNNING']
+            })
         return self.remoter.sudo('sh -c "{0} || {0}.service"'.format(f"supervisorctl status {service_name}"),
                                  timeout=timeout, ignore_status=ignore_status)
 
     def start_scylla_server(self, verify_up=True, verify_down=False, timeout=300, verify_up_timeout=None):
         verify_up_timeout = verify_up_timeout or self.verify_up_timeout
         if verify_down:
             self.wait_db_down(timeout=timeout)
-        self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl start scylla"),
-                          timeout=timeout)
+        if self._docker_service_manager:
+            self.start_container_service('scylla', timeout=timeout)
+        else:
+            self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl start scylla"),
+                              timeout=timeout)
         if verify_up:
             self.wait_db_up(timeout=verify_up_timeout)
 
@@ -162,8 +226,11 @@ def start_scylla(self, verify_up=True, verify_down=False, timeout=300):
     def stop_scylla_server(self, verify_up=False, verify_down=True, timeout=300, ignore_status=False):
         if verify_up:
             self.wait_db_up(timeout=timeout)
-        self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl stop scylla"),
-                          timeout=timeout)
+        if self._docker_service_manager:
+            self.stop_container_service('scylla', timeout=timeout)
+        else:
+            self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl stop scylla"),
+                              timeout=timeout)
         if verify_down:
             self.wait_db_down(timeout=timeout)
 
@@ -172,12 +239,18 @@ def stop_scylla_server(self, verify_up=False, verify_down=True, timeout=300, ign
         self.stop_scylla_housekeeping_service(timeout=timeout)
 
     def stop_scylla_housekeeping_service(self, timeout=300):
-        self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl stop scylla-housekeeping"),
-                          timeout=timeout)
+        if self._docker_service_manager:
+            self.stop_container_service('scylla-housekeeping', timeout=timeout)
+        else:
+            self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl stop scylla-housekeeping"),
+                              timeout=timeout)
 
     def start_scylla_housekeeping_service(self, timeout=300):
-        self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl start scylla-housekeeping"),
-                          timeout=timeout)
+        if self._docker_service_manager:
+            self.start_container_service('scylla-housekeeping', timeout=timeout)
+        else:
+            self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl start scylla-housekeeping"),
+                              timeout=timeout)
 
     @cluster.log_run_info
     def stop_scylla(self, verify_up=False, verify_down=True, timeout=300):
@@ -192,7 +265,11 @@ def restart_scylla_server(self, verify_up_before=False, verify_up_after=True, ti
         # Need to restart the scylla-housekeeping service manually because of autostart of this service is disabled
         # for the docker backend. See, for example, docker/scylla-sct/ubuntu/Dockerfile
         self.stop_scylla_housekeeping_service(timeout=timeout)
-        self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl restart scylla"), timeout=timeout)
+
+        if self._docker_service_manager:
+            self.restart_container_service('scylla', timeout=timeout)
+        else:
+            self.remoter.sudo('sh -c "{0} || {0}-server"'.format("supervisorctl restart scylla"), timeout=timeout)
         if verify_up_after:
             self.wait_db_up(timeout=verify_up_timeout)
         self.start_scylla_housekeeping_service(timeout=timeout)
@@ -260,6 +337,9 @@ def _create_node(self, node_index, container=None):
         ContainerManager.wait_for_status(node, "node", status="running")
         ContainerManager.ssh_copy_id(node, "node", self.node_container_user, self.node_container_key_file)
 
+        container = ContainerManager.get_container(node, "node")
+        node.setup_docker_management(container)
+
         node.init()
 
         return node