rubber-jcarnegie 0.0.1

data/lib/rubber/railtie.rb

@@ -0,0 +1,14 @@
+require 'rubber'
+require 'rails'
+
+module Rubber
+
+  class Railtie < Rails::Railtie
+
+    initializer "rubber.configure_rails_initialization" do
+      Rubber::initialize(Rails.root, Rails.env)
+    end
+
+  end
+
+end

data/lib/rubber/recipes/rubber.rb

@@ -0,0 +1,96 @@
+# add this plugins lib dir to load path for capistrano
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'rubygems'
+require "socket"
+require 'resolv'
+require 'enumerator'
+require 'capistrano/hostcmd'
+require 'pp'
+require 'rubber'
+
+namespace :rubber do
+
+  # Disable connecting to any Windows instance.
+  alias :original_task :task
+  def task(name, options={}, &block)
+    original_task(name, options.merge(:except => { :platform => 'windows' }), &block)
+  end
+
+  # advise capistrano's task method so that tasks for non-existent roles don't
+  # fail when roles isn't defined due to using a FILTER for load_roles
+  # If you have a task you need to execute even when there are no
+  # roles, you have to use required_task instead of task - see rubber:create
+  # as an example of this role bootstrapping problem.
+  def allow_optional_tasks(ns)
+    class << ns
+      alias :required_task :task
+      def task(name, options={}, &block)
+        # Disable connecting to any Windows instance.
+        required_task(name, options.merge(:except => { :platform => 'windows' })) do
+          # define empty roles for the case when a task has a role that we don't define anywhere
+          [*options[:roles]].each do |r|
+            roles[r] ||= []
+          end
+          
+          if find_servers_for_task(current_task).empty?
+            logger.info "No servers for task #{name}, skipping"
+            next
+          end
+          block.call
+        end
+      end
+    end
+  end
+
+  allow_optional_tasks(self)
+  on :load, "rubber:init"
+    
+  required_task :init do
+    set :rubber_cfg, Rubber::Configuration.get_configuration(RUBBER_ENV)
+    set :rubber_env, rubber_cfg.environment.bind()
+    set :rubber_instances, rubber_cfg.instance
+
+    # Disable connecting to any Windows instance.
+    # pass -l to bash in :shell to that run also gets full env
+    # use a pty so we don't get "stdin: is not a tty" error output
+    set :default_run_options, :pty => true, :shell => "/bin/bash -l", :except => { :platform => 'windows' }
+
+    set :cloud, Rubber::Cloud::get_provider(rubber_env.cloud_provider || "aws", rubber_env, self)
+
+    load_roles() unless rubber_env.disable_auto_roles
+    # NOTE: for some reason Capistrano requires you to have both the public and
+    # the private key in the same folder, the public key should have the
+    # extension ".pub".
+    ssh_options[:keys] = rubber_env.cloud_providers[rubber_env.cloud_provider].key_file
+    ssh_options[:timeout] = fetch(:ssh_timeout, 5)
+  end
+
+
+  # Automatically load and define capistrano roles from instance config
+  def load_roles
+    top.roles.clear
+
+    # define empty roles for all known ones so tasks don't fail if a role
+    # doesn't exist due to a filter
+    all_roles = rubber_instances.all_roles
+    all_roles += rubber_cfg.environment.known_roles
+    all_roles.uniq!
+    all_roles.each {|name| top.roles[name.to_sym] = []}
+
+    # define capistrano host => role mapping for all instances
+    rubber_instances.filtered.each do |ic|
+      ic.roles.each do |role|
+        opts = Rubber::Util::symbolize_keys(role.options).merge(:platform => ic.platform)
+        msg = "Auto role: #{role.name.to_sym} => #{ic.full_name}"
+        msg << ", #{opts.inspect}" if opts.inspect.size > 0
+        logger.info msg
+        top.role role.name.to_sym, ic.full_name, opts
+      end
+    end
+  end
+
+end
+
+Dir[File.join(File.dirname(__FILE__), 'rubber/*.rb')].each do |rubber_part|
+  load(rubber_part)
+end

data/lib/rubber/recipes/rubber/bundles.rb

@@ -0,0 +1,30 @@
+namespace :rubber do
+
+  desc "Back up and register an image of the running instance"
+  task :bundle do
+    if find_servers_for_task(current_task).size > 1
+      fatal "Can only bundle a single instance at a time, use FILTER to limit the scope"
+    end
+    image_name = get_env('IMAGE', "The image name for the bundle", true, Time.now.strftime("%Y%m%d_%H%M"))
+    image_id = cloud.create_image(image_name)
+    logger.info "Newly registered image is: #{image_id}"
+  end
+
+  desc "De-register and Destroy the image for the given name"
+  required_task :destroy_bundle do
+    image_id = get_env('IMAGE_ID', 'The id of the image to be destroyed', true)
+    cloud.destroy_image(image_id)
+  end
+
+  desc "Describes all your own image bundles"
+  required_task :describe_bundles do
+    images = cloud.describe_images()
+    images.each do |image|
+      logger.info "======================"
+      logger.info "ID: #{image[:id]}"
+      logger.info "Location: #{image[:location]}"
+      logger.info "Root device type: #{image[:root_device_type]}"
+    end
+  end
+
+end

data/lib/rubber/recipes/rubber/deploy.rb

@@ -0,0 +1,90 @@
+namespace :rubber do
+
+  # Add in some hooks so that we can insert our own hooks at head/tail of
+  # hook chain - this is needed for making monit stop before everyone else.
+  before "deploy:start", "rubber:pre_start"
+  before "deploy:restart", "rubber:pre_restart"
+  before "deploy:stop", "rubber:pre_stop"
+  on :load do
+    after "deploy:start", "rubber:post_start"
+    after "deploy:restart", "rubber:post_restart"
+    after "deploy:stop", "rubber:post_stop"
+  end
+
+  task :pre_start do
+  end
+  task :pre_restart do
+  end
+  task :pre_stop do
+  end
+  task :post_start do
+  end
+  task :post_restart do
+  end
+  task :post_stop do
+  end
+
+  # Don't want to do rubber:config for update_code as that tree isn't official
+  # until it is 'committed' by the symlink task (and doing so causes it to run
+  # for bootstrap_db which should only config the db config file).  However,
+  # deploy:migrations doesn't call update, so we need an additional trigger for
+  # it
+  after "deploy:update", "rubber:config"
+  after "deploy:rollback_code", "rubber:config"
+  before "deploy:migrate", "rubber:config"
+
+  desc <<-DESC
+    Configures the deployed rails application by running the rubber configuration process
+  DESC
+  task :config do
+    opts = {}
+    opts['NO_POST'] = true if ENV['NO_POST']
+    opts['FILE'] = ENV['FILE'] if ENV['FILE']
+    opts['RUBBER_ENV'] = RUBBER_ENV
+    # we need to set rails env as well because when running rake
+    # in a rails project, rails gets loaded before the rubber hook gets run
+    opts['RAILS_ENV'] = RUBBER_ENV
+
+    # when running deploy:migrations, we need to run config against release_path
+    opts[:deploy_path] = current_release if fetch(:migrate_target, :current).to_sym == :latest
+
+    run_config(opts)
+  end
+
+  # because we start server as appserver user, but migrate as root, server needs to be able to write logs, etc.
+  before "rubber:pre_start", "rubber:setup_app_permissions"
+  before "rubber:pre_restart", "rubber:setup_app_permissions"
+
+  desc <<-DESC
+    Sets permissions of files in application directory to be owned by app_user.
+  DESC
+  task :setup_app_permissions do
+    rsudo "find #{shared_path} -name cached-copy -prune -o -name bundle -prune -o -print0 | xargs -0 chown #{rubber_env.app_user}:#{rubber_env.app_user}"
+    rsudo "chown -R #{rubber_env.app_user}:#{rubber_env.app_user} #{current_path}/tmp"
+  end
+
+  def run_config(options={})
+    path = options.delete(:deploy_path) || current_path
+    extra_env = options.keys.inject("") {|all, k|  "#{all} #{k}=\"#{options[k]}\""}
+
+    # Need to do this so we can work with staging instances without having to
+    # checkin instance file between create and bootstrap, as well as during a deploy
+    if fetch(:push_instance_config, false)
+      push_files = [rubber_instances.file] + rubber_cfg.environment.config_files
+      push_files.each do |file|
+        dest_file = file.sub(/^#{RUBBER_ROOT}\/?/, '')
+        put(File.read(file), File.join(path, dest_file), :mode => "+r")
+      end
+    end
+
+    # if the user has defined a secret config file, then push it into RUBBER_ROOT/config/rubber
+    secret = rubber_cfg.environment.config_secret
+    if secret && File.exist?(secret)
+      base = rubber_cfg.environment.config_root.sub(/^#{RUBBER_ROOT}\/?/, '')
+      put(File.read(secret), File.join(path, base, File.basename(secret)), :mode => "+r")
+    end
+
+    rsudo "cd #{path} && #{extra_env} rake rubber:config"
+  end
+
+end

data/lib/rubber/recipes/rubber/instances.rb

@@ -0,0 +1,453 @@
+namespace :rubber do
+
+  desc <<-DESC
+    Create a new EC2 instance with the given ALIAS and ROLES
+  DESC
+  required_task :create do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+
+    env = rubber_cfg.environment.bind(nil, instance_alias)
+    default_roles = env.instance_roles
+    r = get_env("ROLES", "Instance roles (e.g. web,app,db:primary=true)", true, default_roles)
+
+    create_spot_instance = ENV.delete("SPOT_INSTANCE") || env.cloud_providers[env.cloud_provider].spot_instance
+
+    if r == '*'
+      instance_roles = rubber_cfg.environment.known_roles
+      instance_roles = instance_roles.collect {|role| role == "db" ? "db:primary=true" : role }
+    else
+      instance_roles = r.split(",")
+    end
+
+    ir = []
+    instance_roles.each do |r|
+      role = Rubber::Configuration::RoleItem.parse(r)
+
+      # If user doesn't setup a primary db, then be nice and do it
+      if role.name == "db" && role.options["primary"] == nil && rubber_instances.for_role("db").size == 0
+        value = Capistrano::CLI.ui.ask("You do not have a primary db role, should #{instance_alias} be it [y/n]?: ")
+        role.options["primary"] = true if value =~ /^y/
+      end
+
+      ir << role
+    end
+
+    # Add in roles that the given set of roles depends on
+    ir = Rubber::Configuration::RoleItem.expand_role_dependencies(ir, get_role_dependencies)
+
+    create_instance(instance_alias, ir, create_spot_instance)
+  end
+
+  desc <<-DESC
+    Refresh the host data for a EC2 instance with the given ALIAS.
+    This is useful to run when rubber:create fails after instance creation
+  DESC
+  required_task :refresh do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+    ENV.delete('ROLES') # so we don't get an error if people leave ROLES in env from :create CLI
+    refresh_instance(instance_alias)
+  end
+
+  desc <<-DESC
+    Destroy the EC2 instance for the given ALIAS
+  DESC
+  required_task :destroy do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+    ENV.delete('ROLES') # so we don't get an error if people leave ROLES in env from :create CLI
+    destroy_instance(instance_alias)
+  end
+
+  desc <<-DESC
+    Destroy ALL the EC2 instances for the current env
+  DESC
+  required_task :destroy_all do
+    rubber_instances.each do |ic|
+      destroy_instance(ic.name)
+    end
+  end
+
+  desc <<-DESC
+    Reboot the EC2 instance for the give ALIAS
+  DESC
+  required_task :reboot do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+    ENV.delete('ROLES') # so we don't get an error if people leave ROLES in env from :create CLI
+    reboot_instance(instance_alias)
+  end
+
+  desc <<-DESC
+    Stop the EC2 instance for the give ALIAS
+  DESC
+  required_task :stop do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+    ENV.delete('ROLES') # so we don't get an error if people leave ROLES in env from :create CLI
+    stop_instance(instance_alias)
+  end
+
+  desc <<-DESC
+    Start the EC2 instance for the give ALIAS
+  DESC
+  required_task :start do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+    ENV.delete('ROLES') # so we don't get an error if people leave ROLES in env from :create CLI
+    start_instance(instance_alias)
+  end
+
+  desc <<-DESC
+    Adds the given ROLES to the instance named ALIAS
+  DESC
+  required_task :add_role do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+    r = get_env('ROLES', "Instance roles (e.g. web,app,db:primary=true)", true)
+
+    instance_roles = r.split(",")
+
+    ir = []
+    instance_roles.each do |r|
+      role = Rubber::Configuration::RoleItem.parse(r)
+      ir << role
+    end
+
+    # Add in roles that the given set of roles depends on
+    ir = Rubber::Configuration::RoleItem.expand_role_dependencies(ir, get_role_dependencies)
+
+    instance = rubber_instances[instance_alias]
+    fatal "Instance does not exist: #{instance_alias}" unless instance
+
+    instance.roles = (instance.roles + ir).uniq
+    rubber_instances.save()
+    logger.info "Roles for #{instance_alias} are now:"
+    logger.info instance.role_names.sort.join("\n")
+    logger.info ''
+    logger.info "Run 'cap rubber:bootstrap' if done adding roles"
+  end
+
+  desc <<-DESC
+    Removes the given ROLES from the instance named ALIAS
+  DESC
+  required_task :remove_role do
+    instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
+    r = get_env('ROLES', "Instance roles (e.g. web,app,db:primary=true)", true)
+
+    instance_roles = r.split(",")
+
+    ir = []
+    instance_roles.each do |r|
+      role = Rubber::Configuration::RoleItem.parse(r)
+      ir << role
+    end
+
+    instance = rubber_instances[instance_alias]
+    fatal "Instance does not exist: #{instance_alias}" unless instance
+
+    instance.roles = (instance.roles - ir).uniq
+    rubber_instances.save()
+    logger.info "Roles for #{instance_alias} are now:"
+    logger.info instance.role_names.sort.join("\n")
+  end
+
+  desc <<-DESC
+    List all your EC2 instances
+  DESC
+  required_task :describe do
+    results = []
+    format = "%-10s %-10s %-10s %-15s %-30s"
+    results << format % %w[InstanceID State Zone IP Alias\ (*=unknown)]
+
+    instances = cloud.describe_instances()
+    instances.each do |instance|
+      local_alias = find_alias(instance[:external_ip], instance[:id], instance[:state] == 'running')
+      results << format % [instance[:id], instance[:state], instance[:zone], instance[:external_ip] || "NoIP", local_alias || "Unknown"]
+    end
+    results.each {|r| logger.info r}
+  end
+
+  desc <<-DESC
+    Describes the availability zones
+  DESC
+  required_task :describe_zones do
+    results = []
+    format = "%-20s %-15s"
+    results << format % %w[Name State]
+
+    zones = cloud.describe_availability_zones()
+    zones.each do |zone|
+      results << format % [zone[:name], zone[:state]]
+    end
+
+    results.each {|r| logger.info r}
+  end
+
+
+  set :print_ip_command, "ifconfig eth0 | awk 'NR==2 {print $2}' | awk -F: '{print $2}'"
+
+  # Creates a new ec2 instance with the given alias and roles
+  # Configures aliases (/etc/hosts) on local and remote machines
+  def create_instance(instance_alias, instance_roles, create_spot_instance=false)
+    fatal "Instance already exists: #{instance_alias}" if rubber_instances[instance_alias]
+
+    role_names = instance_roles.collect{|x| x.name}
+    env = rubber_cfg.environment.bind(role_names, instance_alias)
+
+    # We need to use security_groups during create, so create them up front
+    setup_security_groups(instance_alias, role_names)
+    security_groups = get_assigned_security_groups(instance_alias, role_names)
+
+    ami = env.cloud_providers[env.cloud_provider].image_id
+    ami_type = env.cloud_providers[env.cloud_provider].image_type
+    availability_zone = env.availability_zone
+
+    if create_spot_instance
+      spot_price = env.cloud_providers[env.cloud_provider].spot_price.to_s
+
+      logger.info "Creating spot instance request for instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
+      request_id = cloud.create_spot_instance_request(spot_price, ami, ami_type, security_groups, availability_zone)
+
+      print "Waiting for spot instance request to be fulfilled"
+      max_wait_time = env.cloud_providers[env.cloud_provider].spot_instance_request_timeout || (1.0 / 0) # Use the specified timeout value or default to infinite.
+      instance_id = nil
+      while instance_id.nil? do
+        print "."
+        sleep 2
+        max_wait_time -= 2
+
+        request = cloud.describe_spot_instance_requests(request_id).first
+        instance_id = request[:instance_id]
+
+        if max_wait_time < 0 && instance_id.nil?
+          cloud.destroy_spot_instance_request(request[:id])
+
+          print "\n"
+          print "Failed to fulfill spot instance in the time specified. Falling back to on-demand instance creation."
+          break
+        end
+      end
+
+      print "\n"
+    end
+
+    if !create_spot_instance || (create_spot_instance && max_wait_time < 0)
+      logger.info "Creating instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
+      instance_id = cloud.create_instance(ami, ami_type, security_groups, availability_zone)
+    end
+
+    logger.info "Instance #{instance_id} created"
+
+    instance_item = Rubber::Configuration::InstanceItem.new(instance_alias, env.domain, instance_roles, instance_id, security_groups)
+    instance_item.spot_instance_request_id = request_id if create_spot_instance
+    rubber_instances.add(instance_item)
+    rubber_instances.save()
+
+    # Sometimes tag creation will fail, indicating that the instance doesn't exist yet even though it does.  It seems to
+    # be a propagation delay on Amazon's end, so the best we can do is wait and try again.
+    begin
+      Rubber::Tag::update_instance_tags(instance_alias)
+    rescue Exception
+      sleep 0.5
+      retry
+    end
+
+    print "Waiting for instance to start"
+    while true do
+      print "."
+      sleep 2
+
+      break if refresh_instance(instance_alias)
+    end
+  end
+
+  # Refreshes a ec2 instance with the given alias
+  # Configures aliases (/etc/hosts) on local and remote machines
+  def refresh_instance(instance_alias)
+    instance_item = rubber_instances[instance_alias]
+
+    fatal "Instance does not exist: #{instance_alias}" if ! instance_item
+
+    env = rubber_cfg.environment.bind(instance_item.role_names, instance_alias)
+
+    instance = cloud.describe_instances(instance_item.instance_id).first rescue {}
+
+    if instance[:state] == "running"
+      print "\n"
+      logger.info "Instance running, fetching hostname/ip data"
+      instance_item.external_host = instance[:external_host]
+      instance_item.external_ip = instance[:external_ip]
+      instance_item.internal_host = instance[:internal_host]
+      instance_item.internal_ip = instance[:internal_ip]
+      instance_item.zone = instance[:zone]
+      instance_item.platform = instance[:platform]
+      instance_item.root_device_type = instance[:root_device_type]
+      rubber_instances.save()
+
+      unless instance_item.windows?
+        # weird cap/netssh bug, sometimes just hangs forever on initial connect, so force a timeout
+        begin
+          Timeout::timeout(30) do
+            # turn back on root ssh access if we are using root as the capistrano user for connecting
+            enable_root_ssh(instance_item.external_ip, fetch(:initial_ssh_user, 'ubuntu')) if user == 'root'
+            # force a connection so if above isn't enabled we still timeout if initial connection hangs
+            direct_connection(instance_item.external_ip) do
+              run "echo"
+            end
+          end
+        rescue Timeout::Error
+          logger.info "timeout in initial connect, retrying"
+          retry
+        end
+      end
+
+      # setup amazon elastic ips if configured to do so
+      setup_static_ips
+
+      # Need to setup aliases so ssh doesn't give us errors when we
+      # later try to connect to same ip but using alias
+      setup_local_aliases
+
+      # re-load the roles since we may have just defined new ones
+      load_roles() unless env.disable_auto_roles
+
+      rubber_instances.save()
+
+      # Add the aliases for this instance to all other hosts
+      setup_remote_aliases
+      setup_dns_aliases
+
+      return true
+    end
+    return false
+  end
+
+
+  # Destroys the given ec2 instance
+  def destroy_instance(instance_alias)
+    instance_item = rubber_instances[instance_alias]
+    fatal "Instance does not exist: #{instance_alias}" if ! instance_item
+
+    env = rubber_cfg.environment.bind(instance_item.role_names, instance_item.name)
+
+    value = Capistrano::CLI.ui.ask("About to DESTROY #{instance_alias} (#{instance_item.instance_id}) in mode #{RUBBER_ENV}.  Are you SURE [yes/NO]?: ")
+    fatal("Exiting", 0) if value != "yes"
+
+    if instance_item.static_ip
+      value = Capistrano::CLI.ui.ask("Instance has a static ip, do you want to release it? [y/N]?: ")
+      destroy_static_ip(instance_item.static_ip) if value =~ /^y/
+    end
+
+    if instance_item.volumes
+      value = Capistrano::CLI.ui.ask("Instance has persistent volumes, do you want to destroy them? [y/N]?: ")
+      if value =~ /^y/
+        instance_item.volumes.clone.each do |volume_id|
+          destroy_volume(volume_id)
+        end
+      end
+    end
+
+    logger.info "Destroying instance alias=#{instance_alias}, instance_id=#{instance_item.instance_id}"
+
+    cloud.destroy_instance(instance_item.instance_id)
+
+    rubber_instances.remove(instance_alias)
+    rubber_instances.save()
+
+    # re-load the roles since we just removed some and setup_remote_aliases
+    # shouldn't hit removed ones
+    load_roles() unless env.disable_auto_roles
+
+    setup_aliases
+    destroy_dyndns(instance_item)
+    cleanup_known_hosts(instance_item) unless env.disable_known_hosts_cleanup
+  end
+
+  # Reboots the given ec2 instance
+  def reboot_instance(instance_alias)
+    instance_item = rubber_instances[instance_alias]
+    fatal "Instance does not exist: #{instance_alias}" if ! instance_item
+
+    env = rubber_cfg.environment.bind(instance_item.role_names, instance_item.name)
+
+    value = Capistrano::CLI.ui.ask("About to REBOOT #{instance_alias} (#{instance_item.instance_id}) in mode #{RUBBER_ENV}.  Are you SURE [yes/NO]?: ")
+    fatal("Exiting", 0) if value != "yes"
+
+    logger.info "Rebooting instance alias=#{instance_alias}, instance_id=#{instance_item.instance_id}"
+
+    cloud.reboot_instance(instance_item.instance_id)
+  end
+
+  # Stops the given ec2 instance.  Note that this operation only works for instances that use an EBS volume for the root
+  # device and that are not spot instances.
+  def stop_instance(instance_alias)
+    instance_item = rubber_instances[instance_alias]
+    fatal "Instance does not exist: #{instance_alias}" if ! instance_item
+    fatal "Cannot stop spot instances!" if ! instance_item.spot_instance_request_id.nil?
+    fatal "Cannot stop instances with instance-store root device!" if (instance_item.root_device_type != 'ebs')
+
+    env = rubber_cfg.environment.bind(instance_item.role_names, instance_item.name)
+
+    value = Capistrano::CLI.ui.ask("About to STOP #{instance_alias} (#{instance_item.instance_id}) in mode #{RUBBER_ENV}.  Are you SURE [yes/NO]?: ")
+    fatal("Exiting", 0) if value != "yes"
+
+    logger.info "Stopping instance alias=#{instance_alias}, instance_id=#{instance_item.instance_id}"
+
+    cloud.stop_instance(instance_item.instance_id)
+  end
+
+  # Starts the given ec2 instance.  Note that this operation only works for instances that use an EBS volume for the root
+  # device, that are not spot instances, and that are already stopped.
+  def start_instance(instance_alias)
+    instance_item = rubber_instances[instance_alias]
+    fatal "Instance does not exist: #{instance_alias}" if ! instance_item
+    fatal "Cannot start spot instances!" if ! instance_item.spot_instance_request_id.nil?
+    fatal "Cannot start instances with instance-store root device!" if (instance_item.root_device_type != 'ebs')
+
+    env = rubber_cfg.environment.bind(instance_item.role_names, instance_item.name)
+
+    value = Capistrano::CLI.ui.ask("About to START #{instance_alias} (#{instance_item.instance_id}) in mode #{RUBBER_ENV}.  Are you SURE [yes/NO]?: ")
+    fatal("Exiting", 0) if value != "yes"
+
+    logger.info "Starting instance alias=#{instance_alias}, instance_id=#{instance_item.instance_id}"
+
+    cloud.start_instance(instance_item.instance_id)
+
+    # Re-starting an instance will almost certainly give it a new set of IPs and DNS entries, so refresh the values.
+    print "Waiting for instance to start"
+    while true do
+      print "."
+      sleep 2
+
+      break if refresh_instance(instance_alias)
+    end
+  end
+
+  # delete from ~/.ssh/known_hosts all lines that begin with ec2- or instance_alias
+  def cleanup_known_hosts(instance_item)
+    logger.info "Cleaning ~/.ssh/known_hosts"
+    File.open(File.expand_path('~/.ssh/known_hosts'), 'r+') do |f|
+        out = ""
+        f.each do |line|
+          line = case line
+            when /^ec2-/; ''
+            when /#{instance_item.full_name}/; ''
+            when /#{instance_item.external_host}/; ''
+            when /#{instance_item.external_ip}/; ''
+            else line;
+          end
+          out << line
+        end
+        f.pos = 0
+        f.print out
+        f.truncate(f.pos)
+    end
+  end
+
+  def get_role_dependencies
+    # convert string format of role_dependencies from rubber.yml into
+    # objects for use by expand_role_dependencies
+    deps = {}
+    rubber_env.role_dependencies.each do |k, v|
+      rhs = Array(v).collect {|r| Rubber::Configuration::RoleItem.parse(r)}
+      deps[Rubber::Configuration::RoleItem.parse(k)] = rhs
+    end if rubber_env.role_dependencies
+    return deps
+  end
+  
+end