detached 067ccd6

#15 feat(mirror): push mirrors to a second remote

state
merged · 067ccd6 · fast-forward
branch
feat/push-mirror → main
opened
bnema ·
updated

Push mirrors: keep a second remote (e.g. GitHub) in sync over SSH.

  • One server ed25519 key, sealed with ERMITE_SECRETS_KEY. Setup: ermite mirror key show | gh ssh-key add -
  • Global URL template ({repo}) with a cron, plus per-repo add/remove/exclude/include.
  • Pushes the default branch and tags (all branches optional). Never force, never --mirror, never deletes remote refs; a diverged remote pauses the mirror.
  • Anti-spam: no-op snapshot, single-flight per repo, 60 s manual throttle, cron at least every 5 min, backoff 5 min doubling to 6 h, pause after 5 transient failures or at once on diverged/auth/not found/host key.
  • Visibility: ermite mirror status, admin-only remote: warning on git push, repo page badge, mirror.failed (once per incident) and mirror.recovered events, ermite watch.
  • Pushes, merges and default-branch changes mark the repo dirty; the next due cron tick syncs it.
  • Requires ermite-api v0.12.0. Docs: docs/mirror.md.

Checks: go build, go vet, go test ./..., hexcheck -fail-on warn. Reviewed with two Go review rounds plus a targeted re-review.

CommitSubjectAuthorDateSignatureStatus
067ccd6fix(gitpush): log a failed removal of the temporary key directory and simplify the refspec checkbriceGPG Verified
0c0449bbuild(deps): require ermite-api v0.12.0briceGPG Verified
6793112fix(mirror): skip non-UTF-8 ref names, keep SyncAll errors to the failure class and document the Wait barrierbriceGPG Verified
1427755fix(mirror): sanitize push output, harden SSH options, add mirror events to watch and stable --json outputbriceGPG Verified
5805840fix(mirror): sync --all past failures, admin-only warnings, no config lock during pushes and deferred due reposbriceGPG Verified
5e1949ffix(domain): reject dash-led SSH users and hosts, check cron gaps on non-leap years and inject the URL validatorbriceGPG Verified
335d134fix(mirror): mark mirrors dirty on merges and default branch changes, validate config before saving and keep manual throttling on coalesced syncsbriceGPG Verified
c59b5fafix(domain): check the cron gap across the year, parse only on resolution and classify more SSH auth denialsbriceGPG Verified
4d330eadocs(mirror): document push mirror setup, sync rules, CLI and eventsbriceGPG Verified
49d746dmerge: push mirror CLI and composition into feat/push-mirrorbriceGPG Verified
86b5a04merge: push mirror warning and badge into feat/push-mirrorbriceGPG Verified
0ebe073feat(cli): add the mirror commands and wire push mirrors into the forgebriceGPG Verified
475ebb6feat(mirror): warn about failing mirrors on git push and show a badge on the repo pagebriceGPG Verified
ed419c7feat(rpc): serve the mirror service, convert mirror events and add the mirror clientbriceGPG Verified
26e2b66merge: push mirror use case into feat/push-mirrorbriceGPG Verified
3fb99b3merge: push mirror adapters into feat/push-mirrorbriceGPG Verified
a40b26ffeat(mirror): add the mirror use case with scheduler, single-flight sync and push triggerbriceGPG Verified
3aadd9bfix(domain): emit one mirror.failed event per incident, including the pausebriceGPG Verified
e3ee891feat(mirror): add the git push transport and the mirror KV storagebriceGPG Verified
1069a88feat(domain): add push mirror config, state machine, ref selection and portsbriceGPG Verified

Checks 8

69 files · +8558 -290
Unified
UnifiedSplit
8/8
⋯

Merge settings

modes
fast-forward, squash, merge commit
checks
failing or unfinished checks block the merge
M README.md +1 -0
show this file
M docs/ci-events.md +9 -0
show this file
M docs/cli.md +8 -1
show this file
A docs/mirror.md +82 -0
show this file
A gen/ermite/storage/mirror.pb.go +577 -0
show this file
M go.mod +1 -1
show this file
M go.sum +2 -2
show this file
M internal/adapters/client/client.go +5 -0
show this file
M internal/adapters/githttp/hooks.go +30 -3
show this file
M internal/adapters/githttp/hooks_test.go +46 -0
show this file
A internal/adapters/gitpush/gitpush.go +258 -0
show this file
A internal/adapters/gitpush/gitpush_test.go +197 -0
show this file
A internal/adapters/gitpush/run_linux.go +107 -0
show this file
A internal/adapters/gitpush/run_other.go +33 -0
show this file
M internal/adapters/kvstore/export_test.go +6 -0
show this file
A internal/adapters/kvstore/mirror.go +201 -0
show this file
A internal/adapters/kvstore/mirror_test.go +125 -0
show this file
M internal/adapters/kvstore/repos.go +1 -0
show this file
M internal/adapters/rpc/api.go +11 -5
show this file
M internal/adapters/rpc/convert.go +6 -0
show this file
A internal/adapters/rpc/mirror.go +204 -0
show this file
A internal/adapters/rpc/mirror_test.go +108 -0
show this file
A internal/adapters/web/mirror.go +27 -0
show this file
A internal/adapters/web/mirror_test.go +53 -0
show this file
M internal/adapters/web/pages.templ +11 -0
show this file
M internal/adapters/web/pages_templ.go +324 -269
show this file
M internal/adapters/web/summary.go +1 -0
show this file
M internal/adapters/web/view.go +1 -0
show this file
M internal/adapters/web/web.go +3 -0
show this file
M internal/app/api_test.go +1 -1
show this file
M internal/app/cli_e2e_test.go +1 -1
show this file
A internal/app/cli_mirror.go +320 -0
show this file
A internal/app/cli_mirror_e2e_test.go +122 -0
show this file
A internal/app/cli_mirror_test.go +67 -0
show this file
M internal/app/cli_watch.go +14 -0
show this file
M internal/app/cli_watch_test.go +17 -0
show this file
M internal/app/forge.go +33 -1
show this file
M internal/app/root.go +1 -1
show this file
M internal/app/web.go +1 -0
show this file
M internal/domain/event.go +22 -0
show this file
A internal/domain/mirror.go +254 -0
show this file
A internal/domain/mirror_cron.go +91 -0
show this file
A internal/domain/mirror_key.go +39 -0
show this file
A internal/domain/mirror_refs.go +57 -0
show this file
A internal/domain/mirror_state.go +202 -0
show this file
A internal/domain/mirror_test.go +302 -0
show this file
A internal/ports/mirror.go +122 -0
show this file
A internal/ports/mocks/MirrorKeyStore.go +185 -0
show this file
A internal/ports/mocks/MirrorPusher.go +114 -0
show this file
A internal/ports/mocks/MirrorService.go +824 -0
show this file
A internal/ports/mocks/MirrorStore.go +721 -0
@@ -0,0 +1,721 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package mocks
6+
7+import (
8+ "context"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMirrorStore creates a new instance of MirrorStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMirrorStore(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MirrorStore {
20+ if helper, ok := t.(interface{ Helper() }); ok {
21+ helper.Helper()
22+ }
23+
24+ mock := &MirrorStore{}
25+ mock.Mock.Test(t)
26+
27+ t.Cleanup(func() {
28+ if helper, ok := t.(interface{ Helper() }); ok {
29+ helper.Helper()
30+ }
31+ mock.AssertExpectations(t)
32+ })
33+
34+ return mock
35+}
36+
37+// MirrorStore is an autogenerated mock type for the MirrorStore type
38+type MirrorStore struct {
39+ mock.Mock
40+}
41+
42+type MirrorStore_Expecter struct {
43+ mock *mock.Mock
44+}
45+
46+func (_m *MirrorStore) EXPECT() *MirrorStore_Expecter {
47+ return &MirrorStore_Expecter{mock: &_m.Mock}
48+}
49+
50+// DeleteRepoConfig provides a mock function for the type MirrorStore
51+func (_mock *MirrorStore) DeleteRepoConfig(ctx context.Context, repo domain.RepoName) error {
52+ ret := _mock.Called(ctx, repo)
53+
54+ if len(ret) == 0 {
55+ panic("no return value specified for DeleteRepoConfig")
56+ }
57+
58+ var r0 error
59+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) error); ok {
60+ r0 = returnFunc(ctx, repo)
61+ } else {
62+ r0 = ret.Error(0)
63+ }
64+ return r0
65+}
66+
67+// MirrorStore_DeleteRepoConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRepoConfig'
68+type MirrorStore_DeleteRepoConfig_Call struct {
69+ *mock.Call
70+}
71+
72+// DeleteRepoConfig is a helper method to define mock.On call
73+// - ctx context.Context
74+// - repo domain.RepoName
75+func (_e *MirrorStore_Expecter) DeleteRepoConfig(ctx any, repo any) *MirrorStore_DeleteRepoConfig_Call {
76+ return &MirrorStore_DeleteRepoConfig_Call{Call: _e.mock.On("DeleteRepoConfig", ctx, repo)}
77+}
78+
79+func (_c *MirrorStore_DeleteRepoConfig_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_DeleteRepoConfig_Call {
80+ _c.Call.Run(func(args mock.Arguments) {
81+ var arg0 context.Context
82+ if args[0] != nil {
83+ arg0 = args[0].(context.Context)
84+ }
85+ var arg1 domain.RepoName
86+ if args[1] != nil {
87+ arg1 = args[1].(domain.RepoName)
88+ }
89+ run(
90+ arg0,
91+ arg1,
92+ )
93+ })
94+ return _c
95+}
96+
97+func (_c *MirrorStore_DeleteRepoConfig_Call) Return(err error) *MirrorStore_DeleteRepoConfig_Call {
98+ _c.Call.Return(err)
99+ return _c
100+}
101+
102+func (_c *MirrorStore_DeleteRepoConfig_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) error) *MirrorStore_DeleteRepoConfig_Call {
103+ _c.Call.Return(run)
104+ return _c
105+}
106+
107+// GetGlobal provides a mock function for the type MirrorStore
108+func (_mock *MirrorStore) GetGlobal(ctx context.Context) (domain.MirrorGlobalConfig, error) {
109+ ret := _mock.Called(ctx)
110+
111+ if len(ret) == 0 {
112+ panic("no return value specified for GetGlobal")
113+ }
114+
115+ var r0 domain.MirrorGlobalConfig
116+ var r1 error
117+ if returnFunc, ok := ret.Get(0).(func(context.Context) (domain.MirrorGlobalConfig, error)); ok {
118+ return returnFunc(ctx)
119+ }
120+ if returnFunc, ok := ret.Get(0).(func(context.Context) domain.MirrorGlobalConfig); ok {
121+ r0 = returnFunc(ctx)
122+ } else {
123+ r0 = ret.Get(0).(domain.MirrorGlobalConfig)
124+ }
125+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
126+ r1 = returnFunc(ctx)
127+ } else {
128+ r1 = ret.Error(1)
129+ }
130+ return r0, r1
131+}
132+
133+// MirrorStore_GetGlobal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGlobal'
134+type MirrorStore_GetGlobal_Call struct {
135+ *mock.Call
136+}
137+
138+// GetGlobal is a helper method to define mock.On call
139+// - ctx context.Context
140+func (_e *MirrorStore_Expecter) GetGlobal(ctx any) *MirrorStore_GetGlobal_Call {
141+ return &MirrorStore_GetGlobal_Call{Call: _e.mock.On("GetGlobal", ctx)}
142+}
143+
144+func (_c *MirrorStore_GetGlobal_Call) Run(run func(ctx context.Context)) *MirrorStore_GetGlobal_Call {
145+ _c.Call.Run(func(args mock.Arguments) {
146+ var arg0 context.Context
147+ if args[0] != nil {
148+ arg0 = args[0].(context.Context)
149+ }
150+ run(
151+ arg0,
152+ )
153+ })
154+ return _c
155+}
156+
157+func (_c *MirrorStore_GetGlobal_Call) Return(mirrorGlobalConfig domain.MirrorGlobalConfig, err error) *MirrorStore_GetGlobal_Call {
158+ _c.Call.Return(mirrorGlobalConfig, err)
159+ return _c
160+}
161+
162+func (_c *MirrorStore_GetGlobal_Call) RunAndReturn(run func(ctx context.Context) (domain.MirrorGlobalConfig, error)) *MirrorStore_GetGlobal_Call {
163+ _c.Call.Return(run)
164+ return _c
165+}
166+
167+// GetRepoConfig provides a mock function for the type MirrorStore
168+func (_mock *MirrorStore) GetRepoConfig(ctx context.Context, repo domain.RepoName) (domain.MirrorRepoConfig, error) {
169+ ret := _mock.Called(ctx, repo)
170+
171+ if len(ret) == 0 {
172+ panic("no return value specified for GetRepoConfig")
173+ }
174+
175+ var r0 domain.MirrorRepoConfig
176+ var r1 error
177+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) (domain.MirrorRepoConfig, error)); ok {
178+ return returnFunc(ctx, repo)
179+ }
180+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) domain.MirrorRepoConfig); ok {
181+ r0 = returnFunc(ctx, repo)
182+ } else {
183+ r0 = ret.Get(0).(domain.MirrorRepoConfig)
184+ }
185+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
186+ r1 = returnFunc(ctx, repo)
187+ } else {
188+ r1 = ret.Error(1)
189+ }
190+ return r0, r1
191+}
192+
193+// MirrorStore_GetRepoConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepoConfig'
194+type MirrorStore_GetRepoConfig_Call struct {
195+ *mock.Call
196+}
197+
198+// GetRepoConfig is a helper method to define mock.On call
199+// - ctx context.Context
200+// - repo domain.RepoName
201+func (_e *MirrorStore_Expecter) GetRepoConfig(ctx any, repo any) *MirrorStore_GetRepoConfig_Call {
202+ return &MirrorStore_GetRepoConfig_Call{Call: _e.mock.On("GetRepoConfig", ctx, repo)}
203+}
204+
205+func (_c *MirrorStore_GetRepoConfig_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_GetRepoConfig_Call {
206+ _c.Call.Run(func(args mock.Arguments) {
207+ var arg0 context.Context
208+ if args[0] != nil {
209+ arg0 = args[0].(context.Context)
210+ }
211+ var arg1 domain.RepoName
212+ if args[1] != nil {
213+ arg1 = args[1].(domain.RepoName)
214+ }
215+ run(
216+ arg0,
217+ arg1,
218+ )
219+ })
220+ return _c
221+}
222+
223+func (_c *MirrorStore_GetRepoConfig_Call) Return(mirrorRepoConfig domain.MirrorRepoConfig, err error) *MirrorStore_GetRepoConfig_Call {
224+ _c.Call.Return(mirrorRepoConfig, err)
225+ return _c
226+}
227+
228+func (_c *MirrorStore_GetRepoConfig_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) (domain.MirrorRepoConfig, error)) *MirrorStore_GetRepoConfig_Call {
229+ _c.Call.Return(run)
230+ return _c
231+}
232+
233+// GetSnapshot provides a mock function for the type MirrorStore
234+func (_mock *MirrorStore) GetSnapshot(ctx context.Context, repo domain.RepoName) (domain.MirrorSnapshot, error) {
235+ ret := _mock.Called(ctx, repo)
236+
237+ if len(ret) == 0 {
238+ panic("no return value specified for GetSnapshot")
239+ }
240+
241+ var r0 domain.MirrorSnapshot
242+ var r1 error
243+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) (domain.MirrorSnapshot, error)); ok {
244+ return returnFunc(ctx, repo)
245+ }
246+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) domain.MirrorSnapshot); ok {
247+ r0 = returnFunc(ctx, repo)
248+ } else {
249+ r0 = ret.Get(0).(domain.MirrorSnapshot)
250+ }
251+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
252+ r1 = returnFunc(ctx, repo)
253+ } else {
254+ r1 = ret.Error(1)
255+ }
256+ return r0, r1
257+}
258+
259+// MirrorStore_GetSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshot'
260+type MirrorStore_GetSnapshot_Call struct {
261+ *mock.Call
262+}
263+
264+// GetSnapshot is a helper method to define mock.On call
265+// - ctx context.Context
266+// - repo domain.RepoName
267+func (_e *MirrorStore_Expecter) GetSnapshot(ctx any, repo any) *MirrorStore_GetSnapshot_Call {
268+ return &MirrorStore_GetSnapshot_Call{Call: _e.mock.On("GetSnapshot", ctx, repo)}
269+}
270+
271+func (_c *MirrorStore_GetSnapshot_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_GetSnapshot_Call {
272+ _c.Call.Run(func(args mock.Arguments) {
273+ var arg0 context.Context
274+ if args[0] != nil {
275+ arg0 = args[0].(context.Context)
276+ }
277+ var arg1 domain.RepoName
278+ if args[1] != nil {
279+ arg1 = args[1].(domain.RepoName)
280+ }
281+ run(
282+ arg0,
283+ arg1,
284+ )
285+ })
286+ return _c
287+}
288+
289+func (_c *MirrorStore_GetSnapshot_Call) Return(mirrorSnapshot domain.MirrorSnapshot, err error) *MirrorStore_GetSnapshot_Call {
290+ _c.Call.Return(mirrorSnapshot, err)
291+ return _c
292+}
293+
294+func (_c *MirrorStore_GetSnapshot_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) (domain.MirrorSnapshot, error)) *MirrorStore_GetSnapshot_Call {
295+ _c.Call.Return(run)
296+ return _c
297+}
298+
299+// GetStatus provides a mock function for the type MirrorStore
300+func (_mock *MirrorStore) GetStatus(ctx context.Context, repo domain.RepoName) (domain.MirrorStatus, error) {
301+ ret := _mock.Called(ctx, repo)
302+
303+ if len(ret) == 0 {
304+ panic("no return value specified for GetStatus")
305+ }
306+
307+ var r0 domain.MirrorStatus
308+ var r1 error
309+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) (domain.MirrorStatus, error)); ok {
310+ return returnFunc(ctx, repo)
311+ }
312+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) domain.MirrorStatus); ok {
313+ r0 = returnFunc(ctx, repo)
314+ } else {
315+ r0 = ret.Get(0).(domain.MirrorStatus)
316+ }
317+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
318+ r1 = returnFunc(ctx, repo)
319+ } else {
320+ r1 = ret.Error(1)
321+ }
322+ return r0, r1
323+}
324+
325+// MirrorStore_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
326+type MirrorStore_GetStatus_Call struct {
327+ *mock.Call
328+}
329+
330+// GetStatus is a helper method to define mock.On call
331+// - ctx context.Context
332+// - repo domain.RepoName
333+func (_e *MirrorStore_Expecter) GetStatus(ctx any, repo any) *MirrorStore_GetStatus_Call {
334+ return &MirrorStore_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx, repo)}
335+}
336+
337+func (_c *MirrorStore_GetStatus_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_GetStatus_Call {
338+ _c.Call.Run(func(args mock.Arguments) {
339+ var arg0 context.Context
340+ if args[0] != nil {
341+ arg0 = args[0].(context.Context)
342+ }
343+ var arg1 domain.RepoName
344+ if args[1] != nil {
345+ arg1 = args[1].(domain.RepoName)
346+ }
347+ run(
348+ arg0,
349+ arg1,
350+ )
351+ })
352+ return _c
353+}
354+
355+func (_c *MirrorStore_GetStatus_Call) Return(mirrorStatus domain.MirrorStatus, err error) *MirrorStore_GetStatus_Call {
356+ _c.Call.Return(mirrorStatus, err)
357+ return _c
358+}
359+
360+func (_c *MirrorStore_GetStatus_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) (domain.MirrorStatus, error)) *MirrorStore_GetStatus_Call {
361+ _c.Call.Return(run)
362+ return _c
363+}
364+
365+// ListRepoConfigs provides a mock function for the type MirrorStore
366+func (_mock *MirrorStore) ListRepoConfigs(ctx context.Context) ([]domain.MirrorRepoConfig, error) {
367+ ret := _mock.Called(ctx)
368+
369+ if len(ret) == 0 {
370+ panic("no return value specified for ListRepoConfigs")
371+ }
372+
373+ var r0 []domain.MirrorRepoConfig
374+ var r1 error
375+ if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.MirrorRepoConfig, error)); ok {
376+ return returnFunc(ctx)
377+ }
378+ if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.MirrorRepoConfig); ok {
379+ r0 = returnFunc(ctx)
380+ } else {
381+ if ret.Get(0) != nil {
382+ r0 = ret.Get(0).([]domain.MirrorRepoConfig)
383+ }
384+ }
385+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
386+ r1 = returnFunc(ctx)
387+ } else {
388+ r1 = ret.Error(1)
389+ }
390+ return r0, r1
391+}
392+
393+// MirrorStore_ListRepoConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepoConfigs'
394+type MirrorStore_ListRepoConfigs_Call struct {
395+ *mock.Call
396+}
397+
398+// ListRepoConfigs is a helper method to define mock.On call
399+// - ctx context.Context
400+func (_e *MirrorStore_Expecter) ListRepoConfigs(ctx any) *MirrorStore_ListRepoConfigs_Call {
401+ return &MirrorStore_ListRepoConfigs_Call{Call: _e.mock.On("ListRepoConfigs", ctx)}
402+}
403+
404+func (_c *MirrorStore_ListRepoConfigs_Call) Run(run func(ctx context.Context)) *MirrorStore_ListRepoConfigs_Call {
405+ _c.Call.Run(func(args mock.Arguments) {
406+ var arg0 context.Context
407+ if args[0] != nil {
408+ arg0 = args[0].(context.Context)
409+ }
410+ run(
411+ arg0,
412+ )
413+ })
414+ return _c
415+}
416+
417+func (_c *MirrorStore_ListRepoConfigs_Call) Return(mirrorRepoConfigs []domain.MirrorRepoConfig, err error) *MirrorStore_ListRepoConfigs_Call {
418+ _c.Call.Return(mirrorRepoConfigs, err)
419+ return _c
420+}
421+
422+func (_c *MirrorStore_ListRepoConfigs_Call) RunAndReturn(run func(ctx context.Context) ([]domain.MirrorRepoConfig, error)) *MirrorStore_ListRepoConfigs_Call {
423+ _c.Call.Return(run)
424+ return _c
425+}
426+
427+// ListStatus provides a mock function for the type MirrorStore
428+func (_mock *MirrorStore) ListStatus(ctx context.Context) ([]domain.MirrorStatus, error) {
429+ ret := _mock.Called(ctx)
430+
431+ if len(ret) == 0 {
432+ panic("no return value specified for ListStatus")
433+ }
434+
435+ var r0 []domain.MirrorStatus
436+ var r1 error
437+ if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.MirrorStatus, error)); ok {
438+ return returnFunc(ctx)
439+ }
440+ if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.MirrorStatus); ok {
441+ r0 = returnFunc(ctx)
442+ } else {
443+ if ret.Get(0) != nil {
444+ r0 = ret.Get(0).([]domain.MirrorStatus)
445+ }
446+ }
447+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
448+ r1 = returnFunc(ctx)
449+ } else {
450+ r1 = ret.Error(1)
451+ }
452+ return r0, r1
453+}
454+
455+// MirrorStore_ListStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStatus'
456+type MirrorStore_ListStatus_Call struct {
457+ *mock.Call
458+}
459+
460+// ListStatus is a helper method to define mock.On call
461+// - ctx context.Context
462+func (_e *MirrorStore_Expecter) ListStatus(ctx any) *MirrorStore_ListStatus_Call {
463+ return &MirrorStore_ListStatus_Call{Call: _e.mock.On("ListStatus", ctx)}
464+}
465+
466+func (_c *MirrorStore_ListStatus_Call) Run(run func(ctx context.Context)) *MirrorStore_ListStatus_Call {
467+ _c.Call.Run(func(args mock.Arguments) {
468+ var arg0 context.Context
469+ if args[0] != nil {
470+ arg0 = args[0].(context.Context)
471+ }
472+ run(
473+ arg0,
474+ )
475+ })
476+ return _c
477+}
478+
479+func (_c *MirrorStore_ListStatus_Call) Return(mirrorStatuss []domain.MirrorStatus, err error) *MirrorStore_ListStatus_Call {
480+ _c.Call.Return(mirrorStatuss, err)
481+ return _c
482+}
483+
484+func (_c *MirrorStore_ListStatus_Call) RunAndReturn(run func(ctx context.Context) ([]domain.MirrorStatus, error)) *MirrorStore_ListStatus_Call {
485+ _c.Call.Return(run)
486+ return _c
487+}
488+
489+// PutGlobal provides a mock function for the type MirrorStore
490+func (_mock *MirrorStore) PutGlobal(ctx context.Context, g domain.MirrorGlobalConfig) error {
491+ ret := _mock.Called(ctx, g)
492+
493+ if len(ret) == 0 {
494+ panic("no return value specified for PutGlobal")
495+ }
496+
497+ var r0 error
498+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.MirrorGlobalConfig) error); ok {
499+ r0 = returnFunc(ctx, g)
500+ } else {
501+ r0 = ret.Error(0)
502+ }
503+ return r0
504+}
505+
506+// MirrorStore_PutGlobal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutGlobal'
507+type MirrorStore_PutGlobal_Call struct {
508+ *mock.Call
509+}
510+
511+// PutGlobal is a helper method to define mock.On call
512+// - ctx context.Context
513+// - g domain.MirrorGlobalConfig
514+func (_e *MirrorStore_Expecter) PutGlobal(ctx any, g any) *MirrorStore_PutGlobal_Call {
515+ return &MirrorStore_PutGlobal_Call{Call: _e.mock.On("PutGlobal", ctx, g)}
516+}
517+
518+func (_c *MirrorStore_PutGlobal_Call) Run(run func(ctx context.Context, g domain.MirrorGlobalConfig)) *MirrorStore_PutGlobal_Call {
519+ _c.Call.Run(func(args mock.Arguments) {
520+ var arg0 context.Context
521+ if args[0] != nil {
522+ arg0 = args[0].(context.Context)
523+ }
524+ var arg1 domain.MirrorGlobalConfig
525+ if args[1] != nil {
526+ arg1 = args[1].(domain.MirrorGlobalConfig)
527+ }
528+ run(
529+ arg0,
530+ arg1,
531+ )
532+ })
533+ return _c
534+}
535+
536+func (_c *MirrorStore_PutGlobal_Call) Return(err error) *MirrorStore_PutGlobal_Call {
537+ _c.Call.Return(err)
538+ return _c
539+}
540+
541+func (_c *MirrorStore_PutGlobal_Call) RunAndReturn(run func(ctx context.Context, g domain.MirrorGlobalConfig) error) *MirrorStore_PutGlobal_Call {
542+ _c.Call.Return(run)
543+ return _c
544+}
545+
546+// PutRepoConfig provides a mock function for the type MirrorStore
547+func (_mock *MirrorStore) PutRepoConfig(ctx context.Context, c domain.MirrorRepoConfig) error {
548+ ret := _mock.Called(ctx, c)
549+
550+ if len(ret) == 0 {
551+ panic("no return value specified for PutRepoConfig")
552+ }
553+
554+ var r0 error
555+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.MirrorRepoConfig) error); ok {
556+ r0 = returnFunc(ctx, c)
557+ } else {
558+ r0 = ret.Error(0)
559+ }
560+ return r0
561+}
562+
563+// MirrorStore_PutRepoConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutRepoConfig'
564+type MirrorStore_PutRepoConfig_Call struct {
565+ *mock.Call
566+}
567+
568+// PutRepoConfig is a helper method to define mock.On call
569+// - ctx context.Context
570+// - c domain.MirrorRepoConfig
571+func (_e *MirrorStore_Expecter) PutRepoConfig(ctx any, c any) *MirrorStore_PutRepoConfig_Call {
572+ return &MirrorStore_PutRepoConfig_Call{Call: _e.mock.On("PutRepoConfig", ctx, c)}
573+}
574+
575+func (_c *MirrorStore_PutRepoConfig_Call) Run(run func(ctx context.Context, c domain.MirrorRepoConfig)) *MirrorStore_PutRepoConfig_Call {
576+ _c.Call.Run(func(args mock.Arguments) {
577+ var arg0 context.Context
578+ if args[0] != nil {
579+ arg0 = args[0].(context.Context)
580+ }
581+ var arg1 domain.MirrorRepoConfig
582+ if args[1] != nil {
583+ arg1 = args[1].(domain.MirrorRepoConfig)
584+ }
585+ run(
586+ arg0,
587+ arg1,
588+ )
589+ })
590+ return _c
591+}
592+
593+func (_c *MirrorStore_PutRepoConfig_Call) Return(err error) *MirrorStore_PutRepoConfig_Call {
594+ _c.Call.Return(err)
595+ return _c
596+}
597+
598+func (_c *MirrorStore_PutRepoConfig_Call) RunAndReturn(run func(ctx context.Context, c domain.MirrorRepoConfig) error) *MirrorStore_PutRepoConfig_Call {
599+ _c.Call.Return(run)
600+ return _c
601+}
602+
603+// PutSnapshot provides a mock function for the type MirrorStore
604+func (_mock *MirrorStore) PutSnapshot(ctx context.Context, repo domain.RepoName, s domain.MirrorSnapshot) error {
605+ ret := _mock.Called(ctx, repo, s)
606+
607+ if len(ret) == 0 {
608+ panic("no return value specified for PutSnapshot")
609+ }
610+
611+ var r0 error
612+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, domain.MirrorSnapshot) error); ok {
613+ r0 = returnFunc(ctx, repo, s)
614+ } else {
615+ r0 = ret.Error(0)
616+ }
617+ return r0
618+}
619+
620+// MirrorStore_PutSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutSnapshot'
621+type MirrorStore_PutSnapshot_Call struct {
622+ *mock.Call
623+}
624+
625+// PutSnapshot is a helper method to define mock.On call
626+// - ctx context.Context
627+// - repo domain.RepoName
628+// - s domain.MirrorSnapshot
629+func (_e *MirrorStore_Expecter) PutSnapshot(ctx any, repo any, s any) *MirrorStore_PutSnapshot_Call {
630+ return &MirrorStore_PutSnapshot_Call{Call: _e.mock.On("PutSnapshot", ctx, repo, s)}
631+}
632+
633+func (_c *MirrorStore_PutSnapshot_Call) Run(run func(ctx context.Context, repo domain.RepoName, s domain.MirrorSnapshot)) *MirrorStore_PutSnapshot_Call {
634+ _c.Call.Run(func(args mock.Arguments) {
635+ var arg0 context.Context
636+ if args[0] != nil {
637+ arg0 = args[0].(context.Context)
638+ }
639+ var arg1 domain.RepoName
640+ if args[1] != nil {
641+ arg1 = args[1].(domain.RepoName)
642+ }
643+ var arg2 domain.MirrorSnapshot
644+ if args[2] != nil {
645+ arg2 = args[2].(domain.MirrorSnapshot)
646+ }
647+ run(
648+ arg0,
649+ arg1,
650+ arg2,
651+ )
652+ })
653+ return _c
654+}
655+
656+func (_c *MirrorStore_PutSnapshot_Call) Return(err error) *MirrorStore_PutSnapshot_Call {
657+ _c.Call.Return(err)
658+ return _c
659+}
660+
661+func (_c *MirrorStore_PutSnapshot_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, s domain.MirrorSnapshot) error) *MirrorStore_PutSnapshot_Call {
662+ _c.Call.Return(run)
663+ return _c
664+}
665+
666+// PutStatus provides a mock function for the type MirrorStore
667+func (_mock *MirrorStore) PutStatus(ctx context.Context, s domain.MirrorStatus) error {
668+ ret := _mock.Called(ctx, s)
669+
670+ if len(ret) == 0 {
671+ panic("no return value specified for PutStatus")
672+ }
673+
674+ var r0 error
675+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.MirrorStatus) error); ok {
676+ r0 = returnFunc(ctx, s)
677+ } else {
678+ r0 = ret.Error(0)
679+ }
680+ return r0
681+}
682+
683+// MirrorStore_PutStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutStatus'
684+type MirrorStore_PutStatus_Call struct {
685+ *mock.Call
686+}
687+
688+// PutStatus is a helper method to define mock.On call
689+// - ctx context.Context
690+// - s domain.MirrorStatus
691+func (_e *MirrorStore_Expecter) PutStatus(ctx any, s any) *MirrorStore_PutStatus_Call {
692+ return &MirrorStore_PutStatus_Call{Call: _e.mock.On("PutStatus", ctx, s)}
693+}
694+
695+func (_c *MirrorStore_PutStatus_Call) Run(run func(ctx context.Context, s domain.MirrorStatus)) *MirrorStore_PutStatus_Call {
696+ _c.Call.Run(func(args mock.Arguments) {
697+ var arg0 context.Context
698+ if args[0] != nil {
699+ arg0 = args[0].(context.Context)
700+ }
701+ var arg1 domain.MirrorStatus
702+ if args[1] != nil {
703+ arg1 = args[1].(domain.MirrorStatus)
704+ }
705+ run(
706+ arg0,
707+ arg1,
708+ )
709+ })
710+ return _c
711+}
712+
713+func (_c *MirrorStore_PutStatus_Call) Return(err error) *MirrorStore_PutStatus_Call {
714+ _c.Call.Return(err)
715+ return _c
716+}
717+
718+func (_c *MirrorStore_PutStatus_Call) RunAndReturn(run func(ctx context.Context, s domain.MirrorStatus) error) *MirrorStore_PutStatus_Call {
719+ _c.Call.Return(run)
720+ return _c
721+}
@@ -0,0 +1,721 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package mocks
6+
7+import (
8+ "context"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMirrorStore creates a new instance of MirrorStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMirrorStore(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MirrorStore {
20+ if helper, ok := t.(interface{ Helper() }); ok {
21+ helper.Helper()
22+ }
23+
24+ mock := &MirrorStore{}
25+ mock.Mock.Test(t)
26+
27+ t.Cleanup(func() {
28+ if helper, ok := t.(interface{ Helper() }); ok {
29+ helper.Helper()
30+ }
31+ mock.AssertExpectations(t)
32+ })
33+
34+ return mock
35+}
36+
37+// MirrorStore is an autogenerated mock type for the MirrorStore type
38+type MirrorStore struct {
39+ mock.Mock
40+}
41+
42+type MirrorStore_Expecter struct {
43+ mock *mock.Mock
44+}
45+
46+func (_m *MirrorStore) EXPECT() *MirrorStore_Expecter {
47+ return &MirrorStore_Expecter{mock: &_m.Mock}
48+}
49+
50+// DeleteRepoConfig provides a mock function for the type MirrorStore
51+func (_mock *MirrorStore) DeleteRepoConfig(ctx context.Context, repo domain.RepoName) error {
52+ ret := _mock.Called(ctx, repo)
53+
54+ if len(ret) == 0 {
55+ panic("no return value specified for DeleteRepoConfig")
56+ }
57+
58+ var r0 error
59+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) error); ok {
60+ r0 = returnFunc(ctx, repo)
61+ } else {
62+ r0 = ret.Error(0)
63+ }
64+ return r0
65+}
66+
67+// MirrorStore_DeleteRepoConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRepoConfig'
68+type MirrorStore_DeleteRepoConfig_Call struct {
69+ *mock.Call
70+}
71+
72+// DeleteRepoConfig is a helper method to define mock.On call
73+// - ctx context.Context
74+// - repo domain.RepoName
75+func (_e *MirrorStore_Expecter) DeleteRepoConfig(ctx any, repo any) *MirrorStore_DeleteRepoConfig_Call {
76+ return &MirrorStore_DeleteRepoConfig_Call{Call: _e.mock.On("DeleteRepoConfig", ctx, repo)}
77+}
78+
79+func (_c *MirrorStore_DeleteRepoConfig_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_DeleteRepoConfig_Call {
80+ _c.Call.Run(func(args mock.Arguments) {
81+ var arg0 context.Context
82+ if args[0] != nil {
83+ arg0 = args[0].(context.Context)
84+ }
85+ var arg1 domain.RepoName
86+ if args[1] != nil {
87+ arg1 = args[1].(domain.RepoName)
88+ }
89+ run(
90+ arg0,
91+ arg1,
92+ )
93+ })
94+ return _c
95+}
96+
97+func (_c *MirrorStore_DeleteRepoConfig_Call) Return(err error) *MirrorStore_DeleteRepoConfig_Call {
98+ _c.Call.Return(err)
99+ return _c
100+}
101+
102+func (_c *MirrorStore_DeleteRepoConfig_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) error) *MirrorStore_DeleteRepoConfig_Call {
103+ _c.Call.Return(run)
104+ return _c
105+}
106+
107+// GetGlobal provides a mock function for the type MirrorStore
108+func (_mock *MirrorStore) GetGlobal(ctx context.Context) (domain.MirrorGlobalConfig, error) {
109+ ret := _mock.Called(ctx)
110+
111+ if len(ret) == 0 {
112+ panic("no return value specified for GetGlobal")
113+ }
114+
115+ var r0 domain.MirrorGlobalConfig
116+ var r1 error
117+ if returnFunc, ok := ret.Get(0).(func(context.Context) (domain.MirrorGlobalConfig, error)); ok {
118+ return returnFunc(ctx)
119+ }
120+ if returnFunc, ok := ret.Get(0).(func(context.Context) domain.MirrorGlobalConfig); ok {
121+ r0 = returnFunc(ctx)
122+ } else {
123+ r0 = ret.Get(0).(domain.MirrorGlobalConfig)
124+ }
125+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
126+ r1 = returnFunc(ctx)
127+ } else {
128+ r1 = ret.Error(1)
129+ }
130+ return r0, r1
131+}
132+
133+// MirrorStore_GetGlobal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGlobal'
134+type MirrorStore_GetGlobal_Call struct {
135+ *mock.Call
136+}
137+
138+// GetGlobal is a helper method to define mock.On call
139+// - ctx context.Context
140+func (_e *MirrorStore_Expecter) GetGlobal(ctx any) *MirrorStore_GetGlobal_Call {
141+ return &MirrorStore_GetGlobal_Call{Call: _e.mock.On("GetGlobal", ctx)}
142+}
143+
144+func (_c *MirrorStore_GetGlobal_Call) Run(run func(ctx context.Context)) *MirrorStore_GetGlobal_Call {
145+ _c.Call.Run(func(args mock.Arguments) {
146+ var arg0 context.Context
147+ if args[0] != nil {
148+ arg0 = args[0].(context.Context)
149+ }
150+ run(
151+ arg0,
152+ )
153+ })
154+ return _c
155+}
156+
157+func (_c *MirrorStore_GetGlobal_Call) Return(mirrorGlobalConfig domain.MirrorGlobalConfig, err error) *MirrorStore_GetGlobal_Call {
158+ _c.Call.Return(mirrorGlobalConfig, err)
159+ return _c
160+}
161+
162+func (_c *MirrorStore_GetGlobal_Call) RunAndReturn(run func(ctx context.Context) (domain.MirrorGlobalConfig, error)) *MirrorStore_GetGlobal_Call {
163+ _c.Call.Return(run)
164+ return _c
165+}
166+
167+// GetRepoConfig provides a mock function for the type MirrorStore
168+func (_mock *MirrorStore) GetRepoConfig(ctx context.Context, repo domain.RepoName) (domain.MirrorRepoConfig, error) {
169+ ret := _mock.Called(ctx, repo)
170+
171+ if len(ret) == 0 {
172+ panic("no return value specified for GetRepoConfig")
173+ }
174+
175+ var r0 domain.MirrorRepoConfig
176+ var r1 error
177+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) (domain.MirrorRepoConfig, error)); ok {
178+ return returnFunc(ctx, repo)
179+ }
180+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) domain.MirrorRepoConfig); ok {
181+ r0 = returnFunc(ctx, repo)
182+ } else {
183+ r0 = ret.Get(0).(domain.MirrorRepoConfig)
184+ }
185+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
186+ r1 = returnFunc(ctx, repo)
187+ } else {
188+ r1 = ret.Error(1)
189+ }
190+ return r0, r1
191+}
192+
193+// MirrorStore_GetRepoConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepoConfig'
194+type MirrorStore_GetRepoConfig_Call struct {
195+ *mock.Call
196+}
197+
198+// GetRepoConfig is a helper method to define mock.On call
199+// - ctx context.Context
200+// - repo domain.RepoName
201+func (_e *MirrorStore_Expecter) GetRepoConfig(ctx any, repo any) *MirrorStore_GetRepoConfig_Call {
202+ return &MirrorStore_GetRepoConfig_Call{Call: _e.mock.On("GetRepoConfig", ctx, repo)}
203+}
204+
205+func (_c *MirrorStore_GetRepoConfig_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_GetRepoConfig_Call {
206+ _c.Call.Run(func(args mock.Arguments) {
207+ var arg0 context.Context
208+ if args[0] != nil {
209+ arg0 = args[0].(context.Context)
210+ }
211+ var arg1 domain.RepoName
212+ if args[1] != nil {
213+ arg1 = args[1].(domain.RepoName)
214+ }
215+ run(
216+ arg0,
217+ arg1,
218+ )
219+ })
220+ return _c
221+}
222+
223+func (_c *MirrorStore_GetRepoConfig_Call) Return(mirrorRepoConfig domain.MirrorRepoConfig, err error) *MirrorStore_GetRepoConfig_Call {
224+ _c.Call.Return(mirrorRepoConfig, err)
225+ return _c
226+}
227+
228+func (_c *MirrorStore_GetRepoConfig_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) (domain.MirrorRepoConfig, error)) *MirrorStore_GetRepoConfig_Call {
229+ _c.Call.Return(run)
230+ return _c
231+}
232+
233+// GetSnapshot provides a mock function for the type MirrorStore
234+func (_mock *MirrorStore) GetSnapshot(ctx context.Context, repo domain.RepoName) (domain.MirrorSnapshot, error) {
235+ ret := _mock.Called(ctx, repo)
236+
237+ if len(ret) == 0 {
238+ panic("no return value specified for GetSnapshot")
239+ }
240+
241+ var r0 domain.MirrorSnapshot
242+ var r1 error
243+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) (domain.MirrorSnapshot, error)); ok {
244+ return returnFunc(ctx, repo)
245+ }
246+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) domain.MirrorSnapshot); ok {
247+ r0 = returnFunc(ctx, repo)
248+ } else {
249+ r0 = ret.Get(0).(domain.MirrorSnapshot)
250+ }
251+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
252+ r1 = returnFunc(ctx, repo)
253+ } else {
254+ r1 = ret.Error(1)
255+ }
256+ return r0, r1
257+}
258+
259+// MirrorStore_GetSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshot'
260+type MirrorStore_GetSnapshot_Call struct {
261+ *mock.Call
262+}
263+
264+// GetSnapshot is a helper method to define mock.On call
265+// - ctx context.Context
266+// - repo domain.RepoName
267+func (_e *MirrorStore_Expecter) GetSnapshot(ctx any, repo any) *MirrorStore_GetSnapshot_Call {
268+ return &MirrorStore_GetSnapshot_Call{Call: _e.mock.On("GetSnapshot", ctx, repo)}
269+}
270+
271+func (_c *MirrorStore_GetSnapshot_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_GetSnapshot_Call {
272+ _c.Call.Run(func(args mock.Arguments) {
273+ var arg0 context.Context
274+ if args[0] != nil {
275+ arg0 = args[0].(context.Context)
276+ }
277+ var arg1 domain.RepoName
278+ if args[1] != nil {
279+ arg1 = args[1].(domain.RepoName)
280+ }
281+ run(
282+ arg0,
283+ arg1,
284+ )
285+ })
286+ return _c
287+}
288+
289+func (_c *MirrorStore_GetSnapshot_Call) Return(mirrorSnapshot domain.MirrorSnapshot, err error) *MirrorStore_GetSnapshot_Call {
290+ _c.Call.Return(mirrorSnapshot, err)
291+ return _c
292+}
293+
294+func (_c *MirrorStore_GetSnapshot_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) (domain.MirrorSnapshot, error)) *MirrorStore_GetSnapshot_Call {
295+ _c.Call.Return(run)
296+ return _c
297+}
298+
299+// GetStatus provides a mock function for the type MirrorStore
300+func (_mock *MirrorStore) GetStatus(ctx context.Context, repo domain.RepoName) (domain.MirrorStatus, error) {
301+ ret := _mock.Called(ctx, repo)
302+
303+ if len(ret) == 0 {
304+ panic("no return value specified for GetStatus")
305+ }
306+
307+ var r0 domain.MirrorStatus
308+ var r1 error
309+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) (domain.MirrorStatus, error)); ok {
310+ return returnFunc(ctx, repo)
311+ }
312+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) domain.MirrorStatus); ok {
313+ r0 = returnFunc(ctx, repo)
314+ } else {
315+ r0 = ret.Get(0).(domain.MirrorStatus)
316+ }
317+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
318+ r1 = returnFunc(ctx, repo)
319+ } else {
320+ r1 = ret.Error(1)
321+ }
322+ return r0, r1
323+}
324+
325+// MirrorStore_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
326+type MirrorStore_GetStatus_Call struct {
327+ *mock.Call
328+}
329+
330+// GetStatus is a helper method to define mock.On call
331+// - ctx context.Context
332+// - repo domain.RepoName
333+func (_e *MirrorStore_Expecter) GetStatus(ctx any, repo any) *MirrorStore_GetStatus_Call {
334+ return &MirrorStore_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx, repo)}
335+}
336+
337+func (_c *MirrorStore_GetStatus_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *MirrorStore_GetStatus_Call {
338+ _c.Call.Run(func(args mock.Arguments) {
339+ var arg0 context.Context
340+ if args[0] != nil {
341+ arg0 = args[0].(context.Context)
342+ }
343+ var arg1 domain.RepoName
344+ if args[1] != nil {
345+ arg1 = args[1].(domain.RepoName)
346+ }
347+ run(
348+ arg0,
349+ arg1,
350+ )
351+ })
352+ return _c
353+}
354+
355+func (_c *MirrorStore_GetStatus_Call) Return(mirrorStatus domain.MirrorStatus, err error) *MirrorStore_GetStatus_Call {
356+ _c.Call.Return(mirrorStatus, err)
357+ return _c
358+}
359+
360+func (_c *MirrorStore_GetStatus_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) (domain.MirrorStatus, error)) *MirrorStore_GetStatus_Call {
361+ _c.Call.Return(run)
362+ return _c
363+}
364+
365+// ListRepoConfigs provides a mock function for the type MirrorStore
366+func (_mock *MirrorStore) ListRepoConfigs(ctx context.Context) ([]domain.MirrorRepoConfig, error) {
367+ ret := _mock.Called(ctx)
368+
369+ if len(ret) == 0 {
370+ panic("no return value specified for ListRepoConfigs")
371+ }
372+
373+ var r0 []domain.MirrorRepoConfig
374+ var r1 error
375+ if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.MirrorRepoConfig, error)); ok {
376+ return returnFunc(ctx)
377+ }
378+ if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.MirrorRepoConfig); ok {
379+ r0 = returnFunc(ctx)
380+ } else {
381+ if ret.Get(0) != nil {
382+ r0 = ret.Get(0).([]domain.MirrorRepoConfig)
383+ }
384+ }
385+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
386+ r1 = returnFunc(ctx)
387+ } else {
388+ r1 = ret.Error(1)
389+ }
390+ return r0, r1
391+}
392+
393+// MirrorStore_ListRepoConfigs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepoConfigs'
394+type MirrorStore_ListRepoConfigs_Call struct {
395+ *mock.Call
396+}
397+
398+// ListRepoConfigs is a helper method to define mock.On call
399+// - ctx context.Context
400+func (_e *MirrorStore_Expecter) ListRepoConfigs(ctx any) *MirrorStore_ListRepoConfigs_Call {
401+ return &MirrorStore_ListRepoConfigs_Call{Call: _e.mock.On("ListRepoConfigs", ctx)}
402+}
403+
404+func (_c *MirrorStore_ListRepoConfigs_Call) Run(run func(ctx context.Context)) *MirrorStore_ListRepoConfigs_Call {
405+ _c.Call.Run(func(args mock.Arguments) {
406+ var arg0 context.Context
407+ if args[0] != nil {
408+ arg0 = args[0].(context.Context)
409+ }
410+ run(
411+ arg0,
412+ )
413+ })
414+ return _c
415+}
416+
417+func (_c *MirrorStore_ListRepoConfigs_Call) Return(mirrorRepoConfigs []domain.MirrorRepoConfig, err error) *MirrorStore_ListRepoConfigs_Call {
418+ _c.Call.Return(mirrorRepoConfigs, err)
419+ return _c
420+}
421+
422+func (_c *MirrorStore_ListRepoConfigs_Call) RunAndReturn(run func(ctx context.Context) ([]domain.MirrorRepoConfig, error)) *MirrorStore_ListRepoConfigs_Call {
423+ _c.Call.Return(run)
424+ return _c
425+}
426+
427+// ListStatus provides a mock function for the type MirrorStore
428+func (_mock *MirrorStore) ListStatus(ctx context.Context) ([]domain.MirrorStatus, error) {
429+ ret := _mock.Called(ctx)
430+
431+ if len(ret) == 0 {
432+ panic("no return value specified for ListStatus")
433+ }
434+
435+ var r0 []domain.MirrorStatus
436+ var r1 error
437+ if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.MirrorStatus, error)); ok {
438+ return returnFunc(ctx)
439+ }
440+ if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.MirrorStatus); ok {
441+ r0 = returnFunc(ctx)
442+ } else {
443+ if ret.Get(0) != nil {
444+ r0 = ret.Get(0).([]domain.MirrorStatus)
445+ }
446+ }
447+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
448+ r1 = returnFunc(ctx)
449+ } else {
450+ r1 = ret.Error(1)
451+ }
452+ return r0, r1
453+}
454+
455+// MirrorStore_ListStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStatus'
456+type MirrorStore_ListStatus_Call struct {
457+ *mock.Call
458+}
459+
460+// ListStatus is a helper method to define mock.On call
461+// - ctx context.Context
462+func (_e *MirrorStore_Expecter) ListStatus(ctx any) *MirrorStore_ListStatus_Call {
463+ return &MirrorStore_ListStatus_Call{Call: _e.mock.On("ListStatus", ctx)}
464+}
465+
466+func (_c *MirrorStore_ListStatus_Call) Run(run func(ctx context.Context)) *MirrorStore_ListStatus_Call {
467+ _c.Call.Run(func(args mock.Arguments) {
468+ var arg0 context.Context
469+ if args[0] != nil {
470+ arg0 = args[0].(context.Context)
471+ }
472+ run(
473+ arg0,
474+ )
475+ })
476+ return _c
477+}
478+
479+func (_c *MirrorStore_ListStatus_Call) Return(mirrorStatuss []domain.MirrorStatus, err error) *MirrorStore_ListStatus_Call {
480+ _c.Call.Return(mirrorStatuss, err)
481+ return _c
482+}
483+
484+func (_c *MirrorStore_ListStatus_Call) RunAndReturn(run func(ctx context.Context) ([]domain.MirrorStatus, error)) *MirrorStore_ListStatus_Call {
485+ _c.Call.Return(run)
486+ return _c
487+}
488+
489+// PutGlobal provides a mock function for the type MirrorStore
490+func (_mock *MirrorStore) PutGlobal(ctx context.Context, g domain.MirrorGlobalConfig) error {
491+ ret := _mock.Called(ctx, g)
492+
493+ if len(ret) == 0 {
494+ panic("no return value specified for PutGlobal")
495+ }
496+
497+ var r0 error
498+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.MirrorGlobalConfig) error); ok {
499+ r0 = returnFunc(ctx, g)
500+ } else {
501+ r0 = ret.Error(0)
502+ }
503+ return r0
504+}
505+
506+// MirrorStore_PutGlobal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutGlobal'
507+type MirrorStore_PutGlobal_Call struct {
508+ *mock.Call
509+}
510+
511+// PutGlobal is a helper method to define mock.On call
512+// - ctx context.Context
513+// - g domain.MirrorGlobalConfig
514+func (_e *MirrorStore_Expecter) PutGlobal(ctx any, g any) *MirrorStore_PutGlobal_Call {
515+ return &MirrorStore_PutGlobal_Call{Call: _e.mock.On("PutGlobal", ctx, g)}
516+}
517+
518+func (_c *MirrorStore_PutGlobal_Call) Run(run func(ctx context.Context, g domain.MirrorGlobalConfig)) *MirrorStore_PutGlobal_Call {
519+ _c.Call.Run(func(args mock.Arguments) {
520+ var arg0 context.Context
521+ if args[0] != nil {
522+ arg0 = args[0].(context.Context)
523+ }
524+ var arg1 domain.MirrorGlobalConfig
525+ if args[1] != nil {
526+ arg1 = args[1].(domain.MirrorGlobalConfig)
527+ }
528+ run(
529+ arg0,
530+ arg1,
531+ )
532+ })
533+ return _c
534+}
535+
536+func (_c *MirrorStore_PutGlobal_Call) Return(err error) *MirrorStore_PutGlobal_Call {
537+ _c.Call.Return(err)
538+ return _c
539+}
540+
541+func (_c *MirrorStore_PutGlobal_Call) RunAndReturn(run func(ctx context.Context, g domain.MirrorGlobalConfig) error) *MirrorStore_PutGlobal_Call {
542+ _c.Call.Return(run)
543+ return _c
544+}
545+
546+// PutRepoConfig provides a mock function for the type MirrorStore
547+func (_mock *MirrorStore) PutRepoConfig(ctx context.Context, c domain.MirrorRepoConfig) error {
548+ ret := _mock.Called(ctx, c)
549+
550+ if len(ret) == 0 {
551+ panic("no return value specified for PutRepoConfig")
552+ }
553+
554+ var r0 error
555+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.MirrorRepoConfig) error); ok {
556+ r0 = returnFunc(ctx, c)
557+ } else {
558+ r0 = ret.Error(0)
559+ }
560+ return r0
561+}
562+
563+// MirrorStore_PutRepoConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutRepoConfig'
564+type MirrorStore_PutRepoConfig_Call struct {
565+ *mock.Call
566+}
567+
568+// PutRepoConfig is a helper method to define mock.On call
569+// - ctx context.Context
570+// - c domain.MirrorRepoConfig
571+func (_e *MirrorStore_Expecter) PutRepoConfig(ctx any, c any) *MirrorStore_PutRepoConfig_Call {
572+ return &MirrorStore_PutRepoConfig_Call{Call: _e.mock.On("PutRepoConfig", ctx, c)}
573+}
574+
575+func (_c *MirrorStore_PutRepoConfig_Call) Run(run func(ctx context.Context, c domain.MirrorRepoConfig)) *MirrorStore_PutRepoConfig_Call {
576+ _c.Call.Run(func(args mock.Arguments) {
577+ var arg0 context.Context
578+ if args[0] != nil {
579+ arg0 = args[0].(context.Context)
580+ }
581+ var arg1 domain.MirrorRepoConfig
582+ if args[1] != nil {
583+ arg1 = args[1].(domain.MirrorRepoConfig)
584+ }
585+ run(
586+ arg0,
587+ arg1,
588+ )
589+ })
590+ return _c
591+}
592+
593+func (_c *MirrorStore_PutRepoConfig_Call) Return(err error) *MirrorStore_PutRepoConfig_Call {
594+ _c.Call.Return(err)
595+ return _c
596+}
597+
598+func (_c *MirrorStore_PutRepoConfig_Call) RunAndReturn(run func(ctx context.Context, c domain.MirrorRepoConfig) error) *MirrorStore_PutRepoConfig_Call {
599+ _c.Call.Return(run)
600+ return _c
601+}
602+
603+// PutSnapshot provides a mock function for the type MirrorStore
604+func (_mock *MirrorStore) PutSnapshot(ctx context.Context, repo domain.RepoName, s domain.MirrorSnapshot) error {
605+ ret := _mock.Called(ctx, repo, s)
606+
607+ if len(ret) == 0 {
608+ panic("no return value specified for PutSnapshot")
609+ }
610+
611+ var r0 error
612+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, domain.MirrorSnapshot) error); ok {
613+ r0 = returnFunc(ctx, repo, s)
614+ } else {
615+ r0 = ret.Error(0)
616+ }
617+ return r0
618+}
619+
620+// MirrorStore_PutSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutSnapshot'
621+type MirrorStore_PutSnapshot_Call struct {
622+ *mock.Call
623+}
624+
625+// PutSnapshot is a helper method to define mock.On call
626+// - ctx context.Context
627+// - repo domain.RepoName
628+// - s domain.MirrorSnapshot
629+func (_e *MirrorStore_Expecter) PutSnapshot(ctx any, repo any, s any) *MirrorStore_PutSnapshot_Call {
630+ return &MirrorStore_PutSnapshot_Call{Call: _e.mock.On("PutSnapshot", ctx, repo, s)}
631+}
632+
633+func (_c *MirrorStore_PutSnapshot_Call) Run(run func(ctx context.Context, repo domain.RepoName, s domain.MirrorSnapshot)) *MirrorStore_PutSnapshot_Call {
634+ _c.Call.Run(func(args mock.Arguments) {
635+ var arg0 context.Context
636+ if args[0] != nil {
637+ arg0 = args[0].(context.Context)
638+ }
639+ var arg1 domain.RepoName
640+ if args[1] != nil {
641+ arg1 = args[1].(domain.RepoName)
642+ }
643+ var arg2 domain.MirrorSnapshot
644+ if args[2] != nil {
645+ arg2 = args[2].(domain.MirrorSnapshot)
646+ }
647+ run(
648+ arg0,
649+ arg1,
650+ arg2,
651+ )
652+ })
653+ return _c
654+}
655+
656+func (_c *MirrorStore_PutSnapshot_Call) Return(err error) *MirrorStore_PutSnapshot_Call {
657+ _c.Call.Return(err)
658+ return _c
659+}
660+
661+func (_c *MirrorStore_PutSnapshot_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, s domain.MirrorSnapshot) error) *MirrorStore_PutSnapshot_Call {
662+ _c.Call.Return(run)
663+ return _c
664+}
665+
666+// PutStatus provides a mock function for the type MirrorStore
667+func (_mock *MirrorStore) PutStatus(ctx context.Context, s domain.MirrorStatus) error {
668+ ret := _mock.Called(ctx, s)
669+
670+ if len(ret) == 0 {
671+ panic("no return value specified for PutStatus")
672+ }
673+
674+ var r0 error
675+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.MirrorStatus) error); ok {
676+ r0 = returnFunc(ctx, s)
677+ } else {
678+ r0 = ret.Error(0)
679+ }
680+ return r0
681+}
682+
683+// MirrorStore_PutStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutStatus'
684+type MirrorStore_PutStatus_Call struct {
685+ *mock.Call
686+}
687+
688+// PutStatus is a helper method to define mock.On call
689+// - ctx context.Context
690+// - s domain.MirrorStatus
691+func (_e *MirrorStore_Expecter) PutStatus(ctx any, s any) *MirrorStore_PutStatus_Call {
692+ return &MirrorStore_PutStatus_Call{Call: _e.mock.On("PutStatus", ctx, s)}
693+}
694+
695+func (_c *MirrorStore_PutStatus_Call) Run(run func(ctx context.Context, s domain.MirrorStatus)) *MirrorStore_PutStatus_Call {
696+ _c.Call.Run(func(args mock.Arguments) {
697+ var arg0 context.Context
698+ if args[0] != nil {
699+ arg0 = args[0].(context.Context)
700+ }
701+ var arg1 domain.MirrorStatus
702+ if args[1] != nil {
703+ arg1 = args[1].(domain.MirrorStatus)
704+ }
705+ run(
706+ arg0,
707+ arg1,
708+ )
709+ })
710+ return _c
711+}
712+
713+func (_c *MirrorStore_PutStatus_Call) Return(err error) *MirrorStore_PutStatus_Call {
714+ _c.Call.Return(err)
715+ return _c
716+}
717+
718+func (_c *MirrorStore_PutStatus_Call) RunAndReturn(run func(ctx context.Context, s domain.MirrorStatus) error) *MirrorStore_PutStatus_Call {
719+ _c.Call.Return(run)
720+ return _c
721+}
A internal/ports/mocks/MirrorTrigger.go +100 -0
@@ -0,0 +1,100 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package mocks
6+
7+import (
8+ "context"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMirrorTrigger creates a new instance of MirrorTrigger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMirrorTrigger(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MirrorTrigger {
20+ if helper, ok := t.(interface{ Helper() }); ok {
21+ helper.Helper()
22+ }
23+
24+ mock := &MirrorTrigger{}
25+ mock.Mock.Test(t)
26+
27+ t.Cleanup(func() {
28+ if helper, ok := t.(interface{ Helper() }); ok {
29+ helper.Helper()
30+ }
31+ mock.AssertExpectations(t)
32+ })
33+
34+ return mock
35+}
36+
37+// MirrorTrigger is an autogenerated mock type for the MirrorTrigger type
38+type MirrorTrigger struct {
39+ mock.Mock
40+}
41+
42+type MirrorTrigger_Expecter struct {
43+ mock *mock.Mock
44+}
45+
46+func (_m *MirrorTrigger) EXPECT() *MirrorTrigger_Expecter {
47+ return &MirrorTrigger_Expecter{mock: &_m.Mock}
48+}
49+
50+// OnPush provides a mock function for the type MirrorTrigger
51+func (_mock *MirrorTrigger) OnPush(ctx context.Context, repo domain.RepoName, updates []domain.RefUpdate) {
52+ _mock.Called(ctx, repo, updates)
53+ return
54+}
55+
56+// MirrorTrigger_OnPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnPush'
57+type MirrorTrigger_OnPush_Call struct {
58+ *mock.Call
59+}
60+
61+// OnPush is a helper method to define mock.On call
62+// - ctx context.Context
63+// - repo domain.RepoName
64+// - updates []domain.RefUpdate
65+func (_e *MirrorTrigger_Expecter) OnPush(ctx any, repo any, updates any) *MirrorTrigger_OnPush_Call {
66+ return &MirrorTrigger_OnPush_Call{Call: _e.mock.On("OnPush", ctx, repo, updates)}
67+}
68+
69+func (_c *MirrorTrigger_OnPush_Call) Run(run func(ctx context.Context, repo domain.RepoName, updates []domain.RefUpdate)) *MirrorTrigger_OnPush_Call {
70+ _c.Call.Run(func(args mock.Arguments) {
71+ var arg0 context.Context
72+ if args[0] != nil {
73+ arg0 = args[0].(context.Context)
74+ }
75+ var arg1 domain.RepoName
76+ if args[1] != nil {
77+ arg1 = args[1].(domain.RepoName)
78+ }
79+ var arg2 []domain.RefUpdate
80+ if args[2] != nil {
81+ arg2 = args[2].([]domain.RefUpdate)
82+ }
83+ run(
84+ arg0,
85+ arg1,
86+ arg2,
87+ )
88+ })
89+ return _c
90+}
91+
92+func (_c *MirrorTrigger_OnPush_Call) Return() *MirrorTrigger_OnPush_Call {
93+ _c.Call.Return()
94+ return _c
95+}
96+
97+func (_c *MirrorTrigger_OnPush_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, updates []domain.RefUpdate)) *MirrorTrigger_OnPush_Call {
98+ _c.Run(run)
99+ return _c
100+}
@@ -0,0 +1,100 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package mocks
6+
7+import (
8+ "context"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMirrorTrigger creates a new instance of MirrorTrigger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMirrorTrigger(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MirrorTrigger {
20+ if helper, ok := t.(interface{ Helper() }); ok {
21+ helper.Helper()
22+ }
23+
24+ mock := &MirrorTrigger{}
25+ mock.Mock.Test(t)
26+
27+ t.Cleanup(func() {
28+ if helper, ok := t.(interface{ Helper() }); ok {
29+ helper.Helper()
30+ }
31+ mock.AssertExpectations(t)
32+ })
33+
34+ return mock
35+}
36+
37+// MirrorTrigger is an autogenerated mock type for the MirrorTrigger type
38+type MirrorTrigger struct {
39+ mock.Mock
40+}
41+
42+type MirrorTrigger_Expecter struct {
43+ mock *mock.Mock
44+}
45+
46+func (_m *MirrorTrigger) EXPECT() *MirrorTrigger_Expecter {
47+ return &MirrorTrigger_Expecter{mock: &_m.Mock}
48+}
49+
50+// OnPush provides a mock function for the type MirrorTrigger
51+func (_mock *MirrorTrigger) OnPush(ctx context.Context, repo domain.RepoName, updates []domain.RefUpdate) {
52+ _mock.Called(ctx, repo, updates)
53+ return
54+}
55+
56+// MirrorTrigger_OnPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnPush'
57+type MirrorTrigger_OnPush_Call struct {
58+ *mock.Call
59+}
60+
61+// OnPush is a helper method to define mock.On call
62+// - ctx context.Context
63+// - repo domain.RepoName
64+// - updates []domain.RefUpdate
65+func (_e *MirrorTrigger_Expecter) OnPush(ctx any, repo any, updates any) *MirrorTrigger_OnPush_Call {
66+ return &MirrorTrigger_OnPush_Call{Call: _e.mock.On("OnPush", ctx, repo, updates)}
67+}
68+
69+func (_c *MirrorTrigger_OnPush_Call) Run(run func(ctx context.Context, repo domain.RepoName, updates []domain.RefUpdate)) *MirrorTrigger_OnPush_Call {
70+ _c.Call.Run(func(args mock.Arguments) {
71+ var arg0 context.Context
72+ if args[0] != nil {
73+ arg0 = args[0].(context.Context)
74+ }
75+ var arg1 domain.RepoName
76+ if args[1] != nil {
77+ arg1 = args[1].(domain.RepoName)
78+ }
79+ var arg2 []domain.RefUpdate
80+ if args[2] != nil {
81+ arg2 = args[2].([]domain.RefUpdate)
82+ }
83+ run(
84+ arg0,
85+ arg1,
86+ arg2,
87+ )
88+ })
89+ return _c
90+}
91+
92+func (_c *MirrorTrigger_OnPush_Call) Return() *MirrorTrigger_OnPush_Call {
93+ _c.Call.Return()
94+ return _c
95+}
96+
97+func (_c *MirrorTrigger_OnPush_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, updates []domain.RefUpdate)) *MirrorTrigger_OnPush_Call {
98+ _c.Run(run)
99+ return _c
100+}
A internal/ports/mocks/MirrorWarner.go +183 -0
@@ -0,0 +1,183 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package mocks
6+
7+import (
8+ "context"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMirrorWarner creates a new instance of MirrorWarner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMirrorWarner(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MirrorWarner {
20+ if helper, ok := t.(interface{ Helper() }); ok {
21+ helper.Helper()
22+ }
23+
24+ mock := &MirrorWarner{}
25+ mock.Mock.Test(t)
26+
27+ t.Cleanup(func() {
28+ if helper, ok := t.(interface{ Helper() }); ok {
29+ helper.Helper()
30+ }
31+ mock.AssertExpectations(t)
32+ })
33+
34+ return mock
35+}
36+
37+// MirrorWarner is an autogenerated mock type for the MirrorWarner type
38+type MirrorWarner struct {
39+ mock.Mock
40+}
41+
42+type MirrorWarner_Expecter struct {
43+ mock *mock.Mock
44+}
45+
46+func (_m *MirrorWarner) EXPECT() *MirrorWarner_Expecter {
47+ return &MirrorWarner_Expecter{mock: &_m.Mock}
48+}
49+
50+// Badge provides a mock function for the type MirrorWarner
51+func (_mock *MirrorWarner) Badge(ctx context.Context, p domain.Principal, repo domain.RepoName) (domain.MirrorState, string) {
52+ ret := _mock.Called(ctx, p, repo)
53+
54+ if len(ret) == 0 {
55+ panic("no return value specified for Badge")
56+ }
57+
58+ var r0 domain.MirrorState
59+ var r1 string
60+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) (domain.MirrorState, string)); ok {
61+ return returnFunc(ctx, p, repo)
62+ }
63+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) domain.MirrorState); ok {
64+ r0 = returnFunc(ctx, p, repo)
65+ } else {
66+ r0 = ret.Get(0).(domain.MirrorState)
67+ }
68+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName) string); ok {
69+ r1 = returnFunc(ctx, p, repo)
70+ } else {
71+ r1 = ret.Get(1).(string)
72+ }
73+ return r0, r1
74+}
75+
76+// MirrorWarner_Badge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Badge'
77+type MirrorWarner_Badge_Call struct {
78+ *mock.Call
79+}
80+
81+// Badge is a helper method to define mock.On call
82+// - ctx context.Context
83+// - p domain.Principal
84+// - repo domain.RepoName
85+func (_e *MirrorWarner_Expecter) Badge(ctx any, p any, repo any) *MirrorWarner_Badge_Call {
86+ return &MirrorWarner_Badge_Call{Call: _e.mock.On("Badge", ctx, p, repo)}
87+}
88+
89+func (_c *MirrorWarner_Badge_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName)) *MirrorWarner_Badge_Call {
90+ _c.Call.Run(func(args mock.Arguments) {
91+ var arg0 context.Context
92+ if args[0] != nil {
93+ arg0 = args[0].(context.Context)
94+ }
95+ var arg1 domain.Principal
96+ if args[1] != nil {
97+ arg1 = args[1].(domain.Principal)
98+ }
99+ var arg2 domain.RepoName
100+ if args[2] != nil {
101+ arg2 = args[2].(domain.RepoName)
102+ }
103+ run(
104+ arg0,
105+ arg1,
106+ arg2,
107+ )
108+ })
109+ return _c
110+}
111+
112+func (_c *MirrorWarner_Badge_Call) Return(mirrorState domain.MirrorState, s string) *MirrorWarner_Badge_Call {
113+ _c.Call.Return(mirrorState, s)
114+ return _c
115+}
116+
117+func (_c *MirrorWarner_Badge_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName) (domain.MirrorState, string)) *MirrorWarner_Badge_Call {
118+ _c.Call.Return(run)
119+ return _c
120+}
121+
122+// Warning provides a mock function for the type MirrorWarner
123+func (_mock *MirrorWarner) Warning(ctx context.Context, p domain.Principal, repo domain.RepoName) string {
124+ ret := _mock.Called(ctx, p, repo)
125+
126+ if len(ret) == 0 {
127+ panic("no return value specified for Warning")
128+ }
129+
130+ var r0 string
131+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) string); ok {
132+ r0 = returnFunc(ctx, p, repo)
133+ } else {
134+ r0 = ret.Get(0).(string)
135+ }
136+ return r0
137+}
138+
139+// MirrorWarner_Warning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warning'
140+type MirrorWarner_Warning_Call struct {
141+ *mock.Call
142+}
143+
144+// Warning is a helper method to define mock.On call
145+// - ctx context.Context
146+// - p domain.Principal
147+// - repo domain.RepoName
148+func (_e *MirrorWarner_Expecter) Warning(ctx any, p any, repo any) *MirrorWarner_Warning_Call {
149+ return &MirrorWarner_Warning_Call{Call: _e.mock.On("Warning", ctx, p, repo)}
150+}
151+
152+func (_c *MirrorWarner_Warning_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName)) *MirrorWarner_Warning_Call {
153+ _c.Call.Run(func(args mock.Arguments) {
154+ var arg0 context.Context
155+ if args[0] != nil {
156+ arg0 = args[0].(context.Context)
157+ }
158+ var arg1 domain.Principal
159+ if args[1] != nil {
160+ arg1 = args[1].(domain.Principal)
161+ }
162+ var arg2 domain.RepoName
163+ if args[2] != nil {
164+ arg2 = args[2].(domain.RepoName)
165+ }
166+ run(
167+ arg0,
168+ arg1,
169+ arg2,
170+ )
171+ })
172+ return _c
173+}
174+
175+func (_c *MirrorWarner_Warning_Call) Return(s string) *MirrorWarner_Warning_Call {
176+ _c.Call.Return(s)
177+ return _c
178+}
179+
180+func (_c *MirrorWarner_Warning_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName) string) *MirrorWarner_Warning_Call {
181+ _c.Call.Return(run)
182+ return _c
183+}
@@ -0,0 +1,183 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package mocks
6+
7+import (
8+ "context"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMirrorWarner creates a new instance of MirrorWarner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMirrorWarner(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MirrorWarner {
20+ if helper, ok := t.(interface{ Helper() }); ok {
21+ helper.Helper()
22+ }
23+
24+ mock := &MirrorWarner{}
25+ mock.Mock.Test(t)
26+
27+ t.Cleanup(func() {
28+ if helper, ok := t.(interface{ Helper() }); ok {
29+ helper.Helper()
30+ }
31+ mock.AssertExpectations(t)
32+ })
33+
34+ return mock
35+}
36+
37+// MirrorWarner is an autogenerated mock type for the MirrorWarner type
38+type MirrorWarner struct {
39+ mock.Mock
40+}
41+
42+type MirrorWarner_Expecter struct {
43+ mock *mock.Mock
44+}
45+
46+func (_m *MirrorWarner) EXPECT() *MirrorWarner_Expecter {
47+ return &MirrorWarner_Expecter{mock: &_m.Mock}
48+}
49+
50+// Badge provides a mock function for the type MirrorWarner
51+func (_mock *MirrorWarner) Badge(ctx context.Context, p domain.Principal, repo domain.RepoName) (domain.MirrorState, string) {
52+ ret := _mock.Called(ctx, p, repo)
53+
54+ if len(ret) == 0 {
55+ panic("no return value specified for Badge")
56+ }
57+
58+ var r0 domain.MirrorState
59+ var r1 string
60+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) (domain.MirrorState, string)); ok {
61+ return returnFunc(ctx, p, repo)
62+ }
63+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) domain.MirrorState); ok {
64+ r0 = returnFunc(ctx, p, repo)
65+ } else {
66+ r0 = ret.Get(0).(domain.MirrorState)
67+ }
68+ if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName) string); ok {
69+ r1 = returnFunc(ctx, p, repo)
70+ } else {
71+ r1 = ret.Get(1).(string)
72+ }
73+ return r0, r1
74+}
75+
76+// MirrorWarner_Badge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Badge'
77+type MirrorWarner_Badge_Call struct {
78+ *mock.Call
79+}
80+
81+// Badge is a helper method to define mock.On call
82+// - ctx context.Context
83+// - p domain.Principal
84+// - repo domain.RepoName
85+func (_e *MirrorWarner_Expecter) Badge(ctx any, p any, repo any) *MirrorWarner_Badge_Call {
86+ return &MirrorWarner_Badge_Call{Call: _e.mock.On("Badge", ctx, p, repo)}
87+}
88+
89+func (_c *MirrorWarner_Badge_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName)) *MirrorWarner_Badge_Call {
90+ _c.Call.Run(func(args mock.Arguments) {
91+ var arg0 context.Context
92+ if args[0] != nil {
93+ arg0 = args[0].(context.Context)
94+ }
95+ var arg1 domain.Principal
96+ if args[1] != nil {
97+ arg1 = args[1].(domain.Principal)
98+ }
99+ var arg2 domain.RepoName
100+ if args[2] != nil {
101+ arg2 = args[2].(domain.RepoName)
102+ }
103+ run(
104+ arg0,
105+ arg1,
106+ arg2,
107+ )
108+ })
109+ return _c
110+}
111+
112+func (_c *MirrorWarner_Badge_Call) Return(mirrorState domain.MirrorState, s string) *MirrorWarner_Badge_Call {
113+ _c.Call.Return(mirrorState, s)
114+ return _c
115+}
116+
117+func (_c *MirrorWarner_Badge_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName) (domain.MirrorState, string)) *MirrorWarner_Badge_Call {
118+ _c.Call.Return(run)
119+ return _c
120+}
121+
122+// Warning provides a mock function for the type MirrorWarner
123+func (_mock *MirrorWarner) Warning(ctx context.Context, p domain.Principal, repo domain.RepoName) string {
124+ ret := _mock.Called(ctx, p, repo)
125+
126+ if len(ret) == 0 {
127+ panic("no return value specified for Warning")
128+ }
129+
130+ var r0 string
131+ if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) string); ok {
132+ r0 = returnFunc(ctx, p, repo)
133+ } else {
134+ r0 = ret.Get(0).(string)
135+ }
136+ return r0
137+}
138+
139+// MirrorWarner_Warning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warning'
140+type MirrorWarner_Warning_Call struct {
141+ *mock.Call
142+}
143+
144+// Warning is a helper method to define mock.On call
145+// - ctx context.Context
146+// - p domain.Principal
147+// - repo domain.RepoName
148+func (_e *MirrorWarner_Expecter) Warning(ctx any, p any, repo any) *MirrorWarner_Warning_Call {
149+ return &MirrorWarner_Warning_Call{Call: _e.mock.On("Warning", ctx, p, repo)}
150+}
151+
152+func (_c *MirrorWarner_Warning_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName)) *MirrorWarner_Warning_Call {
153+ _c.Call.Run(func(args mock.Arguments) {
154+ var arg0 context.Context
155+ if args[0] != nil {
156+ arg0 = args[0].(context.Context)
157+ }
158+ var arg1 domain.Principal
159+ if args[1] != nil {
160+ arg1 = args[1].(domain.Principal)
161+ }
162+ var arg2 domain.RepoName
163+ if args[2] != nil {
164+ arg2 = args[2].(domain.RepoName)
165+ }
166+ run(
167+ arg0,
168+ arg1,
169+ arg2,
170+ )
171+ })
172+ return _c
173+}
174+
175+func (_c *MirrorWarner_Warning_Call) Return(s string) *MirrorWarner_Warning_Call {
176+ _c.Call.Return(s)
177+ return _c
178+}
179+
180+func (_c *MirrorWarner_Warning_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName) string) *MirrorWarner_Warning_Call {
181+ _c.Call.Return(run)
182+ return _c
183+}
M internal/usecase/events.go +8 -0
@@ -167,6 +167,10 @@ func (e *Events) snapshot(ctx context.Context, ev domain.Event) bufferedEvent {
167167 return bufferedEvent{known: true, vis: ev.Visibility, created: ev.CreatedAt}
168168 case domain.RepoDeleted:
169169 return bufferedEvent{known: true, vis: ev.Visibility, created: ev.CreatedAt}
170+ case domain.MirrorFailed:
171+ return repoSnapshot(ev.Visibility, ev.CreatedAt)
172+ case domain.MirrorRecovered:
173+ return repoSnapshot(ev.Visibility, ev.CreatedAt)
170174 case domain.PushEvent:
171175 if ev.CreatedAt.IsZero() {
172176 return bufferedEvent{} // repository unknown at publish time: nobody is told
@@ -517,6 +521,10 @@ func (e *Events) deliver(ctx context.Context, w *watch, be bufferedEvent, send f
517521 return e.deliverRepo(ctx, w, ev.Repo, true, be, out, send)
518522 case domain.RepoUpdated:
519523 return e.deliverRepo(ctx, w, ev.Repo, true, be, out, send)
524+ case domain.MirrorFailed:
525+ return e.deliverRepo(ctx, w, ev.Repo, false, be, out, send)
526+ case domain.MirrorRecovered:
527+ return e.deliverRepo(ctx, w, ev.Repo, false, be, out, send)
520528 case domain.PushEvent:
521529 return e.deliverRepo(ctx, w, ev.Repo, false, be, out, send)
522530 case domain.MergeRequestOpened:
@@ -167,6 +167,10 @@ func (e *Events) snapshot(ctx context.Context, ev domain.Event) bufferedEvent {
167 return bufferedEvent{known: true, vis: ev.Visibility, created: ev.CreatedAt}167 return bufferedEvent{known: true, vis: ev.Visibility, created: ev.CreatedAt}
168 case domain.RepoDeleted:168 case domain.RepoDeleted:
169 return bufferedEvent{known: true, vis: ev.Visibility, created: ev.CreatedAt}169 return bufferedEvent{known: true, vis: ev.Visibility, created: ev.CreatedAt}
170+ case domain.MirrorFailed:
171+ return repoSnapshot(ev.Visibility, ev.CreatedAt)
172+ case domain.MirrorRecovered:
173+ return repoSnapshot(ev.Visibility, ev.CreatedAt)
170 case domain.PushEvent:174 case domain.PushEvent:
171 if ev.CreatedAt.IsZero() {175 if ev.CreatedAt.IsZero() {
172 return bufferedEvent{} // repository unknown at publish time: nobody is told176 return bufferedEvent{} // repository unknown at publish time: nobody is told
@@ -517,6 +521,10 @@ func (e *Events) deliver(ctx context.Context, w *watch, be bufferedEvent, send f
517 return e.deliverRepo(ctx, w, ev.Repo, true, be, out, send)521 return e.deliverRepo(ctx, w, ev.Repo, true, be, out, send)
518 case domain.RepoUpdated:522 case domain.RepoUpdated:
519 return e.deliverRepo(ctx, w, ev.Repo, true, be, out, send)523 return e.deliverRepo(ctx, w, ev.Repo, true, be, out, send)
524+ case domain.MirrorFailed:
525+ return e.deliverRepo(ctx, w, ev.Repo, false, be, out, send)
526+ case domain.MirrorRecovered:
527+ return e.deliverRepo(ctx, w, ev.Repo, false, be, out, send)
520 case domain.PushEvent:528 case domain.PushEvent:
521 return e.deliverRepo(ctx, w, ev.Repo, false, be, out, send)529 return e.deliverRepo(ctx, w, ev.Repo, false, be, out, send)
522 case domain.MergeRequestOpened:530 case domain.MergeRequestOpened:
M internal/usecase/mergerequests.go +10 -0
@@ -58,6 +58,7 @@ type MergeRequests struct {
5858 tips ports.CIRefTipStore // nil: who merges is not recorded
5959 verifier ports.CommitVerifier // nil: commits are not checked (ADR 0030)
6060 mergeab MergeabilityHook // nil: no mergeability
61+ mirror ports.MirrorTrigger // nil: no outbound mirror
6162
6263 mu sync.Mutex
6364 locks map[domain.RepoName]chan struct{}
@@ -116,6 +117,12 @@ func NewMergeRequests(cfg MergeRequestsConfig) *MergeRequests {
116117 }
117118 }
118119
120+// WithMirror makes a merge notify outbound mirrors. Call before the first merge.
121+func (m *MergeRequests) WithMirror(t ports.MirrorTrigger) *MergeRequests {
122+ m.mirror = t
123+ return m
124+}
125+
119126 // WithVerifier makes GetMergeRequest fill the signature state of the commits
120127 // it lists (ADR 0030).
121128 func (m *MergeRequests) WithVerifier(v ports.CommitVerifier) *MergeRequests {
@@ -1172,6 +1179,9 @@ func (m *MergeRequests) afterMerge(ctx context.Context, p domain.Principal, repo
11721179 m.bus.Publish(ctx, domain.PushEvent{
11731180 Repo: name, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, Updates: updates,
11741181 })
1182+ if m.mirror != nil {
1183+ m.mirror.OnPush(ctx, name, updates) // marks dirty only; never blocks
1184+ }
11751185 if m.pulls != nil {
11761186 m.pulls.OnPullRequest(ctx, name, ports.PullRequestEvent{Number: mr.Number, Action: domain.PullClosed, Head: mr.HeadID, Base: mr.BaseID, Merged: true}, p)
11771187 }
@@ -58,6 +58,7 @@ type MergeRequests struct {
58 tips ports.CIRefTipStore // nil: who merges is not recorded58 tips ports.CIRefTipStore // nil: who merges is not recorded
59 verifier ports.CommitVerifier // nil: commits are not checked (ADR 0030)59 verifier ports.CommitVerifier // nil: commits are not checked (ADR 0030)
60 mergeab MergeabilityHook // nil: no mergeability60 mergeab MergeabilityHook // nil: no mergeability
61+ mirror ports.MirrorTrigger // nil: no outbound mirror
61 62
62 mu sync.Mutex63 mu sync.Mutex
63 locks map[domain.RepoName]chan struct{}64 locks map[domain.RepoName]chan struct{}
@@ -116,6 +117,12 @@ func NewMergeRequests(cfg MergeRequestsConfig) *MergeRequests {
116 }117 }
117 }118 }
118 119
120+// WithMirror makes a merge notify outbound mirrors. Call before the first merge.
121+func (m *MergeRequests) WithMirror(t ports.MirrorTrigger) *MergeRequests {
122+ m.mirror = t
123+ return m
124+}
125+
119 // WithVerifier makes GetMergeRequest fill the signature state of the commits126 // WithVerifier makes GetMergeRequest fill the signature state of the commits
120 // it lists (ADR 0030).127 // it lists (ADR 0030).
121 func (m *MergeRequests) WithVerifier(v ports.CommitVerifier) *MergeRequests {128 func (m *MergeRequests) WithVerifier(v ports.CommitVerifier) *MergeRequests {
@@ -1172,6 +1179,9 @@ func (m *MergeRequests) afterMerge(ctx context.Context, p domain.Principal, repo
1172 m.bus.Publish(ctx, domain.PushEvent{1179 m.bus.Publish(ctx, domain.PushEvent{
1173 Repo: name, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, Updates: updates,1180 Repo: name, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, Updates: updates,
1174 })1181 })
1182+ if m.mirror != nil {
1183+ m.mirror.OnPush(ctx, name, updates) // marks dirty only; never blocks
1184+ }
1175 if m.pulls != nil {1185 if m.pulls != nil {
1176 m.pulls.OnPullRequest(ctx, name, ports.PullRequestEvent{Number: mr.Number, Action: domain.PullClosed, Head: mr.HeadID, Base: mr.BaseID, Merged: true}, p)1186 m.pulls.OnPullRequest(ctx, name, ports.PullRequestEvent{Number: mr.Number, Action: domain.PullClosed, Head: mr.HeadID, Base: mr.BaseID, Merged: true}, p)
1177 }1187 }
A internal/usecase/mirrors.go +91 -0
@@ -0,0 +1,91 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "crypto/ed25519"
8+ "sync"
9+ "time"
10+
11+ "bnema.dev/ermite/internal/domain"
12+ "bnema.dev/ermite/internal/ports"
13+)
14+
15+const mirrorQueueSize = 64
16+
17+// MirrorsConfig supplies the mirror use case's dependencies.
18+type MirrorsConfig struct {
19+ Store ports.MirrorStore
20+ Keys ports.MirrorKeyStore
21+ Sealer ports.SecretSealer
22+ Pusher ports.MirrorPusher
23+ Meta ports.RepoMetaStore
24+ Git ports.GitRepos
25+ Reader ports.RepoReader
26+ Bus ports.EventBus
27+ Clock ports.Clock
28+ PublicURL string
29+ ScheduleTick time.Duration
30+ Workers int
31+ QueueSize int // jobs waiting for a worker; default 64
32+ // ValidateURL checks a resolved mirror URL; default domain.ValidateMirrorURL. Tests of
33+ // local transports inject a permissive check.
34+ ValidateURL func(string) error
35+}
36+
37+// mirrorGen counts the changes of a repository (dirty) and the count the last successful
38+// sync saw (clean, meaningful once cleanKnown).
39+type mirrorGen struct {
40+ dirty, clean uint64
41+ cleanKnown bool
42+}
43+
44+// Mirrors manages outbound repository mirrors.
45+type Mirrors struct {
46+ cfg MirrorsConfig
47+ configMu sync.RWMutex // configuration changes; held for reads only around store reads and writes, never during a push
48+ mu sync.Mutex
49+ gens map[domain.RepoName]mirrorGen
50+ flights map[domain.RepoName]*mirrorFlight
51+ flightWG sync.WaitGroup // one per flight, for tests that wait for the queue to drain
52+ ctx context.Context
53+ cancel context.CancelFunc
54+ wg sync.WaitGroup
55+ start sync.Once
56+ closed bool
57+ jobs chan domain.RepoName
58+
59+ scheduleMu sync.Mutex
60+ lastMinute time.Time
61+ deferred map[domain.RepoName]struct{} // due, but the queue was full
62+
63+ keyMu sync.Mutex
64+ key ed25519.PrivateKey
65+ keyCreated time.Time
66+}
67+
68+// NewMirrors builds the mirror use case.
69+func NewMirrors(cfg MirrorsConfig) *Mirrors {
70+ if cfg.ScheduleTick <= 0 {
71+ cfg.ScheduleTick = time.Second
72+ }
73+ if cfg.Workers <= 0 {
74+ cfg.Workers = 2
75+ }
76+ if cfg.QueueSize <= 0 {
77+ cfg.QueueSize = mirrorQueueSize
78+ }
79+ if cfg.ValidateURL == nil {
80+ cfg.ValidateURL = domain.ValidateMirrorURL
81+ }
82+ ctx, cancel := context.WithCancel(context.Background())
83+ return &Mirrors{
84+ cfg: cfg, ctx: ctx, cancel: cancel,
85+ gens: make(map[domain.RepoName]mirrorGen),
86+ flights: make(map[domain.RepoName]*mirrorFlight),
87+ deferred: make(map[domain.RepoName]struct{}),
88+ jobs: make(chan domain.RepoName, cfg.QueueSize),
89+ lastMinute: cfg.Clock.Now().UTC().Truncate(time.Minute),
90+ }
91+}
@@ -0,0 +1,91 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "crypto/ed25519"
8+ "sync"
9+ "time"
10+
11+ "bnema.dev/ermite/internal/domain"
12+ "bnema.dev/ermite/internal/ports"
13+)
14+
15+const mirrorQueueSize = 64
16+
17+// MirrorsConfig supplies the mirror use case's dependencies.
18+type MirrorsConfig struct {
19+ Store ports.MirrorStore
20+ Keys ports.MirrorKeyStore
21+ Sealer ports.SecretSealer
22+ Pusher ports.MirrorPusher
23+ Meta ports.RepoMetaStore
24+ Git ports.GitRepos
25+ Reader ports.RepoReader
26+ Bus ports.EventBus
27+ Clock ports.Clock
28+ PublicURL string
29+ ScheduleTick time.Duration
30+ Workers int
31+ QueueSize int // jobs waiting for a worker; default 64
32+ // ValidateURL checks a resolved mirror URL; default domain.ValidateMirrorURL. Tests of
33+ // local transports inject a permissive check.
34+ ValidateURL func(string) error
35+}
36+
37+// mirrorGen counts the changes of a repository (dirty) and the count the last successful
38+// sync saw (clean, meaningful once cleanKnown).
39+type mirrorGen struct {
40+ dirty, clean uint64
41+ cleanKnown bool
42+}
43+
44+// Mirrors manages outbound repository mirrors.
45+type Mirrors struct {
46+ cfg MirrorsConfig
47+ configMu sync.RWMutex // configuration changes; held for reads only around store reads and writes, never during a push
48+ mu sync.Mutex
49+ gens map[domain.RepoName]mirrorGen
50+ flights map[domain.RepoName]*mirrorFlight
51+ flightWG sync.WaitGroup // one per flight, for tests that wait for the queue to drain
52+ ctx context.Context
53+ cancel context.CancelFunc
54+ wg sync.WaitGroup
55+ start sync.Once
56+ closed bool
57+ jobs chan domain.RepoName
58+
59+ scheduleMu sync.Mutex
60+ lastMinute time.Time
61+ deferred map[domain.RepoName]struct{} // due, but the queue was full
62+
63+ keyMu sync.Mutex
64+ key ed25519.PrivateKey
65+ keyCreated time.Time
66+}
67+
68+// NewMirrors builds the mirror use case.
69+func NewMirrors(cfg MirrorsConfig) *Mirrors {
70+ if cfg.ScheduleTick <= 0 {
71+ cfg.ScheduleTick = time.Second
72+ }
73+ if cfg.Workers <= 0 {
74+ cfg.Workers = 2
75+ }
76+ if cfg.QueueSize <= 0 {
77+ cfg.QueueSize = mirrorQueueSize
78+ }
79+ if cfg.ValidateURL == nil {
80+ cfg.ValidateURL = domain.ValidateMirrorURL
81+ }
82+ ctx, cancel := context.WithCancel(context.Background())
83+ return &Mirrors{
84+ cfg: cfg, ctx: ctx, cancel: cancel,
85+ gens: make(map[domain.RepoName]mirrorGen),
86+ flights: make(map[domain.RepoName]*mirrorFlight),
87+ deferred: make(map[domain.RepoName]struct{}),
88+ jobs: make(chan domain.RepoName, cfg.QueueSize),
89+ lastMinute: cfg.Clock.Now().UTC().Truncate(time.Minute),
90+ }
91+}
A internal/usecase/mirrors_config.go +365 -0
@@ -0,0 +1,365 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "errors"
8+ "time"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ "bnema.dev/ermite/internal/ports"
12+)
13+
14+func mirrorOwner(p domain.Principal) error {
15+ if p.IsAnonymous() {
16+ return domain.ErrUnauthenticated
17+ }
18+ if !p.HasOwnerRights() {
19+ return domain.ErrForbidden
20+ }
21+ return nil
22+}
23+func (m *Mirrors) admin(ctx context.Context, p domain.Principal, repo domain.RepoName) error {
24+ if p.IsAnonymous() {
25+ return domain.ErrUnauthenticated
26+ }
27+ r, err := m.cfg.Meta.Get(ctx, repo)
28+ if err != nil {
29+ return err
30+ }
31+ if !p.Allows(domain.ScopeRepoAdmin, repo) {
32+ if !canRead(p, r) {
33+ return domain.ErrNotFound
34+ }
35+ return domain.ErrForbidden
36+ }
37+ return nil
38+}
39+func (m *Mirrors) target(ctx context.Context, repo domain.RepoName) (domain.MirrorTarget, error) {
40+ g, err := m.cfg.Store.GetGlobal(ctx)
41+ if err != nil {
42+ return domain.MirrorTarget{}, err
43+ }
44+ r, err := m.cfg.Store.GetRepoConfig(ctx, repo)
45+ if errors.Is(err, domain.ErrNotFound) {
46+ return m.resolve(g, nil, repo)
47+ }
48+ if err != nil {
49+ return domain.MirrorTarget{}, err
50+ }
51+ return m.resolve(g, &r, repo)
52+}
53+func (m *Mirrors) status(ctx context.Context, repo domain.RepoName) (domain.MirrorStatus, error) {
54+ s, err := m.cfg.Store.GetStatus(ctx, repo)
55+ if errors.Is(err, domain.ErrNotFound) {
56+ return domain.MirrorStatus{Repo: repo, State: domain.MirrorDisabled}, nil
57+ }
58+ return s, err
59+}
60+
61+// GetGlobalConfig returns server-wide policy to an owner.
62+func (m *Mirrors) GetGlobalConfig(ctx context.Context, p domain.Principal) (domain.MirrorGlobalConfig, error) {
63+ if err := mirrorOwner(p); err != nil {
64+ return domain.MirrorGlobalConfig{}, err
65+ }
66+ return m.cfg.Store.GetGlobal(ctx)
67+}
68+
69+// SetGlobalConfig patches server-wide policy and resets affected mirror incidents.
70+func (m *Mirrors) SetGlobalConfig(ctx context.Context, p domain.Principal, patch ports.MirrorGlobalPatch) (domain.MirrorGlobalConfig, error) {
71+ if err := mirrorOwner(p); err != nil {
72+ return domain.MirrorGlobalConfig{}, err
73+ }
74+ m.configMu.Lock()
75+ defer m.configMu.Unlock()
76+ old, err := m.cfg.Store.GetGlobal(ctx)
77+ if err != nil {
78+ return old, err
79+ }
80+ g := old
81+ if patch.Enabled != nil {
82+ g.Enabled = *patch.Enabled
83+ }
84+ if patch.URLTemplate != nil {
85+ g.URLTemplate = *patch.URLTemplate
86+ }
87+ if patch.Cron != nil {
88+ g.Cron = *patch.Cron
89+ }
90+ if patch.AllBranches != nil {
91+ g.AllBranches = *patch.AllBranches
92+ }
93+ if err := m.validateGlobal(g); err != nil {
94+ return old, err
95+ }
96+ repos, err := m.cfg.Meta.List(ctx)
97+ if err != nil {
98+ return old, err
99+ }
100+ // Resolve every effective target before and after, and persist nothing
101+ // unless all of them stay valid.
102+ var changed []domain.RepoName
103+ for _, r := range repos {
104+ c, e := m.cfg.Store.GetRepoConfig(ctx, r.Name)
105+ var cp *domain.MirrorRepoConfig
106+ if e == nil {
107+ cp = &c
108+ } else if !errors.Is(e, domain.ErrNotFound) {
109+ return old, e
110+ }
111+ before, _ := m.resolve(old, cp, r.Name)
112+ after, e := m.resolve(g, cp, r.Name)
113+ if e != nil {
114+ return old, invalidCron(e)
115+ }
116+ if !sameMirrorTarget(before, after) {
117+ changed = append(changed, r.Name)
118+ }
119+ }
120+ g.UpdatedAt = m.cfg.Clock.Now().UTC()
121+ if err := m.cfg.Store.PutGlobal(ctx, g); err != nil {
122+ return old, err
123+ }
124+ // One failing reset must not leave the others stale: the policy is saved.
125+ var errs []error
126+ for _, name := range changed {
127+ if err := m.reset(ctx, name); err != nil {
128+ errs = append(errs, err)
129+ }
130+ }
131+ return g, errors.Join(errs...)
132+}
133+
134+func invalidCron(e error) error {
135+ var inv *domain.InvalidFieldsError
136+ if errors.As(e, &inv) {
137+ return e
138+ }
139+ return &domain.InvalidFieldsError{Fields: []domain.FieldViolation{{Field: "cron", Reason: e.Error()}}}
140+}
141+
142+func sameMirrorTarget(a, b domain.MirrorTarget) bool {
143+ return a.Enabled == b.Enabled && a.URL == b.URL && a.CronSpec == b.CronSpec && a.AllBranches == b.AllBranches && a.Source == b.Source
144+}
145+
146+// reset lifts the incident of a repository whose effective target changed and marks it dirty.
147+func (m *Mirrors) reset(ctx context.Context, repo domain.RepoName) error {
148+ t, err := m.target(ctx, repo)
149+ if err != nil {
150+ return err
151+ }
152+ s, err := m.status(ctx, repo)
153+ if err != nil {
154+ return err
155+ }
156+ now := m.cfg.Clock.Now().UTC()
157+ if t.Enabled {
158+ s = domain.MirrorReset(s, now)
159+ } else {
160+ s = domain.MirrorDisable(s, now)
161+ }
162+ m.mu.Lock()
163+ g := m.gens[repo]
164+ g.dirty++
165+ m.gens[repo] = g
166+ m.mu.Unlock()
167+ return m.cfg.Store.PutStatus(ctx, s)
168+}
169+
170+// resetIfChanged resets repo when its effective target is no longer before. configMu is held.
171+func (m *Mirrors) resetIfChanged(ctx context.Context, repo domain.RepoName, before domain.MirrorTarget, beforeErr error) (domain.MirrorTarget, error) {
172+ after, err := m.target(ctx, repo)
173+ if err != nil {
174+ return after, err
175+ }
176+ if beforeErr == nil && sameMirrorTarget(before, after) {
177+ return after, nil
178+ }
179+ return after, m.reset(ctx, repo)
180+}
181+
182+// SetRepoMirror sets a repository override.
183+func (m *Mirrors) SetRepoMirror(ctx context.Context, p domain.Principal, c domain.MirrorRepoConfig) (domain.MirrorTarget, error) {
184+ if err := m.admin(ctx, p, c.Repo); err != nil {
185+ return domain.MirrorTarget{}, err
186+ }
187+ if err := m.validateRepo(c); err != nil {
188+ return domain.MirrorTarget{}, err
189+ }
190+ m.configMu.Lock()
191+ defer m.configMu.Unlock()
192+ return m.setRepoLocked(ctx, c)
193+}
194+
195+// setRepoLocked validates the prospective target, then persists. configMu must be held.
196+func (m *Mirrors) setRepoLocked(ctx context.Context, c domain.MirrorRepoConfig) (domain.MirrorTarget, error) {
197+ g, err := m.cfg.Store.GetGlobal(ctx)
198+ if err != nil {
199+ return domain.MirrorTarget{}, err
200+ }
201+ if _, err := m.resolve(g, &c, c.Repo); err != nil {
202+ return domain.MirrorTarget{}, invalidCron(err)
203+ }
204+ before, beforeErr := m.target(ctx, c.Repo)
205+ c.UpdatedAt = m.cfg.Clock.Now().UTC()
206+ if err := m.cfg.Store.PutRepoConfig(ctx, c); err != nil {
207+ return domain.MirrorTarget{}, err
208+ }
209+ return m.resetIfChanged(ctx, c.Repo, before, beforeErr)
210+}
211+
212+// RemoveRepoMirror restores inherited policy.
213+func (m *Mirrors) RemoveRepoMirror(ctx context.Context, p domain.Principal, repo domain.RepoName) error {
214+ if err := m.admin(ctx, p, repo); err != nil {
215+ return err
216+ }
217+ m.configMu.Lock()
218+ defer m.configMu.Unlock()
219+ before, beforeErr := m.target(ctx, repo)
220+ if err := m.cfg.Store.DeleteRepoConfig(ctx, repo); err != nil {
221+ return err
222+ }
223+ _, err := m.resetIfChanged(ctx, repo, before, beforeErr)
224+ return err
225+}
226+
227+// SetRepoExcluded updates exclusion without discarding an override.
228+func (m *Mirrors) SetRepoExcluded(ctx context.Context, p domain.Principal, repo domain.RepoName, excluded bool) (domain.MirrorTarget, error) {
229+ if err := m.admin(ctx, p, repo); err != nil {
230+ return domain.MirrorTarget{}, err
231+ }
232+ m.configMu.Lock()
233+ defer m.configMu.Unlock()
234+ c, err := m.cfg.Store.GetRepoConfig(ctx, repo)
235+ if err != nil && !errors.Is(err, domain.ErrNotFound) {
236+ return domain.MirrorTarget{}, err
237+ }
238+ c.Repo, c.Excluded = repo, excluded
239+ return m.setRepoLocked(ctx, c)
240+}
241+
242+// GetStatus returns a read-authorized status, redacting administrative diagnostics.
243+func (m *Mirrors) GetStatus(ctx context.Context, p domain.Principal, repo domain.RepoName) (ports.MirrorStatusView, error) {
244+ return m.statusView(ctx, p, repo, true)
245+}
246+
247+// statusView builds the view of one repository; withNext computes the next scheduled run.
248+func (m *Mirrors) statusView(ctx context.Context, p domain.Principal, repo domain.RepoName, withNext bool) (ports.MirrorStatusView, error) {
249+ r, err := m.cfg.Meta.Get(ctx, repo)
250+ if err != nil {
251+ return ports.MirrorStatusView{}, err
252+ }
253+ if !canRead(p, r) {
254+ return ports.MirrorStatusView{}, domain.ErrNotFound
255+ }
256+ t, err := m.target(ctx, repo)
257+ if err != nil {
258+ return ports.MirrorStatusView{}, err
259+ }
260+ s, err := m.status(ctx, repo)
261+ if err != nil {
262+ return ports.MirrorStatusView{}, err
263+ }
264+ return m.view(p, t, s, withNext), nil
265+}
266+
267+func (m *Mirrors) view(p domain.Principal, t domain.MirrorTarget, s domain.MirrorStatus, withNext bool) ports.MirrorStatusView {
268+ var next time.Time
269+ if withNext && t.Enabled && s.State != domain.MirrorPaused {
270+ if s.State == domain.MirrorFailing {
271+ next = s.NextRetryAt
272+ } else {
273+ next, _ = domain.NextCron(domain.CronSchedule{Cron: t.Cron, Loc: time.UTC}, m.cfg.Clock.Now())
274+ }
275+ }
276+ if !p.Allows(domain.ScopeRepoAdmin, t.Repo) {
277+ s.Detail, s.Reason = "", ""
278+ t.URL = ""
279+ }
280+ return ports.MirrorStatusView{Target: t, Status: s, NextRunAt: next}
281+}
282+
283+// ListStatus returns all statuses to an owner, from three reads instead of three per repository.
284+func (m *Mirrors) ListStatus(ctx context.Context, p domain.Principal) ([]ports.MirrorStatusView, error) {
285+ if err := mirrorOwner(p); err != nil {
286+ return nil, err
287+ }
288+ repos, err := m.cfg.Meta.List(ctx)
289+ if err != nil {
290+ return nil, err
291+ }
292+ g, err := m.cfg.Store.GetGlobal(ctx)
293+ if err != nil {
294+ return nil, err
295+ }
296+ configs, err := m.cfg.Store.ListRepoConfigs(ctx)
297+ if err != nil {
298+ return nil, err
299+ }
300+ byRepo := make(map[domain.RepoName]domain.MirrorRepoConfig, len(configs))
301+ for _, c := range configs {
302+ byRepo[c.Repo] = c
303+ }
304+ statuses, err := m.cfg.Store.ListStatus(ctx)
305+ if err != nil {
306+ return nil, err
307+ }
308+ stored := make(map[domain.RepoName]domain.MirrorStatus, len(statuses))
309+ for _, s := range statuses {
310+ stored[s.Repo] = s
311+ }
312+ out := make([]ports.MirrorStatusView, 0, len(repos))
313+ for _, r := range repos {
314+ var cp *domain.MirrorRepoConfig
315+ if c, ok := byRepo[r.Name]; ok {
316+ cp = &c
317+ }
318+ t, err := m.resolve(g, cp, r.Name)
319+ if err != nil {
320+ return nil, err
321+ }
322+ s, ok := stored[r.Name]
323+ if !ok {
324+ s = domain.MirrorStatus{Repo: r.Name, State: domain.MirrorDisabled}
325+ }
326+ out = append(out, m.view(p, t, s, true))
327+ }
328+ return out, nil
329+}
330+
331+// Warning provides the post-receive diagnostic of a failing or paused mirror to the admins of
332+// the repository only: it names the remote and the reason.
333+func (m *Mirrors) Warning(ctx context.Context, p domain.Principal, repo domain.RepoName) string {
334+ if !p.Allows(domain.ScopeRepoAdmin, repo) {
335+ return ""
336+ }
337+ s, err := m.status(ctx, repo)
338+ if err != nil || (s.State != domain.MirrorFailing && s.State != domain.MirrorPaused) {
339+ return ""
340+ }
341+ t, err := m.target(ctx, repo)
342+ if err != nil {
343+ return ""
344+ }
345+ return "ermite: mirror to " + domain.RedactMirrorURL(t.URL) + " is " + string(s.State) + ": " + s.Reason
346+}
347+
348+// Badge returns a viewer-safe state and optional administrative reason.
349+func (m *Mirrors) Badge(ctx context.Context, p domain.Principal, repo domain.RepoName) (domain.MirrorState, string) {
350+ v, err := m.statusView(ctx, p, repo, false)
351+ if err != nil {
352+ return domain.MirrorDisabled, ""
353+ }
354+ return v.Status.State, v.Status.Reason
355+}
356+
357+func (m *Mirrors) validateGlobal(g domain.MirrorGlobalConfig) error {
358+ return domain.ValidateMirrorGlobalConfigWith(g, m.cfg.ValidateURL)
359+}
360+func (m *Mirrors) validateRepo(c domain.MirrorRepoConfig) error {
361+ return domain.ValidateMirrorRepoConfigWith(c, m.cfg.ValidateURL)
362+}
363+func (m *Mirrors) resolve(g domain.MirrorGlobalConfig, c *domain.MirrorRepoConfig, repo domain.RepoName) (domain.MirrorTarget, error) {
364+ return domain.ResolveMirrorWith(g, c, repo, m.cfg.ValidateURL)
365+}
@@ -0,0 +1,365 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "errors"
8+ "time"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ "bnema.dev/ermite/internal/ports"
12+)
13+
14+func mirrorOwner(p domain.Principal) error {
15+ if p.IsAnonymous() {
16+ return domain.ErrUnauthenticated
17+ }
18+ if !p.HasOwnerRights() {
19+ return domain.ErrForbidden
20+ }
21+ return nil
22+}
23+func (m *Mirrors) admin(ctx context.Context, p domain.Principal, repo domain.RepoName) error {
24+ if p.IsAnonymous() {
25+ return domain.ErrUnauthenticated
26+ }
27+ r, err := m.cfg.Meta.Get(ctx, repo)
28+ if err != nil {
29+ return err
30+ }
31+ if !p.Allows(domain.ScopeRepoAdmin, repo) {
32+ if !canRead(p, r) {
33+ return domain.ErrNotFound
34+ }
35+ return domain.ErrForbidden
36+ }
37+ return nil
38+}
39+func (m *Mirrors) target(ctx context.Context, repo domain.RepoName) (domain.MirrorTarget, error) {
40+ g, err := m.cfg.Store.GetGlobal(ctx)
41+ if err != nil {
42+ return domain.MirrorTarget{}, err
43+ }
44+ r, err := m.cfg.Store.GetRepoConfig(ctx, repo)
45+ if errors.Is(err, domain.ErrNotFound) {
46+ return m.resolve(g, nil, repo)
47+ }
48+ if err != nil {
49+ return domain.MirrorTarget{}, err
50+ }
51+ return m.resolve(g, &r, repo)
52+}
53+func (m *Mirrors) status(ctx context.Context, repo domain.RepoName) (domain.MirrorStatus, error) {
54+ s, err := m.cfg.Store.GetStatus(ctx, repo)
55+ if errors.Is(err, domain.ErrNotFound) {
56+ return domain.MirrorStatus{Repo: repo, State: domain.MirrorDisabled}, nil
57+ }
58+ return s, err
59+}
60+
61+// GetGlobalConfig returns server-wide policy to an owner.
62+func (m *Mirrors) GetGlobalConfig(ctx context.Context, p domain.Principal) (domain.MirrorGlobalConfig, error) {
63+ if err := mirrorOwner(p); err != nil {
64+ return domain.MirrorGlobalConfig{}, err
65+ }
66+ return m.cfg.Store.GetGlobal(ctx)
67+}
68+
69+// SetGlobalConfig patches server-wide policy and resets affected mirror incidents.
70+func (m *Mirrors) SetGlobalConfig(ctx context.Context, p domain.Principal, patch ports.MirrorGlobalPatch) (domain.MirrorGlobalConfig, error) {
71+ if err := mirrorOwner(p); err != nil {
72+ return domain.MirrorGlobalConfig{}, err
73+ }
74+ m.configMu.Lock()
75+ defer m.configMu.Unlock()
76+ old, err := m.cfg.Store.GetGlobal(ctx)
77+ if err != nil {
78+ return old, err
79+ }
80+ g := old
81+ if patch.Enabled != nil {
82+ g.Enabled = *patch.Enabled
83+ }
84+ if patch.URLTemplate != nil {
85+ g.URLTemplate = *patch.URLTemplate
86+ }
87+ if patch.Cron != nil {
88+ g.Cron = *patch.Cron
89+ }
90+ if patch.AllBranches != nil {
91+ g.AllBranches = *patch.AllBranches
92+ }
93+ if err := m.validateGlobal(g); err != nil {
94+ return old, err
95+ }
96+ repos, err := m.cfg.Meta.List(ctx)
97+ if err != nil {
98+ return old, err
99+ }
100+ // Resolve every effective target before and after, and persist nothing
101+ // unless all of them stay valid.
102+ var changed []domain.RepoName
103+ for _, r := range repos {
104+ c, e := m.cfg.Store.GetRepoConfig(ctx, r.Name)
105+ var cp *domain.MirrorRepoConfig
106+ if e == nil {
107+ cp = &c
108+ } else if !errors.Is(e, domain.ErrNotFound) {
109+ return old, e
110+ }
111+ before, _ := m.resolve(old, cp, r.Name)
112+ after, e := m.resolve(g, cp, r.Name)
113+ if e != nil {
114+ return old, invalidCron(e)
115+ }
116+ if !sameMirrorTarget(before, after) {
117+ changed = append(changed, r.Name)
118+ }
119+ }
120+ g.UpdatedAt = m.cfg.Clock.Now().UTC()
121+ if err := m.cfg.Store.PutGlobal(ctx, g); err != nil {
122+ return old, err
123+ }
124+ // One failing reset must not leave the others stale: the policy is saved.
125+ var errs []error
126+ for _, name := range changed {
127+ if err := m.reset(ctx, name); err != nil {
128+ errs = append(errs, err)
129+ }
130+ }
131+ return g, errors.Join(errs...)
132+}
133+
134+func invalidCron(e error) error {
135+ var inv *domain.InvalidFieldsError
136+ if errors.As(e, &inv) {
137+ return e
138+ }
139+ return &domain.InvalidFieldsError{Fields: []domain.FieldViolation{{Field: "cron", Reason: e.Error()}}}
140+}
141+
142+func sameMirrorTarget(a, b domain.MirrorTarget) bool {
143+ return a.Enabled == b.Enabled && a.URL == b.URL && a.CronSpec == b.CronSpec && a.AllBranches == b.AllBranches && a.Source == b.Source
144+}
145+
146+// reset lifts the incident of a repository whose effective target changed and marks it dirty.
147+func (m *Mirrors) reset(ctx context.Context, repo domain.RepoName) error {
148+ t, err := m.target(ctx, repo)
149+ if err != nil {
150+ return err
151+ }
152+ s, err := m.status(ctx, repo)
153+ if err != nil {
154+ return err
155+ }
156+ now := m.cfg.Clock.Now().UTC()
157+ if t.Enabled {
158+ s = domain.MirrorReset(s, now)
159+ } else {
160+ s = domain.MirrorDisable(s, now)
161+ }
162+ m.mu.Lock()
163+ g := m.gens[repo]
164+ g.dirty++
165+ m.gens[repo] = g
166+ m.mu.Unlock()
167+ return m.cfg.Store.PutStatus(ctx, s)
168+}
169+
170+// resetIfChanged resets repo when its effective target is no longer before. configMu is held.
171+func (m *Mirrors) resetIfChanged(ctx context.Context, repo domain.RepoName, before domain.MirrorTarget, beforeErr error) (domain.MirrorTarget, error) {
172+ after, err := m.target(ctx, repo)
173+ if err != nil {
174+ return after, err
175+ }
176+ if beforeErr == nil && sameMirrorTarget(before, after) {
177+ return after, nil
178+ }
179+ return after, m.reset(ctx, repo)
180+}
181+
182+// SetRepoMirror sets a repository override.
183+func (m *Mirrors) SetRepoMirror(ctx context.Context, p domain.Principal, c domain.MirrorRepoConfig) (domain.MirrorTarget, error) {
184+ if err := m.admin(ctx, p, c.Repo); err != nil {
185+ return domain.MirrorTarget{}, err
186+ }
187+ if err := m.validateRepo(c); err != nil {
188+ return domain.MirrorTarget{}, err
189+ }
190+ m.configMu.Lock()
191+ defer m.configMu.Unlock()
192+ return m.setRepoLocked(ctx, c)
193+}
194+
195+// setRepoLocked validates the prospective target, then persists. configMu must be held.
196+func (m *Mirrors) setRepoLocked(ctx context.Context, c domain.MirrorRepoConfig) (domain.MirrorTarget, error) {
197+ g, err := m.cfg.Store.GetGlobal(ctx)
198+ if err != nil {
199+ return domain.MirrorTarget{}, err
200+ }
201+ if _, err := m.resolve(g, &c, c.Repo); err != nil {
202+ return domain.MirrorTarget{}, invalidCron(err)
203+ }
204+ before, beforeErr := m.target(ctx, c.Repo)
205+ c.UpdatedAt = m.cfg.Clock.Now().UTC()
206+ if err := m.cfg.Store.PutRepoConfig(ctx, c); err != nil {
207+ return domain.MirrorTarget{}, err
208+ }
209+ return m.resetIfChanged(ctx, c.Repo, before, beforeErr)
210+}
211+
212+// RemoveRepoMirror restores inherited policy.
213+func (m *Mirrors) RemoveRepoMirror(ctx context.Context, p domain.Principal, repo domain.RepoName) error {
214+ if err := m.admin(ctx, p, repo); err != nil {
215+ return err
216+ }
217+ m.configMu.Lock()
218+ defer m.configMu.Unlock()
219+ before, beforeErr := m.target(ctx, repo)
220+ if err := m.cfg.Store.DeleteRepoConfig(ctx, repo); err != nil {
221+ return err
222+ }
223+ _, err := m.resetIfChanged(ctx, repo, before, beforeErr)
224+ return err
225+}
226+
227+// SetRepoExcluded updates exclusion without discarding an override.
228+func (m *Mirrors) SetRepoExcluded(ctx context.Context, p domain.Principal, repo domain.RepoName, excluded bool) (domain.MirrorTarget, error) {
229+ if err := m.admin(ctx, p, repo); err != nil {
230+ return domain.MirrorTarget{}, err
231+ }
232+ m.configMu.Lock()
233+ defer m.configMu.Unlock()
234+ c, err := m.cfg.Store.GetRepoConfig(ctx, repo)
235+ if err != nil && !errors.Is(err, domain.ErrNotFound) {
236+ return domain.MirrorTarget{}, err
237+ }
238+ c.Repo, c.Excluded = repo, excluded
239+ return m.setRepoLocked(ctx, c)
240+}
241+
242+// GetStatus returns a read-authorized status, redacting administrative diagnostics.
243+func (m *Mirrors) GetStatus(ctx context.Context, p domain.Principal, repo domain.RepoName) (ports.MirrorStatusView, error) {
244+ return m.statusView(ctx, p, repo, true)
245+}
246+
247+// statusView builds the view of one repository; withNext computes the next scheduled run.
248+func (m *Mirrors) statusView(ctx context.Context, p domain.Principal, repo domain.RepoName, withNext bool) (ports.MirrorStatusView, error) {
249+ r, err := m.cfg.Meta.Get(ctx, repo)
250+ if err != nil {
251+ return ports.MirrorStatusView{}, err
252+ }
253+ if !canRead(p, r) {
254+ return ports.MirrorStatusView{}, domain.ErrNotFound
255+ }
256+ t, err := m.target(ctx, repo)
257+ if err != nil {
258+ return ports.MirrorStatusView{}, err
259+ }
260+ s, err := m.status(ctx, repo)
261+ if err != nil {
262+ return ports.MirrorStatusView{}, err
263+ }
264+ return m.view(p, t, s, withNext), nil
265+}
266+
267+func (m *Mirrors) view(p domain.Principal, t domain.MirrorTarget, s domain.MirrorStatus, withNext bool) ports.MirrorStatusView {
268+ var next time.Time
269+ if withNext && t.Enabled && s.State != domain.MirrorPaused {
270+ if s.State == domain.MirrorFailing {
271+ next = s.NextRetryAt
272+ } else {
273+ next, _ = domain.NextCron(domain.CronSchedule{Cron: t.Cron, Loc: time.UTC}, m.cfg.Clock.Now())
274+ }
275+ }
276+ if !p.Allows(domain.ScopeRepoAdmin, t.Repo) {
277+ s.Detail, s.Reason = "", ""
278+ t.URL = ""
279+ }
280+ return ports.MirrorStatusView{Target: t, Status: s, NextRunAt: next}
281+}
282+
283+// ListStatus returns all statuses to an owner, from three reads instead of three per repository.
284+func (m *Mirrors) ListStatus(ctx context.Context, p domain.Principal) ([]ports.MirrorStatusView, error) {
285+ if err := mirrorOwner(p); err != nil {
286+ return nil, err
287+ }
288+ repos, err := m.cfg.Meta.List(ctx)
289+ if err != nil {
290+ return nil, err
291+ }
292+ g, err := m.cfg.Store.GetGlobal(ctx)
293+ if err != nil {
294+ return nil, err
295+ }
296+ configs, err := m.cfg.Store.ListRepoConfigs(ctx)
297+ if err != nil {
298+ return nil, err
299+ }
300+ byRepo := make(map[domain.RepoName]domain.MirrorRepoConfig, len(configs))
301+ for _, c := range configs {
302+ byRepo[c.Repo] = c
303+ }
304+ statuses, err := m.cfg.Store.ListStatus(ctx)
305+ if err != nil {
306+ return nil, err
307+ }
308+ stored := make(map[domain.RepoName]domain.MirrorStatus, len(statuses))
309+ for _, s := range statuses {
310+ stored[s.Repo] = s
311+ }
312+ out := make([]ports.MirrorStatusView, 0, len(repos))
313+ for _, r := range repos {
314+ var cp *domain.MirrorRepoConfig
315+ if c, ok := byRepo[r.Name]; ok {
316+ cp = &c
317+ }
318+ t, err := m.resolve(g, cp, r.Name)
319+ if err != nil {
320+ return nil, err
321+ }
322+ s, ok := stored[r.Name]
323+ if !ok {
324+ s = domain.MirrorStatus{Repo: r.Name, State: domain.MirrorDisabled}
325+ }
326+ out = append(out, m.view(p, t, s, true))
327+ }
328+ return out, nil
329+}
330+
331+// Warning provides the post-receive diagnostic of a failing or paused mirror to the admins of
332+// the repository only: it names the remote and the reason.
333+func (m *Mirrors) Warning(ctx context.Context, p domain.Principal, repo domain.RepoName) string {
334+ if !p.Allows(domain.ScopeRepoAdmin, repo) {
335+ return ""
336+ }
337+ s, err := m.status(ctx, repo)
338+ if err != nil || (s.State != domain.MirrorFailing && s.State != domain.MirrorPaused) {
339+ return ""
340+ }
341+ t, err := m.target(ctx, repo)
342+ if err != nil {
343+ return ""
344+ }
345+ return "ermite: mirror to " + domain.RedactMirrorURL(t.URL) + " is " + string(s.State) + ": " + s.Reason
346+}
347+
348+// Badge returns a viewer-safe state and optional administrative reason.
349+func (m *Mirrors) Badge(ctx context.Context, p domain.Principal, repo domain.RepoName) (domain.MirrorState, string) {
350+ v, err := m.statusView(ctx, p, repo, false)
351+ if err != nil {
352+ return domain.MirrorDisabled, ""
353+ }
354+ return v.Status.State, v.Status.Reason
355+}
356+
357+func (m *Mirrors) validateGlobal(g domain.MirrorGlobalConfig) error {
358+ return domain.ValidateMirrorGlobalConfigWith(g, m.cfg.ValidateURL)
359+}
360+func (m *Mirrors) validateRepo(c domain.MirrorRepoConfig) error {
361+ return domain.ValidateMirrorRepoConfigWith(c, m.cfg.ValidateURL)
362+}
363+func (m *Mirrors) resolve(g domain.MirrorGlobalConfig, c *domain.MirrorRepoConfig, repo domain.RepoName) (domain.MirrorTarget, error) {
364+ return domain.ResolveMirrorWith(g, c, repo, m.cfg.ValidateURL)
365+}
A internal/usecase/mirrors_config_test.go +276 -0
@@ -0,0 +1,276 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "context"
7+ "errors"
8+ "sync"
9+ "testing"
10+ "time"
11+
12+ "github.com/stretchr/testify/require"
13+
14+ "bnema.dev/ermite/internal/domain"
15+ "bnema.dev/ermite/internal/ports"
16+ "bnema.dev/ermite/internal/usecase"
17+)
18+
19+func TestMirrorsAuthorizationMatrix(t *testing.T) {
20+ f := newMirrorFixture(t)
21+ ctx := context.Background()
22+ reader := tokenPrincipal(domain.ScopeRepoRead)
23+ admin := tokenPrincipal(domain.ScopeRepoAdmin)
24+ _, err := f.m.GetGlobalConfig(ctx, reader)
25+ require.ErrorIs(t, err, domain.ErrForbidden)
26+ _, err = f.m.SetGlobalConfig(ctx, reader, ports.MirrorGlobalPatch{})
27+ require.ErrorIs(t, err, domain.ErrForbidden)
28+ _, err = f.m.ListStatus(ctx, reader)
29+ require.ErrorIs(t, err, domain.ErrForbidden)
30+ _, err = f.m.RotateKey(ctx, admin)
31+ require.ErrorIs(t, err, domain.ErrForbidden)
32+ // Key show deliberately requires authentication, not owner rights.
33+ _, err = f.m.ShowKey(ctx, reader)
34+ require.NoError(t, err)
35+ _, err = f.m.ShowKey(ctx, domain.Anonymous())
36+ require.ErrorIs(t, err, domain.ErrUnauthenticated)
37+ _, err = f.m.SetRepoMirror(ctx, reader, domain.MirrorRepoConfig{Repo: f.repo})
38+ require.ErrorIs(t, err, domain.ErrForbidden)
39+ err = f.m.RemoveRepoMirror(ctx, reader, f.repo)
40+ require.ErrorIs(t, err, domain.ErrForbidden)
41+ _, err = f.m.SetRepoExcluded(ctx, reader, f.repo, true)
42+ require.ErrorIs(t, err, domain.ErrForbidden)
43+ _, err = f.m.Sync(ctx, reader, f.repo, false)
44+ require.ErrorIs(t, err, domain.ErrForbidden)
45+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorOK, Detail: "admin detail", Reason: "admin reason"})
46+ view, err := f.m.GetStatus(ctx, domain.Anonymous(), f.repo)
47+ require.NoError(t, err)
48+ require.Empty(t, view.Status.Detail)
49+ require.Empty(t, view.Status.Reason)
50+ require.Empty(t, view.Target.URL)
51+ view, err = f.m.GetStatus(ctx, admin, f.repo)
52+ require.NoError(t, err)
53+ require.Equal(t, "admin detail", view.Status.Detail)
54+ _, err = f.m.SetRepoMirror(ctx, admin, domain.MirrorRepoConfig{Repo: f.repo})
55+ require.NoError(t, err)
56+}
57+
58+func TestMirrorsPrivateStatusAuthorization(t *testing.T) {
59+ f := newMirrorFixture(t)
60+ f.mu.Lock()
61+ f.repos[0].Visibility = domain.VisibilityPrivate
62+ f.mu.Unlock()
63+ _, err := f.m.GetStatus(context.Background(), domain.Anonymous(), f.repo)
64+ require.ErrorIs(t, err, domain.ErrNotFound)
65+ _, err = f.m.GetStatus(context.Background(), tokenPrincipal(domain.ScopeRepoRead, "other"), f.repo)
66+ require.ErrorIs(t, err, domain.ErrNotFound)
67+ _, err = f.m.GetStatus(context.Background(), tokenPrincipal(domain.ScopeRepoRead, "tools"), f.repo)
68+ require.NoError(t, err)
69+}
70+
71+func TestMirrorsWarningIsAdminOnly(t *testing.T) {
72+ f := newMirrorFixture(t)
73+ other := name(t, "other")
74+ failing := domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, Reason: "the remote has commits"}
75+ for _, tc := range []struct {
76+ name string
77+ p domain.Principal
78+ status domain.MirrorStatus
79+ want bool
80+ }{
81+ {"root", domain.Root(), failing, true},
82+ {"repo admin", tokenPrincipal(domain.ScopeRepoAdmin, "tools"), failing, true},
83+ {"admin of another repository", tokenPrincipal(domain.ScopeRepoAdmin, other.String()), failing, false},
84+ {"writer", tokenPrincipal(domain.ScopeRepoWrite, "tools"), failing, false},
85+ {"anonymous", domain.Anonymous(), failing, false},
86+ {"admin, mirror ok", domain.Root(), domain.MirrorStatus{Repo: f.repo, State: domain.MirrorOK}, false},
87+ } {
88+ t.Run(tc.name, func(t *testing.T) {
89+ f.setStatus(tc.status)
90+ w := f.m.Warning(context.Background(), tc.p, f.repo)
91+ if !tc.want {
92+ require.Empty(t, w)
93+ return
94+ }
95+ require.Contains(t, w, "example.com:acme/tools")
96+ require.Contains(t, w, "paused")
97+ require.Contains(t, w, "the remote has commits")
98+ })
99+ }
100+}
101+
102+func TestMirrorsBadge(t *testing.T) {
103+ f := newMirrorFixture(t)
104+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorFailing, Reason: "retrying"})
105+ state, reason := f.m.Badge(context.Background(), tokenPrincipal(domain.ScopeRepoAdmin, "tools"), f.repo)
106+ require.Equal(t, domain.MirrorFailing, state)
107+ require.Equal(t, "retrying", reason)
108+ state, reason = f.m.Badge(context.Background(), domain.Anonymous(), f.repo)
109+ require.Equal(t, domain.MirrorFailing, state)
110+ require.Empty(t, reason, "the reason is for admins")
111+ state, _ = f.m.Badge(context.Background(), domain.Root(), name(t, "ghost"))
112+ require.Equal(t, domain.MirrorDisabled, state)
113+ // A badge needs no schedule: with an unparsable-looking cron the view still works and costs no search.
114+ require.NotPanics(t, func() { f.m.Badge(context.Background(), domain.Root(), f.repo) })
115+}
116+
117+func TestMirrorsListStatusReadsOnceAndHidesNothingFromOwner(t *testing.T) {
118+ f := newMirrorFixture(t)
119+ second := name(t, "second")
120+ f.addRepo(second)
121+ f.setStatus(domain.MirrorStatus{Repo: second, State: domain.MirrorPaused, Reason: "r"})
122+ list, err := f.m.ListStatus(context.Background(), domain.Root())
123+ require.NoError(t, err)
124+ require.Len(t, list, 2)
125+ require.Equal(t, "git@example.com:acme/tools", list[0].Target.URL)
126+ require.Equal(t, domain.MirrorPaused, list[1].Status.State)
127+ require.False(t, list[0].NextRunAt.IsZero())
128+ require.True(t, list[1].NextRunAt.IsZero(), "a paused mirror has no next run")
129+}
130+
131+func TestMirrorsDivergedPausedAndConfigReset(t *testing.T) {
132+ f := newMirrorFixture(t)
133+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, ConsecutiveFailures: 1})
134+ _, err := f.m.SetRepoMirror(context.Background(), domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@other.example:acme/tools", Cron: "*/5 * * * *"})
135+ require.NoError(t, err)
136+ s := f.statusOf(f.repo)
137+ require.Equal(t, domain.MirrorOK, s.State)
138+ require.Zero(t, s.ConsecutiveFailures)
139+}
140+
141+func TestMirrorsRepoChangesResetOnlyWhenTheTargetChanged(t *testing.T) {
142+ f := newMirrorFixture(t)
143+ ctx := context.Background()
144+ paused := domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, ConsecutiveFailures: 1}
145+ f.setStatus(paused)
146+ // The override restates the inherited target: nothing changed, the incident stays.
147+ _, err := f.m.SetRepoMirror(ctx, domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@example.com:acme/tools"})
148+ require.NoError(t, err) // source changes global -> override: a change
149+ f.setStatus(paused)
150+ writes := f.statusWrites()
151+ _, err = f.m.SetRepoMirror(ctx, domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@example.com:acme/tools"})
152+ require.NoError(t, err)
153+ require.Equal(t, writes, f.statusWrites(), "same effective target: no reset")
154+ require.Equal(t, domain.MirrorPaused, f.statusOf(f.repo).State)
155+ // Removing a no-op exclusion, and excluding to the same effect, follow the same rule.
156+ err = f.m.RemoveRepoMirror(ctx, domain.Root(), f.repo)
157+ require.NoError(t, err)
158+ require.Equal(t, domain.MirrorOK, f.statusOf(f.repo).State, "override gone: the source changed back to global")
159+ f.setStatus(paused)
160+ writes = f.statusWrites()
161+ err = f.m.RemoveRepoMirror(ctx, domain.Root(), f.repo)
162+ require.NoError(t, err)
163+ require.Equal(t, writes, f.statusWrites(), "no override to remove: no reset")
164+ _, err = f.m.SetRepoExcluded(ctx, domain.Root(), f.repo, true)
165+ require.NoError(t, err)
166+ require.Equal(t, domain.MirrorDisabled, f.statusOf(f.repo).State)
167+}
168+
169+func TestMirrorsGlobalResetContinuesPastErrors(t *testing.T) {
170+ f := newMirrorFixture(t)
171+ second := name(t, "second")
172+ f.addRepo(second)
173+ f.setStatus(domain.MirrorStatus{Repo: second, State: domain.MirrorPaused, ConsecutiveFailures: 1})
174+ f.failStatusWrites(f.repo, errBoom)
175+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Cron: ptr("*/10 * * * *")})
176+ require.ErrorIs(t, err, errBoom)
177+ require.Equal(t, domain.MirrorOK, f.statusOf(second).State, "the other repository was still reset")
178+ require.Equal(t, "*/10 * * * *", f.global.Cron, "the policy itself is saved")
179+}
180+
181+func TestMirrorsOverrideWithoutCronRejectedWhenGlobalCronEmpty(t *testing.T) {
182+ f := newMirrorFixture(t)
183+ f.setGlobal(domain.MirrorGlobalConfig{})
184+ _, err := f.m.SetRepoMirror(context.Background(), domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@example.com:acme/tools"})
185+ var fe *domain.InvalidFieldsError
186+ require.ErrorAs(t, err, &fe)
187+ require.Equal(t, "cron", fe.Fields[0].Field)
188+ require.Empty(t, f.cfgs, "nothing is stored")
189+}
190+
191+func TestMirrorsGlobalChangeInvalidatingOverrideRejected(t *testing.T) {
192+ f := newMirrorFixture(t)
193+ f.setRepoConfig(domain.MirrorRepoConfig{Repo: f.repo, URL: "git@other.example:x/y"})
194+ // Disabling the global with an empty cron leaves the inheriting override with no cron.
195+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Enabled: ptr(false), Cron: ptr("")})
196+ var fe *domain.InvalidFieldsError
197+ require.ErrorAs(t, err, &fe)
198+ require.True(t, f.global.Enabled, "nothing is stored")
199+}
200+
201+func TestMirrorsGlobalChangeResetsInheritingURLOverride(t *testing.T) {
202+ f := newMirrorFixture(t)
203+ f.setRepoConfig(domain.MirrorRepoConfig{Repo: f.repo, URL: "git@other.example:x/y"})
204+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged})
205+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Cron: ptr("*/10 * * * *")})
206+ require.NoError(t, err)
207+ require.Equal(t, domain.MirrorOK, f.statusOf(f.repo).State)
208+}
209+
210+func TestMirrorsSetRepoExcludedConcurrentIsSerialized(t *testing.T) {
211+ f := newMirrorFixture(t)
212+ var mu sync.Mutex
213+ active, maxActive := 0, 0
214+ enter, leave := make(chan struct{}), make(chan struct{})
215+ f.onPutRepo = func() {
216+ mu.Lock()
217+ active++
218+ maxActive = max(maxActive, active)
219+ mu.Unlock()
220+ enter <- struct{}{}
221+ <-leave
222+ mu.Lock()
223+ active--
224+ mu.Unlock()
225+ }
226+ errs := make(chan error, 4)
227+ for i := range 4 {
228+ go func() {
229+ _, err := f.m.SetRepoExcluded(context.Background(), domain.Root(), f.repo, i%2 == 0)
230+ errs <- err
231+ }()
232+ }
233+ // While one writer is blocked inside the store, the others cannot have entered it.
234+ for range 4 {
235+ <-enter
236+ mu.Lock()
237+ require.Equal(t, 1, active)
238+ mu.Unlock()
239+ leave <- struct{}{}
240+ }
241+ for range 4 {
242+ require.NoError(t, <-errs)
243+ }
244+ require.Equal(t, 1, maxActive, "read-modify-write must be serialized")
245+}
246+
247+func TestMirrorsURLValidatorIsInjectable(t *testing.T) {
248+ for _, tc := range []struct {
249+ name string
250+ validate func(string) error
251+ ok bool
252+ }{
253+ {"default rejects file", nil, false},
254+ {"injected accepts file", func(string) error { return nil }, true},
255+ {"injected rejects", func(string) error { return errors.New("no") }, false},
256+ } {
257+ t.Run(tc.name, func(t *testing.T) {
258+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.ValidateURL = tc.validate })
259+ target, err := f.m.SetRepoMirror(context.Background(), domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "file:///tmp/remotes/tools", Cron: "*/5 * * * *"})
260+ if tc.ok {
261+ require.NoError(t, err)
262+ require.Equal(t, "file:///tmp/remotes/tools", target.URL)
263+ } else {
264+ require.ErrorIs(t, err, domain.ErrInvalid)
265+ }
266+ })
267+ }
268+}
269+
270+func TestMirrorsNextRunIsComputedForStatusOnly(t *testing.T) {
271+ f := newMirrorFixture(t)
272+ view, err := f.m.GetStatus(context.Background(), domain.Root(), f.repo)
273+ require.NoError(t, err)
274+ require.True(t, view.NextRunAt.Equal(now.Add(8*time.Minute)) || !view.NextRunAt.IsZero())
275+ require.Equal(t, 0, view.NextRunAt.Minute()%5)
276+}
@@ -0,0 +1,276 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "context"
7+ "errors"
8+ "sync"
9+ "testing"
10+ "time"
11+
12+ "github.com/stretchr/testify/require"
13+
14+ "bnema.dev/ermite/internal/domain"
15+ "bnema.dev/ermite/internal/ports"
16+ "bnema.dev/ermite/internal/usecase"
17+)
18+
19+func TestMirrorsAuthorizationMatrix(t *testing.T) {
20+ f := newMirrorFixture(t)
21+ ctx := context.Background()
22+ reader := tokenPrincipal(domain.ScopeRepoRead)
23+ admin := tokenPrincipal(domain.ScopeRepoAdmin)
24+ _, err := f.m.GetGlobalConfig(ctx, reader)
25+ require.ErrorIs(t, err, domain.ErrForbidden)
26+ _, err = f.m.SetGlobalConfig(ctx, reader, ports.MirrorGlobalPatch{})
27+ require.ErrorIs(t, err, domain.ErrForbidden)
28+ _, err = f.m.ListStatus(ctx, reader)
29+ require.ErrorIs(t, err, domain.ErrForbidden)
30+ _, err = f.m.RotateKey(ctx, admin)
31+ require.ErrorIs(t, err, domain.ErrForbidden)
32+ // Key show deliberately requires authentication, not owner rights.
33+ _, err = f.m.ShowKey(ctx, reader)
34+ require.NoError(t, err)
35+ _, err = f.m.ShowKey(ctx, domain.Anonymous())
36+ require.ErrorIs(t, err, domain.ErrUnauthenticated)
37+ _, err = f.m.SetRepoMirror(ctx, reader, domain.MirrorRepoConfig{Repo: f.repo})
38+ require.ErrorIs(t, err, domain.ErrForbidden)
39+ err = f.m.RemoveRepoMirror(ctx, reader, f.repo)
40+ require.ErrorIs(t, err, domain.ErrForbidden)
41+ _, err = f.m.SetRepoExcluded(ctx, reader, f.repo, true)
42+ require.ErrorIs(t, err, domain.ErrForbidden)
43+ _, err = f.m.Sync(ctx, reader, f.repo, false)
44+ require.ErrorIs(t, err, domain.ErrForbidden)
45+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorOK, Detail: "admin detail", Reason: "admin reason"})
46+ view, err := f.m.GetStatus(ctx, domain.Anonymous(), f.repo)
47+ require.NoError(t, err)
48+ require.Empty(t, view.Status.Detail)
49+ require.Empty(t, view.Status.Reason)
50+ require.Empty(t, view.Target.URL)
51+ view, err = f.m.GetStatus(ctx, admin, f.repo)
52+ require.NoError(t, err)
53+ require.Equal(t, "admin detail", view.Status.Detail)
54+ _, err = f.m.SetRepoMirror(ctx, admin, domain.MirrorRepoConfig{Repo: f.repo})
55+ require.NoError(t, err)
56+}
57+
58+func TestMirrorsPrivateStatusAuthorization(t *testing.T) {
59+ f := newMirrorFixture(t)
60+ f.mu.Lock()
61+ f.repos[0].Visibility = domain.VisibilityPrivate
62+ f.mu.Unlock()
63+ _, err := f.m.GetStatus(context.Background(), domain.Anonymous(), f.repo)
64+ require.ErrorIs(t, err, domain.ErrNotFound)
65+ _, err = f.m.GetStatus(context.Background(), tokenPrincipal(domain.ScopeRepoRead, "other"), f.repo)
66+ require.ErrorIs(t, err, domain.ErrNotFound)
67+ _, err = f.m.GetStatus(context.Background(), tokenPrincipal(domain.ScopeRepoRead, "tools"), f.repo)
68+ require.NoError(t, err)
69+}
70+
71+func TestMirrorsWarningIsAdminOnly(t *testing.T) {
72+ f := newMirrorFixture(t)
73+ other := name(t, "other")
74+ failing := domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, Reason: "the remote has commits"}
75+ for _, tc := range []struct {
76+ name string
77+ p domain.Principal
78+ status domain.MirrorStatus
79+ want bool
80+ }{
81+ {"root", domain.Root(), failing, true},
82+ {"repo admin", tokenPrincipal(domain.ScopeRepoAdmin, "tools"), failing, true},
83+ {"admin of another repository", tokenPrincipal(domain.ScopeRepoAdmin, other.String()), failing, false},
84+ {"writer", tokenPrincipal(domain.ScopeRepoWrite, "tools"), failing, false},
85+ {"anonymous", domain.Anonymous(), failing, false},
86+ {"admin, mirror ok", domain.Root(), domain.MirrorStatus{Repo: f.repo, State: domain.MirrorOK}, false},
87+ } {
88+ t.Run(tc.name, func(t *testing.T) {
89+ f.setStatus(tc.status)
90+ w := f.m.Warning(context.Background(), tc.p, f.repo)
91+ if !tc.want {
92+ require.Empty(t, w)
93+ return
94+ }
95+ require.Contains(t, w, "example.com:acme/tools")
96+ require.Contains(t, w, "paused")
97+ require.Contains(t, w, "the remote has commits")
98+ })
99+ }
100+}
101+
102+func TestMirrorsBadge(t *testing.T) {
103+ f := newMirrorFixture(t)
104+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorFailing, Reason: "retrying"})
105+ state, reason := f.m.Badge(context.Background(), tokenPrincipal(domain.ScopeRepoAdmin, "tools"), f.repo)
106+ require.Equal(t, domain.MirrorFailing, state)
107+ require.Equal(t, "retrying", reason)
108+ state, reason = f.m.Badge(context.Background(), domain.Anonymous(), f.repo)
109+ require.Equal(t, domain.MirrorFailing, state)
110+ require.Empty(t, reason, "the reason is for admins")
111+ state, _ = f.m.Badge(context.Background(), domain.Root(), name(t, "ghost"))
112+ require.Equal(t, domain.MirrorDisabled, state)
113+ // A badge needs no schedule: with an unparsable-looking cron the view still works and costs no search.
114+ require.NotPanics(t, func() { f.m.Badge(context.Background(), domain.Root(), f.repo) })
115+}
116+
117+func TestMirrorsListStatusReadsOnceAndHidesNothingFromOwner(t *testing.T) {
118+ f := newMirrorFixture(t)
119+ second := name(t, "second")
120+ f.addRepo(second)
121+ f.setStatus(domain.MirrorStatus{Repo: second, State: domain.MirrorPaused, Reason: "r"})
122+ list, err := f.m.ListStatus(context.Background(), domain.Root())
123+ require.NoError(t, err)
124+ require.Len(t, list, 2)
125+ require.Equal(t, "git@example.com:acme/tools", list[0].Target.URL)
126+ require.Equal(t, domain.MirrorPaused, list[1].Status.State)
127+ require.False(t, list[0].NextRunAt.IsZero())
128+ require.True(t, list[1].NextRunAt.IsZero(), "a paused mirror has no next run")
129+}
130+
131+func TestMirrorsDivergedPausedAndConfigReset(t *testing.T) {
132+ f := newMirrorFixture(t)
133+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, ConsecutiveFailures: 1})
134+ _, err := f.m.SetRepoMirror(context.Background(), domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@other.example:acme/tools", Cron: "*/5 * * * *"})
135+ require.NoError(t, err)
136+ s := f.statusOf(f.repo)
137+ require.Equal(t, domain.MirrorOK, s.State)
138+ require.Zero(t, s.ConsecutiveFailures)
139+}
140+
141+func TestMirrorsRepoChangesResetOnlyWhenTheTargetChanged(t *testing.T) {
142+ f := newMirrorFixture(t)
143+ ctx := context.Background()
144+ paused := domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, ConsecutiveFailures: 1}
145+ f.setStatus(paused)
146+ // The override restates the inherited target: nothing changed, the incident stays.
147+ _, err := f.m.SetRepoMirror(ctx, domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@example.com:acme/tools"})
148+ require.NoError(t, err) // source changes global -> override: a change
149+ f.setStatus(paused)
150+ writes := f.statusWrites()
151+ _, err = f.m.SetRepoMirror(ctx, domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@example.com:acme/tools"})
152+ require.NoError(t, err)
153+ require.Equal(t, writes, f.statusWrites(), "same effective target: no reset")
154+ require.Equal(t, domain.MirrorPaused, f.statusOf(f.repo).State)
155+ // Removing a no-op exclusion, and excluding to the same effect, follow the same rule.
156+ err = f.m.RemoveRepoMirror(ctx, domain.Root(), f.repo)
157+ require.NoError(t, err)
158+ require.Equal(t, domain.MirrorOK, f.statusOf(f.repo).State, "override gone: the source changed back to global")
159+ f.setStatus(paused)
160+ writes = f.statusWrites()
161+ err = f.m.RemoveRepoMirror(ctx, domain.Root(), f.repo)
162+ require.NoError(t, err)
163+ require.Equal(t, writes, f.statusWrites(), "no override to remove: no reset")
164+ _, err = f.m.SetRepoExcluded(ctx, domain.Root(), f.repo, true)
165+ require.NoError(t, err)
166+ require.Equal(t, domain.MirrorDisabled, f.statusOf(f.repo).State)
167+}
168+
169+func TestMirrorsGlobalResetContinuesPastErrors(t *testing.T) {
170+ f := newMirrorFixture(t)
171+ second := name(t, "second")
172+ f.addRepo(second)
173+ f.setStatus(domain.MirrorStatus{Repo: second, State: domain.MirrorPaused, ConsecutiveFailures: 1})
174+ f.failStatusWrites(f.repo, errBoom)
175+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Cron: ptr("*/10 * * * *")})
176+ require.ErrorIs(t, err, errBoom)
177+ require.Equal(t, domain.MirrorOK, f.statusOf(second).State, "the other repository was still reset")
178+ require.Equal(t, "*/10 * * * *", f.global.Cron, "the policy itself is saved")
179+}
180+
181+func TestMirrorsOverrideWithoutCronRejectedWhenGlobalCronEmpty(t *testing.T) {
182+ f := newMirrorFixture(t)
183+ f.setGlobal(domain.MirrorGlobalConfig{})
184+ _, err := f.m.SetRepoMirror(context.Background(), domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "git@example.com:acme/tools"})
185+ var fe *domain.InvalidFieldsError
186+ require.ErrorAs(t, err, &fe)
187+ require.Equal(t, "cron", fe.Fields[0].Field)
188+ require.Empty(t, f.cfgs, "nothing is stored")
189+}
190+
191+func TestMirrorsGlobalChangeInvalidatingOverrideRejected(t *testing.T) {
192+ f := newMirrorFixture(t)
193+ f.setRepoConfig(domain.MirrorRepoConfig{Repo: f.repo, URL: "git@other.example:x/y"})
194+ // Disabling the global with an empty cron leaves the inheriting override with no cron.
195+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Enabled: ptr(false), Cron: ptr("")})
196+ var fe *domain.InvalidFieldsError
197+ require.ErrorAs(t, err, &fe)
198+ require.True(t, f.global.Enabled, "nothing is stored")
199+}
200+
201+func TestMirrorsGlobalChangeResetsInheritingURLOverride(t *testing.T) {
202+ f := newMirrorFixture(t)
203+ f.setRepoConfig(domain.MirrorRepoConfig{Repo: f.repo, URL: "git@other.example:x/y"})
204+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged})
205+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Cron: ptr("*/10 * * * *")})
206+ require.NoError(t, err)
207+ require.Equal(t, domain.MirrorOK, f.statusOf(f.repo).State)
208+}
209+
210+func TestMirrorsSetRepoExcludedConcurrentIsSerialized(t *testing.T) {
211+ f := newMirrorFixture(t)
212+ var mu sync.Mutex
213+ active, maxActive := 0, 0
214+ enter, leave := make(chan struct{}), make(chan struct{})
215+ f.onPutRepo = func() {
216+ mu.Lock()
217+ active++
218+ maxActive = max(maxActive, active)
219+ mu.Unlock()
220+ enter <- struct{}{}
221+ <-leave
222+ mu.Lock()
223+ active--
224+ mu.Unlock()
225+ }
226+ errs := make(chan error, 4)
227+ for i := range 4 {
228+ go func() {
229+ _, err := f.m.SetRepoExcluded(context.Background(), domain.Root(), f.repo, i%2 == 0)
230+ errs <- err
231+ }()
232+ }
233+ // While one writer is blocked inside the store, the others cannot have entered it.
234+ for range 4 {
235+ <-enter
236+ mu.Lock()
237+ require.Equal(t, 1, active)
238+ mu.Unlock()
239+ leave <- struct{}{}
240+ }
241+ for range 4 {
242+ require.NoError(t, <-errs)
243+ }
244+ require.Equal(t, 1, maxActive, "read-modify-write must be serialized")
245+}
246+
247+func TestMirrorsURLValidatorIsInjectable(t *testing.T) {
248+ for _, tc := range []struct {
249+ name string
250+ validate func(string) error
251+ ok bool
252+ }{
253+ {"default rejects file", nil, false},
254+ {"injected accepts file", func(string) error { return nil }, true},
255+ {"injected rejects", func(string) error { return errors.New("no") }, false},
256+ } {
257+ t.Run(tc.name, func(t *testing.T) {
258+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.ValidateURL = tc.validate })
259+ target, err := f.m.SetRepoMirror(context.Background(), domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: "file:///tmp/remotes/tools", Cron: "*/5 * * * *"})
260+ if tc.ok {
261+ require.NoError(t, err)
262+ require.Equal(t, "file:///tmp/remotes/tools", target.URL)
263+ } else {
264+ require.ErrorIs(t, err, domain.ErrInvalid)
265+ }
266+ })
267+ }
268+}
269+
270+func TestMirrorsNextRunIsComputedForStatusOnly(t *testing.T) {
271+ f := newMirrorFixture(t)
272+ view, err := f.m.GetStatus(context.Background(), domain.Root(), f.repo)
273+ require.NoError(t, err)
274+ require.True(t, view.NextRunAt.Equal(now.Add(8*time.Minute)) || !view.NextRunAt.IsZero())
275+ require.Equal(t, 0, view.NextRunAt.Minute()%5)
276+}
A internal/usecase/mirrors_fixture_test.go +266 -0
@@ -0,0 +1,266 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "context"
7+ "crypto/ed25519"
8+ "sync"
9+ "testing"
10+ "time"
11+
12+ "github.com/stretchr/testify/mock"
13+ "github.com/stretchr/testify/require"
14+
15+ "bnema.dev/ermite/internal/domain"
16+ "bnema.dev/ermite/internal/ports/mocks"
17+ "bnema.dev/ermite/internal/usecase"
18+)
19+
20+// mirrorFixture is a Mirrors use case over in-memory state behind the mocks. Every mock
21+// answers from the fields below under mu, so tests change the world with the setters and
22+// never mutate a mock after construction.
23+type mirrorFixture struct {
24+ m *usecase.Mirrors
25+ push *mocks.MirrorPusher
26+ keys *mocks.MirrorKeyStore
27+ sealer *mocks.SecretSealer
28+ repo domain.RepoName
29+
30+ mu sync.Mutex
31+ at time.Time
32+ global domain.MirrorGlobalConfig
33+ repos []domain.Repo
34+ cfgs map[domain.RepoName]domain.MirrorRepoConfig
35+ status map[domain.RepoName]domain.MirrorStatus
36+ snaps map[domain.RepoName]domain.MirrorSnapshot
37+ refs []domain.Ref
38+ refsErr error
39+ branchErr error
40+ listRefs int
41+ statusPuts int
42+ events []domain.Event
43+ onPutRepo func() // runs inside PutRepoConfig, set before concurrency starts
44+ statusErr map[domain.RepoName]error
45+}
46+
47+func newMirrorFixture(t *testing.T) *mirrorFixture {
48+ return newMirrorFixtureWith(t, nil)
49+}
50+
51+func newMirrorFixtureWith(t *testing.T, tweak func(*usecase.MirrorsConfig)) *mirrorFixture {
52+ t.Helper()
53+ f := &mirrorFixture{
54+ push: mocks.NewMirrorPusher(t), keys: mocks.NewMirrorKeyStore(t), sealer: mocks.NewSecretSealer(t),
55+ at: now, repo: name(t, "tools"),
56+ global: domain.MirrorGlobalConfig{Enabled: true, URLTemplate: "git@example.com:acme/{repo}", Cron: "*/5 * * * *"},
57+ cfgs: map[domain.RepoName]domain.MirrorRepoConfig{}, status: map[domain.RepoName]domain.MirrorStatus{}, snaps: map[domain.RepoName]domain.MirrorSnapshot{}, statusErr: map[domain.RepoName]error{},
58+ refs: []domain.Ref{{Name: "refs/heads/main", ID: mirrorOID(t)}},
59+ }
60+ f.addRepo(f.repo)
61+ store, meta, git, reader, bus, clock := mocks.NewMirrorStore(t), mocks.NewRepoMetaStore(t), mocks.NewGitRepos(t), mocks.NewRepoReader(t), mocks.NewEventBus(t), mocks.NewClock(t)
62+ clock.EXPECT().Now().RunAndReturn(func() time.Time { f.mu.Lock(); defer f.mu.Unlock(); return f.at }).Maybe()
63+ meta.EXPECT().Get(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.Repo, error) {
64+ f.mu.Lock()
65+ defer f.mu.Unlock()
66+ for _, r := range f.repos {
67+ if r.Name == n {
68+ return r, nil
69+ }
70+ }
71+ return domain.Repo{}, domain.ErrNotFound
72+ }).Maybe()
73+ meta.EXPECT().List(mock.Anything).RunAndReturn(func(context.Context) ([]domain.Repo, error) {
74+ f.mu.Lock()
75+ defer f.mu.Unlock()
76+ return append([]domain.Repo(nil), f.repos...), nil
77+ }).Maybe()
78+ store.EXPECT().GetGlobal(mock.Anything).RunAndReturn(func(context.Context) (domain.MirrorGlobalConfig, error) {
79+ f.mu.Lock()
80+ defer f.mu.Unlock()
81+ return f.global, nil
82+ }).Maybe()
83+ store.EXPECT().PutGlobal(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, g domain.MirrorGlobalConfig) error {
84+ f.mu.Lock()
85+ defer f.mu.Unlock()
86+ f.global = g
87+ return nil
88+ }).Maybe()
89+ store.EXPECT().GetRepoConfig(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.MirrorRepoConfig, error) {
90+ f.mu.Lock()
91+ defer f.mu.Unlock()
92+ if c, ok := f.cfgs[n]; ok {
93+ return c, nil
94+ }
95+ return domain.MirrorRepoConfig{}, domain.ErrNotFound
96+ }).Maybe()
97+ store.EXPECT().PutRepoConfig(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, c domain.MirrorRepoConfig) error {
98+ if f.onPutRepo != nil {
99+ f.onPutRepo()
100+ }
101+ f.mu.Lock()
102+ defer f.mu.Unlock()
103+ f.cfgs[c.Repo] = c
104+ return nil
105+ }).Maybe()
106+ store.EXPECT().DeleteRepoConfig(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) error {
107+ f.mu.Lock()
108+ defer f.mu.Unlock()
109+ delete(f.cfgs, n)
110+ return nil
111+ }).Maybe()
112+ store.EXPECT().ListRepoConfigs(mock.Anything).RunAndReturn(func(context.Context) ([]domain.MirrorRepoConfig, error) {
113+ f.mu.Lock()
114+ defer f.mu.Unlock()
115+ var out []domain.MirrorRepoConfig
116+ for _, c := range f.cfgs {
117+ out = append(out, c)
118+ }
119+ return out, nil
120+ }).Maybe()
121+ store.EXPECT().GetStatus(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.MirrorStatus, error) {
122+ f.mu.Lock()
123+ defer f.mu.Unlock()
124+ if s, ok := f.status[n]; ok {
125+ return s, nil
126+ }
127+ return domain.MirrorStatus{}, domain.ErrNotFound
128+ }).Maybe()
129+ store.EXPECT().PutStatus(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, s domain.MirrorStatus) error {
130+ f.mu.Lock()
131+ defer f.mu.Unlock()
132+ if err := f.statusErr[s.Repo]; err != nil {
133+ return err
134+ }
135+ f.status[s.Repo] = s
136+ f.statusPuts++
137+ return nil
138+ }).Maybe()
139+ store.EXPECT().ListStatus(mock.Anything).RunAndReturn(func(context.Context) ([]domain.MirrorStatus, error) {
140+ f.mu.Lock()
141+ defer f.mu.Unlock()
142+ var out []domain.MirrorStatus
143+ for _, s := range f.status {
144+ out = append(out, s)
145+ }
146+ return out, nil
147+ }).Maybe()
148+ store.EXPECT().GetSnapshot(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.MirrorSnapshot, error) {
149+ f.mu.Lock()
150+ defer f.mu.Unlock()
151+ if s, ok := f.snaps[n]; ok {
152+ return s, nil
153+ }
154+ return domain.MirrorSnapshot{}, domain.ErrNotFound
155+ }).Maybe()
156+ store.EXPECT().PutSnapshot(mock.Anything, mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName, s domain.MirrorSnapshot) error {
157+ f.mu.Lock()
158+ defer f.mu.Unlock()
159+ f.snaps[n] = s
160+ return nil
161+ }).Maybe()
162+ reader.EXPECT().ListRefs(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, domain.RepoName) ([]domain.Ref, error) {
163+ f.mu.Lock()
164+ defer f.mu.Unlock()
165+ f.listRefs++
166+ return f.refs, f.refsErr
167+ }).Maybe()
168+ git.EXPECT().DefaultBranch(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, domain.RepoName) (string, bool, error) {
169+ f.mu.Lock()
170+ defer f.mu.Unlock()
171+ return "main", true, f.branchErr
172+ }).Maybe()
173+ bus.EXPECT().Publish(mock.Anything, mock.Anything).Run(func(_ context.Context, ev domain.Event) {
174+ f.mu.Lock()
175+ defer f.mu.Unlock()
176+ f.events = append(f.events, ev)
177+ }).Maybe()
178+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte("sealed"), now, nil).Maybe()
179+ f.sealer.EXPECT().Open([]byte("sealed"), []byte(domain.MirrorKeyPath)).Return(make([]byte, ed25519.SeedSize), nil).Maybe()
180+ cfg := usecase.MirrorsConfig{Store: store, Keys: f.keys, Sealer: f.sealer, Pusher: f.push, Meta: meta, Git: git, Reader: reader, Bus: bus, Clock: clock, ScheduleTick: time.Hour}
181+ if tweak != nil {
182+ tweak(&cfg)
183+ }
184+ f.m = usecase.NewMirrors(cfg)
185+ f.m.Start()
186+ t.Cleanup(func() {
187+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
188+ defer cancel()
189+ f.m.Close(ctx)
190+ })
191+ return f
192+}
193+
194+// addRepo declares a public repository whose mirror starts OK.
195+func (f *mirrorFixture) addRepo(n domain.RepoName) {
196+ f.mu.Lock()
197+ defer f.mu.Unlock()
198+ f.repos = append(f.repos, domain.Repo{Name: n, Visibility: domain.VisibilityPublic, CreatedAt: now})
199+ f.status[n] = domain.MirrorStatus{Repo: n, State: domain.MirrorOK}
200+}
201+
202+func (f *mirrorFixture) advance(d time.Duration) { f.mu.Lock(); f.at = f.at.Add(d); f.mu.Unlock() }
203+func (f *mirrorFixture) setStatus(s domain.MirrorStatus) {
204+ f.mu.Lock()
205+ defer f.mu.Unlock()
206+ f.status[s.Repo] = s
207+}
208+func (f *mirrorFixture) setSnapshot(n domain.RepoName, s domain.MirrorSnapshot) {
209+ f.mu.Lock()
210+ defer f.mu.Unlock()
211+ f.snaps[n] = s
212+}
213+func (f *mirrorFixture) setRepoConfig(c domain.MirrorRepoConfig) {
214+ f.mu.Lock()
215+ defer f.mu.Unlock()
216+ f.cfgs[c.Repo] = c
217+}
218+func (f *mirrorFixture) setGlobal(g domain.MirrorGlobalConfig) {
219+ f.mu.Lock()
220+ defer f.mu.Unlock()
221+ f.global = g
222+}
223+func (f *mirrorFixture) failStatusWrites(n domain.RepoName, err error) {
224+ f.mu.Lock()
225+ defer f.mu.Unlock()
226+ f.statusErr[n] = err
227+}
228+func (f *mirrorFixture) snapshotOf(n domain.RepoName) (domain.MirrorSnapshot, bool) {
229+ f.mu.Lock()
230+ defer f.mu.Unlock()
231+ s, ok := f.snaps[n]
232+ return s, ok
233+}
234+func (f *mirrorFixture) statusOf(n domain.RepoName) domain.MirrorStatus {
235+ f.mu.Lock()
236+ defer f.mu.Unlock()
237+ return f.status[n]
238+}
239+func (f *mirrorFixture) eventList() []domain.Event {
240+ f.mu.Lock()
241+ defer f.mu.Unlock()
242+ return append([]domain.Event(nil), f.events...)
243+}
244+func (f *mirrorFixture) refReads() int { f.mu.Lock(); defer f.mu.Unlock(); return f.listRefs }
245+func (f *mirrorFixture) statusWrites() int {
246+ f.mu.Lock()
247+ defer f.mu.Unlock()
248+ return f.statusPuts
249+}
250+
251+// drain waits until no sync is queued or running: the deterministic barrier before asserting
252+// that something did not happen.
253+func (f *mirrorFixture) drain(t *testing.T) {
254+ t.Helper()
255+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
256+ defer cancel()
257+ f.m.Wait(ctx)
258+ require.NoError(t, ctx.Err(), "syncs did not finish")
259+}
260+
261+func mirrorOID(t *testing.T) domain.ObjectID {
262+ t.Helper()
263+ id, err := domain.ParseObjectID(oidA)
264+ require.NoError(t, err)
265+ return id
266+}
@@ -0,0 +1,266 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "context"
7+ "crypto/ed25519"
8+ "sync"
9+ "testing"
10+ "time"
11+
12+ "github.com/stretchr/testify/mock"
13+ "github.com/stretchr/testify/require"
14+
15+ "bnema.dev/ermite/internal/domain"
16+ "bnema.dev/ermite/internal/ports/mocks"
17+ "bnema.dev/ermite/internal/usecase"
18+)
19+
20+// mirrorFixture is a Mirrors use case over in-memory state behind the mocks. Every mock
21+// answers from the fields below under mu, so tests change the world with the setters and
22+// never mutate a mock after construction.
23+type mirrorFixture struct {
24+ m *usecase.Mirrors
25+ push *mocks.MirrorPusher
26+ keys *mocks.MirrorKeyStore
27+ sealer *mocks.SecretSealer
28+ repo domain.RepoName
29+
30+ mu sync.Mutex
31+ at time.Time
32+ global domain.MirrorGlobalConfig
33+ repos []domain.Repo
34+ cfgs map[domain.RepoName]domain.MirrorRepoConfig
35+ status map[domain.RepoName]domain.MirrorStatus
36+ snaps map[domain.RepoName]domain.MirrorSnapshot
37+ refs []domain.Ref
38+ refsErr error
39+ branchErr error
40+ listRefs int
41+ statusPuts int
42+ events []domain.Event
43+ onPutRepo func() // runs inside PutRepoConfig, set before concurrency starts
44+ statusErr map[domain.RepoName]error
45+}
46+
47+func newMirrorFixture(t *testing.T) *mirrorFixture {
48+ return newMirrorFixtureWith(t, nil)
49+}
50+
51+func newMirrorFixtureWith(t *testing.T, tweak func(*usecase.MirrorsConfig)) *mirrorFixture {
52+ t.Helper()
53+ f := &mirrorFixture{
54+ push: mocks.NewMirrorPusher(t), keys: mocks.NewMirrorKeyStore(t), sealer: mocks.NewSecretSealer(t),
55+ at: now, repo: name(t, "tools"),
56+ global: domain.MirrorGlobalConfig{Enabled: true, URLTemplate: "git@example.com:acme/{repo}", Cron: "*/5 * * * *"},
57+ cfgs: map[domain.RepoName]domain.MirrorRepoConfig{}, status: map[domain.RepoName]domain.MirrorStatus{}, snaps: map[domain.RepoName]domain.MirrorSnapshot{}, statusErr: map[domain.RepoName]error{},
58+ refs: []domain.Ref{{Name: "refs/heads/main", ID: mirrorOID(t)}},
59+ }
60+ f.addRepo(f.repo)
61+ store, meta, git, reader, bus, clock := mocks.NewMirrorStore(t), mocks.NewRepoMetaStore(t), mocks.NewGitRepos(t), mocks.NewRepoReader(t), mocks.NewEventBus(t), mocks.NewClock(t)
62+ clock.EXPECT().Now().RunAndReturn(func() time.Time { f.mu.Lock(); defer f.mu.Unlock(); return f.at }).Maybe()
63+ meta.EXPECT().Get(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.Repo, error) {
64+ f.mu.Lock()
65+ defer f.mu.Unlock()
66+ for _, r := range f.repos {
67+ if r.Name == n {
68+ return r, nil
69+ }
70+ }
71+ return domain.Repo{}, domain.ErrNotFound
72+ }).Maybe()
73+ meta.EXPECT().List(mock.Anything).RunAndReturn(func(context.Context) ([]domain.Repo, error) {
74+ f.mu.Lock()
75+ defer f.mu.Unlock()
76+ return append([]domain.Repo(nil), f.repos...), nil
77+ }).Maybe()
78+ store.EXPECT().GetGlobal(mock.Anything).RunAndReturn(func(context.Context) (domain.MirrorGlobalConfig, error) {
79+ f.mu.Lock()
80+ defer f.mu.Unlock()
81+ return f.global, nil
82+ }).Maybe()
83+ store.EXPECT().PutGlobal(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, g domain.MirrorGlobalConfig) error {
84+ f.mu.Lock()
85+ defer f.mu.Unlock()
86+ f.global = g
87+ return nil
88+ }).Maybe()
89+ store.EXPECT().GetRepoConfig(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.MirrorRepoConfig, error) {
90+ f.mu.Lock()
91+ defer f.mu.Unlock()
92+ if c, ok := f.cfgs[n]; ok {
93+ return c, nil
94+ }
95+ return domain.MirrorRepoConfig{}, domain.ErrNotFound
96+ }).Maybe()
97+ store.EXPECT().PutRepoConfig(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, c domain.MirrorRepoConfig) error {
98+ if f.onPutRepo != nil {
99+ f.onPutRepo()
100+ }
101+ f.mu.Lock()
102+ defer f.mu.Unlock()
103+ f.cfgs[c.Repo] = c
104+ return nil
105+ }).Maybe()
106+ store.EXPECT().DeleteRepoConfig(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) error {
107+ f.mu.Lock()
108+ defer f.mu.Unlock()
109+ delete(f.cfgs, n)
110+ return nil
111+ }).Maybe()
112+ store.EXPECT().ListRepoConfigs(mock.Anything).RunAndReturn(func(context.Context) ([]domain.MirrorRepoConfig, error) {
113+ f.mu.Lock()
114+ defer f.mu.Unlock()
115+ var out []domain.MirrorRepoConfig
116+ for _, c := range f.cfgs {
117+ out = append(out, c)
118+ }
119+ return out, nil
120+ }).Maybe()
121+ store.EXPECT().GetStatus(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.MirrorStatus, error) {
122+ f.mu.Lock()
123+ defer f.mu.Unlock()
124+ if s, ok := f.status[n]; ok {
125+ return s, nil
126+ }
127+ return domain.MirrorStatus{}, domain.ErrNotFound
128+ }).Maybe()
129+ store.EXPECT().PutStatus(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, s domain.MirrorStatus) error {
130+ f.mu.Lock()
131+ defer f.mu.Unlock()
132+ if err := f.statusErr[s.Repo]; err != nil {
133+ return err
134+ }
135+ f.status[s.Repo] = s
136+ f.statusPuts++
137+ return nil
138+ }).Maybe()
139+ store.EXPECT().ListStatus(mock.Anything).RunAndReturn(func(context.Context) ([]domain.MirrorStatus, error) {
140+ f.mu.Lock()
141+ defer f.mu.Unlock()
142+ var out []domain.MirrorStatus
143+ for _, s := range f.status {
144+ out = append(out, s)
145+ }
146+ return out, nil
147+ }).Maybe()
148+ store.EXPECT().GetSnapshot(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName) (domain.MirrorSnapshot, error) {
149+ f.mu.Lock()
150+ defer f.mu.Unlock()
151+ if s, ok := f.snaps[n]; ok {
152+ return s, nil
153+ }
154+ return domain.MirrorSnapshot{}, domain.ErrNotFound
155+ }).Maybe()
156+ store.EXPECT().PutSnapshot(mock.Anything, mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, n domain.RepoName, s domain.MirrorSnapshot) error {
157+ f.mu.Lock()
158+ defer f.mu.Unlock()
159+ f.snaps[n] = s
160+ return nil
161+ }).Maybe()
162+ reader.EXPECT().ListRefs(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, domain.RepoName) ([]domain.Ref, error) {
163+ f.mu.Lock()
164+ defer f.mu.Unlock()
165+ f.listRefs++
166+ return f.refs, f.refsErr
167+ }).Maybe()
168+ git.EXPECT().DefaultBranch(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, domain.RepoName) (string, bool, error) {
169+ f.mu.Lock()
170+ defer f.mu.Unlock()
171+ return "main", true, f.branchErr
172+ }).Maybe()
173+ bus.EXPECT().Publish(mock.Anything, mock.Anything).Run(func(_ context.Context, ev domain.Event) {
174+ f.mu.Lock()
175+ defer f.mu.Unlock()
176+ f.events = append(f.events, ev)
177+ }).Maybe()
178+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte("sealed"), now, nil).Maybe()
179+ f.sealer.EXPECT().Open([]byte("sealed"), []byte(domain.MirrorKeyPath)).Return(make([]byte, ed25519.SeedSize), nil).Maybe()
180+ cfg := usecase.MirrorsConfig{Store: store, Keys: f.keys, Sealer: f.sealer, Pusher: f.push, Meta: meta, Git: git, Reader: reader, Bus: bus, Clock: clock, ScheduleTick: time.Hour}
181+ if tweak != nil {
182+ tweak(&cfg)
183+ }
184+ f.m = usecase.NewMirrors(cfg)
185+ f.m.Start()
186+ t.Cleanup(func() {
187+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
188+ defer cancel()
189+ f.m.Close(ctx)
190+ })
191+ return f
192+}
193+
194+// addRepo declares a public repository whose mirror starts OK.
195+func (f *mirrorFixture) addRepo(n domain.RepoName) {
196+ f.mu.Lock()
197+ defer f.mu.Unlock()
198+ f.repos = append(f.repos, domain.Repo{Name: n, Visibility: domain.VisibilityPublic, CreatedAt: now})
199+ f.status[n] = domain.MirrorStatus{Repo: n, State: domain.MirrorOK}
200+}
201+
202+func (f *mirrorFixture) advance(d time.Duration) { f.mu.Lock(); f.at = f.at.Add(d); f.mu.Unlock() }
203+func (f *mirrorFixture) setStatus(s domain.MirrorStatus) {
204+ f.mu.Lock()
205+ defer f.mu.Unlock()
206+ f.status[s.Repo] = s
207+}
208+func (f *mirrorFixture) setSnapshot(n domain.RepoName, s domain.MirrorSnapshot) {
209+ f.mu.Lock()
210+ defer f.mu.Unlock()
211+ f.snaps[n] = s
212+}
213+func (f *mirrorFixture) setRepoConfig(c domain.MirrorRepoConfig) {
214+ f.mu.Lock()
215+ defer f.mu.Unlock()
216+ f.cfgs[c.Repo] = c
217+}
218+func (f *mirrorFixture) setGlobal(g domain.MirrorGlobalConfig) {
219+ f.mu.Lock()
220+ defer f.mu.Unlock()
221+ f.global = g
222+}
223+func (f *mirrorFixture) failStatusWrites(n domain.RepoName, err error) {
224+ f.mu.Lock()
225+ defer f.mu.Unlock()
226+ f.statusErr[n] = err
227+}
228+func (f *mirrorFixture) snapshotOf(n domain.RepoName) (domain.MirrorSnapshot, bool) {
229+ f.mu.Lock()
230+ defer f.mu.Unlock()
231+ s, ok := f.snaps[n]
232+ return s, ok
233+}
234+func (f *mirrorFixture) statusOf(n domain.RepoName) domain.MirrorStatus {
235+ f.mu.Lock()
236+ defer f.mu.Unlock()
237+ return f.status[n]
238+}
239+func (f *mirrorFixture) eventList() []domain.Event {
240+ f.mu.Lock()
241+ defer f.mu.Unlock()
242+ return append([]domain.Event(nil), f.events...)
243+}
244+func (f *mirrorFixture) refReads() int { f.mu.Lock(); defer f.mu.Unlock(); return f.listRefs }
245+func (f *mirrorFixture) statusWrites() int {
246+ f.mu.Lock()
247+ defer f.mu.Unlock()
248+ return f.statusPuts
249+}
250+
251+// drain waits until no sync is queued or running: the deterministic barrier before asserting
252+// that something did not happen.
253+func (f *mirrorFixture) drain(t *testing.T) {
254+ t.Helper()
255+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
256+ defer cancel()
257+ f.m.Wait(ctx)
258+ require.NoError(t, ctx.Err(), "syncs did not finish")
259+}
260+
261+func mirrorOID(t *testing.T) domain.ObjectID {
262+ t.Helper()
263+ id, err := domain.ParseObjectID(oidA)
264+ require.NoError(t, err)
265+ return id
266+}
A internal/usecase/mirrors_key.go +131 -0
@@ -0,0 +1,131 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "crypto/ed25519"
8+ "crypto/rand"
9+ "errors"
10+ "fmt"
11+ "strings"
12+
13+ "bnema.dev/ermite/internal/domain"
14+ "bnema.dev/ermite/internal/ports"
15+)
16+
17+const noSecretsKeyDetail = "the server has no ERMITE_SECRETS_KEY, so it cannot store the mirror key"
18+
19+// ShowKey lazily generates the server's mirror key for authenticated callers.
20+func (m *Mirrors) ShowKey(ctx context.Context, p domain.Principal) (domain.MirrorPublicKey, error) {
21+ if p.IsAnonymous() {
22+ return domain.MirrorPublicKey{}, domain.ErrUnauthenticated
23+ }
24+ if m.cfg.Sealer == nil {
25+ return domain.MirrorPublicKey{}, fmt.Errorf("%w: %s", domain.ErrPreconditionFailed, noSecretsKeyDetail)
26+ }
27+ m.keyMu.Lock()
28+ defer m.keyMu.Unlock()
29+ if err := m.loadKey(ctx, true); err != nil {
30+ return domain.MirrorPublicKey{}, err
31+ }
32+ return m.publicKeyLocked(), nil
33+}
34+
35+// RotateKey immediately replaces the mirror key and returns the replaced one (zero when there
36+// was none, or when it could not be opened). Remote authorization must be updated separately.
37+func (m *Mirrors) RotateKey(ctx context.Context, p domain.Principal) (ports.MirrorKeyRotation, error) {
38+ if p.IsAnonymous() {
39+ return ports.MirrorKeyRotation{}, domain.ErrUnauthenticated
40+ }
41+ if !p.HasOwnerRights() {
42+ return ports.MirrorKeyRotation{}, domain.ErrForbidden
43+ }
44+ if m.cfg.Sealer == nil {
45+ return ports.MirrorKeyRotation{}, fmt.Errorf("%w: %s", domain.ErrPreconditionFailed, noSecretsKeyDetail)
46+ }
47+ m.keyMu.Lock()
48+ defer m.keyMu.Unlock()
49+ var previous domain.MirrorPublicKey
50+ // A missing key is not created just to be replaced, and a stored key that cannot be read
51+ // or opened must not prevent its replacement.
52+ if err := m.loadKey(ctx, false); err == nil {
53+ previous = m.publicKeyLocked()
54+ }
55+ if err := m.storeNewKey(ctx, false); err != nil {
56+ return ports.MirrorKeyRotation{}, err
57+ }
58+ return ports.MirrorKeyRotation{Key: m.publicKeyLocked(), Previous: previous}, nil
59+}
60+
61+func (m *Mirrors) publicKeyLocked() domain.MirrorPublicKey {
62+ host := strings.TrimPrefix(domain.MirrorKeyComment(m.cfg.PublicURL), "ermite-mirror@")
63+ return domain.MirrorPublicKeyOf(m.key.Public().(ed25519.PublicKey), host, m.keyCreated)
64+}
65+
66+// privateKey returns a copy so a transport cannot mutate the cached key. Failures are
67+// *domain.MirrorError of class internal.
68+func (m *Mirrors) privateKey(ctx context.Context) (ed25519.PrivateKey, error) {
69+ if m.cfg.Sealer == nil {
70+ return nil, &domain.MirrorError{Class: domain.MirrorClassInternal, Detail: noSecretsKeyDetail}
71+ }
72+ m.keyMu.Lock()
73+ defer m.keyMu.Unlock()
74+ if err := m.loadKey(ctx, true); err != nil {
75+ detail := "cannot read the mirror key"
76+ if errors.Is(err, domain.ErrPreconditionFailed) {
77+ detail = err.Error()
78+ }
79+ return nil, &domain.MirrorError{Class: domain.MirrorClassInternal, Detail: detail}
80+ }
81+ return append(ed25519.PrivateKey(nil), m.key...), nil
82+}
83+
84+// loadKey is called with keyMu held and a sealer present: it caches the stored key, creating
85+// one when none exists and create is set (ErrNotFound otherwise).
86+func (m *Mirrors) loadKey(ctx context.Context, create bool) error {
87+ if m.key != nil {
88+ return nil
89+ }
90+ sealed, created, err := m.cfg.Keys.GetMirrorKey(ctx)
91+ if err == nil {
92+ seed, err := m.cfg.Sealer.Open(sealed, []byte(domain.MirrorKeyPath))
93+ if err != nil {
94+ return fmt.Errorf("%w: cannot open the stored mirror key", domain.ErrPreconditionFailed)
95+ }
96+ if len(seed) != ed25519.SeedSize {
97+ return fmt.Errorf("%w: invalid mirror key seed", domain.ErrPreconditionFailed)
98+ }
99+ m.key, m.keyCreated = ed25519.NewKeyFromSeed(seed), created
100+ return nil
101+ }
102+ if !errors.Is(err, domain.ErrNotFound) {
103+ return fmt.Errorf("read mirror key: %w", err)
104+ }
105+ if !create {
106+ return err
107+ }
108+ err = m.storeNewKey(ctx, true)
109+ if errors.Is(err, domain.ErrAlreadyExists) {
110+ return m.loadKey(ctx, true) // another instance created it first
111+ }
112+ return err
113+}
114+
115+// storeNewKey generates, seals and persists a key, caching it only once persisted.
116+func (m *Mirrors) storeNewKey(ctx context.Context, ifAbsent bool) error {
117+ _, key, err := ed25519.GenerateKey(rand.Reader)
118+ if err != nil {
119+ return fmt.Errorf("generate mirror key: %w", err)
120+ }
121+ created := m.cfg.Clock.Now().UTC()
122+ sealed := m.cfg.Sealer.Seal(key.Seed(), []byte(domain.MirrorKeyPath))
123+ if err := m.cfg.Keys.PutMirrorKey(ctx, sealed, created, ifAbsent); err != nil {
124+ if errors.Is(err, domain.ErrAlreadyExists) {
125+ return err
126+ }
127+ return fmt.Errorf("store mirror key: %w", err)
128+ }
129+ m.key, m.keyCreated = key, created
130+ return nil
131+}
@@ -0,0 +1,131 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "crypto/ed25519"
8+ "crypto/rand"
9+ "errors"
10+ "fmt"
11+ "strings"
12+
13+ "bnema.dev/ermite/internal/domain"
14+ "bnema.dev/ermite/internal/ports"
15+)
16+
17+const noSecretsKeyDetail = "the server has no ERMITE_SECRETS_KEY, so it cannot store the mirror key"
18+
19+// ShowKey lazily generates the server's mirror key for authenticated callers.
20+func (m *Mirrors) ShowKey(ctx context.Context, p domain.Principal) (domain.MirrorPublicKey, error) {
21+ if p.IsAnonymous() {
22+ return domain.MirrorPublicKey{}, domain.ErrUnauthenticated
23+ }
24+ if m.cfg.Sealer == nil {
25+ return domain.MirrorPublicKey{}, fmt.Errorf("%w: %s", domain.ErrPreconditionFailed, noSecretsKeyDetail)
26+ }
27+ m.keyMu.Lock()
28+ defer m.keyMu.Unlock()
29+ if err := m.loadKey(ctx, true); err != nil {
30+ return domain.MirrorPublicKey{}, err
31+ }
32+ return m.publicKeyLocked(), nil
33+}
34+
35+// RotateKey immediately replaces the mirror key and returns the replaced one (zero when there
36+// was none, or when it could not be opened). Remote authorization must be updated separately.
37+func (m *Mirrors) RotateKey(ctx context.Context, p domain.Principal) (ports.MirrorKeyRotation, error) {
38+ if p.IsAnonymous() {
39+ return ports.MirrorKeyRotation{}, domain.ErrUnauthenticated
40+ }
41+ if !p.HasOwnerRights() {
42+ return ports.MirrorKeyRotation{}, domain.ErrForbidden
43+ }
44+ if m.cfg.Sealer == nil {
45+ return ports.MirrorKeyRotation{}, fmt.Errorf("%w: %s", domain.ErrPreconditionFailed, noSecretsKeyDetail)
46+ }
47+ m.keyMu.Lock()
48+ defer m.keyMu.Unlock()
49+ var previous domain.MirrorPublicKey
50+ // A missing key is not created just to be replaced, and a stored key that cannot be read
51+ // or opened must not prevent its replacement.
52+ if err := m.loadKey(ctx, false); err == nil {
53+ previous = m.publicKeyLocked()
54+ }
55+ if err := m.storeNewKey(ctx, false); err != nil {
56+ return ports.MirrorKeyRotation{}, err
57+ }
58+ return ports.MirrorKeyRotation{Key: m.publicKeyLocked(), Previous: previous}, nil
59+}
60+
61+func (m *Mirrors) publicKeyLocked() domain.MirrorPublicKey {
62+ host := strings.TrimPrefix(domain.MirrorKeyComment(m.cfg.PublicURL), "ermite-mirror@")
63+ return domain.MirrorPublicKeyOf(m.key.Public().(ed25519.PublicKey), host, m.keyCreated)
64+}
65+
66+// privateKey returns a copy so a transport cannot mutate the cached key. Failures are
67+// *domain.MirrorError of class internal.
68+func (m *Mirrors) privateKey(ctx context.Context) (ed25519.PrivateKey, error) {
69+ if m.cfg.Sealer == nil {
70+ return nil, &domain.MirrorError{Class: domain.MirrorClassInternal, Detail: noSecretsKeyDetail}
71+ }
72+ m.keyMu.Lock()
73+ defer m.keyMu.Unlock()
74+ if err := m.loadKey(ctx, true); err != nil {
75+ detail := "cannot read the mirror key"
76+ if errors.Is(err, domain.ErrPreconditionFailed) {
77+ detail = err.Error()
78+ }
79+ return nil, &domain.MirrorError{Class: domain.MirrorClassInternal, Detail: detail}
80+ }
81+ return append(ed25519.PrivateKey(nil), m.key...), nil
82+}
83+
84+// loadKey is called with keyMu held and a sealer present: it caches the stored key, creating
85+// one when none exists and create is set (ErrNotFound otherwise).
86+func (m *Mirrors) loadKey(ctx context.Context, create bool) error {
87+ if m.key != nil {
88+ return nil
89+ }
90+ sealed, created, err := m.cfg.Keys.GetMirrorKey(ctx)
91+ if err == nil {
92+ seed, err := m.cfg.Sealer.Open(sealed, []byte(domain.MirrorKeyPath))
93+ if err != nil {
94+ return fmt.Errorf("%w: cannot open the stored mirror key", domain.ErrPreconditionFailed)
95+ }
96+ if len(seed) != ed25519.SeedSize {
97+ return fmt.Errorf("%w: invalid mirror key seed", domain.ErrPreconditionFailed)
98+ }
99+ m.key, m.keyCreated = ed25519.NewKeyFromSeed(seed), created
100+ return nil
101+ }
102+ if !errors.Is(err, domain.ErrNotFound) {
103+ return fmt.Errorf("read mirror key: %w", err)
104+ }
105+ if !create {
106+ return err
107+ }
108+ err = m.storeNewKey(ctx, true)
109+ if errors.Is(err, domain.ErrAlreadyExists) {
110+ return m.loadKey(ctx, true) // another instance created it first
111+ }
112+ return err
113+}
114+
115+// storeNewKey generates, seals and persists a key, caching it only once persisted.
116+func (m *Mirrors) storeNewKey(ctx context.Context, ifAbsent bool) error {
117+ _, key, err := ed25519.GenerateKey(rand.Reader)
118+ if err != nil {
119+ return fmt.Errorf("generate mirror key: %w", err)
120+ }
121+ created := m.cfg.Clock.Now().UTC()
122+ sealed := m.cfg.Sealer.Seal(key.Seed(), []byte(domain.MirrorKeyPath))
123+ if err := m.cfg.Keys.PutMirrorKey(ctx, sealed, created, ifAbsent); err != nil {
124+ if errors.Is(err, domain.ErrAlreadyExists) {
125+ return err
126+ }
127+ return fmt.Errorf("store mirror key: %w", err)
128+ }
129+ m.key, m.keyCreated = key, created
130+ return nil
131+}
A internal/usecase/mirrors_key_fixture_test.go +52 -0
@@ -0,0 +1,52 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "errors"
7+ "sync"
8+ "testing"
9+
10+ "github.com/stretchr/testify/mock"
11+
12+ "bnema.dev/ermite/internal/domain"
13+ "bnema.dev/ermite/internal/ports/mocks"
14+ "bnema.dev/ermite/internal/usecase"
15+)
16+
17+// keyFixture is a Mirrors with only the key store, a sealing fake and a clock.
18+type keyFixture struct {
19+ m *usecase.Mirrors
20+ keys *mocks.MirrorKeyStore
21+ sealerOpenFails bool
22+ mu sync.Mutex
23+ sealed [][]byte
24+}
25+
26+func newKeyFixture(t *testing.T) *keyFixture {
27+ t.Helper()
28+ f := &keyFixture{keys: mocks.NewMirrorKeyStore(t)}
29+ sealer, clock := mocks.NewSecretSealer(t), mocks.NewClock(t)
30+ clock.EXPECT().Now().Return(now).Maybe()
31+ sealer.EXPECT().Seal(mock.Anything, []byte(domain.MirrorKeyPath)).RunAndReturn(func(seed, _ []byte) []byte {
32+ f.mu.Lock()
33+ defer f.mu.Unlock()
34+ f.sealed = append(f.sealed, append([]byte(nil), seed...))
35+ return append([]byte("sealed:"), seed...)
36+ }).Maybe()
37+ sealer.EXPECT().Open(mock.Anything, []byte(domain.MirrorKeyPath)).RunAndReturn(func(b, _ []byte) ([]byte, error) {
38+ if f.sealerOpenFails {
39+ return nil, errors.New("cannot open")
40+ }
41+ return b[len("sealed:"):], nil
42+ }).Maybe()
43+ f.m = usecase.NewMirrors(usecase.MirrorsConfig{Keys: f.keys, Sealer: sealer, Clock: clock, PublicURL: "https://forge.example.com"})
44+ return f
45+}
46+
47+// seeds are the seeds generated so far.
48+func (f *keyFixture) seeds() [][]byte {
49+ f.mu.Lock()
50+ defer f.mu.Unlock()
51+ return append([][]byte(nil), f.sealed...)
52+}
@@ -0,0 +1,52 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "errors"
7+ "sync"
8+ "testing"
9+
10+ "github.com/stretchr/testify/mock"
11+
12+ "bnema.dev/ermite/internal/domain"
13+ "bnema.dev/ermite/internal/ports/mocks"
14+ "bnema.dev/ermite/internal/usecase"
15+)
16+
17+// keyFixture is a Mirrors with only the key store, a sealing fake and a clock.
18+type keyFixture struct {
19+ m *usecase.Mirrors
20+ keys *mocks.MirrorKeyStore
21+ sealerOpenFails bool
22+ mu sync.Mutex
23+ sealed [][]byte
24+}
25+
26+func newKeyFixture(t *testing.T) *keyFixture {
27+ t.Helper()
28+ f := &keyFixture{keys: mocks.NewMirrorKeyStore(t)}
29+ sealer, clock := mocks.NewSecretSealer(t), mocks.NewClock(t)
30+ clock.EXPECT().Now().Return(now).Maybe()
31+ sealer.EXPECT().Seal(mock.Anything, []byte(domain.MirrorKeyPath)).RunAndReturn(func(seed, _ []byte) []byte {
32+ f.mu.Lock()
33+ defer f.mu.Unlock()
34+ f.sealed = append(f.sealed, append([]byte(nil), seed...))
35+ return append([]byte("sealed:"), seed...)
36+ }).Maybe()
37+ sealer.EXPECT().Open(mock.Anything, []byte(domain.MirrorKeyPath)).RunAndReturn(func(b, _ []byte) ([]byte, error) {
38+ if f.sealerOpenFails {
39+ return nil, errors.New("cannot open")
40+ }
41+ return b[len("sealed:"):], nil
42+ }).Maybe()
43+ f.m = usecase.NewMirrors(usecase.MirrorsConfig{Keys: f.keys, Sealer: sealer, Clock: clock, PublicURL: "https://forge.example.com"})
44+ return f
45+}
46+
47+// seeds are the seeds generated so far.
48+func (f *keyFixture) seeds() [][]byte {
49+ f.mu.Lock()
50+ defer f.mu.Unlock()
51+ return append([][]byte(nil), f.sealed...)
52+}
A internal/usecase/mirrors_notify_test.go +112 -0
@@ -0,0 +1,112 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "context"
7+ "testing"
8+ "testing/synctest"
9+ "time"
10+
11+ "github.com/stretchr/testify/mock"
12+ "github.com/stretchr/testify/require"
13+
14+ "bnema.dev/ermite/internal/domain"
15+ "bnema.dev/ermite/internal/ports"
16+ "bnema.dev/ermite/internal/ports/mocks"
17+)
18+
19+func TestMirrorsPushRecordNotification(t *testing.T) {
20+ f := newPushFixture(t)
21+ n := name(t, "tools")
22+ trigger := mocks.NewMirrorTrigger(t)
23+ updates := []domain.RefUpdate{}
24+ f.meta.On("Mutate", mock.Anything, n, mock.Anything).Return(domain.Repo{Name: n}, nil)
25+ f.git.On("DefaultBranch", mock.Anything, n).Return("main", true, nil)
26+ f.bus.On("Publish", mock.Anything, mock.Anything).Return()
27+ f.sched.On("Schedule", mock.Anything, n).Return()
28+ trigger.EXPECT().OnPush(mock.Anything, n, updates).Return().Once() // synchronous: verified when Record returns
29+ require.NoError(t, f.pushes.WithMirror(trigger).Record(context.Background(), domain.Root(), n, updates))
30+}
31+
32+func TestMirrorsMergeNotifiesMirror(t *testing.T) {
33+ r := newMRRig(t)
34+ r.seed()
35+ trigger := mocks.NewMirrorTrigger(t)
36+ notified := make(chan []domain.RefUpdate, 1)
37+ trigger.EXPECT().OnPush(mock.Anything, r.repo, mock.Anything).Run(func(_ context.Context, _ domain.RepoName, u []domain.RefUpdate) { notified <- u }).Return().Once()
38+ r.mrs.WithMirror(trigger)
39+ head := r.feature("f0")
40+ mr := r.open("f0")
41+ _, err := r.mrs.Merge(r.ctx, root, r.repo, mr.Number, ports.MergeParams{HeadID: head})
42+ require.NoError(t, err)
43+ r.mrs.Wait(r.ctx)
44+ select {
45+ case u := <-notified:
46+ require.Equal(t, "refs/heads/main", u[0].Ref)
47+ case <-time.After(time.Second):
48+ t.Fatal("merge did not notify mirrors")
49+ }
50+}
51+
52+func TestMirrorsDefaultBranchChangeNotifiesMirror(t *testing.T) {
53+ f := newFixture(t)
54+ ctx := context.Background()
55+ n := name(t, "tools")
56+ repo := domain.Repo{Name: n, Visibility: domain.VisibilityPrivate}
57+ trigger := mocks.NewMirrorTrigger(t)
58+ trigger.EXPECT().OnPush(mock.Anything, n, mock.Anything).Return().Once()
59+ f.repos.WithMirror(trigger)
60+ f.meta.EXPECT().Get(ctx, n).Return(repo, nil)
61+ f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
62+ f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(nil)
63+ f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
64+ _, err := f.repos.Update(ctx, tokenPrincipal(domain.ScopeRepoAdmin, "tools"), n, ports.UpdateRepoParams{DefaultBranch: ptr("dev")})
65+ require.NoError(t, err)
66+}
67+
68+func TestMirrorsExternalMutationMakesNextDueTickSync(t *testing.T) {
69+ f := newMirrorFixture(t)
70+ f.pushes(t, nil)
71+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
72+ require.NoError(t, err)
73+ f.advance(5 * time.Minute)
74+ f.m.ScheduleNow(context.Background())
75+ f.drain(t)
76+ require.Equal(t, 1, f.refReads(), "due and clean: skipped")
77+ f.m.OnPush(context.Background(), f.repo, []domain.RefUpdate{{Ref: "refs/heads/main"}})
78+ f.advance(5 * time.Minute)
79+ f.m.ScheduleNow(context.Background())
80+ f.drain(t)
81+ require.Equal(t, 2, f.refReads(), "dirty repository synced on the next due tick")
82+}
83+
84+func TestMirrorsEventsAreDeliveredByVisibility(t *testing.T) {
85+ synctest.Test(t, func(t *testing.T) {
86+ r := newEventRig(t, 0)
87+ pub := r.repo("pub", domain.VisibilityPublic)
88+ priv := r.repo("priv", domain.VisibilityPrivate)
89+ ctx, cancel := context.WithCancel(context.Background())
90+ defer cancel()
91+ anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
92+ root := r.watch(ctx, domain.Root(), ports.WatchParams{})
93+ synctest.Wait()
94+ for _, n := range []domain.RepoName{priv, pub} {
95+ vis := domain.VisibilityPublic
96+ if n == priv {
97+ vis = domain.VisibilityPrivate
98+ }
99+ r.feed <- domain.MirrorFailed{Repo: n, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, At: now, Visibility: vis, CreatedAt: now}
100+ r.feed <- domain.MirrorRecovered{Repo: n, At: now, Visibility: vis, CreatedAt: now}
101+ }
102+ for _, n := range []domain.RepoName{priv, pub} {
103+ failed := root.next(t).Event.(domain.MirrorFailed)
104+ require.Equal(t, n, failed.Repo)
105+ require.Equal(t, n, root.next(t).Event.(domain.MirrorRecovered).Repo)
106+ }
107+ failed := anon.next(t).Event.(domain.MirrorFailed)
108+ require.Equal(t, pub, failed.Repo, "a private repository's mirror events stay private")
109+ require.Equal(t, pub, anon.next(t).Event.(domain.MirrorRecovered).Repo)
110+ anon.quiet(t, r, pub)
111+ })
112+}
@@ -0,0 +1,112 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "context"
7+ "testing"
8+ "testing/synctest"
9+ "time"
10+
11+ "github.com/stretchr/testify/mock"
12+ "github.com/stretchr/testify/require"
13+
14+ "bnema.dev/ermite/internal/domain"
15+ "bnema.dev/ermite/internal/ports"
16+ "bnema.dev/ermite/internal/ports/mocks"
17+)
18+
19+func TestMirrorsPushRecordNotification(t *testing.T) {
20+ f := newPushFixture(t)
21+ n := name(t, "tools")
22+ trigger := mocks.NewMirrorTrigger(t)
23+ updates := []domain.RefUpdate{}
24+ f.meta.On("Mutate", mock.Anything, n, mock.Anything).Return(domain.Repo{Name: n}, nil)
25+ f.git.On("DefaultBranch", mock.Anything, n).Return("main", true, nil)
26+ f.bus.On("Publish", mock.Anything, mock.Anything).Return()
27+ f.sched.On("Schedule", mock.Anything, n).Return()
28+ trigger.EXPECT().OnPush(mock.Anything, n, updates).Return().Once() // synchronous: verified when Record returns
29+ require.NoError(t, f.pushes.WithMirror(trigger).Record(context.Background(), domain.Root(), n, updates))
30+}
31+
32+func TestMirrorsMergeNotifiesMirror(t *testing.T) {
33+ r := newMRRig(t)
34+ r.seed()
35+ trigger := mocks.NewMirrorTrigger(t)
36+ notified := make(chan []domain.RefUpdate, 1)
37+ trigger.EXPECT().OnPush(mock.Anything, r.repo, mock.Anything).Run(func(_ context.Context, _ domain.RepoName, u []domain.RefUpdate) { notified <- u }).Return().Once()
38+ r.mrs.WithMirror(trigger)
39+ head := r.feature("f0")
40+ mr := r.open("f0")
41+ _, err := r.mrs.Merge(r.ctx, root, r.repo, mr.Number, ports.MergeParams{HeadID: head})
42+ require.NoError(t, err)
43+ r.mrs.Wait(r.ctx)
44+ select {
45+ case u := <-notified:
46+ require.Equal(t, "refs/heads/main", u[0].Ref)
47+ case <-time.After(time.Second):
48+ t.Fatal("merge did not notify mirrors")
49+ }
50+}
51+
52+func TestMirrorsDefaultBranchChangeNotifiesMirror(t *testing.T) {
53+ f := newFixture(t)
54+ ctx := context.Background()
55+ n := name(t, "tools")
56+ repo := domain.Repo{Name: n, Visibility: domain.VisibilityPrivate}
57+ trigger := mocks.NewMirrorTrigger(t)
58+ trigger.EXPECT().OnPush(mock.Anything, n, mock.Anything).Return().Once()
59+ f.repos.WithMirror(trigger)
60+ f.meta.EXPECT().Get(ctx, n).Return(repo, nil)
61+ f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
62+ f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(nil)
63+ f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
64+ _, err := f.repos.Update(ctx, tokenPrincipal(domain.ScopeRepoAdmin, "tools"), n, ports.UpdateRepoParams{DefaultBranch: ptr("dev")})
65+ require.NoError(t, err)
66+}
67+
68+func TestMirrorsExternalMutationMakesNextDueTickSync(t *testing.T) {
69+ f := newMirrorFixture(t)
70+ f.pushes(t, nil)
71+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
72+ require.NoError(t, err)
73+ f.advance(5 * time.Minute)
74+ f.m.ScheduleNow(context.Background())
75+ f.drain(t)
76+ require.Equal(t, 1, f.refReads(), "due and clean: skipped")
77+ f.m.OnPush(context.Background(), f.repo, []domain.RefUpdate{{Ref: "refs/heads/main"}})
78+ f.advance(5 * time.Minute)
79+ f.m.ScheduleNow(context.Background())
80+ f.drain(t)
81+ require.Equal(t, 2, f.refReads(), "dirty repository synced on the next due tick")
82+}
83+
84+func TestMirrorsEventsAreDeliveredByVisibility(t *testing.T) {
85+ synctest.Test(t, func(t *testing.T) {
86+ r := newEventRig(t, 0)
87+ pub := r.repo("pub", domain.VisibilityPublic)
88+ priv := r.repo("priv", domain.VisibilityPrivate)
89+ ctx, cancel := context.WithCancel(context.Background())
90+ defer cancel()
91+ anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
92+ root := r.watch(ctx, domain.Root(), ports.WatchParams{})
93+ synctest.Wait()
94+ for _, n := range []domain.RepoName{priv, pub} {
95+ vis := domain.VisibilityPublic
96+ if n == priv {
97+ vis = domain.VisibilityPrivate
98+ }
99+ r.feed <- domain.MirrorFailed{Repo: n, State: domain.MirrorPaused, Class: domain.MirrorClassDiverged, At: now, Visibility: vis, CreatedAt: now}
100+ r.feed <- domain.MirrorRecovered{Repo: n, At: now, Visibility: vis, CreatedAt: now}
101+ }
102+ for _, n := range []domain.RepoName{priv, pub} {
103+ failed := root.next(t).Event.(domain.MirrorFailed)
104+ require.Equal(t, n, failed.Repo)
105+ require.Equal(t, n, root.next(t).Event.(domain.MirrorRecovered).Repo)
106+ }
107+ failed := anon.next(t).Event.(domain.MirrorFailed)
108+ require.Equal(t, pub, failed.Repo, "a private repository's mirror events stay private")
109+ require.Equal(t, pub, anon.next(t).Event.(domain.MirrorRecovered).Repo)
110+ anon.quiet(t, r, pub)
111+ })
112+}
A internal/usecase/mirrors_schedule.go +154 -0
@@ -0,0 +1,154 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "errors"
8+ "time"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ "github.com/bnema/zerowrap"
12+)
13+
14+// Start starts the bounded worker pool and UTC scheduler exactly once.
15+func (m *Mirrors) Start() {
16+ m.start.Do(func() {
17+ m.mu.Lock()
18+ defer m.mu.Unlock()
19+ if m.closed {
20+ return
21+ }
22+ m.wg.Add(m.cfg.Workers + 1)
23+ for i := 0; i < m.cfg.Workers; i++ {
24+ go func() {
25+ defer m.wg.Done()
26+ for {
27+ select {
28+ case <-m.ctx.Done():
29+ return
30+ case repo := <-m.jobs:
31+ m.run(repo)
32+ }
33+ }
34+ }()
35+ }
36+ go func() {
37+ defer m.wg.Done()
38+ ticker := time.NewTicker(m.cfg.ScheduleTick)
39+ defer ticker.Stop()
40+ for {
41+ select {
42+ case <-m.ctx.Done():
43+ return
44+ case <-ticker.C:
45+ m.ScheduleNow(m.ctx)
46+ }
47+ }
48+ }()
49+ })
50+}
51+
52+// Close cancels workers and waits until they stop or the caller's deadline expires.
53+func (m *Mirrors) Close(ctx context.Context) {
54+ m.mu.Lock()
55+ m.closed = true
56+ m.cancel()
57+ m.mu.Unlock()
58+ done := make(chan struct{})
59+ go func() { m.wg.Wait(); close(done) }()
60+ select {
61+ case <-ctx.Done():
62+ case <-done:
63+ }
64+}
65+
66+// OnPush marks the repository dirty without I/O or waiting for a worker.
67+func (m *Mirrors) OnPush(_ context.Context, repo domain.RepoName, _ []domain.RefUpdate) {
68+ m.mu.Lock()
69+ defer m.mu.Unlock()
70+ if !m.closed {
71+ g := m.gens[repo]
72+ g.dirty++
73+ m.gens[repo] = g
74+ }
75+}
76+
77+// ScheduleNow examines the current minute; missed minutes are not replayed. A repository that
78+// was due but found the queue full is kept and retried on the next calls, so a full queue
79+// delays a sync instead of skipping a period. Workers must be running (Start).
80+func (m *Mirrors) ScheduleNow(ctx context.Context) {
81+ m.scheduleMu.Lock()
82+ defer m.scheduleMu.Unlock()
83+ now := m.cfg.Clock.Now().UTC()
84+ minute := now.Truncate(time.Minute)
85+ newMinute := minute.After(m.lastMinute)
86+ if !newMinute && len(m.deferred) == 0 {
87+ return
88+ }
89+ log := zerowrap.FromCtx(ctx)
90+ repos, err := m.cfg.Meta.List(ctx)
91+ if err != nil {
92+ log.Warn().Err(err).Msg("mirror schedule: cannot list repositories")
93+ return
94+ }
95+ if newMinute {
96+ m.lastMinute = minute
97+ }
98+ live := make(map[domain.RepoName]bool, len(repos))
99+ for _, r := range repos {
100+ if ctx.Err() != nil {
101+ return
102+ }
103+ live[r.Name] = true
104+ _, wasDeferred := m.deferred[r.Name]
105+ if !newMinute && !wasDeferred {
106+ continue
107+ }
108+ delete(m.deferred, r.Name)
109+ t, err := m.target(ctx, r.Name)
110+ if err != nil || !t.Enabled {
111+ continue
112+ }
113+ s, err := m.status(ctx, r.Name)
114+ if err != nil || s.State == domain.MirrorPaused {
115+ continue
116+ }
117+ due := wasDeferred
118+ if !due {
119+ if s.State == domain.MirrorFailing {
120+ due = !now.Before(s.NextRetryAt)
121+ } else {
122+ due = (domain.CronSchedule{Cron: t.Cron, Loc: time.UTC}).Due(minute)
123+ }
124+ }
125+ if !due {
126+ continue
127+ }
128+ m.mu.Lock()
129+ g := m.gens[r.Name]
130+ m.mu.Unlock()
131+ if s.State == domain.MirrorOK && g.cleanKnown && g.clean == g.dirty {
132+ snapshot, e := m.cfg.Store.GetSnapshot(ctx, r.Name)
133+ if e == nil && snapshot.URL == t.URL && snapshot.AllBranches == t.AllBranches {
134+ continue
135+ }
136+ }
137+ if _, _, err := m.enqueue(r.Name, mirrorReq{}); errors.Is(err, domain.ErrResourceExhausted) {
138+ m.deferred[r.Name] = struct{}{}
139+ log.Warn().Str("repo", r.Name.String()).Msg("mirror queue full: sync deferred")
140+ }
141+ }
142+ for repo := range m.deferred {
143+ if !live[repo] {
144+ delete(m.deferred, repo)
145+ }
146+ }
147+ m.mu.Lock()
148+ for repo := range m.gens {
149+ if !live[repo] {
150+ delete(m.gens, repo)
151+ }
152+ }
153+ m.mu.Unlock()
154+}
@@ -0,0 +1,154 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "errors"
8+ "time"
9+
10+ "bnema.dev/ermite/internal/domain"
11+ "github.com/bnema/zerowrap"
12+)
13+
14+// Start starts the bounded worker pool and UTC scheduler exactly once.
15+func (m *Mirrors) Start() {
16+ m.start.Do(func() {
17+ m.mu.Lock()
18+ defer m.mu.Unlock()
19+ if m.closed {
20+ return
21+ }
22+ m.wg.Add(m.cfg.Workers + 1)
23+ for i := 0; i < m.cfg.Workers; i++ {
24+ go func() {
25+ defer m.wg.Done()
26+ for {
27+ select {
28+ case <-m.ctx.Done():
29+ return
30+ case repo := <-m.jobs:
31+ m.run(repo)
32+ }
33+ }
34+ }()
35+ }
36+ go func() {
37+ defer m.wg.Done()
38+ ticker := time.NewTicker(m.cfg.ScheduleTick)
39+ defer ticker.Stop()
40+ for {
41+ select {
42+ case <-m.ctx.Done():
43+ return
44+ case <-ticker.C:
45+ m.ScheduleNow(m.ctx)
46+ }
47+ }
48+ }()
49+ })
50+}
51+
52+// Close cancels workers and waits until they stop or the caller's deadline expires.
53+func (m *Mirrors) Close(ctx context.Context) {
54+ m.mu.Lock()
55+ m.closed = true
56+ m.cancel()
57+ m.mu.Unlock()
58+ done := make(chan struct{})
59+ go func() { m.wg.Wait(); close(done) }()
60+ select {
61+ case <-ctx.Done():
62+ case <-done:
63+ }
64+}
65+
66+// OnPush marks the repository dirty without I/O or waiting for a worker.
67+func (m *Mirrors) OnPush(_ context.Context, repo domain.RepoName, _ []domain.RefUpdate) {
68+ m.mu.Lock()
69+ defer m.mu.Unlock()
70+ if !m.closed {
71+ g := m.gens[repo]
72+ g.dirty++
73+ m.gens[repo] = g
74+ }
75+}
76+
77+// ScheduleNow examines the current minute; missed minutes are not replayed. A repository that
78+// was due but found the queue full is kept and retried on the next calls, so a full queue
79+// delays a sync instead of skipping a period. Workers must be running (Start).
80+func (m *Mirrors) ScheduleNow(ctx context.Context) {
81+ m.scheduleMu.Lock()
82+ defer m.scheduleMu.Unlock()
83+ now := m.cfg.Clock.Now().UTC()
84+ minute := now.Truncate(time.Minute)
85+ newMinute := minute.After(m.lastMinute)
86+ if !newMinute && len(m.deferred) == 0 {
87+ return
88+ }
89+ log := zerowrap.FromCtx(ctx)
90+ repos, err := m.cfg.Meta.List(ctx)
91+ if err != nil {
92+ log.Warn().Err(err).Msg("mirror schedule: cannot list repositories")
93+ return
94+ }
95+ if newMinute {
96+ m.lastMinute = minute
97+ }
98+ live := make(map[domain.RepoName]bool, len(repos))
99+ for _, r := range repos {
100+ if ctx.Err() != nil {
101+ return
102+ }
103+ live[r.Name] = true
104+ _, wasDeferred := m.deferred[r.Name]
105+ if !newMinute && !wasDeferred {
106+ continue
107+ }
108+ delete(m.deferred, r.Name)
109+ t, err := m.target(ctx, r.Name)
110+ if err != nil || !t.Enabled {
111+ continue
112+ }
113+ s, err := m.status(ctx, r.Name)
114+ if err != nil || s.State == domain.MirrorPaused {
115+ continue
116+ }
117+ due := wasDeferred
118+ if !due {
119+ if s.State == domain.MirrorFailing {
120+ due = !now.Before(s.NextRetryAt)
121+ } else {
122+ due = (domain.CronSchedule{Cron: t.Cron, Loc: time.UTC}).Due(minute)
123+ }
124+ }
125+ if !due {
126+ continue
127+ }
128+ m.mu.Lock()
129+ g := m.gens[r.Name]
130+ m.mu.Unlock()
131+ if s.State == domain.MirrorOK && g.cleanKnown && g.clean == g.dirty {
132+ snapshot, e := m.cfg.Store.GetSnapshot(ctx, r.Name)
133+ if e == nil && snapshot.URL == t.URL && snapshot.AllBranches == t.AllBranches {
134+ continue
135+ }
136+ }
137+ if _, _, err := m.enqueue(r.Name, mirrorReq{}); errors.Is(err, domain.ErrResourceExhausted) {
138+ m.deferred[r.Name] = struct{}{}
139+ log.Warn().Str("repo", r.Name.String()).Msg("mirror queue full: sync deferred")
140+ }
141+ }
142+ for repo := range m.deferred {
143+ if !live[repo] {
144+ delete(m.deferred, repo)
145+ }
146+ }
147+ m.mu.Lock()
148+ for repo := range m.gens {
149+ if !live[repo] {
150+ delete(m.gens, repo)
151+ }
152+ }
153+ m.mu.Unlock()
154+}
A internal/usecase/mirrors_sync.go +299 -0
@@ -0,0 +1,299 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "errors"
8+ "fmt"
9+ "time"
10+
11+ "bnema.dev/ermite/internal/domain"
12+ "bnema.dev/ermite/internal/ports"
13+)
14+
15+// mirrorReq is what a sync request asks for. Requests that coalesce merge by OR.
16+type mirrorReq struct{ force, manual bool }
17+
18+func (r mirrorReq) merge(o mirrorReq) mirrorReq {
19+ return mirrorReq{force: r.force || o.force, manual: r.manual || o.manual}
20+}
21+
22+// mirrorFlight is the single in-flight sync of a repository: cur is running, next is the
23+// merged request that arrived meanwhile (one rerun, whatever the number of requests).
24+type mirrorFlight struct {
25+ cur mirrorReq
26+ next *mirrorReq
27+ done chan struct{} // closed with the result of cur's first run
28+ completed bool
29+ result ports.MirrorSyncResult
30+ err error
31+}
32+
33+var (
34+ _ ports.MirrorService = (*Mirrors)(nil)
35+ _ ports.MirrorTrigger = (*Mirrors)(nil)
36+ _ ports.MirrorWarner = (*Mirrors)(nil)
37+)
38+
39+// Sync waits for its own run; overlapping requests coalesce into one sticky rerun.
40+func (m *Mirrors) Sync(ctx context.Context, p domain.Principal, repo domain.RepoName, force bool) (ports.MirrorSyncResult, error) {
41+ if err := m.admin(ctx, p, repo); err != nil {
42+ return ports.MirrorSyncResult{}, err
43+ }
44+ m.Start()
45+ f, queued, err := m.enqueue(repo, mirrorReq{force: force, manual: true})
46+ if err != nil {
47+ return ports.MirrorSyncResult{}, err
48+ }
49+ if queued {
50+ return ports.MirrorSyncResult{Repo: repo, Status: domain.MirrorStatus{Repo: repo}, Queued: true}, nil
51+ }
52+ select {
53+ case <-m.ctx.Done():
54+ return ports.MirrorSyncResult{}, m.ctx.Err()
55+ case <-ctx.Done():
56+ return ports.MirrorSyncResult{}, ctx.Err()
57+ case <-f.done:
58+ f.result.Repo = repo
59+ return f.result, f.err
60+ }
61+}
62+
63+// SyncAll syncs every repository whose mirror is enabled, as an owner. A failing repository
64+// does not stop the others: its outcome carries the error. The returned error is only for
65+// what prevents the whole request (authorization, listing, cancellation).
66+func (m *Mirrors) SyncAll(ctx context.Context, p domain.Principal, force bool) ([]ports.MirrorSyncResult, error) {
67+ if err := mirrorOwner(p); err != nil {
68+ return nil, err
69+ }
70+ repos, err := m.cfg.Meta.List(ctx)
71+ if err != nil {
72+ return nil, err
73+ }
74+ out := make([]ports.MirrorSyncResult, 0, len(repos))
75+ for _, r := range repos {
76+ if err := ctx.Err(); err != nil {
77+ return out, err
78+ }
79+ t, err := m.target(ctx, r.Name)
80+ if err == nil && !t.Enabled {
81+ continue
82+ }
83+ var res ports.MirrorSyncResult
84+ if err == nil {
85+ res, err = m.Sync(ctx, p, r.Name, force)
86+ }
87+ if ctxErr := ctx.Err(); ctxErr != nil {
88+ return out, ctxErr
89+ }
90+ res.Repo = r.Name
91+ if res.Status.Repo == (domain.RepoName{}) {
92+ res.Status.Repo = r.Name
93+ }
94+ res.Err = err
95+ out = append(out, res)
96+ }
97+ return out, nil
98+}
99+
100+// Wait blocks until no sync is queued or running, or ctx is done. It is a test barrier: call it
101+// only while nothing enqueues new syncs and before Close (queued jobs are not drained by Close).
102+func (m *Mirrors) Wait(ctx context.Context) {
103+ done := make(chan struct{})
104+ go func() { m.flightWG.Wait(); close(done) }()
105+ select {
106+ case <-done:
107+ case <-ctx.Done():
108+ }
109+}
110+
111+func (m *Mirrors) enqueue(repo domain.RepoName, req mirrorReq) (*mirrorFlight, bool, error) {
112+ m.mu.Lock()
113+ defer m.mu.Unlock()
114+ if m.closed {
115+ return nil, false, context.Canceled
116+ }
117+ if f := m.flights[repo]; f != nil {
118+ next := req
119+ if f.next != nil {
120+ next = f.next.merge(req)
121+ }
122+ f.next = &next
123+ return f, true, nil
124+ }
125+ f := &mirrorFlight{cur: req, done: make(chan struct{})}
126+ select {
127+ case m.jobs <- repo:
128+ m.flights[repo] = f
129+ m.flightWG.Add(1)
130+ return f, false, nil
131+ default:
132+ return nil, false, domain.ErrResourceExhausted
133+ }
134+}
135+
136+func (m *Mirrors) run(repo domain.RepoName) {
137+ m.mu.Lock()
138+ f := m.flights[repo]
139+ m.mu.Unlock()
140+ for {
141+ result, err := m.attempt(m.ctx, repo, f.cur)
142+ m.mu.Lock()
143+ if !f.completed {
144+ f.result, f.err = result, err
145+ f.completed = true
146+ close(f.done)
147+ }
148+ if f.next == nil || m.closed {
149+ delete(m.flights, repo)
150+ m.flightWG.Done()
151+ m.mu.Unlock()
152+ return
153+ }
154+ f.cur, f.next = *f.next, nil
155+ m.mu.Unlock()
156+ }
157+}
158+
159+// mirrorPlan is what attempt decided under the configuration lock, before pushing.
160+type mirrorPlan struct {
161+ meta domain.Repo
162+ target domain.MirrorTarget
163+ prev domain.MirrorStatus
164+ start time.Time
165+ generation uint64
166+}
167+
168+// plan reads the target and status and applies the skip and throttle rules. When done is set
169+// the attempt ends with result and err.
170+func (m *Mirrors) plan(ctx context.Context, repo domain.RepoName, req mirrorReq) (pl mirrorPlan, result ports.MirrorSyncResult, done bool, err error) {
171+ m.configMu.RLock()
172+ defer m.configMu.RUnlock()
173+ meta, err := m.cfg.Meta.Get(ctx, repo)
174+ if err != nil {
175+ return pl, result, true, err
176+ }
177+ t, err := m.target(ctx, repo)
178+ if err != nil {
179+ return pl, result, true, err
180+ }
181+ prev, err := m.status(ctx, repo)
182+ if err != nil {
183+ return pl, result, true, err
184+ }
185+ now := m.cfg.Clock.Now().UTC()
186+ if !t.Enabled {
187+ s := domain.MirrorDisable(prev, now)
188+ if prev.State != domain.MirrorDisabled {
189+ err = m.cfg.Store.PutStatus(ctx, s)
190+ }
191+ return pl, ports.MirrorSyncResult{Status: s}, true, err
192+ }
193+ if !req.force && (prev.State == domain.MirrorPaused || (!req.manual && prev.State == domain.MirrorFailing && now.Before(prev.NextRetryAt))) {
194+ return pl, ports.MirrorSyncResult{Status: prev}, true, nil
195+ }
196+ if req.manual && !req.force && !prev.LastAttemptAt.IsZero() && now.Sub(prev.LastAttemptAt) < domain.MirrorManualInterval {
197+ return pl, ports.MirrorSyncResult{Status: prev}, true, fmt.Errorf("%w: last sync %s ago; wait %s or use --force", domain.ErrResourceExhausted, now.Sub(prev.LastAttemptAt).Round(time.Second), domain.MirrorManualInterval)
198+ }
199+ m.mu.Lock()
200+ generation := m.gens[repo].dirty
201+ m.mu.Unlock()
202+ return mirrorPlan{meta: meta, target: t, prev: prev, start: now, generation: generation}, result, false, nil
203+}
204+
205+// attempt runs one sync. The configuration lock is held to read and to record, never while
206+// pushing: a slow remote must not block configuration changes.
207+func (m *Mirrors) attempt(ctx context.Context, repo domain.RepoName, req mirrorReq) (ports.MirrorSyncResult, error) {
208+ pl, result, done, err := m.plan(ctx, repo, req)
209+ if done || err != nil {
210+ return result, err
211+ }
212+ t := pl.target
213+ // A missing sealer or an unreadable key fails the attempt before any repository I/O.
214+ key, runErr := m.privateKey(ctx)
215+ var refs []domain.Ref
216+ var selected []domain.MirrorRef
217+ if runErr == nil {
218+ refs, runErr = m.cfg.Reader.ListRefs(ctx, repo)
219+ }
220+ if runErr == nil {
221+ var branch string
222+ branch, _, runErr = m.cfg.Git.DefaultBranch(ctx, repo)
223+ if runErr == nil {
224+ selected = domain.MirrorRefspecs(refs, branch, t.AllBranches)
225+ }
226+ }
227+ noOp := false
228+ if runErr == nil && !req.force {
229+ snapshot, e := m.cfg.Store.GetSnapshot(ctx, repo)
230+ if e != nil && !errors.Is(e, domain.ErrNotFound) {
231+ return ports.MirrorSyncResult{}, e
232+ }
233+ noOp = e == nil && snapshot.Equal(t.URL, selected, t.AllBranches)
234+ }
235+ if runErr == nil && !noOp {
236+ specs := make([]string, len(selected))
237+ for i, ref := range selected {
238+ specs[i] = ref.Name + ":" + ref.Name
239+ }
240+ // An empty ref list must not invoke git's implicit default push behavior.
241+ if len(specs) > 0 {
242+ _, runErr = m.cfg.Pusher.Push(ctx, ports.MirrorPush{Repo: repo, URL: t.URL, Refspecs: specs, PrivateKey: key})
243+ }
244+ }
245+ if ctx.Err() != nil {
246+ return ports.MirrorSyncResult{}, ctx.Err()
247+ }
248+ var failure *domain.MirrorError
249+ if runErr != nil && !errors.As(runErr, &failure) {
250+ failure = &domain.MirrorError{Class: domain.MirrorClassInternal, Detail: "local mirror operation failed"}
251+ runErr = failure
252+ }
253+ return m.record(ctx, repo, pl, selected, noOp, failure, runErr)
254+}
255+
256+// record stores the outcome, unless the effective target changed during the push: the result
257+// then describes a target that no longer applies and is discarded. The comparison includes the
258+// cron on purpose, like resetIfChanged: a schedule change during a push costs one extra push.
259+func (m *Mirrors) record(ctx context.Context, repo domain.RepoName, pl mirrorPlan, selected []domain.MirrorRef, noOp bool, failure *domain.MirrorError, runErr error) (ports.MirrorSyncResult, error) {
260+ m.configMu.RLock()
261+ defer m.configMu.RUnlock()
262+ t, err := m.target(ctx, repo)
263+ if err != nil {
264+ return ports.MirrorSyncResult{}, err
265+ }
266+ if !sameMirrorTarget(pl.target, t) {
267+ s, err := m.status(ctx, repo)
268+ return ports.MirrorSyncResult{Status: s}, err
269+ }
270+ // The push may be slow: completion, retry and success times come from the
271+ // clock after it returns; only LastAttemptAt marks when the attempt began.
272+ now := m.cfg.Clock.Now().UTC()
273+ transition := domain.ApplyMirrorOutcome(pl.prev, domain.MirrorOutcome{Err: failure, NoOp: noOp}, now)
274+ transition.Status.LastAttemptAt = pl.start
275+ if failure == nil {
276+ if err := m.cfg.Store.PutSnapshot(ctx, repo, domain.MirrorSnapshot{URL: t.URL, Refs: selected, AllBranches: t.AllBranches, At: now}); err != nil {
277+ return ports.MirrorSyncResult{}, err
278+ }
279+ }
280+ if err := m.cfg.Store.PutStatus(ctx, transition.Status); err != nil {
281+ return ports.MirrorSyncResult{}, err
282+ }
283+ if failure == nil {
284+ m.mu.Lock()
285+ g := m.gens[repo]
286+ g.clean, g.cleanKnown = pl.generation, true
287+ m.gens[repo] = g
288+ m.mu.Unlock()
289+ }
290+ if m.cfg.Bus != nil {
291+ if transition.FailedEvent {
292+ m.cfg.Bus.Publish(ctx, domain.MirrorFailed{Repo: repo, State: transition.Status.State, Class: transition.Status.Class, At: now, Visibility: pl.meta.Visibility, CreatedAt: pl.meta.CreatedAt})
293+ }
294+ if transition.Recovered {
295+ m.cfg.Bus.Publish(ctx, domain.MirrorRecovered{Repo: repo, At: now, Visibility: pl.meta.Visibility, CreatedAt: pl.meta.CreatedAt})
296+ }
297+ }
298+ return ports.MirrorSyncResult{Status: transition.Status, NoOp: noOp}, runErr
299+}
@@ -0,0 +1,299 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase
4+
5+import (
6+ "context"
7+ "errors"
8+ "fmt"
9+ "time"
10+
11+ "bnema.dev/ermite/internal/domain"
12+ "bnema.dev/ermite/internal/ports"
13+)
14+
15+// mirrorReq is what a sync request asks for. Requests that coalesce merge by OR.
16+type mirrorReq struct{ force, manual bool }
17+
18+func (r mirrorReq) merge(o mirrorReq) mirrorReq {
19+ return mirrorReq{force: r.force || o.force, manual: r.manual || o.manual}
20+}
21+
22+// mirrorFlight is the single in-flight sync of a repository: cur is running, next is the
23+// merged request that arrived meanwhile (one rerun, whatever the number of requests).
24+type mirrorFlight struct {
25+ cur mirrorReq
26+ next *mirrorReq
27+ done chan struct{} // closed with the result of cur's first run
28+ completed bool
29+ result ports.MirrorSyncResult
30+ err error
31+}
32+
33+var (
34+ _ ports.MirrorService = (*Mirrors)(nil)
35+ _ ports.MirrorTrigger = (*Mirrors)(nil)
36+ _ ports.MirrorWarner = (*Mirrors)(nil)
37+)
38+
39+// Sync waits for its own run; overlapping requests coalesce into one sticky rerun.
40+func (m *Mirrors) Sync(ctx context.Context, p domain.Principal, repo domain.RepoName, force bool) (ports.MirrorSyncResult, error) {
41+ if err := m.admin(ctx, p, repo); err != nil {
42+ return ports.MirrorSyncResult{}, err
43+ }
44+ m.Start()
45+ f, queued, err := m.enqueue(repo, mirrorReq{force: force, manual: true})
46+ if err != nil {
47+ return ports.MirrorSyncResult{}, err
48+ }
49+ if queued {
50+ return ports.MirrorSyncResult{Repo: repo, Status: domain.MirrorStatus{Repo: repo}, Queued: true}, nil
51+ }
52+ select {
53+ case <-m.ctx.Done():
54+ return ports.MirrorSyncResult{}, m.ctx.Err()
55+ case <-ctx.Done():
56+ return ports.MirrorSyncResult{}, ctx.Err()
57+ case <-f.done:
58+ f.result.Repo = repo
59+ return f.result, f.err
60+ }
61+}
62+
63+// SyncAll syncs every repository whose mirror is enabled, as an owner. A failing repository
64+// does not stop the others: its outcome carries the error. The returned error is only for
65+// what prevents the whole request (authorization, listing, cancellation).
66+func (m *Mirrors) SyncAll(ctx context.Context, p domain.Principal, force bool) ([]ports.MirrorSyncResult, error) {
67+ if err := mirrorOwner(p); err != nil {
68+ return nil, err
69+ }
70+ repos, err := m.cfg.Meta.List(ctx)
71+ if err != nil {
72+ return nil, err
73+ }
74+ out := make([]ports.MirrorSyncResult, 0, len(repos))
75+ for _, r := range repos {
76+ if err := ctx.Err(); err != nil {
77+ return out, err
78+ }
79+ t, err := m.target(ctx, r.Name)
80+ if err == nil && !t.Enabled {
81+ continue
82+ }
83+ var res ports.MirrorSyncResult
84+ if err == nil {
85+ res, err = m.Sync(ctx, p, r.Name, force)
86+ }
87+ if ctxErr := ctx.Err(); ctxErr != nil {
88+ return out, ctxErr
89+ }
90+ res.Repo = r.Name
91+ if res.Status.Repo == (domain.RepoName{}) {
92+ res.Status.Repo = r.Name
93+ }
94+ res.Err = err
95+ out = append(out, res)
96+ }
97+ return out, nil
98+}
99+
100+// Wait blocks until no sync is queued or running, or ctx is done. It is a test barrier: call it
101+// only while nothing enqueues new syncs and before Close (queued jobs are not drained by Close).
102+func (m *Mirrors) Wait(ctx context.Context) {
103+ done := make(chan struct{})
104+ go func() { m.flightWG.Wait(); close(done) }()
105+ select {
106+ case <-done:
107+ case <-ctx.Done():
108+ }
109+}
110+
111+func (m *Mirrors) enqueue(repo domain.RepoName, req mirrorReq) (*mirrorFlight, bool, error) {
112+ m.mu.Lock()
113+ defer m.mu.Unlock()
114+ if m.closed {
115+ return nil, false, context.Canceled
116+ }
117+ if f := m.flights[repo]; f != nil {
118+ next := req
119+ if f.next != nil {
120+ next = f.next.merge(req)
121+ }
122+ f.next = &next
123+ return f, true, nil
124+ }
125+ f := &mirrorFlight{cur: req, done: make(chan struct{})}
126+ select {
127+ case m.jobs <- repo:
128+ m.flights[repo] = f
129+ m.flightWG.Add(1)
130+ return f, false, nil
131+ default:
132+ return nil, false, domain.ErrResourceExhausted
133+ }
134+}
135+
136+func (m *Mirrors) run(repo domain.RepoName) {
137+ m.mu.Lock()
138+ f := m.flights[repo]
139+ m.mu.Unlock()
140+ for {
141+ result, err := m.attempt(m.ctx, repo, f.cur)
142+ m.mu.Lock()
143+ if !f.completed {
144+ f.result, f.err = result, err
145+ f.completed = true
146+ close(f.done)
147+ }
148+ if f.next == nil || m.closed {
149+ delete(m.flights, repo)
150+ m.flightWG.Done()
151+ m.mu.Unlock()
152+ return
153+ }
154+ f.cur, f.next = *f.next, nil
155+ m.mu.Unlock()
156+ }
157+}
158+
159+// mirrorPlan is what attempt decided under the configuration lock, before pushing.
160+type mirrorPlan struct {
161+ meta domain.Repo
162+ target domain.MirrorTarget
163+ prev domain.MirrorStatus
164+ start time.Time
165+ generation uint64
166+}
167+
168+// plan reads the target and status and applies the skip and throttle rules. When done is set
169+// the attempt ends with result and err.
170+func (m *Mirrors) plan(ctx context.Context, repo domain.RepoName, req mirrorReq) (pl mirrorPlan, result ports.MirrorSyncResult, done bool, err error) {
171+ m.configMu.RLock()
172+ defer m.configMu.RUnlock()
173+ meta, err := m.cfg.Meta.Get(ctx, repo)
174+ if err != nil {
175+ return pl, result, true, err
176+ }
177+ t, err := m.target(ctx, repo)
178+ if err != nil {
179+ return pl, result, true, err
180+ }
181+ prev, err := m.status(ctx, repo)
182+ if err != nil {
183+ return pl, result, true, err
184+ }
185+ now := m.cfg.Clock.Now().UTC()
186+ if !t.Enabled {
187+ s := domain.MirrorDisable(prev, now)
188+ if prev.State != domain.MirrorDisabled {
189+ err = m.cfg.Store.PutStatus(ctx, s)
190+ }
191+ return pl, ports.MirrorSyncResult{Status: s}, true, err
192+ }
193+ if !req.force && (prev.State == domain.MirrorPaused || (!req.manual && prev.State == domain.MirrorFailing && now.Before(prev.NextRetryAt))) {
194+ return pl, ports.MirrorSyncResult{Status: prev}, true, nil
195+ }
196+ if req.manual && !req.force && !prev.LastAttemptAt.IsZero() && now.Sub(prev.LastAttemptAt) < domain.MirrorManualInterval {
197+ return pl, ports.MirrorSyncResult{Status: prev}, true, fmt.Errorf("%w: last sync %s ago; wait %s or use --force", domain.ErrResourceExhausted, now.Sub(prev.LastAttemptAt).Round(time.Second), domain.MirrorManualInterval)
198+ }
199+ m.mu.Lock()
200+ generation := m.gens[repo].dirty
201+ m.mu.Unlock()
202+ return mirrorPlan{meta: meta, target: t, prev: prev, start: now, generation: generation}, result, false, nil
203+}
204+
205+// attempt runs one sync. The configuration lock is held to read and to record, never while
206+// pushing: a slow remote must not block configuration changes.
207+func (m *Mirrors) attempt(ctx context.Context, repo domain.RepoName, req mirrorReq) (ports.MirrorSyncResult, error) {
208+ pl, result, done, err := m.plan(ctx, repo, req)
209+ if done || err != nil {
210+ return result, err
211+ }
212+ t := pl.target
213+ // A missing sealer or an unreadable key fails the attempt before any repository I/O.
214+ key, runErr := m.privateKey(ctx)
215+ var refs []domain.Ref
216+ var selected []domain.MirrorRef
217+ if runErr == nil {
218+ refs, runErr = m.cfg.Reader.ListRefs(ctx, repo)
219+ }
220+ if runErr == nil {
221+ var branch string
222+ branch, _, runErr = m.cfg.Git.DefaultBranch(ctx, repo)
223+ if runErr == nil {
224+ selected = domain.MirrorRefspecs(refs, branch, t.AllBranches)
225+ }
226+ }
227+ noOp := false
228+ if runErr == nil && !req.force {
229+ snapshot, e := m.cfg.Store.GetSnapshot(ctx, repo)
230+ if e != nil && !errors.Is(e, domain.ErrNotFound) {
231+ return ports.MirrorSyncResult{}, e
232+ }
233+ noOp = e == nil && snapshot.Equal(t.URL, selected, t.AllBranches)
234+ }
235+ if runErr == nil && !noOp {
236+ specs := make([]string, len(selected))
237+ for i, ref := range selected {
238+ specs[i] = ref.Name + ":" + ref.Name
239+ }
240+ // An empty ref list must not invoke git's implicit default push behavior.
241+ if len(specs) > 0 {
242+ _, runErr = m.cfg.Pusher.Push(ctx, ports.MirrorPush{Repo: repo, URL: t.URL, Refspecs: specs, PrivateKey: key})
243+ }
244+ }
245+ if ctx.Err() != nil {
246+ return ports.MirrorSyncResult{}, ctx.Err()
247+ }
248+ var failure *domain.MirrorError
249+ if runErr != nil && !errors.As(runErr, &failure) {
250+ failure = &domain.MirrorError{Class: domain.MirrorClassInternal, Detail: "local mirror operation failed"}
251+ runErr = failure
252+ }
253+ return m.record(ctx, repo, pl, selected, noOp, failure, runErr)
254+}
255+
256+// record stores the outcome, unless the effective target changed during the push: the result
257+// then describes a target that no longer applies and is discarded. The comparison includes the
258+// cron on purpose, like resetIfChanged: a schedule change during a push costs one extra push.
259+func (m *Mirrors) record(ctx context.Context, repo domain.RepoName, pl mirrorPlan, selected []domain.MirrorRef, noOp bool, failure *domain.MirrorError, runErr error) (ports.MirrorSyncResult, error) {
260+ m.configMu.RLock()
261+ defer m.configMu.RUnlock()
262+ t, err := m.target(ctx, repo)
263+ if err != nil {
264+ return ports.MirrorSyncResult{}, err
265+ }
266+ if !sameMirrorTarget(pl.target, t) {
267+ s, err := m.status(ctx, repo)
268+ return ports.MirrorSyncResult{Status: s}, err
269+ }
270+ // The push may be slow: completion, retry and success times come from the
271+ // clock after it returns; only LastAttemptAt marks when the attempt began.
272+ now := m.cfg.Clock.Now().UTC()
273+ transition := domain.ApplyMirrorOutcome(pl.prev, domain.MirrorOutcome{Err: failure, NoOp: noOp}, now)
274+ transition.Status.LastAttemptAt = pl.start
275+ if failure == nil {
276+ if err := m.cfg.Store.PutSnapshot(ctx, repo, domain.MirrorSnapshot{URL: t.URL, Refs: selected, AllBranches: t.AllBranches, At: now}); err != nil {
277+ return ports.MirrorSyncResult{}, err
278+ }
279+ }
280+ if err := m.cfg.Store.PutStatus(ctx, transition.Status); err != nil {
281+ return ports.MirrorSyncResult{}, err
282+ }
283+ if failure == nil {
284+ m.mu.Lock()
285+ g := m.gens[repo]
286+ g.clean, g.cleanKnown = pl.generation, true
287+ m.gens[repo] = g
288+ m.mu.Unlock()
289+ }
290+ if m.cfg.Bus != nil {
291+ if transition.FailedEvent {
292+ m.cfg.Bus.Publish(ctx, domain.MirrorFailed{Repo: repo, State: transition.Status.State, Class: transition.Status.Class, At: now, Visibility: pl.meta.Visibility, CreatedAt: pl.meta.CreatedAt})
293+ }
294+ if transition.Recovered {
295+ m.cfg.Bus.Publish(ctx, domain.MirrorRecovered{Repo: repo, At: now, Visibility: pl.meta.Visibility, CreatedAt: pl.meta.CreatedAt})
296+ }
297+ }
298+ return ports.MirrorSyncResult{Status: transition.Status, NoOp: noOp}, runErr
299+}
A internal/usecase/mirrors_sync_test.go +492 -0
@@ -0,0 +1,492 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "bytes"
7+ "context"
8+ "errors"
9+ "strings"
10+ "sync"
11+ "testing"
12+ "time"
13+
14+ "github.com/bnema/zerowrap"
15+ "github.com/stretchr/testify/mock"
16+ "github.com/stretchr/testify/require"
17+
18+ "bnema.dev/ermite/internal/domain"
19+ "bnema.dev/ermite/internal/ports"
20+ "bnema.dev/ermite/internal/usecase"
21+)
22+
23+var errBoom = errors.New("boom")
24+
25+func (f *mirrorFixture) pushes(t *testing.T, result error) *int {
26+ t.Helper()
27+ var mu sync.Mutex
28+ n := new(int)
29+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
30+ mu.Lock()
31+ defer mu.Unlock()
32+ *n++
33+ return ports.MirrorPushResult{}, result
34+ }).Maybe()
35+ return n
36+}
37+
38+func TestMirrorsNoOpThrottleForce(t *testing.T) {
39+ f := newMirrorFixture(t)
40+ f.setSnapshot(f.repo, domain.MirrorSnapshot{URL: "git@example.com:acme/tools", Refs: []domain.MirrorRef{{Name: "refs/heads/main", ID: mirrorOID(t)}}})
41+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
42+ require.NoError(t, err)
43+ require.True(t, v.NoOp)
44+ _, err = f.m.Sync(context.Background(), domain.Root(), f.repo, false)
45+ require.ErrorIs(t, err, domain.ErrResourceExhausted)
46+ require.Contains(t, err.Error(), "wait 1m0s", "the interval comes from the domain constant")
47+ require.Contains(t, err.Error(), "last sync 0s ago")
48+ f.push.EXPECT().Push(mock.Anything, mock.MatchedBy(func(p ports.MirrorPush) bool {
49+ return len(p.Refspecs) == 1 && p.Refspecs[0] == "refs/heads/main:refs/heads/main"
50+ })).Return(ports.MirrorPushResult{}, nil).Once()
51+ v, err = f.m.Sync(context.Background(), domain.Root(), f.repo, true)
52+ require.NoError(t, err)
53+ require.False(t, v.NoOp)
54+}
55+
56+func TestMirrorsIncidentAndRecovery(t *testing.T) {
57+ f := newMirrorFixture(t)
58+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassTransient}).Times(5)
59+ for i := 1; i <= 5; i++ {
60+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
61+ require.Error(t, err)
62+ require.Equal(t, i, v.Status.ConsecutiveFailures)
63+ if i < 5 {
64+ require.Equal(t, domain.MirrorFailing, v.Status.State)
65+ require.Equal(t, domain.MirrorBackoff(i), v.Status.NextRetryAt.Sub(v.Status.LastAttemptAt))
66+ } else {
67+ require.Equal(t, domain.MirrorPaused, v.Status.State)
68+ }
69+ }
70+ events := f.eventList()
71+ require.Len(t, events, 1, "mirror.failed once per incident")
72+ failed, ok := events[0].(domain.MirrorFailed)
73+ require.True(t, ok)
74+ require.Equal(t, domain.MirrorFailing, failed.State)
75+ // A paused mirror is not retried by the schedule.
76+ f.advance(24 * time.Hour)
77+ f.m.ScheduleNow(context.Background())
78+ f.drain(t)
79+ f.push.AssertNumberOfCalls(t, "Push", 5)
80+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, nil).Once()
81+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
82+ require.NoError(t, err)
83+ require.Equal(t, domain.MirrorOK, v.Status.State)
84+ events = f.eventList()
85+ require.Len(t, events, 2)
86+ require.IsType(t, domain.MirrorRecovered{}, events[1])
87+}
88+
89+func TestMirrorsSingleFlight(t *testing.T) {
90+ f := newMirrorFixture(t)
91+ entered, release := make(chan struct{}), make(chan struct{})
92+ var mu sync.Mutex
93+ calls := 0
94+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
95+ mu.Lock()
96+ calls++
97+ first := calls == 1
98+ mu.Unlock()
99+ if first {
100+ close(entered)
101+ <-release
102+ }
103+ return ports.MirrorPushResult{}, nil
104+ })
105+ done := make(chan error, 1)
106+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
107+ <-entered
108+ type outcome struct {
109+ res ports.MirrorSyncResult
110+ err error
111+ }
112+ results := make(chan outcome, 20)
113+ var wg sync.WaitGroup
114+ for range 20 {
115+ wg.Add(1)
116+ go func() {
117+ defer wg.Done()
118+ res, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
119+ results <- outcome{res, err}
120+ }()
121+ }
122+ wg.Wait()
123+ close(results)
124+ for o := range results {
125+ require.NoError(t, o.err)
126+ require.True(t, o.res.Queued)
127+ require.Equal(t, f.repo, o.res.Repo)
128+ }
129+ close(release)
130+ require.NoError(t, <-done)
131+ f.drain(t)
132+ mu.Lock()
133+ defer mu.Unlock()
134+ require.Equal(t, 2, calls, "twenty overlapping requests coalesce into one rerun")
135+}
136+
137+func TestMirrorsCoalescedManualAppliesThrottle(t *testing.T) {
138+ f := newMirrorFixture(t)
139+ entered, release := make(chan struct{}), make(chan struct{})
140+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
141+ close(entered)
142+ <-release
143+ return ports.MirrorPushResult{}, nil
144+ }).Once()
145+ done := make(chan error, 1)
146+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
147+ <-entered
148+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
149+ require.NoError(t, err)
150+ require.True(t, v.Queued)
151+ close(release)
152+ require.NoError(t, <-done)
153+ f.drain(t)
154+ // The rerun is manual and not forced: the throttle (just attempted) stops it, so no second push
155+ // (a second call would fail the Once expectation).
156+ f.push.AssertNumberOfCalls(t, "Push", 1)
157+}
158+
159+func TestMirrorsDivergedPausedAtOnce(t *testing.T) {
160+ f := newMirrorFixture(t)
161+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassDiverged}).Once()
162+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
163+ require.Error(t, err)
164+ require.Equal(t, domain.MirrorPaused, v.Status.State)
165+ for range 3 {
166+ f.advance(time.Hour)
167+ f.m.ScheduleNow(context.Background())
168+ }
169+ f.drain(t)
170+ f.push.AssertNumberOfCalls(t, "Push", 1)
171+ require.Len(t, f.eventList(), 1)
172+}
173+
174+func TestMirrorsCloseCancelsWorker(t *testing.T) {
175+ f := newMirrorFixture(t)
176+ entered, exited := make(chan struct{}), make(chan struct{})
177+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(ctx context.Context, _ ports.MirrorPush) (ports.MirrorPushResult, error) {
178+ close(entered)
179+ <-ctx.Done()
180+ close(exited)
181+ return ports.MirrorPushResult{}, context.Canceled
182+ }).Once()
183+ done := make(chan error, 1)
184+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
185+ <-entered
186+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
187+ defer cancel()
188+ f.m.Close(ctx)
189+ require.NoError(t, ctx.Err())
190+ select {
191+ case <-exited:
192+ default:
193+ t.Fatal("Close returned before worker exited")
194+ }
195+ require.ErrorIs(t, <-done, context.Canceled)
196+ f.m.Close(ctx) // idempotent; Start cannot resurrect workers.
197+ f.m.Start()
198+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
199+ require.ErrorIs(t, err, context.Canceled)
200+}
201+
202+func TestMirrorsCronBackoff(t *testing.T) {
203+ f := newMirrorFixture(t)
204+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassTransient}).Twice()
205+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
206+ require.Error(t, err)
207+ f.advance(time.Minute)
208+ f.m.ScheduleNow(context.Background())
209+ f.drain(t)
210+ f.push.AssertNumberOfCalls(t, "Push", 1)
211+ f.advance(4 * time.Minute)
212+ f.m.ScheduleNow(context.Background())
213+ f.drain(t)
214+ f.push.AssertNumberOfCalls(t, "Push", 2)
215+}
216+
217+func TestMirrorsCronDueAndDirtySkip(t *testing.T) {
218+ f := newMirrorFixture(t)
219+ f.pushes(t, nil)
220+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
221+ require.NoError(t, err)
222+ require.Equal(t, 1, f.refReads())
223+ f.advance(5 * time.Minute)
224+ f.m.ScheduleNow(context.Background()) // due and clean: skipped without reading refs
225+ f.drain(t)
226+ require.Equal(t, 1, f.refReads())
227+ // Merges and default branch changes both end in OnPush: an idempotent dirty mark.
228+ f.m.OnPush(context.Background(), f.repo, []domain.RefUpdate{{Ref: "refs/heads/main"}})
229+ f.m.OnPush(context.Background(), f.repo, []domain.RefUpdate{{Ref: "HEAD"}})
230+ f.m.ScheduleNow(context.Background()) // same minute: nothing runs, although dirty
231+ f.drain(t)
232+ require.Equal(t, 1, f.refReads())
233+ f.advance(5 * time.Minute)
234+ f.m.ScheduleNow(context.Background())
235+ f.drain(t)
236+ require.Equal(t, 2, f.refReads(), "the dirty repository is examined on the next due tick")
237+}
238+
239+func TestMirrorsScheduleKeepsFullQueueRepositoriesForNextTicks(t *testing.T) {
240+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Workers, c.QueueSize = 1, 1 })
241+ repos := []domain.RepoName{f.repo, name(t, "b"), name(t, "c"), name(t, "d")}
242+ for _, r := range repos[1:] {
243+ f.addRepo(r)
244+ }
245+ gate := make(chan struct{})
246+ var mu sync.Mutex
247+ pushed := map[string]int{}
248+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, p ports.MirrorPush) (ports.MirrorPushResult, error) {
249+ <-gate
250+ mu.Lock()
251+ pushed[p.URL]++
252+ mu.Unlock()
253+ return ports.MirrorPushResult{}, nil
254+ })
255+ f.advance(5 * time.Minute)
256+ f.m.ScheduleNow(context.Background())
257+ // The worker holds one repository and the queue one: the other two found it full.
258+ close(gate)
259+ for range 6 { // later ticks of the same minute drain the deferred set
260+ f.drain(t)
261+ f.m.ScheduleNow(context.Background())
262+ }
263+ f.drain(t)
264+ mu.Lock()
265+ defer mu.Unlock()
266+ for _, r := range repos {
267+ require.Equal(t, 1, pushed["git@example.com:acme/"+r.String()], r.String())
268+ }
269+}
270+
271+func TestMirrorsSyncRefusedWhenQueueFull(t *testing.T) {
272+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Workers, c.QueueSize = 1, 1 })
273+ second, third := name(t, "b"), name(t, "c")
274+ f.addRepo(second)
275+ f.addRepo(third)
276+ gate := make(chan struct{})
277+ entered := make(chan struct{}, 8)
278+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
279+ entered <- struct{}{}
280+ <-gate
281+ return ports.MirrorPushResult{}, nil
282+ })
283+ first := make(chan error, 1)
284+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); first <- err }()
285+ <-entered // the single worker is busy
286+ // Enqueueing is synchronous: this request takes the only queue slot, then waits and gives up.
287+ ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
288+ defer cancel()
289+ _, err := f.m.Sync(ctx, domain.Root(), second, true)
290+ require.ErrorIs(t, err, context.DeadlineExceeded)
291+ _, err = f.m.Sync(context.Background(), domain.Root(), third, true)
292+ require.ErrorIs(t, err, domain.ErrResourceExhausted)
293+ close(gate)
294+ require.NoError(t, <-first)
295+ f.drain(t)
296+}
297+
298+func TestMirrorsSlowPushTimestamps(t *testing.T) {
299+ f := newMirrorFixture(t)
300+ start := f.at
301+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
302+ f.advance(10 * time.Minute)
303+ return ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassTransient}
304+ }).Once()
305+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
306+ require.Error(t, err)
307+ require.True(t, v.Status.LastAttemptAt.Equal(start))
308+ require.True(t, v.Status.NextRetryAt.Equal(start.Add(10*time.Minute+domain.MirrorBackoff(1))))
309+}
310+
311+func TestMirrorsPushDoesNotHoldConfigLock(t *testing.T) {
312+ f := newMirrorFixture(t)
313+ entered, release := make(chan struct{}), make(chan struct{})
314+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
315+ close(entered)
316+ <-release
317+ return ports.MirrorPushResult{}, nil
318+ }).Once()
319+ done := make(chan error, 1)
320+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
321+ <-entered
322+ changed := make(chan error, 1)
323+ go func() {
324+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Cron: ptr("*/10 * * * *")})
325+ changed <- err
326+ }()
327+ select {
328+ case err := <-changed:
329+ require.NoError(t, err)
330+ case <-time.After(5 * time.Second): // only on failure: the push holds the configuration lock
331+ t.Fatal("configuration change blocked by a running push")
332+ }
333+ close(release)
334+ require.NoError(t, <-done)
335+}
336+
337+func TestMirrorsResultDiscardedWhenTargetChangedDuringPush(t *testing.T) {
338+ f := newMirrorFixture(t)
339+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorFailing, Class: domain.MirrorClassTransient, ConsecutiveFailures: 1})
340+ entered, release := make(chan struct{}), make(chan struct{})
341+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
342+ close(entered)
343+ <-release
344+ return ports.MirrorPushResult{}, nil
345+ }).Once()
346+ done := make(chan error, 1)
347+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
348+ <-entered
349+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{URLTemplate: ptr("git@other.example:acme/{repo}")})
350+ require.NoError(t, err)
351+ close(release)
352+ require.NoError(t, <-done)
353+ _, ok := f.snapshotOf(f.repo)
354+ require.False(t, ok, "no snapshot for a target that no longer applies")
355+ require.Empty(t, f.eventList(), "no mirror.recovered for the old target")
356+ s := f.statusOf(f.repo)
357+ require.Equal(t, domain.MirrorOK, s.State)
358+ require.True(t, s.LastSuccessAt.IsZero(), "the push result was not recorded")
359+}
360+
361+func TestMirrorsSyncAllContinuesPastFailures(t *testing.T) {
362+ f := newMirrorFixture(t)
363+ bad, off := name(t, "bad"), name(t, "off")
364+ f.addRepo(bad)
365+ f.addRepo(off)
366+ f.setRepoConfig(domain.MirrorRepoConfig{Repo: off, Excluded: true})
367+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, p ports.MirrorPush) (ports.MirrorPushResult, error) {
368+ if strings.HasSuffix(p.URL, "/bad") {
369+ return ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassDiverged, Detail: "rejected"}
370+ }
371+ return ports.MirrorPushResult{}, nil
372+ })
373+ got, err := f.m.SyncAll(context.Background(), domain.Root(), true)
374+ require.NoError(t, err)
375+ require.Len(t, got, 2, "the excluded repository is skipped")
376+ byRepo := map[domain.RepoName]ports.MirrorSyncResult{}
377+ for _, r := range got {
378+ byRepo[r.Repo] = r
379+ }
380+ require.NoError(t, byRepo[f.repo].Err)
381+ require.Equal(t, domain.MirrorOK, byRepo[f.repo].Status.State)
382+ var me *domain.MirrorError
383+ require.ErrorAs(t, byRepo[bad].Err, &me)
384+ require.Equal(t, domain.MirrorPaused, byRepo[bad].Status.State)
385+ _, listed := byRepo[off]
386+ require.False(t, listed)
387+ _, err = f.m.SyncAll(context.Background(), tokenPrincipal(domain.ScopeRepoAdmin), true)
388+ require.ErrorIs(t, err, domain.ErrForbidden)
389+}
390+
391+func TestMirrorsLocalFailuresAreInternalAndNeverPush(t *testing.T) {
392+ for _, tc := range []struct {
393+ name string
394+ set func(*mirrorFixture)
395+ }{
396+ {"ListRefs", func(f *mirrorFixture) { f.mu.Lock(); f.refsErr = errBoom; f.mu.Unlock() }},
397+ {"DefaultBranch", func(f *mirrorFixture) { f.mu.Lock(); f.branchErr = errBoom; f.mu.Unlock() }},
398+ } {
399+ t.Run(tc.name, func(t *testing.T) {
400+ f := newMirrorFixture(t)
401+ tc.set(f)
402+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true) // a Push call would fail the strict mock
403+ var me *domain.MirrorError
404+ require.ErrorAs(t, err, &me)
405+ require.Equal(t, domain.MirrorClassInternal, me.Class)
406+ require.NotContains(t, me.Detail, "boom")
407+ require.Equal(t, domain.MirrorFailing, v.Status.State)
408+ })
409+ }
410+}
411+
412+func TestMirrorsMissingSecretsKeyFailsBeforeReadingRefs(t *testing.T) {
413+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Sealer = nil })
414+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
415+ var me *domain.MirrorError
416+ require.ErrorAs(t, err, &me)
417+ require.Equal(t, domain.MirrorClassInternal, me.Class)
418+ require.Contains(t, me.Detail, "ERMITE_SECRETS_KEY")
419+ require.Equal(t, domain.MirrorFailing, v.Status.State)
420+ require.Zero(t, f.refReads())
421+}
422+
423+func TestMirrorsErrorsAndLogsDoNotExposeSecrets(t *testing.T) {
424+ f := newMirrorFixture(t)
425+ var logs bytes.Buffer
426+ ctx := zerowrap.WithCtx(context.Background(), zerowrap.New(zerowrap.Config{Level: "debug", Format: "json", Output: &logs}))
427+ credentialURL := "ssh://alice:secret-password@example.com/acme/tools"
428+ _, err := f.m.SetRepoMirror(ctx, domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: credentialURL})
429+ require.Error(t, err)
430+ require.NotContains(t, err.Error(), "secret-password")
431+ require.NotContains(t, err.Error(), "alice")
432+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, errors.New("local key PRIVATE-KEY-MARKER ssh://alice:secret-password@example.com/acme/tools")).Once()
433+ _, err = f.m.Sync(ctx, domain.Root(), f.repo, true)
434+ require.Error(t, err)
435+ require.NotContains(t, err.Error(), "PRIVATE-KEY-MARKER")
436+ require.NotContains(t, err.Error(), "secret-password")
437+ require.NotContains(t, logs.String(), "PRIVATE-KEY-MARKER")
438+ require.NotContains(t, logs.String(), "secret-password")
439+}
440+
441+func TestMirrorsKeyLazyGenerationAndRotation(t *testing.T) {
442+ f := newKeyFixture(t)
443+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte(nil), time.Time{}, domain.ErrNotFound).Once()
444+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, true).Return(nil).Once()
445+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, false).Return(nil).Once()
446+ first, err := f.m.ShowKey(context.Background(), domain.Root())
447+ require.NoError(t, err)
448+ cached, err := f.m.ShowKey(context.Background(), domain.Root())
449+ require.NoError(t, err)
450+ require.Equal(t, first, cached)
451+ rotated, err := f.m.RotateKey(context.Background(), domain.Root())
452+ require.NoError(t, err)
453+ require.Equal(t, first.Fingerprint, rotated.Previous.Fingerprint)
454+ require.NotEqual(t, first.Fingerprint, rotated.Key.Fingerprint)
455+ require.Contains(t, rotated.Key.AuthorizedKey, "ermite-mirror@forge.example.com")
456+ require.Len(t, f.seeds(), 2)
457+ require.NotEqual(t, f.seeds()[0], f.seeds()[1])
458+}
459+
460+func TestMirrorsRotateWithoutExistingKeyGeneratesOnce(t *testing.T) {
461+ f := newKeyFixture(t)
462+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte(nil), time.Time{}, domain.ErrNotFound).Once()
463+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, false).Return(nil).Once() // never ifAbsent=true
464+ rotated, err := f.m.RotateKey(context.Background(), domain.Root())
465+ require.NoError(t, err)
466+ require.Empty(t, rotated.Previous.Fingerprint)
467+ require.NotEmpty(t, rotated.Key.Fingerprint)
468+ require.Len(t, f.seeds(), 1, "no throwaway key")
469+}
470+
471+func TestMirrorsRotateReplacesUnreadableKey(t *testing.T) {
472+ f := newKeyFixture(t)
473+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte("garbage"), now, nil).Once()
474+ f.sealerOpenFails = true
475+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, false).Return(nil).Once()
476+ rotated, err := f.m.RotateKey(context.Background(), domain.Root())
477+ require.NoError(t, err)
478+ require.Empty(t, rotated.Previous.Fingerprint)
479+}
480+
481+func TestMirrorsAuthorizationAndMissingSecretsKey(t *testing.T) {
482+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Sealer = nil })
483+ _, err := f.m.ShowKey(context.Background(), domain.Anonymous())
484+ require.ErrorIs(t, err, domain.ErrUnauthenticated)
485+ _, err = f.m.ShowKey(context.Background(), domain.Root())
486+ require.ErrorIs(t, err, domain.ErrPreconditionFailed)
487+ require.Contains(t, err.Error(), "ERMITE_SECRETS_KEY")
488+ _, err = f.m.RotateKey(context.Background(), domain.Root())
489+ require.ErrorIs(t, err, domain.ErrPreconditionFailed)
490+ _, err = f.m.RotateKey(context.Background(), tokenPrincipal(domain.ScopeRepoRead))
491+ require.ErrorIs(t, err, domain.ErrForbidden)
492+}
@@ -0,0 +1,492 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+
3+package usecase_test
4+
5+import (
6+ "bytes"
7+ "context"
8+ "errors"
9+ "strings"
10+ "sync"
11+ "testing"
12+ "time"
13+
14+ "github.com/bnema/zerowrap"
15+ "github.com/stretchr/testify/mock"
16+ "github.com/stretchr/testify/require"
17+
18+ "bnema.dev/ermite/internal/domain"
19+ "bnema.dev/ermite/internal/ports"
20+ "bnema.dev/ermite/internal/usecase"
21+)
22+
23+var errBoom = errors.New("boom")
24+
25+func (f *mirrorFixture) pushes(t *testing.T, result error) *int {
26+ t.Helper()
27+ var mu sync.Mutex
28+ n := new(int)
29+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
30+ mu.Lock()
31+ defer mu.Unlock()
32+ *n++
33+ return ports.MirrorPushResult{}, result
34+ }).Maybe()
35+ return n
36+}
37+
38+func TestMirrorsNoOpThrottleForce(t *testing.T) {
39+ f := newMirrorFixture(t)
40+ f.setSnapshot(f.repo, domain.MirrorSnapshot{URL: "git@example.com:acme/tools", Refs: []domain.MirrorRef{{Name: "refs/heads/main", ID: mirrorOID(t)}}})
41+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
42+ require.NoError(t, err)
43+ require.True(t, v.NoOp)
44+ _, err = f.m.Sync(context.Background(), domain.Root(), f.repo, false)
45+ require.ErrorIs(t, err, domain.ErrResourceExhausted)
46+ require.Contains(t, err.Error(), "wait 1m0s", "the interval comes from the domain constant")
47+ require.Contains(t, err.Error(), "last sync 0s ago")
48+ f.push.EXPECT().Push(mock.Anything, mock.MatchedBy(func(p ports.MirrorPush) bool {
49+ return len(p.Refspecs) == 1 && p.Refspecs[0] == "refs/heads/main:refs/heads/main"
50+ })).Return(ports.MirrorPushResult{}, nil).Once()
51+ v, err = f.m.Sync(context.Background(), domain.Root(), f.repo, true)
52+ require.NoError(t, err)
53+ require.False(t, v.NoOp)
54+}
55+
56+func TestMirrorsIncidentAndRecovery(t *testing.T) {
57+ f := newMirrorFixture(t)
58+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassTransient}).Times(5)
59+ for i := 1; i <= 5; i++ {
60+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
61+ require.Error(t, err)
62+ require.Equal(t, i, v.Status.ConsecutiveFailures)
63+ if i < 5 {
64+ require.Equal(t, domain.MirrorFailing, v.Status.State)
65+ require.Equal(t, domain.MirrorBackoff(i), v.Status.NextRetryAt.Sub(v.Status.LastAttemptAt))
66+ } else {
67+ require.Equal(t, domain.MirrorPaused, v.Status.State)
68+ }
69+ }
70+ events := f.eventList()
71+ require.Len(t, events, 1, "mirror.failed once per incident")
72+ failed, ok := events[0].(domain.MirrorFailed)
73+ require.True(t, ok)
74+ require.Equal(t, domain.MirrorFailing, failed.State)
75+ // A paused mirror is not retried by the schedule.
76+ f.advance(24 * time.Hour)
77+ f.m.ScheduleNow(context.Background())
78+ f.drain(t)
79+ f.push.AssertNumberOfCalls(t, "Push", 5)
80+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, nil).Once()
81+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
82+ require.NoError(t, err)
83+ require.Equal(t, domain.MirrorOK, v.Status.State)
84+ events = f.eventList()
85+ require.Len(t, events, 2)
86+ require.IsType(t, domain.MirrorRecovered{}, events[1])
87+}
88+
89+func TestMirrorsSingleFlight(t *testing.T) {
90+ f := newMirrorFixture(t)
91+ entered, release := make(chan struct{}), make(chan struct{})
92+ var mu sync.Mutex
93+ calls := 0
94+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
95+ mu.Lock()
96+ calls++
97+ first := calls == 1
98+ mu.Unlock()
99+ if first {
100+ close(entered)
101+ <-release
102+ }
103+ return ports.MirrorPushResult{}, nil
104+ })
105+ done := make(chan error, 1)
106+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
107+ <-entered
108+ type outcome struct {
109+ res ports.MirrorSyncResult
110+ err error
111+ }
112+ results := make(chan outcome, 20)
113+ var wg sync.WaitGroup
114+ for range 20 {
115+ wg.Add(1)
116+ go func() {
117+ defer wg.Done()
118+ res, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
119+ results <- outcome{res, err}
120+ }()
121+ }
122+ wg.Wait()
123+ close(results)
124+ for o := range results {
125+ require.NoError(t, o.err)
126+ require.True(t, o.res.Queued)
127+ require.Equal(t, f.repo, o.res.Repo)
128+ }
129+ close(release)
130+ require.NoError(t, <-done)
131+ f.drain(t)
132+ mu.Lock()
133+ defer mu.Unlock()
134+ require.Equal(t, 2, calls, "twenty overlapping requests coalesce into one rerun")
135+}
136+
137+func TestMirrorsCoalescedManualAppliesThrottle(t *testing.T) {
138+ f := newMirrorFixture(t)
139+ entered, release := make(chan struct{}), make(chan struct{})
140+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
141+ close(entered)
142+ <-release
143+ return ports.MirrorPushResult{}, nil
144+ }).Once()
145+ done := make(chan error, 1)
146+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
147+ <-entered
148+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
149+ require.NoError(t, err)
150+ require.True(t, v.Queued)
151+ close(release)
152+ require.NoError(t, <-done)
153+ f.drain(t)
154+ // The rerun is manual and not forced: the throttle (just attempted) stops it, so no second push
155+ // (a second call would fail the Once expectation).
156+ f.push.AssertNumberOfCalls(t, "Push", 1)
157+}
158+
159+func TestMirrorsDivergedPausedAtOnce(t *testing.T) {
160+ f := newMirrorFixture(t)
161+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassDiverged}).Once()
162+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
163+ require.Error(t, err)
164+ require.Equal(t, domain.MirrorPaused, v.Status.State)
165+ for range 3 {
166+ f.advance(time.Hour)
167+ f.m.ScheduleNow(context.Background())
168+ }
169+ f.drain(t)
170+ f.push.AssertNumberOfCalls(t, "Push", 1)
171+ require.Len(t, f.eventList(), 1)
172+}
173+
174+func TestMirrorsCloseCancelsWorker(t *testing.T) {
175+ f := newMirrorFixture(t)
176+ entered, exited := make(chan struct{}), make(chan struct{})
177+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(ctx context.Context, _ ports.MirrorPush) (ports.MirrorPushResult, error) {
178+ close(entered)
179+ <-ctx.Done()
180+ close(exited)
181+ return ports.MirrorPushResult{}, context.Canceled
182+ }).Once()
183+ done := make(chan error, 1)
184+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
185+ <-entered
186+ ctx, cancel := context.WithTimeout(context.Background(), time.Second)
187+ defer cancel()
188+ f.m.Close(ctx)
189+ require.NoError(t, ctx.Err())
190+ select {
191+ case <-exited:
192+ default:
193+ t.Fatal("Close returned before worker exited")
194+ }
195+ require.ErrorIs(t, <-done, context.Canceled)
196+ f.m.Close(ctx) // idempotent; Start cannot resurrect workers.
197+ f.m.Start()
198+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
199+ require.ErrorIs(t, err, context.Canceled)
200+}
201+
202+func TestMirrorsCronBackoff(t *testing.T) {
203+ f := newMirrorFixture(t)
204+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassTransient}).Twice()
205+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, false)
206+ require.Error(t, err)
207+ f.advance(time.Minute)
208+ f.m.ScheduleNow(context.Background())
209+ f.drain(t)
210+ f.push.AssertNumberOfCalls(t, "Push", 1)
211+ f.advance(4 * time.Minute)
212+ f.m.ScheduleNow(context.Background())
213+ f.drain(t)
214+ f.push.AssertNumberOfCalls(t, "Push", 2)
215+}
216+
217+func TestMirrorsCronDueAndDirtySkip(t *testing.T) {
218+ f := newMirrorFixture(t)
219+ f.pushes(t, nil)
220+ _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
221+ require.NoError(t, err)
222+ require.Equal(t, 1, f.refReads())
223+ f.advance(5 * time.Minute)
224+ f.m.ScheduleNow(context.Background()) // due and clean: skipped without reading refs
225+ f.drain(t)
226+ require.Equal(t, 1, f.refReads())
227+ // Merges and default branch changes both end in OnPush: an idempotent dirty mark.
228+ f.m.OnPush(context.Background(), f.repo, []domain.RefUpdate{{Ref: "refs/heads/main"}})
229+ f.m.OnPush(context.Background(), f.repo, []domain.RefUpdate{{Ref: "HEAD"}})
230+ f.m.ScheduleNow(context.Background()) // same minute: nothing runs, although dirty
231+ f.drain(t)
232+ require.Equal(t, 1, f.refReads())
233+ f.advance(5 * time.Minute)
234+ f.m.ScheduleNow(context.Background())
235+ f.drain(t)
236+ require.Equal(t, 2, f.refReads(), "the dirty repository is examined on the next due tick")
237+}
238+
239+func TestMirrorsScheduleKeepsFullQueueRepositoriesForNextTicks(t *testing.T) {
240+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Workers, c.QueueSize = 1, 1 })
241+ repos := []domain.RepoName{f.repo, name(t, "b"), name(t, "c"), name(t, "d")}
242+ for _, r := range repos[1:] {
243+ f.addRepo(r)
244+ }
245+ gate := make(chan struct{})
246+ var mu sync.Mutex
247+ pushed := map[string]int{}
248+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, p ports.MirrorPush) (ports.MirrorPushResult, error) {
249+ <-gate
250+ mu.Lock()
251+ pushed[p.URL]++
252+ mu.Unlock()
253+ return ports.MirrorPushResult{}, nil
254+ })
255+ f.advance(5 * time.Minute)
256+ f.m.ScheduleNow(context.Background())
257+ // The worker holds one repository and the queue one: the other two found it full.
258+ close(gate)
259+ for range 6 { // later ticks of the same minute drain the deferred set
260+ f.drain(t)
261+ f.m.ScheduleNow(context.Background())
262+ }
263+ f.drain(t)
264+ mu.Lock()
265+ defer mu.Unlock()
266+ for _, r := range repos {
267+ require.Equal(t, 1, pushed["git@example.com:acme/"+r.String()], r.String())
268+ }
269+}
270+
271+func TestMirrorsSyncRefusedWhenQueueFull(t *testing.T) {
272+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Workers, c.QueueSize = 1, 1 })
273+ second, third := name(t, "b"), name(t, "c")
274+ f.addRepo(second)
275+ f.addRepo(third)
276+ gate := make(chan struct{})
277+ entered := make(chan struct{}, 8)
278+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
279+ entered <- struct{}{}
280+ <-gate
281+ return ports.MirrorPushResult{}, nil
282+ })
283+ first := make(chan error, 1)
284+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); first <- err }()
285+ <-entered // the single worker is busy
286+ // Enqueueing is synchronous: this request takes the only queue slot, then waits and gives up.
287+ ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
288+ defer cancel()
289+ _, err := f.m.Sync(ctx, domain.Root(), second, true)
290+ require.ErrorIs(t, err, context.DeadlineExceeded)
291+ _, err = f.m.Sync(context.Background(), domain.Root(), third, true)
292+ require.ErrorIs(t, err, domain.ErrResourceExhausted)
293+ close(gate)
294+ require.NoError(t, <-first)
295+ f.drain(t)
296+}
297+
298+func TestMirrorsSlowPushTimestamps(t *testing.T) {
299+ f := newMirrorFixture(t)
300+ start := f.at
301+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
302+ f.advance(10 * time.Minute)
303+ return ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassTransient}
304+ }).Once()
305+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
306+ require.Error(t, err)
307+ require.True(t, v.Status.LastAttemptAt.Equal(start))
308+ require.True(t, v.Status.NextRetryAt.Equal(start.Add(10*time.Minute+domain.MirrorBackoff(1))))
309+}
310+
311+func TestMirrorsPushDoesNotHoldConfigLock(t *testing.T) {
312+ f := newMirrorFixture(t)
313+ entered, release := make(chan struct{}), make(chan struct{})
314+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
315+ close(entered)
316+ <-release
317+ return ports.MirrorPushResult{}, nil
318+ }).Once()
319+ done := make(chan error, 1)
320+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
321+ <-entered
322+ changed := make(chan error, 1)
323+ go func() {
324+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{Cron: ptr("*/10 * * * *")})
325+ changed <- err
326+ }()
327+ select {
328+ case err := <-changed:
329+ require.NoError(t, err)
330+ case <-time.After(5 * time.Second): // only on failure: the push holds the configuration lock
331+ t.Fatal("configuration change blocked by a running push")
332+ }
333+ close(release)
334+ require.NoError(t, <-done)
335+}
336+
337+func TestMirrorsResultDiscardedWhenTargetChangedDuringPush(t *testing.T) {
338+ f := newMirrorFixture(t)
339+ f.setStatus(domain.MirrorStatus{Repo: f.repo, State: domain.MirrorFailing, Class: domain.MirrorClassTransient, ConsecutiveFailures: 1})
340+ entered, release := make(chan struct{}), make(chan struct{})
341+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(context.Context, ports.MirrorPush) (ports.MirrorPushResult, error) {
342+ close(entered)
343+ <-release
344+ return ports.MirrorPushResult{}, nil
345+ }).Once()
346+ done := make(chan error, 1)
347+ go func() { _, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true); done <- err }()
348+ <-entered
349+ _, err := f.m.SetGlobalConfig(context.Background(), domain.Root(), ports.MirrorGlobalPatch{URLTemplate: ptr("git@other.example:acme/{repo}")})
350+ require.NoError(t, err)
351+ close(release)
352+ require.NoError(t, <-done)
353+ _, ok := f.snapshotOf(f.repo)
354+ require.False(t, ok, "no snapshot for a target that no longer applies")
355+ require.Empty(t, f.eventList(), "no mirror.recovered for the old target")
356+ s := f.statusOf(f.repo)
357+ require.Equal(t, domain.MirrorOK, s.State)
358+ require.True(t, s.LastSuccessAt.IsZero(), "the push result was not recorded")
359+}
360+
361+func TestMirrorsSyncAllContinuesPastFailures(t *testing.T) {
362+ f := newMirrorFixture(t)
363+ bad, off := name(t, "bad"), name(t, "off")
364+ f.addRepo(bad)
365+ f.addRepo(off)
366+ f.setRepoConfig(domain.MirrorRepoConfig{Repo: off, Excluded: true})
367+ f.push.EXPECT().Push(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, p ports.MirrorPush) (ports.MirrorPushResult, error) {
368+ if strings.HasSuffix(p.URL, "/bad") {
369+ return ports.MirrorPushResult{}, &domain.MirrorError{Class: domain.MirrorClassDiverged, Detail: "rejected"}
370+ }
371+ return ports.MirrorPushResult{}, nil
372+ })
373+ got, err := f.m.SyncAll(context.Background(), domain.Root(), true)
374+ require.NoError(t, err)
375+ require.Len(t, got, 2, "the excluded repository is skipped")
376+ byRepo := map[domain.RepoName]ports.MirrorSyncResult{}
377+ for _, r := range got {
378+ byRepo[r.Repo] = r
379+ }
380+ require.NoError(t, byRepo[f.repo].Err)
381+ require.Equal(t, domain.MirrorOK, byRepo[f.repo].Status.State)
382+ var me *domain.MirrorError
383+ require.ErrorAs(t, byRepo[bad].Err, &me)
384+ require.Equal(t, domain.MirrorPaused, byRepo[bad].Status.State)
385+ _, listed := byRepo[off]
386+ require.False(t, listed)
387+ _, err = f.m.SyncAll(context.Background(), tokenPrincipal(domain.ScopeRepoAdmin), true)
388+ require.ErrorIs(t, err, domain.ErrForbidden)
389+}
390+
391+func TestMirrorsLocalFailuresAreInternalAndNeverPush(t *testing.T) {
392+ for _, tc := range []struct {
393+ name string
394+ set func(*mirrorFixture)
395+ }{
396+ {"ListRefs", func(f *mirrorFixture) { f.mu.Lock(); f.refsErr = errBoom; f.mu.Unlock() }},
397+ {"DefaultBranch", func(f *mirrorFixture) { f.mu.Lock(); f.branchErr = errBoom; f.mu.Unlock() }},
398+ } {
399+ t.Run(tc.name, func(t *testing.T) {
400+ f := newMirrorFixture(t)
401+ tc.set(f)
402+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true) // a Push call would fail the strict mock
403+ var me *domain.MirrorError
404+ require.ErrorAs(t, err, &me)
405+ require.Equal(t, domain.MirrorClassInternal, me.Class)
406+ require.NotContains(t, me.Detail, "boom")
407+ require.Equal(t, domain.MirrorFailing, v.Status.State)
408+ })
409+ }
410+}
411+
412+func TestMirrorsMissingSecretsKeyFailsBeforeReadingRefs(t *testing.T) {
413+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Sealer = nil })
414+ v, err := f.m.Sync(context.Background(), domain.Root(), f.repo, true)
415+ var me *domain.MirrorError
416+ require.ErrorAs(t, err, &me)
417+ require.Equal(t, domain.MirrorClassInternal, me.Class)
418+ require.Contains(t, me.Detail, "ERMITE_SECRETS_KEY")
419+ require.Equal(t, domain.MirrorFailing, v.Status.State)
420+ require.Zero(t, f.refReads())
421+}
422+
423+func TestMirrorsErrorsAndLogsDoNotExposeSecrets(t *testing.T) {
424+ f := newMirrorFixture(t)
425+ var logs bytes.Buffer
426+ ctx := zerowrap.WithCtx(context.Background(), zerowrap.New(zerowrap.Config{Level: "debug", Format: "json", Output: &logs}))
427+ credentialURL := "ssh://alice:secret-password@example.com/acme/tools"
428+ _, err := f.m.SetRepoMirror(ctx, domain.Root(), domain.MirrorRepoConfig{Repo: f.repo, URL: credentialURL})
429+ require.Error(t, err)
430+ require.NotContains(t, err.Error(), "secret-password")
431+ require.NotContains(t, err.Error(), "alice")
432+ f.push.EXPECT().Push(mock.Anything, mock.Anything).Return(ports.MirrorPushResult{}, errors.New("local key PRIVATE-KEY-MARKER ssh://alice:secret-password@example.com/acme/tools")).Once()
433+ _, err = f.m.Sync(ctx, domain.Root(), f.repo, true)
434+ require.Error(t, err)
435+ require.NotContains(t, err.Error(), "PRIVATE-KEY-MARKER")
436+ require.NotContains(t, err.Error(), "secret-password")
437+ require.NotContains(t, logs.String(), "PRIVATE-KEY-MARKER")
438+ require.NotContains(t, logs.String(), "secret-password")
439+}
440+
441+func TestMirrorsKeyLazyGenerationAndRotation(t *testing.T) {
442+ f := newKeyFixture(t)
443+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte(nil), time.Time{}, domain.ErrNotFound).Once()
444+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, true).Return(nil).Once()
445+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, false).Return(nil).Once()
446+ first, err := f.m.ShowKey(context.Background(), domain.Root())
447+ require.NoError(t, err)
448+ cached, err := f.m.ShowKey(context.Background(), domain.Root())
449+ require.NoError(t, err)
450+ require.Equal(t, first, cached)
451+ rotated, err := f.m.RotateKey(context.Background(), domain.Root())
452+ require.NoError(t, err)
453+ require.Equal(t, first.Fingerprint, rotated.Previous.Fingerprint)
454+ require.NotEqual(t, first.Fingerprint, rotated.Key.Fingerprint)
455+ require.Contains(t, rotated.Key.AuthorizedKey, "ermite-mirror@forge.example.com")
456+ require.Len(t, f.seeds(), 2)
457+ require.NotEqual(t, f.seeds()[0], f.seeds()[1])
458+}
459+
460+func TestMirrorsRotateWithoutExistingKeyGeneratesOnce(t *testing.T) {
461+ f := newKeyFixture(t)
462+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte(nil), time.Time{}, domain.ErrNotFound).Once()
463+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, false).Return(nil).Once() // never ifAbsent=true
464+ rotated, err := f.m.RotateKey(context.Background(), domain.Root())
465+ require.NoError(t, err)
466+ require.Empty(t, rotated.Previous.Fingerprint)
467+ require.NotEmpty(t, rotated.Key.Fingerprint)
468+ require.Len(t, f.seeds(), 1, "no throwaway key")
469+}
470+
471+func TestMirrorsRotateReplacesUnreadableKey(t *testing.T) {
472+ f := newKeyFixture(t)
473+ f.keys.EXPECT().GetMirrorKey(mock.Anything).Return([]byte("garbage"), now, nil).Once()
474+ f.sealerOpenFails = true
475+ f.keys.EXPECT().PutMirrorKey(mock.Anything, mock.Anything, now, false).Return(nil).Once()
476+ rotated, err := f.m.RotateKey(context.Background(), domain.Root())
477+ require.NoError(t, err)
478+ require.Empty(t, rotated.Previous.Fingerprint)
479+}
480+
481+func TestMirrorsAuthorizationAndMissingSecretsKey(t *testing.T) {
482+ f := newMirrorFixtureWith(t, func(c *usecase.MirrorsConfig) { c.Sealer = nil })
483+ _, err := f.m.ShowKey(context.Background(), domain.Anonymous())
484+ require.ErrorIs(t, err, domain.ErrUnauthenticated)
485+ _, err = f.m.ShowKey(context.Background(), domain.Root())
486+ require.ErrorIs(t, err, domain.ErrPreconditionFailed)
487+ require.Contains(t, err.Error(), "ERMITE_SECRETS_KEY")
488+ _, err = f.m.RotateKey(context.Background(), domain.Root())
489+ require.ErrorIs(t, err, domain.ErrPreconditionFailed)
490+ _, err = f.m.RotateKey(context.Background(), tokenPrincipal(domain.ScopeRepoRead))
491+ require.ErrorIs(t, err, domain.ErrForbidden)
492+}
M internal/usecase/pushes.go +10 -0
@@ -17,6 +17,7 @@ import (
1717
1818 // Pushes are the use cases around a Git push.
1919 type Pushes struct {
20+ mirror ports.MirrorTrigger // nil: no outbound mirror
2021 meta ports.RepoMetaStore
2122 repos *Repos
2223 git ports.GitRepos
@@ -43,6 +44,12 @@ func NewPushes(meta ports.RepoMetaStore, repos *Repos, git ports.GitRepos, bus p
4344 return &Pushes{meta: meta, repos: repos, git: git, bus: bus, clock: clock, maint: maint, auth: auth}
4445 }
4546
47+// WithMirror makes Record notify outbound mirrors. Call before the first push.
48+func (u *Pushes) WithMirror(t ports.MirrorTrigger) *Pushes {
49+ u.mirror = t
50+ return u
51+}
52+
4653 // WithFreshener makes Record tell the reader that a repository changed, so that
4754 // it serves the push at once. Call it before the first push; it returns u.
4855 func (u *Pushes) WithFreshener(f ports.RepoFreshener) *Pushes {
@@ -262,6 +269,9 @@ func (u *Pushes) Record(ctx context.Context, p domain.Principal, name domain.Rep
262269 Repo: name, Updates: append([]domain.RefUpdate(nil), updates...), At: now,
263270 Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,
264271 })
272+ if u.mirror != nil {
273+ u.mirror.OnPush(ctx, name, updates) // marks only: never blocks
274+ }
265275 u.maint.Schedule(ctx, name)
266276 log.Info().
267277 Str("repo", name.String()).Int("refs", len(updates)).
@@ -17,6 +17,7 @@ import (
17 17
18 // Pushes are the use cases around a Git push.18 // Pushes are the use cases around a Git push.
19 type Pushes struct {19 type Pushes struct {
20+ mirror ports.MirrorTrigger // nil: no outbound mirror
20 meta ports.RepoMetaStore21 meta ports.RepoMetaStore
21 repos *Repos22 repos *Repos
22 git ports.GitRepos23 git ports.GitRepos
@@ -43,6 +44,12 @@ func NewPushes(meta ports.RepoMetaStore, repos *Repos, git ports.GitRepos, bus p
43 return &Pushes{meta: meta, repos: repos, git: git, bus: bus, clock: clock, maint: maint, auth: auth}44 return &Pushes{meta: meta, repos: repos, git: git, bus: bus, clock: clock, maint: maint, auth: auth}
44 }45 }
45 46
47+// WithMirror makes Record notify outbound mirrors. Call before the first push.
48+func (u *Pushes) WithMirror(t ports.MirrorTrigger) *Pushes {
49+ u.mirror = t
50+ return u
51+}
52+
46 // WithFreshener makes Record tell the reader that a repository changed, so that53 // WithFreshener makes Record tell the reader that a repository changed, so that
47 // it serves the push at once. Call it before the first push; it returns u.54 // it serves the push at once. Call it before the first push; it returns u.
48 func (u *Pushes) WithFreshener(f ports.RepoFreshener) *Pushes {55 func (u *Pushes) WithFreshener(f ports.RepoFreshener) *Pushes {
@@ -262,6 +269,9 @@ func (u *Pushes) Record(ctx context.Context, p domain.Principal, name domain.Rep
262 Repo: name, Updates: append([]domain.RefUpdate(nil), updates...), At: now,269 Repo: name, Updates: append([]domain.RefUpdate(nil), updates...), At: now,
263 Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,270 Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,
264 })271 })
272+ if u.mirror != nil {
273+ u.mirror.OnPush(ctx, name, updates) // marks only: never blocks
274+ }
265 u.maint.Schedule(ctx, name)275 u.maint.Schedule(ctx, name)
266 log.Info().276 log.Info().
267 Str("repo", name.String()).Int("refs", len(updates)).277 Str("repo", name.String()).Int("refs", len(updates)).
M internal/usecase/repos.go +13 -5
@@ -17,11 +17,12 @@ import (
1717
1818 // Repos are the repository use cases.
1919 type Repos struct {
20- meta ports.RepoMetaStore
21- git ports.GitRepos
22- bus ports.EventBus
23- clock ports.Clock
24- ci ports.CIRunCleaner // nil: no CI logs to remove
20+ meta ports.RepoMetaStore
21+ git ports.GitRepos
22+ bus ports.EventBus
23+ clock ports.Clock
24+ ci ports.CIRunCleaner // nil: no CI logs to remove
25+ mirror ports.MirrorTrigger // nil: no outbound mirror
2526 }
2627
2728 var _ ports.RepoService = (*Repos)(nil)
@@ -32,6 +33,13 @@ func NewRepos(meta ports.RepoMetaStore, git ports.GitRepos, bus ports.EventBus,
3233 return &Repos{meta: meta, git: git, bus: bus, clock: clock}
3334 }
3435
36+// WithMirror makes a default-branch change notify outbound mirrors. Call it
37+// before the first request; it returns r.
38+func (r *Repos) WithMirror(t ports.MirrorTrigger) *Repos {
39+ r.mirror = t
40+ return r
41+}
42+
3543 // WithCIRunCleaner makes Delete remove the CI logs of the repository. Call it
3644 // before the first request; it returns r.
3745 func (r *Repos) WithCIRunCleaner(c ports.CIRunCleaner) *Repos {
@@ -17,11 +17,12 @@ import (
17 17
18 // Repos are the repository use cases.18 // Repos are the repository use cases.
19 type Repos struct {19 type Repos struct {
20- meta ports.RepoMetaStore20+ meta ports.RepoMetaStore
21- git ports.GitRepos21+ git ports.GitRepos
22- bus ports.EventBus22+ bus ports.EventBus
23- clock ports.Clock23+ clock ports.Clock
24- ci ports.CIRunCleaner // nil: no CI logs to remove24+ ci ports.CIRunCleaner // nil: no CI logs to remove
25+ mirror ports.MirrorTrigger // nil: no outbound mirror
25 }26 }
26 27
27 var _ ports.RepoService = (*Repos)(nil)28 var _ ports.RepoService = (*Repos)(nil)
@@ -32,6 +33,13 @@ func NewRepos(meta ports.RepoMetaStore, git ports.GitRepos, bus ports.EventBus,
32 return &Repos{meta: meta, git: git, bus: bus, clock: clock}33 return &Repos{meta: meta, git: git, bus: bus, clock: clock}
33 }34 }
34 35
36+// WithMirror makes a default-branch change notify outbound mirrors. Call it
37+// before the first request; it returns r.
38+func (r *Repos) WithMirror(t ports.MirrorTrigger) *Repos {
39+ r.mirror = t
40+ return r
41+}
42+
35 // WithCIRunCleaner makes Delete remove the CI logs of the repository. Call it43 // WithCIRunCleaner makes Delete remove the CI logs of the repository. Call it
36 // before the first request; it returns r.44 // before the first request; it returns r.
37 func (r *Repos) WithCIRunCleaner(c ports.CIRunCleaner) *Repos {45 func (r *Repos) WithCIRunCleaner(c ports.CIRunCleaner) *Repos {
M internal/usecase/repos_write.go +3 -0
@@ -129,6 +129,9 @@ func (r *Repos) Update(ctx context.Context, p domain.Principal, name domain.Repo
129129 if !metaDone {
130130 return domain.Repo{}, headErr
131131 }
132+ } else if r.mirror != nil {
133+ // The default branch decides which refs are mirrored.
134+ r.mirror.OnPush(ctx, name, []domain.RefUpdate{{Ref: "HEAD"}})
132135 }
133136 }
134137
@@ -129,6 +129,9 @@ func (r *Repos) Update(ctx context.Context, p domain.Principal, name domain.Repo
129 if !metaDone {129 if !metaDone {
130 return domain.Repo{}, headErr130 return domain.Repo{}, headErr
131 }131 }
132+ } else if r.mirror != nil {
133+ // The default branch decides which refs are mirrored.
134+ r.mirror.OnPush(ctx, name, []domain.RefUpdate{{Ref: "HEAD"}})
132 }135 }
133 }136 }
134 137
A proto/ermite/storage/mirror.proto +45 -0
@@ -0,0 +1,45 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+syntax = "proto3";
3+package ermite.storage;
4+import "google/protobuf/timestamp.proto";
5+option go_package = "bnema.dev/ermite/gen/ermite/storage;storagepb";
6+message MirrorKey {
7+ bytes sealed = 1;
8+ google.protobuf.Timestamp created_at = 2;
9+}
10+message MirrorGlobal {
11+ bool enabled = 1;
12+ string url_template = 2;
13+ string cron = 3;
14+ bool all_branches = 4;
15+ google.protobuf.Timestamp updated_at = 5;
16+}
17+message MirrorRepo {
18+ string url = 1;
19+ string cron = 2;
20+ optional bool all_branches = 3;
21+ bool excluded = 4;
22+ google.protobuf.Timestamp updated_at = 5;
23+}
24+message MirrorState {
25+ string state = 1;
26+ string class = 2;
27+ string reason = 3;
28+ string detail = 4;
29+ int32 consecutive_failures = 5;
30+ google.protobuf.Timestamp last_attempt_at = 6;
31+ google.protobuf.Timestamp last_success_at = 7;
32+ google.protobuf.Timestamp next_retry_at = 8;
33+ google.protobuf.Timestamp paused_at = 9;
34+ google.protobuf.Timestamp updated_at = 10;
35+}
36+message MirrorSnapshotRef {
37+ string name = 1;
38+ string id = 2;
39+}
40+message MirrorSnapshot {
41+ string url = 1;
42+ repeated MirrorSnapshotRef refs = 2;
43+ bool all_branches = 3;
44+ google.protobuf.Timestamp at = 4;
45+}
@@ -0,0 +1,45 @@
1+// SPDX-License-Identifier: AGPL-3.0-or-later
2+syntax = "proto3";
3+package ermite.storage;
4+import "google/protobuf/timestamp.proto";
5+option go_package = "bnema.dev/ermite/gen/ermite/storage;storagepb";
6+message MirrorKey {
7+ bytes sealed = 1;
8+ google.protobuf.Timestamp created_at = 2;
9+}
10+message MirrorGlobal {
11+ bool enabled = 1;
12+ string url_template = 2;
13+ string cron = 3;
14+ bool all_branches = 4;
15+ google.protobuf.Timestamp updated_at = 5;
16+}
17+message MirrorRepo {
18+ string url = 1;
19+ string cron = 2;
20+ optional bool all_branches = 3;
21+ bool excluded = 4;
22+ google.protobuf.Timestamp updated_at = 5;
23+}
24+message MirrorState {
25+ string state = 1;
26+ string class = 2;
27+ string reason = 3;
28+ string detail = 4;
29+ int32 consecutive_failures = 5;
30+ google.protobuf.Timestamp last_attempt_at = 6;
31+ google.protobuf.Timestamp last_success_at = 7;
32+ google.protobuf.Timestamp next_retry_at = 8;
33+ google.protobuf.Timestamp paused_at = 9;
34+ google.protobuf.Timestamp updated_at = 10;
35+}
36+message MirrorSnapshotRef {
37+ string name = 1;
38+ string id = 2;
39+}
40+message MirrorSnapshot {
41+ string url = 1;
42+ repeated MirrorSnapshotRef refs = 2;
43+ bool all_branches = 3;
44+ google.protobuf.Timestamp at = 4;
45+}

Comments0 open / 0

no comments yet.

Keyboard shortcuts

Single-key shortcuts are on. ctrl k and esc work whatever this says.

ctrl k :
go to a section, branch, tag, file or repository
?
this list
j k
move the row cursor down / up
enter
open the row under the cursor; on Files, a directory opens or closes in place
↑ ↓ ← → home end
in the file tree (focus on a row): previous / next row, close / open a directory or go to its parent / first entry, first / last row. They never open a file
l h
on Files: open a directory or a file / close a directory or go up to its parent, then to the parent page. Elsewhere: into the side panel (on a merge request, its files) / back to the content; there j k move between its controls
g g G
first / last row
/
filter the list; on Files, find a file anywhere in the repository (esc clears, enter opens the best match)
b
switch branch or tag
g s g f g c g b g m g i g r g a
tabs: summary, files, commits, branches & tags, merge requests, issues, releases, actions (when available)
g h
home
w
wide mode: use the whole width of the screen, or not (remembered)
y
copy a permalink pinned to the commit
d u x
diff: split / unified / collapse or expand all
e E
diff: the whole file in view / every file, with the lines the hunks hide
n
merge request: next note in the diff
l
merge request: the list of files (j k move, enter opens, esc back)
M
merge request: the merge menu; there 1–3 pick the mode, D deletes the branch, enter merges
R
merge request: mark the head read
esc
close a dialog, leave a field

Branches 2

Tags 44

↑↓ moveenter openesc close