Старый postinstall

postinstall/option/docker.py

@@ -0,0 +1,533 @@
+import subprocess
+import os
+import re
+import shlex
+from abc import ABC, abstractmethod
+from typing import Optional, List, Callable
+
+from dialog import Dialog
+from postinstall.logger import logger
+
+import socket
+
+REGISTRY_URL = "dr.gosrv.ru"
+REGISTRY_LOGIN = "anon_user"
+REGISTRY_PASSWORD = "Qweasdzxc123C@"
+DOCKER_COMPOSE_FILE_PATH = "/usr/local/share/postinstall/portainer/"
+
+
+class CommandExecutor:
+    @staticmethod
+    def run_command(
+        command: str,
+        shell: bool = False,
+        input_data: Optional[str] = None,
+        ignore_errors: List[int] = [],
+    ) -> subprocess.CompletedProcess:
+        try:
+            return subprocess.run(
+                command if shell else shlex.split(command),
+                shell=shell,
+                check=True,
+                input=input_data,
+                text=True,
+                capture_output=True,
+            )
+        except subprocess.CalledProcessError as e:
+            if e.returncode not in ignore_errors:
+                logger.error(f"Ошибка выполнения команды: {e}")
+                raise
+            else:
+                logger.warning(
+                    f"Команда завершилась с игнорируемым кодом ошибки {e.returncode}: {e}"
+                )
+                return e
+
+
+class SystemChecker:
+    @staticmethod
+    def is_command_installed(command: str) -> bool:
+        try:
+            return CommandExecutor.run_command(f"which {command}").returncode == 0
+        except subprocess.CalledProcessError:
+            return False
+
+
+class ProgressGauge:
+    def __init__(self, dialog: Dialog, title: str, total_steps: int):
+        self.dialog = dialog
+        self.title = title
+        self.total_steps = total_steps
+        self.current_step = 0
+
+    def update(self, step: int, message: str):
+        self.current_step = step
+        percent = int((step / self.total_steps) * 100)
+        self.dialog.gauge_update(percent, f"{message} ({percent}%)", update_text=True)
+
+    def __enter__(self):
+        self.dialog.gauge_start(self.title, percent=0)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.dialog.gauge_stop()
+
+
+class DockerManager:
+    @staticmethod
+    def install(progress_callback: Callable[[int, str], None]):
+        logger.info("Установка Docker...")
+        progress_callback(1, "Обновление пакетов")
+        CommandExecutor.run_command("apt-get update")
+        progress_callback(2, "Установка Docker")
+        CommandExecutor.run_command("apt-get install -y docker.io")
+        progress_callback(3, "Установка Docker Compose")
+        CommandExecutor.run_command("apt-get install -y docker-compose")
+        progress_callback(4, "Выполнение входа в Docker registry")
+        DockerManager.login_to_registry()
+        progress_callback(5, "Docker успешно установлен")
+        logger.info("Docker успешно установлен")
+
+    @staticmethod
+    def uninstall(progress_callback: Callable[[int, str], None]):
+        logger.info("Удаление Docker...")
+        progress_callback(1, "Удаление Docker и Docker Compose")
+        CommandExecutor.run_command("apt-get remove -y docker.io docker-compose")
+        progress_callback(2, "Очистка зависимостей")
+        CommandExecutor.run_command("apt-get autoremove -y")
+        progress_callback(3, "Удаление файлов Docker")
+        CommandExecutor.run_command("rm -rf /var/run/docker")
+        CommandExecutor.run_command("rm -rf /var/lib/docker")
+        progress_callback(4, "Docker успешно удален")
+        logger.info("Docker успешно удален")
+
+    @staticmethod
+    def login_to_registry():
+        logger.info("Выполняется вход в Docker registry...")
+        try:
+            result = CommandExecutor.run_command(
+                f"echo {REGISTRY_PASSWORD} | docker login --username {REGISTRY_LOGIN} --password-stdin {REGISTRY_URL}",
+                shell=True,
+            )
+            logger.info("Успешный вход в Docker registry")
+            logger.debug(f"Docker login output: {result.stdout}")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Ошибка входа в Docker registry: {e}")
+            logger.error(f"Stderr: {e.stderr}")
+            raise
+
+
+class UFWManager:
+    @staticmethod
+    def add_rule(port: str):
+        rule_name = "portainer"
+        logger.info(
+            f"Добавление именованного правила UFW '{rule_name}' для порта {port}..."
+        )
+        CommandExecutor.run_command(f"sudo ufw allow {port}/tcp comment '{rule_name}'")
+        CommandExecutor.run_command(f"sudo ufw app update {rule_name}")
+        logger.info(
+            f"Именованное правило UFW '{rule_name}' для порта {port} успешно добавлено"
+        )
+
+    @staticmethod
+    def remove_rule(port: str):
+        rule_name = "portainer"
+        logger.info(
+            f"Удаление именованного правила UFW '{rule_name}' для порта {port}..."
+        )
+        CommandExecutor.run_command(f"sudo ufw delete allow {port}/tcp")
+        CommandExecutor.run_command(f"sudo ufw app update {rule_name}")
+        logger.info(
+            f"Именованное правило UFW '{rule_name}' для порта {port} успешно удалено"
+        )
+
+
+class PortainerManager:
+    @staticmethod
+    def install(
+        port: str, password: str, ip: str, progress_callback: Callable[[int, str], None]
+    ):
+        logger.info("Установка Portainer...")
+        progress_callback(1, "Вход в Docker registry")
+        DockerManager.login_to_registry()
+        progress_callback(2, "Остановка предыдущей версии Portainer")
+        try:
+            CommandExecutor.run_command(
+                f"sudo docker-compose -f {DOCKER_COMPOSE_FILE_PATH}docker-compose.yml down",
+                ignore_errors=[1],
+            )
+        except subprocess.CalledProcessError:
+            pass
+
+        progress_callback(3, "Удаление старых данных Portainer")
+        try:
+            CommandExecutor.run_command(
+                "docker volume ls -q -f name=portainer* | xargs -r docker volume rm",
+                ignore_errors=[1],
+            )
+        except subprocess.CalledProcessError:
+            pass
+
+        progress_callback(4, "Установка apache2-utils для htpasswd")
+        if not SystemChecker.is_command_installed("htpasswd"):
+            CommandExecutor.run_command("apt-get install -y apache2-utils")
+
+        progress_callback(5, "Создание конфигурации Portainer")
+        os.makedirs(os.path.dirname(DOCKER_COMPOSE_FILE_PATH), exist_ok=True)
+        password_hash = PortainerManager._generate_password_hash(password)
+        PortainerManager._create_docker_compose_file(port, password_hash, ip)
+
+        progress_callback(6, "Запуск Portainer")
+        CommandExecutor.run_command(
+            f"sudo docker-compose -f {DOCKER_COMPOSE_FILE_PATH}docker-compose.yml up -d"
+        )
+
+        # if ip != "127.0.0.1":
+        if True:
+            progress_callback(7, "Добавление правила UFW")
+            UFWManager.add_rule(port)
+
+        progress_callback(8, "Portainer успешно установлен")
+        logger.info("Portainer успешно установлен")
+
+    @staticmethod
+    def uninstall(progress_callback: Callable[[int, str], None]):
+        logger.info("Удаление Portainer...")
+        progress_callback(1, "Остановка Portainer")
+        try:
+            CommandExecutor.run_command(
+                f"docker-compose -f {DOCKER_COMPOSE_FILE_PATH}docker-compose.yml down --volumes",
+                ignore_errors=[1],
+            )
+        except subprocess.CalledProcessError:
+            pass
+        progress_callback(2, "Удаление файлов конфигурации")
+        CommandExecutor.run_command(
+            f"rm -f {DOCKER_COMPOSE_FILE_PATH}docker-compose.yml"
+        )
+        # try:
+        #     with open(f"{DOCKER_COMPOSE_FILE_PATH}docker-compose.yml", "r") as f:
+        #         config = f.read()
+        #         port_ip_match = re.search(r'"(.+):(\d+):9000"', config)
+        #         if port_ip_match:
+        #             ip, port = port_ip_match.groups()
+        #             # if True:
+        #                 # progress_callback(3, "Удаление правила UFW")
+        #                 # UFWManager.remove_rule(port)
+        # except FileNotFoundError:
+        #     logger.warning("Файл конфигурации не найден. Пропуск удаления правила UFW.")
+
+        progress_callback(4, "Portainer успешно удален")
+        logger.info("Portainer успешно удален")
+
+    @staticmethod
+    def _generate_password_hash(password: str) -> str:
+        return CommandExecutor.run_command(
+            f"htpasswd -nbB admin {shlex.quote(password)} | cut -d ':' -f 2 | sed 's/\\$/\\$\\$/g'",
+            shell=True,
+        ).stdout.strip()
+
+    @staticmethod
+    def _create_docker_compose_file(port: str, password_hash: str, ip: str):
+        docker_compose_content = f"""
+version: '2'
+
+services:
+  portainer:
+    image: {REGISTRY_URL}/base_images/portainer:latest
+    ports:
+      - "{ip}:{port}:9000"
+    command: --admin-password '{password_hash}'
+    networks:
+      - local
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - portainer-data:/data
+    environment:
+      - PORTAINER_LOCAL_IMAGES_ENVIRONMENT_ID=1
+    deploy:
+      mode: global
+
+networks:
+  local:
+    driver: bridge
+
+volumes:
+  portainer-data:
+        """
+        with open(f"{DOCKER_COMPOSE_FILE_PATH}docker-compose.yml", "w") as f:
+            f.write(docker_compose_content)
+
+
+class InputValidator:
+    @staticmethod
+    def validate(value: str, pattern: str) -> bool:
+        return bool(re.match(pattern, value))
+
+
+class UIElement(ABC):
+    def __init__(self, dialog: Dialog):
+        self.dialog = dialog
+
+    @abstractmethod
+    def show(self):
+        pass
+
+
+class Menu(UIElement):
+    def show(self):
+        choices = []
+        if not SystemChecker.is_command_installed("docker"):
+            choices.append(("1", "Установить Docker"))
+        else:
+            choices.append(("1", "Удалить Docker"))
+
+        if SystemChecker.is_command_installed("docker"):
+            if not os.path.exists(f"{DOCKER_COMPOSE_FILE_PATH}docker-compose.yml"):
+                choices.append(("2", "Установить Portainer"))
+            else:
+                choices.append(("2", "Удалить Portainer"))
+
+        code, choice = self.dialog.menu("Выберите действие:", choices=choices)
+        return code, choice
+
+
+class YesNoUI(UIElement):
+    def show(self, text: str):
+        return self.dialog.yesno(text) == self.dialog.OK
+
+
+class PasswordInput(UIElement):
+    def show(self):
+        while True:
+            code, password = self.dialog.passwordbox(
+                "Введите пароль для Portainer:", insecure=True
+            )
+            if code == self.dialog.CANCEL:
+                return None
+            if InputValidator.validate(password, r"^.{12,}$"):
+                return password
+            self.dialog.msgbox(
+                "Пароль должен содержать минимум 12 символов.", width=50, height=10
+            )
+
+
+class PortInput(UIElement):
+    def show(self):
+        while True:
+            code, port = self.dialog.inputbox(
+                "Введите порт для Portainer:", init="9000"
+            )
+            if code == self.dialog.CANCEL:
+                return None
+            if InputValidator.validate(port, r"^[1-9][0-9]{0,4}$"):
+                return port
+            self.dialog.msgbox(
+                "Некорректный порт. Введите число от 1 до 65535.", width=50, height=10
+            )
+
+
+class IPInput(UIElement):
+    def get_default_interface_ip(self):
+        try:
+            # Выполнение команды для получения IP-адреса основного интерфейса
+            command = "ip -o -4 addr show $(ip route | grep default | awk '{print $5}') | awk '{print $4}' | cut -d/ -f1"
+            result = subprocess.check_output(command, shell=True, text=True)
+            return result.strip()  # Возвращаем IP-адрес без лишних символов
+        except subprocess.CalledProcessError:
+            return "127.0.0.1"  # В случае ошибки вернём стандартный IP
+
+    def show(self):
+        # Получаем IP-адрес основного сетевого интерфейса
+        default_ip = self.get_default_interface_ip()
+
+        while True:
+            # Используем полученный IP-адрес как начальное значение
+            code, ip = self.dialog.inputbox(
+                "Введите IP адрес для Portainer:", init=default_ip
+            )
+            if code == self.dialog.CANCEL:
+                return None
+            if InputValidator.validate(ip, r"^(\d{1,3}\.){3}\d{1,3}$"):
+                return ip
+            self.dialog.msgbox(
+                "Некорректный IP адрес. Введите адрес в формате X.X.X.X",
+                width=50,
+                height=10,
+            )
+
+
+class NetworkInterfaceInput(UIElement):
+    def get_network_interfaces(self):
+        try:
+            # Get all network interfaces
+            interfaces = subprocess.check_output(
+                "ip -o link show", shell=True, text=True
+            )
+            # Extract interface names and their IP addresses
+            interface_list = []
+            for line in interfaces.split("\n"):
+                if line:
+                    interface = line.split(":")[1].strip()
+                    ip = self.get_ip_address(interface)
+                    if ip:
+                        interface_list.append((interface, ip))
+            return interface_list
+        except subprocess.CalledProcessError:
+            return []
+
+    def get_ip_address(self, interface):
+        try:
+            ip = subprocess.check_output(
+                f"ip -o -4 addr list {interface}", shell=True, text=True
+            )
+            return ip.split()[3].split("/")[0]
+        except subprocess.CalledProcessError:
+            return None
+
+    def show(self):
+        interfaces = self.get_network_interfaces()
+        if not interfaces:
+            self.dialog.msgbox(
+                "Не удалось получить список сетевых интерфейсов.", width=50, height=10
+            )
+            return None
+
+        choices = [(f"{interface} ({ip})", interface) for interface, ip in interfaces]
+        code, choice = self.dialog.menu(
+            "Выберите сетевой интерфейс для Docker Swarm:", choices=choices
+        )
+
+        if code == self.dialog.OK:
+            return choice
+        return None
+
+
+class DockerConfigUI:
+    def __init__(self):
+        self.dialog = Dialog(dialog="dialog")
+        self.menu = Menu(self.dialog)
+        self.password_input = PasswordInput(self.dialog)
+        self.port_input = PortInput(self.dialog)
+        self.ip_input = IPInput(self.dialog)
+        self.network_interface_input = NetworkInterfaceInput(self.dialog)
+
+    def run(self):
+        try:
+            while True:
+                code, choice = self.menu.show()
+                if code == self.dialog.OK:
+                    if choice == "1":
+                        self._handle_docker()
+                    elif choice == "2":
+                        self.handle_portainer()
+                    elif choice == "3":
+                        break
+                else:
+                    break
+        except Exception as e:
+            logger.error(f"Произошла ошибка: {e}")
+            self.dialog.msgbox(f"Произошла ошибка: {str(e)}", width=50, height=10)
+
+    def _handle_docker(self):
+        if not SystemChecker.is_command_installed("docker"):
+            with ProgressGauge(self.dialog, "Установка Docker", 4) as gauge:
+                DockerManager.install(gauge.update)
+            self.dialog.msgbox("Docker успешно установлен.", width=50, height=10)
+            logger.info("Docker успешно установлен.")
+            yes_no_ui = YesNoUI(self.dialog)
+            if yes_no_ui.show(
+                text="Вы хотите установить Docker Swarm - инструмент для управления кластером докер серверов?"
+            ):
+                interface = self.network_interface_input.show()
+                if interface:
+                    ip = interface.split("(")[1].split(")")[0]
+                    if ip:
+                        try:
+                            CommandExecutor.run_command(
+                                f"docker swarm init --advertise-addr {ip}"
+                            )
+                            self.dialog.msgbox(
+                                f"Docker Swarm успешно инициализирован на интерфейсе {interface}",
+                                width=50,
+                                height=10,
+                            )
+                        except subprocess.CalledProcessError as e:
+                            self.dialog.msgbox(
+                                f"Ошибка при инициализации Docker Swarm: {str(e)}",
+                                width=50,
+                                height=10,
+                            )
+                    else:
+                        self.dialog.msgbox(
+                            f"Не удалось получить IP-адрес для интерфейса {interface}.",
+                            width=50,
+                            height=10,
+                        )
+                else:
+                    self.dialog.msgbox(
+                        "Инициализация Docker Swarm отменена.", width=50, height=10
+                    )
+
+            if yes_no_ui.show(
+                text="Вы хотите установить Portainer - удобный Web интерфейс для управления докер контейнерами?"
+            ):
+                self.handle_portainer()
+        else:
+            with ProgressGauge(self.dialog, "Удаление Docker", 4) as gauge:
+                PortainerManager.uninstall(gauge.update)
+                DockerManager.uninstall(gauge.update)
+            self.dialog.msgbox("Docker успешно удален.", width=50, height=10)
+            logger.info("Docker успешно удален.")
+
+    def handle_portainer(self):
+        if not SystemChecker.is_command_installed("docker"):
+            self.dialog.msgbox(
+                "Docker не установлен. Пожалуйста, сначала установите Docker.",
+                width=50,
+                height=10,
+            )
+            return
+
+        if not os.path.exists(f"{DOCKER_COMPOSE_FILE_PATH}docker-compose.yml"):
+            self._install_portainer()
+        else:
+            with ProgressGauge(self.dialog, "Удаление Portainer", 3) as gauge:
+                PortainerManager.uninstall(gauge.update)
+            self.dialog.msgbox("Portainer успешно удален.", width=50, height=10)
+            logger.info("Portainer успешно удален.")
+
+    def _install_portainer(self):
+        password = self.password_input.show()
+        if not password:
+            return
+
+        port = self.port_input.show()
+        if not port:
+            return
+
+        ip = self.ip_input.show()
+        if not ip:
+            return
+
+        try:
+            with ProgressGauge(self.dialog, "Установка Portainer", 6) as gauge:
+                PortainerManager.install(port, password, ip, gauge.update)
+            self.dialog.msgbox(
+                f"Portainer успешно установлен.\nВы можете войти в Portainer по адресу {ip}:{port} используя логин admin и введенный пароль",
+                width=50,
+                height=10,
+            )
+            logger.info(
+                f"Portainer успешно установлен.\nВы можете войти в Portainer по адресу {ip}:{port} используя логин admin и введенный пароль"
+            )
+        except Exception as e:
+            self.dialog.msgbox(
+                f"Ошибка при установке Portainer: {str(e)}", width=50, height=10
+            )
+
+
+def run():
+    ui = DockerConfigUI()
+    ui.run()