forked from asteris-llc/converge
-
Notifications
You must be signed in to change notification settings - Fork 0
/
status.go
287 lines (237 loc) · 7.23 KB
/
status.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
// Copyright © 2016 Asteris, LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package resource
import (
"errors"
"fmt"
)
// StatusLevel will be used as a level in Status. It indicates if a resource
// needs to be changed, as well as fatal conditions.
type StatusLevel uint32
const (
// StatusNoChange means no changes are necessary. This status signals that
// execution of dependent resources can continue.
StatusNoChange StatusLevel = iota
// StatusWontChange indicates an acceptable delta that wont be corrected.
// This status signals that execution of dependent resources can continue.
StatusWontChange
// StatusWillChange indicates an unacceptable delta that will be corrected.
// This status signals that execution of dependent resources can continue.
StatusWillChange
// StatusCantChange indicates an unacceptable delta that can't be corrected.
// This is just like StatusFatal except the user will see that the resource
// needs to change, but can't because of the condition specified in your
// messaging. This status halts execution of dependent resources.
StatusCantChange
// StatusFatal indicates an error. This is just like StatusCantChange except
// it does not imply that there are changes to be made. This status halts
// execution of dependent resources.
StatusFatal
)
// error messages
var (
// ErrStatusCantChange is returned when an error is not set but the level is
// StatusCantChange
ErrStatusCantChange = errors.New("resource cannot change because of an error")
// ErrStatusFatal is returned when an error is not set but the level is
// StatusFatal
ErrStatusFatal = errors.New("resource encountered an error")
)
func (l StatusLevel) String() string {
switch l {
case StatusNoChange:
return "no change"
case StatusWontChange:
return "won't change"
case StatusWillChange:
return "will change"
case StatusCantChange:
return "can't change"
case StatusFatal:
return "fatal"
}
return "invalid status level"
}
type badDep struct {
ID string
Status TaskStatus
}
// TaskStatus represents the results of Check called during planning or
// application.
type TaskStatus interface {
Diffs() map[string]Diff
StatusCode() StatusLevel
Messages() []string
HasChanges() bool
Error() error
}
// Status is the default TaskStatus implementation
type Status struct {
// Differences contains the things that will change as a part of this
// Status. This will be used almost exclusively in the Check phase of
// operations on resources. Use `NewStatus` to get a Status with this
// initialized properly.
Differences map[string]Diff
// Output is the human-consumable fields on this struct. Output will be
// returned as the Status' messages
Output []string
// Level indicates the change level of the status. Level is a gradation (see
// the Status* contsts above.)
Level StatusLevel
error error
failingDeps []badDep
}
// NewStatus returns a Status with all fields initialized
func NewStatus() *Status {
return &Status{
Differences: map[string]Diff{},
}
}
// SetError sets an error on a status
func (t *Status) SetError(err error) {
if t == nil {
*t = *NewStatus()
}
switch t.Level {
case StatusWillChange, StatusCantChange:
t.Level = StatusCantChange
default:
t.Level = StatusFatal
}
t.error = err
}
// Error returns an error, if set. If the level is StatusCantChange or
// StatusFatal and an error is not set, Error will generate an appropriate
// error message.
func (t *Status) Error() error {
if t.error == nil {
switch t.Level {
case StatusCantChange:
return ErrStatusCantChange
case StatusFatal:
return ErrStatusFatal
}
}
return t.error
}
// Diffs returns the internal differences
func (t *Status) Diffs() map[string]Diff {
return t.Differences
}
// StatusCode returns the current warning level
func (t *Status) StatusCode() StatusLevel {
return t.Level
}
// Messages returns the current output slice
func (t *Status) Messages() []string {
return t.Output
}
// HasChanges returns the WillChange value
func (t *Status) HasChanges() bool {
if t.Level == StatusWillChange || t.Level == StatusCantChange {
return true
}
for _, diff := range t.Diffs() {
if diff.Changes() {
return true
}
}
return false
}
// HealthCheck provides a default health check implementation for statuses
func (t *Status) HealthCheck() (status *HealthStatus, err error) {
status = &HealthStatus{TaskStatus: t, FailingDeps: make(map[string]string)}
if !t.HasChanges() && len(t.failingDeps) == 0 {
return
}
// There are changes or failing dependencies so the health check is at least
// at a warning status.
status.UpgradeWarning(StatusWarning)
for _, failingDep := range t.failingDeps {
status.FailingDeps[failingDep.ID] = fmt.Sprintf("returned %d", failingDep.Status.StatusCode())
}
if t.StatusCode() >= 2 {
status.UpgradeWarning(StatusError)
}
return
}
// FailingDep tracks a new failing dependency
func (t *Status) FailingDep(id string, stat TaskStatus) {
t.failingDeps = append(t.failingDeps, badDep{ID: id, Status: stat})
}
// AddDifference adds a TextDiff to the Differences map
func (t *Status) AddDifference(name, original, current, defaultVal string) {
t.Differences = AddTextDiff(t.Differences, name, original, current, defaultVal)
}
// AddMessage adds a human-readable message(s) to the output
func (t *Status) AddMessage(message ...string) {
t.Output = append(t.Output, message...)
}
// RaiseLevel raises the status level to the given level
func (t *Status) RaiseLevel(level StatusLevel) {
if level > t.Level {
t.Level = level
}
}
// Diff represents a difference
type Diff interface {
Original() string
Current() string
Changes() bool
}
// TextDiff is the default Diff implementation
type TextDiff struct {
Default string
Values [2]string
}
// Original returns the unmodified value of the diff
func (t TextDiff) Original() string {
if t.Values[0] == "" {
return t.Default
}
return t.Values[0]
}
// Current returns the modified value of the diff
func (t TextDiff) Current() string {
if t.Values[1] == "" {
return t.Default
}
return t.Values[1]
}
// Changes is true if the Original and Current values differ
func (t TextDiff) Changes() bool {
return t.Values[0] != t.Values[1]
}
// AnyChanges takes a diff map and returns true if any of the diffs in the map
// have changes.
func AnyChanges(diffs map[string]Diff) bool {
for _, diffIf := range diffs {
diff, ok := diffIf.(Diff)
if !ok {
panic("invalid conversion")
}
if diff.Changes() {
return true
}
}
return false
}
// AddTextDiff inserts a new TextDiff into a map of names to Diffs
func AddTextDiff(m map[string]Diff, name, original, current, defaultVal string) map[string]Diff {
if m == nil {
m = make(map[string]Diff)
}
m[name] = TextDiff{Values: [2]string{original, current}, Default: defaultVal}
return m
}