mt5-manager/deploy_service.py

'''
File: deploy_service.py
Description: Разворачивает сервис ServiceStateWriter по всем терминалам из
config.json - обновляет исходный код через git, компилирует его через
MetaEditor (ME) и раскладывает config/services.ini.
'''

__version__ = '0.4.0'

import argparse
import os
import re
import shutil
import subprocess
import sys
import uuid
from pathlib import Path

from config import ConfigStore, instance_directory
from mt5_control import MT5_Control

SCRIPT_DIR = Path(__file__).resolve().parent
SHARED_REL = Path('MQL5/Shared Projects/mt5-manager')
SERVICE_NAME = 'ServiceStateWriter'
SERVICE_MQ5 = f'{SERVICE_NAME}.mq5'
SERVICE_EX5_REL = Path('MQL5/Services/Shared Projects/mt5-manager') / f'{SERVICE_NAME}.ex5'
SERVICES_INI_REL = Path('static/services.ini')


def services_ini_update(terminal_dir: Path, template: Path, database: str) -> tuple[Path, str, bool]:
    '''Готовит запись нашего сервиса, сохраняя остальные сервисы и их параметры.'''
    target = terminal_dir / 'config/services.ini'
    try:
        current = target.read_text(encoding='utf-16') if target.is_file() and target.stat().st_size else ''
        sample = template.read_text(encoding='utf-16')
    except UnicodeError as error:
        raise ValueError('services.ini должен быть в UTF-16; файл не изменён.') from error
    blocks = list(re.finditer(r'<service>.*?</service>', current, re.I | re.S))
    if (len(re.findall(r'<service>', current, re.I)) != len(blocks)
            or len(re.findall(r'</service>', current, re.I)) != len(blocks)):
        raise ValueError('Некорректные секции в services.ini; файл не изменён.')

    def field(text, key):
        found = re.search(rf'(?mi)^[ \t]*{re.escape(key)}[ \t]*=(.*)$', text)
        return found.group(1).strip() if found else ''

    def set_field(text, key, value, marker):
        pattern = rf'(?mi)^[ \t]*{re.escape(key)}[ \t]*=.*$'
        if re.search(pattern, text):
            return re.sub(pattern, lambda _: f'{key}={value}', text)
        return re.sub(re.escape(marker), lambda match: f'{key}={value}\n' + match.group(),
                      text, count=1, flags=re.I)

    expected_path = str(SERVICE_EX5_REL.relative_to('MQL5')).replace('/', '\\')
    owned = [block for block in blocks
             if (field(block.group(), 'name').casefold() == SERVICE_NAME.casefold()
                 or field(block.group(), 'path').replace('/', '\\').casefold() == expected_path.casefold())]
    if len(owned) > 1:
        raise ValueError('В services.ini несколько записей ServiceStateWriter; устраните дублирование.')
    entry = owned[0].group() if owned else sample.strip()
    if not re.fullmatch(r'<service>.*?</service>', entry, re.I | re.S):
        raise ValueError('Некорректный образец services.ini.')
    for key, value in (('name', SERVICE_NAME), ('path', expected_path), ('enabled', '1')):
        entry = set_field(entry, key, value, '</service>')
    if (len(re.findall(r'<inputs>', entry, re.I)) != len(re.findall(r'</inputs>', entry, re.I))
            or len(re.findall(r'<inputs>', entry, re.I)) > 1):
        raise ValueError('Некорректная секция inputs в services.ini; файл не изменён.')
    if not re.search(r'<inputs>.*?</inputs>', entry, re.I | re.S):
        entry = re.sub(r'</service>', '<inputs>\n</inputs>\n</service>', entry, count=1, flags=re.I)
    database_name = Path(database).name
    if not database_name or any(character in database_name for character in '\r\n\x00'):
        raise ValueError('Некорректное имя базы для services.ini.')
    entry = set_field(entry, 'InpDatabase', database_name, '</inputs>')
    if owned:
        block = owned[0]
        updated = current[:block.start()] + entry + current[block.end():]
    else:
        updated = current.rstrip() + '\n' + entry + '\n'
    return target, updated, updated != current


def write_services_ini(target: Path, text: str) -> None:
    target.parent.mkdir(parents=True, exist_ok=True)
    temporary = target.with_name(target.name + '.' + uuid.uuid4().hex + '.tmp')
    try:
        temporary.write_text(text, encoding='utf-16')
        os.replace(temporary, target)
    finally:
        temporary.unlink(missing_ok=True)


def reference_terminal(project: Path, configured: str = '') -> Path | None:
    '''Явная установка MT5 или установка с проектом в MQL5/Shared Projects.'''
    if configured:
        return Path(configured).resolve()
    project = Path(project).resolve()
    if (project.parent.name.casefold() == 'shared projects'
            and project.parent.parent.name.casefold() == 'mql5'):
        return project.parent.parent.parent
    return None


def service_build_paths(project: Path, data: dict) -> tuple[Path, Path, Path]:
    '''Компилятор, исходник и результат сборки без привязки проекта к MT5.'''
    project = Path(project).resolve()
    uploaded_editor = Path(data.get('terminal_template', project / 'terminal-template')) / 'MetaEditor64.exe'
    reference = reference_terminal(project, data.get('mt5_installation', ''))
    editor = (uploaded_editor if uploaded_editor.is_file() or reference is None
              else reference / 'MetaEditor64.exe')
    source = project / SERVICE_MQ5
    # Для Shared Projects MetaEditor переносит сервис в MQL5/Services.
    # В отдельном репозитории EX5 создаётся рядом с исходником.
    enclosing = reference_terminal(project)
    output = (enclosing / 'MQL5/Services/Shared Projects' / project.name / f'{SERVICE_NAME}.ex5'
              if enclosing else source.with_suffix('.ex5'))
    return editor, source, output


def run(args: list | str, cwd: Path | None = None, timeout: int | None = None) -> subprocess.CompletedProcess:
    return subprocess.run(args, cwd=cwd, capture_output=True, text=True, timeout=timeout)


def git_output(args: list, cwd: Path) -> str:
    return run(['git', *args], cwd=cwd).stdout.strip()


def current_repo_info() -> tuple[str, Path, str]:
    '''Определяет ветку, корень и URL репозитория по текущему рабочему дереву,
    из которого запущен сам скрипт - это и есть источник для развёртывания.
    '''
    branch = git_output(['rev-parse', '--abbrev-ref', 'HEAD'], SCRIPT_DIR)
    repo_root = Path(git_output(['rev-parse', '--show-toplevel'], SCRIPT_DIR))
    remote_url = git_output(['config', '--get', 'remote.origin.url'], SCRIPT_DIR)
    return branch, repo_root, remote_url


def update_source(shared_dir: Path, repo_root: Path, repo_url: str, branch: str) -> bool:
    '''Обновляет исходный код сервиса в shared_dir до указанной ветки.

    Возвращает False, если что-то пошло не так и терминал стоит пропустить.
    Исходник в repo_root не трогаем - это и есть текущее рабочее дерево.
    '''
    if shared_dir.resolve() == repo_root.resolve():
        print(f'  {shared_dir}: это текущий репозиторий, git не трогаем')
        return True

    if not (shared_dir / '.git').exists():
        print(f'  Клонирую {repo_url} (ветка {branch})')
        shared_dir.parent.mkdir(parents=True, exist_ok=True)
        result = run(['git', 'clone', '--branch', branch, repo_url, str(shared_dir)])
        if result.returncode != 0:
            print(f'  ОШИБКА клонирования: {result.stderr.strip()}')
            return False
        return True

    # Незакоммиченные изменения не трогаем - мало ли, зачем они там оказались
    if git_output(['status', '--porcelain'], shared_dir):
        print(f'  {shared_dir}: есть незакоммиченные изменения, git pull пропущен')
        return True

    run(['git', 'fetch', 'origin'], shared_dir)

    checkout = run(['git', 'checkout', branch], shared_dir)
    if checkout.returncode != 0:
        print(f'  ОШИБКА checkout {branch}: {checkout.stderr.strip()}')
        return False

    pull = run(['git', 'pull', '--ff-only', 'origin', branch], shared_dir)
    if pull.returncode != 0:
        print(f'  ОШИБКА pull: {pull.stderr.strip()}')
        return False

    commit = git_output(['rev-parse', '--short', 'HEAD'], shared_dir)
    print(f'  Обновлено до {branch} ({commit})')
    return True


def read_log(log_path: Path) -> str:
    if not log_path.exists():
        return ''
    for encoding in ('utf-16', 'utf-8', 'cp1251'):
        try:
            return log_path.read_text(encoding=encoding)
        except (UnicodeError, UnicodeDecodeError):
            continue
    return log_path.read_text(errors='replace')


def compile_service(metaeditor: Path, mq5_path: Path, ex5_path: Path, *, force: bool = False) -> bool:
    '''Собирает сервис и проверяет обновление EX5, а не только код возврата ME.'''
    log_path = mq5_path.parent / 'compile.log'

    if not metaeditor.exists():
        print(f'ОШИБКА: не найден {metaeditor}')
        return False
    if not mq5_path.exists():
        print(f'ОШИБКА: не найден {mq5_path}')
        return False

    before = ex5_path.stat().st_mtime_ns if ex5_path.is_file() else None

    # Если .ex5 уже новее исходника (например, его собрали вручную в
    # MetaEditor по F7), повторная компиляция не нужна
    if (not force and before is not None and ex5_path.stat().st_size
            and before >= mq5_path.stat().st_mtime_ns):
        print(f'Компиляция пропущена, {ex5_path.name} уже новее исходника')
        return True

    try:
        # ME требует кавычки вокруг значения после двоеточия. Обычный
        # list2cmdline для всего аргумента с пробелами приводит к пустому запуску.
        command = (subprocess.list2cmdline([str(metaeditor)])
                   + f' /portable /compile:"{mq5_path}" /log:"{log_path}"')
        run(command, timeout=120)
    except (OSError, subprocess.TimeoutExpired):
        print('ОШИБКА: MetaEditor не запустился или компиляция превысила 120 секунд.')
        return False

    log_text = read_log(log_path)
    log_path.unlink(missing_ok=True)

    after = ex5_path.stat().st_mtime_ns if ex5_path.is_file() else None
    if after is None or after == before or not ex5_path.stat().st_size:
        print('ОШИБКА: MetaEditor завершился, но .ex5 не обновился.')
        print('Откройте '
              f'{mq5_path} в MetaEditor вручную и нажмите F7, затем '
              'запустите скрипт заново (шаг компиляции пропустится сам,'
              ' раз .ex5 уже свежий).')
        if log_text.strip():
            print('  ' + log_text.replace('\n', '\n  ').strip())
        return False

    print(f'Скомпилировано: {ex5_path}')
    return True


def compile_reference(reference_dir: Path, *, force: bool = False) -> bool:
    '''Совместимость со сборкой из стандартной папки Shared Projects.'''
    return compile_service(reference_dir / 'MetaEditor64.exe',
                           reference_dir / SHARED_REL / SERVICE_MQ5,
                           reference_dir / SERVICE_EX5_REL, force=force)


def deploy_ex5(terminal_dir: Path, ex5_path: Path) -> bool:
    dst = terminal_dir / SERVICE_EX5_REL
    dst.parent.mkdir(parents=True, exist_ok=True)
    shutil.copyfile(ex5_path, dst)
    print('  .ex5 скопирован')
    return True


def deploy_services_ini(terminal_dir: Path, src: Path, database: str, *, running: bool = False) -> bool:
    try:
        target, text, changed = services_ini_update(terminal_dir, src, database)
        if changed:
            if running:
                raise ValueError('Остановите терминал и повторите развёртывание для обновления services.ini.')
            write_services_ini(target, text)
    except (OSError, ValueError) as error:
        print(f'  ОШИБКА services.ini: {error}')
        return False
    print('  services.ini: автозапуск настроен')
    return True


def main():
    branch_default, repo_root, repo_url_default = current_repo_info()

    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--config-file', default='config.json',
                        help='Путь к файлу конфигурации менеджера')
    parser.add_argument('--branch', default=branch_default,
                        help=f'Ветка для развёртывания (сейчас: {branch_default})')
    parser.add_argument('--repo-url', default=repo_url_default,
                        help='URL репозитория для клонирования на новых терминалах')
    args = parser.parse_args()

    data = ConfigStore(args.config_file).data

    terminal_dirs = {name: instance_directory(data['mt5_folder'], name) for name in data['terminals']}

    print('=== Обновление исходного кода ===')
    ok = True
    for name, terminal_dir in terminal_dirs.items():
        print(f'--- {name} ---')
        if not terminal_dir.exists():
            print(f'  ОШИБКА: папка терминала не найдена: {terminal_dir}')
            ok = False
            continue
        if not update_source(terminal_dir / SHARED_REL, repo_root, args.repo_url, args.branch):
            ok = False

    print('\n=== Компиляция ===')
    editor, source, ex5_path = service_build_paths(repo_root, data)
    compiled = compile_service(editor, source, ex5_path)
    ok = ok and compiled

    print('\n=== Раскладка .ex5 и services.ini ===')
    services_ini_src = repo_root / SERVICES_INI_REL
    control = MT5_Control(data['terminals'], data['mt5_folder'], data['database'], data['mt5_exe'])
    running_now = {name for name, info in control.load_instances().items() if info.get('pid')}
    for name, terminal_dir in terminal_dirs.items():
        if not terminal_dir.exists():
            continue
        print(f'--- {name} ---')
        if compiled and (terminal_dir / SERVICE_EX5_REL).resolve() != ex5_path.resolve():
            if not deploy_ex5(terminal_dir, ex5_path):
                ok = False
        if not deploy_services_ini(terminal_dir, services_ini_src, data['database'], running=name in running_now):
            ok = False

    # Напоминание, какие терминалы сейчас запущены - у них в памяти всё ещё
    # старый .ex5, свежий файл на диске сам по себе не перезагрузится
    running = [n for n, i in control.load_instances().items() if i.get('pid')]

    print()
    if not ok:
        print('Готово с ошибками, см. вывод выше.')
    if running:
        print('Запущены сейчас (нужен перезапуск, чтобы подхватить новый .ex5): '
              + ', '.join(running))
    if ok and not running:
        print('Готово.')

    sys.exit(0 if ok else 1)


if __name__ == '__main__':
    main()