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
|
package documentdb
import (
"time"
"github.com/scaleway/scaleway-sdk-go/errors"
"github.com/scaleway/scaleway-sdk-go/internal/async"
"github.com/scaleway/scaleway-sdk-go/scw"
)
const (
defaultRetryInterval = 15 * time.Second
defaultTimeout = 15 * time.Minute
)
// WaitForInstanceRequest is used by WaitForInstance method.
type WaitForInstanceRequest struct {
InstanceID string
Region scw.Region
Timeout *time.Duration
RetryInterval *time.Duration
}
// WaitForInstance waits for the instance to be in a "terminal state" before returning.
// This function can be used to wait for an instance to be ready for example.
func (s *API) WaitForInstance(req *WaitForInstanceRequest, opts ...scw.RequestOption) (*Instance, error) {
timeout := defaultTimeout
if req.Timeout != nil {
timeout = *req.Timeout
}
retryInterval := defaultRetryInterval
if req.RetryInterval != nil {
retryInterval = *req.RetryInterval
}
terminalStatus := map[InstanceStatus]struct{}{
InstanceStatusReady: {},
InstanceStatusDiskFull: {},
InstanceStatusError: {},
}
instance, err := async.WaitSync(&async.WaitSyncConfig{
Get: func() (interface{}, bool, error) {
res, err := s.GetInstance(&GetInstanceRequest{
InstanceID: req.InstanceID,
Region: req.Region,
}, opts...)
if err != nil {
return nil, false, err
}
_, isTerminal := terminalStatus[res.Status]
return res, isTerminal, nil
},
Timeout: timeout,
IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
})
if err != nil {
return nil, errors.Wrap(err, "waiting for instance failed")
}
return instance.(*Instance), nil
}
type WaitForInstanceLogRequest struct {
InstanceLogID string
Region scw.Region
Timeout *time.Duration
RetryInterval *time.Duration
}
// WaitForInstanceLog waits for the instance logs to be in a "terminal state" before returning.
// This function can be used to wait for an instance logs to be ready for example.
func (s *API) WaitForInstanceLog(req *WaitForInstanceLogRequest, opts ...scw.RequestOption) (*InstanceLog, error) {
timeout := defaultTimeout
if req.Timeout != nil {
timeout = *req.Timeout
}
retryInterval := defaultRetryInterval
if req.RetryInterval != nil {
retryInterval = *req.RetryInterval
}
terminalStatus := map[InstanceLogStatus]struct{}{
InstanceLogStatusReady: {},
InstanceLogStatusError: {},
}
logs, err := async.WaitSync(&async.WaitSyncConfig{
Get: func() (interface{}, bool, error) {
res, err := s.GetInstanceLog(&GetInstanceLogRequest{
Region: req.Region,
}, opts...)
if err != nil {
return nil, false, err
}
_, isTerminal := terminalStatus[res.Status]
return res, isTerminal, nil
},
Timeout: timeout,
IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
})
if err != nil {
return nil, errors.Wrap(err, "waiting for instance logs failed")
}
return logs.(*InstanceLog), nil
}
// WaitForReadReplicaRequest is used by WaitForReadReplica method.
type WaitForReadReplicaRequest struct {
ReadReplicaID string
Region scw.Region
Timeout *time.Duration
RetryInterval *time.Duration
}
// WaitForReadReplica waits for the read replica to be in a "terminal state" before returning.
// This function can be used to wait for a read replica to be ready for example.
func (s *API) WaitForReadReplica(req *WaitForReadReplicaRequest, opts ...scw.RequestOption) (*ReadReplica, error) {
timeout := defaultTimeout
if req.Timeout != nil {
timeout = *req.Timeout
}
retryInterval := defaultRetryInterval
if req.RetryInterval != nil {
retryInterval = *req.RetryInterval
}
terminalStatus := map[ReadReplicaStatus]struct{}{
ReadReplicaStatusReady: {},
ReadReplicaStatusError: {},
}
readReplica, err := async.WaitSync(&async.WaitSyncConfig{
Get: func() (interface{}, bool, error) {
res, err := s.GetReadReplica(&GetReadReplicaRequest{
ReadReplicaID: req.ReadReplicaID,
Region: req.Region,
}, opts...)
if err != nil {
return nil, false, err
}
_, isTerminal := terminalStatus[res.Status]
return res, isTerminal, nil
},
Timeout: timeout,
IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
})
if err != nil {
return nil, errors.Wrap(err, "waiting for read replica failed")
}
return readReplica.(*ReadReplica), nil
}
|
