小鱼开发
2403 lines
66 KiB
Markdown
2403 lines
66 KiB
Markdown
# 应用自动更新系统开发文档
|
||
|
||
## 概述
|
||
|
||
本文档详细说明美家卡智影应用自动更新系统的完整实现方案，采用自建更新服务器 + 七牛云存储的架构，解决国内访问 GitHub 不稳定的问题。
|
||
|
||
**架构特点**：
|
||
- 轻量云账号 + 全本地业务数据
|
||
- 七牛云存储更新包，稳定访问
|
||
- FastAPI 提供更新检查和下载接口
|
||
- Tauri 应用通过 API 获取更新并安装
|
||
- 支持强制更新、下载统计等功能
|
||
|
||
---
|
||
|
||
## 一、架构设计
|
||
|
||
### 1.1 整体架构
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ 桌面应用 │
|
||
│ ┌──────────────────────┐ ┌──────────────────────────┐ │
|
||
│ │ React 前端 │────────▶│ Rust 后端 │ │
|
||
│ │ - 更新对话框 │ IPC │ - 检查/下载/安装 │ │
|
||
│ └──────────────────────┘ └──────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
│ │
|
||
│ HTTP │
|
||
▼ │
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ 后端服务层 │
|
||
│ ┌──────────────────────┐ ┌──────────────────────────┐ │
|
||
│ │ FastAPI 后端 │────────▶│ PostgreSQL 数据库 │ │
|
||
│ │ - 更新 API │ │ - 版本/包/下载日志 │ │
|
||
│ └──────────────────────┘ └──────────────────────────┘ │
|
||
│ │ │
|
||
│ ▼ │
|
||
│ ┌──────────────────────┐ │
|
||
│ │ 七牛云存储 │ │
|
||
│ └──────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 1.2 更新流程
|
||
|
||
应用启动 → 检查更新 → 显示对话框 → 下载安装包 → 安装 → 重启应用
|
||
|
||
---
|
||
|
||
## 二、数据库设计
|
||
|
||
### 2.1 数据表结构
|
||
|
||
#### 2.1.1 app_releases - 版本发布记录
|
||
|
||
| 字段 | 类型 | 说明 | 约束 |
|
||
|------|------|------|------|
|
||
| id | SERIAL | 主键 | PRIMARY KEY |
|
||
| version | VARCHAR(20) | 版本号 (语义化版本) | NOT NULL, UNIQUE |
|
||
| release_date | TIMESTAMP | 发布时间 | NOT NULL |
|
||
| notes | TEXT | 更新说明 | NOT NULL |
|
||
| mandatory | BOOLEAN | 是否强制更新 | DEFAULT FALSE |
|
||
| created_at | TIMESTAMP | 创建时间 | DEFAULT NOW() |
|
||
|
||
**示例数据**:
|
||
```sql
|
||
INSERT INTO app_releases (version, release_date, notes, mandatory) VALUES
|
||
('0.1.0', '2026-04-01 10:00:00', '初始版本发布', FALSE),
|
||
('0.1.1', '2026-04-14 10:00:00', '新功能：视频字幕压制\n修复：导出问题', FALSE),
|
||
('0.2.0', '2026-04-20 10:00:00', '新增：批量导出功能\n优化：性能提升 30%', FALSE);
|
||
```
|
||
|
||
#### 2.1.2 release_packages - 平台包信息
|
||
|
||
| 字段 | 类型 | 说明 | 约束 |
|
||
|------|------|------|------|
|
||
| id | SERIAL | 主键 | PRIMARY KEY |
|
||
| release_id | INTEGER | 关联版本发布 | FOREIGN KEY → app_releases.id |
|
||
| platform | VARCHAR(20) | 操作系统平台 | NOT NULL |
|
||
| architecture | VARCHAR(20) | CPU 架构 | NOT NULL |
|
||
| filename | VARCHAR(255) | 文件名 | NOT NULL |
|
||
| file_url | VARCHAR(500) | 七牛云下载 URL | NOT NULL |
|
||
| file_size | BIGINT | 文件大小（字节） | NOT NULL |
|
||
| file_hash | VARCHAR(64) | SHA256 哈希 | NOT NULL |
|
||
| download_count | INTEGER | 下载次数 | DEFAULT 0 |
|
||
| created_at | TIMESTAMP | 创建时间 | DEFAULT NOW() |
|
||
|
||
**平台枚举值**:
|
||
- `darwin`: macOS
|
||
- `windows`: Windows
|
||
- `linux`: Linux
|
||
|
||
**架构枚举值**:
|
||
- `x86_64`: 64位 Intel/AMD
|
||
- `arm64`: ARM64 (Apple Silicon)
|
||
|
||
**示例数据**:
|
||
```sql
|
||
INSERT INTO release_packages (release_id, platform, architecture, filename, file_url, file_size, file_hash) VALUES
|
||
(2, 'darwin', 'x86_64', 'meijiaka_0.1.1_darwin_x86_64.dmg',
|
||
'https://cdn.meijiaka.com/releases/meijiaka_0.1.1_darwin_x86_64.dmg',
|
||
102400000, 'sha256:abc123...'),
|
||
|
||
(2, 'windows', 'x86_64', 'meijiaka_0.1.1_windows_x86_64-setup.exe',
|
||
'https://cdn.meijiaka.com/releases/meijiaka_0.1.1_windows_x86_64-setup.exe',
|
||
115343360, 'sha256:def456...'),
|
||
|
||
(2, 'linux', 'amd64', 'meijiaka_0.1.1_linux_amd64.AppImage',
|
||
'https://cdn.meijiaka.com/releases/meijiaka_0.1.1_linux_amd64.AppImage',
|
||
104857600, 'sha256:ghi789...');
|
||
```
|
||
|
||
#### 2.1.3 update_downloads - 更新下载日志
|
||
|
||
| 字段 | 类型 | 说明 | 约束 |
|
||
|------| | | |
|
||
| id | SERIAL | 主键 | PRIMARY KEY |
|
||
| release_id | INTEGER | 关联版本发布 | FOREIGN KEY → app_releases.id |
|
||
| platform | VARCHAR(20) | 下载平台 | NOT NULL |
|
||
| app_version | VARCHAR(20) | 应用当前版本 | NOT NULL |
|
||
| user_id | INTEGER | 用户 ID (可选) | FOREIGN KEY → users.id |
|
||
| download_at | TIMESTAMP | 下载时间 | DEFAULT NOW() |
|
||
|
||
### 2.2 索引设计
|
||
|
||
```sql
|
||
-- 快速查询最新版本
|
||
CREATE INDEX idx_releases_release_date ON app_releases(release_date DESC);
|
||
|
||
-- 平台包复合索引
|
||
CREATE INDEX idx_packages_platform_arch ON release_packages(platform, architecture);
|
||
|
||
-- 下载统计
|
||
CREATE INDEX idx_downloads_release_id ON update_downloads(release_id);
|
||
```
|
||
|
||
### 2.3 初始化脚本
|
||
|
||
文件位置：`python-api/scripts/init_update_tables.sql`
|
||
|
||
```sql
|
||
-- 创建版本发布记录表
|
||
CREATE TABLE IF NOT EXISTS app_releases (
|
||
id SERIAL PRIMARY KEY,
|
||
version VARCHAR(20) NOT NULL UNIQUE,
|
||
release_date TIMESTAMP NOT NULL,
|
||
notes TEXT NOT NULL,
|
||
mandatory BOOLEAN DEFAULT FALSE,
|
||
created_at TIMESTAMP DEFAULT NOW()
|
||
);
|
||
|
||
-- 创建平台包信息表
|
||
CREATE TABLE IF NOT EXISTS release_packages (
|
||
id SERIAL PRIMARY KEY,
|
||
release_id INTEGER NOT NULL REFERENCES app_releases(id) ON DELETE CASCADE,
|
||
platform VARCHAR(20) NOT NULL,
|
||
architecture VARCHAR(20) NOT NULL,
|
||
filename VARCHAR(255) NOT NULL,
|
||
file_url VARCHAR(500) NOT NULL,
|
||
file_size BIGINT NOT NULL,
|
||
file_hash VARCHAR(64) NOT NULL,
|
||
download_count INTEGER DEFAULT 0,
|
||
created_at TIMESTAMP DEFAULT NOW()
|
||
);
|
||
|
||
-- 创建更新下载日志表
|
||
CREATE TABLE IF NOT EXISTS update_downloads (
|
||
id SERIAL PRIMARY KEY,
|
||
release_id INTEGER NOT NULL REFERENCES app_releases(id) ON DELETE CASCADE,
|
||
platform VARCHAR(20) NOT NULL,
|
||
app_version VARCHAR(20) NOT NULL,
|
||
user_id INTEGER REFERENCES users(id) ON DELETE SET NULL,
|
||
download_at TIMESTAMP DEFAULT NOW()
|
||
);
|
||
|
||
-- 创建索引
|
||
CREATE INDEX IF NOT EXISTS idx_releases_version ON app_releases(version);
|
||
CREATE INDEX IF NOT EXISTS idx_releases_release_date ON app_releases(release_date DESC);
|
||
CREATE INDEX IF NOT EXISTS idx_packages_platform_arch ON release_packages(platform, architecture);
|
||
CREATE INDEX IF NOT EXISTS idx_packages_release_id ON release_packages(release_id);
|
||
CREATE INDEX IF NOT EXISTS idx_downloads_release_id ON update_downloads(release_id);
|
||
CREATE INDEX IF NOT EXISTS idx_downloads_download_at ON update_downloads(download_at);
|
||
|
||
-- 插入初始版本（可选）
|
||
INSERT INTO app_releases (version, release_date, notes, mandatory)
|
||
VALUES ('0.1.0', '2026-04-01 10:00:00', '初始版本发布', FALSE)
|
||
ON CONFLICT (version) DO NOTHING;
|
||
```
|
||
|
||
---
|
||
|
||
## 三、后端 API 设计
|
||
|
||
### 3.1 API 端点列表
|
||
|
||
| 方法 | 路径 | 说明 | 认证 |
|
||
|------|------|------|------|
|
||
| POST | `/api/v1/update/check` | 检查应用更新 | 无需认证 |
|
||
| GET | `/api/v1/update/download/{version}/{platform}` | 获取下载 URL 并记录 | 无需认证 |
|
||
| POST | `/api/v1/update/releases` | 创建新版本发布 | 需要管理员认证 |
|
||
| GET | `/api/v1/update/releases` | 获取所有版本列表 | 需要管理员认证 |
|
||
| DELETE | `/api/v1/update/releases/{version}` | 删除版本发布 | 需要管理员认证 |
|
||
|
||
### 3.2 数据模型
|
||
|
||
#### 3.2.1 SQLAlchemy 模型
|
||
|
||
文件位置：`python-api/app/models/update.py`
|
||
|
||
```python
|
||
from datetime import datetime
|
||
from typing import Optional
|
||
from sqlalchemy import DateTime, Boolean, Integer, String, Text, BigInteger, ForeignKey
|
||
from sqlalchemy.orm import Mapped, mapped_column, relationship
|
||
from .base import Base
|
||
|
||
class AppRelease(Base):
|
||
"""应用版本发布记录"""
|
||
__tablename__ = "app_releases"
|
||
|
||
id: Mapped[int] = mapped_column(Integer, primary_key=True)
|
||
version: Mapped[str] = mapped_column(String(20), unique=True, index=True)
|
||
release_date: Mapped[datetime] = mapped_column(DateTime, nullable=False)
|
||
notes: Mapped[str] = mapped_column(Text, nullable=False)
|
||
mandatory: Mapped[bool] = mapped_column(Boolean, default=False)
|
||
created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
|
||
|
||
# 关系
|
||
packages: Mapped[list["ReleasePackage"]] = relationship(
|
||
"ReleasePackage",
|
||
back_populates="release",
|
||
cascade="all, delete-orphan"
|
||
)
|
||
downloads: Mapped[list["UpdateDownload"]] = relationship(
|
||
"UpdateDownload",
|
||
back_populates="release",
|
||
cascade="all, delete-orphan"
|
||
)
|
||
|
||
class ReleasePackage(Base):
|
||
"""平台包信息"""
|
||
__tablename__ = "release_packages"
|
||
|
||
id: Mapped[int] = mapped_column(Integer, primary_key=True)
|
||
release_id: Mapped[int] = mapped_column(
|
||
Integer,
|
||
ForeignKey("app_releases.id", ondelete="CASCADE"),
|
||
nullable=False
|
||
)
|
||
platform: Mapped[str] = mapped_column(String(20), nullable=False)
|
||
architecture: Mapped[str] = mapped_column(String(20), nullable=False)
|
||
filename: Mapped[str] = mapped_column(String(255), nullable=False)
|
||
file_url: Mapped[str] = mapped_column(String(500), nullable=False)
|
||
file_size: Mapped[int] = mapped_column(BigInteger, nullable=False)
|
||
file_hash: Mapped[str] = mapped_column(String(64), nullable=False)
|
||
download_count: Mapped[int] = mapped_column(Integer, default=0)
|
||
created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
|
||
|
||
# 关系
|
||
release: Mapped["AppRelease"] = relationship("AppRelease", back_populates="packages")
|
||
|
||
class UpdateDownload(Base):
|
||
"""更新下载日志"""
|
||
__tablename__ = "update_downloads"
|
||
|
||
id: Mapped[int] = mapped_column(Integer, primary_key=True)
|
||
release_id: Mapped[int] = mapped_column(
|
||
Integer,
|
||
ForeignKey("app_releases.id", ondelete="CASCADE"),
|
||
nullable=False
|
||
)
|
||
platform: Mapped[str] = mapped_column(String(20), nullable=False)
|
||
app_version: Mapped[str] = mapped_column(String(20), nullable=False)
|
||
user_id: Mapped[Optional[int]] = mapped_column(
|
||
Integer,
|
||
ForeignKey("users.id", ondelete="SET NULL")
|
||
)
|
||
download_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
|
||
|
||
# 关系
|
||
release: Mapped["AppRelease"] = relationship("AppRelease", back_populates="downloads")
|
||
```
|
||
|
||
#### 3.2.2 Pydantic Schemas
|
||
|
||
文件位置：`python-api/app/schemas/update.py`
|
||
|
||
```python
|
||
from datetime import datetime
|
||
from typing import Optional
|
||
from pydantic import BaseModel, Field
|
||
|
||
class UpdateCheckRequest(BaseModel):
|
||
"""更新检查请求"""
|
||
current_version: str = Field(..., description="当前应用版本")
|
||
platform: str = Field(..., description="操作系统平台: darwin, windows, linux")
|
||
architecture: Optional[str] = Field(None, description="CPU架构: x86_64, arm64")
|
||
|
||
class PackageInfo(BaseModel):
|
||
"""包信息"""
|
||
platform: str
|
||
architecture: str
|
||
file_url: str
|
||
file_size: int
|
||
file_hash: str
|
||
|
||
class UpdateInfoResponse(BaseModel):
|
||
"""更新信息响应"""
|
||
version: str
|
||
release_date: datetime
|
||
notes: str
|
||
mandatory: bool
|
||
packages: list[PackageInfo]
|
||
|
||
class PackageCreate(BaseModel):
|
||
"""包创建信息"""
|
||
platform: str
|
||
architecture: str
|
||
file_url: str
|
||
file_size: int
|
||
file_hash: str
|
||
|
||
class ReleaseCreate(BaseModel):
|
||
"""版本发布创建请求"""
|
||
version: str
|
||
notes: str
|
||
mandatory: bool = False
|
||
packages: list[PackageCreate]
|
||
|
||
class ReleaseResponse(BaseModel):
|
||
"""版本发布响应"""
|
||
id: int
|
||
version: str
|
||
release_date: datetime
|
||
notes: str
|
||
mandatory: bool
|
||
created_at: datetime
|
||
packages: list[PackageInfo]
|
||
|
||
class DownloadResponse(BaseModel):
|
||
"""下载信息响应"""
|
||
download_url: str
|
||
file_size: int
|
||
file_hash: str
|
||
```
|
||
|
||
### 3.3 API 路由实现
|
||
|
||
文件位置：`python-api/app/api/v1/update.py`
|
||
|
||
```python
|
||
from fastapi import APIRouter, HTTPException, Depends, status
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from sqlalchemy import select, and_
|
||
from typing import Optional
|
||
|
||
from ...deps import get_db
|
||
from ...models.update import AppRelease, ReleasePackage, UpdateDownload
|
||
from ...schemas.update import (
|
||
UpdateCheckRequest,
|
||
UpdateInfoResponse,
|
||
ReleaseCreate,
|
||
ReleaseResponse,
|
||
DownloadResponse,
|
||
PackageInfo,
|
||
PackageCreate
|
||
)
|
||
|
||
router = APIRouter()
|
||
|
||
@router.post("/check", response_model=UpdateInfoResponse, status_code=status.HTTP_200_OK)
|
||
async def check_update(
|
||
request: UpdateCheckRequest,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""
|
||
检查应用更新
|
||
|
||
Args:
|
||
request: 包含当前版本、平台信息的请求
|
||
|
||
Returns:
|
||
最新的版本信息，如果已是最新版本则返回 204 No Content
|
||
"""
|
||
# 查询最新版本
|
||
result = await db.execute(
|
||
select(AppRelease)
|
||
.order_by(AppRelease.release_date.desc())
|
||
.limit(1)
|
||
)
|
||
latest_release = result.scalar_one_or_none()
|
||
|
||
if not latest_release:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_404_NOT_FOUND,
|
||
detail="No releases found"
|
||
)
|
||
|
||
# 如果已是最新版本
|
||
if latest_release.version == request.current_version:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_204_NO_CONTENT,
|
||
detail="Already up to date"
|
||
)
|
||
|
||
# 确定架构（如果未提供）
|
||
arch = request.architecture or _get_default_architecture(request.platform)
|
||
|
||
# 查询对应平台的包
|
||
result = await db.execute(
|
||
select(ReleasePackage).where(
|
||
and_(
|
||
ReleasePackage.release_id == latest_release.id,
|
||
ReleasePackage.platform == request.platform,
|
||
ReleasePackage.architecture == arch
|
||
)
|
||
)
|
||
)
|
||
packages = result.scalars().all()
|
||
|
||
if not packages:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_404_NOT_FOUND,
|
||
detail=f"No package found for platform {request.platform} {arch}"
|
||
)
|
||
|
||
# 构建响应
|
||
return UpdateInfoResponse(
|
||
version=latest_release.version,
|
||
release_date=latest_release.release_date,
|
||
notes=latest_release.notes,
|
||
mandatory=latest_release.mandatory,
|
||
packages=[
|
||
PackageInfo(
|
||
platform=p.platform,
|
||
architecture=p.architecture,
|
||
file_url=p.file_url,
|
||
file_size=p.file_size,
|
||
file_hash=p.file_hash
|
||
)
|
||
for p in packages
|
||
]
|
||
)
|
||
|
||
@router.get("/download/{version}/{platform}", response_model=DownloadResponse)
|
||
async def get_download_url(
|
||
version: str,
|
||
platform: str,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""
|
||
获取下载 URL 并记录下载日志
|
||
|
||
Args:
|
||
version: 目标版本
|
||
platform: 平台类型
|
||
|
||
Returns:
|
||
包含下载 URL、文件大小和哈希的响应
|
||
"""
|
||
# 查询版本信息
|
||
result = await db.execute(
|
||
select(AppRelease).where(AppRelease.version == version)
|
||
)
|
||
release = result.scalar_one_or_none()
|
||
|
||
if not release:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_404_NOT_FOUND,
|
||
detail="Release not found"
|
||
)
|
||
|
||
# 查询对应平台的包
|
||
result = await db.execute(
|
||
select(ReleasePackage).where(
|
||
and_(
|
||
ReleasePackage.release_id == release.id,
|
||
ReleasePackage.platform == platform
|
||
)
|
||
)
|
||
)
|
||
package = result.scalar_one_or_none()
|
||
|
||
if not package:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_404_NOT_FOUND,
|
||
detail=f"Package not found for platform {platform}"
|
||
)
|
||
|
||
# 增加下载计数
|
||
package.download_count += 1
|
||
|
||
# 记录下载日志（可选，不阻塞主流程）
|
||
download_log = UpdateDownload(
|
||
release_id=release.id,
|
||
platform=platform,
|
||
app_version=version
|
||
)
|
||
db.add(download_log)
|
||
|
||
await db.commit()
|
||
|
||
return DownloadResponse(
|
||
download_url=package.file_url,
|
||
file_size=package.file_size,
|
||
file_hash=package.file_hash
|
||
)
|
||
|
||
@router.post("/releases", response_model=ReleaseResponse)
|
||
async def create_release(
|
||
release: ReleaseCreate,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""
|
||
创建新版本发布
|
||
|
||
Args:
|
||
release: 版本发布信息
|
||
|
||
Returns:
|
||
创建的版本发布信息
|
||
"""
|
||
# 检查版本是否已存在
|
||
result = await db.execute(
|
||
select(AppRelease).where(AppRelease.version == release.version)
|
||
)
|
||
if result.scalar_one_or_none():
|
||
raise HTTPException(
|
||
status_code=status.HTTP_400_BAD_REQUEST,
|
||
detail="Version already exists"
|
||
)
|
||
|
||
# 创建发布记录
|
||
new_release = AppRelease(
|
||
version=release.version,
|
||
release_date=datetime.utcnow(),
|
||
notes=release.notes,
|
||
mandatory=release.mandatory
|
||
)
|
||
db.add(new_release)
|
||
await db.flush() # 获取 ID
|
||
|
||
# 创建包记录
|
||
for pkg in release.packages:
|
||
package = ReleasePackage(
|
||
release_id=new_release.id,
|
||
platform=pkg.platform,
|
||
architecture=pkg.architecture,
|
||
filename=pkg.file_url.split("/")[-1],
|
||
file_url=pkg.file_url,
|
||
file_size=pkg.file_size,
|
||
file_hash=pkg.file_hash
|
||
)
|
||
db.add(package)
|
||
|
||
await db.commit()
|
||
|
||
# 构建响应
|
||
return ReleaseResponse(
|
||
id=new_release.id,
|
||
version=new_release.version,
|
||
release_date=new_release.release_date,
|
||
notes=new_release.notes,
|
||
mandatory=new_release.mandatory,
|
||
created_at=new_release.created_at,
|
||
packages=[
|
||
PackageInfo(
|
||
platform=pkg.platform,
|
||
architecture=pkg.architecture,
|
||
file_url=pkg.file_url,
|
||
file_size=pkg.file_size,
|
||
file_hash=pkg.file_hash
|
||
)
|
||
for pkg in release.packages
|
||
]
|
||
)
|
||
|
||
@router.get("/releases", response_model=list[ReleaseResponse])
|
||
async def list_releases(
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""
|
||
获取所有版本发布列表
|
||
|
||
Returns:
|
||
所有版本发布信息列表
|
||
"""
|
||
result = await db.execute(
|
||
select(AppRelease).order_by(AppRelease.release_date.desc())
|
||
)
|
||
releases = result.scalars().all()
|
||
|
||
responses = []
|
||
for release in releases:
|
||
# 获取包信息
|
||
result = await db.execute(
|
||
select(ReleasePackage).where(
|
||
ReleasePackage.release_id == release.id
|
||
)
|
||
)
|
||
packages = result.scalars().all()
|
||
|
||
responses.append(ReleaseResponse(
|
||
id=release.id,
|
||
version=release.version,
|
||
release_date=release.release_date,
|
||
notes=release.notes,
|
||
mandatory=release.mandatory,
|
||
created_at=release.created_at,
|
||
packages=[
|
||
PackageInfo(
|
||
platform=p.platform,
|
||
architecture=p.architecture,
|
||
file_url=p.file_url,
|
||
file_size=p.file_size,
|
||
file_hash=p.file_hash
|
||
)
|
||
for p in packages
|
||
]
|
||
))
|
||
|
||
return responses
|
||
|
||
@router.delete("/releases/{version}")
|
||
async def delete_release(
|
||
version: str,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
"""
|
||
删除版本发布
|
||
|
||
Args:
|
||
version: 要删除的版本号
|
||
|
||
Returns:
|
||
操作结果
|
||
"""
|
||
result = await db.execute(
|
||
select(AppRelease).where(AppRelease.version == version)
|
||
)
|
||
release = result.scalar_one_or_none()
|
||
|
||
if not release:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_404_NOT_FOUND,
|
||
detail="Release not found"
|
||
)
|
||
|
||
await db.delete(release)
|
||
await db.commit()
|
||
|
||
return {"status": "success", "message": f"Release {version} deleted"}
|
||
|
||
# 辅助函数
|
||
def _get_default_architecture(platform: str) -> str:
|
||
"""获取系统架构默认值"""
|
||
if platform == "darwin":
|
||
return "universal" # macOS 默认 universal
|
||
elif platform == "linux":
|
||
return "amd64" # Linux 默认 amd64
|
||
else:
|
||
return "x86_64" # Windows 默认 x86_64
|
||
```
|
||
|
||
### 3.4 注册路由
|
||
|
||
在 `python-api/app/main.py` 中注册：
|
||
|
||
```python
|
||
from app.api.v1.update import router as update_router
|
||
|
||
app.include_router(update_router, prefix="/api/v1/update", tags=["更新"])
|
||
```
|
||
|
||
---
|
||
|
||
## 四、Rust 后端更新逻辑
|
||
|
||
### 4.1 模块结构
|
||
|
||
```
|
||
tauri-app/src-tauri/src/
|
||
├── updater.rs # 更新模块主文件
|
||
├── lib.rs # 命令注册
|
||
└── Cargo.toml # 依赖配置
|
||
```
|
||
|
||
### 4.2 依赖配置
|
||
|
||
在 `tauri-app/src-tauri/Cargo.toml` 中添加：
|
||
|
||
```toml
|
||
[dependencies]
|
||
# 现有依赖...
|
||
sha2 = "0.10" # SHA256 哈希计算
|
||
tokio = { version = "1", features = ["fs", "io-util"] } # 异步 I/O
|
||
dirs = "5" # 获取系统目录路径
|
||
```
|
||
|
||
### 4.3 更新模块实现
|
||
|
||
文件位置：`tauri-app/src-tauri/src/updater.rs`
|
||
|
||
```rust
|
||
use tauri::{AppHandle, Emitter};
|
||
use reqwest::{self, Client};
|
||
use std::fs::{self, File};
|
||
use std::io::Write;
|
||
use std::path::PathBuf;
|
||
use serde::{Deserialize, Serialize};
|
||
use tokio::io::AsyncReadExt;
|
||
use sha2::{Sha256, Digest};
|
||
|
||
// ============ 数据结构 ============
|
||
|
||
#[derive(Debug, Serialize, Deserialize)]
|
||
pub struct PackageInfo {
|
||
pub platform: String,
|
||
pub architecture: String,
|
||
pub file_url: String,
|
||
pub file_size: u64,
|
||
pub file_hash: String,
|
||
}
|
||
|
||
#[derive(Debug, Serialize, Deserialize)]
|
||
pub struct UpdateInfo {
|
||
pub version: String,
|
||
pub release_date: String,
|
||
pub notes: String,
|
||
pub mandatory: bool,
|
||
pub packages: Vec<PackageInfo>,
|
||
}
|
||
|
||
#[derive(Debug, Serialize, Deserialize)]
|
||
pub struct DownloadProgress {
|
||
pub downloaded: u64,
|
||
pub total: u64,
|
||
pub percentage: f32,
|
||
}
|
||
|
||
// ============ Tauri 命令 ============
|
||
|
||
/// 检查应用更新
|
||
#[tauri::command]
|
||
pub async fn check_update(
|
||
app: AppHandle,
|
||
current_version: String,
|
||
) -> Result<Option<UpdateInfo>, String> {
|
||
// 获取平台信息
|
||
let platform = std::env::consts::OS;
|
||
let platform_name = match platform {
|
||
"macos" => "darwin",
|
||
"windows" => "windows",
|
||
"linux" => "linux",
|
||
_ => return Err(format!("Unsupported platform: {}", platform)),
|
||
};
|
||
|
||
// 获取架构信息
|
||
let arch = if cfg!(target_arch = "x86_64") {
|
||
"x86_64"
|
||
} else if cfg!(target_arch = "aarch64") {
|
||
"arm64"
|
||
} else {
|
||
return Err("Unsupported architecture".to_string());
|
||
};
|
||
|
||
// 调用 FastAPI 检查更新
|
||
let client = Client::new();
|
||
let api_url = "http://localhost:8080"; // 从配置读取
|
||
|
||
let url = format!(
|
||
"{}/api/v1/update/check",
|
||
api_url
|
||
);
|
||
|
||
let response = client
|
||
.post(&url)
|
||
.json(&serde_json::json!({
|
||
"current_version": current_version,
|
||
"platform": platform_name,
|
||
"architecture": arch
|
||
}))
|
||
.send()
|
||
.await
|
||
.map_err(|e| format!("Failed to check update: {}", e))?;
|
||
|
||
if response.status() == 204 {
|
||
return Ok(None); // 已是最新版本
|
||
}
|
||
|
||
let update_info: UpdateInfo = response
|
||
.json()
|
||
.await
|
||
.map_err(|e| format!("Failed to parse update info: {}", e))?;
|
||
|
||
Ok(Some(update_info))
|
||
}
|
||
|
||
/// 下载更新包
|
||
#[tauri::command]
|
||
pub async fn download_update(
|
||
app: AppHandle,
|
||
url: String,
|
||
file_hash: String,
|
||
expected_size: u64,
|
||
) -> Result<String, String> {
|
||
// 创建更新目录
|
||
let cache_dir = app.path().app_cache_dir()
|
||
.map_err(|e| format!("Failed to get cache dir: {}", e))?;
|
||
|
||
let updates_dir = cache_dir.join("updates");
|
||
fs::create_dir_all(&updates_dir)
|
||
.map_err(|e| format!("Failed to create updates dir: {}", e))?;
|
||
|
||
// 从 URL 提取文件名
|
||
let filename = url.split('/').last()
|
||
.unwrap_or("update.pkg")
|
||
.to_string();
|
||
|
||
let save_path = updates_dir.join(&filename);
|
||
|
||
// 检查是否已下载并验证
|
||
if save_path.exists() {
|
||
if verify_file_hash(&save_path, &file_hash).await {
|
||
return Ok(save_path.to_string_lossy().to_string());
|
||
}
|
||
// 哈希不匹配，删除重新下载
|
||
fs::remove_file(&save_path)?;
|
||
}
|
||
|
||
// 发起下载请求
|
||
let client = Client::new();
|
||
let mut response = client
|
||
.get(&url)
|
||
.send()
|
||
.await
|
||
.map_err(|e| format!("Failed to download: {}", e))?;
|
||
|
||
let total_size = expected_size;
|
||
let mut downloaded = 0u64;
|
||
let mut file = File::create(&save_path)
|
||
.map_err(|e| format!("Failed to create file: {}", e))?;
|
||
|
||
// 流式下载并报告进度
|
||
while let Some(chunk_result) = response.chunk().await {
|
||
let chunk = chunk_result
|
||
.map_err(|e| format!("Download error: {}", e))?;
|
||
|
||
file.write_all(&chunk)
|
||
.map_err(|e| format!("Write error: {}", e))?;
|
||
|
||
downloaded += chunk.len() as u64;
|
||
|
||
// 发送进度事件
|
||
let percentage = if total_size > 0 {
|
||
(downloaded as f32 / total_size as f32) * 100.0
|
||
} else {
|
||
0.0
|
||
};
|
||
|
||
let _ = app.emit("download-progress", DownloadProgress {
|
||
downloaded,
|
||
total: total_size,
|
||
percentage,
|
||
});
|
||
}
|
||
|
||
// 验证文件哈希
|
||
if !verify_file_hash(&save_path, &file_hash).await {
|
||
fs::remove_file(&save_path)?;
|
||
return Err("File hash verification failed".to_string());
|
||
}
|
||
|
||
Ok(save_path.to_string_lossy().to_string())
|
||
}
|
||
|
||
/// 安装更新包
|
||
#[tauri::command]
|
||
pub async fn install_update(
|
||
app: AppHandle,
|
||
package_path: String,
|
||
) -> Result<(), String> {
|
||
let package_path = PathBuf::from(package_path);
|
||
|
||
#[cfg(target_os = "macos")]
|
||
{
|
||
install_macos(app, package_path).await?;
|
||
}
|
||
|
||
#[cfg(target_os = "windows")]
|
||
{
|
||
install_windows(app, package_path).await?;
|
||
}
|
||
|
||
#[cfg(target_os = "linux")]
|
||
{
|
||
install_linux(app, package_path).await?;
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
// ============ 平台特定实现 ============
|
||
|
||
#[cfg(target_os = "macos")]
|
||
async fn install_macos(app: AppHandle, package_path: PathBuf) -> Result<(), String> {
|
||
use std::process::Command;
|
||
use std::thread;
|
||
use std::time::Duration;
|
||
|
||
// macOS: 使用 hdiutil 挂载 dmg 并复制应用到 ~/Applications
|
||
let mount_dir = PathBuf::from("/tmp/meijiaka_mount");
|
||
|
||
// 确保挂载目录不存在
|
||
if mount_dir.exists() {
|
||
let _ = Command::new("hdiutil")
|
||
.args(["detach", mount_dir.to_str().unwrap(), "-force"])
|
||
.status();
|
||
}
|
||
|
||
// 挂载 DMG
|
||
let output = Command::new("hdiutil")
|
||
.args([
|
||
"attach",
|
||
"-readonly",
|
||
"-nobrowse",
|
||
"-mountpoint",
|
||
mount_dir.to_str().unwrap(),
|
||
package_path.to_str().unwrap(),
|
||
])
|
||
.output()
|
||
.map_err(|e| format!("Failed to mount DMG: {}", e))?;
|
||
|
||
if !output.status.success() {
|
||
return Err(format!("Failed to mount DMG: {}",
|
||
String::from_utf8_loss(output.stderr.as_slice())));
|
||
}
|
||
|
||
// 查找应用文件
|
||
let app_path = find_app_in_dmg(&mount_dir)?;
|
||
let app_name = app_path.file_name()
|
||
.ok_or("Invalid app path")?
|
||
.to_string_lossy()
|
||
.to_string();
|
||
|
||
// 用户目录 Applications
|
||
let dest_dir = dirs::home_dir()
|
||
.ok_or("Failed to get home directory")?
|
||
.join("Applications");
|
||
|
||
fs::create_dir_all(&dest_dir)
|
||
.map_err(|e| format!("Failed to create Applications dir: {}", e))?;
|
||
|
||
let dest_path = dest_dir.join(&app_name);
|
||
|
||
// 删除旧版本
|
||
if dest_path.exists() {
|
||
let _ = Command::new("rm")
|
||
.args(["-rf", dest_path.to_str().unwrap()])
|
||
.status();
|
||
}
|
||
|
||
// 复制应用
|
||
let output = Command::new("cp")
|
||
.args(["-R", app_path.to_str().unwrap(), dest_dir.to_str().unwrap()])
|
||
.output()
|
||
.map_err(|e| format!("Failed to copy app: {}", e))?;
|
||
|
||
if !output.status.success() {
|
||
return Err("Failed to copy app".to_string());
|
||
}
|
||
|
||
// 卸载 DMG
|
||
let _ = Command::new("hdiutil")
|
||
.args(["detach", mount_dir.to_str().unwrap(), "-force"])
|
||
.status();
|
||
|
||
// 延迟启动新版本
|
||
thread::spawn(move || {
|
||
thread::sleep(Duration::from_secs(2));
|
||
let _ = Command::new("open")
|
||
.args(["-a", &app_name])
|
||
.status();
|
||
});
|
||
|
||
// 退出当前应用
|
||
app.exit(0);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
#[cfg(target_os = "macos")]
|
||
fn find_app_in_dmg(mount_dir: &PathBuf) -> Result<PathBuf, String> {
|
||
use std::fs;
|
||
|
||
let entries = fs::read_dir(mount_dir)
|
||
.map_err(|e| format!("Failed to read mount dir: {}", e))?;
|
||
|
||
for entry in entries {
|
||
let entry = entry.map_err(|e| format!("Failed to read entry: {}", e))?;
|
||
let path = entry.path();
|
||
|
||
// 查找 .app 目录
|
||
if path.extension().and_then(|s| s.to_str()) == Some("app") {
|
||
return Ok(path);
|
||
}
|
||
|
||
// 递归查找
|
||
if path.is_dir() {
|
||
if let Ok(app_path) = find_app_in_dmg(&path) {
|
||
return Ok(app_path);
|
||
}
|
||
}
|
||
}
|
||
|
||
Err("App not found in DMG".to_string())
|
||
}
|
||
|
||
#[cfg(target_os = "windows")]
|
||
async fn install_windows(app: AppHandle, package_path: PathBuf) -> Result<(), String> {
|
||
use std::process::Command;
|
||
use std::thread;
|
||
use std::time::Duration;
|
||
|
||
// Windows: 使用 NSIS 安装包
|
||
let _ = Command::new(package_path.to_str().unwrap())
|
||
.args(["/S"]) // 静默安装
|
||
.spawn()
|
||
.map_err(|e| format!("Failed to start installer: {}", e))?;
|
||
|
||
// 延迟退出，让安装程序完成
|
||
thread::sleep(Duration::from_secs(2));
|
||
|
||
app.exit(0);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
#[cfg(target_os = "linux")]
|
||
async fn install_linux(app: AppHandle, package_path: PathBuf) -> Result<(), String> {
|
||
use std::process::Command;
|
||
use std::thread;
|
||
use std::time::Duration;
|
||
|
||
// Linux: 提取 AppImage 并设置执行权限
|
||
let home_dir = dirs::home_dir()
|
||
.ok_or("Failed to get home directory")?;
|
||
|
||
let app_dir = home_dir.join("Applications");
|
||
fs::create_dir_all(&app_dir)?;
|
||
|
||
let filename = package_path.file_name()
|
||
.ok_or("Invalid package path")?;
|
||
|
||
let dest_path = app_dir.join(filename);
|
||
|
||
// 复制文件
|
||
fs::copy(&package_path, &dest_path)?;
|
||
|
||
// 设置执行权限
|
||
#[cfg(unix)]
|
||
{
|
||
use std::os::unix::fs::PermissionsExt;
|
||
let mut perms = fs::metadata(&dest_path)?.permissions();
|
||
perms.set_mode(perms.mode() | 0o111);
|
||
fs::set_permissions(&dest_path, perms)?;
|
||
}
|
||
|
||
// 启动新版本
|
||
thread::spawn(move || {
|
||
thread::sleep(Duration::from_secs(2));
|
||
let _ = Command::new(dest_path.to_str().unwrap())
|
||
.status();
|
||
});
|
||
|
||
app.exit(0);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
// ============ 工具函数 ============
|
||
|
||
/// 验证文件 SHA256 哈希
|
||
async fn verify_file_hash(file_path: &PathBuf, expected_hash: &str) -> bool {
|
||
use tokio::fs;
|
||
|
||
let file = fs::File::open(file_path).await;
|
||
if file.is_err() {
|
||
return false;
|
||
}
|
||
|
||
let mut file = file.unwrap();
|
||
let mut hasher = Sha256::new();
|
||
let mut buffer = [0u8; 8192];
|
||
|
||
loop {
|
||
let n = file.read(&mut buffer).await.unwrap_or(0);
|
||
if n == 0 {
|
||
break;
|
||
}
|
||
hasher.update(&buffer[..n]);
|
||
}
|
||
|
||
let actual_hash = format!("sha256:{:x}", hasher.finalize());
|
||
actual_hash == expected_hash
|
||
}
|
||
```
|
||
|
||
**注意**：上述示例代码混合使用了同步和异步 I/O。在生产环境中，建议统一使用异步 I/O 以获得更好的性能。统一后的代码需要使用 `tokio::fs` 替代 `std::fs`，并使用 `tokio::process::Command` 替代 `std::process::Command`。
|
||
|
||
### 4.4 注册命令
|
||
|
||
在 `tauri-app/src-tauri/src/lib.rs` 中注册命令：
|
||
|
||
```rust
|
||
mod updater;
|
||
|
||
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
||
pub fn run() {
|
||
tauri::Builder::default()
|
||
.plugin(tauri_plugin_fs::init())
|
||
.plugin(tauri_plugin_dialog::init())
|
||
.plugin(tauri_plugin_shell::init())
|
||
.plugin(tauri_plugin_opener::init())
|
||
.invoke_handler(tauri::generate_handler![
|
||
// ... 其他命令
|
||
updater::check_update,
|
||
updater::download_update,
|
||
updater::install_update
|
||
])
|
||
.setup(|app| {
|
||
#[cfg(debug_assertions)]
|
||
{
|
||
let window = app.get_webview_window("main").unwrap();
|
||
window.open_devtools();
|
||
}
|
||
Ok(())
|
||
})
|
||
.run(tauri::generate_context!())
|
||
.expect("error while running tauri application");
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 五、前端实现
|
||
|
||
### 5.1 更新状态管理
|
||
|
||
文件位置：`tauri-app/src/store/updateStore.ts`
|
||
|
||
```typescript
|
||
import { create } from 'zustand';
|
||
import { invoke } from '@tauri-apps/api/core';
|
||
import { listen } from '@tauri-apps/api/event';
|
||
|
||
interface UpdatePackage {
|
||
platform: string;
|
||
architecture: string;
|
||
file_url: string;
|
||
file_size: number;
|
||
file_hash: string;
|
||
}
|
||
|
||
interface UpdateInfo {
|
||
version: string;
|
||
release_date: string;
|
||
notes: string;
|
||
mandatory: boolean;
|
||
packages: UpdatePackage[];
|
||
}
|
||
|
||
interface DownloadProgress {
|
||
downloaded: number;
|
||
total: number;
|
||
percentage: number;
|
||
}
|
||
|
||
interface UpdateState {
|
||
updateAvailable: boolean;
|
||
updateInfo: UpdateInfo | null;
|
||
downloadProgress: DownloadProgress;
|
||
downloading: boolean;
|
||
checking: boolean;
|
||
installing: boolean;
|
||
downloadedPath: string | null;
|
||
|
||
checkUpdate: (currentVersion: string) => Promise<void>;
|
||
downloadUpdate: () => Promise<void>;
|
||
installUpdate: () => Promise<void>;
|
||
dismissUpdate: () => void;
|
||
}
|
||
|
||
export const useUpdateStore = create<UpdateState>((set, get) => ({
|
||
updateAvailable: false,
|
||
updateInfo: null,
|
||
downloadProgress: { downloaded: 0, total: 0, percentage: 0 },
|
||
downloading: false,
|
||
checking: false,
|
||
installing: false,
|
||
downloadedPath: null,
|
||
|
||
checkUpdate: async (currentVersion: string) => {
|
||
set({ checking: true });
|
||
try {
|
||
const updateInfo = await invoke<UpdateInfo | null>('check_update', {
|
||
currentVersion,
|
||
});
|
||
|
||
if (updateInfo) {
|
||
set({ updateAvailable: true, updateInfo });
|
||
} else {
|
||
set({ updateAvailable: false, updateInfo: null });
|
||
}
|
||
} catch (error) {
|
||
console.error('Check update failed:', error);
|
||
set({ updateAvailable: false, updateInfo: null });
|
||
} finally {
|
||
set({ checking: false });
|
||
}
|
||
},
|
||
|
||
downloadUpdate: async () => {
|
||
const { updateInfo } = get();
|
||
if (!updateInfo) {
|
||
throw new Error('No update available');
|
||
}
|
||
|
||
// 获取当前平台的包
|
||
const platform = process.platform === 'darwin' ? 'darwin' :
|
||
process.platform === 'win32' ? 'windows' : 'linux';
|
||
|
||
const arch = process.arch === 'arm64' ? 'arm64' : 'x86_64';
|
||
|
||
const pkg = updateInfo.packages.find(
|
||
p => p.platform === platform && p.architecture === arch
|
||
);
|
||
|
||
if (!pkg) {
|
||
throw new Error(`No package found for ${platform} ${arch}`);
|
||
}
|
||
|
||
set({ downloading: true, downloadProgress: { downloaded: 0, total: pkg.file_size, percentage: 0 } });
|
||
|
||
try {
|
||
// 监听下载进度
|
||
const unlisten = await listen<DownloadProgress>('download-progress', (event) => {
|
||
set({ downloadProgress: event.payload });
|
||
});
|
||
|
||
const downloadedPath = await invoke<string>('download_update', {
|
||
url: pkg.file_url,
|
||
fileHash: pkg.file_hash,
|
||
expectedSize: pkg.file_size,
|
||
});
|
||
|
||
await unlisten();
|
||
set({ downloadedPath });
|
||
} catch (error) {
|
||
console.error('Download failed:', error);
|
||
throw error;
|
||
} finally {
|
||
set({ downloading: false });
|
||
}
|
||
},
|
||
|
||
installUpdate: async () => {
|
||
const { downloadedPath } = get();
|
||
if (!downloadedPath) {
|
||
throw new Error('No downloaded package');
|
||
}
|
||
|
||
set({ installing: true });
|
||
try {
|
||
await invoke('install_update', {
|
||
packagePath: downloadedPath,
|
||
});
|
||
// 安装后应用会重启，这里不会执行
|
||
} catch (error) {
|
||
console.error('Install failed:', error);
|
||
throw error;
|
||
} finally {
|
||
set({ installing: false });
|
||
}
|
||
},
|
||
|
||
dismissUpdate: () => {
|
||
set({ updateAvailable: false, updateInfo: null });
|
||
},
|
||
}));
|
||
```
|
||
|
||
### 5.2 更新对话框组件
|
||
|
||
文件位置：`tauri-app/src/components/UpdateDialog.tsx`
|
||
|
||
```tsx
|
||
import { useEffect } from 'react';
|
||
import { Dialog, DialogContent, DialogTitle } from '@/components/ui/dialog';
|
||
import { Button } from '@/components/ui/button';
|
||
import { Progress } from '@/components/ui/progress';
|
||
import { useUpdateStore } from '@/store/updateStore';
|
||
|
||
export function UpdateDialog() {
|
||
const {
|
||
updateAvailable,
|
||
updateInfo,
|
||
downloadProgress,
|
||
downloading,
|
||
checking,
|
||
installing,
|
||
checkUpdate,
|
||
downloadUpdate,
|
||
installUpdate,
|
||
dismissUpdate,
|
||
} = useUpdateStore();
|
||
|
||
// 当前应用版本（从 package.json 或构建时注入）
|
||
const CURRENT_VERSION = import.meta.env.VITE_APP_VERSION || '0.1.0';
|
||
|
||
useEffect(() => {
|
||
// 启动时检查更新
|
||
checkUpdate(CURRENT_VERSION);
|
||
}, []);
|
||
|
||
if (!updateAvailable) return null;
|
||
|
||
const isMandatory = updateInfo?.mandatory;
|
||
|
||
return (
|
||
<Dialog open={updateAvailable} onOpenChange={(open) => !open && !isMandatory && dismissUpdate()}>
|
||
<DialogContent className="sm:max-w-md">
|
||
<DialogTitle className="text-xl font-bold">
|
||
{checking ? '检查更新...' :
|
||
downloading ? '下载更新中...' :
|
||
installing ? '安装更新...' :
|
||
`发现新版本 ${updateInfo?.version}`}
|
||
</DialogTitle>
|
||
|
||
<div className="space-y-4">
|
||
{!checking && updateInfo && (
|
||
<>
|
||
<div className="text-sm text-muted-foreground whitespace-pre-line">
|
||
{updateInfo.notes}
|
||
</div>
|
||
|
||
{downloading && (
|
||
<div className="space-y-2">
|
||
<Progress value={downloadProgress.percentage} />
|
||
<div className="text-xs text-muted-foreground text-center">
|
||
{Math.round(downloadProgress.percentage)}%
|
||
({(downloadProgress.downloaded / 1024 / 1024).toFixed(1)} MB /
|
||
{(downloadProgress.total / 1024 / 1024).toFixed(1)} MB)
|
||
</div>
|
||
</div>
|
||
)}
|
||
|
||
<div className="flex justify-end gap-2">
|
||
{!downloading && !installing && (
|
||
<>
|
||
{!isMandatory && (
|
||
<Button variant="outline" onClick={dismissUpdate}>
|
||
稍后
|
||
</Button>
|
||
)}
|
||
<Button onClick={downloadUpdate}>
|
||
立即更新
|
||
</Button>
|
||
</>
|
||
)}
|
||
|
||
{!checking && !downloading && installing && (
|
||
<Button onClick={installUpdate} disabled>
|
||
安装中...
|
||
</Button>
|
||
)}
|
||
|
||
{downloading && (
|
||
<Button variant="outline" disabled>
|
||
取消
|
||
</Button>
|
||
)}
|
||
</div>
|
||
|
||
{isMandatory && !installing && !downloading && (
|
||
<div className="text-sm text-orange-500 text-center">
|
||
此版本为强制更新，必须安装后才能继续使用
|
||
</div>
|
||
)}
|
||
</>
|
||
)}
|
||
</div>
|
||
</DialogContent>
|
||
</Dialog>
|
||
);
|
||
}
|
||
```
|
||
|
||
### 5.3 设置页面集成
|
||
|
||
在设置页面添加手动检查更新按钮：
|
||
|
||
```tsx
|
||
import { useUpdateStore } from '@/store/updateStore';
|
||
import { Button } from '@/components/ui/button';
|
||
|
||
function SettingsPage() {
|
||
const { checkUpdate, updateAvailable, updateInfo } = useUpdateStore();
|
||
|
||
const CURRENT_VERSION = import.meta.env.VITE_APP_VERSION || '0.1.0';
|
||
|
||
return (
|
||
<div className="space-y-6">
|
||
<div className="flex items-center justify-between">
|
||
<div>
|
||
<h3 className="text-lg font-semibold">应用更新</h3>
|
||
<p className="text-sm text-muted-foreground">
|
||
当前版本：{CURRENT_VERSION}
|
||
</p>
|
||
</div>
|
||
<Button onClick={() => checkUpdate(CURRENT_VERSION)}>
|
||
检查更新
|
||
</Button>
|
||
</div>
|
||
|
||
{updateAvailable && updateInfo && (
|
||
<div className="rounded-lg border p-4">
|
||
<h4 className="font-semibold">发现新版本 {updateInfo.version}</h4>
|
||
<p className="text-sm text-muted-foreground mt-2">
|
||
{updateInfo.notes}
|
||
</p>
|
||
</div>
|
||
)}
|
||
</div>
|
||
);
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 六、七牛云集成
|
||
|
||
### 6.1 七牛云配置
|
||
|
||
在 `python-api/.env` 中添加：
|
||
|
||
```bash
|
||
# 七牛云配置
|
||
QINIU_ACCESS_KEY=your-access-key
|
||
QINIU_SECRET_KEY=your-secret-key
|
||
QINIU_BUCKET_NAME=meijiaka-releases
|
||
QINIU_BUCKET_DOMAIN=cdn.meijiaka.com
|
||
```
|
||
|
||
### 6.2 七牛云服务封装
|
||
|
||
文件位置：`python-api/app/services/qiniu_service.py`
|
||
|
||
```python
|
||
import os
|
||
import hashlib
|
||
from typing import Optional
|
||
from qiniu import Auth, BucketManager
|
||
|
||
class QiniuService:
|
||
"""七牛云服务封装"""
|
||
|
||
def __init__(self):
|
||
access_key = os.getenv('QINIU_ACCESS_KEY')
|
||
secret_key = os.getenv('QINIU_SECRET_KEY')
|
||
self.bucket_name = os.getenv('QINIU_BUCKET_NAME')
|
||
self.domain = os.getenv('QINIU_BUCKET_DOMAIN')
|
||
|
||
self.auth = Auth(access_key, secret_key)
|
||
self.bucket = BucketManager(self.auth)
|
||
|
||
def get_file_url(self, key: str) -> str:
|
||
"""获取文件访问 URL"""
|
||
return f"https://{self.domain}/{key}"
|
||
|
||
def upload_file(self, local_path: str, key: str) -> dict:
|
||
"""上传文件到七牛云"""
|
||
from qiniu import put_file_v2, etag
|
||
|
||
token = self.auth.upload_token(self.bucket_name, key, 3600)
|
||
ret, info = put_file_v2(token, key, local_path, version='v2')
|
||
|
||
if ret is None:
|
||
raise Exception(f"上传失败: {info}")
|
||
|
||
return {
|
||
"key": ret['key'],
|
||
"hash": ret['hash'],
|
||
"url": self.get_file_url(key)
|
||
}
|
||
|
||
def get_file_info(self, key: str) -> dict:
|
||
"""获取文件信息"""
|
||
ret, info = self.bucket.stat(self.bucket_name, key)
|
||
if ret is None:
|
||
raise Exception(f"获取文件信息失败: {info}")
|
||
return ret
|
||
|
||
def get_file_hash(self, local_path: str) -> str:
|
||
"""计算本地文件 SHA256 哈希"""
|
||
sha256_hash = hashlib.sha256()
|
||
with open(local_path, "rb") as f:
|
||
for byte_block in iter(lambda: f.read(4096), b""):
|
||
sha256_hash.update(byte_block)
|
||
return f"sha256:{sha256_hash.hexdigest()}"
|
||
|
||
# 全局单例
|
||
_qiniu_service: Optional[QiniuService] = None
|
||
|
||
def get_qiniu_service() -> QiniuService:
|
||
global _qiniu_service
|
||
if _qiniu_service is None:
|
||
_qiniu_service = QiniuService()
|
||
return _qiniu_service
|
||
```
|
||
|
||
---
|
||
|
||
## 七、部署流程
|
||
|
||
### 7.1 构建流程
|
||
|
||
```bash
|
||
# 1. 构建 Tauri 应用
|
||
cd tauri-app
|
||
npm run tauri build
|
||
|
||
# 2. 构建产物位置
|
||
# macOS: src-tauri/target/release/bundle/dmg/
|
||
# Windows: src-tauri/target/release/bundle/nsis/
|
||
# Linux: src-tauri/target/release/bundle/appimage/
|
||
```
|
||
|
||
### 7.2 上传到七牛云
|
||
|
||
文件位置：`python-api/scripts/upload_release.py`
|
||
|
||
```python
|
||
#!/usr/bin/env python3
|
||
"""
|
||
上传版本发布包到七牛云并创建版本发布记录
|
||
"""
|
||
|
||
import os
|
||
import sys
|
||
import argparse
|
||
import subprocess
|
||
from pathlib import Path
|
||
|
||
# 添加项目路径
|
||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||
|
||
from app.services.qiniu_service import get_qiniu_service
|
||
import httpx
|
||
|
||
def upload_package(local_path: str, version: str) -> dict:
|
||
"""上传单个安装包"""
|
||
qiniu = get_qiniu_service()
|
||
|
||
filename = Path(local_path).name
|
||
key = f"releases/{version}/{filename}"
|
||
|
||
# 计算哈希
|
||
file_hash = qiniu.get_file_hash(local_path)
|
||
|
||
# 上传
|
||
print(f"上传 {filename}...")
|
||
result = qiniu.upload_file(local_path, key)
|
||
|
||
# 获取文件信息
|
||
file_info = qiniu.get_file_info(key)
|
||
|
||
return {
|
||
"platform": filename.split('_')[2],
|
||
"architecture": filename.split('_')[3].split('.')[0],
|
||
"file_url": result['url'],
|
||
"file_size": file_info['fsize'],
|
||
"file_hash": file_hash
|
||
}
|
||
|
||
def create_release(version: str, notes: str, packages: list, mandatory: bool = False):
|
||
"""创建版本发布"""
|
||
api_url = "http://localhost:8080/api/v1/update/releases"
|
||
|
||
response = httpx.post(api_url, json={
|
||
"version": version,
|
||
"notes": notes,
|
||
"mandatory": mandatory,
|
||
"packages": packages
|
||
})
|
||
|
||
if response.status_code == 200:
|
||
print(f"版本 {version} 发布成功！")
|
||
return response.json()
|
||
else:
|
||
print(f"创建版本发布失败: {response.text}")
|
||
sys.exit(1)
|
||
|
||
def main():
|
||
parser = argparse.ArgumentParser(description="上传版本发布包")
|
||
parser.add_argument("--version", required=True, help="版本号 (如: 0.1.1)")
|
||
parser.add_argument("--notes", required=True, help="更新说明")
|
||
parser.add_argument("--mandatory", action="store_true", help="强制更新")
|
||
parser.add_argument("--path", required=True, help="构建产物目录")
|
||
|
||
args = parser.parse_args()
|
||
|
||
build_dir = Path(args.path)
|
||
|
||
# 查找所有安装包
|
||
packages = []
|
||
for file in build_dir.rglob("*"):
|
||
if file.suffix in ['.dmg', '.exe', '.AppImage']:
|
||
pkg_info = upload_package(str(file), args.version)
|
||
packages.append(pkg_info)
|
||
|
||
# 创建版本发布
|
||
create_release(args.version, args.notes, packages, args.mandatory)
|
||
|
||
if __name__ == "__main__":
|
||
main()
|
||
```
|
||
|
||
使用方式：
|
||
```bash
|
||
cd python-api
|
||
python scripts/upload_release.py \
|
||
--version 0.1.1 \
|
||
--notes "新功能：视频字幕压制\n修复：导出问题" \
|
||
--path ../tauri-app/src-tauri/target/release/bundle
|
||
```
|
||
|
||
### 7.3 GitHub Actions 自动化（多平台）
|
||
|
||
文件位置：`.github/workflows/release.yml`
|
||
|
||
```yaml
|
||
name: Release
|
||
|
||
on:
|
||
push:
|
||
tags:
|
||
- 'v*'
|
||
|
||
jobs:
|
||
# macOS 构建
|
||
build-macos:
|
||
runs-on: macos-latest
|
||
|
||
steps:
|
||
- uses: actions/checkout@v4
|
||
|
||
- name: Setup Python
|
||
uses: actions/setup-python@v5
|
||
with:
|
||
python-version: '3.13'
|
||
|
||
- name: Setup Node.js
|
||
uses: actions/setup-node@v4
|
||
with:
|
||
node-version: '20'
|
||
|
||
- name: Install Rust
|
||
uses: dtolnay/rust-toolchain@stable
|
||
with:
|
||
target: x86_64-apple-darwin
|
||
|
||
- name: Install Tauri CLI
|
||
run: cargo install tauri-cli --version "^2.0"
|
||
|
||
- name: Install Python dependencies
|
||
run: |
|
||
cd python-api
|
||
python -m venv venv
|
||
source venv/bin/activate
|
||
pip install -e ".[dev]"
|
||
pip install qiniu httpx
|
||
|
||
- name: Install Node dependencies
|
||
run: |
|
||
cd tauri-app
|
||
npm install
|
||
|
||
- name: Build Tauri app (macOS)
|
||
run: |
|
||
cd tauri-app
|
||
npm run tauri build --target x86_64-apple-darwin
|
||
|
||
- name: Upload artifacts
|
||
uses: actions/upload-artifact@v4
|
||
with:
|
||
name: macos-bundle
|
||
path: tauri-app/src-tauri/target/x86_64-apple-darwin/release/bundle/
|
||
retention-days: 1
|
||
|
||
# Windows 构建
|
||
build-windows:
|
||
runs-on: windows-latest
|
||
|
||
steps:
|
||
- uses: actions/checkout@v4
|
||
|
||
- name: Setup Python
|
||
uses: actions/setup-python@v5
|
||
with:
|
||
python-version: '3.13'
|
||
|
||
- name: Setup Node.js
|
||
uses: actions/setup-node@v4
|
||
with:
|
||
node-version: '20'
|
||
|
||
- name: Install Rust
|
||
uses: dtolnay/rust-toolchain@stable
|
||
with:
|
||
target: x86_64-pc-windows-msvc
|
||
|
||
- name: Install Tauri CLI
|
||
run: cargo install tauri-cli --version "^2.0"
|
||
|
||
- name: Install Python dependencies
|
||
run: |
|
||
cd python-api
|
||
python -m venv venv
|
||
venv\Scripts\pip install -e ".[dev]"
|
||
venv\Scripts\pip install qiniu httpx
|
||
|
||
- name: Install Node dependencies
|
||
run: |
|
||
cd tauri-app
|
||
npm install
|
||
|
||
- name: Build Tauri app (Windows)
|
||
)
|
||
run: |
|
||
cd tauri-app
|
||
npm run tauri build --target x86_64-pc-windows-msvc
|
||
|
||
- name: Upload artifacts
|
||
uses: actions/upload-artifact@v4
|
||
with:
|
||
name: windows-bundle
|
||
path: tauri-app/src-tauri/target/x86_64-pc-windows-msvc/release/bundle/
|
||
retention-days: 1
|
||
|
||
# Linux 构建
|
||
build-linux:
|
||
runs-on: ubuntu-latest
|
||
|
||
steps:
|
||
- uses: actions/checkout@v4
|
||
|
||
- name: Setup Python
|
||
uses: actions/setup-python@v5
|
||
with:
|
||
python-version: '3.13'
|
||
|
||
- name: Setup Node.js
|
||
uses: actions/setup-node@v4
|
||
with:
|
||
node-version: '20'
|
||
|
||
- name: Install Rust
|
||
uses: dtolnay/rust-toolchain@stable
|
||
with:
|
||
target: x86_64-unknown-linux-gnu
|
||
|
||
- name: Install Tauri CLI
|
||
run: cargo install tauri-cli --version "^2.0"
|
||
|
||
- name: Install Python dependencies
|
||
run: |
|
||
cd python-api
|
||
python -m venv venv
|
||
source venv/bin/activate
|
||
pip install -e ".[dev]"
|
||
pip install qiniu httpx
|
||
|
||
- name: Install Node dependencies
|
||
run: |
|
||
cd tauri-app
|
||
npm install
|
||
|
||
- name: Install Linux dependencies
|
||
run: |
|
||
sudo apt-get update
|
||
sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev
|
||
|
||
- name: Build Tauri app (Linux)
|
||
run: |
|
||
cd tauri-app
|
||
npm run tauri build --target x86_64-unknown-linux-gnu
|
||
|
||
- name: Upload artifacts
|
||
uses: actions/upload-artifact@v4
|
||
with:
|
||
name: linux-bundle
|
||
path: tauri-app/src-tauri/target/x86_64-unknown-linux-gnu/release/bundle/
|
||
retention-days: 1
|
||
|
||
# 统一发布
|
||
release:
|
||
needs: [build-macos, build-windows, build-linux]
|
||
runs-on: ubuntu-latest
|
||
|
||
steps:
|
||
- uses: actions/checkout@v4
|
||
|
||
- name: Setup Python
|
||
uses: actions/setup-python@v5
|
||
with:
|
||
python-version: '3.13'
|
||
|
||
- name: Download macOS artifacts
|
||
uses: actions/download-artifact@v4
|
||
with:
|
||
name: macos-bundle
|
||
path: bundle/macos
|
||
|
||
- name: Download Windows artifacts
|
||
uses: actions/download-artifact@v4
|
||
with:
|
||
name: windows-bundle
|
||
path: bundle/windows
|
||
|
||
- name: Download Linux artifacts
|
||
uses: actions/download-artifact@v4
|
||
with:
|
||
name: linux-bundle
|
||
path: bundle/linux
|
||
|
||
- name: Install Python dependencies
|
||
run: |
|
||
cd python-api
|
||
python -m venv venv
|
||
source venv/bin/activate
|
||
pip install -e ".[dev]"
|
||
pip install qiniu httpx
|
||
|
||
- name: Upload to Qiniu and create release
|
||
env:
|
||
QINIU_ACCESS_KEY: ${{ secrets.QINIU_ACCESS_KEY }}
|
||
QINIU_SECRET_KEY: ${{ secrets.QINIU_SECRET_KEY }}
|
||
QINIU_BUCKET_NAME: ${{ secrets.QINIU_BUCKET_NAME }}
|
||
QINIU_BUCKET_DOMAIN: ${{ secrets.QINIU_BUCKET_DOMAIN }}
|
||
run: |
|
||
VERSION=${GITHUB_REF#refs/tags/v}
|
||
cd python-api
|
||
source venv/bin/activate
|
||
|
||
# 上传所有平台的包
|
||
python scripts/upload_release.py \
|
||
--version $VERSION \
|
||
--notes "Release $VERSION" \
|
||
--path ../bundle
|
||
```
|
||
|
||
---
|
||
|
||
## 八、配置总结
|
||
|
||
### 8.1 功能配置
|
||
|
||
| 配置项 | 选择 |
|
||
|--------|------|
|
||
| OSS/COS 服务 | 七牛云 |
|
||
| 更新触发方式 | 启动时自动检查，需用户确认再下载 |
|
||
| 灰度发布 | 不需要 |
|
||
| 强制更新 | 需要 |
|
||
| 版本兼容性检查 | 不需要 |
|
||
| 更新检查频率 | 仅启动时 + 手动按钮 |
|
||
| 下载日志统计 | 需要 |
|
||
| macOS 安装位置 | ~/Applications（无需管理员） |
|
||
| 更新 UI 风格 | shadcn/ui 对话框 |
|
||
| 构建部署自动化 | 需要 |
|
||
|
||
### 8.2 环境变量
|
||
|
||
**后端 (.env)**:
|
||
```bash
|
||
# 七牛云配置
|
||
QINIU_ACCESS_KEY=your-access-key
|
||
QINIU_SECRET_KEY=your-secret-key
|
||
QINIU_BUCKET_NAME=meijiaka-releases
|
||
QINIU_BUCKET_DOMAIN=cdn.meijiaka.com
|
||
|
||
# FastAPI 配置
|
||
DATABASE_URL=postgresql+asyncpg://...
|
||
API_BASE_URL=http://localhost:8080
|
||
```
|
||
|
||
**前端**:
|
||
```bash
|
||
# 应用版本（在构建时注入）
|
||
VITE_APP_VERSION=0.1.0
|
||
```
|
||
|
||
### 8.3 文件清单
|
||
|
||
```
|
||
python-api/
|
||
├── app/
|
||
│ ├── models/
|
||
│ │ └── update.py # 数据模型
|
||
│ ├── schemas/
|
||
│ │ └── update.py # Pydantic schemas
|
||
│ ├── api/
|
||
│ │ └── v1/
|
||
│ │ └── update.py # API 路由
|
||
│ ├── services/
|
||
│ │ └── qiniu_service.py # 七牛云服务
|
||
│ └── main.py # 注册路由
|
||
├── scripts/
|
||
│ ├── init_update_tables.sql # 数据库初始化
|
||
│ └── upload_release.py # 上传和发布脚本
|
||
└── .env # 环境变量
|
||
|
||
tauri-app/
|
||
├── src/
|
||
│ ├── components/
|
||
│ │ └── UpdateDialog.tsx # 更新对话框
|
||
│ ├── store/
|
||
│ │ └── updateStore.ts # 更新状态管理
|
||
│ └── pages/
|
||
│ └── Settings.tsx # 设置页面集成
|
||
└── src-tauri/
|
||
├── src/
|
||
│ ├── updater.rs # Rust 更新模块
|
||
│ └── lib.rs # 命令注册
|
||
└── Cargo.toml # 依赖配置
|
||
|
||
.github/
|
||
└── workflows/
|
||
└── release.yml # 自动化发布
|
||
```
|
||
|
||
---
|
||
|
||
## 九、测试指南
|
||
|
||
### 9.1 本地测试
|
||
|
||
1. **初始化数据库**：
|
||
```bash
|
||
cd python-api
|
||
psql -h localhost -U postgres -d meijiaka -f scripts/init_update_tables.sql
|
||
```
|
||
|
||
2. **创建测试版本**：
|
||
```bash
|
||
curl -X POST http://localhost:8080/api/v1/update/releases \
|
||
-H "Content-Type: application/json" \
|
||
-d '{
|
||
"version": "0.1.1",
|
||
"notes": "测试版本",
|
||
"mandatory": false,
|
||
"packages": [
|
||
{
|
||
"platform": "darwin",
|
||
"architecture": "x86_64",
|
||
"file_url": "https://cdn.meijiaka.com/releases/test.dmg",
|
||
"file_size": 102400000,
|
||
"file_hash": "sha256:test123"
|
||
}
|
||
]
|
||
}'
|
||
```
|
||
|
||
3. **启动 Tauri 应用并测试更新流程**
|
||
|
||
### 9.2 测试检查清单
|
||
|
||
- [ ] 版本检查 API 返回正确信息
|
||
- [ ] 下载进度正确显示
|
||
- [ ] 文件哈希验证工作正常
|
||
- [ ] macOS 安装到 ~/Applications
|
||
- [ ] 安装后自动重启应用
|
||
- [ ] 强制更新无法跳过
|
||
- [ ] 下载日志正确记录
|
||
- [ ] 手动检查更新按钮工作
|
||
|
||
---
|
||
|
||
## 十、常见问题
|
||
|
||
### Q1: 如何处理更新失败？
|
||
|
||
**A**: Rust 后端会验证文件哈希，如果验证失败会删除损坏的文件并提示用户重试。建议实现重试机制，最多重试 3 次。
|
||
|
||
### Q2: 如何回滚版本？
|
||
|
||
**A**:
|
||
1. 发布上一个版本为最新
|
||
2. 或标记当前版本为不可用（修改 mandatory 和 notes）
|
||
|
||
```sql
|
||
-- 回滚到上一个版本
|
||
UPDATE app_releases
|
||
SET release_date = NOW()
|
||
WHERE version = '0.1.0';
|
||
```
|
||
|
||
### Q3: 如何处理网络中断？
|
||
|
||
**A**: Rust 下载器使用流式下载，支持断点续传。建议实现下载状态持久化，应用重启后继续下载。
|
||
|
||
### Q4: 如何测试更新流程？
|
||
|
||
**A**:
|
||
1. 修改前端当前版本为旧版本
|
||
2. 创建测试版本发布
|
||
3. 启动应用测试更新流程
|
||
4. 使用七牛云测试文件（不是真实安装包）
|
||
|
||
### Q5: macOS 安装需要权限吗？
|
||
|
||
**A**: 使用 ~/Applications 目录，用户权限即可，不需要管理员权限。
|
||
|
||
---
|
||
|
||
## 十一、错误处理与重试机制
|
||
|
||
### 11.1 下载重试机制
|
||
|
||
在 Rust 下载函数中添加重试逻辑：
|
||
|
||
```rust
|
||
use std::time::Duration;
|
||
|
||
#[tauri::command]
|
||
pub async fn download_update_with_retry(
|
||
app: AppHandle,
|
||
url: String,
|
||
file_hash: String,
|
||
expected_size: u64,
|
||
max_retries: u32,
|
||
) -> Result<String, String> {
|
||
let mut last_error = String::new();
|
||
|
||
for attempt in 0..max_retries {
|
||
match download_update_internal(&app, &url, &file_hash, expected_size).await {
|
||
Ok(path) => return Ok(path),
|
||
Err(e) => {
|
||
last_error = e.clone();
|
||
eprintln!("下载失败（尝试 {}/{}）：{}", attempt + 1, max_retries, e);
|
||
|
||
if attempt < max_retries - 1 {
|
||
// 指数退避
|
||
let delay = Duration::from_secs(2_u64.pow(attempt));
|
||
tokio::time::sleep(delay).await;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Err(format!("下载失败，已重试 {} 次：{}", max_retries, last_error))
|
||
}
|
||
|
||
async fn download_update_internal(
|
||
app: &AppHandle,
|
||
url: &str,
|
||
file_hash: &str,
|
||
expected_size: u64,
|
||
) -> Result<String, String> {
|
||
// 原有的下载逻辑
|
||
// ...
|
||
}
|
||
```
|
||
|
||
### 11.2 安装失败回滚
|
||
|
||
macOS 安装失败时自动回滚：
|
||
|
||
```rust
|
||
#[cfg(target_os = "macos")]
|
||
async fn install_macos(app: AppHandle, package_path: PathBuf) -> Result<(), String> {
|
||
use std::process::Command;
|
||
use std::thread;
|
||
use std::time::Duration;
|
||
|
||
let mount_dir = PathBuf::from("/tmp/meijiaka_mount");
|
||
let backup_path = PathBuf::from("/tmp/meijiaka_backup");
|
||
|
||
// 1. 挂载 DMG
|
||
if mount_dir.exists() {
|
||
let _ = Command::new("hdiutil")
|
||
.args(["detach", mount_dir.to_str().unwrap(), "-force"])
|
||
.status();
|
||
}
|
||
|
||
let output = Command::new("hdiutil")
|
||
.args([
|
||
"attach",
|
||
"-readonly",
|
||
"-nobrowse",
|
||
"-mountpoint",
|
||
mount_dir.to_str().unwrap(),
|
||
package_path.to_str().unwrap(),
|
||
])
|
||
.output()
|
||
.map_err(|e| format!("Failed to mount DMG: {}", e))?;
|
||
|
||
if !output.status.success() {
|
||
return Err(format!("Failed to mount DMG: {}",
|
||
String::from_utf8_lossy(output.stderr.as_slice())));
|
||
}
|
||
|
||
// 2. 查找应用文件
|
||
let app_path = find_app_in_dmg(&mount_dir)?;
|
||
let app_name = app_path.file_name()
|
||
.ok_or("Invalid app path")?
|
||
.to_string_lossy()
|
||
.to_string();
|
||
|
||
let dest_dir = dirs::home_dir()
|
||
.ok_or("Failed to get home directory")?
|
||
.join("Applications");
|
||
|
||
fs::create_dir_all(&dest_dir)
|
||
.map_err(|e| format!("Failed to create Applications dir: {}", e))?;
|
||
|
||
let dest_path = dest_dir.join(&app_name);
|
||
|
||
// 3. 备份旧版本
|
||
let backup_exists = dest_path.exists();
|
||
if backup_exists {
|
||
fs::create_dir_all(&backup_path)?;
|
||
let _ = Command::new("cp")
|
||
.args(["-R", dest_path.to_str().unwrap(), backup_path.to_str().unwrap()])
|
||
.status();
|
||
}
|
||
|
||
// 4. 删除旧版本
|
||
if dest_path.exists() {
|
||
let _ = Command::new("rm")
|
||
.args(["-rf", dest_path.to_str().unwrap()])
|
||
.status();
|
||
}
|
||
|
||
// 5. 复制新版本
|
||
let output = Command::new("cp")
|
||
.args(["-R", app_path.to_str().unwrap(), dest_dir.to_str().unwrap()])
|
||
.output()
|
||
.map_err(|e| format!("Failed to copy app: {}", e))?;
|
||
|
||
if !output.status.success() {
|
||
// 复制失败，恢复备份
|
||
if backup_exists {
|
||
eprintln!("安装失败，正在恢复旧版本...");
|
||
let _ = Command::new("cp")
|
||
.args(["-R",
|
||
backup_path.join(&app_name).to_str().unwrap(),
|
||
dest_dir.to_str().unwrap()])
|
||
.status();
|
||
let _ = Command::new("rm")
|
||
.args(["-rf", backup_path.to_str().unwrap()])
|
||
.status();
|
||
}
|
||
return Err("Failed to copy app".to_string());
|
||
}
|
||
|
||
// 6. 验证新版本
|
||
if !dest_path.exists() {
|
||
// 验证失败，恢复备份
|
||
if backup_exists {
|
||
eprintln!("验证失败，正在恢复旧版本...");
|
||
let _ = Command::new("cp")
|
||
.args(["-R",
|
||
backup_path.join(&app_name).to_str().unwrap(),
|
||
dest_dir.to_str().unwrap()])
|
||
.status();
|
||
}
|
||
return Err("New app not found after installation".to_string());
|
||
}
|
||
|
||
// 7. 清理备份
|
||
if backup_exists {
|
||
let _ = Command::new("rm")
|
||
.args(["-rf", backup_path.to_str().unwrap()])
|
||
.status();
|
||
}
|
||
|
||
// 8. 卸载 DMG
|
||
let _ = Command::new("hdiutil")
|
||
.args(["detach", mount_dir.to_str().unwrap(), "-force"])
|
||
.status();
|
||
|
||
// 9. 延迟启动新版本
|
||
thread::spawn(move || {
|
||
thread::sleep(Duration::from_secs(2));
|
||
let _ = Command::new("open")
|
||
.args(["-a", &app_name])
|
||
.status();
|
||
});
|
||
|
||
// 10. 退出当前应用
|
||
app.exit(0);
|
||
|
||
Ok(())
|
||
}
|
||
```
|
||
|
||
### 11.3 下载状态持久化
|
||
|
||
实现下载状态保存，应用重启后继续下载：
|
||
|
||
```rust
|
||
use serde::{Deserialize, Serialize};
|
||
use std::fs;
|
||
|
||
#[derive(Debug, Serialize, Deserialize)]
|
||
struct DownloadState {
|
||
url: String,
|
||
file_hash: String,
|
||
expected_size: u64,
|
||
downloaded: u64,
|
||
save_path: String,
|
||
}
|
||
|
||
fn save_download_state(app: &AppHandle, state: &DownloadState) -> Result<(), String> {
|
||
let cache_dir = app.path().app_cache_dir()?;
|
||
let state_file = cache_dir.join("updates/download_state.json");
|
||
|
||
let json = serde_json::to_string_pretty(state)
|
||
.map_err(|e| format!("Failed to serialize state: {}", e))?;
|
||
|
||
fs::write(&state_file, json)
|
||
.map_err(|e| format!("Failed to save state: {}", e))
|
||
}
|
||
|
||
fn load_download_state(app: &AppHandle) -> Result<Option<DownloadState>, String> {
|
||
let cache_dir = app.path().app_cache_dir()?;
|
||
let state_file = cache_dir.join("updates/download_state.json");
|
||
|
||
if !state_file.exists() {
|
||
return Ok(None);
|
||
}
|
||
|
||
let content = fs::read_to_string(&state_file)
|
||
.map_err(|e| format!("Failed to read state: {}", e))?;
|
||
|
||
let state: DownloadState = serde_json::from_str(&content)
|
||
.map_err(|e| format!("Failed to parse state: {}", e))?;
|
||
|
||
Ok(Some(state))
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 十二、安全性最佳实践
|
||
|
||
### 12.1 强制 HTTPS
|
||
|
||
在 FastAPI 中强制使用 HTTPS：
|
||
|
||
```python
|
||
from fastapi.middleware.httpsredirect import HTTPSRedirectMiddleware
|
||
|
||
# 在生产环境强制 HTTPS
|
||
if not os.getenv("DEBUG"):
|
||
app.add_middleware(HTTPSRedirectMiddleware)
|
||
```
|
||
|
||
### 12.2 API 速率限制
|
||
|
||
使用 slowapi 实现速率限制：
|
||
|
||
```python
|
||
from slowapi import Limiter, _rate_limit_exceeded_handler
|
||
from slowapi.util import get_remote_address
|
||
from slowapi.errors import RateLimitExceeded
|
||
|
||
# 配置速率限制
|
||
limiter = Limiter(
|
||
key_func=get_remote_address,
|
||
default_limits=["200/minute"],
|
||
storage_uri="redis://localhost:6379/1"
|
||
)
|
||
|
||
app.state.limiter = limiter
|
||
|
||
# 在检查更新接口添加速率限制
|
||
@router.post("/check", response_model=UpdateInfoResponse)
|
||
@limiter.limit("10/minute") # 每分钟最多 10 次检查
|
||
async def check_update(
|
||
request: UpdateCheckRequest,
|
||
db: AsyncSession = Depends(get_db)
|
||
):
|
||
# ...
|
||
```
|
||
|
||
### 12.3 文件签名验证
|
||
|
||
添加 HMAC 签名验证：
|
||
|
||
```python
|
||
import hmac
|
||
import hashlib
|
||
from fastapi import Header, HTTPException
|
||
|
||
def verify_file_signature(
|
||
file_path: str,
|
||
expected_signature: str,
|
||
secret: str
|
||
) -> bool:
|
||
"""验证文件签名"""
|
||
with open(file_path, 'rb') as f:
|
||
file_hash = hashlib.sha256(f.read()).hexdigest()
|
||
|
||
signature = hmac.new(
|
||
secret.encode(),
|
||
file_hash.encode(),
|
||
hashlib.sha256
|
||
).hexdigest()
|
||
|
||
return hmac.compare_digest(signature, expected_signature)
|
||
```
|
||
|
||
### 12.4 CORS 配置
|
||
|
||
严格配置 CORS：
|
||
|
||
```python
|
||
from fastapi.middleware.cors import CORSMiddleware
|
||
|
||
app.add_middleware(
|
||
CORSMiddleware,
|
||
allow_origins=[
|
||
"tauri://localhost", # Tauri 开发环境
|
||
"http://localhost:1420", # Vite 开发服务器
|
||
"https://yourdomain.com", # 生产域名
|
||
],
|
||
allow_credentials=True,
|
||
allow_methods=["GET", "POST"],
|
||
allow_headers=["*"],
|
||
)
|
||
```
|
||
|
||
### 12.5 环境变量验证
|
||
|
||
在启动时验证必需的环境变量：
|
||
|
||
```python
|
||
import os
|
||
|
||
def validate_env_vars():
|
||
"""验证环境变量"""
|
||
required_vars = [
|
||
"DATABASE_URL",
|
||
"QINIU_ACCESS_KEY",
|
||
"QINIU_SECRET_KEY",
|
||
"QINIU_BUCKET_NAME",
|
||
"QINIU_BUCKET_DOMAIN",
|
||
]
|
||
|
||
missing = [var for var in required_vars if not os.getenv(var)]
|
||
if missing:
|
||
raise RuntimeError(f"缺少必需的环境变量: {', '.join(missing)}")
|
||
|
||
# 在应用启动时调用
|
||
validate_env_vars()
|
||
```
|
||
|
||
### 12.6 敏感信息不记录
|
||
|
||
确保日志中不包含敏感信息：
|
||
|
||
```python
|
||
import logging
|
||
|
||
# 配置日志过滤器
|
||
class SensitiveDataFilter(logging.Filter):
|
||
"""过滤敏感数据"""
|
||
|
||
SENSITIVE_KEYWORDS = ["access_key", "secret_key", "password", "token"]
|
||
|
||
def filter(self, record):
|
||
msg = record.getMessage().lower()
|
||
if any(keyword in msg for keyword in self.SENSITIVE_KEYWORDS):
|
||
return False
|
||
return True
|
||
|
||
# 添加过滤器
|
||
logging.getLogger().addFilter(SensitiveDataFilter())
|
||
```
|
||
|
||
---
|
||
|
||
## 十三、参考资料
|
||
|
||
- [Tauri 更新插件文档](https://v2.tauri.app/plugin/updater/)
|
||
- [七牛云 Python SDK](https://developer.qiniu.com/kodo/1242/python)
|
||
- [语义化版本规范](https://semver.org/lang/zh-CN/)
|
||
- [FastAPI 官方文档](https://fastapi.tiangolo.com/zh/)
|
||
- [FastAPI 安全最佳实践](https://fastapi.tiangolo.com/tutorial/security/)
|