sml-rubber 0.9.1

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

@@ -0,0 +1,298 @@
+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)
+    r = get_env('ROLES', "Instance roles (e.g. web,app,db:primary=true)", true)
+    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|
+      data = r.split(':');
+      role = Rubber::Configuration::RoleItem.new(data[0])
+      if data[1]
+        data[1].split(';').each do |pair|
+          p = pair.split('=')
+          val = case p[1]
+                  when 'true' then true
+                  when 'false' then false
+                  else p[1] end
+          role.options[p[0]] = val
+        end
+      end
+
+      # If user doesn't setup a primary db, then be nice and do it
+      if role.name == "db" && role.options["primary"] == nil && rubber_cfg.instance.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
+
+    create_instance(instance_alias, ir)
+  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
+  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
+  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
+  task :destroy_all do
+    rubber_cfg.instance.each do |ic|
+      destroy_instance(ic.name)
+    end
+  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)
+    fatal "Instance already exists: #{instance_alias}" if rubber_cfg.instance[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
+    security_groups = env.assigned_security_groups
+    security_group_defns = env.security_groups
+    if env.auto_security_groups
+      hosts = rubber_cfg.instance.collect{|ic| ic.name } + [instance_alias]
+      roles = (rubber_cfg.instance.all_roles + role_names).uniq
+      security_groups << instance_alias
+      security_groups += role_names
+      security_groups.uniq!
+      security_group_defns = inject_auto_security_groups(security_group_defns, hosts, roles)
+      sync_security_groups(security_group_defns)
+    else
+      sync_security_groups(security_group_defns)
+    end
+
+    ami = env.cloud_providers[env.cloud_provider].image_id
+    ami_type = env.cloud_providers[env.cloud_provider].image_type
+    availability_zone = env.availability_zone
+    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)
+
+    logger.info "Instance #{instance_id} created"
+
+    instance_item = Rubber::Configuration::InstanceItem.new(instance_alias, env.domain, instance_roles, instance_id)
+    rubber_cfg.instance.add(instance_item)
+    rubber_cfg.instance.save()
+
+
+    print "Waiting for instance to start"
+    while true do
+      print "."
+      sleep 2
+      instance = cloud.describe_instances(instance_id).first
+
+      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]
+        rubber_cfg.instance.save()
+
+        # 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
+
+        # Connect to newly created instance and grab its internal ip
+        # so that we can update all aliases
+
+        task :_get_ip, :hosts => instance_item.external_ip do
+          instance_item.internal_ip = capture(print_ip_command).strip
+          rubber_cfg.instance.save()
+        end
+
+        # even though instance is running, sometimes ssh hasn't started yet,
+        # so retry on connect failure
+        begin
+          _get_ip
+        rescue ConnectionError
+          sleep 2
+          logger.info "Failed to connect to #{instance_alias} (#{instance_item.external_ip}), retrying"
+          retry
+        end
+
+        # Add the aliases for this instance to all other hosts
+        setup_remote_aliases
+        setup_dns_aliases
+
+        break
+      end
+    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_cfg.instance[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_instance(instance_item.instance_id).first
+
+    if instance[:state] == "running"
+      logger.info "\nInstance 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]
+
+      # 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
+
+      # Connect to newly created instance and grab its internal ip
+      # so that we can update all aliases
+      task :_get_ip, :hosts => instance_item.external_ip do
+        instance_item.internal_ip = capture(print_ip_command).strip
+      end
+      # even though instance is running, we need to give ssh a chance
+      # to get started
+      sleep 5
+      _get_ip
+
+      # Add the aliases for this instance to all other hosts
+      setup_remote_aliases
+      setup_dns_aliases
+    end
+
+    rubber_cfg.instance.save()
+  end
+
+
+  # Destroys the given ec2 instance
+  def destroy_instance(instance_alias)
+    instance_item = rubber_cfg.instance[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_cfg.instance.remove(instance_alias)
+    rubber_cfg.instance.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
+
+
+  # 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
+
+end

data/lib/rubber/recipes/rubber/security_groups.rb

@@ -0,0 +1,149 @@
+namespace :rubber do
+
+  desc <<-DESC
+    Sets up the network security groups
+    All defined groups will be created, and any not defined will be removed.
+    Likewise, rules within a group will get created, and those not will be removed
+  DESC
+  required_task :setup_security_groups do
+    env = rubber_cfg.environment.bind()
+    security_group_defns = env.security_groups
+    if env.auto_security_groups
+      hosts = rubber_cfg.instance.collect{|ic| ic.name }
+      roles = rubber_cfg.instance.all_roles
+      security_group_defns = inject_auto_security_groups(security_group_defns, hosts, roles)
+      sync_security_groups(security_group_defns)
+    else
+      sync_security_groups(security_group_defns)
+    end
+  end
+
+  desc <<-DESC
+    Describes the network security groups
+  DESC
+  required_task :describe_security_groups do
+    groups = cloud.describe_security_groups()
+    groups.each do |group|
+      puts "#{group[:name]}, #{group[:description]}"
+      group[:permissions].each do |perm|
+        puts "  protocol: #{perm[:protocol]}"
+        puts "  from_port: #{perm[:from_port]}"
+        puts "  to_port: #{perm[:to_port]}"
+        puts "  source_groups: #{perm[:source_groups].collect {|g| g[:name]}.join(", ") }" if perm[:source_groups]
+        puts "  source_ips: #{perm[:source_ips].join(", ") }" if perm[:source_ips]
+        puts "\n"
+      end if group[:permissions]
+      puts "\n"
+    end
+  end
+
+
+  def inject_auto_security_groups(groups, hosts, roles)
+    hosts.each do |name|
+      group_name = name
+      groups[group_name] ||= {'description' => "Rubber automatic security group for host: #{name}", 'rules' => []}
+    end
+    roles.each do |name|
+      group_name = name
+      groups[group_name] ||= {'description' => "Rubber automatic security group for role: #{name}", 'rules' => []}
+    end
+    return groups
+  end
+
+  def sync_security_groups(groups)
+    env = rubber_cfg.environment.bind()
+    return unless groups
+
+    groups = Rubber::Util::stringify(groups)
+    group_keys = groups.keys.clone()
+
+    # For each group that does already exist in ec2
+    cloud_groups = cloud.describe_security_groups()
+    cloud_groups.each do |cloud_group|
+      group_name = cloud_group[:name]
+      if group_keys.delete(group_name)
+        # sync rules
+        logger.debug "Security Group already in ec2, syncing rules: #{group_name}"
+        group = groups[group_name]
+        rules = group['rules'].clone
+        rule_maps = []
+
+        # first collect the rule maps from the request (group/user pairs are duplicated for tcp/udp/icmp,
+        # so we need to do this up frnot and remove duplicates before checking against the local rubber rules)
+        cloud_group[:permissions].each do |rule|
+          if rule[:source_groups]
+            rule.source_groups.each do |source_group|
+              rule_map = {:source_group_name => source_group[:name], :source_group_account => source_group[:account]}
+              rule_map = Rubber::Util::stringify(rule_map)
+              rule_maps << rule_map unless rule_maps.include?(rule_map)
+            end
+          else
+            rule_map = Rubber::Util::stringify(rule)
+            rule_maps << rule_map unless rule_maps.include?(rule_map)
+          end
+        end if cloud_group[:permissions]
+        # For each rule, if it exists, do nothing, otherwise remove it as its no longer defined locally
+        rule_maps.each do |rule_map|
+          if rules.delete(rule_map)
+            # rules match, don't need to do anything
+            # logger.debug "Rule in sync: #{rule_map.inspect}"
+          else
+            # rules don't match, remove them from ec2 and re-add below
+            answer = Capistrano::CLI.ui.ask("Rule '#{rule_map.inspect}' exists in ec2, but not locally, remove from ec2? [y/N]?: ")
+            rule_map = Rubber::Util::symbolize_keys(rule_map)
+            if rule_map[:source_group_name]
+              cloud.remove_security_group_rule(group_name, nil, nil, nil, {:name => rule_map[:source_group_name], :account => rule_map[:source_group_account]})
+            else
+              rule_map[:source_ips].each do |source_ip|
+                cloud.remove_security_group_rule(group_name, rule_map[:protocol], rule_map[:from_port], rule_map[:to_port], source_ip)
+              end if rule_map[:source_ips] && answer =~ /^y/
+            end
+          end
+        end
+
+        rules.each do |rule_map|
+          # create non-existing rules
+          logger.debug "Missing rule, creating: #{rule_map.inspect}"
+          rule_map = Rubber::Util::symbolize_keys(rule_map)
+          if rule_map[:source_group_name]
+            cloud.add_security_group_rule(group_name, nil, nil, nil, {:name => rule_map[:source_group_name], :account => rule_map[:source_group_account]})
+          else
+            rule_map[:source_ips].each do |source_ip|
+              cloud.add_security_group_rule(group_name, rule_map[:protocol], rule_map[:from_port], rule_map[:to_port], source_ip)
+            end if rule_map[:source_ips]
+          end
+        end
+      else
+        # when using auto groups, get prompted too much to delete when
+        # switching between production/staging since the hosts aren't shared
+        # between the two environments
+        if env.force_security_group_cleanup || ! env.auto_security_groups
+          # delete group
+          answer = Capistrano::CLI.ui.ask("Security group '#{group_name}' exists in ec2 but not locally, remove from ec2? [y/N]: ")
+          cloud.destroy_security_group(group_name) if answer =~ /^y/
+        end
+      end
+    end
+
+    # For each group that didnt already exist in ec2
+    group_keys.each do |group_name|
+      group = groups[group_name]
+      logger.debug "Creating new security group: #{group_name}"
+      # create each group
+      cloud.create_security_group(group_name, group['description'])
+      # create rules for group
+      group['rules'].each do |rule_map|
+        logger.debug "Creating new rule: #{rule_map.inspect}"
+        rule_map = Rubber::Util::symbolize_keys(rule_map)
+        if rule_map[:source_group_name]
+          cloud.add_security_group_rule(group_name, nil, nil, nil, {:name => rule_map[:source_group_name], :account => rule_map[:source_group_account]})
+        else
+          rule_map[:source_ips].each do |source_ip|
+            cloud.add_security_group_rule(group_name, rule_map[:protocol], rule_map[:from_port], rule_map[:to_port], source_ip)
+          end if rule_map[:source_ips]
+        end
+      end
+    end
+  end
+
+end

data/lib/rubber/recipes/rubber/setup.rb

@@ -0,0 +1,285 @@
+namespace :rubber do
+
+  desc <<-DESC
+    Bootstraps instances by setting timezone, installing packages and gems
+  DESC
+  task :bootstrap do
+    set_timezone
+    link_bash
+    install_packages
+    setup_volumes
+    add_gem_sources
+    install_gems
+    deploy.setup
+  end
+
+  desc <<-DESC
+    Sets up aliases for instance hostnames based on contents of instance.yml.
+    Generates /etc/hosts for local/remote machines and sets hostname on
+    remote instances, and sets values in dynamic dns entries
+  DESC
+  required_task :setup_aliases do
+    setup_local_aliases
+    setup_remote_aliases
+    setup_dns_aliases
+  end
+
+  desc <<-DESC
+    Sets up local aliases for instance hostnames based on contents of instance.yml.
+    Generates/etc/hosts for local machine
+  DESC
+  required_task :setup_local_aliases do
+    hosts_file = '/etc/hosts'
+
+    # Generate /etc/hosts contents for the local machine from instance config
+    env = rubber_cfg.environment.bind()
+    delim = "## rubber config #{env.domain} #{RUBBER_ENV}"
+    local_hosts = delim + "\n"
+    rubber_cfg.instance.each do |ic|
+      # don't add unqualified hostname in local hosts file since user may be
+      # managing multiple domains with same aliases
+      hosts_data = [ic.full_name, ic.external_host, ic.internal_host].join(' ')
+      local_hosts << ic.external_ip << ' ' << hosts_data << "\n"
+    end
+    local_hosts << delim << "\n"
+
+    # Write out the hosts file for this machine, use sudo
+    filtered = File.read(hosts_file).gsub(/^#{delim}.*^#{delim}\n?/m, '')
+    logger.info "Writing out aliases into local machines #{hosts_file}, sudo access needed"
+    Rubber::Util::sudo_open(hosts_file, 'w') do |f|
+      f.write(filtered)
+      f.write(local_hosts)
+    end
+  end
+
+  desc <<-DESC
+    Sets up aliases in dynamic dns provider for instance hostnames based on contents of instance.yml.
+  DESC
+  required_task :setup_dns_aliases do
+    rubber_cfg.instance.each do |ic|
+      update_dyndns(ic)
+    end
+  end
+
+  desc <<-DESC
+    Sets up aliases for instance hostnames based on contents of instance.yml.
+    Generates /etc/hosts for remote machines and sets hostname on remote instances
+  DESC
+  task :setup_remote_aliases do
+    hosts_file = '/etc/hosts'
+
+    # Generate /etc/hosts contents for the remote instance from instance config
+    delim = "## rubber config"
+    delim = "#{delim} #{RUBBER_ENV}"
+    remote_hosts = delim + "\n"
+    rubber_cfg.instance.each do |ic|
+      hosts_data = [ic.name, ic.full_name, ic.external_host, ic.internal_host].join(' ')
+      remote_hosts << ic.internal_ip << ' ' << hosts_data << "\n"
+    end
+    remote_hosts << delim << "\n"
+    if rubber_cfg.instance.size > 0
+      # write out the hosts file for the remote instances
+      # NOTE that we use "capture" to get the existing hosts
+      # file, which only grabs the hosts file from the first host
+      filtered = (capture "cat #{hosts_file}").gsub(/^#{delim}.*^#{delim}\n?/m, '')
+      filtered = filtered + remote_hosts
+      # Put the generated hosts back on remote instance
+      put filtered, hosts_file
+
+      # Setup hostname on instance so shell, etcs have nice display
+      sudo "echo $CAPISTRANO:HOST$ > /etc/hostname && hostname $CAPISTRANO:HOST$"
+    end
+
+    # TODO
+    # /etc/resolv.conf to add search domain
+    # ~/.ssh/options to setup user/host/key aliases
+  end
+
+  desc <<-DESC
+    Update to the newest versions of all packages/gems.
+  DESC
+  task :update do
+    upgrade_packages
+    update_gems
+  end
+
+  desc <<-DESC
+    Upgrade to the newest versions of all Ubuntu packages.
+  DESC
+  task :upgrade_packages do
+    package_helper(true)
+  end
+
+  desc <<-DESC
+    Upgrade to the newest versions of all rubygems.
+  DESC
+  task :update_gems do
+    gem_helper(true)
+  end
+
+  desc <<-DESC
+    Install extra packages and gems.
+  DESC
+  task :install do
+    install_packages
+    install_gems
+  end
+
+  desc <<-DESC
+    Install extra Ubuntu packages. Set 'packages' in rubber.yml to \
+    be an array of strings.
+  DESC
+  task :install_packages do
+    package_helper(false)
+  end
+
+  desc <<-DESC
+    Install extra ruby gems. Set 'gems' in rubber.yml to \
+    be an array of strings.
+  DESC
+  task :install_gems do
+    gem_helper(false)
+  end
+
+  desc <<-DESC
+    Add extra ruby gems sources. Set 'gemsources' in rubber.yml to \
+    be an array of URI strings.
+  DESC
+  task :add_gem_sources do
+    env = rubber_cfg.environment.bind()
+    if env.gemsources
+      env.gemsources.each { |source| sudo "gem sources -a #{source}"}
+    end
+  end
+
+  desc <<-DESC
+    The ubuntu has /bin/sh linking to dash instead of bash, fix this
+    You can override this task if you don't want this to happen
+  DESC
+  task :link_bash do
+    sudo("ln -sf /bin/bash /bin/sh")
+  end
+
+  desc <<-DESC
+    Set the timezone using the value of the variable named timezone. \
+    Valid options for timezone can be determined by the contents of \
+    /usr/share/zoneinfo, which can be seen here: \
+    http://packages.ubuntu.com/cgi-bin/search_contents.pl?searchmode=filelist&word=tzdata&version=gutsy&arch=all&page=1&number=all \
+    Remove 'usr/share/zoneinfo/' from the filename, and use the last \
+    directory and file as the value. For example 'Africa/Abidjan' or \
+    'posix/GMT' or 'Canada/Eastern'.
+  DESC
+  task :set_timezone do
+    opts = get_host_options('timezone')
+    sudo "bash -c 'echo $CAPISTRANO:VAR$ > /etc/timezone'", opts
+    sudo "cp /usr/share/zoneinfo/$CAPISTRANO:VAR$ /etc/localtime", opts
+    # restart syslog so that times match timezone
+    sudo "/etc/init.d/sysklogd restart"
+  end
+  
+  def update_dyndns(instance_item)
+    env = rubber_cfg.environment.bind(instance_item.role_names, instance_item.name)
+    if env.dns_provider
+      provider = Rubber::Dns::get_provider(env.dns_provider, env)
+      provider.update(instance_item.name, instance_item.external_ip)
+    end
+  end
+
+  def destroy_dyndns(instance_item)
+    env = rubber_cfg.environment.bind(instance_item.role_names, instance_item.name)
+    if env.dns_provider
+      provider = Rubber::Dns::get_provider(env.dns_provider, env)
+      provider.destroy(instance_item.name)
+    end
+  end
+
+  def package_helper(upgrade=false)
+    opts = get_host_options('packages') do |pkg_list|
+      expanded_pkg_list = []
+      pkg_list.each do |pkg_spec|
+        if pkg_spec.is_a?(Array)
+          expanded_pkg_list << "#{pkg_spec[0]}=#{pkg_spec[1]}"
+        else
+          expanded_pkg_list << pkg_spec
+        end
+      end
+      expanded_pkg_list.join(' ')
+    end
+
+    sudo "apt-get -q update"
+    if upgrade
+      sudo "/bin/sh -c 'export DEBIAN_FRONTEND=noninteractive; apt-get -q -y --force-yes dist-upgrade'"
+    else
+      sudo "/bin/sh -c 'export DEBIAN_FRONTEND=noninteractive; apt-get -q -y --force-yes install $CAPISTRANO:VAR$'", opts
+    end
+  end
+
+  def custom_package(url_base, name, ver, install_test)
+    rubber.run_script "install_#{name}", <<-ENDSCRIPT
+      if [[ #{install_test} ]]; then
+        arch=`uname -m`
+        if [ "$arch" = "x86_64" ]; then
+          src="#{url_base}/#{name}_#{ver}_amd64.deb"
+        else
+          src="#{url_base}/#{name}_#{ver}_i386.deb"
+        fi
+        src_file="${src##*/}"
+        wget -qP /tmp ${src}
+        dpkg -i /tmp/${src_file}
+      fi
+    ENDSCRIPT
+  end
+
+  def handle_gem_prompt(ch, data, str)
+    ch[:data] ||= ""
+    ch[:data] << data
+    if data =~ />\s*$/
+      logger.info data
+      logger.info "The gem command is asking for a number:"
+      choice = STDIN.gets
+      ch.send_data(choice)
+    else
+      logger.info data
+    end
+  end
+
+  # Helper for installing gems,allows one to respond to prompts
+  def gem_helper(update=false)
+    cmd = update ? "update" : "install"
+
+    # when versions are provided for a gem, rubygems fails unless versions ae provided for all gems
+    #
+    # first do the gems that the user specified versions for
+    opts = get_host_options('gems') do |gem_list|
+      expanded_gem_list = []
+      gem_list.each do |gem_spec|
+        if gem_spec.is_a?(Array)
+          expanded_gem_list << "#{gem_spec[0]} -v #{gem_spec[1]}"
+        end
+      end
+      expanded_gem_list.join(' ')
+    end
+    if opts.size > 0
+      sudo "gem #{cmd} $CAPISTRANO:VAR$ --no-rdoc --no-ri", opts do |ch, str, data|
+        handle_gem_prompt(ch, data, str)
+      end
+    end
+
+    # then do the gems without versions
+    opts = get_host_options('gems') do |gem_list|
+      expanded_gem_list = []
+      gem_list.each do |gem_spec|
+        if ! gem_spec.is_a?(Array)
+          expanded_gem_list << gem_spec
+        end
+      end
+      expanded_gem_list.join(' ')
+    end
+    if opts.size > 0
+      sudo "gem #{cmd} $CAPISTRANO:VAR$ --no-rdoc --no-ri", opts do |ch, str, data|
+        handle_gem_prompt(ch, data, str)
+      end
+    end
+  end
+
+end