syncthing/internal/upgrade/upgrade_common.go

143 lines
2.8 KiB
Go
Raw Normal View History

2014-07-31 14:01:23 +00:00
// Copyright (C) 2014 Jakob Borg and Contributors (see the CONTRIBUTORS file).
// All rights reserved. Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
2014-07-31 15:01:11 +00:00
// Package upgrade downloads and compares releases, and upgrades the running binary.
2014-07-31 14:01:23 +00:00
package upgrade
2014-07-14 08:45:29 +00:00
import (
"errors"
2014-07-14 08:45:29 +00:00
"strconv"
"strings"
)
2014-07-31 14:01:23 +00:00
type Release struct {
Tag string `json:"tag_name"`
Prerelease bool `json:"prerelease"`
Assets []Asset `json:"assets"`
2014-07-14 08:45:29 +00:00
}
2014-07-31 14:01:23 +00:00
type Asset struct {
2014-07-14 08:45:29 +00:00
URL string `json:"url"`
Name string `json:"name"`
}
var (
2014-07-31 14:01:23 +00:00
ErrVersionUpToDate = errors.New("current version is up to date")
ErrVersionUnknown = errors.New("couldn't fetch release information")
ErrUpgradeUnsupported = errors.New("upgrade unsupported")
)
// Returns 1 if a>b, -1 if a<b and 0 if they are equal
2014-07-31 14:01:23 +00:00
func CompareVersions(a, b string) int {
arel, apre := versionParts(a)
brel, bpre := versionParts(b)
minlen := len(arel)
if l := len(brel); l < minlen {
minlen = l
}
// First compare major-minor-patch versions
for i := 0; i < minlen; i++ {
if arel[i] < brel[i] {
return -1
}
if arel[i] > brel[i] {
return 1
}
}
// Longer version is newer, when the preceding parts are equal
if len(arel) < len(brel) {
return -1
}
if len(arel) > len(brel) {
return 1
}
// Prerelease versions are older, if the versions are the same
if len(apre) == 0 && len(bpre) > 0 {
return 1
}
if len(apre) > 0 && len(bpre) == 0 {
return -1
}
minlen = len(apre)
if l := len(bpre); l < minlen {
minlen = l
}
// Compare prerelease strings
for i := 0; i < minlen; i++ {
switch av := apre[i].(type) {
case int:
switch bv := bpre[i].(type) {
case int:
if av < bv {
return -1
}
if av > bv {
return 1
}
case string:
return -1
}
case string:
switch bv := bpre[i].(type) {
case int:
return 1
case string:
if av < bv {
return -1
}
if av > bv {
return 1
}
}
}
}
// If all else is equal, longer prerelease string is newer
if len(apre) < len(bpre) {
return -1
}
if len(apre) > len(bpre) {
return 1
}
// Looks like they're actually the same
return 0
2014-07-14 08:45:29 +00:00
}
// Split a version into parts.
// "1.2.3-beta.2" -> []int{1, 2, 3}, []interface{}{"beta", 2}
func versionParts(v string) ([]int, []interface{}) {
parts := strings.SplitN(v, "+", 2)
parts = strings.SplitN(parts[0], "-", 2)
2014-07-14 08:45:29 +00:00
fields := strings.Split(parts[0], ".")
release := make([]int, len(fields))
2014-07-14 08:45:29 +00:00
for i, s := range fields {
v, _ := strconv.Atoi(s)
release[i] = v
2014-07-14 08:45:29 +00:00
}
var prerelease []interface{}
if len(parts) > 1 {
fields = strings.Split(parts[1], ".")
prerelease = make([]interface{}, len(fields))
for i, s := range fields {
v, err := strconv.Atoi(s)
if err == nil {
prerelease[i] = v
} else {
prerelease[i] = s
}
}
}
return release, prerelease
2014-07-14 08:45:29 +00:00
}