Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package system
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"testing"
"time"
backuptypes "github.com/getarcaneapp/arcane/types/v2/backup"
"github.com/getarcaneapp/arcane/types/v2/scheduler"
volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"
"github.com/libtnb/sqlite"
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/mount"
"github.com/moby/moby/api/types/network"
"github.com/moby/moby/client"
"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/activity"
"github.com/getarcaneapp/arcane/backend/v2/internal/backup"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/s3"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/volume"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler/flow/flowtest"
"github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler/runs"
francistest "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/francis/testing"
)
func TestResolveSystemUpgraderRuntimeOptions_TCPDockerHost(t *testing.T) {
currentContainer := &container.InspectResponse{
HostConfig: &container.HostConfig{NetworkMode: "bridge"},
NetworkSettings: &container.NetworkSettings{
Networks: map[string]*network.EndpointSettings{
"bridge": {},
"arcane-test": {},
},
},
}
containerEnv, mounts, networkMode, err := resolveUpgraderRuntimeOptions(
t.Context(),
"tcp://docker-socket-proxy:2375",
currentContainer,
nil,
func() bool { return true },
nil,
)
require.NoError(t, err)
require.Equal(t, []string{"DOCKER_HOST=tcp://docker-socket-proxy:2375"}, containerEnv)
require.Empty(t, mounts)
require.Equal(t, container.NetworkMode("arcane-test"), networkMode)
}
func TestResolveSystemUpgraderRuntimeOptions_UnixDockerHost(t *testing.T) {
containerEnv, mounts, networkMode, err := resolveUpgraderRuntimeOptions(
t.Context(),
"unix:///var/run/docker.sock",
nil,
func(context.Context, string) (string, error) {
return "/host/run/docker.sock", nil
},
func() bool { return true },
nil,
)
require.NoError(t, err)
require.Equal(t, []string{"DOCKER_HOST=unix:///var/run/docker.sock"}, containerEnv)
require.Equal(t, container.NetworkMode(""), networkMode)
require.Equal(t, []mount.Mount{
{
Type: mount.TypeBind,
Source: "/host/run/docker.sock",
Target: "/var/run/docker.sock",
},
}, mounts)
}
func TestResolveSystemUpgraderRuntimeOptions_DefaultDockerHost(t *testing.T) {
containerEnv, mounts, _, err := resolveUpgraderRuntimeOptions(
t.Context(),
"",
nil,
func(context.Context, string) (string, error) {
return "/var/run/docker.sock", nil
},
func() bool { return true },
nil,
)
require.NoError(t, err)
require.Nil(t, containerEnv)
require.Equal(t, []mount.Mount{
{
Type: mount.TypeBind,
Source: "/var/run/docker.sock",
Target: "/var/run/docker.sock",
},
}, mounts)
}
func TestResolveSystemUpgraderRuntimeOptions_UnixDockerHostResolutionError(t *testing.T) {
_, _, _, err := resolveUpgraderRuntimeOptions(
t.Context(),
"unix:///var/run/docker.sock",
nil,
func(context.Context, string) (string, error) {
return "", errors.New("inspect failed")
},
func() bool { return true },
nil,
)
require.Error(t, err)
require.Contains(t, err.Error(), "resolve unix socket source")
}
func TestListBackupHistoryClassifiesAndFiltersOrigins(t *testing.T) {
gormDB, err := gorm.Open(sqlite.Open("file:system-volume-history?mode=memory&cache=shared"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gormDB.AutoMigrate(&SystemBackupRun{}, &volume.VolumeBackup{}, &s3.S3Destination{}, &settings.SettingVariable{}))
now := time.Now().UTC()
require.NoError(t, gormDB.Create(&SystemBackupRun{
CreatedAt: now.Add(-2 * time.Minute), Status: SystemBackupStatusSucceeded, Trigger: SystemBackupTriggerManual,
Destination: backuptypes.SystemBackupDestinationLocal,
}).Error)
require.NoError(t, gormDB.Create(&volume.VolumeBackup{
VolumeName: "app-data", CreatedAt: now.Add(-time.Minute), Status: volume.VolumeBackupStatusSucceeded,
Trigger: volume.VolumeBackupTriggerScheduled, Destination: volumetypes.BackupDestinationLocal,
Format: volume.VolumeBackupFormatRustic, PolicyID: backuptypes.SystemVolumePolicyPrefix + "nightly:" + kit.SHA256Hex("app-data")[:16],
}).Error)
require.NoError(t, gormDB.Create(&volume.VolumeBackup{
VolumeName: "cache", CreatedAt: now, Status: volume.VolumeBackupStatusSucceeded,
Trigger: volume.VolumeBackupTriggerManual, Destination: volumetypes.BackupDestinationLocal,
Format: volume.VolumeBackupFormatRustic,
}).Error)
db := &database.DB{DB: gormDB}
settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
service := NewSystemService(
db, nil, nil, nil, nil, nil, settingsService, nil, nil, nil, nil, nil, nil,
s3.NewS3DestinationService(db, func(context.Context, string) error { return nil }), nil, nil, &config.Config{},
)
systemRows, page, err := service.backup.ListBackupHistory(t.Context(), pagination.QueryParams{
Sort: "createdAt", Order: pagination.SortDesc, Limit: 20,
Filters: map[string]string{"type": "system"},
})
require.NoError(t, err)
require.EqualValues(t, 2, page.TotalItems)
require.Len(t, systemRows, 2)
require.Equal(t, backuptypes.ManagementTypeSystem, systemRows[0].Type)
require.Equal(t, "app-data", systemRows[0].ResourceName)
require.Equal(t, "volume", systemRows[0].ResourceType)
volumeRows, page, err := service.backup.ListBackupHistory(t.Context(), pagination.QueryParams{
Search: "cache", Sort: "createdAt", Order: pagination.SortDesc, Limit: 1,
Filters: map[string]string{"type": "volume"},
})
require.NoError(t, err)
require.EqualValues(t, 1, page.TotalItems)
require.Len(t, volumeRows, 1)
require.Equal(t, backuptypes.ManagementTypeVolume, volumeRows[0].Type)
require.Equal(t, "cache", volumeRows[0].ResourceName)
}
func newSystemBackupAdmissionGateForTest(t testing.TB) *runs.Admission {
t.Helper()
runtime := francistest.New(t)
gate := runs.NewAdmission(runtime.Service(), t.Name())
require.NoError(t, gate.Register(runtime))
francistest.Start(t, runtime)
return gate
}
type systemBackupPolicyScheduler struct {
submitted []scheduler.Request
jobs map[string]scheduler.Job
}
func (s *systemBackupPolicyScheduler) AddJob(_ context.Context, job scheduler.Job) error {
s.jobs[job.Name()] = job
return nil
}
func (s *systemBackupPolicyScheduler) RemoveJob(_ context.Context, name string) {
delete(s.jobs, name)
}
func (s *systemBackupPolicyScheduler) HasJob(name string) bool {
_, ok := s.jobs[name]
return ok
}
func (s *systemBackupPolicyScheduler) Submit(_ context.Context, request scheduler.Request) (scheduler.Run, error) {
s.submitted = append(s.submitted, request)
return scheduler.Run{ID: request.RunID, JobID: request.JobID, EnvironmentID: request.EnvironmentID, Status: scheduler.Queued}, nil
}
func TestSystemBackupPoliciesRegisterIndependentJobs(t *testing.T) {
gormDB, err := gorm.Open(sqlite.Open("file:system-backup-schedules?mode=memory&cache=shared"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gormDB.AutoMigrate(
&SystemBackupPolicy{},
&SystemBackupRun{},
&backup.SystemBackupRecoveryConfig{},
&s3.S3Destination{},
&activity.Activity{},
&activity.ActivityMessage{},
&settings.SettingVariable{},
&volume.VolumeBackup{},
))
crypto.InitEncryption(&crypto.Config{EncryptionKey: "system-backup-policy-test-key-32bytes", Environment: "test"})
db := &database.DB{DB: gormDB}
recoveryKeys := backup.NewRecoveryKeyStore(db)
s3Destinations := s3.NewS3DestinationService(db, func(context.Context, string) error { return nil })
settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
gate := newSystemBackupAdmissionGateForTest(t)
dockerService := &docker.DockerClientService{Client: func() *client.Client {
cli, _ := client.New(client.WithHost("tcp://127.0.0.1:1"), client.WithAPIVersion("1.41"))
return cli
}()}
service := NewSystemService(
db,
dockerService,
nil,
nil,
volume.NewVolumeService(db, dockerService, nil, nil, nil, nil, nil, nil, nil, nil),
nil,
settingsService,
nil,
nil,
nil,
nil,
nil,
backup.NewEngine(gate, nil),
s3Destinations,
recoveryKeys,
nil,
&config.Config{DatabaseURL: "file:system-backup-schedules-test.db"},
)
harness := flowtest.New(t, activity.NewActivityService(db, nil))
require.NoError(t, service.backup.RegisterWorkflows(harness.Engine))
harness.Start(t)
jobScheduler := &systemBackupPolicyScheduler{jobs: make(map[string]scheduler.Job)}
require.NoError(t, service.SetBackupScheduler(t.Context(), jobScheduler, gate))
status, err := service.backup.SetRecoveryKey(t.Context(), "QWERTY-ABCDEF-234567-GHIJKL-MNOPQR-STUVWX-YZ2345-ZXCVBN")
require.NoError(t, err)
require.True(t, status.Configured)
storedKey, err := recoveryKeys.Get(t.Context())
require.NoError(t, err)
require.Equal(t, "QWERTY-ABCDEF-234567-GHIJKL-MNOPQR-STUVWX-YZ2345-ZXCVBN", storedKey)
collection, err := service.backup.UpdatePolicies(t.Context(), []backuptypes.UpdateSystemBackupPolicy{
{Enabled: true, Schedule: "0 0 2 * * *", RetentionCount: 5, LocalEnabled: true},
{Enabled: true, Schedule: "0 0 14 * * *", RetentionCount: 30, LocalEnabled: true},
})
require.NoError(t, err)
require.True(t, collection.RecoveryKeyStored)
require.Len(t, collection.Policies, 2)
require.Len(t, jobScheduler.jobs, 2)
firstID := collection.Policies[0].ID
collection, err = service.backup.UpdatePolicies(t.Context(), []backuptypes.UpdateSystemBackupPolicy{{
ID: firstID, Enabled: true, Schedule: "0 */30 * * * *", RetentionCount: 9, LocalEnabled: true,
}})
require.NoError(t, err)
require.Len(t, collection.Policies, 1)
require.Equal(t, firstID, collection.Policies[0].ID)
require.Equal(t, 9, collection.Policies[0].RetentionCount)
require.Len(t, jobScheduler.jobs, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.Header().Set("Content-Type", "application/xml")
w.WriteHeader(http.StatusNotFound)
_, _ = w.Write([]byte("<Error><Code>NoSuchBucket</Code></Error>"))
}))
defer server.Close()
destination, err := s3Destinations.CreateS3Destination(t.Context(), backuptypes.CreateS3Destination{
Name: "Missing storage", Endpoint: server.URL, Bucket: "backups", AccessKeyID: "test", SecretAccessKey: "test", ForcePathStyle: true,
})
require.NoError(t, err)
for _, local := range []bool{false, true} {
policy := &SystemBackupPolicy{Enabled: true, LocalEnabled: local, S3Enabled: true, S3DestinationID: destination.ID, Schedule: "0 0 2 * * *"}
require.NoError(t, gormDB.Create(policy).Error)
require.NoError(t, gormDB.Model(policy).Update("local_enabled", local).Error)
service.RegisterBackupJobOnStartup(t.Context())
jobName := "system-backup:" + policy.ID
job, registered := jobScheduler.jobs[jobName]
require.True(t, registered)
// The scheduled run checks the remote first; a local policy then
// attempts its backup, which has no reachable Docker in this test.
outcome, runErr := job.Run(t.Context())
require.NoError(t, runErr)
if local {
require.Equal(t, scheduler.Failed, outcome.Status)
require.Contains(t, outcome.Message, "failed to create local system recovery snapshot")
} else {
require.Equal(t, scheduler.NeedsAttention, outcome.Status)
require.Equal(t, backup.RemoteDisabledMessage, outcome.Message)
}
require.NoError(t, gormDB.First(policy, "id = ?", policy.ID).Error)
require.Equal(t, local, policy.Enabled)
require.Equal(t, !local, policy.S3Enabled)
require.Equal(t, local, jobScheduler.HasJob(jobName))
}
}
func TestSystemBackupPolicyRequiresConfiguredRecoveryKeyWhenEnabled(t *testing.T) {
gormDB, err := gorm.Open(sqlite.Open("file:system-backup-key-required?mode=memory&cache=shared"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gormDB.AutoMigrate(&SystemBackupPolicy{}, &backup.SystemBackupRecoveryConfig{}, &s3.S3Destination{}))
db := &database.DB{DB: gormDB}
service := NewSystemService(
db, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
s3.NewS3DestinationService(db, func(context.Context, string) error { return nil }),
backup.NewRecoveryKeyStore(db), nil, &config.Config{DatabaseURL: "file:system-backup-key-required-test.db"},
)
_, err = service.backup.UpdatePolicies(t.Context(), []backuptypes.UpdateSystemBackupPolicy{{
Enabled: true, Schedule: "0 0 2 * * *", RetentionCount: 7, LocalEnabled: true,
}})
require.ErrorContains(t, err, "configure a recovery key")
}