package backup import ( "net/http" "runtime/debug" "strconv" "strings" ) // Compatibiliteit tussen BlueGit en bluegit-backup. // // Elke kant heeft een protocolversie (wat hij zelf spreekt) en een // minimumversie (de oudste versie van de andere kant die hij nog // ondersteunt). Ze zijn compatibel als elk de minimumversie van de ander // haalt. Een kant die de koppen niet stuurt, spreekt protocol 1 (zo was het // tot en met bluegit-backup v0.1.0). // // De waarden zijn strings, zodat een test-build ze met // -ldflags "-X gitlab.com/Timfa/bluegit/internal/backup.protocolVersion=…" // kan overschrijven. var ( protocolVersion = "1" minBackupProtocol = "1" ) // Koppen met de protocolversie. BlueGit zet de X-BlueGit-koppen op zijn // verzoeken aan en antwoorden van de backup-API; de backup server zet de // X-Backup-koppen op zijn verzoeken en antwoorden. const ( HeaderBlueGitProtocol = "X-BlueGit-Protocol" HeaderBlueGitMinProtocol = "X-BlueGit-Min-Protocol" HeaderBlueGitVersion = "X-BlueGit-Version" HeaderBackupProtocol = "X-Backup-Protocol" HeaderBackupMinProtocol = "X-Backup-Min-Protocol" HeaderBackupVersion = "X-Backup-Version" ) // Uitkomsten van Compat. const ( CompatOK = "ok" CompatBlueGitTooOld = "bluegit_too_old" CompatBackupTooOld = "backup_too_old" ) func atoiMin1(s string) int { n, err := strconv.Atoi(strings.TrimSpace(s)) if err != nil || n < 1 { return 1 } return n } // Protocol is de protocolversie van deze BlueGit. func Protocol() int { return atoiMin1(protocolVersion) } // MinProtocol is de oudste protocolversie van een backup server die deze // BlueGit ondersteunt. func MinProtocol() int { if m := atoiMin1(minBackupProtocol); m <= Protocol() { return m } return Protocol() } // Version is de commit waarvan deze BlueGit gebouwd is (of "dev"). func Version() string { if bi, ok := debug.ReadBuildInfo(); ok { for _, s := range bi.Settings { if s.Key == "vcs.revision" && len(s.Value) >= 12 { return s.Value[:12] } } } return "dev" } // Compat vergelijkt BlueGit (protocol, minimum voor de backup server) met // een backup server (protocol, minimum voor BlueGit). func Compat(bluegit, bluegitMin, backup, backupMin int) string { switch { case backup < bluegitMin: return CompatBackupTooOld case bluegit < backupMin: return CompatBlueGitTooOld } return CompatOK } // Peer is wat een backup server over zijn protocol zegt. type Peer struct { Protocol int MinProtocol int Version string } // PeerFromHeader leest de X-Backup-koppen. Zonder koppen is het protocol 1. // ok is false als er geen protocolkop is. func PeerFromHeader(h http.Header) (Peer, bool) { p := Peer{Protocol: 1, MinProtocol: 1} raw := h.Get(HeaderBackupProtocol) if raw == "" { return p, false } p.Protocol = atoiMin1(raw) if m := h.Get(HeaderBackupMinProtocol); m != "" { p.MinProtocol = atoiMin1(m) } p.Version = CleanVersion(h.Get(HeaderBackupVersion)) return p, true } // CleanVersion houdt een versie kort en toonbaar. func CleanVersion(v string) string { v = strings.TrimSpace(v) out := make([]rune, 0, len(v)) for _, r := range v { if r > ' ' && r < 0x7f && r != '<' && r != '>' && r != '"' { out = append(out, r) } if len(out) == 40 { break } } return string(out) } // SetOwnHeaders zet de X-BlueGit-koppen. func SetOwnHeaders(h http.Header) { h.Set(HeaderBlueGitProtocol, strconv.Itoa(Protocol())) h.Set(HeaderBlueGitMinProtocol, strconv.Itoa(MinProtocol())) h.Set(HeaderBlueGitVersion, Version()) } // Compat zegt of deze backup server bij deze BlueGit past. Leeg als de // backup server zich nog niet gemeld heeft. func (c Conn) Compat() string { if !c.Connected() || c.PeerProtocol == 0 { return "" } min := c.PeerMinProtocol if min == 0 { min = 1 } return Compat(Protocol(), MinProtocol(), c.PeerProtocol, min) } // Incompatible zegt of er iets geüpdatet moet worden. func (c Conn) Incompatible() bool { r := c.Compat() return r == CompatBlueGitTooOld || r == CompatBackupTooOld } // SetPeer legt het protocol van de backup server vast. Alleen bij een // verandering wordt backup.json herschreven. func (m *Manager) SetPeer(id string, p Peer) { c, ok := m.Get(id) if !ok || (c.PeerProtocol == p.Protocol && c.PeerMinProtocol == p.MinProtocol && c.PeerVersion == p.Version) { return } _, _ = m.update(id, func(c *Conn) error { c.PeerProtocol, c.PeerMinProtocol, c.PeerVersion = p.Protocol, p.MinProtocol, p.Version return nil }) } // OverrideProtocol zet protocol en minimum tijdelijk anders (alleen voor // tests). De teruggegeven functie zet ze terug. func OverrideProtocol(protocol, min string) (restore func()) { oldP, oldM := protocolVersion, minBackupProtocol protocolVersion, minBackupProtocol = protocol, min return func() { protocolVersion, minBackupProtocol = oldP, oldM } }