test

build-with-maven-proxy.sh

@@ -1,110 +0,0 @@
-#!/bin/bash
-
-# 使用Maven代理的构建脚本
-set -e
-
-# 颜色定义
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 项目信息
-PROJECT_NAME="digital-archive"
-VERSION="latest"
-DOCKERFILE="Dockerfile"
-
-# 处理参数
-USE_OPTIMIZED=false
-USE_ROBUST=false
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -o|--optimized)
-            USE_OPTIMIZED=true
-            DOCKERFILE="Dockerfile.optimized"
-            shift
-            ;;
-        -r|--robust)
-            USE_ROBUST=true
-            DOCKERFILE="Dockerfile.robust"
-            shift
-            ;;
-        -h|--help)
-            echo "用法: $0 [选项]"
-            echo "选项:"
-            echo "  -o, --optimized  使用优化的Dockerfile"
-            echo "  -r, --robust     使用容错的Dockerfile"
-            echo "  -h, --help      显示帮助信息"
-            exit 0
-            ;;
-        *)
-            shift
-            ;;
-    esac
-done
-
-echo -e "${GREEN}=== 使用Maven代理构建数字档案系统 ===${NC}"
-echo -e "${YELLOW}Dockerfile: ${DOCKERFILE}${NC}"
-echo -e "${YELLOW}优化版本: ${USE_OPTIMIZED}${NC}"
-echo -e "${YELLOW}容错版本: ${USE_ROBUST}${NC}"
-
-# 检查Docker是否安装
-if ! command -v docker &> /dev/null; then
-    echo -e "${RED}错误: Docker未安装${NC}"
-    exit 1
-fi
-
-# 检查settings.xml是否存在
-if [ ! -f "settings.xml" ]; then
-    echo -e "${RED}错误: settings.xml文件不存在${NC}"
-    exit 1
-fi
-
-echo -e "${YELLOW}Maven配置文件:${NC}"
-echo "  - 使用国内镜像加速"
-echo "  - 阿里云Maven镜像"
-echo "  - 华为云Maven镜像"
-echo "  - 腾讯云Maven镜像"
-echo "  - 网易云Maven镜像"
-
-echo -e "${YELLOW}Alpine包管理器配置:${NC}"
-echo "  - 使用阿里云Alpine镜像源"
-if [ "$USE_ROBUST" = true ]; then
-    echo "  - 使用清华大学镜像源作为备份"
-    echo "  - 多镜像源容错机制"
-fi
-
-# 构建Docker镜像
-echo -e "${YELLOW}开始构建Docker镜像...${NC}"
-docker build -f ${DOCKERFILE} -t ${PROJECT_NAME}:${VERSION} .
-
-if [ $? -eq 0 ]; then
-    echo -e "${GREEN}Docker镜像构建成功: ${PROJECT_NAME}:${VERSION}${NC}"
-else
-    echo -e "${RED}Docker镜像构建失败${NC}"
-    exit 1
-fi
-
-# 显示镜像信息
-echo -e "${YELLOW}镜像信息：${NC}"
-docker images | grep ${PROJECT_NAME}
-
-# 显示镜像大小
-echo -e "${YELLOW}镜像大小：${NC}"
-docker images ${PROJECT_NAME}:${VERSION} --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"
-
-echo -e "${GREEN}构建完成！${NC}"
-echo -e "${YELLOW}使用以下命令测试镜像：${NC}"
-echo "docker run --rm -p 9081:9081 ${PROJECT_NAME}:${VERSION}"
-
-# 可选：推送到镜像仓库
-read -p "是否推送到镜像仓库? (y/N): " -n 1 -r
-echo
-if [[ $REPLY =~ ^[Yy]$ ]]; then
-    read -p "请输入镜像仓库地址: " REGISTRY
-    if [ ! -z "$REGISTRY" ]; then
-        docker tag ${PROJECT_NAME}:${VERSION} ${REGISTRY}/${PROJECT_NAME}:${VERSION}
-        docker push ${REGISTRY}/${PROJECT_NAME}:${VERSION}
-        echo -e "${GREEN}镜像已推送到: ${REGISTRY}/${PROJECT_NAME}:${VERSION}${NC}"
-    fi
-fi

build.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-
-# 数字档案系统构建脚本
-set -e
-
-# 颜色定义
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 项目信息
-PROJECT_NAME="digital-archive"
-JAR_NAME="point-strategy"
-VERSION="latest"
-
-echo -e "${GREEN}开始构建数字档案系统...${NC}"
-
-# 检查Docker Compose是否安装
-if ! docker compose version &> /dev/null && ! command -v docker-compose &> /dev/null; then
-    echo -e "${RED}错误: Docker Compose未安装${NC}"
-    exit 1
-fi
-
-# 检测Docker Compose命令类型
-if docker compose version &> /dev/null; then
-    COMPOSE_CMD="docker compose"
-else
-    COMPOSE_CMD="docker-compose"
-fi
-echo -e "${YELLOW}使用命令: ${COMPOSE_CMD}${NC}"
-
-# 构建Docker镜像
-echo -e "${YELLOW}构建Docker镜像...${NC}"
-docker build -t ${PROJECT_NAME}:${VERSION} .
-
-if [ $? -eq 0 ]; then
-    echo -e "${GREEN}Docker镜像构建成功: ${PROJECT_NAME}:${VERSION}${NC}"
-else
-    echo -e "${RED}Docker镜像构建失败${NC}"
-    exit 1
-fi
-
-# 可选：运行测试
-if [ "$1" = "--test" ]; then
-    echo -e "${YELLOW}运行测试...${NC}"
-    ${COMPOSE_CMD} -f docker-compose.test.yml up --abort-on-container-exit --exit-code-from test
-fi
-
-# 可选：推送到镜像仓库
-if [ "$1" = "--push" ]; then
-    echo -e "${YELLOW}推送到镜像仓库...${NC}"
-    docker tag ${PROJECT_NAME}:${VERSION} your-registry.com/${PROJECT_NAME}:${VERSION}
-    docker push your-registry.com/${PROJECT_NAME}:${VERSION}
-fi
-
-echo -e "${GREEN}构建完成！${NC}"
-echo -e "${YELLOW}使用 ./deploy.sh <部署目录> 来部署服务${NC}"
-
-# 显示镜像信息
-echo -e "${YELLOW}镜像信息：${NC}"
-docker images | grep ${PROJECT_NAME}

check-docker-compose.sh

@@ -1,73 +0,0 @@
-#!/bin/bash
-
-# Docker Compose版本检测脚本
-set -e
-
-# 颜色定义
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-echo -e "${GREEN}检测Docker Compose环境...${NC}"
-
-# 检查Docker是否安装
-if ! command -v docker &> /dev/null; then
-    echo -e "${RED}错误: Docker未安装${NC}"
-    exit 1
-fi
-
-echo -e "${GREEN}Docker版本: $(docker --version)${NC}"
-
-# 检测Docker Compose类型
-COMPOSE_CMD=""
-COMPOSE_TYPE=""
-
-if docker compose version &> /dev/null; then
-    COMPOSE_CMD="docker compose"
-    COMPOSE_TYPE="插件"
-    echo -e "${GREEN}检测到Docker Compose插件${NC}"
-    echo -e "${YELLOW}版本: $(docker compose version)${NC}"
-elif command -v docker-compose &> /dev/null; then
-    COMPOSE_CMD="docker-compose"
-    COMPOSE_TYPE="独立应用"
-    echo -e "${GREEN}检测到Docker Compose独立应用${NC}"
-    echo -e "${YELLOW}版本: $(docker-compose --version)${NC}"
-else
-    echo -e "${RED}错误: Docker Compose未安装${NC}"
-    echo -e "${YELLOW}请安装Docker Compose插件或独立应用${NC}"
-    exit 1
-fi
-
-# 测试命令是否可用
-echo -e "${YELLOW}测试Docker Compose命令...${NC}"
-if ${COMPOSE_CMD} version &> /dev/null; then
-    echo -e "${GREEN}Docker Compose命令可用: ${COMPOSE_CMD}${NC}"
-else
-    echo -e "${RED}Docker Compose命令不可用${NC}"
-    exit 1
-fi
-
-# 输出配置信息
-echo -e "${GREEN}=== Docker Compose配置信息 ===${NC}"
-echo -e "${YELLOW}类型: ${COMPOSE_TYPE}${NC}"
-echo -e "${YELLOW}命令: ${COMPOSE_CMD}${NC}"
-
-# 生成环境变量文件
-cat > .compose-env << EOF
-# Docker Compose环境配置
-COMPOSE_CMD="${COMPOSE_CMD}"
-COMPOSE_TYPE="${COMPOSE_TYPE}"
-EOF
-
-echo -e "${GREEN}已生成 .compose-env 文件${NC}"
-echo -e "${YELLOW}可以在脚本中使用: source .compose-env${NC}"
-
-# 显示使用示例
-echo -e "${GREEN}=== 使用示例 ===${NC}"
-echo -e "${YELLOW}启动服务: ${COMPOSE_CMD} up -d${NC}"
-echo -e "${YELLOW}停止服务: ${COMPOSE_CMD} down${NC}"
-echo -e "${YELLOW}查看状态: ${COMPOSE_CMD} ps${NC}"
-echo -e "${YELLOW}查看日志: ${COMPOSE_CMD} logs -f${NC}"
-
-echo -e "${GREEN}检测完成！${NC}"

check-network.sh

@@ -1,112 +0,0 @@
-#!/bin/bash
-
-# Docker网络检查脚本
-set -e
-
-# 颜色定义
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-NETWORK_NAME="proxy"
-
-echo -e "${GREEN}检查Docker网络环境...${NC}"
-
-# 检查Docker是否安装
-if ! command -v docker &> /dev/null; then
-    echo -e "${RED}错误: Docker未安装${NC}"
-    exit 1
-fi
-
-# 检查proxy网络是否存在
-if docker network ls | grep -q ${NETWORK_NAME}; then
-    echo -e "${GREEN}网络 ${NETWORK_NAME} 已存在${NC}"
-    
-    # 显示网络详情
-    echo -e "${YELLOW}网络详情:${NC}"
-    docker network inspect ${NETWORK_NAME} --format 'table {{.Name}}\t{{.Driver}}\t{{.Scope}}'
-    
-    # 显示连接的容器
-    echo -e "${YELLOW}连接到 ${NETWORK_NAME} 网络的容器:${NC}"
-    docker network inspect ${NETWORK_NAME} --format '{{range .Containers}}{{.Name}} {{end}}' | tr ' ' '\n' | grep -v '^$' | while read container; do
-        if [ ! -z "$container" ]; then
-            echo -e "${GREEN}  - ${container}${NC}"
-        fi
-    done
-    
-else
-    echo -e "${RED}网络 ${NETWORK_NAME} 不存在${NC}"
-    echo -e "${YELLOW}请先创建网络: docker network create ${NETWORK_NAME}${NC}"
-    exit 1
-fi
-
-# 检查MySQL容器是否在proxy网络中
-echo -e "${YELLOW}检查MySQL容器...${NC}"
-MYSQL_CONTAINERS=$(docker network inspect ${NETWORK_NAME} --format '{{range .Containers}}{{.Name}} {{end}}' | tr ' ' '\n' | grep -i mysql || true)
-
-if [ ! -z "$MYSQL_CONTAINERS" ]; then
-    echo -e "${GREEN}找到MySQL容器:${NC}"
-    echo "$MYSQL_CONTAINERS" | while read container; do
-        if [ ! -z "$container" ]; then
-            echo -e "${GREEN}  - ${container}${NC}"
-        fi
-    done
-else
-    echo -e "${RED}未找到MySQL容器${NC}"
-    echo -e "${YELLOW}请确保MySQL容器已连接到 ${NETWORK_NAME} 网络${NC}"
-fi
-
-# 检查Redis容器是否在proxy网络中
-echo -e "${YELLOW}检查Redis容器...${NC}"
-REDIS_CONTAINERS=$(docker network inspect ${NETWORK_NAME} --format '{{range .Containers}}{{.Name}} {{end}}' | tr ' ' '\n' | grep -i redis || true)
-
-if [ ! -z "$REDIS_CONTAINERS" ]; then
-    echo -e "${GREEN}找到Redis容器:${NC}"
-    echo "$REDIS_CONTAINERS" | while read container; do
-        if [ ! -z "$container" ]; then
-            echo -e "${GREEN}  - ${container}${NC}"
-        fi
-    done
-else
-    echo -e "${RED}未找到Redis容器${NC}"
-    echo -e "${YELLOW}请确保Redis容器已连接到 ${NETWORK_NAME} 网络${NC}"
-fi
-
-# 检查Elasticsearch容器是否在proxy网络中
-echo -e "${YELLOW}检查Elasticsearch容器...${NC}"
-ES_CONTAINERS=$(docker network inspect ${NETWORK_NAME} --format '{{range .Containers}}{{.Name}} {{end}}' | tr ' ' '\n' | grep -i elasticsearch || true)
-
-if [ ! -z "$ES_CONTAINERS" ]; then
-    echo -e "${GREEN}找到Elasticsearch容器:${NC}"
-    echo "$ES_CONTAINERS" | while read container; do
-        if [ ! -z "$container" ]; then
-            echo -e "${GREEN}  - ${container}${NC}"
-        fi
-    done
-else
-    echo -e "${RED}未找到Elasticsearch容器${NC}"
-    echo -e "${YELLOW}请确保Elasticsearch容器已连接到 ${NETWORK_NAME} 网络${NC}"
-fi
-
-# 测试网络连通性
-echo -e "${YELLOW}测试网络连通性...${NC}"
-if docker run --rm --network ${NETWORK_NAME} alpine ping -c 1 mysql &> /dev/null; then
-    echo -e "${GREEN}可以ping通mysql容器${NC}"
-else
-    echo -e "${RED}无法ping通mysql容器${NC}"
-fi
-
-if docker run --rm --network ${NETWORK_NAME} alpine ping -c 1 redis &> /dev/null; then
-    echo -e "${GREEN}可以ping通redis容器${NC}"
-else
-    echo -e "${RED}无法ping通redis容器${NC}"
-fi
-
-if docker run --rm --network ${NETWORK_NAME} alpine ping -c 1 elasticsearch &> /dev/null; then
-    echo -e "${GREEN}可以ping通elasticsearch容器${NC}"
-else
-    echo -e "${RED}无法ping通elasticsearch容器${NC}"
-fi
-
-echo -e "${GREEN}网络检查完成！${NC}"

deploy-all.sh

@@ -1,225 +0,0 @@
-#!/bin/bash
-
-# 数字档案系统一键部署脚本
-set -e
-
-# 颜色定义
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# 默认配置
-DEFAULT_DEPLOY_DIR="/root/server/archive"
-PROJECT_NAME="digital-archive"
-VERSION="latest"
-
-# 处理参数
-DEPLOY_DIR=$DEFAULT_DEPLOY_DIR
-SKIP_CHECKS=false
-
-# 显示帮助信息
-show_help() {
-    echo -e "${GREEN}数字档案系统一键部署脚本${NC}"
-    echo ""
-    echo -e "${YELLOW}用法: $0 [选项] [部署目录]${NC}"
-    echo ""
-    echo -e "${BLUE}选项:${NC}"
-    echo "  -h, --help      显示帮助信息"
-    echo "  -s, --skip      跳过环境检查"
-    echo "  -c, --check     只执行环境检查"
-    echo "  -b, --build     只构建镜像"
-    echo ""
-    echo -e "${BLUE}参数:${NC}"
-    echo "  部署目录        目标部署目录 (默认: ${DEFAULT_DEPLOY_DIR})"
-    echo ""
-    echo -e "${YELLOW}示例:${NC}"
-    echo "  $0                           # 使用默认目录部署"
-    echo "  $0 /opt/digital-archive      # 部署到指定目录"
-    echo "  $0 -s /opt/archive           # 跳过检查部署到指定目录"
-    echo "  $0 -c                        # 只执行环境检查"
-    echo "  $0 -b                        # 只构建镜像"
-}
-
-# 解析命令行参数
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -h|--help)
-            show_help
-            exit 0
-            ;;
-        -s|--skip)
-            SKIP_CHECKS=true
-            shift
-            ;;
-        -c|--check)
-            CHECK_ONLY=true
-            shift
-            ;;
-        -b|--build)
-            BUILD_ONLY=true
-            shift
-            ;;
-        -*)
-            echo -e "${RED}未知选项: $1${NC}"
-            show_help
-            exit 1
-            ;;
-        *)
-            DEPLOY_DIR=$1
-            shift
-            ;;
-    esac
-done
-
-# 显示配置信息
-echo -e "${GREEN}=== 数字档案系统一键部署 ===${NC}"
-echo -e "${YELLOW}部署目录: ${DEPLOY_DIR}${NC}"
-echo -e "${YELLOW}跳过检查: ${SKIP_CHECKS}${NC}"
-if [ "$CHECK_ONLY" = true ]; then
-    echo -e "${YELLOW}模式: 仅检查环境${NC}"
-elif [ "$BUILD_ONLY" = true ]; then
-    echo -e "${YELLOW}模式: 仅构建镜像${NC}"
-else
-    echo -e "${YELLOW}模式: 完整部署${NC}"
-fi
-echo ""
-
-# 检查脚本文件是否存在
-check_scripts() {
-    local scripts=("build.sh" "check-network.sh" "pre-deploy-check.sh" "deploy.sh")
-    for script in "${scripts[@]}"; do
-        if [ ! -f "$script" ]; then
-            echo -e "${RED}错误: 脚本文件 $script 不存在${NC}"
-            exit 1
-        fi
-        if [ ! -x "$script" ]; then
-            echo -e "${YELLOW}设置脚本执行权限: $script${NC}"
-            chmod +x "$script"
-        fi
-    done
-}
-
-# 执行环境检查
-run_checks() {
-    echo -e "${BLUE}=== 执行环境检查 ===${NC}"
-    
-    # 检查网络
-    echo -e "${YELLOW}1. 检查Docker网络...${NC}"
-    if [ -f "./check-network.sh" ]; then
-        ./check-network.sh
-    else
-        echo -e "${RED}check-network.sh 脚本不存在${NC}"
-        return 1
-    fi
-    
-    # 部署前检查
-    echo -e "${YELLOW}2. 执行部署前检查...${NC}"
-    if [ -f "./pre-deploy-check.sh" ]; then
-        ./pre-deploy-check.sh "$DEPLOY_DIR"
-    else
-        echo -e "${RED}pre-deploy-check.sh 脚本不存在${NC}"
-        return 1
-    fi
-    
-    echo -e "${GREEN}环境检查完成！${NC}"
-}
-
-# 构建镜像
-build_image() {
-    echo -e "${BLUE}=== 构建应用镜像 ===${NC}"
-    
-    if [ -f "./build.sh" ]; then
-        ./build.sh
-    else
-        echo -e "${RED}build.sh 脚本不存在${NC}"
-        return 1
-    fi
-    
-    echo -e "${GREEN}镜像构建完成！${NC}"
-}
-
-# 部署应用
-deploy_app() {
-    echo -e "${BLUE}=== 部署应用 ===${NC}"
-    
-    if [ -f "./deploy.sh" ]; then
-        ./deploy.sh "$DEPLOY_DIR"
-    else
-        echo -e "${RED}deploy.sh 脚本不存在${NC}"
-        return 1
-    fi
-    
-    echo -e "${GREEN}应用部署完成！${NC}"
-}
-
-# 启动服务
-start_services() {
-    echo -e "${BLUE}=== 启动服务 ===${NC}"
-    
-    cd "$DEPLOY_DIR"
-    
-    echo -e "${YELLOW}启动数字档案系统...${NC}"
-    ./start.sh
-    
-    echo -e "${GREEN}服务启动完成！${NC}"
-    echo -e "${YELLOW}访问地址: http://localhost:9081/point-strategy${NC}"
-}
-
-# 显示部署后信息
-show_post_info() {
-    echo -e "${GREEN}=== 部署完成 ===${NC}"
-    echo -e "${YELLOW}部署目录: ${DEPLOY_DIR}${NC}"
-    echo -e "${YELLOW}服务管理:${NC}"
-    echo "  启动服务: cd ${DEPLOY_DIR} && ./start.sh"
-    echo "  停止服务: cd ${DEPLOY_DIR} && ./stop.sh"
-    echo "  更新服务: cd ${DEPLOY_DIR} && ./update.sh"
-    echo "  查看状态: cd ${DEPLOY_DIR} && docker-compose ps"
-    echo "  查看日志: cd ${DEPLOY_DIR} && docker-compose logs -f app"
-    echo ""
-    echo -e "${YELLOW}访问地址: http://localhost:9081/point-strategy${NC}"
-}
-
-# 主执行流程
-main() {
-    # 检查脚本文件
-    check_scripts
-    
-    # 根据模式执行不同操作
-    if [ "$CHECK_ONLY" = true ]; then
-        run_checks
-        exit 0
-    fi
-    
-    if [ "$BUILD_ONLY" = true ]; then
-        build_image
-        exit 0
-    fi
-    
-    # 完整部署流程
-    if [ "$SKIP_CHECKS" = false ]; then
-        echo -e "${YELLOW}提示: 使用 -s 参数可跳过环境检查${NC}"
-        run_checks
-    else
-        echo -e "${YELLOW}跳过环境检查${NC}"
-    fi
-    
-    build_image
-    deploy_app
-    
-    # 询问是否立即启动
-    echo ""
-    read -p "是否立即启动服务? (Y/n): " -n 1 -r
-    echo
-    if [[ $REPLY =~ ^[Nn]$ ]]; then
-        echo -e "${YELLOW}服务未启动，手动启动命令: cd ${DEPLOY_DIR} && ./start.sh${NC}"
-    else
-        start_services
-    fi
-    
-    show_post_info
-}
-
-# 执行主函数
-main

deploy.sh

@@ -1,273 +0,0 @@
-#!/bin/bash
-
-# 数字档案系统部署脚本
-set -e
-
-# 颜色定义
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 项目信息
-PROJECT_NAME="digital-archive"
-VERSION="latest"
-
-# 检查参数
-if [ $# -eq 0 ]; then
-    echo -e "${RED}用法: $0 <部署目录>${NC}"
-    echo -e "${YELLOW}示例: $0 /opt/digital-archive${NC}"
-    exit 1
-fi
-
-DEPLOY_DIR=$1
-
-# 检查Docker是否安装
-if ! command -v docker &> /dev/null; then
-    echo -e "${RED}错误: Docker未安装${NC}"
-    exit 1
-fi
-
-# 检查Docker Compose是否安装
-if ! docker compose version &> /dev/null && ! command -v docker-compose &> /dev/null; then
-    echo -e "${RED}错误: Docker Compose未安装${NC}"
-    exit 1
-fi
-
-# 检测Docker Compose命令类型
-if docker compose version &> /dev/null; then
-    COMPOSE_CMD="docker compose"
-else
-    COMPOSE_CMD="docker-compose"
-fi
-echo -e "${YELLOW}使用命令: ${COMPOSE_CMD}${NC}"
-
-echo -e "${GREEN}开始部署数字档案系统到 ${DEPLOY_DIR}...${NC}"
-echo -e "${YELLOW}提示: 可以先运行 ./pre-deploy-check.sh ${DEPLOY_DIR} 进行部署前检查${NC}"
-
-# 检查镜像是否存在
-if ! docker images | grep -q ${PROJECT_NAME}; then
-    echo -e "${RED}错误: 镜像 ${PROJECT_NAME}:${VERSION} 不存在，请先运行 ./build.sh${NC}"
-    exit 1
-fi
-
-# 创建必要的目录
-echo -e "${YELLOW}创建部署目录...${NC}"
-mkdir -p ${DEPLOY_DIR}/{data/{upload,temp,unzip,images,reports,elasticsearch},logs,nginx}
-
-# 复制配置文件
-echo -e "${YELLOW}复制配置文件...${NC}"
-cp docker-compose.simple.yml ${DEPLOY_DIR}/docker-compose.yml
-
-# 创建环境配置文件
-cat > ${DEPLOY_DIR}/.env << EOF
-# 数字档案系统环境配置
-COMPOSE_PROJECT_NAME=digital-archive
-
-# 服务配置
-SERVER_PORT=9081
-SERVER_CONTEXT_PATH=/point-strategy
-
-# MySQL数据库配置
-DB_HOST=mysql
-DB_PORT=3306
-DB_NAME=enterprise_digital_archives
-DB_USERNAME=root
-DB_PASSWORD=Abc@123456
-DB_DRIVER=com.mysql.jdbc.Driver
-
-# Redis配置
-REDIS_HOST=redis
-REDIS_PORT=6379
-REDIS_PASSWORD=Abc123456
-
-# Elasticsearch配置
-ELASTICSEARCH_URIS=http://elasticsearch:9200
-
-# OCR配置
-TESS_PATH=/usr/bin/tesseract
-
-# 其他配置
-SWAGGER_SHOW=false
-LOG_ROOT_LEVEL=info
-LOG_APP_LEVEL=info
-JAVA_OPTS=-Xmx2g -Xms1g -XX:+UseG1GC -XX:MaxGCPauseMillis=200
-EOF
-
-# 创建nginx配置目录和基础配置
-mkdir -p ${DEPLOY_DIR}/nginx/conf.d
-cat > ${DEPLOY_DIR}/nginx/nginx.conf << 'EOF'
-events {
-    worker_connections 1024;
-}
-
-http {
-    upstream app {
-        server app:9081;
-    }
-
-    server {
-        listen 80;
-        server_name localhost;
-
-        location / {
-            proxy_pass http://app;
-            proxy_set_header Host $host;
-            proxy_set_header X-Real-IP $remote_addr;
-            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-            proxy_set_header X-Forwarded-Proto $scheme;
-        }
-    }
-}
-EOF
-
-# 设置目录权限
-echo -e "${YELLOW}设置目录权限...${NC}"
-chmod -R 755 ${DEPLOY_DIR}/data/
-chmod -R 755 ${DEPLOY_DIR}/logs/
-chmod 644 ${DEPLOY_DIR}/.env
-chmod 644 ${DEPLOY_DIR}/docker-compose.yml
-
-# 创建启动脚本
-cat > ${DEPLOY_DIR}/start.sh << 'EOF'
-#!/bin/bash
-# 启动数字档案系统
-echo "启动数字档案系统..."
-
-# 检测Docker Compose命令类型
-if docker compose version &> /dev/null; then
-    COMPOSE_CMD="docker compose"
-else
-    COMPOSE_CMD="docker-compose"
-fi
-
-${COMPOSE_CMD} up -d
-
-echo "等待服务启动..."
-sleep 30
-
-echo "检查服务状态..."
-${COMPOSE_CMD} ps
-
-echo "查看应用日志..."
-${COMPOSE_CMD} logs -f app
-EOF
-
-# 创建停止脚本
-cat > ${DEPLOY_DIR}/stop.sh << 'EOF'
-#!/bin/bash
-# 停止数字档案系统
-echo "停止数字档案系统..."
-
-# 检测Docker Compose命令类型
-if docker compose version &> /dev/null; then
-    COMPOSE_CMD="docker compose"
-else
-    COMPOSE_CMD="docker-compose"
-fi
-
-${COMPOSE_CMD} down
-
-echo "清理未使用的镜像和容器..."
-docker system prune -f
-EOF
-
-# 创建更新脚本
-cat > ${DEPLOY_DIR}/update.sh << 'EOF'
-#!/bin/bash
-# 更新数字档案系统
-echo "更新数字档案系统..."
-
-# 检测Docker Compose命令类型
-if docker compose version &> /dev/null; then
-    COMPOSE_CMD="docker compose"
-else
-    COMPOSE_CMD="docker-compose"
-fi
-
-echo "停止服务..."
-${COMPOSE_CMD} down
-
-echo "拉取最新镜像..."
-${COMPOSE_CMD} pull
-
-echo "启动服务..."
-${COMPOSE_CMD} up -d
-
-echo "清理旧镜像..."
-docker image prune -f
-EOF
-
-# 设置脚本执行权限
-chmod +x ${DEPLOY_DIR}/start.sh
-chmod +x ${DEPLOY_DIR}/stop.sh
-chmod +x ${DEPLOY_DIR}/update.sh
-
-# 创建生产环境docker-compose文件
-cat > ${DEPLOY_DIR}/docker-compose.prod.yml << 'EOF'
-version: '3.8'
-
-services:
-  app:
-    image: digital-archive:latest
-    container_name: digital-archive-app
-    ports:
-      - "9081:9081"
-    volumes:
-      - ./data/upload:/app/data/upload
-      - ./data/temp:/app/data/temp
-      - ./data/unzip:/app/data/unzip
-      - ./data/images:/app/data/images
-      - ./data/reports:/app/data/reports
-      - ./logs:/app/logs
-    env_file:
-      - .env
-    depends_on:
-      - elasticsearch
-    networks:
-      - proxy
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:9081/point-strategy/actuator/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 60s
-
-  elasticsearch:
-    image: elasticsearch:7.17.0
-    container_name: digital-archive-elasticsearch
-    ports:
-      - "9200:9200"
-      - "9300:9300"
-    environment:
-      - discovery.type=single-node
-      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
-      - xpack.security.enabled=false
-    volumes:
-      - ./data/elasticsearch:/usr/share/elasticsearch/data
-    networks:
-      - proxy
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD-SHELL", "curl -f http://localhost:9200/_cluster/health || exit 1"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 60s
-
-networks:
-  proxy:
-    external: true
-EOF
-
-echo -e "${GREEN}部署完成！${NC}"
-echo -e "${YELLOW}部署目录: ${DEPLOY_DIR}${NC}"
-echo -e "${YELLOW}可用命令:${NC}"
-echo "  启动服务: cd ${DEPLOY_DIR} && ./start.sh"
-echo "  停止服务: cd ${DEPLOY_DIR} && ./stop.sh"
-echo "  更新服务: cd ${DEPLOY_DIR} && ./update.sh"
-echo "  查看状态: cd ${DEPLOY_DIR} && ./start.sh 或 docker-compose ps"
-echo "  查看日志: cd ${DEPLOY_DIR} && docker-compose logs -f app"
-echo ""
-echo -e "${YELLOW}访问地址: http://localhost:9081/point-strategy${NC}"

pre-deploy-check.sh

@@ -1,137 +0,0 @@
-#!/bin/bash
-
-# 部署前检查脚本
-set -e
-
-# 颜色定义
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-echo -e "${GREEN}=== 数字档案系统部署前检查 ===${NC}"
-
-# 检查参数
-if [ $# -eq 0 ]; then
-    echo -e "${RED}用法: $0 <部署目录>${NC}"
-    exit 1
-fi
-
-DEPLOY_DIR=$1
-
-# 1. 检查Docker环境
-echo -e "${YELLOW}1. 检查Docker环境...${NC}"
-if ! command -v docker &> /dev/null; then
-    echo -e "${RED}错误: Docker未安装${NC}"
-    exit 1
-fi
-echo -e "${GREEN}Docker版本: $(docker --version)${NC}"
-
-# 2. 检查Docker Compose
-echo -e "${YELLOW}2. 检查Docker Compose...${NC}"
-if docker compose version &> /dev/null; then
-    COMPOSE_CMD="docker compose"
-elif command -v docker-compose &> /dev/null; then
-    COMPOSE_CMD="docker-compose"
-else
-    echo -e "${RED}错误: Docker Compose未安装${NC}"
-    exit 1
-fi
-echo -e "${GREEN}使用命令: ${COMPOSE_CMD}${NC}"
-
-# 3. 检查proxy网络
-echo -e "${YELLOW}3. 检查proxy网络...${NC}"
-if ! docker network ls | grep -q proxy; then
-    echo -e "${RED}错误: proxy网络不存在${NC}"
-    echo -e "${YELLOW}请创建网络: docker network create proxy${NC}"
-    exit 1
-fi
-echo -e "${GREEN}proxy网络存在${NC}"
-
-# 4. 检查MySQL容器
-echo -e "${YELLOW}4. 检查MySQL容器...${NC}"
-MYSQL_CONTAINER=$(docker network inspect proxy --format '{{range .Containers}}{{.Name}} {{end}}' | tr ' ' '\n' | grep -i mysql | head -1 || true)
-if [ -z "$MYSQL_CONTAINER" ]; then
-    echo -e "${RED}错误: proxy网络中未找到MySQL容器${NC}"
-    echo -e "${YELLOW}请确保MySQL容器已启动并连接到proxy网络${NC}"
-    exit 1
-fi
-echo -e "${GREEN}找到MySQL容器: ${MYSQL_CONTAINER}${NC}"
-
-# 5. 检查Redis容器
-echo -e "${YELLOW}5. 检查Redis容器...${NC}"
-REDIS_CONTAINER=$(docker network inspect proxy --format '{{range .Containers}}{{.Name}} {{end}}' | tr ' ' '\n' | grep -i redis | head -1 || true)
-if [ -z "$REDIS_CONTAINER" ]; then
-    echo -e "${RED}错误: proxy网络中未找到Redis容器${NC}"
-    echo -e "${YELLOW}请确保Redis容器已启动并连接到proxy网络${NC}"
-    exit 1
-fi
-echo -e "${GREEN}找到Redis容器: ${REDIS_CONTAINER}${NC}"
-
-# 6. 检查Elasticsearch容器
-echo -e "${YELLOW}6. 检查Elasticsearch容器...${NC}"
-ES_CONTAINER=$(docker network inspect proxy --format '{{range .Containers}}{{.Name}} {{end}}' | tr ' ' '\n' | grep -i elasticsearch | head -1 || true)
-if [ -z "$ES_CONTAINER" ]; then
-    echo -e "${RED}错误: proxy网络中未找到Elasticsearch容器${NC}"
-    echo -e "${YELLOW}请确保Elasticsearch容器已启动并连接到proxy网络${NC}"
-    exit 1
-fi
-echo -e "${GREEN}找到Elasticsearch容器: ${ES_CONTAINER}${NC}"
-
-# 7. 检查镜像
-echo -e "${YELLOW}7. 检查应用镜像...${NC}"
-if ! docker images | grep -q digital-archive; then
-    echo -e "${RED}错误: digital-archive镜像不存在${NC}"
-    echo -e "${YELLOW}请先运行: ./build.sh${NC}"
-    exit 1
-fi
-echo -e "${GREEN}digital-archive镜像存在${NC}"
-
-# 8. 检查部署目录
-echo -e "${YELLOW}8. 检查部署目录...${NC}"
-if [ -d "$DEPLOY_DIR" ]; then
-    echo -e "${YELLOW}部署目录已存在: ${DEPLOY_DIR}${NC}"
-    read -p "是否继续部署到现有目录? (y/N): " -n 1 -r
-    echo
-    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-        echo -e "${YELLOW}部署已取消${NC}"
-        exit 0
-    fi
-else
-    echo -e "${GREEN}创建新部署目录: ${DEPLOY_DIR}${NC}"
-fi
-
-# 9. 测试网络连通性
-echo -e "${YELLOW}9. 测试网络连通性...${NC}"
-if docker run --rm --network proxy alpine ping -c 1 mysql &> /dev/null; then
-    echo -e "${GREEN}可以连接MySQL容器${NC}"
-else
-    echo -e "${RED}无法连接MySQL容器${NC}"
-    exit 1
-fi
-
-if docker run --rm --network proxy alpine ping -c 1 redis &> /dev/null; then
-    echo -e "${GREEN}可以连接Redis容器${NC}"
-else
-    echo -e "${RED}无法连接Redis容器${NC}"
-    exit 1
-fi
-
-if docker run --rm --network proxy alpine ping -c 1 elasticsearch &> /dev/null; then
-    echo -e "${GREEN}可以连接Elasticsearch容器${NC}"
-else
-    echo -e "${RED}无法连接Elasticsearch容器${NC}"
-    exit 1
-fi
-
-# 10. 显示部署信息
-echo -e "${GREEN}=== 部署信息 ===${NC}"
-echo -e "${YELLOW}部署目录: ${DEPLOY_DIR}${NC}"
-echo -e "${YELLOW}MySQL容器: ${MYSQL_CONTAINER}${NC}"
-echo -e "${YELLOW}Redis容器: ${REDIS_CONTAINER}${NC}"
-echo -e "${YELLOW}Elasticsearch容器: ${ES_CONTAINER}${NC}"
-echo -e "${YELLOW}网络: proxy${NC}"
-echo -e "${YELLOW}Docker Compose: ${COMPOSE_CMD}${NC}"
-
-echo -e "${GREEN}检查完成，可以开始部署！${NC}"
-echo -e "${YELLOW}运行部署命令: ./deploy.sh ${DEPLOY_DIR}${NC}"