nogara-rubber 1.7.2

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/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

data/lib/rubber/recipes/rubber/volumes.rb

@@ -0,0 +1,264 @@
+namespace :rubber do
+
+  desc <<-DESC
+    Sets up persistent volumes in the cloud
+    All volumes defined in rubber.yml will be created if neccessary, and attached/mounted on their associated instances
+  DESC
+  required_task :setup_volumes do
+    rubber_instances.filtered.each do |ic|
+      env = rubber_cfg.environment.bind(ic.role_names, ic.name)
+      created_vols = []
+      vol_specs = env.volumes || []
+      vol_specs.each do |vol_spec|
+        created_vols << setup_volume(ic, vol_spec)
+      end
+      created_vols.compact!
+
+      created_parts = []
+      partition_specs = env.local_volumes || []
+      partition_specs.each do |partition_spec|
+        created_parts << setup_partition(ic, partition_spec)
+      end
+      created_parts.compact!
+      zero_partitions(ic, created_parts)
+      created_vols += created_parts
+      
+      created_vols = created_vols.compact.uniq
+      raid_specs = env.raid_volumes || []
+      raid_specs.each do |raid_spec|
+        # we want to format if we created the ec2 volumes, or if we don't have any
+        # ec2 volumes and are just creating raid array from ephemeral stores
+        format = raid_spec['source_devices'].all? {|dev| created_vols.include?(dev)}
+        setup_raid_volume(ic, raid_spec, format)
+      end
+    end
+  end
+
+  desc <<-DESC
+    Shows the configured persistent volumes
+  DESC
+  required_task :describe_volumes do
+    results = []
+    format = "%-20s %-15s %-15s %-20s"
+    results << format % %w[Id Status Attached Instance]
+
+    volumes = cloud.describe_volumes()
+    volumes.each do |volume|
+      results << format % [volume[:id], volume[:status], volume[:attachment_status], volume[:attachment_instance_id]]
+    end
+
+    results.each {|r| logger.info r}
+  end
+
+  desc <<-DESC
+    Shows the configured persistent volumes
+  DESC
+  required_task :destroy_volume do
+    volume_id = get_env('VOLUME_ID', "Volume ID", true)
+    destroy_volume(volume_id)
+  end
+
+  def create_volume(size, zone)
+    volumeId = cloud.create_volume(size.to_s, zone)
+    fatal "Failed to create volume" if volumeId.nil?
+    return volumeId
+  end
+
+  def attach_volume(vol_id, instance_id, device)
+    cloud.attach_volume(vol_id, instance_id, device)
+  end
+
+  def setup_volume(ic, vol_spec)
+    created = nil
+    key = "#{ic.name}_#{vol_spec['device']}"
+    artifacts = rubber_instances.artifacts
+    vol_id = artifacts['volumes'][key]
+
+    # first create the volume if we don't have a global record (artifacts) for it
+    if ! vol_id
+      logger.info "Creating volume for #{ic.full_name}:#{vol_spec['device']}"
+      vol_id = create_volume(vol_spec['size'], vol_spec['zone'])
+      artifacts['volumes'][key] = vol_id
+      rubber_instances.save
+      created = vol_spec['device']
+    end
+
+    # then, attach it if we don't have a record (on instance) of attachment
+    ic.volumes ||= []
+    if ! ic.volumes.include?(vol_id)
+      logger.info "Attaching volume #{vol_id} to #{ic.full_name}:#{vol_spec['device']}"
+      attach_volume(vol_id, ic.instance_id, vol_spec['device'])
+      ic.volumes << vol_id
+      rubber_instances.save
+
+      print "Waiting for volume to attach"
+      while true do
+        print "."
+        sleep 2
+        volume = cloud.describe_volumes(vol_id).first
+        break if volume[:status] == "in-use"
+      end
+      print "\n"
+
+      # we don't mount/format at this time if we are doing a RAID array
+      if vol_spec['mount'] && vol_spec['filesystem']
+        # then format/mount/etc if we don't have an entry in hosts file
+        task :_setup_volume, :hosts => ic.external_ip do
+          rubber.sudo_script 'setup_volume', <<-ENDSCRIPT
+            if ! grep -q '#{vol_spec['mount']}' /etc/fstab; then
+              if mount | grep -q '#{vol_spec['mount']}'; then
+                umount '#{vol_spec['mount']}'
+              fi
+              mv /etc/fstab /etc/fstab.bak
+              cat /etc/fstab.bak | grep -v '#{vol_spec['mount']}' > /etc/fstab
+              echo '#{vol_spec['device']} #{vol_spec['mount']} #{vol_spec['filesystem']} noatime 0 0 # rubber volume #{vol_id}' >> /etc/fstab
+
+              #{('yes | mkfs -t ' + vol_spec['filesystem'] + ' ' + vol_spec['device']) if created}
+              mkdir -p '#{vol_spec['mount']}'
+              mount '#{vol_spec['mount']}'
+            fi
+          ENDSCRIPT
+        end
+        _setup_volume
+      end
+
+    end
+    return created
+  end
+
+  def setup_partition(ic, partition_spec)
+    created = nil
+    part_id = partition_spec['partition_device']
+
+    # Only create the partition if we haven't already done so
+    ic.partitions ||= []
+    if ! ic.partitions.include?(part_id)
+      # then format/mount/etc if we don't have an entry in hosts file
+      task :_setup_partition, :hosts => ic.external_ip do
+        rubber.sudo_script 'setup_partition', <<-ENDSCRIPT
+          if ! fdisk -l 2>&1 | grep -q '#{partition_spec['partition_device']}'; then
+            if grep -q '#{partition_spec['disk_device']}\\b' /etc/fstab; then
+              umount #{partition_spec['disk_device']}
+              mv /etc/fstab /etc/fstab.bak
+              cat /etc/fstab.bak | grep -v '#{partition_spec['disk_device']}\\b' > /etc/fstab
+            fi
+
+            # partition format is: Start (blank is first available),Size(MB due to -uM),Id(83=linux,82=swap,etc),Bootable
+            echo "#{partition_spec['start']},#{partition_spec['size']},#{partition_spec['type']},#{partition_spec['bootable']}" | sfdisk -L -uM #{partition_spec['disk_device']}
+          fi
+        ENDSCRIPT
+      end
+      _setup_partition
+
+      ic.partitions << part_id
+      rubber_instances.save
+      created = part_id
+
+    end
+
+    return created
+  end
+
+  def zero_partitions(ic, partitions)
+    env = rubber_cfg.environment.bind(ic.role_names, ic.name)
+
+    # don't zero out the ones that we weren't told to
+    partitions.delete_if do |part|
+      spec = env.local_volumes.find {|s| s['partition_device'] == part}
+      ! spec['zero']
+    end
+
+    if partitions.size > 0
+      zero_script = ""
+      partitions.each do |partition|
+        zero_script << "nohup dd if=/dev/zero bs=1M of=#{partition} &> /dev/null &\n"
+      end
+      # then format/mount/etc if we don't have an entry in hosts file
+      task :_zero_partitions, :hosts => ic.external_ip do
+        rubber.sudo_script 'zero_partitions', <<-ENDSCRIPT
+          # zero out parition for performance (see amazon DevGuide)
+          echo "Zeroing out raid partitions to improve performance, this way take a while"
+          #{zero_script}
+
+          echo "Waiting for partitions to zero out"
+          while true; do
+            if ! ps ax | grep -q "[d]d.*/dev/zero"; then exit; fi
+            echo -n .
+            sleep 1
+          done
+        ENDSCRIPT
+      end
+      _zero_partitions
+    end
+  end
+
+  def setup_raid_volume(ic, raid_spec, create=false)
+    if create
+      mdadm_init = "mdadm --create #{raid_spec['device']} --level #{raid_spec['raid_level']} --raid-devices #{raid_spec['source_devices'].size} #{raid_spec['source_devices'].sort.join(' ')}"
+    else
+      mdadm_init = "mdadm --assemble #{raid_spec['device']} #{raid_spec['source_devices'].sort.join(' ')}"
+    end
+
+    task :_setup_raid_volume, :hosts => ic.external_ip do
+      rubber.sudo_script 'setup_raid_volume', <<-ENDSCRIPT
+        if ! grep -q '#{raid_spec['device']}' /etc/fstab; then
+          if mount | grep -q '#{raid_spec['mount']}'; then
+            umount '#{raid_spec['mount']}'
+          fi
+          mv /etc/fstab /etc/fstab.bak
+          cat /etc/fstab.bak | grep -v '#{raid_spec['mount']}' > /etc/fstab
+          echo '#{raid_spec['device']} #{raid_spec['mount']} #{raid_spec['filesystem']} noatime 0 0 # rubber raid volume' >> /etc/fstab
+
+          # seems to help devices initialize, otherwise mdadm fails because
+          # device not ready even though ec2 says the volume is attached
+          fdisk -l &> /dev/null
+
+          #{mdadm_init}
+
+          # set reconstruction speed
+          echo $((30*1024)) > /proc/sys/dev/raid/speed_limit_min
+
+          echo 'DEVICE /dev/hd*[0-9] /dev/sd*[0-9]' > /etc/mdadm/mdadm.conf
+          mdadm --detail --scan >> /etc/mdadm/mdadm.conf
+
+          mv /etc/rc.local /etc/rc.local.bak
+          echo "mdadm --assemble --scan" > /etc/rc.local
+          chmod +x /etc/rc.local
+
+          #{('yes | mkfs -t ' + raid_spec['filesystem'] + ' ' + raid_spec['device']) if create}
+          mkdir -p '#{raid_spec['mount']}'
+          mount '#{raid_spec['mount']}'
+        fi
+      ENDSCRIPT
+    end
+    _setup_raid_volume
+  end
+
+  def destroy_volume(volume_id)
+
+    logger.info "Detaching volume #{volume_id}"
+    cloud.detach_volume(volume_id) rescue logger.info("Volume was not attached")
+
+    print "Waiting for volume to detach"
+    while true do
+      print "."
+      sleep 2
+      volume = cloud.describe_volumes(volume_id).first
+      status = volume && volume[:attachment_status]
+      break if !status || status == "detached"
+    end
+    print "\n"
+
+    logger.info "Deleting volume #{volume_id}"
+    cloud.destroy_volume(volume_id)
+
+    logger.info "Removing volume #{volume_id} from rubber instances file"
+    artifacts = rubber_instances.artifacts
+    artifacts['volumes'].delete_if {|k,v| v == volume_id}
+    rubber_instances.each do |ic|
+      ic.volumes.delete(volume_id) if ic.volumes
+    end
+    rubber_instances.save
+  end
+  
+end