Class: Net::HTTP::Persistent

Inherits:
Object
  • Object
show all
Defined in:
lib/net/http/persistent.rb

Overview

Persistent connections for Net::HTTP

Net::HTTP::Persistent maintains persistent connections across all the servers you wish to talk to. For each host:port you communicate with a single persistent connection is created.

Multiple Net::HTTP::Persistent objects will share the same set of connections.

For each thread you start a new connection will be created. A Net::HTTP::Persistent connection will not be shared across threads.

You can shut down the HTTP connections when done by calling #shutdown. You should name your Net::HTTP::Persistent object if you intend to call this method.

Example:

require 'net/http/persistent'

uri = URI 'http://example.com/awesome/web/service'

http = Net::HTTP::Persistent.new 'my_app_name'

# perform a GET
response = http.request uri

# create a POST
post_uri = uri + 'create'
post = Net::HTTP::Post.new post_uri.path
post.set_form_data 'some' => 'cool data'

# perform the POST, the URI is always required
response http.request post_uri, post

SSL

SSL connections are automatically created depending upon the scheme of the URI. SSL connections are automatically verified against the default certificate store for your computer. You can override this by changing verify_mode or by specifying an alternate cert_store.

Here are the SSL settings, see the individual methods for documentation:

#certificate

This client’s certificate

#ca_file

The certificate-authority

#cert_store

An SSL certificate store

#private_key

The client’s SSL private key

#reuse_ssl_sessions

Reuse a previously opened SSL session for a new connection

#ssl_version

Which specific SSL version to use

#verify_callback

For server certificate verification

#verify_mode

How connections should be verified

Proxies

A proxy can be set through #proxy= or at initialization time by providing a second argument to ::new. The proxy may be the URI of the proxy server or :ENV which will consult environment variables.

See #proxy= and #proxy_from_env for details.

Headers

Headers may be specified for use in every request. #headers are appended to any headers on the request. #override_headers replace existing headers on the request.

The difference between the two can be seen in setting the User-Agent. Using http.headers['User-Agent'] = 'MyUserAgent' will send “Ruby, MyUserAgent” while http.override_headers['User-Agent'] = 'MyUserAgent' will send “MyUserAgent”.

Tuning

Segregation

By providing an application name to ::new you can separate your connections from the connections of other applications.

Idle Timeout

If a connection hasn’t been used for this number of seconds it will automatically be reset upon the next use to avoid attempting to send to a closed connection. The default value is 5 seconds. nil means no timeout. Set through #idle_timeout.

Reducing this value may help avoid the “too many connection resets” error when sending non-idempotent requests while increasing this value will cause fewer round-trips.

Read Timeout

The amount of time allowed between reading two chunks from the socket. Set through #read_timeout

Open Timeout

The amount of time to wait for a connection to be opened. Set through #open_timeout.

Socket Options

Socket options may be set on newly-created connections. See #socket_options for details.

Non-Idempotent Requests

By default non-idempotent requests will not be retried per RFC 2616. By setting retry_change_requests to true requests will automatically be retried once.

Only do this when you know that retrying a POST or other non-idempotent request is safe for your application and will not create duplicate resources.

The recommended way to handle non-idempotent requests is the following:

require 'net/http/persistent'

uri = URI 'http://example.com/awesome/web/service'
post_uri = uri + 'create'

http = Net::HTTP::Persistent.new 'my_app_name'

post = Net::HTTP::Post.new post_uri.path
# ... fill in POST request

begin
  response = http.request post_uri, post
rescue Net::HTTP::Persistent::Error

  # POST failed, make a new request to verify the server did not process
  # the request
  exists_uri = uri + '...'
  response = http.get exists_uri

  # Retry if it failed
  retry if response.code == '404'
end

The method of determining if the resource was created or not is unique to the particular service you are using. Of course, you will want to add protection from infinite looping.

Connection Termination

If you are done using the Net::HTTP::Persistent instance you may shut down all the connections in the current thread with #shutdown. This is not recommended for normal use, it should only be used when it will be several minutes before you make another HTTP request.

If you are using multiple threads, call #shutdown in each thread when the thread is done making requests. If you don’t call shutdown, that’s OK. Ruby will automatically garbage collect and shutdown your HTTP connections when the thread terminates.

Defined Under Namespace

Classes: Error

Constant Summary collapse

EPOCH =

The beginning of Time

Time.at 0
VERSION =

The version of Net::HTTP::Persistent you are using

'2.6'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name = nil, proxy = nil) ⇒ Persistent

Creates a new Net::HTTP::Persistent.

Set name to keep your connections apart from everybody else’s. Not required currently, but highly recommended. Your library name should be good enough. This parameter will be required in a future version.

proxy may be set to a URI::HTTP or :ENV to pick up proxy options from the environment. See proxy_from_env for details.

In order to use a URI for the proxy you may need to do some extra work beyond URI parsing if the proxy requires a password:

proxy = URI 'http://proxy.example'
proxy.user     = 'AzureDiamond'
proxy.password = 'hunter2'



374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
 
# File 'lib/net/http/persistent.rb', line 374

def initialize name = nil, proxy = nil
  @name = name

  @debug_output     = nil
  @proxy_uri        = nil
  @headers          = {}
  @override_headers = {}
  @http_versions    = {}
  @keep_alive       = 30
  @open_timeout     = nil
  @read_timeout     = nil
  @idle_timeout     = 5
  @socket_options   = []

  @socket_options << [Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1] if
    Socket.const_defined? :TCP_NODELAY

  key = ['net_http_persistent', name].compact
  @generation_key     = [key, 'generations'    ].join('_').intern
  @ssl_generation_key = [key, 'ssl_generations'].join('_').intern
  @request_key        = [key, 'requests'       ].join('_').intern
  @timeout_key        = [key, 'timeouts'       ].join('_').intern

  @certificate        = nil
  @ca_file            = nil
  @private_key        = nil
  @ssl_version        = nil
  @verify_callback    = nil
  @verify_mode        = OpenSSL::SSL::VERIFY_PEER
  @cert_store         = nil

  @generation         = 0 # incremented when proxy URI changes
  @ssl_generation     = 0 # incremented when SSL session variables change
  @reuse_ssl_sessions = true

  @retry_change_requests = false

  self.proxy = proxy if proxy
end

Instance Attribute Details

#ca_file ⇒ Object

An SSL certificate authority. Setting this will set verify_mode to VERIFY_PEER.



197
198
199
 
# File 'lib/net/http/persistent.rb', line 197

def ca_file
  @ca_file
end

#cert_store ⇒ Object

An SSL certificate store. Setting this will override the default certificate store. See verify_mode for more information.



203
204
205
 
# File 'lib/net/http/persistent.rb', line 203

def cert_store
  @cert_store
end

#certificate ⇒ Object

This client’s OpenSSL::X509::Certificate



191
192
193
 
# File 'lib/net/http/persistent.rb', line 191

def certificate
  @certificate
end

#debug_output ⇒ Object

Sends debug_output to this IO via Net::HTTP#set_debug_output.

Never use this method in production code, it causes a serious security hole.



211
212
213
 
# File 'lib/net/http/persistent.rb', line 211

def debug_output
  @debug_output
end

#generation ⇒ Object (readonly)

Current connection generation



216
217
218
 
# File 'lib/net/http/persistent.rb', line 216

def generation
  @generation
end

#generation_key ⇒ Object (readonly)

Where this instance’s connections live in the thread local variables



221
222
223
 
# File 'lib/net/http/persistent.rb', line 221

def generation_key
  @generation_key
end

#headers ⇒ Object (readonly)

Headers that are added to every request using Net::HTTP#add_field



226
227
228
 
# File 'lib/net/http/persistent.rb', line 226

def headers
  @headers
end

#http_versions ⇒ Object (readonly)

Maps host:port to an HTTP version. This allows us to enable version specific features.



232
233
234
 
# File 'lib/net/http/persistent.rb', line 232

def http_versions
  @http_versions
end

#idle_timeout ⇒ Object

Maximum time an unused connection can remain idle before being automatically closed.



238
239
240
 
# File 'lib/net/http/persistent.rb', line 238

def idle_timeout
  @idle_timeout
end

#keep_alive ⇒ Object

The value sent in the Keep-Alive header. Defaults to 30. Not needed for HTTP/1.1 servers.

This may not work correctly for HTTP/1.0 servers

This method may be removed in a future version as RFC 2616 does not require this header.



249
250
251
 
# File 'lib/net/http/persistent.rb', line 249

def keep_alive
  @keep_alive
end

#name ⇒ Object (readonly)

A name for this connection. Allows you to keep your connections apart from everybody else’s.



255
256
257
 
# File 'lib/net/http/persistent.rb', line 255

def name
  @name
end

#open_timeout ⇒ Object

Seconds to wait until a connection is opened. See Net::HTTP#open_timeout



260
261
262
 
# File 'lib/net/http/persistent.rb', line 260

def open_timeout
  @open_timeout
end

#override_headers ⇒ Object (readonly)

Headers that are added to every request using Net::HTTP#[]=



265
266
267
 
# File 'lib/net/http/persistent.rb', line 265

def override_headers
  @override_headers
end

#private_key ⇒ Object

This client’s SSL private key



270
271
272
 
# File 'lib/net/http/persistent.rb', line 270

def private_key
  @private_key
end

#proxy_uri ⇒ Object (readonly)

The URL through which requests will be proxied



275
276
277
 
# File 'lib/net/http/persistent.rb', line 275

def proxy_uri
  @proxy_uri
end

#read_timeout ⇒ Object

Seconds to wait until reading one block. See Net::HTTP#read_timeout



280
281
282
 
# File 'lib/net/http/persistent.rb', line 280

def read_timeout
  @read_timeout
end

#request_key ⇒ Object (readonly)

Where this instance’s request counts live in the thread local variables



285
286
287
 
# File 'lib/net/http/persistent.rb', line 285

def request_key
  @request_key
end

#retry_change_requests ⇒ Object

Enable retries of non-idempotent requests that change data (e.g. POST requests) when the server has disconnected.

This will in the worst case lead to multiple requests with the same data, but it may be useful for some applications. Take care when enabling this option to ensure it is safe to POST or perform other non-idempotent requests to the server.



355
356
357
 
# File 'lib/net/http/persistent.rb', line 355

def retry_change_requests
  @retry_change_requests
end

#reuse_ssl_sessions ⇒ Object

By default SSL sessions are reused to avoid extra SSL handshakes. Set this to false if you have problems communicating with an HTTPS server like:

SSL_connect [...] read finished A: unexpected message (OpenSSL::SSL::SSLError)



294
295
296
 
# File 'lib/net/http/persistent.rb', line 294

def reuse_ssl_sessions
  @reuse_ssl_sessions
end

#socket_options ⇒ Object (readonly)

An array of options for Socket#setsockopt.

By default the TCP_NODELAY option is set on sockets.

To set additional options append them to this array:

http.socket_options << [Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1]



305
306
307
 
# File 'lib/net/http/persistent.rb', line 305

def socket_options
  @socket_options
end

#ssl_generation ⇒ Object (readonly)

Current SSL connection generation



310
311
312
 
# File 'lib/net/http/persistent.rb', line 310

def ssl_generation
  @ssl_generation
end

#ssl_generation_key ⇒ Object (readonly)

Where this instance’s SSL connections live in the thread local variables



315
316
317
 
# File 'lib/net/http/persistent.rb', line 315

def ssl_generation_key
  @ssl_generation_key
end

#ssl_version ⇒ Object

SSL version to use.

By default, the version will be negotiated automatically between client and server. Ruby 1.9 and newer only.



323
324
325
 
# File 'lib/net/http/persistent.rb', line 323

def ssl_version
  @ssl_version
end

#timeout_key ⇒ Object (readonly)

Where this instance’s last-use times live in the thread local variables



328
329
330
 
# File 'lib/net/http/persistent.rb', line 328

def timeout_key
  @timeout_key
end

#verify_callback ⇒ Object

SSL verification callback. Used when ca_file is set.



333
334
335
 
# File 'lib/net/http/persistent.rb', line 333

def verify_callback
  @verify_callback
end

#verify_mode ⇒ Object

HTTPS verify mode. Defaults to OpenSSL::SSL::VERIFY_PEER which verifies the server certificate.

If no ca_file or cert_store is set the default system certificate store is used.

You can use verify_mode to override any default values.



344
345
346
 
# File 'lib/net/http/persistent.rb', line 344

def verify_mode
  @verify_mode
end

Instance Method Details

#can_retry?(req) ⇒ Boolean

Is the request idempotent or is retry_change_requests allowed

Returns:

  • (Boolean) 


607
608
609
 
# File 'lib/net/http/persistent.rb', line 607

def can_retry? req
  retry_change_requests or idempotent?(req)
end

#cleanup(generation, thread = Thread.current, generation_key = @generation_key) ⇒ Object

Finishes all connections on the given thread that were created before the given generation in the threads generation_key list.

See #shutdown for a bunch of scary warning about misusing this method.



448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
 
# File 'lib/net/http/persistent.rb', line 448

def cleanup(generation, thread = Thread.current,
            generation_key = @generation_key) # :nodoc:
  timeouts = thread[@timeout_key]

  (0...generation).each do |old_generation|
    next unless thread[generation_key]

    conns = thread[generation_key].delete old_generation

    conns.each_value do |conn|
      finish conn, thread

      timeouts.delete conn.object_id if timeouts
    end if conns
  end
end

#connection_close?(header) ⇒ Boolean

Workaround for missing Net::HTTPRequest#connection_close? on Ruby 1.8

Returns:

  • (Boolean) 


615
616
617
 
# File 'lib/net/http/persistent.rb', line 615

def connection_close? header
  header.connection_close?
end

#connection_for(uri) ⇒ Object

Creates a new connection for uri



468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# File 'lib/net/http/persistent.rb', line 468

def connection_for uri
  Thread.current[@generation_key]     ||= Hash.new { |h,k| h[k] = {} }
  Thread.current[@ssl_generation_key] ||= Hash.new { |h,k| h[k] = {} }
  Thread.current[@request_key]        ||= Hash.new 0
  Thread.current[@timeout_key]        ||= Hash.new EPOCH

  use_ssl = uri.scheme.downcase == 'https'

  if use_ssl then
    ssl_generation = @ssl_generation

    ssl_cleanup ssl_generation

    connections = Thread.current[@ssl_generation_key][ssl_generation]
  else
    generation = @generation

    cleanup generation

    connections = Thread.current[@generation_key][generation]
  end

  net_http_args = [uri.host, uri.port]
  connection_id = net_http_args.join ':'

  if @proxy_uri then
    connection_id << @proxy_connection_id
    net_http_args.concat @proxy_args
  end

  connection = connections[connection_id]

  unless connection = connections[connection_id] then
    connections[connection_id] = http_class.new(*net_http_args)
    connection = connections[connection_id]
    ssl connection if use_ssl
  else
    reset connection if expired? connection
  end

  unless connection.started? then
    connection.set_debug_output @debug_output if @debug_output
    connection.open_timeout = @open_timeout if @open_timeout
    connection.read_timeout = @read_timeout if @read_timeout

    connection.start

    socket = connection.instance_variable_get :@socket

    if socket then # for fakeweb
      @socket_options.each do |option|
        socket.io.setsockopt(*option)
      end
    end
  end

  connection
rescue Errno::ECONNREFUSED
  raise Error, "connection refused: #{connection.address}:#{connection.port}"
rescue Errno::EHOSTDOWN
  raise Error, "host down: #{connection.address}:#{connection.port}"
end

#connection_keep_alive?(header) ⇒ Boolean

Workaround for missing Net::HTTPRequest#connection_keep_alive? on Ruby 1.8

Returns:

  • (Boolean) 


622
623
624
 
# File 'lib/net/http/persistent.rb', line 622

def connection_keep_alive? header
  header.connection_keep_alive?
end

#error_message(connection) ⇒ Object

Returns an error message containing the number of requests performed on this connection



535
536
537
538
539
540
541
542
543
 
# File 'lib/net/http/persistent.rb', line 535

def error_message connection
  requests = Thread.current[@request_key][connection.object_id] - 1 # fixup
  last_use = Thread.current[@timeout_key][connection.object_id]

  age = Time.now - last_use

  "after #{requests} requests on #{connection.object_id}, " \
    "last used #{age} seconds ago"
end

#escape(str) ⇒ Object

URI::escape wrapper



548
549
550
 
# File 'lib/net/http/persistent.rb', line 548

def escape str
  CGI.escape str if str
end

#expired?(connection) ⇒ Boolean

Returns true if the connection should be reset due to an idle timeout, false otherwise.

Returns:

  • (Boolean) 


556
557
558
559
560
561
562
563
 
# File 'lib/net/http/persistent.rb', line 556

def expired? connection
  return false unless @idle_timeout
  return true  if     @idle_timeout.zero?

  last_used = Thread.current[@timeout_key][connection.object_id]

  Time.now - last_used > @idle_timeout
end

#finish(connection, thread = Thread.current) ⇒ Object

Finishes the Net::HTTP connection



568
569
570
571
572
573
574
575
 
# File 'lib/net/http/persistent.rb', line 568

def finish connection, thread = Thread.current
  if requests = thread[@request_key] then
    requests.delete connection.object_id
  end

  connection.finish
rescue IOError
end

#http_class ⇒ Object

:nodoc:



577
578
579
580
581
582
583
584
 
# File 'lib/net/http/persistent.rb', line 577

def http_class # :nodoc:
  if [:FakeWeb, :WebMock].any? { |klass| Object.const_defined?(klass) } or
    not @reuse_ssl_sessions then
      Net::HTTP
  else
    Net::HTTP::Persistent::SSLReuse
  end
end

#http_version(uri) ⇒ Object

Returns the HTTP protocol version for uri



589
590
591
 
# File 'lib/net/http/persistent.rb', line 589

def http_version uri
  @http_versions["#{uri.host}:#{uri.port}"]
end

#idempotent?(req) ⇒ Boolean

Is req idempotent according to RFC 2616?

Returns:

  • (Boolean) 


596
597
598
599
600
601
602
 
# File 'lib/net/http/persistent.rb', line 596

def idempotent? req
  case req
  when Net::HTTP::Delete, Net::HTTP::Get, Net::HTTP::Head,
       Net::HTTP::Options, Net::HTTP::Put, Net::HTTP::Trace then
    true
  end
end

#max_age ⇒ Object

Deprecated in favor of #expired?



646
647
648
649
650
 
# File 'lib/net/http/persistent.rb', line 646

def max_age # :nodoc:
  return Time.now + 1 unless @idle_timeout

  Time.now - @idle_timeout
end

#normalize_uri(uri) ⇒ Object

Adds “http://” to the String uri if it is missing.



655
656
657
 
# File 'lib/net/http/persistent.rb', line 655

def normalize_uri uri
  (uri =~ /^https?:/) ? uri : "http://#{uri}"
end

#pipeline(uri, requests, &block) ⇒ Object

Pipelines requests to the HTTP server at uri yielding responses if a block is given. Returns all responses recieved.

See Net::HTTP::Pipeline for further details.

Only if net-http-pipeline was required before net-http-persistent #pipeline will be present.



670
671
672
673
674
 
# File 'lib/net/http/persistent.rb', line 670

def pipeline uri, requests, &block # :yields: responses
  connection = connection_for uri

  connection.pipeline requests, &block
end

#proxy=(proxy) ⇒ Object

Sets the proxy server. The proxy may be the URI of the proxy server, the symbol :ENV which will read the proxy from the environment or nil to disable use of a proxy. See #proxy_from_env for details on setting the proxy from the environment.

If the proxy URI is set after requests have been made, the next request will shut-down and re-open all connections.

If you are making some requests through a proxy and others without a proxy use separate Net::Http::Persistent instances.



697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
 
# File 'lib/net/http/persistent.rb', line 697

def proxy= proxy
  @proxy_uri = case proxy
               when :ENV      then proxy_from_env
               when URI::HTTP then proxy
               when nil       then # ignore
               else raise ArgumentError, 'proxy must be :ENV or a URI::HTTP'
               end

  if @proxy_uri then
    @proxy_args = [
      @proxy_uri.host,
      @proxy_uri.port,
      @proxy_uri.user,
      @proxy_uri.password,
    ]

    @proxy_connection_id = [nil, *@proxy_args].join ':'
  end

  reconnect
  reconnect_ssl
end

#proxy_from_env ⇒ Object

Creates a URI for an HTTP proxy server from ENV variables.

If HTTP_PROXY is set a proxy will be returned.

If HTTP_PROXY_USER or HTTP_PROXY_PASS are set the URI is given the indicated user and password unless HTTP_PROXY contains either of these in the URI.

For Windows users, lowercase ENV variables are preferred over uppercase ENV variables.



732
733
734
735
736
737
738
739
740
741
742
743
744
745
 
# File 'lib/net/http/persistent.rb', line 732

def proxy_from_env
  env_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']

  return nil if env_proxy.nil? or env_proxy.empty?

  uri = URI normalize_uri env_proxy

  unless uri.user or uri.password then
    uri.user     = escape ENV['http_proxy_user'] || ENV['HTTP_PROXY_USER']
    uri.password = escape ENV['http_proxy_pass'] || ENV['HTTP_PROXY_PASS']
  end

  uri
end

#reconnect ⇒ Object

Forces reconnection of HTTP connections.



750
751
752
 
# File 'lib/net/http/persistent.rb', line 750

def reconnect
  @generation += 1
end

#reconnect_ssl ⇒ Object

Forces reconnection of SSL connections.



757
758
759
 
# File 'lib/net/http/persistent.rb', line 757

def reconnect_ssl
  @ssl_generation += 1
end

#request(uri, req = nil, &block) ⇒ Object

Makes a request on uri. If req is nil a Net::HTTP::Get is performed against uri.

If a block is passed #request behaves like Net::HTTP#request (the body of the response will not have been read).

req must be a Net::HTTPRequest subclass (see Net::HTTP for a list).

If there is an error and the request is idempontent according to RFC 2616 it will be retried automatically.



789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
 
# File 'lib/net/http/persistent.rb', line 789

def request uri, req = nil, &block
  retried      = false
  bad_response = false

  req = Net::HTTP::Get.new uri.request_uri unless req

  @headers.each do |pair|
    req.add_field(*pair)
  end

  @override_headers.each do |name, value|
    req[name] = value
  end

  unless req['Connection'] then
    req.add_field 'Connection', 'keep-alive'
    req.add_field 'Keep-Alive', @keep_alive
  end

  connection = connection_for uri
  connection_id = connection.object_id

  begin
    Thread.current[@request_key][connection_id] += 1
    response = connection.request req, &block

    if connection_close?(req) or
       (response.http_version <= '1.0' and
        not connection_keep_alive?(response)) or
       connection_close?(response) then
      connection.finish
    end
  rescue Net::HTTPBadResponse => e
    message = error_message connection

    finish connection

    raise Error, "too many bad responses #{message}" if
      bad_response or not can_retry? req

    bad_response = true
    retry
  rescue IOError, EOFError, Timeout::Error,
         Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
         Errno::EINVAL, OpenSSL::SSL::SSLError => e

    if retried or not can_retry? req
      due_to = "(due to #{e.message} - #{e.class})"
      message = error_message connection

      finish connection

      raise Error, "too many connection resets #{due_to} #{message}"
    end

    reset connection

    retried = true
    retry
  ensure
    Thread.current[@timeout_key][connection_id] = Time.now
  end

  @http_versions["#{uri.host}:#{uri.port}"] ||= response.http_version

  response
end

#reset(connection) ⇒ Object

Finishes then restarts the Net::HTTP connection



764
765
766
767
768
769
770
771
772
773
774
775
 
# File 'lib/net/http/persistent.rb', line 764

def reset connection
  Thread.current[@request_key].delete connection.object_id
  Thread.current[@timeout_key].delete connection.object_id

  finish connection

  connection.start
rescue Errno::ECONNREFUSED
  raise Error, "connection refused: #{connection.address}:#{connection.port}"
rescue Errno::EHOSTDOWN
  raise Error, "host down: #{connection.address}:#{connection.port}"
end

#shutdown(thread = Thread.current) ⇒ Object

Shuts down all connections for thread.

Uses the current thread by default.

If you’ve used Net::HTTP::Persistent across multiple threads you should call this in each thread when you’re done making HTTP requests.

NOTE: Calling shutdown for another thread can be dangerous!

If the thread is still using the connection it may cause an error! It is best to call #shutdown in the thread at the appropriate time instead!



870
871
872
873
874
875
876
877
878
879
 
# File 'lib/net/http/persistent.rb', line 870

def shutdown thread = Thread.current
  generation = reconnect
  cleanup generation, thread, @generation_key

  ssl_generation = reconnect_ssl
  cleanup ssl_generation, thread, @ssl_generation_key

  thread[@request_key] = nil
  thread[@timeout_key] = nil
end

#shutdown_in_all_threads ⇒ Object

Shuts down all connections in all threads

NOTE: THIS METHOD IS VERY DANGEROUS!

Do not call this method if other threads are still using their connections! Call #shutdown at the appropriate time instead!

Use this method only as a last resort!



891
892
893
894
895
896
897
 
# File 'lib/net/http/persistent.rb', line 891

def shutdown_in_all_threads
  Thread.list.each do |thread|
    shutdown thread
  end

  nil
end

#ssl(connection) ⇒ Object

Enables SSL on connection



902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
 
# File 'lib/net/http/persistent.rb', line 902

def ssl connection
  connection.use_ssl = true

  connection.ssl_version = @ssl_version if @ssl_version

  connection.verify_mode = @verify_mode

  if OpenSSL::SSL::VERIFY_PEER == OpenSSL::SSL::VERIFY_NONE and
     not Object.const_defined?(:I_KNOW_THAT_OPENSSL_VERIFY_PEER_EQUALS_VERIFY_NONE_IS_WRONG) then
    warn <<-WARNING
                           !!!SECURITY WARNING!!!

The SSL HTTP connection to:

#{connection.address}:#{connection.port}

                         !!!MAY NOT BE VERIFIED!!!

On your platform your OpenSSL implementation is broken.

There is no difference between the values of VERIFY_NONE and VERIFY_PEER.

This means that attempting to verify the security of SSL connections may not
work.  This exposes you to man-in-the-middle exploits, snooping on the
contents of your connection and other dangers to the security of your data.

To disable this warning define the following constant at top-level in your
application:

I_KNOW_THAT_OPENSSL_VERIFY_PEER_EQUALS_VERIFY_NONE_IS_WRONG = nil

    WARNING
  end

  if @ca_file then
    connection.ca_file = @ca_file
    connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
    connection.verify_callback = @verify_callback if @verify_callback
  end

  if @certificate and @private_key then
    connection.cert = @certificate
    connection.key  = @private_key
  end

  connection.cert_store = if @cert_store then
                            @cert_store
                          else
                            store = OpenSSL::X509::Store.new
                            store.set_default_paths
                            store
                          end
end

#ssl_cleanup(generation) ⇒ Object

Finishes all connections that existed before the given SSL parameter generation.



960
961
962
 
# File 'lib/net/http/persistent.rb', line 960

def ssl_cleanup generation # :nodoc:
  cleanup generation, Thread.current, @ssl_generation_key
end