# MY Network Monitoring System ## Обзор Системы Мониторинга MY Network Monitoring System представляет собой комплексную систему мониторинга с ASCII-арт интерфейсом в хакерском стиле, API endpoints для мониторинга, веб-интерфейс и интеграцию с Telegram ботом. ## ASCII-арт Интерфейс в Хакерском Стиле ### 1. Terminal Dashboard ```python class HackerStyleTerminalUI: def __init__(self): self.screen_width = 120 self.screen_height = 40 self.refresh_rate = 1.0 # секунды def render_main_dashboard(self, node_status: dict) -> str: """Главная панель мониторинга""" ascii_art = f""" ╔════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗ ║ ███╗ ███╗██╗ ██╗ ███╗ ██╗███████╗████████╗██╗ ██╗ ██████╗ ██████╗ ██╗ ██╗ ║ ║ ████╗ ████║╚██╗ ██╔╝ ████╗ ██║██╔════╝╚══██╔══╝██║ ██║██╔═══██╗██╔══██╗██║ ██╔╝ ║ ║ ██╔████╔██║ ╚████╔╝ ██╔██╗ ██║█████╗ ██║ ██║ █╗ ██║██║ ██║██████╔╝█████╔╝ ║ ║ ██║╚██╔╝██║ ╚██╔╝ ██║╚██╗██║██╔══╝ ██║ ██║███╗██║██║ ██║██╔══██╗██╔═██╗ ║ ║ ██║ ╚═╝ ██║ ██║ ██║ ╚████║███████╗ ██║ ╚███╔███╔╝╚██████╔╝██║ ██║██║ ██╗ ║ ║ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═══╝╚══════╝ ╚═╝ ╚══╝╚══╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ║ ║ ║ ║ Node ID: {node_status['node_id'][:16]}... Status: {self.get_status_indicator(node_status)} ║ ║ Uptime: {self.format_uptime(node_status['uptime'])} Network: ONLINE ║ ╠════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╣ ║ ┌─ NETWORK STATUS ─────────────────────┐ ┌─ CONTENT METRICS ──────────────────┐ ┌─ SYSTEM RESOURCES ──────────────┐ ║ ║ │ Peers Connected: {node_status['peer_count']:>3} │ │ Total Content: {node_status['content_count']:>6} │ │ CPU Usage: {self.render_bar(node_status['cpu_usage'], 10)} │ ║ ║ │ Active Connections: {node_status.get('active_connections', 0):>3} │ │ Synced Today: {node_status.get('synced_today', 0):>7} │ │ Memory: {self.render_bar(node_status['memory_usage'], 13)} │ ║ ║ │ Network Bandwidth: {node_status.get('bandwidth', '0 MB/s'):>8} │ │ Replication Rate: {node_status.get('replication_rate', '0/s'):>4} │ │ Disk: {self.render_bar(node_status['disk_usage'], 15)} │ ║ ║ │ Consensus Participation: {node_status.get('consensus_rate', '0%'):>3} │ │ Failed Syncs: {node_status.get('failed_syncs', 0):>6} │ │ Network I/O: {node_status.get('network_io', '0 KB/s'):>8} │ ║ ║ └─────────────────────────────────────┘ └────────────────────────────────────┘ └─────────────────────────────────┘ ║ ║ ║ ║ ┌─ RECENT ACTIVITY ────────────────────────────────────────────────────────────────────────────────────────────┐ ║ ║ │ {self.format_recent_activities(node_status.get('recent_activities', []))} │ ║ ║ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ ║ ║ ║ ║ ┌─ PEER CONNECTIONS ───────────────────────────────────────────────────────────────────────────────────────────┐ ║ ║ │ {self.format_peer_connections(node_status.get('peer_connections', []))} │ ║ ║ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ ║ ║ ║ ║ Commands: [S]ync | [P]eers | [C]ontent | [L]ogs | [Q]uit Last Update: {datetime.now().strftime('%H:%M:%S')} ║ ╚════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝ """ return ascii_art def render_bar(self, percentage: float, width: int) -> str: """Рендер прогресс-бара в ASCII""" filled_width = int((percentage / 100) * width) bar = "█" * filled_width + "░" * (width - filled_width) return f"{bar} {percentage:>5.1f}%" def get_status_indicator(self, node_status: dict) -> str: """Индикатор статуса ноды""" if node_status.get('is_healthy', True): return "🟢 HEALTHY" elif node_status.get('has_warnings', False): return "🟡 WARNING" else: return "🔴 CRITICAL" ``` ### 2. Network Topology Visualization ```python def render_network_topology(self, network_data: dict) -> str: """ASCII визуализация топологии сети""" topology_art = f""" ┌─ MY NETWORK TOPOLOGY ──────────────────────────────────────────────────────────────────────────────────┐ │ │ │ ┌─────────────┐ │ │ ┌──│ Bootstrap-1 │──┐ │ │ │ └─────────────┘ │ │ │ │ │ │ │ ┌─────────────┴──┐ ┌──┴─────────────┐ │ │ │ Regional-EU │ │ Regional-US │ │ │ └─────────────┬──┘ └──┬─────────────┘ │ │ │ │ │ │ ┌────────────────────────┼─────────────────┼────────────────────────┐ │ │ │ │ │ │ │ │ ┌────▼───┐ ┌───▼───┐ ┌───▼───┐ ┌───▼────┐ │ │ │ Node-A │────────────────│ Node-B│─────────│ Node-C│────────────────│ Node-D │ │ │ └────────┘ └───────┘ └───────┘ └────────┘ │ │ │ │ │ │ │ │ │ ┌──────────────┴─────────────────┴──────────────┐ │ │ │ │ │ │ │ │ │ ┌────▼───┐ ┌───▼───┐ ┌───▼───┐ ┌───▼────┐ │ │ │ Node-E │ │ Node-F│ │ Node-G│ │ Node-H │ │ │ └────────┘ └───────┘ └───────┘ └────────┘ │ │ │ │ Legend: ━━━ High Bandwidth │ ─── Standard │ ╬╬╬ Consensus Link │ ░░░ Sync Active │ │ │ │ Network Stats: │ │ • Total Nodes: {network_data.get('total_nodes', 0)} │ │ • Active Connections: {network_data.get('active_connections', 0)} │ │ • Average Latency: {network_data.get('avg_latency', '0ms')} │ │ • Network Health: {network_data.get('health_score', '0%')} │ └────────────────────────────────────────────────────────────────────────────────────────────────────┘ """ return topology_art def render_matrix_rain_effect(self) -> str: """Matrix-style rain effect для заставки""" matrix_art = """ ╔═══════════════════════════════════════════════════════════════════════════════════════════════════╗ ║ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║ ║ ░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░ ║ ║ ░░█░░░░█░░█░░░░█░░░░█░░█░░░░█░░░░█░░█░░░░█░░░░█░░█░░░░█░░░░█░░█░░░░█░░░░█░░█░░░░█░░░░█░░█░░░░█░ ║ ║ █░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░ ║ ║ ░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░ ║ ║ ░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░ ║ ║ ║ ║ ╔══════════════════════════════════════════╗ ║ ║ ║ INITIALIZING MY NETWORK MONITORING... ║ ║ ║ ║ ║ ║ ║ ║ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░ ║ ║ ║ ║ ║ ║ ║ ║ Loading quantum encryption protocols... ║ ║ ║ ║ Establishing secure P2P connections... ║ ║ ║ ║ Synchronizing with blockchain nodes... ║ ║ ║ ╚══════════════════════════════════════════╝ ║ ║ ║ ║ ░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░ ║ ║ ░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░░█░░░█░█░░█░ ║ ║ █░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░░█░█░░█░░█░█░ ║ ║ ░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░░░█░ ║ ║ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║ ╚═══════════════════════════════════════════════════════════════════════════════════════════════════╝ """ return matrix_art ``` ### 3. Content Flow Visualization ```python def render_content_flow(self, flow_data: dict) -> str: """Визуализация потока контента в реальном времени""" flow_art = f""" ┌─ CONTENT FLOW MONITOR ─────────────────────────────────────────────────────────────────────────────────┐ │ │ │ 📥 INCOMING 🔄 PROCESSING 📤 OUTGOING │ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Node-A │════════════════▶│ THIS-NODE │════════════════▶│ Node-B │ │ │ │ {flow_data.get('incoming', {}).get('node_a', '0 KB/s'):>11} │ │ {flow_data.get('processing', '0 ops/s'):>11} │ │ {flow_data.get('outgoing', {}).get('node_b', '0 KB/s'):>11} │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ ║ ║ ║ │ │ ▼ ▼ ▼ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Node-C │════════════════▶│ QUEUE │════════════════▶│ Node-D │ │ │ │ {flow_data.get('incoming', {}).get('node_c', '0 KB/s'):>11} │ │ {flow_data.get('queue_size', '0 items'):>11} │ │ {flow_data.get('outgoing', {}).get('node_d', '0 KB/s'):>11} │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ ║ ║ ║ │ │ ▼ ▼ ▼ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Node-E │════════════════▶│ STORAGE │════════════════▶│ Node-F │ │ │ │ {flow_data.get('incoming', {}).get('node_e', '0 KB/s'):>11} │ │ {flow_data.get('storage_ops', '0 ops/s'):>11} │ │ {flow_data.get('outgoing', {}).get('node_f', '0 KB/s'):>11} │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ Flow Statistics: │ │ • Total Throughput: {flow_data.get('total_throughput', '0 MB/s')} │ │ • Peak Bandwidth: {flow_data.get('peak_bandwidth', '0 MB/s')} │ │ • Average Latency: {flow_data.get('avg_latency', '0ms')} │ │ • Queue Backlog: {flow_data.get('queue_backlog', '0 items')} │ │ │ │ Legend: ════ High Volume │ ──── Normal │ ░░░░ Low Volume │ ╳╳╳╳ Error │ └────────────────────────────────────────────────────────────────────────────────────────────────────┘ """ return flow_art ``` ## API Endpoints для Мониторинга (/api/monitor/*) ### 1. Core Monitoring Endpoints ```python from fastapi import APIRouter, HTTPException, BackgroundTasks from fastapi.responses import StreamingResponse import json import asyncio monitor_router = APIRouter(prefix="/api/monitor", tags=["monitoring"]) @monitor_router.get("/status") async def get_node_status(): """Получение статуса ноды""" status = await NodeStatusCollector.get_current_status() return { "node_id": status["node_id"], "uptime_seconds": status["uptime"], "health_status": status["health"], "peer_connections": status["peer_count"], "content_stats": status["content_stats"], "resource_usage": status["resource_usage"], "network_metrics": status["network_metrics"], "timestamp": status["timestamp"] } @monitor_router.get("/peers") async def get_peer_status(): """Статус всех подключенных пиров""" peers = await PeerManager.get_all_peers_status() return { "total_peers": len(peers), "active_peers": len([p for p in peers if p["status"] == "active"]), "peers": [ { "peer_id": peer["id"], "address": peer["address"], "status": peer["status"], "latency_ms": peer["latency"], "last_seen": peer["last_seen"], "data_transferred": peer["data_transferred"], "reputation_score": peer["reputation"] } for peer in peers ] } @monitor_router.get("/content") async def get_content_metrics(): """Метрики контента""" metrics = await ContentMetricsCollector.get_metrics() return { "total_content_items": metrics["total_items"], "content_by_type": metrics["by_type"], "storage_usage": metrics["storage_usage"], "replication_stats": metrics["replication"], "sync_status": metrics["sync_status"], "popular_content": metrics["popular_items"][:10] } @monitor_router.get("/network") async def get_network_metrics(): """Сетевые метрики""" network_stats = await NetworkMetricsCollector.get_stats() return { "network_topology": network_stats["topology"], "bandwidth_usage": network_stats["bandwidth"], "message_stats": network_stats["messages"], "consensus_metrics": network_stats["consensus"], "error_rates": network_stats["errors"] } @monitor_router.get("/performance") async def get_performance_metrics(): """Метрики производительности""" perf_data = await PerformanceCollector.get_metrics() return { "cpu_usage": perf_data["cpu"], "memory_usage": perf_data["memory"], "disk_io": perf_data["disk_io"], "network_io": perf_data["network_io"], "operation_latencies": perf_data["latencies"], "throughput_stats": perf_data["throughput"] } ``` ### 2. Real-time Streaming Endpoints ```python @monitor_router.get("/stream/status") async def stream_node_status(): """Потоковая передача статуса ноды""" async def generate_status_stream(): while True: try: status = await NodeStatusCollector.get_current_status() yield f"data: {json.dumps(status)}\n\n" await asyncio.sleep(1) except Exception as e: yield f"data: {json.dumps({'error': str(e)})}\n\n" break return StreamingResponse( generate_status_stream(), media_type="text/plain", headers={"Cache-Control": "no-cache"} ) @monitor_router.get("/stream/content-flow") async def stream_content_flow(): """Потоковая передача данных о потоке контента""" async def generate_flow_stream(): while True: try: flow_data = await ContentFlowMonitor.get_current_flow() yield f"data: {json.dumps(flow_data)}\n\n" await asyncio.sleep(0.5) # Высокая частота для real-time except Exception as e: yield f"data: {json.dumps({'error': str(e)})}\n\n" break return StreamingResponse( generate_flow_stream(), media_type="text/plain" ) @monitor_router.post("/alerts/subscribe") async def subscribe_to_alerts(subscription: AlertSubscription): """Подписка на алерты""" subscription_id = await AlertManager.subscribe(subscription) return { "subscription_id": subscription_id, "status": "subscribed", "alert_types": subscription.alert_types } @monitor_router.get("/logs/tail") async def tail_logs(lines: int = 100, level: str = "info"): """Получение последних логов""" logs = await LogManager.get_recent_logs(lines, level) return { "logs": logs, "total_lines": len(logs), "level_filter": level } ``` ### 3. Advanced Analytics Endpoints ```python @monitor_router.get("/analytics/performance") async def get_performance_analytics(hours: int = 24): """Аналитика производительности за период""" analytics = await PerformanceAnalyzer.analyze_period(hours) return { "period_hours": hours, "summary": analytics["summary"], "trends": analytics["trends"], "bottlenecks": analytics["bottlenecks"], "recommendations": analytics["recommendations"] } @monitor_router.get("/analytics/content-distribution") async def get_content_distribution_analytics(): """Аналитика распределения контента""" distribution = await ContentAnalyzer.analyze_distribution() return { "replication_efficiency": distribution["efficiency"], "load_balancing": distribution["balance"], "hotspots": distribution["hotspots"], "optimization_opportunities": distribution["optimizations"] } @monitor_router.get("/health-check") async def comprehensive_health_check(): """Комплексная проверка здоровья системы""" health_status = await HealthChecker.perform_full_check() return { "overall_health": health_status["overall"], "component_health": health_status["components"], "critical_issues": health_status["critical"], "warnings": health_status["warnings"], "recommendations": health_status["recommendations"] } ``` ## Метрики Производительности и Нагрузки ### 1. Performance Metrics Collector ```python class PerformanceMetricsCollector: def __init__(self): self.metrics_buffer = [] self.buffer_size = 1000 self.collection_interval = 5 # секунды async def start_collection(self): """Запуск сбора метрик""" asyncio.create_task(self.collect_system_metrics()) asyncio.create_task(self.collect_network_metrics()) asyncio.create_task(self.collect_application_metrics()) async def collect_system_metrics(self): """Сбор системных метрик""" while True: try: metrics = { "timestamp": datetime.utcnow().isoformat(), "type": "system", "cpu_percent": psutil.cpu_percent(interval=1), "memory_percent": psutil.virtual_memory().percent, "memory_available": psutil.virtual_memory().available, "disk_usage": { path: psutil.disk_usage(path).percent for path in ["/", "/tmp", "/var/log"] }, "disk_io": await self.get_disk_io_stats(), "network_io": await self.get_network_io_stats(), "load_average": os.getloadavg(), "process_count": len(psutil.pids()) } await self.store_metric(metrics) await asyncio.sleep(self.collection_interval) except Exception as e: logger.error(f"Error collecting system metrics: {e}") await asyncio.sleep(self.collection_interval) async def collect_network_metrics(self): """Сбор сетевых метрик""" while True: try: network_stats = await self.get_network_statistics() metrics = { "timestamp": datetime.utcnow().isoformat(), "type": "network", "active_connections": network_stats["connections"], "bytes_sent": network_stats["bytes_sent"], "bytes_received": network_stats["bytes_received"], "packets_sent": network_stats["packets_sent"], "packets_received": network_stats["packets_received"], "errors": network_stats["errors"], "drops": network_stats["drops"], "peer_latencies": await self.measure_peer_latencies(), "bandwidth_usage": await self.calculate_bandwidth_usage() } await self.store_metric(metrics) await asyncio.sleep(self.collection_interval) except Exception as e: logger.error(f"Error collecting network metrics: {e}") await asyncio.sleep(self.collection_interval) async def collect_application_metrics(self): """Сбор метрик приложения""" while True: try: app_stats = await self.get_application_statistics() metrics = { "timestamp": datetime.utcnow().isoformat(), "type": "application", "content_operations": app_stats["content_ops"], "sync_operations": app_stats["sync_ops"], "consensus_operations": app_stats["consensus_ops"], "replication_operations": app_stats["replication_ops"], "api_requests": app_stats["api_requests"], "error_rates": app_stats["error_rates"], "queue_sizes": app_stats["queue_sizes"], "cache_hit_rates": app_stats["cache_stats"] } await self.store_metric(metrics) await asyncio.sleep(self.collection_interval) except Exception as e: logger.error(f"Error collecting application metrics: {e}") await asyncio.sleep(self.collection_interval) ``` ### 2. Load Testing and Stress Monitoring ```python class LoadMonitor: def __init__(self): self.load_thresholds = { "cpu_critical": 90.0, "cpu_warning": 70.0, "memory_critical": 95.0, "memory_warning": 80.0, "disk_critical": 95.0, "disk_warning": 85.0, "network_critical": 90.0, "network_warning": 70.0 } async def monitor_load_continuously(self): """Непрерывный мониторинг нагрузки""" while True: try: current_load = await self.assess_current_load() # Проверка критических уровней critical_alerts = await self.check_critical_levels(current_load) if critical_alerts: await self.handle_critical_alerts(critical_alerts) # Проверка предупреждений warning_alerts = await self.check_warning_levels(current_load) if warning_alerts: await self.handle_warning_alerts(warning_alerts) # Адаптивное управление ресурсами await self.adaptive_resource_management(current_load) await asyncio.sleep(10) # Проверка каждые 10 секунд except Exception as e: logger.error(f"Error in load monitoring: {e}") await asyncio.sleep(10) async def assess_current_load(self) -> dict: """Оценка текущей нагрузки""" return { "cpu_load": psutil.cpu_percent(interval=1), "memory_load": psutil.virtual_memory().percent, "disk_load": max([ psutil.disk_usage(path).percent for path in ["/", "/tmp", "/var/log"] ]), "network_load": await self.calculate_network_load(), "application_load": await self.calculate_application_load(), "timestamp": datetime.utcnow() } async def adaptive_resource_management(self, current_load: dict): """Адаптивное управление ресурсами""" # CPU нагрузка if current_load["cpu_load"] > self.load_thresholds["cpu_warning"]: await self.reduce_cpu_intensive_operations() # Память if current_load["memory_load"] > self.load_thresholds["memory_warning"]: await self.optimize_memory_usage() # Сеть if current_load["network_load"] > self.load_thresholds["network_warning"]: await self.throttle_network_operations() # Приложение if current_load["application_load"] > 80.0: await self.scale_application_resources() ``` ## Telegram Bot Команды для Управления ### 1. MY Network Telegram Bot ```python from aiogram import Bot, Dispatcher, types from aiogram.filters import Command from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup class MYNetworkTelegramBot: def __init__(self, token: str, authorized_users: List[int]): self.bot = Bot(token) self.dp = Dispatcher() self.authorized_users = set(authorized_users) self.setup_handlers() def setup_handlers(self): """Настройка обработчиков команд""" @self.dp.message(Command("start")) async def start_command(message: types.Message): if message.from_user.id not in self.authorized_users: await message.reply("❌ Access denied. Unauthorized user.") return keyboard = InlineKeyboardMarkup(inline_keyboard=[ [InlineKeyboardButton(text="📊 Node Status", callback_data="status")], [InlineKeyboardButton(text="🌐 Network Info", callback_data="network")], [InlineKeyboardButton(text="📁 Content Stats", callback_data="content")], [InlineKeyboardButton(text="⚡ Performance", callback_data="performance")], [InlineKeyboardButton(text="🔧 Controls", callback_data="controls")] ]) await message.reply( "🤖 MY Network Control Bot\n\n" "Welcome to the MY Network monitoring and control interface.\n" "Select an option below:", reply_markup=keyboard ) @self.dp.message(Command("status")) async def status_command(message: types.Message): if message.from_user.id not in self.authorized_users: return try: status = await NodeStatusCollector.get_current_status() status_text = f""" 🖥 **MY Network Node Status** 🆔 Node ID: `{status['node_id'][:16]}...` ⏰ Uptime: {self.format_uptime(status['uptime'])} 🟢 Status: {status['health_status']} 👥 Peers: {status['peer_count']} connected 📁 Content: {status['content_count']} items 💾 Storage: {status['storage_usage']} 🔄 Sync: {status['sync_status']} 📊 **Resources:** 🖥 CPU: {status['cpu_usage']:.1f}% 💾 RAM: {status['memory_usage']:.1f}% 💿 Disk: {status['disk_usage']:.1f}% 🌐 Network: {status['network_io']} """ await message.reply(status_text, parse_mode="Markdown") except Exception as e: await message.reply(f"❌ Error getting status: {str(e)}") @self.dp.message(Command("peers")) async def peers_command(message: types.Message): if message.from_user.id not in self.authorized_users: return try: peers = await PeerManager.get_all_peers_status() if not peers: await message.reply("No peers connected.") return peers_text = "👥 **Connected Peers:**\n\n" for peer in peers[:10]: # Показать первые 10 status_emoji = "🟢" if peer["status"] == "active" else "🔴" peers_text += f"{status_emoji} `{peer['id'][:12]}...`\n" peers_text += f" 📍 {peer['address']}\n" peers_text += f" ⏱ {peer['latency']}ms\n" peers_text += f" 📊 {peer['reputation']:.2f}/5.0\n\n" if len(peers) > 10: peers_text += f"... and {len(peers) - 10} more peers" await message.reply(peers_text, parse_mode="Markdown") except Exception as e: await message.reply(f"❌ Error getting peers: {str(e)}") @self.dp.message(Command("sync")) async def sync_command(message: types.Message): if message.from_user.id not in self.authorized_users: return try: # Запуск принудительной синхронизации sync_task = await ContentSyncManager.start_full_sync() await message.reply( f"🔄 Full synchronization started\n" f"Task ID: `{sync_task.id}`\n" f"Use /sync_status to check progress." ) except Exception as e: await message.reply(f"❌ Error starting sync: {str(e)}") @self.dp.message(Command("alerts")) async def alerts_command(message: types.Message): if message.from_user.id not in self.authorized_users: return try: recent_alerts = await AlertManager.get_recent_alerts(limit=10) if not recent_alerts: await message.reply("✅ No recent alerts.") return alerts_text = "🚨 **Recent Alerts:**\n\n" for alert in recent_alerts: severity_emoji = { "critical": "🔴", "warning": "🟡", "info": "ℹ️" }.get(alert["severity"], "ℹ️") alerts_text += f"{severity_emoji} **{alert['title']}**\n" alerts_text += f" {alert['message']}\n" alerts_text += f" 📅 {alert['timestamp']}\n\n" await message.reply(alerts_text, parse_mode="Markdown") except Exception as e: await message.reply(f"❌ Error getting alerts: {str(e)}") ``` ### 2. Advanced Bot Commands ```python @self.dp.message(Command("restart")) async def restart_command(message: types.Message): if message.from_user.id not in self.authorized_users: return # Подтверждение перезапуска keyboard = InlineKeyboardMarkup(inline_keyboard=[ [InlineKeyboardButton(text="✅ Confirm Restart", callback_data="restart_confirm")], [InlineKeyboardButton(text="❌ Cancel", callback_data="restart_cancel")] ]) await message.reply( "⚠️ **Restart Confirmation**\n\n" "This will restart the MY Network node.\n" "All active connections will be lost.\n\n" "Are you sure?", reply_markup=keyboard, parse_mode="Markdown" ) @self.dp.message(Command("config")) async def config_command(message: types.Message, args: str = None): if message.from_user.id not in self.authorized_users: return if not args: # Показать текущую конфигурацию config = await ConfigManager.get_current_config() config_text = f""" ⚙️ **Current Configuration:** 🔧 **Network Settings:** • Max Peers: {config['max_peers']} • Sync Interval: {config['sync_interval']}s • Consensus Timeout: {config['consensus_timeout']}s 📊 **Resource Limits:** • Max Storage: {config['max_storage']} • Max Bandwidth: {config['max_bandwidth']} • Max Memory: {config['max_memory']} 🔒 **Security:** • Encryption: {config['encryption_enabled']} • Auth Required: {config['auth_required']} """ await message.reply(config_text, parse_mode="Markdown") else: # Обновить конфигурацию try: key, value = args.split("=", 1) await ConfigManager.update_config(key.strip(), value.strip()) await message.reply(f"✅ Configuration updated: {key} = {value}") except ValueError: await message.reply( "❌ Invalid format. Use: /config key=value" ) except Exception as e: await message.reply(f"❌ Error updating config: {str(e)}") @self.dp.message(Command("blacklist")) async def blacklist_command(message: types.Message, args: str = None): if message.from_user.id not in self.authorized_users: return if not args: # Показать blacklist blacklisted = await PeerManager.get_blacklisted_peers() if not blacklisted: await message.reply("📝 Blacklist is empty.") return blacklist_text = "🚫 **Blacklisted Peers:**\n\n" for peer_id in blacklisted: blacklist_text += f"• `{peer_id}`\n" await message.reply(blacklist_text, parse_mode="Markdown") else: # Добавить в blacklist try: peer_id = args.strip() await PeerManager.blacklist_peer(peer_id) await message.reply(f"✅ Peer blacklisted: `{peer_id}`") except Exception as e: await message.reply(f"❌ Error blacklisting peer: {str(e)}") ``` ## Web-интерфейс ### 1. Web Dashboard ```html MY Network Monitoring Dashboard

🔹 MY NETWORK MONITORING DASHBOARD 🔹

Real-time monitoring of distributed content network

📊 Node Status

Node ID: Loading...

Uptime: Loading...

Status: Loading...

Peers: Loading...

💾 Resources

CPU Usage:

Memory Usage:

Disk Usage:

🌐 Network

Bandwidth: Loading...

Latency: Loading...

Messages/sec: Loading...

Errors: Loading...

📁 Content

Total Items: Loading...

Sync Status: Loading...

Replication Rate: Loading...

Storage Used: Loading...

📡 Live Terminal

Connecting to MY Network node...
Establishing secure connection...
█

🗺️ Network Topology

``` Данная система мониторинга обеспечивает полный контроль над MY Network с помощью различных интерфейсов - от хакерского ASCII-арт терминала до современного веб-интерфейса и Telegram бота для удаленного управления.