I took Bryan’s rake task and built upon it to help prevent this sort of issue. Here’s the goals:

• All code deployed to either the staging or production environments must be in GitHub. Using Capistrano for deployment helps enforce this, in that no code from a local repository can ever get deployed to the server.
• All changes start by branching off the current production head. This ensures we always have a stable place to start working, regardless of whether its for a quick bugfix or a month-long feature update.
• Any developer can deploy their current development branch to staging at any time. Remember, their development branch is based off of something that was a stable production release at one time. However, updates may have been made to production since then that are not included in their development branch. We consider this to be okay.
• Any developer can merge their current development branch back into production. However, their merge must be a direct fast-forward (which guarantees no conflicts). If changes have been committed to production since their branch was created, they must first rebase their branch to start from the current production head.
• All code merged into production is ready to be deployed at any time. Sounds obvious, but our first strategy failed on this because commits made to staging weren’t always ready to go to production in that order.
• Lastly, all this needs to be automatic, safe, and simple.

In our solution, we treat production as a real branch and merge code into it. This prevents commits from being lost by rewriting history. However, we borrowed the idea of creating staging as a branch, but treating it like a tag. I like this because it lets any developer tear down staging to use themselves at any time. By not making commits to staging, I never have to worry about my buggy code affecting someone else’s testing. (Or more realistically, someone else’s buggy code screwing up my testing.)

So, without further ado, here’s the rake tasks:

class GitCommands

  # Shows a diff of the current production and staging branches
  # (ie, what would change if staging was deployed to production)
  def self.diff_staging
    `git fetch`
    puts `git diff origin/production origin/staging`
  end

  # Pushes the specified branch to the remote origin, then
  # resets the staging branch to be a copy of that branch.
  def self.push_staging(branch_name)
    verify_working_directory_clean
    `git push origin #{branch_name}`
    `git fetch`
    `git branch -f staging origin/staging`
    `git checkout staging`
    `git reset --hard origin/#{branch_name}`
    `git push -f origin staging`
    `git checkout #{branch_name}`
    `git branch -D staging`

    `cap deploy`

    unless is_fast_forward_of_production(branch_name)
      puts("nnWARNING: NON-FAST-FORWARD!n"+
        "The production branch has been updated since this branchn"+
        "was created (or you've made more than 100 commits). Stagingn"+
        "has been updated, but you'll need to run the followingn"+
        "before attempting to push to production.nn"+
        "  git rebase -i origin/productionn"+
        "  git push -f origin #{branch_name}nn"+
        "You may want to do this now before testing on staging.nn"
      )
    end
  end

  # Pushes the specified branch to the remote origin, then
  # merges its changes into the production branch.
  def self.push_production(branch_name)
    verify_working_directory_clean
    `git push origin #{branch_name}`
    `git fetch`

    verify_fast_forward_of_production(branch_name)

    # Update master to be the previous production
    `git checkout master`
    `git reset --hard origin/production`
    `git push origin master`

    # Merge the current branch into production
    `git branch -f production origin/production`
    `git checkout production`
    `git merge #{branch_name}`
    `git push origin production`
    `git checkout #{branch_name}`
    `git branch -D production`

    puts("nnYour branch has been merged into production, but hasn"+
      "NOT YET been deployed.  Call the appropriate capistranon"+
      "tasks to deploy code, migrate the database, then restartn"+
      "passenger to make your changes live.nn"+
      "  cap production deploy:updaten"+
      "  cap production deploy:migraten"+
      "  cap production deploy:restartnn"
    )
  end

  # Creates a new branch using the current production branch
  # as a base.
  def self.create_branch(branch_name)
    verify_working_directory_clean

    `git fetch`
    `git branch -f production origin/production`
    `git checkout production`
    `git branch #{branch_name}`
    `git checkout #{branch_name}`
    `git push origin #{branch_name}`
  end

  # Creates a new local branch tracking a remote branch
  def self.track_branch(branch_name)
    verify_working_directory_clean

    `git fetch`
    `git branch -f #{branch_name} origin/#{branch_name}`
    `git checkout #{branch_name}`
  end

  # Creates a new branch using the current production branch
  # as a base.
  def self.destroy_branch(branch_name)
    verify_working_directory_clean

    `git fetch`
    `git checkout master`
    `git branch -D #{branch_name}`
    `git push origin :#{branch_name}`
  end

  # Determines the name of the current working branch.
  def self.get_branch_name
    branch = `git status`.scan(/A# On branch (.+)$/)
    raise "Could not determine which branch to use.  Perhaps use BRANCH=?" if branch.blank? || branch.first.blank? || branch.first.first.blank?
    return branch.first.first
  end

protected

  # Ensures that there are no pending changes in the working directory.
  # This was edited to allow untracked (and unignored) files, but that
  # may need to be removed for 100% functionality.
  def self.verify_working_directory_clean
    output = `git status`
    return if output =~ /working directory clean/ || output =~ /nothing added to commit but untracked files present/
    raise "Must have clean working directory"
  end

  # Verifies that the specified branch is a direct fast-forward of
  # the production branch.  This ensures that merges will be smooth
  # and conflict-free when running the git:push:production task.
  def self.verify_fast_forward_of_production(branch_name)
    unless is_fast_forward_of_production(branch_name)
      raise(
        "Branch #{branch_name} is not a fast-forward of the production branchn"+
        "(or there's more than 100 commits since the branch).n"+
        "Run:   "git rebase -i origin/production" and resolve all conflicts,n"+
        "then:  "git push -f origin #{branch_name}" to fix this."
      )
    end
    return
  end

  # Determines if the specified branch is a direct fast-forward of
  # the production branch.
  def self.is_fast_forward_of_production(branch_name)
    production_last_hex = `git log -1 origin/production`.scan(/Acommit ([da-f]{40})$/).first.first
    branch_log = `git log -100 --pretty=oneline #{branch_name}`.scan(/^[da-f]{40}/)
    return branch_log.include?(production_last_hex)
  end

end

namespace :git do

  namespace :push do

    desc "Push the current branch to origin/staging for testing"
    task :staging do
      branch_name = ENV['BRANCH'] || GitCommands.get_branch_name
      GitCommands.push_staging(branch_name)
    end

    desc "Safely merge the current branch back into origin/production"
    task :production do # => ['diff:staging'] do
      branch_name = ENV['BRANCH'] || GitCommands.get_branch_name
      GitCommands.push_production(branch_name)
    end

  end

  desc "Show the differences between the origin/staging branch and the origin/production branch"
  task :diff do
    GitCommands.diff_staging
  end

  namespace :branch do

    desc "Create a branch for a feature or bug fix. Specify BRANCH=name"
    task :create do
      branch_name = ENV['BRANCH']
      raise "You must specify a branch name using BRANCH=name" if branch_name.blank?
      GitCommands.create_branch(branch_name)
    end

    desc "Creates a local branch tracking an already-created remote branch.  Specify BRANCH=name"
    task :track do
      branch_name = ENV['BRANCH']
      raise "You must specify a branch name using BRANCH=name" if branch_name.blank?
      GitCommands.track_branch(branch_name)
    end

    desc "Removes a remote branch from the origin.  Specify BRANCH=name"
    task :destroy do
      branch_name = ENV['BRANCH']
      raise "You must specify a branch name using BRANCH=name" if branch_name.blank?
      GitCommands.destroy_branch(branch_name)
    end

  end

end

We’ve been using this for the past several weeks and it’s been working great. So, did we do any better? Anyone see any flaws or have any other ideas?

1. Set the Cache-Control http header.
2. Make S3 urls expire at a consistent time.

Setting the Cache-Control header tells our web browser that the cached image is valid and that it doesn’t need to check for an updated copy of the image on the server.  Making the url expire at a consistent time gives our images that are the same a consistent url, so our browser doesn’t get confused and think they are different images.  For example, image.jpg?expires=100 appears to our browser as a different image than image.jpg?expires=101.

Set Cache-Control Header in AWS S3

The technique we use for setting the Cache-Control header was originally posted in this guide. We’ll enhance the AWS::S3 store method to add a Cache-Control header that’s 10 years in the future if there isn’t already a Cache-Conrol header present.  The first step is to create a file in your lib/ folder and name it s3_cache_control.rb.

# Adjusts the cache control to the maximum value of 10 years (315360000 seconds)
module AWS
  module S3
    class S3Object
      class << self
        def store_with_cache_control(key, data, bucket = nil, options = {})
          if (options['Cache-Control'].blank?)
            options['Cache-Control'] = 'max-age=315360000'
          end
          store_without_cache_control(key, data, bucket, options)
        end

        alias_method_chain :store, :cache_control
      end
    end
  end
end

Make S3 URLs Expire at a Consistent Time

We’re going to make generated S3 URLs expire at a consistent time by overriding attachment_fu’s authenticated_s3_url method.  You can view the original authenticated_s3_url method.  We’re going to override it to add an expires option in there isn’t one present.  Place this code in lib/s3_cache_control.rb.

require 'technoweenie/attachment_fu/backends/s3_backend'
  module Technoweenie
    module AttachmentFu
      module Backends
        module S3Backend
        def authenticated_s3_url(*args)
          options = args.extract_options!
          options[:expires] = Time.now.advance(:minutes => 5).end_of_day.to_i if options[:expires].blank? and options[:expires_on].blank?
          thumbnail = args.shift
          S3Object.url_for(full_filename(thumbnail), bucket_name, options)
        end
      end
    end
  end
end

You can set expires to whatever value you would like, as long as its consistent.  In our case it made since to do it at the end of the day. But it could be at the end of the hour if you didn’t want photos cached long, or at the end of the week if you wanted them cached longer.

Now just add these two lines to your config/environment.rb file and you’re set:

require 'aws/s3'
require 's3_cache_control'

There’s plenty of resources online discussing how easy it is to use the Ruby Icalendar library.  However, just following those directions didn’t produce quite the results I was looking for when exporting multi-day events.  Using the directions from the previous links, Apple’s iCal app displayed every event as ending one day early.  And Google Calendar put “(12:00am?)” in front of the titles.  Not exactly seamless integration.  A quick Google search didn’t turn up anything useful, so hopefully this solution will save someone else some time.

The first one is easy.  If you dive into RFC2445, section 4.8.2.2 states that the DTEND parameter “defines the date and time by which the event ends.”  That’s an up-to-but-not-including statement.  If an event starts Feb 2 and ends Feb 5, then that means the event is over by Feb 5, and it displays as occupying only Feb 2, 3, and 4.  This is different than our model, where we define the end date to be included.  (That made more sense to me – most users who enter “Feb 2-5″ are describing a four day event.)  The solution here is just to use event.end_on.advance(:days => 1) to push it one day forward.

The second one is a little more difficult.  Google’s iCal parser interprets all DTSTART and DTEND values as times unless specifically told otherwise.  If you look at the output from the Icalendar library, it lists dates and date/times as:

    DTSTART:20090205
    DTSTART:20090205T083000

That’s valid, but according to the RFC you can add an additional parameter in there to specify what type of value you’re providing.  This looks like:

    DTSTART;VALUE=DATE:20090205
    DTSTART;VALUE=DATE-TIME:20090205T083000

I couldn’t find any documentation for how to do this with the Icalendar library, so I began digging into the source for Icalendar’s component.rb.  Turns out there’s a function called print_parameters(val) that is called during generation, and that it prints these pairs from hash called val.ical_params.  So if you assign event.start.ical_params = {'VALUE' => 'DATE'}, the Icalendar library will add in these additional descriptors.  Seems to be undocumented, but it works for me.

Note that since ical_params is a parameter of the object itself, you can only assign this hash after you’ve assigned the object itself.  Also, it didn’t seem to work for me when the value I had assigned was a String.  It did work when I assigned a Date or DateTime object directly.

All in all, our Event#to_ical looks like this:

def to_ical
  ical = Icalendar::Event.new
  if self.multi_day? || self.all_day?
    ical.start = self.start_on
    ical.start.ical_params = {'VALUE' => 'DATE'}
  else
    ical.start = self.start_at
    ical.start.ical_params = {'VALUE' => 'DATE-TIME'}
  end
  if self.multi_day?
    ical.end = self.end_on.advance(:days => 1)
    ical.end.ical_params = {'VALUE' => 'DATE'}
  end
  ical.summary = self.name
  ical.description = self.details
  ical.uid = "#{self.id}@gozuus"
  ical.created = self.created_at.utc
  ical.last_modified = self.updated_at.utc
  return ical
end

For completeness, here’s the output portion of our controller action:

format.ics do
  @ical = Icalendar::Calendar.new
  @events.each { |event| @ical.add event.to_ical }
  @ical.publish
  render :text => @ical.to_ical, :layout => false
end