package mirror import ( "encoding/json" "errors" "os" "path/filepath" "time" "gitlab.com/Timfa/bluegit/internal/backupserver/protocol" ) // Progress is het deel van de BlueGit-dataset (database, repositories, // releases, artifacts, avatars, enz.) dat deze kopie al bij heeft en dat // overeenkomt met het laatste manifest. De teller is in bytes, zodat een // groot repository zwaarder weegt dan een klein bestand. Als de hele set // 0 bytes is (of leeg), telt het aantal bestanden; 0/0 is 100%. type Progress struct { Known bool `json:"known"` Percent int `json:"percent"` Syncing bool `json:"syncing,omitempty"` DoneBytes int64 `json:"done_bytes"` TotalBytes int64 `json:"total_bytes"` DoneFiles int `json:"done_files"` TotalFiles int `json:"total_files"` UpdatedAt time.Time `json:"updated_at,omitempty"` } // ComputeProgress vergelijkt de index met de bestanden uit een manifest. // files == nil betekent: nog geen manifest, voortgang onbekend. func ComputeProgress(idx map[string]protocol.Entry, files []protocol.Entry) Progress { if files == nil { return Progress{} } if idx == nil { idx = map[string]protocol.Entry{} } p := Progress{Known: true, TotalFiles: len(files), UpdatedAt: time.Now().UTC()} for _, e := range files { logical, ok := protocol.CleanLogical(e.Path) if !ok { p.TotalFiles-- continue } p.TotalBytes += e.Size if old, ok := idx[logical]; ok && same(old, e) { p.DoneFiles++ p.DoneBytes += e.Size } } switch { case p.TotalFiles == 0: p.Percent = 100 case p.DoneFiles == p.TotalFiles: p.Percent = 100 case p.TotalBytes > 0: p.Percent = int(p.DoneBytes * 100 / p.TotalBytes) if p.Percent >= 100 { // Nog ontbrekende lege bestanden: nooit 100% tot alles er is. p.Percent = 99 } default: p.Percent = p.DoneFiles * 100 / p.TotalFiles } if p.Percent < 0 { p.Percent = 0 } return p } func (m *Mirror) manifestPath() string { return filepath.Join(filepath.Dir(m.Index), "last-manifest.json") } // SaveManifest bewaart het laatste manifest, zodat de voortgang tussen // syncs en na een herstart bekend blijft. func (m *Mirror) SaveManifest(man protocol.Manifest) error { b, err := json.Marshal(man) if err != nil { return err } tmp := m.manifestPath() + ".tmp" if err := os.WriteFile(tmp, b, 0o600); err != nil { return err } return os.Rename(tmp, m.manifestPath()) } // LoadManifest leest het laatste manifest. ok is false als het ontbreekt. func (m *Mirror) LoadManifest() (protocol.Manifest, bool, error) { var man protocol.Manifest b, err := os.ReadFile(m.manifestPath()) if errors.Is(err, os.ErrNotExist) { return man, false, nil } if err != nil { return man, false, err } if err := json.Unmarshal(b, &man); err != nil { return man, false, err } return man, true, nil } // CurrentProgress berekent de voortgang uit de index en het laatste manifest. func (m *Mirror) CurrentProgress() Progress { man, ok, err := m.LoadManifest() if err != nil || !ok { return Progress{} } idx, err := m.LoadIndex() if err != nil { idx = nil } return ComputeProgress(idx, man.Files) } // ClearManifest verwijdert het bewaarde manifest (na wissen of ontkoppelen). func (m *Mirror) ClearManifest() error { err := os.Remove(m.manifestPath()) if errors.Is(err, os.ErrNotExist) { return nil } return err }