Class: SimpleHttp

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

Overview

Wrapper around ruby’s standard net/http classes. Currently, only GET and POST https methods are supported. SimpleHttp provides class methods get and post to handle basic functionality. In case more complicated requests need to be made or default settings need to be overriden, it’s possible to instantiate SimpleHttp and use instance methods get and put.

Features:

  • Handles Redirects automatically

  • Proxy used transparently if http_proxy environment variable is set.

  • SSL handled automatically

  • fault tolerant uri, e.g. all of these would work:

“www.example.com”, “www.example.com/”, “www.example.com”

Some usage examples: # plain GET (using class methods) SimpleHttp.get “www.example.com”

# POST using the instance methods uri = URI.parse “www.example.com/index.html” sh = SimpleHttp uri sh.set_proxy “my.proxy”, “8080” sh.post => “query_data”

# POST using class methods. binaryData = getImage SimpleData.post binaryData, “image/png”

# GET requst with a custom request_header sh = SimpleHttp.new “www.example.com” sh.request_headers= ‘X-Special-Http-Header’=>‘my-value’ sh.get

Constant Summary collapse

VERSION = 
'0.1.3'
RESPONSE_HANDLERS = 
{
  Net::HTTPResponse => lambda { |request, response, http| 
    response.each_header {|key, value|
      http.response_headers[key]=value 
    }
    raise "#{response.to_s} : #{response.code} : #{http.uri}"
  },
  Net::HTTPSuccess => lambda { |request, response, http|
    response.each_header {|key, value|
      http.response_headers[key]=value 
    }
    #http.cookies += response.cookies
    if request.class == Net::HTTP::Head || request.class == Net::HTTP::Options
      return http.response_headers 
    end
    return response.body
  },
  Net::HTTPRedirection =>  lambda { |request, response, http|
    raise "too many redirects!" unless http.follow_num_redirects > 0  
    # create a new SimpleHttp for the location
    # refered to decreasing the remaining redirects
    # by one.
    
    if (location = response['location']) !~ /^https?:\/\//
      new_location = "#{http.uri.scheme}://#{http.uri.host}"
      if location =~ /^\//
        new_location += location
      else
        new_location += "/#{http.uri.path}/#{location}"
      end
      location = new_location  
    end

    sh = SimpleHttp.new location 
    #STDERR.puts location 
    sh.follow_num_redirects = http.follow_num_redirects-1

    # copy the response handlers used in the current
    # request in case they were non standard.
    sh.response_handlers = http.response_handlers

    # copy the request headers
    sh.request_headers=http.request_headers
    sh.response_headers=http.response_headers
    #sh.cookies+=http.cookies

    # copy host and port
    sh.uri.host = http.uri.host
    sh.uri.port = http.uri.port

    # HTTP doesn't permit redirects for methods other than
    # GET or HEAD. The exception is 303 redirects, which
    # should automatically follow the redirect URI using a
    # GET method regardless of the initial method. For
    # other classes of redirection, the client is required
    # to prompt the user before redirection occurs. Because
    # that's not a feasible action for this library, all
    # 3xx redirect URIs are followed using a GET method. 
    #
    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

    case request
    when  Net::HTTP::Get, 
      Net::HTTP::Head,
      Net::HTTP::Options
      
      sh.get
    when Net::HTTP::Post
      sh.request_headers['content-length']=nil
      sh.get
      else 
        raise "Not a valid HTTP method for redirection: #{request.class}"
    end

  }

}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(uri) ⇒ SimpleHttp

SimpleHttp can either be used directly through the get and post class methods or be instantiated, in case you need to to add custom behaviour to the requests.

Example: http = SimpleHttp.new(URI.parse(“www.example.com”)) http = SimpleHttp.new “www.example.com” http = SimpleHttp.new “usr:[email protected]:1234”

Parameters:

  • may —

    be a URI or a String.



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
 
# File 'lib/simplehttp.rb', line 140

def initialize uri
  set_proxy ENV['http_proxy'] if ENV['http_proxy']
          
  if uri.class == String

    unless uri =~ /^https?:\/\//
      uri = "http://#{uri}"
    end

    uri = URI.parse uri

  end
  @uri = uri
  if !@uri.path || "" == @uri.path.strip
    @uri.path="/"
  end


  @request_headers={}
  @response_headers={}
  @cookies=[]
  @response_handlers=RESPONSE_HANDLERS.clone
  @follow_num_redirects=5

  if @uri.user
    basic_authentication @uri.user, @uri.password
  end

end

Instance Attribute Details

#follow_num_redirects ⇒ Object

Returns the value of attribute follow_num_redirects.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def follow_num_redirects
  @follow_num_redirects
end

#proxy_host ⇒ Object

Returns the value of attribute proxy_host.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def proxy_host
  @proxy_host
end

#proxy_port ⇒ Object

Returns the value of attribute proxy_port.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def proxy_port
  @proxy_port
end

#proxy_pwd ⇒ Object

Returns the value of attribute proxy_pwd.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def proxy_pwd
  @proxy_pwd
end

#proxy_user ⇒ Object

Returns the value of attribute proxy_user.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def proxy_user
  @proxy_user
end

#request_headers ⇒ Object

Returns the value of attribute request_headers.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def request_headers
  @request_headers
end

#response_handlers ⇒ Object

Returns the value of attribute response_handlers.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def response_handlers
  @response_handlers
end

#response_headers ⇒ Object

Returns the value of attribute response_headers.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def response_headers
  @response_headers
end

#uri ⇒ Object

Returns the value of attribute uri.



51
52
53
 
# File 'lib/simplehttp.rb', line 51

def uri
  @uri
end

Class Method Details

.get(uri, query = nil) ⇒ Object

Make a simple GET request to the provided URI.

Example: puts(SimpleHttp.get(“www.example.com”))



338
339
340
341
 
# File 'lib/simplehttp.rb', line 338

def self.get uri, query=nil
  http = SimpleHttp.new uri
  http.get query 
end

.head(uri, query = nil) ⇒ Object 



343
344
345
346
 
# File 'lib/simplehttp.rb', line 343

def self.head uri, query=nil
  http = SimpleHttp.new uri
  http.head query
end

.options(uri) ⇒ Object 



348
349
350
351
 
# File 'lib/simplehttp.rb', line 348

def self.options uri
  http = SimpleHttp.new uri
  http.options 
end

.post(uri, query = nil, content_type = 'application/x-www-form-urlencoded') ⇒ Object

Make a POST request to the provided URI.

Example: puts(SimpleHttp.post(“www.example.com”, “query”=>“my_query”))

Alternatively, you can post any sort of data, but will have to set the appriate content_type:

SimpleHttp.post(“www.example.com/”, binary_data, “img/png”)



368
369
370
371
 
# File 'lib/simplehttp.rb', line 368

def self.post uri, query=nil, content_type='application/x-www-form-urlencoded'
  http = SimpleHttp.new uri
  http.post query, content_type
end

.trace(uri) ⇒ Object 



353
354
355
356
 
# File 'lib/simplehttp.rb', line 353

def self.trace uri
  http = SimpleHttp.new uri
  http.trace
end

Instance Method Details

#basic_authentication(usr, pwd) ⇒ Object

Provides facilities to perform http basic authentication. You don’t need to provide usr and pwd if they are already included in the uri, i.e. user:[email protected]/



176
177
178
179
180
 
# File 'lib/simplehttp.rb', line 176

def basic_authentication usr, pwd
  str = Base64.encode64("#{usr}:#{pwd}")
  str = "Basic #{str}"
  @request_headers["Authorization"]=str
end

#do_http(request) ⇒ Object

internal



310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/simplehttp.rb', line 310

def do_http request
  response = nil

  http = Net::HTTP.new(@uri.host, @uri.port, @proxy_host,
    @proxy_port, @proxy_user, @proxy_pwd)
  http.use_ssl = @uri.scheme == 'https'

  # add custom request headers.
  
  @request_headers.each {|key,value|
    request[key]=value;
  }

  handle_response(request, http.request(request));
end

#get(query = nil) ⇒ Object

Call the get method as an instance method if you need to modify the default behaviour of the library, or set special headers:

http = SimpleHttp.new “www.example.com” http.request_headers=“whatever” str = http.get



380
381
382
383
384
385
386
387
388
389
 
# File 'lib/simplehttp.rb', line 380

def get query = nil
  if (query = make_query query)
    @uri.query = @uri.query ? @uri.query+"&"+query : query
  end
  full_path = @uri.path + (@uri.query ? "?#{@uri.query}" : "")
    
  req = Net::HTTP::Get.new(full_path)
  # puts Net::HTTP::Proxy(@proxy_host, @proxy_port, @proxy_user, @proxy_pwd).get(@uri)
  do_http req
end

#handle_response(http_request, http_response) ⇒ Object

interal Takes a HTTPResponse (or subclass) and determines how to handle the response. Default behaviour is:

HTTPSuccess : return the body of the response HTTPRedirection : follow the redirect until success. default : raise the HTTPResponse.

the default behaviour can be overidden by registering a response handler using the register_response_handler method.



287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/simplehttp.rb', line 287

def handle_response http_request, http_response
  raise "Not a Net::HTTPResponse" unless http_response.is_a? Net::HTTPResponse
  
  c = http_response.class
  while c!=Object
    # the response_handlers hash contains a handler
    # for the specific response class.
    if @response_handlers[c]
    #STDERR.puts "!#{http_response.class}"
    #STDERR.puts "!#{@response_handlers[c]}"
      return @response_handlers[c].call(http_request, http_response, self)
    end

    c=c.superclass
  end  

  # if we reached this place, no handler was registered
  # for this response. default is to return the response.
  
  return http_response
end

#head(query = nil) ⇒ Object

Call the head method as an instance method.



393
394
395
396
397
398
399
400
401
402
 
# File 'lib/simplehttp.rb', line 393

def head query = nil
  if (query = make_query query)
    @uri.query = @uri.query ? @uri.query+"&"+query : query
  end
  full_path = @uri.path + (@uri.query ? "?#{@uri.query}" : "")
    
  req = Net::HTTP::Head.new(full_path)
  # puts Net::HTTP::Proxy(@proxy_host, @proxy_port, @proxy_user, @proxy_pwd).get(@uri)
  do_http req
end

#make_query(query) ⇒ Object

internal



327
328
329
330
331
332
 
# File 'lib/simplehttp.rb', line 327

def make_query query
  return query unless query && query.class == Hash
  query.inject([]) do |s, (key, value)|
    s << CGI::escape(key) + "=" + CGI::escape(value)
  end.join('&')
end

#options ⇒ Object

Call http options method. Returns the response



405
406
407
408
409
 
# File 'lib/simplehttp.rb', line 405

def options
  # we don't support sending a payload in options' body.
  req = Net::HTTP::Options.new(@uri.path)
  do_http req
end

#post(query = nil, content_type = 'application/x-www-form-urlencoded') ⇒ Object

Post the query data to the url. The body of the request remains empty if query=nil. In case query is a Hash, it’s assumed that we are sending a form. In case query is a String, it’s also assumed that a form is being sent, UNLESS the content_type parameter is set.



426
427
428
429
430
431
432
433
434
 
# File 'lib/simplehttp.rb', line 426

def post query=nil, content_type='application/x-www-form-urlencoded'
  req = Net::HTTP::Post.new(@uri.path)

  req.body= make_query query if query
  req.content_type=content_type if query
  req.content_length=query ? req.body.length : 0

  do_http req
end

#register_response_handler(clazz, &block) ⇒ Object

this method can be used to register response handlers for specific http responses in case you need to override the default behaviour. Defaults are:

HTTPSuccess : return the body of the response HTTPRedirection : follow the redirection until success Others : raise an exception

clazz is the subclass of HTTPResponse (or HTTPResponse in case you want to define “default” behaviour) that you are registering the handler for.

block is the handler itself, if a response of the appropriate class is received, block is called with three parameters: the the Net::HTTPRequest, the actual HTTPResponse object that was received and a reference to the instance of SimpleHttp that is executing the call.

example:

# to override the default action of following a HTTP # redirect, you could register the folllowing handler:

sh = SimpleHttp “www.example.com” sh.register_response_handler Net::HTTPRedirection {|request, response, shttp| response }



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

def register_response_handler clazz, &block
  c = clazz
        while c != Object
    # completely unnecessary sanity check to make sure parameter
    # `clazz` is in fact a HTTPResponse ...
    if c == Net::HTTPResponse
      @response_handlers[clazz]=block 
      return
    end
    c = c.superclass
  end

  raise "Trying to register a response handler for non-response class: #{clazz}" 
end

#set_proxy(proxy, port = nil, user = nil, pwd = nil) ⇒ Object 



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
 
# File 'lib/simplehttp.rb', line 248

def set_proxy proxy, port=nil, user=nil, pwd=nil
  
  
  if !proxy  
    @proxy_host=@proxy_port=@proxy_user=@proxy_pwd=nil 
    return
  end

  if proxy.class == String 
    if !port && !user && !pwd
      proxy = URI.parse(proxy)
    else 
      @proxy_host= host
      @proxy_port= port
      @proxy_user= user
      @proxy_pwd = pwd
    end
  end
  
  if proxy.class == URI::HTTP 
    @proxy_host= proxy.host
    @proxy_port= proxy.port
    @proxy_user= proxy.user
    @proxy_pwd = proxy.password
  end
end

#trace ⇒ Object 



411
412
413
414
415
 
# File 'lib/simplehttp.rb', line 411

def trace
  # payload? 
  req = Net::HTTP::Trace.new(@uri.path)
  do_http req
end