BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / mirror / progress.go

progress.go

progress.go 3.3 KiB Download Raw
1package mirror
2
3import (
4 "encoding/json"
5 "errors"
6 "os"
7 "path/filepath"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
11)
12
13// Progress is het deel van de BlueGit-dataset (database, repositories,
14// releases, artifacts, avatars, enz.) dat deze kopie al bij heeft en dat
15// overeenkomt met het laatste manifest. De teller is in bytes, zodat een
16// groot repository zwaarder weegt dan een klein bestand. Als de hele set
17// 0 bytes is (of leeg), telt het aantal bestanden; 0/0 is 100%.
18type Progress struct {
19 Known bool `json:"known"`
20 Percent int `json:"percent"`
21 Syncing bool `json:"syncing,omitempty"`
22 DoneBytes int64 `json:"done_bytes"`
23 TotalBytes int64 `json:"total_bytes"`
24 DoneFiles int `json:"done_files"`
25 TotalFiles int `json:"total_files"`
26 UpdatedAt time.Time `json:"updated_at,omitempty"`
27}
28
29// ComputeProgress vergelijkt de index met de bestanden uit een manifest.
30// files == nil betekent: nog geen manifest, voortgang onbekend.
31func ComputeProgress(idx map[string]protocol.Entry, files []protocol.Entry) Progress {
32 if files == nil {
33 return Progress{}
34 }
35 if idx == nil {
36 idx = map[string]protocol.Entry{}
37 }
38 p := Progress{Known: true, TotalFiles: len(files), UpdatedAt: time.Now().UTC()}
39 for _, e := range files {
40 logical, ok := protocol.CleanLogical(e.Path)
41 if !ok {
42 p.TotalFiles--
43 continue
44 }
45 p.TotalBytes += e.Size
46 if old, ok := idx[logical]; ok && same(old, e) {
47 p.DoneFiles++
48 p.DoneBytes += e.Size
49 }
50 }
51 switch {
52 case p.TotalFiles == 0:
53 p.Percent = 100
54 case p.DoneFiles == p.TotalFiles:
55 p.Percent = 100
56 case p.TotalBytes > 0:
57 p.Percent = int(p.DoneBytes * 100 / p.TotalBytes)
58 if p.Percent >= 100 {
59 // Nog ontbrekende lege bestanden: nooit 100% tot alles er is.
60 p.Percent = 99
61 }
62 default:
63 p.Percent = p.DoneFiles * 100 / p.TotalFiles
64 }
65 if p.Percent < 0 {
66 p.Percent = 0
67 }
68 return p
69}
70
71func (m *Mirror) manifestPath() string {
72 return filepath.Join(filepath.Dir(m.Index), "last-manifest.json")
73}
74
75// SaveManifest bewaart het laatste manifest, zodat de voortgang tussen
76// syncs en na een herstart bekend blijft.
77func (m *Mirror) SaveManifest(man protocol.Manifest) error {
78 b, err := json.Marshal(man)
79 if err != nil {
80 return err
81 }
82 tmp := m.manifestPath() + ".tmp"
83 if err := os.WriteFile(tmp, b, 0o600); err != nil {
84 return err
85 }
86 return os.Rename(tmp, m.manifestPath())
87}
88
89// LoadManifest leest het laatste manifest. ok is false als het ontbreekt.
90func (m *Mirror) LoadManifest() (protocol.Manifest, bool, error) {
91 var man protocol.Manifest
92 b, err := os.ReadFile(m.manifestPath())
93 if errors.Is(err, os.ErrNotExist) {
94 return man, false, nil
95 }
96 if err != nil {
97 return man, false, err
98 }
99 if err := json.Unmarshal(b, &man); err != nil {
100 return man, false, err
101 }
102 return man, true, nil
103}
104
105// CurrentProgress berekent de voortgang uit de index en het laatste manifest.
106func (m *Mirror) CurrentProgress() Progress {
107 man, ok, err := m.LoadManifest()
108 if err != nil || !ok {
109 return Progress{}
110 }
111 idx, err := m.LoadIndex()
112 if err != nil {
113 idx = nil
114 }
115 return ComputeProgress(idx, man.Files)
116}
117
118// ClearManifest verwijdert het bewaarde manifest (na wissen of ontkoppelen).
119func (m *Mirror) ClearManifest() error {
120 err := os.Remove(m.manifestPath())
121 if errors.Is(err, os.ErrNotExist) {
122 return nil
123 }
124 return err
125}