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
|
package exec
import "github.com/pkg/errors"
var (
// ErrRuntimeUnsupported encountered when a task requires a runtime
// unsupported by the executor.
ErrRuntimeUnsupported = errors.New("exec: unsupported runtime")
// ErrTaskPrepared is called if the task is already prepared.
ErrTaskPrepared = errors.New("exec: task already prepared")
// ErrTaskStarted can be returned from any operation that cannot be
// performed because the task has already been started. This does not imply
// that the task is running but rather that it is no longer valid to call
// Start.
ErrTaskStarted = errors.New("exec: task already started")
// ErrTaskUpdateRejected is returned if a task update is rejected by a controller.
ErrTaskUpdateRejected = errors.New("exec: task update rejected")
// ErrControllerClosed returned when a task controller has been closed.
ErrControllerClosed = errors.New("exec: controller closed")
// ErrTaskRetry is returned by Do when an operation failed by should be
// retried. The status should still be reported in this case.
ErrTaskRetry = errors.New("exec: task retry")
// ErrTaskNoop returns when the a subsequent call to Do will not result in
// advancing the task. Callers should avoid calling Do until the task has been updated.
ErrTaskNoop = errors.New("exec: task noop")
// ErrDependencyNotReady is returned if a given dependency can be accessed
// through the Getter, but is not yet ready to be used. This is most
// relevant for Volumes, which must be staged and published on the node.
ErrDependencyNotReady error = errors.New("dependency not ready")
)
// ExitCoder is implemented by errors that have an exit code.
type ExitCoder interface {
// ExitCode returns the exit code.
ExitCode() int
}
// Temporary indicates whether or not the error condition is temporary.
//
// If this is encountered in the controller, the failing operation will be
// retried when this returns true. Otherwise, the operation is considered
// fatal.
type Temporary interface {
Temporary() bool
}
// MakeTemporary makes the error temporary.
func MakeTemporary(err error) error {
if IsTemporary(err) {
return err
}
return temporary{err}
}
type temporary struct {
error
}
func (t temporary) Cause() error { return t.error }
func (t temporary) Temporary() bool { return true }
// IsTemporary returns true if the error or a recursive cause returns true for
// temporary.
func IsTemporary(err error) bool {
var tmp Temporary
if errors.As(err, &tmp) {
return tmp.Temporary()
}
return false
}
|
