mirror of
https://github.com/juanfont/headscale.git
synced 2026-07-17 16:36:02 +00:00
eb23c125fa
Regenerate capver for tailscale v1.98 — `MinSupportedCapabilityVersion` slides 109 → 113 (v1.78 → v1.80). v1.80+ clients understand `Node.HomeDERP`, which superseded `LegacyDERPString` upstream at capver 111. Drops the emit, plumbing, the trip-wire that caught this cleanup, the golden test fixtures, and the integration check on `peer.LegacyDERPString()` — the sibling `HomeDERP` check covers intent. `v1.98` was added by hand to `capver_generated.go` because tailscale skipped publishing v1.97/v1.98 to ghcr until late in the cycle; a clean regeneration produces the same content.
124 lines
2.8 KiB
Go
124 lines
2.8 KiB
Go
package capver
|
|
|
|
//go:generate go run ../../tools/capver/main.go
|
|
|
|
import (
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
|
|
xmaps "golang.org/x/exp/maps"
|
|
"tailscale.com/tailcfg"
|
|
"tailscale.com/util/set"
|
|
)
|
|
|
|
// minVersionParts is the minimum number of version parts needed for major.minor.
|
|
const minVersionParts = 2
|
|
|
|
// CanOldCodeBeCleanedUp is called at server startup to panic when
|
|
// [MinSupportedCapabilityVersion] has crossed a threshold at which a
|
|
// backwards-compat emit path can be deleted. Each entry pairs a
|
|
// [tailcfg.CapabilityVersion] threshold with the message identifying
|
|
// the code to remove; today there are none.
|
|
//
|
|
// All capability-version-gated cleanups should be registered here.
|
|
func CanOldCodeBeCleanedUp() {
|
|
}
|
|
|
|
func tailscaleVersSorted() []string {
|
|
vers := xmaps.Keys(tailscaleToCapVer)
|
|
sort.Strings(vers)
|
|
|
|
return vers
|
|
}
|
|
|
|
func capVersSorted() []tailcfg.CapabilityVersion {
|
|
capVers := xmaps.Keys(capVerToTailscaleVer)
|
|
slices.Sort(capVers)
|
|
|
|
return capVers
|
|
}
|
|
|
|
// TailscaleVersion returns the Tailscale version for the given [tailcfg.CapabilityVersion].
|
|
func TailscaleVersion(ver tailcfg.CapabilityVersion) string {
|
|
return capVerToTailscaleVer[ver]
|
|
}
|
|
|
|
// CapabilityVersion returns the [tailcfg.CapabilityVersion] for the given Tailscale version.
|
|
// It accepts both full versions (v1.90.1) and minor versions (v1.90).
|
|
func CapabilityVersion(ver string) tailcfg.CapabilityVersion {
|
|
if !strings.HasPrefix(ver, "v") {
|
|
ver = "v" + ver
|
|
}
|
|
|
|
// Try direct lookup first (works for minor versions like v1.90)
|
|
if cv, ok := tailscaleToCapVer[ver]; ok {
|
|
return cv
|
|
}
|
|
|
|
// Try extracting minor version from full version (v1.90.1 -> v1.90)
|
|
parts := strings.Split(strings.TrimPrefix(ver, "v"), ".")
|
|
if len(parts) >= minVersionParts {
|
|
minor := "v" + parts[0] + "." + parts[1]
|
|
return tailscaleToCapVer[minor]
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
// TailscaleLatest returns the n latest Tailscale versions.
|
|
func TailscaleLatest(n int) []string {
|
|
if n <= 0 {
|
|
return nil
|
|
}
|
|
|
|
tsSorted := tailscaleVersSorted()
|
|
|
|
if n > len(tsSorted) {
|
|
return tsSorted
|
|
}
|
|
|
|
return tsSorted[len(tsSorted)-n:]
|
|
}
|
|
|
|
// TailscaleLatestMajorMinor returns the n latest Tailscale versions (e.g. 1.80).
|
|
func TailscaleLatestMajorMinor(n int, stripV bool) []string {
|
|
if n <= 0 {
|
|
return nil
|
|
}
|
|
|
|
majors := set.Set[string]{}
|
|
|
|
for _, vers := range tailscaleVersSorted() {
|
|
if stripV {
|
|
vers = strings.TrimPrefix(vers, "v")
|
|
}
|
|
|
|
v := strings.Split(vers, ".")
|
|
majors.Add(v[0] + "." + v[1])
|
|
}
|
|
|
|
majorSl := majors.Slice()
|
|
sort.Strings(majorSl)
|
|
|
|
if n > len(majorSl) {
|
|
return majorSl
|
|
}
|
|
|
|
return majorSl[len(majorSl)-n:]
|
|
}
|
|
|
|
// CapVerLatest returns the n latest [tailcfg.CapabilityVersion] values.
|
|
func CapVerLatest(n int) []tailcfg.CapabilityVersion {
|
|
if n <= 0 {
|
|
return nil
|
|
}
|
|
|
|
s := capVersSorted()
|
|
|
|
if n > len(s) {
|
|
return s
|
|
}
|
|
|
|
return s[len(s)-n:]
|
|
}
|