.
├── CMakeLists.txt
├── docker
│   └── Dockerfile
├── include
│   ├── api_handler.h
│   ├── engine.h
│   ├── http_server.h
│   ├── parser.h
│   └── storage.h
├── src
│   ├── api_handler.c
│   ├── engine.c
│   ├── http_server.c
│   ├── main.c
│   ├── parser.c
│   └── storage.c
├── test
│   ├── test_engine.c
│   ├── test_parser.c
│   └── test_storage.c
└── web
    ├── app.js
    ├── index.html
    └── style.css

docker run -p 8080:8080 minikv-dev

groups debian

debian : debian sudo

sudo apt update
sudo apt install -y \
    git \
    cmake \
    clang \
    check \
    gdb \
    curl \
    build-essential \
    pkg-config

cat /proc/cpuinfo     # 查看CPU信息（本质是个文件）
ls /dev/tty*           # 所有终端也是设备文件

cat access.log | grep 404 | wc -l   # 查找所有 404 错误并统计数量

#!/bin/bash
make && ./test && echo "测试通过"

sudo adduser devuser   # 创建干净的开发用户
chown devuser:devuser  # 赋予目录权限

less /etc/ssh/sshd_config   # 所有服务配置都可查看、可编辑

int kv_put(const char* key, const char* value);
char* kv_get(const char* key);

#ifndef STORAGE_H
#define STORAGE_H

typedef struct Storage Storage;

// 创建和释放存储实例
Storage* storage_create();
void storage_free(Storage* storage);

// 设置键值对
int storage_set(Storage* storage, const char* key, const char* value);

// 获取键对应的值（返回内部静态指针，不要 free）
const char* storage_get(Storage* storage, const char* key);

#endif

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "../include/storage.h"

#define MAX_ITEMS 1024
#define KEY_SIZE 128
#define VALUE_SIZE 256

typedef struct {
    char key[KEY_SIZE];
    char value[VALUE_SIZE];
} KvPair;

struct Storage {
    KvPair items[MAX_ITEMS];
    int count;
};

Storage* storage_create() {
    Storage* s = malloc(sizeof(Storage));
    if (s) {
        s->count = 0;
    }
    return s;
}

void storage_free(Storage* s) {
    free(s);
}

int storage_set(Storage* s, const char* key, const char* value) {
    for (int i = 0; i < s->count; ++i) {
        if (strcmp(s->items[i].key, key) == 0) {
            strncpy(s->items[i].value, value, VALUE_SIZE);
            return 0;
        }
    }
    if (s->count >= MAX_ITEMS) return -1;
    strncpy(s->items[s->count].key, key, KEY_SIZE);
    strncpy(s->items[s->count].value, value, VALUE_SIZE);
    s->count++;
    return 0;
}

const char* storage_get(Storage* s, const char* key) {
    for (int i = 0; i < s->count; ++i) {
        if (strcmp(s->items[i].key, key) == 0) {
            return s->items[i].value;
        }
    }
    return NULL;
}

#ifndef PARSER_H
#define PARSER_H

typedef enum {
    CMD_SET,
    CMD_GET,
    CMD_UNKNOWN
} CommandType;

typedef struct {
    CommandType type;
    char key[128];
    char value[256]; // 仅在 SET 使用
} KvCommand;

int parse_input(const char* input, KvCommand* cmd);

#endif

#include <string.h>
#include <stdio.h>
#include "../include/parser.h"

int parse_input(const char* input, KvCommand* cmd) {
    char op[16] = {0};
    int matched = sscanf(input, "%15s %127s %255[^\n]", op, cmd->key, cmd->value);

    if (matched == 2 && strcmp(op, "GET") == 0) {
        cmd->type = CMD_GET;
        return 0;
    } else if (matched == 3 && strcmp(op, "SET") == 0) {
        cmd->type = CMD_SET;
        return 0;
    }

    cmd->type = CMD_UNKNOWN;
    return -1;
}

#ifndef ENGINE_H
#define ENGINE_H

#include "parser.h"
#include "storage.h"

int engine_execute(Storage* storage, const KvCommand* cmd);

#endif

#include <stdio.h>
#include "../include/engine.h"

int engine_execute(Storage* storage, const KvCommand* cmd) {
    switch (cmd->type) {
        case CMD_SET:
            storage_set(storage, cmd->key, cmd->value);
            printf("OK\n");
            return 0;
        case CMD_GET: {
            const char* val = storage_get(storage, cmd->key);
            if (val) printf("%s\n", val);
            else printf("NULL\n");
            return 0;
        }
        default:
            printf("Error: unknown command.\n");
            return 1;
    }
}

#include <stdio.h>
#include <string.h>
#include "../include/parser.h"
#include "../include/engine.h"
#include "../include/storage.h"

int main() {
    Storage* store = storage_create();
    char input[512];
    KvCommand cmd;

    printf("MiniKV > ");
    while (fgets(input, sizeof(input), stdin)) {
        if (parse_input(input, &cmd) == 0) {
            engine_execute(store, &cmd);
        } else {
            printf("Invalid command.\n");
        }
        printf("MiniKV > ");
    }

    storage_free(store);
    return 0;
}

cmake_minimum_required(VERSION 3.10)
project(MiniKV C)

set(CMAKE_C_STANDARD 99)

include_directories(include)

add_executable(minikv
    src/main.c
    src/parser.c
    src/engine.c
    src/storage.c
)

mkdir build && cd build
cmake ..
make
./minikv

git add *
git commit
git co -b main
git merge dev
git tag -a v0.1.0 -m "release: 实现基础"

git checkout -b feature/http

#ifndef HTTP_SERVER_H
#define HTTP_SERVER_H

#include "storage.h"

void http_server_start(Storage* store, int port);

#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>

#include "../include/http_server.h"
#include "../include/parser.h"
#include "../include/engine.h"

#define PORT_DEFAULT 8080
#define BUFFER_SIZE 4096

void handle_client(int client_sock, Storage* store) {
    char buffer[BUFFER_SIZE];
    int bytes = recv(client_sock, buffer, sizeof(buffer) - 1, 0);
    if (bytes <= 0) return;
    buffer[bytes] = '\0';

    // 简单提取 POST /api/query
    if (strncmp(buffer, "POST /api/query", 15) != 0) {
        const char* err = "HTTP/1.0 404 Not Found\r\nContent-Length: 0\r\n\r\n";
        send(client_sock, err, strlen(err), 0);
        return;
    }

    // 查找请求体（body）
    char* body = strstr(buffer, "\r\n\r\n");
    if (!body) return;
    body += 4; // skip \r\n\r\n

    // 解析 SQL 并执行
    KvCommand cmd;
    char response[512];

    if (parse_input(body, &cmd) == 0) {
        engine_execute(store, &cmd, response, sizeof(response));
    } else {
        snprintf(response, sizeof(response), "{\"error\": \"invalid command\"}");
    }

    char http_response[1024];
    snprintf(http_response, sizeof(http_response),
        "HTTP/1.0 200 OK\r\n"
        "Content-Type: application/json\r\n"
        "Content-Length: %zu\r\n"
        "\r\n"
        "%s",
        strlen(response), response);

    send(client_sock, http_response, strlen(http_response), 0);
}

void http_server_start(Storage* store, int port) {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(port),
        .sin_addr.s_addr = INADDR_ANY
    };

    if (bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(server_fd);
        exit(1);
    }

    if (listen(server_fd, 5) < 0) {
        perror("listen");
        close(server_fd);
        exit(1);
    }

    printf("HTTP server running on port %d...\n", port);
    while (1) {
        int client_sock = accept(server_fd, NULL, NULL);
        if (client_sock >= 0) {
            handle_client(client_sock, store);
            close(client_sock);
        }
    }

    close(server_fd);
}

int engine_execute(Storage* storage, const KvCommand* cmd);

engine_execute(store, &cmd, response, sizeof(response));  // ❌ 错误

int engine_execute(Storage*, const KvCommand*);        // 只执行，输出 stdout
int engine_execute_with_result(Storage*, const KvCommand*, char* buf, size_t buf_size);  // 执行+填充 JSON

typedef struct {
    int code;
    char message[256];  // 可填 JSON
} ExecutionResult;

ExecutionResult engine_execute(Storage*, const KvCommand*);

#ifndef ENGINE_H
#define ENGINE_H

#include "parser.h"
#include "storage.h"

typedef struct {
    int code;          // 返回的状态码，0为成功，非0为失败
    char message[256]; // 存储JSON响应
} ExecutionResult;

// 执行命令，返回执行结果
ExecutionResult engine_execute(Storage* storage, const KvCommand* cmd);

#endif

#include "engine.h"
#include "storage.h"
#include <stdio.h>
#include <string.h>

ExecutionResult engine_execute(Storage* storage, const KvCommand* cmd) {
    ExecutionResult result = {0};  // 默认返回成功

    switch (cmd->type) {
        case CMD_SET:
            // 执行 SET 命令
            if (storage_set(storage, cmd->key, cmd->value) == 0) {
                snprintf(result.message, sizeof(result.message), "{\"status\": \"ok\"}");
                result.code = 0;  // 成功
            } else {
                snprintf(result.message, sizeof(result.message), "{\"error\": \"set failed\"}");
                result.code = -1; // 失败
            }
            break;
        
        case CMD_GET:
            // 执行 GET 命令
            const char* val = storage_get(storage, cmd->key);
            if (val) {
                snprintf(result.message, sizeof(result.message), "{\"value\": \"%s\"}", val);
                result.code = 0;  // 成功
            } else {
                snprintf(result.message, sizeof(result.message), "{\"error\": \"not found\"}");
                result.code = -1; // 失败
            }
            break;

        default:
            snprintf(result.message, sizeof(result.message), "{\"error\": \"unknown command\"}");
            result.code = -1; // 失败
            break;
    }

    return result;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../include/parser.h"
#include "../include/engine.h"
#include "../include/storage.h"
#include "../include/http_server.h"

int run_cli_mode() {
    Storage* store = storage_create();
    if (!store) {
        perror("Failed to create storage");
        return -1;
    }

    char input[512];
    KvCommand cmd;

    printf("MiniKV > ");
    while (fgets(input, sizeof(input), stdin)) {
        if (parse_input(input, &cmd) == 0) {
            ExecutionResult result = engine_execute(store, &cmd);
            printf("%s\n", result.message);
        } else {
            printf("Invalid command.\n");
        }
        printf("MiniKV > ");
    }

    storage_free(store);
    return 0;
}

int run_http_mode() {
    Storage* store = storage_create();
    if (!store) {
        perror("Failed to create storage");
        return -1;
    }

    // 启动 HTTP 服务器
    http_server_start(store, 8080); // 启动 HTTP 服务，监听 8080 端口

    storage_free(store);
    return 0;
}

int main() {
    int mode;
    printf("Choose mode: 1 for CLI, 2 for HTTP: ");
    scanf("%d", &mode);
    getchar();  // 捕获换行符

    if (mode == 1) {
        // CLI 模式
        return run_cli_mode();
    } else if (mode == 2) {
        // HTTP 模式
        return run_http_mode();
    } else {
        printf("Invalid mode selected.\n");
        return -1;
    }
}

#include "http_server.h"
#include "engine.h"
#include "parser.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BUFFER_SIZE 1024

// 处理客户端请求
void handle_client(int client_sock, Storage* store) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;

    // 读取客户端请求
    bytes_read = read(client_sock, buffer, sizeof(buffer) - 1);
    if (bytes_read <= 0) {
        perror("read");
        close(client_sock);
        return;
    }
    buffer[bytes_read] = '\0'; // 确保字符串结尾

    // 找到请求体（跳过请求头）
    char* body = strstr(buffer, "\r\n\r\n");
    if (!body || strlen(body) < 4) {
        const char* msg = "{\"error\": \"Malformed request\"}";
        char response[BUFFER_SIZE];
        snprintf(response, sizeof(response),
            "HTTP/1.0 400 Bad Request\r\n"
            "Content-Type: application/json\r\n"
            "Content-Length: %zu\r\n"
            "\r\n"
            "%s", strlen(msg), msg);
        write(client_sock, response, strlen(response));
        close(client_sock);
        return;
    }

    body += 4;  // 跳过 "\r\n\r\n"，body 现在指向请求体部分

    // 解析 SQL 命令
    KvCommand cmd;
    if (parse_input(body, &cmd) != 0) {
        const char* msg = "{\"error\": \"Invalid command\"}";
        char response[BUFFER_SIZE];
        snprintf(response, sizeof(response),
            "HTTP/1.0 400 Bad Request\r\n"
            "Content-Type: application/json\r\n"
            "Content-Length: %zu\r\n"
            "\r\n"
            "%s", strlen(msg), msg);
        write(client_sock, response, strlen(response));
        close(client_sock);
        return;
    }

    // 执行命令
    ExecutionResult result = engine_execute(store, &cmd);

    // 构建 JSON 响应
    char response[BUFFER_SIZE];
    snprintf(response, sizeof(response),
        "HTTP/1.0 200 OK\r\n"
        "Content-Type: application/json\r\n"
        "Content-Length: %zu\r\n"
        "\r\n"
        "%s", strlen(result.message), result.message);
    write(client_sock, response, strlen(response));

    // 关闭连接
    close(client_sock);
}

// 启动 HTTP 服务
void http_server_start(Storage* store, int port) {
    int server_sock, client_sock;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);

    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sock < 0) {
        perror("socket");
        exit(1);
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(port);

    if (bind(server_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_sock);
        exit(1);
    }

    if (listen(server_sock, 5) < 0) {
        perror("listen");
        close(server_sock);
        exit(1);
    }

    printf("HTTP server started on port %d...\n", port);

    while (1) {
        client_sock = accept(server_sock, (struct sockaddr*)&client_addr, &client_len);
        if (client_sock < 0) {
            perror("accept");
            continue;
        }

        handle_client(client_sock, store);
    }

    close(server_sock);
}

git tag -a v0.2.0 -m "release: v0.2.0：完成http服务的搭建"

int kv_put(const char* key, const char* value);
char* kv_get(const char* key);

curl -X POST http://localhost:8080/api/query -d '{"sql": "GET name"}'

#ifndef API_HANDLER_H
#define API_HANDLER_H

#include "storage.h"

// 处理 API 请求（传入路径、正文内容，输出 JSON 响应）
void handle_api_request(Storage* store, const char* path, const char* body, char* response, int max_len);

#endif

#include "api_handler.h"
#include "parser.h"
#include "engine.h"
#include <stdio.h>
#include <string.h>

// 支持 POST /api/query
void handle_api_request(Storage* store, const char* path, const char* body, char* response, int max_len) {
    if (strcmp(path, "/api/query") != 0) {
        snprintf(response, max_len, "{\"error\": \"Unknown API endpoint\"}");
        return;
    }

    // 解析 body 为 KvCommand
    KvCommand cmd;
    if (parse_input(body, &cmd) != 0) {
        snprintf(response, max_len, "{\"error\": \"Invalid query syntax\"}");
        return;
    }

    // 执行命令
    ExecutionResult result = engine_execute(store, &cmd);

    // 构造 JSON 响应（假设 message 为 JSON 片段）
    snprintf(response, max_len, "%s\n", result.message);
}

#include "api_handler.h" // 加在开头

// 在解析请求后加入
if (strncmp(request_line, "POST /api/query", 15) == 0) {
    // ... 读取 body ...
    char api_response[BUFFER_SIZE];
    handle_api_request(store, "/api/query", body, api_response, sizeof(api_response));
    // 构造 HTTP 响应
}

add_executable(minikv
    src/main.c
    src/parser.c
    src/engine.c
    src/storage.c
    src/http_server.c
    src/api_handler.c  # 添加此行
)

#include "http_server.h"
#include "api_handler.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BUFFER_SIZE 1024

// 处理客户端请求
void handle_client(int client_sock, Storage* store) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;

    // 读取客户端请求
    bytes_read = read(client_sock, buffer, sizeof(buffer) - 1);
    if (bytes_read <= 0) {
        perror("read");
        close(client_sock);
        return;
    }
    buffer[bytes_read] = '\0'; // 确保字符串结尾

    // 提取 HTTP 方法和路径
    char method[8], path[64];
    if (sscanf(buffer, "%7s %63s", method, path) != 2) {
        const char* msg = "{\"error\": \"Malformed request line\"}";
        char response[BUFFER_SIZE];
        snprintf(response, sizeof(response),
            "HTTP/1.0 400 Bad Request\r\n"
            "Content-Type: application/json\r\n"
            "Content-Length: %zu\r\n"
            "\r\n"
            "%s", strlen(msg), msg);
        write(client_sock, response, strlen(response));
        close(client_sock);
        return;
    }

    // 找到请求体
    char* body = strstr(buffer, "\r\n\r\n");
    if (!body || strlen(body) < 4) {
        const char* msg = "{\"error\": \"Missing request body\"}";
        char response[BUFFER_SIZE];
        snprintf(response, sizeof(response),
            "HTTP/1.0 400 Bad Request\r\n"
            "Content-Type: application/json\r\n"
            "Content-Length: %zu\r\n"
            "\r\n"
            "%s", strlen(msg), msg);
        write(client_sock, response, strlen(response));
        close(client_sock);
        return;
    }
    body += 4; // 跳过 "\r\n\r\n"

    // 使用 API 处理模块生成响应体
    char msg[BUFFER_SIZE];
    handle_api_request(store, path, body, msg, sizeof(msg));

    // 构建完整 HTTP 响应
    char response[BUFFER_SIZE * 2]; // 预留更大空间
    snprintf(response, sizeof(response),
        "HTTP/1.0 200 OK\r\n"
        "Content-Type: application/json\r\n"
        "Content-Length: %zu\r\n"
        "\r\n"
        "%s", strlen(msg), msg);

    write(client_sock, response, strlen(response));
    close(client_sock);
}

// 启动 HTTP 服务
void http_server_start(Storage* store, int port) {
    int server_sock, client_sock;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);

    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sock < 0) {
        perror("socket");
        exit(1);
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(port);

    if (bind(server_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_sock);
        exit(1);
    }

    if (listen(server_sock, 5) < 0) {
        perror("listen");
        close(server_sock);
        exit(1);
    }

    printf("HTTP server started on port %d...\n", port);

    while (1) {
        client_sock = accept(server_sock, (struct sockaddr*)&client_addr, &client_len);
        if (client_sock < 0) {
            perror("accept");
            continue;
        }

        handle_client(client_sock, store);
    }

    close(server_sock);
}

#ifndef API_HANDLER_H
#define API_HANDLER_H

#include "storage.h"

// 所有 API 处理函数的签名
typedef void (*ApiHandlerFn)(Storage* store, const char* body, char* response, int max_len);

// 路由器主入口
void handle_api_request(Storage* store, const char* path, const char* body, char* response, int max_len);

#endif

#include "api_handler.h"
#include "parser.h"
#include "engine.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// 每个路径对应一个处理函数
static void handle_query(Storage* store, const char* body, char* response, int max_len) {
    KvCommand cmd;
    if (parse_input(body, &cmd) != 0) {
        snprintf(response, max_len, "{\"error\": \"Invalid query syntax\"}\n");
        return;
    }

    ExecutionResult result = engine_execute(store, &cmd);
    snprintf(response, max_len, "%s\n", result.message);
}

static void handle_health(Storage* store, const char* body, char* response, int max_len) {
    (void)store;  // unused
    (void)body;
    snprintf(response, max_len, "{\"status\": \"ok\"}\n");
}

// 处理 / 请求，返回 index.html 文件内容
static void handle_index(Storage* store, const char* body, char* response, int max_len) {
    (void)store;  // unused
    (void)body;

    // 读取 index.html 文件内容
    FILE* file = fopen("web/index.html", "r");
    if (!file) {
        snprintf(response, max_len, "{\"error\": \"index.html not found\"}\n");
        return;
    }

    // 读取文件内容并构建响应
    char file_content[1024];
    size_t bytes_read = fread(file_content, 1, sizeof(file_content) - 1, file);
    if (bytes_read < 0) {
        snprintf(response, max_len, "{\"error\": \"Failed to read index.html\"}\n");
        fclose(file);
        return;
    }

    file_content[bytes_read] = '\0';  // 确保字符串结束

    // 构造响应头
    snprintf(response, max_len,
        "HTTP/1.0 200 OK\r\n"
        "Content-Type: text/html\r\n"
        "Content-Length: %zu\r\n"
        "\r\n"
        "%s", bytes_read, file_content);

    fclose(file);
}

// 定义路由表
typedef struct {
    const char* path;
    ApiHandlerFn handler;
} ApiRoute;

static ApiRoute routes[] = {
    { "/api/query", handle_query },
    { "/api/health", handle_health },
    { "/", handle_index },  // 新增：返回 index.html
};

#define NUM_ROUTES (sizeof(routes) / sizeof(routes[0]))

// 调度器
void handle_api_request(Storage* store, const char* path, const char* body, char* response, int max_len) {
    for (size_t i = 0; i < NUM_ROUTES; ++i) {
        if (strcmp(path, routes[i].path) == 0) {
            routes[i].handler(store, body, response, max_len);
            return;
        }
    }

    snprintf(response, max_len, "{\"error\": \"Unknown API endpoint\"}\n");
}

#include "http_server.h"
#include "api_handler.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BUFFER_SIZE 2048

/
 * @brief 处理客户端请求，包括解析请求、路由匹配并构造响应。
 *
 * @param client_sock 客户端 socket 文件描述符
 * @param store       指向 Storage 对象的指针
 */
void handle_client(int client_sock, Storage* store) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;

    bytes_read = read(client_sock, buffer, sizeof(buffer) - 1);
    if (bytes_read <= 0) {
        perror("read");
        close(client_sock);
        return;
    }

    buffer[bytes_read] = '\0';

    // 解析请求行
    char method[8], path[128];
    if (sscanf(buffer, "%7s %127s", method, path) != 2) {
        const char* msg = "{\"error\": \"Malformed request line\"}";
        char response[BUFFER_SIZE];
        snprintf(response, sizeof(response),
            "HTTP/1.0 400 Bad Request\r\n"
            "Content-Type: application/json\r\n"
            "Content-Length: %zu\r\n"
            "\r\n"
            "%s", strlen(msg), msg);
        write(client_sock, response, strlen(response));
        close(client_sock);
        return;
    }

    // 查找请求体
    char* body = strstr(buffer, "\r\n\r\n");
    if (body) {
        body += 4;
    } else {
        body = "";
    }

    // 响应缓存
    char msg[BUFFER_SIZE * 2];
    memset(msg, 0, sizeof(msg));

    // 是否为完整响应（含 HTTP 头），用于区分 HTML vs JSON
    int is_full_http_response = 0;

    // 分发请求
    handle_api_request(store, path, body, msg, sizeof(msg));

    // 如果返回内容以 "HTTP/" 开头，视为完整响应（如 handle_index 返回）
    if (strncmp(msg, "HTTP/", 5) == 0) {
        is_full_http_response = 1;
    }

    if (is_full_http_response) {
        // 已包含完整 HTTP 头
        write(client_sock, msg, strlen(msg));
    } else {
        // 标准 JSON 响应包裹 HTTP 头
        char response[BUFFER_SIZE * 2];
        snprintf(response, sizeof(response),
            "HTTP/1.0 200 OK\r\n"
            "Content-Type: application/json\r\n"
            "Content-Length: %zu\r\n"
            "\r\n"
            "%s", strlen(msg), msg);
        write(client_sock, response, strlen(response));
    }

    close(client_sock);
}

/
 * @brief 启动 HTTP 服务，监听指定端口并处理每个客户端连接。
 *
 * @param store 指向 Storage 对象的指针
 * @param port  要监听的端口号
 */
void http_server_start(Storage* store, int port) {
    int server_sock, client_sock;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);

    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sock < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    int reuse = 1;
    setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(port);

    if (bind(server_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_sock);
        exit(EXIT_FAILURE);
    }

    if (listen(server_sock, 5) < 0) {
        perror("listen");
        close(server_sock);
        exit(EXIT_FAILURE);
    }

    printf("HTTP server started on port %d...\n", port);

    while (1) {
        client_sock = accept(server_sock, (struct sockaddr*)&client_addr, &client_len);
        if (client_sock < 0) {
            perror("accept");
            continue;
        }

        handle_client(client_sock, store);
    }

    close(server_sock);
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HTML, CSS, JS Example</title>
</head>
<body>
    <h1>Hello, World!</h1>
    <p id="message">This is a paragraph.</p>
    <button id="changeText">Change Text</button>
</body>
</html>

/* style.css */
body {
    font-family: Arial, sans-serif;
    background-color: #f4f4f4;
}

h1 {
    color: #333;
}

button {
    background-color: #4CAF50;
    color: white;
    padding: 10px 20px;
    border: none;
    cursor: pointer;
}

button:hover {
    background-color: #45a049;
}

// script.js
document.getElementById('changeText').addEventListener('click', function() {
    document.getElementById('message').textContent = 'The text has been changed!';
});

<form id="userForm">
    <label for="username">Username:</label>
    <input type="text" id="username" name="username">
    <button type="submit">Submit</button>
</form>
<p id="responseMessage"></p>

document.getElementById('userForm').addEventListener('submit', function(event) {
    event.preventDefault();  // 防止表单默认提交
    
    // 获取用户输入的数据
    const username = document.getElementById('username').value;

    // 发送 POST 请求到后端
    fetch('https://example.com/api/submit', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ username: username })
    })
    .then(response => response.json())  // 处理响应的 JSON 数据
    .then(data => {
        document.getElementById('responseMessage').textContent = data.message;
    })
    .catch(error => {
        console.error('Error:', error);
    });
});

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>MiniKV 控制台</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <div class="console">
        <h1>MiniKV Console</h1>
        <textarea id="sqlInput" placeholder="请输入命令，如 SET a 123 或 GET a"></textarea>
        <button onclick="sendQuery()">执行</button>
        <pre id="resultArea">等待响应...</pre>
    </div>

    <script src="app.js"></script>
</body>
</html>

body {
    margin: 0;
    background-color: #fff;
    font-family: 'Courier New', Courier, monospace;
    color: #000;
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
}

.console {
    border: 5px solid #000;
    padding: 2rem;
    width: 500px;
    box-shadow: 10px 10px 0 #000;
    background-color: #fdfdfd;
}

h1 {
    font-size: 1.8rem;
    margin-bottom: 1rem;
    text-align: center;
    border-bottom: 2px solid #000;
    padding-bottom: 0.5rem;
}

button {
    width: 100%;
    padding: 0.7rem;
    font-size: 1rem;
    background-color: #000;
    color: #fff;
    border: none;
    cursor: pointer;
    transition: all 0.2s ease;
}

button:hover {
    background-color: #444;
}

textarea,
pre {
    width: 100%;
    box-sizing: border-box;
    font-size: 1rem;
    border: 2px solid #000;
    font-family: 'Courier New', Courier, monospace;
}

textarea {
    height: 80px;
    padding: 0.5rem;
    resize: none;
    margin-bottom: 1rem;
}

pre {
    background: #eee;
    padding: 1rem;
    min-height: 100px;
    overflow: auto;
    white-space: pre-wrap;
}

function sendQuery() {
    const sql = document.getElementById("sqlInput").value;
    fetch('/api/query', {
        method: 'POST',
        headers: {
            'Content-Type': 'text/plain'
        },
        body: sql
    })
    .then(response => response.text())
    .then(data => {
        document.getElementById("resultArea").textContent = data;
    })
    .catch(error => {
        document.getElementById("resultArea").textContent = `错误: ${error}`;
    });
}

#include "api_handler.h"
#include "parser.h"
#include "engine.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>

/// 查询命令处理函数：解析 body 并执行
static void handle_query(Storage* store, const char* body, char* response, int max_len) {
    KvCommand cmd;
    if (parse_input(body, &cmd) != 0) {
        snprintf(response, max_len, "{\"error\": \"Invalid query syntax\"}\n");
        return;
    }

    ExecutionResult result = engine_execute(store, &cmd);
    snprintf(response, max_len, "%s\n", result.message);
}

/// 健康检查处理函数
static void handle_health(Storage* store, const char* body, char* response, int max_len) {
    (void)store;
    (void)body;
    snprintf(response, max_len, "{\"status\": \"ok\"}\n");
}

/// 返回 index.html 主页内容
static void handle_index(Storage* store, const char* body, char* response, int max_len) {
    (void)store;
    (void)body;

    FILE* file = fopen("../web/index.html", "r");
    if (!file) {
        snprintf(response, max_len, "{\"error\": \"index.html not found\"}\n");
        return;
    }

    char file_content[8192];
    size_t bytes_read = fread(file_content, 1, sizeof(file_content) - 1, file);
    file_content[bytes_read] = '\0';

    fclose(file);

    snprintf(response, max_len,
        "HTTP/1.0 200 OK\r\n"
        "Content-Type: text/html\r\n"
        "Content-Length: %zu\r\n"
        "\r\n"
        "%s", bytes_read, file_content);
}

/// 静态资源通用处理器：支持 .css/.js/.html 等文件
static void handle_static(Storage* store, const char* body, char* response, int max_len, const char* path) {
    (void)store;
    (void)body;

    // 构造完整文件路径
    char filepath[256];
    snprintf(filepath, sizeof(filepath), "../web%s", path);

    FILE* file = fopen(filepath, "rb");
    if (!file) {
        snprintf(response, max_len, "HTTP/1.0 404 Not Found\r\nContent-Type: text/plain\r\n\r\nFile not found");
        return;
    }

    struct stat st;
    stat(filepath, &st);
    size_t file_size = st.st_size;

    // 判断 MIME 类型
    const char* content_type = "application/octet-stream";
    if (strstr(path, ".css")) {
        content_type = "text/css";
    } else if (strstr(path, ".js")) {
        content_type = "application/javascript";
    } else if (strstr(path, ".html")) {
        content_type = "text/html";
    } else if (strstr(path, ".png")) {
        content_type = "image/png";
    } else if (strstr(path, ".jpg") || strstr(path, ".jpeg")) {
        content_type = "image/jpeg";
    } else if (strstr(path, ".svg")) {
        content_type = "image/svg+xml";
    }

    // 读取内容
    char* file_content = malloc(file_size + 1);
    fread(file_content, 1, file_size, file);
    file_content[file_size] = '\0';
    fclose(file);

    snprintf(response, max_len,
        "HTTP/1.0 200 OK\r\n"
        "Content-Type: %s\r\n"
        "Content-Length: %zu\r\n"
        "\r\n", content_type, file_size);
    memcpy(response + strlen(response), file_content, file_size);
    response[strlen(response) + file_size] = '\0';

    free(file_content);
}

/// 路由定义
typedef struct {
    const char* path;
    ApiHandlerFn handler;
} ApiRoute;

static ApiRoute routes[] = {
    { "/api/query", handle_query },
    { "/api/health", handle_health },
    { "/", handle_index }
};

#define NUM_ROUTES (sizeof(routes) / sizeof(routes[0]))

/// 请求调度器，根据 path 调用对应处理函数
void handle_api_request(Storage* store, const char* path, const char* body, char* response, int max_len) {
    for (size_t i = 0; i < NUM_ROUTES; ++i) {
        if (strcmp(path, routes[i].path) == 0) {
            routes[i].handler(store, body, response, max_len);
            return;
        }
    }

    // fallback: 尝试作为静态文件处理
    handle_static(store, body, response, max_len, path);
}

git tag -a v0.3.0 -m "release: v0.3.0：完成web的搭建"

sudo apt install check

#include <check.h>
#include "../include/storage.h"

START_TEST(test_set_and_get) {
    Storage* s = storage_create();
    ck_assert_int_eq(storage_set(s, "hello", "world"), 0);
    ck_assert_str_eq(storage_get(s, "hello"), "world");
    storage_free(s);
}
END_TEST

Suite* storage_suite(void) {
    Suite* s;
    TCase* tc_core;

    s = suite_create("Storage");
    tc_core = tcase_create("Core");
    tcase_add_test(tc_core, test_set_and_get);
    suite_add_tcase(s, tc_core);

    return s;
}

int main(void) {
    int failed = 0;
    Suite* s = storage_suite();
    SRunner* runner = srunner_create(s);
    srunner_run_all(runner, CK_NORMAL);
    failed = srunner_ntests_failed(runner);
    srunner_free(runner);
    return (failed == 0) ? 0 : 1;
}

cmake_minimum_required(VERSION 3.10)
project(MiniKV C)

set(CMAKE_C_STANDARD 99)

# 包含头文件目录
include_directories(include)

# 主程序构建
add_executable(minikv
    src/main.c
    src/parser.c
    src/engine.c
    src/storage.c
)

# 构建测试程序
add_executable(test_storage
    test/test_storage.c
    src/storage.c
)

# 链接 Check 测试库（不依赖 find_package）
target_link_libraries(test_storage check subunit m pthread)

# 可选：启用测试集成（ctest）
enable_testing()
add_test(NAME StorageTest COMMAND test_storage)

cd build
cmake ..
make
ctest

gcc -g -o server main.c api_handler.c engine.c parser.c storage.c -o kvserver
gdb ./kvserver

Description: System tray for KDE3/GNOME2 docklet applications

sudo apt update
sudo apt install -y \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | \
    sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y \
    docker-ce \
    docker-ce-cli \
    containerd.io \
    docker-buildx-plugin \
    docker-compose-plugin

sudo sed -i 's|download.docker.com|mirrors.ustc.edu.cn/docker-ce|g' /etc/apt/sources.list.d/docker.list
sudo apt-get update

sudo usermod -aG docker $USER
newgrp docker

docker run hello-world

docker --version
# 示例：Docker version 24.x.x, build xxxxxxx

docker info
# 查看守护进程、存储驱动、是否 rootless 等信息

<h1>Hello,Docker.</h1>

mkdir docker
touch docker/Dockerfile
nvim docker/Dockerdile

FROM debian:bookworm

# 设置时区与非交互模式以防卡死
ENV DEBIAN_FRONTEND=noninteractive

# 安装构建和调试所需工具
RUN apt update && apt install -y \
    git \
    cmake \
    clang \
    check \
    gdb \
    curl \
    tree \
    build-essential \
    pkg-config \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# 创建工作目录并进入
WORKDIR /app

# 默认进入 shell，支持挂载 + 编译 + 调试
CMD ["/bin/bash"]

docker build -t minikv-dev ./docker

sudo systemctl daemon-reexec
sudo systemctl restart docker

sudo mkdir -p /etc/systemd/system/docker.service.d

sudo nano /etc/systemd/system/docker.service.d/http-proxy.conf

[Service]
Environment="HTTP_PROXY=http://192.168.31.35:7890"
Environment="HTTPS_PROXY=http://192.168.31.35:7890"
Environment="NO_PROXY=localhost,127.0.0.1"