Class: MintHttp::Request

Inherits:
Object
  • Object
show all
Defined in:
lib/mint_http/request.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Request

Returns a new instance of Request.



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
 
# File 'lib/mint_http/request.rb', line 33

def initialize
  @pool = nil
  @base_url = nil
  @headers = {}
  @body_type = nil
  @body = nil
  @query = {}
  @files = []
  @open_timeout = 5
  @write_timeout = 5
  @read_timeout = 20
  @ca = nil
  @cert = nil
  @key = nil
  @proxy_address = nil
  @proxy_port = nil
  @proxy_user = nil
  @proxy_pass = nil
  @ssl_verify_mode = nil
  @ssl_verify_hostname = nil
  @ssl_min_version = nil
  @ssl_max_version = nil

  @logger = MintHttp.config.logger
  @filter_params_list = MintHttp.config.filter_params_list
  @filter_params = MintHttp.config.filter_params

  header('User-Agent' => 'Mint Http')
  as_json
end

Instance Attribute Details

#base_url(url) ⇒ Object (readonly)

Returns the value of attribute base_url.



12
13
14
 
# File 'lib/mint_http/request.rb', line 12

def base_url
  @base_url
end

#body ⇒ Object (readonly)

Returns the value of attribute body.



15
16
17
 
# File 'lib/mint_http/request.rb', line 15

def body
  @body
end

#body_type ⇒ Object (readonly)

Returns the value of attribute body_type.



14
15
16
 
# File 'lib/mint_http/request.rb', line 14

def body_type
  @body_type
end

#ca ⇒ Object (readonly)

Returns the value of attribute ca.



20
21
22
 
# File 'lib/mint_http/request.rb', line 20

def ca
  @ca
end

#cert ⇒ Object (readonly)

Returns the value of attribute cert.



21
22
23
 
# File 'lib/mint_http/request.rb', line 21

def cert
  @cert
end

#headers ⇒ Object (readonly)

Returns the value of attribute headers.



13
14
15
 
# File 'lib/mint_http/request.rb', line 13

def headers
  @headers
end

#method ⇒ Object (readonly)

Attributes only available when request is made



30
31
32
 
# File 'lib/mint_http/request.rb', line 30

def method
  @method
end

#open_timeout ⇒ Object (readonly)

Returns the value of attribute open_timeout.



17
18
19
 
# File 'lib/mint_http/request.rb', line 17

def open_timeout
  @open_timeout
end

#proxy_address ⇒ Object (readonly)

Returns the value of attribute proxy_address.



22
23
24
 
# File 'lib/mint_http/request.rb', line 22

def proxy_address
  @proxy_address
end

#proxy_port ⇒ Object (readonly)

Returns the value of attribute proxy_port.



23
24
25
 
# File 'lib/mint_http/request.rb', line 23

def proxy_port
  @proxy_port
end

#query(queries = {}) ⇒ Object (readonly)

Returns the value of attribute query.



16
17
18
 
# File 'lib/mint_http/request.rb', line 16

def query
  @query
end

#read_timeout ⇒ Object (readonly)

Returns the value of attribute read_timeout.



19
20
21
 
# File 'lib/mint_http/request.rb', line 19

def read_timeout
  @read_timeout
end

#request_url ⇒ Object (readonly)

Returns the value of attribute request_url.



31
32
33
 
# File 'lib/mint_http/request.rb', line 31

def request_url
  @request_url
end

#ssl_max_version ⇒ Object (readonly)

Returns the value of attribute ssl_max_version.



27
28
29
 
# File 'lib/mint_http/request.rb', line 27

def ssl_max_version
  @ssl_max_version
end

#ssl_min_version ⇒ Object (readonly)

Returns the value of attribute ssl_min_version.



26
27
28
 
# File 'lib/mint_http/request.rb', line 26

def ssl_min_version
  @ssl_min_version
end

#ssl_verify_hostname(verify) ⇒ Object (readonly)

Returns the value of attribute ssl_verify_hostname.



25
26
27
 
# File 'lib/mint_http/request.rb', line 25

def ssl_verify_hostname
  @ssl_verify_hostname
end

#ssl_verify_mode(mode) ⇒ Object (readonly)

Returns the value of attribute ssl_verify_mode.



24
25
26
 
# File 'lib/mint_http/request.rb', line 24

def ssl_verify_mode
  @ssl_verify_mode
end

#write_timeout ⇒ Object (readonly)

Returns the value of attribute write_timeout.



18
19
20
 
# File 'lib/mint_http/request.rb', line 18

def write_timeout
  @write_timeout
end

Instance Method Details

#accept(type) ⇒ Object 



174
175
176
 
# File 'lib/mint_http/request.rb', line 174

def accept(type)
  header('Accept' => type)
end

#accept_json ⇒ Object 



178
179
180
 
# File 'lib/mint_http/request.rb', line 178

def accept_json
  accept('application/json; charset=utf-8')
end

#as_form ⇒ Object 



202
203
204
205
 
# File 'lib/mint_http/request.rb', line 202

def as_form
  @body_type = :form
  content_type('application/x-www-form-urlencoded')
end

#as_json ⇒ Object 



197
198
199
200
 
# File 'lib/mint_http/request.rb', line 197

def as_json
  @body_type = :json
  content_type('application/json; charset=utf-8')
end

#as_multipart ⇒ Object 



207
208
209
210
 
# File 'lib/mint_http/request.rb', line 207

def as_multipart
  @body_type = :multipart
  content_type('multipart/form-data')
end

#basic_auth(username, password = '') ⇒ Object 



162
163
164
 
# File 'lib/mint_http/request.rb', line 162

def basic_auth(username, password = '')
  header('Authorization' => 'Basic ' + Base64.strict_encode64("#{username}:#{password}"))
end

#bearer(token) ⇒ Object 



170
171
172
 
# File 'lib/mint_http/request.rb', line 170

def bearer(token)
  token_auth('Bearer', token)
end

#content_type(type) ⇒ Object 



182
183
184
 
# File 'lib/mint_http/request.rb', line 182

def content_type(type)
  header('Content-Type' => type)
end

#delete(url, data = nil) ⇒ Object 



271
272
273
274
 
# File 'lib/mint_http/request.rb', line 271

def delete(url, data = nil)
  @body = data if data
  send_request('delete', url)
end

#filter_param(*params) ⇒ Object

Parameters:

  • params (Array[String]) 


238
239
240
241
 
# File 'lib/mint_http/request.rb', line 238

def filter_param(*params)
  @filter_params_list.concat(params)
  self
end

#get(url, params = {}) ⇒ Object 



248
249
250
 
# File 'lib/mint_http/request.rb', line 248

def get(url, params = {})
  query(params).send_request('get', url)
end

#head(url, params = {}) ⇒ Object 



252
253
254
 
# File 'lib/mint_http/request.rb', line 252

def head(url, params = {})
  query(params).send_request('head', url)
end

#header(headers = {}) ⇒ Object 



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/mint_http/request.rb', line 146

def header(headers = {})
  headers.each do |k, v|
    k = k.downcase.to_s

    if v.nil?
      @headers.delete(k)
      next
    end

    v = v.join(' ;') if Array === v
    @headers[k] = v
  end

  self
end

#no_logger ⇒ Object 



232
233
234
235
 
# File 'lib/mint_http/request.rb', line 232

def no_logger
  @logger = Logger.new('/dev/null')
  self
end

#patch(url, data = nil) ⇒ Object 



266
267
268
269
 
# File 'lib/mint_http/request.rb', line 266

def patch(url, data = nil)
  @body = data if data
  send_request('patch', url)
end

#post(url, data = nil) ⇒ Object 



256
257
258
259
 
# File 'lib/mint_http/request.rb', line 256

def post(url, data = nil)
  @body = data if data
  send_request('post', url)
end

#put(url, data = nil) ⇒ Object 



261
262
263
264
 
# File 'lib/mint_http/request.rb', line 261

def put(url, data = nil)
  @body = data if data
  send_request('put', url)
end

#send_request(method, url) ⇒ Object 



276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/mint_http/request.rb', line 276

def send_request(method, url)
  @method = method

  logger = RequestLogger.new(@logger, @filter_params_list, @filter_params)
  url, net_request, options = build_request(method, url)

  logger.log_request(self, net_request)
  logger.log_start

  begin
    response = with_client(url.hostname, url.port, options) do |http|
      logger.log_connected
      logger.log_connection_info(http)
      net_response = http.request(net_request)

      Response.new(net_response, net_request, self, http)
    end
  rescue StandardError => error
    logger.log_end
    logger.log_error(error)
    logger.write_log

    raise error
  end

  logger.log_end
  logger.log_response(response)
  logger.put_timing(response)
  logger.write_log

  response

rescue SocketError => e
  if e.message.include?('getaddrinfo') || e.cause.is_a?(Resolv::ResolvError) || e.cause.is_a?(Resolv::ResolvTimeout)
    raise NameResolutionError, e.message
  else
    raise ConnectionIoError, e.message
  end

rescue Net::OpenTimeout => e
  raise OpenTimeoutError, e.message
rescue Net::WriteTimeout => e
  raise WriteTimeoutError, e.message
rescue Net::ReadTimeout => e
  raise ReadTimeoutError, e.message

rescue Errno::ECONNREFUSED => e
  raise ConnectionRefusedError, e.message
rescue Errno::ECONNRESET => e
  raise ConnectionResetError, e.message

rescue IOError, EOFError, Errno::EPIPE, Errno::EIO => e
  raise ConnectionIoError, e.message
rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH => e
  raise ConnectionError, e.message

rescue OpenSSL::SSL::SSLError => e
  raise ConnectionSslError, e.message
end

#should_filter_params(filter = true) ⇒ Object 



243
244
245
246
 
# File 'lib/mint_http/request.rb', line 243

def should_filter_params(filter = true)
  @filter_params = filter
  self
end

#ssl_version(min, max) ⇒ Object 



96
97
98
99
100
 
# File 'lib/mint_http/request.rb', line 96

def ssl_version(min, max)
  @ssl_min_version = min
  @ssl_max_version = max
  self
end

#timeout(open, write, read) ⇒ Object 



73
74
75
76
77
78
79
 
# File 'lib/mint_http/request.rb', line 73

def timeout(open, write, read)
  @open_timeout = open
  @write_timeout = write
  @read_timeout = read

  self
end

#token_auth(type, token) ⇒ Object 



166
167
168
 
# File 'lib/mint_http/request.rb', line 166

def token_auth(type, token)
  header('Authorization' => "#{type} #{token}")
end

#use_ca(ca) ⇒ Object 



102
103
104
105
 
# File 'lib/mint_http/request.rb', line 102

def use_ca(ca)
  @ca = ca
  self
end

#use_cert(cert, key) ⇒ Object 



107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/mint_http/request.rb', line 107

def use_cert(cert, key)
  unless OpenSSL::X509::Certificate === cert
    raise ArgumentError, 'Expected an OpenSSL::X509::Certificate'
  end

  unless OpenSSL::PKey::PKey === key
    raise ArgumentError, 'Expected an OpenSSL::PKey::PKey'
  end

  @cert = cert
  @key = key

  self
end

#use_logger(logger) ⇒ Object

Parameters:

  • logger (Logger) 


227
228
229
230
 
# File 'lib/mint_http/request.rb', line 227

def use_logger(logger)
  @logger = logger
  self
end

#use_pool(pool) ⇒ Object

Raises:

  • (ArgumentError) 


64
65
66
67
68
69
70
71
 
# File 'lib/mint_http/request.rb', line 64

def use_pool(pool)
  raise ArgumentError, 'Expected a MintHttp::Pool' unless Pool === pool

  @pool = pool
  header('Connection' => 'keep-alive')

  self
end

#via_proxy(proxy_address, proxy_port = 3128, proxy_user = nil, proxy_pass = nil) ⇒ Object 



122
123
124
125
126
127
128
129
 
# File 'lib/mint_http/request.rb', line 122

def via_proxy(proxy_address, proxy_port = 3128, proxy_user = nil, proxy_pass = nil)
  @proxy_address = proxy_address
  @proxy_port = proxy_port
  @proxy_user = proxy_user
  @proxy_pass = proxy_pass

  self
end

#with_body(raw) ⇒ Object 



186
187
188
189
190
191
192
193
194
195
 
# File 'lib/mint_http/request.rb', line 186

def with_body(raw)
  @body_type = :raw
  @body = raw

  unless @headers['Content-Type']
    content_type('application/octet-stream')
  end

  self
end

#with_file(name, file, filename = nil, content_type = nil) ⇒ Object 



212
213
214
215
216
217
218
219
220
221
222
223
224
 
# File 'lib/mint_http/request.rb', line 212

def with_file(name, file, filename = nil, content_type = nil)
  unless file.respond_to?(:read)
    raise ArgumentError, "File must be an IO or IO like"
  end

  @files << [
    name,
    file,
    { filename: filename, content_type: content_type }.compact
  ]

  self
end