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
|
# frozen_string_literal: true
module Net
module Hippie
# A simple client for connecting with http resources.
class Client
DEFAULT_HEADERS = {
'Accept' => 'application/json',
'Content-Type' => 'application/json',
'User-Agent' => "net/hippie #{Net::Hippie::VERSION}"
}.freeze
attr_accessor :mapper
attr_accessor :read_timeout
attr_accessor :logger
def initialize(
certificate: nil,
headers: DEFAULT_HEADERS,
key: nil,
passphrase: nil,
verify_mode: nil
)
@certificate = certificate
@default_headers = headers
@key = key
@mapper = ContentTypeMapper.new
@passphrase = passphrase
@read_timeout = 30
@verify_mode = verify_mode
@logger = Net::Hippie.logger
end
def execute(uri, request)
response = http_for(normalize_uri(uri)).request(request)
if block_given?
yield request, response
else
response
end
end
def get(uri, headers: {}, body: {}, &block)
request = request_for(Net::HTTP::Get, uri, headers: headers, body: body)
execute(uri, request, &block)
end
def post(uri, headers: {}, body: {}, &block)
type = Net::HTTP::Post
request = request_for(type, uri, headers: headers, body: body)
execute(uri, request, &block)
end
def put(uri, headers: {}, body: {}, &block)
request = request_for(Net::HTTP::Put, uri, headers: headers, body: body)
execute(uri, request, &block)
end
def delete(uri, headers: {}, body: {}, &block)
type = Net::HTTP::Delete
request = request_for(type, uri, headers: headers, body: body)
execute(uri, request, &block)
end
# attempt 1 -> delay 0.1 second
# attempt 2 -> delay 0.2 second
# attempt 3 -> delay 0.4 second
# attempt 4 -> delay 0.8 second
# attempt 5 -> delay 1.6 second
# attempt 6 -> delay 3.2 second
# attempt 7 -> delay 6.4 second
# attempt 8 -> delay 12.8 second
def with_retry(retries: 3)
retries = 0 if retries.nil? || retries.negative?
0.upto(retries) do |n|
attempt(n, retries) do
return yield self
end
end
end
private
attr_reader :default_headers
attr_reader :verify_mode
attr_reader :certificate, :key, :passphrase
def attempt(attempt, max)
yield
rescue *CONNECTION_ERRORS => error
raise error if attempt == max
delay = ((2**attempt) * 0.1) + Random.rand(0.05) # delay + jitter
warn("`#{error.message}` Retry: #{attempt + 1}/#{max} Delay: #{delay}s")
sleep delay
end
def http_for(uri)
http = Net::HTTP.new(uri.host, uri.port)
http.read_timeout = read_timeout
http.use_ssl = uri.scheme == 'https'
http.verify_mode = verify_mode
http.set_debug_output(logger)
apply_client_tls_to(http)
http
end
def request_for(type, uri, headers: {}, body: {})
final_headers = default_headers.merge(headers)
type.new(uri.to_s, final_headers).tap do |x|
x.body = mapper.map_from(final_headers, body) unless body.empty?
end
end
def normalize_uri(uri)
uri.is_a?(URI) ? uri : URI.parse(uri)
end
def private_key(type = OpenSSL::PKey::RSA)
passphrase ? type.new(key, passphrase) : type.new(key)
end
def apply_client_tls_to(http)
return if certificate.nil? || key.nil?
http.cert = OpenSSL::X509::Certificate.new(certificate)
http.key = private_key
end
def warn(message)
logger.warn(message)
end
end
end
end
|
