Merge branch 'main' into feat/opfs

Author: asukaminato0721

.env.example

@@ -207,3 +207,8 @@ OPENDAL_ALIYUN_DRIVE_ROOT=/path/to/dir
 OPENDAL_ALIYUN_DRIVE_REFRESH_TOKEN=<refresh_token>
 OPENDAL_ALIYUN_DRIVE_CLIENT_ID=<client_id>
 OPENDAL_ALIYUN_DRIVE_CLIENT_SECRET=<client_secret>
+# cloudflare
+OPENDAL_CLOUDFLARE_KV_ROOT=/path/to/dir
+OPENDAL_CLOUDFLARE_KV_API_TOKEN=<api_token>
+OPENDAL_CLOUDFLARE_KV_ACCOUNT_ID=<account_id>
+OPENDAL_CLOUDFLARE_KV_NAMESPACE_ID=<namespace_id>

.github/actions/test_behavior_bin_ofs/action.yaml

@@ -41,7 +41,7 @@ runs:
           - name: Run Test Ofs
             shell: bash
             working-directory: bin/ofs
-            run: cargo test --features ${{ inputs.feature }} --no-default-features -- --nocapture
+            run: cargo test --features ${{ inputs.feature }} --no-default-features -- --no-capture
             env:
               OPENDAL_TEST: ${{ inputs.service }}
               # Remove me after we find out what happened

bindings/d/README.md

@@ -11,6 +11,8 @@ To compile OpenDAL d binding from source code, you need:
 - [dmd/ldc/gdc](https://dlang.org/download)
 
 ```bash
+# Test a specific backend
+export OPENDAL_TEST=memory
 # build libopendal_c (underneath call make -C ../c)
 dub build -b release
 # build and run unit tests

bindings/d/build.d

@@ -1,42 +1,231 @@
+#!/usr/bin/env dub
+/+ dub.sdl:
+    name "build"
+    dependency "std" version="*"
++/
+
+/**
+ * OpenDAL D Bindings Build Script
+ *
+ * This script builds the OpenDAL C library with specified features
+ * and copies the necessary files for D bindings.
+ *
+ * This script is automatically executed during:
+ *   dub build
+ *   dub test
+ *   dub run
+ *
+ * For manual execution with custom options:
+ *   OPENDAL_TEST=memory dmd -run build.d
+ *   OPENDAL_TEST=fs OPENDAL_VERBOSE=1 dmd -run build.d release
+ */
 module build;
-import std.stdio: writeln;
-import std.path: buildPath;
-import std.process: spawnShell, wait;
-import std.exception;
-import std.file: copy, mkdir, exists;
-import std.conv: to;
+
+import std.stdio : writeln, stderr;
+import std.path : buildPath;
+import std.process : spawnShell, wait, environment;
+import std.exception : enforce;
+import std.file : copy, mkdir, exists;
+import std.conv : to;
+import std.string : startsWith, split, strip, toLower;
+import std.array : join;
+
 
 version (Windows)
     enum staticlib = "opendal_c.lib";
 else
     enum staticlib = "libopendal_c.a";
 
-void main (string[] args)
+struct BuildConfig
 {
-    bool isRelease = args.length > 1 && args[1] == "release";
-    string buildType = isRelease ? "release" : "debug";
+    bool isRelease;
+    string[] services;
+    bool verbose;
+    bool help;
+}
 
-    // Run cargo build
-    auto cargoCmd = "cargo build --manifest-path " ~ buildPath(
-        "..", "c", "Cargo.toml") ~ (isRelease ? " --release" : "");
+void printHelp()
+{
+    writeln("OpenDAL D Bindings Build Script");
+    writeln();
+    writeln("This script is automatically executed during:");
+    writeln("  dub build    - Build the D bindings");
+    writeln("  dub test     - Run unit tests");
+    writeln("  dub run      - Build and run examples");
+    writeln();
+    writeln("Environment Variables (for use with dub commands):");
+    writeln("  OPENDAL_TEST         The service to test (e.g., fs, s3, memory, etc.)");
+    writeln("  OPENDAL_{SERVICE}_*  Service-specific configuration (e.g., OPENDAL_FS_ROOT)");
+    writeln("  OPENDAL_VERBOSE      Set to '1' or 'true' for verbose output");
+    writeln();
+    writeln("Examples with environment variables:");
+    writeln("  OPENDAL_TEST=memory dub build");
+    writeln("  OPENDAL_TEST=fs OPENDAL_FS_ROOT=/tmp/test dub test");
+    writeln("  OPENDAL_TEST=memory OPENDAL_VERBOSE=1 dub build -b release");
+    writeln();
+    writeln("For manual execution with command line options:");
+    writeln("  dmd -run build.d [options]");
+    writeln();
+    writeln("Command line options:");
+    writeln("  release              Build in release mode (default: debug)");
+    writeln("  --verbose            Enable verbose output");
+    writeln("  --help               Show this help message");
+    writeln();
+    writeln("Manual execution examples:");
+    writeln("  OPENDAL_TEST=memory dmd -run build.d");
+    writeln("  OPENDAL_TEST=fs OPENDAL_FS_ROOT=/tmp/test dmd -run build.d release");
+    writeln("  OPENDAL_TEST=fs OPENDAL_FS_ROOT=/tmp OPENDAL_VERBOSE=1 dmd -run build.d release");
+}
 
-    auto status = wait(spawnShell(cargoCmd));
-    if (status != 0)
+BuildConfig parseArgs(string[] args)
+{
+    BuildConfig config;
+    config.services = []; // No default services - user must specify
+
+    // Check environment variables first
+    auto envTest = environment.get("OPENDAL_TEST", "");
+    if (envTest.length > 0)
     {
-        throw new Exception("Cargo build failed with status: " ~ status.to!string);
+        config.services = [envTest];
     }
-    else
+
+    auto envVerbose = environment.get("OPENDAL_VERBOSE", "");
+    if (envVerbose == "1" || envVerbose.toLower() == "true")
     {
-        writeln("Cargo build completed successfully");
+        config.verbose = true;
+    }
+
+    foreach (arg; args[1..$])
+    {
+        if (arg == "release")
+        {
+            config.isRelease = true;
+        }
+        else if (arg == "--verbose")
+        {
+            config.verbose = true;
+        }
+        else if (arg == "--help" || arg == "-h")
+        {
+            config.help = true;
+        }
+
+        else
+        {
+            stderr.writeln("Unknown argument: ", arg);
+            stderr.writeln("Use --help for usage information");
+        }
     }
 
-    // Get opendal.h
-    copy(buildPath("..", "c", "include", "opendal.h"), buildPath("source", "opendal", "opendal.h"));
+    return config;
+}
+
+void buildCargoLibrary(BuildConfig config)
+{
+    // Check if services are specified
+    if (config.services.length == 0)
+    {
+        stderr.writeln("Warning: No OpenDAL service specified for testing!");
+        stderr.writeln("Use OPENDAL_TEST environment variable to specify the service to test.");
+        stderr.writeln("Example: OPENDAL_TEST=memory dub build");
+        stderr.writeln("Available services: memory, fs, s3, etc. (see OpenDAL documentation)");
+        stderr.writeln();
+        stderr.writeln("Building with only core functionality (no storage backends)...");
+    }
+
+    // Build features list
+    string[] features = ["opendal/blocking"];
+    foreach (service; config.services)
+    {
+        features ~= "opendal/services-" ~ service.strip();
+    }
+
+    // Construct cargo command
+    auto cargoCmd = "cargo build --manifest-path " ~ buildPath("..", "c", "Cargo.toml");
+
+    if (config.isRelease)
+        cargoCmd ~= " --release";
+
+    cargoCmd ~= " --features \"" ~ features.join(",") ~ "\"";
+
+    if (config.verbose)
+        cargoCmd ~= " --verbose";
+
+    writeln("Building OpenDAL C library...");
+    writeln("Features: ", features.join(", "));
+    if (config.verbose)
+        writeln("Command: ", cargoCmd);
 
-    // Get libopendal_c.a
-    auto libPath = buildPath("..", "c", "target", buildType, staticlib);
-    writeln("Copying ", libPath, " to ", buildPath("lib", staticlib));
+    auto status = wait(spawnShell(cargoCmd));
+    enforce(status == 0, "Cargo build failed with status: " ~ status.to!string);
+
+    writeln("✓ Cargo build completed successfully");
+}
+
+void copyArtifacts(BuildConfig config)
+{
+    string buildType = config.isRelease ? "release" : "debug";
+
+    writeln("Copying build artifacts...");
+
+    // Copy header file
+    auto headerSrc = buildPath("..", "c", "include", "opendal.h");
+    auto headerDst = buildPath("source", "opendal", "opendal.h");
+
+    if (config.verbose)
+        writeln("Copying header: ", headerSrc, " -> ", headerDst);
+
+    copy(headerSrc, headerDst);
+
+    // Ensure lib directory exists
     if (!exists("lib"))
-        mkdir ("lib");
-    copy(libPath, buildPath("lib", staticlib));
+    {
+        if (config.verbose)
+            writeln("Creating lib directory");
+        mkdir("lib");
+    }
+
+    // Copy static library
+    auto libSrc = buildPath("..", "c", "target", buildType, staticlib);
+    auto libDst = buildPath("lib", staticlib);
+
+    if (config.verbose)
+        writeln("Copying library: ", libSrc, " -> ", libDst);
+
+    copy(libSrc, libDst);
+
+    writeln("✓ Build artifacts copied successfully");
+}
+
+void main(string[] args)
+{
+    try
+    {
+        auto config = parseArgs(args);
+
+        if (config.help)
+        {
+            printHelp();
+            return;
+        }
+
+        writeln("OpenDAL D Bindings Build");
+        writeln("========================");
+        writeln("Build mode: ", config.isRelease ? "release" : "debug");
+        writeln("Services: ", config.services.join(", "));
+        writeln();
+
+        buildCargoLibrary(config);
+        copyArtifacts(config);
+
+        writeln();
+        writeln("✓ Build completed successfully!");
+        writeln("Ready for: dub build, dub test, or dub run");
+    }
+    catch (Exception e)
+    {
+        stderr.writeln("❌ Build failed: ", e.msg);
+        import core.stdc.stdlib : exit;
+        exit(1);
+    }
 }