Class: SimpleHttp

Inherits:
Object show all
Defined in:
lib/ramaze/spec/helper/simple_http.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.1'
RESPONSE_HANDLERS = 
{
  Net::HTTPResponse => lambda { |request, response, http|
    response.each_header {|key, value|
      http.response_headers[key]=value
    }
    raise response.to_s
  },
  Net::HTTPSuccess => lambda { |request, response, http|
    response.each_header {|key, value|
      http.response_headers[key]=value
    }
    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.
    sh = SimpleHttp.new response['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

     # 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 of HEAD, so we complain in case
    # we get them in response to a POST request. (Or
    # anything other than GET, for that matter.)

     case request
     when Net::HTTP::Get
       sh.get
     when Net::HTTP::Post
       sh.post
    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.



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
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 169

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={}
  @response_handlers=RESPONSE_HANDLERS.clone
  @follow_num_redirects=3

  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.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def follow_num_redirects
  @follow_num_redirects
end

#proxy_host ⇒ Object

Returns the value of attribute proxy_host.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def proxy_host
  @proxy_host
end

#proxy_port ⇒ Object

Returns the value of attribute proxy_port.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def proxy_port
  @proxy_port
end

#proxy_pwd ⇒ Object

Returns the value of attribute proxy_pwd.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def proxy_pwd
  @proxy_pwd
end

#proxy_user ⇒ Object

Returns the value of attribute proxy_user.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def proxy_user
  @proxy_user
end

#request_headers ⇒ Object

Returns the value of attribute request_headers.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def request_headers
  @request_headers
end

#response_handlers ⇒ Object

Returns the value of attribute response_handlers.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def response_handlers
  @response_handlers
end

#response_headers ⇒ Object

Returns the value of attribute response_headers.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

def response_headers
  @response_headers
end

#uri ⇒ Object

Returns the value of attribute uri.



106
107
108
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 106

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”))



364
365
366
367
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 364

def self.get uri, query=nil
  http = SimpleHttp.new uri
  http.get query
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”)



379
380
381
382
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 379

def self.post uri, query=nil, content_type='application/x-www-form-urlencoded'
  http = SimpleHttp.new uri
  http.post query, content_type
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]/



204
205
206
207
208
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 204

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

#do_http(request) ⇒ Object

internal



336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 336

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



391
392
393
394
395
396
397
398
399
400
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 391

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.



315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 315

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]
      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

#make_query(query) ⇒ Object

internal



353
354
355
356
357
358
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 353

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

#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.



411
412
413
414
415
416
417
418
419
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 411

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 }



240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 240

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 



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
 
# File 'lib/ramaze/spec/helper/simple_http.rb', line 276

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