roundsman 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.vagrant

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@roundsman

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in roundsman.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 iain
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,236 @@
+# Roundsman
+
+This is an attempt to combine the powers of [Capistrano](http://capify.org) and
+[chef-solo](http://wiki.opscode.com/display/chef/Chef+Solo).
+
+The only thing you need is SSH access and a supported OS. At this time only
+Ubuntu is supported.
+
+## Introduction
+
+You can skip this if you already know about Capistrano and Chef.
+
+Installing servers can be tedious work. Keeping your configuration in sync can
+be hard too. Chef is an excellent tool for managing this. It can provision your
+server from scratch. It can also be run again and again to check and update
+your configuration if needed.
+
+Capistrano is an excellent tool for deployment. It can deploy your code on
+multiple machines, with clever defaults, limited downtime and the ability to
+quickly roll back your deployment if something has gone wrong.
+
+Roundsman aims to integrate Capistrano and Chef. This means that with every
+deploy, it can check and update your configuration if needed. Are you using a
+new version of Ruby in your next release? It will automatically install when
+you deploy! Adding a new machine to your cluster? No problem! Roundsman will go
+from a bare bones Linux machine to a working server in minutes!
+
+Before you can use Roundsman, you need to know how to use Capistrano and how to
+write Chef recipes. Here are some resources you might want to check out:
+
+* [Capistrano's homepage](http://capify.org)
+* [Opscode, the company behind Chef](http://www.opscode.com)
+* [The wiki page on Chef Solo](http://wiki.opscode.com/display/chef/Chef+Solo)
+* [The wiki page on creating Chef recipes](http://wiki.opscode.com/display/chef/Resources)
+* [Railscast on Chef Solo](http://railscasts.com/episodes/339-chef-solo-basics) (paid)
+* [Railscast on Capistrano Tasks](http://railscasts.com/episodes/133-capistrano-tasks-revised)
+* [Railscast on digging deeper into Capistrano](http://railscasts.com/episodes/337-capistrano-recipes) (paid)
+
+Feeling comfortable you can tackle deploying your application with Capistrano
+and Chef? Now you can use Roundsman to combine them.
+
+## Installing
+
+Roundsman runs on Ruby 1.8.7 and above.
+
+If you're using Bundler, you can add Roundsman to your Gemfile:
+
+``` ruby
+# Gemfile
+
+gem 'roundsman', :require => false
+```
+
+Run `bundle install` to get it.
+
+If you're not using Bundler, you can install Roundsman by hand:
+
+``` bash
+$ gem install roundsman
+```
+
+And "capify" your project:
+
+``` bash
+$ capify .
+```
+
+Next, load Roundsman in `Capfile`
+
+``` ruby
+# Capfile
+
+require 'roundsman/capistrano'
+```
+
+## Usage
+
+By default, Roundsman assumes you put your Chef cookbooks inside
+`config/cookbooks`. If you don't like this, see the
+[Configuration](#Configuration) chapter. But here we're going to use that.
+
+I'm also going to assume that you put all Capistano configuration inside
+`config/deploy.rb`. When you have a lot of configuration or use the multistage
+extension, you might want to place it elsewhere.
+
+After configuring Capistrano and writing and downloading Chef recipes, you can
+hook them up, with a Capistrano hook. Simply provide provide a run list. Let's
+say you want to run the default recipe of your own cookbook, called `main`.
+
+``` ruby
+# config/deploy.rb
+
+before "deploy:update_code" do
+  roundsman.run_list "recipe[main]"
+end
+```
+
+I'm hooking it up before the `update_code` command, and not before `deploy` so
+it will also run when running `cap deploy:migrations`.
+
+Setting up a webserver usually requires that you have the code already there;
+otherwise restarting nginx or Apache will fail, because it cannot find your
+application yet. To remedy that you can make another recipe that will configure
+your webserver and have it run after deploying your new code:
+
+``` ruby
+# config/deploy.rb
+
+after "deploy:create_symlink" do
+  roundsman.run_list "recipe[main::webserver]"
+end
+```
+
+If you want a recipe to only run on a specific role, you can do so like this:
+
+``` ruby
+# config/deploy.rb
+
+namespace :install do
+  task :postgres, :roles => [:db] do
+    roundsman.run_list "recipe[main::postgres]"
+  end
+end
+
+before "deploy:update_code", "install:postgres"
+```
+
+## Configuration
+
+By default, Roundsman will make a lot of Capistrano's configuration available to chef.
+
+So, you might have these settings:
+
+``` ruby
+# config/deploy.rb
+
+set :application, "my-awesome-blog"
+set :rails_env, "production"
+set :deploy_to, "/var/www/#{application}-#{rails_env}"
+set :user, "deployer"
+```
+
+Here's how you can use them inside your recipes:
+
+``` ruby
+# config/cookbooks/main/recipes/default.rb
+
+directory File.join(node[:deploy_to], "uploads") do
+  owner node[:user]
+  owner node[:user]
+  recursive true
+end
+```
+
+Every configuration option from Capistrano is available in Chef. If your using
+the [passenger_apache2](https://github.com/opscode-cookbooks/passenger_apache2)
+cookbook for example, you can set the attributes like this:
+
+``` ruby
+# config/deploy.rb
+
+set :passenger, :version => "3.0.12", :max_pool_size => 4
+```
+
+There are also a set of configuration options for Roundsman itself. They all
+have sensible defaults, but you can override them if needed. To read all the
+default configuration:
+
+``` bash
+$ cap roundsman:configuration
+```
+
+
+You can also perform a lot of tasks by hand if you need to. Here's how to get
+information:
+
+``` bash
+$ cap --tasks roundsman
+```
+
+To get more information, use the `--explain` flag and specify a task name, like
+this:
+
+``` bash
+$ cap --explain roundsman:install_ruby
+```
+
+## How does it work?
+
+What Roundsman does is this:
+
+It will determine if you have the right version of Ruby installed. Your machine
+might already have an older version of Ruby installed, so if it needs to, it
+will use [ruby-build](https://github.com/sstephenson/ruby-build) to install the
+version of Ruby you need for your application.
+
+Then, it will install check the version of chef-solo and install or upgrade as
+needed.
+
+It will then copy over the cookbooks from your local machine to your deployment
+machine. This means that you don't need to commit every change while your still
+working on it.
+
+It will create your node.json file based upon your Capistrano configuration and
+run the recipes needed.
+
+This is all done in Capistrano hooks, using Capistrano methods like `run`, so
+you can determine when and how your recipes are run.
+
+## Tips
+
+### Colors
+
+Capistrano and Chef both give a lot of output. Check out
+[capistrano_colors](https://github.com/stjernstrom/capistrano_colors)
+to colorize your output for better readability.
+
+### Vagrant
+
+If you want to test out your configuration locally, you should take a look at
+[Vagrant](http://vagrantup.com). It makes managing a VirtualBox a breeze. You
+can even create a stage just for Vagrant with the Capistrano multistage
+extension.
+
+## Contributing
+
+If you want to help out, please! Create an issue or do a pull request and I
+will take a look at it.
+
+To get this project up and running, make sure you have VirtualBox, because we
+use vagrant. Then all you need to do is:
+
+``` bash
+bundle install
+rake
+```

data/Rakefile

@@ -0,0 +1,18 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+
+namespace :test do
+
+  desc "Run integration test for Ubuntu 10.04 LTE"
+  task :lucid do
+    result = system "cd test/ubuntu-lucid && ./test.sh"
+    exit 1 unless result
+  end
+
+  task :all => [ :lucid ]
+
+end
+task :test => "test:all"
+
+task :default => :test

data/lib/roundsman.rb

@@ -0,0 +1,4 @@
+require "roundsman/version"
+
+module Roundsman
+end

data/lib/roundsman/capistrano.rb

@@ -0,0 +1,275 @@
+require 'json'
+require 'tempfile'
+
+::Capistrano::Configuration.instance(:must_exist).load do
+
+  namespace :roundsman do
+
+    def run_list(*recipes)
+      if recipes.any?
+        set :run_list, recipes
+        install_ruby
+        run_chef
+      else
+        Array(fetch(:run_list))
+      end
+    end
+
+    def set_default(name, *args, &block)
+      @_defaults ||= []
+      @_overridden_defaults ||= []
+      @_defaults << name
+      if exists?(name)
+        @_overridden_defaults << name
+      else
+        set(name, *args, &block)
+      end
+    end
+
+    def roundsman_working_dir(*path)
+      ensure_roundsman_working_dir
+      File.join(fetch(:roundsman_working_dir), *path)
+    end
+
+    def sudo(command, *args)
+      run "#{top.sudo} #{command}", *args
+    end
+
+    def run(*args)
+      if fetch(:stream_roundsman_output)
+        top.stream *args
+      else
+        top.run *args
+      end
+    end
+
+    set_default :roundsman_working_dir, "/tmp/roundsman"
+    set_default :stream_roundsman_output, true
+
+    desc "Lists configuration"
+    task :configuration do
+      @_defaults.sort.each do |name|
+        display_name = ":#{name},".ljust(30)
+        if variables[name].is_a?(Proc)
+          value = "<block>"
+        else
+          value = fetch(name).inspect
+          value = "#{value[0..40]}... (truncated)" if value.length > 40
+        end
+        overridden = @_overridden_defaults.include?(name) ? "(overridden)" : ""
+        puts "set #{display_name} #{value} #{overridden}"
+      end
+    end
+
+    desc "Prepares the server for chef"
+    task :install_ruby do
+      install.default
+    end
+
+    desc "Runs chef"
+    task :run_chef do
+      chef.default
+    end
+
+    def ensure_roundsman_working_dir
+      unless @ensured_roundsman_working_dir
+        run "mkdir -p #{fetch(:roundsman_working_dir)}"
+        sudo "chown -R #{user} #{fetch(:roundsman_working_dir)}"
+        @ensured_roundsman_working_dir = true
+      end
+    end
+
+
+    namespace :install do
+
+      set_default :ruby_version, "1.9.3-p125"
+      set_default :care_about_ruby_version, true
+      set_default :ruby_install_dir, "/usr/local"
+
+      set_default :ruby_dependencies do
+        %w(git-core curl build-essential bison openssl
+          libreadline6 libreadline6-dev zlib1g zlib1g-dev libssl-dev
+          libyaml-dev libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev
+          vim wget tree)
+      end
+
+      set_default :ruby_install_script do
+        %Q{
+          set -e
+          cd #{roundsman_working_dir}
+          rm -rf ruby-build
+          git clone -q git://github.com/sstephenson/ruby-build.git
+          cd ruby-build
+          ./install.sh
+          ruby-build #{fetch(:ruby_version)} #{fetch(:ruby_install_dir)}
+        }
+      end
+
+      task :default, :except => { :no_release => true } do
+        if install_ruby?
+          dependencies
+          ruby
+        end
+      end
+
+      desc "Installs ruby."
+      task :ruby, :except => { :no_release => true } do
+        put fetch(:ruby_install_script), roundsman_working_dir("install_ruby.sh"), :via => :scp
+        sudo "bash #{roundsman_working_dir("install_ruby.sh")}"
+      end
+
+      desc "Installs the dependencies needed for Ruby"
+      task :dependencies, :except => { :no_release => true } do
+        ensure_supported_distro
+        sudo "aptitude -yq update"
+        sudo "aptitude -yq install #{fetch(:ruby_dependencies).join(' ')}"
+      end
+
+      desc "Checks if the ruby version installed matches the version specified"
+      task :check_ruby_version do
+        abort if install_ruby?
+      end
+
+      def distribution
+        @distribution ||= capture("cat /etc/issue").strip
+      end
+
+      def ensure_supported_distro
+        unless @ensured_supported_distro
+          logger.info "Using Linux distribution #{distribution}"
+          abort "This distribution is not (yet) supported." unless distribution.include?("Ubuntu")
+          @ensured_supported_distro = true
+        end
+      end
+
+      def install_ruby?
+        installed_version = capture("ruby --version || true").strip
+        if installed_version.include?("not found")
+          logger.info "No version of Ruby could be found."
+          return true
+        end
+        required_version = fetch(:ruby_version).gsub("-", "")
+        if installed_version.include?(required_version)
+          if fetch(:care_about_ruby_version)
+            logger.info "Ruby #{installed_version} matches the required version: #{required_version}."
+            return false
+          else
+            logger.info "Already installed Ruby #{installed_version}, not #{required_version}. Set :care_about_ruby_version if you want to fix this."
+            return false
+          end
+        else
+          logger.info "Ruby version mismatch. Installed version: #{installed_version}, required is #{required_version}"
+          return true
+        end
+      end
+
+    end
+
+    namespace :chef do
+
+      set_default :chef_version, "~> 0.10.8"
+      set_default :cookbooks_directory, ["config/cookbooks"]
+      set_default :copyfile_disable, false
+
+      task :default, :except => { :no_release => true } do
+        ensure_cookbooks_exists
+        prepare_chef
+        chef_solo
+      end
+
+      desc "Generates the config and copies over the cookbooks to the server"
+      task :prepare_chef, :except => { :no_release => true } do
+        install if install_chef?
+        ensure_cookbooks_exists
+        generate_config
+        generate_attributes
+        copy_cookbooks
+      end
+
+      desc "Installs chef"
+      task :install, :except => { :no_release => true } do
+        sudo "gem uninstall -xaI chef || true"
+        sudo "gem install chef -v #{fetch(:chef_version).inspect} --quiet --no-ri --no-rdoc"
+        sudo "gem install ruby-shadow --quiet --no-ri --no-rdoc"
+      end
+
+      desc "Runs the existing chef configuration"
+      task :chef_solo, :except => { :no_release => true } do
+        logger.info "Now running #{fetch(:run_list).join(', ')}"
+        sudo "chef-solo -c #{roundsman_working_dir("solo.rb")} -j #{roundsman_working_dir("solo.json")}"
+      end
+
+      def ensure_cookbooks_exists
+        abort "You must specify at least one recipe when running roundsman.chef" if fetch(:run_list, []).empty?
+        abort "No cookbooks found in #{fetch(:cookbooks_directory).inspect}" if cookbooks_paths.empty?
+      end
+
+      def cookbooks_paths
+        Array(fetch(:cookbooks_directory)).select { |path| File.exist?(path) }
+      end
+
+      def install_chef?
+        required_version = fetch(:chef_version).inspect
+        output = capture("gem list -i -v #{required_version} || true").strip
+        output == "false"
+      end
+
+      def generate_config
+        cookbook_string = cookbooks_paths.map { |c| "File.join(root, #{c.to_s.inspect})" }.join(', ')
+        solo_rb = <<-RUBY
+        root = File.expand_path(File.dirname(__FILE__))
+        file_cache_path File.join(root, "cache")
+        cookbook_path [ #{cookbook_string} ]
+          RUBY
+          put solo_rb, roundsman_working_dir("solo.rb"), :via => :scp
+      end
+
+      def generate_attributes
+        attrs = remove_procs_from_hash variables.dup
+        put attrs.to_json, roundsman_working_dir("solo.json"), :via => :scp
+      end
+
+      # Recursively removes procs from hashes. Procs can exist because you specified them like this:
+      #
+      #     set(:root_password) { Capistrano::CLI.password_prompt("Root password: ") }
+      def remove_procs_from_hash(hash)
+        new_hash = {}
+        hash.each do |key, value|
+          real_value = if value.respond_to?(:call)
+                         begin
+                           value.call
+                         rescue ::Capistrano::CommandError => e
+                           logger.debug "Could not get the value of #{key}: #{e.message}"
+                           nil
+                         end
+                       else
+                         value
+                       end
+
+          if real_value.is_a?(Hash)
+            real_value = remove_procs_from_hash(real_value)
+          end
+          unless real_value.class.to_s.include?("Capistrano") # skip capistrano tasks
+            new_hash[key] = real_value
+          end
+        end
+        new_hash
+      end
+
+      def copy_cookbooks
+        tar_file = Tempfile.new("cookbooks.tar")
+        begin
+          tar_file.close
+          env_vars = fetch(:copyfile_disable) && RUBY_PLATFORM.downcase.include?('darwin') ? "COPYFILE_DISABLE=true" : ""
+          system "#{env_vars} tar -cjf #{tar_file.path} #{cookbooks_paths.join(' ')}"
+          upload tar_file.path, roundsman_working_dir("cookbooks.tar"), :via => :scp
+          run "cd #{roundsman_working_dir} && tar -xjf cookbooks.tar"
+        ensure
+          tar_file.unlink
+        end
+      end
+
+    end
+
+  end
+end

data/lib/roundsman/version.rb

@@ -0,0 +1,3 @@
+module Roundsman
+  VERSION = "0.0.1"
+end

data/roundsman.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/roundsman/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["iain"]
+  gem.email         = ["iain@iain.nl"]
+  gem.description   = %q{Combine the awesome powers of Capistrano and Chef. The only thing you need is SSH access.}
+  gem.summary       = %q{Various Capistrano tasks for bootstrapping servers with Chef}
+  gem.homepage      = "https://github.com/iain/roundsman"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "roundsman"
+  gem.require_paths = ["lib"]
+  gem.version       = Roundsman::VERSION
+
+  gem.add_runtime_dependency "capistrano", "~> 2.12"
+  gem.add_development_dependency "vagrant", "~> 1.0"
+end

data/test/ubuntu-lucid/Capfile

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# These lines are part of the default Capfile
+load 'deploy'
+load 'config/deploy'
+
+# These lines are to get Roundsman loaded for the test
+require 'roundsman/capistrano'

data/test/ubuntu-lucid/Rakefile

@@ -0,0 +1,5 @@
+namespace :db do
+  task :migrate do
+    puts "rake db:migrate ran"
+  end
+end

data/test/ubuntu-lucid/Vagrantfile

@@ -0,0 +1,99 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "lucid32"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://files.vagrantup.com/lucid32.box"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  config.vm.network :hostonly, "192.168.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file base.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "base.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding 
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # IF you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/test/ubuntu-lucid/config/cookbooks/main/recipes/cold.rb

@@ -0,0 +1 @@
+gem_package "bundler"

data/test/ubuntu-lucid/config/deploy.rb

@@ -0,0 +1,20 @@
+set :application, "my-awesome-blog"
+
+set :repository, "."
+set :scm,        :none # not recommended in production
+set :deploy_via, :copy
+
+server "192.168.33.10", :web, :app, :db, :primary => true
+
+set :user,     "vagrant"
+set :password, "vagrant" # not recommended in production
+
+set :deploy_to, "/home/#{user}/#{application}"
+
+set :use_sudo, false
+default_run_options[:pty] = true
+
+before "deploy:cold" do
+  deploy.setup
+  roundsman.run_list "recipe[main::cold]"
+end

data/test/ubuntu-lucid/test.sh

@@ -0,0 +1,4 @@
+set -e
+
+bundle exec vagrant up
+bundle exec cap deploy:cold

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: roundsman
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- iain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: &70276376984320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70276376984320
+- !ruby/object:Gem::Dependency
+  name: vagrant
+  requirement: &70276376983820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70276376983820
+description: Combine the awesome powers of Capistrano and Chef. The only thing you
+  need is SSH access.
+email:
+- iain@iain.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/roundsman.rb
+- lib/roundsman/capistrano.rb
+- lib/roundsman/version.rb
+- roundsman.gemspec
+- test/ubuntu-lucid/Capfile
+- test/ubuntu-lucid/Rakefile
+- test/ubuntu-lucid/Vagrantfile
+- test/ubuntu-lucid/config/cookbooks/main/recipes/cold.rb
+- test/ubuntu-lucid/config/deploy.rb
+- test/ubuntu-lucid/test.sh
+homepage: https://github.com/iain/roundsman
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Various Capistrano tasks for bootstrapping servers with Chef
+test_files:
+- test/ubuntu-lucid/Capfile
+- test/ubuntu-lucid/Rakefile
+- test/ubuntu-lucid/Vagrantfile
+- test/ubuntu-lucid/config/cookbooks/main/recipes/cold.rb
+- test/ubuntu-lucid/config/deploy.rb
+- test/ubuntu-lucid/test.sh