I was helping a friend integrate an API into the application. He is running Rails 2.3.4 with Authlogic. His authentication check method was the following:
1
2
3
4
5
6
7
8
| def require_user
unless current_user
session[:return_to] = request.request_uri
flash[:notice] = "You must be logged in to access this page"
redirect_to new_user_session_url
return false
end
end |
Although this worked great for the HTML requests, the XML requests were getting HTML response with a redirect to the login page. Not what we were looking for. Instead, the require_user method needed to be aware of the mime-type and return an appropriate response.
Here is the block that responds to the mime-type. Instead of getting an HTML response to an XML request, an XML error reponse with the correct HTTP status code is returned.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| def require_user
unless current_user
respond_to do |format|
format.html {
session[:return_to] = request.request_uri
flash[:notice] = "You must be logged in to access this page"
redirect_to new_user_session_url
}
format.xml {
user = User.new
user.errors.add_to_base("Authentication is required.")
render :xml => user.errors, :status => 401
}
end
return false
end
end |
One thing missing from the color picker in OS X is the ability to see the hex code for a color. An absolute must for web development. Luckily, there is a handy extension to add a pane to the color picker to view the hex code.
When deploying from Capistrano, I like to have the following in my ‘deploy.rb’ file:
set :scm, "git"
set :repository, "git@www.example.com:project.git"
set :git_shallow_clone, 1
set :deploy_via, :remote_cache
This allows speeds deployments by keeping a versions checked out on the server in ‘shared/cached-copy’. When it comes to deploying, it is always best to deploy from a branch instead of the master/head/trunk. To handle this, add the following:
set :branch, fetch(:branch, “master”)
When you deploy, run the following:
$ cap deploy -S branch=REL_1.0
If you don’t specify the branch, the master is used.
It’s a good practice to send a notification to certain people when a new version is deployed. This process can easily be automated in Capistrano. Add the following file to the ‘lib’ directory with the filename ‘cap_mailer.rb’:
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
| require 'rubygems'
require 'actionmailer'
ActionMailer::Base.smtp_settings = {:address => "localhost", :port => 25, :domain => 'example.com'}
class CapMailer < ActionMailer::Base
def deploy_notification(options)
message = "Deployment\n\n"
options.each_pair do |k,v|
message << " #{k}: #{v}\n"
end
recipients "notify-deployment@example.com"
from 'noreply@example.com'
subject "Deployment to #{options[:rails_env]}"
body message
end
end
module CapistranoMailer
def send(options)
CapMailer.deliver_deploy_notification(options)
end
end
Capistrano.plugin :mailer, CapistranoMailer |
In the ‘deploy.rb’ file, add the following:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| require 'lib/cap_mailer'
require 'etc'
namespace :deploy do
desc "Sends an email upon successful deployment"
task :notify do
mailer.send(
:rails_env => rails_env,
:deploy_to => deploy_to,
:branch => branch,
:application => application,
:repository => repository,
:deployment_time => Time.new.to_s,
:deployer_username => Etc.getlogin)
end
end
after "deploy", "deploy:notify"
after "deploy:migrations", "deploy:notify" |
Attached is a spreadsheet template for a Sprint Burndown Chart.
Features:
- Color coding for the time estimate (green when estimate goes down and red when it goes up)
- Color coding for the status (In Progress, Done, and Impediment)
- Pace and 20% above/below lines on the chart
- Supports multiple tasks per backlog item
- Sort any column without loosing which backlog item tasks belong to
- Prints nicely on Tabloid paper
Download it here: Sprint_Tasks_Burndown_Chart
Capistrano does not have out-of-the-box support for installing gems on your servers. You may not need this if you are packing them, but some of us would like to run the equivalent of ‘rake gems:install’. To do this in capistrano, add the following to your deploy.rb file:
namespace :gems do
desc "Install gems"
task :install, :roles => :app do
run "cd #{current_release} && #{sudo} rake RAILS_ENV=#{rails_env} gems:install"
end
end
If you don’t do something everyday, you tend to forget how to do it. The same is with the deployments. To help this, you can easily add a help section to Capistrano in your ‘config/deploy.rb’ file. Here is a sample:
desc "Print usage/help information"
task :help do
puts "Usage: cap <task> -S stage=[staging|production] -S branch=<branch_name>"
puts ""
puts "Examples:"
puts "----------------------------------------------------------------------"
puts " Production:"
puts " $ cap deploy:migrations -S stage=production"
puts ""
puts " Staging:"
puts " $ cap deploy:migrations"
puts ""
puts " Production with branch:"
puts " $ cap deploy:migrations -S stage=production -S branch=rel_001"
puts ""
puts " Staging with branch:"
puts " $ cap deploy:migrations -S branch=rel_001"
endWhen you forget how to do something, just run the following:
$ cap help
Usage: cap <task> -S stage=[staging|production] -S branch=<branch_name>
* executing `help'
Examples:
----------------------------------------------------------------------
Production:
$ cap deploy:migrations -S stage=production
Staging:
$ cap deploy:migrations
Production with branch:
$ cap deploy:migrations -S stage=production -S branch=rel_001
Staging with branch:
$ cap deploy:migrations -S branch=rel_001
Capistrano is designed to deploy your Rails application (yes it can handle others, but more work is required) to production. However, most applications need to be deployed to more than one environment. For example, we deploy to a staging environment in addition to production. This lets select users and internal employees kick the tires before we release it in the wild. After many complaints, capistrano-ext was born. I am all in favor of using plug ins, but this is such a trivial issue, it’s easier to add the code than worry about the plugin.
set :stage, "staging" unless variables[:stage]
set :deploy_to, "/var/www/#{application}"
case stage
when "staging"
set :rails_env, "staging"
role :web, "staging.example.com"
role :app, "staging.example.com"
role :db, "staging.example.com", :primary => true
when "production"
set :rails_env, "production"
role :web, "production.example.com"
role :app, "production.example.com"
role :db, "production.example.com", :primary => true
endTo deploy to the correct environment call capistrano:
$ cap deploy -S stage=staging
If your staging and production share the same machine (not the best idea):
set :stage, "staging" unless variables[:stage]
server "example.com", :app, :web: db
case stage
when "staging"
set :rails_env, "staging"
set :deploy_to, "/var/www/staging-#{application}"
when "production"
set :rails_env, "production"
set :deploy_to, "/var/www/production-#{application}"
end
It looks like people who were invited to Google Wave by other users (the ones that received the original invite from Google) are still waiting to get their invite. If Google sent out 100,000 invites and each user could invite 8 more people, that’s about 800,000 people who are waiting around getting frustrated.
Has anyone received their invite yet?
Looking at the results from a trending topic in Twitter, I saw the following:
Notice the description of the results, “Google Wave was released September 30, 2009. People are discussing it and begging for beta invites.” I tried a few others and they all seem to have a bit of information relevant to the topic. Is Twitter adding commentary to the discussions? Is their commentary accurate? I wonder what sampling size they used to determine that people were begging for a beta vs. offering a beta to other people?
As it turns out, they are leveraging data from WhatTheTrend.com. This UGC can be modified by anyone, I just modified the meaning of #googlewave. How long until people start abusing this to spread rumors. From the position of the content, it appears this is official information about a trend when in reality, it is the rambling from a random user.
Comments (1) 
Technology
| 
api, authlogic, rails, xml 
Themocracy