chore(config): resolve merge conflicts and update example config

Merged restart_command documentation and examples; updated config samples and docs as part of analysis report.

Author: xNetVN

README.md

@@ -13,6 +13,7 @@
 ### Key Features
 
 - ⚡ **Automatic Recovery**: Auto-restart services when failures detected
+- 🔧 **Sequential Restart Commands**: Support list-based restart commands and scripts
 - 📊 **Comprehensive Monitoring**: CPU, RAM, disk space, and critical services
 - 🌐 **HTTP/HTTPS Health Checks**: Detect connection errors, 4xx/5xx, timeouts, slow responses
 - 📧 **Multi-channel Notifications**: Email, Telegram, Slack, Discord, Webhook
@@ -80,6 +81,10 @@ The daemon loads an optional `.env` file from:
 Use `/opt/xnetvn_monitord/config/.env.example` as a template and copy it to
 `.env` without committing secrets.
 
+The installer and auto-updater refresh `/opt/xnetvn_monitord/config/main.example.yaml`
+and `/opt/xnetvn_monitord/config/.env.example` on each install/upgrade, without
+overwriting `/opt/xnetvn_monitord/config/main.yaml` or `/opt/xnetvn_monitord/config/.env`.
+
 You can also use systemd `EnvironmentFile` entries when running via systemd:
 
 When using `${VAR}` in `config/main.yaml`, define environment variables via a
@@ -114,6 +119,11 @@ general:
 service_monitor:
   enabled: true
   action_on_failure: "restart_and_notify"
+  services:
+    - name: "nginx"
+      restart_command:
+        - "systemctl restart nginx"
+        - "bash /opt/xnetvn_monitord/scripts/custom-restart.sh"
 
 resource_monitor:
   enabled: true

config/main.example.yaml

@@ -140,7 +140,9 @@ service_monitor:
   # - check_command/check_timeout: Custom command and timeout (custom_command only)
   # - url/http_method/headers/timeout_seconds/expected_status_codes/
   #   max_response_time_ms/verify_tls: HTTP/HTTPS health checks
-  # - restart_command: Recovery command (string or list executed in order)
+  # - restart_command: Recovery command to execute on failure.
+  #   Supports a single command string or a list of commands executed in order.
+  #   External scripts are supported (bash/php/python, etc.).
   # - pre_restart_hook/post_restart_hook: Optional hooks before/after recovery
   # - check_interval/action_cooldown: Per-service overrides for frequency/cooldown
   # - critical/description: Notification metadata
@@ -158,10 +160,11 @@ service_monitor:
       service_name: "nginx"
       # Optional regex to match multiple systemd units
       # service_name_pattern: "php.*-fpm\.service"
-      # Restart command to execute when failure detected
-      restart_command: 
+      # Example: execute multiple commands in order
+      restart_command:
         - "systemctl restart nginx"
-        #- "bash /path/to/scripts/custom-restart.sh" # Custom script
+        #- "systemctl restart php*-fpm"
+        #- "bash /opt/xnetvn_monitord/scripts/custom-restart.sh" # Custom script
       # Per-service check interval override
       check_interval:
         value: 30
@@ -183,7 +186,8 @@ service_monitor:
       enabled: false
       check_method: "process_regex"
       process_pattern: "php-fpm.*master"
-      restart_command: "systemctl restart php*-fpm"
+      restart_command:
+        - "systemctl restart php*-fpm"
       critical: true
       description: "PHP-FPM master process"
 

docs/en/README.md

@@ -11,6 +11,7 @@
 ## Key Features
 
 - Service monitoring (systemd/OpenRC/SysV/process/regex/custom/HTTP/HTTPS).
+- Sequential restart commands via list-based `restart_command`.
 - Per-service check intervals and action cooldowns.
 - Pre- and post-recovery notifications.
 - CPU/RAM/Disk threshold monitoring.
@@ -63,6 +64,17 @@ Key sections:
 - `resource_monitor`: CPU/RAM/Disk thresholds and recovery actions
 - `notifications`: Email/Telegram and rate limits
 
+Example restart command list:
+
+```yaml
+service_monitor:
+    services:
+        - name: "nginx"
+            restart_command:
+                - "systemctl restart nginx"
+                - "bash /opt/xnetvn_monitord/scripts/custom-restart.sh"
+```
+
 ## Environment Variables (.env + systemd)
 
 The daemon loads an optional `.env` file from:
@@ -74,6 +86,10 @@ The daemon loads an optional `.env` file from:
 Use `/opt/xnetvn_monitord/config/.env.example` as a template and copy it to
 `.env` without committing secrets.
 
+Install and auto-update refresh `/opt/xnetvn_monitord/config/main.example.yaml`
+and `/opt/xnetvn_monitord/config/.env.example` on every install/upgrade, without
+overwriting `/opt/xnetvn_monitord/config/main.yaml` or `/opt/xnetvn_monitord/config/.env`.
+
 When using `${VAR}` in `config/main.yaml`, define environment variables via a
 systemd EnvironmentFile:
 

scripts/install.sh

@@ -124,13 +124,16 @@ copy_files() {
         exit 1
     fi
 
+    if [ -f "$SCRIPT_DIR/config/main.example.yaml" ]; then
+        cp "$SCRIPT_DIR/config/main.example.yaml" "$CONFIG_DIR/main.example.yaml"
+        log_info "Configuration example file refreshed"
+    else
+        log_warning "Configuration example file not found in repository"
+    fi
+
     if [ -f "$SCRIPT_DIR/config/.env.example" ]; then
-        if [ -f "$CONFIG_DIR/.env.example" ]; then
-            log_warning "Environment example already exists: $CONFIG_DIR/.env.example"
-        else
-            cp "$SCRIPT_DIR/config/.env.example" "$CONFIG_DIR/.env.example"
-            log_info "Environment example file copied"
-        fi
+        cp "$SCRIPT_DIR/config/.env.example" "$CONFIG_DIR/.env.example"
+        log_info "Environment example file refreshed"
     else
         log_warning "Environment example file not found in repository"
     fi

src/xnetvn_monitord/monitors/service_monitor.py

@@ -919,15 +919,32 @@ def _restart_service(self, service_config: Dict) -> bool:
                 subprocess.run(pre_hook, shell=True, timeout=30)
 
             # Restart the service
-            logger.info(f"Executing restart command for {service_name}: {resolved_command}")
             if isinstance(resolved_command, list):
-                result = subprocess.run(
+                for command in resolved_command:
+                    logger.info(
+                        "Executing restart command for %s: %s",
+                        service_name,
+                        command,
+                    )
+                    result = subprocess.run(
+                        command,
+                        shell=True,
+                        capture_output=True,
+                        text=True,
+                        timeout=60,
+                    )
+                    if result.returncode != 0:
+                        logger.warning(
+                            "Restart command returned non-zero for %s: %s",
+                            service_name,
+                            (result.stderr or result.stdout or "").strip(),
+                        )
+            else:
+                logger.info(
+                    "Executing restart command for %s: %s",
+                    service_name,
                     resolved_command,
-                    capture_output=True,
-                    text=True,
-                    timeout=60,
                 )
-            else:
                 result = subprocess.run(
                     resolved_command,
                     shell=True,
@@ -957,28 +974,53 @@ def _restart_service(self, service_config: Dict) -> bool:
             logger.error(f"Error restarting service {service_name}: {str(e)}", exc_info=True)
             return False
 
-    def _resolve_restart_command(self, restart_command: Optional[str], service_config: Dict) -> Optional[Any]:
+    def _resolve_restart_command(self, restart_command: Optional[Any], service_config: Dict) -> Optional[Any]:
         """Resolve restart command based on available service manager.
 
         Args:
             restart_command: Explicit restart command from configuration.
             service_config: Service configuration dictionary.
 
         Returns:
-            Command string or list, or None if not resolvable.
+            Command string, list of commands, or None if not resolvable.
         """
         service_name = service_config.get("service_name") or service_config.get("name")
         if not restart_command:
             if service_name:
                 return self.service_manager.build_restart_command(service_name)
             return None
 
-        command_value = restart_command.strip()
-        if command_value.startswith("systemctl") and not self.service_manager.is_systemd:
-            if service_name:
-                return self.service_manager.build_restart_command(service_name)
+        if isinstance(restart_command, list):
+            normalized_commands = [
+                str(command).strip()
+                for command in restart_command
+                if str(command).strip()
+            ]
+            if not normalized_commands:
+                if service_name:
+                    return self.service_manager.build_restart_command(service_name)
+                return None
+            return normalized_commands
 
-        return restart_command
+        if isinstance(restart_command, str):
+            command_value = restart_command.strip()
+            if not command_value:
+                if service_name:
+                    return self.service_manager.build_restart_command(service_name)
+                return None
+            if command_value.startswith("systemctl") and not self.service_manager.is_systemd:
+                if service_name:
+                    return self.service_manager.build_restart_command(service_name)
+            return command_value
+
+        logger.warning(
+            "Unsupported restart_command type for %s: %s",
+            service_name,
+            type(restart_command).__name__,
+        )
+        if service_name:
+            return self.service_manager.build_restart_command(service_name)
+        return None
 
     def reset_restart_history(self) -> None:
         """Reset all restart history and cooldown trackers."""

src/xnetvn_monitord/utils/update_checker.py

@@ -344,7 +344,8 @@ def apply_update(self, tarball_url: str) -> bool:
                     logger.error("No extracted release directory found")
                     return False
 
-                source_dir = extracted_dirs[0] / "src" / "xnetvn_monitord"
+                release_root = extracted_dirs[0]
+                source_dir = release_root / "src" / "xnetvn_monitord"
                 if not source_dir.exists():
                     logger.error("Release source directory not found: %s", source_dir)
                     return False
@@ -361,6 +362,24 @@ def apply_update(self, tarball_url: str) -> bool:
 
                 shutil.rmtree(target_dir)
                 shutil.copytree(source_dir, target_dir)
+
+                config_dir = self.install_dir / "config"
+                config_dir.mkdir(parents=True, exist_ok=True)
+                release_config_dir = release_root / "config"
+                if release_config_dir.exists():
+                    example_config = release_config_dir / "main.example.yaml"
+                    if example_config.exists():
+                        shutil.copy2(example_config, config_dir / "main.example.yaml")
+                    else:
+                        logger.warning("Release missing main.example.yaml")
+
+                    env_example = release_config_dir / ".env.example"
+                    if env_example.exists():
+                        shutil.copy2(env_example, config_dir / ".env.example")
+                    else:
+                        logger.warning("Release missing .env.example")
+                else:
+                    logger.warning("Release missing config directory")
         except Exception as exc:
             logger.error("Failed to apply update: %s", exc)
             return False

tests/unit/test_service_monitor.py

@@ -1390,6 +1390,47 @@ def test_should_restart_service_with_hooks(self, mocker):
 
         assert mock_run.call_count >= 2
 
+    def test_should_execute_restart_command_sequence(self, mocker):
+        """Test restart executes a list of commands sequentially."""
+        mock_run = mocker.patch("subprocess.run")
+        mock_run.return_value = MagicMock(returncode=0, stdout="ok", stderr="")
+        mocker.patch("time.sleep")
+
+        monitor = ServiceMonitor({"enabled": True, "restart_wait_time": 0})
+        service_config = {
+            "name": "nginx",
+            "restart_command": [
+                "systemctl restart nginx",
+                "bash /opt/xnetvn_monitord/scripts/custom-restart.sh",
+            ],
+            "check_method": "systemctl",
+            "service_name": "nginx",
+        }
+
+        mocker.patch.object(monitor, "_check_service", return_value={"running": True})
+
+        assert monitor._restart_service(service_config) is True
+
+        mock_run.assert_has_calls(
+            [
+                call(
+                    "systemctl restart nginx",
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                ),
+                call(
+                    "bash /opt/xnetvn_monitord/scripts/custom-restart.sh",
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                ),
+            ],
+            any_order=False,
+        )
+
     def test_should_execute_post_restart_hook_and_check_status(self, mocker):
         """Test post-restart hook execution and status verification."""
         mock_run = mocker.patch("subprocess.run")

tests/unit/test_update_checker.py

@@ -17,6 +17,8 @@
 from __future__ import annotations
 
 import json
+import shutil
+import tarfile
 from pathlib import Path
 
 import pytest
@@ -158,3 +160,61 @@ def test_should_handle_fetch_failure(self, tmp_path, monkeypatch) -> None:
         assert result.checked is True
         assert result.update_available is False
         assert "Failed to fetch" in result.message
+
+
+class TestUpdateCheckerApplyUpdate:
+    """Tests for applying updates and refreshing example files."""
+
+    def test_should_refresh_example_files_without_overwriting_user_config(
+        self, tmp_path, monkeypatch
+    ) -> None:
+        """Ensure example files are refreshed while user config stays intact."""
+        install_dir = tmp_path / "install"
+        install_dir.mkdir()
+
+        target_dir = install_dir / "xnetvn_monitord"
+        target_dir.mkdir()
+        (target_dir / "old.txt").write_text("old")
+
+        config_dir = install_dir / "config"
+        config_dir.mkdir()
+        (config_dir / "main.yaml").write_text("user-config")
+        (config_dir / ".env").write_text("SECRET=1")
+        (config_dir / "main.example.yaml").write_text("old example")
+        (config_dir / ".env.example").write_text("old env")
+
+        package_root = tmp_path / "package" / "xnetvn_monitord-1.1.0"
+        source_dir = package_root / "src" / "xnetvn_monitord"
+        source_dir.mkdir(parents=True)
+        (source_dir / "new.txt").write_text("new")
+
+        release_config = package_root / "config"
+        release_config.mkdir(parents=True)
+        (release_config / "main.example.yaml").write_text("new example")
+        (release_config / ".env.example").write_text("new env")
+
+        tarball_path = tmp_path / "release.tar.gz"
+        with tarfile.open(tarball_path, "w:gz") as tar_handle:
+            tar_handle.add(package_root, arcname=package_root.name)
+
+        def _fake_urlretrieve(url: str, filename: str) -> None:
+            shutil.copy(tarball_path, filename)
+
+        monkeypatch.setattr(
+            "xnetvn_monitord.utils.update_checker.request.urlretrieve",
+            _fake_urlretrieve,
+        )
+
+        state_file = tmp_path / "state.json"
+        checker = UpdateChecker(
+            _build_config(state_file),
+            current_version="1.0.0",
+            install_dir=install_dir,
+        )
+
+        assert checker.apply_update("https://example.com/release.tar.gz") is True
+        assert (install_dir / "xnetvn_monitord" / "new.txt").read_text() == "new"
+        assert (config_dir / "main.example.yaml").read_text() == "new example"
+        assert (config_dir / ".env.example").read_text() == "new env"
+        assert (config_dir / "main.yaml").read_text() == "user-config"
+        assert (config_dir / ".env").read_text() == "SECRET=1"