@filebox/s3-server 1.0.0 → 1.0.1

package/handlers/listObjects.js

@@ -1,230 +0,0 @@
-const Responses = require("../responses");
-const path = require("path");
-
-/**
- * 处理S3 ListObjects(V2)请求
- * 列出存储桶中的对象
- */
-class ListObjects {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 解析请求查询参数
-   * @param {object} req - Express请求对象
-   * @returns {object} 解析后的参数
-   */
-  parseQueryParams(req) {
-    if (!req || !req.query) {
-      return { prefix: "", delimiter: "" };
-    }
-
-    return {
-      prefix:
-        typeof req.query.prefix === "string" && req.query.prefix.length > 0
-          ? req.query.prefix
-          : "",
-      delimiter:
-        typeof req.query.delimiter === "string" &&
-        req.query.delimiter.length > 0
-          ? req.query.delimiter
-          : "",
-    };
-  }
-
-  /**
-   * 规范化前缀
-   * @param {string} prefix - 原始前缀
-   * @returns {string} 规范化后的前缀
-   */
-  normalizePrefix(prefix) {
-    let trimmed = decodeURIComponent(prefix).trim();
-
-    if (
-      trimmed.length === 0 ||
-      trimmed === "/" ||
-      trimmed.startsWith("./") ||
-      trimmed.startsWith("../") ||
-      trimmed.includes("../")
-    ) {
-      return "/";
-    }
-
-    if (!trimmed.startsWith("/")) {
-      trimmed = `/${trimmed}`;
-    }
-
-    return trimmed;
-  }
-
-  /**
-   * 处理ListObjects请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 检查是否为位置查询
-      if (req.url.includes("?location")) {
-        await Responses.getBucketLocation(
-          res,
-          this.server.config.region || "default",
-        );
-        return;
-      }
-
-      // 获取存储桶和键
-      const { bucket } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      // 解析查询参数
-      const params = this.parseQueryParams(req);
-      const normalizedPrefix = this.normalizePrefix(params.prefix);
-
-      // 构建目录路径
-      let dirname = this.normalizePrefix(
-        normalizedPrefix === "/"
-          ? `/${bucket}`
-          : path.posix.dirname(path.posix.join(bucket, normalizedPrefix)),
-      );
-
-      const requestedPath = this.normalizePrefix(
-        path.posix.join(bucket, normalizedPrefix),
-      );
-
-      // 检查请求的路径是否存在
-      const requestedPathStats = await this.server.driver.stat(requestedPath);
-
-      if (requestedPathStats && requestedPathStats.isDirectory) {
-        dirname = requestedPath;
-      }
-
-      // 检查目录是否存在
-      const dirnameStats = await this.server.driver.stat(dirname);
-
-      if (!dirnameStats) {
-        await Responses.listObjectsV2(
-          res,
-          params.prefix,
-          [],
-          [],
-          bucket,
-          params.delimiter,
-        );
-        return;
-      }
-
-      // 读取目录内容
-      const depth = params.delimiter.length === 0 ? 10 : 0;
-      const dirContent = await this.readdir(dirname, depth);
-
-      // 处理目录内容
-      const objects = [];
-      const commonPrefixes = [];
-
-      for (const item of dirContent) {
-        const itemPath = path.posix.join(dirname, item);
-        const itemStats = await this.server.driver.stat(itemPath);
-
-        if (!itemStats) continue;
-
-        // 计算相对路径
-        const relativePath = itemPath.startsWith(`/${bucket}/`)
-          ? itemPath.slice(`/${bucket}/`.length)
-          : itemPath;
-
-        if (itemStats.isDirectory) {
-          commonPrefixes.push(`${relativePath}/`);
-        } else {
-          objects.push({
-            path: relativePath,
-            mtimeMs: itemStats.mtime || Date.now(),
-            size: itemStats.size || 0,
-            uuid: itemStats.uuid || crypto.randomUUID(),
-          });
-        }
-      }
-
-      // 返回对象列表
-      await Responses.listObjectsV2(
-        res,
-        normalizedPrefix === "/" ? "/" : normalizedPrefix.slice(1),
-        objects,
-        commonPrefixes,
-        bucket,
-        params.delimiter,
-      );
-    } catch (error) {
-      console.error("Error in ListObjects:", error);
-      await Responses.error(res, 500, "InternalError", "服务器内部错误");
-    }
-  }
-
-  /**
-   * 从请求参数中提取存储桶和键
-   * @param {object} req - Express请求对象
-   * @returns {object} 包含存储桶和键的对象
-   */
-  extractBucketAndKey(req) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const pathParts = url.pathname.split("/").filter(Boolean);
-
-    return {
-      bucket: pathParts[0],
-      key: pathParts.slice(1).join("/"),
-    };
-  }
-
-  /**
-   * 读取目录内容
-   * @param {string} dirPath - 目录路径
-   * @param {number} depth - 递归深度
-   * @returns {Promise<Array>} 目录内容列表
-   */
-  async readdir(dirPath, depth) {
-    try {
-      // 基本情况：不递归
-      if (depth <= 0) {
-        return await this.server.driver.readdir(dirPath);
-      }
-
-      const items = [];
-
-      // 递归读取目录
-      const traverse = async (currentPath, currentDepth) => {
-        if (currentDepth >= depth) {
-          return;
-        }
-
-        const entries = await this.server.driver.readdir(currentPath);
-
-        for (const entry of entries) {
-          const entryPath = path.posix.join(currentPath, entry);
-          const stats = await this.server.driver.stat(entryPath);
-
-          // 添加相对路径
-          items.push(entryPath.slice(dirPath.length));
-
-          // 如果是目录且未达到最大深度，则递归
-          if (stats && stats.isDirectory) {
-            await traverse(entryPath, currentDepth + 1);
-          }
-        }
-      };
-
-      await traverse(dirPath, 0);
-      return items;
-    } catch (error) {
-      console.error("Error reading directory:", error);
-      return [];
-    }
-  }
-}
-
-module.exports = ListObjects;

package/handlers/putObject.js

@@ -1,158 +0,0 @@
-const Responses = require("../responses");
-const crypto = require("crypto");
-
-/**
- * 处理S3 PutObject请求
- * 上传对象到存储桶
- */
-class PutObject {
-  constructor(server) {
-    this.server = server;
-    this.handle = this.handle.bind(this);
-  }
-
-  /**
-   * 处理PutObject请求
-   * @param {object} req - Express请求对象
-   * @param {object} res - Express响应对象
-   */
-  async handle(req, res) {
-    try {
-      // 获取存储桶和键
-      const { bucket, key } = this.extractBucketAndKey(req);
-
-      if (!bucket) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      if (!key) {
-        await Responses.error(res, 400, "InvalidRequest", "无效的对象键");
-        return;
-      }
-
-      // 检查存储桶是否存在
-      const bucketExists = await this.server.driver.bucketExists(bucket);
-      if (!bucketExists) {
-        await Responses.error(res, 404, "NoSuchBucket", "存储桶不存在");
-        return;
-      }
-
-      // 构建对象路径
-      const objectPath = `/${bucket}/${key}`;
-
-      // 获取内容长度
-      const contentLength = parseInt(req.headers["content-length"] || "0", 10);
-
-      if (isNaN(contentLength) || contentLength < 0) {
-        await Responses.error(
-          res,
-          400,
-          "InvalidRequest",
-          "无效的Content-Length",
-        );
-        return;
-      }
-
-      // 创建写入流
-      const writeStream =
-        await this.server.driver.createWriteStream(objectPath);
-
-      // 计算MD5哈希
-      const md5Hash = crypto.createHash("md5");
-
-      // 处理请求体。body-parser.raw 会先消费请求流并写入 req.body，
-      // 如果这里只监听 data/end，真实 S3 PUT 会一直等不到 end。
-      let bytesWritten = 0;
-
-      await new Promise((resolve, reject) => {
-        let settled = false;
-        const rejectOnce = (error) => {
-          if (settled) return;
-          settled = true;
-          writeStream.destroy();
-          reject(error);
-        };
-        const complete = async () => {
-          if (settled) return;
-          settled = true;
-          try {
-            const etag = md5Hash.digest("hex");
-
-            await this.server.driver.updateObjectMetadata(objectPath, {
-              etag,
-              contentType:
-                req.headers["content-type"] || "application/octet-stream",
-              contentLength: bytesWritten,
-              lastModified: new Date(),
-            });
-
-            res.set("ETag", `"${etag}"`);
-            res.set("Date", new Date().toUTCString());
-            res.status(200).end();
-            resolve();
-          } catch (error) {
-            reject(error);
-          }
-        };
-
-        writeStream.on("error", rejectOnce);
-
-        const rawBody = req.body;
-        if (Buffer.isBuffer(rawBody) || rawBody instanceof Uint8Array) {
-          const chunk = Buffer.from(rawBody);
-          if (chunk.length > 0) {
-            writeStream.write(chunk);
-            md5Hash.update(chunk);
-            bytesWritten += chunk.length;
-          }
-          writeStream.end(() => void complete());
-          return;
-        }
-
-        if (typeof rawBody === "string") {
-          const chunk = Buffer.from(rawBody);
-          if (chunk.length > 0) {
-            writeStream.write(chunk);
-            md5Hash.update(chunk);
-            bytesWritten += chunk.length;
-          }
-          writeStream.end(() => void complete());
-          return;
-        }
-
-        req.on("data", (chunk) => {
-          writeStream.write(chunk);
-          md5Hash.update(chunk);
-          bytesWritten += chunk.length;
-        });
-        req.on("end", () => {
-          writeStream.end(() => void complete());
-        });
-        req.on("error", rejectOnce);
-      });
-    } catch (error) {
-      console.error("Error in PutObject:", error);
-      if (!res.headersSent) {
-        await Responses.error(res, 500, "InternalError", "服务器内部错误");
-      }
-    }
-  }
-
-  /**
-   * 从请求参数中提取存储桶和键
-   * @param {object} req - Express请求对象
-   * @returns {object} 包含存储桶和键的对象
-   */
-  extractBucketAndKey(req) {
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const pathParts = url.pathname.split("/").filter(Boolean);
-
-    return {
-      bucket: pathParts[0],
-      key: pathParts.slice(1).join("/"),
-    };
-  }
-}
-
-module.exports = PutObject;

package/index.js

@@ -1,268 +0,0 @@
-const express = require("express");
-const http = require("http");
-const https = require("https");
-const bodyParser = require("body-parser");
-const crypto = require("crypto");
-const { v4: uuidv4 } = require("uuid");
-const createContext = require("./context");
-
-// 导入处理程序
-const ListBuckets = require("./handlers/listBuckets");
-const ListObjects = require("./handlers/listObjects");
-const GetObject = require("./handlers/getObject");
-const PutObject = require("./handlers/putObject");
-const DeleteObject = require("./handlers/deleteObject");
-const DeleteObjects = require("./handlers/deleteObjects");
-const HeadObject = require("./handlers/headObject");
-const HeadBucket = require("./handlers/headBucket");
-const CreateBucket = require("./handlers/createBucket");
-const DeleteBucket = require("./handlers/deleteBucket");
-
-/**
- * S3 服务器配置
- * @typedef {Object} S3ServerConfig
- * @property {string} hostname - 主机名
- * @property {number} port - 端口
- * @property {boolean} https - 是否启用HTTPS
- * @property {string} region - S3区域
- * @property {string} accessKeyId - 访问密钥ID
- * @property {string} secretAccessKey - 访问密钥
- * @property {string} [displayName] - 显示名称
- */
-
-/**
- * S3服务器
- */
-class S3Server {
-  /**
-   * 创建S3服务器实例
-   * @param {Object} config - 服务器配置
-   * @param {Object} driver - 存储驱动
-   */
-  constructor(config, driver) {
-    this.config = {
-      hostname: config.hostname || "0.0.0.0",
-      port: config.port || 9000,
-      https: config.https || false,
-      region: config.region || "default",
-      accessKeyId: config.accessKeyId || "accessKey1",
-      secretAccessKey: config.secretAccessKey || "verySecretKey1",
-      displayName: config.displayName || "S3 User",
-    };
-
-    this.driver = driver;
-    this.app = express();
-    this.server = null;
-
-    // 初始化处理程序
-    this.handlers = {
-      listBuckets: new ListBuckets(this),
-      listObjects: new ListObjects(this),
-      getObject: new GetObject(this),
-      putObject: new PutObject(this),
-      deleteObject: new DeleteObject(this),
-      deleteObjects: new DeleteObjects(this),
-      headObject: new HeadObject(this),
-      headBucket: new HeadBucket(this),
-      createBucket: new CreateBucket(this),
-      deleteBucket: new DeleteBucket(this),
-    };
-
-    // 配置中间件
-    this.setupMiddleware();
-
-    // 配置路由
-    this.setupRoutes();
-  }
-
-  /**
-   * 配置Express中间件
-   */
-  setupMiddleware() {
-    // 解析请求体
-    this.app.use(
-      bodyParser.raw({
-        type: "*/*",
-        limit: "10gb",
-      }),
-    );
-
-    // 身份验证中间件
-    this.app.use((req, res, next) => {
-      // 创建请求上下文
-      const ctx = createContext(req);
-      req.s3Context = ctx;
-
-      // 检查认证信息
-      if (this.config.accessKeyId && this.config.secretAccessKey) {
-        const { accessKeyId, secretAccessKey } = ctx.auth;
-
-        if (
-          accessKeyId !== this.config.accessKeyId ||
-          secretAccessKey !== this.config.secretAccessKey
-        ) {
-          res.status(403).send({
-            Error: {
-              Code: "AccessDenied",
-              Message: "访问被拒绝",
-            },
-          });
-          return;
-        }
-      }
-
-      next();
-    });
-
-    // 请求日志中间件
-    this.app.use((req, res, next) => {
-      console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
-      next();
-    });
-  }
-
-  /**
-   * 配置API路由
-   */
-  setupRoutes() {
-    // 根路径 - 列出所有存储桶
-    this.app.get("/", (req, res) => {
-      this.handlers.listBuckets.handle(req, res);
-    });
-
-    // 存储桶操作
-    this.app.head("/:bucket", (req, res) => {
-      this.handlers.headBucket.handle(req, res);
-    });
-
-    this.app.get("/:bucket", (req, res) => {
-      this.handlers.listObjects.handle(req, res);
-    });
-
-    this.app.put("/:bucket", (req, res) => {
-      this.handlers.createBucket.handle(req, res);
-    });
-
-    this.app.delete("/:bucket", (req, res) => {
-      this.handlers.deleteBucket.handle(req, res);
-    });
-
-    // 对象操作
-    this.app.head("/:bucket/*", (req, res) => {
-      this.handlers.headObject.handle(req, res);
-    });
-
-    this.app.get("/:bucket/*", (req, res) => {
-      this.handlers.getObject.handle(req, res);
-    });
-
-    this.app.put("/:bucket/*", (req, res) => {
-      this.handlers.putObject.handle(req, res);
-    });
-
-    this.app.delete("/:bucket/*", (req, res) => {
-      this.handlers.deleteObject.handle(req, res);
-    });
-
-    // 批量删除对象
-    this.app.post("/:bucket", (req, res) => {
-      if (req.query.delete !== undefined) {
-        this.handlers.deleteObjects.handle(req, res);
-      } else {
-        res.status(400).send({
-          Error: {
-            Code: "InvalidRequest",
-            Message: "无效的请求",
-          },
-        });
-      }
-    });
-
-    // 404处理
-    this.app.use((req, res) => {
-      res.status(404).send({
-        Error: {
-          Code: "NotFound",
-          Message: "请求的资源不存在",
-        },
-      });
-    });
-
-    // 错误处理
-    this.app.use((err, req, res, next) => {
-      console.error("Server error:", err);
-      res.status(500).send({
-        Error: {
-          Code: "InternalError",
-          Message: "服务器内部错误",
-        },
-      });
-    });
-  }
-
-  /**
-   * 启动服务器
-   * @returns {Promise<void>}
-   */
-  async start() {
-    return new Promise((resolve, reject) => {
-      try {
-        // 创建HTTP或HTTPS服务器
-        if (this.config.https) {
-          // 在实际环境中，应该提供有效的证书
-          const options = {
-            key: "...", // 私钥
-            cert: "...", // 证书
-          };
-          this.server = https.createServer(options, this.app);
-        } else {
-          this.server = http.createServer(this.app);
-        }
-
-        // 启动服务器
-        this.server.listen(this.config.port, this.config.hostname, () => {
-          console.log(
-            `S3服务器已启动: ${this.config.https ? "https" : "http"}://${this.config.hostname}:${this.config.port}`,
-          );
-          resolve();
-        });
-
-        // 错误处理
-        this.server.on("error", (err) => {
-          console.error("服务器启动失败:", err);
-          reject(err);
-        });
-      } catch (error) {
-        console.error("启动服务器时发生错误:", error);
-        reject(error);
-      }
-    });
-  }
-
-  /**
-   * 停止服务器
-   * @returns {Promise<void>}
-   */
-  async stop() {
-    return new Promise((resolve, reject) => {
-      if (!this.server) {
-        resolve();
-        return;
-      }
-
-      this.server.close((err) => {
-        if (err) {
-          console.error("停止服务器时发生错误:", err);
-          reject(err);
-          return;
-        }
-
-        console.log("S3服务器已停止");
-        this.server = null;
-        resolve();
-      });
-    });
-  }
-}
-
-module.exports = S3Server;