580 lines
24 KiB
Python
580 lines
24 KiB
Python
import os
|
||
import select
|
||
import time
|
||
import uuid
|
||
import subprocess
|
||
import threading
|
||
from flask import Blueprint, request, current_app, session
|
||
from flask_socketio import Namespace, join_room, leave_room, emit, SocketIO, rooms, disconnect
|
||
from threading import Thread
|
||
import sys
|
||
from ..extensions import socketio
|
||
import pty
|
||
import termios
|
||
import struct
|
||
import fcntl
|
||
import psutil
|
||
|
||
TERM_INIT_CONFIG = {
|
||
# instead of local server runnning this web terminal service
|
||
# "domain" is the target that you want to access through local server (with this web terminal)
|
||
# and before doing so - make sure you have username and port (on the "domain") to implement remote access
|
||
'domain': '127.0.0.1', # or ip address like 192.168.10.11
|
||
'client_path': {
|
||
'telnet': '/usr/bin/telnet', # confirmed location of your client binary (with cmd like 'which telnet')
|
||
'ssh': '/usr/bin/ssh'
|
||
}
|
||
}
|
||
|
||
terminal_bp = Blueprint('terminal', __name__, url_prefix='/vsc-like')
|
||
|
||
|
||
class TerminalSessionManager:
|
||
"""终端会话管理器，用于统一管理所有终端会话"""
|
||
def __init__(self):
|
||
# 存储所有终端会话，key为session_id，value为会话配置
|
||
self.sessions = {}
|
||
# 线程锁，保证多线程安全
|
||
self.lock = threading.Lock()
|
||
# 最大终端数量限制
|
||
self.max_terminals = 100
|
||
# 终端空闲超时时间（秒）
|
||
self.idle_timeout = 3600 # 1小时
|
||
|
||
def create_session(self):
|
||
"""创建新的终端会话"""
|
||
with self.lock:
|
||
# 检查是否达到最大终端数量
|
||
if len(self.sessions) >= self.max_terminals:
|
||
return None, "Maximum number of terminals reached"
|
||
|
||
# 生成唯一的会话ID和房间ID
|
||
session_id = str(uuid.uuid4())
|
||
room_id = f"terminal_{session_id}"
|
||
|
||
# 创建会话配置
|
||
session_config = {
|
||
**TERM_INIT_CONFIG.copy(),
|
||
'session_id': session_id,
|
||
'room_id': room_id,
|
||
'created_at': time.time(),
|
||
'last_activity': time.time()
|
||
}
|
||
|
||
# 保存会话
|
||
self.sessions[session_id] = session_config
|
||
|
||
return session_config, None
|
||
|
||
def get_session(self, session_id):
|
||
"""获取会话配置"""
|
||
with self.lock:
|
||
return self.sessions.get(session_id)
|
||
|
||
def update_session(self, session_id, updates):
|
||
"""更新会话配置"""
|
||
with self.lock:
|
||
if session_id not in self.sessions:
|
||
return False
|
||
|
||
# 更新会话配置
|
||
self.sessions[session_id].update(updates)
|
||
# 更新最后活动时间
|
||
self.sessions[session_id]['last_activity'] = time.time()
|
||
|
||
return True
|
||
|
||
def delete_session(self, session_id):
|
||
"""删除会话"""
|
||
with self.lock:
|
||
if session_id in self.sessions:
|
||
del self.sessions[session_id]
|
||
return True
|
||
return False
|
||
|
||
def get_session_by_room_id(self, room_id):
|
||
"""通过房间ID获取会话"""
|
||
with self.lock:
|
||
for session_config in self.sessions.values():
|
||
if session_config.get('room_id') == room_id:
|
||
return session_config
|
||
return None
|
||
|
||
def cleanup_inactive_sessions(self):
|
||
"""清理不活动的会话"""
|
||
with self.lock:
|
||
current_time = time.time()
|
||
expired_sessions = []
|
||
|
||
# 找出超时的会话
|
||
for session_id, session_config in self.sessions.items():
|
||
if current_time - session_config['last_activity'] > self.idle_timeout:
|
||
expired_sessions.append(session_id)
|
||
|
||
# 删除超时的会话
|
||
for session_id in expired_sessions:
|
||
del self.sessions[session_id]
|
||
|
||
return expired_sessions
|
||
|
||
def get_active_session_count(self):
|
||
"""获取当前活动会话数量"""
|
||
with self.lock:
|
||
return len(self.sessions)
|
||
|
||
|
||
# 创建全局终端会话管理器实例
|
||
terminal_manager = TerminalSessionManager()
|
||
|
||
|
||
|
||
def set_winsize(fd, row, col, xpix=0, ypix=0):
|
||
try:
|
||
winsize = struct.pack("HHHH", row, col, xpix, ypix)
|
||
fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
|
||
except (OSError, IOError):
|
||
# File descriptor closed or invalid, do nothing
|
||
pass
|
||
|
||
|
||
def read_and_forward_pty_output(fd=None, pid=None, room_id=None, namespace=None):
|
||
"""
|
||
read data on pty master from the pty slave, and emit to the web terminal visitor
|
||
"""
|
||
max_read_bytes = 1024 * 20
|
||
# 初始超时时间设置为较短值，确保响应迅速
|
||
timeout = 0.05
|
||
# 最大超时时间，避免太频繁的检查
|
||
max_timeout = 0.5
|
||
# 成功读取数据后的重置超时时间
|
||
reset_timeout = 0.05
|
||
|
||
try:
|
||
while True:
|
||
# 等待一段时间，减少CPU占用
|
||
socketio.sleep(timeout)
|
||
|
||
# 使用指数退避算法调整超时时间，但不超过最大值
|
||
timeout = min(timeout * 1.5, max_timeout)
|
||
|
||
# 检查子进程状态
|
||
try:
|
||
child_process = psutil.Process(pid)
|
||
except psutil.NoSuchProcess:
|
||
# 进程已终止，清理僵尸进程
|
||
try:
|
||
os.waitpid(pid, os.WNOHANG)
|
||
except Exception:
|
||
pass
|
||
return
|
||
|
||
# 检查进程状态，如果不是运行或睡眠状态，则退出
|
||
if child_process.status() not in ('running', 'sleeping'):
|
||
try:
|
||
# 等待进程终止
|
||
child_process.wait(timeout=1)
|
||
except Exception:
|
||
try:
|
||
os.waitpid(pid, os.WNOHANG)
|
||
except Exception:
|
||
pass
|
||
return
|
||
|
||
# 如果文件描述符有效，尝试读取数据
|
||
if fd:
|
||
try:
|
||
# 使用非阻塞select检查是否有数据可读
|
||
(data_ready, _, _) = select.select([fd], [], [], 0)
|
||
if data_ready:
|
||
# 有数据可读，重置超时时间
|
||
timeout = reset_timeout
|
||
try:
|
||
# 读取数据
|
||
output = os.read(fd, max_read_bytes).decode()
|
||
except (OSError, IOError, EOFError):
|
||
# 文件描述符已关闭或其他IO错误，优雅退出
|
||
return
|
||
except UnicodeDecodeError as err:
|
||
# 处理编码错误
|
||
output = f"""
|
||
***AQUI WEB TERM ERR***
|
||
Unicode decode error: {err}
|
||
***********************
|
||
"""
|
||
|
||
# 发送数据到客户端
|
||
try:
|
||
namespace.emit("pty_output", {"output": output}, room=room_id)
|
||
except Exception:
|
||
# 如果发送失败，客户端可能已断开连接，退出
|
||
return
|
||
except (OSError, IOError):
|
||
# 文件描述符无效，优雅退出
|
||
return
|
||
except Exception as e:
|
||
# 捕获任何其他未预期的异常，防止服务器崩溃
|
||
current_app.logger.error(f"Unexpected error in read_and_forward_pty_output: {e}")
|
||
finally:
|
||
# 清理文件描述符
|
||
if fd:
|
||
try:
|
||
os.close(fd)
|
||
except Exception:
|
||
pass
|
||
|
||
class VSCLikeNameSpace(Namespace):
|
||
def __init__(self, namespace=None):
|
||
super().__init__(namespace)
|
||
# 存储客户端socket_id到session_id的映射
|
||
self.socket_session_map = {}
|
||
# 线程锁，保证多线程安全
|
||
self.lock = threading.Lock()
|
||
|
||
def create_terminal(self, session_id):
|
||
"""创建新的终端并更新会话配置"""
|
||
# 获取会话配置
|
||
terminal_config = terminal_manager.get_session(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Session not found: {session_id}")
|
||
return None
|
||
|
||
room_id = terminal_config['room_id']
|
||
current_app.logger.debug(f"Creating new terminal for room: {room_id}")
|
||
|
||
# create child process attached to a pty we can read from and write to
|
||
(child_pid, fd) = pty.fork()
|
||
if child_pid == 0:
|
||
# this is the child process fork.
|
||
# anything printed here will show up in the pty, including the output
|
||
# of this subprocess
|
||
try:
|
||
# 获取终端配置
|
||
term_type = terminal_config.get('term_type')
|
||
|
||
if not term_type:
|
||
print("Terminal type not specified, exit")
|
||
os._exit(1)
|
||
|
||
path = terminal_config.get('client_path', {}).get(term_type, None)
|
||
if not path or not os.path.exists(path):
|
||
print(f"Can't locate {term_type} binary at {path}, exit")
|
||
os._exit(1)
|
||
|
||
# 获取连接参数
|
||
username = terminal_config.get('username')
|
||
domain = terminal_config.get('domain')
|
||
port = terminal_config.get('port')
|
||
|
||
if not username or not domain:
|
||
print("Missing required connection parameters, exit")
|
||
os._exit(1)
|
||
|
||
if term_type == 'telnet':
|
||
# 使用telnet连接
|
||
if not port:
|
||
print("Port not specified for telnet, exit")
|
||
os._exit(1)
|
||
os.execl(path, 'telnet', '-l', username, domain, str(port))
|
||
elif term_type == 'ssh':
|
||
# 使用ssh连接
|
||
ssh_port = port if port else 22 # 默认端口22
|
||
os.execl(path, 'ssh', '-p', str(ssh_port), f'{username}@{domain}')
|
||
else:
|
||
print(f"Wrong term type {term_type}, exit")
|
||
os._exit(1)
|
||
except Exception as e:
|
||
print(f"Error in child process: {e}")
|
||
os._exit(1)
|
||
else:
|
||
# 更新会话配置，保存到终端管理器
|
||
updates = {
|
||
'fd': fd,
|
||
'child_pid': child_pid
|
||
}
|
||
terminal_manager.update_session(session_id, updates)
|
||
|
||
# 设置初始窗口大小
|
||
set_winsize(fd, 50, 50)
|
||
|
||
# 记录日志
|
||
current_app.logger.debug(f"Child process created: {child_pid} for room: {room_id}")
|
||
|
||
# 启动后台任务读取pty输出，传入正确的room_id
|
||
socketio.start_background_task(read_and_forward_pty_output, fd, child_pid, room_id, self)
|
||
current_app.logger.debug("Background task running")
|
||
|
||
return terminal_config
|
||
|
||
def on_connect(self):
|
||
"""new client connected"""
|
||
# 创建新的终端会话
|
||
terminal_config, error = terminal_manager.create_session()
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Failed to create terminal session: {error}")
|
||
return
|
||
|
||
session_id = terminal_config['session_id']
|
||
room_id = terminal_config['room_id']
|
||
|
||
# 加入房间
|
||
join_room(room_id)
|
||
|
||
# 保存socket_id到session_id的映射
|
||
socket_id = request.sid
|
||
with self.lock:
|
||
self.socket_session_map[socket_id] = session_id
|
||
|
||
current_app.logger.debug(f"Client connected, session_id: {session_id}, room_id: {room_id}, socket_id: {socket_id}")
|
||
|
||
# 创建终端
|
||
self.create_terminal(session_id)
|
||
current_app.logger.debug("background task running")
|
||
|
||
def on_pty_input(self, data):
|
||
"""write to the child pty, which now is the ssh process from this machine to the 'domain' configured
|
||
"""
|
||
# 获取socket_id对应的session_id
|
||
socket_id = request.sid
|
||
with self.lock:
|
||
session_id = self.socket_session_map.get(socket_id)
|
||
|
||
if not session_id:
|
||
current_app.logger.error(f"No session found for socket: {socket_id}")
|
||
return
|
||
|
||
# 输入验证
|
||
if not isinstance(data, dict):
|
||
current_app.logger.error("Invalid input format: expected dictionary")
|
||
return
|
||
|
||
input_data = data.get("input")
|
||
if not isinstance(input_data, str):
|
||
current_app.logger.error("Invalid input data: expected string")
|
||
return
|
||
|
||
# 限制输入长度，防止缓冲区溢出
|
||
if len(input_data) > 1024:
|
||
input_data = input_data[:1024]
|
||
current_app.logger.warning("Input truncated due to length")
|
||
|
||
try:
|
||
terminal_config = terminal_manager.get_session(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Session not found: {session_id}")
|
||
return
|
||
|
||
child_pid = terminal_config.get('child_pid')
|
||
|
||
# 如果没有子进程，重新创建终端
|
||
if not child_pid:
|
||
current_app.logger.debug(f"No child process found for session: {session_id}, creating new terminal")
|
||
terminal_config = self.create_terminal(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Failed to create new terminal for session: {session_id}")
|
||
return
|
||
child_pid = terminal_config.get('child_pid')
|
||
if not child_pid:
|
||
current_app.logger.error(f"Failed to get child_pid for session: {session_id}")
|
||
return
|
||
|
||
# 检查子进程是否存在且运行中
|
||
try:
|
||
child_process = psutil.Process(child_pid)
|
||
if child_process.status() not in ('running', 'sleeping'):
|
||
current_app.logger.debug(f"Child process not running for session: {session_id}, creating new terminal")
|
||
terminal_config = self.create_terminal(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Failed to create new terminal for session: {session_id}")
|
||
return
|
||
child_pid = terminal_config.get('child_pid')
|
||
if not child_pid:
|
||
current_app.logger.error(f"Failed to get child_pid for session: {session_id}")
|
||
return
|
||
except psutil.NoSuchProcess:
|
||
current_app.logger.debug(f"Child process not found for session: {session_id}, creating new terminal")
|
||
terminal_config = self.create_terminal(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Failed to create new terminal for session: {session_id}")
|
||
return
|
||
child_pid = terminal_config.get('child_pid')
|
||
if not child_pid:
|
||
current_app.logger.error(f"Failed to get child_pid for session: {session_id}")
|
||
return
|
||
|
||
# 获取文件描述符并写入数据
|
||
fd = terminal_config.get('fd')
|
||
if fd:
|
||
try:
|
||
os.write(fd, input_data.encode())
|
||
except (OSError, IOError) as e:
|
||
# File descriptor closed or invalid, create new terminal
|
||
current_app.logger.debug(f"Error writing to file descriptor: {e}, creating new terminal for session: {session_id}")
|
||
self.create_terminal(session_id)
|
||
except Exception as e:
|
||
current_app.logger.error(f"Error in pty_input handling: {e}")
|
||
# 发生异常时尝试重新创建终端
|
||
try:
|
||
self.create_terminal(session_id)
|
||
except Exception as create_err:
|
||
current_app.logger.error(f"Failed to recreate terminal: {create_err}")
|
||
|
||
|
||
def on_resize(self, data):
|
||
# 获取socket_id对应的session_id
|
||
socket_id = request.sid
|
||
with self.lock:
|
||
session_id = self.socket_session_map.get(socket_id)
|
||
|
||
if not session_id:
|
||
current_app.logger.error(f"No session found for socket: {socket_id}")
|
||
return
|
||
|
||
# 输入验证
|
||
if not isinstance(data, dict):
|
||
current_app.logger.error("Invalid resize data format: expected dictionary")
|
||
return
|
||
|
||
rows = data.get("rows")
|
||
cols = data.get("cols")
|
||
|
||
# 验证行和列的值是否为正整数
|
||
if not (isinstance(rows, int) and isinstance(cols, int)):
|
||
current_app.logger.error("Invalid resize dimensions: expected integers")
|
||
return
|
||
|
||
# 限制窗口大小范围，防止异常值
|
||
if rows <= 0 or rows > 1000 or cols <= 0 or cols > 1000:
|
||
current_app.logger.error(f"Invalid resize dimensions: {rows}x{cols} (out of range)")
|
||
return
|
||
|
||
try:
|
||
terminal_config = terminal_manager.get_session(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Session not found: {session_id}")
|
||
return
|
||
|
||
child_pid = terminal_config.get('child_pid')
|
||
|
||
# 如果没有子进程，重新创建终端
|
||
if not child_pid:
|
||
current_app.logger.debug(f"No child process found for resize, creating new terminal for session: {session_id}")
|
||
terminal_config = self.create_terminal(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Failed to create new terminal for resize, session: {session_id}")
|
||
return
|
||
child_pid = terminal_config.get('child_pid')
|
||
if not child_pid:
|
||
current_app.logger.error(f"Failed to get child_pid for resize, session: {session_id}")
|
||
return
|
||
|
||
# 检查子进程是否存在且运行中
|
||
try:
|
||
child_process = psutil.Process(child_pid)
|
||
if child_process.status() not in ('running', 'sleeping'):
|
||
current_app.logger.debug(f"Child process not running for resize, creating new terminal for session: {session_id}")
|
||
terminal_config = self.create_terminal(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Failed to create new terminal for resize, session: {session_id}")
|
||
return
|
||
child_pid = terminal_config.get('child_pid')
|
||
if not child_pid:
|
||
current_app.logger.error(f"Failed to get child_pid for resize, session: {session_id}")
|
||
return
|
||
except psutil.NoSuchProcess:
|
||
current_app.logger.debug(f"Child process not found for resize, creating new terminal for session: {session_id}")
|
||
terminal_config = self.create_terminal(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Failed to create new terminal for resize, session: {session_id}")
|
||
return
|
||
child_pid = terminal_config.get('child_pid')
|
||
if not child_pid:
|
||
current_app.logger.error(f"Failed to get child_pid for resize, session: {session_id}")
|
||
return
|
||
|
||
# 获取文件描述符并调整窗口大小
|
||
fd = terminal_config.get('fd')
|
||
if fd:
|
||
try:
|
||
os.fstat(fd)
|
||
set_winsize(fd, rows, cols)
|
||
except (OSError, IOError) as e:
|
||
# 文件描述符无效，创建新终端
|
||
current_app.logger.debug(f"Error resizing terminal: {e}, creating new terminal for session: {session_id}")
|
||
self.create_terminal(session_id)
|
||
except Exception as e:
|
||
current_app.logger.error(f"Error in resize handling: {e}")
|
||
# 发生异常时尝试重新创建终端
|
||
try:
|
||
self.create_terminal(session_id)
|
||
except Exception as create_err:
|
||
current_app.logger.error(f"Failed to recreate terminal for resize: {create_err}")
|
||
|
||
def on_disconnect(self):
|
||
# 获取socket_id对应的session_id
|
||
socket_id = request.sid
|
||
with self.lock:
|
||
session_id = self.socket_session_map.pop(socket_id, None)
|
||
|
||
if not session_id:
|
||
current_app.logger.error(f"No session found for socket: {socket_id}")
|
||
return
|
||
|
||
# 获取会话配置
|
||
terminal_config = terminal_manager.get_session(session_id)
|
||
if not terminal_config:
|
||
current_app.logger.error(f"Session not found: {session_id}")
|
||
return
|
||
|
||
child_pid = terminal_config.get('child_pid')
|
||
fd = terminal_config.get('fd')
|
||
room_id = terminal_config.get('room_id')
|
||
|
||
current_app.logger.debug(f"Client disconnecting, session_id: {session_id}, room_id: {room_id}, socket_id: {socket_id}")
|
||
|
||
# 退出房间
|
||
if room_id:
|
||
leave_room(room_id)
|
||
current_app.logger.debug(f"Client left room: {room_id}")
|
||
|
||
# 先关闭文件描述符，避免其他操作尝试使用无效的文件描述符
|
||
if fd:
|
||
try:
|
||
os.close(fd)
|
||
current_app.logger.debug(f"Closed file descriptor: {fd}")
|
||
except Exception as e:
|
||
current_app.logger.debug(f"Error closing file descriptor: {e}")
|
||
|
||
if child_pid:
|
||
try:
|
||
child_process = psutil.Process(child_pid)
|
||
if child_process.status() in ('running', 'sleeping'):
|
||
# if visitor just close the browser tab then left alone the pty here
|
||
# it should be terminated by the parent process after
|
||
child_process.terminate()
|
||
# Wait for the process to terminate and collect its exit status
|
||
child_process.wait(timeout=2)
|
||
current_app.logger.debug(f'User left pty alone, terminated and waited: {child_pid}')
|
||
except psutil.NoSuchProcess:
|
||
# Process already terminated, try to wait anyway to clean up any zombie
|
||
try:
|
||
os.waitpid(child_pid, os.WNOHANG)
|
||
current_app.logger.debug(f'Cleaned up zombie process: {child_pid}')
|
||
except Exception as e:
|
||
current_app.logger.debug(f"Error cleaning up zombie process: {e}")
|
||
except psutil.TimeoutExpired:
|
||
# If process didn't terminate in time, kill it forcefully
|
||
try:
|
||
child_process.kill()
|
||
child_process.wait(timeout=1)
|
||
current_app.logger.debug(f'Forcefully killed process: {child_pid}')
|
||
except Exception as e:
|
||
current_app.logger.debug(f"Error forcefully killing process: {e}")
|
||
except Exception as err:
|
||
current_app.logger.error(f'Error terminating process: {err}')
|
||
|
||
# 从终端管理器中删除会话
|
||
terminal_manager.delete_session(session_id)
|
||
current_app.logger.debug(f"Session deleted: {session_id}")
|
||
|
||
current_app.logger.debug(f"Client disconnected, session_id: {session_id}, room_id: {room_id}")
|
||
current_app.logger.debug('Client disconnected') |