Add WebDAV server files

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+COPY start.sh .
+RUN chmod +x start.sh
+
+EXPOSE 7860
+CMD ["/app/start.sh"]

app.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""WebDAV server backed by Hugging Face Hub (dataset storage)."""
+
+import os
+import io
+import logging
+import stat
+from datetime import datetime, timezone
+from typing import Optional
+
+from wsgidav.wsgidav_app import WsgiDAVApp
+from wsgidav.dav_provider import DAVProvider, DAVCollection, DAVNonCollection
+
+from huggingface_hub import HfFileSystem, hf_hub_download
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ── Configuration ──────────────────────────────────────────────
+HF_REPO_ID = os.environ.get("HF_REPO_ID", "e2dew32/cloud-drive")
+HF_REPO_TYPE = "dataset"
+
+fs = HfFileSystem()
+REPO_ROOT = f"{HF_REPO_TYPE}s/{HF_REPO_ID}"
+
+
+def _norm(path: str) -> str:
+    """Normalise a WebDAV path to an HF path."""
+    path = path.strip("/")
+    return f"{REPO_ROOT}/{path}" if path else REPO_ROOT
+
+
+def _stat(path: str) -> dict:
+    """Return info dict for a file or directory."""
+    try:
+        info = fs.info(path)
+        return info
+    except Exception:
+        return {}
+
+
+# ── DAV Provider ───────────────────────────────────────────────
+class HFDAVProvider(DAVProvider):
+    """Expose HF Hub storage as a WebDAV tree."""
+
+    def __init__(self):
+        super().__init__()
+
+    def get_resource_inst(self, path, environ):
+        norm = _norm(path)
+        info = _stat(norm)
+        if not info:
+            return None
+
+        if info["type"] == "directory":
+            return HFDavCollection(path, environ, info)
+        return HFDavNonCollection(path, environ, info)
+
+    def is_collection(self, path):
+        info = _stat(_norm(path))
+        return info.get("type") == "directory"
+
+
+class HFDavCollection(DAVCollection):
+    def __init__(self, path, environ, info):
+        super().__init__(path, environ)
+        self._info = info
+
+    def get_display_name(self):
+        return self.path.rstrip("/").split("/")[-1] or "/"
+
+    def get_member_names(self):
+        norm = _norm(self.path)
+        entries = fs.ls(norm, detail=False)
+        names = []
+        for e in entries:
+            # e is like "datasets/e2dew32/cloud-drive/foo.txt"
+            name = e.rsplit("/", 1)[-1]
+            names.append(name)
+        return names
+
+    def get_member(self, name):
+        child_path = self.path.rstrip("/") + "/" + name
+        return self.provider.get_resource_inst(child_path, self.environ)
+
+    def create_empty_resource(self, name):
+        """Called when client does PUT with no body first."""
+        return HFDavNonCollection(
+            self.path.rstrip("/") + "/" + name, self.environ, {}
+        )
+
+    def create_collection(self, name):
+        """MKCOL – create a directory."""
+        new_path = self.path.rstrip("/") + "/" + name
+        try:
+            fs.mkdir(_norm(new_path), exist_ok=True)
+        except Exception as e:
+            logger.error(f"mkdir failed: {e}")
+
+    def get_creation_date(self):
+        return datetime.now(timezone.utc)
+
+    def get_modified_date(self):
+        return datetime.now(timezone.utc)
+
+    def get_content_length(self):
+        return 0
+
+    def get_content_type(self):
+        return "httpd/unix-directory"
+
+    def is_collection(self):
+        return True
+
+    def is_property_locked(self, name):
+        return False
+
+    def get_property_names(self, is_allprop):
+        return []
+
+    def get_property_value(self, name):
+        return None
+
+    def support_recursive_delete(self, path):
+        return True
+
+    def delete(self):
+        norm = _norm(self.path)
+        try:
+            # Recursively delete contents
+            entries = fs.ls(norm, detail=False)
+            for e in entries:
+                rel = e.replace(f"{REPO_ROOT}/", "")
+                if fs.isdir(e):
+                    try:
+                        fs.rm(e, recursive=True)
+                    except Exception:
+                        pass
+                else:
+                    try:
+                        fs.rm(e)
+                    except Exception:
+                        pass
+            fs.rmdir(norm)
+        except Exception as e:
+            logger.error(f"delete collection failed: {e}")
+
+
+class HFDavNonCollection(DAVNonCollection):
+    def __init__(self, path, environ, info):
+        super().__init__(path, environ)
+        self._info = info
+
+    def get_display_name(self):
+        return self.path.rstrip("/").split("/")[-1]
+
+    def get_content_length(self):
+        return self._info.get("size", 0)
+
+    def get_content_type(self):
+        name = self.get_display_name()
+        if "." in name:
+            ext = name.rsplit(".", 1)[-1].lower()
+            types = {
+                "txt": "text/plain",
+                "md": "text/markdown",
+                "json": "application/json",
+                "html": "text/html",
+                "css": "text/css",
+                "js": "application/javascript",
+                "xml": "application/xml",
+                "csv": "text/csv",
+                "jpg": "image/jpeg",
+                "jpeg": "image/jpeg",
+                "png": "image/png",
+                "gif": "image/gif",
+                "svg": "image/svg+xml",
+                "pdf": "application/pdf",
+                "zip": "application/zip",
+                "mp3": "audio/mpeg",
+                "mp4": "video/mp4",
+            }
+            return types.get(ext, "application/octet-stream")
+        return "application/octet-stream"
+
+    def get_creation_date(self):
+        return datetime.now(timezone.utc)
+
+    def get_modified_date(self):
+        mtime = self._info.get("last_commit", {}).get("date")
+        if mtime:
+            try:
+                return datetime.fromisoformat(mtime.replace("Z", "+00:00"))
+            except Exception:
+                pass
+        return datetime.now(timezone.utc)
+
+    def get_content(self):
+        norm = _norm(self.path)
+        try:
+            with fs.open(norm, "rb") as f:
+                return io.BytesIO(f.read())
+        except Exception as e:
+            logger.error(f"read failed: {e}")
+            return io.BytesIO(b"")
+
+    def begin_write(self, content_type=None):
+        norm = _norm(self.path)
+        logger.info(f"begin_write: {norm}")
+        return HFWriteBuffer(norm)
+
+    def is_property_locked(self, name):
+        return False
+
+    def get_property_names(self, is_allprop):
+        return []
+
+    def get_property_value(self, name):
+        return None
+
+    def delete(self):
+        norm = _norm(self.path)
+        try:
+            fs.rm(norm)
+        except Exception as e:
+            logger.error(f"delete file failed: {e}")
+
+    def move_dest(self, dest_provider, dest_path, recursive, dry_run, environ):
+        """Handle MOVE (rename)."""
+        src_norm = _norm(self.path)
+        dst_norm = _norm(dest_path)
+        logger.info(f"MOVE {src_norm} -> {dst_norm}")
+        try:
+            # Download locally then upload to new path
+            data = fs.cat(src_norm)
+            fs.pipe(dst_norm, data)
+            fs.rm(src_norm)
+        except Exception as e:
+            logger.error(f"move failed: {e}")
+
+    def copy(self, dest_provider, dest_path, environ, depth="infinity", dry_run=False):
+        """Handle COPY."""
+        src_norm = _norm(self.path)
+        dst_norm = _norm(dest_path)
+        logger.info(f"COPY {src_norm} -> {dst_norm}")
+        try:
+            data = fs.cat(src_norm)
+            fs.pipe(dst_norm, data)
+        except Exception as e:
+            logger.error(f"copy failed: {e}")
+
+
+class HFWriteBuffer(io.BytesIO):
+    """Buffer for writing file content to HF Hub."""
+
+    def __init__(self, path):
+        super().__init__()
+        self.path = path
+
+    def close(self):
+        data = self.getvalue()
+        try:
+            fs.pipe(self.path, data)
+            logger.info(f"Written {len(data)} bytes to {self.path}")
+        except Exception as e:
+            logger.error(f"Write failed: {e}")
+        super().close()
+
+
+# ── WsgiDAVApp setup ──────────────────────────────────────────
+def create_app():
+    user = os.environ.get("WEBDAV_USER", "user")
+    passwd = os.environ.get("WEBDAV_PASS", "pass")
+
+    app = WsgiDAVApp(
+        {
+            "host": "0.0.0.0",
+            "port": 7860,
+            "provider_mapping": {"/": HFDAVProvider()},
+            "simple_dc": {
+                "user_mapping": {"*": {user: {"password": passwd, "roles": ["admin"]}}}
+            },
+            "verbose": 1,
+        }
+    )
+    return app
+
+
+if __name__ == "__main__":
+    from cheroot.wsgi import Server
+
+    app = create_app()
+    server = Server(("0.0.0.0", 7860), app)
+    logger.info("Starting WebDAV server on :7860")
+    try:
+        server.start()
+    except KeyboardInterrupt:
+        server.stop()

requirements.txt

@@ -0,0 +1,3 @@
+wsgidav
+huggingface_hub
+cheroot

start.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+echo "=== Starting HF WebDAV Server ==="
+echo "Repo: ${HF_REPO_ID:-e2dew32/cloud-drive}"
+echo "Type: ${HF_REPO_TYPE:-dataset}"
+echo "WebDAV user: ${WEBDAV_USER:-user}"
+echo ""
+
+python3 /app/app.py