Skip to content

Modern Docker Management, Designed for Everyone

14.9 KB
Raw Blame
package s3

import (
	"context"
	"io"
	"net/http"
	"net/http/httptest"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/backup"
	"github.com/libtnb/sqlite"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.getarcane.app/kit/pkg"
	"go.getarcane.app/sys/crypto"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/s3"
)

func setupS3DestinationServiceTest(t *testing.T) (*S3DestinationService, *gorm.DB) {
	t.Helper()

	gormDB, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, gormDB.AutoMigrate(
		&S3Destination{},
		&settings.SettingVariable{},
	))
	require.NoError(t, gormDB.Exec("CREATE TABLE system_backup_runs (s3_destination_id text, remote_snapshot_id text)").Error)
	require.NoError(t, gormDB.Exec("CREATE TABLE system_backup_policies (s3_destination_id text, s3_enabled numeric)").Error)
	require.NoError(t, gormDB.Exec("CREATE TABLE volume_backups (s3_destination_id text, remote_snapshot_id text)").Error)
	require.NoError(t, gormDB.Exec("CREATE TABLE volume_backup_policies (s3_destination_id text, s3_enabled numeric)").Error)
	crypto.InitEncryption(&crypto.Config{
		EncryptionKey: "test-encryption-key-for-s3-destination-32bytes",
		Environment:   "test",
	})
	return NewS3DestinationService(&database.DB{DB: gormDB}, func(context.Context, string) error { return nil }), gormDB
}

func TestS3DestinationService_CRUD(t *testing.T) {
	service, gormDB := setupS3DestinationServiceTest(t)
	ctx := t.Context()

	created, err := service.CreateS3Destination(ctx, backup.CreateS3Destination{
		Name:            "  Cafe\u0301 offsite  ",
		Endpoint:        "https://s3.example.com",
		Bucket:          "arcane-backups",
		Region:          "eu-central-1",
		AccessKeyID:     "access-key",
		SecretAccessKey: "secret-key",
		Prefix:          "/production/",
		UseSSL:          true,
		ForcePathStyle:  true,
	})
	require.NoError(t, err)
	require.NotEmpty(t, created.ID)
	require.Equal(t, "Café offsite", created.Name)
	require.True(t, created.SecretConfigured)
	require.Equal(t, "production", created.Prefix)

	var stored S3Destination
	require.NoError(t, gormDB.First(&stored, "id = ?", created.ID).Error)
	require.NotEqual(t, "secret-key", stored.SecretAccessKey)

	listed, page, err := service.ListS3Destinations(ctx, pagination.QueryParams{
		Search: "arcane-backups",
		Limit:  20,
	})
	require.NoError(t, err)
	require.EqualValues(t, 1, page.TotalItems)
	require.Len(t, listed, 1)

	updated, err := service.UpdateS3Destination(ctx, created.ID, backup.UpdateS3Destination{
		Name:           "  Primary cafe\u0301 offsite  ",
		Endpoint:       created.Endpoint,
		Bucket:         created.Bucket,
		Region:         created.Region,
		AccessKeyID:    created.AccessKeyID,
		Prefix:         created.Prefix,
		UseSSL:         created.UseSSL,
		ForcePathStyle: created.ForcePathStyle,
	})
	require.NoError(t, err)
	require.Equal(t, "Primary café offsite", updated.Name)

	var updatedStored S3Destination
	require.NoError(t, gormDB.First(&updatedStored, "id = ?", created.ID).Error)
	require.Equal(t, stored.SecretAccessKey, updatedStored.SecretAccessKey)

	require.NoError(t, service.DeleteS3Destination(ctx, created.ID))
	_, err = service.GetS3Destination(ctx, created.ID)
	require.ErrorIs(t, err, ErrS3DestinationNotFound)
}

func TestS3DestinationService_DeleteRejectsConfiguredDestination(t *testing.T) {
	service, gormDB := setupS3DestinationServiceTest(t)
	ctx := t.Context()
	destination, err := service.CreateS3Destination(ctx, backup.CreateS3Destination{
		Name:            "In use",
		Bucket:          "arcane-backups",
		Region:          "us-east-1",
		AccessKeyID:     "access-key",
		SecretAccessKey: "secret-key",
		UseSSL:          true,
	})
	require.NoError(t, err)
	require.NoError(t, gormDB.Exec("INSERT INTO volume_backup_policies (s3_destination_id, s3_enabled) VALUES (?, 1)", destination.ID).Error)

	err = service.DeleteS3Destination(ctx, destination.ID)
	require.ErrorIs(t, err, ErrS3DestinationInUse)
}

func TestS3DestinationService_UpdateRejectsLocationChangeWhileInUse(t *testing.T) {
	service, gormDB := setupS3DestinationServiceTest(t)
	ctx := t.Context()
	destination, err := service.CreateS3Destination(ctx, backup.CreateS3Destination{
		Name:            "In use",
		Bucket:          "arcane-backups",
		Region:          "us-east-1",
		AccessKeyID:     "access-key",
		SecretAccessKey: "secret-key",
		UseSSL:          true,
	})
	require.NoError(t, err)
	require.NoError(t, gormDB.Exec("INSERT INTO volume_backups (s3_destination_id, remote_snapshot_id) VALUES (?, ?)", destination.ID, "snapshot-1").Error)

	_, err = service.UpdateS3Destination(ctx, destination.ID, backup.UpdateS3Destination{
		Name:            destination.Name,
		Bucket:          "other-bucket",
		Region:          destination.Region,
		AccessKeyID:     destination.AccessKeyID,
		SecretAccessKey: "secret-key",
		UseSSL:          destination.UseSSL,
	})
	require.ErrorIs(t, err, ErrS3DestinationInUse)

	updated, err := service.UpdateS3Destination(ctx, destination.ID, backup.UpdateS3Destination{
		Name:        "Renamed",
		Bucket:      destination.Bucket,
		Region:      destination.Region,
		AccessKeyID: destination.AccessKeyID,
		UseSSL:      destination.UseSSL,
	})
	require.NoError(t, err)
	require.Equal(t, "Renamed", updated.Name)
}

func TestS3DestinationService_SyncS3Destinations(t *testing.T) {
	service, gormDB := setupS3DestinationServiceTest(t)
	ctx := t.Context()

	legacy, err := service.CreateS3Destination(ctx, backup.CreateS3Destination{
		Name:            "Legacy",
		Bucket:          "legacy-bucket",
		Region:          "us-east-1",
		AccessKeyID:     "legacy-access-key",
		SecretAccessKey: "legacy-secret",
		UseSSL:          true,
	})
	require.NoError(t, err)

	createdAt := time.Now().Add(-time.Hour).UTC().Truncate(time.Second)
	require.NoError(t, service.SyncS3Destinations(ctx, []backup.S3DestinationSync{
		{
			ID:              "destination-1",
			Name:            "Remote primary",
			Endpoint:        "https://s3.example.com",
			Bucket:          "volume-backups",
			Region:          "eu-central-1",
			AccessKeyID:     "remote-access-key",
			SecretAccessKey: "remote-secret",
			Prefix:          "/agents/",
			UseSSL:          true,
			ForcePathStyle:  true,
			CreatedAt:       createdAt,
		},
	}))

	var synced S3Destination
	require.NoError(t, gormDB.First(&synced, "id = ?", "destination-1").Error)
	require.Equal(t, "Remote primary", synced.Name)
	require.Equal(t, "agents", synced.Prefix)
	require.NotEqual(t, "remote-secret", synced.SecretAccessKey)
	secret, err := crypto.Decrypt(synced.SecretAccessKey)
	require.NoError(t, err)
	require.Equal(t, "remote-secret", secret)

	_, err = service.GetS3Destination(ctx, legacy.ID)
	require.ErrorIs(t, err, ErrS3DestinationNotFound)

	require.NoError(t, service.SyncS3Destinations(ctx, []backup.S3DestinationSync{
		{
			ID:              "destination-1",
			Name:            "Remote primary updated",
			Bucket:          "updated-volume-backups",
			Region:          "eu-west-1",
			AccessKeyID:     "updated-access-key",
			SecretAccessKey: "updated-secret",
			UseSSL:          true,
		},
	}))

	require.NoError(t, gormDB.First(&synced, "id = ?", "destination-1").Error)
	require.Equal(t, "Remote primary updated", synced.Name)
	require.Equal(t, "updated-volume-backups", synced.Bucket)
	secret, err = crypto.Decrypt(synced.SecretAccessKey)
	require.NoError(t, err)
	require.Equal(t, "updated-secret", secret)
}

func TestS3DestinationService_TestS3DestinationRoundTrip(t *testing.T) {
	var object []byte
	var requestMethods []string
	expectedPathPrefix := "/arcane-backups/production/.arcane-connection-test-"
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !assert.NotEmpty(t, r.Header.Get("Authorization")) {
			return
		}
		if !assert.True(t, strings.HasPrefix(r.URL.Path, expectedPathPrefix)) {
			return
		}
		requestMethods = append(requestMethods, r.Method)
		switch r.Method {
		case http.MethodPut:
			var err error
			object, err = io.ReadAll(r.Body)
			if !assert.NoError(t, err) {
				return
			}
			w.Header().Set("ETag", `"test-etag"`)
			w.WriteHeader(http.StatusOK)
		case http.MethodGet:
			w.Header().Set("Content-Length", strconv.Itoa(len(object)))
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write(object)
		case http.MethodDelete:
			object = nil
			w.WriteHeader(http.StatusNoContent)
		default:
			http.Error(w, "unsupported method", http.StatusMethodNotAllowed)
		}
	}))
	defer server.Close()

	service, _ := setupS3DestinationServiceTest(t)
	require.NoError(t, service.TestS3DestinationConfiguration(t.Context(), backup.CreateS3Destination{
		Name:            "Unsaved destination",
		Endpoint:        server.URL,
		Bucket:          "arcane-backups",
		Region:          "",
		AccessKeyID:     "access-key",
		SecretAccessKey: "secret-key",
		Prefix:          "production",
		UseSSL:          false,
		ForcePathStyle:  true,
	}))
	destination, err := service.CreateS3Destination(t.Context(), backup.CreateS3Destination{
		Name:            "Test destination",
		Endpoint:        server.URL,
		Bucket:          "arcane-backups",
		Region:          "",
		AccessKeyID:     "access-key",
		SecretAccessKey: "secret-key",
		Prefix:          "production",
		UseSSL:          false,
		ForcePathStyle:  true,
	})
	require.NoError(t, err)

	require.NoError(t, service.TestS3Destination(t.Context(), destination.ID, nil))

	// Changing a connection field without re-supplying the secret is rejected
	// before any outbound request: the stored secret must never sign requests
	// against caller-modified connection settings.
	requestsBeforeRejection := len(requestMethods)
	err = service.TestS3Destination(t.Context(), destination.ID, &backup.UpdateS3Destination{
		Name:           destination.Name,
		Endpoint:       server.URL,
		Bucket:         "edited-bucket",
		Region:         "",
		AccessKeyID:    destination.AccessKeyID,
		Prefix:         "edited",
		UseSSL:         false,
		ForcePathStyle: true,
	})
	require.ErrorContains(t, err, "re-enter the secret access key")
	require.Len(t, requestMethods, requestsBeforeRejection)

	expectedPathPrefix = "/edited-bucket/edited/.arcane-connection-test-"
	require.NoError(t, service.TestS3Destination(t.Context(), destination.ID, &backup.UpdateS3Destination{
		Name:            destination.Name,
		Endpoint:        server.URL,
		Bucket:          "edited-bucket",
		Region:          "",
		AccessKeyID:     destination.AccessKeyID,
		SecretAccessKey: "secret-key",
		Prefix:          "edited",
		UseSSL:          false,
		ForcePathStyle:  true,
	}))

	require.Equal(t, []string{
		http.MethodPut, http.MethodGet, http.MethodDelete,
		http.MethodPut, http.MethodGet, http.MethodDelete,
		http.MethodPut, http.MethodGet, http.MethodDelete,
	}, requestMethods)
	require.Empty(t, object)
	persisted, err := service.GetS3Destination(t.Context(), destination.ID)
	require.NoError(t, err)
	require.Equal(t, "arcane-backups", persisted.Bucket)
	require.Equal(t, "production", persisted.Prefix)
	require.Empty(t, persisted.Region)

	for _, scenario := range []struct {
		name          string
		code          string
		status        int
		reason        string
		wantError     bool
		snapshotError bool
		configOnly    bool
	}{
		{name: "only the requested snapshot is read"},
		{name: "repository check reads only config", configOnly: true},
		{name: "confirmed bucket loss", code: "NoSuchBucket", status: http.StatusNotFound, reason: "missing_bucket"},
		{name: "confirmed repository loss", code: "NoSuchKey", status: http.StatusNotFound, reason: "missing_repository"},
		{name: "access denied is not deletion", code: "AccessDenied", status: http.StatusForbidden, wantError: true},
		{name: "generic not found is inconclusive", code: "NotFound", status: http.StatusNotFound, wantError: true},
		{name: "missing snapshot leaves repository available", code: "NoSuchKey", status: http.StatusNotFound, snapshotError: true},
		{name: "snapshot access denied is inconclusive", code: "AccessDenied", status: http.StatusForbidden, snapshotError: true, wantError: true},
	} {
		t.Run(scenario.name, func(t *testing.T) {
			snapshotID := strings.Repeat("a", 64)
			metadataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				isConfig := r.URL.Path == "/arcane-backups/production/repository/config"
				isSnapshot := !scenario.configOnly && r.URL.Path == "/arcane-backups/production/repository/snapshots/"+snapshotID
				if r.Method != http.MethodGet || (!isConfig && !isSnapshot) || r.URL.Query().Get("list-type") != "" {
					t.Errorf("unexpected metadata request: %s %s", r.Method, r.URL)
					w.WriteHeader(http.StatusBadRequest)
					return
				}
				if r.Header.Get("Range") != "bytes=0-0" {
					t.Errorf("metadata request must be limited to one byte")
				}
				if scenario.code != "" && (!scenario.snapshotError || !isConfig) {
					w.Header().Set("Content-Type", "application/xml")
					w.WriteHeader(scenario.status)
					_, _ = io.WriteString(w, "<Error><Code>"+scenario.code+"</Code><Message>test response</Message></Error>")
					return
				}
				w.Header().Set("Content-Range", "bytes 0-0/100")
				w.WriteHeader(http.StatusPartialContent)
				_, _ = io.WriteString(w, "x")
			}))
			defer metadataServer.Close()
			configuration := s3.Configuration{
				Name: "Metadata destination", Endpoint: metadataServer.URL, Bucket: "arcane-backups",
				AccessKeyID: "test-access", SecretAccessKey: "test-secret", Prefix: "production", ForcePathStyle: true,
			}
			requestedID := kit.Ternary(scenario.configOnly, "", snapshotID)
			observation, checkErr := s3.CheckRepository(t.Context(), configuration, "repository", requestedID)
			if scenario.wantError {
				require.Error(t, checkErr)
				require.Empty(t, observation.Reason)
				return
			}
			require.NoError(t, checkErr)
			require.Equal(t, scenario.reason, observation.Reason)
			require.Equal(t, scenario.reason == "", observation.Available)
			require.Equal(t, scenario.reason == "" && !scenario.configOnly && !scenario.snapshotError, observation.SnapshotAvailable)
		})
	}
}

func TestDestinationsByID(t *testing.T) {
	service, db := setupS3DestinationServiceTest(t)
	require.Empty(t, service.DestinationsByID(t.Context()))
	destination := S3Destination{Name: "Offsite", Bucket: "backups", SecretAccessKey: "encrypted"}
	require.NoError(t, db.Create(&destination).Error)
	indexed := service.DestinationsByID(t.Context())
	require.Len(t, indexed, 1)
	require.Equal(t, "Offsite", indexed[destination.ID].Name)
	require.Equal(t, "backups", indexed[destination.ID].Bucket)
	require.True(t, indexed[destination.ID].SecretConfigured)
	require.Empty(t, indexed["missing"].Name)
	// Listing failures leave records undecorated rather than failing.
	require.NoError(t, db.Migrator().DropTable(&S3Destination{}))
	require.Nil(t, service.DestinationsByID(t.Context()))
}