blob: f44edc9239e40a7ff3069c0586794caf2e8cbf27 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
import os
import sys
import asyncio
import logging
import socket
from network.tor_manager import TorManager
from network.mesh import MeshNetwork
from ui.chat_window import ChatWindow
from security.memory import SecureMemory
from security.crypto import CryptoManager
class MeshChat:
def __init__(self):
# Configure logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
self.logger = logging.getLogger('MeshChat')
# Initialize components
self.tor_manager = TorManager()
self.mesh_network = MeshNetwork(base_port=12345, max_retry_ports=5)
self.crypto = CryptoManager()
self.secure_memory = SecureMemory()
async def _verify_network(self) -> bool:
"""Verify network components are running"""
try:
# Try connecting to health check endpoint
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 12345))
sock.close()
self.logger.info("Network connectivity verified")
return True
except Exception as e:
self.logger.error(f"Network verification failed: {str(e)}")
return False
async def start(self):
"""Start application with robust error handling"""
try:
# Start Tor
self.logger.info("Starting Tor...")
await self.tor_manager.start()
self.logger.info(f"Tor started with onion address: {self.tor_manager.onion_address}")
# Initialize mesh network with retries
max_retries = 3
retry_delay = 2
last_error = None
for attempt in range(max_retries):
try:
self.logger.info(f"Starting mesh network (attempt {attempt + 1}/{max_retries})...")
await self.mesh_network.start()
# Verify network is running
if await self._verify_network():
self.logger.info("Mesh network started and verified")
break
else:
raise Exception("Network verification failed")
except Exception as e:
last_error = e
self.logger.warning(f"Attempt {attempt + 1} failed: {str(e)}")
if attempt < max_retries - 1:
await asyncio.sleep(retry_delay)
else:
raise Exception(f"Failed to start mesh network after {max_retries} attempts: {str(last_error)}")
# Start GUI
self.logger.info("Initializing GUI...")
self.window = ChatWindow(
self.mesh_network,
self.tor_manager,
self.crypto,
self.secure_memory
)
self.logger.info("Application fully started")
await self.window.run()
except Exception as e:
self.logger.error(f"Fatal error: {str(e)}")
await self.cleanup()
sys.exit(1)
async def cleanup(self):
"""Cleanup with proper error handling"""
self.logger.info("Starting cleanup...")
cleanup_tasks = []
# Stop Tor
if hasattr(self, 'tor_manager'):
cleanup_tasks.append(self.tor_manager.stop())
# Stop mesh network
if hasattr(self, 'mesh_network'):
cleanup_tasks.append(self.mesh_network.stop())
# Wipe sensitive data
if hasattr(self, 'secure_memory'):
self.secure_memory.wipe_all()
# Wait for all cleanup tasks
if cleanup_tasks:
await asyncio.gather(*cleanup_tasks, return_exceptions=True)
self.logger.info("Cleanup completed")
if __name__ == "__main__":
app = MeshChat()
try:
asyncio.run(app.start())
except KeyboardInterrupt:
app.logger.info("Received shutdown signal")
asyncio.run(app.cleanup())
|
