/
version.go
147 lines (135 loc) · 4.46 KB
/
version.go
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
146
147
package opts
import (
"strings"
"github.com/jenkins-x/jx/v2/pkg/versionstream/versionstreamrepo"
"github.com/jenkins-x/jx/v2/pkg/versionstream"
"github.com/jenkins-x/jx-logging/pkg/log"
"github.com/jenkins-x/jx/v2/pkg/table"
"github.com/jenkins-x/jx/v2/pkg/util"
)
// CreateVersionResolver creates a new VersionResolver service
func (o *CommonOptions) CreateVersionResolver(repo string, gitRef string) (*versionstream.VersionResolver, error) {
versionsDir, _, err := o.CloneJXVersionsRepo(repo, gitRef)
if err != nil {
return nil, err
}
return &versionstream.VersionResolver{
VersionsDir: versionsDir,
}, nil
}
// GetVersionResolver gets a VersionResolver, lazy creating one if required so we can reuse it later
func (o *CommonOptions) GetVersionResolver() (*versionstream.VersionResolver, error) {
var err error
if o.versionResolver == nil {
o.versionResolver, err = o.CreateVersionResolver("", "")
}
return o.versionResolver, err
}
// SetVersionResolver gets a VersionResolver, lazy creating one if required
func (o *CommonOptions) SetVersionResolver(resolver *versionstream.VersionResolver) {
o.versionResolver = resolver
}
// GetPackageVersions returns the package versions and a table if they need to be rendered
func (o *CommonOptions) GetPackageVersions(ns string, helmTLS bool) (map[string]string, table.Table) {
info := util.ColorInfo
packages := map[string]string{}
table := o.CreateTable()
table.AddRow("NAME", "VERSION")
// Jenkins X version
releases, _, err := o.Helm().ListReleases(ns)
if err != nil {
log.Logger().Warnf("Failed to find helm installs: %s", err)
} else {
for _, release := range releases {
if release.Chart == "jenkins-x-platform" {
table.AddRow("jenkins x platform", info(release.ChartVersion))
}
}
}
// Kubernetes version
client, err := o.KubeClient()
if err != nil {
log.Logger().Warnf("Failed to connect to Kubernetes: %s", err)
} else {
serverVersion, err := client.Discovery().ServerVersion()
if err != nil {
log.Logger().Warnf("Failed to get Kubernetes server version: %s", err)
} else if serverVersion != nil {
version := serverVersion.String()
packages["kubernetesCluster"] = version
table.AddRow("Kubernetes cluster", info(version))
}
}
// kubectl version
output, err := o.GetCommandOutput("", "kubectl", "version", "--short")
if err != nil {
log.Logger().Warnf("Failed to get kubectl version: %s", err)
} else {
for i, line := range strings.Split(output, "\n") {
fields := strings.Fields(line)
if len(fields) > 1 {
v := fields[2]
if v != "" {
switch i {
case 0:
table.AddRow("kubectl (installed in JX_BIN)", info(v))
packages["kubectl"] = v
case 1:
// Ignore K8S server details as we have these above
}
}
}
}
}
// helm version
output, err = o.Helm().Version(helmTLS)
if err != nil {
log.Logger().Warnf("Failed to get helm version: %s", err)
} else {
helmBinary, noTiller, helmTemplate, _ := o.TeamHelmBin()
if helmBinary == "helm3" || noTiller || helmTemplate {
table.AddRow("helm client", info(output))
} else {
for i, line := range strings.Split(output, "\n") {
fields := strings.Fields(line)
if len(fields) > 1 {
v := fields[1]
if v != "" {
switch i {
case 0:
table.AddRow("helm client", info(v))
packages["helm"] = v
case 1:
table.AddRow("helm server", info(v))
}
}
}
}
}
}
// git version
version, err := o.Git().Version()
if err != nil {
log.Logger().Warnf("Failed to get git version: %s", err)
} else {
table.AddRow("git", info(version))
packages["git"] = version
}
return packages, table
}
// GetVersionNumber returns the version number for the given kind and name or blank string if there is no locked version
func (o *CommonOptions) GetVersionNumber(kind versionstream.VersionKind, name, repo string, gitRef string) (string, error) {
versioner, err := o.CreateVersionResolver(repo, gitRef)
if err != nil {
return "", err
}
return versioner.StableVersionNumber(kind, name)
}
// CloneJXVersionsRepo clones the jenkins-x versions repo to a local working dir
func (o *CommonOptions) CloneJXVersionsRepo(versionRepository string, versionRef string) (string, string, error) {
settings, err := o.TeamSettings()
if err != nil {
log.Logger().Debugf("Unable to load team settings because %v", err)
}
return versionstreamrepo.CloneJXVersionsRepo(versionRepository, versionRef, settings, o.Git(), o.BatchMode, o.AdvancedMode, o.GetIOFileHandles())
}