一、什么是 Monorepo？#
Monorepo = Mono（单一）+ Repo（仓库）
将组织内所有的代码放在同一个版本控制仓库中管理。
Monorepo vs Polyrepo 对比#
┌─────────────────────────────────────────────────────────────────────────────┐
│ Polyrepo（传统多仓库模式） Monorepo（单一仓库模式） │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────────────────────────────┐│
│ │ repo-A │ │ repo-B │ │ repo-C │ │ mega-repo ││
│ │ 前端 │ │ 后端 │ │ 公共库 │ │ ┌───────────────────────────┐ ││
│ │ .git │ │ .git │ │ .git │ │ │ frontend/ │ ││
│ └─────────┘ └─────────┘ └─────────┘ │ │ backend/ │ ││
│ │ │ libs/common/ │ ││
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ services/auth/ │ ││
│ │ repo-D │ │ repo-E │ │ repo-F │ │ │ services/payment/ │ ││
│ │ 认证 │ │ 支付 │ │ 工具库 │ │ │ tools/ │ ││
│ │ .git │ │ .git │ │ .git │ │ └───────────────────────────┘ ││
│ └─────────┘ └─────────┘ └─────────┘ │ .git (唯一) ││
│ └─────────────────────────────────┘│
│ 每个项目独立的 Git 仓库 所有项目在同一个 Git 仓库 │
└─────────────────────────────────────────────────────────────────────────────┘二、Monorepo 要解决什么问题？#
Polyrepo（多仓库）模式在实践中会遇到一系列痛点：
1. 依赖地狱 (Dependency Hell)#
repo-A (前端) repo-B (后端) repo-C (公共库)
├── package.json ├── go.mod ├── common v1.0
│ common: "^1.0" │ common v1.2 │
│ │ │
└── 使用 v1.0 └── 使用 v1.2 └── 最新是 v2.0
😱 问题: 每个仓库依赖不同版本，升级公共库要协调多个团队
"先升级 C，再升级 B，最后升级 A" ← 顺序错了就炸2. 跨仓库修改困难#
场景：修改一个 API 接口，需要同时改前端和后端
Polyrepo 流程：
- 在 repo-B 创建分支，修改后端 API
- 提交 PR，等待 review，合并
- 发布新版本 v1.2.3
- 在 repo-A 创建分支，升级依赖到 v1.2.3
- 修改前端代码适配新 API
- 提交 PR，等待 review，合并
- 部署…
😱 一个简单的改动需要跨 2 个仓库、2 次 PR、2 次 review
3. 代码复用困难#
团队 A: "我写了一个很好用的日志库"
团队 B: "在哪？我怎么用？"
团队 A: "在 repo-X 里，你需要配置私有 npm registry..."
团队 B: "太麻烦了，我自己写一个吧"
结果: 组织内出现 N 个功能重复的日志库 😱4. 工具链和标准不统一#
| 仓库 | Lint | 格式化 | 测试框架 |
|---|---|---|---|
| repo-A | ESLint | Prettier | Jest |
| repo-B | TSLint | 无 | Mocha |
| repo-C | 无 | 无 | 无 |
每个仓库各自为政，代码质量参差不齐。
5. 原子提交不可能#
需求：“重命名 User 为 Account，涉及 10 个服务”
- Polyrepo：需要 10 个 PR，10 次 review，必须按顺序合并。中间状态系统不可用，出错回滚困难。
- Monorepo：1 个 PR，1 次 review，原子提交。要么全部生效，要么全部回滚 ✅
三、Monorepo 的优势#
| 优势 | 说明 |
|---|---|
| 统一版本，无依赖地狱 | 所有代码在同一仓库，总是使用最新版本。修改公共库 → 自动影响所有使用者 → CI 立即告诉你哪里坏了 |
| 原子提交，跨项目修改简单 | 一个 commit 可以同时修改前端 + 后端 + 公共库。一个 PR，一次 review，一次部署 |
| 代码可见性，促进复用 | 所有代码在同一个地方，搜索即可发现。“有人写过这个功能吗？” → grep 一下就知道 |
| 统一工具链和标准 | 根目录统一配置 eslint.config.js, tsconfig.json, CI/CD。所有项目自动继承，保证一致性 |
| 简化团队协作 | 新人 onboarding：clone 一个仓库，所有代码都有了。跨团队协作：直接改代码，不需要等对方发版 |
四、为什么 Monorepo 需要”Google 级别的基础设施”？#
这是关键问题。Monorepo 理念很美好，但实现起来有严重的技术挑战：
挑战 1：仓库体积爆炸 💥#
| 公司 | 规模 |
|---|---|
| Google Piper | ~86 TB 代码，20 亿行，3500 万次提交 |
| Microsoft | ~300 GB (Windows 仓库) |
传统 Git 的问题：
$ git clone mega-repo
Cloning into 'mega-repo'...
Receiving objects: 100% (50000000/50000000), 50.00 GiB | 10.00 MiB/s
... 等待 1.5 小时 ...
$ git status
... 等待 30 秒 ... (扫描数百万文件)
$ git log
... 等待 10 秒 ... (遍历数千万提交)😱 Git 在设计时没考虑这种规模，完全不可用
挑战 2：必须 clone 整个仓库#
开发者: "我只想改 frontend/button.tsx，为什么要下载 50 GB？"
Git 的设计: 仓库是一个整体，要么全有，要么全无
(sparse-checkout 只是不显示文件，数据还是要下载)挑战 3：CI/CD 时间爆炸#
场景：修改了 libs/common/utils.ts
天真的 CI: "common 改了，重新构建所有依赖它的 100 个项目"
→ 构建时间: 4 小时
需要: 智能的增量构建 + 依赖分析 + 分布式构建 + 远程缓存挑战 4：权限控制#
- Git 权限：仓库级别（要么能访问整个仓库，要么不能）
- 现实需求：
- 财务代码只有财务团队能看
- 安全相关代码只有安全团队能改
- 实习生不能碰生产配置
需要：文件夹/文件级别的细粒度权限控制
五、Google 的解决方案 vs 普通团队的困境#
Google 的解决方案#
| 组件 | 功能 |
|---|---|
| Piper (版本控制) | 自研的集中式版本控制系统（不是 Git），服务端存储，客户端只下载需要的文件 |
| CitC (Clients in the Cloud) | 云端虚拟文件系统。开发者的 workspace 在云端，本地只是一个薄客户端。修改的文件按需同步，不需要 clone |
| Blaze/Bazel (构建系统) | 增量构建，只构建真正改变的部分。分布式构建，数千台机器并行。远程缓存，相同输入直接复用结果 |
| Critique (代码审查) | 支持超大规模的 code review 工具 |
| 基础设施 | 数万台服务器 |
普通团队的困境#
“我们想用 Monorepo，但是…”
- ❌ Git 在大仓库下太慢
- ❌ 没有云端 workspace，必须 clone 整个仓库
- ❌ GitHub/GitLab 不支持文件级权限
- ❌ 没有分布式构建集群
- ❌ 没有智能的增量 CI
结果：仓库一大就卡死，只能拆分成多个仓库 → 回到 Polyrepo 😢
六、Mega 如何填补这个空白#
Mega ↗ 是一个开源项目，旨在为普通团队提供类似 Google Piper 的能力：
| 能力 | Google Piper | Mega |
|---|---|---|
| 版本控制 | Piper (自研) | Mega Server (Git 兼容)，服务端存储，支持标准 Git 协议 |
| 虚拟文件系统 | CitC (云端 workspace) | Scorpio (FUSE)，将 Monorepo 挂载为本地文件系统，按需加载，不需要 clone |
| 构建系统 | Blaze/Bazel | Buck2 集成，Meta 开源的构建系统，增量构建 + 远程缓存 |
| 权限控制 | 内部 ACL 系统 | Saturn (Cedar Policy)，基于 AWS Cedar 的策略引擎，文件/目录级别的细粒度权限 |
| 开源 | ❌ 不开源 | ✅ 完全开源 |
| 自托管 | ❌ 只能在 Google 内部 | ✅ 可以自己部署 |
| Git 兼容 | ❌ 完全不同的协议 | ✅ 使用标准 Git 命令 |
七、总结#
| 问题 | 答案 |
|---|---|
| 什么是 Monorepo? | 将所有代码放在单一仓库中管理的实践 |
| 解决什么问题? | 依赖管理混乱、跨项目修改困难、代码复用低、标准不统一 |
| 为什么需要特殊基础设施? | Git 在设计时没考虑超大仓库：必须 clone 整个仓库（太大）、大仓库下所有操作都很慢、没有文件级权限控制、需要智能的增量构建系统 |
| Mega 的价值? | 开源的 Google Piper 替代品：Scorpio FUSE 按需加载、Git 兼容无学习成本、Cedar 细粒度权限、Buck2 高效构建、可自托管 |
一句话：Mega 让没有 Google 级别资源的团队，也能享受 Monorepo 的好处。
八、Mega 系统架构深度解析#
下面我们深入 Mega 的技术架构，看看它是如何实现 “开源版 Google Piper” 的。
8.1 整体架构总览#
┌─────────────────────────────────────────────────────────────────────────────────────────┐
│ MEGA 系统架构 │
│ (Monorepo & Monolithic Codebase Management) │
│ Google Piper 的开源实现 │
├─────────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ Client Layer 客户端层 │ │
│ ├─────────────────────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │ │
│ │ │ Git CLI │ │ Moon │ │ Scorpio │ │ IDE/Editor │ │ │
│ │ │ (git push │ │ (Web UI) │ │ (FUSE FS) │ │ (VSCode, etc.) │ │ │
│ │ │ git pull) │ │ React/TS │ │ 挂载 Mono │ │ │ │ │
│ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └─────────┬───────────┘ │ │
│ │ │ │ │ │ │ │
│ └─────────┼─────────────────┼─────────────────┼───────────────────┼──────────────┘ │
│ │ │ │ │ │
│ │ SSH/HTTP │ HTTP REST │ HTTP REST │ HTTP/Git │
│ │ Git Protocol │ API │ API │ Protocol │
│ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ Gateway Layer 网关层 (Mono) │ │
│ ├─────────────────────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ mono (Main Binary) │ │ │
│ │ │ ┌───────────────┐ ┌───────────────┐ ┌───────────────────────────┐ │ │ │
│ │ │ │ HTTP Server │ │ SSH Server │ │ REST API Router │ │ │ │
│ │ │ │ (Axum) │ │ (Russh) │ │ /api/v1/repo/* │ │ │ │
│ │ │ │ :8000 │ │ :8100 │ │ /api/v1/cl/* │ │ │ │
│ │ │ └───────────────┘ └───────────────┘ │ /api/v1/issue/* │ │ │ │
│ │ │ │ /api/v1/lfs/* │ │ │ │
│ │ │ ┌───────────────────────────────────┐ │ /api/v1/user/* │ │ │ │
│ │ │ │ Git Protocol Handler │ └───────────────────────────┘ │ │ │
│ │ │ │ git-upload-pack / receive-pack │ │ │ │
│ │ │ └───────────────────────────────────┘ │ │ │
│ │ └─────────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ Core Services Layer 核心服务层 │ │
│ ├─────────────────────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │ │
│ │ │ Ceres │ │ Vault │ │ Saturn │ │ Context │ │ │
│ │ │ Git 业务 │ │ 密钥管理 │ │ 权限控制 │ │ 请求上下文管理 │ │ │
│ │ │ API Service│ │ GPG/Sign │ │ Cedar │ │ │ │ │
│ │ │ Pack处理 │ │ Crypto │ │ Policy │ │ │ │ │
│ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └─────────────────────────┘ │ │
│ │ │ │ │ │ │
│ └─────────┼────────────────┼────────────────┼─────────────────────────────────────┘ │
│ │ │ │ │
│ └────────────────┴────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ Data Access Layer 数据访问层 │ │
│ ├─────────────────────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Jupiter (Storage & ORM) │ │ │
│ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │
│ │ │ │ git_db_stg │ │ mono_stg │ │ lfs_db_stg │ │ user_stg │ │ │ │
│ │ │ │ raw_db_stg │ │ cl_stg │ │ lfs_s3_stg │ │ vault_stg │ │ │ │
│ │ │ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────────────────────────────────────────────────────────┐ │ │ │
│ │ │ │ Callisto (Entity Models - SeaORM) │ │ │ │
│ │ │ │ mega_commit, mega_tree, mega_blob, mega_cl, mega_issue... │ │ │ │
│ │ │ └─────────────────────────────────────────────────────────────────┘ │ │ │
│ │ └─────────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ Storage Layer 存储层 │ │
│ ├─────────────────────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────────────────┐ │ │
│ │ │ PostgreSQL │ │ Redis │ │ AWS S3 / Local │ │ │
│ │ │ (主数据库) │ │ (缓存/锁) │ │ (LFS 对象存储) │ │ │
│ │ └─────────────────┘ └─────────────────┘ └─────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────────┘分层解读：
- Client Layer - 支持多种客户端接入：标准 Git CLI、Moon Web UI、Scorpio FUSE 挂载、IDE 插件
- Gateway Layer -
mono主程序作为统一入口，处理 HTTP/SSH/Git 协议 - Core Services Layer - 核心业务逻辑：Ceres (Git 操作)、Vault (密钥)、Saturn (权限)、Context (上下文)
- Data Access Layer - Jupiter 统一数据访问，Callisto 定义 ORM 实体
- Storage Layer - PostgreSQL 主存储 + Redis 缓存 + S3/本地 LFS 存储
8.2 Crate 依赖关系#
┌──────────────────────────────────────────────────────────────────────────────────────────┐
│ Mega Crate 依赖关系 │
└──────────────────────────────────────────────────────────────────────────────────────────┘
┌──────────────┐
│ mono │ ← 主入口 (HTTP/SSH Server)
│ (binary) │
└──────┬───────┘
│
┌─────────────────────────────┼─────────────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ context │ │ ceres │ │ vault │
│ 请求上下文 │ │ Git业务层 │ │ 密钥管理 │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │
│ ┌──────────────────┼──────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ bellatrix │ │ common │ │ saturn │ │
│ │ Orion协议 │ │ 公共工具 │ │ 权限策略 │ │
│ └─────────────┘ └──────┬──────┘ │ (Cedar) │ │
│ │ └─────────────┘ │
│ │ │
└────────────────────────────┼────────────────────────────┘
│
▼
┌─────────────┐
│ jupiter │ ← 数据访问核心
│ Storage & │
│ ORM │
└──────┬──────┘
│
┌──────────────────┼──────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ callisto │ │ git-internal│ │ libvault- │
│ DB Entity │ │ Git 对象 │ │ core │
│ (SeaORM) │ │ 解析库 │ │ 加密核心 │
└─────────────┘ └─────────────┘ └─────────────┘
│
▼
┌─────────────┐
│ PostgreSQL │
│ SeaORM │
└─────────────┘
═══════════════════════════════════════════════════════════════════════════════════════════
独立组件 (不在主依赖链中)
┌─────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ scorpio │ │ orion-server │ │ extensions │
│ FUSE 客户端 │ │ 构建执行服务 │ │ 扩展功能 │
│ (独立进程) │ │ │ │ │
└──────┬──────┘ └────────┬────────┘ └────────┬────────┘
│ │ │
│ │ │
┌──────┴──────┐ ┌──────┴──────┐ ┌───────┴───────┐
│ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼
┌───────┐ ┌─────────┐ ┌───────┐ ┌───────────┐ ┌─────────┐ ┌─────────┐
│rfuse3 │ │libfuse │ │ orion │ │ bellatrix │ │ RAG │ │ Rust │
│ │ │ -fs │ │Client │ │ │ │ AI检索 │ │ 安全分析│
└───────┘ └─────────┘ └───────┘ └───────────┘ └─────────┘ └─────────┘依赖层次：
- mono - 最上层的二进制入口，组装所有服务
- ceres/vault/context - 核心业务模块，直接被 mono 调用
- jupiter - 数据访问抽象层，被所有需要持久化的模块依赖
- callisto/git-internal - 最底层的实体定义和 Git 对象解析
8.3 各 Crate 职责详解#
┌────────────────────────────────────────────────────────────────────────────────────────┐
│ Crate 职责说明 │
├────────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🚀 mono (主程序入口) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • HTTP Server (Axum) - 提供 REST API │ │ │
│ │ │ • SSH Server (Russh) - 提供 Git SSH 协议 │ │ │
│ │ │ • Git Protocol Handler - 处理 git push/pull/fetch │ │ │
│ │ │ • API Routes - CL/Issue/Commit/LFS/User/Repo 等接口 │ │ │
│ │ │ • OAuth Integration - GitHub/GitLab OAuth 登录 │ │ │
│ │ │ • Swagger UI - API 文档 (utoipa) │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 📦 ceres (Git 业务核心) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • API Service - Mono API 业务逻辑实现 │ │ │
│ │ │ • Pack Processing - Git pack 文件解析与处理 │ │ │
│ │ │ • Protocol - Smart HTTP/SSH Git 协议实现 │ │ │
│ │ │ • LFS Handler - Git LFS 协议支持 │ │ │
│ │ │ • Merge Checker - CL 合并检查 (代码审查/GPG签名/提交信息) │ │ │
│ │ │ • Model - 业务模型 (CL, Issue, Commit, Blame, Tag...) │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 💾 jupiter (数据访问层) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • Storage Modules: │ │ │
│ │ │ - git_db_storage - Git 对象存储 (commit/tree/blob) │ │ │
│ │ │ - mono_storage - Monorepo 特有数据 │ │ │
│ │ │ - cl_storage - Change List 存储 │ │ │
│ │ │ - issue_storage - Issue 存储 │ │ │
│ │ │ - lfs_db_storage - LFS 元数据 │ │ │
│ │ │ - vault_storage - 密钥存储 │ │ │
│ │ │ • LFS Storage - 本地/S3 大文件存储 │ │ │
│ │ │ • Migration - 数据库迁移脚本 (SeaORM) │ │ │
│ │ │ • Redis - 分布式锁与缓存 │ │ │
│ │ │ • Service - CL/Issue/MergeQueue 服务 │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 📊 callisto (实体模型) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • SeaORM Entity 定义: │ │ │
│ │ │ - mega_commit, mega_tree, mega_blob, mega_tag │ │ │
│ │ │ - mega_cl (Change List), mega_issue, mega_conversation │ │ │
│ │ │ - mega_user, mega_cl_reviewer, mega_label │ │ │
│ │ │ - lfs_locks, lfs_objects │ │ │
│ │ │ - vault_key, gpg_key │ │ │
│ │ │ - merge_queue, builds, tasks, checks │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🔐 vault (密钥管理) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • GPG Key Management - GPG 密钥存储与验证 │ │ │
│ │ │ • Commit Signing - 提交签名验证 │ │ │
│ │ │ • Crypto Operations - secp256k1/ed25519 加密操作 │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🛡️ saturn (权限控制) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • Cedar Policy Engine - 基于 AWS Cedar 的策略引擎 │ │ │
│ │ │ • Access Control - 仓库/分支/CL 的访问控制 │ │ │
│ │ │ • Policy Evaluation - 权限策略评估 │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🔧 common (公共工具) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • Config - 配置文件加载 (config crate) │ │ │
│ │ │ • Error Types - 公共错误类型 │ │ │
│ │ │ • Utils - ID 生成器、正则等工具函数 │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🌐 context (请求上下文) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • Request Context - HTTP 请求上下文管理 │ │ │
│ │ │ • User Session - 用户会话信息 │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────────────────────────┘8.4 独立子系统#
┌────────────────────────────────────────────────────────────────────────────────────────┐
│ 独立子系统 │
├────────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🦂 Scorpio (FUSE 文件系统客户端) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 独立进程，将 Monorepo 挂载为本地文件系统 │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │
│ │ │ │ MegaFuse │ │ Dicfuse │ │ OverlayFs │ │ Daemon │ │ │ │
│ │ │ │ FUSE核心 │ │ 虚拟只读层 │ │ 读写工作层 │ │ HTTP API │ │ │ │
│ │ │ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │
│ │ │ │ │ │
│ │ │ 功能: 挂载/卸载、文件读写、Git 操作 (status/add/commit/push) │ │ │
│ │ │ 依赖: rfuse3, libfuse-fs, ceres │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🌟 Orion (构建执行系统) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 类似 GitHub Actions 的 CI/CD 执行引擎 │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────────┐ ┌─────────────────────────────┐ │ │ │
│ │ │ │ orion (Client) │◄────────────►│ orion-server │ │ │ │
│ │ │ │ WebSocket连接 │ │ 任务调度与管理 │ │ │ │
│ │ │ │ 任务执行 │ │ 结果存储 │ │ │ │
│ │ │ └─────────────────┘ └─────────────────────────────┘ │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────────────────────────────────────────────────────┐ │ │ │
│ │ │ │ bellatrix (协议层) │ │ │ │
│ │ │ │ Client-Server 通信协议定义 │ │ │ │
│ │ │ └─────────────────────────────────────────────────────────────┘ │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🌙 Moon (Web 前端) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ React + TypeScript + pnpm monorepo │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────────────┐ │ │ │
│ │ │ │ apps │ │ packages │ │ api │ │ │ │
│ │ │ │ Web 应用 │ │ UI 组件库 │ │ API 客户端 │ │ │ │
│ │ │ └─────────────┘ └─────────────┘ └─────────────────────────────────┘ │ │ │
│ │ │ │ │ │
│ │ │ 构建工具: Turbo (monorepo 构建) │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ 🧩 Extensions (扩展功能) │ │
│ │ ┌────────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────────┐ ┌─────────────────┐ ┌───────────────────────┐ │ │ │
│ │ │ │ RAG (AI) │ │ Observatory │ │ Rust Security │ │ │ │
│ │ │ │ ┌───────────┐ │ │ │ │ ┌─────────────────┐ │ │ │ │
│ │ │ │ │ chat │ │ │ 代码可观测 │ │ │ sensleak │ │ │ │ │
│ │ │ │ │ index │ │ │ 性分析 │ │ │ CVE 分析 │ │ │ │ │
│ │ │ │ └───────────┘ │ │ │ │ │ MIR checker │ │ │ │ │
│ │ │ │ 向量检索/问答 │ │ │ │ └─────────────────┘ │ │ │ │
│ │ │ └─────────────────┘ └─────────────────┘ └───────────────────────┘ │ │ │
│ │ │ │ │ │
│ │ └────────────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────────────────────────┘关键子系统说明：
| 子系统 | 类比 | 核心功能 |
|---|---|---|
| Scorpio | Google CitC | 将超大仓库挂载为本地文件系统，按需加载，无需完整 clone |
| Orion | GitHub Actions | 分布式 CI/CD 任务执行，支持构建/测试自动化 |
| Moon | GitHub Web UI | 现代化 Web 界面，支持 CL/Issue/代码浏览 |
| Extensions | - | AI 辅助 (RAG)、安全扫描、代码分析等增值功能 |
8.5 核心数据流#
Git Push 流程#
┌─────────────┐ ┌─────────────┐
│ Developer │ │ PostgreSQL │
│ (git) │ │ (Storage) │
└──────┬──────┘ └──────▲──────┘
│ │
│ 1. git push │
▼ │
┌─────────────┐ 2. Git Protocol ┌─────────────┐ │
│ mono │ ◄────────────────────►│ ceres │──────────────┘
│ HTTP/SSH │ git-receive-pack │ Pack处理 │ 4. Store Objects
│ Server │ │ 协议解析 │
└──────┬──────┘ └──────┬──────┘
│ │
│ │ 3. Parse Pack
│ ▼
│ ┌─────────────┐
│ │ jupiter │
│ │ Storage │
│ └─────────────┘
│
│ 5. Trigger CI (optional)
▼
┌─────────────┐ ┌─────────────┐
│ orion │ ◄────────────────────►│orion-server │
│ Client │ WebSocket │ CI/CD │
└─────────────┘ └─────────────┘流程说明：
- 开发者执行
git push - mono 服务器接收 Git 协议请求，调用 ceres 处理
- ceres 解析 pack 文件，提取 Git 对象
- jupiter 将对象持久化到 PostgreSQL
- (可选) 触发 Orion CI 执行构建任务
Scorpio FUSE 流程#
┌─────────────┐ ┌─────────────┐
│ Developer │ │ mono │
│ (ls, cat) │ │ Server │
└──────┬──────┘ └──────▲──────┘
│ │
│ 1. File Operation │
▼ │
┌─────────────┐ 2. FUSE Callback ┌─────────────┐ │
│ Mount │ ◄────────────────────►│ Scorpio │──────────────┘
│ Point │ │ MegaFuse │ 4. HTTP API
│ /workspace │ │ │ (if needed)
└─────────────┘ └──────┬──────┘
│
│ 3. Local Cache
▼
┌─────────────┐
│ Store │
│ (Local) │
└─────────────┘流程说明：
- 开发者在挂载点执行文件操作 (
ls,cat,vim等) - FUSE 拦截系统调用，转发给 Scorpio
- Scorpio 检查本地缓存
- 如缓存未命中，通过 HTTP API 从 mono 服务器拉取
- 返回数据给开发者，同时更新本地缓存
8.6 技术栈汇总#
┌────────────────────────────────────────────────────────────────────────────────────────┐
│ 技术栈汇总 │
├────────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ 后端 (Rust) │ │
│ │ ├── Web Framework: Axum │ │
│ │ ├── Async Runtime: Tokio │ │
│ │ ├── SSH Protocol: Russh │ │
│ │ ├── ORM: SeaORM │ │
│ │ ├── Database: PostgreSQL │ │
│ │ ├── Cache: Redis │ │
│ │ ├── Object Storage: AWS S3 / Local │ │
│ │ ├── Auth: OAuth2, Cedar Policy │ │
│ │ ├── Crypto: secp256k1, ed25519, ring, pgp │ │
│ │ ├── API Docs: utoipa + Swagger UI │ │
│ │ └── Git Library: git-internal (自研) │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ FUSE 客户端 (Scorpio) │ │
│ │ ├── FUSE Library: rfuse3, libfuse-fs │ │
│ │ ├── Async Runtime: Tokio (目标迁移到 Monoio) │ │
│ │ ├── Local Storage: Sled DB │ │
│ │ └── HTTP Client: Reqwest │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ 前端 (Moon) │ │
│ │ ├── Framework: React + TypeScript │ │
│ │ ├── Build Tool: Turbo (monorepo) │ │
│ │ ├── Package Manager: pnpm │ │
│ │ └── Node Version: .nvmrc managed │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ DevOps │ │
│ │ ├── Container: Docker │ │
│ │ ├── CI/CD: GitHub Actions │ │
│ │ ├── Build System: Buck2 (可选集成) │ │
│ │ └── Memory Alloc: jemalloc (Linux), mimalloc (Windows) │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────────────────────────┘技术亮点：
- 全 Rust 后端 - 高性能、内存安全，适合处理大规模 Git 操作
- Axum + Tokio - 现代异步 Web 框架，支持高并发
- SeaORM - 类型安全的 ORM，编译期检查 SQL
- Cedar Policy - AWS 开源的策略语言，支持复杂权限规则
- FUSE 虚拟文件系统 - 无需 clone 整个仓库，按需加载文件