main.py

import os
import sys
import time
import shutil
import signal
import threading
import subprocess
import configparser
from git import Repo
from git.exc import GitCommandError


class ScriptMonitor:
    def __init__(self, config_file="config.ini"):
        self.config = self._load_config(config_file)
        self._validate_config()

        # Настройки репозитория
        self.repo_url = self.config["Repository"]["url"]
        self.branch = self.config.get("Repository", "branch", fallback="main")
        self.script_path = self.config["Repository"]["script_path"]
        self.token = self.config.get("Repository", "token")

        # Настройки монитора
        self.local_path = os.path.abspath(
            self.config.get("Repository", "local_path", fallback="repo")
        )
        self.check_interval = self.config.getint(
            "Monitor", "check_interval", fallback=60
        )
        self.max_restarts = self.config.getint("Monitor", "max_restarts", fallback=0)

        # Внутренние переменные
        self.process = None
        self.current_commit = None
        self.restart_count = 0
        self.input_thread = None
        self._normalize_repo_url()

        # Обеспечиваем корректное завершение
        signal.signal(signal.SIGINT, self._handle_signal)
        signal.signal(signal.SIGTERM, self._handle_signal)

    def _load_config(self, config_file):
        """Загрузка конфигурации"""
        config = configparser.ConfigParser()
        if not os.path.exists(config_file):
            self._create_default_config(config_file)
            print(
                f"Создан файл конфигурации {config_file}. Настройте его и перезапустите."
            )
            sys.exit(1)
        config.read(config_file)
        return config

    def _create_default_config(self, config_file):
        """Создание конфига по умолчанию"""
        config = configparser.ConfigParser()
        config["Repository"] = {
            "url": "https://github.com/username/private-repo.git",
            "script_path": "script/main.py",
            "branch": "main",
            "token": "your_github_token",
            "local_path": "repo",
        }
        config["Monitor"] = {"check_interval": "60", "max_restarts": "0"}
        with open(config_file, "w") as f:
            config.write(f)

    def _validate_config(self):
        """Проверка обязательных параметров"""
        required = ["url", "script_path"]
        for param in required:
            if param not in self.config["Repository"]:
                raise ValueError(f"Не указан обязательный параметр: {param}")

    def _normalize_repo_url(self):
        """Нормализация URL с аутентификацией"""
        if not self.token:
            return

        if "https://" in self.repo_url:
            self.repo_url = self.repo_url.replace("https://", f"https://{self.token}@")
        elif "git@" not in self.repo_url:
            raise ValueError("Неподдерживаемый формат URL репозитория")

    def _prepare_repo_dir(self):
        """Подготовка директории репозитория"""
        # Always create directory if not exists
        os.makedirs(self.local_path, exist_ok=True)
        

    def _check_for_updates(self, repo):
        """Проверка наличия обновлений в удаленном репозитории"""
        origin = repo.remotes.origin
        origin.fetch()

        local_commit = repo.head.commit.hexsha
        remote_commit = repo.refs[f"origin/{self.branch}"].commit.hexsha

        return local_commit != remote_commit

    def _clone_repo(self):
        """Клонирование репозитория"""
        print("Клонирование репозитория...")
        try:
            repo = Repo.clone_from(
                self.repo_url, self.local_path, branch=self.branch, depth=1
            )
        except GitCommandError as e:
            if "already exists and is not an empty directory" in str(e):
                print("Обнаружены существующие файлы, используем их как рабочую директорию")
                repo = Repo.init(self.local_path)
                try:
                    origin = repo.create_remote('origin', self.repo_url)
                except GitCommandError as e:
                    if "remote origin already exists" in str(e):
                        origin = repo.remote('origin')
                    else:
                        raise e
                origin.fetch()
                repo.git.checkout(f'origin/{self.branch}', force=True)
            else:
                raise e
                
        self.current_commit = repo.head.commit.hexsha
        return True

    def _ensure_repo(self):
        """Обеспечение наличия актуального репозитория"""
        try:
            self._prepare_repo_dir()
            return self._clone_repo()

        except GitCommandError as e:
            print(f"Ошибка Git: {e.stderr.strip()}")
            if "Authentication failed" in str(e):
                print("Ошибка аутентификации. Проверьте токен доступа.")
            raise

    def _get_script_full_path(self):
        """Получение полного пути к скрипту"""
        path = os.path.join(self.local_path, self.script_path)
        if not os.path.exists(path):
            raise FileNotFoundError(f"Скрипт не найден: {path}")
        return path

    def _setup_venv(self, only_requirements=False):
        """Создание виртуального окружения и установка зависимостей"""
        # Изменяем путь venv на уровень выше репозитория
        venv_dir = os.path.join(os.path.dirname(self.local_path), 'venv')
        requirements = os.path.join(self.local_path, 'requirements.txt')

        pip_executable = os.path.join(venv_dir, 'Scripts' if os.name == 'nt' else 'bin', 'pip')
        if only_requirements:
            if os.path.exists(requirements):
                print("Установка зависимостей из requirements.txt...")
                subprocess.run([pip_executable, "install", "-r", requirements], check=True)
            else:
                print("Файл requirements.txt не найден.")
            return
                
        # Создание venv если не существует
        if not os.path.exists(venv_dir):
            print("Создание виртуального окружения...")
            subprocess.run([sys.executable, "-m", "venv", venv_dir], check=True)
        
        python_executable = os.path.join(venv_dir, 'Scripts' if os.name == 'nt' else 'bin', 'python') 
        
        # Обновление pip до последней версии
        print("Обновление pip...")
        subprocess.run([python_executable, "-m", "pip", "install", "--upgrade", "pip"], check=True)

        # Установка gitpython в любом случае
        print("Установка обязательного пакета gitpython...")
        subprocess.run([pip_executable, "install", "gitpython"], check=True)

    def _handle_user_input(self):
        """Обработка ввода пользователя и передача его в дочерний процесс"""
        while self.process and self.process.poll() is None:
            try:
                user_input = input() + "\n"  # Чтение ввода с новой строки
                if self.process and self.process.poll() is None:
                    self.process.stdin.write(user_input)
                    self.process.stdin.flush()
            except (EOFError, BrokenPipeError, OSError):
                # Процесс завершился или канал закрыт
                break
            except Exception as e:
                print(f"Ошибка при обработке ввода: {e}")
                break

    def _start_script(self):
        """Запуск дочернего скрипта"""
        if self.process and self.process.poll() is None:
            self._stop_script()

        self._setup_venv(True)
        script_path = self._get_script_full_path()

        # Обновляем путь к venv в соответствии с новой структурой
        venv_dir = os.path.join(os.path.dirname(self.local_path), 'venv')
        venv_python = os.path.join(
            venv_dir,
            'Scripts' if os.name == 'nt' else 'bin',
            'python'
        )
        python_exec = venv_python if os.path.exists(venv_python) else sys.executable

        cmd = (
            [python_exec, script_path]
            if script_path.endswith(".py")
            else [script_path]
        )

        self.process = subprocess.Popen(
            cmd,
            cwd=os.path.dirname(script_path),
            stdout=sys.stdout,
            stderr=sys.stderr,
            stdin=subprocess.PIPE,
            universal_newlines=True,
            bufsize=1,  # Построчная буферизация
            text=True,
        )

        # Запускаем поток для обработки пользовательского ввода
        self.input_thread = threading.Thread(
            target=self._handle_user_input, daemon=True
        )
        self.input_thread.start()

        print(f"Дочерний скрипт запущен (PID: {self.process.pid})")

    def _stop_script(self):
        """Остановка дочернего скрипта"""
        if self.process:
            # Останавливаем поток ввода
            if self.input_thread and self.input_thread.is_alive():
                self.input_thread = None

            try:
                print(f"Остановка дочернего скрипта (PID: {self.process.pid})...")
                self.process.stdin.close()  # Закрываем stdin
                self.process.terminate()
                self.process.wait(timeout=5)
                print("Дочерний скрипт остановлен")
            except subprocess.TimeoutExpired:
                print("Принудительное завершение дочернего скрипта...")
                self.process.kill()
                self.process.wait()
                print("Дочерний скрипт принудительно завершен")
            except Exception as e:
                print(f"Ошибка при остановке скрипта: {e}")
            finally:
                self.process = None

    def _check_script_status(self):
        """Проверка состояния скрипта"""
        return self.process and self.process.poll() is None

    def _handle_signal(self, signum, frame):
        """Обработчик сигналов завершения"""
        print(f"\nПолучен сигнал {signum}, завершение...")
        self._stop_script()
        sys.exit(0)

    def run(self):
        """Основной цикл мониторинга"""
        print("\n=== Запуск монитора скриптов ===")
        print(f"Репозиторий: {self.repo_url}")
        print(f"Ветка: {self.branch}")
        print(f"Скрипт: {self.script_path}")
        print(f"Интервал проверки: {self.check_interval} сек")
        print(
            "Для ввода данных в дочерний скрипт просто введите текст и нажмите Enter\n"
        )

        try:
            # Создание директории и настройка окружения перед клонированием
            self._prepare_repo_dir()
            self._setup_venv()  # Перенесено выше инициализации репозитория
            
            # Инициализация репозитория
            repo_updated = self._ensure_repo()
            self._start_script()

            # Основной цикл
            while True:
                time.sleep(self.check_interval)

                update = False
                restart = False
                # Проверка состояния скрипта
                if not self._check_script_status():
                    self.restart_count += 1
                    if self.max_restarts > 0 and self.restart_count > self.max_restarts:
                        print("Достигнут лимит перезапусков. Завершение.")
                        break

                    restart = True

                # Проверка обновлений репозитория
                if os.path.exists(os.path.join(self.local_path, ".git")):
                    repo = Repo(self.local_path)
                    if self._check_for_updates(repo):
                        print("Обнаружены обновления. Обновление репозитория...")
                        if self._clone_repo():
                            update = True
                
                if update:
                    print("Перезапуск скрипта после обновления...")
                    self._start_script()
                elif restart:
                    print("Перезапуск дочернего скрипта...")
                    self._start_script()

        except Exception as e:
            print(f"Критическая ошибка: {str(e)}")
        finally:
            self._stop_script()


if __name__ == "__main__":
    monitor = ScriptMonitor()
    monitor.run()