/usr/lib/ruby/1.8/right_http_connection.rb is in libright-http-connection-ruby1.8 1.2.4-0ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 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 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 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 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 | #
# Copyright (c) 2007-2008 RightScale Inc
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
require "net/https"
require "uri"
require "time"
require "logger"
$:.unshift(File.dirname(__FILE__))
require "net_fix"
module RightHttpConnection #:nodoc:
module VERSION #:nodoc:
MAJOR = 1
MINOR = 2
TINY = 4
STRING = [MAJOR, MINOR, TINY].join('.')
end
end
module Rightscale
=begin rdoc
HttpConnection maintains a persistent HTTP connection to a remote
server. Each instance maintains its own unique connection to the
HTTP server. HttpConnection makes a best effort to receive a proper
HTTP response from the server, although it does not guarantee that
this response contains a HTTP Success code.
On low-level errors (TCP/IP errors) HttpConnection invokes a reconnect
and retry algorithm. Note that although each HttpConnection object
has its own connection to the HTTP server, error handling is shared
across all connections to a server. For example, if there are three
connections to www.somehttpserver.com, a timeout error on one of those
connections will cause all three connections to break and reconnect.
A connection will not break and reconnect, however, unless a request
becomes active on it within a certain amount of time after the error
(as specified by HTTP_CONNECTION_RETRY_DELAY). An idle connection will not
break even if other connections to the same server experience errors.
A HttpConnection will retry a request a certain number of times (as
defined by HTTP_CONNNECTION_RETRY_COUNT). If all the retries fail,
an exception is thrown and all HttpConnections associated with a
server enter a probationary period defined by HTTP_CONNECTION_RETRY_DELAY.
If the user makes a new request subsequent to entering probation,
the request will fail immediately with the same exception thrown
on probation entry. This is so that if the HTTP server has gone
down, not every subsequent request must wait for a connect timeout
before failing. After the probation period expires, the internal
state of the HttpConnection is reset and subsequent requests have
the full number of potential reconnects and retries available to
them.
=end
class HttpConnection
# Number of times to retry the request after encountering the first error
HTTP_CONNECTION_RETRY_COUNT = 3
# Throw a Timeout::Error if a connection isn't established within this number of seconds
HTTP_CONNECTION_OPEN_TIMEOUT = 5
# Throw a Timeout::Error if no data have been read on this connnection within this number of seconds
HTTP_CONNECTION_READ_TIMEOUT = 120
# Length of the post-error probationary period during which all requests will fail
HTTP_CONNECTION_RETRY_DELAY = 15
#--------------------
# class methods
#--------------------
#
@@params = {}
@@params[:http_connection_retry_count] = HTTP_CONNECTION_RETRY_COUNT
@@params[:http_connection_open_timeout] = HTTP_CONNECTION_OPEN_TIMEOUT
@@params[:http_connection_read_timeout] = HTTP_CONNECTION_READ_TIMEOUT
@@params[:http_connection_retry_delay] = HTTP_CONNECTION_RETRY_DELAY
# Query the global (class-level) parameters:
#
# :user_agent => 'www.HostName.com' # String to report as HTTP User agent
# :ca_file => 'path_to_file' # Path to a CA certification file in PEM format. The file can contain several CA certificates. If this parameter isn't set, HTTPS certs won't be verified.
# :logger => Logger object # If omitted, HttpConnection logs to STDOUT
# :exception => Exception to raise # The type of exception to raise
# # if a request repeatedly fails. RuntimeError is raised if this parameter is omitted.
# :http_connection_retry_count # by default == Rightscale::HttpConnection::HTTP_CONNECTION_RETRY_COUNT
# :http_connection_open_timeout # by default == Rightscale::HttpConnection::HTTP_CONNECTION_OPEN_TIMEOUT
# :http_connection_read_timeout # by default == Rightscale::HttpConnection::HTTP_CONNECTION_READ_TIMEOUT
# :http_connection_retry_delay # by default == Rightscale::HttpConnection::HTTP_CONNECTION_RETRY_DELAY
def self.params
@@params
end
# Set the global (class-level) parameters
def self.params=(params)
@@params = params
end
#------------------
# instance methods
#------------------
attr_accessor :http
attr_accessor :server
attr_accessor :params # see @@params
attr_accessor :logger
# Params hash:
# :user_agent => 'www.HostName.com' # String to report as HTTP User agent
# :ca_file => 'path_to_file' # A path of a CA certification file in PEM format. The file can contain several CA certificates.
# :logger => Logger object # If omitted, HttpConnection logs to STDOUT
# :exception => Exception to raise # The type of exception to raise if a request repeatedly fails. RuntimeError is raised if this parameter is omitted.
# :http_connection_retry_count # by default == Rightscale::HttpConnection.params[:http_connection_retry_count]
# :http_connection_open_timeout # by default == Rightscale::HttpConnection.params[:http_connection_open_timeout]
# :http_connection_read_timeout # by default == Rightscale::HttpConnection.params[:http_connection_read_timeout]
# :http_connection_retry_delay # by default == Rightscale::HttpConnection.params[:http_connection_retry_delay]
#
def initialize(params={})
@params = params
@params[:http_connection_retry_count] ||= @@params[:http_connection_retry_count]
@params[:http_connection_open_timeout] ||= @@params[:http_connection_open_timeout]
@params[:http_connection_read_timeout] ||= @@params[:http_connection_read_timeout]
@params[:http_connection_retry_delay] ||= @@params[:http_connection_retry_delay]
@http = nil
@server = nil
@logger = get_param(:logger) ||
(RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)) ||
Logger.new(STDOUT)
end
def get_param(name)
@params[name] || @@params[name]
end
# Query for the maximum size (in bytes) of a single read from the underlying
# socket. For bulk transfer, especially over fast links, this is value is
# critical to performance.
def socket_read_size?
Net::BufferedIO.socket_read_size?
end
# Set the maximum size (in bytes) of a single read from the underlying
# socket. For bulk transfer, especially over fast links, this is value is
# critical to performance.
def socket_read_size=(newsize)
Net::BufferedIO.socket_read_size=(newsize)
end
# Query for the maximum size (in bytes) of a single read from local data
# sources like files. This is important, for example, in a streaming PUT of a
# large buffer.
def local_read_size?
Net::HTTPGenericRequest.local_read_size?
end
# Set the maximum size (in bytes) of a single read from local data
# sources like files. This can be used to tune the performance of, for example, a streaming PUT of a
# large buffer.
def local_read_size=(newsize)
Net::HTTPGenericRequest.local_read_size=(newsize)
end
private
#--------------
# Retry state - Keep track of errors on a per-server basis
#--------------
@@state = {} # retry state indexed by server: consecutive error count, error time, and error
@@eof = {}
# number of consecutive errors seen for server, 0 all is ok
def error_count
@@state[@server] ? @@state[@server][:count] : 0
end
# time of last error for server, nil if all is ok
def error_time
@@state[@server] && @@state[@server][:time]
end
# message for last error for server, "" if all is ok
def error_message
@@state[@server] ? @@state[@server][:message] : ""
end
# add an error for a server
def error_add(message)
@@state[@server] = { :count => error_count+1, :time => Time.now, :message => message }
end
# reset the error state for a server (i.e. a request succeeded)
def error_reset
@@state.delete(@server)
end
# Error message stuff...
def banana_message
return "#{@server} temporarily unavailable: (#{error_message})"
end
def err_header
return "#{self.class.name} :"
end
# Adds new EOF timestamp.
# Returns the number of seconds to wait before new conection retry:
# 0.5, 1, 2, 4, 8
def add_eof
(@@eof[@server] ||= []).unshift Time.now
0.25 * 2 ** @@eof[@server].size
end
# Returns first EOF timestamp or nul if have no EOFs being tracked.
def eof_time
@@eof[@server] && @@eof[@server].last
end
# Returns true if we are receiving EOFs during last @params[:http_connection_retry_delay] seconds
# and there were no successful response from server
def raise_on_eof_exception?
@@eof[@server].blank? ? false : ( (Time.now.to_i-@params[:http_connection_retry_delay]) > @@eof[@server].last.to_i )
end
# Reset a list of EOFs for this server.
# This is being called when we have got an successful response from server.
def eof_reset
@@eof.delete(@server)
end
# Detects if an object is 'streamable' - can we read from it, and can we know the size?
def setup_streaming(request)
if(request.body && request.body.respond_to?(:read))
body = request.body
request.content_length = body.respond_to?(:lstat) ? body.lstat.size : body.size
request.body_stream = request.body
true
end
end
def get_fileptr_offset(request_params)
request_params[:request].body.pos
rescue Exception => e
# Probably caught this because the body doesn't support the pos() method, like if it is a socket.
# Just return 0 and get on with life.
0
end
def reset_fileptr_offset(request, offset = 0)
if(request.body_stream && request.body_stream.respond_to?(:pos))
begin
request.body_stream.pos = offset
rescue Exception => e
@logger.warn("Failed file pointer reset; aborting HTTP retries." +
" -- #{err_header} #{e.inspect}")
raise e
end
end
end
# Start a fresh connection. The object closes any existing connection and
# opens a new one.
def start(request_params)
# close the previous if exists
finish
# create new connection
@server = request_params[:server]
@port = request_params[:port]
@protocol = request_params[:protocol]
@logger.info("Opening new #{@protocol.upcase} connection to #@server:#@port")
@http = Net::HTTP.new(@server, @port)
@http.open_timeout = @params[:http_connection_open_timeout]
@http.read_timeout = @params[:http_connection_read_timeout]
if @protocol == 'https'
verifyCallbackProc = Proc.new{ |ok, x509_store_ctx|
code = x509_store_ctx.error
msg = x509_store_ctx.error_string
#debugger
@logger.warn("##### #{@server} certificate verify failed: #{msg}") unless code == 0
true
}
@http.use_ssl = true
ca_file = get_param(:ca_file)
if ca_file
@http.verify_mode = OpenSSL::SSL::VERIFY_PEER
@http.verify_callback = verifyCallbackProc
@http.ca_file = ca_file
end
end
# open connection
@http.start
end
public
=begin rdoc
Send HTTP request to server
request_params hash:
:server => 'www.HostName.com' # Hostname or IP address of HTTP server
:port => '80' # Port of HTTP server
:protocol => 'https' # http and https are supported on any port
:request => 'requeststring' # Fully-formed HTTP request to make
Raises RuntimeError, Interrupt, and params[:exception] (if specified in new).
=end
def request(request_params, &block)
# We save the offset here so that if we need to retry, we can return the file pointer to its initial position
mypos = get_fileptr_offset(request_params)
loop do
# if we are inside a delay between retries: no requests this time!
if error_count > @params[:http_connection_retry_count] &&
error_time + @params[:http_connection_retry_delay] > Time.now
# store the message (otherwise it will be lost after error_reset and
# we will raise an exception with an empty text)
banana_message_text = banana_message
@logger.warn("#{err_header} re-raising same error: #{banana_message_text} " +
"-- error count: #{error_count}, error age: #{Time.now.to_i - error_time.to_i}")
exception = get_param(:exception) || RuntimeError
raise exception.new(banana_message_text)
end
# try to connect server(if connection does not exist) and get response data
begin
request_params[:protocol] ||= (request_params[:port] == 443 ? 'https' : 'http')
request = request_params[:request]
request['User-Agent'] = get_param(:user_agent) || ''
# (re)open connection to server if none exists or params has changed
unless @http &&
@http.started? &&
@server == request_params[:server] &&
@port == request_params[:port] &&
@protocol == request_params[:protocol]
start(request_params)
end
# Detect if the body is a streamable object like a file or socket. If so, stream that
# bad boy.
setup_streaming(request)
response = @http.request(request, &block)
error_reset
eof_reset
return response
# We treat EOF errors and the timeout/network errors differently. Both
# are tracked in different statistics blocks. Note below that EOF
# errors will sleep for a certain (exponentially increasing) period.
# Other errors don't sleep because there is already an inherent delay
# in them; connect and read timeouts (for example) have already
# 'slept'. It is still not clear which way we should treat errors
# like RST and resolution failures. For now, there is no additional
# delay for these errors although this may change in the future.
# EOFError means the server closed the connection on us.
rescue EOFError => e
@logger.debug("#{err_header} server #{@server} closed connection")
@http = nil
# if we have waited long enough - raise an exception...
if raise_on_eof_exception?
exception = get_param(:exception) || RuntimeError
@logger.warn("#{err_header} raising #{exception} due to permanent EOF being received from #{@server}, error age: #{Time.now.to_i - eof_time.to_i}")
raise exception.new("Permanent EOF is being received from #{@server}.")
else
# ... else just sleep a bit before new retry
sleep(add_eof)
# We will be retrying the request, so reset the file pointer
reset_fileptr_offset(request, mypos)
end
rescue Exception => e # See comment at bottom for the list of errors seen...
@http = nil
# if ctrl+c is pressed - we have to reraise exception to terminate proggy
if e.is_a?(Interrupt) && !( e.is_a?(Errno::ETIMEDOUT) || e.is_a?(Timeout::Error))
@logger.debug( "#{err_header} request to server #{@server} interrupted by ctrl-c")
raise
elsif e.is_a?(ArgumentError) && e.message.include?('wrong number of arguments (5 for 4)')
# seems our net_fix patch was overriden...
exception = get_param(:exception) || RuntimeError
raise exception.new('incompatible Net::HTTP monkey-patch')
end
# oops - we got a banana: log it
error_add(e.message)
@logger.warn("#{err_header} request failure count: #{error_count}, exception: #{e.inspect}")
# We will be retrying the request, so reset the file pointer
reset_fileptr_offset(request, mypos)
end
end
end
def finish(reason = '')
if @http && @http.started?
reason = ", reason: '#{reason}'" unless reason.blank?
@logger.info("Closing #{@http.use_ssl? ? 'HTTPS' : 'HTTP'} connection to #{@http.address}:#{@http.port}#{reason}")
@http.finish
end
end
# Errors received during testing:
#
# #<Timeout::Error: execution expired>
# #<Errno::ETIMEDOUT: Connection timed out - connect(2)>
# #<SocketError: getaddrinfo: Name or service not known>
# #<SocketError: getaddrinfo: Temporary failure in name resolution>
# #<EOFError: end of file reached>
# #<Errno::ECONNRESET: Connection reset by peer>
# #<OpenSSL::SSL::SSLError: SSL_write:: bad write retry>
end
end
|