rudy 0.4.0 → 0.6.0

data/lib/rudy/aws/simpledb.rb

@@ -1,53 +0,0 @@
-
-
-
-module Rudy::AWS
-
-  
-  class SimpleDB
-    class Domains 
-      include Rudy::AWS::ObjectBase
-      
-      def create(name)
-        @aws.create_domain(name)
-      end
-      
-      def destroy(name)
-        @aws.delete_domain(name)
-      end
-    
-      def list
-        @aws.list_domains
-      end
-    end
-    
-    def destroy(domain, item, attributes={})
-      @aws.delete_attributes(domain, item, attributes)
-    end
-    
-    def store(domain, item, attributes={}, replace=false)
-      @aws.put_attributes(domain, item, attributes, replace)
-    end
-    
-    def query(domain, query=nil, max=nil)
-      @aws.query(domain, query, max)
-    end
-    
-    def query_with_attributes(domain, query, max=nil)
-      items = {}
-      query(domain, query)[:items].each do |item|
-        items[item] = get_attributes(domain, item)[:attributes]
-      end
-      items
-    end
-    
-    def select(query)
-      list = @aws2.select(query) || []
-      list[0]
-    end
-    
-    def get_attributes(domain, item, attribute=nil)
-      @aws.get_attributes(domain, item, attribute)
-    end
-  end
-end

data/lib/rudy/command/addresses.rb

@@ -1,46 +0,0 @@
-
-
-
-module Rudy
-  module Command
-    class Addresses < Rudy::Command::Base
-
-
-      def associate_addresses_valid?
-        raise "You have not supplied an IP addresses" unless @argv.address
-        raise "You did not supply an instance ID" unless @argv.instanceid
-        
-        @inst = @ec2.instances.get(@argv.instanceid)
-        raise "Instance #{@inst[:aws_instance_id]} does not exist!" unless @inst
-        
-        raise "That's not an elastic IP you own!" unless @ec2.addresses.valid?(@argv.address)
-        raise "#{@argv.address} is already associated!" if @ec2.addresses.associated?(@argv.address)
-        
-        true
-      end
-      
-      def associate_addresses
-        puts "Associating #{@argv.address} to #{@inst[:aws_groups]}: #{@inst[:dns_name]}"
-        @ec2.addresses.associate(@inst[:aws_instance_id], @argv.address)
-        puts "Done!"
-        puts
-        
-        addresses
-      end
-      
-      def addresses
-        puts "Elastic IP mappings:"
-        @ec2.addresses.list.each do |address|
-          print "IP: #{address[:public_ip]} "
-          if address[:instance_id]
-            inst = @ec2.instances.get(address[:instance_id])
-            puts "%s: %s %s" % [inst[:aws_groups], inst[:aws_instance_id], inst[:dns_name]]
-          end
-        end
-        puts
-      end
-      
-    end
-  end
-end
-

data/lib/rudy/command/backups.rb

@@ -1,175 +0,0 @@
-
-
-
-
-module Rudy
-  module Command
-    class Backups < Rudy::Command::Base
-      
-      
-      def backup
-        criteria = [@global.zone]
-        criteria += [@global.environment, @global.role] unless @option.all
-        
-        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
-          puts "%s (%s)" % [backup.name, backup.awsid]
-        end
-      end
-      
-      # Check for backups pointing to snapshots that don't exist. 
-      def sync_backup
-        unless argv.empty?
-          puts "The disk you specified will be ignored."
-          argv.clear
-        end
-        
-        criteria = [@global.zone]
-        criteria += [@global.environment, @global.role] unless @option.all
-        
-        puts "Looking for backup metadata with delinquent snapshots..."
-        to_be_deleted = {} # snap-id => backup
-        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
-          to_be_deleted[backup.awsid] = backup unless @ec2.snapshots.exists?(backup.awsid)
-        end
-        
-        if to_be_deleted.empty?
-          puts "All backups are in-sync with snapshots. Nothing to do."
-          return
-        end
-        
-        puts
-        puts "These backup metadata will be deleted:"
-        to_be_deleted.each do |snap_id, backup|
-          puts "%s: %s" % [snap_id, backup.name]
-        end
-        
-        puts
-        are_you_sure?
-        
-        puts 
-        puts "Deleting..."
-        to_be_deleted.each do |snap_id, backup|
-          print " -> #{backup.name}... "
-          @sdb.destroy(RUDY_DOMAIN, backup.name)
-          puts "done"
-        end
-        
-        puts "Done!"
-      end
-      
-      def destroy_backup_valid?
-        raise "No backup specified" if argv.empty?
-        exit unless are_you_sure?(5)
-        true
-      end
-      
-      def destroy_backup
-        name = @argv.first
-        puts "Destroying #{name}"
-        begin
-          backup = Rudy::MetaData::Backup.get(@sdb, name)
-        rescue => ex
-          puts "Error deleteing backup: #{ex.message}"
-        end
-        
-        return unless backup
-        
-        begin
-          puts " -> deleting snapshot..."
-          @ec2.snapshots.destroy(backup.awsid)
-        rescue => ex
-          puts "Error deleting snapshot: #{ex.message}."
-          puts "Continuing..."
-        ensure
-          puts " -> deleting metadata..."
-          @sdb.destroy(RUDY_DOMAIN, name)
-        end
-        puts "Done."
-      end
-      
-      def create_backup
-        diskname = @argv.first
-        
-        machine = find_current_machine
-        
-        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @global.environment, @global.role, @global.position)
-        raise "The machine #{machine_name} does not have any disk metadata" if disks.empty?
-        
-        puts "Machine: #{machine_name}"
-        
-        if @option.snapshot
-          raise "You must supply a diskname when using an existing snapshot" unless diskname
-          raise "The snapshot #{@option.snapshot} does not exist" unless @ec2.snapshots.exists?(@option.snapshot)
-          disk = Rudy::MetaData::Disk.get(@sdb, diskname)
-          
-          raise "The disk #{diskname} does not exist" unless disk
-          backup = Rudy::MetaData::Backup.new
-          backup.awsid = @option.snapshot
-          backup.time_stamp
-            
-          # Populate machine infos
-          [:zone, :environment, :role, :position].each do |n|
-            backup.send("#{n}=", @global.send(n)) if @global.send(n)
-          end
-        
-          # Populate disk infos
-          [:path, :size].each do |n|
-            backup.send("#{n}=", disk.send(n)) if disk.send(n)
-          end
-          
-          
-          Rudy::MetaData::Backup.save(@sdb, backup)
-          
-          puts backup.name
-          
-        else
-          volumes = @ec2.instances.volumes(machine[:aws_instance_id])
-          raise "The machine #{machine_name} does not have any volumes attached." if volumes.empty?
-          
-          puts "#{disks.size} Disk(s) defined with #{volumes.size} Volume(s) running"
-        
-          volumes.each do |volume|
-            print "Volume #{volume[:aws_id]}... "
-            disk = Rudy::MetaData::Disk.find_from_volume(@sdb, volume[:aws_id])
-            backup = Rudy::MetaData::Backup.new
-          
-            # TODO: Look for the disk based on the machine
-            raise "No disk associated to volume #{volume[:aws_id]}" unless disk 
-          
-            backup.volume = volume[:aws_id]
-
-            # Populate machine infos
-            [:zone, :environment, :role, :position].each do |n|
-              backup.send("#{n}=", @global.send(n)) if @global.send(n)
-            end
-
-            # Populate disk infos
-            [:path, :size].each do |n|
-              backup.send("#{n}=", disk.send(n)) if disk.send(n)
-            end
-            
-            backup.time_stamp
-            
-            raise "There was a problem creating the backup metadata" unless backup.valid?
-            
-            snap = @ec2.snapshots.create(volume[:aws_id])
-          
-            if !snap || !snap.is_a?(Hash)
-              puts "There was an unknown problem creating #{backup.name}. Continuing with the next volume..."
-              next
-            end
-            
-            backup.awsid = snap[:aws_id]
-
-            Rudy::MetaData::Backup.save(@sdb, backup)
-
-            puts backup.name
-            
-          end
-        end          
-      end
-      
-      
-    end
-  end
-end

data/lib/rudy/command/base.rb

@@ -1,841 +0,0 @@
-
-module Rudy
-  class UnknownInstance < RuntimeError; end
-end
-
-module Rudy
-  module Command
-    class NoCred < RuntimeError; end;
-    
-    class Base < Drydock::Command
-
-      attr_reader :scm
-  
-      attr_reader :rscripts
-      attr_reader :domains
-      attr_reader :machine_images
-      
-      attr_reader :config
-      
-      
-      def init
-        
-        
-        raise "PRODUCTION ACCESS IS DISABLED IN DEBUG MODE" if @global.environment == "prod" && Drydock.debug?
-        
-        @global.config ||= RUDY_CONFIG_FILE
-        
-        unless File.exists?(@global.config)
-          init_config_dir
-        end
-        
-        @config = Rudy::Config.new(@global.config, {:verbose => (@global.verbose > 0)} )
-        @config.look_and_load
-        
-        raise "There is no machine group configured" if @config.machines.nil?
-        raise "There is no AWS info configured" if @config.awsinfo.nil?
-        
-        
-        @global.accesskey ||= @config.awsinfo.accesskey || ENV['AWS_ACCESS_KEY']
-        @global.secretkey ||= @config.awsinfo.secretkey || ENV['AWS_SECRET_KEY'] || ENV['AWS_SECRET_ACCESS_KEY']
-        @global.account ||= @config.awsinfo.account || ENV['AWS_ACCOUNT_NUMBER'] 
-        
-        @global.cert ||= @config.awsinfo.cert || ENV['EC2_CERT']
-        @global.privatekey ||= @config.awsinfo.privatekey || ENV['EC2_PRIVATE_KEY']
-        
-        @global.cert = File.expand_path(@global.cert || '')
-        @global.privatekey = File.expand_path(@global.privatekey || '')
-        
-        @global.region ||= @config.defaults.region || DEFAULT_REGION
-        @global.zone ||= @config.defaults.zone || DEFAULT_ZONE
-        @global.environment ||= @config.defaults.environment || DEFAULT_ENVIRONMENT
-        @global.role ||= @config.defaults.role || DEFAULT_ROLE
-        @global.position ||= @config.defaults.position || DEFAULT_POSITION
-        @global.user ||= @config.defaults.user || DEFAULT_USER
-        
-        @global.local_user = ENV['USER'] || :user
-        @global.local_hostname = Socket.gethostname || :host
-
-        check_keys
-        
-        if @global.verbose > 1
-          puts "GLOBALS:"
-          @global.marshal_dump.each_pair do |n,v|
-            puts "#{n}: #{v}"
-          end
-          ["machines", "routines"].each do |type|
-            puts "#{$/*2}#{type.upcase}:"
-            val = @config.send(type).find_deferred(@global.environment, @global.role)
-            puts val.to_hash.to_yaml
-          end
-          puts
-        end
-        
-        
-        
-        # TODO: enforce home directory permissions
-        #if File.exists?(RUDY_CONFIG_DIR)
-        #  puts "Checking #{check_environment} permissions..."
-        #end
-        
-        if has_keys?
-          @ec2 = Rudy::AWS::EC2.new(@global.accesskey, @global.secretkey)
-          @sdb = Rudy::AWS::SimpleDB.new(@global.accesskey, @global.secretkey)
-          #@s3 = Rudy::AWS::SimpleDB.new(@global.accesskey, @global.secretkey)
-        end
-      end
-      protected :init
-      
-      def machine_data
-        machine_data = {
-          # Give the machine an identity
-          :zone => @global.zone,
-          :environment => @global.environment,
-          :role => @global.role,
-          :position => @global.position,
-          
-          # Add hosts to the /etc/hosts file
-          :hosts => {
-            :dbmaster => "127.0.0.1",
-          }
-        } 
-        
-        machine_data.to_hash
-      end
-      
-      
-      # Raises exceptions if the requested user does 
-      # not have a valid keypair configured. (See: EC2_KEYPAIR_*)
-      def check_keys
-        raise "No SSH key provided for #{@global.user}! (check #{RUDY_CONFIG_FILE})" unless has_keypair?
-        raise "SSH key provided but cannot be found! (check #{RUDY_CONFIG_FILE})" unless File.exists?(keypairpath)
-      end  
-      
-      def has_pem_keys?
-        (@global.cert       && File.exists?(@global.cert) && 
-         @global.privatekey && File.exists?(@global.privatekey))
-      end
-       
-      def has_keys?
-        (@global.accesskey && !@global.accesskey.empty? && @global.secretkey && !@global.secretkey.empty?)
-      end
-      
-      def keypairpath(name=nil)
-        name ||= @global.user
-        raise "No default user configured" unless name
-        kp = @config.machines.find(@global.environment, @global.role, :users, name, :keypair2)
-        kp ||= @config.machines.find(@global.environment, :users, name, :keypair)
-        kp ||= @config.machines.find(:users, name, :keypair)
-        kp &&= File.expand_path(kp)
-        kp
-      end
-      def has_keypair?(name=nil)
-        kp = keypairpath(name)
-        (!kp.nil? && File.exists?(kp))
-      end
-      
-      # Opens an SSH session. 
-      # <li>+host+ the hostname to connect to. Defaults to the machine specified
-      # by @global.environment, @global.role, @global.position.</li>
-      # <li>+b+ a block to execute on the host. Receives |session|</li>
-      # 
-      #      ssh do |session|
-      #        session.exec(cmd)
-      #      end
-      #
-      # See Net::SSH
-      #
-      def ssh(host=nil, &b)
-        host ||= machine_hostname
-        raise "No host provided for SSH" unless host
-        raise "No block provided for SSH" unless b
-        
-        Net::SSH.start(host, @global.user, :keys => [keypairpath]) do |session|
-          b.call(session)
-        end
-      end
-      
-      # Secure copy. 
-      # 
-      #      scp do |scp|
-      #        # upload a file to a remote server
-      #        scp.upload! "/local/path", "/remote/path"
-      #
-      #        # upload from an in-memory buffer
-      #        scp.upload! StringIO.new("some data to upload"), "/remote/path"
-      #
-      #        # run multiple downloads in parallel
-      #        d1 = scp.download("/remote/path", "/local/path")
-      #        d2 = scp.download("/remote/path2", "/local/path2")
-      #        [d1, d2].each { |d| d.wait }
-      #      end
-      #
-      def scp(host=nil, &b)
-        host ||= machine_hostname
-        raise "No host provided for scp" unless host
-        raise "No block provided for scp" unless b
-        
-        Net::SCP.start(host, @global.user, :keys => [keypairpath]) do |scp|
-          b.call(scp)
-        end
-      end
-      
-      # +name+ the name of the remote user to use for the remainder of the command
-      # (or until switched again). If no name is provided, the user will be revert
-      # to whatever it was before the previous switch. 
-      def switch_user(name=nil)
-        if name == nil && @switch_user_previous
-          @global.user = @switch_user_previous
-        elsif @global.user != name
-          puts "Remote commands will be run as #{name} user"
-          @switch_user_previous = @global.user
-          @global.user = name
-        end
-      end
-      
-      # Returns a hash of info for the requested machine. If the requested machine
-      # is not running, it will raise an exception. 
-      def find_current_machine
-        find_machine(machine_group)
-      end
-        
-      def find_machine(group)
-        machine_list = @ec2.instances.list(group)
-        machine = machine_list.values.first  # NOTE: Only one machine per group, for now...
-        raise "There's no machine running in #{group}" unless machine
-        raise "The primary machine in #{group} is not in a running state" unless machine[:aws_state] == 'running'
-        machine
-      end
-      
-      def machine_hostname(group=nil)
-        group ||= machine_group
-        find_machine(group)[:dns_name]
-      end
-      
-      def machine_group
-        [@global.environment, @global.role].join(RUDY_DELIM)
-      end
-      
-      def machine_image
-        ami = @config.machines.find_deferred(@global.environment, @global.role, :ami)
-        raise "There is no AMI configured for #{machine_group}" unless ami
-        ami
-      end
-      
-      def machine_address
-        @config.machines.find_deferred(@global.environment, @global.role, :address)
-      end
-      
-      # TODO: fix machine_group to include zone
-      def machine_name
-        [@global.zone, machine_group, @global.position].join(RUDY_DELIM)
-      end
-
-      def instance_id?(id=nil)
-        (id && id[0,2] == "i-")
-      end
-      
-      def image_id?(id=nil)
-        (id && id[0,4] == "ami-")
-      end
-      
-      def volume_id?(id=nil)
-        (id && id[0,4] == "vol-")
-      end
-      
-      def snapshot_id?(id=nil)
-        (id && id[0,5] == "snap-")
-      end
-      
-      
-      def wait_for_machine(id)
-        
-        print "Waiting for #{id} to become available"
-        STDOUT.flush
-        
-        while @ec2.instances.pending?(id)
-          sleep 2
-          print '.'
-          STDOUT.flush
-        end
-        
-        machine = @ec2.instances.get(id)
-        
-        puts " It's up!\a\a" # with bells
-        print "Waiting for SSH daemon at #{machine[:dns_name]}"
-        STDOUT.flush
-        
-        while !Rudy::Utils.service_available?(machine[:dns_name], 22)
-          print '.'
-          STDOUT.flush
-        end
-        puts " It's up!\a\a\a"
-
-      end
-      
-      
-      def device_to_path(machine, device)
-        # /dev/sdr            10321208    154232   9642688   2% /rilli/app
-        dfoutput = ssh_command(machine[:dns_name], keypairpath, @global.user, "df #{device} | tail -1").chomp
-        dfvals = dfoutput.scan(/(#{device}).+\s(.+?)$/).flatten  # ["/dev/sdr", "/rilli/app"]
-        dfvals.last
-      end
-      
-      # +action+ is one of: :shutdown, :start, :deploy
-      # +machine+ is a right_aws machine instance hash
-      def execute_disk_routines(machines, action)
-        machines = [machines] unless machines.is_a?( Array)
-        
-        puts "Running #{action.to_s.capitalize} DISK routines".att(:bright)
-        
-        disks = @config.machines.find_deferred(@global.environment, @global.role, :disks)
-        routines = @config.routines.find(@global.environment, @global.role, action, :disks)
-        
-        unless routines
-          puts "No #{action} disk routines for #{machine_group}"
-          return
-        end
-        
-        switch_user("root")
-        
-        machines.each do |machine|
-
-          unless machine[:aws_instance_id]
-            puts "Machine given has no instance ID. Skipping disks."
-            return
-          end
-        
-          unless machine[:dns_name]
-            puts "Machine given has no DNS name. Skipping disks."
-            return
-          end
-          
-          if routines.destroy
-            disk_paths = routines.destroy.keys
-            vols = @ec2.instances.volumes(machine[:aws_instance_id]) || []
-            puts "No volumes to destroy for (#{machine[:aws_instance_id]})" if vols.empty?
-            vols.each do |vol|
-              disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
-              if disk
-                this_path = disk.path
-              else
-                puts "No disk metadata for volume #{vol[:aws_id]}. Going old school..."
-                this_path = device_to_path(machine, vol[:aws_device])
-              end
-              
-              dconf = disks[this_path]
-              
-              unless dconf
-                puts "#{this_path} is not defined for this machine. Check your machines config."
-                next
-              end
-              
-              if disk_paths.member?(this_path) 
-              
-                unless disks.has_key?(this_path)
-                  puts "#{this_path} is not defined as a machine disk. Skipping..."
-                  next
-                end
-                
-                begin
-                  puts "Unmounting #{this_path}..."
-                  ssh_command machine[:dns_name], keypairpath, @global.user, "umount #{this_path}"
-                  sleep 3
-                rescue => ex
-                  puts "Error while unmounting #{this_path}: #{ex.message}"
-                  puts ex.backtrace if Drydock.debug?
-                  puts "We'll keep going..."
-                end
-                
-                begin
-                  
-                  if @ec2.volumes.attached?(disk.awsid)
-                    puts "Detaching #{vol[:aws_id]}"
-                    @ec2.volumes.detach(vol[:aws_id])
-                    sleep 3 # TODO: replace with something like wait_for_machine
-                  end
-                  
-                  puts "Destroying #{this_path} (#{vol[:aws_id]})"
-                  if @ec2.volumes.available?(disk.awsid)
-                    @ec2.volumes.destroy(vol[:aws_id])
-                  else
-                    puts "Volume is still attached (maybe a web server of database is running?)"
-                  end
-                  
-                  if disk
-                    puts "Deleteing metadata for #{disk.name}"
-                    Rudy::MetaData::Disk.destroy(@sdb, disk)
-                  end
-                
-                rescue => ex
-                  puts "Error while detaching volume #{vol[:aws_id]}: #{ex.message}"
-                  puts ex.backtrace if Drydock.debug?
-                  puts "Continuing..."
-                end
-                
-              end
-              puts
-              
-            end
-          
-          end
-          
-          
-          if routines.mount
-            disk_paths = routines.mount.keys
-            vols = @ec2.instances.volumes(machine[:aws_instance_id]) || []
-            puts "No volumes to mount for (#{machine[:aws_instance_id]})" if vols.empty?
-            vols.each do |vol|
-              disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
-              if disk
-                this_path = disk.path
-              else
-                puts "No disk metadata for volume #{vol[:aws_id]}. Going old school..."
-                this_path = device_to_path(machine, vol[:aws_device])
-              end
-              
-              next unless disk_paths.member?(this_path)
-                
-              dconf = disks[this_path]
-              
-              unless dconf
-                puts "#{this_path} is not defined for this machine. Check your machines config."
-                next
-              end
-              
-              
-              begin
-                unless @ec2.instances.attached_volume?(machine[:aws_instance_id], vol[:aws_device])
-                  puts "Attaching #{vol[:aws_id]} to #{machine[:aws_instance_id]}".att(:bright)
-                  @ec2.volumes.attach(machine[:aws_instance_id], vol[:aws_id],vol[:aws_device])
-                  sleep 3
-                end
-
-                puts "Mounting #{this_path} to #{vol[:aws_device]}".att(:bright)
-                ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{this_path} && mount -t ext3 #{vol[:aws_device]} #{this_path}"
-
-                sleep 1
-              rescue => ex
-                puts "There was an error mounting #{this_path}: #{ex.message}"
-                puts ex.backtrace if Drydock.debug?
-              end
-              puts 
-            end
-          end
-        
-        
-          
-          if routines.restore
-            
-            routines.restore.each_pair do |path,props|
-              from = props[:from] || "unknown"
-              unless from.to_s == "backup"
-                puts "Sorry! You can currently only restore from backup. Check your routines config."
-                next
-              end
-              
-              begin 
-                puts "Restoring disk for #{path}"
-                
-                dconf = disks[path]
-                
-                unless dconf
-                  puts "#{path} is not defined for this machine. Check your machines config."
-                  next
-                end
-                    
-                zon = props[:zone] || @global.zone
-                env = props[:environment] || @global.environment
-                rol = props[:role] || @global.role
-                pos = props[:position] || @global.position
-                puts "Looking for backup from #{zon}-#{env}-#{rol}-#{pos}"
-                backup = find_most_recent_backup(zon, env, rol, pos, path)
-                
-                unless backup
-                  puts "No backups found"
-                  next
-                end
-                
-                puts "Found: #{backup.name}".att(:bright)
-                
-                disk = Rudy::MetaData::Disk.new
-                disk.path = path
-                [:region, :zone, :environment, :role, :position].each do |n|
-                  disk.send("#{n}=", @global.send(n)) if @global.send(n)
-                end
-                
-                disk.device = dconf[:device]
-                size = (backup.size.to_i > dconf[:size].to_i) ? backup.size : dconf[:size]
-                disk.size = size.to_i
-                
-                
-                if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
-                  puts "The disk #{disk.name} already exists."
-                  puts "You probably need to define when to destroy the disk."
-                  puts "Skipping..."
-                  next
-                end
-
-                if @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
-                  puts "Skipping disk for #{disk.path} (device #{disk.device} is in use)"
-                  next
-                end
-
-                # NOTE: It's important to use Caesars' hash syntax b/c the disk property
-                # "size" conflicts with Hash#size which is what we'll get if there's no 
-                # size defined. 
-                unless disk.size.kind_of?(Integer)
-                  puts "Skipping disk for #{disk.path} (size not defined)"
-                  next
-                end
-
-                if disk.path.nil?
-                  puts "Skipping disk for #{disk.path} (no path defined)"
-                  next
-                end
-
-                unless disk.valid?
-                  puts "Skipping #{disk.name} (not enough info)"
-                  next
-                end
-
-                puts "Creating volume... (from #{backup.awsid})".att(:bright)
-                volume = @ec2.volumes.create(@global.zone, disk.size, backup.awsid)
-
-                puts "Attaching #{volume[:aws_id]} to #{machine[:aws_instance_id]}".att(:bright)
-                @ec2.volumes.attach(machine[:aws_instance_id], volume[:aws_id], disk.device)
-                sleep 3
-
-                puts "Mounting #{disk.device} to #{disk.path}".att(:bright)
-                ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
-
-                puts "Creating disk metadata for #{disk.name}"
-                disk.awsid = volume[:aws_id]
-                Rudy::MetaData::Disk.save(@sdb, disk)
-
-                sleep 1
-              rescue => ex
-                puts "There was an error creating #{path}: #{ex.message}"
-                puts ex.backtrace if Drydock.debug?
-                if disk
-                  puts "Removing metadata for #{disk.name}"
-                  Rudy::MetaData::Disk.destroy(@sdb, disk)
-                end
-              end
-              puts
-            end
-          end
-          
-          
-          
-          if routines.create
-            routines.create.each_pair do |path,props|
-        
-              begin 
-                puts "Creating disk for #{path}"
-                
-                dconf = disks[path]
-
-                unless dconf
-                  puts "#{path} is not defined for this machine. Check your machines config."
-                  next
-                end
-                
-                disk = Rudy::MetaData::Disk.new
-                disk.path = path
-                [:region, :zone, :environment, :role, :position].each do |n|
-                  disk.send("#{n}=", @global.send(n)) if @global.send(n)
-                end
-                [:device, :size].each do |n|
-                  disk.send("#{n}=", dconf[n]) if dconf.has_key?(n)
-                end
-            
-                if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
-                  puts "The disk #{disk.name} already exists."
-                  puts "You probably need to define when to destroy the disk."
-                  puts "Skipping..."
-                  next
-                end
-            
-                if @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
-                  puts "Skipping disk for #{disk.path} (device #{disk.device} is in use)"
-                  next
-                end
-            
-                # NOTE: It's important to use Caesars' hash syntax b/c the disk property
-                # "size" conflicts with Hash#size which is what we'll get if there's no 
-                # size defined. 
-                unless disk.size.kind_of?(Integer)
-                  puts "Skipping disk for #{disk.path} (size not defined)"
-                  next
-                end
-            
-                if disk.path.nil?
-                  puts "Skipping disk for #{disk.path} (no path defined)"
-                  next
-                end
-            
-                unless disk.valid?
-                  puts "Skipping #{disk.name} (not enough info)"
-                  next
-                end
-                        
-                puts "Creating volume... (#{disk.size}GB in #{@global.zone})".att(:bright)
-                volume = @ec2.volumes.create(@global.zone, disk.size)
-            
-                puts "Attaching #{volume[:aws_id]} to #{machine[:aws_instance_id]}".att(:bright)
-                @ec2.volumes.attach(machine[:aws_instance_id], volume[:aws_id], disk.device)
-                sleep 6
-                
-                puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})".att(:bright)
-                ssh_command machine[:dns_name], keypairpath, @global.user, "mkfs.ext3 -F #{disk.device}"
-                sleep 3
-                
-                puts "Mounting #{disk.device} to #{disk.path}".att(:bright)
-                ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
-              
-                puts "Creating disk metadata for #{disk.name}"
-                disk.awsid = volume[:aws_id]
-                Rudy::MetaData::Disk.save(@sdb, disk)
-              
-                sleep 1
-              rescue => ex
-                puts "There was an error creating #{path}: #{ex.message}"
-                if disk
-                  puts "Removing metadata for #{disk.name}"
-                  Rudy::MetaData::Disk.destroy(@sdb, disk)
-                end
-              end
-              puts
-            end
-          end
-        end
-      end
-      
-      def find_most_recent_backup(zon, env, rol, pos, path)
-        criteria = [zon, env, rol, pos, path]
-        (Rudy::MetaData::Backup.list(@sdb, *criteria) || []).first
-      end
-      
-      def execute_routines(machines, action, before_or_after)
-        machines = [machines] unless machines.is_a?( Array)
-        config = @config.routines.find_deferred(@global.environment, @global.role, :config) || {}        
-        config[:global] = @global.marshal_dump
-        config[:global].reject! { |n,v| n == :cert || n == :privatekey }
-        
-        # The config file contains settings from ~/.rudy/config 
-        #
-        #     routines do 
-        #       config do
-        #       end
-        #     end
-        #
-        config_file = "#{action}-config.yaml"
-        tf = Tempfile.new(config_file)
-        write_to_file(tf.path, config.to_hash.to_yaml, 'w')
-        puts "Running #{action.to_s.capitalize} #{before_or_after.to_s.upcase} routines".att(:bright)
-        machines.each do |machine|
-          puts "Machine Group: #{machine_group}"
-          puts "Hostname: #{machine[:dns_name]}"
-          
-          rscripts = @config.routines.find_deferred(@global.environment, @global.role, action, before_or_after) || []
-          rscripts = [rscripts] unless rscripts.is_a?(Array)
-          
-          puts "No scripts defined." if !rscripts || rscripts.empty?
-          
-          rscripts.each do |rscript|
-            user, script = rscript.shift
-            
-            switch_user(user) # scp and ssh will run as this user
-        
-            puts "Transfering #{config_file}..."
-            scp do |scp|
-              scp.upload!(tf.path, "~/#{config_file}") do |ch, name, sent, total|
-                "#{name}: #{sent}/#{total}"
-              end
-            end
-            ssh do |session|
-              puts "Running #{script}...".att(:bright)
-              session.exec!("chmod 700 ~/#{config_file}")
-              session.exec!("chmod 700 #{script}")
-              puts session.exec!("#{script}")
-          
-              puts "Removing remote copy of #{config_file}..."
-              session.exec!("rm ~/#{config_file}")
-            end
-            puts $/
-          end
-        end
-        
-        tf.delete     # remove local copy of config_file
-        #switch_user   # return to the requested user
-      end
-      
-      # Print a default header to the screen for every command.
-      # +cmd+ is the name of the command current running. 
-      def print_header(cmd=nil)
-        title = "RUDY v#{Rudy::VERSION}" unless @global.quiet
-        now_utc = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
-        criteria = []
-        [:zone, :environment, :role, :position].each do |n|
-          val = @global.send(n)
-          next unless val
-          criteria << "#{n.to_s.slice(0,1).att :normal}:#{val.att :bright}"
-        end
-        puts '%s -- %s UTC' % [title, now_utc] unless @global.quiet
-        puts '[%s]' % criteria.join("  ") unless @global.quiet
-        
-        puts unless @global.quiet
-        
-        if (@global.environment == "prod") 
-          msg = without_indent %q(
-          =======================================================
-          =======================================================
-          !!!!!!!!!   YOU ARE PLAYING WITH PRODUCTION   !!!!!!!!!
-          =======================================================
-          =======================================================)
-          puts msg.colour(:red).bgcolour(:white).att(:bright), $/  unless @global.quiet
-          
-        end
-        
-        if Rudy.in_situ?
-          msg = %q(============ THIS IS EC2 ============)
-          puts msg.colour(:blue).bgcolour(:white).att(:bright), $/ unless @global.quiet
-        end
-        
-      end
-      
-      def print_footer
-        
-      end
-      
-
-
-      
-      def group_metadata(env=@global.environment, role=@global.role)
-        query = "['environment' = '#{env}'] intersection ['role' = '#{role}']"
-        @sdb.query_with_attributes(RUDY_DOMAIN, query)
-      end
-      
-      private 
-        # Print info about a running instance
-        # +inst+ is a hash
-        def print_instance(inst)
-          puts '-'*60
-          puts "Instance: #{inst[:aws_instance_id].att(:bright)} (AMI: #{inst[:aws_image_id]})"
-          [:aws_state, :dns_name, :private_dns_name, :aws_availability_zone, :aws_launch_time, :ssh_key_name].each do |key|
-             printf(" %22s: %s#{$/}", key, inst[key]) if inst[key]
-           end
-          printf(" %22s: %s#{$/}", 'aws_groups', inst[:aws_groups].join(', '))
-          puts
-        end
-        
-        def print_image(img)
-          puts '-'*60
-          puts "Image: #{img[:aws_id].att(:bright)}"
-          img.each_pair do |key, value|
-             printf(" %22s: %s#{$/}", key, value) if value
-           end
-          puts
-        end
-        
-        def print_disk(disk, backups=[])
-          puts '-'*60
-          puts "Disk: #{disk.name.att(:bright)}"
-          puts disk.to_s
-          puts "#{backups.size} most recent backups:", backups.collect { |back| "#{back.nice_time} (#{back.awsid})" }
-          puts
-        end
-        
-        
-        def print_volume(vol, disk)
-          puts '-'*60
-          puts "Volume: #{vol[:aws_id].att(:bright)} (disk: #{disk.name if disk})"
-          vol.each_pair do |key, value|
-             printf(" %22s: %s#{$/}", key, value) if value
-           end
-          puts
-        end
-        
-        # Print info about a a security group
-        # +group+ is an OpenStruct
-        def print_group(group)
-          puts '-'*60
-          puts "%12s: %s" % ['GROUP', group[:aws_group_name].att(:bright)]
-          puts 
-          
-          group_ip = {}
-          group[:aws_perms].each do |perm| 
-             (group_ip[ perm[:cidr_ips] ] ||= []) << "#{perm[:protocol]}/#{perm[:from_port]}-#{perm[:to_port]}"
-          end
-           
-          puts "%22s  %s" % ["source address/mask", "protocol/ports (from, to)"]
-          
-           
-          group_ip.each_pair do |ip, perms|
-            puts "%22s  %s" % [ip, perms.shift]
-            perms.each do |perm|
-              puts "%22s  %s" % ['', perm]
-            end
-            puts
-          end
-        end
-        
-        def init_config_dir
-          unless File.exists?(RUDY_CONFIG_DIR)
-            puts "Creating #{RUDY_CONFIG_DIR}"
-            Dir.mkdir(RUDY_CONFIG_DIR, 0700)
-          end
-
-          unless File.exists?(RUDY_CONFIG_FILE)
-            puts "Creating #{RUDY_CONFIG_FILE}"
-            rudy_config = without_indent %Q{
-              # Amazon Web Services 
-              # Account access indentifiers.
-              awsinfo do
-                account ""
-                accesskey ""
-                secretkey ""
-                privatekey "~/path/2/pk-xxxx.pem"
-                cert "~/path/2/cert-xxxx.pem"
-              end
-              
-              # Machine Configuration
-              # Specify your private keys here. These can be defined globally
-              # or by environment and role like in machines.rb.
-              machines do
-                users do
-                  root :keypair => "path/2/root-private-key"
-                end
-              end
-              
-              # Routine Configuration
-              # Define stuff here that you don't want to be stored in version control. 
-              routines do
-                config do 
-                  # ...
-                end
-              end
-
-              # Global Defaults 
-              # Define the values to use unless otherwise specified on the command-line. 
-              defaults do
-                region "us-east-1" 
-                zone "us-east-1b"
-                environment "stage"
-                role "app"
-                position "01"
-                user ENV['USER']
-              end
-            }
-            write_to_file(RUDY_CONFIG_FILE, rudy_config, 'w')
-          end
-
-          #puts "Creating SimpleDB domain called #{RUDY_DOMAIN}"
-          #@sdb.domains.create(RUDY_DOMAIN)
-        end
-    end
-  end
-end
-
-