rubber-jcarnegie 0.0.1

data/lib/rubber/recipes/rubber/spot_requests.rb

@@ -0,0 +1,23 @@
+namespace :rubber do
+
+  desc "Describes all your spot instance requests"
+  required_task :describe_spot_instance_requests do
+    requests = cloud.describe_spot_instance_requests()
+    requests.each do |request|
+      logger.info "======================"
+      logger.info "ID: #{request[:id]}"
+      logger.info "Created at: #{request[:created_at]}"
+      logger.info "Max. price: $#{request[:spot_price]}"
+      logger.info "State: #{request[:state]}"
+      logger.info "Instance type: #{request[:type]}"
+      logger.info "AMI: #{request[:image_id]}"
+    end
+  end
+
+  desc "Cancel the spot instances request for the given id"
+  required_task :cancel_spot_instances_request do
+    request_id = get_env('SPOT_INSTANCE_REQUEST_ID', 'The id of the spot instances request to cancel', true)
+    cloud.destroy_spot_instance_request(request_id)
+  end
+
+end

data/lib/rubber/recipes/rubber/static_ips.rb

@@ -0,0 +1,190 @@
+namespace :rubber do
+
+
+  desc <<-DESC
+    Sets up static IPs for the instances configured to have them
+  DESC
+  required_task :setup_static_ips do
+    rubber_instances.each do |ic|
+      env = rubber_cfg.environment.bind(ic.role_names, ic.name)
+      if env.use_static_ip
+        artifacts = rubber_instances.artifacts
+        ip = artifacts['static_ips'][ic.name] rescue nil
+
+        # first allocate the static ip if we don't have a global record (artifacts) for it
+        if ! ip
+          logger.info "Allocating static IP for #{ic.full_name}"
+          ip = allocate_static_ip()
+          artifacts['static_ips'][ic.name] = ip
+          rubber_instances.save
+        end
+
+        # then, associate it if we don't have a record (on instance) of association
+        if ! ic.static_ip
+          logger.info "Associating static ip #{ip} with #{ic.full_name}"
+          associate_static_ip(ip, ic.instance_id)
+
+          instance = cloud.describe_instances(ic.instance_id).first
+          ic.external_host = instance[:external_host]
+          ic.internal_host = instance[:internal_host]
+          ic.external_ip = ip
+          ic.static_ip = ip
+          rubber_instances.save()
+
+          logger.info "Waiting for static ip to associate"
+          while true do
+            task :_wait_for_static_ip, :hosts => ip do
+              run "echo"
+            end
+            begin
+              _wait_for_static_ip
+            rescue ConnectionError
+              sleep 2
+              logger.info "Failed to connect to static ip #{ip}, retrying"
+              retry
+            end
+            break
+          end
+        end
+
+      end
+    end
+  end
+
+  desc <<-DESC
+    Shows the configured static IPs
+  DESC
+  required_task :describe_static_ips do
+    results = []
+    format = "%-10s %-15s %-30s"
+    results << format % %w[InstanceID IP Alias]
+
+    ips = cloud.describe_static_ips()
+    ips.each do |ip_data|
+      instance_id = ip_data[:instance_id]
+      ip = ip_data[:ip]
+
+      local_alias = find_alias(ip, instance_id, false)
+
+      results << format % [instance_id || "Unassigned", ip, local_alias || "Unknown"]
+    end
+    
+    results.each {|r| logger.info r}
+  end
+
+  desc <<-DESC
+    Deallocates the given static ip
+  DESC
+  required_task :destroy_static_ip do
+    ip = get_env('IP', "Static IP (run rubber:describe_static_ips for a list)", true)
+    destroy_static_ip(ip)
+  end
+
+  desc 'Move a static IP address from DONOR machine to RECEIVER machine.'
+  task :move_static_ip do
+    donor_alias = get_env 'DONOR', 'Instance alias to get the IP from (e.g., web01)', true
+    receiver_alias = get_env 'RECEIVER', 'Instance alias to assign the IP to (e.g., web02)', true
+
+    # Sanity checks
+    donor = rubber_instances[donor_alias]
+    fatal "Instance does not exist: #{donor_alias}" unless donor
+
+    static_ip = donor.static_ip
+    fatal 'No static IP address to move exists' unless static_ip && static_ip != ''
+
+    receiver = rubber_instances[receiver_alias]
+    fatal "Instance does not exist: #{receiver_alias}" unless receiver
+
+    # Temporary removal of the instances.
+    old_donor = rubber_instances.remove(donor_alias)
+    old_receiver = rubber_instances.remove(receiver_alias)
+
+    rubber_instances.save
+
+    # Getting rid of alias->IP mappings and SSH's known_hosts records.
+    load_roles
+    setup_aliases
+    cleanup_known_hosts(old_donor)
+    cleanup_known_hosts(old_receiver)
+
+    # Detachment of EIPA.
+    success = cloud.detach_static_ip(static_ip)
+    fatal "Failed to detach static IP address #{static_ip}" unless success
+    rubber_instances.artifacts['static_ips'].delete(old_donor.name)
+
+    rubber_instances.save
+
+    # Attachment of EIPA.
+    success = cloud.attach_static_ip(static_ip, old_receiver.instance_id)
+    fatal "Failed to associate static IP address #{static_ip}" unless success
+
+    print "Waiting for #{receiver_alias} to get the address"
+    while true do
+      print '.'
+      sleep 3
+      instance = cloud.describe_instances(old_receiver.instance_id).first
+      break if instance[:external_ip] == static_ip
+    end
+
+    # Partial cleanup of static IP records.
+    rubber_instances.artifacts['static_ips'][old_receiver.name] = static_ip
+
+    rubber_instances.save
+
+    # First half of the sync.
+    new_receiver = Rubber::Configuration::InstanceItem.new(old_receiver.name,
+      old_receiver.domain, old_receiver.roles, old_receiver.instance_id,
+      old_receiver.security_groups)
+    new_receiver.static_ip = static_ip
+    rubber_instances.add(new_receiver)
+
+    rubber_instances.save
+
+    refresh_instance(receiver_alias)
+
+    print "Waiting for #{donor_alias} to get a new address"
+    while true do
+      print '.'
+      sleep 3
+      instance = cloud.describe_instances(old_donor.instance_id).first
+      break if instance[:external_ip] && instance[:external_ip] != ''
+    end
+
+    # Second half of the sync.
+    new_donor = Rubber::Configuration::InstanceItem.new(old_donor.name,
+      old_donor.domain, old_donor.roles, old_donor.instance_id,
+      old_donor.security_groups)
+    rubber_instances.add(new_donor)
+
+    rubber_instances.save
+
+    refresh_instance(donor_alias)
+
+    logger.info "Run 'cap rubber:describe_static_ips' to check the allocated ones"
+  end
+
+  def allocate_static_ip()
+    ip = cloud.create_static_ip()
+    fatal "Failed to allocate static ip" if ip.nil?
+    return ip
+  end
+
+  def associate_static_ip(ip, instance_id)
+    success = cloud.attach_static_ip(ip, instance_id)
+    fatal "Failed to associate static ip" unless success
+  end
+
+  def destroy_static_ip(ip)
+    logger.info "Releasing static ip: #{ip}"
+    cloud.destroy_static_ip(ip) rescue logger.info("IP was not attached")
+
+    logger.info "Removing ip #{ip} from rubber instances file"
+    artifacts = rubber_instances.artifacts
+    artifacts['static_ips'].delete_if {|k,v| v == ip}
+    rubber_instances.each do |ic|
+      ic.static_ip = nil if ic.static_ip == ip
+    end
+    rubber_instances.save
+  end
+
+end

data/lib/rubber/recipes/rubber/tags.rb

@@ -0,0 +1,12 @@
+require 'rubber/tag'
+
+namespace :rubber do
+  desc <<-DESC
+    Updates ALL the tags on EC2 instances for the current env
+  DESC
+  required_task :update_tags do
+    rubber_instances.each do |ic|
+      Rubber::Tag::update_instance_tags(ic.name)
+    end
+  end
+end

data/lib/rubber/recipes/rubber/utils.rb

@@ -0,0 +1,226 @@
+namespace :rubber do
+    
+  desc <<-DESC
+    Convenience task for creating a staging instance for the given RUBBER_ENV/RAILS_ENV.
+    By default this task assigns all known roles when creating the instance,
+    but you can specify a different default in rubber.yml:staging_roles
+    At the end, the instance will be up and running
+    e.g. RUBBER_ENV=matt cap create_staging
+  DESC
+  required_task :create_staging do
+    if rubber_instances.size > 0
+      value = Capistrano::CLI.ui.ask("The #{RUBBER_ENV} environment already has instances, Are you SURE you want to create a staging instance that may interact with them [y/N]?: ")
+      fatal("Exiting", 0) if value !~ /^y/
+    end
+    instance_alias = ENV['ALIAS'] = rubber.get_env("ALIAS", "Hostname to use for staging instance", true, RUBBER_ENV)
+    default_roles = rubber_env.staging_roles || "*"
+    roles = ENV['ROLES'] = rubber.get_env("ROLES", "Roles to use for staging instance", true, default_roles)
+
+    if rubber_instances[instance_alias]
+      logger.info "Instance already exists, skipping to bootstrap"
+    else
+      rubber.create
+    end
+
+    # stop everything before so monit doesn't start stuff during bootstrapping
+    # if its already installed due to a bundled instance
+    deploy.stop rescue nil
+
+    rubber.bootstrap
+    
+    # stop everything after in case package upgrades during bootstrap start up
+    # services - we should be able to safely do a deploy:start below
+    deploy.stop rescue nil
+
+    # some bootstraps update code (bootstrap_db) but if you don't have that role, need to do it here
+    # Since release directory variable gets reused by cap, we have to just do the symlink here - doing
+    # a update again will fail
+    if ! fetch(:rubber_code_was_updated, false)
+      deploy.update_code
+    end
+    deploy.symlink
+    deploy.migrate
+    deploy.start
+  end
+
+  desc <<-DESC
+    Destroy the staging instance for the given RUBBER_ENV.
+  DESC
+  task :destroy_staging do
+    ENV['ALIAS'] = rubber.get_env("ALIAS", "Hostname of staging instance to be destroyed", true, RUBBER_ENV)
+    rubber.destroy
+  end
+
+  desc <<-DESC
+    Live tail of rails log files for all machines
+    By default tails the rails logs for the current RUBBER_ENV, but one can
+    set FILE=/path/file.*.glob to tails a different set
+  DESC
+  task :tail_logs, :roles => :app do
+    log_file_glob = rubber.get_env("FILE", "Log files to tail", true, "#{current_path}/log/#{RUBBER_ENV}*.log")
+    run "tail -qf #{log_file_glob}" do |channel, stream, data|
+      puts  # for an extra line break before the host name
+      puts data
+      break if stream == :err
+    end
+  end
+
+  # Use instead of task to define a capistrano task that runs serially instead of in parallel
+  # The :groups option specifies how many groups to partition the servers into so that we can
+  # do the task for N (= total/groups) servers at a time.  When multiple roles are supplied,
+  # this tries to be intelligent and slice up each role independently, but runs the slices together
+  # so that things don't take too long, e.g. adding an :api role to some :app servers, when restarting
+  # you don't want to do the api first, then the others as this would take a long time, so instead
+  # it does some :api and some :app, then some more of each
+  #
+  def serial_task(ns, name, options = {}, &block)
+    # first figure out server names for the passed in roles - when no roles
+    # are passed in, use all servers
+    serial_roles = Array(options[:roles])
+    servers = {}
+    if serial_roles.empty?
+      all_servers = []
+      self.roles.each do |rolename, serverdefs|
+        all_servers += serverdefs.collect {|server| server.host}
+      end
+      servers[:_serial_all] = all_servers.uniq.sort
+    else
+      # get servers for each role
+      self.roles.each do |rolename, serverdefs|
+        if serial_roles.include?(rolename)
+          servers[rolename] ||= []
+          servers[rolename] += serverdefs.collect {|server| server.host}
+        end
+      end
+
+      # Remove duplication of servers - roles which come first in list
+      # have precedence, so the servers show up in that group
+      serial_roles.each_with_index do |rolename, i|
+        servers[rolename] ||= []
+        serial_roles[i+1..-1].each do |r|
+          servers[r] -= servers[rolename]
+        end
+        servers[rolename] = servers[rolename].uniq.sort
+      end
+    end
+
+    # group each role's servers into slices, but combine slices across roles
+    slices = []
+    servers.each do |rolename, svrs|
+      next if svrs.size == 0
+      # figure out size of each slice by dividing server count by # of groups
+      slice_size = (Float(svrs.size) / (options.delete(:groups) || 2)).round
+      slice_size = 1 if slice_size == 0
+      slice_idx = 0
+      svrs.each_slice(slice_size) do |srv_slice|
+        slices[slice_idx] ||= []
+        slices[slice_idx] += srv_slice
+        slice_idx += 1
+      end
+    end
+    # for each slice, define a new task specific to the hosts in that slice
+    task_syms = []
+    slices.each do |server_group|
+      servers = server_group.map{|s| s.gsub(/\..*/, '')}.join("_")
+      task_sym = "_serial_task_#{name.to_s}_#{servers}".to_sym
+      task_syms << task_sym
+      ns.task task_sym, options.merge(:hosts => server_group), &block
+    end
+
+    # create the top level task that calls all the serial ones
+    ns.task name, options do
+      task_syms.each do |t|
+        ns.send t
+      end
+    end
+  end
+
+  def find_alias(ip, instance_id, do_connect=true)
+    if instance_id
+      instance = rubber_instances.find {|i| i.instance_id == instance_id }
+      local_alias = instance.full_name if instance
+    end
+    local_alias ||= File.read("/etc/hosts").grep(/#{ip}/).first.split[1] rescue nil
+    if ! local_alias && do_connect
+      task :_get_ip, :hosts => ip do
+        local_alias = "* " + capture("hostname").strip
+      end
+      _get_ip rescue ConnectionError
+    end
+    return local_alias
+  end
+
+  def prepare_script(name, contents, stop_on_error_cmd=rubber_env.stop_on_error_cmd)
+    script = "/tmp/#{name}"
+    # this lets us abort a script if a command in the middle of it errors out
+    contents = "#{stop_on_error_cmd}\n#{contents}" if stop_on_error_cmd
+    put(contents, script)
+    return script
+  end
+
+  def run_script(name, contents, opts = {})
+    args = opts.delete(:script_args)
+    script = prepare_script(name, contents)
+    run "bash #{script} #{args}", opts
+  end
+
+  def sudo_script(name, contents, opts = {})
+    args = opts.delete(:script_args)
+    script = prepare_script(name, contents)
+    run "#{sudo} bash -l #{script} #{args}", opts
+  end
+
+  def top.rsudo(command, opts = {}, &block)
+    user = opts.delete(:as)
+    args = "-H -u #{user}" if user
+    run "#{sudo opts} #{args} bash -l -c '#{command}'", opts, &block
+  end
+
+  def get_env(name, desc, required=false, default=nil)
+    value = ENV.delete(name)
+    msg = "#{desc}"
+    msg << " [#{default}]" if default
+    msg << ": "
+    value = Capistrano::CLI.ui.ask(msg) unless value
+    value = value.size == 0 ? default : value
+    fatal "#{name} is required, pass using environment or enter at prompt" if required && ! value
+    return value
+  end
+
+  def fatal(msg, code=1)
+    logger.info msg
+    exit code
+  end
+
+  # Returns a map of "hostvar_<hostname>" => value for the given config value for each instance host
+  # This is used to run capistrano tasks scoped to the correct role/host so that a config value
+  # specific to a role/host will only be used for that role/host, e.g. the list of packages to
+  # be installed.
+  def get_host_options(cfg_name, &block)
+    opts = {}
+    rubber_instances.each do | ic|
+      env = rubber_cfg.environment.bind(ic.role_names, ic.name)
+      cfg_value = env[cfg_name]
+      if cfg_value
+        if block
+          cfg_value = block.call(cfg_value)
+        end
+        opts["hostvar_#{ic.full_name}"] = cfg_value if cfg_value && cfg_value.strip.size > 0
+      end
+    end
+    return opts
+  end
+
+  # some bootstraps update code (bootstrap_db), so keep track so we don't do it multiple times  
+  after "deploy:update_code" do
+    set :rubber_code_was_updated, true
+  end
+  
+  def update_code_for_bootstrap
+    unless (fetch(:rubber_code_was_updated, false))
+      deploy.setup
+      deploy.update_code
+    end
+  end
+  
+end