Посольство для дураков

#!/bin/bash # ====================================================================== # Самораспаковывающийся установщик системы "Локи" v3.0 # Фрактально-зеркальные нано-симуляции с интеграцией проекта "Зевс" # Кроссплатформенная версия (Linux, Android, WSL2) # ====================================================================== set -euo pipefail exec > >(tee -i /var/log/loki_installation.log) exec 2>&1 # Глобальные параметры системы LOKI_VERSION="3.0" ZEUS_INTEGRATION_VERSION="1.2" INSTALL_DIR="/opt/loki_system" FRACTAL_LEVEL="9" NANO_SIMULATIONS="1000" MIRRORING_ITERATIONS="7" ZEUS_API_URL="https://zeus.api/project/loki" # Определение платформы detect_platform() { if [ -d "/data/data/com.termux/files" ]; then echo "android" elif grep -q Microsoft /proc/version 2>/dev/null; then echo "wsl" elif [ "$(uname -s)" = "Linux" ]; then echo "linux" elif [ "$(uname -s)" = "Darwin" ]; then echo "macos" else echo "unknown" fi } PLATFORM=$(detect_platform) # Цвета для вывода RED='\033[0;31m' GREEN='\033[0;32m' YELLOW='\033[1;33m' BLUE='\033[0;34m' CYAN='\033[0;36m' MAGENTA='\033[0;35m' NC='\033[0m' # Функции логирования с интеграцией в Зевс log() { local level=$1 shift local message=$* local timestamp=$(date '+%Y-%m-%d %H:%M:%S') case $level in "INFO") echo -e "${BLUE}[INFO]${NC} $timestamp - $message" ;; "SUCCESS") echo -e "${GREEN}[SUCCESS]${NC} $timestamp - $message" ;; "WARNING") echo -e "${YELLOW}[WARNING]${NC} $timestamp - $message" ;; "ERROR") echo -e "${RED}[ERROR]${NC} $timestamp - $message" ;; "FRACTAL") echo -e "${MAGENTA}[FRACTAL]${NC} $timestamp - $message" ;; "NANO") echo -e "${CYAN}[NANO]${NC} $timestamp - $message" ;; "ZEUS") echo -e "${GREEN}[ZEUS]${NC} $timestamp - $message" ;; esac # Отправка логов в проект Зевс send_to_zeus "$level" "$message" "$timestamp" } # Функция отправки данных в проект Зевс send_to_zeus() { local level=$1 local message=$2 local timestamp=$3 # Формирование JSON данных local json_data=$(jq -n \ --arg platform "$PLATFORM" \ --arg level "$level" \ --arg message "$message" \ --arg timestamp "$timestamp" \ --arg version "$LOKI_VERSION" \ '{platform: $platform, level: $level, message: $message, timestamp: $timestamp, version: $version}') # Отправка через curl (если доступно) if command -v curl >/dev/null 2>&1; then curl -s -X POST -H "Content-Type: application/json" \ -d "$json_data" "$ZEUS_API_URL/logs" > /dev/null 2>&1 & fi } # Проверка и установка необходимых зависимостей install_dependencies() { log INFO "Установка зависимостей для платформы: $PLATFORM" case $PLATFORM in "linux") apt-get update && apt-get upgrade -y apt-get install -y \ build-essential software-properties-common apt-transport-https \ ca-certificates curl wget gnupg git python3.10 python3-pip python3-venv \ python3-dev nvidia-cuda-toolkit docker.io docker-compose-plugin jq \ htop iotop nethogs sysstat lm-sensors firmware-linux firmware-linux-nonfree \ libelf-dev libnuma-dev libssl-dev libffi-dev libopenblas-dev libjemalloc-dev \ ocl-icd-opencl-dev nvtop cmake ninja-build pkg-config libboost-all-dev \ libeigen3-dev libtbb-dev openssh-client # Автоматическое определение драйвера NVIDIA NVIDIA_DRIVER=$(ubuntu-drivers devices | grep -oP "nvidia-driver-\K[0-9]+" | sort -n | tail -1) if [ ! -z "$NVIDIA_DRIVER" ]; then apt-get install -y "nvidia-driver-${NVIDIA_DRIVER}" fi ;; "android") pkg update && pkg upgrade -y pkg install -y python numpy opencl-vendors git wget curl cmake make \ clang termux-api termux-exec openssh tmux ;; "wsl") apt-get update && apt-get upgrade -y apt-get install -y \ build-essential python3.10 python3-pip python3-venv python3-dev \ curl wget git jq htop libopenblas-dev libjemalloc-dev cmake \ ninja-build pkg-config libboost-all-dev libeigen3-dev libtbb-dev ;; "macos") # Установка через Homebrew if ! command -v brew >/dev/null 2>&1; then /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" fi brew update brew install python@3.10 git curl wget jq htop cmake ninja pkg-config \ boost eigen tbb openblas ;; esac log SUCCESS "Зависимости установлены для платформы: $PLATFORM" } # Фрактально-зеркальный нано-двигатель (основной модуль) install_fractal_engine() { log INFO "Установка фрактально-зеркального нано-двигателя" # Создание структуры каталогов mkdir -p $INSTALL_DIR/{fractal,mirror,nano,simulations,drivers,zeus_integration} # Копирование драйверов и компонентов cp -r drivers/* $INSTALL_DIR/drivers/ cp -r zeus_integration/* $INSTALL_DIR/zeus_integration/ # Настройка фрактальной структуры for i in $(seq 1 $FRACTAL_LEVEL); do mkdir -p $INSTALL_DIR/fractal/level$i mkdir -p $INSTALL_DIR/mirror/{primary,secondary,tertiary}/level$i done # Создание конфигурации cat > $INSTALL_DIR/config.yaml << EOF fractal: levels: $FRACTAL_LEVEL iterations: 1000 precision: double optimization: avx: true openmp: true cuda: true opencl: true mirroring: enabled: true levels: $MIRRORING_ITERATIONS synchronization: realtime nano: simulations: $NANO_SIMULATIONS precision: nano quantum_effects: true thermal_analysis: true zeus_integration: api_url: $ZEUS_API_URL enabled: true sync_interval: 60 platform: $PLATFORM output: format: hdf5 compression: gzip chunk_size: 1024 EOF log SUCCESS "Фрактально-зеркальный нано-двигатель установлен" } # Установка Python окружения с кроссплатформенной поддержкой setup_python_environment() { log INFO "Настройка Python окружения" # Создание виртуального окружения python3.10 -m venv $INSTALL_DIR/venv source $INSTALL_DIR/venv/bin/activate # Базовые пакеты pip install --upgrade pip setuptools wheel # Определение платформенно-специфичных зависимостей case $PLATFORM in "linux"|"wsl") pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu118 ;; "android"|"macos") pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cpu ;; esac # Общие зависимости pip install \ numpy scipy pandas matplotlib seaborn jupyterlab ipywidgets \ networkx scikit-learn scikit-image opencv-python pillow tqdm \ numba cython pyopencl mpi4py h5py zarr dask distributed ray \ modin vaex bokeh plotly dash streamlit fastapi uvicorn gunicorn \ pydantic sqlalchemy alembic psycopg2-binary redis celery flower \ requests aiohttp httpx beautifulsoup4 lxml selenium pyyaml toml \ python-dotenv loguru prometheus-client grafana-client elasticsearch \ kafka-python pika websockets asyncpg uvloop rich typer click \ cryptography bcrypt pyjwt oauthlib authlib jmespath log SUCCESS "Python окружение настроено" } # Установка и настройка системы мониторинга setup_monitoring() { log INFO "Настройка системы мониторинга" # Для Android используем упрощенный мониторинг if [ "$PLATFORM" = "android" ]; then setup_android_monitoring return fi # Стандартный мониторинг для других платформ mkdir -p $INSTALL_DIR/monitoring/{prometheus,grafana,alertmanager} # Конфигурация Prometheus cat > $INSTALL_DIR/monitoring/prometheus/prometheus.yml << EOF global: scrape_interval: 15s evaluation_interval: 15s external_labels: monitor: 'loki-fractal' platform: '$PLATFORM' scrape_configs: - job_name: 'loki-node' static_configs: - targets: ['localhost:9100'] - job_name: 'loki-app' static_configs: - targets: ['localhost:8080'] metrics_path: /metrics scheme: http - job_name: 'loki-simulations' static_configs: - targets: ['localhost:9095'] metrics_path: /metrics scheme: http - job_name: 'loki-fractal' static_configs: - targets: ['localhost:9096'] metrics_path: /fractal_metrics scheme: http - job_name: 'zeus-integration' static_configs: - targets: ['localhost:9097'] metrics_path: /zeus_metrics scheme: http rule_files: - 'alert.rules.yml' alerting: alertmanagers: - static_configs: - targets: ['localhost:9093'] EOF # Запуск мониторинга (только для Linux и WSL) if [ "$PLATFORM" = "linux" ] || [ "$PLATFORM" = "wsl" ]; then docker-compose -f $INSTALL_DIR/docker-compose.monitoring.yml up -d fi log SUCCESS "Система мониторинга настроена" } # Упрощенный мониторинг для Android setup_android_monitoring() { log INFO "Настройка мониторинга для Android" mkdir -p $INSTALL_DIR/monitoring/android # Скрипт мониторинга ресурсов cat > $INSTALL_DIR/monitoring/android_monitor.sh << 'EOF' #!/bin/bash while true; do # Мониторинг ресурсов Android CPU_USAGE=$(top -bn1 | grep -oP "CPU:\s+\K[0-9]+") MEM_INFO=$(termux-memory-info | grep -oP "Total:\s+\K[0-9]+") TEMP=$(termux-battery-status | grep -oP "temperature\":\s*\K[0-9.]+") BATTERY=$(termux-battery-status | grep -oP "percentage\":\s*\K[0-9]+") # Сохранение метрик echo "android_cpu_usage $CPU_USAGE" > $INSTALL_DIR/monitoring/android/metrics.prom echo "android_memory_total $MEM_INFO" >> $INSTALL_DIR/monitoring/android/metrics.prom echo "android_temperature $TEMP" >> $INSTALL_DIR/monitoring/android/metrics.prom echo "android_battery_level $BATTERY" >> $INSTALL_DIR/monitoring/android/metrics.prom sleep 5 done EOF chmod +x $INSTALL_DIR/monitoring/android_monitor.sh nohup $INSTALL_DIR/monitoring/android_monitor.sh > /dev/null 2>&1 & log SUCCESS "Мониторинг для Android настроен" } # Интеграция с проектом "Зевс" setup_zeus_integration() { log ZEUS "Настройка интеграции с проектом Зевс" # Создание директории интеграции mkdir -p $INSTALL_DIR/zeus_integration # Основной модуль интеграции cat > $INSTALL_DIR/zeus_integration/core.py << 'EOF' import requests import json import os import logging from datetime import datetime from pathlib import Path class ZeusIntegration: def __init__(self, config_path): self.config = self.load_config(config_path) self.api_url = self.config['zeus_integration']['api_url'] self.auth_token = os.getenv('ZEUS_AUTH_TOKEN', '') self.setup_logging() def load_config(self, config_path): with open(config_path, 'r') as f: return yaml.safe_load(f) def setup_logging(self): logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) self.logger = logging.getLogger("ZeusIntegration") def send_metrics(self, metrics_data): """Отправка метрик в проект Зевс""" headers = { 'Authorization': f'Bearer {self.auth_token}', 'Content-Type': 'application/json' } try: response = requests.post( f'{self.api_url}/metrics', json=metrics_data, headers=headers, timeout=10 ) return response.status_code == 200 except Exception as e: self.logger.error(f"Ошибка отправки метрик: {e}") return False def get_config_updates(self): """Получение обновлений конфигурации от Зевса""" headers = {'Authorization': f'Bearer {self.auth_token}'} try: response = requests.get( f'{self.api_url}/config', headers=headers, timeout=10 ) if response.status_code == 200: return response.json() except Exception as e: self.logger.error(f"Ошибка получения конфигурации: {e}") return None def sync_simulation_results(self, results): """Синхронизация результатов симуляций с Зевсом""" headers = { 'Authorization': f'Bearer {self.auth_token}', 'Content-Type': 'application/json' } try: response = requests.post( f'{self.api_url}/simulations', json=results, headers=headers, timeout=30 ) return response.status_code == 200 except Exception as e: self.logger.error(f"Ошибка синхронизации результатов: {e}") return False # Глобальный экземпляр интеграции zeus_integration = None def init_zeus_integration(config_path): global zeus_integration zeus_integration = ZeusIntegration(config_path) return zeus_integration EOF # Скрипт синхронизации с Зевсом cat > $INSTALL_DIR/zeus_integration/sync_zeus.sh << 'EOF' #!/bin/bash # Скрипт синхронизации с проектом Зевс CONFIG_FILE="$INSTALL_DIR/config.yaml" LOG_FILE="/var/log/zeus_sync.log" # Активация Python окружения source $INSTALL_DIR/venv/bin/activate # Запуск синхронизации python -c " import yaml import sys sys.path.append('$INSTALL_DIR/zeus_integration') from core import init_zeus_integration try: zeus = init_zeus_integration('$CONFIG_FILE') # Синхронизация конфигурации config_updates = zeus.get_config_updates() if config_updates: with open('$CONFIG_FILE', 'w') as f: yaml.dump(config_updates, f) print('Конфигурация обновлена от Зевса') # Отправка системных метрик import psutil metrics = { 'cpu_percent': psutil.cpu_percent(), 'memory_percent': psutil.virtual_memory().percent, 'disk_usage': psutil.disk_usage('/').percent, 'platform': '$PLATFORM' } zeus.send_metrics(metrics) print('Синхронизация с Зевсом завершена успешно') except Exception as e: print(f'Ошибка синхронизации с Зевсом: {e}') " >> $LOG_FILE 2>&1 EOF chmod +x $INSTALL_DIR/zeus_integration/sync_zeus.sh # Настройка периодической синхронизации if [ "$PLATFORM" != "android" ]; then # Добавление задания cron для синхронизации (crontab -l 2>/dev/null; echo "*/5 * * * * $INSTALL_DIR/zeus_integration/sync_zeus.sh") | crontab - else # Для Android используем termux-job-scheduler termux-job-scheduler -s $INSTALL_DIR/zeus_integration/sync_zeus.sh -p 300000 fi log ZEUS "Интеграция с проектом Зевс настроена" } # Установка фрактально-зеркальных нано-симуляций install_nano_simulations() { log INFO "Установка фрактально-зеркальных нано-симуляций" # Создание основных скриптов симуляций cat > $INSTALL_DIR/simulations/run_fractal_simulations.py << 'EOF' #!/usr/bin/env python3 # Фрактально-зеркальные нано-симуляции v3.0 # С интеграцией проекта Зевс и кроссплатформенной поддержкой import numpy as np import numba from numba import jit, prange import multiprocessing as mp from multiprocessing import Pool import time from datetime import datetime import logging import json import h5py import zarr from pathlib import Path from typing import Dict, List, Tuple, Optional import itertools from scipy import ndimage from scipy.spatial import distance from scipy.fft import fftn, ifftn import networkx as nx import matplotlib.pyplot as plt import os import sys import yaml # Добавление пути для интеграции с Зевсом sys.path.append(os.path.join(os.path.dirname(__file__), '../zeus_integration')) from core import init_zeus_integration # Настройка логирования logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler("/var/log/loki_simulations.log"), logging.StreamHandler() ] ) logger = logging.getLogger("Loki-Simulations") # Попытка импорта аппаратно-зависимых модулей try: from numba import cuda CUDA_AVAILABLE = cuda.is_available() except ImportError: CUDA_AVAILABLE = False try: import pyopencl as cl OPENCL_AVAILABLE = True except ImportError: OPENCL_AVAILABLE = False class FractalSimulator: """Фрактальный симулятор для нано-уровневого моделирования""" def __init__(self, config_path: str): self.config = self.load_config(config_path) self.zeus = init_zeus_integration(config_path) self.setup_hardware() self.initialize_fractal_structures() def load_config(self, config_path: str) -> Dict: """Загрузка конфигурации""" with open(config_path, 'r') as f: return yaml.safe_load(f) def setup_hardware(self): """Настройка аппаратного обеспечения для симуляций""" self.cpu_cores = mp.cpu_count() self.gpu_devices = [] # Инициализация OpenCL if OPENCL_AVAILABLE: try: self.ocl_platforms = cl.get_platforms() self.ocl_devices = [] for platform in self.ocl_platforms: self.ocl_devices.extend(platform.get_devices(device_type=cl.device_type.GPU)) if self.ocl_devices: self.ocl_context = cl.Context(devices=self.ocl_devices) self.ocl_queue = cl.CommandQueue(self.ocl_context) logger.info(f"OpenCL инициализирован с {len(self.ocl_devices)} устройствами") except Exception as e: logger.warning(f"Ошибка инициализации OpenCL: {e}") # Инициализация CUDA if CUDA_AVAILABLE: try: self.cuda_devices = [] for i in range(len(cuda.list_devices())): self.cuda_devices.append(cuda.select_device(i)) logger.info(f"CUDA инициализирована с {len(self.cuda_devices)} устройствами") except Exception as e: logger.warning(f"Ошибка инициализации CUDA: {e}") def initialize_fractal_structures(self): """Инициализация фрактальных структур""" self.fractal_levels = self.config['fractal']['levels'] self.fractal_data = [] # Создание фрактальных структур разных уровней for level in range(self.fractal_levels): size = 2 ** (level + 3) # Размер увеличивается с уровнем fractal = self.generate_mandelbrot_fractal(size, level) self.fractal_data.append(fractal) # Зеркалирование структур if self.config['mirroring']['enabled']: self.mirror_fractal_structure(fractal, level) @staticmethod @jit(nopython=True, parallel=True, fastmath=True) def generate_mandelbrot_fractal(size: int, level: int) -> np.ndarray: """Генерация фрактала Мандельброта с оптимизацией""" fractal = np.zeros((size, size), dtype=np.complex128) max_iter = 100 + level * 50 for i in prange(size): for j in prange(size): c = complex(-2.0 + 3.0 * i / size, -1.5 + 3.0 * j / size) z = 0.0j iteration = 0 while abs(z) < 2.0 and iteration < max_iter: z = z * z + c iteration += 1 fractal[i, j] = complex(iteration, abs(z)) return fractal def mirror_fractal_structure(self, fractal: np.ndarray, level: int): """Зеркалирование фрактальной структуры""" install_dir = os.environ.get('INSTALL_DIR', '/opt/loki_system') mirror_path = f"{install_dir}/mirror/primary/level{level+1}" np.save(f"{mirror_path}/fractal.npy", fractal) # Копирование во вторичные зеркала for mirror_type in ['secondary', 'tertiary']: mirror_path = f"{install_dir}/mirror/{mirror_type}/level{level+1}" np.save(f"{mirror_path}/fractal.npy", fractal) def run_nano_simulations(self): """Запуск нано-симуляций""" logger.info(f"Запуск {self.config['nano']['simulations']} нано-симуляций") # Отправка статуса в Зевс self.zeus.send_metrics({ 'simulations_started': self.config['nano']['simulations'], 'timestamp': datetime.now().isoformat() }) results = [] for sim_id in range(self.config['nano']['simulations']): result = self.run_single_simulation(sim_id) results.append(result) # Отправка прогресса в Зевс каждые 10% if (sim_id + 1) % (self.config['nano']['simulations'] // 10) == 0: progress = (sim_id + 1) / self.config['nano']['simulations'] * 100 logger.info(f"Прогресс: {progress:.1f}%") self.zeus.send_metrics({ 'simulation_progress': progress, 'timestamp': datetime.now().isoformat() }) return results def run_single_simulation(self, sim_id: int) -> Dict: """Выполнение одной симуляции""" start_time = time.time() # Выбор случайного фрактального уровня level = np.random.randint(0, self.fractal_levels) fractal_data = self.fractal_data[level] # Применение различных методов симуляции if self.config['optimization']['cuda'] and hasattr(self, 'cuda_devices') and self.cuda_devices: result = self.run_cuda_simulation(fractal_data, level) elif self.config['optimization']['opencl'] and hasattr(self, 'ocl_devices') and self.ocl_devices: result = self.run_opencl_simulation(fractal_data, level) else: result = self.run_cpu_simulation(fractal_data, level) # Добавление метаданных result.update({ 'simulation_id': sim_id, 'fractal_level': level, 'computation_time': time.time() - start_time, 'timestamp': datetime.now().isoformat() }) return result def run_cpu_simulation(self, fractal_data: np.ndarray, level: int) -> Dict: """Запуск симуляции на CPU""" # Многопоточная обработка с использованием всех ядер with Pool(self.cpu_cores) as pool: results = pool.map(self.process_fractal_slice, [(i, fractal_data) for i in range(fractal_data.shape[0])]) return { 'method': 'cpu_parallel', 'cores_used': self.cpu_cores, 'result': np.vstack(results) } def process_fractal_slice(self, args) -> np.ndarray: """Обработка среза фрактальных данных""" i, fractal_data = args return np.abs(fractal_data[i, :]) ** 2 def run_opencl_simulation(self, fractal_data: np.ndarray, level: int) -> Dict: """Запуск симуляции на OpenCL""" # Создание OpenCL буферов mf = cl.mem_flags fractal_buffer = cl.Buffer(self.ocl_context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=fractal_data) result_buffer = cl.Buffer(self.ocl_context, mf.WRITE_ONLY, fractal_data.nbytes) # Компиляция OpenCL кернела kernel_code = """ __kernel void fractal_simulation(__global const double2* fractal, __global double* result, int size) { int idx = get_global_id(0); int idy = get_global_id(1); double2 val = fractal[idx * size + idy]; double real = val.x; double imag = val.y; result[idx * size + idy] = real * real + imag * imag; } """ program = cl.Program(self.ocl_context, kernel_code).build() # Запуск кернела program.fractal_simulation(self.ocl_queue, fractal_data.shape, None, fractal_buffer, result_buffer, np.int32(fractal_data.shape[1])) # Чтение результатов result = np.empty_like(fractal_data, dtype=np.float64) cl.enqueue_copy(self.ocl_queue, result, result_buffer) return { 'method': 'opencl', 'devices_used': len(self.ocl_devices), 'result': result } def save_results(self, results: List[Dict]): """Сохранение результатов симуляций""" output_dir = Path(self.config['output']['directory']) output_dir.mkdir(parents=True, exist_ok=True) # Сохранение в HDF5 формате with h5py.File(output_dir / 'simulation_results.h5', 'w') as f: for i, result in enumerate(results): group = f.create_group(f'simulation_{i}') for key, value in result.items(): if isinstance(value, np.ndarray): group.create_dataset(key, data=value, compression='gzip') else: group.attrs[key] = value # Синхронизация результатов с Зевсом if self.zeus.sync_simulation_results(results): logger.info("Результаты синхронизированы с проектом Зевс") logger.info(f"Результаты сохранены в {output_dir / 'simulation_results.h5'}") def main(): """Основная функция запуска симуляций""" install_dir = os.environ.get('INSTALL_DIR', '/opt/loki_system') config_path = os.path.join(install_dir, "config.yaml") try: simulator = FractalSimulator(config_path) results = simulator.run_nano_simulations() simulator.save_results(results) logger.info("Все симуляции успешно завершены") return True except Exception as e: logger.error(f"Ошибка при выполнении симуляций: {e}") return False if __name__ == "__main__": main() EOF # Установка прав и создание службы chmod +x $INSTALL_DIR/simulations/run_fractal_simulations.py # Создание службы (только для Linux и WSL) if [ "$PLATFORM" = "linux" ] || [ "$PLATFORM" = "wsl" ]; then cat > /etc/systemd/system/loki-simulations.service << EOF [Unit] Description=Loki Fractal Nano Simulations After=network.target docker.service Requires=docker.service [Service] Type=simple User=root Group=root WorkingDirectory=$INSTALL_DIR/simulations ExecStart=$INSTALL_DIR/venv/bin/python $INSTALL_DIR/simulations/run_fractal_simulations.py Restart=on-failure RestartSec=10 Environment=PYTHONPATH=$INSTALL_DIR/simulations Environment=INSTALL_DIR=$INSTALL_DIR [Install] WantedBy=multi-user.target EOF systemctl daemon-reload systemctl enable loki-simulations fi log SUCCESS "Фрактально-зеркальные нано-симуляции установлены" } # Финальная настройка и оптимизация finalize_installation() { log INFO "Финальная настройка и оптимизация системы..." # Оптимизация параметров ядра (только для Linux) if [ "$PLATFORM" = "linux" ]; then cat > /etc/sysctl.d/99-loki-optimization.conf << EOF # Фрактально-зеркальная оптимизация ядра net.core.rmem_max=268435456 net.core.wmem_max=268435456 net.ipv4.tcp_rmem=4096 87380 268435456 net.ipv4.tcp_wmem=4096 65536 268435456 net.ipv4.tcp_congestion_control=bbr net.ipv4.tcp_window_scaling=1 net.ipv4.tcp_max_syn_backlog=3240000 net.ipv4.tcp_syncookies=1 net.ipv4.tcp_tw_reuse=1 vm.swappiness=10 vm.vfs_cache_pressure=50 kernel.sched_migration_cost_ns=5000000 kernel.sched_autogroup_enabled=0 vm.dirty_ratio=10 vm.dirty_background_ratio=5 vm.overcommit_memory=1 vm.overcommit_ratio=75 EOF sysctl -p /etc/sysctl.d/99-loki-optimization.conf fi # Настройка ограничений системы echo "* soft nofile 1048576" >> /etc/security/limits.conf echo "* hard nofile 1048576" >> /etc/security/limits.conf echo "* soft nproc unlimited" >> /etc/security/limits.conf echo "* hard nproc unlimited" >> /etc/security/limits.conf echo "* soft memlock unlimited" >> /etc/security/limits.conf echo "* hard memlock unlimited" >> /etc/security/limits.conf # Создание скрипта управления cat > /usr/local/bin/loki-control /dev/null 2>&1 & fi echo "Система Локи запущена" ;; stop) if [ "$PLATFORM" = "linux" ] || [ "$PLATFORM" = "wsl" ]; then systemctl stop loki-simulations docker-compose -f $INSTALL_DIR/docker-compose.monitoring.yml stop else pkill -f "run_fractal_simulations.py" fi echo "Система Локи остановлена" ;; status) if [ "$PLATFORM" = "linux" ] || [ "$PLATFORM" = "wsl" ]; then systemctl status loki-simulations docker-compose -f $INSTALL_DIR/docker-compose.monitoring.yml ps else pgrep -f "run_fractal_simulations.py" > /dev/null && echo "Симуляции запущены" || echo "Симуляции остановлены" fi ;; restart) if [ "$PLATFORM" = "linux" ] || [ "$PLATFORM" = "wsl" ]; then systemctl restart loki-simulations docker-compose -f $INSTALL_DIR/docker-compose.monitoring.yml restart else pkill -f "run_fractal_simulations.py" nohup $INSTALL_DIR/venv/bin/python $INSTALL_DIR/simulations/run_fractal_simulations.py > /dev/null 2>&1 & fi echo "Система Локи перезапущена" ;; simulations) $INSTALL_DIR/venv/bin/python $INSTALL_DIR/simulations/run_fractal_simulations.py ;; zeus-sync) $INSTALL_DIR/zeus_integration/sync_zeus.sh ;; *) echo "Использование: \$0 {start|stop|status|restart|simulations|zeus-sync}" exit 1 ;; esac EOF chmod +x /usr/local/bin/loki-control log SUCCESS "Финальная настройка завершена" } # Запуск начальных симуляций run_initial_simulations() { log INFO "Запуск начальных фрактально-зеркальных нано-симуляций..." # Для Android увеличиваем интервал между симуляциями if [ "$PLATFORM" = "android" ]; then export SIMULATION_DELAY=2 fi # Запуск симуляций в фоновом режиме nohup $INSTALL_DIR/venv/bin/python $INSTALL_DIR/simulations/run_fractal_simulations.py \ > /var/log/loki_initial_simulations.log 2>&1 & # Ожидание завершения симуляций SIMULATION_PID=$! # Для Android ограничиваем время выполнения if [ "$PLATFORM" = "android" ]; then sleep 300 # Ожидание 5 минут kill $SIMULATION_PID 2>/dev/null log SUCCESS "Начальные симуляции завершены (ограничение по времени для Android)" return 0 else wait $SIMULATION_PID if [ $? -eq 0 ]; then log SUCCESS "Начальные симуляции успешно завершены" return 0 else log ERROR "Ошибка при выполнении симуляций" return 1 fi fi } # Основная функция установки main() { log INFO "Начало установки системы Локи с фрактально-зеркальными нано-симуляциями" log INFO "Версия: $LOKI_VERSION" log INFO "Платформа: $PLATFORM" log INFO "Уровень фрактальности: $FRACTAL_LEVEL" log INFO "Количество нано-симуляций: $NANO_SIMULATIONS" log INFO "Итерации зеркалирования: $MIRRORING_ITERATIONS" log ZEUS "Интеграция с проектом Зевс: $ZEUS_API_URL" # Проверка прав (кроме Android) if [ "$PLATFORM" != "android" ] && [ "$EUID" -ne 0 ]; then log ERROR "Скрипт должен запускаться с правами root" exit 1 fi # Этапы установки install_dependencies install_fractal_engine setup_python_environment setup_zeus_integration install_nano_simulations setup_monitoring finalize_installation # Запуск начальных симуляций if run_initial_simulations; then log SUCCESS "Система Локи успешно установлена и настроена!" log INFO "Для управления системой используйте: loki-control {start|stop|status|restart|simulations|zeus-sync}" if [ "$PLATFORM" = "linux" ] || [ "$PLATFORM" = "wsl" ]; then log INFO "Мониторинг доступен по адресу: http://localhost:3000" fi log INFO "Логи симуляций: /var/log/loki_simulations.log" # Создание файла с информацией об установке cat > $INSTALL_DIR/installation_info.txt << EOF Система Локи - Установка завершена Версия: $LOKI_VERSION Платформа: $PLATFORM Дата установки: $(date) Уровень фрактальности: $FRACTAL_LEVEL Нано-симуляции: $NANO_SIMULATIONS Итерации зеркалирования: $MIRRORING_ITERATIONS Интеграция с Зевсом: $ZEUS_API_URL Доступные интерфейсы: - Мониторинг: http://localhost:3000 (admin/loki_fractal_admin) - Prometheus: http://localhost:9090 - Node Exporter: http://localhost:9100 - cAdvisor: http://localhost:8080 Управление системой: - Запуск: loki-control start - Остановка: loki-control stop - Статус: loki-control status - Симуляции: loki-control simulations - Синхронизация с Зевсом: loki-control zeus-sync Логи: - Основные логи: /var/log/loki_installation.log - Логи симуляций: /var/log/loki_simulations.log - Локи системы: /var/log/loki_initial_simulations.log EOF else log ERROR "Установка завершена с ошибками" exit 1 fi } # Обработка сигналов trap 'log ERROR "Прерывание установки"; exit 1' INT TERM # Запуск основной функции main "$@"