mirror of
https://github.com/StarFleetCPTN/GoMFT.git
synced 2026-09-08 15:41:20 +02:00
StarFleetCPTN
db44823ecf
- Added logic to close the database connection after migrations to ensure a clean state. - Implemented reconnection to the database post-migrations to prevent potential issues. - Updated rclone connection logic to use 'host' instead of 'endpoint' for webdav and nextcloud providers, enhancing consistency in configuration arguments.
319 lines
10 KiB
Go
319 lines
10 KiB
Go
package rclone_service
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/starfleetcptn/gomft/internal/db"
|
|
)
|
|
|
|
// --- Mockable os/exec ---
|
|
|
|
// execCommandContext allows mocking exec.CommandContext during tests.
|
|
var execCommandContext = exec.CommandContext
|
|
|
|
// cmdCombinedOutput allows mocking the CombinedOutput method during tests.
|
|
var cmdCombinedOutput = (*exec.Cmd).CombinedOutput
|
|
|
|
// cmdRun allows mocking the Run method during tests.
|
|
var cmdRun = (*exec.Cmd).Run
|
|
|
|
// --- Function Implementation ---
|
|
|
|
// TestRcloneConnection attempts to connect to a provider using temporary config created via `rclone config create`.
|
|
// It returns success (bool), a message (string), and an error.
|
|
func TestRcloneConnection(config db.TransferConfig, providerType string, dbInstance *db.DB) (bool, string, error) {
|
|
var remoteName string
|
|
var remotePath string
|
|
var provider string
|
|
var host, user, pass, keyFile, region, accessKey, secretKey, endpoint, domain, clientID, clientSecret, driveID, teamDrive string
|
|
var port int
|
|
var err error
|
|
|
|
tempDir, err := os.MkdirTemp("", "gomft-rclone-test-")
|
|
if err != nil {
|
|
return false, "Failed to create temp directory for rclone config", err
|
|
}
|
|
defer os.RemoveAll(tempDir)
|
|
tempConfigPath := filepath.Join(tempDir, "rclone_test.conf")
|
|
|
|
if providerType == "source" {
|
|
remoteName = "testSource"
|
|
remotePath = config.SourcePath
|
|
provider = config.SourceType
|
|
host = config.SourceHost
|
|
port = config.SourcePort
|
|
user = config.SourceUser
|
|
pass = config.SourcePassword
|
|
keyFile = config.SourceKeyFile
|
|
region = config.SourceRegion
|
|
accessKey = config.SourceAccessKey
|
|
secretKey = config.SourceSecretKey
|
|
endpoint = config.SourceEndpoint
|
|
domain = config.SourceDomain
|
|
clientID = config.SourceClientID
|
|
clientSecret = config.SourceClientSecret
|
|
driveID = config.SourceDriveID
|
|
teamDrive = config.SourceTeamDrive
|
|
} else if providerType == "destination" {
|
|
remoteName = "testDest"
|
|
remotePath = config.DestinationPath
|
|
provider = config.DestinationType
|
|
host = config.DestHost
|
|
port = config.DestPort
|
|
user = config.DestUser
|
|
pass = config.DestPassword
|
|
keyFile = config.DestKeyFile
|
|
region = config.DestRegion
|
|
accessKey = config.DestAccessKey
|
|
secretKey = config.DestSecretKey
|
|
endpoint = config.DestEndpoint
|
|
domain = config.DestDomain
|
|
clientID = config.DestClientID
|
|
clientSecret = config.DestClientSecret
|
|
driveID = config.DestDriveID
|
|
teamDrive = config.DestTeamDrive
|
|
} else {
|
|
return false, "Invalid provider type specified", fmt.Errorf("unknown provider type: %s", providerType)
|
|
}
|
|
|
|
rclonePath := os.Getenv("RCLONE_PATH")
|
|
if rclonePath == "" {
|
|
rclonePath = "rclone"
|
|
}
|
|
|
|
primaryProvider := provider
|
|
|
|
// Convert hetzner to sftp
|
|
if provider == "hetzner" {
|
|
primaryProvider = "sftp"
|
|
}
|
|
|
|
// S3 compatible providers
|
|
if provider == "minio" || provider == "wasabi" {
|
|
primaryProvider = "s3"
|
|
}
|
|
|
|
createArgs := []string{
|
|
"config", "create", remoteName, primaryProvider,
|
|
"--config", tempConfigPath,
|
|
"--non-interactive",
|
|
"--log-level", "DEBUG",
|
|
}
|
|
|
|
var ctx context.Context
|
|
var cancel context.CancelFunc
|
|
var lsdArgs []string
|
|
var stdout, stderr bytes.Buffer
|
|
var lsdCmd *exec.Cmd
|
|
var createCmd *exec.Cmd
|
|
|
|
switch provider {
|
|
case "sftp", "hetzner":
|
|
createArgs = append(createArgs, "host", host, "user", user)
|
|
if port != 0 {
|
|
createArgs = append(createArgs, "port", fmt.Sprintf("%d", port))
|
|
}
|
|
if pass != "" {
|
|
createArgs = append(createArgs, "pass", pass)
|
|
}
|
|
if keyFile != "" {
|
|
createArgs = append(createArgs, "key_file", keyFile)
|
|
}
|
|
case "s3":
|
|
createArgs = append(createArgs, "provider", "AWS", "env_auth", "false")
|
|
if accessKey != "" {
|
|
createArgs = append(createArgs, "access_key_id", accessKey)
|
|
}
|
|
if secretKey != "" {
|
|
createArgs = append(createArgs, "secret_access_key", secretKey)
|
|
}
|
|
if region != "" {
|
|
createArgs = append(createArgs, "region", region)
|
|
}
|
|
if endpoint != "" {
|
|
createArgs = append(createArgs, "endpoint", endpoint)
|
|
}
|
|
case "wasabi":
|
|
createArgs = append(createArgs, "provider", "Wasabi", "env_auth", "false")
|
|
if accessKey != "" {
|
|
createArgs = append(createArgs, "access_key_id", accessKey)
|
|
}
|
|
if secretKey != "" {
|
|
createArgs = append(createArgs, "secret_access_key", secretKey)
|
|
}
|
|
if region != "" {
|
|
createArgs = append(createArgs, "region", region)
|
|
}
|
|
if endpoint != "" {
|
|
createArgs = append(createArgs, "endpoint", endpoint)
|
|
}
|
|
case "minio":
|
|
createArgs = append(createArgs, "provider", "Minio", "env_auth", "false")
|
|
if accessKey != "" {
|
|
createArgs = append(createArgs, "access_key_id", accessKey)
|
|
}
|
|
if secretKey != "" {
|
|
createArgs = append(createArgs, "secret_access_key", secretKey)
|
|
}
|
|
if region != "" {
|
|
createArgs = append(createArgs, "region", region)
|
|
}
|
|
if endpoint != "" {
|
|
createArgs = append(createArgs, "endpoint", endpoint)
|
|
}
|
|
case "b2":
|
|
createArgs = append(createArgs, "provider", "B2", "env_auth", "false")
|
|
if accessKey != "" {
|
|
createArgs = append(createArgs, "account", accessKey)
|
|
}
|
|
if secretKey != "" {
|
|
createArgs = append(createArgs, "key", secretKey)
|
|
}
|
|
if endpoint != "" {
|
|
createArgs = append(createArgs, "endpoint", endpoint)
|
|
}
|
|
if region != "" {
|
|
createArgs = append(createArgs, "region", region)
|
|
}
|
|
case "ftp":
|
|
createArgs = append(createArgs, "host", host, "user", user)
|
|
if port != 0 {
|
|
createArgs = append(createArgs, "port", fmt.Sprintf("%d", port))
|
|
}
|
|
if pass != "" {
|
|
createArgs = append(createArgs, "pass", pass)
|
|
}
|
|
if config.GetSourcePassiveMode() || config.GetDestPassiveMode() {
|
|
createArgs = append(createArgs, "passive_mode", "true")
|
|
} else {
|
|
createArgs = append(createArgs, "passive_mode", "false")
|
|
}
|
|
createArgs = append(createArgs, "explicit_tls", "true")
|
|
case "smb":
|
|
createArgs = append(createArgs, "host", host, "user", user)
|
|
if port != 0 {
|
|
createArgs = append(createArgs, "port", fmt.Sprintf("%d", port))
|
|
}
|
|
if pass != "" {
|
|
createArgs = append(createArgs, "pass", pass)
|
|
}
|
|
if domain != "" {
|
|
createArgs = append(createArgs, "domain", domain)
|
|
}
|
|
case "webdav":
|
|
createArgs = append(createArgs, "url", host, "vendor", "other", "user", user)
|
|
if pass != "" {
|
|
createArgs = append(createArgs, "pass", pass)
|
|
}
|
|
case "nextcloud":
|
|
createArgs = append(createArgs, "url", host, "vendor", "nextcloud", "user", user)
|
|
if pass != "" {
|
|
createArgs = append(createArgs, "pass", pass)
|
|
}
|
|
case "gdrive":
|
|
createArgs = append(createArgs, "scope", "drive")
|
|
if clientID != "" {
|
|
createArgs = append(createArgs, "client_id", clientID)
|
|
}
|
|
if clientSecret != "" {
|
|
createArgs = append(createArgs, "client_secret", clientSecret)
|
|
}
|
|
if driveID != "" {
|
|
createArgs = append(createArgs, "root_folder_id", driveID)
|
|
}
|
|
if teamDrive != "" {
|
|
createArgs = append(createArgs, "team_drive", teamDrive)
|
|
}
|
|
log.Println("Warning: Google Drive test may require pre-existing token or manual auth.")
|
|
case "gphotos":
|
|
if clientID != "" {
|
|
createArgs = append(createArgs, "client_id", clientID)
|
|
}
|
|
if clientSecret != "" {
|
|
createArgs = append(createArgs, "client_secret", clientSecret)
|
|
}
|
|
log.Println("Warning: Google Photos test may require pre-existing token or manual auth.")
|
|
case "local":
|
|
localConfigContent := fmt.Sprintf("[%s]\ntype = local\nnounc = true\n", remoteName)
|
|
if err := os.WriteFile(tempConfigPath, []byte(localConfigContent), 0600); err != nil {
|
|
return false, fmt.Sprintf("Failed to write temporary local config: %v", err), err
|
|
}
|
|
goto RunLsd
|
|
default:
|
|
return false, fmt.Sprintf("Provider type '%s' not yet supported for testing via 'rclone config create'", provider), fmt.Errorf("unsupported provider")
|
|
}
|
|
|
|
log.Printf("Executing rclone config create command: %s %s", rclonePath, strings.Join(createArgs, " "))
|
|
createCmd = execCommandContext(context.Background(), rclonePath, createArgs...)
|
|
// Use the mockable function variable
|
|
if output, err := cmdCombinedOutput(createCmd); err != nil {
|
|
configContentBytes, _ := os.ReadFile(tempConfigPath)
|
|
log.Printf("Temp config content on create error:\n---\n%s\n---", string(configContentBytes))
|
|
return false, fmt.Sprintf("Failed to create temp config section: %v\nOutput: %s", err, string(output)), err
|
|
}
|
|
log.Printf("Successfully created temp config section for %s", remoteName)
|
|
|
|
RunLsd:
|
|
|
|
ctx, cancel = context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
lsdArgs = []string{
|
|
"--config", tempConfigPath,
|
|
"lsd",
|
|
fmt.Sprintf("%s:%s", remoteName, remotePath),
|
|
"--low-level-retries", "1",
|
|
"--retries", "1",
|
|
}
|
|
|
|
log.Printf("Executing rclone lsd command: %s %s", rclonePath, strings.Join(lsdArgs, " "))
|
|
lsdCmd = execCommandContext(ctx, rclonePath, lsdArgs...)
|
|
|
|
lsdCmd.Stdout = &stdout
|
|
lsdCmd.Stderr = &stderr
|
|
|
|
// Use the mockable function variable
|
|
err = cmdRun(lsdCmd)
|
|
|
|
stdoutStr := stdout.String()
|
|
stderrStr := stderr.String()
|
|
|
|
log.Printf("Rclone lsd stdout:\n%s", stdoutStr)
|
|
log.Printf("Rclone lsd stderr:\n%s", stderrStr)
|
|
|
|
if err != nil {
|
|
if errors.Is(err, context.DeadlineExceeded) {
|
|
return false, "Connection test timed out after 30 seconds.", context.DeadlineExceeded
|
|
}
|
|
// Check ctx.Err() as a fallback - This check might be redundant now
|
|
if ctx.Err() == context.DeadlineExceeded {
|
|
return false, "Connection test timed out after 30 seconds.", ctx.Err()
|
|
}
|
|
|
|
errMsg := fmt.Sprintf("Connection test failed: %v. Stderr: %s", err, stderrStr)
|
|
if strings.Contains(stderrStr, "connect: connection refused") {
|
|
errMsg = "Connection test failed: Connection refused by host."
|
|
} else if strings.Contains(stderrStr, "no such host") || strings.Contains(stderrStr, "name resolution error") {
|
|
errMsg = "Connection test failed: Hostname not found or DNS resolution error."
|
|
} else if strings.Contains(stderrStr, "authentication failed") || strings.Contains(stderrStr, "login incorrect") || strings.Contains(stderrStr, "permission denied") {
|
|
errMsg = "Connection test failed: Authentication failed (check credentials/permissions)."
|
|
} else if strings.Contains(stderrStr, "directory not found") {
|
|
errMsg = "Connection test failed: Directory/Path not found (check path)."
|
|
} else if strings.Contains(stderrStr, "Couldn't find section") {
|
|
errMsg = "Connection test failed: Invalid parameters provided for provider type."
|
|
}
|
|
return false, errMsg, err
|
|
}
|
|
|
|
return true, "Connection test successful!", nil
|
|
}
|