fix(alist): created missing parent directories before upload

Author: krau

storage/alist/alist.go

@@ -9,6 +9,7 @@ import (
 	"net/http"
 	"net/url"
 	"path"
+	"strings"
 	"sync"
 	"time"
 
@@ -122,6 +123,10 @@ func (a *Alist) Save(ctx context.Context, reader io.Reader, storagePath string)
 		}, 1000)
 	}
 
+	if err := a.mkdirAll(ctx, path.Dir(candidate)); err != nil {
+		return fmt.Errorf("failed to create parent directories: %w", err)
+	}
+
 	resp, err := a.putFile(ctx, reader, candidate)
 	if err != nil {
 		return err
@@ -200,6 +205,90 @@ func (a *Alist) JoinStoragePath(p string) string {
 	return path.Join(a.config.BasePath, p)
 }
 
+// mkdirAll creates the directory and any missing parents. Alist's upload API
+// returns FileNotFound when the parent directory does not exist, so callers
+// must ensure it before uploading. Existing directories are skipped.
+func (a *Alist) mkdirAll(ctx context.Context, dirPath string) error {
+	if dirPath == "" || dirPath == "/" || dirPath == "." {
+		return nil
+	}
+	segments := strings.Split(strings.Trim(dirPath, "/"), "/")
+	tokenRefreshed := false
+	for i := range segments {
+		current := "/" + strings.Join(segments[:i+1], "/")
+		if a.existsPath(ctx, current) {
+			continue
+		}
+		status, code, message, err := a.mkdirRequest(ctx, current)
+		if err != nil {
+			return err
+		}
+		if (status == http.StatusUnauthorized || status == http.StatusForbidden) && !tokenRefreshed {
+			// Stale token. Token-only storage cannot refresh; otherwise
+			// re-login once and retry this segment (the probe above runs
+			// again first, so an already-created directory is not an error).
+			if a.loginInfo == nil {
+				return fmt.Errorf("failed to create directory %s: %s", current, message)
+			}
+			if err := a.getToken(ctx); err != nil {
+				return fmt.Errorf("failed to refresh alist token: %w", err)
+			}
+			tokenRefreshed = true
+			if a.existsPath(ctx, current) {
+				continue
+			}
+			status, code, message, err = a.mkdirRequest(ctx, current)
+			if err != nil {
+				return err
+			}
+		}
+		if status != http.StatusOK {
+			return fmt.Errorf("failed to create directory %s: %s", current, message)
+		}
+		if code != http.StatusOK {
+			// The directory may have been created by a concurrent upload
+			// between the probe and the request.
+			if a.existsPath(ctx, current) {
+				continue
+			}
+			return fmt.Errorf("failed to create directory %s: %d, %s", current, code, message)
+		}
+	}
+	return nil
+}
+
+// mkdirRequest sends a single /api/fs/mkdir request and returns the HTTP
+// status, the response body code and message.
+func (a *Alist) mkdirRequest(ctx context.Context, p string) (int, int, string, error) {
+	bodyBytes, err := json.Marshal(fsMkdirRequest{Path: p})
+	if err != nil {
+		return 0, 0, "", fmt.Errorf("failed to marshal request body: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, a.baseURL+"/api/fs/mkdir", bytes.NewBuffer(bodyBytes))
+	if err != nil {
+		return 0, 0, "", fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Authorization", a.authHeader())
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := a.client.Do(req)
+	if err != nil {
+		return 0, 0, "", fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return resp.StatusCode, 0, resp.Status, nil
+	}
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0, 0, "", fmt.Errorf("failed to read response body: %w", err)
+	}
+	var mkResp fsSimpleResponse
+	if err := json.Unmarshal(data, &mkResp); err != nil {
+		return 0, 0, "", fmt.Errorf("failed to unmarshal mkdir response: %w", err)
+	}
+	return resp.StatusCode, mkResp.Code, mkResp.Message, nil
+}
+
 func (a *Alist) Exists(ctx context.Context, storagePath string) bool {
 	return a.existsPath(ctx, a.JoinStoragePath(storagePath))
 }

storage/alist/alist_test.go

@@ -17,11 +17,12 @@ import (
 // newAlistServer starts a fake alist whose login endpoint issues sequential
 // tokens and whose PUT endpoint rejects the given token (simulating an expired
 // credential) while accepting refreshed ones.
-func newAlistServer(t *testing.T, rejectedToken string) (*httptest.Server, *sync.Mutex, *int, *[]putRecord) {
+func newAlistServer(t *testing.T, rejectedToken string) (*httptest.Server, *sync.Mutex, *int, *[]putRecord, map[string]bool) {
 	t.Helper()
 	var mu sync.Mutex
 	loginCount := 0
 	tokenSeq := 0
+	createdDirs := map[string]bool{}
 	var puts []putRecord
 
 	mux := http.NewServeMux()
@@ -51,9 +52,41 @@ func newAlistServer(t *testing.T, rejectedToken string) (*httptest.Server, *sync
 		}
 		json.NewEncoder(w).Encode(map[string]any{"code": 200, "message": "ok"})
 	})
+	mux.HandleFunc("/api/fs/get", func(w http.ResponseWriter, r *http.Request) {
+		var body struct {
+			Path string `json:"path"`
+		}
+		json.NewDecoder(r.Body).Decode(&body)
+		mu.Lock()
+		defer mu.Unlock()
+		exists := body.Path == "/probe" || createdDirs[body.Path]
+		w.Header().Set("Content-Type", "application/json")
+		if !exists {
+			json.NewEncoder(w).Encode(map[string]any{"code": 500, "message": "object not found"})
+			return
+		}
+		json.NewEncoder(w).Encode(map[string]any{"code": 200, "message": "ok", "data": map[string]any{"is_dir": true}})
+	})
+	mux.HandleFunc("/api/fs/mkdir", func(w http.ResponseWriter, r *http.Request) {
+		var body struct {
+			Path string `json:"path"`
+		}
+		json.NewDecoder(r.Body).Decode(&body)
+		mu.Lock()
+		defer mu.Unlock()
+		if r.Header.Get("Authorization") == rejectedToken {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusUnauthorized)
+			json.NewEncoder(w).Encode(map[string]any{"code": 401, "message": "unauthorized"})
+			return
+		}
+		createdDirs[body.Path] = true
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]any{"code": 200, "message": "ok"})
+	})
 	srv := httptest.NewServer(mux)
 	t.Cleanup(srv.Close)
-	return srv, &mu, &loginCount, &puts
+	return srv, &mu, &loginCount, &puts, createdDirs
 }
 
 type putRecord struct {
@@ -66,7 +99,7 @@ type putRecord struct {
 // (token-1); the server rejects it, so the concurrent uploads must trigger a
 // second, merged login (token-2).
 func TestConcurrent401RetrySingleLogin(t *testing.T) {
-	srv, mu, loginCount, putAuths := newAlistServer(t, "token-1")
+	srv, mu, loginCount, putAuths, _ := newAlistServer(t, "token-1")
 
 	cfg := &storconfig.AlistStorageConfig{}
 	cfg.Name = "probe"
@@ -123,7 +156,7 @@ func TestConcurrent401RetrySingleLogin(t *testing.T) {
 // A token-only storage receives 401 and must return the auth error without
 // attempting a login (it has no credentials to refresh with).
 func TestTokenOnlyNoLoginOn401(t *testing.T) {
-	srv, mu, loginCount, _ := newAlistServer(t, "token-0")
+	srv, mu, loginCount, _, _ := newAlistServer(t, "token-0")
 
 	cfg := &storconfig.AlistStorageConfig{}
 	cfg.Name = "probe"
@@ -150,3 +183,37 @@ func TestTokenOnlyNoLoginOn401(t *testing.T) {
 		t.Fatalf("expected no login attempts for token-only storage, got %d", *loginCount)
 	}
 }
+
+// Regression for issue #239: uploading when the parent directory does not
+// exist made alist return FileNotFound (code 500) and the task layer retried
+// until exhaustion. Save must create missing parent directories first.
+func TestSaveCreatesMissingParentDirs(t *testing.T) {
+	srv, mu, loginCount, _, createdDirs := newAlistServer(t, "unused")
+
+	cfg := &storconfig.AlistStorageConfig{}
+	cfg.Name = "probe"
+	cfg.URL = srv.URL
+	cfg.Username = "user"
+	cfg.Password = "pass"
+	cfg.BasePath = "/probe"
+
+	stor := &alist.Alist{}
+	if err := stor.Init(t.Context(), cfg); err != nil {
+		t.Fatalf("Init failed: %v", err)
+	}
+
+	if err := stor.Save(t.Context(), bytes.NewReader([]byte("data")), "a/b/file.txt"); err != nil {
+		t.Fatalf("Save failed: %v", err)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	for _, dir := range []string{"/probe/a", "/probe/a/b"} {
+		if !createdDirs[dir] {
+			t.Fatalf("expected directory %s to be created", dir)
+		}
+	}
+	if *loginCount != 1 {
+		t.Fatalf("expected only the init login, got %d", *loginCount)
+	}
+}

storage/alist/types.go

@@ -89,3 +89,12 @@ type fsListResponse struct {
 		Provider string `json:"provider"`
 	} `json:"data"`
 }
+
+type fsMkdirRequest struct {
+	Path string `json:"path"`
+}
+
+type fsSimpleResponse struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}