555 lines
22 KiB
Go
555 lines
22 KiB
Go
//go:build integration
|
|
|
|
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/shcizo/package-updater/internal/master/model"
|
|
"github.com/shcizo/package-updater/internal/protocol"
|
|
)
|
|
|
|
var (
|
|
digNew = "sha256:" + strings.Repeat("e", 64)
|
|
digOld = "sha256:" + strings.Repeat("f", 64)
|
|
sluskDrift = "gitea.shcizo.se/shcizo/slusk"
|
|
)
|
|
|
|
// serviceID returns the ID of the service the agent reports under svc's key.
|
|
func serviceID(t *testing.T, s *Store, agentID int64, svc protocol.Service) int64 {
|
|
t.Helper()
|
|
var id int64
|
|
require.NoError(t, s.pool.QueryRow(context.Background(),
|
|
`SELECT id FROM services WHERE location_key = $1`, model.LocationKey(agentID, "", svc.Key())).Scan(&id))
|
|
return id
|
|
}
|
|
|
|
// finishJob runs a job for the service to success with the deployed ref.
|
|
func finishJob(t *testing.T, s *Store, agentID, svcID int64, toRef, deployed string) {
|
|
t.Helper()
|
|
ctx := context.Background()
|
|
nj := newJob(svcID, agentID)
|
|
nj.ToRef = toRef
|
|
j, err := s.CreateJob(ctx, nj)
|
|
require.NoError(t, err)
|
|
ok, err := s.FinishJob(ctx, agentID, j.ID, model.JobFinish{Status: model.JobSucceeded, Ref: deployed, StartedAt: t0, FinishedAt: t0})
|
|
require.NoError(t, err)
|
|
require.True(t, ok)
|
|
}
|
|
|
|
func mustExec(t *testing.T, s *Store, sql string, args ...any) {
|
|
t.Helper()
|
|
_, err := s.pool.Exec(context.Background(), sql, args...)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestFinishJob_SetsAwaitingInventoryUntilTheNextUpsert(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
agent, svc := jobFixture(t, s, "a")
|
|
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.False(t, got.AwaitingInventory)
|
|
|
|
finishJob(t, s, agent, svc, "r:1", "r:1@"+digNew)
|
|
got, err = s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.True(t, got.AwaitingInventory, "set by the successful job")
|
|
assert.False(t, got.Drifted(), "desired is ahead of actual only until the inventory arrives")
|
|
|
|
require.NoError(t, s.UpsertService(ctx, agent, "", slusk, t0.Add(time.Minute)))
|
|
got, err = s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.False(t, got.AwaitingInventory, "cleared by the agent's upsert")
|
|
assert.True(t, got.Drifted(), "the agent still reports the old version")
|
|
}
|
|
|
|
func TestFinishJob_FailedJobDoesNotSetAwaitingInventory(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
agent, svc := jobFixture(t, s, "a")
|
|
j, err := s.CreateJob(ctx, newJob(svc, agent))
|
|
require.NoError(t, err)
|
|
|
|
ok, err := s.FinishJob(ctx, agent, j.ID, model.JobFinish{Status: model.JobFailed, Error: "boom", StartedAt: t0, FinishedAt: t0})
|
|
require.NoError(t, err)
|
|
require.True(t, ok)
|
|
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.False(t, got.AwaitingInventory)
|
|
}
|
|
|
|
func TestCreateJob_UnknownServiceIsNotFound(t *testing.T) {
|
|
s := openTestStore(t)
|
|
agent := newAgent(t, s, "a")
|
|
|
|
_, err := s.CreateJob(context.Background(), newJob(9999, agent))
|
|
|
|
assert.ErrorIs(t, err, model.ErrNotFound)
|
|
}
|
|
|
|
// driftedFixture is a service updated to digNew whose agent now reports digD1.
|
|
func driftedFixture(t *testing.T, s *Store) (agent, svc int64) {
|
|
t.Helper()
|
|
agent, svc = jobFixture(t, s, "a")
|
|
finishJob(t, s, agent, svc, "r:1", sluskDrift+":1.4.2@"+digNew)
|
|
require.NoError(t, s.UpsertService(context.Background(), agent, "", slusk, t0.Add(time.Minute)))
|
|
return agent, svc
|
|
}
|
|
|
|
func TestAcceptRunning_WritesTheDesiredRef(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
_, svc := driftedFixture(t, s)
|
|
require.NoError(t, s.SetLastTagDigest(ctx, svc, "sha256:ltd"))
|
|
require.NoError(t, s.SetAvailable(ctx, svc, model.Available{Ref: sluskDrift + ":1.5.0", Source: model.SourcePoll, At: t0}))
|
|
require.NoError(t, s.SetUpdateMode(ctx, svc, model.ModeAuto))
|
|
before, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
require.True(t, before.Drifted())
|
|
|
|
running := model.RunningRef(before.ActualRef, before.ActualDigest)
|
|
require.NoError(t, s.AcceptRunning(ctx, svc, before.ActualRef, before.ActualDigest, running))
|
|
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, sluskDrift+":1.4.2@"+digD1, got.DesiredRef)
|
|
assert.False(t, got.Drifted())
|
|
assert.False(t, got.AwaitingInventory)
|
|
assert.Equal(t, "sha256:ltd", got.LastTagDigest, "last_tag_digest untouched")
|
|
assert.Equal(t, sluskDrift+":1.5.0", got.AvailableRef, "available suggestion untouched")
|
|
assert.Equal(t, model.ModeAuto, got.UpdateMode)
|
|
}
|
|
|
|
func TestAcceptRunning_Refusals(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
prepare func(t *testing.T, s *Store, agent, svc int64) (id int64, actualRef, actualDigest string)
|
|
wantError error
|
|
}{
|
|
{"running version changed", func(t *testing.T, s *Store, agent, svc int64) (int64, string, string) {
|
|
return svc, sluskDrift + ":1.4.2", digOld
|
|
}, model.ErrConflict},
|
|
{"actual ref changed", func(t *testing.T, s *Store, agent, svc int64) (int64, string, string) {
|
|
return svc, sluskDrift + ":1.3.0", digD1
|
|
}, model.ErrConflict},
|
|
{"never updated", func(t *testing.T, s *Store, agent, svc int64) (int64, string, string) {
|
|
mustExec(t, s, `UPDATE services SET desired_ref = '' WHERE id = $1`, svc)
|
|
return svc, sluskDrift + ":1.4.2", digD1
|
|
}, model.ErrConflict},
|
|
{"removed", func(t *testing.T, s *Store, agent, svc int64) (int64, string, string) {
|
|
require.NoError(t, s.RemoveService(context.Background(), agent, "", slusk.Key(), t0.Add(time.Hour)))
|
|
return svc, sluskDrift + ":1.4.2", digD1
|
|
}, model.ErrNotFound},
|
|
{"unknown", func(t *testing.T, s *Store, agent, svc int64) (int64, string, string) {
|
|
return 9999, sluskDrift + ":1.4.2", digD1
|
|
}, model.ErrNotFound},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s := openTestStore(t)
|
|
agent, svc := driftedFixture(t, s)
|
|
id, ref, digest := tt.prepare(t, s, agent, svc)
|
|
|
|
err := s.AcceptRunning(context.Background(), id, ref, digest, "x:1@"+digOld)
|
|
|
|
assert.ErrorIs(t, err, tt.wantError)
|
|
got, gerr := s.GetService(context.Background(), svc)
|
|
require.NoError(t, gerr)
|
|
assert.NotEqual(t, "x:1@"+digOld, got.DesiredRef, "nothing written")
|
|
})
|
|
}
|
|
}
|
|
|
|
// moveFixture has agent "a" with slusk removed after it was updated (history,
|
|
// auto mode) and agent "b" reporting a new slusk row.
|
|
type moveFixture struct {
|
|
a, b int64
|
|
from, to int64
|
|
}
|
|
|
|
func newMoveFixture(t *testing.T, s *Store) moveFixture {
|
|
t.Helper()
|
|
ctx := context.Background()
|
|
f := moveFixture{a: newAgent(t, s, "a"), b: newAgent(t, s, "b")}
|
|
require.NoError(t, s.ApplySnapshot(ctx, f.a, worker, []protocol.Service{slusk}, t0))
|
|
f.from = serviceID(t, s, f.a, slusk)
|
|
finishJob(t, s, f.a, f.from, "r:1", sluskDrift+":1.4.2@"+digNew)
|
|
require.NoError(t, s.SetUpdateMode(ctx, f.from, model.ModeAuto))
|
|
require.NoError(t, s.ApplySnapshot(ctx, f.a, worker, nil, t0.Add(time.Hour)))
|
|
require.NoError(t, s.ApplySnapshot(ctx, f.b, worker, []protocol.Service{slusk}, t0.Add(2*time.Hour)))
|
|
f.to = serviceID(t, s, f.b, slusk)
|
|
return f
|
|
}
|
|
|
|
func TestMoveCandidates(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mutate func(t *testing.T, s *Store, f moveFixture)
|
|
want bool
|
|
from string // agent name of the removed row
|
|
}{
|
|
{"one removed and one live", func(*testing.T, *Store, moveFixture) {}, true, "a"},
|
|
{"removed row's agent was revoked", func(t *testing.T, s *Store, f moveFixture) {
|
|
_, err := s.RevokeAgent(context.Background(), f.a, t0.Add(3*time.Hour))
|
|
require.NoError(t, err)
|
|
}, true, "a"},
|
|
{"two live targets", func(t *testing.T, s *Store, f moveFixture) {
|
|
c := newAgent(t, s, "c")
|
|
require.NoError(t, s.ApplySnapshot(context.Background(), c, worker, []protocol.Service{slusk}, t0.Add(3*time.Hour)))
|
|
}, false, ""},
|
|
{"two removed sources", func(t *testing.T, s *Store, f moveFixture) {
|
|
ctx := context.Background()
|
|
d := newAgent(t, s, "d")
|
|
require.NoError(t, s.ApplySnapshot(ctx, d, worker, []protocol.Service{slusk}, t0))
|
|
require.NoError(t, s.ApplySnapshot(ctx, d, worker, nil, t0.Add(time.Hour)))
|
|
}, false, ""},
|
|
{"target has history", func(t *testing.T, s *Store, f moveFixture) {
|
|
finishJob(t, s, f.b, f.to, "r:1", sluskDrift+":1.4.2@"+digNew)
|
|
}, false, ""},
|
|
{"target has a desired ref", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `UPDATE services SET desired_ref = 'r:1@x' WHERE id = $1`, f.to)
|
|
}, false, ""},
|
|
{"source has no history", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `DELETE FROM update_jobs WHERE service_id = $1`, f.from)
|
|
mustExec(t, s, `UPDATE services SET desired_ref = '', update_mode = 'manual' WHERE id = $1`, f.from)
|
|
}, false, ""},
|
|
{"source only has auto mode", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `DELETE FROM update_jobs WHERE service_id = $1`, f.from)
|
|
mustExec(t, s, `UPDATE services SET desired_ref = '' WHERE id = $1`, f.from)
|
|
}, true, "a"},
|
|
{"source only has jobs", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `UPDATE services SET desired_ref = '', update_mode = 'manual' WHERE id = $1`, f.from)
|
|
}, true, "a"},
|
|
{"target is older than the source", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `UPDATE services SET first_seen_at = $2 WHERE id = $1`, f.to, t0.Add(-time.Hour))
|
|
}, false, ""},
|
|
{"plain containers", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `UPDATE services SET kind = 'container' WHERE id IN ($1, $2)`, f.from, f.to)
|
|
}, false, ""},
|
|
{"swarm services", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `UPDATE services SET kind = 'swarm' WHERE id IN ($1, $2)`, f.from, f.to)
|
|
}, false, ""},
|
|
{"the updater itself (target)", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `UPDATE services SET self = true WHERE id = $1`, f.to)
|
|
}, false, ""},
|
|
{"the updater itself (source)", func(t *testing.T, s *Store, f moveFixture) {
|
|
mustExec(t, s, `UPDATE services SET self = true WHERE id = $1`, f.from)
|
|
}, false, ""},
|
|
{"live row also removed", func(t *testing.T, s *Store, f moveFixture) {
|
|
require.NoError(t, s.RemoveService(context.Background(), f.b, "", slusk.Key(), t0.Add(3*time.Hour)))
|
|
}, false, ""},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s := openTestStore(t)
|
|
f := newMoveFixture(t, s)
|
|
tt.mutate(t, s, f)
|
|
|
|
got, err := s.MoveCandidates(context.Background())
|
|
|
|
require.NoError(t, err)
|
|
if !tt.want {
|
|
assert.Empty(t, got)
|
|
return
|
|
}
|
|
assert.Equal(t, []model.Move{{FromID: f.from, ToID: f.to, FromAgent: tt.from, ToAgent: "b"}}, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMergeService_MovesHistoryModeAndDesiredToTheNewLocation(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
f := newMoveFixture(t, s)
|
|
finishJob(t, s, f.b, f.to, "r:2", sluskDrift+":2.0.0@"+digOld)
|
|
require.NoError(t, s.SetLastTagDigest(ctx, f.to, "sha256:fromto"))
|
|
require.NoError(t, s.SetAvailable(ctx, f.to, model.Available{Ref: sluskDrift + ":3", Digest: digNew, Source: model.SourcePoll, At: t0}))
|
|
require.NoError(t, s.SetPollError(ctx, []int64{f.to}, "registry down"))
|
|
require.NoError(t, s.SetNewer(ctx, f.to, sluskDrift+":3.1", t0))
|
|
// A job on the old row is finished, and awaiting_inventory is set on both.
|
|
before, err := s.GetService(ctx, f.from)
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, s.MergeService(ctx, f.from, f.to))
|
|
|
|
got, err := s.GetService(ctx, f.from)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, f.from, got.ID, "the old id survives")
|
|
assert.Nil(t, got.RemovedAt)
|
|
assert.False(t, got.AwaitingInventory)
|
|
assert.Equal(t, "b", got.AgentName)
|
|
assert.Equal(t, model.LocationKey(f.b, "", slusk.Key()), got.LocationKey)
|
|
assert.Equal(t, before.FirstSeenAt, got.FirstSeenAt, "first_seen_at kept")
|
|
assert.Equal(t, model.ModeAuto, got.UpdateMode, "mode kept")
|
|
assert.Equal(t, before.DesiredRef, got.DesiredRef, "desired ref kept")
|
|
assert.Equal(t, slusk.Image, got.ActualRef, "inventory from the duplicate")
|
|
assert.Equal(t, digD1, got.ActualDigest)
|
|
assert.Equal(t, "running", got.Status)
|
|
assert.Equal(t, sluskDrift+":3", got.AvailableRef)
|
|
assert.Equal(t, digNew, got.AvailableDigest)
|
|
assert.Equal(t, "registry down", got.LastPollError)
|
|
assert.Equal(t, sluskDrift+":3.1", got.NewerRef, "newer tag from the duplicate")
|
|
require.NotNil(t, got.NewerAt)
|
|
assert.True(t, t0.Equal(*got.NewerAt))
|
|
assert.Equal(t, before.LastTagDigest, got.LastTagDigest, "an existing last_tag_digest wins")
|
|
|
|
_, err = s.GetService(ctx, f.to)
|
|
assert.ErrorIs(t, err, model.ErrNotFound, "the duplicate is deleted")
|
|
jobs, err := s.ListJobs(ctx, model.JobFilter{ServiceID: f.from})
|
|
require.NoError(t, err)
|
|
assert.Len(t, jobs, 2, "the duplicate's job moved to the survivor")
|
|
live, err := s.ListServices(ctx)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, []string{"slusk/web"}, names(live))
|
|
}
|
|
|
|
func TestMergeService_TakesLastTagDigestOfTheDuplicateWhenTheOldRowHasNone(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
f := newMoveFixture(t, s)
|
|
mustExec(t, s, `UPDATE services SET last_tag_digest = '' WHERE id = $1`, f.from)
|
|
require.NoError(t, s.SetLastTagDigest(ctx, f.to, "sha256:fromto"))
|
|
|
|
require.NoError(t, s.MergeService(ctx, f.from, f.to))
|
|
|
|
got, err := s.GetService(ctx, f.from)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "sha256:fromto", got.LastTagDigest)
|
|
}
|
|
|
|
func TestMergeService_ManualMergeOfAnyRemovedServiceOfTheSameKind(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
f := newMoveFixture(t, s)
|
|
other := protocol.Service{Kind: protocol.KindCompose, ComposeProject: "renamed", ComposeService: "app", Image: "x/y:1", Status: "running"}
|
|
require.NoError(t, s.UpsertService(ctx, f.b, "", other, t0.Add(3*time.Hour)))
|
|
target := serviceID(t, s, f.b, other)
|
|
|
|
require.NoError(t, s.MergeService(ctx, f.from, target))
|
|
|
|
got, err := s.GetService(ctx, f.from)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "renamed/app", got.DisplayName(), "names may differ")
|
|
}
|
|
|
|
func TestMergeService_SameAgentIsAllowed(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
f := newMoveFixture(t, s)
|
|
other := protocol.Service{Kind: protocol.KindCompose, ComposeProject: "renamed", ComposeService: "app", Image: "x/y:1", Status: "running"}
|
|
require.NoError(t, s.UpsertService(ctx, f.a, "", other, t0.Add(3*time.Hour)))
|
|
|
|
require.NoError(t, s.MergeService(ctx, f.from, serviceID(t, s, f.a, other)))
|
|
|
|
got, err := s.GetService(ctx, f.from)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "a", got.AgentName)
|
|
}
|
|
|
|
func TestMergeService_Swarm(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
m1 := newAgent(t, s, "m1")
|
|
require.NoError(t, s.ApplySnapshot(ctx, m1, manager, []protocol.Service{gitea}, t0))
|
|
oldID := serviceIDByName(t, s, "gitea_gitea")
|
|
require.NoError(t, s.ApplySnapshot(ctx, m1, manager, nil, t0.Add(time.Hour)))
|
|
renamed := gitea
|
|
renamed.SwarmService = "gitea2_gitea"
|
|
require.NoError(t, s.ApplySnapshot(ctx, m1, manager, []protocol.Service{renamed}, t0.Add(2*time.Hour)))
|
|
newID := serviceIDByName(t, s, "gitea2_gitea")
|
|
|
|
require.NoError(t, s.MergeService(ctx, oldID, newID))
|
|
|
|
got, err := s.GetService(ctx, oldID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "gitea2_gitea", got.SwarmService)
|
|
assert.Nil(t, got.RemovedAt)
|
|
}
|
|
|
|
func serviceIDByName(t *testing.T, s *Store, swarmService string) int64 {
|
|
t.Helper()
|
|
var id int64
|
|
require.NoError(t, s.pool.QueryRow(context.Background(),
|
|
`SELECT id FROM services WHERE swarm_service = $1`, swarmService).Scan(&id))
|
|
return id
|
|
}
|
|
|
|
func TestMergeService_Refusals(t *testing.T) {
|
|
refused := func(reason string) func(*testing.T, error) {
|
|
return func(t *testing.T, err error) {
|
|
var mr *model.MergeRefusedError
|
|
require.True(t, errors.As(err, &mr), "got %v", err)
|
|
assert.Equal(t, reason, mr.Reason)
|
|
}
|
|
}
|
|
is := func(want error) func(*testing.T, error) {
|
|
return func(t *testing.T, err error) { assert.ErrorIs(t, err, want) }
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
run func(t *testing.T, s *Store, f moveFixture) error
|
|
assert func(*testing.T, error)
|
|
}{
|
|
{"into itself", func(t *testing.T, s *Store, f moveFixture) error {
|
|
return s.MergeService(context.Background(), f.to, f.to)
|
|
}, refused(model.ReasonMergeSame)},
|
|
{"the old service still exists", func(t *testing.T, s *Store, f moveFixture) error {
|
|
mustExec(t, s, `UPDATE services SET removed_at = NULL WHERE id = $1`, f.from)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, refused(model.ReasonMergeLiveOld)},
|
|
{"the new service was removed", func(t *testing.T, s *Store, f moveFixture) error {
|
|
require.NoError(t, s.RemoveService(context.Background(), f.b, "", slusk.Key(), t0.Add(3*time.Hour)))
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, refused(model.ReasonMergeGoneNew)},
|
|
{"different kinds", func(t *testing.T, s *Store, f moveFixture) error {
|
|
mustExec(t, s, `UPDATE services SET kind = 'swarm' WHERE id = $1`, f.to)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, refused(model.ReasonMergeKind)},
|
|
{"plain containers", func(t *testing.T, s *Store, f moveFixture) error {
|
|
mustExec(t, s, `UPDATE services SET kind = 'container' WHERE id IN ($1, $2)`, f.from, f.to)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, refused(model.ReasonMergeContainer)},
|
|
{"the updater itself (new)", func(t *testing.T, s *Store, f moveFixture) error {
|
|
mustExec(t, s, `UPDATE services SET self = true WHERE id = $1`, f.to)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, refused(model.ReasonMergeSelf)},
|
|
{"the updater itself (old)", func(t *testing.T, s *Store, f moveFixture) error {
|
|
mustExec(t, s, `UPDATE services SET self = true WHERE id = $1`, f.from)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, refused(model.ReasonMergeSelf)},
|
|
{"active job on the old service", func(t *testing.T, s *Store, f moveFixture) error {
|
|
_, err := s.CreateJob(context.Background(), newJob(f.from, f.a))
|
|
require.NoError(t, err)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, is(model.ErrJobActive)},
|
|
{"active job on the new service", func(t *testing.T, s *Store, f moveFixture) error {
|
|
_, err := s.CreateJob(context.Background(), newJob(f.to, f.b))
|
|
require.NoError(t, err)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, is(model.ErrJobActive)},
|
|
{"unknown old service", func(t *testing.T, s *Store, f moveFixture) error {
|
|
return s.MergeService(context.Background(), 9999, f.to)
|
|
}, is(model.ErrNotFound)},
|
|
{"unknown new service", func(t *testing.T, s *Store, f moveFixture) error {
|
|
return s.MergeService(context.Background(), f.from, 9999)
|
|
}, is(model.ErrNotFound)},
|
|
{"the new service's agent is revoked", func(t *testing.T, s *Store, f moveFixture) error {
|
|
_, err := s.RevokeAgent(context.Background(), f.b, t0.Add(3*time.Hour))
|
|
require.NoError(t, err)
|
|
return s.MergeService(context.Background(), f.from, f.to)
|
|
}, is(model.ErrRevoked)},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s := openTestStore(t)
|
|
f := newMoveFixture(t, s)
|
|
var rowsBefore int
|
|
require.NoError(t, s.pool.QueryRow(context.Background(), `SELECT count(*) FROM services`).Scan(&rowsBefore))
|
|
|
|
err := tt.run(t, s, f)
|
|
|
|
tt.assert(t, err)
|
|
var rowsAfter int
|
|
require.NoError(t, s.pool.QueryRow(context.Background(), `SELECT count(*) FROM services`).Scan(&rowsAfter))
|
|
assert.Equal(t, rowsBefore, rowsAfter, "nothing is deleted when the merge is refused")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMergeService_InventoryAfterTheMerge(t *testing.T) {
|
|
setup := func(t *testing.T) (*Store, moveFixture) {
|
|
s := openTestStore(t)
|
|
f := newMoveFixture(t, s)
|
|
require.NoError(t, s.MergeService(context.Background(), f.from, f.to))
|
|
return s, f
|
|
}
|
|
|
|
t.Run("an upsert for the new location updates the survivor", func(t *testing.T) {
|
|
s, f := setup(t)
|
|
ctx := context.Background()
|
|
moved := slusk
|
|
moved.Digest = digOld
|
|
require.NoError(t, s.UpsertService(ctx, f.b, "", moved, t0.Add(4*time.Hour)))
|
|
|
|
live, err := s.ListServices(ctx)
|
|
require.NoError(t, err)
|
|
require.Len(t, live, 1)
|
|
assert.Equal(t, f.from, live[0].ID)
|
|
assert.Equal(t, digOld, live[0].ActualDigest)
|
|
})
|
|
|
|
t.Run("a snapshot keeps the survivor", func(t *testing.T) {
|
|
s, f := setup(t)
|
|
ctx := context.Background()
|
|
require.NoError(t, s.ApplySnapshot(ctx, f.b, worker, []protocol.Service{slusk}, t0.Add(4*time.Hour)))
|
|
|
|
got, err := s.GetService(ctx, f.from)
|
|
require.NoError(t, err)
|
|
assert.Nil(t, got.RemovedAt)
|
|
live, err := s.ListServices(ctx)
|
|
require.NoError(t, err)
|
|
assert.Len(t, live, 1)
|
|
})
|
|
|
|
t.Run("the old agent returning with the stack creates a new row", func(t *testing.T) {
|
|
s, f := setup(t)
|
|
ctx := context.Background()
|
|
require.NoError(t, s.ApplySnapshot(ctx, f.a, worker, []protocol.Service{slusk}, t0.Add(4*time.Hour)))
|
|
|
|
returned := serviceID(t, s, f.a, slusk)
|
|
assert.NotEqual(t, f.from, returned)
|
|
got, err := s.GetService(ctx, returned)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, model.ModeManual, got.UpdateMode)
|
|
assert.Empty(t, got.DesiredRef)
|
|
live, err := s.ListServices(ctx)
|
|
require.NoError(t, err)
|
|
assert.Len(t, live, 2)
|
|
})
|
|
}
|
|
|
|
func TestMergeSources(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
f := newMoveFixture(t, s)
|
|
// A removed service with another name, removed later than the matching one.
|
|
other := protocol.Service{Kind: protocol.KindCompose, ComposeProject: "renamed", ComposeService: "app", Image: "x/y:1", Status: "running"}
|
|
require.NoError(t, s.UpsertService(ctx, f.a, "", other, t0))
|
|
require.NoError(t, s.RemoveService(ctx, f.a, "", other.Key(), t0.Add(5*time.Hour)))
|
|
otherID := serviceID(t, s, f.a, other)
|
|
// Other kinds, the updater itself and a live service never show up.
|
|
require.NoError(t, s.ApplySnapshot(ctx, f.a, worker, []protocol.Service{adhoc}, t0.Add(6*time.Hour)))
|
|
require.NoError(t, s.ApplySnapshot(ctx, f.a, worker, nil, t0.Add(7*time.Hour)))
|
|
selfSvc := protocol.Service{Kind: protocol.KindCompose, ComposeProject: "pu", ComposeService: "agent", Image: "pu:1", Status: "running", Self: true}
|
|
require.NoError(t, s.UpsertService(ctx, f.a, "", selfSvc, t0))
|
|
require.NoError(t, s.RemoveService(ctx, f.a, "", selfSvc.Key(), t0.Add(8*time.Hour)))
|
|
|
|
got, err := s.MergeSources(ctx, f.to)
|
|
|
|
require.NoError(t, err)
|
|
var ids []int64
|
|
for _, m := range got {
|
|
ids = append(ids, m.ID)
|
|
}
|
|
assert.Equal(t, []int64{f.from, otherID}, ids, "same name first, then the most recently removed")
|
|
assert.Equal(t, "a", got[0].AgentName)
|
|
|
|
_, err = s.MergeSources(ctx, 9999)
|
|
assert.ErrorIs(t, err, model.ErrNotFound)
|
|
|
|
containerID := serviceID(t, s, f.a, adhoc)
|
|
got, err = s.MergeSources(ctx, containerID)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, got, "plain containers cannot be merged")
|
|
}
|