feat!: (WIP) decouple storage, users, and configuration files to support multiple users

storage/alist/alist.go

@@ -1,19 +1,19 @@
 package alist
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"os"
+	"path"
 	"time"
 
 	"github.com/krau/SaveAny-Bot/config"
 	"github.com/krau/SaveAny-Bot/logger"
+	"github.com/krau/SaveAny-Bot/types"
 )
 
 type Alist struct {
@@ -21,154 +21,72 @@ type Alist struct {
 	token     string
 	baseURL   string
 	loginInfo *loginRequest
+	config    config.AlistConfig
 }
 
-var (
-	ErrAlistLoginFailed = errors.New("failed to login to Alist")
-)
-
-type loginRequest struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
-}
-
-type loginResponse struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-	Data    struct {
-		Token string `json:"token"`
-	} `json:"data"`
-}
-
-type meResponse struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-	Data    struct {
-		ID       int    `json:"id"`
-		Username string `json:"username"`
-	} `json:"data"`
-}
-
-type putResponse struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-	Data    struct {
-		Task struct {
-			ID       string `json:"id"`
-			Name     string `json:"name"`
-			State    int    `json:"state"`
-			Status   string `json:"status"`
-			Progress int    `json:"progress"`
-			Error    string `json:"error"`
-		} `json:"task"`
-	} `json:"data"`
-}
-
-func (a *Alist) getToken() error {
-	loginBody, err := json.Marshal(a.loginInfo)
-	if err != nil {
-		return fmt.Errorf("failed to marshal login request: %w", err)
+func (a *Alist) Init(model types.StorageModel) error {
+	var alistConfig config.AlistConfig
+	if err := json.Unmarshal([]byte(model.Config), &alistConfig); err != nil {
+		return fmt.Errorf("failed to unmarshal alist config: %w", err)
 	}
-
-	req, err := http.NewRequest(http.MethodPost, a.baseURL+"/api/auth/login", bytes.NewBuffer(loginBody))
-	if err != nil {
-		return fmt.Errorf("failed to create login request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := a.client.Do(req)
-	if err != nil {
-		return fmt.Errorf("failed to send login request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read login response: %w", err)
-	}
-
-	var loginResp loginResponse
-	if err := json.Unmarshal(body, &loginResp); err != nil {
-		return fmt.Errorf("failed to unmarshal login response: %w", err)
-	}
-
-	if loginResp.Code != http.StatusOK {
-		return fmt.Errorf("%w: %s", ErrAlistLoginFailed, loginResp.Message)
-	}
-
-	a.token = loginResp.Data.Token
-	return nil
-}
-
-func (a *Alist) refreshToken() {
-	for {
-		time.Sleep(time.Duration(config.Cfg.Storage.Alist.TokenExp) * time.Second)
-		if err := a.getToken(); err != nil {
-			logger.L.Errorf("Failed to refresh jwt token: %v", err)
-			continue
-		}
-		logger.L.Info("Refreshed Alist jwt token")
-	}
-}
-
-func (a *Alist) Init() {
-	a.baseURL = config.Cfg.Storage.Alist.URL
-	a.client = &http.Client{
-		Timeout: 12 * time.Hour,
-		Transport: &http.Transport{
-			TLSHandshakeTimeout: 10 * time.Second,
-		},
-	}
-	if config.Cfg.Storage.Alist.Token != "" {
-		a.token = config.Cfg.Storage.Alist.Token
+	a.config = alistConfig
+	a.baseURL = alistConfig.URL
+	a.client = getHttpClient()
+	if alistConfig.Token != "" {
+		a.token = alistConfig.Token
 		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
 		defer cancel()
 		req, err := http.NewRequestWithContext(ctx, http.MethodGet, a.baseURL+"/api/me", nil)
 		if err != nil {
 			logger.L.Fatalf("Failed to create request: %v", err)
-			os.Exit(1)
+			return err
 		}
 		req.Header.Set("Authorization", a.token)
 
 		resp, err := a.client.Do(req)
 		if err != nil {
 			logger.L.Fatalf("Failed to send request: %v", err)
-			os.Exit(1)
+			return err
 		}
 		defer resp.Body.Close()
 		if resp.StatusCode != http.StatusOK {
 			logger.L.Fatalf("Failed to get alist user info: %s", resp.Status)
-			os.Exit(1)
+			return err
 		}
 		body, err := io.ReadAll(resp.Body)
 		if err != nil {
 			logger.L.Fatalf("Failed to read response body: %v", err)
-			os.Exit(1)
+			return err
 		}
 		var meResp meResponse
 		if err := json.Unmarshal(body, &meResp); err != nil {
 			logger.L.Fatalf("Failed to unmarshal me response: %v", err)
-			os.Exit(1)
+			return err
 		}
 		if meResp.Code != http.StatusOK {
 			logger.L.Fatalf("Failed to get alist user info: %s", meResp.Message)
-			os.Exit(1)
+			return err
 		}
 		logger.L.Debugf("Logged in Alist as %s", meResp.Data.Username)
-		return
+		return nil
 	}
 	a.loginInfo = &loginRequest{
-		Username: config.Cfg.Storage.Alist.Username,
-		Password: config.Cfg.Storage.Alist.Password,
+		Username: alistConfig.Username,
+		Password: alistConfig.Password,
 	}
 
 	if err := a.getToken(); err != nil {
 		logger.L.Fatalf("Failed to login to Alist: %v", err)
-		os.Exit(1)
+		return err
 	}
 	logger.L.Debug("Logged in to Alist")
 
-	go a.refreshToken()
+	go a.refreshToken(alistConfig)
+	return nil
+}
+
+func (a *Alist) Type() types.StorageType {
+	return types.StorageTypeAlist
 }
 
 func (a *Alist) Save(ctx context.Context, filePath, storagePath string) error {
@@ -219,3 +137,7 @@ func (a *Alist) Save(ctx context.Context, filePath, storagePath string) error {
 
 	return nil
 }
+
+func (a *Alist) JoinStoragePath(task types.Task) string {
+	return path.Join(a.config.BasePath, task.StoragePath)
+}

storage/alist/token.go

@@ -0,0 +1,60 @@
+package alist
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/krau/SaveAny-Bot/config"
+	"github.com/krau/SaveAny-Bot/logger"
+)
+
+func (a *Alist) getToken() error {
+	loginBody, err := json.Marshal(a.loginInfo)
+	if err != nil {
+		return fmt.Errorf("failed to marshal login request: %w", err)
+	}
+
+	req, err := http.NewRequest(http.MethodPost, a.baseURL+"/api/auth/login", bytes.NewBuffer(loginBody))
+	if err != nil {
+		return fmt.Errorf("failed to create login request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := a.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send login request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read login response: %w", err)
+	}
+
+	var loginResp loginResponse
+	if err := json.Unmarshal(body, &loginResp); err != nil {
+		return fmt.Errorf("failed to unmarshal login response: %w", err)
+	}
+
+	if loginResp.Code != http.StatusOK {
+		return fmt.Errorf("%w: %s", ErrAlistLoginFailed, loginResp.Message)
+	}
+
+	a.token = loginResp.Data.Token
+	return nil
+}
+
+func (a *Alist) refreshToken(cfg config.AlistConfig) {
+	for {
+		time.Sleep(time.Duration(cfg.TokenExp) * time.Second)
+		if err := a.getToken(); err != nil {
+			logger.L.Errorf("Failed to refresh jwt token: %v", err)
+			continue
+		}
+		logger.L.Info("Refreshed Alist jwt token")
+	}
+}

storage/alist/types.go

@@ -0,0 +1,44 @@
+package alist
+
+import "errors"
+
+var (
+	ErrAlistLoginFailed = errors.New("failed to login to Alist")
+)
+
+type loginRequest struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+type loginResponse struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		Token string `json:"token"`
+	} `json:"data"`
+}
+
+type meResponse struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		ID       int    `json:"id"`
+		Username string `json:"username"`
+	} `json:"data"`
+}
+
+type putResponse struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		Task struct {
+			ID       string `json:"id"`
+			Name     string `json:"name"`
+			State    int    `json:"state"`
+			Status   string `json:"status"`
+			Progress int    `json:"progress"`
+			Error    string `json:"error"`
+		} `json:"task"`
+	} `json:"data"`
+}

storage/alist/utils.go

@@ -0,0 +1,23 @@
+package alist
+
+import (
+	"net/http"
+	"time"
+)
+
+var (
+	httpClient *http.Client
+)
+
+func getHttpClient() *http.Client {
+	if httpClient != nil {
+		return httpClient
+	}
+	httpClient = &http.Client{
+		Timeout: 12 * time.Hour,
+		Transport: &http.Transport{
+			TLSHandshakeTimeout: 10 * time.Second,
+		},
+	}
+	return httpClient
+}