Skip to content

SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.

9.6 KB
Raw Blame
package remote_cache

import (
	"fmt"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// TestRemoteCopyLocalBasic tests copying local-only files to remote
func TestRemoteCopyLocalBasic(t *testing.T) {
	checkServersRunning(t)

	testKey := fmt.Sprintf("copylocal-basic-%d.txt", time.Now().UnixNano())
	testData := createTestFile(t, testKey, 2048)

	// File is now local-only (not on remote yet)
	// Use remote.copy.local to copy it to remote
	t.Log("Copying local file to remote...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s", testBucket)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "remote.copy.local failed")
	t.Logf("Copy output: %s", output)

	// Verify file is still readable
	verifyFileContent(t, testKey, testData)

	// Now uncache and read again - should work if copied to remote
	uncacheLocal(t, testKey)
	time.Sleep(500 * time.Millisecond)
	verifyFileContent(t, testKey, testData)
}

// TestRemoteCopyLocalDryRun tests preview mode without actual copying
func TestRemoteCopyLocalDryRun(t *testing.T) {
	checkServersRunning(t)

	testKey := fmt.Sprintf("copylocal-dryrun-%d.txt", time.Now().UnixNano())
	createTestFile(t, testKey, 1024)

	// Run in dry-run mode
	t.Log("Running remote.copy.local in dry-run mode...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -dryRun=true", testBucket)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err)
	t.Logf("Dry-run output: %s", output)

	// Output should indicate what would be copied
	assert.Contains(t, strings.ToLower(output), "dry", "dry-run output should mention dry run")
}

// TestRemoteCopyLocalWithInclude tests copying only matching files
func TestRemoteCopyLocalWithInclude(t *testing.T) {
	checkServersRunning(t)

	// Create multiple files
	pdfFile := fmt.Sprintf("copylocal-doc-%d.pdf", time.Now().UnixNano())
	txtFile := fmt.Sprintf("copylocal-doc-%d.txt", time.Now().UnixNano())

	pdfData := createTestFile(t, pdfFile, 1024)
	txtData := createTestFile(t, txtFile, 1024)

	// Copy only PDF files
	t.Log("Copying only PDF files to remote...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -include=*.pdf", testBucket)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "remote.copy.local with include failed")
	t.Logf("Copy output: %s", output)

	// Verify both files are still readable
	verifyFileContent(t, pdfFile, pdfData)
	verifyFileContent(t, txtFile, txtData)
}

// TestRemoteCopyLocalWithExclude tests excluding pattern from copy
func TestRemoteCopyLocalWithExclude(t *testing.T) {
	checkServersRunning(t)

	// Create test files
	keepFile := fmt.Sprintf("copylocal-keep-%d.dat", time.Now().UnixNano())
	tmpFile := fmt.Sprintf("copylocal-temp-%d.tmp", time.Now().UnixNano())

	keepData := createTestFile(t, keepFile, 1024)
	tmpData := createTestFile(t, tmpFile, 1024)

	// Copy excluding .tmp files
	t.Log("Copying excluding .tmp files...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -exclude=*.tmp", testBucket)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "remote.copy.local with exclude failed")
	t.Logf("Copy output: %s", output)

	// Both should still be readable
	verifyFileContent(t, keepFile, keepData)
	verifyFileContent(t, tmpFile, tmpData)
}

// TestRemoteCopyLocalForceUpdate tests overwriting existing remote files
func TestRemoteCopyLocalForceUpdate(t *testing.T) {
	checkServersRunning(t)

	testKey := fmt.Sprintf("copylocal-force-%d.txt", time.Now().UnixNano())

	// Create and copy file to remote
	originalData := createTestFile(t, testKey, 1024)
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -include=%s", testBucket, testKey)
	_, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "initial copy failed")

	// Modify the file locally (simulate local change)
	newData := []byte("Updated content for force update test")
	uploadToPrimary(t, testKey, newData)
	time.Sleep(500 * time.Millisecond)

	// Copy again with force update
	t.Log("Copying with force update...")
	cmd = fmt.Sprintf("remote.copy.local -dir=/buckets/%s -include=%s -forceUpdate=true", testBucket, testKey)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "remote.copy.local with forceUpdate failed")
	t.Logf("Force update output: %s", output)

	// Verify new content
	verifyFileContent(t, testKey, newData)

	// Uncache and verify it was updated on remote
	uncacheLocal(t, testKey)
	time.Sleep(500 * time.Millisecond)
	verifyFileContent(t, testKey, newData)

	// Clean up - restore original for other tests
	uploadToPrimary(t, testKey, originalData)
}

// TestRemoteCopyLocalConcurrency tests parallel copy operations
func TestRemoteCopyLocalConcurrency(t *testing.T) {
	checkServersRunning(t)

	// Create multiple files
	var files []string
	var dataMap = make(map[string][]byte)

	for i := 0; i < 5; i++ {
		key := fmt.Sprintf("copylocal-concurrent-%d-%d.bin", time.Now().UnixNano(), i)
		data := createTestFile(t, key, 2048)
		files = append(files, key)
		dataMap[key] = data
		time.Sleep(10 * time.Millisecond) // Small delay to ensure unique timestamps
	}

	// Copy with high concurrency
	t.Log("Copying with concurrency=8...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -concurrent=8", testBucket)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "remote.copy.local with concurrency failed")
	t.Logf("Copy output: %s", output)

	// Verify all files are still readable
	for _, file := range files {
		verifyFileContent(t, file, dataMap[file])
	}
}

// TestRemoteCopyLocalEmptyDirectory tests handling empty directories
func TestRemoteCopyLocalEmptyDirectory(t *testing.T) {
	checkServersRunning(t)

	// Try to copy from a directory with no local-only files
	// (all files are already synced to remote)
	t.Log("Testing copy from directory with no local-only files...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s", testBucket)
	output, err := runWeedShellWithOutput(t, cmd)

	// Should not error, just report nothing to copy
	require.NoError(t, err, "remote.copy.local should handle empty directory gracefully")
	t.Logf("Empty directory output: %s", output)
}

// TestRemoteCopyLocalLargeFile tests copying large files
func TestRemoteCopyLocalLargeFile(t *testing.T) {
	checkServersRunning(t)

	testKey := fmt.Sprintf("copylocal-large-%d.bin", time.Now().UnixNano())

	// Create a 10MB file
	t.Log("Creating 10MB test file...")
	testData := createTestFile(t, testKey, 10*1024*1024)

	// Copy to remote
	t.Log("Copying large file to remote...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -include=%s", testBucket, testKey)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "remote.copy.local large file failed")
	t.Logf("Large file copy output: %s", output)

	// Verify file integrity
	verifyFileContent(t, testKey, testData)

	// Uncache and verify it was copied to remote
	uncacheLocal(t, testKey)
	time.Sleep(1 * time.Second)
	verifyFileContent(t, testKey, testData)
}

// TestRemoteCopyLocalAlreadyExists tests skipping files already on remote
func TestRemoteCopyLocalAlreadyExists(t *testing.T) {
	checkServersRunning(t)

	testKey := fmt.Sprintf("copylocal-exists-%d.txt", time.Now().UnixNano())
	testData := createTestFile(t, testKey, 1024)

	// First copy
	t.Log("First copy to remote...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -include=%s", testBucket, testKey)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "first copy failed")
	t.Logf("First copy output: %s", output)

	// Second copy without forceUpdate - should skip
	t.Log("Second copy (should skip)...")
	output, err = runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "second copy failed")
	t.Logf("Second copy output: %s", output)

	// File should still be readable
	verifyFileContent(t, testKey, testData)
}

// TestRemoteCopyLocalNotMounted tests error when directory not mounted
func TestRemoteCopyLocalNotMounted(t *testing.T) {
	checkServersRunning(t)

	// Try to copy from a non-mounted directory
	notMountedDir := fmt.Sprintf("/notmounted-%d", time.Now().UnixNano())

	t.Log("Testing copy from non-mounted directory...")
	cmd := fmt.Sprintf("remote.copy.local -dir=%s", notMountedDir)
	output, err := runWeedShellWithOutput(t, cmd)

	// Should fail or show error
	hasError := err != nil || strings.Contains(strings.ToLower(output), "not mounted") || strings.Contains(strings.ToLower(output), "error")
	assert.True(t, hasError, "Expected error or error message for non-mounted directory, got: %s", output)
	t.Logf("Non-mounted directory result: err=%v, output: %s", err, output)
}

// TestRemoteCopyLocalMinMaxSize tests size-based filtering
func TestRemoteCopyLocalMinMaxSize(t *testing.T) {
	checkServersRunning(t)

	// Create files of different sizes
	smallFile := fmt.Sprintf("copylocal-small-%d.bin", time.Now().UnixNano())
	mediumFile := fmt.Sprintf("copylocal-medium-%d.bin", time.Now().UnixNano())
	largeFile := fmt.Sprintf("copylocal-large-%d.bin", time.Now().UnixNano())

	smallData := createTestFile(t, smallFile, 500)    // 500 bytes
	mediumData := createTestFile(t, mediumFile, 5000) // 5KB
	largeData := createTestFile(t, largeFile, 50000)  // 50KB

	// Copy only files between 1KB and 10KB
	t.Log("Copying files between 1KB and 10KB...")
	cmd := fmt.Sprintf("remote.copy.local -dir=/buckets/%s -minSize=1024 -maxSize=10240", testBucket)
	output, err := runWeedShellWithOutput(t, cmd)
	require.NoError(t, err, "remote.copy.local with size filters failed")
	t.Logf("Size filter output: %s", output)

	// All files should still be readable
	verifyFileContent(t, smallFile, smallData)
	verifyFileContent(t, mediumFile, mediumData)
	verifyFileContent(t, largeFile, largeData)
}