Installation

First of all, prerequisites for installing R with homebrew is XQuartz and homebrew itself. You can find XQuartz here.

The installation itself is just couple of lines:

1
2
3

brew update
brew tap homebrew/science
brew install gcc r

That’s it, to test your environment just type r in the terminal and you will be prompted to r shell. To quit it use q() command.

If you are using zsh shell you also need to disable binding for r(by default it’s mapped for repeating last command). You can do so by adding disable r line to the .zshrc file.

Before we start, here is an image of Dr. Faraday from LOST:

By the way github handle of faraday author is @lostisland. Coincidence? I don’t think so :)

To the work! Let’s look inside the instrumentation middleware:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

module FaradayMiddleware
  class Instrumentation < Faraday::Middleware
    dependency 'active_support/notifications'

    def initialize(app, options = {})
      super(app)
      @name = options.fetch(:name, 'request.faraday')
    end

    def call(env)
      ActiveSupport::Notifications.instrument(@name, env) do
        @app.call(env)
      end
    end
  end
end

Pretty straightforward, we just instrument event 'request.faraday'. If you are not familiar with the ActiveSupport::Notifications mechanism you can read about it here.

We should add this middleware to our faraday connection object:

1
2
3
4
5
6
7

  def connection
    Faraday.new(url: "http://google.com") do |faraday|
      faraday.use FaradayMiddleware::Instrumentation
      faraday.adapter  Faraday.default_adapter
      faraday.response :logger
    end
  end

Let’s subscribe to the request.faraday events with the ActiveSupport::Notifications. You can execute any code inside your subscribe block, save information and time to the file or database for example. I will use rails logger in my example:

1
2
3
4
5
6

ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
  url = env[:url]
  http_method = env[:method].to_s.upcase
  duration = ends - starts
  Rails.logger.info "#{url.host}, #{http_method}, #{url.request_uri}, takes #{duration} seconds"
end

That’s all, you are set and ready, whenever your application will send any request with the faraday connection, it will print request time information to your log file.

This is a short guide on how to setup Jenkins(Hudson) for Rails project with cucumber features. The steps are described for Ubuntu machine. First of all – what is Jenkins?

Jenkins is an award-winning application that monitors executions of repeated jobs, such as building a software project or jobs run by cron. Among those things, current Jenkins focuses on the following two jobs:

• Building/testing software projects continuously, just like CruiseControl or DamageControl. In a nutshell, Jenkins provides an easy-to-use so-called continuous integration system, making it easier for developers to integrate changes to the project, and making it easier for users to obtain a fresh build. The automated, continuous build increases the productivity.
• Monitoring executions of externally-run jobs, such as cron jobs and procmail jobs, even those that are run on a remote machine. For example, with cron, all you receive is regular e-mails that capture the output, and it is up to you to look at them diligently and notice when it broke. Jenkins keeps those outputs and makes it easy for you to notice when something is wrong.

Let’s install Jenkins with following commands:

1
2
3
4

  wget -q -O - http://pkg.jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add -
  sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian binary/ > /etc/apt/sources.list.d/jenkins.list'
  sudo apt-get update
  sudo apt-get install jenkins

From this point you can start jenkins like this:

1

sudo /etc/init.d/jenkins start

NGINX

Now we need to configure nginx for jenkins, the most basic setup will look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

upstream jenkins {
  server 127.0.0.1:8080;
}

server {
  listen 111.111.111.111:80;
  server_name jenkins.project_name.com *.jenkins.project_name.com;

  try_files $uri @jenkins;

  location @jenkins {
      proxy_pass http://jenkins;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_redirect off;
  }
}

So now jenkins web interface is up and running at jenkins.project_name.com

Jenkins User

Jenkins using jenkins ubuntu user by default. We should add the pair of ssh keys to him, as well as install ruby. For this purposes login as jenkins sudo su jenkins. ssh-keygen -t rsa to generate ssh keys. Install ruby with rvm or your ruby version manager of choice. Also we should add name and email to git for jenkins. So the list of commands will be following:

1
2
3
4
5
6
7
8

sudo su jenkins
ssh-keygen -t rsa
\curl -L https://get.rvm.io | bash -s stable --ruby
echo "source $HOME/.rvm/scripts/rvm" >> ~/.bash_profile
source ~/.bash_profile
rvm install 1.9.3
git config --global user.email "jenkins@example.com"
git config --global user.name "Jenkins Hudson"

Jenkins Plugins

Now let’s install some useful plugins for Jenkins. Go to the Manage Jenkins –> Manage Plugins and check following plugins:

• Git Client Plugin
• GitHub Plugin
• Ruby Plugin
• Rake plugin
• Cucumber plugin

Add project to Jenkins

Now we a ready to add our project to Jenkins. Go to the New Job –> Free-style Navigate to Source Code Management menu and choose Git, enter your git repository address and specify the branch.

Now we only need to specify commands for building our project. Specify “Execute shell script” and add following commands, you may want to change them for your needs:

1
2
3
4
5
6
7

#!/bin/bash -x
source ~/.bash_profile
rvm use 1.9.3
bundle install
cp config/database.yml.example database.yml
rake db:test:prepare RAILS_ENV=test
cucumber

You also may want to add some notifications, for my project i’m using hipchat notification, but the most easiest solution to setup is email notifications. You will need to add SMTP settings in the Manage Jenkins –> System Configurations –> E-mail Notification. After that just specify emails in the project settings.

If you want to run your rspec tests instead of cucumber, or run all together just change your build commands.

That’s all, you are ready to go!

First of all, what is Faraday? It’s an awesome HTTP client library that provides a common interface over many adapters (such as Net::HTTP) and embraces the concept of Rack middleware when processing the request/response cycle. Middleware are classes that implement a call instance method. They hook into the request/response cycle. Our middleware will be hooked to the request cycle.

Now to our middleware. All we need from it is simple checking for errors, such as Faraday::Error::TimeoutError or Faraday::ConnectionFailed. If some errors from the list were araised, than we should switch request to the backup server. So let’s jump to the code:

1
2
3
4
5
6
7
8
9
10
11
12

def call(env)
  begin
    @app.call(env)
  rescue @errmatch
    unless env[:url].host == @options.host
      env[:url].host = @options.host
      retry
    end

    raise
  end
end

call is the main method for almost every faraday middleware. Here we just trying to catch any exception from the list, and switch the url of request if the exception was raised.

You can pass exception that you want to the @errmatch list. Here is the list of defaults:

1
2
3
4

def exceptions
 Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error',
                             Faraday::ConnectionFailed, Faraday::Error::TimeoutError])
end

In the end you can use this middleware like this:

1
2
3
4
5

Faraday.new do |conn|
  conn.use FaradayMiddleware::HostBackup, host: "backup-service.com",
                                          exceptions: [CustomException, 'Timeout::Error']
  conn.adapter ...
end

You can grab this middleware from my repository.

1
2
3
4
5
6
7
8

class SupportBase < ActiveRecord::Base

  self.abstract_class = true

  databases = YAML::load(IO.read('config/database_support.yml'))
  establish_connection(databases[Rails.env])

end

The self.abstract_class = true tells Active Record to not look up for a table, since this class is only used to add customm settings we don’t need any database table for it.

After that we should create a databases.rake file that will wrap database tasks for external database.

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

namespace :support do

  desc "Configure the variables that rails need in order to look up for the db
    configuration in a different folder"
  task :set_custom_db_config_paths do
    # This is the minimum required to tell rails to use a different location
    # for all the files related to the database.
    ENV['SCHEMA'] = 'db_support/schema.rb'
    Rails.application.config.paths['db'] = ['db_support']
    Rails.application.config.paths['db/migrate'] = ['db_support/migrate']
    Rails.application.config.paths['db/seeds'] = ['db_support/seeds.rb']
    Rails.application.config.paths['config/database'] = ['config/database_support.yml']
  end

  namespace :db do
    task :drop => :set_custom_db_config_paths do
      Rake::Task["db:drop"].invoke
    end

    task :create => :set_custom_db_config_paths do
      Rake::Task["db:create"].invoke
    end

    task :migrate => :set_custom_db_config_paths do
      Rake::Task["db:migrate"].invoke
    end

    task :rollback => :set_custom_db_config_paths do
      Rake::Task["db:rollback"].invoke
    end

    task :seed => :set_custom_db_config_paths do
      Rake::Task["db:seed"].invoke
    end
    namespace :test do
      task :prepare => :set_custom_db_config_paths do
        Rake::Task["db:test:prepare"].invoke
      end
    end

    task :version => :set_custom_db_config_paths do
      Rake::Task["db:version"].invoke
    end
  end
end

We basically get all the standart rake database tasks wrapped in the support namespace and redefine application paths, so rake will run this commands on the external database.

Now, let’s create files that we mention in this task:

• db_support folder in the root of application
• db_support/migrate folder for migrations
• db_support/seeds.rb file with the seeds for support database
• config/database_support.yml file with the settings for database connection

Here is an example of database_support.yml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

development:
  adapter: mysql2
  database: support_development
  pool: 5
  username: user
  password: password

test:
  adapter: mysql2
  database: support_test
  pool: 5
  username: user
  password: password

production:
  adapter: mysql2
  database: partners_external
  pool: 5
  ip: 192.168.1.1
  port: 3306
  username: external_username
  password: external_password

The key is that you still want to use local database in the development and for the tests.

At this point we are pretty much done, now we can use commands like bundle exec rake support:db:create to create development and test database. We also still able to use bundle exec rake db:migrate for the default database.

This solution is pretty extensible, so it wouldn’t be hard to add as much databases as you need.