-
Notifications
You must be signed in to change notification settings - Fork 0
/
versions.go
288 lines (242 loc) · 7.87 KB
/
versions.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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
/*
MongoDB Versions
The MongoDBVersion type provides support for interacting with MongoDB
versions. This type makes it possible to validate MongoDB version
numbers and ask common questions about MongoDB versions.
*/
package bond
import (
"fmt"
"sort"
"strconv"
"strings"
"github.com/blang/semver"
)
// MongoDBVersion is a structure representing a version identifier for
// MongoDB. Use the associated methods to ask questions about MongoDB
// versions. All parsing of versions happens during construction, and
// individual method calls are very light-weight.
type MongoDBVersion struct {
source string
parsed semver.Version
isRc bool
isDev bool
rcNumber int
series string
tag string
}
// NewMongoDBVersion takes a string representing a MongoDB version and
// returns a MongoDBVersion object. If the input string is not a valid
// version, or there were problems parsing the string, the error value
// is non-nil. All parsing of a version happens during this phase.
func NewMongoDBVersion(version string) (*MongoDBVersion, error) {
v := &MongoDBVersion{source: version, rcNumber: -1}
if strings.HasSuffix(version, "-") {
v.isDev = true
if !strings.Contains(version, "pre") {
version += "pre-"
}
}
if strings.Contains(version, "~") {
versionParts := strings.Split(version, "~")
version = versionParts[0]
version += "-pre-"
v.tag = strings.Join(versionParts[1:], "")
v.isDev = true
}
parsed, err := semver.Parse(version)
if err != nil {
return nil, err
}
v.parsed = parsed
if strings.Contains(version, "rc") {
v.isRc = true
}
tagParts := strings.Split(version, "-")
if len(tagParts) > 1 {
v.tag = strings.Join(tagParts[1:], "-")
if v.isRc {
// Prerelease may have +buildinfo suffix, like: 1.0.0-rc0+buildinfo
rcPart := strings.Split(tagParts[1], "+")
v.rcNumber, err = strconv.Atoi(rcPart[0][2:])
if len(tagParts) > 2 {
v.isDev = true
}
} else {
v.isDev = true
}
}
v.series = version[:3]
return v, err
}
// ConvertVersion takes an un-typed object and attempts to convert it to a
// version object. For use with compactor functions.
func ConvertVersion(v interface{}) (*MongoDBVersion, error) {
switch version := v.(type) {
case *MongoDBVersion:
return version, nil
case MongoDBVersion:
return &version, nil
case string:
output, err := NewMongoDBVersion(version)
if err != nil {
return nil, err
}
return output, nil
case semver.Version:
return NewMongoDBVersion(version.String())
default:
return nil, fmt.Errorf("%v is not a valid version type (%T)", version, version)
}
}
// String returns a string representation of the MongoDB version
// number.
func (v *MongoDBVersion) String() string {
return v.source
}
// Series return the release series, generally the first two
// components of a version. For example for 3.2.6, the series is 3.2.
func (v *MongoDBVersion) Series() string {
return v.series
}
// IsReleaseCandidate returns true for releases that have the "rc[0-9]"
// tag and false otherwise.
func (v *MongoDBVersion) IsReleaseCandidate() bool {
return v.IsRelease() && v.isRc
}
// IsStableSeries returns true for stable releases, ones where the
// second component of the version string (i.e. "Minor" in semantic
// versioning terms) are even, and false otherwise.
func (v *MongoDBVersion) IsStableSeries() bool {
return v.parsed.Minor%2 == 0
}
// IsDevelopmentSeries returns true for development (snapshot)
// releases. These versions are those where the second component
// (e.g. "Minor" in semantic versioning terms) are odd, and false
// otherwise.
func (v *MongoDBVersion) IsDevelopmentSeries() bool {
return !v.IsStableSeries()
}
// StableReleaseSeries returns a series string (e.g. X.Y) for this
// version. For stable releases, the output is the same as
// .Series(). For development releases, this method returns the *next*
// stable series.
func (v *MongoDBVersion) StableReleaseSeries() string {
if v.IsStableSeries() {
return v.Series()
}
if v.parsed.Minor < 9 {
return fmt.Sprintf("%d.%d", v.parsed.Major, v.parsed.Minor+1)
}
return fmt.Sprintf("%d.0", v.parsed.Major+1)
}
// IsRelease returns true for all version strings that refer to a
// release, including development, release candidate and GA releases,
// and false otherwise. Other builds, including test builds and
// "nightly" snapshots of MongoDB have version strings, but are not
// releases.
func (v *MongoDBVersion) IsRelease() bool {
return !v.isDev
}
// IsDevelopmentBuild returns true for all non-release builds,
// including nightly snapshots and all testing and development
// builds.
func (v *MongoDBVersion) IsDevelopmentBuild() bool {
return v.isDev
}
// IsInitialStableReleaseCandidate returns true for release
// candidates for the initial public release of a new stable release
// series.
func (v *MongoDBVersion) IsInitialStableReleaseCandidate() bool {
if v.IsStableSeries() {
return v.parsed.Patch == 0 && v.IsReleaseCandidate()
}
return false
}
// RcNumber returns an integer for the RC counter. For non-rc releases,
// returns -1.
func (v *MongoDBVersion) RcNumber() int {
return v.rcNumber
}
// IsLessThan returns true when "version" is less than (e.g. earlier)
// than the object itself.
func (v *MongoDBVersion) IsLessThan(version *MongoDBVersion) bool {
return v.parsed.LT(version.parsed)
}
// IsLessThanOrEqualTo returns true when "version" is less than or
// equal to (e.g. earlier or the same as) the object itself.
func (v *MongoDBVersion) IsLessThanOrEqualTo(version *MongoDBVersion) bool {
// semver considers release candidates equal to GA, so we have to special case this
if v.IsEqualTo(version) {
return true
}
return v.parsed.LT(version.parsed)
}
// IsGreaterThan returns true when "version" is greater than (e.g. later)
// than the object itself.
func (v *MongoDBVersion) IsGreaterThan(version *MongoDBVersion) bool {
return v.parsed.GT(version.parsed)
}
// IsGreaterThanOrEqualTo returns true when "version" is greater than
// or equal to (e.g. the same as or later than) the object itself.
func (v *MongoDBVersion) IsGreaterThanOrEqualTo(version *MongoDBVersion) bool {
if v.IsEqualTo(version) {
return true
}
return v.parsed.GT(version.parsed)
}
// IsEqualTo returns true when "version" is the same as the object
// itself.
func (v *MongoDBVersion) IsEqualTo(version *MongoDBVersion) bool {
return v.source == version.source
}
// IsNotEqualTo returns true when "version" is the different from the
// object itself.
func (v *MongoDBVersion) IsNotEqualTo(version *MongoDBVersion) bool {
return v.source != version.source
}
/////////////////////////////////////////////
//
// Support for Sorting Slices of MongoDB Versions
//
/////////////////////////////////////////////
// MongoDBVersionSlice is an alias for []MongoDBVersion that supports
// the sort.Sorter interface, and makes it possible to sort slices of
// MongoDB versions.
type MongoDBVersionSlice []MongoDBVersion
// Len is required by the sort.Sorter interface. Returns
// the length of the slice.
func (s MongoDBVersionSlice) Len() int {
return len(s)
}
// Less is a required by the sort.Sorter interface. Uses blang/semver
// to compare two versions.
func (s MongoDBVersionSlice) Less(i, j int) bool {
left := s[i]
right := s[j]
return left.parsed.LT(right.parsed)
}
// Swap is a required by the sort.Sorter interface. Changes the
// position of two elements in the slice.
func (s MongoDBVersionSlice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
// String() adds suport for the Stringer interface, which makes it
// possible to print slices of MongoDB versions as comma separated
// lists.
func (s MongoDBVersionSlice) String() string {
var out []string
for _, v := range s {
if len(v.source) == 0 {
// some elements end up empty.
continue
}
out = append(out, v.source)
}
return strings.Join(out, ", ")
}
// Sort provides a wrapper around sort.Sort() for slices of MongoDB
// versions objects.
func (s MongoDBVersionSlice) Sort() {
sort.Sort(s)
}