1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package cmd
import (
"encoding/json"
"log"
"net/http"
"os"
"os/exec"
"path/filepath"
"runtime"
"sort"
"strings"
"time"
"github.com/spf13/cobra"
"github.com/vespa-engine/vespa/client/go/build"
"github.com/vespa-engine/vespa/client/go/util"
"github.com/vespa-engine/vespa/client/go/version"
)
var skipVersionCheck bool
var sp subprocess = &execSubprocess{}
type subprocess interface {
pathOf(name string) (string, error)
outputOf(name string, args ...string) ([]byte, error)
isTerminal() bool
}
type execSubprocess struct{}
func (c *execSubprocess) pathOf(name string) (string, error) { return exec.LookPath(name) }
func (c *execSubprocess) isTerminal() bool { return isTerminal() }
func (c *execSubprocess) outputOf(name string, args ...string) ([]byte, error) {
return exec.Command(name, args...).Output()
}
func init() {
rootCmd.AddCommand(versionCmd)
versionCmd.Flags().BoolVarP(&skipVersionCheck, "no-check", "n", false, "Do not check if a new version is available")
}
var versionCmd = &cobra.Command{
Use: "version",
Short: "Show current version and check for updates",
DisableAutoGenTag: true,
Args: cobra.ExactArgs(0),
Run: func(cmd *cobra.Command, args []string) {
log.Printf("vespa version %s compiled with %v on %v/%v", build.Version, runtime.Version(), runtime.GOOS, runtime.GOARCH)
if !skipVersionCheck && sp.isTerminal() {
if err := checkVersion(); err != nil {
fatalErr(err)
}
}
},
}
func checkVersion() error {
current, err := version.Parse(build.Version)
if err != nil {
return err
}
latest, err := latestRelease()
if err != nil {
return err
}
if !current.Less(latest.Version) {
return nil
}
usingHomebrew := usingHomebrew()
if usingHomebrew && latest.isRecent() {
return nil // Allow some time for new release to appear in Homebrew repo
}
log.Printf("\nNew release available: %s", color.Green(latest.Version))
log.Printf("https://github.com/vespa-engine/vespa/releases/tag/v%s", latest.Version)
if usingHomebrew {
log.Printf("\nUpgrade by running:\n%s", color.Cyan("brew update && brew upgrade vespa-cli"))
}
return nil
}
func latestRelease() (release, error) {
req, err := http.NewRequest("GET", "https://api.github.com/repos/vespa-engine/vespa/releases", nil)
if err != nil {
return release{}, err
}
response, err := util.HttpDo(req, time.Minute, "GitHub")
if err != nil {
return release{}, err
}
defer response.Body.Close()
var ghReleases []githubRelease
dec := json.NewDecoder(response.Body)
if err := dec.Decode(&ghReleases); err != nil {
return release{}, err
}
if len(ghReleases) == 0 {
return release{}, nil // No releases found
}
var releases []release
for _, r := range ghReleases {
v, err := version.Parse(r.TagName)
if err != nil {
return release{}, err
}
publishedAt, err := time.Parse(time.RFC3339, r.PublishedAt)
if err != nil {
return release{}, err
}
releases = append(releases, release{Version: v, PublishedAt: publishedAt})
}
sort.Slice(releases, func(i, j int) bool { return releases[i].Version.Less(releases[j].Version) })
return releases[len(releases)-1], nil
}
func usingHomebrew() bool {
selfPath, err := sp.pathOf("vespa")
if err != nil {
return false
}
brewPrefix, err := sp.outputOf("brew", "--prefix")
if err != nil {
return false
}
brewBin := filepath.Join(strings.TrimSpace(string(brewPrefix)), "bin") + string(os.PathSeparator)
return strings.HasPrefix(selfPath, brewBin)
}
type githubRelease struct {
TagName string `json:"tag_name"`
PublishedAt string `json:"published_at"`
}
type release struct {
Version version.Version
PublishedAt time.Time
}
func (r release) isRecent() bool {
return time.Now().Before(r.PublishedAt.Add(time.Hour * 24))
}
|
