axtro-rubber 1.0.2.1

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

@@ -0,0 +1,28 @@
+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 "ID: #{image[:id]}"
+      logger.info "Location: #{image[:location]}"
+    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
+    run "find #{shared_path} -name cached-copy -prune -o -print | xargs chown #{rubber_env.app_user}:#{rubber_env.app_user}"
+    run "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
+
+    sudo "sh -c 'cd #{path} && #{extra_env} rake rubber:config'"
+  end
+
+end

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

@@ -0,0 +1,348 @@
+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|
+      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)
+  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_instances.each do |ic|
+      destroy_instance(ic.name)
+    end
+  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()
+  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()
+  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_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
+    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, security_groups)
+    rubber_instances.add(instance_item)
+    rubber_instances.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]
+        instance_item.zone = instance[:zone]
+        rubber_instances.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_instances.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_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
+
+    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]
+      instance_item.zone = instance[:zone]
+
+      # 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_instances.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
+    end
+  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
+
+
+  # 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