IoT物联网平台 - Part 7: WebSocket部署和运行指南

zhilin_tang

1026人浏览 · 2026-01-06 14:18:05

zhilin_tang · 2026-01-06 14:18:05 发布

文件8: CMakeLists.txt - 跨平台构建配置

#=============================================================================
# @file CMakeLists.txt
# @brief IoT平台CMake构建配置文件
# @author IoT Platform Team
# @version 1.0
# @date 2024
# 
# 支持Linux/Windows/macOS多平台构建
# 使用现代CMake实践，支持多种编译选项
#=============================================================================

# CMake最低版本要求（使用现代特性）
cmake_minimum_required(VERSION 3.16)

# 项目基本信息
project(iot_platform
    VERSION 1.0.0          # 项目版本号
    DESCRIPTION "IoT物联网平台服务器"
    LANGUAGES CXX          # 使用C++语言
)

# 设置C++标准为C++17（支持现代特性）
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)  # 禁用编译器扩展，确保可移植性

# 项目配置选项
option(BUILD_SHARED_LIBS "构建共享库" OFF)               # 默认构建静态库
option(WITH_SSL "启用SSL/TLS支持" ON)                    # 默认启用SSL
option(WITH_TESTS "构建测试" OFF)                        # 默认不构建测试
option(WITH_BENCHMARKS "构建性能基准测试" OFF)           # 默认不构建基准测试
option(WITH_DOCS "构建文档" OFF)                         # 默认不构建文档
option(WITH_EXAMPLES "构建示例" OFF)                     # 默认不构建示例
option(ENABLE_LTO "启用链接时优化" OFF)                  # 默认不启用LTO
option(ENABLE_ASAN "启用地址消毒器" OFF)                 # 默认不启用ASAN
option(ENABLE_UBSAN "启用未定义行为消毒器" OFF)          # 默认不启用UBSAN

# 平台检测和设置
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
    set(LINUX TRUE)
    message(STATUS "平台: Linux")
elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
    set(WINDOWS TRUE)
    message(STATUS "平台: Windows")
elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    set(MACOS TRUE)
    message(STATUS "平台: macOS")
else()
    message(WARNING "未知平台: ${CMAKE_SYSTEM_NAME}")
endif()

# 编译器检测和设置
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    set(GCC TRUE)
    message(STATUS "编译器: GNU GCC ${CMAKE_CXX_COMPILER_VERSION}")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    set(CLANG TRUE)
    message(STATUS "编译器: Clang ${CMAKE_CXX_COMPILER_VERSION}")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    set(MSVC TRUE)
    message(STATUS "编译器: Microsoft Visual C++")
else()
    message(WARNING "未知编译器: ${CMAKE_CXX_COMPILER_ID}")
endif()

# 输出构建类型
message(STATUS "构建类型: ${CMAKE_BUILD_TYPE}")
message(STATUS "安装前缀: ${CMAKE_INSTALL_PREFIX}")

# 根据平台设置默认安装路径
if(UNIX AND NOT APPLE)
    # Linux系统
    set(CMAKE_INSTALL_BINDIR "bin")
    set(CMAKE_INSTALL_LIBDIR "lib")
    set(CMAKE_INSTALL_INCLUDEDIR "include")
    set(CMAKE_INSTALL_DATADIR "share/iot_platform")
elseif(APPLE)
    # macOS系统
    set(CMAKE_INSTALL_BINDIR "bin")
    set(CMAKE_INSTALL_LIBDIR "lib")
    set(CMAKE_INSTALL_INCLUDEDIR "include")
    set(CMAKE_INSTALL_DATADIR "share/iot_platform")
elseif(WINDOWS)
    # Windows系统
    set(CMAKE_INSTALL_BINDIR "bin")
    set(CMAKE_INSTALL_LIBDIR "lib")
    set(CMAKE_INSTALL_INCLUDEDIR "include")
    set(CMAKE_INSTALL_DATADIR "share")
endif()

# 编译器优化选项
if(CMAKE_BUILD_TYPE STREQUAL "Release")
    # Release模式优化
    add_compile_options(-O3 -DNDEBUG)
    message(STATUS "优化级别: O3 (Release)")
    
    if(ENABLE_LTO)
        add_compile_options(-flto)
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto")
        message(STATUS "链接时优化: 启用")
    endif()
    
elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
    # Debug模式调试信息
    add_compile_options(-O0 -g3 -DDEBUG)
    message(STATUS "优化级别: O0 (Debug)")
    
    # 调试符号
    if(GCC OR CLANG)
        add_compile_options(-ggdb)
    endif()
    
elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
    # 带调试信息的Release
    add_compile_options(-O2 -g -DNDEBUG)
    message(STATUS "优化级别: O2 with debug info")
    
elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
    # 最小尺寸优化
    add_compile_options(-Os -DNDEBUG)
    message(STATUS "优化级别: Os (最小尺寸)")
endif()

# 编译器特定选项
if(GCC)
    # GCC编译器选项
    add_compile_options(
        -Wall                      # 启用所有警告
        -Wextra                    # 启用额外警告
        -Wpedantic                 # 启用严格ISO C++警告
        -Wshadow                   # 警告变量遮蔽
        -Wformat=2                 # 格式化字符串检查
        -Wconversion               # 类型转换警告
        -Wsign-conversion          # 有符号/无符号转换警告
        -Wnull-dereference         # 空指针解引用警告
        -Wduplicated-cond          # 重复条件警告
        -Wduplicated-branches      # 重复分支警告
        -Wlogical-op               # 逻辑操作警告
        -Wuseless-cast             # 无用类型转换警告
        -Werror                    # 将警告视为错误
    )
    
    # 架构优化
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
        add_compile_options(-march=native)  # 针对本地CPU优化
    endif()
    
elseif(CLANG)
    # Clang编译器选项
    add_compile_options(
        -Wall                      # 启用所有警告
        -Wextra                    # 启用额外警告
        -Wpedantic                 # 启用严格ISO C++警告
        -Wshadow                   # 警告变量遮蔽
        -Wformat=2                 # 格式化字符串检查
        -Wconversion               # 类型转换警告
        -Wnull-dereference         # 空指针解引用警告
        -Werror                    # 将警告视为错误
    )
    
elseif(MSVC)
    # MSVC编译器选项
    add_compile_options(
        /W4        # 警告等级4（最高）
        /WX        # 将警告视为错误
        /EHsc      # C++异常处理
        /utf-8     # 使用UTF-8编码
    )
endif()

# 消毒器选项（用于调试）
if(ENABLE_ASAN)
    if(GCC OR CLANG)
        add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
        message(STATUS "地址消毒器: 启用")
    else()
        message(WARNING "地址消毒器只支持GCC/Clang编译器")
    endif()
endif()

if(ENABLE_UBSAN)
    if(GCC OR CLANG)
        add_compile_options(-fsanitize=undefined)
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined")
        message(STATUS "未定义行为消毒器: 启用")
    else()
        message(WARNING "未定义行为消毒器只支持GCC/Clang编译器")
    endif()
endif()

# 查找依赖库
message(STATUS "查找依赖库...")

# OpenSSL库（用于WebSocket TLS）
if(WITH_SSL)
    find_package(OpenSSL REQUIRED)
    if(OPENSSL_FOUND)
        message(STATUS "OpenSSL 版本: ${OPENSSL_VERSION}")
        include_directories(${OPENSSL_INCLUDE_DIR})
        set(SSL_LIBRARIES ${OPENSSL_LIBRARIES})
    else()
        message(FATAL_ERROR "找不到OpenSSL库，请安装OpenSSL开发包")
    endif()
else()
    message(STATUS "SSL支持: 禁用")
    set(SSL_LIBRARIES "")
endif()

# 线程库（必需）
find_package(Threads REQUIRED)
if(CMAKE_USE_PTHREADS_INIT)
    message(STATUS "线程库: pthread")
else()
    message(STATUS "线程库: 系统线程")
endif()

# 可选：jsoncpp库（用于配置解析）
# find_package(jsoncpp QUIET)
# if(jsoncpp_FOUND)
#     message(STATUS "jsoncpp: 找到")
#     set(HAVE_JSONCPP 1)
# else()
#     message(STATUS "jsoncpp: 未找到，使用内置简单JSON解析")
#     set(HAVE_JSONCPP 0)
# endif()

# 可选：libwebsockets库（备用WebSocket实现）
# find_package(LibWebSockets QUIET)
# if(LibWebSockets_FOUND)
#     message(STATUS "libwebsockets: 找到")
#     set(HAVE_LIBWEBSOCKETS 1)
# else()
#     message(STATUS "libwebsockets: 未找到，使用内置WebSocket实现")
#     set(HAVE_LIBWEBSOCKETS 0)
# endif()

# 包含目录设置
include_directories(
    ${CMAKE_CURRENT_SOURCE_DIR}    # 当前源码目录
    ${CMAKE_CURRENT_BINARY_DIR}    # 当前构建目录
)

# 添加子目录（如果有）
# add_subdirectory(lib)     # 库目录
# add_subdirectory(src)     # 源码目录
# add_subdirectory(test)    # 测试目录

# 源码文件列表
set(IOT_SERVER_SOURCES
    # 核心源文件
    ${CMAKE_CURRENT_SOURCE_DIR}/iot_server.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/websocket_handler.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/device_manager.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/message_router.cpp
    
    # 头文件
    ${CMAKE_CURRENT_SOURCE_DIR}/config.h
)

# 可执行目标
add_executable(iot_server ${IOT_SERVER_SOURCES})

# 设置可执行文件属性
set_target_properties(iot_server PROPERTIES
    OUTPUT_NAME "iot_server"                    # 输出文件名
    VERSION ${PROJECT_VERSION}                  # 版本号
    SOVERSION ${PROJECT_VERSION_MAJOR}          # 主版本号
    # POSITION_INDEPENDENT_CODE ON              # 启用PIC（如果需要）
)

# 链接库
target_link_libraries(iot_server
    ${SSL_LIBRARIES}        # OpenSSL库
    Threads::Threads        # 线程库
    # ${JSONCPP_LIBRARIES}  # jsoncpp库
    # ${LIBWEBSOCKETS_LIBRARIES}  # libwebsockets库
)

# 特定平台链接选项
if(LINUX)
    # Linux特定库
    target_link_libraries(iot_server
        rt          # 实时扩展库
        dl          # 动态加载库
        pthread     # pthread库
    )
    
    # 设置rpath
    set_target_properties(iot_server PROPERTIES
        INSTALL_RPATH "$ORIGIN/../lib"
        BUILD_WITH_INSTALL_RPATH TRUE
    )
    
elseif(WINDOWS)
    # Windows特定库
    target_link_libraries(iot_server
        ws2_32      # Winsock2库
        crypt32     # 加密API库
    )
    
elseif(MACOS)
    # macOS特定设置
    target_link_libraries(iot_server
        "-framework CoreFoundation"
        "-framework Security"
    )
endif()

# 安装目标
install(TARGETS iot_server
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}     # 可执行文件
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}     # 库文件（如果构建共享库）
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}     # 静态库
)

# 安装配置文件
install(FILES
    ${CMAKE_CURRENT_SOURCE_DIR}/config/iot_server.conf
    DESTINATION ${CMAKE_INSTALL_DATADIR}/config
    PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
)

# 安装前端文件
install(DIRECTORY
    ${CMAKE_CURRENT_SOURCE_DIR}/frontend/
    DESTINATION ${CMAKE_INSTALL_DATADIR}/web
    PATTERN "*.html"
    PATTERN "*.js"
    PATTERN "*.css"
    PATTERN "*.ico"
    PATTERN ".gitkeep" EXCLUDE
)

# 安装文档（如果构建）
if(WITH_DOCS)
    install(FILES
        ${CMAKE_CURRENT_BINARY_DIR}/docs/html/*
        DESTINATION ${CMAKE_INSTALL_DATADIR}/docs
    )
endif()

# 安装启动脚本
if(UNIX AND NOT APPLE)
    # Linux启动脚本
    configure_file(
        ${CMAKE_CURRENT_SOURCE_DIR}/scripts/iot_server.service.in
        ${CMAKE_CURRENT_BINARY_DIR}/iot_server.service
        @ONLY
    )
    
    install(FILES
        ${CMAKE_CURRENT_BINARY_DIR}/iot_server.service
        DESTINATION /lib/systemd/system
        PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
    )
    
    # systemd配置文件
    install(FILES
        ${CMAKE_CURRENT_SOURCE_DIR}/scripts/iot_server.sysconfig
        DESTINATION /etc/sysconfig
        RENAME iot_server
        PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
    )
    
elseif(WINDOWS)
    # Windows服务安装脚本
    install(FILES
        ${CMAKE_CURRENT_SOURCE_DIR}/scripts/install_windows_service.bat
        ${CMAKE_CURRENT_SOURCE_DIR}/scripts/uninstall_windows_service.bat
        DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
endif()

# 创建包配置（用于find_package）
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/iot_platformConfigVersion.cmake
    VERSION ${PROJECT_VERSION}
    COMPATIBILITY SameMajorVersion
)

configure_package_config_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/iot_platformConfig.cmake.in
    ${CMAKE_CURRENT_BINARY_DIR}/iot_platformConfig.cmake
    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iot_platform
)

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/iot_platformConfig.cmake
    ${CMAKE_CURRENT_BINARY_DIR}/iot_platformConfigVersion.cmake
    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iot_platform
)

# 导出目标（用于find_package）
install(EXPORT iot_platformTargets
    FILE iot_platformTargets.cmake
    NAMESPACE iot_platform::
    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iot_platform
)

# 测试目标（如果启用）
if(WITH_TESTS)
    enable_testing()
    
    # 添加测试子目录
    add_subdirectory(tests)
    
    # 添加单元测试
    add_executable(test_websocket tests/test_websocket.cpp)
    target_link_libraries(test_websocket iot_server)
    add_test(NAME test_websocket COMMAND test_websocket)
    
    add_executable(test_device_manager tests/test_device_manager.cpp)
    target_link_libraries(test_device_manager iot_server)
    add_test(NAME test_device_manager COMMAND test_device_manager)
    
    # 添加集成测试
    add_executable(test_integration tests/test_integration.cpp)
    target_link_libraries(test_integration iot_server)
    add_test(NAME test_integration COMMAND test_integration)
endif()

# 性能基准测试（如果启用）
if(WITH_BENCHMARKS)
    # 查找Google Benchmark库
    find_package(benchmark QUIET)
    if(benchmark_FOUND)
        add_executable(benchmark_websocket benchmarks/benchmark_websocket.cpp)
        target_link_libraries(benchmark_websocket iot_server benchmark::benchmark)
        
        add_executable(benchmark_message_router benchmarks/benchmark_message_router.cpp)
        target_link_libraries(benchmark_message_router iot_server benchmark::benchmark)
    else()
        message(WARNING "Google Benchmark库未找到，跳过基准测试")
    endif()
endif()

# 文档生成（如果启用）
if(WITH_DOCS)
    # 查找Doxygen
    find_package(Doxygen REQUIRED)
    
    if(DOXYGEN_FOUND)
        # 配置Doxygen
        set(DOXYGEN_PROJECT_NAME "IoT物联网平台")
        set(DOXYGEN_PROJECT_NUMBER "${PROJECT_VERSION}")
        set(DOXYGEN_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/docs")
        set(DOXYGEN_USE_MDFILE_AS_MAINPAGE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
        
        # 添加文档生成目标
        doxygen_add_docs(docs
            ${IOT_SERVER_SOURCES}
            COMMENT "生成API文档"
        )
    else()
        message(WARNING "Doxygen未找到，跳过文档生成")
    endif()
endif()

# 打包目标
include(InstallRequiredSystemLibraries)

set(CPACK_PACKAGE_NAME "iot_platform")
set(CPACK_PACKAGE_VENDOR "IoT Platform Team")
set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "高性能IoT物联网平台服务器")
set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")

# 平台特定打包设置
if(LINUX)
    set(CPACK_GENERATOR "DEB;RPM;TGZ")
    set(CPACK_DEBIAN_PACKAGE_MAINTAINER "IoT Platform Team <iot-platform@example.com>")
    set(CPACK_DEBIAN_PACKAGE_DEPENDS "libssl-dev, libc6")
    set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
    
    set(CPACK_RPM_PACKAGE_RELEASE 1)
    set(CPACK_RPM_PACKAGE_LICENSE "MIT")
    set(CPACK_RPM_PACKAGE_REQUIRES "openssl-devel")
    
elseif(WINDOWS)
    set(CPACK_GENERATOR "NSIS;ZIP")
    set(CPACK_NSIS_MODIFY_PATH ON)
    set(CPACK_NSIS_DISPLAY_NAME "IoT物联网平台")
    set(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\iot_server.exe")
    
elseif(MACOS)
    set(CPACK_GENERATOR "DragNDrop;PackageMaker")
endif()

include(CPack)

# 自定义目标
# 代码格式化目标
find_program(CLANG_FORMAT "clang-format")
if(CLANG_FORMAT)
    add_custom_target(format
        COMMAND ${CLANG_FORMAT}
        -i
        --style=file
        ${IOT_SERVER_SOURCES}
        COMMENT "格式化源代码"
    )
endif()

# 代码分析目标
find_program(CPPCHECK "cppcheck")
if(CPPCHECK)
    add_custom_target(analyze
        COMMAND ${CPPCHECK}
        --enable=all
        --std=c++17
        --verbose
        --error-exitcode=1
        ${CMAKE_CURRENT_SOURCE_DIR}
        COMMENT "静态代码分析"
    )
endif()

# 清理构建目标
add_custom_target(clean-all
    COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target clean
    COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_BINARY_DIR}
    COMMENT "完全清理构建目录"
)

# 显示构建摘要
message(STATUS "")
message(STATUS "===========================================")
message(STATUS "IoT物联网平台构建配置完成")
message(STATUS "===========================================")
message(STATUS "项目版本:      ${PROJECT_VERSION}")
message(STATUS "构建类型:      ${CMAKE_BUILD_TYPE}")
message(STATUS "安装前缀:      ${CMAKE_INSTALL_PREFIX}")
message(STATUS "SSL支持:       ${WITH_SSL}")
message(STATUS "编译器:        ${CMAKE_CXX_COMPILER_ID}")
message(STATUS "C++标准:       ${CMAKE_CXX_STANDARD}")
message(STATUS "平台:          ${CMAKE_SYSTEM_NAME}")
message(STATUS "")
message(STATUS "可用目标:")
message(STATUS "  iot_server   - 构建主服务器")
if(TARGET docs)
    message(STATUS "  docs         - 生成文档")
endif()
if(TARGET tests)
    message(STATUS "  tests        - 构建测试")
endif()
if(TARGET format)
    message(STATUS "  format       - 格式化代码")
endif()
if(TARGET analyze)
    message(STATUS "  analyze      - 代码分析")
endif()
message(STATUS "")
message(STATUS "构建命令:")
message(STATUS "  mkdir build && cd build")
message(STATUS "  cmake .. -DCMAKE_BUILD_TYPE=Release")
message(STATUS "  make -j$(nproc)")
message(STATUS "")
message(STATUS "安装命令:")
message(STATUS "  sudo make install")
message(STATUS "===========================================")

文件9: README.md - 项目说明文档

<!--
 * @file README.md
 * @brief IoT物联网平台项目说明文档
 * @author IoT Platform Team
 * @version 1.0
 * @date 2024
 *
 * 项目概述、构建指南和部署说明
-->

# IoT物联网平台

## 项目概述

### 简介
IoT物联网平台是一个高性能、可扩展的物联网设备管理和数据监控平台。平台支持大规模设备连接、实时数据采集、设备控制、消息路由和Web可视化。

### 主要特性
- 🚀 **高性能**: 基于反应器模式，支持10K+并发连接
- 🔧 **模块化设计**: 使用多种设计模式，易于扩展和维护
- 📊 **实时监控**: WebSocket实时数据推送，图表可视化
- 🔒 **安全可靠**: SSL/TLS加密，认证授权机制
- 🌐 **跨平台**: 支持Linux、Windows、macOS
- 📱 **响应式界面**: 适配桌面和移动设备
- 🔌 **多协议支持**: WebSocket为主，预留其他协议扩展

### 技术栈
- **后端**: C++17, CMake, OpenSSL, pthread
- **前端**: HTML5, CSS3, JavaScript, Chart.js, Bootstrap 5
- **网络**: WebSocket (RFC 6455), TCP/IP
- **构建**: CMake, Make, GCC/Clang/MSVC

## 目录结构

iot_platform/
├── backend/                     # C++后端代码
│   ├── iot_server.cpp          # 主服务器
│   ├── websocket_handler.cpp   # WebSocket处理器
│   ├── device_manager.cpp      # 设备管理器
│   ├── message_router.cpp      # 消息路由器
│   └── config.h                # 配置和协议定义
├── frontend/                   # Web前端代码
│   ├── index.html              # 主页面
│   ├── dashboard.js            # 仪表板控制
│   └── device_monitor.js       # 设备监控
├── scripts/                    # 部署脚本
│   ├── iot_server.service.in   # systemd服务模板
│   ├── install_service.sh      # 服务安装脚本
│   └── config_gen.py           # 配置生成脚本
├── config/                     # 配置文件
│   ├── iot_server.conf         # 服务器配置示例
│   └── nginx.conf              # Nginx代理配置
├── tests/                      # 测试代码
│   ├── test_websocket.cpp      # WebSocket测试
│   └── test_integration.cpp    # 集成测试
├── docs/                       # 文档
│   ├── API.md                  # API文档
│   └── deployment_guide.md     # 部署指南
├── CMakeLists.txt              # CMake构建配置
├── README.md                   # 本文档
└── LICENSE                     # 许可证文件


## 快速开始

### 环境要求

#### 系统要求
- **操作系统**: Linux (Ubuntu 20.04+, CentOS 7+), Windows 10+, macOS 10.15+
- **内存**: 至少 512MB RAM
- **磁盘空间**: 至少 100MB 可用空间

#### 开发工具
- **C++编译器**: GCC 9+ 或 Clang 10+ 或 MSVC 2019+
- **CMake**: 3.16+
- **OpenSSL**: 1.1.1+
- **Git**: 版本控制

#### 前端依赖
- **现代浏览器**: Chrome 90+, Firefox 88+, Edge 90+
- **Node.js**: 14+ (仅用于开发构建)

### 安装依赖

#### Ubuntu/Debian
```bash
# 更新包管理器
sudo apt update

# 安装编译工具
sudo apt install -y build-essential cmake git

# 安装OpenSSL开发包
sudo apt install -y libssl-dev

# 安装其他可选依赖
sudo apt install -y libjsoncpp-dev doxygen graphviz

CentOS/RHEL

# 安装EPEL仓库
sudo yum install -y epel-release

# 安装编译工具
sudo yum install -y gcc-c++ cmake3 make git

# 安装OpenSSL开发包
sudo yum install -y openssl-devel

# 创建cmake符号链接（如果需要）
sudo ln -s /usr/bin/cmake3 /usr/bin/cmake

macOS

# 安装Homebrew（如果未安装）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 安装依赖
brew install cmake openssl

Windows

安装 Visual Studio 2019+（包含C++开发工具）
安装 CMake
安装 OpenSSL
安装 Git for Windows

构建项目

Linux/macOS

# 克隆代码库
git clone https://github.com/your-org/iot_platform.git
cd iot_platform

# 创建构建目录
mkdir build
cd build

# 配置项目（Debug模式）
cmake .. -DCMAKE_BUILD_TYPE=Debug

# 或者配置为Release模式（生产环境）
cmake .. -DCMAKE_BUILD_TYPE=Release

# 编译项目
make -j$(nproc)  # Linux使用所有CPU核心
# 或者 make -j4    # 指定4个并行任务

# 运行单元测试（如果启用）
make test

# 查看构建的可执行文件
ls -lh iot_server

Windows (命令行)

# 使用PowerShell或CMD
git clone https://github.com/your-org/iot_platform.git
cd iot_platform

# 创建构建目录
mkdir build
cd build

# 配置项目
cmake .. -G "Visual Studio 16 2019" -A x64

# 编译项目
cmake --build . --config Release

# 或者使用Visual Studio打开生成的sln文件

Windows (Visual Studio GUI)

打开Visual Studio
选择"克隆存储库"
输入仓库URL: https://github.com/your-org/iot_platform.git
打开CMakeLists.txt文件
Visual Studio会自动配置和构建

配置服务器

生成配置文件

cd build
cp ../config/iot_server.conf.example iot_server.conf

编辑配置文件

# iot_server.conf - IoT服务器配置文件
[server]
# 服务器监听的IP地址
bind_address = 0.0.0.0

# WebSocket服务端口
websocket_port = 8080

# HTTPS服务端口（如果启用SSL）
https_port = 8443

# 最大连接数
max_connections = 10000

# 工作线程数
worker_threads = 4

[database]
# 数据库类型：memory（内存）或 mysql（MySQL数据库）
type = memory

# MySQL连接信息（如果使用MySQL）
mysql_host = localhost
mysql_port = 3306
mysql_user = iot_user
mysql_password = your_password
mysql_database = iot_platform

[security]
# 启用SSL/TLS
enable_ssl = false

# SSL证书文件路径
ssl_cert_file = /path/to/cert.pem

# SSL私钥文件路径
ssl_key_file = /path/to/key.pem

# 客户端认证要求
require_client_auth = false

[logging]
# 日志级别：debug, info, warning, error
log_level = info

# 日志文件路径
log_file = /var/log/iot_server.log

# 日志轮转：最大文件大小（MB）
max_log_size = 100

# 保留的日志文件数量
max_log_files = 10

运行服务器

开发环境运行

# 进入构建目录
cd build

# 直接运行服务器
./iot_server

# 或者指定配置文件
./iot_server --config ../config/iot_server.conf

# 或者指定端口
./iot_server --port 8888

# 查看帮助
./iot_server --help

命令行参数

# 完整参数列表
./iot_server --help

# 输出：
# 用法: iot_server [选项]
# 选项:
#   -c, --config FILE    从FILE加载配置
#   -p, --port PORT      使用PORT进行WebSocket连接
#   -h, --help           显示此帮助信息
#   -v, --version        显示版本信息
#   -d, --daemon         以守护进程模式运行
#   -l, --log FILE       指定日志文件
#   --pid-file FILE      指定PID文件路径

验证运行状态

# 检查进程
ps aux | grep iot_server

# 检查端口监听
netstat -tlnp | grep 8080

# 查看日志
tail -f /var/log/iot_server.log

访问Web界面

打开浏览器，访问 http://localhost:8080
或者访问 http://服务器IP:8080
如果启用SSL，访问 https://服务器IP:8443

部署指南

生产环境部署

1. 安装到系统目录

cd build
sudo make install

# 默认安装路径：
# 可执行文件: /usr/local/bin/iot_server
# 配置文件: /usr/local/share/iot_platform/config/
# Web文件: /usr/local/share/iot_platform/web/

2. 创建系统用户

# 创建专用系统用户
sudo useradd -r -s /bin/false iot_server

# 创建数据目录
sudo mkdir -p /var/lib/iot_platform
sudo mkdir -p /var/log/iot_platform
sudo mkdir -p /etc/iot_platform

# 设置权限
sudo chown -R iot_server:iot_server /var/lib/iot_platform
sudo chown -R iot_server:iot_server /var/log/iot_platform
sudo chown -R iot_server:iot_server /etc/iot_platform

3. 配置systemd服务（Linux）

# 复制systemd服务文件
sudo cp scripts/iot_server.service /etc/systemd/system/

# 编辑服务配置
sudo nano /etc/systemd/system/iot_server.service

# 重新加载systemd
sudo systemctl daemon-reload

# 启动服务
sudo systemctl start iot_server

# 设置开机启动
sudo systemctl enable iot_server

# 查看服务状态
sudo systemctl status iot_server

# 查看服务日志
sudo journalctl -u iot_server -f

4. 配置Nginx反向代理（推荐）

# /etc/nginx/sites-available/iot_platform
server {
    listen 80;
    server_name iot.example.com;
    
    # 重定向到HTTPS
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name iot.example.com;
    
    # SSL证书配置
    ssl_certificate /etc/ssl/certs/iot.example.com.crt;
    ssl_certificate_key /etc/ssl/private/iot.example.com.key;
    
    # SSL优化设置
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    
    # WebSocket代理
    location /ws {
        proxy_pass http://localhost:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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;
        
        # 超时设置
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
    
    # 静态文件服务
    location / {
        proxy_pass http://localhost:8080;
        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;
    }
    
    # 访问日志
    access_log /var/log/nginx/iot_platform.access.log;
    error_log /var/log/nginx/iot_platform.error.log;
}

5. 配置防火墙

# 允许Web端口
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 8080/tcp

# 或者使用firewalld（CentOS/RHEL）
sudo firewall-cmd --permanent --add-port=80/tcp
sudo firewall-cmd --permanent --add-port=443/tcp
sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --reload

Docker部署

1. 构建Docker镜像

# Dockerfile
FROM ubuntu:20.04 AS builder

# 安装构建依赖
RUN apt-get update && apt-get install -y \
    build-essential \
    cmake \
    libssl-dev \
    && rm -rf /var/lib/apt/lists/*

# 复制源代码
COPY . /app
WORKDIR /app

# 构建
RUN mkdir build && cd build \
    && cmake .. -DCMAKE_BUILD_TYPE=Release \
    && make -j$(nproc)

# 运行阶段
FROM ubuntu:20.04

# 安装运行时依赖
RUN apt-get update && apt-get install -y \
    libssl1.1 \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# 创建非root用户
RUN useradd -r -s /bin/false iot_server

# 复制构建产物
COPY --from=builder /app/build/iot_server /usr/local/bin/
COPY --from=builder /app/frontend /usr/local/share/iot_platform/web/
COPY --from=builder /app/config/iot_server.conf.example /etc/iot_platform/iot_server.conf

# 创建数据目录
RUN mkdir -p /var/lib/iot_platform \
    && chown -R iot_server:iot_server /var/lib/iot_platform \
    && chown -R iot_server:iot_server /etc/iot_platform

# 切换用户
USER iot_server

# 暴露端口
EXPOSE 8080

# 运行命令
CMD ["/usr/local/bin/iot_server", "--config", "/etc/iot_platform/iot_server.conf"]

2. 使用docker-compose

# docker-compose.yml
version: '3.8'

services:
  iot_server:
    build: .
    container_name: iot_server
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./config:/etc/iot_platform:ro
      - ./data:/var/lib/iot_platform
      - ./logs:/var/log/iot_platform
    environment:
      - TZ=Asia/Shanghai
      - LOG_LEVEL=info
    networks:
      - iot_network

  nginx:
    image: nginx:alpine
    container_name: iot_nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/ssl:ro
      - ./logs/nginx:/var/log/nginx
    depends_on:
      - iot_server
    networks:
      - iot_network

networks:
  iot_network:
    driver: bridge

3. 运行Docker容器

# 构建和运行
docker-compose up -d

# 查看日志
docker-compose logs -f

# 停止服务
docker-compose down

# 清理所有容器
docker system prune -af

Kubernetes部署

1. 创建Kubernetes部署文件

# kubernetes/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: iot-server
  namespace: iot-platform
spec:
  replicas: 3
  selector:
    matchLabels:
      app: iot-server
  template:
    metadata:
      labels:
        app: iot-server
    spec:
      containers:
      - name: iot-server
        image: iot-platform:latest
        ports:
        - containerPort: 8080
        env:
        - name: LOG_LEVEL
          value: "info"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        volumeMounts:
        - name: config-volume
          mountPath: /etc/iot_platform
        - name: data-volume
          mountPath: /var/lib/iot_platform
      volumes:
      - name: config-volume
        configMap:
          name: iot-server-config
      - name: data-volume
        emptyDir: {}

2. 创建服务

# kubernetes/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: iot-server
  namespace: iot-platform
spec:
  selector:
    app: iot-server
  ports:
  - port: 8080
    targetPort: 8080
  type: LoadBalancer

配置说明

环境变量配置

# 服务器配置
export IOT_WEBSOCKET_PORT=8080
export IOT_WORKER_THREADS=4
export IOT_MAX_CONNECTIONS=10000

# 数据库配置
export IOT_DB_TYPE=memory
export IOT_DB_HOST=localhost
export IOT_DB_PORT=3306

# 日志配置
export IOT_LOG_LEVEL=info
export IOT_LOG_FILE=/var/log/iot_server.log

# 启动服务器（自动读取环境变量）
./iot_server

配置文件格式

支持多种配置文件格式：

INI格式（默认）
JSON格式
YAML格式（需要yaml-cpp库）

示例JSON配置：

{
    "server": {
        "bind_address": "0.0.0.0",
        "websocket_port": 8080,
        "worker_threads": 4
    },
    "database": {
        "type": "memory"
    },
    "logging": {
        "level": "info",
        "file": "/var/log/iot_server.log"
    }
}

性能调优

系统级调优

# 增加文件描述符限制
echo "iot_server soft nofile 65535" >> /etc/security/limits.conf
echo "iot_server hard nofile 65535" >> /etc/security/limits.conf

# 增加epoll最大连接数
echo "fs.epoll.max_user_watches = 524288" >> /etc/sysctl.conf
sysctl -p

# 优化TCP参数
echo "net.core.somaxconn = 65535" >> /etc/sysctl.conf
echo "net.ipv4.tcp_max_syn_backlog = 65535" >> /etc/sysctl.conf
echo "net.ipv4.tcp_tw_reuse = 1" >> /etc/sysctl.conf
sysctl -p

服务器调优参数

[performance]
# 调整工作线程数（建议为CPU核心数）
worker_threads = 8

# 调整epoll事件大小
epoll_max_events = 1024

# 调整缓冲区大小
read_buffer_size = 8192
write_buffer_size = 8192

# 连接超时设置
connection_timeout = 300

# 心跳间隔
heartbeat_interval = 30

# 启用连接复用
enable_keepalive = true
keepalive_time = 600
keepalive_probes = 3
keepalive_interval = 60

内存优化

[memory]
# 对象池大小
connection_pool_size = 1000
message_pool_size = 5000

# 缓存大小
device_cache_size = 10000
message_cache_size = 1000

# 内存分配器（Linux）
use_jemalloc = true

监控和日志

日志配置

[logging]
# 日志级别
level = info

# 日志输出
console_output = true
file_output = true
syslog_output = false

# 日志文件
log_file = /var/log/iot_server.log
max_file_size = 104857600  # 100MB
max_files = 10

# 访问日志
access_log = /var/log/iot_server_access.log
log_format = "%t %a %r %s %b %D"

# 慢请求日志
slow_request_threshold = 5000  # 5秒

监控指标

平台提供以下监控指标：

连接数统计
消息吞吐量
内存使用情况
CPU使用率
请求延迟分布
错误率统计

Prometheus监控

# prometheus配置
scrape_configs:
  - job_name: 'iot_platform'
    static_configs:
      - targets: ['iot-server:9090']
    metrics_path: '/metrics'

健康检查

# HTTP健康检查端点
curl http://localhost:8080/health

# 返回：
# {
#   "status": "healthy",
#   "timestamp": "2024-01-01T00:00:00Z",
#   "uptime": 3600,
#   "connections": 150,
#   "memory_usage": "45.2MB"
# }

# WebSocket连接测试
wscat -c ws://localhost:8080/ws

故障排除

常见问题

1. 编译错误

错误：找不到OpenSSL库
解决：安装libssl-dev包
sudo apt install libssl-dev

2. 运行错误

错误：端口已被占用
解决：更改端口或停止占用进程
./iot_server --port 8888

3. 连接问题

错误：WebSocket连接失败
解决：检查防火墙和网络配置
sudo ufw allow 8080/tcp

4. 性能问题

问题：高并发下连接断开
解决：调整系统限制
ulimit -n 65535

调试模式

# 启用调试日志
./iot_server --log-level debug

# 启用详细日志
export IOT_DEBUG=1
./iot_server

# 使用GDB调试
gdb --args ./iot_server --port 8080

日志分析

# 查看错误日志
grep ERROR /var/log/iot_server.log

# 查看慢请求
grep "slow request" /var/log/iot_server.log

# 实时监控日志
tail -f /var/log/iot_server.log | grep -E "(ERROR|WARNING|slow)"

开发指南

代码结构

src/
├── core/           # 核心模块
│   ├── server.cpp
│   └── config.cpp
├── network/        # 网络模块
│   ├── websocket.cpp
│   └── tcp_server.cpp
├── device/         # 设备管理
│   ├── manager.cpp
│   └── registry.cpp
├── message/        # 消息处理
│   ├── router.cpp
│   └── handler.cpp
├── utils/          # 工具类
│   ├── logger.cpp
│   └── crypto.cpp
└── web/           # Web接口
    ├── api.cpp
    └── static_handler.cpp

添加新功能

创建新的源文件和头文件
在CMakeLists.txt中添加文件
实现业务逻辑
添加单元测试
更新文档

代码规范

使用C++17特性
遵循Google C++风格指南
使用Doxygen注释
编写单元测试
保持向后兼容

测试

# 运行所有测试
cd build && ctest --output-on-failure

# 运行特定测试
./test_websocket
./test_device_manager

# 覆盖率测试
mkdir coverage && cd coverage
cmake .. -DCMAKE_BUILD_TYPE=Debug -DWITH_COVERAGE=ON
make
lcov --capture --directory . --output-file coverage.info
genhtml coverage.info --output-directory out

安全建议

生产环境安全

启用SSL/TLS: 所有通信使用加密
防火墙配置: 只开放必要端口
定期更新: 及时更新系统和依赖
访问控制: 实现身份验证和授权
日志审计: 记录所有重要操作

数据安全

加密存储: 敏感数据加密存储
备份策略: 定期备份配置和数据
密钥管理: 安全存储SSL证书和密钥
输入验证: 验证所有输入数据

许可证

本项目采用MIT许可证。详见LICENSE文件。

贡献指南

Fork本仓库
创建特性分支
提交更改
推送到分支
创建Pull Request

支持

问题跟踪: GitHub Issues
文档: 在线文档
邮件列表: iot-platform@example.com
Slack: #iot-platform

更新日志

v1.0.0 (2024-01-01)

初始版本发布
支持WebSocket设备连接
设备管理和监控
Web仪表板界面
基础消息路由

注意: 本文档会随着项目发展而更新，请定期查看最新版本。


## 文件10: scripts/deploy.sh - 自动化部署脚本

```bash
#!/bin/bash
#=============================================================================
# @file deploy.sh
# @brief IoT平台自动化部署脚本
# @author IoT Platform Team
# @version 1.0
# @date 2024
# 
# 支持一键部署到开发、测试和生产环境
# 包含依赖安装、编译、配置和服务部署
#=============================================================================

# 设置严格模式：遇到错误退出，使用未定义变量报错
set -euo pipefail

# 颜色定义用于输出
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly NC='\033[0m' # No Color

# 日志函数
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 显示使用说明
show_usage() {
    cat << EOF
用法: $0 [选项]

IoT平台部署脚本

选项:
  -h, --help              显示此帮助信息
  -e, --env ENV           部署环境 (dev|test|prod) [默认: dev]
  -c, --clean             清理构建目录
  -i, --install           安装到系统目录
  -s, --start             启动服务
  -r, --restart           重启服务
  -d, --stop              停止服务
  -u, --uninstall         卸载服务
  --no-deps               跳过依赖安装
  --build-only            仅构建不部署
  --with-docker           使用Docker部署
  --with-kubernetes       使用Kubernetes部署

示例:
  $0 -e dev -c            # 清理并部署到开发环境
  $0 -e prod --install    # 部署到生产环境并安装服务
  $0 --with-docker        # 使用Docker部署
EOF
}

# 检查命令是否存在
check_command() {
    if ! command -v "$1" &> /dev/null; then
        log_error "命令 '$1' 未找到，请先安装"
        return 1
    fi
    return 0
}

# 检查操作系统
detect_os() {
    if [[ -f /etc/os-release ]]; then
        # 读取/etc/os-release文件
        . /etc/os-release
        OS_NAME="$ID"
        OS_VERSION="$VERSION_ID"
    elif [[ "$(uname)" == "Darwin" ]]; then
        OS_NAME="macos"
        OS_VERSION="$(sw_vers -productVersion)"
    elif [[ "$(uname)" == "MINGW"* ]] || [[ "$(uname)" == "MSYS"* ]]; then
        OS_NAME="windows"
        OS_VERSION="$(cmd.exe /c ver 2>/dev/null | grep -o '[0-9]\+\.[0-9]\+')"
    else
        OS_NAME="unknown"
        OS_VERSION="unknown"
    fi
    
    log_info "操作系统: $OS_NAME $OS_VERSION"
}

# 安装系统依赖
install_dependencies() {
    local env="$1"
    
    log_info "开始安装系统依赖..."
    
    case "$OS_NAME" in
        ubuntu|debian)
            # Ubuntu/Debian系统
            sudo apt-get update
            
            # 基础编译工具
            sudo apt-get install -y \
                build-essential \
                cmake \
                git \
                pkg-config
                
            # OpenSSL开发库
            sudo apt-get install -y \
                libssl-dev
                
            # 可选：数据库客户端库
            if [[ "$env" == "prod" ]]; then
                sudo apt-get install -y \
                    libmysqlclient-dev \
                    libpq-dev
            fi
            
            # 可选：监控工具
            if [[ "$env" == "prod" ]]; then
                sudo apt-get install -y \
                    htop \
                    nmon \
                    sysstat
            fi
            ;;
            
        centos|rhel|fedora)
            # CentOS/RHEL/Fedora系统
            if [[ "$OS_NAME" == "centos" ]] || [[ "$OS_NAME" == "rhel" ]]; then
                sudo yum install -y epel-release
            fi
            
            # 基础编译工具
            sudo yum install -y \
                gcc-c++ \
                cmake3 \
                make \
                git \
                pkgconfig
                
            # 创建cmake符号链接
            sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
            
            # OpenSSL开发库
            sudo yum install -y \
                openssl-devel
                
            # 可选：数据库客户端库
            if [[ "$env" == "prod" ]]; then
                sudo yum install -y \
                    mysql-devel \
                    postgresql-devel
            fi
            ;;
            
        macos)
            # macOS系统（使用Homebrew）
            if ! check_command brew; then
                log_error "Homebrew未安装，请先安装Homebrew"
                return 1
            fi
            
            brew update
            
            # 基础编译工具
            brew install \
                cmake \
                pkg-config
                
            # OpenSSL
            brew install openssl
            
            # 设置OpenSSL路径
            export LDFLAGS="-L/usr/local/opt/openssl/lib"
            export CPPFLAGS="-I/usr/local/opt/openssl/include"
            ;;
            
        windows)
            # Windows系统（使用Chocolatey或手动安装）
            log_warning "Windows系统请手动安装以下依赖："
            log_warning "1. Visual Studio 2019+ with C++ tools"
            log_warning "2. CMake"
            log_warning "3. OpenSSL"
            log_warning "4. Git for Windows"
            return 0
            ;;
            
        *)
            log_error "不支持的操作系统: $OS_NAME"
            return 1
            ;;
    esac
    
    log_success "系统依赖安装完成"
}

# 清理构建目录
clean_build() {
    log_info "清理构建目录..."
    
    if [[ -d "build" ]]; then
        rm -rf build
        log_success "构建目录已清理"
    else
        log_info "构建目录不存在，跳过清理"
    fi
}

# 配置项目
configure_project() {
    local env="$1"
    local build_type="Debug"
    
    # 根据环境设置构建类型
    case "$env" in
        dev) build_type="Debug" ;;
        test) build_type="RelWithDebInfo" ;;
        prod) build_type="Release" ;;
    esac
    
    log_info "配置项目 (环境: $env, 构建类型: $build_type)..."
    
    # 创建构建目录
    mkdir -p build
    cd build
    
    # CMake配置选项
    local cmake_options="-DCMAKE_BUILD_TYPE=$build_type"
    
    # 生产环境启用优化选项
    if [[ "$env" == "prod" ]]; then
        cmake_options="$cmake_options -DENABLE_LTO=ON"
    fi
    
    # 运行CMake配置
    cmake .. $cmake_options
    
    cd ..
    
    log_success "项目配置完成"
}

# 编译项目
build_project() {
    log_info "开始编译项目..."
    
    cd build
    
    # 获取CPU核心数（用于并行编译）
    local num_cores
    if [[ "$OS_NAME" == "macos" ]]; then
        num_cores=$(sysctl -n hw.ncpu)
    elif [[ "$OS_NAME" == "windows" ]]; then
        num_cores=$NUMBER_OF_PROCESSORS
    else
        num_cores=$(nproc)
    fi
    
    # 构建项目
    log_info "使用 $num_cores 个并行任务编译..."
    make -j"$num_cores"
    
    cd ..
    
    log_success "项目编译完成"
}

# 运行测试
run_tests() {
    local env="$1"
    
    # 开发环境运行测试
    if [[ "$env" == "dev" ]] || [[ "$env" == "test" ]]; then
        log_info "运行单元测试..."
        
        cd build
        
        if ctest --output-on-failure; then
            log_success "所有测试通过"
        else
            log_error "测试失败"
            cd ..
            return 1
        fi
        
        cd ..
    fi
}

# 创建配置文件
create_config() {
    local env="$1"
    
    log_info "创建 $env 环境配置文件..."
    
    # 配置文件模板
    local config_template="config/iot_server.conf.example"
    local config_file="config/iot_server.$env.conf"
    
    if [[ ! -f "$config_template" ]]; then
        log_error "配置文件模板不存在: $config_template"
        return 1
    fi
    
    # 复制模板文件
    cp "$config_template" "$config_file"
    
    # 根据环境修改配置
    case "$env" in
        dev)
            # 开发环境配置
            sed -i.bak \
                -e "s/^log_level = .*/log_level = debug/" \
                -e "s/^max_connections = .*/max_connections = 100/" \
                -e "s/^worker_threads = .*/worker_threads = 2/" \
                "$config_file"
            ;;
            
        test)
            # 测试环境配置
            sed -i.bak \
                -e "s/^log_level = .*/log_level = info/" \
                -e "s/^max_connections = .*/max_connections = 1000/" \
                -e "s/^worker_threads = .*/worker_threads = 4/" \
                "$config_file"
            ;;
            
        prod)
            # 生产环境配置
            sed -i.bak \
                -e "s/^log_level = .*/log_level = warning/" \
                -e "s/^max_connections = .*/max_connections = 10000/" \
                -e "s/^worker_threads = .*/worker_threads = 8/" \
                -e "s/^enable_ssl = .*/enable_ssl = true/" \
                "$config_file"
            ;;
    esac
    
    # 清理备份文件
    rm -f "$config_file.bak"
    
    log_success "配置文件已创建: $config_file"
}

# 安装到系统目录
install_service() {
    local env="$1"
    
    log_info "安装服务到系统目录..."
    
    # 检查是否为root用户
    if [[ "$(id -u)" -ne 0 ]]; then
        log_error "需要root权限安装服务"
        log_info "请使用: sudo $0 -e $env --install"
        return 1
    fi
    
    cd build
    
    # 运行make install
    make install
    
    cd ..
    
    # 创建数据目录
    local data_dir="/var/lib/iot_platform"
    local log_dir="/var/log/iot_platform"
    local config_dir="/etc/iot_platform"
    
    mkdir -p "$data_dir" "$log_dir" "$config_dir"
    
    # 设置权限
    chown -R iot_server:iot_server "$data_dir" "$log_dir"
    chmod 755 "$data_dir" "$log_dir"
    
    # 复制配置文件
    cp "config/iot_server.$env.conf" "$config_dir/iot_server.conf"
    chmod 644 "$config_dir/iot_server.conf"
    
    # 安装systemd服务文件
    if [[ "$OS_NAME" == "ubuntu" ]] || [[ "$OS_NAME" == "debian" ]] || 
       [[ "$OS_NAME" == "centos" ]] || [[ "$OS_NAME" == "rhel" ]]; then
        install_systemd_service
    elif [[ "$OS_NAME" == "macos" ]]; then
        install_launchd_service
    elif [[ "$OS_NAME" == "windows" ]]; then
        install_windows_service
    fi
    
    log_success "服务安装完成"
}

# 安装systemd服务
install_systemd_service() {
    log_info "安装systemd服务..."
    
    # 服务文件模板
    local service_template="scripts/iot_server.service.in"
    local service_file="/etc/systemd/system/iot_server.service"
    
    # 生成服务文件
    sed \
        -e "s|@BINDIR@|/usr/local/bin|g" \
        -e "s|@CONFDIR@|/etc/iot_platform|g" \
        -e "s|@DATADIR@|/var/lib/iot_platform|g" \
        -e "s|@LOGDIR@|/var/log/iot_platform|g" \
        -e "s|@USER@|iot_server|g" \
        -e "s|@GROUP@|iot_server|g" \
        "$service_template" > "$service_file"
    
    # 重新加载systemd
    systemctl daemon-reload
    
    # 启用服务
    systemctl enable iot_server
    
    log_success "systemd服务安装完成"
}

# 安装launchd服务（macOS）
install_launchd_service() {
    log_info "安装launchd服务..."
    
    local plist_file="/Library/LaunchDaemons/com.iot.platform.plist"
    
    cat > "$plist_file" << EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.iot.platform</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/iot_server</string>
        <string>--config</string>
        <string>/etc/iot_platform/iot_server.conf</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
    <key>StandardOutPath</key>
    <string>/var/log/iot_platform/stdout.log</string>
    <key>StandardErrorPath</key>
    <string>/var/log/iot_platform/stderr.log</string>
    <key>UserName</key>
    <string>iot_server</string>
    <key>GroupName</key>
    <string>staff</string>
</dict>
</plist>
EOF
    
    # 设置权限
    chmod 644 "$plist_file"
    
    # 加载服务
    launchctl load "$plist_file"
    
    log_success "launchd服务安装完成"
}

# 安装Windows服务
install_windows_service() {
    log_warning "Windows服务安装需要手动配置"
    log_info "请参考 scripts/install_windows_service.bat"
}

# 启动服务
start_service() {
    log_info "启动IoT平台服务..."
    
    case "$OS_NAME" in
        ubuntu|debian|centos|rhel)
            systemctl start iot_server
            systemctl status iot_server
            ;;
        macos)
            launchctl start com.iot.platform
            ;;
        windows)
            net start iot_server
            ;;
        *)
            log_error "不支持的操作系统"
            return 1
            ;;
    esac
    
    log_success "服务启动完成"
}

# 停止服务
stop_service() {
    log_info "停止IoT平台服务..."
    
    case "$OS_NAME" in
        ubuntu|debian|centos|rhel)
            systemctl stop iot_server
            ;;
        macos)
            launchctl stop com.iot.platform
            ;;
        windows)
            net stop iot_server
            ;;
        *)
            log_error "不支持的操作系统"
            return 1
            ;;
    esac
    
    log_success "服务停止完成"
}

# 重启服务
restart_service() {
    log_info "重启IoT平台服务..."
    
    case "$OS_NAME" in
        ubuntu|debian|centos|rhel)
            systemctl restart iot_server
            systemctl status iot_server
            ;;
        macos)
            launchctl stop com.iot.platform
            sleep 2
            launchctl start com.iot.platform
            ;;
        windows)
            net stop iot_server
            sleep 5
            net start iot_server
            ;;
        *)
            log_error "不支持的操作系统"
            return 1
            ;;
    esac
    
    log_success "服务重启完成"
}

# 卸载服务
uninstall_service() {
    log_info "卸载IoT平台服务..."
    
    # 检查是否为root用户
    if [[ "$(id -u)" -ne 0 ]]; then
        log_error "需要root权限卸载服务"
        log_info "请使用: sudo $0 -e $env --uninstall"
        return 1
    fi
    
    # 停止服务
    stop_service
    
    case "$OS_NAME" in
        ubuntu|debian|centos|rhel)
            # 禁用并删除systemd服务
            systemctl disable iot_server
            rm -f /etc/systemd/system/iot_server.service
            systemctl daemon-reload
            ;;
        macos)
            # 删除launchd服务
            launchctl unload /Library/LaunchDaemons/com.iot.platform.plist
            rm -f /Library/LaunchDaemons/com.iot.platform.plist
            ;;
        windows)
            # Windows服务卸载
            log_info "请运行 scripts/uninstall_windows_service.bat"
            ;;
    esac
    
    # 删除安装的文件
    rm -f /usr/local/bin/iot_server
    rm -rf /usr/local/share/iot_platform
    rm -rf /etc/iot_platform
    rm -rf /var/lib/iot_platform
    rm -rf /var/log/iot_platform
    
    log_success "服务卸载完成"
}

# Docker部署
deploy_with_docker() {
    local env="$1"
    
    log_info "使用Docker部署 (环境: $env)..."
    
    # 检查Docker是否安装
    if ! check_command docker; then
        log_error "Docker未安装，请先安装Docker"
        return 1
    fi
    
    # 检查Docker Compose是否安装
    if ! check_command docker-compose; then
        log_error "Docker Compose未安装，请先安装Docker Compose"
        return 1
    fi
    
    # 创建Docker网络
    docker network create iot_network 2>/dev/null || true
    
    # 构建Docker镜像
    log_info "构建Docker镜像..."
    docker build -t iot_platform:"$env" .
    
    # 创建Docker Compose配置文件
    create_docker_compose_config "$env"
    
    # 启动服务
    log_info "启动Docker容器..."
    docker-compose up -d
    
    # 等待服务启动
    sleep 10
    
    # 检查容器状态
    docker-compose ps
    
    log_success "Docker部署完成"
}

# 创建Docker Compose配置
create_docker_compose_config() {
    local env="$1"
    
    cat > docker-compose.yml << EOF
version: '3.8'

services:
  iot_server:
    image: iot_platform:$env
    container_name: iot_server_$env
    restart: unless-stopped
    ports:
      - "8080:8080"
    environment:
      - ENV=$env
      - LOG_LEVEL=${LOG_LEVEL:-info}
    volumes:
      - ./data:/var/lib/iot_platform
      - ./logs:/var/log/iot_platform
      - ./config/iot_server.$env.conf:/etc/iot_platform/iot_server.conf:ro
    networks:
      - iot_network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

networks:
  iot_network:
    external: true
EOF
}

# Kubernetes部署
deploy_with_kubernetes() {
    local env="$1"
    
    log_info "使用Kubernetes部署 (环境: $env)..."
    
    # 检查kubectl是否安装
    if ! check_command kubectl; then
        log_error "kubectl未安装，请先安装kubectl"
        return 1
    fi
    
    # 创建命名空间
    kubectl create namespace iot-platform 2>/dev/null || true
    
    # 创建配置映射
    kubectl create configmap iot-server-config \
        --namespace iot-platform \
        --from-file=config/iot_server.$env.conf \
        --dry-run=client -o yaml | kubectl apply -f -
    
    # 创建密钥（如果需要）
    if [[ "$env" == "prod" ]]; then
        kubectl create secret generic iot-server-secrets \
            --namespace iot-platform \
            --from-literal=db_password="${DB_PASSWORD:-}" \
            --dry-run=client -o yaml | kubectl apply -f -
    fi
    
    # 创建部署
    kubectl apply -f kubernetes/deployment.yaml
    kubectl apply -f kubernetes/service.yaml
    
    # 等待部署完成
    kubectl rollout status deployment/iot-server --namespace iot-platform
    
    log_success "Kubernetes部署完成"
}

# 主函数
main() {
    # 默认参数
    local env="dev"
    local clean=false
    local install=false
    local start=false
    local stop=false
    local restart=false
    local uninstall=false
    local skip_deps=false
    local build_only=false
    local with_docker=false
    local with_kubernetes=false
    
    # 解析命令行参数
    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                show_usage
                exit 0
                ;;
            -e|--env)
                env="$2"
                shift 2
                ;;
            -c|--clean)
                clean=true
                shift
                ;;
            -i|--install)
                install=true
                shift
                ;;
            -s|--start)
                start=true
                shift
                ;;
            -r|--restart)
                restart=true
                shift
                ;;
            -d|--stop)
                stop=true
                shift
                ;;
            -u|--uninstall)
                uninstall=true
                shift
                ;;
            --no-deps)
                skip_deps=true
                shift
                ;;
            --build-only)
                build_only=true
                shift
                ;;
            --with-docker)
                with_docker=true
                shift
                ;;
            --with-kubernetes)
                with_kubernetes=true
                shift
                ;;
            *)
                log_error "未知选项: $1"
                show_usage
                exit 1
                ;;
        esac
    done
    
    # 验证环境参数
    case "$env" in
        dev|test|prod)
            ;;
        *)
            log_error "无效的环境: $env，必须是 dev, test 或 prod"
            exit 1
            ;;
    esac
    
    # 显示部署信息
    log_info "=== IoT平台部署开始 ==="
    log_info "部署环境: $env"
    log_info "操作系统: $OS_NAME $OS_VERSION"
    
    # 检测操作系统
    detect_os
    
    # 安装依赖
    if [[ "$skip_deps" == false ]]; then
        install_dependencies "$env"
    fi
    
    # 清理构建目录
    if [[ "$clean" == true ]]; then
        clean_build
    fi
    
    # 配置项目
    configure_project "$env"
    
    # 编译项目
    build_project
    
    # 运行测试
    run_tests "$env"
    
    # 创建配置文件
    create_config "$env"
    
    # 如果指定了仅构建，则退出
    if [[ "$build_only" == true ]]; then
        log_success "构建完成"
        exit 0
    fi
    
    # Docker部署
    if [[ "$with_docker" == true ]]; then
        deploy_with_docker "$env"
        exit 0
    fi
    
    # Kubernetes部署
    if [[ "$with_kubernetes" == true ]]; then
        deploy_with_kubernetes "$env"
        exit 0
    fi
    
    # 安装服务
    if [[ "$install" == true ]]; then
        install_service "$env"
    fi
    
    # 启动服务
    if [[ "$start" == true ]]; then
        start_service
    fi
    
    # 停止服务
    if [[ "$stop" == true ]]; then
        stop_service
    fi
    
    # 重启服务
    if [[ "$restart" == true ]]; then
        restart_service
    fi
    
    # 卸载服务
    if [[ "$uninstall" == true ]]; then
        uninstall_service
    fi
    
    # 显示部署结果
    log_success "=== IoT平台部署完成 ==="
    log_info "访问地址: http://localhost:8080"
    log_info "配置文件: config/iot_server.$env.conf"
    log_info "日志文件: /var/log/iot_platform/iot_server.log"
    
    # 如果已启动服务，显示状态
    if [[ "$start" == true ]] || [[ "$install" == true ]]; then
        echo ""
        log_info "使用以下命令管理服务:"
        log_info "  systemctl status iot_server   # 查看服务状态"
        log_info "  journalctl -u iot_server -f  # 查看服务日志"
        log_info "  sudo $0 -r                  # 重启服务"
    fi
}

# 检查必要命令
check_command cmake || exit 1
check_command make || exit 1
check_command git || exit 1

# 运行主函数
main "$@"

设计模式分析（第七部分）

1. 构建器模式（Builder Pattern）

应用位置：CMakeLists.txt中的逐步构建配置
处理突发事件：
- 平台差异：不同操作系统使用不同构建配置
- 编译选项复杂：通过选项逐步配置构建过程
- 依赖管理：动态查找和链接依赖库
工程作用：
- 分离构建过程与具体实现
- 支持多种构建配置组合
- 提供清晰的构建流程

2. 工厂模式（Factory Pattern）

应用位置：deploy.sh中根据环境创建不同配置
处理突发事件：
- 多环境部署：开发、测试、生产环境不同配置
- 平台适配：不同操作系统使用不同部署策略
- 部署方式多样：支持直接部署、Docker、Kubernetes
工程作用：
- 封装部署细节
- 统一部署接口
- 易于扩展新部署方式

3. 模板方法模式（Template Method Pattern）

应用位置：deploy.sh中的部署流程
处理突发事件：
- 部署流程变化：核心流程固定，具体步骤可调整
- 错误处理：统一的错误处理机制
- 流程控制：控制部署步骤的顺序
工程作用：
- 定义部署算法骨架
- 子步骤可以重写
- 代码复用

运行部署流程

1. 快速部署（开发环境）

# 克隆代码
git clone https://github.com/your-org/iot_platform.git
cd iot_platform

# 运行部署脚本
chmod +x scripts/deploy.sh
./scripts/deploy.sh -e dev

# 或者分步执行
./scripts/deploy.sh -e dev -c      # 清理并构建
./scripts/deploy.sh -e dev -i      # 安装
./scripts/deploy.sh -e dev -s      # 启动

2. 生产环境部署

# 生产环境部署
sudo ./scripts/deploy.sh -e prod --install

# 或者使用Docker
./scripts/deploy.sh -e prod --with-docker

# 或者使用Kubernetes
./scripts/deploy.sh -e prod --with-kubernetes

3. 手动编译和运行

# 传统CMake构建流程
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)

# 运行服务器
./iot_server --config ../config/iot_server.conf

# 查看帮助
./iot_server --help

部署架构设计

1. 单机部署架构

用户浏览器 → Nginx (80/443) → IoT服务器 (8080)
                   ↓
               静态文件服务

2. Docker部署架构

用户浏览器 → Nginx容器 → IoT服务器容器
       ↓                    ↓
    Docker网络 ← 数据卷共享

3. Kubernetes部署架构

用户 → Ingress → Service → Pod (IoT服务器)
           ↓
      ConfigMap (配置)
           ↓
      Secret (密钥)

性能调优参数

编译优化

# GCC优化选项
-O3 -march=native -flto -fno-exceptions

# Clang优化选项
-O3 -march=native -flto=thin

# MSVC优化选项
/O2 /GL /MP

运行时优化

[performance]
# Linux内核参数
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
fs.file-max = 1000000

# 进程限制
ulimit -n 100000
ulimit -u unlimited

监控和维护

健康检查端点

GET /health        # 服务健康状态
GET /metrics       # Prometheus指标
GET /status        # 详细状态信息
GET /version       # 版本信息

日志轮转配置

# logrotate配置
/var/log/iot_platform/*.log {
    daily
    rotate 30
    compress
    delaycompress
    missingok
    notifempty
    create 644 iot_server iot_server
    postrotate
        systemctl reload iot_server
    endscript
}

备份策略

# 每日备份脚本
#!/bin/bash
BACKUP_DIR="/backup/iot_platform"
DATE=$(date +%Y%m%d_%H%M%S)

# 备份配置文件
tar -czf $BACKUP_DIR/config_$DATE.tar.gz /etc/iot_platform

# 备份数据库（如果使用）
mysqldump -u iot_user -p iot_platform > $BACKUP_DIR/db_$DATE.sql

# 保留最近7天备份
find $BACKUP_DIR -type f -mtime +7 -delete

第七部分总结：提供了完整的部署和运行指南，包括：

跨平台构建配置：使用CMake支持Linux/Windows/macOS
详细文档：README.md包含完整的使用说明
自动化部署脚本：支持多种部署方式
生产环境配置：包含安全、监控、备份等最佳实践

系统现在可以按照以下步骤部署运行：

快速开始：

# 1. 克隆代码
git clone https://github.com/your-org/iot_platform.git
cd iot_platform

# 2. 一键部署（开发环境）
./scripts/deploy.sh -e dev

# 3. 访问Web界面
# 打开浏览器访问 http://localhost:8080

生产部署：

# 1. 安装依赖
sudo apt update
sudo apt install build-essential cmake libssl-dev

# 2. 生产环境部署
sudo ./scripts/deploy.sh -e prod --install

# 3. 配置Nginx和SSL
# 参考 README.md 中的配置示例

现在IoT物联网平台已经完整实现，可以进行编译、部署和运行。

腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

腾讯云开发者社区

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git