forked from baidubce/bce-sdk-go
-
Notifications
You must be signed in to change notification settings - Fork 0
/
retry.go
118 lines (101 loc) · 3.33 KB
/
retry.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
/*
* Copyright 2017 Baidu, Inc.
*
* 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
*
* https://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.
*/
// retry.go - define the retry policy when making requests to BCE services
package bce
import (
"net"
"net/http"
"time"
"github.com/baidubce/bce-sdk-go/util/log"
)
// RetryPolicy defines the two methods to retry for sending request.
type RetryPolicy interface {
ShouldRetry(BceError, int) bool
GetDelayBeforeNextRetryInMillis(BceError, int) time.Duration
}
// NoRetryPolicy just does not retry.
type NoRetryPolicy struct{}
func (_ *NoRetryPolicy) ShouldRetry(err BceError, attempts int) bool {
return false
}
func (_ *NoRetryPolicy) GetDelayBeforeNextRetryInMillis(
err BceError, attempts int) time.Duration {
return 0 * time.Millisecond
}
func NewNoRetryPolicy() *NoRetryPolicy {
return &NoRetryPolicy{}
}
// BackOffRetryPolicy implements a policy that retries with exponential back-off strategy.
// This policy will keep retrying until the maximum number of retries is reached. The delay time
// will be a fixed interval for the first time then 2 * interval for the second, 4 * internal for
// the third, and so on.
// In general, the delay time will be 2^number_of_retries_attempted*interval. When a maximum of
// delay time is specified, the delay time will never exceed this limit.
type BackOffRetryPolicy struct {
maxErrorRetry int
maxDelayInMillis int64
baseIntervalInMillis int64
}
func (b *BackOffRetryPolicy) ShouldRetry(err BceError, attempts int) bool {
// Do not retry any more when retry the max times
if attempts >= b.maxErrorRetry {
return false
}
if err == nil {
return true
}
// Always retry on IO error
if _, ok := err.(net.Error); ok {
return true
}
// Only retry on a service error
if realErr, ok := err.(*BceServiceError); ok {
switch realErr.StatusCode {
case http.StatusInternalServerError:
log.Warn("retry for internal server error(500)")
return true
case http.StatusBadGateway:
log.Warn("retry for bad gateway(502)")
return true
case http.StatusServiceUnavailable:
log.Warn("retry for service unavailable(503)")
return true
case http.StatusBadRequest:
if realErr.Code != "Http400" {
return false
}
log.Warn("retry for bad request(400)")
return true
}
if realErr.Code == EREQUEST_EXPIRED {
log.Warn("retry for request expired")
return true
}
}
return false
}
func (b *BackOffRetryPolicy) GetDelayBeforeNextRetryInMillis(
err BceError, attempts int) time.Duration {
if attempts < 0 {
return 0 * time.Millisecond
}
delayInMillis := (1 << uint64(attempts)) * b.baseIntervalInMillis
if delayInMillis > b.maxDelayInMillis {
return time.Duration(b.maxDelayInMillis) * time.Millisecond
}
return time.Duration(delayInMillis) * time.Millisecond
}
func NewBackOffRetryPolicy(maxRetry int, maxDelay, base int64) *BackOffRetryPolicy {
return &BackOffRetryPolicy{maxRetry, maxDelay, base}
}