v6ole/H3ConuMS-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始化

Browse Source
This commit is contained in:
v6ole
2026-04-02 23:40:04 +08:00
commit 381ea7085d
107 changed files with 11858 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
deploy/scripts/deploy.sh
Executable
+362
View File
@@ -0,0 +1,362 @@
#!/bin/bash
# H3C ONU设备管理系统 - 部署脚本
# 使用方法: ./deploy.sh [环境] [操作]
# 环境: dev, prod (默认: prod)
# 操作: up, down, restart, logs, build (默认: up)
set -e
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 默认值
ENV=${1:-prod}
ACTION=${2:-up}
COMPOSE_FILE="docker-compose.yml"
# 根据环境选择配置文件
if [ "$ENV" = "dev" ]; then
COMPOSE_FILE="docker-compose.dev.yml"
echo -e "${BLUE}使用开发环境配置${NC}"
elif [ "$ENV" = "prod" ]; then
COMPOSE_FILE="docker-compose.yml"
echo -e "${BLUE}使用生产环境配置${NC}"
else
echo -e "${RED}错误: 未知环境 '$ENV'${NC}"
echo "可用环境: dev, prod"
exit 1
fi
# 检查Docker Compose文件是否存在
if [ ! -f "$COMPOSE_FILE" ]; then
echo -e "${RED}错误: Docker Compose文件 '$COMPOSE_FILE' 不存在${NC}"
exit 1
fi
# 检查环境变量文件
if [ ! -f ".env" ]; then
echo -e "${YELLOW}警告: .env 文件不存在，从 .env.example 复制${NC}"
if [ -f ".env.example" ]; then
cp .env.example .env
echo -e "${YELLOW}请编辑 .env 文件并设置正确的配置${NC}"
exit 1
else
echo -e "${RED}错误: .env.example 文件也不存在${NC}"
exit 1
fi
fi
# 加载环境变量
set -a
source .env
set +a
# 函数：显示帮助信息
show_help() {
echo "H3C ONU设备管理系统 - 部署脚本"
echo ""
echo "使用方法: $0 [环境] [操作]"
echo ""
echo "环境:"
echo " dev 开发环境"
echo " prod 生产环境 (默认)"
echo ""
echo "操作:"
echo " up 启动服务 (默认)"
echo " down 停止服务"
echo " restart 重启服务"
echo " logs 查看日志"
echo " build 构建镜像"
echo " ps 查看服务状态"
echo " exec 进入容器"
echo " backup 备份数据"
echo " restore 恢复数据"
echo ""
echo "示例:"
echo " $0 prod up # 启动生产环境"
echo " $0 dev logs # 查看开发环境日志"
echo " $0 prod restart # 重启生产环境"
}
# 函数：检查Docker是否运行
check_docker() {
if ! docker info > /dev/null 2>&1; then
echo -e "${RED}错误: Docker未运行或当前用户无权限${NC}"
exit 1
fi
}
# 函数：检查Docker Compose是否安装
check_docker_compose() {
if ! command -v docker-compose &> /dev/null; then
echo -e "${RED}错误: Docker Compose未安装${NC}"
exit 1
fi
}
# 函数：启动服务
start_services() {
echo -e "${GREEN}启动服务...${NC}"
docker-compose -f "$COMPOSE_FILE" up -d
# 等待服务启动
echo -e "${BLUE}等待服务启动...${NC}"
sleep 10
# 检查服务状态
check_services_status
}
# 函数：停止服务
stop_services() {
echo -e "${YELLOW}停止服务...${NC}"
docker-compose -f "$COMPOSE_FILE" down
}
# 函数：重启服务
restart_services() {
echo -e "${YELLOW}重启服务...${NC}"
docker-compose -f "$COMPOSE_FILE" restart
}
# 函数：查看日志
show_logs() {
echo -e "${BLUE}查看日志 (Ctrl+C退出)...${NC}"
docker-compose -f "$COMPOSE_FILE" logs -f
}
# 函数：构建镜像
build_images() {
echo -e "${GREEN}构建Docker镜像...${NC}"
docker-compose -f "$COMPOSE_FILE" build --no-cache
# 清理未使用的镜像
echo -e "${BLUE}清理未使用的镜像...${NC}"
docker image prune -f
}
# 函数：查看服务状态
show_status() {
echo -e "${BLUE}服务状态:${NC}"
docker-compose -f "$COMPOSE_FILE" ps
echo -e "\n${BLUE}容器资源使用:${NC}"
docker stats --no-stream $(docker-compose -f "$COMPOSE_FILE" ps -q)
}
# 函数：进入容器
exec_container() {
echo -e "${BLUE}选择要进入的容器:${NC}"
echo "1) backend (后端API)"
echo "2) frontend (前端)"
echo "3) celery-worker (Celery Worker)"
echo "4) celery-beat (Celery Beat)"
echo "5) nginx (Nginx)"
echo "6) redis (Redis)"
read -p "请输入数字 (1-6): " choice
case $choice in
1) CONTAINER="backend" ;;
2) CONTAINER="frontend" ;;
3) CONTAINER="celery-worker" ;;
4) CONTAINER="celery-beat" ;;
5) CONTAINER="nginx" ;;
6) CONTAINER="redis" ;;
*)
echo -e "${RED}无效的选择${NC}"
exit 1
;;
esac
echo -e "${GREEN}进入 $CONTAINER 容器...${NC}"
docker-compose -f "$COMPOSE_FILE" exec "$CONTAINER" sh
}
# 函数：备份数据
backup_data() {
BACKUP_DIR="backups/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"
echo -e "${GREEN}开始备份数据...${NC}"
# 备份数据库
echo -e "${BLUE}备份数据库...${NC}"
DB_CONTAINER=$(docker-compose -f "$COMPOSE_FILE" ps -q backend)
if [ -n "$DB_CONTAINER" ]; then
docker exec "$DB_CONTAINER" pg_dump "$DATABASE_URL" > "$BACKUP_DIR/database.sql"
echo "数据库备份完成: $BACKUP_DIR/database.sql"
else
echo -e "${YELLOW}警告: 数据库容器未运行${NC}"
fi
# 备份Redis数据
echo -e "${BLUE}备份Redis数据...${NC}"
REDIS_CONTAINER=$(docker-compose -f "$COMPOSE_FILE" ps -q redis)
if [ -n "$REDIS_CONTAINER" ]; then
docker exec "$REDIS_CONTAINER" redis-cli --rdb /data/dump.rdb
docker cp "$REDIS_CONTAINER:/data/dump.rdb" "$BACKUP_DIR/redis.rdb"
echo "Redis备份完成: $BACKUP_DIR/redis.rdb"
else
echo -e "${YELLOW}警告: Redis容器未运行${NC}"
fi
# 备份配置文件
echo -e "${BLUE}备份配置文件...${NC}"
cp .env "$BACKUP_DIR/"
cp "$COMPOSE_FILE" "$BACKUP_DIR/"
# 创建备份信息文件
echo "备份时间: $(date)" > "$BACKUP_DIR/backup.info"
echo "环境: $ENV" >> "$BACKUP_DIR/backup.info"
echo "版本: $(git describe --tags 2>/dev/null || echo '未知')" >> "$BACKUP_DIR/backup.info"
# 压缩备份文件
echo -e "${BLUE}压缩备份文件...${NC}"
tar -czf "$BACKUP_DIR.tar.gz" "$BACKUP_DIR"
rm -rf "$BACKUP_DIR"
echo -e "${GREEN}备份完成: $BACKUP_DIR.tar.gz${NC}"
}
# 函数：恢复数据
restore_data() {
echo -e "${YELLOW}警告: 恢复数据将覆盖现有数据${NC}"
read -p "请输入要恢复的备份文件路径: " BACKUP_FILE
if [ ! -f "$BACKUP_FILE" ]; then
echo -e "${RED}错误: 备份文件不存在${NC}"
exit 1
fi
# 解压备份文件
BACKUP_DIR="${BACKUP_FILE%.tar.gz}"
echo -e "${BLUE}解压备份文件...${NC}"
tar -xzf "$BACKUP_FILE"
# 停止服务
echo -e "${BLUE}停止服务...${NC}"
docker-compose -f "$COMPOSE_FILE" down
# 恢复数据库
if [ -f "$BACKUP_DIR/database.sql" ]; then
echo -e "${BLUE}恢复数据库...${NC}"
# 这里需要根据实际情况调整数据库恢复命令
# 例如: psql -d database -f backup.sql
echo "数据库恢复命令需要根据实际情况配置"
fi
# 恢复Redis
if [ -f "$BACKUP_DIR/redis.rdb" ]; then
echo -e "${BLUE}恢复Redis数据...${NC}"
# 这里需要根据实际情况调整Redis恢复命令
echo "Redis恢复命令需要根据实际情况配置"
fi
# 恢复配置文件
if [ -f "$BACKUP_DIR/.env" ]; then
echo -e "${BLUE}恢复配置文件...${NC}"
cp "$BACKUP_DIR/.env" .
fi
# 清理临时文件
rm -rf "$BACKUP_DIR"
# 启动服务
echo -e "${BLUE}启动服务...${NC}"
docker-compose -f "$COMPOSE_FILE" up -d
echo -e "${GREEN}数据恢复完成${NC}"
}
# 函数：检查服务状态
check_services_status() {
echo -e "${BLUE}检查服务健康状态...${NC}"
# 检查后端服务
if curl -f http://localhost:8000/health > /dev/null 2>&1; then
echo -e "${GREEN}✓ 后端服务运行正常${NC}"
else
echo -e "${RED}✗ 后端服务异常${NC}"
fi
# 检查前端服务
if curl -f http://localhost:8080 > /dev/null 2>&1; then
echo -e "${GREEN}✓ 前端服务运行正常${NC}"
else
echo -e "${RED}✗ 前端服务异常${NC}"
fi
# 检查Redis
REDIS_CONTAINER=$(docker-compose -f "$COMPOSE_FILE" ps -q redis)
if [ -n "$REDIS_CONTAINER" ] && docker exec "$REDIS_CONTAINER" redis-cli ping > /dev/null 2>&1; then
echo -e "${GREEN}✓ Redis服务运行正常${NC}"
else
echo -e "${RED}✗ Redis服务异常${NC}"
fi
echo -e "\n${GREEN}部署完成!${NC}"
echo -e "前端访问: ${BLUE}http://localhost:8080${NC}"
echo -e "API文档: ${BLUE}http://localhost:8000/docs${NC}"
echo -e "健康检查: ${BLUE}http://localhost:8000/health${NC}"
}
# 主程序
main() {
# 显示标题
echo -e "${GREEN}========================================${NC}"
echo -e "${GREEN} H3C ONU设备管理系统 - 部署工具${NC}"
echo -e "${GREEN}========================================${NC}"
echo ""
# 检查依赖
check_docker
check_docker_compose
# 根据操作执行相应命令
case "$ACTION" in
up)
start_services
;;
down)
stop_services
;;
restart)
restart_services
;;
logs)
show_logs
;;
build)
build_images
;;
ps)
show_status
;;
exec)
exec_container
;;
backup)
backup_data
;;
restore)
restore_data
;;
help|--help|-h)
show_help
;;
*)
echo -e "${RED}错误: 未知操作 '$ACTION'${NC}"
show_help
exit 1
;;
esac
}
# 执行主程序
main "$@"
deploy/scripts/init-db.sh
Executable
+389
View File
@@ -0,0 +1,389 @@
#!/bin/bash
# H3C ONU设备管理系统 - 数据库初始化脚本
# 用于初始化数据库和创建基础数据
set -e
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 加载环境变量
if [ -f "../.env" ]; then
set -a
source ../.env
set +a
else
echo -e "${RED}错误: .env 文件不存在${NC}"
echo "请先复制 .env.example 为 .env 并配置数据库连接"
exit 1
fi
# 检查数据库连接字符串
if [ -z "$DATABASE_URL" ]; then
echo -e "${RED}错误: DATABASE_URL 未设置${NC}"
exit 1
fi
# 从DATABASE_URL解析连接信息
parse_db_url() {
local url="$1"
# 格式: postgresql://username:password@host:port/database
local pattern="postgresql://([^:]+):([^@]+)@([^:]+):([^/]+)/(.+)"
if [[ $url =~ $pattern ]]; then
DB_USER="${BASH_REMATCH[1]}"
DB_PASSWORD="${BASH_REMATCH[2]}"
DB_HOST="${BASH_REMATCH[3]}"
DB_PORT="${BASH_REMATCH[4]}"
DB_NAME="${BASH_REMATCH[5]}"
else
echo -e "${RED}错误: 无法解析DATABASE_URL${NC}"
exit 1
fi
}
parse_db_url "$DATABASE_URL"
# 函数：检查PostgreSQL连接
check_postgres_connection() {
echo -e "${BLUE}检查PostgreSQL连接...${NC}"
if PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d postgres -c "SELECT 1;" > /dev/null 2>&1; then
echo -e "${GREEN}✓ PostgreSQL连接成功${NC}"
return 0
else
echo -e "${RED}✗ PostgreSQL连接失败${NC}"
return 1
fi
}
# 函数：检查数据库是否存在
check_database_exists() {
echo -e "${BLUE}检查数据库 '$DB_NAME' 是否存在...${NC}"
if PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" -c "SELECT 1;" > /dev/null 2>&1; then
echo -e "${GREEN}✓ 数据库已存在${NC}"
return 0
else
echo -e "${YELLOW}数据库不存在${NC}"
return 1
fi
}
# 函数：创建数据库
create_database() {
echo -e "${BLUE}创建数据库 '$DB_NAME'...${NC}"
# 创建数据库
PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d postgres <<EOF
CREATE DATABASE $DB_NAME;
EOF
if [ $? -eq 0 ]; then
echo -e "${GREEN}✓ 数据库创建成功${NC}"
else
echo -e "${RED}✗ 数据库创建失败${NC}"
exit 1
fi
}
# 函数：创建数据库用户（如果不存在）
create_database_user() {
echo -e "${BLUE}检查数据库用户 '$DB_USER'...${NC}"
# 检查用户是否存在
USER_EXISTS=$(PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d postgres -tAc "SELECT 1 FROM pg_roles WHERE rolname='$DB_USER'")
if [ "$USER_EXISTS" = "1" ]; then
echo -e "${GREEN}✓ 用户已存在${NC}"
else
echo -e "${BLUE}创建用户 '$DB_USER'...${NC}"
# 需要以postgres用户创建新用户
# 这里假设有postgres用户的密码或者使用trust认证
echo -e "${YELLOW}注意: 需要以postgres用户权限创建新用户${NC}"
echo "请手动执行以下命令:"
echo " psql -h $DB_HOST -p $DB_PORT -U postgres -d postgres"
echo " CREATE USER $DB_USER WITH PASSWORD '$DB_PASSWORD';"
echo " GRANT ALL PRIVILEGES ON DATABASE $DB_NAME TO $DB_USER;"
read -p "是否已手动创建用户? (y/n): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo -e "${YELLOW}跳过用户创建${NC}"
fi
fi
}
# 函数：授予权限
grant_privileges() {
echo -e "${BLUE}授予用户权限...${NC}"
# 授予数据库权限
PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d postgres <<EOF
GRANT ALL PRIVILEGES ON DATABASE $DB_NAME TO $DB_USER;
EOF
# 授予schema权限
PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME" <<EOF
GRANT ALL ON SCHEMA public TO $DB_USER;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO $DB_USER;
GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO $DB_USER;
GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public TO $DB_USER;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON TABLES TO $DB_USER;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO $DB_USER;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON FUNCTIONS TO $DB_USER;
EOF
echo -e "${GREEN}✓ 权限授予成功${NC}"
}
# 函数：运行数据库迁移
run_migrations() {
echo -e "${BLUE}运行数据库迁移...${NC}"
# 检查后端目录是否存在
if [ ! -d "../../backend" ]; then
echo -e "${YELLOW}警告: 后端目录不存在，跳过迁移${NC}"
return
fi
# 进入后端目录
cd "../../backend"
# 检查Alembic配置
if [ ! -f "alembic.ini" ]; then
echo -e "${YELLOW}警告: alembic.ini 不存在，跳过迁移${NC}"
cd - > /dev/null
return
fi
# 运行迁移
if command -v alembic &> /dev/null; then
# 设置数据库URL环境变量
export DATABASE_URL
# 初始化迁移（如果第一次运行）
if [ ! -d "alembic/versions" ]; then
echo -e "${BLUE}初始化Alembic迁移...${NC}"
alembic init alembic
# 需要手动配置alembic.ini中的sqlalchemy.url
fi
# 创建迁移版本
echo -e "${BLUE}创建迁移版本...${NC}"
alembic revision --autogenerate -m "初始迁移"
# 应用迁移
echo -e "${BLUE}应用迁移...${NC}"
alembic upgrade head
echo -e "${GREEN}✓ 数据库迁移完成${NC}"
else
echo -e "${YELLOW}警告: alembic 命令未找到，跳过迁移${NC}"
echo "请安装: pip install alembic"
fi
# 返回原目录
cd - > /dev/null
}
# 函数：创建基础数据
create_base_data() {
echo -e "${BLUE}创建基础数据...${NC}"
# 检查数据库连接
if ! check_database_exists; then
echo -e "${RED}错误: 数据库不存在，无法创建基础数据${NC}"
return 1
fi
# 创建基础数据SQL
BASE_DATA_SQL=$(cat <<EOF
-- 创建系统配置
INSERT INTO system_config (config_key, config_value, description) VALUES
('check_interval', '1800', '自动检查间隔（秒）'),
('manual_cooldown', '300', '手动刷新冷却时间（秒）'),
('history_retention', '90', '历史记录保留天数'),
('ssh_timeout', '30', 'SSH连接超时时间'),
('ssh_max_connections', '10', 'SSH最大连接数'),
('batch_check_size', '100', '批量检查设备数量')
ON CONFLICT (config_key) DO NOTHING;
-- 创建默认角色
INSERT INTO roles (name, description, is_system) VALUES
('super_admin', '超级管理员', true),
('admin', '管理员', true),
('area_admin', '区域管理员', true),
('school_admin', '学校管理员', true),
('operator', '操作员', true),
('viewer', '查看员', true)
ON CONFLICT (name) DO NOTHING;
-- 创建基础权限
INSERT INTO permissions (name, code, module, description) VALUES
-- 设备模块权限
('设备查看', 'device_view', 'device', '查看设备信息'),
('设备编辑', 'device_edit', 'device', '编辑设备信息'),
('设备删除', 'device_delete', 'device', '删除设备'),
('设备导入', 'device_import', 'device', '导入设备数据'),
('设备检查', 'device_check', 'device', '检查设备状态'),
-- 用户模块权限
('用户查看', 'user_view', 'user', '查看用户信息'),
('用户管理', 'user_manage', 'user', '管理用户'),
('角色管理', 'role_manage', 'user', '管理角色'),
('权限管理', 'permission_manage', 'user', '管理权限'),
-- 系统模块权限
('系统配置', 'system_config', 'system', '系统配置管理'),
('OLT管理', 'olt_manage', 'system', 'OLT设备管理'),
('任务管理', 'task_manage', 'system', '任务配置管理'),
('审核管理', 'audit_manage', 'system', '审核流程管理'),
-- 统计模块权限
('统计查看', 'stats_view', 'stats', '查看统计信息'),
('报表导出', 'report_export', 'stats', '导出报表')
ON CONFLICT (code) DO NOTHING;
-- 为超级管理员角色分配所有权限
INSERT INTO role_permissions (role_id, permission_id)
SELECT r.id, p.id
FROM roles r
CROSS JOIN permissions p
WHERE r.name = 'super_admin'
ON CONFLICT DO NOTHING;
-- 为管理员角色分配大部分权限（除了用户管理相关）
INSERT INTO role_permissions (role_id, permission_id)
SELECT r.id, p.id
FROM roles r
CROSS JOIN permissions p
WHERE r.name = 'admin'
AND p.code NOT IN ('user_manage', 'role_manage', 'permission_manage')
ON CONFLICT DO NOTHING;
-- 为区域管理员分配基础权限
INSERT INTO role_permissions (role_id, permission_id)
SELECT r.id, p.id
FROM roles r
CROSS JOIN permissions p
WHERE r.name = 'area_admin'
AND p.code IN ('device_view', 'device_edit', 'device_check', 'stats_view')
ON CONFLICT DO NOTHING;
-- 为学校管理员分配基础权限
INSERT INTO role_permissions (role_id, permission_id)
SELECT r.id, p.id
FROM roles r
CROSS JOIN permissions p
WHERE r.name = 'school_admin'
AND p.code IN ('device_view', 'device_edit', 'device_check')
ON CONFLICT DO NOTHING;
-- 为操作员分配基础权限
INSERT INTO role_permissions (role_id, permission_id)
SELECT r.id, p.id
FROM roles r
CROSS JOIN permissions p
WHERE r.name = 'operator'
AND p.code IN ('device_view', 'device_edit', 'device_check')
ON CONFLICT DO NOTHING;
-- 为查看员分配只读权限
INSERT INTO role_permissions (role_id, permission_id)
SELECT r.id, p.id
FROM roles r
CROSS JOIN permissions p
WHERE r.name = 'viewer'
AND p.code IN ('device_view', 'stats_view')
ON CONFLICT DO NOTHING;
-- 创建默认系统用户（通过Casdoor同步，这里只是占位）
INSERT INTO users (casdoor_id, username, email, role, is_active) VALUES
('system', '系统用户', 'system@example.com', 'super_admin', true)
ON CONFLICT (casdoor_id) DO NOTHING;
EOF
)
# 执行SQL
echo "$BASE_DATA_SQL" | PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d "$DB_NAME"
if [ $? -eq 0 ]; then
echo -e "${GREEN}✓ 基础数据创建成功${NC}"
else
echo -e "${YELLOW}警告: 基础数据创建可能失败，表可能不存在${NC}"
echo "请先运行数据库迁移"
fi
}
# 函数：显示数据库信息
show_database_info() {
echo -e "\n${GREEN}========================================${NC}"
echo -e "${GREEN} 数据库初始化完成${NC}"
echo -e "${GREEN}========================================${NC}"
echo ""
echo -e "${BLUE}数据库连接信息:${NC}"
echo " 主机: $DB_HOST"
echo " 端口: $DB_PORT"
echo " 数据库: $DB_NAME"
echo " 用户: $DB_USER"
echo ""
echo -e "${BLUE}连接字符串:${NC}"
echo " $DATABASE_URL"
echo ""
echo -e "${BLUE}下一步:${NC}"
echo " 1. 启动后端服务运行数据库迁移"
echo " 2. 配置Casdoor认证"
echo " 3. 导入设备数据"
echo ""
}
# 主程序
main() {
echo -e "${GREEN}========================================${NC}"
echo -e "${GREEN} H3C ONU设备管理系统 - 数据库初始化${NC}"
echo -e "${GREEN}========================================${NC}"
echo ""
# 检查PostgreSQL连接
if ! check_postgres_connection; then
echo -e "${RED}请检查PostgreSQL服务是否运行，以及连接信息是否正确${NC}"
exit 1
fi
# 检查数据库是否存在
if check_database_exists; then
echo -e "${YELLOW}数据库已存在，是否重新初始化?${NC}"
read -p "重新初始化将删除现有数据! (y/n): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
echo -e "${YELLOW}删除数据库 '$DB_NAME'...${NC}"
PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -d postgres -c "DROP DATABASE IF EXISTS $DB_NAME;"
create_database
else
echo -e "${YELLOW}跳过数据库创建${NC}"
fi
else
create_database
fi
# 创建用户和授予权限
create_database_user
grant_privileges
# 运行迁移（如果后端代码已存在）
run_migrations
# 创建基础数据
create_base_data
# 显示完成信息
show_database_info
}
# 执行主程序
main "$@"
deploy/scripts/monitor.sh
Executable
+368
View File
@@ -0,0 +1,368 @@
#!/bin/bash
# H3C ONU设备管理系统 - 系统监控脚本
# 用于监控系统状态、资源使用和性能指标
set -e
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# 默认值
INTERVAL=${1:-5} # 监控间隔（秒）
DURATION=${2:-0} # 监控时长（0表示无限）
COMPOSE_FILE="docker-compose.yml"
# 加载环境变量
if [ -f ".env" ]; then
set -a
source .env
set +a
fi
# 函数：显示帮助信息
show_help() {
echo "H3C ONU设备管理系统 - 系统监控脚本"
echo ""
echo "使用方法: $0 [间隔] [时长]"
echo ""
echo "参数:"
echo " 间隔 监控间隔（秒，默认: 5）"
echo " 时长 监控总时长（秒，0表示无限，默认: 0）"
echo ""
echo "示例:"
echo " $0 # 每5秒监控一次，无限时长"
echo " $0 10 60 # 每10秒监控一次，持续60秒"
echo ""
}
# 函数：检查Docker Compose服务状态
check_services_status() {
echo -e "${BLUE}=== 服务状态 ===${NC}"
if ! command -v docker-compose &> /dev/null; then
echo -e "${RED}错误: docker-compose 未安装${NC}"
return
fi
# 获取服务状态
SERVICES=$(docker-compose -f "$COMPOSE_FILE" ps --services)
for service in $SERVICES; do
STATUS=$(docker-compose -f "$COMPOSE_FILE" ps --filter "name=$service" --format "table {{.Status}}" | tail -1)
CONTAINER_ID=$(docker-compose -f "$COMPOSE_FILE" ps -q "$service")
if [ -n "$CONTAINER_ID" ]; then
# 检查容器是否运行
if docker inspect --format='{{.State.Status}}' "$CONTAINER_ID" | grep -q "running"; then
# 检查健康状态
HEALTH=$(docker inspect --format='{{if .State.Health}}{{.State.Health.Status}}{{else}}no healthcheck{{end}}' "$CONTAINER_ID")
if [ "$HEALTH" = "healthy" ]; then
echo -e "${GREEN}✓ $service: 运行中 (健康)${NC}"
elif [ "$HEALTH" = "no healthcheck" ]; then
echo -e "${GREEN}✓ $service: 运行中${NC}"
else
echo -e "${YELLOW}⚠ $service: 运行中 ($HEALTH)${NC}"
fi
else
echo -e "${RED}✗ $service: 未运行${NC}"
fi
else
echo -e "${RED}✗ $service: 容器不存在${NC}"
fi
done
}
# 函数：检查系统资源使用
check_system_resources() {
echo -e "\n${BLUE}=== 系统资源 ===${NC}"
# CPU使用率
CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
echo -e "CPU使用率: ${CYAN}${CPU_USAGE}%${NC}"
# 内存使用
MEM_TOTAL=$(free -m | awk '/Mem:/ {print $2}')
MEM_USED=$(free -m | awk '/Mem:/ {print $3}')
MEM_PERCENT=$((MEM_USED * 100 / MEM_TOTAL))
if [ $MEM_PERCENT -lt 70 ]; then
echo -e "内存使用: ${GREEN}${MEM_USED}MB/${MEM_TOTAL}MB (${MEM_PERCENT}%)${NC}"
elif [ $MEM_PERCENT -lt 90 ]; then
echo -e "内存使用: ${YELLOW}${MEM_USED}MB/${MEM_TOTAL}MB (${MEM_PERCENT}%)${NC}"
else
echo -e "内存使用: ${RED}${MEM_USED}MB/${MEM_TOTAL}MB (${MEM_PERCENT}%)${NC}"
fi
# 磁盘使用
DISK_USAGE=$(df -h / | awk 'NR==2 {print $5}' | cut -d'%' -f1)
DISK_TOTAL=$(df -h / | awk 'NR==2 {print $2}')
DISK_USED=$(df -h / | awk 'NR==2 {print $3}')
if [ $DISK_USAGE -lt 70 ]; then
echo -e "磁盘使用: ${GREEN}${DISK_USED}/${DISK_TOTAL} (${DISK_USAGE}%)${NC}"
elif [ $DISK_USAGE -lt 90 ]; then
echo -e "磁盘使用: ${YELLOW}${DISK_USED}/${DISK_TOTAL} (${DISK_USAGE}%)${NC}"
else
echo -e "磁盘使用: ${RED}${DISK_USED}/${DISK_TOTAL} (${DISK_USAGE}%)${NC}"
fi
}
# 函数：检查容器资源使用
check_container_resources() {
echo -e "\n${BLUE}=== 容器资源 ===${NC}"
if ! command -v docker &> /dev/null; then
echo -e "${RED}错误: docker 未安装${NC}"
return
fi
# 获取所有运行中的容器
CONTAINERS=$(docker ps --format "{{.Names}}")
for container in $CONTAINERS; do
# 获取容器资源使用
STATS=$(docker stats --no-stream --format "{{.CPUPerc}} {{.MemUsage}} {{.MemPerc}}" "$container" 2>/dev/null || echo "0% 0B/0B 0%")
CPU=$(echo "$STATS" | awk '{print $1}')
MEM_USAGE=$(echo "$STATS" | awk '{print $2}')
MEM_PERCENT=$(echo "$STATS" | awk '{print $3}' | cut -d'%' -f1)
# 检查是否属于本项目
if echo "$container" | grep -q "h3c-onu-ms"; then
COLOR="$CYAN"
else
COLOR="$PURPLE"
fi
echo -e "${COLOR}$container${NC}: CPU=${CPU}, 内存=${MEM_USAGE} (${MEM_PERCENT}%)"
done
}
# 函数：检查应用健康状态
check_application_health() {
echo -e "\n${BLUE}=== 应用健康 ===${NC}"
# 检查后端API
if curl -s -f http://localhost:8000/health > /dev/null 2>&1; then
echo -e "${GREEN}✓ 后端API: 健康${NC}"
# 获取详细健康信息
HEALTH_INFO=$(curl -s http://localhost:8000/health)
echo " 详细信息: $HEALTH_INFO"
else
echo -e "${RED}✗ 后端API: 不可用${NC}"
fi
# 检查前端
if curl -s -f http://localhost:8080 > /dev/null 2>&1; then
echo -e "${GREEN}✓ 前端应用: 可访问${NC}"
else
echo -e "${RED}✗ 前端应用: 不可访问${NC}"
fi
# 检查Redis
REDIS_CONTAINER=$(docker-compose -f "$COMPOSE_FILE" ps -q redis 2>/dev/null || echo "")
if [ -n "$REDIS_CONTAINER" ]; then
if docker exec "$REDIS_CONTAINER" redis-cli ping > /dev/null 2>&1; then
echo -e "${GREEN}✓ Redis: 运行正常${NC}"
else
echo -e "${RED}✗ Redis: 连接失败${NC}"
fi
fi
# 检查数据库连接
if [ -n "$DATABASE_URL" ]; then
# 简单检查数据库连接
if command -v pg_isready &> /dev/null; then
# 从DATABASE_URL解析主机和端口
DB_HOST=$(echo "$DATABASE_URL" | sed -n 's/.*@\([^:]*\).*/\1/p')
DB_PORT=$(echo "$DATABASE_URL" | sed -n 's/.*:\([0-9]*\)\/.*/\1/p')
if pg_isready -h "$DB_HOST" -p "$DB_PORT" > /dev/null 2>&1; then
echo -e "${GREEN}✓ 数据库: 可连接${NC}"
else
echo -e "${RED}✗ 数据库: 连接失败${NC}"
fi
fi
fi
}
# 函数：检查网络连接
check_network() {
echo -e "\n${BLUE}=== 网络连接 ===${NC}"
# 检查互联网连接
if ping -c 1 -W 2 8.8.8.8 > /dev/null 2>&1; then
echo -e "${GREEN}✓ 互联网: 可连接${NC}"
else
echo -e "${YELLOW}⚠ 互联网: 连接失败${NC}"
fi
# 检查DNS
if nslookup google.com > /dev/null 2>&1; then
echo -e "${GREEN}✓ DNS: 工作正常${NC}"
else
echo -e "${YELLOW}⚠ DNS: 解析失败${NC}"
fi
# 检查端口监听
echo -e "端口监听:"
PORTS="80 443 8000 8080 5432 6379"
for port in $PORTS; do
if ss -tuln | grep -q ":$port "; then
SERVICE=$(ss -tuln | grep ":$port " | awk '{print $5}' | cut -d':' -f2)
echo -e " ${GREEN}✓ 端口 $port: 被监听 ($SERVICE)${NC}"
else
echo -e " ${YELLOW}⚠ 端口 $port: 未监听${NC}"
fi
done
}
# 函数：检查日志错误
check_log_errors() {
echo -e "\n${BLUE}=== 日志检查 ===${NC}"
# 检查最近错误日志
LOG_FILES="/var/log/syslog /var/log/messages /var/log/docker/*.log ../../backend/logs/*.log"
for log_file in $LOG_FILES; do
if [ -f "$log_file" ]; then
ERROR_COUNT=$(tail -100 "$log_file" | grep -i "error\|exception\|failed\|critical" | wc -l)
if [ "$ERROR_COUNT" -gt 0 ]; then
echo -e "${YELLOW}⚠ $log_file: 最近有 $ERROR_COUNT 个错误${NC}"
# 显示最近3个错误
tail -100 "$log_file" | grep -i "error\|exception\|failed\|critical" | tail -3 | while read line; do
echo " - $line"
done
fi
fi
done
}
# 函数：检查定时任务
check_scheduled_tasks() {
echo -e "\n${BLUE}=== 定时任务 ===${NC}"
# 检查Celery Beat
BEAT_CONTAINER=$(docker-compose -f "$COMPOSE_FILE" ps -q celery-beat 2>/dev/null || echo "")
if [ -n "$BEAT_CONTAINER" ]; then
if docker logs --tail 10 "$BEAT_CONTAINER" 2>/dev/null | grep -q "beat"; then
echo -e "${GREEN}✓ Celery Beat: 运行中${NC}"
else
echo -e "${YELLOW}⚠ Celery Beat: 可能异常${NC}"
fi
fi
# 检查Celery Worker
WORKER_CONTAINER=$(docker-compose -f "$COMPOSE_FILE" ps -q celery-worker 2>/dev/null || echo "")
if [ -n "$WORKER_CONTAINER" ]; then
ACTIVE_TASKS=$(docker exec "$WORKER_CONTAINER" celery -A app.core.celery_app inspect active 2>/dev/null | grep -c "worker")
if [ "$ACTIVE_TASKS" -gt 0 ]; then
echo -e "${GREEN}✓ Celery Worker: 有 $ACTIVE_TASKS 个活跃任务${NC}"
else
echo -e "${CYAN}ℹ Celery Worker: 无活跃任务${NC}"
fi
fi
}
# 函数：生成监控报告
generate_report() {
local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
echo -e "\n${PURPLE}========================================${NC}"
echo -e "${PURPLE} 监控报告 - $timestamp${NC}"
echo -e "${PURPLE}========================================${NC}"
check_services_status
check_system_resources
check_container_resources
check_application_health
check_network
check_log_errors
check_scheduled_tasks
echo -e "\n${PURPLE}========================================${NC}"
}
# 函数：连续监控
continuous_monitoring() {
local start_time=$(date +%s)
local iteration=1
echo -e "${GREEN}开始监控，间隔: ${INTERVAL}秒${NC}"
if [ "$DURATION" -gt 0 ]; then
echo -e "监控时长: ${DURATION}秒${NC}"
else
echo -e "监控时长: 无限${NC}"
fi
echo "按 Ctrl+C 停止监控"
echo ""
while true; do
# 检查是否达到监控时长
if [ "$DURATION" -gt 0 ]; then
local current_time=$(date +%s)
local elapsed=$((current_time - start_time))
if [ $elapsed -ge $DURATION ]; then
echo -e "\n${GREEN}监控时长达到，停止监控${NC}"
break
fi
fi
# 清屏并显示报告
clear
echo -e "${BLUE}监控迭代 #$iteration - $(date "+%H:%M:%S")${NC}"
generate_report
# 等待间隔
sleep "$INTERVAL"
iteration=$((iteration + 1))
done
}
# 函数：单次监控
single_monitoring() {
generate_report
}
# 主程序
main() {
# 显示标题
echo -e "${GREEN}========================================${NC}"
echo -e "${GREEN} H3C ONU设备管理系统 - 系统监控${NC}"
echo -e "${GREEN}========================================${NC}"
echo ""
# 检查参数
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
show_help
exit 0
fi
# 检查Docker Compose文件
if [ ! -f "$COMPOSE_FILE" ]; then
echo -e "${YELLOW}警告: $COMPOSE_FILE 不存在，使用默认配置${NC}"
fi
# 选择监控模式
if [ "$DURATION" -eq 0 ] && [ "$INTERVAL" -eq 5 ]; then
# 默认单次监控
single_monitoring
else
# 连续监控
continuous_monitoring
fi
}
# 执行主程序
main "$@"