ChoChoX/obsidian
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8197fd341e3a06e38380ab747cae87cea2bf4a24
obsidian/操作系统/操作系统实践/实践01_Web服务器初步实现.md

579 lines
15 KiB
Markdown
Raw Normal View History

vault backup: 2026-06-14 19:05:57
2026-06-14 19:05:57 +08:00
# 实验一：Web服务器的初步实现
> [!info] 实验信息
> - **课程**: 操作系统实践
> - **实验编号**: 实验一
> - **实验类型**: 综合性实验
> - **关联理论**: [[09_网络编程基础]]、[[10_并发服务器]]、[[18_程序代码优化]]
---
## 一、实验目的
1. 掌握 Linux 系统下网络编程开发环境的搭建
2. 实现简单的单进程 Web 服务器
3. 进行性能测试，掌握网络编程的基本技术
4. 初步掌握 Web 服务器的编程实现和测试技术
---
## 二、实验环境
| 项目 | 说明 |
|------|------|
| 操作系统 | Ubuntu / CentOS (Linux) |
| 编译器 | GCC |
| 测试工具 | http_load、ab、wrk |
| 监控工具 | vmstat、iostat、gprof |
| 服务器端口 | 8088 |
---
## 三、源代码文件清单
```
.
├── common.h # 公共头文件、函数声明、常量定义（由wrapper.h简化而来）
├── common.c # RIO函数库和打开网络连接函数源代码
├── webclient.c # web客户端源代码
├── webserver.c # web服务器源代码（即weblet.c）
├── togglec.c # toggle客户端源代码
├── togglesi.c # 迭代式toggle服务器源代码
├── cgi-bin/
│ └── add.c # CGI程序
├── Makefile # 构建脚本
├── index.html # 测试主页
├── test.html # 测试页面
└── urls # http_load测试用URL列表
```
> [!tip] 文件说明
> - `common.h` / `common.c` 封装了网络编程常用的包装函数（Socket、Bind、Listen、Accept 等），是对 `wrapper.h` 的简化版本
> - `togglec.c` / `togglesi.c` 用于演示迭代式客户-服务器模型
> - `weblet.c` 是核心的单进程 Web 服务器实现
---
## 四、服务器架构
### 4.1 整体架构图
```mermaid
graph TD
subgraph 客户端
Browser["浏览器 / Web客户端"]
end
subgraph Web服务器 - weblet
Main["main() 主循环"]
Accept["accept() 接受连接"]
PT["process_trans() 处理HTTP事务"]
Close["close() 关闭连接"]
end
subgraph 请求处理流程
RR["读取请求行"]
Judge["判断静态/动态请求"]
Parse["解析URI"]
Send["发送响应"]
Err["错误处理"]
end
subgraph 响应模块
FS["feed_static() 静态内容"]
FD["feed_dynamic() 动态内容"]
ER["error_request() 错误响应"]
end
Browser -->|"HTTP请求"| Main
Main --> Accept
Accept --> PT
PT --> RR
RR --> Judge
Judge -->|"静态请求"| Parse
Judge -->|"动态请求"| Parse
Parse --> Send
Send --> FS
Send --> FD
Send --> ER
FS -->|"HTTP响应"| Browser
FD -->|"HTTP响应"| Browser
ER -->|"错误页面"| Browser
PT --> Close
Close -->|"等待下一个连接"| Accept
```
### 4.2 HTTP请求处理流程
```mermaid
flowchart TD
Start(["开始: accept() 获取连接"]) --> ReadReq["1.读取请求行
read_requesthdrs()"]
ReadReq --> ParseReq["2.解析请求方法、URI、版本"]
ParseReq --> IsStatic{"3.is_static()
判断请求类型"}
IsStatic -->|"静态请求"| ParseStatic["4a.parse_static_uri()
解析静态文件URI"]
IsStatic -->|"动态请求"| ParseDynamic["4b.parse_dynamic_uri()
解析CGI程序URI"]
ParseStatic --> OpenFile["5a.打开请求的文件"]
ParseDynamic --> ExecCGI["5b.执行CGI程序"]
OpenFile --> FileExist{"文件是否存在?"}
FileExist -->|"是"| FeedStatic["6a.feed_static()
发送静态文件响应"]
FileExist -->|"否"| ErrorReq["6c.error_request()
返回404错误"]
ExecCGI --> FeedDynamic["6b.feed_dynamic()
发送CGI执行结果"]
FeedStatic --> Done(["结束: close()"])
FeedDynamic --> Done
ErrorReq --> Done
```
---
## 五、核心源码分析
### 5.1 主函数结构 (`weblet.c`)
```c
/*
* weblet.c - 一个简单的单进程迭代式Web服务器
* 服务端口: 8088
*/
int main(int argc, char **argv) {
int listen_sock, conn_sock;
int hit;
/* 创建监听套接字 */
listen_sock = open_listen_sock(port);
/* 主循环：迭代式处理每个请求 */
for (hit = 1; ; hit++) {
/* 接受客户端连接 */
conn_sock = accept(listen_sock,
(struct sockaddr *)&client_addr,
&client_len);
/* 处理一个HTTP事务 */
process_trans(conn_sock, hit);
/* 关闭连接，等待下一个请求 */
close(conn_sock);
}
}
```
> [!warning] 迭代式服务器的局限
> 该服务器是**单进程迭代式**的，一次只能处理一个客户端请求。当某个请求处理耗时较长时，后续请求会被阻塞等待。改进方案参见 [[10_并发服务器]] 中的多进程和多线程服务器。
### 5.2 HTTP事务处理函数 (`process_trans`)
```c
/*
* process_trans - 处理一个HTTP事务
* @fd: 连接套接字描述符
* @hit: 请求计数
*/
void process_trans(int fd, int hit) {
int is_static; /* 是否为静态请求 */
struct stat sbuf; /* 文件状态 */
char buf[MAXLINE]; /* 读缓冲区 */
char method[MAXLINE]; /* 请求方法: GET */
char uri[MAXLINE]; /* 请求URI */
char version[MAXLINE]; /* HTTP版本 */
char filename[MAXLINE]; /* 文件路径 */
char cgiargs[MAXLINE]; /* CGI参数 */
/* 1. 读取并解析请求行 */
read_requesthdrs(buf);
/* 2. 解析请求行: GET /index.html HTTP/1.1 */
sscanf(buf, "%s %s %s", method, uri, version);
/* 3. 判断是否为静态请求 */
is_static = is_static(uri);
/* 4. 解析URI，提取文件名和CGI参数 */
if (is_static) {
parse_static_uri(uri, filename, cgiargs);
} else {
parse_dynamic_uri(uri, filename, cgiargs);
}
/* 5. 检查文件是否存在 */
if (stat(filename, &sbuf) < 0) {
error_request(fd, filename, "404", "Not Found");
return;
}
/* 6. 发送响应 */
if (is_static) {
feed_static(fd, filename, sbuf.st_size);
} else {
feed_dynamic(fd, filename, cgiargs);
}
}
```
### 5.3 RIO函数库 (`common.c`)
```c
/*
* RIO (Robust I/O) 健壮的I/O函数库
* 解决了Unix I/O的不足:
* - 短读(short read)问题
* - 被信号中断(interrupted read)问题
*/
/* 无缓冲的RIO读取 */
ssize_t rio_readn(int fd, void *usrbuf, size_t n);
ssize_t rio_writen(int fd, void *usrbuf, size_t n);
/* 带缓冲的RIO读取 */
void rio_readinitb(rio_t *rp, int fd);
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n);
/* 网络连接函数 */
int open_listen_sock(int port); /* 创建监听套接字 */
int open_client_sock(char *host, int port); /* 创建客户端连接 */
```
---
## 六、MIME类型支持
服务器根据文件扩展名返回对应的 `Content-Type`：
| 扩展名 | MIME类型 |
|--------|----------|
| `.gif` | `image/gif` |
| `.jpg` / `.jpeg` | `image/jpeg` |
| `.png` | `image/png` |
| `.ico` | `image/x-icon` |
| `.zip` | `application/zip` |
| `.gz` / `.tar` | `application/x-tar` |
| `.htm` / `.html` | `text/html` |
---
## 七、实验任务
### 任务1：运行验证迭代式服务器（togglec / togglesi）
> [!example] 操作步骤
```bash
# 终端1: 启动迭代式toggle服务器
$ ./togglesi
# 终端2: 运行toggle客户端
$ ./togglec localhost
```
此任务演示了[[09_网络编程基础]]中的基本客户-服务器通信模型。`togglesi` 是一个迭代式服务器，一次只服务一个客户端。
### 任务2：编写跨计算机文件传输程序
实现 `ftps.c`（服务器）和 `ftpc.c`（客户端），支持以下命令：
- `put <文件名>` —— 客户端上传文件到服务器
- `get <文件名>` —— 客户端从服务器下载文件
> [!abstract] 设计要点
> 1. 使用 Socket API 建立 TCP 连接
> 2. 先传输文件名和文件大小（协议头），再传输文件内容
> 3. 使用 RIO 函数处理短读问题
> 4. 服务器端需处理文件不存在的情况
### 任务3：运行验证 Web 服务器
```bash
# 编译
$ make
# 启动Web服务器 (端口8088)
$ ./weblet 8088
# 在浏览器中访问
# http://localhost:8088/index.html
# http://localhost:8088/test.html
# 使用curl测试
$ curl -v http://localhost:8088/index.html
```
### 任务4：使用 http_load 进行性能测试
```bash
# 准备URL列表文件 (urls)
$ cat urls
http://localhost:8088/index.html
http://localhost:8088/test.html
# 并行度5，总请求数50
$ http_load -parallel 5 -fetches 50 urls
# 并行度10，总请求数50
$ http_load -parallel 10 -fetches 50 urls
# 并行度5，持续20秒
$ http_load -parallel 5 -seconds 20 urls
# 并行度10，持续20秒
$ http_load -parallel 10 -seconds 20 urls
```
> [!note] http_load 输出指标
> - **fetches/sec**: 每秒完成的请求数（吞吐量）
> - **bytes/sec**: 每秒传输的字节数
> - **msecs/connect**: 平均连接建立时间
> - **msecs/first-response**: 首字节响应时间
### 任务5：使用 vmstat、iostat、gprof 收集性能数据
```bash
# ---- vmstat: 监控系统资源 ----
# 每2秒采样一次，共10次
$ vmstat 2 10
# 重点关注:
# r - 运行队列长度
# us - 用户态CPU占比
# sy - 内核态CPU占比
# wa - I/O等待占比
# free - 空闲内存
# ---- iostat: 监控磁盘I/O ----
# 以KB为单位，每2秒采样一次，共10次
$ iostat -k 2 10
# 重点关注:
# tps - 每秒传输次数
# kB_read/s - 每秒读取量
# kB_wrtn/s - 每秒写入量
# ---- gprof: 函数级性能分析 ----
# 编译时加 -pg 选项
$ gcc -pg -o weblet weblet.c common.c
# 运行服务器并处理若干请求后终止
$ ./weblet 8088
# 生成性能分析报告
$ gprof ./weblet gmon.out > perf.txt
$ cat perf.txt
```
### 任务6：优化 Web 服务器
> [!tip] 优化方向 — 参见 [[18_程序代码优化]]
**抑制调试输出**：将 `printf` 等调试输出替换为条件编译或日志级别控制。
```c
/* 优化前: 每个请求都输出调试信息 */
void process_trans(int fd, int hit) {
printf("Request %d: processing...\n", hit);
// ...
}
/* 优化后: 仅在DEBUG模式下输出 */
#ifdef DEBUG
#define DBG_LOG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DBG_LOG(fmt, ...) /* nothing */
#endif
void process_trans(int fd, int hit) {
DBG_LOG("Request %d: processing...\n", hit);
// ...
}
```
```bash
# 编译优化版本 (关闭调试输出)
$ gcc -O2 -o weblet_opt weblet.c common.c
# 重新进行性能测试，对比优化前后结果
$ http_load -parallel 10 -fetches 50 urls
```
### 任务7：优化服务器部署（跨节点测试）
```bash
# 服务器端 (节点A: 192.168.1.100)
$ ./weblet 8088
# 客户端 (节点B: 192.168.1.200)
# 修改urls文件中的地址
$ cat urls
http://192.168.1.100:8088/index.html
http://192.168.1.100:8088/test.html
# 跨节点压测
$ http_load -parallel 10 -seconds 20 urls
# 使用ab进行压测
$ ab -n 1000 -c 100 http://192.168.1.100:8088/
# 使用wrk进行压测
$ wrk -t4 -c100 -d10s http://192.168.1.100:8088/
```
---
## 八、性能测试命令汇总
```bash
# ===== http_load =====
http_load -parallel 5 -fetches 50 urls # 并行5，50次请求
http_load -parallel 10 -fetches 50 urls # 并行10，50次请求
http_load -parallel 5 -seconds 20 urls # 并行5，持续20秒
http_load -parallel 10 -seconds 20 urls # 并行10，持续20秒
# ===== vmstat =====
vmstat 2 10 # 每2秒采样，共10次
# ===== iostat =====
iostat -k 2 10 # KB为单位，每2秒采样
# ===== gprof =====
gprof ./weblet gmon.out > perf.txt # 生成函数调用分析
# ===== ab (Apache Bench) =====
ab -n 1000 -c 100 http://127.0.0.1:8080/ # 1000请求，并发100
# ===== wrk =====
wrk -t4 -c100 -d10s http://127.0.0.1:8088/ # 4线程，并发100，持续10秒
```
---
## 九、Makefile 示例
```makefile
CC = gcc
CFLAGS = -Wall -O2
DEBUG_CFLAGS = -Wall -g -pg -DDEBUG
all: weblet togglec togglesi webclient
weblet: weblet.c common.c common.h
$(CC) $(CFLAGS) -o weblet weblet.c common.c
togglec: togglec.c common.c common.h
$(CC) $(CFLAGS) -o togglec togglec.c common.c
togglesi: togglesi.c common.c common.h
$(CC) $(CFLAGS) -o togglesi togglesi.c common.c
webclient: webclient.c common.c common.h
$(CC) $(CFLAGS) -o webclient webclient.c common.c
debug: weblet.c common.c common.h
$(CC) $(DEBUG_CFLAGS) -o weblet_debug weblet.c common.c
clean:
rm -f weblet togglec togglesi webclient weblet_debug gmon.out perf.txt
```
---
## 十、实验结果与分析
### 10.1 性能对比记录表
| 测试条件 | 并行度 | fetches/sec | bytes/sec | 备注 |
|----------|--------|-------------|-----------|------|
| 原始版本 | 5 | - | - | |
| 原始版本 | 10 | - | - | |
| 优化版本(关闭调试) | 5 | - | - | |
| 优化版本(关闭调试) | 10 | - | - | |
| 跨节点测试 | 10 | - | - | |
### 10.2 gprof 分析要点
> [!abstract] 关键发现
> 1. 识别 CPU 时间占比最高的函数
> 2. 分析系统调用（`read`、`write`、`accept`）的耗时
> 3. 对比优化前后函数调用次数和耗时变化
### 10.3 分析与思考
1. **迭代式服务器的瓶颈**：单进程模型下，请求串行处理，并发性能受限。改进方案可参考 [[10_并发服务器]] 中的多进程 fork 模型、多线程 pthread 模型。
2. **调试输出对性能的影响**：频繁的 `printf` 会触发系统调用和缓冲区刷新，在高并发场景下成为性能瓶颈。
3. **网络传输 vs 本地测试**：跨节点测试引入了网络延迟，更接近真实场景，但本地测试更能反映服务器本身的处理能力。
---
## 十一、知识点总结
```mermaid
mindmap
root((Web服务器实现))
网络编程基础
Socket API
socket/bind/listen/accept
connect/read/write
RIO函数库
健壮的I/O操作
带缓冲读取
服务器架构
迭代式服务器
单进程串行处理
简单但并发性差
并发式服务器
多进程fork模型
多线程pthread模型
HTTP协议
请求行解析
GET / URI / HTTP/1.1
MIME类型
Content-Type头部
静态/动态内容
文件服务 vs CGI
性能测试
压测工具
http_load
ab / wrk
系统监控
vmstat / iostat
代码分析
gprof 函数级分析
```
---
## 十二、课后思考
1. 如何将迭代式 Web 服务器改造为[[10_并发服务器|并发服务器]]？比较 `fork`、`pthread`、`select`/`epoll` 等方案的优劣。
2. RIO 函数库解决了标准 I/O 的哪些问题？为什么不能直接使用 `read()` / `write()`？
3. 如何通过 [[18_程序代码优化|代码优化]] 进一步提升 Web 服务器性能？（减少系统调用、零拷贝、内存映射等）
4. 试分析 `gprof` 输出中各函数的调用关系和时间占比，找出性能热点。
---
> [!quote] 参考资料
> - 《深入理解计算机系统》(CSAPP) 第11章：网络编程
> - 《Unix网络编程》(UNP) 卷1：套接字联网API
> - man pages: `socket(2)`, `bind(2)`, `listen(2)`, `accept(2)`, `connect(2)`
Reference in New Issue Copy Permalink