La rolls des blogs » tips

HTTPClient and SSL verify certificate

Hallelujah — Wed, 12 Jan 2011 11:58:51 +0000

If you as us in my company use self signed certificate and ran into an OpenSSL::SSL::SSLError when using httpclient gem.

Here is how to bypass ssl certificate verification :

The issue :

require 'rubygems'
require 'httpclient'
 
client = HTTPClient.new
url = "https://www.server1.com"
client.get(url)
at depth 1 - 19: self signed certificate in certificate chain
OpenSSL::SSL::SSLError: SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient/session.rb:247:in `connect'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient/session.rb:247:in `ssl_connect'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient/session.rb:639:in `connect'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient/timeout.rb:128:in `timeout'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient/session.rb:631:in `connect'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient/session.rb:522:in `query'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient/session.rb:147:in `query'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient.rb:953:in `do_get_block'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient.rb:765:in `do_request'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient.rb:848:in `protect_keep_alive_disconnected'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient.rb:764:in `do_request'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient.rb:666:in `request'
	from /home/hery/.gem/ruby/1.8/gems/httpclient-2.1.5.2/lib/httpclient.rb:591:in `get'
	from (irb):5

Solution :

client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
client.get(url)

Enumerable grep method in Ruby

Hallelujah — Thu, 19 Aug 2010 13:43:08 +0000

There is some methods that are not very known among ruby developpers.
One of them is Enumerable#grep method.
I would like to share one of the use case I have to face with, and how I implement grep.

Purpose, I have a Hash representing a simple network
I’d like to select all the people related to :patrick with network label as key.

# Say I have this hash
h = {
  :work => { :patrick => [:joana, :elvis] },
  :football => { :patrick => [:john, :fred, :marcus] , :john => [:paul, :patrick]},
  :friends => { :paul => [ :joana, :elisabeth]}
}
# I want this result :
{
  :work => [:joana,:elvis],
  :football => [:john, :fred, :marcus]
}

A solution is to iterate throug each values then select :patrick

  h.inject({}) do |memo,(k,v)|
   if v.has_key?(:patrick)
    memo.merge(k => v[:patrick])
   else 
    memo
   end
  end

Though it works, I think this piece code is not “rubyesque”.

Well, this is a basic case but imagine you have to select X number of variables or more ( :patrick,:paul … etc ) or worse select with a more complex criteria.

After digging into the rdoc documentation, it seems that Enumerable#grep matches our requirements :

It takes a parameter to compare with each elements of the Enumerable
It can take a block that returns the value of matching elements

Well, how can we implement that ?
This code below demonstrate why I love Ruby !

class NetworkPattern
  def initialize(*args)
    @matches = args
  end
 
  def ===(pair)
     key, value = pair
     value.values_at(*@matches).any?
  end
 
  def result(hash)
    hash.values_at(*self).compact.flatten
  end
 
  def exec(hash)
    Hash[ hash.to_a.grep(self){|k,v|  [k,self.result(v)] } ]
  end
 
  def to_a
     @matches
  end
end
 
pattern = NetworkPattern.new(:patrick)
 
Hash[ h.to_a.grep(pattern){|k,v|  [k,pattern.result(v)] } ] 
=> { :work => [:joana, :elvis], :football=>[:john, :fred, :marcus]}
# With somer refactoring, we implement NetworPattern#exec and use it 
pattern.exec(h)
=> { :work => [:joana, :elvis], :football=>[:john, :fred, :marcus]}

Well it may seem more complicated but if you want to select both :patrick and :paul relationships, the code does not change howmany arguments you pass in NetworkPattern.new

pattern = NetworkPattern.new(:patrick, :paul)
pattern.exec(h)
=> { :work => [:joana, :elvis], :football =>[:john, :fred, :marcus], :friends =>[:joana, :elisabeth]}

All the logic belongs to the class NetworkPattern and it uses Enumerable#grep with block return.
In your project you can use something like that since it can be easily tested and more readable.

Bundler default Gemfile and custom Gemfile, example of wirble

Hallelujah — Tue, 29 Jun 2010 13:38:34 +0000

Hi all,
A simple trick I want to share with you if you are using Bundler (or rails 3)
It matters if you want to install wirble gem in your workstation but not in your server

Sometimes, you want to include some gem that are not mandatory for your application to run but you want to use in your workstation. E.g wirble, awesome_print etc … or other debugging tools

Just write something like this in your Gemfile

# Gemfile
if File.exist?(file = File.expand_path('../myGemfile',__FILE__))
  instance_eval(File.read(file))
end

Now in your myGemfile

# myGemfile
gem 'wirble'
gem 'awesome_print'

That’s all! You can now require ‘wirble’ or ‘awesome_print’ in your rails console

Ordered Hash by keys

Hallelujah — Fri, 02 Oct 2009 09:15:50 +0000

Recently, I have to implement my own Hash sorting method. Not really with Hash but with ActiveSupport::OrderedHash

ActiveSupport::OrderedHash

Hash

ActiveSupport::OrderedHash

Arrray

I would like to sort with keys only, not with an array [key, value]

Ok no matter, I implemented my own new SimpleOrderedHash :

require 'active_support/ordered_hash'
class SimpleOrderedHash < ActiveSupport::OrderedHash
 
  # Lets reimplement sort method
  def sort(&block)
    h = self.dup
    h.sort!(&block)
    h
  end
 
  # Lets implement sort! method
  # It uses @keys variable to do the sorting
  def sort!(&block)
    @keys.sort!(&block)
    sync_keys!
    self
  end
 
  # A fancy inspect   
  def inspect
    "#<#{self.class.name} #{Hash.instance_method(:inspect).bind(self).call}>"
  end
end

You can now use it like that :

h = SimpleOrderedHash.new
h.merge!({'second' => 1, 'first' => 5, 'third' => 2.5})
=> #2.5, "second"=>1, "first"=>5}>
 
# sort return a SimpleOrderedHash
result = h.sort do |a,b|
  h[a] <=> h[b]
end
=> #2.5, "second"=>1, "first"=>5}>
 
# and order as I wanted
result.each{ |k,v| puts v }
1
2.5
5
=> ["second", "third", "first"]
 
# sort! change internally the order of a SimpleOrderedHash
h.sort! do |a,b|
  h[b] <=> h[a]
end
h.each{ |k,v| puts v }
5
2.5
1
=> ["first", "third", "second"]

Inspectable accessors

Hallelujah — Wed, 23 Sep 2009 15:49:46 +0000

Hey, it’s been a while I posted here.

So what’s the purpose ? I commonly use script/console to debug my rails applications. Today I wanted to see the values of my custom attributes model without typing model.custom_attribute. So I took a look at ActiveRecord::Base#inspect method. and the default inspect method shows me database fields. Well, let’s do some work to inspect custom attributes.
Say you have a users table with some fields : login,name,encrypted_password.

class User < ActiveRecord::Base
  attr_accessor :heroic_action
end

superman = User.find(1).inspect
superman.heroic_action = "Save the widow and the orphan"
pp superman.inspect
"#Superman",  name: "Clark Kent",
          encrypted_password: "da39a3ee5e6b4b0d3255bfef95601890afd80709">"

Well I also want to know what heroic_action is superman doing. So i have to overwrite inspect method but I would like a DRY solution. That’s why I wrote this code :

EDIT: Just a small change to have inheritance work.

require 'active_support/core_ext/class'
 
module InspectableAttributes
 
  def self.included(base)
    base.class_inheritable_array :inspectable_attributes , :instance_writer => false
    base.extend(ClassMethods)
    base.inspectable_attributes = []
    base.class_eval do 
 
      def inspect
        inspected_values = respond_to?(:attributes_before_type_cast) ? attributes_before_type_cast.map{|k,v| "#{k.to_s}:  #{v.inspect}" } : []
        inspected_values.concat(self.class.inspectable_attributes.map { |attr| "#{attr}: #{send(attr).inspect}" })
        "#<#{self.class.name} #{inspected_values.join(', ')}>"
      end
 
    end
  end
 
  module ClassMethods
    def inspectable_attr_accessor(*args)
      attr_accessor(*args)
      self.inspectable_attributes |= args.map(&:to_s)
    end
  end
 
end

class User < ActiveRecord::Base
  include InspectableAttributes
  inspectable_attr_accessor :heroic_action
end

That’s what I was looking for !!!

superman = User.find(1).inspect
superman.heroic_action = "Save the widow and the orphan"
pp superman.inspect
"#Superman",  name: "Clark Kent",
             encrypted_password: "da39a3ee5e6b4b0d3255bfef95601890afd80709",
             heroic_action: "Save the widow and the orphan">"

Note that this code can be used in any ruby code requiring ‘active_support/core_ext/class’.

Class : to_s or not to_s ? That is the name !

Hallelujah — Fri, 10 Jul 2009 21:22:45 +0000

Many rubyist use the method Class#to_s instead of Class#name

My purpose (shared by some programmers) is that to_s is just a String representation of the Class not its name!!

Imagine you want to store an ordered list of inherited subclasses as a String so you can retrieve the inheritance order of each subclass.

class Parent
  @@subclasses = []
  def self.inherited(subclass)
    @@subclasses << "#{subclass}"
  end
 
  def self.inheritance_order
    @@subclasses.index("#{self}")
  end
end
 
class Child1 < Parent
end
 
class Child2 < Parent
end
 
# etc ...

And now you want to know, the inheritance order of Child2

Child2.inheritance_order
#=> 1

As long as you don’t override Child2.to_s method, this works.

But if you decide to override it ….

 
def Child2.to_s
  "The second child of Parent"
end
 
Child2.inheritance_order
#=> nil

Do you understand what I mean ? My purpose is that Class#to_s is a String representation, so you can do what you want with this method (as long as it returns a String instance)

If you want to write something more reliable, just change Class#to_s by Class#name :

class Parent
  @@subclasses = []
  def self.inherited(subclass)
    @@subclasses << subclass.name
  end
 
  def self.inheritance_order
    @@subclasses.index(self.name)
  end
end

What is your opinion ?